Subscribe to GameFromScratch on YouTube Support GameFromScratch on Patreon

11. May 2012


Alright, I have been programming long enough I shouldn’t have made this mistake, but… I did.  In the comments section for Working with Spritesheets, there were a couple comments about being unable to run on the device.  I swore when I was testing this I ran it on my actual Vita, but apparently I did not.


I really should have, because frankly it doesn’t work.  It just hangs and makes your Vita extremely unhappy with you in the process.  Running it through the debugger, I found it was dying a hideous death on this line:

XDocument doc = XDocument.Load ("application/" + imageDetailsFilename);


Hmm, nothing out of the ordinary there.  So off to Google I go!  Ends up that this is a bug in the SDK, welcome to the wonderful world of beta software!  From the same thread, the fix is fairly straight forward.  In Walker.cs change the beginning of the constructor to look like this:


//XDocument doc = XDocument.Load ("application/" + imageDetailsFilename); FileStream fileStream = File.Open( "/Application/" + imageDetailsFilename,FileMode.Open); StreamReader fileStreamReader = new StreamReader(fileStream); string xml = fileStreamReader.ReadToEnd(); fileStreamReader.Close(); fileStream.Close(); XDocument doc = XDocument.Parse(xml);


You will also need to add SYstem.IO to your using declarations. Now everything will work fine when deployed to an actual Vita.  Hopefully Sony fix the bug in Xdocument.Load soon.



In the future I will make sure I test all tutorials on my device before pushing them live!

Programming , ,

7. May 2012


As the title suggests, this thread is going to be about using sprite sheets with PS Studio.  For those of you unfamiliar with the term, a spritesheet is a single image with multiple sprites.  You generally group your sprites together on a single sheet as it is much more efficient for loading and generally performs better than loading one texture per sprite.


EDIT(5/11/2012): If you are working with an actual Vita device and using the beta SDK, there is a bug on the Vita XML that prevents this from working. Read this post for a simple workaround. Hopefully in time Sony fixes this and you no longer need to apply the bug fix. Note, the problem only occurs on an actual device.


Instead of showing you how to generate a spritesheet, I am going to recycle a previous post I made on creating a spritesheet using Daz3D.  Fortunately Daz Studio is still available for free if you want to follow along.  Of course you can create your spritesheet however you want, or can simply download a freely available spritesheet such as those available at  Or of course you can just use my sheet which will be available later.


In this example, I am going to use a different program than the GIMP for assembling the spritesheet.  The end result of my Daz tutorial is a directory full of 128x96 images like these:




You can download a zipped copy of the sprites I rendered right here.


I generated 19 frames of walking animation in each direction.  This time I am going to use the free version of the tool TexturePacker to generate my sheet.  Download and fire up TexturePacker and you will be greeted with this interface:




The first thing you want to do is add your sprites to the sprite palette. You can either drag and drop the folder ( using Windows Explorer ) containing your sprites to the sprite panel on the right or hit the Add Sprites button and select the sprites individually.  Add all of the sprites you just created in Daz3D ( or the folder you downloaded and unzipped ) using either method.  Dropping a folder will automatically add those sprites in a folder by that name keeping things a bit more organized.  Here is the results of me dropping my walkCycle folder on the sprites panel:




As you can see, it added all of the sprites under a folder named WalkCycle and automatically layed out our sprite sheet as efficiently as possible.  As this point though, we don’t really care all that much about efficiency, so we are going to make a few small changes.  In the Texture Settings panel we want to fill in a couple options.  First drop down DataFormat and change it to “Generic XML”.  Next, under Data File, pick a directory and filename to save your sprite sheet, I choose c:\temp\walk.xml.  This will automatically set the texture file to c:\temp\walk.png.  Otherwise, these are the settings I used:





You of course can use whatever settings you want, but if you want exactly the same results as me, use the above.  Now that you are ready, hit the publish button.



The end result is a PNG file and an XML document. 


The resulting image file:




