ccReturn ccSysinfoInitialize(void)
{
SYSTEM_INFO sysinfo;
MEMORYSTATUSEX memstat;
memstat.dwLength = sizeof(MEMORYSTATUSEX);
GlobalMemoryStatusEx(&memstat);
ccAssert(_ccSysinfo == NULL);
ccMalloc(_ccSysinfo, sizeof(ccSysinfo));
if(GetPhysicallyInstalledSystemMemory(&_ccSysinfo->ramTotal) == FALSE) goto fail;
_ccSysinfo->ramTotal <<= 10;
GetSystemInfo(&sysinfo);
_ccSysinfo->processorCount = sysinfo.dwNumberOfProcessors;
_ccSysinfo->fileMaxOpen = _getmaxstdio();
return CC_SUCCESS;
fail:
free(_ccSysinfo);
return CC_FAIL;
}
void ccSysinfoFree(void)
{
ccAssert(_ccSysinfo != NULL);
free(_ccSysinfo);
_ccSysinfo = NULL;
}
ccReturn ccGLContextFree(void)
{
ccAssert(_ccWindow != NULL);
wglDeleteContext(_CC_WINDOW_DATA->renderContext);
_CC_WINDOW_DATA->renderContext = NULL;
return CC_SUCCESS;
}
ccReturn ccGLBuffersSwap(void)
{
ccAssert(_ccWindow != NULL);
if(SwapBuffers(_CC_WINDOW_DATA->hdc) == TRUE) {
return CC_SUCCESS;
}
else{
ccErrorPush(CC_ERROR_GL_BUFFERSWAP);
return CC_FAIL;
}
}
ccReturn ccDisplayResolutionSet(ccDisplay *display, int resolutionIndex)
{
DEVMODE devMode;
ccDisplayData displayData;
ccAssert(display != NULL);
ccAssert(resolutionIndex < display->amount);
if(resolutionIndex == CC_DEFAULT_RESOLUTION) resolutionIndex = display->initial;
if(resolutionIndex == display->current) return CC_SUCCESS;
ZeroMemory(&devMode, sizeof(DEVMODE));
devMode.dmSize = sizeof(DEVMODE);
if(EnumDisplaySettings(display->deviceName, ENUM_CURRENT_SETTINGS, &devMode) == 0) {
ccErrorPush(CC_ERROR_DISPLAY_RESOLUTIONCHANGE);
return CC_FAIL;
}
displayData = display->resolution[resolutionIndex];
devMode.dmPelsWidth = displayData.width;
devMode.dmPelsHeight = displayData.height;
devMode.dmBitsPerPel = displayData.bitDepth;
devMode.dmDisplayFrequency = displayData.refreshRate;
devMode.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL | DM_DISPLAYFREQUENCY;
if(ChangeDisplaySettingsEx(display->deviceName, &devMode, NULL, CDS_FULLSCREEN, NULL) != DISP_CHANGE_SUCCESSFUL) {
ccErrorPush(CC_ERROR_DISPLAY_RESOLUTIONCHANGE);
return CC_FAIL;
}
display->current = resolutionIndex;
return CC_SUCCESS;
}
ccReturn ccGLContextBind(void)
{
int pixelFormatIndex;
ccAssert(ccWindowExists());
_CC_WINDOW_DATA->hdc = GetDC(_CC_WINDOW_DATA->winHandle);
if(_CC_WINDOW_DATA->hdc == NULL) {
ccErrorPush(CC_ERROR_GL_CONTEXT);
return CC_FAIL;
}
PIXELFORMATDESCRIPTOR pfd = {
sizeof(PIXELFORMATDESCRIPTOR),
1,
PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
PFD_TYPE_RGBA,
32,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
16,
0, 0, 0, 0, 0, 0, 0
};
pixelFormatIndex = ChoosePixelFormat(_CC_WINDOW_DATA->hdc, &pfd);
if(pixelFormatIndex == 0) {
ccErrorPush(CC_ERROR_GL_CONTEXT);
return CC_FAIL;
}
if(SetPixelFormat(_CC_WINDOW_DATA->hdc, pixelFormatIndex, &pfd) == FALSE) {
ccErrorPush(CC_ERROR_GL_CONTEXT);
return CC_FAIL;
}
_CC_WINDOW_DATA->renderContext = wglCreateContext(_CC_WINDOW_DATA->hdc);
if(_CC_WINDOW_DATA->renderContext == NULL) {
ccErrorPush(CC_ERROR_GL_CONTEXT);
return CC_FAIL;
}
//Make window the current context
if(wglMakeCurrent(_CC_WINDOW_DATA->hdc, _CC_WINDOW_DATA->renderContext) == FALSE) {
ccErrorPush(CC_ERROR_GL_CONTEXT);
return CC_FAIL;
}
return CC_SUCCESS;
}
ccReturn ccDisplayFree(void) {
int i;
ccAssert(_ccDisplays != NULL);
for(i = 0; i < _ccDisplays->amount; i++) {
free(_ccDisplays->display[i].gpuName);
free(_ccDisplays->display[i].monitorName);
free(_ccDisplays->display[i].deviceName);
free(_ccDisplays->display[i].resolution);
}
free(_ccDisplays->display);
free(_ccDisplays);
_ccDisplays = NULL;
return CC_SUCCESS;
}
ccReturn ccSysinfoInitialize(void)
{
long value;
ccAssert(_ccSysinfo == NULL);
ccMalloc(_ccSysinfo, sizeof(ccSysinfo));
value = getKBValueFromProc("/proc/meminfo", "MemTotal");
if(value == -1){
return CC_FAIL;
}
_ccSysinfo->ramTotal = ((uint_fast64_t)value) * 1000;
_ccSysinfo->processorCount = sysconf(_SC_NPROCESSORS_CONF);
_ccSysinfo->fileMaxOpen = sysconf(_SC_OPEN_MAX);
return CC_SUCCESS;
}
ccReturn ccDisplayInitialize(void)
{
DISPLAY_DEVICE device;
DISPLAY_DEVICE display;
DEVMODE dm;
ccDisplay *currentDisplay;
ccDisplayData buffer;
ccDisplayData initialBuffer;
int deviceCount = 0;
int displayCount;
int i;
ccAssert(_ccDisplays == NULL);
ccMalloc(_ccDisplays, sizeof(ccDisplays));
_ccDisplays->display = NULL;
dm.dmSize = sizeof(dm);
device.cb = sizeof(DISPLAY_DEVICE);
display.cb = sizeof(DISPLAY_DEVICE);
_ccDisplays->amount = 0;
while(EnumDisplayDevices(NULL, deviceCount, &device, 0)) {
displayCount = 0;
while(EnumDisplayDevices(device.DeviceName, displayCount, &display, 0)) {
_ccDisplays->amount++;
ccRealloc(_ccDisplays->display, sizeof(ccDisplay)*_ccDisplays->amount);
if(EnumDisplaySettings(device.DeviceName, ENUM_CURRENT_SETTINGS, &dm) == 0) {
ccErrorPush(CC_ERROR_DISPLAY_NONE);
return CC_FAIL;
}
currentDisplay = &_ccDisplays->display[_ccDisplays->amount - 1];
ccMalloc(currentDisplay->gpuName, CC_MAXDEVICESTRINGSIZE);
ccMalloc(currentDisplay->monitorName, CC_MAXDEVICESTRINGSIZE);
ccMalloc(currentDisplay->deviceName, CC_MAXDEVICENAMESIZE);
memcpy(currentDisplay->gpuName, device.DeviceString, CC_MAXDEVICESTRINGSIZE);
memcpy(currentDisplay->monitorName, display.DeviceString, CC_MAXDEVICESTRINGSIZE);
memcpy(currentDisplay->deviceName, display.DeviceName, CC_MAXDEVICENAMESIZE);
ccStringTrimToChar(currentDisplay->deviceName, '\\', false);
currentDisplay->x = dm.dmPosition.x;
currentDisplay->y = dm.dmPosition.y;
currentDisplay->amount = 0;
currentDisplay->resolution = NULL;
initialBuffer.bitDepth = dm.dmBitsPerPel;
initialBuffer.refreshRate = dm.dmDisplayFrequency;
initialBuffer.width = dm.dmPelsWidth;
initialBuffer.height = dm.dmPelsHeight;
i = 0;
while(EnumDisplaySettings(device.DeviceName, i, &dm)) {
i++;
buffer.bitDepth = dm.dmBitsPerPel;
buffer.refreshRate = dm.dmDisplayFrequency;
buffer.width = dm.dmPelsWidth;
buffer.height = dm.dmPelsHeight;
if(ccDisplayResolutionExists(currentDisplay, &buffer)) continue;
ccRealloc(currentDisplay->resolution, sizeof(ccDisplayData)*(currentDisplay->amount + 1));
if(ccDisplayResolutionEqual(&buffer, &initialBuffer)) {
currentDisplay->current = currentDisplay->amount;
currentDisplay->initial = currentDisplay->current;
}
currentDisplay->resolution[currentDisplay->amount].width = buffer.width;
currentDisplay->resolution[currentDisplay->amount].height = buffer.height;
currentDisplay->resolution[currentDisplay->amount].refreshRate = buffer.refreshRate;
currentDisplay->resolution[currentDisplay->amount].bitDepth = buffer.bitDepth;
currentDisplay->amount++;
}
if(currentDisplay->x == 0 && currentDisplay->y == 0) _ccDisplays->primary = _ccDisplays->amount - 1;
displayCount++;
}
deviceCount++;
}
return CC_SUCCESS;
}
ccReturn ccGLContextBind(int glVersionMajor, int glVersionMinor)
{
int pixelFormatIndex;
int glVerMajor, glVerMinor;
ccAssert(ccWindowExists());
WINDOW_DATA->hdc = GetDC(WINDOW_DATA->winHandle);
if(WINDOW_DATA->hdc == NULL) {
ccErrorPush(CC_ERROR_GL_CONTEXT);
return CC_FAIL;
}
PIXELFORMATDESCRIPTOR pfd = {
sizeof(PIXELFORMATDESCRIPTOR),
1,
PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
PFD_TYPE_RGBA,
32,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
16,
0, 0, 0, 0, 0, 0, 0
};
pixelFormatIndex = ChoosePixelFormat(WINDOW_DATA->hdc, &pfd);
if(pixelFormatIndex == 0) {
ccErrorPush(CC_ERROR_GL_CONTEXT);
return CC_FAIL;
}
if(SetPixelFormat(WINDOW_DATA->hdc, pixelFormatIndex, &pfd) == FALSE) {
ccErrorPush(CC_ERROR_GL_CONTEXT);
return CC_FAIL;
}
WINDOW_DATA->renderContext = wglCreateContext(WINDOW_DATA->hdc);
if(WINDOW_DATA->renderContext == NULL) {
ccErrorPush(CC_ERROR_GL_CONTEXT);
return CC_FAIL;
}
//Make window the current context
if(wglMakeCurrent(WINDOW_DATA->hdc, WINDOW_DATA->renderContext) == FALSE) {
ccErrorPush(CC_ERROR_GL_CONTEXT);
return CC_FAIL;
}
//Version check
glGetIntegerv(GL_MAJOR_VERSION, &glVerMajor);
glGetIntegerv(GL_MINOR_VERSION, &glVerMinor);
if(glVerMajor < glVersionMajor || (glVerMajor == glVersionMajor && glVerMinor < glVersionMinor)) {
ccErrorPush(CC_ERROR_GL_VERSION);
return CC_FAIL;
}
//Fetch extentions after context creation
if(glewInit() != GLEW_OK) {
ccErrorPush(CC_ERROR_GL_GLEWINIT);
return CC_FAIL;
}
return CC_SUCCESS;
}
