Subscribe to GameFromScratch on YouTube Support GameFromScratch on Patreon

2. May 2012



Nathan, a reader of this site, has graciously agreed to provide his port(s) of the Game From Scratch C++ tutorial from 1.6 to 2.0.  He started with chapter 6, as prior chapters mostly involved simple changes in property/method names, as SFML has moved to CamelCase.  Chapter 6 is the first chapter where more intensive changes needed to be made.



So if you are following along my C++ tutorial, but would prefer to work with SFML 2.0, download these projects instead.  Nathan has promised to make each following chapters code available as well, and once I am up to current, I will edit in the original tutorial posts so you have an option of downloading either 1.6 or 2.0 project versions.


Sometime in the future, I will put together a post on what is required to port from 1.6 to 2.0, I promise… sometime. Smile


This project is exactly like the 1.6 ones.  It is preconfigured ( with SFML 2 release candidate ), so  all you have to do is download, unzip and open the solution in Visual Studio.


Download Pang6 here.   Will update as further chapters become available.


Thanks Nathan.


EDIT: Link fixed.

Programming ,

1. May 2012


Previously available for 40$, Bsurfaces is now available freely under the GPL license.  Thisimage wonderful modeling/retopology tool should be added to your tool chest as soon as possible.  For more details on what BSurfaces offers, check here.



The following guide shows how to install BSurfaces, or for that matter, any Blender plugin.



To install it, head over to this site and download it.


Open the zip file, the file you are interested in is, extract it somewhere, I will use my desktop.


Now fire up Blender.  In select the menu File-> User Preferences… like such:




In the resulting dialog, select Addons, then click Install Addons…




Navigate to the location you extracted, then click Install Addon…




Now click the checkboxes to enable the plugin




And BSurfaces is now installed.


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 , , , ,

30. April 2012





Research in Motion, of Blackberry and Playbook fame, recently released Gameplay 1.2, a cross-platform 3D game programming library aimed at Indie developers.  As a game maker, it is easy to ignore RIM these days, especially with their CEO making comments like:


"We plan to refocus on the enterprise business and capitalise on our leading position in this segment,"


That doesn’t exactly give you the warm and fuzzy about the future of RIM consumer devices now does it?


That said, ignoring GamePlay would be a foolish thing to do.  Why?


Well first off, it’s free.  I like free.  As in, I really like free.


Second and perhaps most amazingly, it is cross platform.  You can target Mac OS, Windows, iOS 5.0 or higher devices, Android 2.3 or greater devices in addition to Blackberry Tablet OS 2.0 and Blackberry 10 devices ( when they arrive ).


Third, it’s IDE agnostic, except when required otherwise ( aka, compiling for iOS ).  I can work in my preferred Visual Studio environment.  You however have the choice between Visual Studio, XCode or Momentics IDE ( an Eclipse based IDE Rim inherited from QNX ).


Fourth, it’s open source and hosted on GitHub.


Here is a screen shot from a demo game in development:



I have to say, it looks impressive to me.



Oh, did I happen to mention it’s C++ based?  I think I just heard half of you cheer, while the other half swore! Winking smile



I do have to say, the folks at Marmalade probably aren’t pleased.  They both fill the same niche… but gameplay is free.  Now the question is, how good is it?


Feature-wise, here is what you can expect:


Current features in gameplay
  • Written completely in C++ and well documented using doxygen.
  • Solution and workspaces for Visual Studio 2010, XCode 3.2.1 and Momentics IDE’s.
  • Platform-Game abstraction layer separating all operating system code from game engine code.
  • Input system support for Mouse, Keyboard and Touch.
  • Full vector math library with classes for Vector2/3/4, Matrix, Quaternion, Ray, Plane. Also Frustum and BoundingBox/BoundingSphere classes for object culling.
  • Solid OpenGL 3.2+ (for Desktop) and OpenGL ES 2.0 (for Mobile) based rendering system with classes for RenderState, FrameBuffer, Mesh, Material, Effect, Pass and Techniques.
  • Easy-to-use and efficient Font and Sprite classes.
  • Scene-graph components such as Scene, Node, Light, Camera and Model.
  • Binary encoding tool for creating optimized bundles for loading TTF fonts and 3D game assets supporting both COLLADA and FBX formats.
  • Extensible animation system with classes for Animation, AnimationClip and Curve with built-in AnimationTarget’s on Transform and MaterialParameter’s classes.
  • Complete 3D audio system with additional support for compressed audio using OGG and supporting HDMI gaming.


New features in gameplay v1.2
  • Newplatforms now supporting:
    • BlackBerry Tablet OS 2.0 and BlackBerry 10 ready!
    • Apple iOS 5.1 for iPhone and iPad
    • Google Android 2.3+
    • Microsoft Windows 7
    • Apple MacOSX
  • New shader-based material system with built-in common shader library.
  • New declarative scene binding.
  • New declarative particle system.
  • Improved physics system with rigid body dynamics and constraints.
  • New character physics and ghost objects.
  • Improved animation system supporting animated skeletal character animation.
  • New declarative user interface system with support for declartive theming and ortho, and 3D form definition with built-in core control classes such as Button, Label, TextBox, Slider, CheckBox, RadioButton. Also includes Layout classes such as Absolute/Vertical and FlowLayout.
  • New cross-platform new game project wizard scripts.
  • New game developer guide.
  • New game samples and tutorials.



With the following coming soon:


The ‘next’ feature branch for v1.3, v1.4, v1.5
  • Optimizations and Performance improvements
  • Shadows
  • Terrain and Sky
  • Gamepad input for Wii, Xbox 360 and Bluetooth® HID controllers
  • Scoreloop Social integration
  • Editor



Editor hmm?  Wonder what that means?



I am going to download and play with the SDK, and if I get some time ( something I am chronically short of lately ) I may post a walk around and possibly a tutorial or two.  Has anyone out there been playing with this technology?  Any opinions?



If you are interested, check out the announcement blog post as well as the source on GitHub.  Oh and perhaps most impressive of all for an open source gaming product… there is actually documentation. The documentation is available here including this development guide[direct pdf link].


I have to say, congratulations to Sean Paul Taylor and Steve Grenier on this impressive release!

General , , , ,

Month List

Popular Comments