You can download the generated image file here.


It also generated an XML file with all of the sprite details.  The contents of that XML file look like:


<?xml version="1.0" encoding="UTF-8"?> <!-- Created with TexturePacker> <!-- $TexturePacker:SmartUpdate:a6e51795dbe6b13cd639951a1f67241c$ --> <!--Format: n => name of the sprite x => sprite x pos in texture y => sprite y pos in texture w => sprite width (may be trimmed) h => sprite height (may be trimmed) oX => sprite's x-corner offset (only available if trimmed) oY => sprite's y-corner offset (only available if trimmed) oW => sprite's original width (only available if trimmed) oH => sprite's original height (only available if trimmed) r => 'y' only set if sprite is rotated --> <TextureAtlas imagePath="walk.png" width="512" height="960"> <sprite n="Walk_left00" x="0" y="0" w="128" h="96"/> <sprite n="Walk_left01" x="128" y="0" w="128" h="96"/> <sprite n="Walk_left02" x="256" y="0" w="128" h="96"/> <sprite n="Walk_left03" x="384" y="0" w="128" h="96"/> <sprite n="Walk_left04" x="0" y="96" w="128" h="96"/> <sprite n="Walk_left05" x="128" y="96" w="128" h="96"/> <sprite n="Walk_left06" x="256" y="96" w="128" h="96"/> <sprite n="Walk_left07" x="384" y="96" w="128" h="96"/> <sprite n="Walk_left08" x="0" y="192" w="128" h="96"/> <sprite n="Walk_left09" x="128" y="192" w="128" h="96"/> <sprite n="Walk_left10" x="256" y="192" w="128" h="96"/> <sprite n="Walk_left11" x="384" y="192" w="128" h="96"/> <sprite n="Walk_left12" x="0" y="288" w="128" h="96"/> <sprite n="Walk_left13" x="128" y="288" w="128" h="96"/> <sprite n="Walk_left14" x="256" y="288" w="128" h="96"/> <sprite n="Walk_left15" x="384" y="288" w="128" h="96"/> <sprite n="Walk_left16" x="0" y="384" w="128" h="96"/> <sprite n="Walk_left17" x="128" y="384" w="128" h="96"/> <sprite n="Walk_left18" x="256" y="384" w="128" h="96"/> <sprite n="Walk_right00" x="384" y="384" w="128" h="96"/> <sprite n="Walk_right01" x="0" y="480" w="128" h="96"/> <sprite n="Walk_right02" x="128" y="480" w="128" h="96"/> <sprite n="Walk_right03" x="256" y="480" w="128" h="96"/> <sprite n="Walk_right04" x="384" y="480" w="128" h="96"/> <sprite n="Walk_right05" x="0" y="576" w="128" h="96"/> <sprite n="Walk_right06" x="128" y="576" w="128" h="96"/> <sprite n="Walk_right07" x="256" y="576" w="128" h="96"/> <sprite n="Walk_right08" x="384" y="576" w="128" h="96"/> <sprite n="Walk_right09" x="0" y="672" w="128" h="96"/> <sprite n="Walk_right10" x="128" y="672" w="128" h="96"/> <sprite n="Walk_right11" x="256" y="672" w="128" h="96"/> <sprite n="Walk_right12" x="384" y="672" w="128" h="96"/> <sprite n="Walk_right13" x="0" y="768" w="128" h="96"/> <sprite n="Walk_right14" x="128" y="768" w="128" h="96"/> <sprite n="Walk_right15" x="256" y="768" w="128" h="96"/> <sprite n="Walk_right16" x="384" y="768" w="128" h="96"/> <sprite n="Walk_right17" x="0" y="864" w="128" h="96"/> <sprite n="Walk_right18" x="128" y="864" w="128" h="96"/> </TextureAtlas>


You can download the xml file here. This XML file contains the details about how our original sprites are arranged within the sprite sheet and will prove useful in a moment.


