static int nvpr_init(void **render, const platform *platform)
{
render_ctx *ctx = calloc(1, sizeof(render_ctx));
*render = ctx;
if (!ctx)
return 0;
int fail = 0;
if (!platform->extension_supported || !platform->extension_supported("GL_NV_path_rendering"))
goto error;
LOAD_PROC(PFNGLMATRIXLOADIDENTITYEXTPROC, glMatrixLoadIdentityEXT);
LOAD_PROC(PFNGLMATRIXORTHOEXTPROC, glMatrixOrthoEXT);
LOAD_PROC(PFNGLMATRIXLOADFEXTPROC, glMatrixLoadfEXT);
/*LOAD_PROC(PFNGLGENPATHSNVPROC, glGenPathsNV);
LOAD_PROC(PFNGLDELETEPATHSNVPROC, glDeletePathsNV);
LOAD_PROC(PFNGLISPATHNVPROC, glIsPathNV);
LOAD_PROC(PFNGLPATHCOMMANDSNVPROC, glPathCommandsNV);
LOAD_PROC(PFNGLPATHCOORDSNVPROC, glPathCoordsNV);
LOAD_PROC(PFNGLPATHSUBCOMMANDSNVPROC, glPathSubCommandsNV);
LOAD_PROC(PFNGLPATHSUBCOORDSNVPROC, glPathSubCoordsNV);
LOAD_PROC(PFNGLPATHSTRINGNVPROC, glPathStringNV);
LOAD_PROC(PFNGLPATHGLYPHSNVPROC, glPathGlyphsNV);
LOAD_PROC(PFNGLPATHGLYPHRANGENVPROC, glPathGlyphRangeNV);
LOAD_PROC(PFNGLWEIGHTPATHSNVPROC, glWeightPathsNV);
LOAD_PROC(PFNGLCOPYPATHNVPROC, glCopyPathNV);
LOAD_PROC(PFNGLINTERPOLATEPATHSNVPROC, glInterpolatePathsNV);
LOAD_PROC(PFNGLTRANSFORMPATHNVPROC, glTransformPathNV);
LOAD_PROC(PFNGLPATHPARAMETERIVNVPROC, glPathParameterivNV);
LOAD_PROC(PFNGLPATHPARAMETERINVPROC, glPathParameteriNV);
LOAD_PROC(PFNGLPATHPARAMETERFVNVPROC, glPathParameterfvNV);
LOAD_PROC(PFNGLPATHPARAMETERFNVPROC, glPathParameterfNV);
LOAD_PROC(PFNGLPATHDASHARRAYNVPROC, glPathDashArrayNV);
LOAD_PROC(PFNGLSTENCILFILLPATHNVPROC, glStencilFillPathNV);
LOAD_PROC(PFNGLSTENCILSTROKEPATHNVPROC, glStencilStrokePathNV);
LOAD_PROC(PFNGLSTENCILFILLPATHINSTANCEDNVPROC, glStencilFillPathInstancedNV);
LOAD_PROC(PFNGLSTENCILSTROKEPATHINSTANCEDNVPROC, glStencilStrokePathInstancedNV);
LOAD_PROC(PFNGLPATHCOLORGENNVPROC, glPathColorGenNV);
LOAD_PROC(PFNGLPATHTEXGENNVPROC, glPathTexGenNV);
LOAD_PROC(PFNGLPATHFOGGENNVPROC, glPathFogGenNV);
LOAD_PROC(PFNGLCOVERFILLPATHNVPROC, glCoverFillPathNV);
LOAD_PROC(PFNGLCOVERSTROKEPATHNVPROC, glCoverStrokePathNV);
LOAD_PROC(PFNGLCOVERFILLPATHINSTANCEDNVPROC, glCoverFillPathInstancedNV);
LOAD_PROC(PFNGLCOVERSTROKEPATHINSTANCEDNVPROC, glCoverStrokePathInstancedNV);
LOAD_PROC(PFNGLGETPATHPARAMETERIVNVPROC, glGetPathParameterivNV);
LOAD_PROC(PFNGLGETPATHPARAMETERFVNVPROC, glGetPathParameterfvNV);
LOAD_PROC(PFNGLGETPATHCOMMANDSNVPROC, glGetPathCommandsNV);
LOAD_PROC(PFNGLGETPATHCOORDSNVPROC, glGetPathCoordsNV);
LOAD_PROC(PFNGLGETPATHDASHARRAYNVPROC, glGetPathDashArrayNV);
LOAD_PROC(PFNGLGETPATHMETRICSNVPROC, glGetPathMetricsNV);
LOAD_PROC(PFNGLGETPATHMETRICRANGENVPROC, glGetPathMetricRangeNV);
LOAD_PROC(PFNGLGETPATHSPACINGNVPROC, glGetPathSpacingNV);
LOAD_PROC(PFNGLGETPATHCOLORGENIVNVPROC, glGetPathColorGenivNV);
LOAD_PROC(PFNGLGETPATHCOLORGENFVNVPROC, glGetPathColorGenfvNV);
LOAD_PROC(PFNGLGETPATHTEXGENIVNVPROC, glGetPathTexGenivNV);
LOAD_PROC(PFNGLGETPATHTEXGENFVNVPROC, glGetPathTexGenfvNV);
LOAD_PROC(PFNGLISPOINTINFILLPATHNVPROC, glIsPointInFillPathNV);
LOAD_PROC(PFNGLISPOINTINSTROKEPATHNVPROC, glIsPointInStrokePathNV);
LOAD_PROC(PFNGLGETPATHLENGTHNVPROC, glGetPathLengthNV);
LOAD_PROC(PFNGLPOINTALONGPATHNVPROC, glPointAlongPathNV);
LOAD_PROC(PFNGLPATHSTENCILFUNCNVPROC, glPathStencilFuncNV);
LOAD_PROC(PFNGLPATHSTENCILDEPTHOFFSETNVPROC, glPathStencilDepthOffsetNV);
LOAD_PROC(PFNGLPATHCOVERDEPTHFUNCNVPROC, glPathCoverDepthFuncNV);*/
if (fail)
goto error;
return 1;
error:
free(ctx);
return 0;
}
int main(int argc, char **argv)
{
ALCdevice *device;
ALuint source, buffer;
const char *soundname;
const char *hrtfname;
ALCint hrtf_state;
ALCint num_hrtf;
ALdouble angle;
ALenum state;
/* Print out usage if no file was specified */
if(argc < 2 || (strcmp(argv[1], "-hrtf") == 0 && argc < 4))
{
fprintf(stderr, "Usage: %s [-hrtf <name>] <soundfile>\n", argv[0]);
return 1;
}
/* Initialize OpenAL with the default device, and check for HRTF support. */
if(InitAL() != 0)
return 1;
if(strcmp(argv[1], "-hrtf") == 0)
{
hrtfname = argv[2];
soundname = argv[3];
}
else
{
hrtfname = NULL;
soundname = argv[1];
}
device = alcGetContextsDevice(alcGetCurrentContext());
if(!alcIsExtensionPresent(device, "ALC_SOFT_HRTF"))
{
fprintf(stderr, "Error: ALC_SOFT_HRTF not supported\n");
CloseAL();
return 1;
}
/* Define a macro to help load the function pointers. */
#define LOAD_PROC(d, x) ((x) = alcGetProcAddress((d), #x))
LOAD_PROC(device, alcGetStringiSOFT);
LOAD_PROC(device, alcResetDeviceSOFT);
#undef LOAD_PROC
/* Enumerate available HRTFs, and reset the device using one. */
alcGetIntegerv(device, ALC_NUM_HRTF_SPECIFIERS_SOFT, 1, &num_hrtf);
if(!num_hrtf)
printf("No HRTFs found\n");
else
{
ALCint attr[5];
ALCint index = -1;
ALCint i;
printf("Available HRTFs:\n");
for(i = 0; i < num_hrtf; i++)
{
const ALCchar *name = alcGetStringiSOFT(device, ALC_HRTF_SPECIFIER_SOFT, i);
printf(" %d: %s\n", i, name);
/* Check if this is the HRTF the user requested. */
if(hrtfname && strcmp(name, hrtfname) == 0)
index = i;
}
i = 0;
attr[i++] = ALC_HRTF_SOFT;
attr[i++] = ALC_TRUE;
if(index == -1)
{
if(hrtfname)
printf("HRTF \"%s\" not found\n", hrtfname);
printf("Using default HRTF...\n");
}
else
{
printf("Selecting HRTF %d...\n", index);
attr[i++] = ALC_HRTF_ID_SOFT;
attr[i++] = index;
}
attr[i] = 0;
if(!alcResetDeviceSOFT(device, attr))
printf("Failed to reset device: %s\n", alcGetString(device, alcGetError(device)));
}
/* Check if HRTF is enabled, and show which is being used. */
alcGetIntegerv(device, ALC_HRTF_SOFT, 1, &hrtf_state);
if(!hrtf_state)
printf("HRTF not enabled!\n");
else
{
const ALchar *name = alcGetString(device, ALC_HRTF_SPECIFIER_SOFT);
printf("HRTF enabled, using %s\n", name);
}
fflush(stdout);
/* Load the sound into a buffer. */
buffer = LoadSound(soundname);
if(!buffer)
{
CloseAL();
return 1;
}
/* Create the source to play the sound with. */
source = 0;
alGenSources(1, &source);
alSourcei(source, AL_SOURCE_RELATIVE, AL_TRUE);
alSource3f(source, AL_POSITION, 0.0f, 0.0f, -1.0f);
alSourcei(source, AL_BUFFER, buffer);
assert(alGetError()==AL_NO_ERROR && "Failed to setup sound source");
/* Play the sound until it finishes. */
angle = 0.0;
alSourcePlay(source);
do {
al_nssleep(10000000);
/* Rotate the source around the listener by about 1/4 cycle per second.
* Only affects mono sounds.
*/
angle += 0.01 * M_PI * 0.5;
alSource3f(source, AL_POSITION, (ALfloat)sin(angle), 0.0f, -(ALfloat)cos(angle));
alGetSourcei(source, AL_SOURCE_STATE, &state);
} while(alGetError() == AL_NO_ERROR && state == AL_PLAYING);
/* All done. Delete resources, and close OpenAL. */
alDeleteSources(1, &source);
alDeleteBuffers(1, &buffer);
CloseAL();
return 0;
}
int main()
{
PlaybackInfo playback = { NULL, NULL, 0 };
SDL_AudioSpec desired, obtained;
ALuint source, buffer;
ALCint attrs[16];
ALenum state;
/* Print out error if extension is missing. */
if(!alcIsExtensionPresent(NULL, "ALC_SOFT_loopback"))
{
fprintf(stderr, "Error: ALC_SOFT_loopback not supported!\n");
return 1;
}
/* Define a macro to help load the function pointers. */
#define LOAD_PROC(x) ((x) = alcGetProcAddress(NULL, #x))
LOAD_PROC(alcLoopbackOpenDeviceSOFT);
LOAD_PROC(alcIsRenderFormatSupportedSOFT);
LOAD_PROC(alcRenderSamplesSOFT);
#undef LOAD_PROC
if(SDL_Init(SDL_INIT_AUDIO) == -1)
{
fprintf(stderr, "Failed to init SDL audio: %s\n", SDL_GetError());
return 1;
}
/* Set up SDL audio with our requested format and callback. */
desired.channels = 2;
desired.format = AUDIO_S16SYS;
desired.freq = 44100;
desired.padding = 0;
desired.samples = 4096;
desired.callback = RenderSDLSamples;
desired.userdata = &playback;
if(SDL_OpenAudio(&desired, &obtained) != 0)
{
SDL_Quit();
fprintf(stderr, "Failed to open SDL audio: %s\n", SDL_GetError());
return 1;
}
/* Set up our OpenAL attributes based on what we got from SDL. */
attrs[0] = ALC_FORMAT_CHANNELS_SOFT;
if(obtained.channels == 1)
attrs[1] = ALC_MONO_SOFT;
else if(obtained.channels == 2)
attrs[1] = ALC_STEREO_SOFT;
else
{
fprintf(stderr, "Unhandled SDL channel count: %d\n", obtained.channels);
goto error;
}
attrs[2] = ALC_FORMAT_TYPE_SOFT;
if(obtained.format == AUDIO_U8)
attrs[3] = ALC_UNSIGNED_BYTE_SOFT;
else if(obtained.format == AUDIO_S8)
attrs[3] = ALC_BYTE_SOFT;
else if(obtained.format == AUDIO_U16SYS)
attrs[3] = ALC_UNSIGNED_SHORT_SOFT;
else if(obtained.format == AUDIO_S16SYS)
attrs[3] = ALC_SHORT_SOFT;
else
{
fprintf(stderr, "Unhandled SDL format: 0x%04x\n", obtained.format);
goto error;
}
attrs[4] = ALC_FREQUENCY;
attrs[5] = obtained.freq;
attrs[6] = 0; /* end of list */
/* Initialize OpenAL loopback device, using our format attributes. */
playback.Device = alcLoopbackOpenDeviceSOFT(NULL);
if(!playback.Device)
{
fprintf(stderr, "Failed to open loopback device!\n");
goto error;
}
/* Make sure the format is supported before setting them on the device. */
if(alcIsRenderFormatSupportedSOFT(playback.Device, attrs[5], attrs[1], attrs[3]) == ALC_FALSE)
{
fprintf(stderr, "Render format not supported: %s, %s, %dhz\n",
ChannelsName(attrs[1]), TypeName(attrs[3]), attrs[5]);
goto error;
}
playback.Context = alcCreateContext(playback.Device, attrs);
if(!playback.Context || alcMakeContextCurrent(playback.Context) == ALC_FALSE)
{
fprintf(stderr, "Failed to set an OpenAL audio context\n");
goto error;
}
playback.FrameSize = FramesToBytes(1, attrs[1], attrs[3]);
/* Start SDL playing. Our callback (thus alcRenderSamplesSOFT) will now
* start being called regularly to update the AL playback state. */
SDL_PauseAudio(0);
/* Load the sound into a buffer. */
buffer = CreateSineWave();
if(!buffer)
{
SDL_CloseAudio();
alcDestroyContext(playback.Context);
alcCloseDevice(playback.Device);
SDL_Quit();
return 1;
}
/* Create the source to play the sound with. */
source = 0;
alGenSources(1, &source);
alSourcei(source, AL_BUFFER, buffer);
assert(alGetError()==AL_NO_ERROR && "Failed to setup sound source");
/* Play the sound until it finishes. */
alSourcePlay(source);
do {
Sleep(10);
alGetSourcei(source, AL_SOURCE_STATE, &state);
} while(alGetError() == AL_NO_ERROR && state == AL_PLAYING);
/* All done. Delete resources, and close OpenAL. */
alDeleteSources(1, &source);
alDeleteBuffers(1, &buffer);
/* Stop SDL playing. */
SDL_PauseAudio(1);
/* Close up OpenAL and SDL. */
SDL_CloseAudio();
alcDestroyContext(playback.Context);
alcCloseDevice(playback.Device);
SDL_Quit();
return 0;
error:
SDL_CloseAudio();
if(playback.Context)
alcDestroyContext(playback.Context);
if(playback.Device)
alcCloseDevice(playback.Device);
SDL_Quit();
return 1;
}
int main(int argc, char **argv)
{
ALuint source, buffer;
ALdouble offsets[2];
ALenum state;
/* Print out usage if no arguments were specified */
if(argc < 2)
{
fprintf(stderr, "Usage: %s [-device <name>] <filename>\n", argv[0]);
return 1;
}
/* Initialize OpenAL, and check for source_latency support. */
argv++; argc--;
if(InitAL(&argv, &argc) != 0)
return 1;
if(!alIsExtensionPresent("AL_SOFT_source_latency"))
{
fprintf(stderr, "Error: AL_SOFT_source_latency not supported\n");
CloseAL();
return 1;
}
/* Define a macro to help load the function pointers. */
#define LOAD_PROC(x) ((x) = alGetProcAddress(#x))
LOAD_PROC(alSourcedSOFT);
LOAD_PROC(alSource3dSOFT);
LOAD_PROC(alSourcedvSOFT);
LOAD_PROC(alGetSourcedSOFT);
LOAD_PROC(alGetSource3dSOFT);
LOAD_PROC(alGetSourcedvSOFT);
LOAD_PROC(alSourcei64SOFT);
LOAD_PROC(alSource3i64SOFT);
LOAD_PROC(alSourcei64vSOFT);
LOAD_PROC(alGetSourcei64SOFT);
LOAD_PROC(alGetSource3i64SOFT);
LOAD_PROC(alGetSourcei64vSOFT);
if(alIsExtensionPresent("AL_SOFT_buffer_samples"))
{
LOAD_PROC(alBufferSamplesSOFT);
LOAD_PROC(alIsBufferFormatSupportedSOFT);
}
#undef LOAD_PROC
/* Load the sound into a buffer. */
buffer = LoadSound(argv[0]);
if(!buffer)
{
CloseAL();
return 1;
}
/* Create the source to play the sound with. */
source = 0;
alGenSources(1, &source);
alSourcei(source, AL_BUFFER, buffer);
assert(alGetError()==AL_NO_ERROR && "Failed to setup sound source");
/* Play the sound until it finishes. */
alSourcePlay(source);
do {
al_nssleep(10000000);
alGetSourcei(source, AL_SOURCE_STATE, &state);
/* Get the source offset and latency. AL_SEC_OFFSET_LATENCY_SOFT will
* place the offset (in seconds) in offsets[0], and the time until that
* offset will be heard (in seconds) in offsets[1]. */
alGetSourcedvSOFT(source, AL_SEC_OFFSET_LATENCY_SOFT, offsets);
printf("\rOffset: %f - Latency:%3u ms ", offsets[0], (ALuint)(offsets[1]*1000));
fflush(stdout);
} while(alGetError() == AL_NO_ERROR && state == AL_PLAYING);
printf("\n");
/* All done. Delete resources, and close OpenAL. */
alDeleteSources(1, &source);
alDeleteBuffers(1, &buffer);
CloseAL();
return 0;
}
void
initializeNVPR(const char *programName)
{
has_NV_path_rendering = glutExtensionSupported("GL_NV_path_rendering");
if (has_NV_path_rendering) {
LOAD_PROC(PFNGLGENPATHSNVPROC, glGenPathsNV);
LOAD_PROC(PFNGLDELETEPATHSNVPROC, glDeletePathsNV);
LOAD_PROC(PFNGLISPATHNVPROC, glIsPathNV);
LOAD_PROC(PFNGLPATHCOMMANDSNVPROC, glPathCommandsNV);
LOAD_PROC(PFNGLPATHCOORDSNVPROC, glPathCoordsNV);
LOAD_PROC(PFNGLPATHSUBCOMMANDSNVPROC, glPathSubCommandsNV);
LOAD_PROC(PFNGLPATHSUBCOORDSNVPROC, glPathSubCoordsNV);
LOAD_PROC(PFNGLPATHSTRINGNVPROC, glPathStringNV);
LOAD_PROC(PFNGLPATHGLYPHSNVPROC, glPathGlyphsNV);
LOAD_PROC(PFNGLPATHGLYPHRANGENVPROC, glPathGlyphRangeNV);
LOAD_PROC(PFNGLWEIGHTPATHSNVPROC, glWeightPathsNV);
LOAD_PROC(PFNGLCOPYPATHNVPROC, glCopyPathNV);
LOAD_PROC(PFNGLINTERPOLATEPATHSNVPROC, glInterpolatePathsNV);
LOAD_PROC(PFNGLTRANSFORMPATHNVPROC, glTransformPathNV);
LOAD_PROC(PFNGLPATHPARAMETERIVNVPROC, glPathParameterivNV);
LOAD_PROC(PFNGLPATHPARAMETERINVPROC, glPathParameteriNV);
LOAD_PROC(PFNGLPATHPARAMETERFVNVPROC, glPathParameterfvNV);
LOAD_PROC(PFNGLPATHPARAMETERFNVPROC, glPathParameterfNV);
LOAD_PROC(PFNGLPATHDASHARRAYNVPROC, glPathDashArrayNV);
LOAD_PROC(PFNGLSTENCILFILLPATHNVPROC, glStencilFillPathNV);
LOAD_PROC(PFNGLSTENCILSTROKEPATHNVPROC, glStencilStrokePathNV);
LOAD_PROC(PFNGLSTENCILFILLPATHINSTANCEDNVPROC, glStencilFillPathInstancedNV);
LOAD_PROC(PFNGLSTENCILSTROKEPATHINSTANCEDNVPROC, glStencilStrokePathInstancedNV);
LOAD_PROC(PFNGLPATHCOLORGENNVPROC, glPathColorGenNV);
LOAD_PROC(PFNGLPATHTEXGENNVPROC, glPathTexGenNV);
LOAD_PROC(PFNGLPATHFOGGENNVPROC, glPathFogGenNV);
LOAD_PROC(PFNGLCOVERFILLPATHNVPROC, glCoverFillPathNV);
LOAD_PROC(PFNGLCOVERSTROKEPATHNVPROC, glCoverStrokePathNV);
LOAD_PROC(PFNGLCOVERFILLPATHINSTANCEDNVPROC, glCoverFillPathInstancedNV);
LOAD_PROC(PFNGLCOVERSTROKEPATHINSTANCEDNVPROC, glCoverStrokePathInstancedNV);
LOAD_PROC(PFNGLGETPATHPARAMETERIVNVPROC, glGetPathParameterivNV);
LOAD_PROC(PFNGLGETPATHPARAMETERFVNVPROC, glGetPathParameterfvNV);
LOAD_PROC(PFNGLGETPATHCOMMANDSNVPROC, glGetPathCommandsNV);
LOAD_PROC(PFNGLGETPATHCOORDSNVPROC, glGetPathCoordsNV);
LOAD_PROC(PFNGLGETPATHDASHARRAYNVPROC, glGetPathDashArrayNV);
LOAD_PROC(PFNGLGETPATHMETRICSNVPROC, glGetPathMetricsNV);
LOAD_PROC(PFNGLGETPATHMETRICRANGENVPROC, glGetPathMetricRangeNV);
LOAD_PROC(PFNGLGETPATHSPACINGNVPROC, glGetPathSpacingNV);
LOAD_PROC(PFNGLGETPATHCOLORGENIVNVPROC, glGetPathColorGenivNV);
LOAD_PROC(PFNGLGETPATHCOLORGENFVNVPROC, glGetPathColorGenfvNV);
LOAD_PROC(PFNGLGETPATHTEXGENIVNVPROC, glGetPathTexGenivNV);
LOAD_PROC(PFNGLGETPATHTEXGENFVNVPROC, glGetPathTexGenfvNV);
LOAD_PROC(PFNGLISPOINTINFILLPATHNVPROC, glIsPointInFillPathNV);
LOAD_PROC(PFNGLISPOINTINSTROKEPATHNVPROC, glIsPointInStrokePathNV);
LOAD_PROC(PFNGLGETPATHLENGTHNVPROC, glGetPathLengthNV);
LOAD_PROC(PFNGLPOINTALONGPATHNVPROC, glPointAlongPathNV);
LOAD_PROC(PFNGLPATHSTENCILFUNCNVPROC, glPathStencilFuncNV);
LOAD_PROC(PFNGLPATHSTENCILDEPTHOFFSETNVPROC, glPathStencilDepthOffsetNV);
LOAD_PROC(PFNGLPATHCOVERDEPTHFUNCNVPROC, glPathCoverDepthFuncNV);
}
}
//
// Attempt to load winsock DLL and obtain entry points to required API.
//
//
HX_RESULT HXWinSockLib::Load()
{
HXScopeLock lock((IHXMutex*)m_pLoadMutex);
HXLOGL3(HXLOG_NETW, "HXWinSockLib::Load(): usage count going to %lu", m_userCount + 1);
if(m_hLib)
{
++m_userCount;
return HXR_OK;
}
#if defined(WIN32_PLATFORM_PSPC)
const TCHAR* const pszLibName = "winsock.dll";
const TCHAR* const pszAltLibName = 0;
#elif defined(_WIN32)
const TCHAR* const pszLibName = "ws2_32.dll"; // 2.X
const TCHAR* const pszAltLibName = "winsock32.dll"; // 1.1
#else
# error fix this
#endif
HX_RESULT hr = HXR_FAIL;
HXLOGL3(HXLOG_NETW, "HXWinSockLib::Load(): loading lib");
m_hLib = LoadLibrary(pszLibName);
if(!m_hLib && pszAltLibName)
{
m_hLib = LoadLibrary(pszAltLibName);
}
if (m_hLib)
{
++m_userCount;
hr = HXR_OK;
//
// load required set of function pointers from library
//
LOAD_PROC(accept);
LOAD_PROC(bind);
LOAD_PROC(closesocket);
LOAD_PROC(WSAStartup);
LOAD_PROC(WSACleanup);
LOAD_PROC(connect);
LOAD_PROC(ioctlsocket);
LOAD_PROC(getpeername);
LOAD_PROC(getsockname);
LOAD_PROC(getsockopt);
LOAD_PROC(htonl);
LOAD_PROC(htons);
LOAD_PROC(inet_addr);
LOAD_PROC(inet_ntoa);
LOAD_PROC(listen);
LOAD_PROC(ntohl);
LOAD_PROC(ntohs);
LOAD_PROC(recv);
LOAD_PROC(recvfrom);
LOAD_PROC(select);
LOAD_PROC(send);
LOAD_PROC(sendto);
LOAD_PROC(setsockopt);
LOAD_PROC(shutdown);
LOAD_PROC(socket);
LOAD_PROC(gethostbyaddr);
LOAD_PROC(gethostbyname);
LOAD_PROC(gethostname);
LOAD_PROC(__WSAFDIsSet);
#if defined(_WINCE)
LOAD_PROC(SetLastError);
LOAD_PROC(GetLastError);
#endif
#if !defined(_WINCE)
LOAD_PROC(getservbyport);
LOAD_PROC(getservbyname);
LOAD_PROC(getprotobynumber);
LOAD_PROC(getprotobyname);
LOAD_PROC(WSASetLastError);
LOAD_PROC(WSAGetLastError);
//LOAD_PROC(WSAIsBlocking);
//LOAD_PROC(WSAUnhookBlockingHook);
//LOAD_PROC(WSASetBlockingHook);
//LOAD_PROC(WSACancelBlockingCall);
LOAD_PROC(WSAAsyncGetServByName);
LOAD_PROC(WSAAsyncGetServByPort);
LOAD_PROC(WSAAsyncGetProtoByName);
LOAD_PROC(WSAAsyncGetProtoByNumber);
LOAD_PROC(WSAAsyncGetHostByName);
LOAD_PROC(WSAAsyncGetHostByAddr);
LOAD_PROC(WSACancelAsyncRequest);
LOAD_PROC(WSAAsyncSelect);
LOAD_PROC(WSASend);
LOAD_PROC(WSASendTo);
LOAD_PROC(WSARecv);
LOAD_PROC(WSARecvFrom);
LOAD_PROC(WSAIoctl);
#endif
// everything prior to this should be succeed even with ipv4-only WinSock support
HX_ASSERT(HXR_OK == hr);
if( HXR_OK == hr )
{
// optional IPv6 api
LOAD_PROC(getaddrinfo);
LOAD_PROC(getnameinfo);
LOAD_PROC(freeaddrinfo);
hr = WinsockInit();
}
if(FAILED(hr))
{
UnLoad();
}
}
return hr;
}
