Today was huge! I am exhausted. I busted my ass today to get an affect known as screen-space ambient occlusion (SSAO) working in a prototype scene in verto studio. Right when I was about to give up, I got it working! I’m too groggy to explain anything about it, so I’ll just post pictures!
This is going to add a huge boost to the visual look-and-feel of the game without a severe performance penalty. Needless to say, I’m pretty stoked!
If you’ve been following this game and you want to see it on steam please head over to the greenlight page and vote yes!
Too far to turn back now. Progress has been steady. I’ll post some shots this weekend. Level 8 is done. I’ve added a really awesome new game mechanic (randomly distributed hostile gangsters) for level 7 and up that makes the gameplay a lot more intense. My initial playthroughs of this new mechanic have been awesome and I find myself almost unable to think I have to react so fast which is exactly the kind of gameplay action that I’m going for.
I’ve decided to try to do one new level of the game per day until it’s done. If I can do this, I’ll be on track to have the game done by some time in April like I’ve been planning for. Let’s see how it goes. I still cannot believe that I originally thought this game could be done in a matter of weeks. Granted that I’ve increased the game beyond its original scope, 2 weeks even for a most basic version of this game is way way off.
Here they are, the public play testing demos! These are downloadable and playable on just about any recent computer (recent meaning 2012 ish). Older laptops may struggle and older older laptops will struggle hard. I wouldn’t expect this game to run on any pre-600 series nvidia card or equivalent amd card. Intel HD 4000 was tested but that’s it from the intel family, so I expect that’s the required card for intel.
Feel free to grab these, play the crap out of the demo, and don’t hold back in giving me feedback. This’ll be the first time I get any real feedback for this game so let me have it!
Edit: these have likely expired by now as the actual game has been finished
Mac – http://vertostudio.com/playtest/gd-playtest-mac.zip
Win – http://vertostudio.com/playtest/gd-playtest-win.zip
Downloads are a little dodgy from my server so you may have to retry once or twice to get it.
Also, IF IT CRASHES, please email or contact me immediately so I can find out what went wrong. There’s one sound-related windows crash that I haven’t fully nailed down yet but I expect it to be quite rare. Either way, if that happens, please let me know via email or on here.
Not a lot of updates here lately because I’ve been working hard to get to the point where I can post a playtest demo and get some early feedback for the game. The demo will feature the first six levels of the game which I’m tying off today.
An early screen shot of the sixth level is below..
It was a pain to convert and simplify all of the “night time” shaders that I had for the night fog scene back into “day mode”. But I got it done. I also noticed that with the fog lifted, the original scene was way to simple so I had to add some desert in the distance and some extra buildings to make it look more presentable.
So asset creation in the form of modeling the final environment that’ll be used in the game took the past few days. It’s amazed how much faster it went this time compared the first scene (the city street). I chalk this up to experience that I’ve picked up now that I’ve been doing this awhile, and my understanding of things that are very time consuming to model vs things I can quickly grab, import, texture, and place from turbosquid. The perfect balance of both techniques has led to me being done with the dark night alley street scene after just a few days.
Where I spent the most time this time was in the shaders. I really wanted to have quality rendering and go out with a bang since this’ll likely be the last environment that I do for the game. I want the dark alleyway to appear foggy and dark, like its just about to rain. That includes moist shiny cobblestone rocks, and a damp fog effect that feels very palpable to the player.
This idea of mine posed two major problems that I haven’t had to tackle until now.
The first major problem, is that I could no longer “cheat” using a single directional light source representing the “sun” in the scene. Instead, I had to place a street lamp every building or so and have these be the only sources of light in the scene. This means, in order to keep my shadows working, I now had to implement shadows from a point light source. In some ways this was easier than point lighting (no longer necessary to compute an optimal shadow bounding box to be used for the light’s ortho matrix projection). However, now I needed render to and utilize cube maps to store the shadow depth information. Surprisingly, there was very little comprehensive information on the web about how to properly do PCF shadows using cubemaps.
What I found that works is the following.
The “light render” shader mentioned above which is used when rendering the depth information to the cubemaps looks like so:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
precision mediump float;
in mediump vec4 w_pos;
out vec4 fragColor;
struct Light
{
vec4 worldPosition;
};
uniform Light lights[8];
#define LIGHT 0
uniform vec2 nearFarPlane;
void main()
{
// distance to light
float distanceToLight = distance(lights[LIGHT].worldPosition.xyz, w_pos.xyz);
float resultingColor = (distanceToLight - nearFarPlane.x) /
(nearFarPlane.y - nearFarPlane.x);
gl_FragDepth = resultingColor;
fragColor = vec4(1.0);
} |
Basically this encodes the distance from the surface point to the light in the form normalized depth information. This is done by manually overriding the depth value stored in gl_FragDepth. Each light has its own cubemap renderer with a custom-tailored shader like this (using the correct light index to compute distance from).
The per-fragment lighting shader code that utilizes the cube shadow maps looks like:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 |
/*....*/
#define LIGHT 0
#define ATTENUATION
uniform samplerCubeShadow shadowMap;
/*.......*/
void pointLight0(in mediump vec3 normal, in mediump vec3 eye, in mediump vec3 ecPosition3)
{
mediump float nDotVP; // normal . light direction
mediump float nDotHV; // normal . light half vector
//mediump float pf = 0.0; // power factor
mediump float attenuation = 1.0; // computed attenuation factor
mediump float d; // distance from surface to light source
mediump vec3 VP; // direction from surface to light position
mediump vec3 halfVector; // direction of maximum highlights
// Compute vector from surface to light position
VP = vec3(lights[LIGHT].position) - ecPosition3;
#ifdef ATTENUATION
// Compute distance between surface and light position
d = length(VP);
#endif
// Normalize the vector from surface to light position
VP = normalize(VP);
// Compute attenuation
#ifdef ATTENUATION
{
attenuation = 1.0 / (lights[LIGHT].constantAttenuation +
lights[LIGHT].linearAttenuation * d +
lights[LIGHT].quadraticAttenuation * d * d);
}
#endif
nDotVP = dot(normal, VP);
mediump vec2 frontAndBack = vec2(nDotVP, -nDotVP);
frontAndBack = max(vec2(0.0), frontAndBack);
float visibility = 1.0;
// difference between position of the light source and position of the fragment
vec3 fromLightToFragment = lights[LIGHT].worldPosition.xyz - va_position.xyz;
// normalized distance to the point light source
float distanceToLight = length(fromLightToFragment);
float currentDistanceToLight = (distanceToLight - nearFarPlane.x) / (nearFarPlane.y - nearFarPlane.x);
// normalized direction from light source for sampling
fromLightToFragment = normalize(fromLightToFragment);
visibility *= max(texture(shadowMap, vec4(-fromLightToFragment, currentDistanceToLight-shadowBias), 0.0), 0.0);
// if(nDotVP > 0.0)
{
diffuse += visibility*material.diffuse*lights[LIGHT].diffuse * frontAndBack.x * attenuation;
diffuseBack += visibility*material.diffuse*lights[LIGHT].diffuse * frontAndBack.y * attenuation;
}
//if(lights[LIGHT].doSpec)
{
mediump vec2 cutOff = step(frontAndBack, vec2(0.0));
halfVector = normalize(VP + eye);
nDotHV = dot(normal, halfVector);
frontAndBack = vec2(nDotHV, -nDotHV);
frontAndBack = max(vec2(0.0), frontAndBack);
lowp vec2 pf = pow(frontAndBack, vec2(material.shininess, material.shininess));
specular += visibility*material.specular*lights[LIGHT].specular * pf.x * attenuation * cutOff.y;
specularBack += lights[LIGHT].specular * pf.y * attenuation * cutOff.x;
}
ambient += lights[LIGHT].ambient * attenuation;
} |
Essentially the highlighted code above compares the distance between the surface point to the light to the stored depth value in the cube texture using the fragment-light vector as a lookup value into the cubemap. Because we’re sampling using a special “shadow” version of the cubemap sampler, the result will be properly interpolated between shadow texels to avoid ugly edges between shadowed and non-shadowed areas.
Luckily, I was able to build this into the Verto Studio editor and associated graphics system and test this out with relatively little trouble. Even though I have 4 or 5 statically rendered cubemap shadow textures in the entire scene. I was able to keep performance high by building versions of the shaders for each side of the street so that each individual shader only has to shade with at most 3 lights at a time. This worked out better than I had expected.
This part was tricky.. I had an idea in my head of how I wanted this to look. So I did something that usually leads to trouble; I tried to come up with a volume rendering technique on my own from scratch and implement it and just kinda see how it goes.
The basic idea stems from what I’ve observed in real life from foggy, dark, damp nights and lighting. Essentially, fog at night is black… IF there is no light around to interact with the fog. Naturally, if the water droplets don’t have any light to interact with them, you won’t see them and the fog will appear black. However, if any light interacts with the water vapor in the air, it’ll create the illusion of a whiter colored and denser fog. So this is what I set out to emulate with my shader.
Now atmospheric shader effects can often lead to the necessity of raymarching and heavy iteration in the fragment shader to simulate the accumulation of light-atomosphere interaction. To this I said “hell no” since ray marching of any kind in a shader terribly robs performance. I quickly realized that I could avoid raymarching entirely if I used a simple model to represent the light-fog interaction that I was going for.
In my case, it turned out I could do the whole effect using something as simple as a sphere intersection test. Basically, when I’m shading a pixel (a point on the surface), I’m interested in what happens to the light on its way back from the surface to the viewer, the surface-to-viewer vector. If the atmosphere affects the light at any point along this vector, I’ll need to compute that. In other words, if the ray from the surface to the viewer intersects a sphere centered at the light, then the fog affects the light on the way back to the viewer. How much? Well if I calculate the length of the segment between the entry and exit points of the ray intersection (how much of the sphere the ray pierces), I find that length is proportional to both the perceived increase in density of the fog and the brightening of the fog color.
This algorithm is given below in fragment shader code:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 |
/*.....*/
uniform float fogDensity;
uniform vec3 fogColor;
//sphere intersection
bool intersect(vec3 raydir, vec3 rayorig, vec3 pos, float radiusSquared,
out float innerSegmentLength)
{
float t0, t1; // solutions for t if the ray intersects
// geometric solution
vec3 L = pos - rayorig;
float tca = dot(L, raydir);
//seems to be true if ray o is inside the sphere
//we want this to be a positive..
//if(tca < 0)
// return false;
float d2 = dot(L, L) - tca * tca;
if(d2 > radiusSquared)
return false;
float thc = sqrt(radiusSquared - d2);
t0 = tca - thc;
t1 = tca + thc;
innerSegmentLength = abs(t0-t1);
return true;
}
vec4 computeFog(vec4 color)
{
vec3 viewDirection = normalize(cameraPosition - vec3(va_position));
vec3 surfacePos = ec_pos.xyz/va_position.w;
const float LOG2 = 1.442695;
float fogFactor = exp2(-fogDensity * length(surfacePos) * LOG2);
vec3 fogCol = fogColor;
vec3 rayO = vec3(va_position);
vec3 rayD = viewDirection;
float len = 0.0;
const float r = 80.0;
//for each light we interact with...
if(intersect(rayD, rayO, lights[LIGHT].worldPosition.xyz, r*r, len))
{
float d = len/r;
float p = clamp(log(d)*d, 0.0, 1.0);
fogCol = mix(fogColor, vec3(0.4), p);
len = 0.0;
const float innerR = 25.0f;
if(intersect(rayD, rayO, lights[LIGHT].worldPosition.xyz, innerR*innerR, len))
{
float len10 = len/innerR;
float nd = min(len10*0.25, 1.0);
fogFactor *= mix(1.0, 0.0, nd);
fogCol += mix(vec3(0.0), vec3(0.2), len10);
}
}
if(intersect(rayD, rayO, lights[LIGHT1].worldPosition.xyz, r*r, len))
{
float d = len/r;
float p = clamp(log(d)*d, 0.0, 1.0);
fogCol = mix(fogColor, vec3(0.4), p);
len = 0.0;
const float innerR = 25.0f;
if(intersect(rayD, rayO, lights[LIGHT1].worldPosition.xyz, innerR*innerR, len))
{
float len10 = len/innerR;
float nd = min(len10*0.25, 1.0);
fogFactor *= mix(1.0, 0.0, nd);
fogCol += mix(vec3(0.0), vec3(0.2), len10);
}
}
return mix(vec4(fogCol, 1.0), color, fogFactor);
} |
I’m sure I’m not the first one to come up with this idea before, but it still did feel pretty cool to reason my way through a shading problem like this. The visual result looks amazing.
The progress of this all is below in a gallery.
So yesterday and today, I bit the bullet and started working on compiling the game for windows. I wanted to do this before the project got too much further along so I didn’t write any code that would have serious implications on windows. I must say, I’m amazed at how much trouble I didn’t have with the rendering system. The levels/screens load up and look great! I did have some issues with visual studio that I chalk up to lack of experience in windows dev on my part. Namely getting the builds to be 64-bit instead of the default 32, SSE3 operator overload stuff, and getting debug builds to forego some of the extremely slow settings that make the engine run at a crawl. Once I took care of all that, my little game was running on windows like a champ, complete with same stellar OpenGL 3.3 performance I get on mac. All was well… that is except for one little tiny issue. The sound.
One thing that became apparent almost right away was that OpenAL support on windows is in a terrible state. Counting on it to just be there like OpenGL is a no no.. and installing your own via something like OpenAL soft gives pretty poor support. I realized that I had to do something I’ve never done before, and that’s directly use a DirectX subsystem. After some quick googling I discovered what I need can be done using a combination of xAudio2 and X3DAudio. Both of these systems come with DirectX and the DX SDK so I was already set up to use em.
So basically, the plan on windows was pretty simple: since I already have all my 3D sound calls abstracted out in my SoundManager class, I all I had to do is re-implement the stuff that OpenAL handled using this new xAudio2 stuff.. and pray that it played nice along side SDL_Mixer which I use for mp3 music. More or less, things went relatively painless and I was able to find an xAudio2/X3DAudio analog for just about everything I was doing in OpenAL EXCEPT for a little issue I had with source playback.
On mac, I’m able to play a source overtop of itself as many times as I want to. On windows, this seems to be a no-go. So for win, I had to manually pre-allocate pools of sources for the sounds that I would be playing rapidly such as bullet ricochet sounds and typewriter keystrokes and ensure that I return an available source whenever I ask to play that sound. That process more or less worked out just fine.
After all that, we have my reworked soundmanager class for windows. The code is below for anyone who wants to learn from it.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 |
//
// SoundManager.h
// Gangster Driveby
//
//
#ifndef __Gangster_Driveby__SoundManager__
#define __Gangster_Driveby__SoundManager__
#include <windows.h>
#include <xaudio2.h>
#include <x3daudio.h>
#include <vector>
#include <iostream>
#include "VecTypes.h"
#include "Wave.h"
#include "SDL_mixer.h"
class SoundManager
{
public:
enum Effect
{
Engine = 0,
Typewriter1,
Typewriter2,
Typewriter3,
Typewriter4,
Typewriter5,
TypewriterSpace,
TypewriterDing,
TypewriterFeed,
TommyGun,
TommyGunLoop,
GlassBreak,
BulbBreak,
BulletHoleGlass,
DramaticBoom,
PaperIn,
PaperOut,
OceanClose,
WavesAmbience,
//MUST be last
LongMusic
};
enum Music
{
DarkFlashes = 0,
NightDocksSax,
DontGoWayNobody
};
class MultiSource
{
friend class SoundManager;
public:
MultiSource(IXAudio2 *engine, Wave *wave, int maxSources = 1)
{
for(int i = 0; i < maxSources; i++)
{
IXAudio2SourceVoice *source = nullptr;
if(FAILED(engine->CreateSourceVoice(&source, wave->wf())))
{
std::cerr << "source creation error!" << std::endl;
}
sources.push_back(source);
}
ZeroMemory(&emitter, sizeof(emitter));
emitter.ChannelCount = 1; //not 100% on this
emitter.CurveDistanceScaler = FLT_MIN;
ZeroMemory(&dspSettings, sizeof(dspSettings));
FLOAT32 *dspMatrix = nullptr;
XAUDIO2_DEVICE_DETAILS details;
engine->GetDeviceDetails(0, &details);
dspMatrix = new FLOAT32[details.OutputFormat.Format.nChannels];
dspSettings.SrcChannelCount = 1;
dspSettings.DstChannelCount = details.OutputFormat.Format.nChannels;
dspSettings.pMatrixCoefficients = dspMatrix;
}
///Returns an available source
IXAudio2SourceVoice *getSource();
///Updates and calculates 3D sound stuff
void update3D(SoundManager *sm);
//One or many sources per sound
std::vector<IXAudio2SourceVoice *> sources;
//3D sound emitter (if needed for this source)
X3DAUDIO_EMITTER emitter;
X3DAUDIO_DSP_SETTINGS dspSettings;
bool is3D = false, is3DUpdated = false;
//Useful to keep track of this since 3D audio calculates its own
float basePitch = 1.0f;
};
SoundManager();
~SoundManager();
static SoundManager *manager();
inline bool isActive() { return (engine != nullptr); }
void setEffectBasicProperties(Effect effect, float gain, float pitch=1.0f, bool looping=false);
void setEffectGain(Effect effect, float gain);
void setEffectPitch(Effect effect, float pitch);
void setEffectSpatialProperties(Effect effect, float referenceDistance, float maxDistance, float rollOffFactor=0.0f,
float3 velocity = float3::zero, float3 direction = float3::zero);
void setEffectPosition(Effect effect, float3 pos);
void setListenerPosition(float3 pos, float3 orientation[]);
void playEffect(Effect effect);
void stopEffect(Effect effect);
void playSong(Music song);
void stopSong();
void setSongVolume(float volume);
void setSongPosition(double pos);
float getSongVolume();
void loadLongMusicEffect(const char *fn);
void unloadLongMusicEffect();
inline void setSoundAvailable(bool b) { soundAvailable = b; }
void update3D();
private:
void loadSoundEffects();
IXAudio2 *engine = nullptr;
IXAudio2MasteringVoice *master = nullptr;
XAUDIO2_DEVICE_DETAILS deviceDetails;
X3DAUDIO_HANDLE engine3d;
X3DAUDIO_LISTENER listener;
std::vector<MultiSource *> sources;
std::vector<Wave *> buffers;
Wave *longMusicBuffer = nullptr;
MultiSource *longMusicSource = nullptr;
Mix_Music *currentSong = nullptr;
bool soundAvailable = true;
float currentSongVolume = 1.0f;
};
#endif /* defined(__Gangster_Driveby__SoundManager__) */ |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 |
//
// SoundManager.cpp
// Gangster Driveby
//
// Created by Mike Farrell on 11/14/14.
// Copyright (c) 2014 Mike Farrell. All rights reserved.
//
#include <cstdlib>
#include <iostream>
#include "PortableSoundInfo.h"
#include "SoundManager.h"
#include "SDL_mixer.h"
static SoundManager *currentSoundManager = nullptr;
static const char *sounds[] = {
"eng_1_mid_loop.wav",
"type1.wav",
"type2.wav",
"type3.wav",
"type4.wav",
"type5.wav",
"type_space.wav",
"type_ding.wav",
"type_feed.wav",
"tommy.wav",
"tommy_loop.wav",
"glassbreak.wav",
"bulb_break.wav",
"bullethole_glass.wav",
"dramatic_boom.wav",
"paper_in.wav",
"paper_out.wav",
"ocean_close.wav",
"waves_ambience.wav"
};
static const int soundSourceCounts[] = {
1,
8, 8, 8, 8, 8, 8,
1, 1,
8, 1,
8, 8, 8,
1, 1, 1, 1, 1
};
static const char *songs[] = {
/*....*/
};
static const int numSounds = sizeof(sounds)/sizeof(char *);
//static const int numSongs = sizeof(songs)/sizeof(char *);
using namespace std;
SoundManager::SoundManager()
{
//create the engine
if(!FAILED(XAudio2Create(&engine)))
{
//create the mastering voice
if(!FAILED(engine->CreateMasteringVoice(&master)))
{
//create 3D sound engine
DWORD dwChannelMask;
if(!FAILED(engine->GetDeviceDetails(0, &deviceDetails)))
{
dwChannelMask = deviceDetails.OutputFormat.dwChannelMask;
X3DAudioInitialize(dwChannelMask, X3DAUDIO_SPEED_OF_SOUND, engine3d);
ZeroMemory(&listener, sizeof(listener));
}
else
{
cerr << "3D sound init failed!" << endl;
}
//and load sound fx
loadSoundEffects();
}
}
else
{
cerr << "Could not initialize DirectSound for sound!" << endl;
}
currentSoundManager = this;
}
SoundManager::~SoundManager()
{
if(engine)
engine->Release();
for(Wave *wave : buffers) if(wave)
delete wave;
for(MultiSource *ms : sources) if(ms)
delete ms;
if(currentSong)
Mix_FreeMusic(currentSong);
}
SoundManager *SoundManager::manager()
{
return currentSoundManager;
}
void SoundManager::loadSoundEffects()
{
auto sz = numSounds;
for(int i = 0; i < numSounds; i++)
{
Wave *buffer = new Wave();
if(!buffer->load(sounds[i]))
{
cerr << "shilt" << endl;
}
int maxSources = soundSourceCounts[i];
MultiSource *source = new MultiSource(engine, buffer, maxSources);
buffers.push_back(buffer);
sources.push_back(source);
}
//long music placeholder
sources.push_back(nullptr);
buffers.push_back(nullptr);
}
void SoundManager::update3D()
{
for(auto s : sources) if(s)
{
s->update3D(this);
}
}
void SoundManager::loadLongMusicEffect(const char *fn)
{
if(longMusicBuffer)
unloadLongMusicEffect();
PortableSoundInfo sound(fn);
longMusicBuffer = new Wave();
if(!longMusicBuffer->load(sound))
{
cerr << "long music load failed!" << endl;
}
longMusicSource = new MultiSource(engine, longMusicBuffer, 1);
sources[(int)LongMusic] = longMusicSource;
buffers[(int)LongMusic] = longMusicBuffer;
}
void SoundManager::unloadLongMusicEffect()
{
delete longMusicBuffer;
longMusicBuffer = nullptr;
delete longMusicSource;
longMusicSource = nullptr;
}
void SoundManager::setEffectGain(SoundManager::Effect effect, float gain)
{
const float vol = gain;
auto source = sources[(int)effect];
for(auto s : source->sources)
{
s->SetVolume(vol);
}
}
void SoundManager::setEffectBasicProperties(SoundManager::Effect effect, float gain, float pitch, bool looping)
{
setEffectGain(effect, gain);
if(pitch != 0.0f)
{
setEffectPitch(effect, pitch);
}
if(!looping)
{
buffers[(int)effect]->xaBuffer()->LoopCount = 0;
}
else
{
buffers[(int)effect]->xaBuffer()->LoopCount = XAUDIO2_MAX_LOOP_COUNT;
}
}
void SoundManager::setEffectPitch(SoundManager::Effect effect, float pitch)
{
auto source = sources[(int)effect];
for(auto s : source->sources)
{
const float ratio = pitch;
s->SetFrequencyRatio(ratio);
}
//mm.. mmmm, pitch!
source->basePitch = pitch;
}
void SoundManager::setEffectSpatialProperties(SoundManager::Effect effect, float referenceDistance, float maxDistance, float rollOffFactor,
float3 velocity, float3 direction)
{
//stereo tracks get a horrible sound blasting result when you try to do this
//lets just do what openAL does, which is silently fail
if(buffers[(int)effect]->wf()->nChannels > 1)
{
return;
}
//not reversible for now
auto source = sources[(int)effect];
source->is3D = true;
source->emitter.Velocity = { velocity.x, velocity.y, velocity.z };
if(direction != float3::zero)
{
source->emitter.OrientFront = { direction.x, direction.y, direction.z };
source->emitter.OrientTop = listener.OrientTop;
}
//a "max distance" isn't available in x3d audio it seems..
float distanceScalar = referenceDistance - rollOffFactor*2.5;
source->emitter.CurveDistanceScaler = max(0.0f, distanceScalar);
}
void SoundManager::setEffectPosition(Effect effect, float3 pos)
{
auto source = sources[(int)effect];
source->emitter.Position = { pos.x, pos.y, pos.z };
}
void SoundManager::setListenerPosition(float3 pos, float3 orientation[])
{
listener.Position = { pos.x, pos.y, pos.z };
listener.OrientFront = { orientation[0].x, orientation[0].y, orientation[0].z };
listener.OrientTop = { orientation[1].x, orientation[1].y, orientation[1].z };
}
void SoundManager::playEffect(SoundManager::Effect effect)
{
auto ms = sources[(int)effect];
auto source = ms->getSource();
//ensure initial 3D calculations done if requested
if(ms->is3D && !ms->is3DUpdated)
{
ms->update3D(this);
}
source->Start();
source->SubmitSourceBuffer(buffers[(int)effect]->xaBuffer());
}
void SoundManager::stopEffect(SoundManager::Effect effect)
{
auto source = sources[(int)effect];
for(auto s : source->sources)
{
s->Stop();
}
}
void SoundManager::playSong(SoundManager::Music song)
{
if(soundAvailable)
{
if(currentSong)
Mix_FreeMusic(currentSong);
currentSong = Mix_LoadMUS(songs[(int)song]);
Mix_PlayMusic(currentSong, -1);
}
}
void SoundManager::stopSong()
{
if(soundAvailable)
{
Mix_HaltMusic();
}
}
void SoundManager::setSongVolume(float volume)
{
currentSongVolume = volume;
if(soundAvailable)
{
Mix_VolumeMusic((int)roundf(volume*MIX_MAX_VOLUME));
}
}
void SoundManager::setSongPosition(double pos)
{
if(soundAvailable)
{
Mix_SetMusicPosition(pos);
}
}
float SoundManager::getSongVolume()
{
return currentSongVolume;
}
IXAudio2SourceVoice *SoundManager::MultiSource::getSource()
{
auto isPlaying = [](IXAudio2SourceVoice *source)->bool {
XAUDIO2_VOICE_STATE state;
ZeroMemory(&state, sizeof(XAUDIO2_VOICE_STATE));
source->GetState(&state);
return (state.BuffersQueued != 0);
};
int i = 0;
while(i < sources.size() && isPlaying(sources[i]))
{
i++;
}
if(i == sources.size())
{
if(sources.size() > 1)
{
#ifdef DEBUG
cout << "Warning: sound queue will occur (this will suck)" << endl;
#endif
}
return sources[0];
}
return sources[i];
}
void SoundManager::MultiSource::update3D(SoundManager *sm)
{
if(is3D)
{
//X3DAUDIO_CALCULATE_LPF_DIRECT ?
X3DAudioCalculate(sm->engine3d, &sm->listener, &emitter, X3DAUDIO_CALCULATE_MATRIX | X3DAUDIO_CALCULATE_DOPPLER, &dspSettings);
for(auto s : sources)
{
s->SetOutputMatrix(sm->master, 1, sm->deviceDetails.OutputFormat.Format.nChannels, dspSettings.pMatrixCoefficients);
s->SetFrequencyRatio(basePitch * dspSettings.DopplerFactor);
}
is3DUpdated = true;
}
} |
All of the multiple source stuff is essentially handled by my inner MultiSource class which handles the souce pools for sounds that need em. I found that I never needed more than 8 sources per sound. I also had to add a new update3D method to update the 3D sound calculations and call it once every other frame or so (which wasn’t needed in OpenAL since it was done automatically).
Not shown here is a Wave class which essentially is a slightly modified version of the one from this tutorial. That class basically handles wav file loading for me and manages the sound buffer data internally.
That’s just about it. Everything else was pretty straightforward.
Nobody ever said developing in windows was easy…
So much has been done. I’ve gotten the menu screen (title) finished and it’s beutifal. I got the early music soundtrack for the title and first two levels in place, and a way to transition between all of these things.
My latest work has been the pre and post status screen in the game showing you how many enemies and bystanders to expect before each level, and how many you correctly or incorrectly killed at the end.
Some of the funnest work has been coding up the cutscenes for introducing the environments in the game. I’m still planning on only doing 3 environments (otherwise I’ll never finish this game), and making the 36 total levels out of different takes on these same environments.
Here’s a tease of the intro into the second environment of the game.