Alright, now that we have our spritesheet and our sprite map XML file, lets fire up PSSuite and get down to some coding.  This tutorial assumes you have already gone through my earlier tutorials, at the very least the two Hello World tutorials.


Now create a new solution in PlayStation Studio, I called mine SpriteSheet.  We need to add a couple of references right away, add a reference to GameEngine2D, System.Xml and System.Xml.Linq. Now add your spritesheet png and xml files to the project, right click them and set their build action to content.



First we are going to create our gameloop in AppMain.cs.  I want to point something out right away… this is not the way you handle game events!  So the way things are done in this example are *NOT* the way we will do things in the future.  I went this route because you are already familiar with most of the code here.  In a (very near) future tutorial, I will show the “proper” way to handle updating game objects.


With that warning in place, lets take a look at AppMain.cs


using System; using System.Collections.Generic; using Sce.Pss.Core; using Sce.Pss.Core.Environment; using Sce.Pss.Core.Graphics; using Sce.Pss.Core.Input; using Sce.Pss.HighLevel.GameEngine2D; namespace SpriteSheet { public class AppMain { private static Walker walker; public static void Main (string[] args) { Director.Initialize(); Director.Instance.GL.Context.SetClearColor(255,255,255,0); walker = new Walker("walk.png","walk.xml"); var scene = new Scene(); scene.Camera.SetViewFromViewport(); var sprite = walker.Get("Walk_left00"); sprite.Position = scene.Camera.CalcBounds().Center; sprite.CenterSprite(); sprite.Scale = new Vector2(2,2); scene.AddChild(sprite); Director.Instance.RunWithScene(scene,true); System.Diagnostics.Stopwatch timer = new System.Diagnostics.Stopwatch(); int spriteOffset = 0; timer.Start(); bool walkLeft = true; while(true) { if(timer.ElapsedMilliseconds > 100f) { string spriteName; if(walkLeft) spriteName= "Walk_left" + spriteOffset.ToString("00"); else spriteName= "Walk_right" + spriteOffset.ToString("00"); sprite.TileIndex2D = walker.Get (spriteName).TileIndex2D; if(spriteOffset >= 18) { spriteOffset = 0; walkLeft = !walkLeft; } else spriteOffset++; timer.Reset(); timer.Start(); } Sce.Pss.HighLevel.GameEngine2D.Director.Instance.Update (); Sce.Pss.HighLevel.GameEngine2D.Director.Instance.Render(); Sce.Pss.HighLevel.GameEngine2D.Director.Instance.GL.Context.SwapBuffers(); Sce.Pss.HighLevel.GameEngine2D.Director.Instance.PostSwap(); } } } }

Click here to download AppMain.cs


Most of the concepts in this code we’ve seen in a previous tutorial, so I will only highlight the new details.  First thing is we declare a Walker object, this is a class we are going to create shortly that is going to handle our sprite sheet.  As you can see, the Walker constructor takes the file name of the sprite texture and xml file you created earlier as parameters. 


Most of the remainder of this initial code is a matter of setting up our scene and sprite objects just like we did in Hello World.  A key difference is we are getting the sprite from our walker object instead of creating it from scratch or loading it from file.  The line:

sprite.Scale = new Vector2(2,2);

Is simply to double the size of our sprite in the viewport to see it better, you can easily remove this if you wish.


We create a Stopwatch ( a .NET object ) and start it counting up, then enter our infinite game loop.  Lets take a look at the new logic in our game loop


if(timer.ElapsedMilliseconds > 100f) { string spriteName; if(walkLeft) spriteName= "Walk_left" + spriteOffset.ToString("00"); else spriteName= "Walk_right" + spriteOffset.ToString("00"); sprite.TileIndex2D = walker.Get (spriteName).TileIndex2D; if(spriteOffset >= 18) { spriteOffset = 0; walkLeft = !walkLeft; } else spriteOffset++; timer.Reset(); timer.Start(); }


