# HG changeset patch # User John Tsiombikas # Date 1414017967 -10800 # Node ID 1cffe3409164d6293d60fed7dff6bba0ef146891 initial commit diff -r 000000000000 -r 1cffe3409164 TheLabDemo.sln --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/TheLabDemo.sln Thu Oct 23 01:46:07 2014 +0300 @@ -0,0 +1,19 @@ +Microsoft Visual Studio Solution File, Format Version 10.00 +# Visual Studio 2008 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "TheLabDemo", "TheLabDemo.vcproj", "{5346BE25-4A84-4401-82EB-88E9E6B9009D}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Release|Win32 = Release|Win32 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {5346BE25-4A84-4401-82EB-88E9E6B9009D}.Debug|Win32.ActiveCfg = Debug|Win32 + {5346BE25-4A84-4401-82EB-88E9E6B9009D}.Debug|Win32.Build.0 = Debug|Win32 + {5346BE25-4A84-4401-82EB-88E9E6B9009D}.Release|Win32.ActiveCfg = Release|Win32 + {5346BE25-4A84-4401-82EB-88E9E6B9009D}.Release|Win32.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff -r 000000000000 -r 1cffe3409164 TheLabDemo.vcproj --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/TheLabDemo.vcproj Thu Oct 23 01:46:07 2014 +0300 @@ -0,0 +1,493 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff -r 000000000000 -r 1cffe3409164 fmod.dll Binary file fmod.dll has changed diff -r 000000000000 -r 1cffe3409164 libs/fmod/fmod.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libs/fmod/fmod.h Thu Oct 23 01:46:07 2014 +0300 @@ -0,0 +1,802 @@ +//========================================================================================== +// FMOD Main header file. Copyright (c), FireLight Multimedia 1999-2000. +//========================================================================================== + +#ifndef _FMOD_H_ +#define _FMOD_H_ + +//=============================================================================================== +// DEFINITIONS +//=============================================================================================== + +#if defined(__GNUC__) && defined(WIN32) + #define _cdecl +#endif /* defined(__GNUC__) && defined(WIN32) */ + +#if defined(PLATFORM_LINUX) + #define _cdecl + #define _stdcall + #define __cdecl + #define __stdcall + #define __declspec(x) + #define __PS __attribute__((packed)) /* gcc packed */ +#else + #define __PS /*dummy*/ +#endif + +#define F_API _stdcall + +#ifdef DLL_EXPORTS + #define DLL_API __declspec(dllexport) +#else + #ifdef __LCC__ + #define DLL_API F_API + #else + #define DLL_API + #endif // __LCC__ +#endif //DLL_EXPORTS + + +#define FMOD_VERSION 3.32f + + +// fmod defined types +typedef struct FSOUND_MATERIAL FSOUND_MATERIAL; +typedef struct FSOUND_GEOMLIST FSOUND_GEOMLIST; +typedef struct FSOUND_SAMPLE FSOUND_SAMPLE; +typedef struct FSOUND_STREAM FSOUND_STREAM; +typedef struct FSOUND_DSPUNIT FSOUND_DSPUNIT; +typedef struct FMUSIC_MODULE FMUSIC_MODULE; + +// callback types +typedef signed char (_cdecl *FSOUND_STREAMCALLBACK) (FSOUND_STREAM *stream, void *buff, int len, int param); +typedef void * (_cdecl *FSOUND_DSPCALLBACK) (void *originalbuffer, void *newbuffer, int length, int param); +typedef void (_cdecl *FMUSIC_CALLBACK) (FMUSIC_MODULE *mod, unsigned char param); + + +/* +[ENUM] +[ + [DESCRIPTION] + On failure of commands in FMOD, use FSOUND_GetError to attain what happened. + + [SEE_ALSO] + FSOUND_GetError +] +*/ +enum FMOD_ERRORS +{ + FMOD_ERR_NONE, // No errors + FMOD_ERR_BUSY, // Cannot call this command after FSOUND_Init. Call FSOUND_Close first. + FMOD_ERR_UNINITIALIZED, // This command failed because FSOUND_Init or FSOUND_SetOutput was not called + FMOD_ERR_INIT, // Error initializing output device. + FMOD_ERR_ALLOCATED, // Error initializing output device, but more specifically, the output device is already in use and cannot be reused. + FMOD_ERR_PLAY, // Playing the sound failed. + FMOD_ERR_OUTPUT_FORMAT, // Soundcard does not support the features needed for this soundsystem (16bit stereo output) + FMOD_ERR_COOPERATIVELEVEL, // Error setting cooperative level for hardware. + FMOD_ERR_CREATEBUFFER, // Error creating hardware sound buffer. + FMOD_ERR_FILE_NOTFOUND, // File not found + FMOD_ERR_FILE_FORMAT, // Unknown file format + FMOD_ERR_FILE_BAD, // Error loading file + FMOD_ERR_MEMORY, // Not enough memory + FMOD_ERR_VERSION, // The version number of this file format is not supported + FMOD_ERR_INVALID_PARAM, // An invalid parameter was passed to this function + FMOD_ERR_NO_EAX, // Tried to use an EAX command on a non EAX enabled channel or output. + FMOD_ERR_NO_EAX2, // Tried to use an advanced EAX2 command on a non EAX2 enabled channel or output. + FMOD_ERR_CHANNEL_ALLOC, // Failed to allocate a new channel + FMOD_ERR_RECORD, // Recording is not supported on this machine + FMOD_ERR_MEDIAPLAYER, // Windows Media Player not installed so cant play wma or use internet streaming. +}; + + +/* +[ENUM] +[ + [DESCRIPTION] + These output types are used with FSOUND_SetOutput, to choose which output driver to use. + + FSOUND_OUTPUT_A3D will cause FSOUND_Init to FAIL if you have not got a vortex + based A3D card. The suggestion for this is to immediately try and reinitialize FMOD with + FSOUND_OUTPUT_DSOUND, and if this fails, try initializing FMOD with FSOUND_OUTPUT_WAVEOUT. + + FSOUND_OUTPUT_DSOUND will not support hardware 3d acceleration if the sound card driver + does not support DirectX 6 Voice Manager Extensions. + + [SEE_ALSO] + FSOUND_SetOutput + FSOUND_GetOutput +] +*/ +enum FSOUND_OUTPUTTYPES +{ + FSOUND_OUTPUT_NOSOUND, // NoSound driver, all calls to this succeed but do nothing. + FSOUND_OUTPUT_WINMM, // Windows Multimedia driver. + FSOUND_OUTPUT_DSOUND, // DirectSound driver. You need this to get EAX or EAX2 support. + FSOUND_OUTPUT_A3D, // A3D driver. You need this to get geometry support. + FSOUND_OUTPUT_OSS, // Linux/Unix OSS (Open Sound System) driver, i.e. the kernel sound drivers. + FSOUND_OUTPUT_ESD, // Linux/Unix ESD (Enlightment Sound Daemon) driver. + FSOUND_OUTPUT_ALSA // Linux Alsa driver. +}; + + +/* +[ENUM] +[ + [DESCRIPTION] + These mixer types are used with FSOUND_SetMixer, to choose which mixer to use, or to act + upon for other reasons using FSOUND_GetMixer. + + [SEE_ALSO] + FSOUND_SetMixer + FSOUND_GetMixer +] +*/ +enum FSOUND_MIXERTYPES +{ + FSOUND_MIXER_AUTODETECT, // Enables autodetection of the fastest mixer based on your cpu. + FSOUND_MIXER_BLENDMODE, // Enables the standard non mmx, blendmode mixer. + FSOUND_MIXER_MMXP5, // Enables the mmx, pentium optimized blendmode mixer. + FSOUND_MIXER_MMXP6, // Enables the mmx, ppro/p2/p3 optimized mixer. + + FSOUND_MIXER_QUALITY_AUTODETECT,// Enables autodetection of the fastest quality mixer based on your cpu. + FSOUND_MIXER_QUALITY_FPU, // Enables the interpolating/volume ramping FPU mixer. + FSOUND_MIXER_QUALITY_MMXP5, // Enables the interpolating/volume ramping p5 MMX mixer. + FSOUND_MIXER_QUALITY_MMXP6, // Enables the interpolating/volume ramping ppro/p2/p3+ MMX mixer. +}; + +/* +[ENUM] +[ + [DESCRIPTION] + These definitions describe the type of song being played. + + [SEE_ALSO] + FMUSIC_GetType +] +*/ +enum FMUSIC_TYPES +{ + FMUSIC_TYPE_NONE, + FMUSIC_TYPE_MOD, // Protracker / Fasttracker + FMUSIC_TYPE_S3M, // ScreamTracker 3 + FMUSIC_TYPE_XM, // FastTracker 2 + FMUSIC_TYPE_IT, // Impulse Tracker. + FMUSIC_TYPE_MIDI, // MIDI file +}; + + +/* +[DEFINE_START] +[ + [NAME] + FSOUND_DSP_PRIORITIES + + [DESCRIPTION] + These default priorities are + + [SEE_ALSO] + FSOUND_DSP_Create + FSOUND_DSP_SetPriority +] +*/ +#define FSOUND_DSP_DEFAULTPRIORITY_CLEARUNIT 0 // DSP CLEAR unit - done first +#define FSOUND_DSP_DEFAULTPRIORITY_SFXUNIT 100 // DSP SFX unit - done second +#define FSOUND_DSP_DEFAULTPRIORITY_MUSICUNIT 200 // DSP MUSIC unit - done third +#define FSOUND_DSP_DEFAULTPRIORITY_USER 300 // User priority, use this as reference +#define FSOUND_DSP_DEFAULTPRIORITY_CLIPANDCOPYUNIT 1000 // DSP CLIP AND COPY unit - last +// [DEFINE_END] + + +/* +[DEFINE_START] +[ + [NAME] + FSOUND_CAPS + + [DESCRIPTION] + Driver description bitfields. Use FSOUND_Driver_GetCaps to determine if a driver enumerated + has the settings you are after. The enumerated driver depends on the output mode, see + FSOUND_OUTPUTTYPES + + [SEE_ALSO] + FSOUND_GetDriverCaps + FSOUND_OUTPUTTYPES +] +*/ +#define FSOUND_CAPS_HARDWARE 0x1 // This driver supports hardware accelerated 3d sound. +#define FSOUND_CAPS_EAX 0x2 // This driver supports EAX reverb +#define FSOUND_CAPS_GEOMETRY_OCCLUSIONS 0x4 // This driver supports (A3D) geometry occlusions +#define FSOUND_CAPS_GEOMETRY_REFLECTIONS 0x8 // This driver supports (A3D) geometry reflections +#define FSOUND_CAPS_EAX2 0x10 // This driver supports EAX2/A3D3 reverb +// [DEFINE_END] + + +/* +[DEFINE_START] +[ + [NAME] + FSOUND_MODES + + [DESCRIPTION] + Sample description bitfields, OR them together for loading and describing samples. +] +*/ +#define FSOUND_LOOP_OFF 0x00000001 // For non looping samples. +#define FSOUND_LOOP_NORMAL 0x00000002 // For forward looping samples. +#define FSOUND_LOOP_BIDI 0x00000004 // For bidirectional looping samples. (no effect if in hardware). +#define FSOUND_8BITS 0x00000008 // For 8 bit samples. +#define FSOUND_16BITS 0x00000010 // For 16 bit samples. +#define FSOUND_MONO 0x00000020 // For mono samples. +#define FSOUND_STEREO 0x00000040 // For stereo samples. +#define FSOUND_UNSIGNED 0x00000080 // For source data containing unsigned samples. +#define FSOUND_SIGNED 0x00000100 // For source data containing signed data. +#define FSOUND_DELTA 0x00000200 // For source data stored as delta values. +#define FSOUND_IT214 0x00000400 // For source data stored using IT214 compression. +#define FSOUND_IT215 0x00000800 // For source data stored using IT215 compression. +#define FSOUND_HW3D 0x00001000 // Attempts to make samples use 3d hardware acceleration. (if the card supports it) +#define FSOUND_2D 0x00002000 // Ignores any 3d processing. overrides FSOUND_HW3D. Located in software. +#define FSOUND_STREAMABLE 0x00004000 // For a streamable sound where you feed the data to it. If you dont supply this sound may come out corrupted. (only affects a3d output) +#define FSOUND_LOADMEMORY 0x00008000 // 'name' will be interpreted as a pointer to data for streaming and samples. +#define FSOUND_LOADRAW 0x00010000 // For will ignore file format and treat as raw pcm. +#define FSOUND_MPEGACCURATE 0x00020000 // For FSOUND_Stream_OpenFile - for accurate FSOUND_Stream_GetLengthMs/FSOUND_Stream_SetTime. WARNING, see FSOUNDStream_OpenFile for inital opening time performance issues. + +// Default sample type. Loop off, 8bit mono, signed, not hardware accelerated. +// Some API functions ignore 8bits and mono, as it may be an mpeg/wav/etc which has its format predetermined. +#define FSOUND_NORMAL (FSOUND_LOOP_OFF | FSOUND_8BITS | FSOUND_MONO) +// [DEFINE_END] + + +/* +[DEFINE_START] +[ + [NAME] + FSOUND_CDPLAYMODES + + [DESCRIPTION] + Playback method for a CD Audio track, using FSOUND_CD_Play + + [SEE_ALSO] + FSOUND_CD_Play +] +*/ +#define FSOUND_CD_PLAYCONTINUOUS 0 // Starts from the current track and plays to end of CD. +#define FSOUND_CD_PLAYONCE 1 // Plays the specified track then stops. +#define FSOUND_CD_PLAYLOOPED 2 // Plays the specified track looped, forever until stopped manually. +#define FSOUND_CD_PLAYRANDOM 3 // Plays tracks in random order +// [DEFINE_END] + + +/* +[DEFINE_START] +[ + [NAME] + FSOUND_CHANNELSAMPLEMODE + + [DESCRIPTION] + Miscellaneous values for FMOD functions. + + [SEE_ALSO] + FSOUND_PlaySound + FSOUND_PlaySound3DAttrib + + FSOUND_Sample_Alloc + FSOUND_Sample_Load + FSOUND_SetPan +] +*/ +#define FSOUND_FREE -1 // value to play on any free channel, or to allocate a sample in a free sample slot. +#define FSOUND_UNMANAGED -2 // value to allocate a sample that is NOT managed by FSOUND or placed in a sample slot. +#define FSOUND_ALL -3 // for a channel index , this flag will affect ALL channels available! Not supported by every function. +#define FSOUND_STEREOPAN -1 // value for FSOUND_SetPan so that stereo sounds are not played at half volume. See FSOUND_SetPan for more on this. +// [DEFINE_END] + + +/* +[ENUM] +[ + [DESCRIPTION] + These are environment types defined for use with the FSOUND_Reverb API. + + [SEE_ALSO] + FSOUND_Reverb_SetEnvironment + FSOUND_Reverb_SetEnvironmentAdvanced +] +*/ +enum FSOUND_REVERB_ENVIRONMENTS +{ + FSOUND_ENVIRONMENT_GENERIC, + FSOUND_ENVIRONMENT_PADDEDCELL, + FSOUND_ENVIRONMENT_ROOM, + FSOUND_ENVIRONMENT_BATHROOM, + FSOUND_ENVIRONMENT_LIVINGROOM, + FSOUND_ENVIRONMENT_STONEROOM, + FSOUND_ENVIRONMENT_AUDITORIUM, + FSOUND_ENVIRONMENT_CONCERTHALL, + FSOUND_ENVIRONMENT_CAVE, + FSOUND_ENVIRONMENT_ARENA, + FSOUND_ENVIRONMENT_HANGAR, + FSOUND_ENVIRONMENT_CARPETEDHALLWAY, + FSOUND_ENVIRONMENT_HALLWAY, + FSOUND_ENVIRONMENT_STONECORRIDOR, + FSOUND_ENVIRONMENT_ALLEY, + FSOUND_ENVIRONMENT_FOREST, + FSOUND_ENVIRONMENT_CITY, + FSOUND_ENVIRONMENT_MOUNTAINS, + FSOUND_ENVIRONMENT_QUARRY, + FSOUND_ENVIRONMENT_PLAIN, + FSOUND_ENVIRONMENT_PARKINGLOT, + FSOUND_ENVIRONMENT_SEWERPIPE, + FSOUND_ENVIRONMENT_UNDERWATER, + FSOUND_ENVIRONMENT_DRUGGED, + FSOUND_ENVIRONMENT_DIZZY, + FSOUND_ENVIRONMENT_PSYCHOTIC, + + FSOUND_ENVIRONMENT_COUNT +}; + +/* +[DEFINE_START] +[ + [NAME] + FSOUND_REVERBMIX_USEDISTANCE + + [DESCRIPTION] + Used with FSOUND_Reverb_SetMix, this setting allows reverb to attenuate based on distance from the listener. + Instead of hard coding a value with FSOUND_Reverb_SetMix, this value can be used instead, for a more natural + reverb dropoff. + + [SEE_ALSO] + FSOUND_Reverb_SetMix +] +*/ +#define FSOUND_REVERBMIX_USEDISTANCE -1.0f // used with FSOUND_Reverb_SetMix to scale reverb by distance +// [DEFINE_END] + + +/* +[DEFINE_START] +[ + [NAME] + FSOUND_REVERB_IGNOREPARAM + + [DESCRIPTION] + Used with FSOUND_Reverb_SetEnvironment and FSOUND_Reverb_SetEnvironmentAdvanced, this can + be placed in the place of a specific parameter for the reverb setting. It allows you to + not set any parameters except the ones you are interested in .. and example would be this. + FSOUND_Reverb_SetEnvironment(FSOUND_REVERB_IGNOREPARAM, + FSOUND_REVERB_IGNOREPARAM, + FSOUND_REVERB_IGNOREPARAM, + 0.0f); + This means env, vol and decay are left alone, but 'damp' is set to 0. + + [SEE_ALSO] + FSOUND_Reverb_SetEnvironment + FSOUND_Reverb_SetEnvironmentAdvanced +] +*/ +#define FSOUND_REVERB_IGNOREPARAM -9999999 // used with FSOUND_Reverb_SetEnvironmentAdvanced to ignore certain parameters by choice. +// [DEFINE_END] + + +/* +[DEFINE_START] +[ + [NAME] + FSOUND_REVERB_PRESETS + + [DESCRIPTION] + A set of predefined environment PARAMETERS, created by Creative Labs + These can be placed directly into the FSOUND_Reverb_SetEnvironment call + + [SEE_ALSO] + FSOUND_Reverb_SetEnvironment +] +*/ +#define FSOUND_PRESET_OFF FSOUND_ENVIRONMENT_GENERIC,0.0f,0.0f,0.0f +#define FSOUND_PRESET_GENERIC FSOUND_ENVIRONMENT_GENERIC,0.5f,1.493f,0.5f +#define FSOUND_PRESET_PADDEDCELL FSOUND_ENVIRONMENT_PADDEDCELL,0.25f,0.1f,0.0f +#define FSOUND_PRESET_ROOM FSOUND_ENVIRONMENT_ROOM,0.417f,0.4f,0.666f +#define FSOUND_PRESET_BATHROOM FSOUND_ENVIRONMENT_BATHROOM,0.653f,1.499f,0.166f +#define FSOUND_PRESET_LIVINGROOM FSOUND_ENVIRONMENT_LIVINGROOM,0.208f,0.478f,0.0f +#define FSOUND_PRESET_STONEROOM FSOUND_ENVIRONMENT_STONEROOM,0.5f,2.309f,0.888f +#define FSOUND_PRESET_AUDITORIUM FSOUND_ENVIRONMENT_AUDITORIUM,0.403f,4.279f,0.5f +#define FSOUND_PRESET_CONCERTHALL FSOUND_ENVIRONMENT_CONCERTHALL,0.5f,3.961f,0.5f +#define FSOUND_PRESET_CAVE FSOUND_ENVIRONMENT_CAVE,0.5f,2.886f,1.304f +#define FSOUND_PRESET_ARENA FSOUND_ENVIRONMENT_ARENA,0.361f,7.284f,0.332f +#define FSOUND_PRESET_HANGAR FSOUND_ENVIRONMENT_HANGAR,0.5f,10.0f,0.3f +#define FSOUND_PRESET_CARPETEDHALLWAY FSOUND_ENVIRONMENT_CARPETEDHALLWAY,0.153f,0.259f,2.0f +#define FSOUND_PRESET_HALLWAY FSOUND_ENVIRONMENT_HALLWAY,0.361f,1.493f,0.0f +#define FSOUND_PRESET_STONECORRIDOR FSOUND_ENVIRONMENT_STONECORRIDOR,0.444f,2.697f,0.638f +#define FSOUND_PRESET_ALLEY FSOUND_ENVIRONMENT_ALLEY,0.25f,1.752f,0.776f +#define FSOUND_PRESET_FOREST FSOUND_ENVIRONMENT_FOREST,0.111f,3.145f,0.472f +#define FSOUND_PRESET_CITY FSOUND_ENVIRONMENT_CITY,0.111f,2.767f,0.224f +#define FSOUND_PRESET_MOUNTAINS FSOUND_ENVIRONMENT_MOUNTAINS,0.194f,7.841f,0.472f +#define FSOUND_PRESET_QUARRY FSOUND_ENVIRONMENT_QUARRY,1.0f,1.499f,0.5f +#define FSOUND_PRESET_PLAIN FSOUND_ENVIRONMENT_PLAIN,0.097f,2.767f,0.224f +#define FSOUND_PRESET_PARKINGLOT FSOUND_ENVIRONMENT_PARKINGLOT,0.208f,1.652f,1.5f +#define FSOUND_PRESET_SEWERPIPE FSOUND_ENVIRONMENT_SEWERPIPE,0.652f,2.886f,0.25f +#define FSOUND_PRESET_UNDERWATER FSOUND_ENVIRONMENT_UNDERWATER,1.0f,1.499f,0.0f +#define FSOUND_PRESET_DRUGGED FSOUND_ENVIRONMENT_DRUGGED,0.875f, 8.392f,1.388f +#define FSOUND_PRESET_DIZZY FSOUND_ENVIRONMENT_DIZZY,0.139f,17.234f,0.666f +#define FSOUND_PRESET_PSYCHOTIC FSOUND_ENVIRONMENT_PSYCHOTIC,0.486f,7.563f,0.806f +// [DEFINE_END] + + +/* +[DEFINE_START] +[ + [NAME] + FSOUND_GEOMETRY_MODES + + [DESCRIPTION] + Geometry flags, used as the mode flag in FSOUND_Geometry_AddPolygon + + [SEE_ALSO] + FSOUND_Geometry_AddPolygon +] +*/ +#define FSOUND_GEOMETRY_NORMAL 0x0 // Default geometry type. Occluding polygon +#define FSOUND_GEOMETRY_REFLECTIVE 0x01 // This polygon is reflective +#define FSOUND_GEOMETRY_OPENING 0x02 // Overlays a transparency over the previous polygon. The 'openingfactor' value supplied is copied internally. +#define FSOUND_GEOMETRY_OPENING_REFERENCE 0x04 // Overlays a transparency over the previous polygon. The 'openingfactor' supplied is pointed to (for access when building a list) +// [DEFINE_END] + +/* +[DEFINE_START] +[ + [NAME] + FSOUND_INIT_FLAGS + + [DESCRIPTION] + Initialization flags. Use them with FSOUND_Init in the flags parameter to change various behaviour. + + [SEE_ALSO] + FSOUND_Init +] +*/ +#define FSOUND_INIT_USEDEFAULTMIDISYNTH 0x01 // Causes MIDI playback to force software decoding. +#define FSOUND_INIT_GLOBALFOCUS 0x02 // For DirectSound output - sound is not muted when window is out of focus. +// [DEFINE_END] + + + + +//=============================================================================================== +// FUNCTION PROTOTYPES +//=============================================================================================== + +#ifdef __cplusplus +extern "C" { +#endif + +// ================================== +// Initialization / Global functions. +// ================================== + +// *Pre* FSOUND_Init functions. These can't be called after FSOUND_Init is +// called (they will fail). They set up FMOD system functionality. +DLL_API signed char F_API FSOUND_SetOutput(int outputtype); +DLL_API signed char F_API FSOUND_SetDriver(int driver); +DLL_API signed char F_API FSOUND_SetMixer(int mixer); +DLL_API signed char F_API FSOUND_SetBufferSize(int len_ms); +DLL_API signed char F_API FSOUND_SetHWND(void *hwnd); +DLL_API signed char F_API FSOUND_SetMinHardwareChannels(int min); +DLL_API signed char F_API FSOUND_SetMaxHardwareChannels(int max); + +// Main initialization / closedown functions. +// Note : Use FSOUND_INIT_USEDEFAULTMIDISYNTH with FSOUND_Init for software override with MIDI playback. +// : Use FSOUND_INIT_GLOBALFOCUS with FSOUND_Init to make sound audible no matter which window is in focus. +DLL_API signed char F_API FSOUND_Init(int mixrate, int maxsoftwarechannels, unsigned int flags); +DLL_API void F_API FSOUND_Close(); + +// Runtime +DLL_API void F_API FSOUND_SetSFXMasterVolume(int volume); +DLL_API void F_API FSOUND_SetPanSeperation(float pansep); + +// System information. +DLL_API int F_API FSOUND_GetError(); +DLL_API float F_API FSOUND_GetVersion(); +DLL_API int F_API FSOUND_GetOutput(); +DLL_API int F_API FSOUND_GetDriver(); +DLL_API int F_API FSOUND_GetMixer(); +DLL_API int F_API FSOUND_GetNumDrivers(); +DLL_API signed char * F_API FSOUND_GetDriverName(int id); +DLL_API signed char F_API FSOUND_GetDriverCaps(int id, unsigned int *caps); +DLL_API int F_API FSOUND_GetOutputRate(); +DLL_API int F_API FSOUND_GetMaxChannels(); +DLL_API int F_API FSOUND_GetMaxSamples(); +DLL_API int F_API FSOUND_GetSFXMasterVolume(); +DLL_API int F_API FSOUND_GetNumHardwareChannels(); +DLL_API int F_API FSOUND_GetChannelsPlaying(); +DLL_API float F_API FSOUND_GetCPUUsage(); + +// =================================== +// Sample management / load functions. +// =================================== + +// Note : Use FSOUND_LOADMEMORY flag with FSOUND_Sample_Load to load from memory. +// Use FSOUND_LOADRAW flag with FSOUND_Sample_Load to treat as as raw pcm data. + +// Sample creation and management functions +DLL_API FSOUND_SAMPLE * F_API FSOUND_Sample_Load(int index, const char *name, unsigned int mode, int memlength); +DLL_API FSOUND_SAMPLE * F_API FSOUND_Sample_Alloc(int index, int length, unsigned int mode, int deffreq, int defvol, int defpan, int defpri); +DLL_API void F_API FSOUND_Sample_Free(FSOUND_SAMPLE *sptr); +DLL_API signed char F_API FSOUND_Sample_Upload(FSOUND_SAMPLE *sptr, void *srcdata, unsigned int mode); +DLL_API signed char F_API FSOUND_Sample_Lock(FSOUND_SAMPLE *sptr, int offset, int length, void **ptr1, void **ptr2, unsigned int *len1, unsigned int *len2); +DLL_API signed char F_API FSOUND_Sample_Unlock(FSOUND_SAMPLE *sptr, void *ptr1, void *ptr2, unsigned int len1, unsigned int len2); + +// Sample control functions +DLL_API signed char F_API FSOUND_Sample_SetLoopMode(FSOUND_SAMPLE *sptr, unsigned int loopmode); +DLL_API signed char F_API FSOUND_Sample_SetLoopPoints(FSOUND_SAMPLE *sptr, int loopstart, int loopend); +DLL_API signed char F_API FSOUND_Sample_SetDefaults(FSOUND_SAMPLE *sptr, int deffreq, int defvol, int defpan, int defpri); +DLL_API signed char F_API FSOUND_Sample_SetMinMaxDistance(FSOUND_SAMPLE *sptr, float min, float max); + +// Sample information +DLL_API FSOUND_SAMPLE * F_API FSOUND_Sample_Get(int sampno); +DLL_API char * F_API FSOUND_Sample_GetName(FSOUND_SAMPLE *sptr); +DLL_API unsigned int F_API FSOUND_Sample_GetLength(FSOUND_SAMPLE *sptr); +DLL_API signed char F_API FSOUND_Sample_GetLoopPoints(FSOUND_SAMPLE *sptr, int *loopstart, int *loopend); +DLL_API signed char F_API FSOUND_Sample_GetDefaults(FSOUND_SAMPLE *sptr, int *deffreq, int *defvol, int *defpan, int *defpri); +DLL_API unsigned int F_API FSOUND_Sample_GetMode(FSOUND_SAMPLE *sptr); + +// ============================ +// Channel control functions. +// ============================ + +// Playing and stopping sounds. +DLL_API int F_API FSOUND_PlaySound(int channel, FSOUND_SAMPLE *sptr); +DLL_API int F_API FSOUND_PlaySound3DAttrib(int channel, FSOUND_SAMPLE *sptr, int freq, int vol, int pan, float *pos, float *vel); +DLL_API signed char F_API FSOUND_StopSound(int channel); + +// Functions to control playback of a channel. +DLL_API signed char F_API FSOUND_SetFrequency(int channel, int freq); +DLL_API signed char F_API FSOUND_SetVolume(int channel, int vol); +DLL_API signed char F_API FSOUND_SetVolumeAbsolute(int channel, int vol); +DLL_API signed char F_API FSOUND_SetPan(int channel, int pan); +DLL_API signed char F_API FSOUND_SetSurround(int channel, signed char surround); +DLL_API signed char F_API FSOUND_SetMute(int channel, signed char mute); +DLL_API signed char F_API FSOUND_SetPriority(int channel, int priority); +DLL_API signed char F_API FSOUND_SetReserved(int channel, signed char reserved); +DLL_API signed char F_API FSOUND_SetPaused(int channel, signed char paused); +DLL_API signed char F_API FSOUND_SetLoopMode(int channel, unsigned int loopmode); + +// Channel information +DLL_API signed char F_API FSOUND_IsPlaying(int channel); +DLL_API int F_API FSOUND_GetFrequency(int channel); +DLL_API int F_API FSOUND_GetVolume(int channel); +DLL_API int F_API FSOUND_GetPan(int channel); +DLL_API signed char F_API FSOUND_GetSurround(int channel); +DLL_API signed char F_API FSOUND_GetMute(int channel); +DLL_API int F_API FSOUND_GetPriority(int channel); +DLL_API signed char F_API FSOUND_GetReserved(int channel); +DLL_API signed char F_API FSOUND_GetPaused(int channel); +DLL_API unsigned int F_API FSOUND_GetCurrentPosition(int channel); +DLL_API FSOUND_SAMPLE * F_API FSOUND_GetCurrentSample(int channel); +DLL_API float F_API FSOUND_GetCurrentVU(int channel); + +// =================== +// 3D sound functions. +// =================== +// see also FSOUND_PlaySound3DAttrib (above) +// see also FSOUND_Sample_SetMinMaxDistance (above) +DLL_API void F_API FSOUND_3D_Update(); +DLL_API signed char F_API FSOUND_3D_SetAttributes(int channel, float *pos, float *vel); +DLL_API signed char F_API FSOUND_3D_GetAttributes(int channel, float *pos, float *vel); +DLL_API void F_API FSOUND_3D_Listener_SetAttributes(float *pos, float *vel, float fx, float fy, float fz, float tx, float ty, float tz); +DLL_API void F_API FSOUND_3D_Listener_GetAttributes(float *pos, float *vel, float *fx, float *fy, float *fz, float *tx, float *ty, float *tz); +DLL_API void F_API FSOUND_3D_Listener_SetDopplerFactor(float scale); +DLL_API void F_API FSOUND_3D_Listener_SetDistanceFactor(float scale); +DLL_API void F_API FSOUND_3D_Listener_SetRolloffFactor(float scale); + +// ========================= +// File Streaming functions. +// ========================= + +// Note : Use FSOUND_LOADMEMORY flag with FSOUND_Stream_OpenFile to stream from memory. +// Use FSOUND_LOADRAW flag with FSOUND_Stream_OpenFile to treat stream as raw pcm data. +// Use FSOUND_MPEGACCURATE flag with FSOUND_Stream_OpenFile to open mpegs in 'accurate mode' for seeking etc. + +DLL_API FSOUND_STREAM * F_API FSOUND_Stream_OpenFile(const char *filename, unsigned int mode, int memlength); +DLL_API FSOUND_STREAM * F_API FSOUND_Stream_Create(FSOUND_STREAMCALLBACK callback, int length, unsigned int mode, int samplerate, int userdata); +DLL_API int F_API FSOUND_Stream_Play(int channel, FSOUND_STREAM *stream); +DLL_API int F_API FSOUND_Stream_Play3DAttrib(int channel, FSOUND_STREAM *stream, int freq, int vol, int pan, float *pos, float *vel); +DLL_API signed char F_API FSOUND_Stream_Stop(FSOUND_STREAM *stream); +DLL_API signed char F_API FSOUND_Stream_Close(FSOUND_STREAM *stream); +DLL_API signed char F_API FSOUND_Stream_SetEndCallback(FSOUND_STREAM *stream, FSOUND_STREAMCALLBACK callback, int userdata); +DLL_API signed char F_API FSOUND_Stream_SetSynchCallback(FSOUND_STREAM *stream, FSOUND_STREAMCALLBACK callback, int userdata); +DLL_API FSOUND_SAMPLE * F_API FSOUND_Stream_GetSample(FSOUND_STREAM *stream); +DLL_API FSOUND_DSPUNIT *F_API FSOUND_Stream_CreateDSP(FSOUND_STREAM *stream, FSOUND_DSPCALLBACK callback, int priority, int param); + +DLL_API signed char F_API FSOUND_Stream_SetPaused(FSOUND_STREAM *stream, signed char paused); +DLL_API signed char F_API FSOUND_Stream_GetPaused(FSOUND_STREAM *stream); +DLL_API signed char F_API FSOUND_Stream_SetPosition(FSOUND_STREAM *stream, int position); +DLL_API int F_API FSOUND_Stream_GetPosition(FSOUND_STREAM *stream); +DLL_API signed char F_API FSOUND_Stream_SetTime(FSOUND_STREAM *stream, int ms); +DLL_API int F_API FSOUND_Stream_GetTime(FSOUND_STREAM *stream); +DLL_API int F_API FSOUND_Stream_GetLength(FSOUND_STREAM *stream); +DLL_API int F_API FSOUND_Stream_GetLengthMs(FSOUND_STREAM *stream); + +// =================== +// CD audio functions. +// =================== + +DLL_API signed char F_API FSOUND_CD_Play(int track); +DLL_API void F_API FSOUND_CD_SetPlayMode(signed char mode); +DLL_API signed char F_API FSOUND_CD_Stop(); +DLL_API signed char F_API FSOUND_CD_SetPaused(signed char paused); +DLL_API signed char F_API FSOUND_CD_SetVolume(int volume); +DLL_API signed char F_API FSOUND_CD_Eject(); + +DLL_API signed char F_API FSOUND_CD_GetPaused(); +DLL_API int F_API FSOUND_CD_GetTrack(); +DLL_API int F_API FSOUND_CD_GetNumTracks(); +DLL_API int F_API FSOUND_CD_GetVolume(); +DLL_API int F_API FSOUND_CD_GetTrackLength(int track); +DLL_API int F_API FSOUND_CD_GetTrackTime(); + + +// ============== +// DSP functions. +// ============== + +// DSP Unit control and information functions. +DLL_API FSOUND_DSPUNIT *F_API FSOUND_DSP_Create(FSOUND_DSPCALLBACK callback, int priority, int param); +DLL_API void F_API FSOUND_DSP_Free(FSOUND_DSPUNIT *unit); +DLL_API void F_API FSOUND_DSP_SetPriority(FSOUND_DSPUNIT *unit, int priority); +DLL_API int F_API FSOUND_DSP_GetPriority(FSOUND_DSPUNIT *unit); +DLL_API void F_API FSOUND_DSP_SetActive(FSOUND_DSPUNIT *unit, signed char active); +DLL_API signed char F_API FSOUND_DSP_GetActive(FSOUND_DSPUNIT *unit); + +// Functions to get hold of FSOUND 'system DSP unit' handles. +DLL_API FSOUND_DSPUNIT *F_API FSOUND_DSP_GetClearUnit(); +DLL_API FSOUND_DSPUNIT *F_API FSOUND_DSP_GetSFXUnit(); +DLL_API FSOUND_DSPUNIT *F_API FSOUND_DSP_GetMusicUnit(); +DLL_API FSOUND_DSPUNIT *F_API FSOUND_DSP_GetClipAndCopyUnit(); + +// misc DSP functions +DLL_API signed char F_API FSOUND_DSP_MixBuffers(void *destbuffer, void *srcbuffer, int len, int freq, int vol, int pan, unsigned int mode); +DLL_API void F_API FSOUND_DSP_ClearMixBuffer(); +DLL_API int F_API FSOUND_DSP_GetBufferLength(); + +// ============================================= +// Geometry functions. (NOT SUPPORTED IN LINUX) +// ============================================= + +// scene/polygon functions +DLL_API signed char F_API FSOUND_Geometry_AddPolygon(float *p1, float *p2, float *p3, float *p4, float *normal, unsigned int mode, float *openingfactor); +DLL_API int F_API FSOUND_Geometry_AddList(FSOUND_GEOMLIST *geomlist); + +// polygon list functions +DLL_API FSOUND_GEOMLIST * F_API FSOUND_Geometry_List_Create(signed char boundingvolume); +DLL_API signed char F_API FSOUND_Geometry_List_Free(FSOUND_GEOMLIST *geomlist); +DLL_API signed char F_API FSOUND_Geometry_List_Begin(FSOUND_GEOMLIST *geomlist); +DLL_API signed char F_API FSOUND_Geometry_List_End(FSOUND_GEOMLIST *geomlist); + +// material functions +DLL_API FSOUND_MATERIAL * F_API FSOUND_Geometry_Material_Create(); +DLL_API signed char F_API FSOUND_Geometry_Material_Free(FSOUND_MATERIAL *material); +DLL_API signed char F_API FSOUND_Geometry_Material_SetAttributes(FSOUND_MATERIAL *material, float reflectancegain, float reflectancefreq, float transmittancegain, float transmittancefreq); +DLL_API signed char F_API FSOUND_Geometry_Material_GetAttributes(FSOUND_MATERIAL *material, float *reflectancegain, float *reflectancefreq, float *transmittancegain, float *transmittancefreq); +DLL_API signed char F_API FSOUND_Geometry_Material_Set(FSOUND_MATERIAL *material); + +// ======================================================================== +// Reverb functions. (eax, eax2, a3d 3.0 reverb) (NOT SUPPORTED IN LINUX) +// ======================================================================== + +// eax1, eax2, a3d 3.0 (use FSOUND_REVERB_PRESETS if you like), (eax2 support through emulation/parameter conversion) +DLL_API signed char F_API FSOUND_Reverb_SetEnvironment(int env, float vol, float decay, float damp); +// eax2, a3d 3.0 only, does not work on eax1 +DLL_API signed char F_API FSOUND_Reverb_SetEnvironmentAdvanced( + int env, + int Room, // [-10000, 0] default: -10000 mB or use FSOUND_REVERB_IGNOREPARAM + int RoomHF, // [-10000, 0] default: 0 mB or use FSOUND_REVERB_IGNOREPARAM + float RoomRolloffFactor, // [0.0, 10.0] default: 0.0 or use FSOUND_REVERB_IGNOREPARAM + float DecayTime, // [0.1, 20.0] default: 1.0 s or use FSOUND_REVERB_IGNOREPARAM + float DecayHFRatio, // [0.1, 2.0] default: 0.5 or use FSOUND_REVERB_IGNOREPARAM + int Reflections, // [-10000, 1000] default: -10000 mB or use FSOUND_REVERB_IGNOREPARAM + float ReflectionsDelay, // [0.0, 0.3] default: 0.02 s or use FSOUND_REVERB_IGNOREPARAM + int Reverb, // [-10000, 2000] default: -10000 mB or use FSOUND_REVERB_IGNOREPARAM + float ReverbDelay, // [0.0, 0.1] default: 0.04 s or use FSOUND_REVERB_IGNOREPARAM + float EnvironmentSize, // [0.0, 100.0] default: 100.0 % or use FSOUND_REVERB_IGNOREPARAM + float EnvironmentDiffusion, // [0.0, 100.0] default: 100.0 % or use FSOUND_REVERB_IGNOREPARAM + float AirAbsorptionHF); // [20.0, 20000.0] default: 5000.0 Hz or use FSOUND_REVERB_IGNOREPARAM + +DLL_API signed char F_API FSOUND_Reverb_SetMix(int channel, float mix); + +// information functions +DLL_API signed char F_API FSOUND_Reverb_GetEnvironment(int *env, float *vol, float *decay, float *damp); +DLL_API signed char F_API FSOUND_Reverb_GetEnvironmentAdvanced( + int *env, + int *Room, + int *RoomHF, + float *RoomRolloffFactor, + float *DecayTime, + float *DecayHFRatio, + int *Reflections, + float *ReflectionsDelay, + int *Reverb, + float *ReverbDelay, + float *EnvironmentSize, + float *EnvironmentDiffusion, + float *AirAbsorptionHF); +DLL_API signed char F_API FSOUND_Reverb_GetMix(int channel, float *mix); + +// ============================================= +// Recording functions (NOT SUPPORTED IN LINUX) +// ============================================= + +// recording initialization functions +DLL_API signed char F_API FSOUND_Record_SetDriver(int outputtype); +DLL_API int F_API FSOUND_Record_GetNumDrivers(); +DLL_API signed char * F_API FSOUND_Record_GetDriverName(int id); +DLL_API int F_API FSOUND_Record_GetDriver(); + +// recording functionality. Only one recording session will work at a time +DLL_API signed char F_API FSOUND_Record_StartSample(FSOUND_SAMPLE *sptr, signed char loop);// record to sample +DLL_API signed char F_API FSOUND_Record_Stop(); // stop recording +DLL_API int F_API FSOUND_Record_GetPosition(); // offset in sample, or wav file + +// ========================= +// File system override +// ========================= + +DLL_API void F_API FSOUND_File_SetCallbacks(unsigned int (_cdecl *OpenCallback)(const char *name), + void (_cdecl *CloseCallback)(unsigned int handle), + int (_cdecl *ReadCallback)(void *buffer, int size, unsigned int handle), + int (_cdecl *SeekCallback)(unsigned int handle, int pos, signed char mode), + int (_cdecl *TellCallback)(unsigned int handle)); + +// ============================================================================================= +// FMUSIC API +// ============================================================================================= + +// Song management / playback functions. +DLL_API FMUSIC_MODULE * F_API FMUSIC_LoadSong(const char *name); +DLL_API FMUSIC_MODULE * F_API FMUSIC_LoadSongMemory(void *data, int length); +DLL_API signed char F_API FMUSIC_FreeSong(FMUSIC_MODULE *mod); +DLL_API signed char F_API FMUSIC_PlaySong(FMUSIC_MODULE *mod); +DLL_API signed char F_API FMUSIC_StopSong(FMUSIC_MODULE *mod); +DLL_API void F_API FMUSIC_StopAllSongs(); +DLL_API signed char F_API FMUSIC_SetZxxCallback(FMUSIC_MODULE *mod, FMUSIC_CALLBACK callback); +DLL_API signed char F_API FMUSIC_SetRowCallback(FMUSIC_MODULE *mod, FMUSIC_CALLBACK callback, int rowstep); +DLL_API signed char F_API FMUSIC_SetOrderCallback(FMUSIC_MODULE *mod, FMUSIC_CALLBACK callback, int orderstep); +DLL_API signed char F_API FMUSIC_SetInstCallback(FMUSIC_MODULE *mod, FMUSIC_CALLBACK callback, int instrument); +DLL_API signed char F_API FMUSIC_SetSample(FMUSIC_MODULE *mod, int sampno, FSOUND_SAMPLE *sptr); +DLL_API signed char F_API FMUSIC_OptimizeChannels(FMUSIC_MODULE *mod, int maxchannels, int minvolume); + +// Runtime song functions. +DLL_API signed char F_API FMUSIC_SetReverb(signed char reverb); // MIDI only. +DLL_API signed char F_API FMUSIC_SetOrder(FMUSIC_MODULE *mod, int order); +DLL_API signed char F_API FMUSIC_SetPaused(FMUSIC_MODULE *mod, signed char pause); +DLL_API signed char F_API FMUSIC_SetMasterVolume(FMUSIC_MODULE *mod, int volume); +DLL_API signed char F_API FMUSIC_SetPanSeperation(FMUSIC_MODULE *mod, float pansep); + +// Static song information functions. +DLL_API char * F_API FMUSIC_GetName(FMUSIC_MODULE *mod); +DLL_API signed char F_API FMUSIC_GetType(FMUSIC_MODULE *mod); +DLL_API int F_API FMUSIC_GetNumOrders(FMUSIC_MODULE *mod); +DLL_API int F_API FMUSIC_GetNumPatterns(FMUSIC_MODULE *mod); +DLL_API int F_API FMUSIC_GetNumInstruments(FMUSIC_MODULE *mod); +DLL_API int F_API FMUSIC_GetNumSamples(FMUSIC_MODULE *mod); +DLL_API int F_API FMUSIC_GetNumChannels(FMUSIC_MODULE *mod); +DLL_API FSOUND_SAMPLE * F_API FMUSIC_GetSample(FMUSIC_MODULE *mod, int sampno); +DLL_API int F_API FMUSIC_GetPatternLength(FMUSIC_MODULE *mod, int orderno); + +// Runtime song information. +DLL_API signed char F_API FMUSIC_IsFinished(FMUSIC_MODULE *mod); +DLL_API signed char F_API FMUSIC_IsPlaying(FMUSIC_MODULE *mod); +DLL_API int F_API FMUSIC_GetMasterVolume(FMUSIC_MODULE *mod); +DLL_API int F_API FMUSIC_GetGlobalVolume(FMUSIC_MODULE *mod); +DLL_API int F_API FMUSIC_GetOrder(FMUSIC_MODULE *mod); +DLL_API int F_API FMUSIC_GetPattern(FMUSIC_MODULE *mod); +DLL_API int F_API FMUSIC_GetSpeed(FMUSIC_MODULE *mod); +DLL_API int F_API FMUSIC_GetBPM(FMUSIC_MODULE *mod); +DLL_API int F_API FMUSIC_GetRow(FMUSIC_MODULE *mod); +DLL_API signed char F_API FMUSIC_GetPaused(FMUSIC_MODULE *mod); +DLL_API int F_API FMUSIC_GetTime(FMUSIC_MODULE *mod); + +#ifdef __cplusplus +} +#endif + +#endif diff -r 000000000000 -r 1cffe3409164 libs/fmod/fmodvc.lib Binary file libs/fmod/fmodvc.lib has changed diff -r 000000000000 -r 1cffe3409164 n3dinit.conf --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/n3dinit.conf Thu Oct 23 01:46:07 2014 +0300 @@ -0,0 +1,20 @@ +; The Lab Demos +; 3D Engine Configuration File +; You are advised not to mess with this file :) +; -- Nuclear / the Lab -- + +fullscreen = false +resolution = 800x600 +bpp = 32 +zbufferdepth = 32 +device = hal +tnl = hw +refresh = 60 +antialiasing = high +flipchain = doublebuffering +vsync = false +dontcareabout = zbufferdepth, tnl, alpha + +; -- syntax reminder -- +; dontcareflags: bpp, refresh, alpha, zbufferdepth, tnl, flipchain, aamode, vsync +; antialiasing: none / low / high \ No newline at end of file diff -r 000000000000 -r 1cffe3409164 readme.txt --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/readme.txt Thu Oct 23 01:46:07 2014 +0300 @@ -0,0 +1,25 @@ +--------------------------------------------------------------- + The Lab Demos presents a rather unfinished demo in ReAct 2003 +--------------------------------------------------------------- + - a B s e n c e - + (final version) + + Code: Nuclear + Gfx: RawNoise + Music: Amigo +Additional Gfx: Amoivikos / ASD + +A big thank you to the ReAct organizers (nlogn) for organizing +once again a great party. + +We want to personally greet: +Nina, Eva-S, Amoivikos, vvas, Navis, Alias Medron, Zouzoulos +j0bo, Psyche, Raoul, zafos, moT, emc, Outsider, imak, Thor +^gfx, Fubyo, Apomakros, Palmuter, nagz, night, aMUSiC, Optimus +Badsector and all the demosceners around the world. + +contact: nuclear@siggraph.org + +--------------------------------------------------------------- +---------------- http://thelab.demoscene.gr ----------------- +--------------------------------------------------------------- \ No newline at end of file diff -r 000000000000 -r 1cffe3409164 resource.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/resource.h Thu Oct 23 01:46:07 2014 +0300 @@ -0,0 +1,16 @@ +//{{NO_DEPENDENCIES}} +// Microsoft Visual C++ generated include file. +// Used by resources.rc +// +#define IDI_ICON1 101 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 102 +#define _APS_NEXT_COMMAND_VALUE 40001 +#define _APS_NEXT_CONTROL_VALUE 1001 +#define _APS_NEXT_SYMED_VALUE 101 +#endif +#endif diff -r 000000000000 -r 1cffe3409164 resources.rc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/resources.rc Thu Oct 23 01:46:07 2014 +0300 @@ -0,0 +1,5 @@ +// Microsoft Visual C++ generated resource script. +// +#include "resource.h" + +IDI_ICON1 ICON "thelab.ico" \ No newline at end of file diff -r 000000000000 -r 1cffe3409164 src/3deng/3deng.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/3deng/3deng.h Thu Oct 23 01:46:07 2014 +0300 @@ -0,0 +1,17 @@ +#ifndef _3DENG_H_ +#define _3DENG_H_ + +#include "switches.h" +#include "3dengine.h" +#include "exceptions.h" +#include "n3dmath.h" +#include "3dengtypes.h" +#include "lights.h" +#include "objects.h" +#include "camera.h" +#include "objectgen.h" +#include "3dscene.h" +#include "sceneloader.h" +#include "particles.h" + +#endif // _3DENG_H_ \ No newline at end of file diff -r 000000000000 -r 1cffe3409164 src/3deng/3dengine.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/3deng/3dengine.cpp Thu Oct 23 01:46:07 2014 +0300 @@ -0,0 +1,1388 @@ +#include +#include +#include +#include +#include "d3dx8.h" +#include "3dengine.h" +#include "exceptions.h" +#include "3dgeom.h" +#include "lights.h" + +// local helper functions +ColorDepth GetColorDepthFromPixelFormat(D3DFORMAT fmt); +D3DFORMAT GetPixelFormatFromColorDepth(ColorDepth cd, bool noalpha=false); +D3DFORMAT GetDepthStencilFormat(int depthbits, bool stencil); + +///////////// Graphics Context Member Functions ///////////////// + +GraphicsContext::GraphicsContext() { + D3DDevice = 0; + BackfaceCulling = true; +} + +/////////////////////////////////// +// ----==( SetDefaultStates )==---- +// (Public Member Function) +// Sets the default render states +/////////////////////////////////// +void GraphicsContext::SetDefaultStates() { + D3DDevice->SetRenderState(D3DRS_LOCALVIEWER, true); + SetPrimitiveType(TriangleList); + SetBackfaceCulling(true); + SetFrontFace(Clockwise); + SetLighting(true); + SetColorVertex(false); + SetAmbientLight(0.0f); + SetMipMapping(true); + SetTextureFiltering(BilinearFiltering); + SetBillboarding(false); + SetSpecular(true); + + Matrix4x4 ProjMat; + CreateProjectionMatrix(&ProjMat, QuarterPi, 1.33333333f, 1.0f, 10000.0f); + SetProjectionMatrix(ProjMat); +} + + +bool GraphicsContext::CreateVertexBuffer(uint32 VertexCount, UsageFlags usage, VertexBuffer **vb) const { + long hr = D3DDevice->CreateVertexBuffer(VertexCount * sizeof(Vertex), (dword)usage, VertexFormat, D3DPOOL_DEFAULT, vb); + return (hr == D3D_OK); +} + +bool GraphicsContext::CreateIndexBuffer(uint32 IndexCount, UsageFlags usage, IndexBuffer **ib) const { + long hr = D3DDevice->CreateIndexBuffer(IndexCount * IndexSize, (dword)usage, IndexFormat, D3DPOOL_DEFAULT, ib); + return (hr == D3D_OK); +} + +bool GraphicsContext::CreateSurface(uint32 Width, uint32 Height, Surface **surf) const { + long hr = D3DDevice->CreateImageSurface(Width, Height, ColorFormat, surf); + return (hr == D3D_OK); +} + +bool GraphicsContext::CreateDepthStencil(uint32 Width, uint32 Height, Surface **zsurf) const { + long hr = D3DDevice->CreateDepthStencilSurface(Width, Height, ZFormat, (D3DMULTISAMPLE_TYPE)AASamples, zsurf); + return (hr == D3D_OK); +} + +void GraphicsContext::Clear(dword color) const { + D3DDevice->Clear(0, 0, D3DCLEAR_TARGET, color, 1.0f, 0); +} + +void GraphicsContext::ClearZBuffer(float zval) const { + D3DDevice->Clear(0, 0, D3DCLEAR_ZBUFFER, 0, zval, 0); +} + +void GraphicsContext::ClearStencil(byte sval) const { + D3DDevice->Clear(0, 0, D3DCLEAR_STENCIL, 0, 1.0f, sval); +} + +void GraphicsContext::ClearZBufferStencil(float zval, byte sval) const { + D3DDevice->Clear(0, 0, D3DCLEAR_ZBUFFER | D3DCLEAR_STENCIL, 0, zval, sval); +} + +void GraphicsContext::Flip() const { + D3DDevice->Present(0, 0, 0, 0); +} + + +bool GraphicsContext::Draw(VertexBuffer *vb) { + D3DVERTEXBUFFER_DESC desc; + vb->GetDesc(&desc); + unsigned int verts = desc.Size / sizeof(Vertex); + + D3DDevice->SetStreamSource(0, vb, sizeof(Vertex)); + long res = D3DDevice->DrawPrimitive((D3DPRIMITIVETYPE)ptype, 0, verts / 3); + D3DDevice->SetStreamSource(0, 0, 0); + return res == D3D_OK; +} + +bool GraphicsContext::Draw(Vertex *varray, unsigned int VertexCount) { + long res = D3DDevice->DrawPrimitiveUP((D3DPRIMITIVETYPE)ptype, VertexCount / 3, varray, sizeof(Vertex)); + return res == D3D_OK; +} + +bool GraphicsContext::Draw(VertexBuffer *vb, IndexBuffer *ib) { + D3DVERTEXBUFFER_DESC vbdesc; + vb->GetDesc(&vbdesc); + unsigned int verts = vbdesc.Size / sizeof(Vertex); + + D3DINDEXBUFFER_DESC ibdesc; + ib->GetDesc(&ibdesc); + unsigned int indices = ibdesc.Size / sizeof(Index); + + D3DDevice->SetStreamSource(0, vb, sizeof(Vertex)); + D3DDevice->SetIndices(ib, 0); + long res = D3DDevice->DrawIndexedPrimitive((D3DPRIMITIVETYPE)ptype, 0, verts, 0, indices / 3); + D3DDevice->SetIndices(0, 0); + D3DDevice->SetStreamSource(0, 0, 0); + return res == D3D_OK; +} + +bool GraphicsContext::Draw(Vertex *varray, Index *iarray, unsigned int VertexCount, unsigned int IndexCount) { + long res = D3DDevice->DrawIndexedPrimitiveUP((D3DPRIMITIVETYPE)ptype, 0, VertexCount, IndexCount / 3, iarray, IndexFormat, varray, sizeof(Vertex)); + return res == D3D_OK; +} + +bool GraphicsContext::Draw(Vertex *varray, Triangle *triarray, unsigned int VertexCount, unsigned int TriCount) { + unsigned int IndexCount = TriCount * 3; + Index *iarray = new Index[IndexCount]; + for(dword i=0; iSetRenderState(D3DRS_CULLMODE, CullOrder); + } else { + D3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE); + } + BackfaceCulling = enable; +} + +void GraphicsContext::SetFrontFace(FaceOrder order) { + if(order == Clockwise) { + CullOrder = CounterClockwise; + } else { + CullOrder = Clockwise; + } + if(BackfaceCulling) SetBackfaceCulling(BackfaceCulling); +} + +void GraphicsContext::SetAutoNormalize(bool enable) { + D3DDevice->SetRenderState(D3DRS_NORMALIZENORMALS, enable); +} + +void GraphicsContext::SetBillboarding(bool enable) { + BillBoardingEnabled = enable; + if(enable) { + + Vector3 pos; + pos.Transform(WorldMat[0]); + + Matrix4x4 world; + world.Translate(pos.x, pos.y, pos.z); + Matrix4x4 BillBoardRot; + + Vector3 dir = ViewMat.Inverse().GetRowVector(2); + float yangle = dir.x > 0.0f ? -atanf(dir.z / dir.x) + HalfPi : -atanf(dir.z / dir.x) - HalfPi; + + BillBoardRot.Rotate(0.0f, yangle, 0.0f); + Vector3 xaxis = VECTOR3_I; + Vector3 normal = -VECTOR3_K; + xaxis.Transform(BillBoardRot); + normal.Transform(BillBoardRot); + + // find angle between quad normal and view direction + float xangle = acosf(DotProduct(normal, dir.Normalized())); + BillBoardRot.Rotate(xaxis, xangle); + + world = BillBoardRot * world; + + D3DDevice->SetTransform(D3DTS_WORLD, &world); + //D3DDevice->SetTransform(D3DTS_VIEW, &BillboardViewMatrix); + } else { + D3DDevice->SetTransform(D3DTS_WORLD, &WorldMat[0]); + //D3DDevice->SetTransform(D3DTS_VIEW, &ViewMat); + } +} + +void GraphicsContext::SetColorWrite(bool red, bool green, bool blue, bool alpha) { + dword channels = 0; + if(red) channels |= D3DCOLORWRITEENABLE_RED; + if(green) channels |= D3DCOLORWRITEENABLE_GREEN; + if(blue) channels |= D3DCOLORWRITEENABLE_BLUE; + if(alpha) channels |= D3DCOLORWRITEENABLE_ALPHA; + + D3DDevice->SetRenderState(D3DRS_COLORWRITEENABLE, channels); +} + +// blending states +void GraphicsContext::SetAlphaBlending(bool enable) { + D3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, enable); +} + +void GraphicsContext::SetBlendFunc(BlendingFactor src, BlendingFactor dest) { + D3DDevice->SetRenderState(D3DRS_SRCBLEND, src); + D3DDevice->SetRenderState(D3DRS_DESTBLEND, dest); +} + +// zbuffer states +void GraphicsContext::SetZBuffering(bool enable) { + D3DDevice->SetRenderState(D3DRS_ZENABLE, enable); +} + +void GraphicsContext::SetZWrite(bool enable) { + D3DDevice->SetRenderState(D3DRS_ZWRITEENABLE, enable); +} + +void GraphicsContext::SetZFunc(CmpFunc func) { + D3DDevice->SetRenderState(D3DRS_ZFUNC, func); +} + +// set stencil buffer states +void GraphicsContext::SetStencilBuffering(bool enable) { + D3DDevice->SetRenderState(D3DRS_STENCILENABLE, enable); +} + +void GraphicsContext::SetStencilPassOp(StencilOp sop) { + D3DDevice->SetRenderState(D3DRS_STENCILPASS, sop); +} + +void GraphicsContext::SetStencilFailOp(StencilOp sop) { + D3DDevice->SetRenderState(D3DRS_STENCILFAIL, sop); +} + +void GraphicsContext::SetStencilPassZFailOp(StencilOp sop) { + D3DDevice->SetRenderState(D3DRS_STENCILZFAIL, sop); +} + +void GraphicsContext::SetStencilOp(StencilOp Fail, StencilOp StencilPassZFail, StencilOp Pass) { + D3DDevice->SetRenderState(D3DRS_STENCILPASS, Pass); + D3DDevice->SetRenderState(D3DRS_STENCILFAIL, Fail); + D3DDevice->SetRenderState(D3DRS_STENCILZFAIL, StencilPassZFail); +} + +void GraphicsContext::SetStencilFunc(CmpFunc func) { + D3DDevice->SetRenderState(D3DRS_STENCILFUNC, func); +} + +void GraphicsContext::SetStencilReference(dword value) { + D3DDevice->SetRenderState(D3DRS_STENCILREF, value); +} + +// texture & material states + +void GraphicsContext::SetTextureFactor(dword factor) { + D3DDevice->SetRenderState(D3DRS_TEXTUREFACTOR, factor); +} + +void GraphicsContext::SetTextureFiltering(TextureFilteringType texfilter, int TextureStage) { + dword TexFilter, MipFilter; + + switch(texfilter) { + case PointSampling: + TexFilter = MipFilter = D3DTEXF_POINT; + break; + + case BilinearFiltering: + TexFilter = D3DTEXF_LINEAR; + MipFilter = D3DTEXF_POINT; + break; + + case TrilinearFiltering: + TexFilter = MipFilter = D3DTEXF_LINEAR; + break; + + case AnisotropicFiltering: + TexFilter = D3DTEXF_ANISOTROPIC; + MipFilter = D3DTEXF_LINEAR; + break; + + default: break; + } + + this->MipFilter = MipFilter; + + if(!MipMapEnabled) MipFilter = D3DTEXF_NONE; + + if(TextureStage == 0xa11) { + for(int i=0; iSetTextureStageState(i, D3DTSS_MINFILTER, TexFilter); + D3DDevice->SetTextureStageState(i, D3DTSS_MAGFILTER, TexFilter); + D3DDevice->SetTextureStageState(i, D3DTSS_MIPFILTER, MipFilter); + } + } else { + D3DDevice->SetTextureStageState(TextureStage, D3DTSS_MINFILTER, TexFilter); + D3DDevice->SetTextureStageState(TextureStage, D3DTSS_MAGFILTER, TexFilter); + D3DDevice->SetTextureStageState(TextureStage, D3DTSS_MIPFILTER, MipFilter); + } +} + +void GraphicsContext::SetTextureAddressing(TextureAddressing uaddr, TextureAddressing vaddr, int TextureStage) { + if(TextureStage == 0xa11) { + for(int i=0; iSetTextureStageState(i, D3DTSS_ADDRESSU, uaddr); + D3DDevice->SetTextureStageState(i, D3DTSS_ADDRESSV, vaddr); + } + } else { + D3DDevice->SetTextureStageState(TextureStage, D3DTSS_ADDRESSU, uaddr); + D3DDevice->SetTextureStageState(TextureStage, D3DTSS_ADDRESSV, vaddr); + } +} + +void GraphicsContext::SetTextureBorderColor(dword color, int TextureStage) { + if(TextureStage == 0xa11) { + for(int i=0; iSetTextureStageState(i, D3DTSS_BORDERCOLOR, color); + } + } else { + D3DDevice->SetTextureStageState(TextureStage, D3DTSS_BORDERCOLOR, color); + } +} + +void GraphicsContext::SetTexture(int index, Texture *tex) { + D3DDevice->SetTexture(index, tex); +} + +void GraphicsContext::SetMipMapping(bool enable, int TextureStage) { + MipMapEnabled = enable; + dword mip = (enable ? MipFilter : D3DTEXF_NONE); + + if(TextureStage == 0xa11) { + for(int i=0; iSetTextureStageState(i, D3DTSS_MIPFILTER, mip); + } + } else { + D3DDevice->SetTextureStageState(TextureStage, D3DTSS_MIPFILTER, mip); + } +} + +void GraphicsContext::SetMaterial(const Material &mat) { + D3DDevice->SetMaterial(&mat); +} + +static unsigned long TLVertexFVF = D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1; + +struct TLVertex { + Vector3 pos; + float rhw; + unsigned long color; + TexCoord tex; + + TLVertex() { + pos = Vector3(0.0f, 0.0f, 0.0f); + color = 0xffffffff; + tex.u = tex.v = 0.0f; + rhw = pos.z; + } + + TLVertex(const Vector3 &pos, const Color &col, float u=0.0f, float v=0.0f) { + this->pos = pos; + rhw = pos.z; + color = col.GetPacked32(); + tex.u = u; + tex.v = v; + } +}; + +void GraphicsContext::BlitTexture(const Texture *texture, RECT *rect, const Color &col) { + bool norect = rect ? false : true; + if(norect) { + rect = new RECT; + rect->left = rect->top = 0; + rect->right = ContextParams.x; + rect->bottom = ContextParams.y; + } + + SetVertexProgram(TLVertexFVF); + + TLVertex tlverts[4]; + tlverts[0] = TLVertex(Vector3((float)rect->right, (float)rect->top, 1.0f), col, 1.0f, 0.0f); + tlverts[1] = TLVertex(Vector3((float)rect->right, (float)rect->bottom, 1.0f), col, 1.0f, 1.0f); + tlverts[2] = TLVertex(Vector3((float)rect->left, (float)rect->top, 1.0f), col, 0.0f, 0.0f); + tlverts[3] = TLVertex(Vector3((float)rect->left, (float)rect->bottom, 1.0f), col, 0.0f, 1.0f); + + EnableTextureStage(0); + DisableTextureStage(1); + SetTexture(0, const_cast(texture)); + + SetZBuffering(false); + D3DDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, tlverts, sizeof(TLVertex)); + SetZBuffering(true); + + SetTexture(0, 0); + + SetVertexProgram(VertexFormat); + + if(norect) { + delete rect; + } +} + +// multitexturing interface +void GraphicsContext::EnableTextureStage(int stage) { + SetTextureStageColor(stage, TexBlendModulate, TexArgTexture, TexArgCurrent); +} + +void GraphicsContext::DisableTextureStage(int stage) { + D3DDevice->SetTextureStageState(stage, D3DTSS_COLOROP, D3DTOP_DISABLE); +} + +void GraphicsContext::SetTextureStageColor(int stage, TextureBlendFunction op, TextureBlendArgument arg1, TextureBlendArgument arg2, TextureBlendArgument arg3) { + D3DDevice->SetTextureStageState(stage, D3DTSS_COLOROP, op); + D3DDevice->SetTextureStageState(stage, D3DTSS_COLORARG1, arg1); + D3DDevice->SetTextureStageState(stage, D3DTSS_COLORARG2, arg2); + if(arg3) D3DDevice->SetTextureStageState(stage, D3DTSS_COLORARG0, arg3); +} + +void GraphicsContext::SetTextureStageAlpha(int stage, TextureBlendFunction op, TextureBlendArgument arg1, TextureBlendArgument arg2, TextureBlendArgument arg3) { + D3DDevice->SetTextureStageState(stage, D3DTSS_ALPHAOP, op); + D3DDevice->SetTextureStageState(stage, D3DTSS_ALPHAARG1, arg1); + D3DDevice->SetTextureStageState(stage, D3DTSS_ALPHAARG2, arg2); + if(arg3) D3DDevice->SetTextureStageState(stage, D3DTSS_ALPHAARG0, arg3); +} + +void GraphicsContext::SetTextureCoordIndex(int stage, int index) { + D3DDevice->SetTextureStageState(stage, D3DTSS_TEXCOORDINDEX, index); +} + +void GraphicsContext::SetTextureTransformState(int stage, TexTransformState TexXForm) { + D3DDevice->SetTextureStageState(stage, D3DTSS_TEXTURETRANSFORMFLAGS, TexXForm); +} + +// programmable pipeline interface +void GraphicsContext::SetVertexProgram(dword vs) { + D3DDevice->SetVertexShader(vs); +} + +void GraphicsContext::SetPixelProgram(dword ps) { + D3DDevice->SetPixelShader(ps); +} + +dword GraphicsContext::CreateVertexProgram(const char *fname) { + + // vertex format declaration + dword VertDecl[] = { + D3DVSD_STREAM(0), + D3DVSD_REG(D3DVSDE_POSITION, D3DVSDT_FLOAT3), + D3DVSD_REG(D3DVSDE_BLENDWEIGHT, D3DVSDT_FLOAT1), + D3DVSD_REG(D3DVSDE_BLENDINDICES, D3DVSDT_UBYTE4), + D3DVSD_REG(D3DVSDE_NORMAL, D3DVSDT_FLOAT3), + D3DVSD_REG(D3DVSDE_DIFFUSE, D3DVSDT_D3DCOLOR), + D3DVSD_REG(D3DVSDE_TEXCOORD0, D3DVSDT_FLOAT2), + D3DVSD_REG(D3DVSDE_TEXCOORD1, D3DVSDT_FLOAT2), + D3DVSD_REG(D3DVSDE_TEXCOORD2, D3DVSDT_FLOAT2), + D3DVSD_REG(D3DVSDE_TEXCOORD3, D3DVSDT_FLOAT2), + D3DVSD_END() + }; + + + ID3DXBuffer *code, *errors; + if(D3DXAssembleShaderFromFile(fname, 0, 0, &code, &errors) != D3D_OK) { + return 0xffffffff; + } + + dword vprog; + if(D3DDevice->CreateVertexShader(VertDecl, (dword*)code->GetBufferPointer(), &vprog, 0) != D3D_OK) { + // could not create hardware vertex shader, try driver emulation... + if(D3DDevice->CreateVertexShader(VertDecl, (dword*)code->GetBufferPointer(), &vprog, D3DUSAGE_SOFTWAREPROCESSING) != D3D_OK) { + throw EngineGeneralException("The system lacks required programmable vertex processing unit support"); + } + } + + return vprog; +} + +void GraphicsContext::DestroyVertexProgram(dword vprog) { + D3DDevice->DeleteVertexShader(vprog); +} + +void GraphicsContext::SetVertexProgramConstant(dword creg, float val) { + float block[4] = {val, 0.0f, 0.0f, 1.0f}; + D3DDevice->SetVertexShaderConstant(creg, &block, 1); +} + +void GraphicsContext::SetVertexProgramConstant(dword creg, const Vector3 &val) { + Vector4 vec(val); + D3DDevice->SetVertexShaderConstant(creg, &vec, 1); +} + +void GraphicsContext::SetVertexProgramConstant(dword creg, const Vector4 &val) { + D3DDevice->SetVertexShaderConstant(creg, &val, 1); +} + +void GraphicsContext::SetVertexProgramConstant(dword creg, const Color &val) { + D3DDevice->SetVertexShaderConstant(creg, &val, 1); +} + +void GraphicsContext::SetVertexProgramConstant(dword creg, const Matrix4x4 &val) { + D3DDevice->SetVertexShaderConstant(creg, &val, 4); +} + +void GraphicsContext::SetVertexProgramConstant(dword creg, const void *data, dword size) { + D3DDevice->SetVertexShaderConstant(creg, data, size); +} + + +// Lighting states +void GraphicsContext::SetLighting(bool enable) { + D3DDevice->SetRenderState(D3DRS_LIGHTING, enable); +} + +void GraphicsContext::SetColorVertex(bool enable) { + D3DDevice->SetRenderState(D3DRS_COLORVERTEX, enable); +} + +void GraphicsContext::SetAmbientLight(Color AmbientColor) { + D3DDevice->SetRenderState(D3DRS_AMBIENT, AmbientColor.GetPacked32()); +} + +void GraphicsContext::SetShadingMode(ShadeMode mode) { + D3DDevice->SetRenderState(D3DRS_SHADEMODE, mode); +} + +void GraphicsContext::SetSpecular(bool enable) { + D3DDevice->SetRenderState(D3DRS_SPECULARENABLE, enable); +} + +// transformation states +void GraphicsContext::SetWorldMatrix(const Matrix4x4 &WorldMat, unsigned int BlendIndex) { + assert(BlendIndex < 256); + this->WorldMat[BlendIndex] = WorldMat; + if(!BillBoardingEnabled) { + D3DDevice->SetTransform(D3DTS_WORLDMATRIX(BlendIndex), &WorldMat); + } else { + SetBillboarding(true); + } +} + +void GraphicsContext::SetViewMatrix(const Matrix4x4 &ViewMat) { + this->ViewMat = ViewMat; + if(!BillBoardingEnabled) { + D3DDevice->SetTransform(D3DTS_VIEW, &ViewMat); + } else { + SetBillboarding(true); + } +} + +void GraphicsContext::SetProjectionMatrix(const Matrix4x4 &ProjMat) { + this->ProjMat = ProjMat; + D3DDevice->SetTransform(D3DTS_PROJECTION, &ProjMat); +} + +void GraphicsContext::SetTextureMatrix(const Matrix4x4 &TexMat, unsigned int TextureStage) { + assert(TextureStage < 8); + this->TexMat[TextureStage] = TexMat; + D3DDevice->SetTransform((D3DTRANSFORMSTATETYPE)((int)D3DTS_TEXTURE0 + TextureStage), &TexMat); +} + +void GraphicsContext::SetViewport(unsigned int x, unsigned int y, unsigned int xsize, unsigned int ysize, float MinZ, float MaxZ) { + D3DVIEWPORT8 viewport; + viewport.X = x; + viewport.Y = y; + viewport.Width = xsize; + viewport.Height = ysize; + viewport.MinZ = MinZ; + viewport.MaxZ = MaxZ; + + D3DDevice->SetViewport(&viewport); +} + + +const Matrix4x4 &GraphicsContext::GetWorldMatrix(unsigned int BlendIndex) { + assert(BlendIndex < 256); + return WorldMat[BlendIndex]; +} + +const Matrix4x4 &GraphicsContext::GetViewMatrix() { + return ViewMat; +} + +const Matrix4x4 &GraphicsContext::GetProjectionMatrix() { + return ProjMat; +} + +const Matrix4x4 &GraphicsContext::GetTextureMatrix(unsigned int TextureStage) { + assert(TextureStage < 8); + return TexMat[TextureStage]; +} + + +// render target +void GraphicsContext::ResetRenderTarget() { + D3DDevice->SetRenderTarget(MainRenderTarget.ColorSurface, MainRenderTarget.DepthStencilSurface); +} + +void GraphicsContext::SetRenderTarget(RenderTarget &rtarg) { + D3DDevice->SetRenderTarget(rtarg.ColorSurface, rtarg.DepthStencilSurface); +} + +void GraphicsContext::SetRenderTarget(Texture *rtarg, Texture *ztarg) { + Surface *rendsurf, *zsurf = 0; + rtarg->GetSurfaceLevel(0, &rendsurf); + if(ztarg) ztarg->GetSurfaceLevel(0, &zsurf); + + D3DDevice->SetRenderTarget(rendsurf, zsurf); +} + +void GraphicsContext::SetRenderTarget(Texture *rtarg, Surface *ztarg) { + Surface *rendsurf; + rtarg->GetSurfaceLevel(0, &rendsurf); + + D3DDevice->SetRenderTarget(rendsurf, ztarg); +} + + +//////////////////////////////////////////////////// +//////////// Engine3D Member Functions ///////////// +//////////////////////////////////////////////////// + +Engine3D::Engine3D() { + + if(!(d3d = Direct3DCreate8(D3D_SDK_VERSION))) { + // actually this will never occur, if directx8 is not available in the system then + // the OS loader will hit the problem first when it'll try to load d3d8.dll that is + // linked through d3d8.lib, and complain for missing imports + throw EngineInitException("DirectX 8.1 is required to run this program"); + } + + RetrieveAdapterInfo(); +} + +Engine3D::~Engine3D() { + + GraphicsContexts.erase(GraphicsContexts.begin(), GraphicsContexts.end()); + + if(d3d) { + d3d->Release(); + d3d = 0; + } +} + + +//////////////////////////////////// +// ----==( RetrieveAdapterInfo )==---- +// (Private Member Function) +// Gets the list of adapters on the system and additional +// information for each adapter including its capabilities +//////////////////////////////////// +void Engine3D::RetrieveAdapterInfo() { + + // retrieve adapter list + AdapterCount = d3d->GetAdapterCount(); + adapters = new Adapter[AdapterCount]; + + for(unsigned int i=0; iGetAdapterIdentifier(i, D3DENUM_NO_WHQL_LEVEL, &AdapterIdentifier); + adapters[i].Description = new char[strlen(AdapterIdentifier.Description)+1]; + strcpy(adapters[i].Description, AdapterIdentifier.Description); + adapters[i].Driver = new char[strlen(AdapterIdentifier.Driver)+1]; + strcpy(adapters[i].Driver, AdapterIdentifier.Driver); + + adapters[i].DeviceGUID = AdapterIdentifier.DeviceIdentifier; + adapters[i].DeviceID = AdapterIdentifier.DeviceId; + adapters[i].DriverVersion = AdapterIdentifier.DriverVersion.QuadPart; + adapters[i].Revision = AdapterIdentifier.Revision; + adapters[i].SubSysID = AdapterIdentifier.SubSysId; + adapters[i].VentorID = AdapterIdentifier.VendorId; + + // get a list of display modes for this adapter + LinkedList dmlist; + adapters[i].ModeCount = d3d->GetAdapterModeCount(i); + for(unsigned int j=0; jEnumAdapterModes(i, j, &d3dmode); + mode.XRes = d3dmode.Width; + mode.YRes = d3dmode.Height; + mode.RefreshRate = d3dmode.RefreshRate; + mode.ColorFormat = GetColorDepthFromPixelFormat(d3dmode.Format); + + // check if this mode is supported from the HAL device + D3DFORMAT dispfmt = GetPixelFormatFromColorDepth(mode.ColorFormat, true); + if(d3d->CheckDeviceType(i, D3DDEVTYPE_HAL, dispfmt, d3dmode.Format, false) == D3D_OK) { + dmlist.PushBack(mode); + } + } + adapters[i].ModeCount = dmlist.Size(); // count of the modes that are supported through HW + adapters[i].Modes = new DisplayMode[adapters[i].ModeCount]; + ListNode *iter = dmlist.Begin(); + int j = 0; + while(iter) { + adapters[i].Modes[j++] = iter->data; + iter = iter->next; + } + + // get the device capabilities + d3d->GetDeviceCaps(i, D3DDEVTYPE_HAL, &adapters[i].Capabilities); + int vsver_major = D3DSHADER_VERSION_MAJOR(adapters[i].Capabilities.VertexShaderVersion); + int vsver_minor = D3DSHADER_VERSION_MINOR(adapters[i].Capabilities.VertexShaderVersion); + } +} + +//////////////////////////////////// +// ----==( CreateModesList )==---- +// (Private Member Function) +// Creates a linked list of the available modes +// of a single adapter for further processing +//////////////////////////////////// +LinkedList *Engine3D::CreateModesList(unsigned int AdapterID) const { + + if(AdapterID >= AdapterCount) return 0; + + LinkedList *newlist = new LinkedList; + for(unsigned int i=0; iPushBack(adapters[AdapterID].Modes[i]); + } + return newlist; +} + +//////////////////////////////////// +// ----==( NarrowModesList )==---- +// (Private Member Function) +// Narrows down the list of available modes +// to those that have the requested item +//////////////////////////////////// +void Engine3D::NarrowModesList(LinkedList *list, DisplayModeItem item, long value, long value2) const { + + ListNode *iter = list->Begin(); + while(iter) { + switch(item) { + case ModeItemSize: + if(iter->data.XRes != value || iter->data.YRes != value2) { + iter = list->Erase(iter); + } else { + if(iter) iter = iter->next; + } + break; + + case ModeItemBpp: + if(iter->data.ColorFormat.bpp != value) { + iter = list->Erase(iter); + } else { + if(iter) iter = iter->next; + } + break; + + case ModeItemAlpha: + if(!iter->data.ColorFormat.alpha && value) { + iter = list->Erase(iter); + } else { + if(iter) iter = iter->next; + } + break; + + case ModeItemRefresh: + if(iter->data.RefreshRate != value) { + iter = list->Erase(iter); + } else { + if(iter) iter = iter->next; + } + break; + + default: break; + } + } +} + +/////////////////////////////////// +// ----==( ChooseBestMode )==---- +// (Private Member Function) +// given a (ideally) narrowed down modes list +// choose the best possible among them +/////////////////////////////////// +DisplayMode Engine3D::ChooseBestMode(LinkedList *modes) const { + + DisplayMode dmode; + memset(&dmode, 0, sizeof(DisplayMode)); + + if(!modes || !modes->Size()) return dmode; + + // find the highest resolution and get only the modes with that resolution + ListNode *iter = modes->Begin(); + unsigned int maxx = 0, maxy = 0; + while(iter) { + if(iter->data.XRes > maxx) maxx = iter->data.XRes; + if(iter->data.YRes > maxy) maxy = iter->data.YRes; + iter = iter->next; + } + NarrowModesList(modes, ModeItemSize, maxx, maxy); + + // find the modes with alpha if any + iter = modes->Begin(); + bool AnyWithAlpha = false; + while(iter) { + if(iter->data.ColorFormat.alpha) { + AnyWithAlpha = true; + break; + } + iter = iter->next; + } + if(AnyWithAlpha) NarrowModesList(modes, ModeItemAlpha, 1); + + // find the modes with the highest bpp + iter = modes->Begin(); + int maxbpp = 0; + while(iter) { + if(iter->data.ColorFormat.bpp > maxbpp) maxbpp = iter->data.ColorFormat.bpp; + iter = iter->next; + } + NarrowModesList(modes, ModeItemBpp, maxbpp); + + // find the modes with the highest refresh rate + iter = modes->Begin(); + unsigned int maxrefresh = 0; + while(iter) { + if(iter->data.RefreshRate > maxrefresh) maxrefresh = iter->data.RefreshRate; + iter = iter->next; + } + NarrowModesList(modes, ModeItemRefresh, maxrefresh); + + // if there is more than one mode left, then there is a problem :) + assert(modes->Size() == 1); + + dmode = modes->Begin()->data; + return dmode; +} + +////////////////////////////////////////// +// ----==( CreateGraphicsContext )==---- +// (Public Member Function) +// Creates a graphics context with the specified parameters +////////////////////////////////////////// +GraphicsContext *Engine3D::CreateGraphicsContext(HWND WindowHandle, unsigned int AdapterID, ContextInitParameters *GCParams) { + + if(AdapterID >= AdapterCount) return 0; + + // check adapter's Transformation & Lighting capability + bool hwtnl = (bool)(adapters[AdapterID].Capabilities.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT); + if(!(GCParams->DontCareFlags & GCPDONTCARE_TNL)) { // bit not set, we want specific TnL mode + if(hwtnl != GCParams->HardwareTnL && !hwtnl) return 0; // we asked for hw tnl and is not available + // else either we asked for sw and found hw so we continue with our initial sw setting + // or we found exactly what we asked, so we still continue with our choice + } else { + GCParams->HardwareTnL = hwtnl; // if we don't care use what we have available + } + + // decide which mode to use + LinkedList *modes = CreateModesList(AdapterID); + NarrowModesList(modes, ModeItemSize, GCParams->x, GCParams->y); + + if(!(GCParams->DontCareFlags & GCPDONTCARE_BPP)) { // we want specific bpp + NarrowModesList(modes, ModeItemBpp, GCParams->bpp); + } + + if(!(GCParams->DontCareFlags & GCPDONTCARE_ALPHA)) { // alpha setting exactly as asked + NarrowModesList(modes, ModeItemAlpha, (long)GCParams->AlphaChannel); + } + + if(!(GCParams->DontCareFlags & GCPDONTCARE_REFRESH)) { // specific refresh rate + NarrowModesList(modes, ModeItemRefresh, GCParams->RefreshRate); + } + + if(!modes->Size()) { // didn't find any mode with the properties that we asked + throw EngineInitException("Requested video mode parameters not available"); + } + + DisplayMode mode = ChooseBestMode(modes); + delete modes; // delete the list of modes + + D3DFORMAT PixelFormat = GetPixelFormatFromColorDepth(mode.ColorFormat); + + // find out if we have the requested zbuffer format avaialble + if(!GCParams->DepthBits) GCParams->DepthBits = 32; // not specified, trying highest possible first + D3DFORMAT zfmt = GetDepthStencilFormat(GCParams->DepthBits, true); + + bool res = !(bool)d3d->CheckDeviceFormat(AdapterID, (D3DDEVTYPE)GCParams->DevType, PixelFormat, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, zfmt); + if(!res) { // try a format without stencil + zfmt = GetDepthStencilFormat(GCParams->DepthBits, false); + res = !(bool)d3d->CheckDeviceFormat(AdapterID, (D3DDEVTYPE)GCParams->DevType, PixelFormat, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, zfmt); + } + + if(!res) { // didn't find requested zbuffer even with no stencil + // if we asked for specific zformat and didn't find it or if the zbuffer that + // we failed to set was 16bits and can't go less, bail out + if(!(GCParams->DontCareFlags & GCPDONTCARE_DEPTH) || GCParams->DepthBits == 16) return 0; + + // try to set a smaller zbuffer with stencil + GCParams->DepthBits = 16; + zfmt = GetDepthStencilFormat(GCParams->DepthBits, true); + res = !(bool)d3d->CheckDeviceFormat(AdapterID, (D3DDEVTYPE)GCParams->DevType, PixelFormat, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, zfmt); + if(!res) { // try a format without stencil + zfmt = GetDepthStencilFormat(GCParams->DepthBits, false); + res = !(bool)d3d->CheckDeviceFormat(AdapterID, (D3DDEVTYPE)GCParams->DevType, PixelFormat, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, zfmt); + } + + if(!res) throw EngineInitException("Requested ZBuffer depth not available"); + } + + int AASamples = 0; + if(GCParams->Antialiasing) { + if(GCParams->BestAA) { + // find the best supported AA mode + for(AASamples=16; AASamples > 0; AASamples--) { + long result = d3d->CheckDeviceMultiSampleType(AdapterID, (D3DDEVTYPE)GCParams->DevType, PixelFormat, !GCParams->FullScreen, (D3DMULTISAMPLE_TYPE)AASamples); + if(result == D3D_OK) break; + } + } else { + // check for cheap AA + AASamples = 2; + long result = d3d->CheckDeviceMultiSampleType(AdapterID, (D3DDEVTYPE)GCParams->DevType, PixelFormat, !GCParams->FullScreen, (D3DMULTISAMPLE_TYPE)AASamples); + if(result != D3D_OK) AASamples = 0; + } + + if(!AASamples && !(GCParams->DontCareFlags & GCPDONTCARE_AA)) { + throw EngineInitException("Requested Antialiasing mode not available"); + } + } + + D3DFORMAT FinalColorFormat; + if(GCParams->FullScreen) { + FinalColorFormat = GetPixelFormatFromColorDepth(mode.ColorFormat); + } else { + D3DDISPLAYMODE CurrentMode; + d3d->GetAdapterDisplayMode(AdapterID, &CurrentMode); + FinalColorFormat = CurrentMode.Format; + } + + // if everything went well, now we can set that mode + D3DPRESENT_PARAMETERS d3dppar; + d3dppar.BackBufferWidth = GCParams->x; + d3dppar.BackBufferHeight = GCParams->y; + d3dppar.BackBufferFormat = FinalColorFormat; + d3dppar.BackBufferCount = (unsigned int)GCParams->Buffers; + d3dppar.MultiSampleType = (D3DMULTISAMPLE_TYPE)AASamples; + d3dppar.SwapEffect = D3DSWAPEFFECT_DISCARD; + d3dppar.hDeviceWindow = WindowHandle; + d3dppar.Windowed = !GCParams->FullScreen; + d3dppar.EnableAutoDepthStencil = true; + d3dppar.AutoDepthStencilFormat = zfmt; + d3dppar.Flags = 0; + d3dppar.FullScreen_RefreshRateInHz = (GCParams->FullScreen) ? mode.RefreshRate : 0; + if(GCParams->FullScreen) { + d3dppar.FullScreen_PresentationInterval = (GCParams->VSync) ? D3DPRESENT_INTERVAL_ONE : D3DPRESENT_INTERVAL_IMMEDIATE; + } else { + d3dppar.FullScreen_PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT; + } + + // create the rendering context + GraphicsContext *gc = new GraphicsContext; + + TnLMode tnlmode = (GCParams->HardwareTnL) ? HardwareTnL : SoftwareTnL; + + long result = d3d->CreateDevice(AdapterID, (D3DDEVTYPE)GCParams->DevType, WindowHandle, tnlmode, &d3dppar, &gc->D3DDevice); + if(result != D3D_OK) { + if(d3dppar.BackBufferCount != GCParams->Buffers) { + if((GCParams->DontCareFlags & GCPDONTCARE_BUFFERS)) { + result = d3d->CreateDevice(AdapterID, (D3DDEVTYPE)GCParams->DevType, WindowHandle, tnlmode, &d3dppar, &gc->D3DDevice); + } else { + throw EngineInitException("Could not create Direct3D device"); + } + } + } + + if(result != D3D_OK) { + throw EngineInitException("Could not create Direct3D device"); + } + + gc->WindowHandle = WindowHandle; + gc->D3DDevice->GetRenderTarget(&gc->MainRenderTarget.ColorSurface); + gc->D3DDevice->GetDepthStencilSurface(&gc->MainRenderTarget.DepthStencilSurface); + gc->ContextParams = *GCParams; + gc->ZFormat = zfmt; + gc->AASamples = AASamples; + gc->ColorFormat = FinalColorFormat; + gc->MaxTextureStages = adapters[AdapterID].Capabilities.MaxSimultaneousTextures; + gc->texman = new TextureManager(gc); + + gc->SetDefaultStates(); + + GraphicsContexts.push_back(gc); + + return gc; +} + +////////////////////////////////////////// +// ----==( CreateGraphicsContext )==---- +// (Public Member Function) +// Creates a graphics context with the specified parameters +// Light version, basic info passed, fills in the rest +////////////////////////////////////////// +GraphicsContext *Engine3D::CreateGraphicsContext(HWND WindowHandle, int x, int y, int bpp, word flags) { + + ContextInitParameters gcp; + gcp.x = x; + gcp.y = y; + gcp.bpp = bpp; + gcp.DepthBits = 24; + gcp.DevType = DeviceHardware; + gcp.FullScreen = (flags & GCCREATE_FULLSCREEN) ? true : false; + gcp.HardwareTnL = true; + gcp.RefreshRate = 75; + gcp.Antialiasing = false; + gcp.Buffers = DoubleBuffering; + gcp.VSync = false; + gcp.DontCareFlags = GCPDONTCARE_DEPTH | GCPDONTCARE_REFRESH | GCPDONTCARE_ALPHA | GCPDONTCARE_VSYNC; + + return CreateGraphicsContext(WindowHandle, D3DADAPTER_DEFAULT, &gcp); +} + +using std::string; +using std::getline; + +string GetValue(string line) { + int nexttoken = (int)line.find("=") + 1; + while(line[++nexttoken] == ' '); + int tokenend = (int)line.find_first_of(" \n\r\t"); + return line.substr(nexttoken, tokenend - nexttoken); +} + +ContextInitParameters Engine3D::LoadContextParamsConfigFile(const char *cfgfilename) { + ContextInitParameters cip; + memset(&cip, 0, sizeof(ContextInitParameters)); + + std::ifstream file(cfgfilename); + if(!file.is_open()) throw EngineInitException("Could not open configuration file"); + + string line; + getline(file, line); + while(!file.eof()) { + if(line[0] != ';' && line[0] != '\n' && line[0] != '\r' && line[0] != ' ') { + int tokenend = (int)line.find(" "); + string token = line.substr(0, tokenend); + + if(token == "fullscreen") { + string value = GetValue(line); + cip.FullScreen = (value == "true") ? true : false; + } else if(token == "resolution") { + string value = GetValue(line); + int x = (int)value.find("x"); + cip.x = atoi(value.substr(0, x).c_str()); + cip.y = atoi(value.substr(x+1, value.size()).c_str()); + } else if(token == "bpp") { + cip.bpp = atoi(GetValue(line).c_str()); + } else if(token == "zbufferdepth") { + cip.DepthBits = atoi(GetValue(line).c_str()); + } else if(token == "device") { + cip.DevType = (GetValue(line) == "ref") ? DeviceReference : DeviceHardware; + } else if(token == "tnl") { + cip.HardwareTnL = (GetValue(line) == "false") ? false : true; + } else if(token == "refresh") { + cip.RefreshRate = atoi(GetValue(line).c_str()); + } else if(token == "antialiasing") { + string value = GetValue(line); + cip.Antialiasing = (value == "none") ? false : true; + if(cip.Antialiasing) { + cip.BestAA = (value == "speed" || value == "low") ? false : true; + } + } else if(token == "flipchain") { + cip.Buffers = (GetValue(line) == "triplebuffering") ? TripleBuffering : DoubleBuffering; + } else if(token == "vsync") { + cip.VSync = (GetValue(line) == "true") ? true : false; + } else if(token == "dontcareabout") { + cip.DontCareFlags = 0; + string flags = GetValue(line); + string part; + while(1) { + int begin = (int)flags.find_first_not_of(", "); + int end = (int)flags.find(",", begin) - begin; + part = flags.substr(begin, end); + //part = flags.substr(0, flags.find(","));// \n\r\t")); + if(part.empty()) break; + if(part == "bpp") cip.DontCareFlags |= GCPDONTCARE_BPP; + if(part == "refresh") cip.DontCareFlags |= GCPDONTCARE_REFRESH; + if(part == "alpha") cip.DontCareFlags |= GCPDONTCARE_ALPHA; + if(part == "zbufferdepth") cip.DontCareFlags |= GCPDONTCARE_DEPTH; + if(part == "tnl") cip.DontCareFlags |= GCPDONTCARE_TNL; + if(part == "flipchain") cip.DontCareFlags |= GCPDONTCARE_BUFFERS; + if(part == "aamode") cip.DontCareFlags |= GCPDONTCARE_AA; + if(part == "vsync") cip.DontCareFlags |= GCPDONTCARE_VSYNC; + int temp = (int)flags.find_first_of(",\n\r"); + if(temp == string::npos) break; + flags.erase(0, temp+1); + } + } + + } + + getline(file, line); + } + + return cip; +} + +void Engine3D::DestroyGraphicsContext(GraphicsContext *gc) { + gc->D3DDevice->Release(); +} + +int Engine3D::GetAdapterCount() const { + return AdapterCount; +} + +const Adapter *Engine3D::GetAdapterInfo(int adapter) const { + return &adapters[adapter]; +} + + +////////////////////////////////////////////////////////////////////////////// +// helper functions + +bool Lock(VertexBuffer *vb, Vertex **data) { + D3DVERTEXBUFFER_DESC desc; + vb->GetDesc(&desc); + dword flags = (desc.Usage & D3DUSAGE_DYNAMIC) ? D3DLOCK_DISCARD | D3DLOCK_NOOVERWRITE : 0; + + return (vb->Lock(0, 0, (byte**)data, flags) == D3D_OK); +} + +bool Lock(IndexBuffer *ib, Index **data) { + D3DINDEXBUFFER_DESC desc; + ib->GetDesc(&desc); + dword flags = (desc.Usage & D3DUSAGE_DYNAMIC) ? D3DLOCK_DISCARD | D3DLOCK_NOOVERWRITE : 0; + + return (ib->Lock(0, 0, (byte**)data, flags) == D3D_OK); +} + +void Unlock(VertexBuffer *vb) { + vb->Unlock(); +} + +void Unlock(IndexBuffer *ib) { + ib->Unlock(); +} + + +void CreateProjectionMatrix(Matrix4x4 *mat, float yFOV, float Aspect, float NearClip, float FarClip) { + + float h, w, Q; + float xFOV = yFOV * Aspect; + + w = (float)(1.0f/tan(xFOV*0.5f)); // 1/tan(x) == cot(x) + h = (float)(1.0f/tan(yFOV*0.5f)); // 1/tan(x) == cot(x) + Q = FarClip / (FarClip - NearClip); + + /* Projection Matrix + [ w 0.0f 0.0f 0.0f] + |0.0f h 0.0f 0.0f| + |0.0f 0.0f Q 1.0f| + [0.0f 0.0f -Q*NearClip 0.0f] + */ + + mat->ResetIdentity(); + mat->m[0][0] = w; + mat->m[1][1] = h; + mat->m[2][2] = Q; + mat->m[3][2] = -Q*NearClip; + mat->m[2][3] = 1.0f; +} + +dword PackVector(const Vector3 &vec, float Height) { + dword r = (dword)(127.0f * vec.x + 128.0f); + dword g = (dword)(127.0f * vec.y + 128.0f); + dword b = (dword)(127.0f * vec.z + 128.0f); + dword a = (dword)(255.0f * Height); + + return( (a<<24L) + (r<<16L) + (g<<8L) + (b<<0L) ); +} + +void NormalMapFromHeightField(Texture *tex) { + + // Lock the texture + D3DLOCKED_RECT d3dlr; + D3DSURFACE_DESC d3dsd; + + int LevelCount = tex->GetLevelCount(); + for(int i=0; iGetLevelDesc(i, &d3dsd); + tex->LockRect(i, &d3dlr, 0, 0); + DWORD* pPixel = (DWORD*)d3dlr.pBits; + + // For each pixel, generate a vector normal that represents the change + // in thea height field at that pixel + for( DWORD j=0; j> 16) / 255.0f; + float fHeight10 = (float)((color10 & 0x00ff0000) >> 16) / 255.0f; + float fHeight01 = (float)((color01 & 0x00ff0000) >> 16) / 255.0f; + + Vector3 vPoint00(i+0.0f, j+0.0f, fHeight00); + Vector3 vPoint10(i+1.0f, j+0.0f, fHeight10); + Vector3 vPoint01(i+0.0f, j+1.0f, fHeight01); + Vector3 v10 = vPoint10 - vPoint00; + Vector3 v01 = vPoint01 - vPoint00; + + Vector3 Normal = v10.CrossProduct(v01); + Normal.Normalize(); + + // Store the normal as an RGBA value in the normal map + *pPixel++ = PackVector(Normal, fHeight00); + } + } + tex->UnlockRect(i); + } +} + +void UpdateMipmapChain(Texture *tex) { + D3DXFilterTexture(tex, 0, 0, D3DX_FILTER_BOX); +} + +dword AddEdge(Edge *edges, dword EdgeCount, const Edge &newedge) { + // remove internal edges + for(dword i=0; iGetType() == LTDir ? l->GetDirection() : p - l->GetPosition()) +inline Vector3 GetLightDir(const Light *light, const Vector3 &pos, const Matrix4x4 &mat) { + if(light->GetType() == LTDir) { + return light->GetDirection(); + } else { + Vector3 lpos = light->GetPosition(); + lpos.Transform(mat); + return pos - lpos; + } + return Vector3(); +} + + +////////////////////////////////////////// +// ----==( CreateShadowVolume )==---- +// (Helper Function) +// Creates a graphics context with the specified parameters +// Light version, basic info passed, fills in the rest +////////////////////////////////////////// + +TriMesh *CreateShadowVolume(const TriMesh &mesh, const Light *light, const Matrix4x4 &MeshXForm, bool WorldCoords) { + + // transform light into object's local coordinate system + //const_cast(light)->Transform(MeshXForm.Inverse()); + Matrix4x4 InvXForm = MeshXForm.Inverse(); + + const Vertex *varray = mesh.GetVertexArray(); + const Triangle *triarray = mesh.GetTriangleArray(); + + dword VertexCount = mesh.GetVertexCount(); + dword TriangleCount = mesh.GetTriangleCount(); + + Edge *edges = new Edge[TriangleCount]; + dword EdgeCount = 0; + + // first find the contour edges + + for(dword i=0; i= 0.0f) { + EdgeCount = AddEdge(edges, EdgeCount, Edge(triarray[i].vertices[0], triarray[i].vertices[1])); + EdgeCount = AddEdge(edges, EdgeCount, Edge(triarray[i].vertices[1], triarray[i].vertices[2])); + EdgeCount = AddEdge(edges, EdgeCount, Edge(triarray[i].vertices[2], triarray[i].vertices[0])); + } + } + + // now extract the contour edges to build the shadow volume boundrary + const float ExtrudeMagnitude = 100000.0f; + Vertex *ShadowVertices = new Vertex[EdgeCount * 6]; + + for(dword i=0; iSetData(ShadowVertices, 0, EdgeCount * 6, 0); + + delete [] ShadowVertices; + delete [] edges; + + //const_cast(light)->Transform(MeshXForm); // return light to world coordinate system + + return ShadowMesh; +} + + +///////////// local ////////////// + +ColorDepth GetColorDepthFromPixelFormat(D3DFORMAT fmt) { + switch(fmt) { + case D3DFMT_R8G8B8: return ColorDepth(24, 24, 0); + case D3DFMT_A8R8G8B8: return ColorDepth(32, 24, 8); + case D3DFMT_X8R8G8B8: return ColorDepth(32, 24, 0); + case D3DFMT_R5G6B5: return ColorDepth(16, 16, 0); + case D3DFMT_X1R5G5B5: return ColorDepth(16, 15, 0); + case D3DFMT_A1R5G5B5: return ColorDepth(16, 15, 1); + case D3DFMT_P8: return ColorDepth(8, 8, 0); + default: return ColorDepth(0, 0, 0); + } +} + +bool operator ==(const ColorDepth &lhs, const ColorDepth &rhs) { + return (lhs.bpp == rhs.bpp && lhs.colorbits == rhs.colorbits && lhs.alpha == rhs.alpha); +} + +D3DFORMAT GetPixelFormatFromColorDepth(ColorDepth cd, bool noalpha) { + if(cd == ColorDepth(24, 24, 0)) return D3DFMT_R8G8B8; + if(cd == ColorDepth(32, 24, 8)) return noalpha ? D3DFMT_X8R8G8B8 : D3DFMT_A8R8G8B8; + if(cd == ColorDepth(32, 24, 0)) return D3DFMT_X8R8G8B8; + if(cd == ColorDepth(16, 16, 0)) return D3DFMT_R5G6B5; + if(cd == ColorDepth(16, 15, 0)) return D3DFMT_X1R5G5B5; + if(cd == ColorDepth(16, 15, 1)) return noalpha ? D3DFMT_X1R5G5B5 : D3DFMT_A1R5G5B5; + if(cd == ColorDepth(8, 8, 0)) return D3DFMT_P8; + return (D3DFORMAT)0; +} + + +D3DFORMAT GetDepthStencilFormat(int depthbits, bool stencil) { + switch(depthbits) { + case 32: + return (stencil) ? D3DFMT_D24S8 : D3DFMT_D32; + break; + + case 24: + return (stencil) ? D3DFMT_D24S8 : D3DFMT_D24X8; + break; + + case 16: + return (stencil) ? D3DFMT_D15S1 : D3DFMT_D16; + break; + + default: + break; + } + + return (D3DFORMAT)0; +} \ No newline at end of file diff -r 000000000000 -r 1cffe3409164 src/3deng/3dengine.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/3deng/3dengine.h Thu Oct 23 01:46:07 2014 +0300 @@ -0,0 +1,391 @@ +#ifndef _3DENGINE_H_ +#define _3DENGINE_H_ + +// standard includes +#include +// system includes +#include "d3d8.h" +// includes from my codebase +#include "typedefs.h" +#include "linkedlist.h" +#include "color.h" +// 3d engine includes +#include "n3dmath.h" +#include "switches.h" +#include "3dengtypes.h" +#include "material.h" +#include "textureman.h" +#include "3dgeom.h" + +enum DeviceType {DeviceHardware = D3DDEVTYPE_HAL, DeviceReference = D3DDEVTYPE_REF}; +enum TnLMode {HardwareTnL = D3DCREATE_HARDWARE_VERTEXPROCESSING, SoftwareTnL = D3DCREATE_SOFTWARE_VERTEXPROCESSING}; +enum BufferChainMode {DoubleBuffering = 1, TripleBuffering = 2}; +enum UsageFlags {UsageStatic = 0, UsageDynamic = D3DUSAGE_DYNAMIC}; +enum ShadeMode {FlatShading = D3DSHADE_FLAT, GouraudShading = D3DSHADE_GOURAUD}; +enum FaceOrder {Clockwise = D3DCULL_CW, CounterClockwise = D3DCULL_CCW}; + +enum PhongComponent {Ambient, Diffuse, Specular}; + +enum PrimitiveType { + TriangleList = D3DPT_TRIANGLELIST, + TriangleStrip = D3DPT_TRIANGLESTRIP, + TriangleFan = D3DPT_TRIANGLEFAN, + LineList = D3DPT_LINELIST, + LineStrip = D3DPT_LINESTRIP, + PointList = D3DPT_POINTLIST +}; + +enum BlendingFactor { + BLEND_ZERO = D3DBLEND_ZERO, + BLEND_ONE = D3DBLEND_ONE, + BLEND_SRCCOLOR = D3DBLEND_SRCCOLOR, + BLEND_INVSRCCOLOR = D3DBLEND_INVSRCCOLOR, + BLEND_SRCALPHA = D3DBLEND_SRCALPHA, + BLEND_INVSRCALPHA = D3DBLEND_INVSRCALPHA, + BLEND_DESTCOLOR = D3DBLEND_DESTCOLOR, + BLEND_INVDESTCOLOR = D3DBLEND_INVDESTCOLOR, + BLEND_DESTALPHA = D3DBLEND_DESTALPHA, + BLEND_INVDESTALPHA = D3DBLEND_INVDESTALPHA, + BLEND_SRCALPHASAT = D3DBLEND_SRCALPHASAT +}; + +enum CmpFunc { + CMP_NEVER = D3DCMP_NEVER, + CMP_LESS = D3DCMP_LESS, + CMP_EQUAL = D3DCMP_EQUAL, + CMP_LEQUAL = D3DCMP_LESSEQUAL, + CMP_GREATER = D3DCMP_GREATER, + CMP_NOTEQUAL = D3DCMP_NOTEQUAL, + CMP_GEQUAL = D3DCMP_GREATEREQUAL, + CMP_ALWAYS = D3DCMP_ALWAYS +}; + +enum StencilOp { + SOP_KEEP = D3DSTENCILOP_KEEP, + SOP_ZERO = D3DSTENCILOP_ZERO, + SOP_REPLACE = D3DSTENCILOP_REPLACE, + SOP_INCSAT = D3DSTENCILOP_INCRSAT, + SOP_DECSAT = D3DSTENCILOP_DECRSAT, + SOP_INVERT = D3DSTENCILOP_INVERT, + SOP_INC = D3DSTENCILOP_INCR, + SOP_DEC = D3DSTENCILOP_DECR +}; + +enum TextureBlendFunction { + TexBlendSelectArg1 = D3DTOP_SELECTARG1, // S[rgba] = Arg1 + TexBlendSelectArg2 = D3DTOP_SELECTARG2, // S[rgba] = Arg2 + TexBlendAdd = D3DTOP_ADD, // S[rgba] = Arg1 + Arg2 + TexBlendAddSigned = D3DTOP_ADDSIGNED, // S[rgba] = Arg1 + Arg2 - 0.5 + TexBlendAddSigned2x = D3DTOP_ADDSIGNED2X, // S[rgba] = (Arg1 + Arg2 - 0.5) << 1 + TexBlendSubtract = D3DTOP_SUBTRACT, // S[rgba] = Arg1 - Arg2 + TexBlendAddSmooth = D3DTOP_ADDSMOOTH, // S[rgba] = (Arg1 + Arg2) - (Arg1 * Arg2) + TexBlendModulate = D3DTOP_MODULATE, // S[rgba] = Arg1 * Arg2 + TexBlendModulate2x = D3DTOP_MODULATE2X, // S[rgba] = (Arg1 * Arg2) << 1 + TexBlendModulate4x = D3DTOP_MODULATE4X, // S[rgba] = (Arg1 * Arg2) << 2 + TexBlendVertexAlpha = D3DTOP_BLENDDIFFUSEALPHA, // S[rgba] = Arg1*Alpha + Arg2*(1-Alpha) + TexBlendTextureAlpha = D3DTOP_BLENDTEXTUREALPHA, // S[rgba] = Arg1*Alpha + Arg2*(1-Alpha) + TexBlendFactorAlpha = D3DTOP_BLENDFACTORALPHA, // S[rgba] = Arg1*Alpha + Arg2*(1-Alpha) + TexBlendPrevAlpha = D3DTOP_BLENDFACTORALPHA, // S[rgba] = Arg1*Alpha + Arg2*(1-Alpha) + TexBlendPreMulAlpha = D3DTOP_BLENDTEXTUREALPHAPM, // S[rgba] = Arg1 + Arg2*(1-Alpha) + TexBlendPreModulate = D3DTOP_PREMODULATE, + TexBlendModAlphaAddColor = D3DTOP_MODULATEALPHA_ADDCOLOR,// S[rgba] = Arg1[rgb] + Arg1[a] * Arg2[rgb] + TexBlendModulateAddAlpha = D3DTOP_MODULATECOLOR_ADDALPHA,// S[rgba] = Arg1[rgb] * Arg2[rgb] + Arg1[a] + TexBlendModInvAlphaAddColor = D3DTOP_MODULATEINVALPHA_ADDCOLOR, // S[rgba] = Arg1[rgb] + (1-Arg1[a]) * Arg2[rgb] + TexBlendModulateInvAddAlpha = D3DTOP_MODULATEINVCOLOR_ADDALPHA, // S[rgba] = (1-Arg1[rgb]) * Arg2[rgb] + Arg1[a] + TexBlendBumpEnv = D3DTOP_BUMPENVMAP, // bump mapping with next stage's env map + TexBlendBumpEnvLuminance = D3DTOP_BUMPENVMAPLUMINANCE, // bump mapping with next stage's env map with luminance + TexBlendDotProduct = D3DTOP_DOTPRODUCT3, // S[rgba] = Arg1[rgb] (dot) Arg2[rgb] + TexBlendMultiplyAdd = D3DTOP_MULTIPLYADD, // S[rgba] = Arg1 + Arg2 * Arg3 + TexBlendLerp = D3DTOP_LERP // S[rgba] = Arg2 + (Arg3 - Arg2) * Arg1 +}; + +enum TextureBlendArgument { + TexArgNone = 0, // valid only for arg3 + TexArgCurrent = D3DTA_CURRENT, // the color from the previous stage output (diffuse for 1st) + TexArgDiffuseColor = D3DTA_DIFFUSE, // the diffuse interpolated color + TexArgSpecularColor = D3DTA_SPECULAR, // the specular interpolated color + TexArgTexture = D3DTA_TEXTURE, // the texture bound to this stage + TexArgFactor = D3DTA_TFACTOR, // a user defined factor + TexArgTemp = D3DTA_TEMP // temp register +}; + +enum TextureFilteringType { + PointSampling, + BilinearFiltering, + TrilinearFiltering, + AnisotropicFiltering +}; + +enum TextureAddressing { + TexAddrWrap = D3DTADDRESS_WRAP, + TexAddrMirror = D3DTADDRESS_MIRROR, + TexAddrClamp = D3DTADDRESS_CLAMP, + TexAddrBorder = D3DTADDRESS_BORDER, + TexAddrMirrorOnce = D3DTADDRESS_MIRRORONCE +}; + +enum TexTransformState { + TexTransformDisable = D3DTTFF_DISABLE, + TexTransform1D = D3DTTFF_COUNT1, + TexTransform2D = D3DTTFF_COUNT2, + TexTransform3D = D3DTTFF_COUNT3, + TexTransform4D = D3DTTFF_COUNT4, + TexTransformProjected = D3DTTFF_PROJECTED +}; + +// don't care flags for context creation +const unsigned short GCPDONTCARE_NONE = 0; // 0000000000000000 +const unsigned short GCPDONTCARE_BPP = 1; // 0000000000000001 +const unsigned short GCPDONTCARE_REFRESH = 2; // 0000000000000010 +const unsigned short GCPDONTCARE_ALPHA = 4; // 0000000000000100 +const unsigned short GCPDONTCARE_DEPTH = 8; // 0000000000001000 +const unsigned short GCPDONTCARE_TNL = 16; // 0000000000010000 +const unsigned short GCPDONTCARE_BUFFERS = 32; // 0000000000100000 +const unsigned short GCPDONTCARE_AA = 64; // 0000000001000000 +const unsigned short GCPDONTCARE_VSYNC = 128; // 0000000010000000 + +// fullscreen / windowed flags +const unsigned short GCCREATE_WINDOWED = 0; +const unsigned short GCCREATE_FULLSCREEN = 1; + + + +class Vertex; + +struct ColorDepth { + int bpp, colorbits, alpha; + + ColorDepth(int bits=0, int c=0, int a=0) {colorbits = c; alpha = a; bpp = bits; } +}; + +struct DisplayMode { + unsigned int XRes, YRes, RefreshRate; + ColorDepth ColorFormat; +}; + +enum DisplayModeItem {ModeItemSize, ModeItemBpp, ModeItemAlpha, ModeItemRefresh}; + +struct Adapter { + char *Driver, *Description; + int64 DriverVersion; + dword VentorID, DeviceID, SubSysID, Revision; + GUID DeviceGUID; + + unsigned int ModeCount; + DisplayMode *Modes; + D3DCAPS8 Capabilities; +}; + +struct RenderTarget { + Surface *ColorSurface, *DepthStencilSurface; +}; + +struct RenderParams { + ShadeMode Shading; + bool Billboarded; + dword VertexProgram; + dword PixelProgram; + bool ZWrite; + BlendingFactor SourceBlendFactor, DestBlendFactor; +}; + +struct ContextInitParameters { + int x, y; + int bpp; + int RefreshRate; + bool AlphaChannel; + int DepthBits; + DeviceType DevType; + bool HardwareTnL; + bool FullScreen; + bool Antialiasing; + bool BestAA; + bool VSync; + BufferChainMode Buffers; + unsigned short DontCareFlags; +}; + + +class GraphicsContext { +private: + PrimitiveType ptype; + FaceOrder CullOrder; + bool BackfaceCulling; + bool MipMapEnabled; + bool BillBoardingEnabled; + dword MipFilter; + + // cache of current transformation matrices + Matrix4x4 WorldMat[256], ViewMat, ProjMat, TexMat[8]; + + // disable copying contexts by making copy constructor and assignment private + GraphicsContext(const GraphicsContext &gc); + const GraphicsContext &operator =(const GraphicsContext &gc); + +public: + HWND WindowHandle; + RenderTarget MainRenderTarget; + IDirect3DDevice8 *D3DDevice; + ContextInitParameters ContextParams; + D3DFORMAT ColorFormat, ZFormat; + int AASamples; + int MaxTextureStages; + + TextureManager *texman; // texture manager + + GraphicsContext(); + + void SetDefaultStates(); + + bool CreateVertexBuffer(uint32 VertexCount, UsageFlags usage, VertexBuffer **vb) const; + bool CreateIndexBuffer(uint32 IndexCount, UsageFlags usage, IndexBuffer **ib) const; + + bool CreateSurface(uint32 Width, uint32 Height, Surface **surf) const; + bool CreateDepthStencil(uint32 Width, uint32 Height, Surface **zsurf) const; + + void Clear(dword color) const; + void ClearZBuffer(float zval) const; + void ClearStencil(byte sval) const; + void ClearZBufferStencil(float zval, byte sval) const; + + void Flip() const; + + bool Draw(VertexBuffer *vb); + bool Draw(Vertex *varray, unsigned int VertexCount); + bool Draw(VertexBuffer *vb, IndexBuffer *ib); + bool Draw(Vertex *varray, Index *iarray, unsigned int VertexCount, unsigned int IndexCount); + bool Draw(Vertex *varray, Triangle *triarray, unsigned int VertexCount, unsigned int TriCount); + + IDirect3DDevice8 *GetDevice() const; + int GetTextureStageNumber() const {return MaxTextureStages;} + + ////// render states ////// + void SetPrimitiveType(PrimitiveType pt); + void SetBackfaceCulling(bool enable); + void SetFrontFace(FaceOrder order); + void SetAutoNormalize(bool enable); + void SetBillboarding(bool enable); + void SetColorWrite(bool red, bool green, bool blue, bool alpha); + + // blending states + void SetAlphaBlending(bool enable); + void SetBlendFunc(BlendingFactor src, BlendingFactor dest); + + // zbuffer states + void SetZBuffering(bool enable); + void SetZWrite(bool enable); + void SetZFunc(CmpFunc func); + + // set stencil buffer states + void SetStencilBuffering(bool enable); + void SetStencilPassOp(StencilOp sop); + void SetStencilFailOp(StencilOp sop); + void SetStencilPassZFailOp(StencilOp sop); + void SetStencilOp(StencilOp Fail, StencilOp StencilPassZFail, StencilOp Pass); + void SetStencilFunc(CmpFunc func); + void SetStencilReference(dword value); + + // texture & material states + void SetTextureFiltering(TextureFilteringType texfilter, int TextureStage = 0xa11); + void SetTextureAddressing(TextureAddressing uaddr, TextureAddressing vaddr, int TextureStage = 0xa11); + void SetTextureBorderColor(dword color, int TextureStage = 0xa11); + void SetTexture(int index, Texture *tex); + void SetTextureFactor(dword factor); + void SetMipMapping(bool enable, int TextureStage = 0xa11); + void SetMaterial(const Material &mat); + + void BlitTexture(const Texture *texture, RECT *rect, const Color &col = Color(1.0f)); + + // multitexturing interface + void EnableTextureStage(int stage); + void DisableTextureStage(int stage); + void SetTextureStageColor(int stage, TextureBlendFunction op, TextureBlendArgument arg1, TextureBlendArgument arg2, TextureBlendArgument arg3 = TexArgNone); + void SetTextureStageAlpha(int stage, TextureBlendFunction op, TextureBlendArgument arg1, TextureBlendArgument arg2, TextureBlendArgument arg3 = TexArgNone); + void SetTextureCoordIndex(int stage, int index); + void SetTextureTransformState(int stage, TexTransformState TexXForm); + //void SetTextureCoordGenerator(int stage, TexGen tgen); + + // programmable interface + void SetVertexProgram(dword vs); + void SetPixelProgram(dword ps); + + dword CreateVertexProgram(const char *fname); + void DestroyVertexProgram(dword vprog); + void SetVertexProgramConstant(dword creg, float val); + void SetVertexProgramConstant(dword creg, const Vector3 &val); + void SetVertexProgramConstant(dword creg, const Vector4 &val); + void SetVertexProgramConstant(dword creg, const Color &val); + void SetVertexProgramConstant(dword creg, const Matrix4x4 &val); + void SetVertexProgramConstant(dword creg, const void *data, dword size); + + + // lighting states + void SetLighting(bool enable); + void SetColorVertex(bool enable); + void SetAmbientLight(Color AmbientColor); + void SetShadingMode(ShadeMode mode); + void SetSpecular(bool enable); + + // Transformation Matrices + void SetWorldMatrix(const Matrix4x4 &WorldMat, unsigned int BlendIndex = 0); + void SetViewMatrix(const Matrix4x4 &ViewMat); + void SetProjectionMatrix(const Matrix4x4 &ProjMat); + void SetTextureMatrix(const Matrix4x4 &TexMat, unsigned int TextureStage = 0); + void SetViewport(unsigned int x, unsigned int y, unsigned int xsize, unsigned int ysize, float MinZ = 0.0f, float MaxZ = 1.0f); + + const Matrix4x4 &GetWorldMatrix(unsigned int BlendIndex = 0); + const Matrix4x4 &GetViewMatrix(); + const Matrix4x4 &GetProjectionMatrix(); + const Matrix4x4 &GetTextureMatrix(unsigned int TextureStage = 0); + + // render target + void ResetRenderTarget(); + void SetRenderTarget(RenderTarget &rtarg); + void SetRenderTarget(Texture *rtarg, Texture *ztarg); + void SetRenderTarget(Texture *rtarg, Surface *ztarg); + //RenderTarget GetRenderTarget() const; +}; + + + +class Engine3D { +private: + IDirect3D8 *d3d; + unsigned int AdapterCount; + Adapter *adapters; // array of adapters (filled in at the constructor) + std::vector GraphicsContexts; // a list of active graphics contexts + + void RetrieveAdapterInfo(); + LinkedList *CreateModesList(unsigned int AdapterID) const; + void NarrowModesList(LinkedList *list, DisplayModeItem item, long value, long value2=0) const; + DisplayMode ChooseBestMode(LinkedList *modes) const; + int MaxAntialiasingSamples() const; + +public: + + Engine3D(); + ~Engine3D(); + + int GetAdapterCount() const; + const Adapter *GetAdapterInfo(int adapter) const; + + GraphicsContext *CreateGraphicsContext(HWND WindowHandle, int x, int y, int bpp, word flags); + GraphicsContext *CreateGraphicsContext(HWND WindowHandle, unsigned int AdapterID, ContextInitParameters *GCParams); + ContextInitParameters LoadContextParamsConfigFile(const char *cfgfilename); + + void DestroyGraphicsContext(GraphicsContext *gc); +}; + +class Light; + +// helper functions +bool Lock(VertexBuffer *vb, Vertex **data); +bool Lock(IndexBuffer *ib, Index **data); +void Unlock(VertexBuffer *vb); +void Unlock(IndexBuffer *ib); +void CreateProjectionMatrix(Matrix4x4 *mat, float yFOV, float Aspect, float NearClip, float FarClip); +void NormalMapFromHeightField(Texture *tex); +void UpdateMipmapChain(Texture *tex); +TriMesh *CreateShadowVolume(const TriMesh &mesh, const Light *light, const Matrix4x4 &MeshXForm, bool WorldCoords = false); + +#endif // _3DENGINE_H_ \ No newline at end of file diff -r 000000000000 -r 1cffe3409164 src/3deng/3dengtypes.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/3deng/3dengtypes.h Thu Oct 23 01:46:07 2014 +0300 @@ -0,0 +1,22 @@ +#ifndef _3DENGTYPES_H_ +#define _3DENGTYPES_H_ + +#include "d3d8.h" +#include "typedefs.h" + +typedef IDirect3DSurface8 Surface; +typedef IDirect3DTexture8 Texture; +typedef IDirect3DVertexBuffer8 VertexBuffer; +typedef IDirect3DIndexBuffer8 IndexBuffer; + +#define FixedFunction VertexFormat + +//const dword VertexFormat = D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_DIFFUSE | D3DFVF_TEX4; +//const dword VertexFormat = D3DFVF_XYZ | D3DFVF_XYZB1 | D3DFVF_NORMAL | D3DFVF_DIFFUSE | D3DFVF_TEX4; +const dword VertexFormat = D3DFVF_XYZB2 | D3DFVF_LASTBETA_UBYTE4 | D3DFVF_NORMAL | D3DFVF_DIFFUSE | D3DFVF_TEX4; +const D3DFORMAT IndexFormat = D3DFMT_INDEX16; +const dword IndexSize = 2; +typedef uint16 Index; + + +#endif // _3DENGTYPES_H_ \ No newline at end of file diff -r 000000000000 -r 1cffe3409164 src/3deng/3dgeom.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/3deng/3dgeom.cpp Thu Oct 23 01:46:07 2014 +0300 @@ -0,0 +1,478 @@ +#include +#include "3dgeom.h" +#include "3dengine.h" + +using std::vector; + +TexCoord::TexCoord(float u, float v) { + this->u = u; + this->v = v; +} + +// Vertex class implementation + +Vertex::Vertex() { + color = 0x00ffffff; + memset(tex, 0, 4*sizeof(TexCoord)); +} + +Vertex::Vertex(const Vector3 &position, float tu, float tv, dword color) { + pos = position; + tex[0].u = tex[1].u = tex[2].u = tex[3].u = tu; + tex[0].v = tex[1].v = tex[2].v = tex[3].v = tv; + this->color = color; +} + +void Vertex::CalculateNormal(const Vertex *vbuffer, const Triangle *triangles, long trinum) { + + // find the position of the curent vertex in the vertex buffer + dword index = (dword)(this - vbuffer); + + normal = Vector3(0, 0, 0); + const Triangle *tri = triangles; + for(int i=0; ivertices[0] == index || tri->vertices[1] == index || tri->vertices[2] == index) { + normal += tri->normal; + } + } + + normal.Normalize(); +} + +/////////// Edge class implementation /////////// + +Edge::Edge() { + vertices[0] = vertices[1] = adjfaces[0] = adjfaces[1] = 0; +} + +Edge::Edge(Index v1, Index v2, Index af1, Index af2) { + vertices[0] = v1; + vertices[1] = v2; + adjfaces[0] = af1; + adjfaces[1] = af2; +} + +/////////// Triangle class implementation ///////////// +Triangle::Triangle(Index v1, Index v2, Index v3) { + vertices[0] = v1; + vertices[1] = v2; + vertices[2] = v3; +} + +void Triangle::CalculateNormal(Vertex *vbuffer, bool normalize) { + Vector3 v1 = vbuffer[vertices[1]].pos - vbuffer[vertices[0]].pos; + Vector3 v2 = vbuffer[vertices[2]].pos - vbuffer[vertices[0]].pos; + normal = v1.CrossProduct(v2); + if(normalize) normal.Normalize(); +} + + +/////////////// Triangular Mesh implementation ///////////// + +TriMesh::TriMesh(byte LODLevels, GraphicsContext *gc) { + memset(this, 0, sizeof(TriMesh)); + this->gc = gc; + Levels = LODLevels; + + varray = new Vertex*[Levels]; + memset(varray, 0, Levels * sizeof(Vertex*)); + + triarray = new Triangle*[Levels]; + memset(triarray, 0, Levels * sizeof(Triangle*)); + + vbuffer = new VertexBuffer*[Levels]; + memset(vbuffer, 0, Levels * sizeof(VertexBuffer*)); + + ibuffer = new IndexBuffer*[Levels]; + memset(ibuffer, 0, Levels * sizeof(IndexBuffer*)); + + AdjTriangles = new std::vector*[Levels]; + memset(AdjTriangles, 0, Levels * sizeof(std::vector*)); + + VertexCount = new dword[Levels]; + TriCount = new dword[Levels]; + + BuffersValid = new bool[Levels]; + memset(BuffersValid, 0, Levels * sizeof(bool)); + + AdjValid = new bool[Levels]; + memset(AdjValid, 0, Levels * sizeof(bool)); +} + +TriMesh::TriMesh(const TriMesh &mesh) { + + memcpy(this, &mesh, sizeof(TriMesh)); + + BuffersValid = new bool[Levels]; + memset(BuffersValid, 0, Levels * sizeof(bool)); + + varray = new Vertex*[Levels]; + triarray = new Triangle*[Levels]; + vbuffer = new VertexBuffer*[Levels]; + ibuffer = new IndexBuffer*[Levels]; + + VertexCount = new dword[Levels]; + TriCount = new dword[Levels]; + + for(int i=0; iRelease(); + } + } + if(ibuffer) { + for(int i=0; iRelease(); + } + } + + if(AdjTriangles) { + for(int i=0; i= Levels) return 0; + return varray[level]; +} + +const Triangle *TriMesh::GetTriangleArray(byte level) const { + if(level >= Levels) return 0; + return triarray[level]; +} + + +Vertex *TriMesh::GetModVertexArray() { + memset(BuffersValid, 0, Levels * sizeof(bool)); + return varray[0]; +} + +Triangle *TriMesh::GetModTriangleArray() { + memset(BuffersValid, 0, Levels * sizeof(bool)); + memset(AdjValid, 0, Levels * sizeof(bool)); + return triarray[0]; +} + +const VertexBuffer *TriMesh::GetVertexBuffer(byte level) const { + if(level >= Levels) return 0; + + if(!BuffersValid[level]) { + const_cast(this)->UpdateSystemBuffers(level); + } + return vbuffer[level]; +} + +const IndexBuffer *TriMesh::GetIndexBuffer(byte level) const { + if(level >= Levels) return 0; + + if(!BuffersValid[level]) { + const_cast(this)->UpdateSystemBuffers(level); + } + + return ibuffer[level]; +} + + +dword TriMesh::GetVertexCount(byte level) const { + if(level >= Levels) return 0xdeadbeef; + return VertexCount[level]; +} + +dword TriMesh::GetTriangleCount(byte level) const { + if(level >= Levels) return 0xdeadbeef; + return TriCount[level]; +} + +byte TriMesh::GetLevelCount() const { + return Levels; +} + +void TriMesh::SetGraphicsContext(GraphicsContext *gc) { + this->gc = gc; + memset(BuffersValid, 0, Levels * sizeof(bool)); // invalidate all system buffers in all levels +} + +void TriMesh::SetData(const Vertex *vdata, const Triangle *tridata, dword vcount, dword tricount) { + + memset(BuffersValid, 0, Levels * sizeof(bool)); + memset(AdjValid, 0, Levels * sizeof(bool)); + + if(varray[0]) delete [] varray[0]; + if(triarray[0]) delete [] triarray[0]; + varray[0] = new Vertex[vcount]; + triarray[0] = new Triangle[tricount]; + + if(vdata) memcpy(varray[0], vdata, vcount * sizeof(Vertex)); + if(tridata) memcpy(triarray[0], tridata, tricount * sizeof(Triangle)); + VertexCount[0] = vcount; + TriCount[0] = tricount; + + UpdateLODChain(); +} + +bool TriMesh::UpdateSystemBuffers(byte level) { + + if(!gc || level >= Levels) return false; + + if(vbuffer[level]) { + D3DVERTEXBUFFER_DESC vbdesc; + vbuffer[level]->GetDesc(&vbdesc); + if(vbdesc.Size / sizeof(Vertex) != VertexCount[level]) { + vbuffer[level]->Release(); + + if(gc->D3DDevice->CreateVertexBuffer(VertexCount[level] * sizeof(Vertex), dynamic ? D3DUSAGE_DYNAMIC : 0, VertexFormat, D3DPOOL_DEFAULT, &vbuffer[level]) != D3D_OK) { + return false; + } + } + } else { + if(gc->D3DDevice->CreateVertexBuffer(VertexCount[level] * sizeof(Vertex), dynamic ? D3DUSAGE_DYNAMIC : 0, VertexFormat, D3DPOOL_DEFAULT, &vbuffer[level]) != D3D_OK) { + return false; + } + } + + Vertex *vbdata; + Lock(vbuffer[level], &vbdata); + memcpy(vbdata, varray[level], VertexCount[level] * sizeof(Vertex)); + Unlock(vbuffer[level]); + + if(ibuffer[level]) { + D3DINDEXBUFFER_DESC ibdesc; + ibuffer[level]->GetDesc(&ibdesc); + if(ibdesc.Size / IndexSize != TriCount[level] * 3) { + ibuffer[level]->Release(); + + if(gc->D3DDevice->CreateIndexBuffer(TriCount[level] * 3 * IndexSize, dynamic ? D3DUSAGE_DYNAMIC : 0, IndexFormat, D3DPOOL_DEFAULT, &ibuffer[level]) != D3D_OK) { + return false; + } + } + } else { + if(gc->D3DDevice->CreateIndexBuffer(TriCount[level] * 3 * IndexSize, dynamic ? D3DUSAGE_DYNAMIC : 0, IndexFormat, D3DPOOL_DEFAULT, &ibuffer[level]) != D3D_OK) { + return false; + } + } + + + Index *ibdata; + Lock(ibuffer[level], &ibdata); + for(dword i=0; i[VertexCount[0]]; + } + + for(dword i=0; iCalculateNormal(varray[0], true); + varray[0][tri->vertices[0]].normal = tri->normal; + varray[0][tri->vertices[1]].normal = tri->normal; + varray[0][tri->vertices[2]].normal = tri->normal; + tri++; + } + + UpdateLODChain(); +} + +void TriMesh::ChangeMode(TriMeshMode mode) { + dynamic = mode == TriMeshDynamic; +} + +/* + +void TriMesh::CalculateEdges() { + + //build a list of triangles that share each vertex + std::list *ShareTris = new std::list[VertexCount[0]]; + + for(dword i=0; iedges[j].vertices[0] = tri->vertices[j]; + tri->edges[j].vertices[1] = tri->vertices[(j+1) % 3]; + tri->edges[j].adjfaces[0] = (Index)i; + } + + for(int j=0; j<3; j++) { + Index v0 = (Index)((Vertex*)&varray[0][tri->edges[j].vertices[0]] - (Vertex*)&varray[0][0]); + Index v1 = (Index)((Vertex*)&varray[0][tri->edges[j].vertices[1]] - (Vertex*)&varray[0][0]); + + std::list::iterator iter = ShareTris[v0].begin(); + while(iter != ShareTris[v0].end()) { + Index TriIndex = (Index)(*iter - &triarray[0][0]); + + if((TriIndex != i) && ((*iter)->vertices[0] == v1 || (*iter)->vertices[1] == v1 || (*iter)->vertices[2] == v1)) { + tri->edges[j].adjfaces[1] = TriIndex; + break; + } + iter++; + } + if(iter == ShareTris[v0].end()) tri->edges[j].adjfaces[1] = (Index)0xffffffff; + } + } + + // TODO: wield duplicate edges +} + +*/ \ No newline at end of file diff -r 000000000000 -r 1cffe3409164 src/3deng/3dgeom.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/3deng/3dgeom.h Thu Oct 23 01:46:07 2014 +0300 @@ -0,0 +1,112 @@ +#ifndef _3DGEOM_H_ +#define _3DGEOM_H_ + +#include +#include "n3dmath.h" +#include "3dengtypes.h" +#include "switches.h" + +struct TexCoord { + float u, v; + + TexCoord(float u = 0.0f, float v = 0.0f); +}; + +class Triangle; // fwd declaration + +class Vertex { +public: + Vector3 pos; + float BlendFactor; + dword BlendIndex; + Vector3 normal; + dword color; + TexCoord tex[4]; + + Vertex(); + Vertex(const Vector3 &position, float tu = 0.0f, float tv = 0.0f, dword color = 0x00ffffff); + + void CalculateNormal(const Vertex *vbuffer, const Triangle *triangles, long trinum); +}; + + +class Edge { +public: + Index vertices[2]; + Index adjfaces[2]; + + Edge(); + Edge(Index v1, Index v2, Index af1 = 0, Index af2 = 0); +}; + + +class Triangle { +public: + Index vertices[3]; + Vector3 normal; + dword SmoothingGroup; + + Triangle(Index v1 = 0, Index v2 = 0, Index v3 = 0); + + void CalculateNormal(Vertex *vbuffer, bool normalize=0); +}; + + +enum TriMeshMode {TriMeshDynamic, TriMeshStatic}; + +class GraphicsContext; + +class TriMesh { +private: + GraphicsContext *gc; + + // LOD arrays of vertex and triangle arrays for the mesh + Vertex **varray; + Triangle **triarray; + // system managed copy of the data (probably on the video ram or something) + VertexBuffer **vbuffer; + IndexBuffer **ibuffer; + + std::vector **AdjTriangles; + bool *AdjValid; + + dword *VertexCount, *TriCount; + byte Levels; + + bool *BuffersValid; + bool dynamic; + + // synchronizes the system managed copy of vertices/indices with the local data + bool UpdateSystemBuffers(byte level); + void UpdateLODChain(); + +public: + TriMesh(byte LODLevels, GraphicsContext *gc = 0); + TriMesh(const TriMesh &mesh); + ~TriMesh(); + + const TriMesh &operator =(const TriMesh &mesh); + + const Vertex *GetVertexArray(byte level = 0) const; + const Triangle *GetTriangleArray(byte level = 0) const; + + Vertex *GetModVertexArray(); + Triangle *GetModTriangleArray(); + + const VertexBuffer *GetVertexBuffer(byte level = 0) const; + const IndexBuffer *GetIndexBuffer(byte level = 0) const; + + dword GetVertexCount(byte level = 0) const; + dword GetTriangleCount(byte level = 0) const; + byte GetLevelCount() const; + + void ChangeMode(TriMeshMode mode); + void SetGraphicsContext(GraphicsContext *gc); + void SetData(const Vertex *vdata, const Triangle *tridata, dword vcount, dword tricount); + + void CalculateNormals(); + void CalculateNormalsFast(); + //void CalculateEdges(); +}; + +#endif // _3DGEOM_H_ \ No newline at end of file diff -r 000000000000 -r 1cffe3409164 src/3deng/3dscene.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/3deng/3dscene.cpp Thu Oct 23 01:46:07 2014 +0300 @@ -0,0 +1,351 @@ +#include +#include "3dscene.h" + +using std::string; + +Scene::Scene(GraphicsContext *gc) { + this->gc = gc; + + ActiveCamera = 0; + Shadows = false; + LightHalos = false; + HaloSize = 10.0f; + UseFog = false; + + memset(lights, 0, 8 * sizeof(Light*)); + + AmbientLight = Color(0.0f, 0.0f, 0.0f); + ManageData = true; +} + +Scene::~Scene() { + + if(ManageData) { + std::list::iterator obj = objects.begin(); + while(obj != objects.end()) { + delete *obj++; + } + + std::list::iterator cam = cameras.begin(); + while(cam != cameras.end()) { + delete *cam++; + } + + for(int i=0; i<8; i++) { + delete lights[i]; + } + + std::list::iterator citer = curves.begin(); + while(citer != curves.end()) { + delete *citer++; + } + + std::list::iterator sv = StaticShadowVolumes.begin(); + while(sv != StaticShadowVolumes.end()) { + delete (*sv++).shadow_mesh; + } + } + +} + +void Scene::SetGraphicsContext(GraphicsContext *gc) { + this->gc = gc; +} + +void Scene::AddCamera(Camera *cam) { + cameras.push_back(cam); + if(!ActiveCamera) ActiveCamera = cam; +} + +void Scene::AddLight(Light *light) { + for(int i=0; i<8; i++) { + if(!lights[i]) { + lights[i] = light; + break; + } + } +} + +void Scene::AddObject(Object *obj) { + if(obj->material.Alpha < 1.0f) { + objects.push_back(obj); + } else { + objects.push_front(obj); + } +} + +void Scene::AddStaticShadowVolume(TriMesh *mesh, const Light *light) { + ShadowVolume svol; + svol.shadow_mesh = mesh; + svol.light = light; + StaticShadowVolumes.push_back(svol); +} + +void Scene::AddCurve(Curve *curve) { + curves.push_back(curve); +} + + +void Scene::RemoveObject(const Object *obj) { + std::list