#include #include #include #include #include #include #include "Env.h" #include #include "gl/glaux.h" #include "viewperf.h" static char *GetShortVendorName(char *input); static int GetHostMemorySize(void); static char *GetHostVendor(void); static char *GetHostModel(void); static char *GetHostCPU(void); static char *GetHostOperatingSystem(void); static char *GetHostOperatingSystemRelease(void); static char *GetHostName(void); static char *GetOpenGLClientVendor(void); static char *GetOpenGLClientVersion(void); static char *GetOpenGLClientExtensions(void); static char *GetHostCPUCount(void); static char *GetHostPrimaryCacheSize(void); static char *GetHostSecondaryCacheSize(void); static char *GetWindowSystem(void); static char *GetDriverVersion(void); static int GetOpenGLBufferConfig(HDC hdc, EnvironmentInfo *info); static int GetWinEnvironInfo(EnvironmentInfo *info); /****************************************************************************** * * StringSearch - search for pattern in string * * Description: * StringSearch returns a pointer to the first occurance of pattern found in * the subject or NULL if the pattern is not found. It implements the * Knuth-Morris-Pratt pattern matching algorithm. If m is the length of the * pattern and n is the length of the subject, the complexity of the KMP * algorithm is (m+n), much better than the (m*n) complexity of the naive * nested loop algorithm. - John Dennis * * Returns: * pointer to the first occurance of pattern found the subject or NULL * * Side Effects: * None * * Errors: * None * * Revision History: * Revision 0: Author: John R. Dennis Date: Thu Aug 4 15:49:59 1994 * Initial Release * *****************************************************************************/ char * StringSearch(char *subject, char *pattern) { #define MAX_FLINK (256) int *flink, *dynamicFlink = NULL, staticFlink[MAX_FLINK]; int patternLen = strlen(pattern); int subjectLen = strlen(subject); int found = 0; int i,j; if (patternLen > MAX_FLINK) { /* -1 for NULL terminator */ dynamicFlink = malloc(patternLen * sizeof(int)); if (dynamicFlink == NULL) { fprintf(stderr, "malloc failure, line %d, file: %s, exiting...\n", __LINE__, __FILE__); exit(1); } flink = dynamicFlink; } else { flink = staticFlink; } /* Step 1: Constuct Flowchart */ flink[0] = -1; /* -1 == read next char */ for(i = 1; i < patternLen; i++) { j = flink[i-1]; while((j >= 0) && (pattern[j] != pattern[i-1])) { j = flink[j]; } flink[i] = j+1; } /* Step 2: Scan Algorithm */ for (i = j = 0; i < subjectLen; i++, j++) { while((j >= 0) && (pattern[j] != subject[i])) { j = flink[j]; } if (j == patternLen-1) { found = 1; goto exit; } } exit: if (dynamicFlink != NULL) free(dynamicFlink); if (!found) return(NULL); else return(&subject[i-patternLen+1]); #undef MAX_FLINK } /****************************************************************************** * * GetShortVendorName - return short vendor string * * Description: * some vendor strings are verbose. This function will return a shortest * vendor name it can given an arbitrary vendor string. The returned string * is allocated with malloc, it should be freed when no longer in use. The * input string is not freed or modified by this function. * * Returns: * pointer to allocated string * * Side Effects: * string allocation, string should be freed when no longer needed. * * Errors: * no errors, if function fails the string "unknown" is returned * * Revision History: * Revision 0: Author: John R. Dennis Date: Mon Aug 8 16:30:53 1994 * Initial Release * *****************************************************************************/ static char * GetShortVendorName(char *input) { int i; char *s1 = NULL; /* s1 is temp work string */ char *s2 = NULL; /* s2 is string to return */ /* duplicate input string so that we can modify it */ s1 = strdup(input); /* upcase string */ for (i = 0; s1[i]; i++) if (islower(s1[i])) s1[i] = toupper(s1[i]); /* return a short name if possible, some vendor names are verbose */ if (StringSearch(s1, "DEC") || StringSearch(s1, "DECWINDOWS") || StringSearch(s1, "Digital Equipment Corporation") || StringSearch(s1, "DigitalEquipmentCorporation")) s2 = strdup("DEC"); else if (StringSearch(s1, "SGI") || StringSearch(s1, "SILCON GRAPHICS")) s2 = strdup("SGI"); else if (StringSearch(s1, "IBM") || StringSearch(s1, "INTERNATIONAL BUSINESS MACHINES")) s2 = strdup("IBM"); else s2 = strdup(s1); free(s1); return(s2); } /****************************************************************************** * * GetHostMemorySize - Return kilobytes of memory installed on host platform * * Description: * Returns the number of kilobytes of memory installed on host platform * * Returns: * kilobytes of host platform memory * * Side Effects: * None * * Errors: * return 0 if unable to determine memory configuration * * Revision History: * Revision 0: Author: John R. Dennis Date: Thu Aug 4 15:55:19 1994 * Initial Release * *****************************************************************************/ static int GetHostMemorySize(void) { /* RESERVED_MEMORY accounts for memory reserved for extended bios data area * that is not included in the total physical memory returned from the * GlobalMemoryStatus call on x86. */ #define RESERVED_MEMORY (500000) MEMORYSTATUS MemoryStatus; MemoryStatus.dwLength = sizeof(MEMORYSTATUS); GlobalMemoryStatus(&MemoryStatus); return (MemoryStatus.dwTotalPhys + RESERVED_MEMORY) / 1024; } /****************************************************************************** * * GetHostVendor - return string naming the system vendor * * Description: * return the name of the system vendor as a string. This is to identify * manufacturer of the system. The string is allocated with malloc, it should * be freed when no longer in use. * * Returns: * pointer to allocated string * * Side Effects: * string allocation, string should be freed when no longer needed. * * Errors: * no errors, if function fails the string "unknown" is returned * * Revision History: * Revision 0: Author: John R. Dennis Date: Mon Aug 8 16:30:53 1994 * Initial Release * *****************************************************************************/ static char * GetHostVendor(void) { /* See if it's a DEC system */ char *hostModel; hostModel = GetHostModel(); if ( strstr(hostModel,"DEC") == hostModel) { free(hostModel); return(strdup("DEC")); } else { free(hostModel); return(strdup("unknown")); } } /****************************************************************************** * * GetHostModel - return string naming the host model * * Description: * return string identifying the host platform's model designation. The string * is allocated with malloc, it should be freed when no longer in use. * * Returns: * pointer to allocated string * * Side Effects: * string allocation, string should be freed when no longer needed. * * Errors: * no errors, if function fails the string "unknown" is returned * * Revision History: * Revision 0: Author: John R. Dennis Date: Mon Aug 8 16:30:53 1994 * Initial Release * *****************************************************************************/ static char * GetHostModel(void) { HKEY hkGlobal; DWORD dwType,chData=256; BYTE DataBuffer[256]; if ( RegOpenKeyEx(HKEY_LOCAL_MACHINE,"HARDWARE\\DESCRIPTION\\System", 0, KEY_READ, &hkGlobal) != ERROR_SUCCESS) { fprintf(stderr, "could not open registry key \ HKEY_LOCAL_MACHINE\\HARDWARE\\DESCRIPTION\\System\n"); return(strdup("unknown")); } if ( RegQueryValueEx(hkGlobal, "Identifier", NULL, &dwType, DataBuffer, &chData) != ERROR_SUCCESS) { fprintf(stderr, "could not read registry value \ HKEY_LOCAL_MACHINE\\HARDWARE\\DESCRIPTION\\System\\Identifier\n"); return(strdup("unknown")); } return(strdup(DataBuffer)); } /****************************************************************************** * * GetHostCPU - return string naming the host CPU * * Description: * return string identifying the host platform's CPU. The string * is allocated with malloc, it should be freed when no longer in use. * * Returns: * pointer to allocated string * * Side Effects: * string allocation, string should be freed when no longer needed. * * Errors: * no errors, if function fails the string "unknown" is returned * * Revision History: * Revision 0: Author: John R. Dennis Date: Mon Aug 8 16:30:53 1994 * Initial Release * *****************************************************************************/ static char * GetHostCPU(void) { char szRegInfoValue[1024]; HKEY hkey; DWORD rc; DWORD cb; if (!(rc = RegOpenKeyEx(HKEY_LOCAL_MACHINE, "HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0", 0, KEY_READ, &hkey))) { cb = sizeof(szRegInfoValue); rc = RegQueryValueEx(hkey, "Identifier", 0, 0, (LPBYTE)szRegInfoValue, &cb); RegCloseKey(hkey); } if (!rc) { return(strdup(szRegInfoValue)); } else return(strdup("unknown")); } /****************************************************************************** * * GetHostCPUCount - return string indicating number of host CPU's * * Description: * return string indicating number of host CPU's. The string "unknown" is * returned if the count is not determinable. The string is allocated with * malloc, it should be freed when no longer in use. * * Returns: * pointer to allocated string * * Side Effects: * string allocation, string should be freed when no longer needed. * * Errors: * no errors, if function fails the string "unknown" is returned * * Revision History: * Revision 0: Author: John R. Dennis Date: Mon Feb 27 14:18:41 EST 1995 * Initial Release * *****************************************************************************/ static char * GetHostCPUCount(void) { return(strdup("unknown")); } /****************************************************************************** * * GetHostPrimaryCacheSize - return string indicating host's primary cache (KB) * * Description: * return string indicating the number of kilobytes of primary cache on the * host's CPU, or "unknown" if not determinable. The string * is allocated with malloc, it should be freed when no longer in use. * * Returns: * pointer to allocated string * * Side Effects: * string allocation, string should be freed when no longer needed. * * Errors: * no errors, if function fails the string "unknown" is returned * * Revision History: * Revision 0: Author: John R. Dennis Date: Mon Feb 27 14:18:41 EST 1995 * Initial Release * *****************************************************************************/ static char * GetHostPrimaryCacheSize(void) { return(strdup("unknown")); } /****************************************************************************** * * GetHostSecondaryCacheSize - return string indicating host's secondary cache (KB) * * Description: * return string indicating the number of kilobytes of secondary cache on the * host's CPU, or "unknown" if not determinable. The string * is allocated with malloc, it should be freed when no longer in use. * * Returns: * pointer to allocated string * * Side Effects: * string allocation, string should be freed when no longer needed. * * Errors: * no errors, if function fails the string "unknown" is returned * * Revision History: * Revision 0: Author: John R. Dennis Date: Mon Feb 27 14:18:41 EST 1995 * Initial Release * *****************************************************************************/ static char * GetHostSecondaryCacheSize(void) { return(strdup("unknown")); } /****************************************************************************** * * GetWindowSystem - return string naming the windowing system * * Description: * return string identifying the windowing system in use on the target * device. The string is allocated with malloc, it should be freed when no * longer in use. * * Returns: * pointer to allocated string * * Side Effects: * string allocation, string should be freed when no longer needed. * * Errors: * no errors, if function fails the string "unknown" is returned * * Revision History: * Revision 0: Author: John R. Dennis Date: Mon Aug 8 16:30:53 1994 * Initial Release * *****************************************************************************/ static char * GetWindowSystem(void) { return(strdup("Win32")); } /****************************************************************************** * * GetDriverVersion - return string identifying the graphics driver * * Description: * Return string identifying the graphics driver version. If there is no * graphics driver than the string "NA" is returned. If a graphics driver * exists, but the function cannot identify it then the string "unknown" is * returned. The string is allocated with malloc, it should be freed when no * longer in use. * * Returns: * pointer to allocated string * * Side Effects: * string allocation, string should be freed when no longer needed. * * Errors: * no errors, if function fails the string "unknown" is returned * * Revision History: * Revision 0: Author: John R. Dennis Date: Mon Feb 27 15:00:18 EST 1995 * Initial Release * *****************************************************************************/ static char * GetDriverVersion(void) { return(strdup("unknown")); } /****************************************************************************** * * GetHostOperatingSystem - return string naming the host CPU operating system * * Description: * return the type of the host operating system as a string. This is to * identify what type of operating system this program is running under. The * string is allocated with malloc, it should be freed when no longer in use. * * Returns: * pointer to allocated string * * Side Effects: * string allocation, string should be freed when no longer needed. * * Errors: * no errors, if function fails the string "unknown" is returned * * Revision History: * Revision 0: Author: John R. Dennis Date: Mon Aug 8 16:30:53 1994 * Initial Release * *****************************************************************************/ static char * GetHostOperatingSystem(void) { DWORD version = GetVersion(); if (version & 0x80000000) return(strdup("Microsoft Win32s with Windows 3.1")); else return(strdup("Microsoft Windows NT")); } /****************************************************************************** * * GetHostOperatingSystemRelease - return string naming operating system release * * Description: * return the release/version of the host operating system as a string. This * is to identify what version of the operating system this program is * running under. The string is allocated with malloc, it should be freed * when no longer in use. * * Returns: * pointer to allocated string * * Side Effects: * string allocation, string should be freed when no longer needed. * * Errors: * no errors, if function fails the string "unknown" is returned * * Revision History: * Revision 0: Author: John R. Dennis Date: Mon Aug 8 16:30:53 1994 * Initial Release * *****************************************************************************/ static char * GetHostOperatingSystemRelease(void) { CHAR szRelease[256]; CHAR szTitle[128]; CHAR szDebug[16]; OSVERSIONINFO Win32VersionInformation; Win32VersionInformation.dwOSVersionInfoSize = sizeof(Win32VersionInformation); if (GetVersionEx(&Win32VersionInformation)) { szTitle[0] = 0; if (Win32VersionInformation.szCSDVersion[0] != 0) { sprintf(szTitle, ": %s", Win32VersionInformation.szCSDVersion); } szDebug[0] = 0; if (GetSystemMetrics(SM_DEBUG)) { sprintf(szDebug, " (Debug)"); } sprintf(szRelease, "Version %d.%d (Build %d%s)%s", Win32VersionInformation.dwMajorVersion, Win32VersionInformation.dwMinorVersion, Win32VersionInformation.dwBuildNumber, (LPSTR)szTitle, (LPSTR)szDebug ); return(strdup(szRelease)); } else { return(strdup("unknown")); } } /****************************************************************************** * * GetHostName - return string naming the host * * Description: * return the name of this host as a string. This is to identify which * platform this program is running on. The string is allocated with malloc, * it should be freed when no longer in use. * * Returns: * pointer to allocated string * * Side Effects: * string allocation, string should be freed when no longer needed. * * Errors: * no errors, if function fails the string "unknown" is returned * * Revision History: * Revision 0: Author: John R. Dennis Date: Mon Aug 8 16:30:53 1994 * Initial Release * *****************************************************************************/ static char * GetHostName(void) { DWORD cchBuffer = 128; BYTE szName[128]; if ( ! GetComputerName(szName,&cchBuffer)) return(strdup("unknown")); return(strdup(szName)); } /****************************************************************************** * * GetDateTime - get the current month, day, year, hour, minute * * Description: * Get the current day, month, year, hour, minute. Each is a pointer to an * integer. If the pointer is NULL then no value is returned for that * parameter, otherwise an assignment is made to the integer pointed to by * the parameter. * * month: in the range [1-12] 1=January, 12=December * day: in the range [1-31] * year: as a 4 digit number, e.g. 1994 * hour: in the range [0-23] * min: in the range [0-59] * * Returns: * 0 for success, error code otherwise * * Side Effects: * None * * Errors: * return non-zero on failure * * Revision History: * Revision 0: Author: John R. Dennis Date: Wed Aug 17 13:08:36 1994 * Initial Release * *****************************************************************************/ int GetDateTime(int *month, int *day, int *year, int *hour, int *minute) { time_t timeT; struct tm *timeTm; time(&timeT); timeTm = localtime(&timeT); if (timeTm == NULL) { fprintf(stderr, "Error calling localtime: %d\n", errno); return(errno); } if (month) *month = timeTm->tm_mon + 1; if (day) *day = timeTm->tm_mday; if (year) *year = timeTm->tm_year + 1900; if (hour) *hour = timeTm->tm_hour; if (minute) *minute = timeTm->tm_min; return(0); } /****************************************************************************** * * GetOpenGLClientVendor - return string naming the client library vendor * * Description: * return the name of the vendor supplying the OpenGL client library. The * string is allocated with malloc,it should be freed when no longer in use. * * Returns: * pointer to allocated string * * Side Effects: * string allocation, string should be freed when no longer needed. * * Errors: * no errors, if function fails the string "unknown" is returned * * Revision History: * Revision 0: Author: John R. Dennis Date: Mon Aug 8 16:30:53 1994 * Initial Release * *****************************************************************************/ static char * GetOpenGLClientVendor(void) { char *pstr; if (pstr = (char *)glGetString(GL_VENDOR)) return(GetShortVendorName(pstr)); else return(strdup("unknown")); } /****************************************************************************** * * GetOpenGLClientVersion - return string naming the client library version * * Description: * return the version of the OpenGL client library. The string is allocated * with malloc,it should be freed when no longer in use. * * Returns: * pointer to allocated string * * Side Effects: * string allocation, string should be freed when no longer needed. * * Errors: * no errors, if function fails the string "unknown" is returned * * Revision History: * Revision 0: Author: John R. Dennis Date: Mon Aug 8 16:30:53 1994 * Initial Release * *****************************************************************************/ static char * GetOpenGLClientVersion(void) { char *pstr; if (pstr = (char *)glGetString(GL_VERSION)) return(strdup(pstr)); else return(strdup("unknown")); } /****************************************************************************** * * GetOpenGLClientExtensions - return string naming the client extensions * * Description: * return the extensions supported in the OpenGL client library. The string * is allocated with malloc,it should be freed when no longer in use. * * Returns: * pointer to allocated string * * Side Effects: * string allocation, string should be freed when no longer needed. * * Errors: * no errors, if function fails the string "unknown" is returned * * Revision History: * Revision 0: Author: John R. Dennis Date: Mon Aug 8 16:30:53 1994 * Initial Release * *****************************************************************************/ static char * GetOpenGLClientExtensions(void) { char *pstr; if (pstr = (char *)glGetString(GL_EXTENSIONS)) return(strdup(pstr)); else return(strdup("unknown")); } /****************************************************************************** * * GetOpenGLBufferInfo - inquire the OpenGL buffer configuration * * Description: * Given a specfic rendering target and visual description, return the OpenGL * buffer configuration. This information includes: * * Returns: * 0 for success, error code otherwise * * Side Effects: * None * * Errors: * None * * Revision History: * Revision 0: Author: John R. Dennis Date: Thu Aug 18 10:18:45 1994 * Initial Release * *****************************************************************************/ static int GetOpenGLBufferConfig(HDC hdc, EnvironmentInfo *info) { PIXELFORMATDESCRIPTOR pfd; BufferConfig *config = &info->bufConfig; config->ipfd = GetPixelFormat(hdc); DescribePixelFormat(hdc, config->ipfd, sizeof(pfd), &pfd); config->doubleBuffer = pfd.dwFlags & PFD_DOUBLEBUFFER; config->stereo = pfd.dwFlags & PFD_STEREO; config->rgba = pfd.iPixelType == PFD_TYPE_RGBA; if (config->rgba) { config->indexSize = -1; config->redSize = pfd.cRedBits; config->greenSize = pfd.cGreenBits; config->blueSize = pfd.cBlueBits; config->alphaSize = pfd.cAlphaBits; config->accumRedSize = pfd.cAccumRedBits; config->accumGreenSize = pfd.cAccumGreenBits; config->accumBlueSize = pfd.cAccumBlueBits; config->accumAlphaSize = pfd.cAccumAlphaBits; } else { config->indexSize = pfd.cColorBits; config->redSize = -1; config->greenSize = -1; config->blueSize = -1; config->alphaSize = -1; config->accumRedSize = -1; config->accumGreenSize = -1; config->accumBlueSize = -1; config->accumAlphaSize = -1; } config->depthSize = pfd.cDepthBits; config->stencilSize = pfd.cStencilBits; config->auxBuffers = pfd.cAuxBuffers; config->level = pfd.iLayerType; return 0; } static int GetWinEnvironInfo(EnvironmentInfo *info) { HWND hwnd; HDC hdc; RECT rc; hdc = auxGetHDC(); if (!hdc) { fprintf(stderr, "GetWinEnvironInfo: no display set\n"); return(1); } hwnd = auxGetHWND(); if (!hwnd) { fprintf(stderr, "GetWinEnvironInfo: no window set\n"); return(1); } GetClientRect(hwnd, &rc); info->windowWidth = rc.right - rc.left; info->windowHeight = rc.bottom - rc.top; info->screenWidth = GetDeviceCaps(hdc, HORZRES); info->screenHeight = GetDeviceCaps(hdc, VERTRES); GetOpenGLBufferConfig(hdc, info); return(0); } /****************************************************************************** * * GetEnvironment - return info about environment test was run in * * Description: * This function fills in an environment info record with every pertinent * piece of information about the condiditons under which the test was run. * * Returns: * 0 success, error code otherwise * * Side Effects: * None * * Errors: * errors generally only with bad configurations, too many to list * * Revision History: * Revision 0: Author: John R. Dennis Date: Thu Aug 18 16:52:35 1994 * Initial Release * *****************************************************************************/ int GetEnvironment(EnvironmentInfo *info) { FreeEnvironmentData(info); GetDateTime(&info->month, &info->day, &info->year, NULL, NULL); info->host = GetHostName(); info->hostOperatingSystem = GetHostOperatingSystem(); info->hostOperatingSystemVersion = GetHostOperatingSystemRelease(); info->hostVendor = GetHostVendor(); info->hostModel = GetHostModel(); info->hostCPU = GetHostCPU(); info->hostCPUCount = GetHostCPUCount(); info->hostPrimaryCacheSize = GetHostPrimaryCacheSize(); info->hostSecondaryCacheSize = GetHostSecondaryCacheSize(); info->windowSystem = GetWindowSystem(); info->driverVersion = GetDriverVersion(); info->hostMemorySize = GetHostMemorySize() / 1024; /* kilobytes to MB */ info->glVendor = GetShortVendorName((char *)glGetString(GL_VENDOR)); info->glVersion = strdup((char *)glGetString(GL_VERSION)); info->glRenderer = strdup((char *)glGetString(GL_RENDERER)); info->glExtensions = strdup((char *)glGetString(GL_EXTENSIONS)); info->glClientVendor = GetOpenGLClientVendor(); info->glClientVersion = GetOpenGLClientVersion(); info->glClientExtensions = GetOpenGLClientExtensions(); #ifdef GLU_VERSION_1_1 info->gluVersion = strdup((char *)gluGetString(GLU_VERSION));; info->gluExtensions = strdup((char *)gluGetString(GLU_EXTENSIONS));; #else info->gluVersion = strdup("unknown"); info->gluExtensions = strdup("unknown"); #endif GetWinEnvironInfo(info); #if defined(WIN32) /* * There is no direct rendering at this time. */ info->directRender = FALSE; #else /* * Direct rendering is a "request", not a guarantee. We need to check the * direct render bit for each test because the GL context is only set up * in the above conditional block. If we didn't check it for each test * then the value for direct rendering store in the test descriptor would * be the "request" value, not the actual value. */ windType = auxGetDisplayMode(); if (windType & AUX_DIRECT) info->directRender = TRUE; else info->directRender = FALSE; #endif return (0); } /****************************************************************************** * * FreeEnvironmentData - frees all dynamic data in EnvironmentInfo struct * * Description: * Free all the dynamically allocated data in an EnvironmentInfo struct. Each * pointer in the struct is assigned the value of NULL after its data has * been freed. The struct itself is not freed. * * Returns: * void * * Side Effects: * free dynamically allocated memory * * Errors: * None * * Revision History: * Revision 0: Author: John R. Dennis Date: Tue Sep 13 17:31:19 1994 * Initial Release * *****************************************************************************/ void FreeEnvironmentData(EnvironmentInfo *info) { if (info->host != NULL) free(info->host); if (info->hostOperatingSystem != NULL) free(info->hostOperatingSystem); if (info->hostOperatingSystemVersion != NULL) free(info->hostOperatingSystemVersion); if (info->hostVendor != NULL) free(info->hostVendor); if (info->hostModel != NULL) free(info->hostModel); if (info->hostCPU != NULL) free(info->hostCPU); if (info->hostCPUCount != NULL) free(info->hostCPUCount); if (info->hostPrimaryCacheSize != NULL) free(info->hostPrimaryCacheSize); if (info->hostSecondaryCacheSize != NULL) free(info->hostSecondaryCacheSize); if (info->windowSystem != NULL) free(info->windowSystem); if (info->driverVersion != NULL) free(info->driverVersion); if (info->glVendor != NULL) free(info->glVendor); if (info->glVersion != NULL) free(info->glVersion); if (info->glRenderer != NULL) free(info->glRenderer); if (info->glExtensions != NULL) free(info->glExtensions); if (info->glClientVendor != NULL) free(info->glClientVendor); if (info->glClientVersion != NULL) free(info->glClientVersion); if (info->glClientExtensions != NULL) free(info->glClientExtensions); if (info->gluVersion != NULL) free(info->gluVersion); if (info->gluExtensions != NULL) free(info->gluExtensions); NullEnvironmentData(info); } /****************************************************************************** * * NullEnvironmentData - sets all dynamic data ptrs in EnvironmentInfo to NULL * * Description: * Sets all the pointers to dynamically allocated data in an EnvironmentInfo * struct to NULL. The data pointed to by the pointers are not freed, use the * function FreeEnvironmentData for that purpose. * * Returns: * void * * Side Effects: * None * * Errors: * None * * Revision History: * Revision 0: Author: John R. Dennis Date: Tue Sep 13 17:31:19 1994 * Initial Release * *****************************************************************************/ void NullEnvironmentData(EnvironmentInfo *info) { info->host = NULL; info->hostOperatingSystem = NULL; info->hostOperatingSystemVersion = NULL; info->hostVendor = NULL; info->hostModel = NULL; info->hostCPU = NULL; info->hostCPUCount = NULL; info->hostPrimaryCacheSize = NULL; info->hostSecondaryCacheSize = NULL; info->windowSystem = NULL; info->driverVersion = NULL; info->glVendor = NULL; info->glVersion = NULL; info->glRenderer = NULL; info->glExtensions = NULL; info->glClientVendor = NULL; info->glClientVersion = NULL; info->glClientExtensions = NULL; info->gluVersion = NULL; info->gluExtensions = NULL; } /****************************************************************************** * * PrintEnvironment - print contents of EnvironmentInfo struct * * Description: * Print the contents of EnvironmentInfo struct. The stream parameter Points * to a FILE structure specifying an open stream to which output will be * written. The title parameter is a pointer to a string which will be output * before any of the EnvironmentInfo data is output, The title string may be * NULL in which case no title string will be written. The leader parameter * is a pointer to a string which will be output before each field in the * EnvironmentInfo struct. The nameWidth parameter is an integer parameter * specifying how pad the name of each field. This can be used to cause the * values to line up in a column. A positive value left justifies, a negative * value right justifies. The suffix parameter is a pointer to a string which * will be output after all of the EnvironmentInfo data is output, The suffix * string may be NULL in which case no suffix string will be written. * * Returns: * void * * Side Effects: * file stream output * * Errors: * None * * Revision History: * Revision 0: Author: John R. Dennis Date: Wed Sep 14 09:02:57 1994 * Initial Release * *****************************************************************************/ void PrintEnvironment(FILE *stream, EnvironmentInfo *info, char *title, char *leader, int nameWidth, char *suffix) { if (title) fprintf(stream, "%s", title); fprintf(stream, "%s%*s%d\n", leader, nameWidth, "Month", info->month); fprintf(stream, "%s%*s%d\n", leader, nameWidth, "Day", info->day); fprintf(stream, "%s%*s%d\n", leader, nameWidth, "Year", info->year); fprintf(stream, "%s%*s%s\n", leader, nameWidth, "Host", info->host); fprintf(stream, "%s%*s%s\n", leader, nameWidth, "Operating System", info->hostOperatingSystem); fprintf(stream, "%s%*s%s\n", leader, nameWidth, "Operating System Version", info->hostOperatingSystemVersion); fprintf(stream, "%s%*s%s\n", leader, nameWidth, "Host Vendor", info->hostVendor); fprintf(stream, "%s%*s%s\n", leader, nameWidth, "Host Model", info->hostModel); fprintf(stream, "%s%*s%s\n", leader, nameWidth, "Host CPU", info->hostCPU); fprintf(stream, "%s%*s%s\n", leader, nameWidth, "Host CPU Count", info->hostCPUCount); fprintf(stream, "%s%*s%d\n", leader, nameWidth, "Host Memory Size (MB)", info->hostMemorySize); fprintf(stream, "%s%*s%s\n", leader, nameWidth, "Host Primary Cache Size (KB)", info->hostPrimaryCacheSize); fprintf(stream, "%s%*s%s\n", leader, nameWidth, "Host Secondary Cache Size (KB)", info->hostSecondaryCacheSize); fprintf(stream, "%s%*s%s\n", leader, nameWidth, "Window System", info->windowSystem); fprintf(stream, "%s%*s%s\n", leader, nameWidth, "Driver Version", info->driverVersion); fprintf(stream, "%s%*s%s\n", leader, nameWidth, "OpenGL Vendor", info->glVendor); fprintf(stream, "%s%*s%s\n", leader, nameWidth, "OpenGL Version", info->glVersion); fprintf(stream, "%s%*s%s\n", leader, nameWidth, "OpenGL Extensions", info->glExtensions); fprintf(stream, "%s%*s%s\n", leader, nameWidth, "OpenGL Renderer", info->glRenderer); fprintf(stream, "%s%*s%s\n", leader, nameWidth, "OpenGL Client Vendor", info->glClientVendor); fprintf(stream, "%s%*s%s\n", leader, nameWidth, "OpenGL Client Version", info->glClientVersion); fprintf(stream, "%s%*s%s\n", leader, nameWidth, "OpenGL Client Extensions", info->glClientExtensions); fprintf(stream, "%s%*s%s\n", leader, nameWidth, "GLU Version", info->gluVersion); fprintf(stream, "%s%*s%s\n", leader, nameWidth, "GLU Extensions", info->gluExtensions); fprintf(stream, "%s%*s%s\n", leader, nameWidth, "Direct Rendering", info->directRender ? "True" : "False"); fprintf(stream, "%s%*s%s\n", leader, nameWidth, "Double Buffer", info->bufConfig.doubleBuffer ? "True" : "False"); fprintf(stream, "%s%*s%s\n", leader, nameWidth, "Stereo", info->bufConfig.stereo ? "True" : "False"); fprintf(stream, "%s%*s%s\n", leader, nameWidth, "RGBA", info->bufConfig.rgba ? "True" : "False"); fprintf(stream, "%s%*s%d\n", leader, nameWidth, "Color Index Size", info->bufConfig.indexSize); fprintf(stream, "%s%*s%d\n", leader, nameWidth, "Red Size", info->bufConfig.redSize); fprintf(stream, "%s%*s%d\n", leader, nameWidth, "Green Size", info->bufConfig.greenSize); fprintf(stream, "%s%*s%d\n", leader, nameWidth, "Blue Size", info->bufConfig.blueSize); fprintf(stream, "%s%*s%d\n", leader, nameWidth, "Alpha Size", info->bufConfig.alphaSize); fprintf(stream, "%s%*s%d\n", leader, nameWidth, "Accum Red Size", info->bufConfig.accumRedSize); fprintf(stream, "%s%*s%d\n", leader, nameWidth, "Accum Green Size", info->bufConfig.accumGreenSize); fprintf(stream, "%s%*s%d\n", leader, nameWidth, "Accum Blue Size", info->bufConfig.accumBlueSize); fprintf(stream, "%s%*s%d\n", leader, nameWidth, "Accum Alpha Size", info->bufConfig.accumAlphaSize); fprintf(stream, "%s%*s%d\n", leader, nameWidth, "Depth Size", info->bufConfig.depthSize); fprintf(stream, "%s%*s%d\n", leader, nameWidth, "Stencil Size", info->bufConfig.stencilSize); fprintf(stream, "%s%*s%d\n", leader, nameWidth, "Auxiliary Buffer Count", info->bufConfig.auxBuffers); fprintf(stream, "%s%*s%d\n", leader, nameWidth, "Frame BufferLevel", info->bufConfig.level); fprintf(stream, "%s%*s%d\n", leader, nameWidth, "Window Width (pixels)", info->windowWidth); fprintf(stream, "%s%*s%d\n", leader, nameWidth, "Window Height (pixels)", info->windowHeight); fprintf(stream, "%s%*s%d\n", leader, nameWidth, "Screen Width (pixels)", info->screenWidth); fprintf(stream, "%s%*s%d\n", leader, nameWidth, "Screen Height (pixels)", info->screenHeight); fprintf(stream, "%s%*s%d\n", leader, nameWidth, "Pixel Format ID", info->bufConfig.ipfd); if (suffix) fprintf(stream, "%s", suffix); }