This is basically the “guts” of our game loop.  What we are doing here is waiting for the timer to reach 1/10th of a second.  Every tenth of a second we want to move on to the next frame of animation.  However we have only 19 ( walk_left00 to walk_left18 ) frames of animation in each direction and once we hit the end of our walk cycle, we want to walk in the other direction.  So what we do here is loop through each frame of animation until we hit walk_left18 or walk_right18, at which point we flip directions by inverting the value of the walkLeft bool.  This results in changing the spriteName text prefix, otherwise we simply increment to the next frame.  Then we start our timer over again to begin the process again a tenth of a second later.  One more time, this is not the proper way to handle updates!


The key line in all of that was:

sprite.TileIndex2D = walker.Get (spriteName).TileIndex2D;


This line actually tells our sprite to refer to a different sprite within our spritesheet, causing the animation.  That will make more sense in a second when we look at the code for Walker.cs.  Speaking of which, lets create it now!


To create a new cs file we either click the New icon ( image) or hit CTRL + N.  In the resulting dialog select General on the left, Empty Class on the right and name it Walker.cs, like such:




Now open up Walker.cs and enter the following code:


using System; using System.Linq; using System.Xml; using System.Xml.Linq; using System.Collections.Generic; using Sce.Pss.Core.Graphics; using Sce.Pss.HighLevel.GameEngine2D; using Sce.Pss.HighLevel.GameEngine2D.Base; namespace SpriteSheet { public class Walker { private TextureInfo _textureInfo; private Texture2D _texture; private System.Collections.Generic.Dictionary<string,Sce.Pss.HighLevel.GameEngine2D.Base.Vector2i> _sprites; public Walker (string imageFilename, string imageDetailsFilename) { XDocument doc = XDocument.Load ("application/" + imageDetailsFilename); var lines = from sprite in doc.Root.Elements("sprite") select new { Name = sprite.Attribute("n").Value, X1 = (int)sprite.Attribute ("x"), Y1 = (int)sprite.Attribute ("y"), Height = (int)sprite.Attribute ("h"), Width = (int)sprite.Attribute("w") }; _sprites = new Dictionary<string,Sce.Pss.HighLevel.GameEngine2D.Base.Vector2i>(); foreach(var curLine in lines) { _sprites.Add(curLine.Name,new Vector2i((curLine.X1/curLine.Width),9-(curLine.Y1/curLine.Height))); } _texture = new Texture2D("/Application/" + imageFilename,false); _textureInfo = new TextureInfo(_texture,new Vector2i(4,10)); } ~Walker() { _texture.Dispose(); _textureInfo.Dispose (); } public Sce.Pss.HighLevel.GameEngine2D.SpriteTile Get(int x, int y) { var spriteTile = new SpriteTile(_textureInfo); spriteTile.TileIndex2D = new Vector2i(x,y); spriteTile.Quad.S = new Sce.Pss.Core.Vector2(128,96); return spriteTile; } public Sce.Pss.HighLevel.GameEngine2D.SpriteTile Get(string name) { return Get (_sprites[name].X,_sprites[name].Y); } } }

Click here to download Walker.cs


Our Walker class is in charge of loading and handling our spritesheet.  TextureInfo and Texture2D you have already been exposed to and in this case, nothing is different here.  Next up we declare a Dictionary of <string,Vector2i> named _sprites.  The Vector2i type is declared in GameEngine2D.Base and is simple a pair of ints. _sprites is used to store the x,y location of each individual sprite in our spritesheet, accessed by the sprites filename.


Let’s take a look first at the constructor.  This code is pretty straight forward if you have ever worked with Linq or XML.  We are simply opening our XML file, the filename of which we passed in from AppMain.  Note that we added “application/” to our paths, all your files on Vita are located under this subdirectory.  Next we read the XML file and extract each <sprite> entry into a new anonymous type composed of Name, X1, Y1, Height and Width.  Name represents the file name of the source image, X1 and Y1 represent the pixel coordinates within the generated spritesheet, while Height and Width are the dimensions of the sprite within the sprite sheet.  Given that all of our sprites are the same size, these values are of little importance.


