r660 - in trunk: . game
black at icculus.org
black at icculus.org
Sun Mar 5 10:28:05 EST 2006
Author: black
Date: 2006-03-05 10:28:05 -0500 (Sun, 05 Mar 2006)
New Revision: 660
Modified:
trunk/game/g_audio.c
trunk/lhsound.c
trunk/lhsound.h
trunk/lhsound_mixmode.h
trunk/system.c
trunk/system.h
Log:
refactor the lhsound code to use multiple enums.
added a macro to make the system states const for everything except the system implementation
and made the system more of a black box.
Modified: trunk/game/g_audio.c
===================================================================
--- trunk/game/g_audio.c 2006-03-05 06:36:45 UTC (rev 659)
+++ trunk/game/g_audio.c 2006-03-05 15:28:05 UTC (rev 660)
@@ -147,7 +147,7 @@
// start mixing this sound
sound = (Sound *)Resource_GetData(entity->sound.resourceindex);
lhsoundBindSample(sound->samplenumber);
- lhsoundBegin(LHSOUND_SEGMENT_STRIP);
+ lhsoundBegin(LHSOUND_RENDER_SEGMENT_STRIP);
// output the previous mix point so that we have a valid
// segment, all later points will be added individually
// with no further segment checks
Modified: trunk/lhsound.c
===================================================================
--- trunk/lhsound.c 2006-03-05 06:36:45 UTC (rev 659)
+++ trunk/lhsound.c 2006-03-05 15:28:05 UTC (rev 660)
@@ -13,11 +13,11 @@
typedef struct lhsound_sample_s
{
int used; // true if GenSamples has marked this, made false by DeleteSamples
- lhsound_enum_t internalformat;
- lhsound_enum_t repeatmode; // one of LHSOUND_CLAMP, LHSOUND_WRAP, LHSOUND_REPEATSECTION
- lhsound_enum_t minfilter; // minification filter (what to do when the input maps to the output as multiple input samples to one output sample)
- lhsound_enum_t magfilter; // magnification filter (what to do when the input maps to the output as one input sample to multiple output samples)
- // if LHSOUND_REPEATSECTION is used, it will repeat the range repeatposition...length
+ lhsound_format_t internalformat;
+ lhsound_repeatmode_t repeatmode;
+ lhsound_filter_t minfilter; // minification filter (what to do when the input maps to the output as multiple input samples to one output sample)
+ lhsound_filter_t magfilter; // magnification filter (what to do when the input maps to the output as one input sample to multiple output samples)
+ // if LHSOUND_REEPAT_REPEATSECTION is used, it will repeat the range repeatposition...length
int repeatposition;
int length;
void *data;
@@ -49,12 +49,12 @@
lhsound_sample_t *boundsample;
// used only during Begin...End
- lhsound_enum_t beginmode;
+ lhsound_rendermode_t rendermode;
unsigned int numpoints;
lhsound_point_t points[2];
// current error code
- int errornum;
+ lhsound_error_t errornum;
// mixing framebuffer
int mixbufferlength;
@@ -62,7 +62,7 @@
}
lhsound_state;
-int lhsoundGetError(void)
+lhsound_error_t lhsoundGetError(void)
{
int n = lhsound_state.errornum;
lhsound_state.errornum = 0;
@@ -98,7 +98,7 @@
{
if (lhsound_state.boundsampleindex == number)
return;
- LHSOUNDASSERT(number < LHSOUND_MAX_SAMPLES, LHSOUND_OUT_OF_MEMORY);
+ LHSOUNDASSERT(number < LHSOUND_MAX_SAMPLES, LHSOUND_ERROR_OUT_OF_MEMORY);
lhsoundExpandSamplesArray(number);
lhsound_state.boundsampleindex = number;
lhsound_state.boundsample = lhsound_state.samples + number;
@@ -113,17 +113,16 @@
void lhsoundGenSamples(int count, int *array)
{
int i;
- LHSOUNDASSERT(count > 0, LHSOUND_INVALID_VALUE);
+ LHSOUNDASSERT(count > 0, LHSOUND_ERROR_INVALID_VALUE);
// TODO: add a firstunused optimization
- for (i = 1;count > 0;i++)
+ for (i = 1;count > 0;count--)
{
- LHSOUNDASSERT(i < LHSOUND_MAX_SAMPLES, LHSOUND_OUT_OF_MEMORY);
+ LHSOUNDASSERT(i < LHSOUND_MAX_SAMPLES, LHSOUND_ERROR_OUT_OF_MEMORY);
lhsoundExpandSamplesArray(i);
if (!lhsound_state.samples[i].used)
{
lhsound_state.samples[i].used = LHSOUND_TRUE;
- count--;
- *array++ = i;
+ *array++ = i++;
}
}
}
@@ -146,12 +145,12 @@
}
}
-void lhsoundSample(unsigned int length, lhsound_enum_t providedformat, const void *data)
+void lhsoundSample(unsigned int length, lhsound_format_t providedformat, const void *data)
{
unsigned int i;
unsigned int bytes;
- int internalformat;
- LHSOUNDASSERT(length >= 1, LHSOUND_INVALID_VALUE);
+ lhsound_format_t internalformat;
+ LHSOUNDASSERT(length >= 1, LHSOUND_ERROR_INVALID_VALUE);
// decide which internal format and detect invalid formats
// TODO: add swapped versions
bytes = 1;
@@ -175,7 +174,7 @@
bytes = 4;
break;
default:
- LHSOUNDERROR(LHSOUND_INVALID_ENUM);
+ LHSOUNDERROR(LHSOUND_ERROR_INVALID_ENUM);
break;
}
if (lhsound_state.boundsample->data)
@@ -265,37 +264,37 @@
}
}
-void lhsoundSampleParami(lhsound_enum_t parameter, int value)
+void lhsoundSampleParami(lhsound_sampleparam_t parameter, int value)
{
switch (parameter)
{
case LHSOUND_SAMPLE_REPEAT:
switch(value)
{
- case LHSOUND_CLAMP:
- case LHSOUND_WRAP:
+ case LHSOUND_REPEAT_CLAMP:
+ case LHSOUND_REPEAT_WRAP:
lhsound_state.boundsample->repeatmode = value;
break;
default:
- LHSOUNDERROR(LHSOUND_INVALID_ENUM);
+ LHSOUNDERROR(LHSOUND_ERROR_INVALID_ENUM);
break;
}
break;
case LHSOUND_SAMPLE_REPEATPOSITION:
- LHSOUNDASSERT(value >= 0 && value < lhsound_state.boundsample->length, LHSOUND_INVALID_VALUE);
+ LHSOUNDASSERT(value >= 0 && value < lhsound_state.boundsample->length, LHSOUND_ERROR_INVALID_VALUE);
lhsound_state.boundsample->repeatposition = value;
break;
case LHSOUND_SAMPLE_MINFILTER:
// TODO: add LHSOUND_SAMPLE_MINFILTER values LHSOUND_NEAREST_MIPMAP_NEAREST, LHSOUND_NEAREST_MIPMAP_LINEAR, LHSOUND_LINEAR_MIPMAP_NEAREST, LHSOUND_LINEAR_MIPMAP_LINEAR
- LHSOUNDASSERT(value == LHSOUND_NEAREST || value == LHSOUND_LINEAR, LHSOUND_INVALID_VALUE);
+ LHSOUNDASSERT(value == LHSOUND_NEAREST || value == LHSOUND_LINEAR, LHSOUND_ERROR_INVALID_VALUE);
lhsound_state.boundsample->minfilter = value;
break;
case LHSOUND_SAMPLE_MAGFILTER:
- LHSOUNDASSERT(value == LHSOUND_NEAREST || value == LHSOUND_LINEAR, LHSOUND_INVALID_VALUE);
+ LHSOUNDASSERT(value == LHSOUND_NEAREST || value == LHSOUND_LINEAR, LHSOUND_ERROR_INVALID_VALUE);
lhsound_state.boundsample->magfilter = value;
break;
default:
- LHSOUNDERROR(LHSOUND_INVALID_ENUM);
+ LHSOUNDERROR(LHSOUND_ERROR_INVALID_ENUM);
break;
}
}
@@ -304,7 +303,8 @@
{
double x1, x2, slope_scale, slope_s, slope_v, s, v, send;
int x, x1s, x2s, si1, si2;
- lhsound_enum_t mixmode, filter;
+ lhsound_repeatmode_t mixmode;
+ lhsound_filter_t filter;
float datasi1, datasi2, sfrac, *out;
lhsound_sample_t *sample = lhsound_state.boundsample;
// if backwards, swap the order
@@ -335,7 +335,7 @@
send = s + slope_s * (x2s-x1s);
// if entirely inside the 0-1 time range use a faster mixing mode
if (s >= 0 && s < 1 && send >= 0 && send < 1)
- mixmode = LHSOUND_NONE;
+ mixmode = LHSOUND_REPEAT_NONE;
else
mixmode = sample->repeatmode;
filter = sample->magfilter;
@@ -366,29 +366,29 @@
return;
}
-void lhsoundBegin(lhsound_enum_t mode)
+void lhsoundBegin(lhsound_rendermode_t mode)
{
- LHSOUNDASSERT(lhsound_state.beginmode == LHSOUND_NONE, LHSOUND_INVALID_OPERATION);
+ LHSOUNDASSERT(lhsound_state.rendermode == LHSOUND_RENDER_NONE, LHSOUND_ERROR_INVALID_OPERATION);
switch (mode)
{
- case LHSOUND_SEGMENTS:
- case LHSOUND_SEGMENT_STRIP:
- lhsound_state.beginmode = mode;
+ case LHSOUND_RENDER_SEGMENTS:
+ case LHSOUND_RENDER_SEGMENT_STRIP:
+ lhsound_state.rendermode = mode;
lhsound_state.numpoints = 0;
break;
default:
- LHSOUNDERROR(LHSOUND_INVALID_ENUM);
+ LHSOUNDERROR(LHSOUND_ERROR_INVALID_ENUM);
break;
}
}
void lhsoundPoint(double x, double s, double v)
{
- LHSOUNDASSERT(lhsound_state.beginmode != LHSOUND_NONE, LHSOUND_INVALID_OPERATION);
- switch (lhsound_state.beginmode)
+ LHSOUNDASSERT(lhsound_state.rendermode != LHSOUND_RENDER_NONE, LHSOUND_ERROR_INVALID_OPERATION);
+ switch (lhsound_state.rendermode)
{
- case LHSOUND_SEGMENTS:
- case LHSOUND_SEGMENT_STRIP:
+ case LHSOUND_RENDER_SEGMENTS:
+ case LHSOUND_RENDER_SEGMENT_STRIP:
lhsound_state.points[0] = lhsound_state.points[1];
lhsound_state.points[1].x = x;
lhsound_state.points[1].s = s;
@@ -398,7 +398,7 @@
{
lhsoundRenderSegment(&lhsound_state.points[0], &lhsound_state.points[1]);
lhsound_state.numpoints = 0;
- if (lhsound_state.beginmode == LHSOUND_SEGMENTS)
+ if (lhsound_state.rendermode == LHSOUND_RENDER_SEGMENTS)
lhsound_state.numpoints = 0;
else
{
@@ -415,8 +415,8 @@
void lhsoundEnd(void)
{
- LHSOUNDASSERT(lhsound_state.beginmode != LHSOUND_NONE, LHSOUND_INVALID_OPERATION);
- lhsound_state.beginmode = LHSOUND_NONE;
+ LHSOUNDASSERT(lhsound_state.rendermode != LHSOUND_RENDER_NONE, LHSOUND_ERROR_INVALID_OPERATION);
+ lhsound_state.rendermode = LHSOUND_RENDER_NONE;
}
void lhsoundInit(void)
@@ -429,17 +429,17 @@
lhsound_state.boundsample = lhsound_state.samples;
lhsound_state.boundsample->used = LHSOUND_TRUE;
lhsound_state.boundsample->internalformat = LHSOUND_SIGNED_BYTE;
- lhsound_state.boundsample->repeatmode = LHSOUND_CLAMP;
+ lhsound_state.boundsample->repeatmode = LHSOUND_REPEAT_CLAMP;
lhsound_state.boundsample->minfilter = LHSOUND_LINEAR;
lhsound_state.boundsample->magfilter = LHSOUND_LINEAR;
lhsound_state.boundsample->repeatposition = 0;
lhsound_state.boundsample->length = 0;
lhsound_state.boundsample->data = NULL;
- lhsound_state.beginmode = LHSOUND_NONE;
+ lhsound_state.rendermode = LHSOUND_RENDER_NONE;
lhsound_state.numpoints = 0;
- lhsound_state.errornum = LHSOUND_NONE;
+ lhsound_state.errornum = LHSOUND_ERROR_NONE;
lhsound_state.mixbufferlength = 0;
}
@@ -454,20 +454,22 @@
lhsoundClearMemory(&lhsound_state, 0, sizeof(lhsound_state));
}
-void lhsoundGeti(lhsound_enum_t what, int *output)
+void lhsoundGeti(lhsound_queryname_t pname, int *output)
{
- switch (what)
+ switch (pname)
{
- case LHSOUND_MIX_BUFFER_LENGTH:LHSOUNDASSERT(lhsound_state.beginmode, LHSOUND_INVALID_OPERATION);output[0] = lhsound_state.mixbufferlength;break;
- default:LHSOUNDERROR(LHSOUND_INVALID_ENUM);break;
+ case LHSOUND_MIX_BUFFER_LENGTH:LHSOUNDASSERT(lhsound_state.rendermode != LHSOUND_RENDER_NONE, LHSOUND_ERROR_INVALID_OPERATION);output[0] = lhsound_state.mixbufferlength;break;
+ default:LHSOUNDERROR(LHSOUND_ERROR_INVALID_ENUM);break;
}
}
void lhsoundMixBegin(int bufferlength)
{
- LHSOUNDASSERT(!lhsound_state.beginmode, LHSOUND_INVALID_OPERATION);
- LHSOUNDASSERT(bufferlength >= 1 && bufferlength < 65536, LHSOUND_INVALID_VALUE);
- lhsound_state.beginmode = LHSOUND_TRUE;
+ LHSOUNDASSERT(lhsound_state.rendermode != LHSOUND_RENDER_NONE, LHSOUND_ERROR_INVALID_OPERATION);
+ LHSOUNDASSERT(bufferlength >= 1 && bufferlength < 65536, LHSOUND_ERROR_INVALID_VALUE);
+ //FIXME: AK this is bad since it would allow a End call without a BeginCall
+ // but I guess its because of Geti, anyway, commented out since it should be solved somehow else
+ //lhsound_state.rendermode = LHSOUND_TRUE;
if (lhsound_state.mixbufferlength != bufferlength)
{
lhsound_state.mixbufferlength = bufferlength;
@@ -476,7 +478,7 @@
lhsoundClearMemory(lhsound_state.mixbuffer, 0, lhsound_state.mixbufferlength * sizeof(*lhsound_state.mixbuffer));
}
-void lhsoundMixEnd(lhsound_enum_t format, size_t stride, void *output, int bufferlength)
+void lhsoundMixEnd(lhsound_format_t format, size_t stride, void *output, int bufferlength)
{
int i;
int ival;
@@ -489,29 +491,30 @@
unsigned short s;
}
swaptest;
- LHSOUNDASSERT(lhsound_state.beginmode, LHSOUND_INVALID_OPERATION);
- LHSOUNDASSERT(bufferlength == lhsound_state.mixbufferlength, LHSOUND_INVALID_VALUE);
- LHSOUNDASSERT(stride != 0, LHSOUND_INVALID_VALUE);
+ // FIXME: same as in mixbegin
+ LHSOUNDASSERT(lhsound_state.rendermode != LHSOUND_RENDER_NONE, LHSOUND_ERROR_INVALID_OPERATION);
+ LHSOUNDASSERT(bufferlength == lhsound_state.mixbufferlength, LHSOUND_ERROR_INVALID_VALUE);
+ LHSOUNDASSERT(stride != 0, LHSOUND_ERROR_INVALID_VALUE);
swaptest.s = 1;
switch (format)
{
- case LHSOUND_UNSIGNED_SHORT_BIG_ENDIAN: format = LHSOUND_UNSIGNED_SHORT;swap = swaptest.c[0] != 0;break;
- case LHSOUND_SIGNED_SHORT_BIG_ENDIAN: format = LHSOUND_SIGNED_SHORT;swap = swaptest.c[0] != 0;break;
- case LHSOUND_UNSIGNED_INT_BIG_ENDIAN: format = LHSOUND_UNSIGNED_INT;swap = swaptest.c[0] != 0;break;
- case LHSOUND_SIGNED_INT_BIG_ENDIAN: format = LHSOUND_SIGNED_INT;swap = swaptest.c[0] != 0;break;
- case LHSOUND_FLOAT_BIG_ENDIAN: format = LHSOUND_FLOAT;swap = swaptest.c[0] != 0;break;
+ case LHSOUND_UNSIGNED_SHORT_BIG_ENDIAN: format = LHSOUND_UNSIGNED_SHORT; swap = swaptest.c[0] != 0;break;
+ case LHSOUND_SIGNED_SHORT_BIG_ENDIAN: format = LHSOUND_SIGNED_SHORT; swap = swaptest.c[0] != 0;break;
+ case LHSOUND_UNSIGNED_INT_BIG_ENDIAN: format = LHSOUND_UNSIGNED_INT; swap = swaptest.c[0] != 0;break;
+ case LHSOUND_SIGNED_INT_BIG_ENDIAN: format = LHSOUND_SIGNED_INT; swap = swaptest.c[0] != 0;break;
+ case LHSOUND_FLOAT_BIG_ENDIAN: format = LHSOUND_FLOAT; swap = swaptest.c[0] != 0;break;
- case LHSOUND_UNSIGNED_SHORT_LITTLE_ENDIAN: format = LHSOUND_UNSIGNED_SHORT;swap = swaptest.c[0] == 0;break;
- case LHSOUND_SIGNED_SHORT_LITTLE_ENDIAN: format = LHSOUND_SIGNED_SHORT;swap = swaptest.c[0] == 0;break;
- case LHSOUND_UNSIGNED_INT_LITTLE_ENDIAN: format = LHSOUND_UNSIGNED_INT;swap = swaptest.c[0] == 0;break;
- case LHSOUND_SIGNED_INT_LITTLE_ENDIAN: format = LHSOUND_SIGNED_INT;swap = swaptest.c[0] == 0;break;
- case LHSOUND_FLOAT_LITTLE_ENDIAN: format = LHSOUND_FLOAT;swap = swaptest.c[0] == 0;break;
+ case LHSOUND_UNSIGNED_SHORT_LITTLE_ENDIAN: format = LHSOUND_UNSIGNED_SHORT; swap = swaptest.c[0] == 0;break;
+ case LHSOUND_SIGNED_SHORT_LITTLE_ENDIAN: format = LHSOUND_SIGNED_SHORT; swap = swaptest.c[0] == 0;break;
+ case LHSOUND_UNSIGNED_INT_LITTLE_ENDIAN: format = LHSOUND_UNSIGNED_INT; swap = swaptest.c[0] == 0;break;
+ case LHSOUND_SIGNED_INT_LITTLE_ENDIAN: format = LHSOUND_SIGNED_INT; swap = swaptest.c[0] == 0;break;
+ case LHSOUND_FLOAT_LITTLE_ENDIAN: format = LHSOUND_FLOAT; swap = swaptest.c[0] == 0;break;
- case LHSOUND_UNSIGNED_SHORT_SWAPPED: format = LHSOUND_UNSIGNED_SHORT;swap = LHSOUND_TRUE;break;
- case LHSOUND_SIGNED_SHORT_SWAPPED: format = LHSOUND_SIGNED_SHORT;swap = LHSOUND_TRUE;break;
- case LHSOUND_UNSIGNED_INT_SWAPPED: format = LHSOUND_UNSIGNED_INT;swap = LHSOUND_TRUE;break;
- case LHSOUND_SIGNED_INT_SWAPPED: format = LHSOUND_SIGNED_INT;swap = LHSOUND_TRUE;break;
- case LHSOUND_FLOAT_SWAPPED: format = LHSOUND_FLOAT;swap = LHSOUND_TRUE;break;
+ case LHSOUND_UNSIGNED_SHORT_SWAPPED: format = LHSOUND_UNSIGNED_SHORT; swap = LHSOUND_TRUE;break;
+ case LHSOUND_SIGNED_SHORT_SWAPPED: format = LHSOUND_SIGNED_SHORT; swap = LHSOUND_TRUE;break;
+ case LHSOUND_UNSIGNED_INT_SWAPPED: format = LHSOUND_UNSIGNED_INT; swap = LHSOUND_TRUE;break;
+ case LHSOUND_SIGNED_INT_SWAPPED: format = LHSOUND_SIGNED_INT; swap = LHSOUND_TRUE;break;
+ case LHSOUND_FLOAT_SWAPPED: format = LHSOUND_FLOAT; swap = LHSOUND_TRUE;break;
default:
swap = LHSOUND_FALSE;
@@ -573,7 +576,7 @@
*((float *)out) = (float)lhsound_state.mixbuffer[i];
break;
default:
- LHSOUNDERROR(LHSOUND_INVALID_ENUM);
+ LHSOUNDERROR(LHSOUND_ERROR_INVALID_ENUM);
break;
}
if (swap)
Modified: trunk/lhsound.h
===================================================================
--- trunk/lhsound.h 2006-03-05 06:36:45 UTC (rev 659)
+++ trunk/lhsound.h 2006-03-05 15:28:05 UTC (rev 660)
@@ -2,14 +2,49 @@
#ifndef LHSOUND_H
#define LHSOUND_H
-typedef enum lhsound_enum_e
+#define LHSOUND_ZERO 0
+#define LHSOUND_ONE 1
+#define LHSOUND_FALSE 0
+#define LHSOUND_TRUE 1
+
+#define LHSOUND_NULL ((void *)0)
+
+typedef enum lhsound_error_e
{
- LHSOUND_ZERO = 0,
- LHSOUND_ONE = 1,
- LHSOUND_FALSE = 0,
- LHSOUND_TRUE = 1,
- LHSOUND_NONE = 0,
- LHSOUND_SIGNED_BYTE,
+ LHSOUND_ERROR_NONE,
+ LHSOUND_ERROR_INVALID_OPERATION,
+ LHSOUND_ERROR_INVALID_VALUE,
+ LHSOUND_ERROR_INVALID_ENUM,
+ LHSOUND_ERROR_OUT_OF_MEMORY,
+}
+lhsound_error_t;
+
+typedef enum lhsound_rendermode_e
+{
+ LHSOUND_RENDER_NONE,
+ LHSOUND_RENDER_SEGMENTS,
+ LHSOUND_RENDER_SEGMENT_STRIP,
+}
+lhsound_rendermode_t;
+
+typedef enum lhsound_queryname_e
+{
+ LHSOUND_MIX_BUFFER_LENGTH = 1,
+}
+lhsound_queryname_t;
+
+typedef enum lhsound_sampleparam_e
+{
+ LHSOUND_SAMPLE_REPEAT = 1,
+ LHSOUND_SAMPLE_REPEATPOSITION,
+ LHSOUND_SAMPLE_MINFILTER,
+ LHSOUND_SAMPLE_MAGFILTER,
+}
+lhsound_sampleparam_t;
+
+typedef enum lhsound_format_e
+{
+ LHSOUND_SIGNED_BYTE = 1,
LHSOUND_UNSIGNED_BYTE,
LHSOUND_SIGNED_SHORT,
LHSOUND_UNSIGNED_SHORT,
@@ -35,44 +70,47 @@
LHSOUND_UNSIGNED_INT_BIG_ENDIAN,
LHSOUND_FLOAT_BIG_ENDIAN,
LHSOUND_DOUBLE_BIG_ENDIAN,
- LHSOUND_SAMPLE_REPEAT,
- LHSOUND_SAMPLE_REPEATPOSITION,
- LHSOUND_SAMPLE_MINFILTER,
- LHSOUND_SAMPLE_MAGFILTER,
- LHSOUND_CLAMP,
- LHSOUND_WRAP,
- LHSOUND_REPEATSECTION,
- LHSOUND_NEAREST,
+}
+lhsound_format_t;
+
+typedef enum lhsound_filter_e
+{
+ LHSOUND_NEAREST = 0,
LHSOUND_LINEAR,
LHSOUND_NEAREST_MIPMAP_NEAREST,
LHSOUND_NEAREST_MIPMAP_LINEAR,
LHSOUND_LINEAR_MIPMAP_NEAREST,
LHSOUND_LINEAR_MIPMAP_LINEAR,
- LHSOUND_SEGMENTS,
- LHSOUND_SEGMENT_STRIP,
- LHSOUND_MIX_BUFFER_LENGTH,
- LHSOUND_INVALID_OPERATION,
- LHSOUND_INVALID_VALUE,
- LHSOUND_INVALID_ENUM,
- LHSOUND_OUT_OF_MEMORY,
}
-lhsound_enum_t;
+lhsound_filter_t;
-#define LHSOUND_NULL ((void *)0)
+typedef enum lhsound_repeatmode_e
+{
+ LHSOUND_REPEAT_NONE = 0,
+ LHSOUND_REPEAT_CLAMP,
+ LHSOUND_REPEAT_WRAP,
+ LHSOUND_REPEAT_REPEATSECTION,
+}
+lhsound_repeatmode_t;
-int lhsoundGetError(void);
-void lhsoundGeti(lhsound_enum_t what, int *output);
+lhsound_error_t lhsoundGetError(void);
+void lhsoundGeti(lhsound_queryname_t pname, int *output);
+
void lhsoundBindSample(unsigned int number);
void lhsoundGenSamples(int count, int *array);
void lhsoundDeleteSamples(unsigned int count, int *array);
-void lhsoundSample(unsigned int length, lhsound_enum_t providedformat, const void *data);
-void lhsoundSampleParami(lhsound_enum_t parameter, int value);
-void lhsoundBegin(lhsound_enum_t mode);
+
+void lhsoundSample(unsigned int length, lhsound_format_t providedformat, const void *data);
+void lhsoundSampleParami(lhsound_sampleparam_t parameter, int value);
+
+void lhsoundBegin(lhsound_rendermode_t mode);
void lhsoundPoint(double x, double s, double v);
void lhsoundEnd(void);
+
void lhsoundInit(void);
void lhsoundShutdown(void);
+
void lhsoundMixBegin(int bufferlength);
-void lhsoundMixEnd(lhsound_enum_t format, size_t stride, void *output, int bufferlength);
+void lhsoundMixEnd(lhsound_format_t format, size_t stride, void *output, int bufferlength);
#endif
Modified: trunk/lhsound_mixmode.h
===================================================================
--- trunk/lhsound_mixmode.h 2006-03-05 06:36:45 UTC (rev 659)
+++ trunk/lhsound_mixmode.h 2006-03-05 15:28:05 UTC (rev 660)
@@ -1,22 +1,22 @@
switch(mixmode)
{
- case LHSOUND_NONE:
+ case LHSOUND_REPEAT_NONE:
#define MIX_WRAP(datasi, si) ((datasi) = data[(si)])
#include "lhsound_mixloop.h"
#undef MIX_WRAP
break;
- case LHSOUND_CLAMP:
+ case LHSOUND_REPEAT_CLAMP:
#define MIX_WRAP(datasi, si) ((datasi) = ((si) >= 0 && (si) < sample->length) ? data[(si)] : 0)
#include "lhsound_mixloop.h"
#undef MIX_WRAP
break;
- case LHSOUND_WRAP:
+ case LHSOUND_REPEAT_WRAP:
#define MIX_WRAP(datasi, si) ((datasi) = ((si) >= 0 && (si) < sample->length) ? data[(si)] : data[(si) - ((si) / sample->length) * sample->length])
#include "lhsound_mixloop.h"
#undef MIX_WRAP
break;
- case LHSOUND_REPEATSECTION:
+ case LHSOUND_REPEAT_REPEATSECTION:
#define MIX_WRAP(datasi, si) ((datasi) = (si) >= 0 ? ((si) < sample->length ? data[(si)] : (data[(si) - ((si - sample->repeatposition) / (sample->length - sample->repeatposition)) * (sample->length - sample->repeatposition)])) : 0)
#include "lhsound_mixloop.h"
#undef MIX_WRAP
Modified: trunk/system.c
===================================================================
--- trunk/system.c 2006-03-05 06:36:45 UTC (rev 659)
+++ trunk/system.c 2006-03-05 15:28:05 UTC (rev 660)
@@ -1,3 +1,4 @@
+#define SYSTEM_IMPLEMENTATION
#include "ncommon.h"
#include "SDL.h"
@@ -14,6 +15,10 @@
AudioState Audio;
InputState Input;
+static void Video_Frame(void);
+static void Input_Frame(void);
+static void Audio_Frame(void);
+
// private
static SDL_Surface *Video_Surface;
@@ -73,7 +78,7 @@
return true;
}
-void Video_Frame(void)
+static void Video_Frame(void)
{
Video.framecount++;
G_DrawFrame();
@@ -165,7 +170,7 @@
return true;
}
-void Audio_Frame(void)
+static void Audio_Frame(void)
{
// TODO update something here?
Audio.framecount++;
@@ -179,7 +184,7 @@
}
extern void G_Command_Quit(void);
-void Input_Frame(void)
+static void Input_Frame(void)
{
SDL_Event event;
Modified: trunk/system.h
===================================================================
--- trunk/system.h 2006-03-05 06:36:45 UTC (rev 659)
+++ trunk/system.h 2006-03-05 15:28:05 UTC (rev 660)
@@ -2,7 +2,6 @@
#ifndef SYSTEM_H
#define SYSTEM_H
-
typedef struct SystemState
{
NUint argc;
@@ -48,22 +47,27 @@
}
InputState;
-extern SystemState System;
-extern VideoState Video;
-extern AudioState Audio;
-extern InputState Input;
+#undef STATEMODIFIER
+#ifndef SYSTEM_IMPLEMENTATION
+# define STATEMODIFIER const
+#else
+# define STATEMODIFIER
+#endif
+extern STATEMODIFIER SystemState System;
+extern STATEMODIFIER VideoState Video;
+extern STATEMODIFIER AudioState Audio;
+extern STATEMODIFIER InputState Input;
+
Nbool Video_SetMode(NUint width, NUint height, NUint bpp, Nbool fullscreen, Nbool openglmode);
-void Video_Frame(void);
Nbool Audio_SetMode(NUint rate, NUint channels);
-void Audio_Frame(void);
void Input_SetMode(Nbool grabmouse);
-void Input_Frame(void);
// calls Video_Frame, Audio_Frame, and Input_Frame
void System_Frame(void);
Ndouble System_Time(void);
NUint32 System_CheckParm(const char *name, NUint32 requiredparms);
+// these functions need to be implemented by the game system
void G_KeyEvent(NUint mod, NUint sym, NUint character, Nbool downevent);
void G_DrawFrame(void);
void G_Main(void);
More information about the neither-commits
mailing list