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; }