Subscribe to GameFromScratch on YouTube Support GameFromScratch on Patreon

2. May 2012

 

I decided to take a quick look at the RIM Gameplay SDK I mentioned a few days ago.  I haven’t really gotten much into coding with it, but I have to say WOW did it ever get up and runningimage quickly.  Cross-platform gaming libraries normally require a number of hoops be jumped through before you get anywhere ( see PlayN for example ).  With GamePlay I was up and going in about 15 minutes, 10 of those was waiting for my computer to compile the source.

 

 

Here’s the process.

 

Head over to Github and download gameplay.  I used the zip link shown below:

image

https://github.com/blackberry/GamePlay/zipball/master

 

Extract that archive somewhere.

 

In the archive, find and double click gameplay-newproject.bat.

Now you will be asked a series of questions, all pretty straight forward.

 

I personally answered: GamePlayTest, GamePlayTest, GamePlayTest, com.gamefromscratch.GamePlayTest, Bob Dole,MyTestGame.

 

Finally when asked for a path, I entered c:\temp.  The following directory structure is created:

 

image

 

 

Open up TestGamePlay.vcxproj, or whatever your version is called.

 

Now is the only tricky part, add a reference to the gameplay library.  In Solution Explorer, right click the Solution->Add->Existing Project…

 

image

 

Navigate to directory you unzipped gameplay, open the subdirectory gameplay and choose gameplay.vxcproj and click Add.

 

image

 

Now right click your game project in Solution Explorer and select Project Dependencies…

 

image

 

In the dialog, make sure gameplay is checked then click OK.

 

image

 

You are now done.  Now hit CTRL + SHIFT + B to build, and go grab a cup of tea.

 

Gameplay will have created the following game cpp to get started with consisting of the following code:

 

//#include "MyTestGame.h" // Declare our game instance MyTestGame game; MyTestGame::MyTestGame() : _scene(NULL) { } void MyTestGame::initialize() { // Load game scene from file Bundle* bundle = Bundle::create("res/box.gpb"); _scene = bundle->loadScene(); SAFE_RELEASE(bundle); // Set the aspect ratio for the scene's camera to match the current resolution _scene->getActiveCamera()->setAspectRatio((float)getWidth() / (float)getHeight()); // Get light node Node* lightNode = _scene->findNode("directionalLight"); Light* light = lightNode->getLight(); // Initialize box model Node* boxNode = _scene->findNode("box"); Model* boxModel = boxNode->getModel(); Material* boxMaterial = boxModel->setMaterial("res/box.material"); boxMaterial->getParameter("u_lightColor")->setValue(light->getColor()); boxMaterial->getParameter("u_lightDirection")->setValue(lightNode->getForwardVectorView()); } void MyTestGame::finalize() { SAFE_RELEASE(_scene); } void MyTestGame::update(long elapsedTime) { // Rotate model _scene->findNode("box")->rotateY(MATH_DEG_TO_RAD((float)elapsedTime / 1000.0f * 180.0f)); } void MyTestGame::render(long elapsedTime) { // Clear the color and depth buffers clear(CLEAR_COLOR_DEPTH, Vector4::zero(), 1.0f, 0); // Visit all the nodes in the scene for drawing _scene->visit(this, &MyTestGame::drawScene); } bool MyTestGame::drawScene(Node* node) { // If the node visited contains a model, draw it Model* model = node->getModel(); if (model) { model->draw(); } return true; } void MyTestGame::touchEvent(Touch::TouchEvent evt, int x, int y, unsigned int contactIndex) { switch (evt) { case Touch::TOUCH_PRESS: break; case Touch::TOUCH_RELEASE: break; case Touch::TOUCH_MOVE: break; }; }

 

 

And:

 

