Cornflower Blue

LostGarden

etayrien — Sat, 08 Nov 2008 02:34:10 GMT

One of the blogs I read regularly is LostGarden. It’s got a lot of great info about game design, and every now and then there’s a “Game Prototyping Challenge,” where Danc posts a bunch of graphics and design doc, challenging his readers to see who can come up with the most fun game. Definitely worth checking out! I dig his graphics quite a bit :)

Audio input and output formats

etayrien — Mon, 22 Sep 2008 05:19:00 GMT

We've had some questions about what audio formats the XNA content pipeline can take as input, and what formats they are converted to. Now that the 3.0 beta has shipped, I figure it's a good time to get some of that information out there. So, to be clear, this information is all true for the 3.0 beta, and will likely be true for the final release of 3.0 as well.

In v3.0, there are three main ways to have your game make some noise. Two of these are new to v3.0. First up is XACT, and the AudioEngine, WaveBank, SoundBank, and Cue types.

XACT:

The version of the XACT used by XNA Game Studio only accepts .WAV files containing PCM data as input. By default, the XACT build process will keep your data in PCM format as it built. This means your data does not go through any kind of re-encoding.

If you want, you can enable compression in XACT, which will change your assets to XMA data when built for Xbox 360, and ADPCM when built for Windows. Mitch has more information here.

MediaPlayer:

The MediaPlayer & Song API, which is new for v3.0, is designed for music playback in your game. To use it, drag a WMA or MP3 file into solution explorer, then use Content.Load to load it as a Song. Once you have a Song, you can use MediaPlayer.Play to play your music.

WMA, MP3, and WAV files can all be built as Songs. This is the default setting for WMA and MP3 files, but not WAVs: if you want to load a WAV as a Song, you have to change its processor to SongProcessor. Regardless of the input format, the SongProcessor will convert your audio assets to WMA files for use at runtime, so your music will go through some re-encoding here. The bitrate of the WMA file depends on the Conversion Quality you select, as you can see below:

Conversion Quality:	Bitrate:
Best (default)	192k
Medium	128k
Low	96k

SoundEffect:

The third way to play audio in v3.0 of the framework is via the SoundEffect and SoundEffectInstance types, which are (duh) designed for sound effect playback. These are the counterpart of the Media/Song API. To use it, drag a WAV file into solution explorer, and then use Content.Load to load the file as a SoundEffect. Once the SoundEffect has been loaded, use SoundEffect.Play to play it.

WMA, MP3, and WAV files can all be built as SoundEffects. This is the default setting for WAV files, but not MP3 and WMA files. (Remember, their default setting is to be built as Songs.) If you want an MP3 or WMA file to be built as a SoundEffect, just change its processor from SongProcessor to SoundEffectProcessor.

The SoundEffectProcessor’s output format depends on two things: the target platform and the quality you select. It breaks down like this:

ConversionQuality:	Windows	Xbox 360	Zune
Best (default)	PCM	XMA 60	PCM
Medium	ADPCM	XMA 40	PCM 3/4*
Low	ADPCM 1/2*	XMA 20	PCM 1/2*

* The audio asset is down-sampled to either 3/4 or 1/2 of the original sample rate, with a lower limit of 8khz.

XMA is an internally developed sound format which has better compression ratios and sound quality than ADPCM. The Xbox 360 can decode XMA data in hardware, making XMA a great choice for a sound effect data format. I’m not privy to the details of the XMA encoding algorithm, so I can’t tell you what the quality ratings of 60, 40, and 20 mean, exactly. They’re not bitrates; they’re more of a hint to the XMA encoder as how aggressively it should compress. In practice, almost no one needs a quality setting higher than 60, so we’ve set that as our upper bound. You should definitely experiment with the quality settings on all platforms, to see how much compression you can get away with before the artifacts start to get too objectionable.

You are hearing me talk.

etayrien — Wed, 03 Sep 2008 02:10:36 GMT

The powers that be have just posted slides and WMA audio recordings from GameFest! Here’s some links.

