Fax Initialized Validated with airSlate SignNow

Fax initialized validated

hey everyone welcome back so in the last episode we got the Vulcan rack or cloth built the Vita liter that we use from Alexander's tutorial and in this episode we're trying to get into some Vulcan code so we're going to create our Vulcan instance and then we're also going to incorporate the validation layers Vulcan doesn't have validation layers built in but what those do is they give you some feedback when there errors and since Vulcan doesn't have any way of giving feedback these are actually part of the Vulcan SDK that we downloaded and we're going to incorporate those so that we can find out when we actually encounter something wrong so let's start with the instance creation so to create a Vulcan instance first off we need somewhere to store it and we already have that we have the Vita leader right here I'm sorry the the instance that's wrapped in the Vita leader but nothing's been assigned to it so we already created a create instance function and it's empty so the function that we want to call to Corinthians is real simple VK creates instance and you'll notice this one has three arguments to it the first one is a reference to a create info struct we're going to mess with that in a second there's going to be a lot of definition for that then you also need a to set the allocation callback which is that P allocator right there we're going to just set that to null pointer there we go now that has to do with managing the the host member sorry managing the host memory for the Vulcan system but setting it to null pointer means that Vulcan we use its own internal allocator and that's going to be good enough for us at the moment it's a lot simpler than trying to figure all that out the third parameter is going to be the actual instance handle that we created before so this is how it's going to assign it to the instance that we have over in planet Vulcan H so we're just going to go ahead and do instance and normally you would pass in a reference to but in this case it's going to be replaced since we're using that wrapper class so that we'll just replace what we already have with the new things we've created and to make sure that we handle any errors instead of just declaring it this way let's go ahead and put it inside an if statement and we're going to check whether this returns VK success any of the the Vulcan calls will return VK success if they work out and if they don't then well we will find out so now if it's not VK success we're going to go ahead and throw an error go ahead runtime error just like before and failed to create instance that way we know something went wrong otherwise I'm this isn't necessary at all but I would just like to have some sort of notifications things went well we're going to go ahead and see out and Vulcan instance created successfully I like to spell correctly all right teacher goes on to the next line so now if this thing were to succeed we would find out but once again we need to have the little create create info struct right here so we're going to go ahead and create that now so we just go ahead and do a BK BK instance create info there you go right there and let's go ahead and call that I'll just call create info nice and simple and this just initializes an empty one so now that we have that even though we haven't actually fixed any of the data in it yet let's go ahead and add that into our VK create instance so we just put in a reference to the Korean info struct and now technically that call is correct I mean it's not getting any of the information it needs but it could succeed in theory so now we need to fill out the create info struct and there's a lot of pieces to this so first off we have create info and there's the S type right here that's the the structure type that we're using and Vulcan has a bunch of these pre-built so it's going to be VK structure type ah there we go structure type and we're looking for instance create infos and there it is so that's just helping Vulcan identify what type of structure this is going to be the next step we have P next we don't really need to worry about this too much this lets you have a linked list of structures we don't really need to do this so we're just going to set it to null pointer alright what else we've got next here flags flags once again we're not going to bother with right now sort of set that to zero because there are zero Flags being used P applications info there we go and this is going to be another struct we're actually doing this in Reverse because it makes a little bit more sense so to do a VK create instance you need to create an foe struct and to make a create instructor you need an application info struct so we're going to leave that blank for now it's going to give us some errors because we're not filling it out but we'll come right back to it in just a second all right now we have the enabled layer count and for now we're going to go ahead and set it to zero this is going to change in a second when we start messing with the validation layers but we'll keep it simple for now and when you have the enabled layer account you also have the PPE enabled layer name which just is a all of the layers that are being used since we're not using any we're just gonna go ahead and set that to null pointer there we go and we also have extensions so it's going to be similar to the layers we do create info enabled extension count and this one's going to be a little bit different because we are going to use some extension since we're using GL fw that's that actually has to pass some extensions so that Vulcan can interface with it so first off GL SW actually has a function to return the extensions associated with it so we're going to create an unsigned int alright we're going call that GL fw extension count there we go and we'll just start it at 0 now we're going to create a constant char star star and that's going to be eg lfw extension so what that is that's an array of pointers and so then to get the actual extension themselves we're going to say GL FW extensions and we're going to assign that to do GL fw get required instance extensions and it might not be recognizing that yes it is not and the reason for that is we need to include a reference to GL fw so the way we do that because we're already we're including Vulcan what we actually need to include is glf w-with Vulcan it's something that's built into GLW so what we're going to do here is we hash define and it's GL FW include let's see if that work there yes it did perfect and of course we probably should include GLW as well glf w /g l fw 3 . h hmm gonna be happy with that oh there we go just took a second great so now that we have that it should recognize this function call yes it does it's wonderful we still need to pass in an argument here and that's going to be the extension count so go ahead and get a reference to the GL fw extension - perfect alright so now that we have that that's going to find all the required extensions and then it's going to change extension count to match the number that we found so since we have the create info dot enabled extension count we can assign that to whatever value is now in GL FW extension count and then create info PP enabled extension names and that can just be GL FW extensions makes things nice and simple not have to do too much work here all right so now that we've got that everything's set up for our create info but we're still missing that P application info struct that we were going to pass in so we're going to make another one right above it just like we did before and once again we're going to declare it before we actually do anything so VK application info call it info and now we're going to start filling it out piece by piece just like we did before so it's very similar in structure a lot of the Vulcan structs have a lot of the same components so once again app info dot s type and this is going to be a VK structure type application info there you go once again we're going to have P max is going to be null pointer we have app info dot application P application name and this is just whatever we want to call it for now I'm going to call it planet Vulcan maybe we'll change that later but right now does it make a huge bit of difference and we also need app info application version this is going to be the version of the current version of the application we're just going to set that to VK make version one zero zero you can see that's major version minor version patch version I'll put two dots we don't want that all right now we need engine name so app info P engine name and I'm just going to call this no engine this is some stuff that I borrowed from Alexander tutorial again I may end up changing it later on but for now let's just get things working an app info engine version once again we're going to do VK make version 100 and now we need API version so this is going to be the minimum version of Vulcan that can run our applications so app info dot API version how I do VK API version 1 ho so that designates the minimum version of Vulcan that can run which is already the minimum version of Vulcan so it'll work out nicely and that should be everything we need so now we have a pin so let's not forget to add it down here so happen so OOP sorry believe that need to be a reference to have app info there we go now that's happy and that should be everything we need to where we have what we have right now should theoretically initialize Vulcan and since we're already calling in it Vulcan from tester game let's rebuild this and see if we can actually get it to work alright so we got that built perfect and let's go ahead and run test your game and it should start up give us a window and then tell us that Vulcan was was initialized successfully if everything worked out let's see how did things work and when those right here Volken instance created successfully so we finally got Vulcan running now let's get to the validation layers now this is going to get a little bit messy but it's all going to be worth it because having some sort of callback for when we get in errors will be particularly helpful and in this case I'm going to be following Alexander's tutorial pretty darn closely so once again I would recommend checking out his tutorial I'll provide a link to it in the description but let's go ahead and dive right into this so first off we need to enable the validation layer so over here in planet Vulcan dot H here we go we are going to create a sector of all of the validation layers that are being included so do a Const vector and it's going to be a vector of constant character pointers and either going to be the validation layers just like that oh and we have an included vector yet so let's go ahead and drop that right in there there we go that vector so it actually has some idea what I'm talking about give me a vector up here we didn't okay good all right so those are validation layers and we're going to go ahead and assign them we have this nice little input we can put P R which is VK layer lunar G standard validation and this is something that's built into the Vulcan SDK it gives us all the validation layers that are the standard set for this SDK and it's particularly helpful it's pretty much everything we need alright now we really don't want to run the validation layers when we are at runtime we only need them when we're debugging so we're going to go ahead and use some preprocessor directives to make sure that this only happens when we are in debug mode so we're going to create a constant bolt call it enable validation layers and we're going to make two versions of it one words initialized to false at the start and another one where it's initialized to true so we're going to use this later on in our code to check whether or not they've been enabled now right now this is terrible terrible programming because you've just declared the same variable twice so what we're going to do is we're going to these are the preprocessor directives if defined and so that's checking whether an hour in debug so if not debug then they're false but we also want them to be activated if we are in debug so then we make else and then let's go ahead that would be set to true and then we end the if so now if we are not in debug the validation layer to false if we are there true and we're going to actually use that variable later right now it's not really doing anything but it's going to come in handy now we also need to check whether or not all of the validation layers we requested are supported so right here we're requesting the standard validation set from the Vulcan SDK we got to make sure if those are actually available so we're going to create another function right here just fool oh not create check validation layer support so that'll test whether or not all the layers are supported if it succeeds then obviously they are and if not it's a failure let's go ahead just grab that from here we're going to Pat it in right underneath create instance and once again we need to give it a scope there we are so what we're going to do here is we are going to find all the available layers and then iterate through the validation layers to make sure that all the ones being used are part of the available layer that we found so to find the available layers we need to call VK enumerate instance layer properties oh here we go BK BK numerate instance layer properties bit of a mouthful now we're actually going to need to do this twice this is something that we're going to encounter a lot when working with Vulcan because when it returns that it gives it can return a number of layers and we want to create a vector that's holding all the layers returned but we can't know what size to make it until that gives us a number so the way we're going to build this we're actually going to use a UN 32 this is what Vulcan prefers because it is sorryyou and 32 T because it is a universal type it is unsigned and it is 32 bits we're going to call it layer count okay so once again here's the first call to this we're going to reference layer count and then normally the second argument you would pass in the property's reference but this is what we're going to fill in in a second so right now we're just going to set that to null pointer okay so when this returns it will just give layer count a number of layers that we found now we're going to declare that vector I was telling you about so STD vector and this is going to be a vector of VK layer properties I'll just call it available layers and we're going to pass it later so now it is the size of the number of layers that we're about to find and I'm just going to copy and paste this it's probably not the best programming practice but it works nicely here and once again we're pouncing it the same number but instead of null pointer we're going to pass in available layers data and that's just going to go ahead and give it all the data that we need so now that we've gotten all of the available layers we need to iterate through the validation layers and make sure that all of them are within the available layers so we're going to go ahead and make a for loop and for each Kahn constant character pointer layer name in the validation layers and remember that's one that's been assigned over here with VK layer lunar G standard validation so it's going to iterate through everything that was returned in that call and it's going to check whether or not it's in available layer so we're going to use a bool layer found false so it's going to assume it's not found and then it's going to iterate through all of the available layers we're going to use the auto key word here Auto just takes whatever type is returned it automatically assigns that particularly useful way of declaring a variable there's going to be layer properties and that's just the name that we made up for it and it's going to be out of available layers so it's going to iterate through all available layers each time returning a layer property object and now we need to compare those layers so we need to actually check if the available layer that we are testing right now kid matchup with that layer name from the validation layers so what we're going to go ahead and do is we're going to do if or do string compare and we're going to test this layer name how that compares to layer properties da layers they're just six two layer names we can pair them and string compare returns a zero is they equal so we'll say if it equals zero then we know that we found that particular layer so we can say layer found equals true and we can also break out of this loop because we don't need to keep checking if that particular layer is and ending two available layers because we found it and then outside of the for loop we're going to go ahead and say if layer found equal false or actually knew it let's let's clean this up a little let's just do if not layer found there we go and then we can just return false underneath this we will return true so at any point if it fails to find one of the layers it will immediately return false if it exits the for loop for the validation layer then we know that every single one was found and we can just go ahead and return true so when this returns we will know whether or not all the layer that we requested are available or not also since we're using that string compare we should probably go back up at the top here and just go ahead and include c-string just so it knows where to grab that from so now that we've done that we have a way of testing if the layers are all available and we're going to go ahead and throw that in to create instance because if we don't have the layers and we're requesting them we already have a problem so right here we're going to check for validation layer availability and we're going to say if let's go ahead and have the braces for that if enable validation layers which that's the one that's going to be assigned at the start based on the pre preprocessor directive so if it turns out that enable validation layers is true then it will actually check the rest of this so if enable validation layers and not check validation layer support so that's going to go ahead and call check validation layer support and if that fails then we really need to immediately get out of here because we messed something up so we're going to throw SCD runtime error able to say validation layers requested but not available so now it will double check just to make sure all of those validation layers exist and if they don't it will throw an error so now we have the validation layers enabled but we actually need set up a callback so we can return receive all the messages returned by the layers so this is actually require an extension and we were using some extensions before or that was with the GL FW extensions it's going to get a little bit Messier now so the essentially needs VK ext debug report so first off we need a function to grab those we're going to go back to our dot our header file and we're going to make another vector and this is going to be a vector of constant Wow can't spell constant character pointers and this is going to be gues required extensions we're going to use this to kind of simplify our extension code in a minute so let's go back over to our CTV file drop down here and once again we need to scope for actually I think I might have yep I did I forgot my parentheses that's bad okay so we have get required extensions right here and what it's actually going to do is it's going to return different numbers of extensions based on whether or not we have the layers enabled whether or not we need those debug callbacks so first off we're going to go ahead and make a vector inside just like the one outside because it's going to return this lighter and it's going to be extension so that's what's going to be returned by the function and now we're actually going to need the same code that we were using before because the extensions that we found in create instance up here that's all going to be handled by this function so we're just going to grab this pack stuff right here evan is grabbing the GL fw extensions that doesn't need to be there anymore that we can move right down into get required extensions let's drop it in there so we'll come back to that in just a second ultimately this function is going to return extensions so since we know that since we're going to fill in the rest of this in just a minute but knowing that it's going to return extensions in a second up here when we did all the messy extension code before we can just say Auto extensions equals get required extensions so it's just going to call that function to get a whole vector of the extensions and now down here in the enabled extension count enabled an extension names we don't actually need to put something specific we can just do extensions dot size which will be the number of them and extensions dot data and that handles it it's pretty nice so let's get back down to the actual get required extensions function so we're now handling the GL fw extensions but we aren't handling any of the call back extensions so we're going to do is for unsigned int I 0 we're just going to do a nice interative for loop here so this is going to iterate through all of the extensions that are in that the GL FW extensions and since we have this vector for extensions right here but the GL FW extensions are separate we're going to add each one of them to that vector we're just going to say extensions da pushback let's just add this to the end of the vector G lfw extensions I go alliterate through all them it'll push each one onto that vector and this would be sufficient right now this would all compile nicely but we have to handle those validation layers as well so we're going to say if enabled validation layers so if we're running in debug mode then we're also going to do extensions the pushback and this was what I mentioned before we need the VK ext debug report be better for extension name that's what we want right there and so that will add that on to the extensions we need and we could always add in other stuff here later to increase the number of extensions that are returned so that way we don't have to worry about extensions anymore they're all just kind of handled in this function all right so let's create an actual callback function now for the validation layer to use so this is going to get super messy but I'll do my best to explain it so we're going to go ahead and create a here we go a static it's going to be a VK bool 32 and we're going to call it debug callback so we also need to add some things right here we're going to add VK API apt R and we're going to add VK sorry not V BBK API Cole these are just some signature so the foal can actually understand how to call the function and now we need to add in a lot of other stuff it's going to get fun so these are all the things that need to go in here we need a VK d bug report flags DX t let's call it flags next up we have the VK debug report object type exe the object type and this is some messy stuff if you don't understand all that don't feel bad and I mean this is the kind of thing you pretty much have to look up next up we have you inch sixty-four key objects Oh unit don't misspell things add it bad in program all right five T location int32 t code constant charts are layer prefix char star message and void star user data that's all the things that need to go inside the debug callback it like I said super messy stuff the flag parameter holds the message being output the object describes which object the call is coming from object type is the type of that object the other parameters aren't super important it's what we really care about is the message right here that's a pointer to the error message it's being output so all we need to do is inside the body of this and bring these down a bit and I'm keeping this out of the CPP just because it's a very short function it's going to be much easier to store it here we need to go ahead and return ZK else just so that Vulcan understands that this is an error and for the users of benefit we're going to do standard C air and then validation layer and we're going to output the message so now we won't just get an error we'll actually get an error with some description as to what's going wrong and we'll kind of get some feedback on this which is really important if you don't know what's going wrong it's pretty hard to fix it now we're also going to need a handle to the callback object and like any other Vulcan object is going to need to be created and destroyed just the way we did before so once again we're going to need that feed to leader so let's go ahead and create a handle to the debug report callback so down here we'll do it after the instance this is another in fact you know we're just going to label this we're gonna put all the handles here we'll call them Vulcan handles just keep things nice and organized so underneath this one another Vita leader this one is going to be a VK debug debug report callback exe there we are and like any other one of these that we made we will name it callback and we're supposed to pass in for this one the instance which we have so right above it and then a destroy function which we don't have yet so let's go ahead and create a create function and destroyed function for the callback so right over here above the debug callback object we're going to go ahead and make a VK result type which is going to be the create debug report rip rip harsh call back EXT alright there's gonna be another one where we have to kind of fill in some arguments later we're going to come back to that and then we're also going to make a static void destroy debug riff for so come on and get capitals right call back EXT so now we have a destroy function we haven't filled that one out yet e'er but again why don't we just take that grab it bring it down here so we don't forget and drop it into the vida leader so now in theory callback knows how to create and destroy itself all right now let's go on back up here and fill these out so the create debug report callback we're going to go ahead it needs a D K instance instance it needs a constant D K debug read porch call back create info ext pointer P create info Jenna spell that I did lowercase K there we go all right now needs a Const B K allocation callbacks perfect pointer a P allocator and then a VK debug report callback ext R is all caps ext pointer P callback quite a mess but that's everything we need for that one and then the destroy one is going to need some as well so once again we're going to need a VK instance I'm just going to copy and I'm starting to get late here okay we need a BK debugger for callback exe again all right is going to call that callback and then once again we need the P alligator and that should handle everything we need for to create and the destroy now we are going to need to actually fill those out in the CPP so let's hop back over there alright and we're just going to add these in down at the bottom now let's fill these out so once again this is all stuff that I looked up from the tutorial this is not stuff that I just have off the top of my head so if it's hard to follow don't feel bad that a lot of the stuff in Vulcan you kind of just have to look up it's not super intuitive so once again give all these their proper scope there we go once again you can't declare static right here we can already been declared static so let's fill out the create first so open to create one we need Auto bunk equals P and PF n this is going to be VK create debug before callback ext so we're just going to cast and then we have BK get instance proc adders Qasimi instance a string of VK create debug port go back ext all right good now that we have that we're going to say if funk does not equal null pointer so long as it's exceeded then we're going to go ahead and return funk with instance P create info which will be passed in P allocator which would also be bounce in and P call back now if it failed we want to let everyone know so we're going to go ahead and return the K error extension not present now let's go ahead and fill out the destroy one this is a little bit simpler so once again we're going to do Auto funk and the reason we're doing this is we have to look up the proper function since these are extensions they're not immediately accessible so BK destroys debugs give a report call back EXT one again casting it BK get instance rock adder instance got in that string again there we go that should find the proper thing don't forget our semicolon and then we're just going to say if funk not equal null pointer again and if it doesn't then we need to get rid of its oldest funk instance call back P okay all right doesn't my call back ha okay so this is why you don't want to copy and paste because you'll notice a callback here it's passing in a pointer and callback here isn't a pointer it's because I messed up in the declaration the callback in the destroy is not a pointer but because I copied it from the create one which is a pointer I kind of screwed that up so this is why you don't want to copy and paste you can break some things that let that be a lesson to you all all right so we have the create we have to destroy everything should be working nicely now and actually I think I changed my mind I think I just want to move these into the header keep the CTP a little bit cleaner there's enough here already we'll just copy and paste this real quick so we're just grabbing the body pulling it out going to the header and just dropping it right after the parameters and of course before the semicolon and then we're just cutting it completely out of here give us a little more room because we're going to run out of room pretty quickly all right so now that we have that we don't actually have any way of creating or destroying the call back yet we have functions for it but we haven't actually done it so what we're going to do is we're going to create one more function after create instance called setup debug call back and that's actually going to initialize it with all the things that we need and we should probably declare that our header file so this is a good place to copy and paste because if we don't do it here and some things don't match up it's going to get angry with us all right it's going to be void so we got that and let's drop it right down here once again giving it the proper scope never forget that there we are alright and so in the setup callback first we need to check if we are even using validation later because if we're not we don't need to be here so my spelling is terrible not usually just when I'm typing with a microphone so if not enable validation layers we can just return we don't need to be here this is pointless now if we do have validation layers it's going to be a lot like the other structures with May we need to create info forms so we're going to save DK debug debug report keep chuckling to the movies report callback there it is create info exe call it create info and once again we're just going to create it and then initialize each thing in there we need so create info dot s type is going to be equal to VK structure type debug report call back create info exe that's what it is quite a mouthful but so go create info dot flags we're going to be equal to DK d bug reports error it's exe and then we're going to bitwise or that rip VK debug report warning XT and then create create info PF n callbacks can equal debug callback all right now we just handles us the same way we've handled any other creation like when we created the instance we're just going to say yes and it's going to be create debug report callback exe using our create function we're going to pass it all the information in each which is going to be the instance reference to create info once again the allocator which is going to be a null pointer and then the p callback which since we're using the delete are again it's just going to be callback replace remember we have to do it that way because we're using that people eater and we're going to check whether or not an equal VK success so if it does not equal BK success we throw that error just like before STD ranking error failed to set up debug callback else and once again we don't have to do this but I always like to just because it makes me feel a little better see out debug callback setup successful so now if it succeeds we won't know and that's kind of what we want all right so now that should take care of just about everything let's see if we can actually get this thing to run now so once again let's never forget to build the engine alright everything built nicely so I think we're okay Oh actually you know what there's one thing we forgot to do if you remember we had a layer section we were setting up the create instance where is it where is it here we go and we did nothing with that and we're using validation layers now which are layers so if we don't actually add those in it's pretty useless so let's go ahead and do that so we're gonna say if enable validation layers then we want to change how we're doing this we're not going to do it like it says there we're going to copy it and we're going to say the layer count is going to be equal to validation layers dot size so now however many validation layers we have that's the count makes sense and of course the layer name is going to be equal to validation layers dot data so that takes care of that all this stuff down here we're still going to keep that that's going to be our Ellis case so if we're not using validation layers it's going to do this and we're just going to grab all that and move it right out okay that should do the trick so now let's rebuild this and see how things go alright so it's built nicely let's go ahead and test test your game and let's see what we get and it crashed all right so the better understand what was going wrong I use the exception settings right here because it's just crashing it's not giving me any information about where it's crashing so what it helps is to go to tools and customize go to commands drop us down to debug go to add command went to debug again there is and then I went down to exception settings where to go well it's not there at this point because I already added it in but you could go ahead and click exception settings hit OK ok again and that will add it right here and exception settings allowed me to choose when to throw an exception and I chose to do when the C++ exceptions happened so that way these unhandled exceptions would be would stop me on a particular line another thing I did just to prevent myself from messing anything up so over here in tester game I keep forgetting to rebuild PD engine and that's causing me some problems so in test dreams you go to right-click build dependencies and project dependencies you can go ahead and check PD engine if you do that now anytime you try and run it it should rebuild PD engine as well just to make everything work out properly alright so I finally figured out what the problem was it turns out that I just didn't have the newest version of the lunar G SDK what happened was in the header file when we initialized validation layers to VK layer of energy standard validation it wasn't really understanding what this was anymore because it turns out that the SDK was out of date so just had to go to the website download the new one install it and then I had to go to the properties for both P V engine and tester game and just wanted for the VCC directories you had to change the path to the new version once it did that went ahead and build everything and there it is the layers are available the instance is created successfully and the debug callback is set up so everything runs that's all there is to it sometimes things mess up like this and you kind of just have to stumble around through it until you figure it out so that's all for this episode in the next one I'm going to set up both the physical and logical devices and once that's all done Vulcans should be ready to go so thanks for watching if you have any questions or suggestions feel free to put a comment in this video and if you'd like to be notified when a new one pops up just go ahead and hit subscribe