bool EAE_Engine::Time::Initialize( std::string* o_errorMessage ) { bool wereThereErrors = false; // Get the frequency of the high-resolution performance counter { LARGE_INTEGER countsPerSecond; if ( QueryPerformanceFrequency( &countsPerSecond ) != FALSE ) { if ( countsPerSecond.QuadPart != 0 ) { s_secondsPerCount = 1.0 / static_cast<double>( countsPerSecond.QuadPart ); } else { wereThereErrors = true; if ( o_errorMessage ) { *o_errorMessage = "This hardware doesn't support high resolution performance counters!"; } goto OnExit; } } else { wereThereErrors = true; if ( o_errorMessage ) { *o_errorMessage = GetLastWindowsError(); } goto OnExit; } } // Store how many counts have elapsed so far if ( QueryPerformanceCounter( &s_totalCountsElapsed_atInitializion ) == FALSE ) { wereThereErrors = true; if ( o_errorMessage ) { *o_errorMessage = GetLastWindowsError(); } goto OnExit; } s_isInitialized = true; // We also need to init the s_fixedUpdateAccumulatTime s_fixedUpdateAccumulatTime = 0.0f; s_fixedUpdateRunTimesOnThisFrame = 0; s_fixedUpdateBlendAlphaOnThisFrame = 0.0f; OnExit: return !wereThereErrors; }
int AssetBuilder::DoesFileExist(lua_State* io_luaState) { const char* i_FilePath; { if (lua_isstring(io_luaState, 1)) { i_FilePath = lua_tostring(io_luaState, 1); } else { return luaL_error(io_luaState, "Argument #1 must be a string (instead of a %s)", luaL_typename(io_luaState, 1)); } } // Try to get information about the file WIN32_FIND_DATA fileData; HANDLE file = FindFirstFile(i_FilePath, &fileData); if (file != INVALID_HANDLE_VALUE) { if (FindClose(file) != FALSE) { lua_pushboolean(io_luaState, true); int returnValueCount = 1; return returnValueCount; } else { std::stringstream errorMessage; errorMessage << GetLastWindowsError().c_str() << i_FilePath; return luaL_error(io_luaState, errorMessage.str().c_str()); } } else { DWORD errorCode; std::string errorMessage = GetLastWindowsError(&errorCode); if ((errorCode == ERROR_FILE_NOT_FOUND) || (errorCode == ERROR_PATH_NOT_FOUND)) { int returnValueCount = 1; lua_pushboolean(io_luaState, false); return returnValueCount; } else { std::stringstream errorMessage; errorMessage << GetLastWindowsError().c_str() << i_FilePath; return luaL_error(io_luaState, errorMessage.str().c_str()); } } }
int AssetBuilder::GetLastWriteTime(lua_State* io_luaState) { //Argument#1: The path const char * i_path; { if (lua_isstring(io_luaState, 1)) { i_path = lua_tostring(io_luaState, 1); } else { return luaL_error(io_luaState, "Argument#1 should be of type string (instead of %s)", luaL_typename(io_luaState, 1)); } } // Get the last time that the file was written to ULARGE_INTEGER lastWriteTime_int; { WIN32_FIND_DATA fileData; { HANDLE file = FindFirstFile( i_path, &fileData ); if ( file != INVALID_HANDLE_VALUE ) { if ( FindClose( file ) == FALSE ) { std::stringstream errorMessage; errorMessage << GetLastWindowsError() << i_path; return luaL_error(io_luaState, errorMessage.str().c_str()); } } else { std::stringstream errorMessage; errorMessage << GetLastWindowsError() << i_path; return luaL_error(io_luaState, errorMessage.str().c_str()); } } FILETIME fileTime = fileData.ftLastWriteTime; lastWriteTime_int.HighPart = fileTime.dwHighDateTime; lastWriteTime_int.LowPart = fileTime.dwLowDateTime; } const lua_Number lastWriteTime = static_cast<lua_Number>(lastWriteTime_int.QuadPart); lua_pushnumber(io_luaState, lastWriteTime); int returnValueCount = 1; return returnValueCount; }
bool Sprite::LoadTextureAndSamplerRegister(const char* iTexturePath, const char* iSamplerName, IDirect3DDevice9 * i_direct3dDevice #ifdef EAE2014_SHOULDALLRETURNVALUESBECHECKED , std::string* o_errorMessage #endif ) { assert(i_direct3dDevice && iTexturePath && iSamplerName); bool WereThereErrors = false; HRESULT result = D3DXCreateTextureFromFile(i_direct3dDevice, iTexturePath, &m_texture); if (FAILED(result)) { WereThereErrors = true; #ifdef EAE2014_SHOULDALLRETURNVALUESBECHECKED if (o_errorMessage) { std::stringstream errorMessage; errorMessage << "Failed to load texture: " << GetLastWindowsError(); *o_errorMessage = errorMessage.str(); } #endif goto OnExit; } D3DXHANDLE samplerHandle = m_pfragmentShaderConsts->GetConstantByName(NULL, iSamplerName); if (samplerHandle == NULL) { WereThereErrors = true; #ifdef EAE2014_SHOULDALLRETURNVALUESBECHECKED if (o_errorMessage) { std::stringstream errorMessage; errorMessage << "Failed to get Constant by name: " << GetLastWindowsError(); *o_errorMessage = errorMessage.str(); } #endif goto OnExit; } m_samplerRegister = static_cast<DWORD>(m_pfragmentShaderConsts->GetSamplerIndex(samplerHandle)); OnExit: return !WereThereErrors; }
bool AssetBuilder::GetAssetBuilderEnvironmentVariable(const char* i_key, std::string& o_value) { // Windows requires a character buffer // to copy the environment variable into. // An arbitrary value is chosen that "should" be "big enough": const DWORD maxCharacterCount = 512; char buffer[maxCharacterCount]; // Ask Windows for the environment variable const DWORD characterCount = GetEnvironmentVariable( i_key, buffer, maxCharacterCount ); if ( characterCount > 0 ) { if ( characterCount <= maxCharacterCount ) { o_value = buffer; return true; } else { // If you're seeing this error you will need to increase maxCharacterCount std::stringstream errorMessage; errorMessage << "The environment variable \"" << i_key << "\" requires " << characterCount << " characters and the provided buffer only has room for " << maxCharacterCount; OutputErrorMessage( errorMessage.str().c_str() ); return false; } } else { DWORD errorCode; std::string errorString = GetLastWindowsError( &errorCode ); if ( errorCode == ERROR_ENVVAR_NOT_FOUND ) { // If you're seeing this error and the environment variable is spelled correctly // it _probably_ means that you are debugging and haven't set up the environment. // * Right click the project name and choose "Properties" // * In the tree view to the left select "Configuration Properties->Debugging" // * In the "Environment" field make sure that you have this environment variable set like: // * someKey=$(someKey) std::string errorMessage = std::string( "The environment variable \"" ) + i_key + "\" doesn't exist"; OutputErrorMessage( errorMessage.c_str() ); } else { std::string errorMessage = std::string( "Windows failed to get the environment variable \"" ) + i_key + "\": " + errorString; OutputErrorMessage( errorMessage.c_str() ); } return false; } }
int AssetBuilder::CopyAssetFile(lua_State* io_luaState) { // Argument #1: The source path const char* i_path_source; { if (lua_isstring(io_luaState, 1)) { i_path_source = lua_tostring(io_luaState, 1); } else { return luaL_error(io_luaState, "Argument#1 should of string type, (instead of a %s)", luaL_typename(io_luaState, 1)); } } // Argument #2: The target path const char* i_path_target; { if (lua_isstring(io_luaState, 2)) { i_path_target = lua_tostring(io_luaState, 2); } else { return luaL_error(io_luaState, "Argument#2 should of string type, (instead of a %s)", luaL_typename(io_luaState, 2)); } } // Copy the file const BOOL noErrorIfTargetFileAlreadyExists = FALSE; if (CopyFile(i_path_source, i_path_target, noErrorIfTargetFileAlreadyExists) != FALSE) { lua_pushboolean(io_luaState, true); // If successful, return a boolean "true" int returnValueCount = 1; return returnValueCount; } else { const std::string errorMessage = GetLastWindowsError(); return luaL_error(io_luaState, errorMessage.c_str()); // On failure, return a boolean "false" _and_ the error message } int returnValueCount = 0; return returnValueCount; }
bool Tools::cEntityBuilder::Build_derived( const char* i_fileName_source, const char* i_fileName_target ) const { // For now textures don't get "built"; // instead, copy the source texture as-is to the target BOOL shouldFailIfDestinationFileAlreadyExists = FALSE; if ( CopyFile( i_fileName_source, i_fileName_target, shouldFailIfDestinationFileAlreadyExists ) == TRUE ) { return true; } else { std::string errorMessage = std::string( "Couldn't copy " ) + i_fileName_source + " to " + i_fileName_target + ": " + GetLastWindowsError(); FormatAndOutputErrorMessage( errorMessage ); return false; } }
/** **************************************************************************************************** \fn bool Destroy( void ) \brief Destroy the window \param NONE \return boolean \retval SUCCESS success \retval FAIL otherwise **************************************************************************************************** */ bool RendererEngine::Window::Destroy( void ) { bool bErrorFound = FAIL; // If the window is created outside, then no need to destroy it here if( !_applicationInstance ) return SUCCESS; if ( _window ) { if ( DestroyWindow( _window ) == SUCCESS ) LogMessage( "Destroyed the main window" ); else { LogMessage( std::string( "Windows failed to destroy the main window: " ) + GetLastWindowsError() ); bErrorFound = SUCCESS; } _window = NULL; } return !bErrorFound; }
bool eae6320::Graphics::ShutDown() { bool wereThereErrors = false; if ( s_openGlRenderingContext != NULL ) { ReleaseObjects(); if ( wglMakeCurrent( s_deviceContext, NULL ) != FALSE ) { if ( wglDeleteContext( s_openGlRenderingContext ) == FALSE ) { std::stringstream errorMessage; errorMessage << "Windows failed to delete the OpenGL rendering context: " << GetLastWindowsError(); UserOutput::Print( errorMessage.str() ); } } else { std::stringstream errorMessage; errorMessage << "Windows failed to unset the current OpenGL rendering context: " << GetLastWindowsError(); UserOutput::Print( errorMessage.str() ); } s_openGlRenderingContext = NULL; } if ( s_deviceContext != NULL ) { // The documentation says that this call isn't necessary when CS_OWNDC is used ReleaseDC( s_renderingWindow, s_deviceContext ); s_deviceContext = NULL; } s_renderingWindow = NULL; return !wereThereErrors; }
/** **************************************************************************************************** \fn bool Build_derived( const char* i_fileName_source, const char* i_fileName_target ) const \brief Output input file \param i_fileName_source name of source file \param i_fileName_targe name of target file \return NONE \date 15 February 2013 \author Sherly Yunita \n Rewrite to output as binary data \n \n\n \date 1 March 2013 \author Sherly Yunita \n Get tangents and biNormal data \n \n\n **************************************************************************************************** */ bool Tools::cMeshBuilder::Build_derived( const char* i_fileName_source, const char* i_fileName_target ) const { // For now mesh don't get "built"; // instead, copy the source mesh as-is to the target /* Sherly 15 February 2013 marked BOOL shouldFailIfDestinationFileAlreadyExists = FALSE; if ( CopyFile( i_fileName_source, i_fileName_target, shouldFailIfDestinationFileAlreadyExists ) == TRUE ) { return true; } else { std::string errorMessage = std::string( "Couldn't copy " ) + i_fileName_source + " to " + i_fileName_target + ": " + GetLastWindowsError(); FormatAndOutputErrorMessage( errorMessage ); return false; }*/ ParserHelper parserHelper; std::ifstream in; std::ofstream out; in.open( i_fileName_source ); if( in.fail() ) { std::string errorMessage = std::string( "Couldn't open source file " ) + i_fileName_source + ": " + GetLastWindowsError(); FormatAndOutputErrorMessage( errorMessage ); return false; } out.open( i_fileName_target, std::ios::binary ); if( out.fail() ) { std::string errorMessage = std::string( "Couldn't create target file " ) + i_fileName_target + ": " + GetLastWindowsError(); FormatAndOutputErrorMessage( errorMessage ); return false; } typedef struct _s_vertex_ { Parser::S_FLOAT3 position; Parser::S_FLOAT3 normal; Parser::S_FLOAT3 tangent; // Sherly 1 March 2013 added Parser::S_FLOAT3 biNormal; // Sherly 1 March 2013 added Parser::S_FLOAT2 texcoord; unsigned int colour; } S_VERTEX; char chInput[MAX_INPUT_LEN]; bool validArrayData = false; UINT32 totalVertices; UINT32 totalPrimitives; std::vector<uint16_t> index; std::vector<S_VERTEX> vertex; S_VERTEX tempVertex = { { 0.0f, 0.0f, 0.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 0.0f }, 0 }; Parser::E_INPUT_TYPE currMajorData = Parser::E_INPUT_TYPE_TOTAL; Parser::E_INPUT_TYPE currMinorType = Parser::E_INPUT_TYPE_TOTAL; in.getline( &chInput[0], MAX_INPUT_LEN ); parserHelper.CleanInputString( chInput ); do { // Skip comment if( chInput[0] == '/' && chInput[1] == '/' ) { in.getline( &chInput[0], MAX_INPUT_LEN ); parserHelper.CleanInputString( chInput ); } // Check for tags // { if( chInput[0] == '<' ) { // Closing tag if( chInput[1] == '/' ) { char *tagStr; char *nextToken = NULL; tagStr = strtok_s( chInput, "</>", &nextToken ); Parser::E_INPUT_TYPE currInputType = parserHelper.SetInputType( tagStr ); if( currMajorData == currInputType ) { currMajorData = Parser::E_INPUT_TYPE_TOTAL; currMinorType = Parser::E_INPUT_TYPE_TOTAL; } else if( currMinorType == currInputType ) { currMinorType = Parser::E_INPUT_TYPE_TOTAL; } else { FormatAndOutputErrorMessage( "Invalid closing tag" ); return false; } } // Start tag else { char *tagStr; char *nextToken = NULL; tagStr = strtok_s( chInput, "</>", &nextToken ); Parser::E_INPUT_TYPE currInputType = parserHelper.SetInputType( tagStr ); if( (currInputType == Parser::E_TYPE_VERTEX) || (currInputType == Parser::E_TYPE_INDEX) ) { currMajorData = currInputType; in.getline( &chInput[0], MAX_INPUT_LEN ); parserHelper.CleanInputString( chInput ); if( currMajorData == Parser::E_TYPE_VERTEX ) { totalVertices = atoi( chInput ); } else { totalPrimitives = atoi( chInput ); totalPrimitives /= 3; } } else { currMinorType = currInputType; } } } // } else { switch( currMajorData ) { case Parser::E_TYPE_VERTEX: if( strcmp(chInput, "}") == 0 ) { if( validArrayData ) { vertex.push_back( tempVertex ); validArrayData = false; } else { FormatAndOutputErrorMessage( "Invalid array data" ); return false; } break; } else if( strcmp(chInput, "{") == 0 ) { validArrayData = true; break; } if( validArrayData ) { switch( currMinorType ) { case Parser::E_TYPE_POSITION: tempVertex.position = parserHelper.ParseVector3Input( chInput ); break; case Parser::E_TYPE_NORMAL: tempVertex.normal = parserHelper.ParseVector3Input( chInput ); break; // Sherly 1 March 2013 added // { case Parser::E_TYPE_TANGENT: tempVertex.tangent = parserHelper.ParseVector3Input( chInput ); break; case Parser::E_TYPE_BI_NORMAL: tempVertex.biNormal = parserHelper.ParseVector3Input( chInput ); break; // } case Parser::E_TYPE_UV: tempVertex.texcoord = parserHelper.ParseVector2Input( chInput ); break; case Parser::E_TYPE_COLOUR: tempVertex.colour = parserHelper.ParseColourInput( chInput ); break; } } break; case Parser::E_TYPE_INDEX: char *token = NULL; char *nextToken = NULL; token = strtok_s( chInput, ",", &nextToken ); index.push_back( atoi(token) ); token = strtok_s( NULL, ",", &nextToken ); index.push_back( atoi(token) ); token = strtok_s( NULL, " ", &nextToken ); index.push_back( atoi(token) ); nextToken = NULL; break; } } in.getline( &chInput[0], MAX_INPUT_LEN ); parserHelper.CleanInputString( chInput ); } while( !in.eof() ); out.write( reinterpret_cast <const char*> (&totalVertices), sizeof(totalVertices) ); out.write( reinterpret_cast <const char*> (&totalPrimitives), sizeof(totalPrimitives) ); for( unsigned int i = 0; i < totalVertices; i++ ) out.write( reinterpret_cast <const char*> (&vertex[i]), sizeof(S_VERTEX) ); for( unsigned int i = 0; i < index.size(); i++ ) out.write( reinterpret_cast <const char*>(&index[i]), sizeof(uint16_t) ); in.close(); out.close(); return true; }
bool Materials::LoadTexture(const char* const i_path, GLuint& o_texture, std::string* o_errorMessage) { bool wereThereErrors = false; HANDLE fileHandle = INVALID_HANDLE_VALUE; void* fileContents = NULL; o_texture = 0; // Open the texture file { const DWORD desiredAccess = FILE_GENERIC_READ; const DWORD otherProgramsCanStillReadTheFile = FILE_SHARE_READ; SECURITY_ATTRIBUTES* useDefaultSecurity = NULL; const DWORD onlySucceedIfFileExists = OPEN_EXISTING; const DWORD useDefaultAttributes = FILE_ATTRIBUTE_NORMAL; const HANDLE dontUseTemplateFile = NULL; fileHandle = CreateFile(i_path, desiredAccess, otherProgramsCanStillReadTheFile, useDefaultSecurity, onlySucceedIfFileExists, useDefaultAttributes, dontUseTemplateFile); if (fileHandle == INVALID_HANDLE_VALUE) { wereThereErrors = true; if (o_errorMessage) { std::string windowsErrorMessage(GetLastWindowsError()); std::stringstream errorMessage; errorMessage << "Windows failed to open the texture file: " << windowsErrorMessage; *o_errorMessage = errorMessage.str(); } goto OnExit; } } // Get the file's size size_t fileSize; { LARGE_INTEGER fileSize_integer; if (GetFileSizeEx(fileHandle, &fileSize_integer) != FALSE) { assert(fileSize_integer.QuadPart <= SIZE_MAX); fileSize = static_cast<size_t>(fileSize_integer.QuadPart); } else { wereThereErrors = true; if (o_errorMessage) { std::string windowsErrorMessage(GetLastWindowsError()); std::stringstream errorMessage; errorMessage << "Windows failed to get the size of the texture file: " << windowsErrorMessage; *o_errorMessage = errorMessage.str(); } goto OnExit; } } // Read the file's contents into temporary memory fileContents = malloc(fileSize); if (fileContents) { DWORD bytesReadCount; OVERLAPPED* readSynchronously = NULL; assert(fileSize < (uint64_t(1) << (sizeof(DWORD) * 8))); if (ReadFile(fileHandle, fileContents, static_cast<DWORD>(fileSize), &bytesReadCount, readSynchronously) == FALSE) { wereThereErrors = true; if (o_errorMessage) { std::string windowsErrorMessage(GetLastWindowsError()); std::stringstream errorMessage; errorMessage << "Windows failed to read the contents of the texture file: " << windowsErrorMessage; *o_errorMessage = errorMessage.str(); } goto OnExit; } } else { wereThereErrors = true; if (o_errorMessage) { std::stringstream errorMessage; errorMessage << "Failed to allocate " << fileSize << " bytes to read in the texture " << i_path; *o_errorMessage = errorMessage.str(); } goto OnExit; } // Create a new texture and make it active { const GLsizei textureCount = 1; glGenTextures(textureCount, &o_texture); const GLenum errorCode = glGetError(); if (errorCode == GL_NO_ERROR) { // This code only supports 2D textures; // if you want to support other types you will need to improve this code. glBindTexture(GL_TEXTURE_2D, o_texture); const GLenum errorCode = glGetError(); if (errorCode != GL_NO_ERROR) { wereThereErrors = true; if (o_errorMessage) { std::stringstream errorMessage; errorMessage << "OpenGL failed to bind a new texture: " << reinterpret_cast<const char*>(gluErrorString(errorCode)); *o_errorMessage = errorMessage.str(); } goto OnExit; } } else { wereThereErrors = true; if (o_errorMessage) { std::stringstream errorMessage; errorMessage << "OpenGL failed to get an unused texture ID: " << reinterpret_cast<const char*>(gluErrorString(errorCode)); *o_errorMessage = errorMessage.str(); } goto OnExit; } } // Extract the data const uint8_t* currentPosition = reinterpret_cast<uint8_t*>(fileContents); // Verify that the file is a valid DDS { const size_t fourCcCount = 4; const uint8_t* const fourCc = currentPosition; const uint8_t fourCc_dds[fourCcCount] = { 'D', 'D', 'S', ' ' }; // Each of the four characters can be compared in a single operation by casting to a uint32_t const bool isDds = *reinterpret_cast<const uint32_t*>(fourCc) == *reinterpret_cast<const uint32_t*>(fourCc_dds); if (isDds) { currentPosition += fourCcCount; } else { wereThereErrors = true; if (o_errorMessage) { char fourCcString[fourCcCount + 1] = { 0 }; // Add NULL terminator memcpy(fourCcString, currentPosition, fourCcCount); std::stringstream errorMessage; errorMessage << "The texture file \"" << i_path << "\" isn't a valid DDS. The Four CC is \"" << fourCcString << "\"" " instead of \"DDS \""; *o_errorMessage = errorMessage.str(); } goto OnExit; } } // Extract the header // (this struct can also be found in Dds.h in the DirectX header files // or here as of this comment: https://msdn.microsoft.com/en-us/library/windows/desktop/bb943982(v=vs.85).aspx ) struct sDdsHeader { uint32_t structSize; uint32_t flags; uint32_t height; uint32_t width; uint32_t pitchOrLinearSize; uint32_t depth; uint32_t mipMapCount; uint32_t reserved1[11]; struct { uint32_t structSize; uint32_t flags; uint8_t fourCc[4]; uint32_t rgbBitCount; uint32_t bitMask_red; uint32_t bitMask_green; uint32_t bitMask_blue; uint32_t bitMask_alpha; } pixelFormat; uint32_t caps[4]; uint32_t reserved2; }; const sDdsHeader* ddsHeader = reinterpret_cast<const sDdsHeader*>(currentPosition); currentPosition += sizeof(sDdsHeader); // Convert the DDS format into an OpenGL format GLenum format; { // This code can only handle the two basic formats that the example TextureBuilder will create. // If a DDS in a different format is provided to TextureBuilder it will be passed through unchanged // and this code won't work. // Similarly, if you improve the example TextureBuilder to support more formats // you will also have to update this code to support them. const uint8_t fourCc_dxt1[] = { 'D', 'X', 'T', '1' }; // No alpha channel const uint8_t fourCc_dxt5[] = { 'D', 'X', 'T', '5' }; // Alpha channel const uint32_t fourCc_texture = *reinterpret_cast<const uint32_t*>(ddsHeader->pixelFormat.fourCc); if (fourCc_texture == *reinterpret_cast<const uint32_t*>(fourCc_dxt1)) { format = GL_COMPRESSED_RGB_S3TC_DXT1_EXT; } else if (fourCc_texture == *reinterpret_cast<const uint32_t*>(fourCc_dxt5)) { format = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; } else { wereThereErrors = true; if (o_errorMessage) { char fourCcString[5] = { 0 }; // Add NULL terminator memcpy(fourCcString, ddsHeader->pixelFormat.fourCc, 4); std::stringstream errorMessage; errorMessage << "The texture file \"" << i_path << "\" has an unsupported format \"" << fourCcString << "\""; *o_errorMessage = errorMessage.str(); } goto OnExit; } } // Iterate through each MIP map level and fill in the OpenGL texture { GLsizei currentWidth = ddsHeader->width; GLsizei currentHeight = ddsHeader->height; const GLsizei blockSize = format == GL_COMPRESSED_RGB_S3TC_DXT1_EXT ? 8 : 16; const GLint borderWidth = 0; for (uint32_t mipMapLevel = 0; mipMapLevel < ddsHeader->mipMapCount; ++mipMapLevel) { const GLsizei mipMapSize = ((currentWidth + 3) / 4) * ((currentHeight + 3) / 4) * blockSize; glCompressedTexImage2D(GL_TEXTURE_2D, static_cast<GLint>(mipMapLevel), format, currentWidth, currentHeight, borderWidth, mipMapSize, currentPosition); const GLenum errorCode = glGetError(); if (errorCode == GL_NO_ERROR) { currentPosition += static_cast<size_t>(mipMapSize); currentWidth = std::max(1, (currentWidth / 2)); currentHeight = std::max(1, (currentHeight / 2)); } else { wereThereErrors = true; if (o_errorMessage) { std::stringstream errorMessage; errorMessage << "OpenGL rejected compressed texture data: " << reinterpret_cast<const char*>(gluErrorString(errorCode)); *o_errorMessage = errorMessage.str(); } goto OnExit; } } } assert(currentPosition == (reinterpret_cast<uint8_t*>(fileContents) + fileSize)); OnExit: if (fileContents != NULL) { free(fileContents); fileContents = NULL; } if (fileHandle != INVALID_HANDLE_VALUE) { if (CloseHandle(fileHandle) == FALSE) { wereThereErrors = true; if (o_errorMessage) { std::string windowsErrorMessage(GetLastWindowsError()); std::stringstream errorMessage; errorMessage << "\nWindows failed to close the texture file handle: " << windowsErrorMessage; *o_errorMessage += errorMessage.str(); } } fileHandle = INVALID_HANDLE_VALUE; } if (wereThereErrors && (o_texture != 0)) { const GLsizei textureCount = 1; glDeleteTextures(textureCount, &o_texture); assert(glGetError == GL_NO_ERROR); o_texture = 0; } return !wereThereErrors; }
int AssetBuilder::CreateDirectoryIfNecessary(lua_State* io_luaState) { // Argument #1: The path std::string i_path; { if (lua_isstring(io_luaState, 1)) { i_path = lua_tostring(io_luaState, 1); } else { return luaL_error(io_luaState, "Argument#1 should of string type, (instead of a %s)", luaL_typename(io_luaState, 1)); } } // If the path is to a file (likely), remove it so that only the directory remains std::string directory; { size_t pos_slash = i_path.find_last_of("\\/"); if (pos_slash != std::string::npos) { directory = i_path.substr(0, pos_slash); } else { directory = i_path; } } // Get the path in a form Windows likes (without any ".."s). // Windows requires a character buffer // to copy the path variable into. // An arbitrary value is chosen that "should" be "big enough": const DWORD maxCharacterCount = MAX_PATH; char buffer[maxCharacterCount]; { char** pathIsDirectory = NULL; DWORD characterCount = GetFullPathName(directory.c_str(), maxCharacterCount, buffer, pathIsDirectory); if (characterCount > 0) { if (characterCount <= maxCharacterCount) { // Create the directory int result; { HWND noWindowIsDisplayed = NULL; const SECURITY_ATTRIBUTES* useDefaultSecurityAttributes = NULL; result = SHCreateDirectoryEx(noWindowIsDisplayed, buffer, useDefaultSecurityAttributes); } if (result == ERROR_SUCCESS) { std::cout << "Created directory " << buffer << "\n"; int returnValueCount = 0; return returnValueCount; } else if ((result == ERROR_FILE_EXISTS) || (result == ERROR_ALREADY_EXISTS)) { // If the file already exists that's ok, // still don't return anything but don't print a message int returnValueCount = 0; return returnValueCount; } else { const std::string errorMessage = GetFormattedWindowsError(result); return luaL_error(io_luaState, errorMessage.c_str()); // Throw an error } } else { // If you're seeing this error you will need to increase maxCharacterCount std::stringstream errorMessage; errorMessage << "The full path of \"" << directory << "\" requires " << characterCount << " characters and the provided buffer only has room for " << maxCharacterCount; return luaL_error(io_luaState, errorMessage.str().c_str()); // Throw an error } } else { const std::string errorMessage = GetLastWindowsError(); return luaL_error(io_luaState, errorMessage.c_str()); // Throw an error } } }
bool eae6320::Graphics::ShutDown() { bool wereThereErrors = false; if ( s_openGlRenderingContext != NULL ) { if ( s_programId != 0 ) { glDeleteProgram( s_programId ); const GLenum errorCode = glGetError(); if ( errorCode != GL_NO_ERROR ) { std::stringstream errorMessage; errorMessage << "OpenGL failed to delete the program: " << reinterpret_cast<const char*>( gluErrorString( errorCode ) ); UserOutput::Print( errorMessage.str() ); } s_programId = 0; } if ( s_vertexArrayId != 0 ) { const GLsizei arrayCount = 1; glDeleteVertexArrays( arrayCount, &s_vertexArrayId ); const GLenum errorCode = glGetError(); if ( errorCode != GL_NO_ERROR ) { std::stringstream errorMessage; errorMessage << "OpenGL failed to delete the vertex array: " << reinterpret_cast<const char*>( gluErrorString( errorCode ) ); UserOutput::Print( errorMessage.str() ); } s_vertexArrayId = 0; } if ( wglMakeCurrent( s_deviceContext, NULL ) != FALSE ) { if ( wglDeleteContext( s_openGlRenderingContext ) == FALSE ) { std::stringstream errorMessage; errorMessage << "Windows failed to delete the OpenGL rendering context: " << GetLastWindowsError(); UserOutput::Print( errorMessage.str() ); } } else { std::stringstream errorMessage; errorMessage << "Windows failed to unset the current OpenGL rendering context: " << GetLastWindowsError(); UserOutput::Print( errorMessage.str() ); } s_openGlRenderingContext = NULL; } if ( s_deviceContext != NULL ) { // The documentation says that this call isn't necessary when CS_OWNDC is used ReleaseDC( s_renderingWindow, s_deviceContext ); s_deviceContext = NULL; } s_renderingWindow = NULL; return !wereThereErrors; }
/** **************************************************************************************************** \fn bool UnregisterClass( void ) \brief Unregister window class \param NONE \return boolean \retval SUCCESS success \retval FAIL otherwise **************************************************************************************************** */ bool RendererEngine::Window::UnregisterClass( void ) { bool bErrorFound = FAIL; if ( _class ) { if ( ::UnregisterClass( _windowName, _applicationInstance ) == SUCCESS ) { LogMessage( "Unregistered the main window class" ); } else { LogMessage( std::string( "Windows failed to unregister the main window's class: " ) + GetLastWindowsError() ); } _class = NULL; } return !bErrorFound; }
/** **************************************************************************************************** \fn bool RegisterClass( void ) \brief Register the window class \param NONE \return boolean \retval SUCCESS success \retval FAIL otherwise **************************************************************************************************** */ bool RendererEngine::Window::RegisterClass( void ) { WNDCLASSEX wndClassEx = { 0 }; wndClassEx.cbSize = sizeof( WNDCLASSEX ); wndClassEx.hInstance = _applicationInstance; // The class's style // (We don't have to worry about any of these) wndClassEx.style = 0; // The function that will process all of the messages // that Windows will send to windows of this class wndClassEx.lpfnWndProc = OnMessageReceived; // Extra bytes can be set aside in the class for user data // (This is rarely used, but can be useful) wndClassEx.cbClsExtra = 0; // Extra bytes can be set aside for each window of the class, // but this is usually specified for each window individually wndClassEx.cbWndExtra = 0; // The large and small icons windows of this class should use // (These can be found in the Resources folder; feel free to change them) wndClassEx.hIcon = LoadIcon( _applicationInstance, MAKEINTRESOURCE( IDI_RENDERER ) ); wndClassEx.hIconSm = LoadIcon( _applicationInstance, MAKEINTRESOURCE( IDI_SMALL ) ); // The cursor that should display when the mouse pointer is over windows of this class wndClassEx.hCursor = LoadCursor( NULL, IDC_ARROW ); // The brush windows of this class will use as a background // (Setting this is a bit confusing, so don't be alarmed if the next line looks scary) wndClassEx.hbrBackground = reinterpret_cast<HBRUSH>( IntToPtr( COLOR_BACKGROUND + 1 ) ); // A menu can be specified that all windows of this class would use by default, // but usually this is set for each window individually wndClassEx.lpszMenuName = NULL; // The class name (see comments where this is initialized) wndClassEx.lpszClassName = _windowName; // Now we can provide this information to Windows. // If all goes well, the class will be successfully registered // and we can specify it by name when creating our windows. _class = RegisterClassEx( &wndClassEx ); if ( _class != NULL ) { LogMessage( "Registered the main window class" ); return SUCCESS; } else { LogMessage( std::string( "Windows failed to register the main window's class: " ) + GetLastWindowsError() ); return FAIL; } }
/** **************************************************************************************************** \fn bool Create( const int i_initialWindowDisplay ) \brief Create the window \param i_initialWindowDisplay the initial state of the window \return boolean \retval SUCCESS success \retval FAIL otherwise **************************************************************************************************** */ bool RendererEngine::Window::Create( const int i_initialWindowDisplayState ) { // The window's style DWORD windowStyle = // "Overlapped" is basically the same as "top-level" WS_OVERLAPPED // The caption is the title bar when in windowed-mode | WS_CAPTION // The window should never change dimensions, so only a minimize box is allowed | WS_MINIMIZEBOX // The system menu appears when you right-click the title bar | WS_SYSMENU; // The window's extended style DWORD windowStyle_extended = // The following is a macro to make the extended style the default top-level look WS_EX_OVERLAPPEDWINDOW; // The width and height of the window // (The renderer is concerned about the width and height of the actual "client area", // which is the part of the window that doesn't include the borders and title bar. // the initial window, then, will created with default values that Windows chooses // and then resized after creation) int width = CW_USEDEFAULT; int height = CW_USEDEFAULT; // The initial position of the window // (We don't care, and will let Windows decide) int position_x = CW_USEDEFAULT; int position_y = CW_USEDEFAULT; // Handle to the parent of this window // (Since this is our main window, it can't have a parent) HWND hParent = NULL; // Handle to the menu for this window HMENU hMenu = NULL; // Handle to the instance of the application this window should be associated with HINSTANCE hApplication = _applicationInstance; // Any arbitrary pointer can be associated with this window; // usually an application's representation of the window will be used, like this: void* userData = this; // (Since the main window is a global singleton, though, this program won't actually use this) // Ask Windows to create the specified window. // CreateWindowEx() will return a handle to the window, // which is what we'll use to communicate with Windows about this window _window = CreateWindowEx( windowStyle_extended, _windowName, _windowName, windowStyle, position_x, position_y, width, height, hParent, hMenu, hApplication, userData ); if ( _window ) { // Change the window's size based on the requested user settings { // Calculate how much of the window is coming from the "non-client area" // (the borders and title bar) RECT windowCoordinates; struct { long width; long height; } nonClientAreaSize; { // Get the coordinates of the entire window if ( GetWindowRect( _window, &windowCoordinates ) == FAIL ) { LogMessage( std::string( "Windows failed to get the coordinates of the main window: " ) + GetLastWindowsError() ); return FAIL; } // Get the dimensions of the client area RECT clientDimensions; if ( GetClientRect( _window, &clientDimensions ) == FAIL ) { LogMessage( std::string( "Windows failed to get the dimensions of the main window's client area: " ) + GetLastWindowsError() ); return FAIL; } // Get the difference between them nonClientAreaSize.width = ( windowCoordinates.right - windowCoordinates.left ) - clientDimensions.right; nonClientAreaSize.height = ( windowCoordinates.bottom - windowCoordinates.top ) - clientDimensions.bottom; } // Resize the window { BOOL shouldTheResizedWindowBeRedrawn = SUCCESS; if ( MoveWindow( _window, windowCoordinates.left, windowCoordinates.top, m_u32Width + nonClientAreaSize.width, m_u32Height + nonClientAreaSize.height, shouldTheResizedWindowBeRedrawn ) == FAIL ) { LogMessage( std::string( "Windows failed to resize the main window: " ) + GetLastWindowsError() ); return FAIL; } } } // Display the window in the initial state that Windows requested ShowWindow( _window, i_initialWindowDisplayState ); LogMessage( "Created the main window" ); return SUCCESS; } else { LogMessage( std::string( "Windows failed to create the main window: " ) + GetLastWindowsError() ); return FAIL; } }