Now that we’ve parsed out our XML file, we populate our _sprites dictionary using these values ( minus height and width which we don’t need past this point ).  However, we don’t actually want the x and y pixel coordinates of our image, but instead the offset within the spritesheet texture.  We can determine this value by dividing the X and Y values by the sprite Width and Height respectively.  Keep in mind, this works because all our sprites are the same size ( 128x96 ) and would require different logic if you had sprites of differing sizes in your sprite sheet.  You may notice I subtract 9 from the height value… this is because GameEngine2D SpriteTile’s locations start from the bottom left instead of the top left!  I prefer top right and this is how I generated the sheet, so invert the values.  If you design your sprite sheets to start at the bottom left ( so the first frame is at the bottom left corner ), you wont need to perform this calculation.  Now you may be wondering… why 9?  Well that’s the number of sprites we have in each row on the sprite sheet (10, counting from 0 equals 9).


Finally we load our texture using the filename we passed in to the constructor.  Again we prepend “Application/” to our filename.  The last thing of note here is the second value in our TextureInfo constructor.  This Vector2i informs the TextureInfo the dimensions of our sprite sheet, telling it at there are 4 columns of 10 rows of sprites.  It doesn’t matter that the last row isn’t full of sprites ( there are only 2 in the spritesheets bottom row ), if you try to access them you will simply get an empty space or whatever the background colour of your spritesheet is.


Our destructor is nothing special, just cleans up like a good little citizen should.  Remember it’s your responsibility to dispose of any objects you own and are no longer using.  C# is garbage collected, but its still easy to run out of memory in a hurry if you don’t keep things tidy.


Finally we have a pair of Get() methods.  The one takes a sprite name, looks it up in our _sprite dictionary, retrieves the X and Y offset of the sprite within the texture, then passes those values into the other Get() method.  This Get() method then creates a new SpriteTile assigning it our already created _textureInfo.  Next it sets the tiles index within the texture using the passed in coordinates to represent our currently selected sprite, sets the tiles dimensions to 128x96 (pixels) and returns our sprite.  Please notice there is absolutely no error checking or handling here in order to keep things short.  You really should have a wee bit more error checking in your own code! Winking smile


The end result of all this activity:





Click here to download the entire project source. In addition to the full project source, the zip also includes all the image files used in this tutorial.

Programming , , , , ,

6. May 2012


I just ran in to one of those massive annoyances while working on another PlayStation SDK tutorial covering the SpriteTile class.



A SpriteTile is used to group multiple sprites together in a single texture.  There are literally dozens of utilities for packing sprites and every single one of them starts at the top left.  For some bizarre reason though, SpriteTile starts from the bottom left!


So as I was flipping through my sprite structure, the on screen results were almost inverted… this would be the reason why.  So, if you are working with SpriteTile, be aware of this!


30. April 2012



We are now going to look at creating a fully textured model in Blender and exporting to a PlayStation Studio SDK project, a simple model viewer.  We create a very simple model, UV map, texture then export it.  At this point, we process it using the PS Studio ModelConverter tool, import it into PS Studio then finally run our code in the simulator.


The example model is as I said, brutally simple ( it’s simply a dice, er… die, also known as a textured cube ). However the process for exporting more complex models is exactly the same.  The process isn’t really all that difficult, especially if you know your way around Blender, but if you don’t know Blender all that well don’t worry, I’ve actually captured the entire process in video form.  This video covers exactly the same thing that the rest of this tutorial does, so if you have problems following one, refer to the other and vice versa.



Modeling, texturing and exporting from Blender to Sony PlayStation Suite SDK in under 5 minutes



The above video is actually encoded at 1080p and is probably almost illegible at anything less than 720p.  You can watch it on YouTube or Vimeo in full definition.  Again, the video demonstrates exactly what I am going to show below, except the source code.  So if you are the type that prefers to learn by watching, or the type that learns by reading, you get the best of both worlds here!  Alright, let’s get started.