Mitch’s presentation, What’s New In XNA Game Studio 3.0
Frank’s perf talk: XNA Game Studio Performance 2008: Multithreading and GPU
My Content Pipeline presentation! W00T! Real World Content Pipeline Examples
Shawn’s Content Pipeline presentation: Building Worlds with the Content Pipeline
Mitch gave a best practices talk: Creating Great Community Games
Shawn’s networking talk. Lots of great info in here, even if you’re not using the XNA framework for networking. Networking, Traffic Jams, and Schrödinger's Cat.

SoundEffect APIs in the CTP

etayrien — Wed, 07 May 2008 22:55:07 GMT

We've just released the Community Technology Preview (CTP) of Game Studio Version 3.0. If you haven't read the post on our team blog yet, check it out here.

One of the coolest new features (I'm a bit biased ) in version 3.0 is the SoundEffect API, which allows you to drag and drop wav files into your game project, and then use Content.Load<SoundEffect> to load SoundEffects.

A few people have asked about what this means for XACT. Well, the XACT APIs aren't going anywhere, they are still supported and we expect people to still use them! XACT is useful if you're looking for a more content-driven solution, where the majority of the sound design is done in the XACT tool. What the SoundEffect APIs offer is a more self-contained, code driven approach. Hope that clears things up a bit.

Content Importers

etayrien — Thu, 21 Feb 2008 10:02:18 GMT

If you've thumbed through the links in my last post on this subject, hopefully you'll have a bit more of an understanding of what problems the content pipeline is trying to solve, and what constraints it has. I'm going to start off by writing a bit about content importers, since (as we'll see) the importer is the first stage of the pipeline. The beginning is a good a place to start as any, I suppose.

Note that throughout these articles I'm going to refer to "assets". It sounds kind of fancy, but it's just a generic catch all for any game resource that isn't code. 3D models, textures, level data - all assets.

OK, so first, the big picture: as you build an asset, it passes through the content pipeline in a series of stages:

Import the asset from disk, and load it into memory
Do some additional processing on that in-memory asset
save the processed asset to disk

At each stage, the content pipeline farms the work out to a helper object. The helper objects in charge of each of those steps are the ContentImporter, ContentProcessor, and ContentTypeWriter, respectively.

The content importer's job is to load a file from disk and into memory. For every file that the content pipeline wants to build, it will call the Import function on a content importer, and then wait for the importer to return the object.

For example, Game Studio ships with the FbxImporter, which loads Autodesk .fbx files. These files contain models and meshes in a 3D scene. Most 3D modeling tools support the .fbx format. The FbxImporter will read and parse the content in an .FBX file and change it into a NodeContent, which represents a 3d scene. (More about NodeContent objects and 3d scenes here.)

Different importers read different file formats, and convert the data into different types. This help page has more information about all of the importers that Game Studio ships with, the file formats they import, and what kind of objects they are imported to.

While the asset is being imported, the importer should also do it's best to get rid of any file-format specific nuances that are a result of the file format, and "normalize" the asset as much as possible. After the importer is finished, the rest of the stages of the pipeline shouldn't have to worry about whether the asset was originally .FBX or .X, or whether it was .TGA or .JPG. This will make it much easier for the next stage, the content processor, to do its work. I'll talk more about this when I write about content processors.

The content pipeline was designed with extensibility in mind, and so it's pretty easy to move beyond the standard importers and plug your importer (or someone elses!) into the content build and use it to bring in other formats. This help page shows how to create a new importer, and this one tells how to tell the content pipeline to use your the assembly containing new content importer. For a sample of how to actually implement an importer, I strongly recommend you check out the Custom Model Importer sample, which'll import models from the .OBJ file format.

So, that's it for importers. Feel free to comment with any questions and I'll do my best to answer them.

Useful Content Pipeline Links

etayrien — Sat, 16 Feb 2008 02:30:45 GMT

