WWDC2003 Session 205

Transcript

Kind: captions Language: en afternoon everyone my name is Travis Browne and the graphics imaging evangelist and it's my pleasure to welcome you to vertex programming with OpenGL session 205 and sort of the theme that we have in this year's WC is the aspect of leveraging the GPU and and the graphics imaging overview yesterday we showed a lot of examples of using program ability to do interesting things because an interesting visual effects those are fragment programs but there's also sort of a companion technology or another way to program the GPU called vertex programming which instead of touching fragments and therefore pixels it's actually maybe using the GPU to do very high-speed geometry calculations the two go hand in hand in terms of the ways you can really offload the burden of doing the graphics from the cpu from the cpu and allow the GPU to do what it does best which is work with geometry and then obviously draw that geometry so it's my pleasure to welcome our speaker today mike larson up to this stage so you can take you to the presentation thanks Travis today we're here to talk about vertical grabbing with opengl it's been around for a couple years starting with the ATI RV 200 in that generation so we'll talk about a little bit let's start out we're go through an introduction to vertex programs we're going to talk about vertex programs in the OpenGL pipeline the computation model used by the vertex program the program since X for the our vertex program and go through a number of examples and starting from simple ones using shader builder and some more complicated one using the project builder so starting out why is vertex programs so much Oh get this button faizan you vert fragment program a lot of the inputs that go into a fragment program come out of the vertex program you might have texture coordinates you might have some bearing position coordinate to come through or system generally it will probably end up using vertex programs if you're using fragment program say your application doesn't fit into the standard OpenGL lighting pipeline you've got an existing lighting model that you want to implement in vertex program and you don't want to change that to the OpenGL one you can you can use a very extra much for that say your application is pre-processing a vertex rays or every time you draw an object you're touching the data one way to get rid of that touching the data sea view time is actually moving up the vertex program isolate that that part of your program actually does that and move it up that examples would be surfaces and vertex cleaning in between it's from keyframe animation it's an old old term you know yeah the general cartoonist and the people who do everything in between so it's called tweening so the benefits of a vertex program essentially we can be offloading functionality from the cpu to the GPU you have more flexible per vertex geometric operations higher performance and lower memory usage let's talk about vertex programs in OpenGL pipeline so here's the old fixed model you start out with the OpenGL vertices you have your standard molecule transformation the color materials and the lighting effects and your prospective division and that's been replaced with vertex program essentially your vertex program replaces a lot of same functionality that was quote a fixed functionality a lot of that was actually included in microcode you're just inching allowing you to use that as microcode the FBI machines for years you microphylla for all these transforms so what changes your program if you're using vertex program you're now responsible for doing all the transformations the color materials and lighting the whole whole slew of other issues if you're using the OpenGL color lighting model and if once you if you're using them and you disable them if you you're here's a scenario i'll say you're switching out of vertex program and you're expecting the standard OpenGL lighting model be there you have to disable them or you'll get everything rover runs to the vertex program regardless let's talk about the computation model so what invokes a vertex program well there's a number of standard methods to find the herb spec say that the issuing a GL vertex command which usually kicks off some kind of operation indirectly through OpenGL about vertically draw elements or jaw ll raise commands the current raster position is changed and simply a a vertex program terminates at the end of reaching the end of the program so a computation model is you have independent execution on each vertex there can be and I likely are 24 vertex in each GPU temporary data so from we write a program you kind of feel there's going to be data left over but vertex program you need you run the program you've done and it's all gone so the input output model you have your vertex program you have virtuous data inputs which be your position color textures coordinates and those kinds of values environment parameters OpenGL state let me talk about environment parameters real quick environment parameters are values that you can load up to your vertex program through GL or across all works program or for a single one and OpenGL state information which would see the current lighting model and a number of a matrix matrix is available from open geo the addition you have a number of temporary registers these water available for youth why are your activating the vertex program and then lunch program completes competition for each value to the color the position and everything else you spit out to the vertex data output and once you reach the end at vertex program you sit out everything to your output register you turn and vertex program stops and kicks it off to the thrust of the engine so what's available to vertex program you know standard attributes position color texture coordinates and additional programmable attributes that you set OpenGL transform and lighting state so the parameter information is read only by the program its defining the spec essentially constant values from the from the arm from Center this program from outside you can you can program them up using environment commands from OpenGL there's two types there's global parameters which say you have multiple vertex programs you can load up across these environment parameters across all vertex program or you have local parameter which is only affect the current vertex program running so the instruction set is limited to about 27 instructions they're focused on transformer lighting number this is kind of like a micro code implementation exposed out so they're very limited there's no loops no branches you have limited program length some instructions are macros which means up you know you have instructions they're complicated that might do mobile things in one operation they might actually be two instructions within or two or three instructions and they are defined by the spec well not all pro instructions can be will require two of two instructions or more so oops Lynette this data operon the scalar operand which are you know standard floating points values and cindy operations which are also zach type values for 40 point values indexed by X Y Z and W we are this is a color texture what they're always index closed the same the same thing all data and all operations is a representative that cindy float for so regardless of what you you know you think you're loading up a single value it's always representatives for value so data component selection you have a normal skin the operation like an altar that construction you know a equals B something you got some input parameter goes to some operation it gets flushed out the bottom and they all get set you have a Swizzle simdi selection which allows you to move data between components so it's on the input select it's not on the output select so if you have a to source component you might have a source a might be XYZ and source be might be vzz you can select them all same one you have a scalar mass operation which is these are the scalar operations you can select which source operation or source component you want for the operation so if you're doing like a reciprocal divide and you want to see the reciprocal of why you essentially select why the instruction set has a number of standard scalar and cindy instructions if i could see an altivec you have your standard add subtract multiply and add multiply and adds a very important struction it's not a macro it's a one struck one instruction you can do a lot with mobile ads and you'll see in the example I'll show you you have absolute value minimum and maximum dot product disinfector the real lighting you can see the lighting in here and reciprocal functions math functions you are pretty limited you have you know the exponent base to floor fraction and log base two and then more complex complex instructions you have component selection lighting conditional set on compare does amount like you think anyways but it's well show you how it works and indirect registers load from parameter space so you can't you can't modify your temporary registers you can't index them through address in director at addressing only parameters can be indirect values so let's look at the constraints these are the base requirements for all vertex program implementation so if you write a vertex program the base implementation will have this many values it has 96 program environments 96 local values 8 program matrices one address register 120 instructions and 12 temporary registers now spec allows for anything more than that but you these are the beige requirements that you can you can you can look look to have an all-in implementation so how do you find out what your new piece of hardware has you are 300 or whatever you put in there um used essentially GL program are an integer value and queries the interface and what's there there's a whole bunch of a pneum that you can ask for and see what see what's out there let's talk about this in text all programs must start with the version signature of our vertex program one point 0 must terminate with an end statement and just about anything in between is ok it has loose you know their temper temporary and parameter variable definitions you don't define all your attempts at top you can define them in line just as long you know before you is just like C++ so what is the syntax it's it's effectively a GPU independent assembly language it's not targeting any specific GPU it's independent of all types it's not see and it's not pure assembly there's no fixed register allocation you don't it's independent like I said its GPU independent it's they're loaded as strings there's run time to pile up by by the driver ati and video whoever and there's no fixed allocation of GPU register so three kinds of parameters you have the concert parameters which are not programmable from your program you have the environment program the parameters which are programmable across all vertex program and you have local parameters which are specific to the currently bound vertex program you have temporary registers could you to start off with the temps and you can aim off up to 12 you'd be surprised how few you actually have to use key thing about using temporary registers is you get a mindset from altivec or whatever you're used to programming on of you know creating a whole bunch of data and then having a result in store them away the key thing about using the temporary registers for vertex program is computed results and stick it in the result as fast you can and reuse that temporary register then a number of urinary binary and ternary instructions you know reciprocals may have and adds and multiplies those things so just to look at the instruction set real quick this just comes out of the arms back you see the instruction on that you have a defined a set of inputs everything just pretty much everything takes a vector input might have two sources the output that's the important part by looking at the spec is you might have it might be a scalar function or it might be a vector op a cindy operation you can see the flavor of the instructions and the syntax that's used and more additional instructions you can look at the sum of math functions of power to reciprocal the reciprocal square root all all those instructions are scalar outputs so you have to select a particular if you want to square root of some value like a square root of the Y value it's going to be spread across all the outputs and it's an absolute show them this an example so we're to get more information on our vertex program well the shader builder in the development tool just comes for free and it's a great place to start it has active syntax checking you're not going to you have to build a framework and build a program to make it work and just turn it on start the island way and please work let's talk about loading program and controlling the execution environment for vertex programs so vertex programs are loaded its strength like I said that runtime compiled by these by the driver essentially there's only one way to do it today they left they've left ways to do it different ways in future but strings are the only today it has active syntax checking so after you try a load of vertex program you can test to get the GL get error and if you call a GL get string with its new it'll actually come back the string reporting the actual position in the code where the air was found which is very useful so you'll find out so loading like I said there's parameters you have environment parameters there's a specific call from loading environment parameters its program a and B parameter and they're all loaded Cindy values there's no way to load a scalar value everything gets loaded Cindy also there's an equivalent call for local parameters you know GL local parameters and they also get loaded Cindy let's go through a basic vertex program what's going to do it's a effective leader shader builder example maybe a little bit simplified we're going to do a model you perspective transform of an input vertex and set the result and moving on you so we are here we have shader builder and bring it up a little bit let's look around here a little bit you have essentially your your code input here this is actually loaded as a vertex program it's like it's the you have to load it before any begin end statement by the way you can't you can't change it while you're doing it to get even well you know draw rays and draw elements have implied begin in but effectively before begins statement you better be doing you have you have to have it slowed as a program ok so let's go through this again you have your editor in interface right here you can enable disable the vertex program you have a number of objects available to draw your you think your test your vertex program out on you have the sphere t pas de he'd run plane I think I think is actually called cool everybody drives cheaper and you have a your dl per hour and you can dial up color you can change the color on the fly go to crayons that's right here we go you can also select a number of texture units available for input you can load them up and select them through this this interface but today we're just going to use protection unit 0 and you can enable or disable it turns things on so and then over here you have a bunch of debugging information I'm not going to go through it you know it's essentially allows you to step through a vertex program and watch the values change in addition shader builder has an instruction reference that comes up over here so you're not digging around the r-spec 64 pages long and it's but it's really detailed you want to read it it really gets there you know okay but you can actually have online documentation of all the instructions and what they're supposed to do so let's go back turn it off so start the program out our vertex program one point oh I have an offset a scale and a zero value it's the constant throw it in here I have even once you program enough you start throwing in your standard you know cut paste and I have a whole bunch of standard values I use all the time you know here's a temporary value the vertex position let's show you example of the runtime compile sorry inliner chick so I see ship comes up with an error saying there's something wrong here and if you look at the bottom it says line 9 actually if you did the deal error check and actually pulled that string out like I show them a previous example able to turn this same value so as you work into project builder example and you start to label yourself just about all your vertex programs will pull that string out just to help you out so let's start up right here i'm just adding a here's the vertex position right here that's an input value that comes from the program here's a here's a temporary called beep beep box and a zero value so i can inline axe it can actually add an offset and they actually automatically adds of the program i can change that offset real time these are great tools by the way you know what one thing i do a lot is i actually get a program up and running here cut and paste it stick it in a file and add to my project builder and then once I if I develop errors in the program I always come back and paste it in here see where the air is a and right here so I'm taking the vertex position the ring from the from the input assigning to a temporary but by doing an ad of an offset and then I'm multiplying by some scale value and you can comment all this stuff out just like that it's pretty easy so moving on then we do the transform of the value we can messing around with we set the result color now you can set these two anything you want to I want to spent too much higher but you know that doesn't work alright and then also set the text coordinate so that's an example of a basic vertex program within shader builder it's pretty simple it's probably 10 instructions five inches long so let's go back so we're going to go through an extra ring go through a lighting vertex program that's another major youth for verdicts program for like I said if you don't have standard GL lighting model if you want to use what we're going to do is we're going to use shader builder essentially the same example Kim's later development example area we're going to model view the transferring of a video booth verdict perform some lighting computations and then move on to the demo a little more complex ok so I want to remove some function out here before I moved on too much I'll leave that up with Naomi so you can look at this in stages thing being applied in stages at rib you know effectively it's a pound of flying I mean it really is so if you want to use nice names for standards input values you can call them at ribs you have now I have two parameters here and if you notice in this parameter right here I'm sharing a whole bunch of values rather than creating multiple parameter variables I'm jamming a four scalar value three scalar values into one simdi value you'll save parameter space and it will end here's your life position so what we go through here we do our model view perspective transform now we start computing the lighting value-based like position then we start issuing a light instruction and then we add that to the to the current value so this is standard shading stuff and then here we had a little funk shading to it so we could see the nice thing about this tools you can do things right in line and test them as you go as you develop say you would develop a bug through here you can comment it out real time and actually see what part of the program is actually messing up and then we go through and remove this is the result of the outputs position and the color so those two simple examples of how to use vertex program and the shader builder we're not going to talk about shooter well too much we move on some new new ideas so as far as sheeter building goes it's a great place to start it's great tool you load up textures you don't have to build a framework you can get started today it also provides active syntax checking for you know of your vertex program as they develop in addition as you start out it has online instruction information so far as program possibilities you know a lot of people you know you look at the instruction set it's it's rather small of lighting focused the code space is pretty small we're all used to having much code as you want to and the number of temperature temporary registers is actually pretty small but you'd be surprised what you can actually do is that you can do surfaces you can do active displacements you can do real-time displacements you can do advanced lighting effects keyframe animation and visual computations so let's go some real quick tips from an application standpoint best way to use vertex program is using vertex raise combined with vertex array ranges key thing about this is you're moving all the CPU from the issuing and fetching of all the vertex raise so you're keeping the CPU out of the equation use a compound selection to save parameter space so rather having you know like mobile parameters defined like one to the runtime supplier is not gonna be able figure this out stick them together in addition use a compound parameter save yourself reciprocal multiply save it by actually pre computing these fixed values and combining in one array so here I have factorial 67 twenty- 720 the inverse of that and the negative of that additional programming tip these are things I've had to figure out at once only one value for some instructions can be selected and at some point you might want to merge all those values back into the same vector of our same 50 value and start computing again rather than generating a single scalar value and then doing a whole bunch of work on generating another sim scalar value doing how much to work on it you might want to merge all back together and just compute them like you would using alt of X so you can use the Select parameter and I multiply add instruction to merge everything back together this shows how you're using your doing a reciprocal on 33 values and then you're starting to merge them back together by two and multiply add back into one value this actually is quite helpful conditional selection there is no you know branches so how do you do conditional selection well the only way really do it is through multiplies so you have a you have a value say you want to do if a greater than equal to B been assigned sequels a or some of that you have to do you know set greater than equal which actually set it doesn't actually what does it sets the if it's if it's true it sets the output to one so you're going to use that one value to multiply against the input value and it's so it's either going to be one or zero and a mad instruction in between that merges the two together as like it's like a conditional would so I've got down to four instructions and there's no branches so let's talk about vertex programs for surfaces so a lot of the lighting functionality for vertex program is actually moved down the fragment program you can get perfect cyl lighting so what else can you do with this this is a pretty powerful little tool here you have here so rather than tweaking with your where two verses every time you want to move from a position or you want to find a new shape to see the UV mesh essentially to two-dimensional mesh that you create once and you never touch it again so the vertex programs can compute the XYZ position of all the values you can be surprised that you can do with it you can do quadratic surfaces implicit surfaces parametric surfaces you can do bilinear interpolation busier b-splines and nerves all critics program so what's a what's UV mesh well you be matched the 2d mesh it's bounded by u and v u and v could be bond between any kind of fixed value parametric surface such as 80 surfaces and nerves b-splines we've gone between zero and one implicitly for the whole surface so you know why would you want to use a vertex program for surface well you'll have to define one mesh one match for all all your objects and by using that you never have to touch your virtus again you can load them up from DRAM and you'll never see them again you can animate surfaces using control parameters will show an example that and you're offloading the work from the cpu the GPU let's uh let's talk about the implicit surface vertex program cool math singing stick it off the web page you know that's three sine values I get a USB for x and y sine of U and V for x and y and then for control parameters combined with you and be so it's the final Z value so we're going to build a birthday will the UV mesh with a vertex array we're going to bound it between negative PI and PI and have some number of steps in between so and then we're going to fill in the position with the UV mesh U and V i sees the Z 0 is actually right here the U and V are just input parameters vertex program so we're going to create our program debug it through shader builder and load it as a program string then we r load the shape control parameters the ABC and D you seen in previous equation as local parameters and then we're a submit a number of quad strips and as a for drawing so here's our object in line format d this is actually a one two dimensional UV mesh being input and it's very it's finally capsulated and if all the positions are being computed by the vertex program right here our control parameter we can dial in anything we want change the shape tear it apart so these are the ABS and sees everybody sees this wants to go out and do not and stuff like that good luck but you do a lot of cool stuff so let's do a little demo here right now for computing shape on applied it similar once in the vram not come across a GP at all vector coordinates are being submitted by the vertex program built on the tapes beach deterred by the equalizer value I'm touching them with an OpenGL context right here I'm pulling the input from a good time and here's the volume [Music] that example it's fun so what you see there you've seen a vertex program that competed the object shape and color and the texture coordinates the control value is a B and C D were fed up as control Prem so one cindy value per frame was loaded up and it computed everything else based on that one value there's no sign function so how do I can choose that I use a McLaren power series you could do you can do a lookup but it just about as much work as doing McLaren because you're going to do in direct address register loads and all that stuff so and then once I had the values computed i computed all three signed values the same time using an alternate similar code so let's take a little program about a small up here you guys see that dim the lights name so there's an input parameter ABCD for temporary values not a whole lot so the surface was described by you know to fix UV values for X&Y and then the control parameter for the shape are in the Z so i had to compute those on the vertex program rather than stuffing the vertex array every time new values so that's about two constructions there it's that's example the syntax it's very assembly like then I'm cranking on and I'm starting to compute the sign values through a number of terms so if you notice I'm doing a multiply and a mad instruction and I'm continually moving on then we do a few more term we set the output position so once i have the output position I jam it away because I'm gonna use that temporary value again and then i set the texture coordinates to some input value which is actually get time I jammed it in the EQ 0 1 2 3 x value and then I add it to the vertex coordinate and it's that guy's been normalized between 0 and 1 and that's it so where do you go from there try doing waves waves are actually pretty simple very similar use cosine functions you can have essentially multiple meters you think about things bobbing up in water in the water you have three four bobbing the water and for each point on the on your water you just simply compute how far you are away from that the cosine emitter and computer your Z value on that and then some across all the emitter xin the whole thing there's a demo tomorrow that shows this is pretty cool so let's go through NURBS actually I had violating your surfaces b-splines and everything else figured out nervous took awhile to figure out how to do them so why is this why is the vertex program for NURBS most people who use Newton herbs in OpenGL have already figured out that nerves is slow you have to do multiply accumulate across the number of control points and they've either rolled their own nerves evaluators you can store multiple patches as a single vertex array and just load up control points for each patch you can do automatic level of detail based on how close the patches to the user or the screen by selecting multiple different you viver meshes so what's nerve actually the Maya come to the airport my book dropped out and a guy comes up and goes what's an herb and I got to about non-uniform rational his eyes glazed over you walk away so well people said nobody really understands there's actually that's what remains would so its surface defined by interpolating a number of control points it's used a lot in cat dominant in cat for because it can do spherical and a number of things you can't do with Bezier surfaces if you want more information on nerves i'm not going to explain how they work here go search for introduction to nerves in the web or rogers has a pretty good book on it and is very simple to read so we're doing outline of how to draw an herb using a vertex program we're going to compute the b-spline basis functions for that particular nerve on the host it's recursive evaluator that's the biggest problem I had with figuring out how to do it on the vertex shaders is it's recursive function there's no branches there's no calls or no jobs so how to compute it on the host that's actually pretty good thing because you only compete at once and you never do it again so the low in your load the control points as local program parameters and then you can do the same thing for your position your normal your texture coordinates they just get loaded as control parameters they don't get loaded with a new new mesh since you just control point parameters so you're you're only loading 16 points for each parameter that you want to load in this example so this example is a four by four controlled mesh position information is interpolated vertex program real simple example on the implementation side say a 4 4 by 4 control mesh if you don't know anything about nerve that means are going to have 16 control points 16 basis functions / UV value and that's that's a lot of storage so what I do is I actually post multiply the basis functions in terms of rows and call them on the vertex program as I go along and that's essentially reduces the the the requirements down to a float if you just look a little you know formula right here you see you know the UV point is the sum of your number of control points which is 16 then you have to set the basis functions one for the rose and one for the column this is a demo so we our surface I put a texture on it just to show you know there's a UV that I use come here in the left hand there it's actually quite a few number points 10,000 points 100-500 grid there's the there's a number of the control points right here you can grab the control points you'd move the surface real time it's all been computed on the vertex program then loaded as a meshed UV mash and vram it never gets never goes across the AGP bust more than one and you can do a lot of fun things with it nerve is actually very flexible surface there we go so that's cool so let's talk about what we've seen Nash 100 110 thousand point if you do the math just for the position only that's 96,150 thousand flops the hostess didn't have to do a full screen application on it at 1280 x 1 k75 frames per second not blah de blah blah it's about a gigaflops just the position only so if you want to add textures and normals of that you can add on entry three giggles Bob and the GPUs can do it let's talk about the program real quick hopefully you're not straining your eyes I have to to input a you basis and a V basis there's for floating-point Cindy values their bring them in through the vertex position and the color and have a number of control points as program locals and then show mall there's number of 16 so here I am I'm pre computing a post you know post multiplying the basis functions to come up with the the required basis functions I need for each row column combination so i multiply post multiply and then I start my multiply accumulate on all the control points as I go along for each point for this example there's four it's a four by four so it's four rows so there's four sets of these things I go along continually computing the new basis functions and I finally end up with a final position do a transform I have a result position and then I start then I just move the texture coordinate long if the texture was normalized between zero one flips it across the whole surface so where do you go from here pretty cool stuff well you can add you can import the position and normal and the color information texture information from a modeler program directly into this you can design vertex programs for different sized meshes you know three by five you know anything anything that value if you look at the number of instructions that take let you figure out work you know that you're bound to a certain size you can't interpolate you know 10 by 10 control matches there's just not enough space in the vertex program to do that and then you can actually do I haven't 30 have I know you can do it subdivision surfaces subrogation services people have always said that they're algorithmic they're always like a similar to be slime but if he looks at there's an exact solution for subdivision surfaces in siggraph 98 in the back end of it so we actually sat down figured it out so that was on the biggest problem of implementing subdivision surfaces you know if you want to do very simple demo violating resurfaces are easy Bezier surfaces you compute the basis functions on it on vertex program and neuro feel it more complicated like instead of users recursions of his ears are simple so let's do a wrap-up so vertex program there a powerful tool for shading and lighting you can use custom lighting models outside the OpenGL lighting model you can add additional complexity to your geometries and vertex program and also you can actually load a lot finer level detail I mean if you look at some of the games out there today the level detail is terrific you know you can use UV meshes to define most surfaces and once the UV mesh is defined you can load in vram and i'll never go across the AGP bus again you said you can lower the cpu load for for most applications and you're seeing up to a hundred times faster performance than having the host compute those kinds of values so where do you start start with a shader builder start with simple transforms you know play with the scale play with the position move those things around change of color gives get a feeling for how the language works move on to lighting model actually skip the lighting model don't expect services but as I am and then move on to simple UV meshes try an implicit surface models come with your crazy cool naphthenes and then start exploring b-splines and nerve everything else so more information on the ARB vertex program you can read the spec it's 60 pages long and very detailed lots of information in there and it gives you a kind of a guideline of what things are supposed to do or you can go to use shader builder I'm going to try and have these these posted in the next couple weeks hopefully yeah yeah and then or for the old Mac OpenGL mailing list thank you Michael now I swear what I want to do is just do a quick you know twirl for the road map here we have plans for the remaining sessions talking about open jail and also the graphics technology and Mac OS 10 I think we're actually on Wednesday obviously so what we have remaining for you tomorrow in the OpenGL track is essentially fragment programming with open jail this is the sort of more pixel specific companion to the programmability it's also gonna be a really cool session lots of interesting demos so if you're interested in programmability unlocking the power of the GPU should also attend that session we also have obviously we're talk tomorrow about our course 2d technology which is also relevant for OpenGL developers because one of the things we announced in our graphics imaging overview session yesterday is the ability to use 2d drawing API to draw directly into an OpenGL context that can also be very exciting for OpenGL developers because they can make things like doing high-quality text and open jail very very easy then we have a great session that if you're doing any OpenGL development you have to send session 209 which is the OpenGL optimizations one thing that I realize been working with a lot of developers are using OpenGL is in many cases they're leaving performance on the floor on the platform and it's a mini case you have a great tool set and this session will provide a lot of information for you to learn how to take a look at your applications and figure out how to unlock the true performance potential of both the GPUs and also the Macintosh is a platform and Mac OS 10 and then another thing that might be interesting is session to 11 which is gonna be on Friday which is introduction to court services now this is a non drawing API in courts but one of the things it does it's very important as it manages the display so a lot of OpenGL developers have need to find out what the configuration of this play is what display modes available on the particular display are and this is the core api's that we really want developers to adopt and use in their applications to do things which is screen capture and display reconfiguration so you should attend that and then also we have our hardware partners ati are here this year and then session to 12 which is also on friday they're going to sort of push the envelope and show what you can do with their latest generation of GPU hardware and also programmable features because their demo team is going to essentially show what they do to create their incredibly captivating demonstrations that they they do to support their announcements of their hardware so it's going to be really cool session and it's leverage going to leverage a lot of what you've learned today and tomorrow and fragment programming with from a program session and vertex programming and then obviously we have a feedback forum on Friday our traditional spot the last feedback forum but we urge you to come back come to the feedback forum and let us know what sort of things you want to see in Mac OS 10 from a technology perspective because a lot of feedback we get at WC is what we take back and start working from figure out what goes in the next major release of Mac OS done so I think we have a QA all right way of contact information you can if you have questions about what you've learned you can contact mike larson who is the presenter today and have those questions are Jeff stalls very active with developers directly and you can also use him as a contact reference point I'd also like to add my name to this list if you had questions about the session or any of the graphics technology is on Mac OS 10 you can feel free to contact me Travis Browne at Travis at apple com so we have some additional information these are essentially the where the art vertex program expect can be found and I'll leave this up here for a little bit and what I'm actually going to do is why I go ahead and bite the Q&A team up the OpenGL engineering team up to the stage and we'll actually engage in a question and answer and I'll leave this up here so if you want to copy information down off this you'll have plenty of time okay so we have some microphones in the center right here if you have any questions about what you've seen today please feel free to go to microphone you know basically announced your name and your company and will filled your question you