#ifndef MyTestGame_H_ #define MyTestGame_H_ #include "gameplay.h" using namespace gameplay; /** * Main game class. */ class MyTestGame: public Game { public: /** * Constructror. */ MyTestGame(); /** * @see Game::touchEvent */ void touchEvent(Touch::TouchEvent evt, int x, int y, unsigned int contactIndex); protected: /** * @see Game::initialize */ void initialize(); /** * @see Game::finalize */ void finalize(); /** * @see Game::update */ void update(long elapsedTime); /** * @see Game::render */ void render(long elapsedTime); private: /** * Draws the scene each frame. */ bool drawScene(Node* node); Scene* _scene; }; #endif

 

 

The results of this code (although animated):

 

capture_002_02052012_210105_138

 

 

That code is Windows only at this point, but the BAT file created XCode and Android projects for easily compiling for iOS and Android respectively.

 

That was a remarkably simple process.  Zero to spinning cube in 10-15 minutes (3/4 of it waiting for my compiler), I’m impressed.  They have done a very good job of making it the kind of product you can just jump into.  Now to jump into the code a bit more and see if I stay impressed.

 

 

A Quick look around the SDK

 

 

external-deps is where all the libraries gameplay depends on are located.  By the way, those libraries are bullet, collada-dom, freetype2, glew, libpng, oggvorbis, openal, pcre and zlib.

 

gameplay directory is where the gameplay library itself resides.  We linked to it earlier as a project dependency.

 

In the gameplay-api folder, there is gameplay.html which contains the system generated HTML class library references.

 

In gameplay-docs are the development guide, and three sample tutorials ( longboard, spaceship and character ) in rtf and pdf formats.  Longboard is a skateboarding game controlled using the motion controls, spaceship is a 2D sidescroller that is actually 3D and character is a 3D scene, that is mostly about demonstrating the 3D pipeline (using Maya ).

 

Longboard:

image

Spaceship Tutorial:

image

Character Tutorial:

image

 

gameplay-encoder contains the project for the gameplay-encoder, which is the utility used to encode assets in the gpb format.  See the Character tutorial for more details on how this utility works.

 

gameplay-samples contains all three tutorial projects I mentioned earlier, as well as a mesh and particle sample.

 

 

Again, nice work overall.

Programming

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 bsurfaces.py, extract it somewhere, I will use my desktop.

 

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

 

image

 

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

 

image

 

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

 

image

 

Now click the checkboxes to enable the plugin

 

image

 

And BSurfaces is now installed.

Art

30. April 2012

 

BlenderOnVita

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:

 

image

 

 

Now change “Type” to Image:

image

 

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

image

 

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.

 

image

 

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:

image

 

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.

image

 

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.

image

 

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.

 

image

 

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:

image

 

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

image

 

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:

image

 

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:

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.

image

 

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

image

 

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

image

 

 

 

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

image

 

 

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.

 

image

 

 

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
BlenderOnVita

 

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:

 

image

 

( 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…

 

image

 

 

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

 

image

 

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

 

image

 

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:

 

image

 

 

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.

 

 

BlendToPssResults

 

 

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:

 

DifferentVersions

 

 

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

Unity 5.3 Released
Subscribe to GameFromScratch on YouTube Support GameFromScratch on Patreon


8. December 2015

 

Unity Technologies just released version 5.3 of their popular Unity game engine.  The biggest news of this release is probably that WebGL is no longer an experimental platform and is considered a fully supported target.  Apple TV support is also coming soon, but as of right now it is in beta only.

 

The major bullet point features of this release are:

  • New tools: A MonoDevelop upgrade, multi-scene editing, 2D tools and automated unit testing
  • Graphics optimizations, including a new OpenGL core, experimental support for Metal in OS X, and an upgraded particle system.
  • Coming soon: tvOS support
  • Improved platform support for WebGL and iOS 9
  • Integrated in-app purchase support
  • VR improvements and new VR learning samples

There appear to have been major revisions to the Unity version of MonoDevelop including a streamlined UI and easier debugging as illustrated in this image:

monodevelop-attach-to-process2

Much more detail about the release is available here. Or you can download Unity 5.3 here.

GameDev News

blog comments powered by Disqus

Month List

Popular Comments