As I wrote the other day, I'd like to help out people that are having trouble understanding the content pipeline, and I'm planning on writing some blog posts about it. I don't have a lot of time right now to dedicate to this, but I was digging around the other day trying to see what information was already out there, and I found several links that might be useful.

Michael Klucher wrote a high level overview of the content pipeline for our team blog back when we shipped v1. (memories....) Shawn also wrote several useful blog posts explaining various concepts about the content pipeline, including:

an example of the way most people will use the content pipeline
some of the design assumptions we made
why we pre-build content, instead of building it when the game runs
an overview of how the pipeline can be extended
and common ways to extend the content pipeline.

From the help pages, we've got a good overview and architecture page. One of the best pages is this How to, which is a walkthrough that adds a custom type to the pipeline and creates a custom importer and processor. It imports pixel shaders as an example, but don't be afraid to read this even if you're not interested in importing pixel shaders! There's a gold mine of info in there.

Ok, that's it. Hope this helps - hopefully in the next few weeks I'll find some time to sit down and give this topic a bit more detail.

Quick N Dirty Tutorial: Making Nice Explosion Sprites

etayrien — Fri, 15 Feb 2008 05:10:00 GMT

When I was working on the alpha blending posts, I found myself in need of a texture to demonstrate how additive blending could be used to make an explosion effect. When I worked on a shooter a few years back I learned a little bit about how to do that, but couldn't really remember the specifics. So, I bugged an artist friend of mine, Michael Clark, and asked him how to do it. I saved the chat log, and I've been meaning to clean it up into a proper tutorial, but I just never had the time. Anyway, here's a really really rough edit of the chat log. Maybe I'll get around to cleaning it up eventually - or maybe someone else can work from this and post better instructions?

These instructions are for Photoshop but you should be able to accomplish something similar with Paint.Net. If I remember correctly, to use this technique you'll have to download a plugin to do more complex gradients.

For reference; the end goal should look something like the image below. I know it looks really dark, but that's OK. Remember we're layering a whole bunch of them together with additive blending. You can check out the particle samples (2D and 3D) to see how this looks in practice.

So, enough ado - here's the chat log. Again, sorry this isn't the greatest quality... but hopefully it's better than nothing.

Talented Artist: first make a 512x512 image or whatever. then hit D to pick black and white as your default colors.
Talented Artist: then filter-render-clouds
Talented Artist: then ctrl-shift-L for auto levels
Talented Artist: then filter-render-difference clouds
Talented Artist: then ctrl-shift-L for auto levels.
Talented Artist: if you don't have some white bits in the middle then hit ctrl-i to invert.

Talented Artist: now make a new layer
Talented Artist: select the gradient tool and select circular gradient and make a circular gradient with a white middle and a black edge. you want the radius to be 2-3 pixels less than the size of the texture, and centered.
Talented Artist: set the blending mode of the gradient layer to multiple
Talented Artist: hit ctrl-L and adjust the levels so you get a nice slope - put a point in the middle or so and move it up some so that you brighten the gradient a bit. You'll have to play around with the control points a bit. Make sure the outside of the circle doesn't become visible.

Talented Artist: now make a new adjustment layer(in the layer palette click the middle button on the bottom, the one that looks like a circle thats half black half white) and make a gradient map layer
Talented Artist: double click the black and white gradient in the window that pops up and make a gradient that...
Talented Artist: okay have you made custom gradients before

Me: once or twice
Talented Artist: okay basically you want to make a gradient that is like black at the 0.0 mark, dark red at the 0.75 mark, orangey-yellow at the .5 mark, and yellow-white at the 1.0 mark. You'll probably wind up needing to tweak this.
Me: explain what you mean by orangeyred
Talented Artist: one sec
Talented Artist: the orangey color was 231,188,85
Talented Artist: and the yellow white is 253 255 213
Talented Artist: also this whole thing might need to be tweaked and have like a solid black at 20% opacity laid over it to darken it.

That's it! So, does your explosion sprite look anything like mine? And more importantly, are there any brave souls out there willing to try this out and turn it into a proper tutorial?