If you already know how to model, texture and export in COLLADA format using Blender, I suggest you skip ahead to part 2, as the remainder of this section will be quite boring for you… it goes into detail, a lot of detail. Smile



If you haven’t already, fire up Blender.  We are going to work with the default cube, if you don’t have a default cube select the Add menu –> Mesh –>Cube.  The first thing we want to do is create a new image to texture our model.


In the properties panel to your right ( assuming you are using the default layout, which I will for the remainder of this tutorial ), locate the Textures tab and click it.  Like such:





Now change “Type” to Image:



Scroll down slightly to the Image section ( expand it if required ) and click New:



In the resulting dialog, we specify the texture details.  I am going to name it the ultra imaginative name “Texture” but fell free to call it whatever you want.  1024x1024 is massive overkill for what we are doing, but hey… I like overkill.  When done, click OK.




Now we want to apply some simple texture mapping to our 3D cube.  In the 3D view, make sure you are in “Edit Mode”, either by hitting Tab until selected, or via this menu:



Now that you are in edit mode, select all the faces of your mesh by hitting “a”.  Now in the Mesh menu, you want to select Mesh->UV Unwrap…->Follow Active Quads.



Simply click OK at the resulting dialog menu.  Now we want to switch to UV editing mode.  Locate the icon to the bottom left of your view, click it and select UV/Image Editor.



We now want to make our texture the active image.  Locate the “Browse image to be linked” button, click it and select texture from the list.




Now press A to select all of our faces, then using hit S to scale ( then mouse move, left click when done), followed by G to translate, until our UV coordinates are all over the black image, like so:



Now we want to quickly paint our dice faces on the texture within the UV coordinates.  From the menubar select Image->Image Painting.



Now left click to mouse paint the texture like the face of a die.  You can use the left hand panel ( press “N” if not visible ) to change the paint settings.  When done you should have something like this:



Now, back in the Image menu, unclick Image Painting.  Now we want to save our completed image.  In the same menu as before, select “Save as Image” or hit F3.  In the resulting dialog, locate the directory you want to save the texture to ( make it the same place you are going to save the model ), name it, then click Save as Image:



Now with that complete, we assign our image to our texture.  Back in the Texture panel ( to the right ), locate the Image section, click the Browse Image to be Linked button and select your texture.



Now scroll down lower in the Texture panel, locate Mapping, then select the Coordinates: dropdown and select UV.



Right below that, select the Map: dropdown and select UVMap.





All right, now we have a fully texture mapped model ready for exporting.  From the File Menu ( top right ), select File->Export->COLLADA(.dae).




In the resulting dialog, navigate to the same location where you saved your texture, name it ( I used box.dae ), optionally select “Export only selected” then click Export COLLADA.





And we are now done with Blender.



This section has already gotten quite long so I am going to break this post into two parts.



Continue on to Part 2.

Programming, Art , , , ,

30. April 2012


This is part 2 of our series looking at getting a fully textured model from Blender to the PlayStation Vita, or at least, the simulator.


In part 1 we created and exported our textured model, a simple 6 sided die.  Now we are going to convert it into a format the PlayStation Suite can make use of.  To do this, we make use of a command line tool called ModelConverter. ModelConverter was installed when you installed the PSSDK.  If you haven’t already installed it, go install it now.  For details about what is installed by the SDK and where take a look at this post.  I will assume you installed to the default drive and directory, if you haven’t adjust your directories accordingly.  If you aren’t using a 64bit copy of Windows, it is Program Files instead of Program Files (X86).



ModelConverter is located at C:\Program Files (X86)\SCE\Pss\tools\ModelConverter, open a dos prompt and CD to that directory.  Now you want to run modelconverter and point it at your dae file.  I saved mine ( and associated textures ) in c:\temp, so I run “modelconverter c:\temp\box.dae”.  The results should look like:




( ModelConverter can handle Fbx, dae, xsi and x file formats ).


You have now created a new file named Box.mdx, in the same folder as your COLLADA file.  We now want to use this model in PlayStation Suite Studio.  Let’s fire it up, and create a new solution called ModelViewer.  If you don’t know how to create a project using PS Suite Studio, take a quick look at this post.  Now that we have our project, double click AppMain.cs and enter the following code (replacing whatever is there already):


using System; using System.Collections.Generic; using Sce.Pss.Core; using Sce.Pss.Core.Environment; using Sce.Pss.Core.Graphics; using Sce.Pss.Core.Input; using Sce.Pss.HighLevel.Model; namespace ModelViewer { public class AppMain { private static GraphicsContext graphics; private static BasicModel model; private static BasicProgram program; private static float cameraAngleX = 0.0f; private static float cameraAngleY = 0.0f; public static void Main (string[] args) { Initialize (); while (true) { SystemEvents.CheckEvents (); Update (); Render (); } } public static void Initialize () { // Set up the graphics system graphics = new GraphicsContext (); program = new BasicProgram(); model = new BasicModel("/Application/box.mdx",0); } public static void Update () { // Query gamepad for current state var gamePadData = GamePad.GetData (0); if((gamePadData.Buttons & GamePadButtons.Up) != 0) cameraAngleX += 1.1f; if((gamePadData.Buttons & GamePadButtons.Down) != 0) cameraAngleX -= 1.1f; if((gamePadData.Buttons & GamePadButtons.Left) != 0) cameraAngleY += 1.1f; if((gamePadData.Buttons & GamePadButtons.Right) != 0) cameraAngleY -= 1.1f; if(cameraAngleX < 0.0f) cameraAngleX = 360.0f; if(cameraAngleX > 360.0f) cameraAngleX = 0.0f; if(cameraAngleY < 0.0f) cameraAngleY = 360.0f; if(cameraAngleY > 360.0f) cameraAngleY = 0.0f; } public static void Render () { // Clear the screen graphics.SetClearColor (1.0f, 1.0f, 1.0f, 0.0f); graphics.Clear (); Matrix4 projectionMatrix = Matrix4.Perspective(FMath.Radians(45.0f),graphics.Screen.AspectRatio, 1.0f, 100000.0f); Matrix4 viewMatrix = Matrix4.LookAt( new Vector3(0.0f,5.0f,5.0f), new Vector3(0.0f,0.0f,0.0f), new Vector3(0.0f,1.0f,0.0f)); Vector3 litDirection = new Vector3( 0.5f, -1.0f, -1.0f ).Normalize(); Vector3 litColor = new Vector3( 1.0f, 1.0f, 1.0f ); BasicParameters parameters = program.Parameters; parameters.Enable(BasicEnableMode.Lighting, true); parameters.SetViewMatrix(ref viewMatrix); parameters.SetLightCount(1) ; parameters.SetLightDirection(0, ref litDirection); parameters.SetLightDiffuse( 0, ref litColor); parameters.SetLightSpecular(0, ref litColor); parameters.SetProjectionMatrix(ref projectionMatrix); Matrix4 world = Matrix4.RotationXyz(FMath.Radians(cameraAngleX),FMath.Radians(cameraAngleY),0.0f); graphics.SetViewport(0,0,graphics.Screen.Width,graphics.Screen.Height ); graphics.Enable(EnableMode.Blend); graphics.Enable(EnableMode.CullFace) ; graphics.SetCullFace(CullFaceMode.Back, CullFaceDirection.Ccw) ; graphics.Enable(EnableMode.DepthTest); graphics.SetDepthFunc(DepthFuncMode.LEqual, true); model.SetWorldMatrix(ref world); model.Update(); model.Draw(graphics,program); graphics.SwapBuffers (); graphics.Disable(EnableMode.CullFace); graphics.Disable(EnableMode.DepthTest); } } }



EDIT: You also need to add a reference to Sce.Pss.HighLevel.Model.  If you don’t know how to add a reference, refer to this post.



I am not going to go into a ton of detail about the code for two reasons.  One, its mostly just a stripped down version of the BasicModelSample included in the SDK and two, I am going to cover 3D in a bit more detail in a later tutorial.  So here is the ultra quick version of what’s happening.


In Main, we have our primary event loop, which calls Inititalize(), then simply loops forever, getting events, then calling Update() and Render().  Initialize sets up our required objects, the GraphicsContext, BasicProgram and most importantly, our BasicModel.  The parameter to the BasicModel is the file path to where our mdx file is stored ( after being imported into Studio, not on your hard drive ).  If you named your model anything other than box.dae, you need to change it here!


Next up is Update(), which is called once per frame before drawing.  All I am doing here is checking the status of the gamepad ( not the analog pads ) and if it is up or down, I set the cameraAngleX variable to increment or decrement 1.1 degrees in that direction.  I do the same thing then for left and right, this time updating the variable cameraAngleY.  Finally I make sure that we aren’t trying to rotate more than 360 degrees, or less than 0 degree.  For more details on handling input, see here.


Next we come to Render, which is responsible for drawing the frame to the screen.  First we set up the required viewing matrixes for our screen, create a light and a BasicParameters object that is going to tell our renderer how to render ( via program ).  The lighting details are part of this parameters object, as are our view and projection matrix.  Next we set up our world matrix, representing “our” or more accurately “our camera’s” location in the world, by transforming it relative to our rotation values we set with earlier in update. This effectively rotates the camera relative to our two rotation variables.


Finally we set up our graphics object, which is actually used to render our scene.   Set the various rendering options, update our model using our world matrix, render the model via it’s Draw() method, passing in our graphics and program object ( which contains are parameters object ).  Finally we tell it to SwapBuffers, which causes the scene we’ve been rendering to be displayed on screen.


I know that grossly glossed over what was happening here, but to go into much more detail would require a couple dozen more pages.  We will cover this stuff later, I promise.



Ok, now that we have code capable of displaying our model, we need to import it into Studio.  In the Solution window on the left hand side of Studio, right click the ModelViewer project and select Add Files…





In the resulting dialog, select your model and texture, in my case box.dae and dice.png.  Click Open.




Once you have selected your file, the following dialog will appear:




Choose “Add a link” if you want to keep your modeling project separate from your code, this personally is what I do.  The nice thing with this setup is if you run modelconverter on your model again, the changes are automatically updated in Studio.  If you choose copy, you will have to reimport each time you change.  The choice ultimately is yours.



Now is the very key part.  You need to tell PlayStation Suite Studio how to handle these files.  Your png texture will automatically be set right, but your mdx file will not.  Files are actually copied into different directory when your project is built, depending on if you are creating a debug or deployment build.  This is the “/Application” folder we saw earlier.  You need to tell PS Studio that your mdx file is a content file, and should be copied to the right folder when you do a build.  To do this, right click the file box.mdx in the Solution Viewer and select Build Action->Content, like such:





Now you should be able to run your application.  If everything worked properly, you should see the following.  Use the gamepad(arrow keys in simulator) to rotate the camera left, right, up and down.






And now, you have successfully exported a fully textured model from Blender to a PlayStation Vita application!



One thing you may notice is your texture looks rather washed out, I found this as well, and currently am unable to figure out why.  The results are even worse when you export as FBX, while astonishingly your results are vastly improved exporting as X ( DirectX format ), as you can see below:





I am not completely sure what is responsible at this point, my code, Blender or modelconverter, but as it stands , X format gives basically identical results to what you started with in Blender.  Once I figure out what is responsible, I will update here.



That concludes how to export from Blender to PlayStation and trust me, it is nowhere near as complex as it looks.  As you can see in the video, the entire process takes less than 4 minutes.


EDIT:  Oops, forgot the project code.  Here is a zip of the project file.

Art, Programming , , , ,

Month List

Popular Comments