Slashdot Mirror
XGL Development Opens Up
An anonymous reader writes "David Reveman has made the latest XGL source code available for download. This comes a few weeks after development of the project was criticized for being done 'behind closed doors'. There have been huge changes to XGL, the most significant being restructuring of the code, allowing XGL's GLX support to function on other drivers than the proprietary Nvidia one. Xcompmgr can currently be run under XGL with full acceleration provided that the proprietary ATI or Nvidia drivers are used. An OpenGL based compositing manager, 'Compiz' is currently in the works and a release is expected in February. David intends to get the code into freedesktop CVS as soon as possible, after which the code should eventually merge with Xorg."
I googled around for it. It seems to be an openGL based X server. I know of a large HMI development project running at the moment which may wind up deploying on windows (as opposed to Linux) due to the faster OpenGL implementation under windows.
Something like this could tip the balance.
http://michaelsmith.id.au
It lets the system offload graphical operations onto the GPU, like Quartz Extreme on MacOS. Things like transparency get a lot easier to do.
I rarely criticize things I don't care about.
If you are in the windows or mac worlds, there's not much of a reason to get excited... OSX already does this, and Vista will as well. But for those of us in *nix world who want eye-candy, it's quite A Good Thing (tm).
I should add that OpenGL support is already available, but XGL allows the X server to transparently use it in a way that's compatible with existing applications.
I rarely criticize things I don't care about.
If you're talking about 3D acceleration (through OpenGL), the NVidia drivers for Linux are just as fast as the Windows drivers, if not faster. XGL is about rendering a 2D desktop using OpenGL (and thusly, taking advantage of the graphics card moreso to speed up rendering and get nifty effects), which Windows doesn't do. XGL really has nothing to do with games, and Linux isn't "now matching" Windows in any respect, it's pulling further ahead of it.
Game! - Where the stick is mightier than the sword!
How much money do you have? Because you're gonna have to buy the IP of a LOT of companies in order to open source their stuff. Lots of proprietary stuff in the chips and the drivers, from what I hear.
And FYI, the older Radeons (up to 8500 I believe?) have a decent open source driver.
My blog. Good stuff (when I remember to update it). Read it.
What about Luminocity? It was an experimental window manager created so that some of the Gnome guys could start work on using compositing and to begin to understand the connection between Opengl and the Linux Desktop.
I wrote a guy to install it if you want to try playing with it. Once you do use it you see what it really is- a tech demo. Its not a full window manager (it does not replace Metacity) and it actually seems that the compositor that is going into Metacity borrows almost nothing from it, so now it seems like it was a fun dead end.
Try it, you will see what I mean.
Open Source Sushi
You don't. Nvidia and ATI could not care about you money- the only reason they made drivers for Linux in the first place was to sell high end cards to render 3D scenes.
If you really want to support open drivers, buy an ATI 9250 and help test EXA and Xgl on there. That is the best card we have with open drivers, and it seems like it will be on top for a LONG time.
Open Source Sushi
No.
... ie an application that runs on an OpenGL system.
If you want a faster OpenGL implementation, then you want to optimise Mesa and the individual video card drivers.
XGL is an X Server that runs on OpenGL. It won't make your OpenGL drivers faster - it's simply an OpenGL client
The point of XGL is to take the 3D engine in most graphics cards and use it as the basis for X's acceleration.
Before, the 2D acceleration engine was used, but 2D has fallen behind in terms of performance, and 3D can do everything 2D can do, plus more. XGL uses OpenGL to render bitmaps, as well as to render video, composite alpha-channeled windows, rotate and deform windows, etc. I think font antialiasing will benefit, via a (potentially) faster XRender implementation. I gather it's also integrated with glitz already, which means that vector graphics like SVG and scalable icons, buttons, widget themes, etc. will also be done via OpenGL.
The one remaining gap (that I know of) is hardware support. The Novell guy releasing this (sorry, I forget his name right now) seems to say that it works with relatively minor changes on Free Software DRI drivers. I know that was always an intention, at least. So, hopefully, we'll see more drivers trying to support DRI as base level of driver compliance, rather than as an afterthought. The X desktop will be faster, smoother, and more featureful... so long as desktop developers don't go overboard and expects everyone to have next-generation 3D engine performance just to run a wordprocessor ;)
All in all, a very good thing :)
I disagree.
... usually areas where more documentation is required.
The opensource R100, R200 & R300 drivers were written by the DRI developers. ATI provided some incomplete and contradictory documentation for the R100 & R200 to some select developers who had to sign an NDA. All the coding has been done by DRI developers. The R300 has been completely reverse-engineered.
Now. Check out all 3 drivers. They not only work, but they work incredibly well. In fact they are faster and more stable than ATI's drivers, except for in some key areas
The simple fact is that the very thing you're saying is impossible - opensource developement of top-quality drivers - has already happened. Not only that, despite your suggestion that they're not up to it, R300 developers continue to reverse-engineer and code for the current and upcoming cards from ATI. Pretty neat, eh? Check out the list of apps the R300 can run - you'll be surprised.
Not really -- Vista will be doing this too, with Direct3D rather than OpenGL.
(And OSX has been doing it since day one.)
What it comes down to is that people want nifty translucency and fluid animation effects even in a 2D GUI, and the best way to implement it is by compositing the desktop using the video card's 3D engine. The Composite extension currently available in Xorg facilitates an alternative approach, based on XRender which still uses the video card's 2D engine, and that's quicker to implement, but not as robust or flexible. (And XRender doesn't benefit from hardware acceleration -- they're working on that now, under the name "Exa", but the nice thing about OpenGL is that we already have it accelerated.)
And even better: Buy a card from the Open Graphics Project when it's available (first half of this year, if all goes well).
It's certainly what I'm doing (just sent back an Nvidia 6600 something-or-other I got for ACGPD).
There are 11 types of people in the world: those who can count in binary, and those who can't.
Really? Everything I read tells me that the crappy closed ATI drivers are still faster when it comes to 3D than the open source drivers.
I mean...its cool that at least one set of cards with decent 3D hardware has open driver, but those drivers are not for gamers to use. Its for me to use to get EXA.
Open Source Sushi
Here is a video demo of the types of effects which become possible with XGL. Note the translucent video playing while being warped and composited with the background window, and simultaneously being displayed live in miniature in the workspace pager to the right.
OS X's "genie" effect, Windows Vista's "frosted" window effect, *real* transparent terminal windows, crazy animated wallpapers, they will all be possible with XGL. But eye candy is not the only use of XGL; it makes possible long-overdue improvements to the Linux desktop experience. OS X's Exposé window management tool will be possible to duplicate on Linux. Window resizing is smoother in the experimental XGL window managers because window borders are drawn synchronized with their contents. Window moving is also faster because window contents are cached instead of drawn on demand. Best of all, all this eye candy will require *less* CPU power than it takes today to draw a screenfull of antialiased text, because OpenGL brings the full power of today's 3D cards to bear on your existing ordinary everyday applications. Today when you're surfing the web your GeForce or Radeon is sitting idle while your CPU draws all the text and graphics. XGL will put that power to work, freeing up your CPU and allowing way more eye candy to boot.
(Note that this video is only a demo and *not* a proposal to make wobbly windows the default in GNOME or KDE. I don't want to see those replies with rants about how you hate eye candy, and you think Linux should have stopped improving after it could run TWM with Emacs in an XTerm on your Pentium 133.)
Just a few minor corrections :).
The Composite extension currently available in Xorg facilitates an alternative approach, based on XRender which still uses the video card's 2D engine, and that's quicker to implement, but not as robust or flexible.
Repeat after me. There is no formal relationship between XRender and Composite. The Composite extension simply provides a method for an external program to handle how the desktop is rendered. It hands that program a bitmap for each window, and it is up to the program to do something with them. xcompmgr and KDE's composite manager, which is based on xcompmgr, use XRender to blit those bitmaps in the proper order. Luminocity, gnome's next gen window manager, contains a composite manager that uses OpenGL to render the desktop. The point is that composite manager can do whatever it wants to the bitmaps it recieves. It can invert the colors, make it translucent, flip it upside down, or tile a picture of elmo all over every window. That is the power of Composite.
And XRender doesn't benefit from hardware acceleration -- they're working on that now, under the name "Exa"
EXA is the replacement for XAA. XAA and EXA are 2D acceleration architectures. Much like OpenGL is to 3d. They provide the raw methods for hardware accelerate bit blitting, line drawing, 2d polygons, etc. Some cards accelerate more things than others. A video driver can provide 2d acceleration using XAA or EXA and not accelerate the XRender extension. The default configuration for the propietary nvidia drivers does this. However it uses neither EXA or XAA, but a propietary acceleration architecture. Not that it matters much as it is transparant to applications. XRender can, and is accelerated under many drivers. EXA and XAA do not depend on it, though, and it does not depend on them.
but the nice thing about OpenGL is that we already have it accelerated.
We already have 2D acceleration as well. The nice thing about OpenGL is it is usually faster and more feature rich. XGL aims, as far as I am able to tell, to replace all the functionality your typical driver comes with using OpenGL: EXA, XRender, Xv, RandR, etc.
Basically, what this boils down to is that XGL will draw the content of the windows: the text, the buttons, the images, etc. Then, if there is a composite manager, it will send the content of those windows to it, and it will do with them as it sees fit. Once the window contents are sent to composite what happens next is beyond the scope of XGL.
Actually, the best (as in "fastest") card with free hardware glx support of the R2X0-series of Radeon chips is the "original" Radeon 8500 with 275MHz clock on GPU and RAM. The Radeon 9250 is just some stripped down (in terms of pixel-pipelines or so) version of the original R250.
However, XOrg 7.x comes with a driver called "r300", supporting glx on more recent hardware, ranging from the Radeon 9500-series up to the X850, I believe. There's just no way to utilize the cards' shaders, yet.
:%s/Open Source/Free Software/g
YTARY!
And in a free market all software would end up being sold at it's true value, which is also pretty minimal.
You are correct, up until you used a comma.
The value of software is to the user. If there is a business need for software, it will be created - and that creation will be paid for by the business that needs it and they will be willing to pay up to as much as it is worth to them.
For the last 30 or so years, the majority money spent of software has been to develop it on contract. Shrink-wrap software may die off, replaced by freely downloadable software - but shrink-wrap is only a small part of the total market. Custom development is always where its been at - just look at IBM Global Services, that's pretty much all they do.
When information is power, privacy is freedom.
Two things:
1. XGL wasn't developed in-house for Novell.
XGL was started by independent free software programmers. Novell highered some of them and then took the developement 'in-house'.
It started off open, Novell paid some of them to concentrate on it on the 'inside', now they are openning it up again.
2. You don't understand the relationship between Xegl and XGL.
XGL is a _toy_, it's a pre-view. It's a beginning. It's forming the basis for future X servers, but it is not actually usefull itself.
XGL requires another X server to run on. Similar to Xnest.
Xegl is based on XGL (again started and worked on originally without any Novell involvement), it is a standalone X server that will actually be used.
You see one is useless without the other. XGL is worthless outside of developement. Xegl is worthless without the basis.
Xegl is called Xegl because it takes OpenGL and add the EGL extensions to it. These extensions were originally designed for embedded work, but can be used with a full-fledged OpenGL system like Linux has. What it does is allow OpenGL programs to send signals to change screen resolution and things like that. These extensions will 'fill out' the OpenGL API so that you can use it effectively for a basis of a standalone system.
Originally Linux's OpenGL stuff was like this. With original Mesa solo you didn't use X to run 3d accelerated applications. With things like GLX (open sourced from SGI) to 'mix' or manage OpenGL applications on a X server.
There still are some gaps though.. Indirect rendering isn't very hot, for instance. That is when you run a application remotely (X Windows is a networking protocol after all, like HTTP or whatnot) you can't get OpenGL acceleration working on it.
This, combined with other advances such as 'Modular X', 'X Damage', 'X composite', and 'XGL'/'xegl', is helping to move the X system from the 1980's era technology (were it is now) to the 2010's technology (where it will be in a couple more years).
Hopefully it will allow you to do things like display your desktop applications on your laptop or handheld (which it can do now) but also allow you to easily transfer applications between devices while they are running, and to display to display. All with nice acceleration with complex window managers. Oh and don't forget Vector-based graphics (which we will have with next releases of Gnome and KDE), which will be OpenGL themselves accelerated in a year or two.
EXA will help this a bit.
As X server switch over to EXA for the time being and applications utilize it's acceleration more and more.. this EXA stuff translates suprisingly well to OpenGL.
Also it will have the added benifit of moving X off of the hardware.
Right now with X.org's X server you have all this extra crap it has to do with hardware drivers and such. By moving to pure OpenGL then each OS can handle the protocol stack on themselves. You can have Linux framebuffer with Mesa-based DRI drivers, propriatory drivers or have software Mesa on Netbsd, some sort of weird embedded stuff, or have Window's OpenGL stuff.. It doesn't matter. Let the OS manage the hardware itself and run X windows on OpenGL, just like any other OpenGL application.
Right now we have Framebuffer, DRI, VGAcon, EXA and such that all have to fight over the hardware at the same time.
That's 4 independant drivers from multiple independant vendors.. some from DRI, some from Linux kernel, some from X.org, that all have to use the _same_peice_of_fucking_hardware.
Think about this:
1 peice of hardware, 4 drivers.
How many devices do you expect to function properly like that?
With OpenGL-based X server, then you have only one driver that can do everything. It can even do console if you want.. (although I don't expect Linux to drop vgacon as long as video cards support legacy vga mode)
Also if your a disapointed programmer wanting to work on X then I suggest you look strongly at XCB.
Dave Reveman was hired by Novell because of his work on XGL.. not to create it. He is not the only one that has been hired to work on XGL because of previous experiance with it.
It's just to bad that they didn't hire more XGL/XeGL hackers. Some of them have been left out in the cold.
He is also the major guy behind Glitz, which is the OpenGL backend for Cairo vector based graphics.
In fact Glitz goes hand in hand with XGL.
He is absolutely wonderfull guy and a good programmer to boot. But Novell isn't responsable for this creation.. mainly because Dave did the initial work on his own!