What's the Most Confusing Part of the Content Pipeline?

etayrien — Wed, 06 Feb 2008 02:32:25 GMT

I've started to look through some of the feedback from our recent survey, and noticed that there's a lot of you out there who are having trouble understanding the content pipeline. Documentation was a frequent complaint, and a few people mentioned a lack of a high level overview.

To remedy this, I'm considering starting a series of blog posts on the content pipeline. Are there any topics in particular you would like me to cover, or any parts that you find particularly confusing? I'll see what I can do to pay particular attention to those areas. Please, remember to be specific! "It's no good" doesn't help!

I've filed a forum post asking the exact same question. Feel free to leave a comment or reply to the thread, I'll be checking both.

Extending the ContentManager for Models

etayrien — Thu, 03 May 2007 03:38:21 GMT

I don't know about everyone else, but usually the first thing I do after loading models is loop over their effects and set up their lighting. (Check Shawn's blog to read more about the standard lighting rig and per pixel lighting. ) The other day I thought of a neat way to tuck this code away a little, so I thought I'd share.

A subclass of ContentManager could easily handle the model setup code for us automatically. It could check what kind of content it's being asked to load, and if the content type is a Model, it can set up the model automatically.

first, make a subclass of ContentManager. I've called mine SmarterContentManager, because I couldn't think of a better name.

    public class SmarterContentManager : ContentManager
    {
        public SmarterContentManager(IServiceProvider serviceProvider)
            : base(serviceProvider)
        {
        }
    }

The next step is to override the Load function, and do the extra bit of set up for models.

    public override T Load<T>(string assetName)
    {
        T t = base.Load<T>(assetName);
        Model model = t as Model;
        if (model != null)
        {
            foreach (ModelMesh mesh in model.Meshes)
            {
                foreach (Effect e in mesh.Effects)
                {
                    BasicEffect basic = e as BasicEffect;
                    if (basic != null)
                    {
                        basic.EnableDefaultLighting();
                        basic.PreferPerPixelLighting = true;
                    }
                }
            }
        }
        return t;
    }

This might not be the best design for larger projects, because it ties the content loading part of your engine to graphics rendering. You might argue that a better place to set up this stuff is in some other class that manages lights and rendering state or something. But for me, this works just fine. Most of my XNA games just use BasicEffect with the default lighting rig.

One more cool thing you can put in this content manager is a bit of code to calculate the absolute bone transforms. (Shawn writes in this post about models and bones and what absolute bone transforms are.) For static models that don't animate, the bones won't change. This means that rather than recalculating the bone transforms every frame, I can calculate them once and save the results. You can do this by adding this function to the SmarterContentManager:

    public Model LoadModel(string assetName, out Matrix[] absoluteBoneTransforms)
    {
        Model model = Load<Model>(assetName);
        absoluteBoneTransforms = new Matrix[model.Bones.Count];
        model.CopyAbsoluteBoneTransformsTo(absoluteBoneTransforms);

        return model;
    }

Now, if I change my game to use the SmarterContentManager, I can just load my models like this:

Model model;
Matrix[] bones;

model = content.LoadModel("models\\asteroid1", out bones);

and draw them like this:

    foreach (ModelMesh mesh in model.Meshes)
    {
        foreach (BasicEffect basic in mesh.Effects)
        {
            basic.Projection = projection;
            basic.View = view;
            basic.World = bones[mesh.ParentBone.Index] * world;
        }
        mesh.Draw();
    }

Shawn's probably going to hassle me for linking to his blog three times in one post (What's the matter - don't you have any content of your own?) but oh well. Maybe someone will find this interesting.

SwampThingTom on Performance Analysis:

etayrien — Thu, 19 Apr 2007 19:43:02 GMT

Interesting read on SwampThingTom's blog today. I'd never heard of the NProf tool before, but the information it gives seems to be very similar to what you can get from much more expensive tools. Definitely worth reading.