15 #include "winGraphicsPipe.h"
16 #include "config_windisplay.h"
17 #include "displaySearchParameters.h"
18 #include "displayInformation.h"
19 #include "dtool_config.h"
31 #ifndef MAXIMUM_PROCESSORS
32 #define MAXIMUM_PROCESSORS 32
35 typedef enum _Process_DPI_Awareness {
36 Process_DPI_Unaware = 0,
37 Process_System_DPI_Aware = 1,
38 Process_Per_Monitor_DPI_Aware = 2
39 } Process_DPI_Awareness;
47 ULONG CurrentIdleState;
50 typedef BOOL (WINAPI *GetProcessMemoryInfoType) (HANDLE Process, PROCESS_MEMORY_COUNTERS *ppsmemCounters, DWORD cb);
51 typedef BOOL (WINAPI *GlobalMemoryStatusExType) (LPMEMORYSTATUSEX lpBuffer);
52 typedef long (__stdcall *CallNtPowerInformationType) (POWER_INFORMATION_LEVEL information_level, PVOID InputBuffer, ULONG InputBufferLength, PVOID OutputBuffer, ULONG OutputBufferLength);
54 static int initialize =
false;
55 static HMODULE psapi_dll = 0;
56 static HMODULE kernel32_dll = 0;
57 static HMODULE power_dll = 0;
58 static GetProcessMemoryInfoType GetProcessMemoryInfoFunction = 0;
59 static GlobalMemoryStatusExType GlobalMemoryStatusExFunction = 0;
60 static CallNtPowerInformationType CallNtPowerInformationFunction = 0;
63 if (initialize ==
false) {
64 psapi_dll = LoadLibrary(
"psapi.dll");
66 GetProcessMemoryInfoFunction = (GetProcessMemoryInfoType) GetProcAddress(psapi_dll,
"GetProcessMemoryInfo");
69 kernel32_dll = LoadLibrary(
"kernel32.dll");
71 GlobalMemoryStatusExFunction = (GlobalMemoryStatusExType) GetProcAddress(kernel32_dll,
"GlobalMemoryStatusEx");
77 if (GlobalMemoryStatusExFunction) {
78 MEMORYSTATUSEX memory_status;
80 memory_status.dwLength =
sizeof(MEMORYSTATUSEX);
81 if (GlobalMemoryStatusExFunction(&memory_status)) {
82 display_information->_physical_memory = memory_status.ullTotalPhys;
83 display_information->_available_physical_memory = memory_status.ullAvailPhys;
84 display_information->_page_file_size = memory_status.ullTotalPageFile;
85 display_information->_available_page_file_size = memory_status.ullAvailPageFile;
86 display_information->_process_virtual_memory = memory_status.ullTotalVirtual;
87 display_information->_available_process_virtual_memory = memory_status.ullAvailVirtual;
88 display_information->_memory_load = memory_status.dwMemoryLoad;
91 MEMORYSTATUS memory_status;
93 memory_status.dwLength =
sizeof(MEMORYSTATUS);
94 GlobalMemoryStatus (&memory_status);
96 display_information->_physical_memory = memory_status.dwTotalPhys;
97 display_information->_available_physical_memory = memory_status.dwAvailPhys;
98 display_information->_page_file_size = memory_status.dwTotalPageFile;
99 display_information->_available_page_file_size = memory_status.dwAvailPageFile;
100 display_information->_process_virtual_memory = memory_status.dwTotalVirtual;
101 display_information->_available_process_virtual_memory = memory_status.dwAvailVirtual;
102 display_information->_memory_load = memory_status.dwMemoryLoad;
105 if (GetProcessMemoryInfoFunction) {
108 PROCESS_MEMORY_COUNTERS process_memory_counters;
110 process_id = GetCurrentProcessId();
111 process = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, process_id);
113 if (GetProcessMemoryInfoFunction (process, &process_memory_counters,
sizeof(PROCESS_MEMORY_COUNTERS))) {
114 display_information->_page_fault_count = process_memory_counters.PageFaultCount;
115 display_information->_process_memory = process_memory_counters.WorkingSetSize;
116 display_information->_peak_process_memory = process_memory_counters.PeakWorkingSetSize;
117 display_information->_page_file_usage = process_memory_counters.PagefileUsage;
118 display_information->_peak_page_file_usage = process_memory_counters.PeakPagefileUsage;
121 CloseHandle(process);
127 PN_uint64 long_integer;
131 PN_uint64 cpu_time_function (
void) {
138 long_integer_pointer = &long_integer;
141 mov ebx,[long_integer_pointer]
147 return long_integer.long_integer;
169 int maximum_cpu_id_input;
170 char cpu_vendor [16];
183 unsigned int version_information;
185 unsigned int stepping_id : 4;
186 unsigned int model : 4;
187 unsigned int family : 4;
188 unsigned int processor_type : 2;
189 unsigned int reserved_0 : 2;
190 unsigned int extended_model_id : 4;
191 unsigned int extended_family_id : 8;
192 unsigned int reserved_1 : 4;
200 unsigned int brand_index : 8;
201 unsigned int clflush : 8;
202 unsigned int maximum_logical_processors : 8;
203 unsigned int initial_apic_id : 8;
211 unsigned int sse3 : 1;
212 unsigned int reserved_1_to_2 : 2;
213 unsigned int monitor : 1;
214 unsigned int ds_cpl : 1;
215 unsigned int vmx : 1;
216 unsigned int reserved_6 : 1;
217 unsigned int est : 1;
218 unsigned int tm2 : 1;
219 unsigned int reserved_9 : 1;
220 unsigned int cnxt_id : 1;
221 unsigned int reserved_11_to_12 : 2;
222 unsigned int cmpxchg16b : 1;
223 unsigned int xtpr_disable : 1;
224 unsigned int reserved_15_to_31 : 17;
232 unsigned int fpu : 1;
233 unsigned int vme : 1;
235 unsigned int pse : 1;
236 unsigned int tsc : 1;
237 unsigned int msr : 1;
238 unsigned int pae : 1;
239 unsigned int mce : 1;
240 unsigned int cx8 : 1;
241 unsigned int apic : 1;
242 unsigned int reserved_10 : 1;
243 unsigned int sep : 1;
244 unsigned int mtrr : 1;
245 unsigned int pge : 1;
246 unsigned int mca : 1;
247 unsigned int cmov : 1;
248 unsigned int pat : 1;
249 unsigned int pse_36 : 1;
250 unsigned int psn : 1;
251 unsigned int cflush : 1;
252 unsigned int reserved_20 : 1;
254 unsigned int acpi : 1;
255 unsigned int mmx : 1;
256 unsigned int fxsr : 1;
257 unsigned int sse : 1;
258 unsigned int sse2 : 1;
260 unsigned int htt : 1;
262 unsigned int reserved_30 : 1;
263 unsigned int pbe : 1;
270 #define MAXIMUM_CHARACTERS (MAXIMUM_2 * sizeof(CPU_ID_REGISTERS))
274 unsigned char character_array_2 [MAXIMUM_CHARACTERS];
302 unsigned int l1_data_cache_line_size : 8;
303 unsigned int l1_data_reserved_8_to_15 : 8;
304 unsigned int l1_data_associativity : 8;
305 unsigned int l1_data_cache_size : 8;
311 unsigned int l1_code_cache_line_size : 8;
312 unsigned int l1_code_reserved_8_to_15 : 8;
313 unsigned int l1_code_associativity : 8;
314 unsigned int l1_code_cache_size : 8;
328 unsigned int l2_cache_line_size : 8;
329 unsigned int l2_reserved_8_to_11 : 4;
330 unsigned int l2_associativity : 4;
331 unsigned int l2_cache_size : 16;
341 unsigned int cache_line_size;
342 unsigned int log_base_2_cache_line_size;
361 cpu_id_binary_data->cpu_id_registers_0 = cpu_id->cpu_id_registers_0;
362 cpu_id_binary_data->cpu_id_registers_1 = cpu_id->cpu_id_registers_1;
363 cpu_id_binary_data->cpu_id_registers_0x80000000 = cpu_id->cpu_id_registers_0x80000000;
364 cpu_id_binary_data->cpu_id_registers_0x80000001 = cpu_id->cpu_id_registers_0x80000001;
365 cpu_id_binary_data->cpu_id_registers_0x80000002 = cpu_id->cpu_id_registers_0x80000002;
366 cpu_id_binary_data->cpu_id_registers_0x80000003 = cpu_id->cpu_id_registers_0x80000003;
367 cpu_id_binary_data->cpu_id_registers_0x80000004 = cpu_id->cpu_id_registers_0x80000004;
368 cpu_id_binary_data->cpu_id_registers_0x80000006 = cpu_id->cpu_id_registers_0x80000006;
369 cpu_id_binary_data->cpu_id_registers_0x80000008 = cpu_id->cpu_id_registers_0x80000008;
373 memset (cpu_id, 0,
sizeof(
CPU_ID));
375 cpu_id->cpu_id_registers_0 = cpu_id_binary_data->cpu_id_registers_0;
376 cpu_id->cpu_id_registers_1 = cpu_id_binary_data->cpu_id_registers_1;
377 cpu_id->cpu_id_registers_0x80000000 = cpu_id_binary_data->cpu_id_registers_0x80000000;
378 cpu_id->cpu_id_registers_0x80000001 = cpu_id_binary_data->cpu_id_registers_0x80000001;
379 cpu_id->cpu_id_registers_0x80000002 = cpu_id_binary_data->cpu_id_registers_0x80000002;
380 cpu_id->cpu_id_registers_0x80000003 = cpu_id_binary_data->cpu_id_registers_0x80000003;
381 cpu_id->cpu_id_registers_0x80000004 = cpu_id_binary_data->cpu_id_registers_0x80000004;
382 cpu_id->cpu_id_registers_0x80000006 = cpu_id_binary_data->cpu_id_registers_0x80000006;
383 cpu_id->cpu_id_registers_0x80000008 = cpu_id_binary_data->cpu_id_registers_0x80000008;
391 if (input_eax == 0) {
394 __cpuid((
int*)cpu_id_registers, input_eax);
395 unsigned int tmp = cpu_id_registers->edx;
396 cpu_id_registers->edx = cpu_id_registers->ecx;
397 cpu_id_registers->ecx = tmp;
401 mov edi, [cpu_id_registers]
413 __cpuid((
int*)cpu_id_registers, input_eax);
417 mov edi, [cpu_id_registers]
438 void parse_cpu_id(
CPU_ID *cpu_id) {
440 printf(
" vendor = %s\n", cpu_id->cpu_vendor);
441 printf(
" brand string %s\n", cpu_id->cpu_brand_string);
442 printf(
" maximum_cpu_id_input = %u\n", cpu_id->maximum_cpu_id_input);
443 printf(
" maximum extended information = 0x%X\n", cpu_id->cpu_id_registers_0x80000000.eax);
445 printf(
" MMX = %u\n", cpu_id->mmx);
446 printf(
" SSE = %u\n", cpu_id->sse);
447 printf(
" SSE2 = %u\n", cpu_id->sse2);
448 printf(
" SSE3 = %u\n", cpu_id->sse3);
450 printf(
" EST = %u\n", cpu_id->est);
452 if (cpu_id->maximum_cpu_id_input >= 1) {
453 printf(
" version_information\n");
454 printf(
" stepping_id %u\n", cpu_id->stepping_id);
455 printf(
" model %u\n", cpu_id->model);
456 printf(
" family %u\n", cpu_id->family);
457 printf(
" processor_type %u\n", cpu_id->processor_type);
458 printf(
" extended_model_id %u\n", cpu_id->extended_model_id);
459 printf(
" extended_family_id %u\n", cpu_id->extended_family_id);
461 printf(
" brand_index %u\n", cpu_id->brand_index);
462 printf(
" clflush %u\n", cpu_id->clflush);
463 printf(
" maximum_logical_processors %u\n", cpu_id->maximum_logical_processors);
464 printf(
" initial_apic_id %u\n", cpu_id->initial_apic_id);
470 if (cpu_id->cpu_id_registers_0x80000000.eax >= 0x80000005) {
471 printf(
" l1_data_cache_line_size %d\n", cpu_id->l1_data_cache_line_size);
472 printf(
" l1_data_associativity %d\n", cpu_id->l1_data_associativity);
473 printf(
" l1_data_cache_size %dK\n", cpu_id->l1_data_cache_size);
475 printf(
" l1_code_cache_line_size %d\n", cpu_id->l1_code_cache_line_size);
476 printf(
" l1_code_associativity %d\n", cpu_id->l1_code_associativity);
477 printf(
" l1_code_cache_size %dK\n", cpu_id->l1_code_cache_size);
480 if (cpu_id->cpu_id_registers_0x80000000.eax >= 0x80000006) {
481 printf(
" l2_cache_line_size %d\n", cpu_id->l2_cache_line_size);
482 printf(
" l2_associativity %d\n", cpu_id->l2_associativity);
483 printf(
" l2_cache_size %dK\n", cpu_id->l2_cache_size);
487 int initialize_cpu_id(
CPU_ID *cpu_id) {
489 memset(cpu_id, 0,
sizeof(
CPU_ID));
491 if (cpuid(0, &cpu_id->cpu_id_registers_0)) {
492 if (cpu_id->maximum_cpu_id_input >= 1) {
493 cpuid(1, &cpu_id->cpu_id_registers_1);
495 if (cpu_id->maximum_cpu_id_input >= 2) {
498 cpuid(2, &cpu_id->cpu_id_registers_2);
500 printf(
" al = %u\n", cpu_id->cpu_id_registers_2.al);
503 for (index = 1; index < cpu_id->cpu_id_registers_2.al && index < MAXIMUM_2; index++) {
504 cpuid(2, &cpu_id->cpu_id_registers_2_array [index]);
507 for (index = 1; index < MAXIMUM_CHARACTERS; index++) {
508 if (cpu_id->character_array_2 [index]) {
510 printf(
" cache/TLB byte = %X\n", cpu_id->character_array_2 [index]);
512 switch (cpu_id->character_array_2 [index]) {
515 cpu_id->cache_line_size = 32;
516 cpu_id->log_base_2_cache_line_size = 5;
524 cpu_id->cache_line_size = 64;
525 cpu_id->log_base_2_cache_line_size = 6;
532 cpuid(0x80000000, &cpu_id->cpu_id_registers_0x80000000);
534 if (cpu_id->cpu_id_registers_0x80000000.eax >= 0x80000001) {
535 cpuid(0x80000001, &cpu_id->cpu_id_registers_0x80000001);
538 if (cpu_id->cpu_id_registers_0x80000000.eax >= 0x80000004) {
539 cpuid(0x80000002, &cpu_id->cpu_id_registers_0x80000002);
540 cpuid(0x80000003, &cpu_id->cpu_id_registers_0x80000003);
541 cpuid(0x80000004, &cpu_id->cpu_id_registers_0x80000004);
544 if (cpu_id->cpu_id_registers_0x80000000.eax >= 0x80000005) {
545 cpuid(0x80000005, &cpu_id->cpu_id_registers_0x80000005);
548 if (cpu_id->cpu_id_registers_0x80000000.eax >= 0x80000006) {
549 cpuid(0x80000006, &cpu_id->cpu_id_registers_0x80000006);
552 if (cpu_id->cpu_id_registers_0x80000000.eax >= 0x80000008) {
553 cpuid(0x80000008, &cpu_id->cpu_id_registers_0x80000008);
562 int update_cpu_frequency_function(
int processor_number,
DisplayInformation *display_information) {
566 display_information->_maximum_cpu_frequency = 0;
567 display_information->_current_cpu_frequency = 0;
569 if (CallNtPowerInformationFunction) {
574 ULONG input_buffer_size;
575 ULONG output_buffer_size;
576 POWER_INFORMATION_LEVEL information_level;
582 processor_power_information = processor_power_information_array;
583 for (i = 0; i < MAXIMUM_PROCESSORS; i++) {
584 processor_power_information->Number = 0xFFFFFFFF;
585 processor_power_information++;
588 information_level = ProcessorInformation;
590 output_buffer = processor_power_information_array;
591 input_buffer_size = 0;
593 if (CallNtPowerInformationFunction(information_level, input_buffer, input_buffer_size, output_buffer, output_buffer_size) == 0) {
594 processor_power_information = processor_power_information_array;
595 for (i = 0; i < MAXIMUM_PROCESSORS; i++) {
596 if (processor_power_information->Number == processor_number) {
599 value = processor_power_information->MaxMhz;
600 display_information->_maximum_cpu_frequency = value * 1000000;
602 value = processor_power_information->CurrentMhz;
603 display_information->_current_cpu_frequency = value * 1000000;
609 processor_power_information++;
619 int num_cpu_cores = 0;
620 int num_logical_cpus = 0;
623 typedef BOOL (WINAPI *LPFN_GLPI)(PSYSTEM_LOGICAL_PROCESSOR_INFORMATION,
626 glpi = (LPFN_GLPI)GetProcAddress(GetModuleHandle(TEXT(
"kernel32")),
627 "GetLogicalProcessorInformation");
629 windisplay_cat.info()
630 <<
"GetLogicalProcessorInformation is not supported.\n";
636 PSYSTEM_LOGICAL_PROCESSOR_INFORMATION buffer = NULL;
637 DWORD buffer_length = 0;
638 DWORD rc = glpi(buffer, &buffer_length);
640 if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
641 if (buffer != NULL) {
642 PANDA_FREE_ARRAY(buffer);
645 buffer = (PSYSTEM_LOGICAL_PROCESSOR_INFORMATION)PANDA_MALLOC_ARRAY(buffer_length);
646 nassertv(buffer != NULL);
648 windisplay_cat.info()
649 <<
"GetLogicalProcessorInformation failed: " << GetLastError()
653 rc = glpi(buffer, &buffer_length);
657 PSYSTEM_LOGICAL_PROCESSOR_INFORMATION ptr = buffer;
658 PSYSTEM_LOGICAL_PROCESSOR_INFORMATION end = (PSYSTEM_LOGICAL_PROCESSOR_INFORMATION)((
char *)buffer + buffer_length);
661 if (ptr->Relationship == RelationProcessorCore) {
665 num_logical_cpus += count_bits_in_word((PN_uint64)(ptr->ProcessorMask));
670 PANDA_FREE_ARRAY(buffer);
672 windisplay_cat.info()
673 << num_cpu_cores <<
" CPU cores, with "
674 << num_logical_cpus <<
" logical processors.\n";
676 display_information->_num_cpu_cores = num_cpu_cores;
677 display_information->_num_logical_cpus = num_logical_cpus;
690 _supported_types = OT_window | OT_fullscreen_window;
694 _pfnTrackMouseEvent = NULL;
696 _hUser32 = (HINSTANCE)LoadLibrary(
"user32.dll");
697 if (_hUser32 != NULL) {
698 _pfnTrackMouseEvent =
699 (PFN_TRACKMOUSEEVENT)GetProcAddress(_hUser32,
"TrackMouseEvent");
702 typedef HRESULT (WINAPI *PFN_SETPROCESSDPIAWARENESS)(Process_DPI_Awareness);
703 PFN_SETPROCESSDPIAWARENESS pfnSetProcessDpiAwareness =
704 (PFN_SETPROCESSDPIAWARENESS)GetProcAddress(_hUser32,
"SetProcessDpiAwarenessInternal");
706 if (pfnSetProcessDpiAwareness == NULL) {
707 if (windisplay_cat.is_debug()) {
708 windisplay_cat.debug() <<
"Unable to find SetProcessDpiAwareness in user32.dll.\n";
711 if (windisplay_cat.is_debug()) {
712 windisplay_cat.debug() <<
"Calling SetProcessDpiAwareness().\n";
714 pfnSetProcessDpiAwareness(Process_Per_Monitor_DPI_Aware);
721 if (request_dxdisplay_information) {
722 if (windisplay_cat.is_debug()) {
723 windisplay_cat.debug() <<
"Using Direct3D 9 to fetch display information.\n";
727 dx9_display_information(display_search_parameters_dx9, _display_information);
732 if (windisplay_cat.is_debug()) {
733 windisplay_cat.debug() <<
"Using EnumDisplaySettings to fetch display information.\n";
737 dm.dmSize =
sizeof(dm);
738 for (
int i = 0; EnumDisplaySettings(NULL, i, &dm) != 0; ++i) {
740 mode.width = dm.dmPelsWidth;
741 mode.height = dm.dmPelsHeight;
742 mode.bits_per_pixel = dm.dmBitsPerPel;
743 mode.refresh_rate = dm.dmDisplayFrequency;
744 mode.fullscreen_only = 0;
745 if (i == 0 || mode != display_modes.back()) {
746 display_modes.push_back(mode);
751 _display_information->_total_display_modes = display_modes.size();
752 if (!display_modes.empty()) {
753 _display_information->_display_mode_array =
new DisplayMode[display_modes.size()];
754 std::copy(display_modes.begin(), display_modes.end(),
755 _display_information->_display_mode_array);
763 OSVERSIONINFO version_info;
765 version_info.dwOSVersionInfoSize =
sizeof(OSVERSIONINFO);
766 if (GetVersionEx(&version_info)) {
767 if (windisplay_cat.is_info()) {
768 sprintf(
string,
"OS version: %d.%d.%d.%d\n", version_info.dwMajorVersion, version_info.dwMinorVersion, version_info.dwPlatformId, version_info.dwBuildNumber);
769 windisplay_cat.info() << string;
770 windisplay_cat.info() <<
" " << version_info.szCSDVersion <<
"\n";
773 _display_information->_os_version_major = version_info.dwMajorVersion;
774 _display_information->_os_version_minor = version_info.dwMinorVersion;
775 _display_information->_os_version_build = version_info.dwBuildNumber;
776 _display_information->_os_platform_id = version_info.dwPlatformId;
779 _display_width = GetSystemMetrics(SM_CXSCREEN);
780 _display_height = GetSystemMetrics(SM_CYSCREEN);
784 power_dll = LoadLibrary(
"PowrProf.dll");
786 CallNtPowerInformationFunction = (CallNtPowerInformationType) GetProcAddress(power_dll,
"CallNtPowerInformation");
787 if (CallNtPowerInformationFunction) {
789 _display_information->_update_cpu_frequency_function = update_cpu_frequency_function;
790 update_cpu_frequency_function(0, _display_information);
792 sprintf(
string,
"max Mhz %I64d, current Mhz %I64d\n", _display_information->_maximum_cpu_frequency, _display_information->_current_cpu_frequency);
794 windisplay_cat.info() << string;
811 _display_information->_get_memory_information_function = get_memory_information;
814 _display_information->_cpu_time_function = cpu_time_function;
819 LARGE_INTEGER counter;
821 LARGE_INTEGER frequency;
825 counter.QuadPart = 0;
827 frequency.QuadPart = 0;
832 windisplay_cat.info() <<
"begin QueryPerformanceFrequency\n";
833 thread = GetCurrentThread();
834 priority = GetThreadPriority (thread);
835 SetThreadPriority(thread, THREAD_PRIORITY_TIME_CRITICAL);
837 if (QueryPerformanceFrequency(&frequency)) {
838 if (frequency.QuadPart > 0) {
839 if (QueryPerformanceCounter (&counter)) {
840 time = cpu_time_function();
841 end.QuadPart = counter.QuadPart + frequency.QuadPart;
842 while (QueryPerformanceCounter (&counter) && counter.QuadPart < end.QuadPart) {
845 end_time = cpu_time_function();
847 _display_information->_cpu_frequency = end_time - time;
852 SetThreadPriority(thread, priority);
853 sprintf(
string,
"QueryPerformanceFrequency: %I64d\n", frequency.QuadPart);
854 windisplay_cat.info() << string;
855 sprintf(
string,
"CPU frequency: %I64d\n", _display_information->_cpu_frequency);
856 windisplay_cat.info() << string;
862 windisplay_cat.info() <<
"start CPU ID\n";
864 if (initialize_cpu_id(&cpu_id)) {
868 if (cpu_id_binary_data) {
869 cpu_id_to_cpu_id_binary_data(&cpu_id, cpu_id_binary_data);
870 _display_information->_cpu_id_size =
sizeof(
CPU_ID_BINARY_DATA) /
sizeof(
unsigned int);
871 _display_information->_cpu_id_data = (
unsigned int *) cpu_id_binary_data;
873 _display_information->_cpu_vendor_string = strdup(cpu_id.cpu_vendor);
874 _display_information->_cpu_brand_string = strdup(cpu_id.cpu_brand_string);
875 _display_information->_cpu_version_information = cpu_id.version_information;
876 _display_information->_cpu_brand_index = cpu_id.brand_index;
878 if (windisplay_cat.is_debug()) {
879 windisplay_cat.debug()
880 << hex << _display_information->_cpu_id_version << dec <<
"|";
883 for (index = 0; index < _display_information->_cpu_id_size; ++index) {
885 data = _display_information->_cpu_id_data[index];
887 windisplay_cat.debug(
false)
888 << hex << data << dec;
889 if (index < _display_information->_cpu_id_size - 1) {
890 windisplay_cat.debug(
false)
894 windisplay_cat.debug(
false)
899 if (windisplay_cat.is_debug()) {
900 parse_cpu_id(&cpu_id);
904 windisplay_cat.info() <<
"end CPU ID\n";
907 count_number_of_cpus(_display_information);
917 if (_hUser32 != NULL) {
918 FreeLibrary(_hUser32);
923 bool MyGetProcAddr(HINSTANCE hDLL, FARPROC *pFn,
const char *szExportedFnName) {
924 *pFn = (FARPROC) GetProcAddress(hDLL, szExportedFnName);
926 windisplay_cat.error() <<
"GetProcAddr failed for " << szExportedFnName <<
", error=" << GetLastError() <<endl;
932 bool MyLoadLib(HINSTANCE &hDLL,
const char *DLLname) {
933 hDLL = LoadLibrary(DLLname);
935 windisplay_cat.error() <<
"LoadLibrary failed for " << DLLname <<
", error=" << GetLastError() <<endl;
This is our own Panda specialization on the default STL vector.
Parameters used for searching display capabilities.
TypeHandle is the identifier used to differentiate C++ class types.
virtual void lookup_cpu_data()
Looks up the detailed CPU information and stores it in _display_information, if supported by the OS...