void InputManager::Initialize()
{
#define USEINPUTKEY(e,hashVal,text) \
_keyNameTable[ToUpper(text)] = e;
#include "InputKeys.h"
#undef USEINPUTKEY
//Clear Xbox Button States
ClearXboxButtonStates();
StringList bindings;
GetLinesFromFile("Config/input_bindings.ini", bindings);
StringList::iterator it = bindings.begin();
while (it != bindings.end())
{
if (((*it).size() == 0) || ((*it)[0] == ';'))
{
it++;
continue;
}
StringList splitBinding = SplitString(*it, "=:", false);
if (splitBinding.size() >= 2)
{
splitBinding[0] = TrimString(splitBinding[0]);
splitBinding[1] = TrimString(splitBinding[1]);
BindKey(splitBinding[0], splitBinding[1]);
}
it++;
}
}
int Xmain() {
ifstream infile;
// Get lines from file
cout << "Let's process a file of random text and count characters!" << endl;
PromptUserToOpenFile(infile);
linesV lines = GetLinesFromFile(infile);
//for (int i = 0; i < lines.size(); i++)
//cout << "score " << i << " is " << lines.getAt(i) << endl;
// Prepare an array to hold the data.
int lCount[alpha_size];
for (int i = 0; i < alpha_size; i++)
lCount[i] = 0;
// Examine each line for its characters, increment the proper indexes.
for (int i = 0; i < lines.size(); i++) {
BumpCountForEachChar(lines[i], lCount);
}
PrintCounts(lCount);
return 0;
}
// Loads a shader, stored as a text file with filename sFile. The shader is of type iType (vertex, fragment, geometry, etc.)
bool CShader::LoadShader(string sFile, int iType)
{
vector<string> sLines;
if(!GetLinesFromFile(sFile, false, &sLines))return false;
const char** sProgram = new const char*[(int)sLines.size()];
for (int i = 0; i < (int)sLines.size(); i++)
sProgram[i] = sLines[i].c_str();
m_uiShader = glCreateShader(iType);
glShaderSource(m_uiShader, (int)sLines.size(), sProgram, NULL);
glCompileShader(m_uiShader);
delete[] sProgram;
int iCompilationStatus;
glGetShaderiv(m_uiShader, GL_COMPILE_STATUS, &iCompilationStatus);
if(iCompilationStatus == GL_FALSE)
{
char sInfoLog[1024];
char sFinalMessage[1536];
int iLogLength;
glGetShaderInfoLog(m_uiShader, 1024, &iLogLength, sInfoLog);
sprintf_s(sFinalMessage, "Error! Shader file wasn't compiled! The compiler returned:\n\n%s", sInfoLog);
MessageBox(NULL, sFinalMessage, "Error", MB_ICONERROR);
return false;
}
m_iType = iType;
m_bLoaded = true;
return true;
}
// Loads a shader, stored as a text file with filename sFile. The shader is of type iType (vertex, fragment, geometry, etc.)
bool CShader::LoadShader(string sFile, int iType)
{
vector<string> sLines;
if(!GetLinesFromFile(sFile, false, &sLines)) {
char message[1024];
sprintf_s(message, "Cannot load shader\n%s\n", sFile.c_str());
MessageBox(NULL, message, "Error", MB_ICONERROR);
return false;
}
const char** sProgram = new const char*[(int)sLines.size()];
for (int i = 0; i < (int)sLines.size(); i++)
sProgram[i] = sLines[i].c_str();
m_uiShader = glCreateShader(iType);
glShaderSource(m_uiShader, (int)sLines.size(), sProgram, NULL);
glCompileShader(m_uiShader);
delete[] sProgram;
int iCompilationStatus;
glGetShaderiv(m_uiShader, GL_COMPILE_STATUS, &iCompilationStatus);
if(iCompilationStatus == GL_FALSE)
{
char sInfoLog[1024];
char sFinalMessage[1536];
int iLogLength;
glGetShaderInfoLog(m_uiShader, 1024, &iLogLength, sInfoLog);
char sShaderType[64];
if (iType == GL_VERTEX_SHADER)
sprintf_s(sShaderType, "vertex shader");
else if (iType == GL_FRAGMENT_SHADER)
sprintf_s(sShaderType, "fragment shader");
else if (iType == GL_GEOMETRY_SHADER)
sprintf_s(sShaderType, "geometry shader");
else if (iType == GL_TESS_CONTROL_SHADER)
sprintf_s(sShaderType, "tesselation control shader");
else if (iType == GL_TESS_EVALUATION_SHADER)
sprintf_s(sShaderType, "tesselation evaluation shader");
else
sprintf_s(sShaderType, "unknown shader type");
sprintf_s(sFinalMessage, "Error in %s!\n%s\nShader file not compiled. The compiler returned:\n\n%s", sShaderType, sFile.c_str(), sInfoLog);
MessageBox(NULL, sFinalMessage, "Error", MB_ICONERROR);
return false;
}
m_iType = iType;
m_bLoaded = true;
return true;
}
bool ShaderManager::GetLinesFromFile(const FString& file, bool bIncludePart, std::vector<FString>* result)
{
// std::cout << "------ Get line From file ------" << std::endl;
FILE* fp = fopen(file.c_str(), "rt");
if(fp == nullptr) { std::cerr << "file not found: " << file << std::endl; return false; }
FString dir = "";
auto slash_index = -1;
for(auto i = 0lu; i < file.size(); i++)
{
if(file[i] == '\\' || file[i] == '/')
{
slash_index = i;
break;
}
}
//
dir = file.substr(0, slash_index + 1);
//Get all lines from a file
char line[255];
bool bLocIncludePart = false;
while(fgets(line, 255, fp))
{
std::stringstream ss(line);
FString first;
ss >> first;
// std::cout << first ;
if(first == "#include")
{
FString file_name;
ss >> file_name;
if(file_name.size() > 0 && file_name[0] == '\"' && file_name[file_name.size()-1] == '\"')
{
file_name = file_name.substr(1, file_name.size()-2);
GetLinesFromFile(dir + file_name, true, result);
}
}
else if(first == "#include_part")
// Loads a file into a vector of strings (vResult)
bool CShader::GetLinesFromFile(string sFile, bool bIncludePart, vector<string>* vResult)
{
FILE* fp;
fopen_s(&fp, sFile.c_str(), "rt");
if(!fp)return false;
string sDirectory;
int slashIndex = -1;
for (int i = (int)sFile.size()-1; i == 0; i--)
{
if(sFile[i] == '\\' || sFile[i] == '/')
{
slashIndex = i;
break;
}
}
sDirectory = sFile.substr(0, slashIndex+1);
// Get all lines from a file
char sLine[255];
bool bInIncludePart = false;
while(fgets(sLine, 255, fp))
{
stringstream ss(sLine);
string sFirst;
ss >> sFirst;
if(sFirst == "#include")
{
string sFileName;
ss >> sFileName;
if((int)sFileName.size() > 0 && sFileName[0] == '\"' && sFileName[(int)sFileName.size()-1] == '\"')
{
sFileName = sFileName.substr(1, (int)sFileName.size()-2);
GetLinesFromFile(sDirectory+sFileName, true, vResult);
}
}
else if(sFirst == "#include_part")
bool OpenGLShader::LoadShader(string _fileName, int _shaderType)
{
vector<string> lines = GetLinesFromFile(_fileName);
if (lines.size() == 0)
return false;
const char** programString = new const char*[lines.size()];
for (int i = 0; i < lines.size(); i++)
{
programString[i] = lines[i].c_str();
}
shaderId = glCreateShader(_shaderType);
glShaderSource(shaderId, (int)lines.size(), programString, NULL);
glCompileShader(shaderId);
delete[] programString;
int status;
glGetShaderiv(shaderId, GL_COMPILE_STATUS, &status);
if (status == GL_FALSE)
{
char infoLog[1024];
_TCHAR finalMessage[1536];
int logLength;
glGetShaderInfoLog(shaderId, 1024, &logLength, infoLog);
swprintf(finalMessage, L"Error! Shader file %s wasn't compiled! The compiler returned:\n\n%s", _fileName.c_str(), infoLog);
MessageBox(NULL, finalMessage, _T("Error"), MB_ICONERROR);
return false;
}
shaderType = _shaderType;
return true;
}
bool ShaderManager::LoadShader(const FString& file, int type)
{
std::vector<FString> vec_lines;
if(!GetLinesFromFile(file, false, &vec_lines)) return false;
const char** program = new const char*[vec_lines.size()];
for(int i = 0; i < (int)vec_lines.size(); i++)
{
program[i] = vec_lines[i].c_str();
std::cout << vec_lines[i].c_str();
}
// for(int i = 0; i < vec_lines.size(); i++)
// {
// std::cout << prg << std::endl;
// }
shader_id_ = glCreateShader(type);
glShaderSource(shader_id_, vec_lines.size(), program, nullptr);
glCompileShader(shader_id_);
delete [] program;
int compilation_status;
glGetShaderiv(shader_id_, GL_COMPILE_STATUS, &compilation_status);
if(compilation_status == GL_FALSE)
{
GLint maxLength = 0;
glGetShaderiv(shader_id_, GL_INFO_LOG_LENGTH, &maxLength);
// The maxLength includes the NULL character
std::vector<GLchar> errorLog(maxLength);
glGetShaderInfoLog(shader_id_, maxLength, &maxLength, &errorLog[0]);
// Provide the infolog in whatever manor you deem best.
// Exit with failure.
glDeleteShader(shader_id_); // Don't leak the shader.
for(int i = 0; i < (int)errorLog.size(); i++)
{
std::cout << errorLog[i];
}
return false;
}
std::cout << glGetError() << std::endl;
type_ = type;
bIsLoaded_ = true;
return true;
}
