bool GLShader::ValidateCompile(GLuint shader)
{
GLint compiled;
glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
if (!compiled) {
GLsizei length;
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &length);
/*output shader log info*/
GLchar* log = new GLchar[length + 1];
glGetShaderInfoLog(shader, length, &length, log);
#ifdef UNICODE
std::string log_text(log);
UConverter converter;
UString log_string = converter.from_bytes(log_text);
DebugPrintF(log_string.c_str());
std::cout << log << std::endl;
#else
DebugPrintF(VTEXT("Shader Log: %s\n"),
log);
#endif
delete[] log;
return false;
}
return true;
}
SDL_GW_Params GameConfig::ParseWindow(const XMLDOC& doc)
{
using namespace tinyxml2;
SDL_GW_Params params;
const XMLElement* gameElement = doc.FirstChildElement("game");
const XMLElement* windowElement = gameElement->FirstChildElement("window");
#ifdef UNICODE /*this could change in future*/
UConverter convert;
params.title = convert.from_bytes(windowElement->Attribute("title"));
#else
params.title = windowElement->Attribute("title");
#endif
params.x = windowElement->IntAttribute("x");
params.y = windowElement->IntAttribute("y");
params.width = windowElement->IntAttribute("width");
params.height = windowElement->IntAttribute("height");
/* const XMLElement* rendererElement = gameElement->FirstChildElement("renderer");
const char* renderer = rendererElement->Attribute("type");
if (!strcmp(renderer, "DirectX"))
params.renderer = SDL_GW_Renderer::OPENGL;
else
params.renderer = SDL_GW_Renderer::DIRECTX;*/
return params;
}
bool SDLGameWindow::VInit()
{
/* Initialize SDL
*/
if (SDL_Init(SDL_INIT_TIMER) != 0) {
DebugPrintF(VTEXT("SDL Failed to Initialize"));
return false;
}
/*Create the SDL_Window handle*/
#ifdef UNICODE
UConverter convert;
std::string title = convert.to_bytes(m_params.title);
#else
std::string title = m_params.title;
#endif
m_windowHandle = SDL_CreateWindow(title.c_str(),
m_params.x <= 0 ? SDL_WINDOWPOS_CENTERED : m_params.x,
m_params.y <= 0 ? SDL_WINDOWPOS_CENTERED : m_params.y,
m_params.width,
m_params.height,
SDL_WINDOW_OPENGL);
if (!m_windowHandle) {
SDL_Quit();
DebugPrintF(VTEXT("Failed to created SDL_Window handle"));
return false;
}
#ifdef VIX_SYS_WINDOWS
SDL_SysWMinfo info;
SDL_VERSION(&info.version);
if (SDL_GetWindowWMInfo(m_windowHandle, &info))
{
m_nativeHandle = info.info.win.window;
if (m_renderer)
m_renderer->VAttachNativeHandle(m_nativeHandle);
}
#endif
#ifdef VIX_SYS_LINUX //for now
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_COMPATIBILITY);
/*create OpenGL context*/
m_context = SDL_GL_CreateContext(m_windowHandle);
if (!m_context) {
SDL_Quit();
DebugPrintF(VTEXT("Failed to create SDL_GL_Context handle"));
return false;
}
#endif
if (m_renderer && !m_renderer->VInitialize()) {
DebugPrintF(VTEXT("Renderer failed to initialize"));
return false;
}
return true;
}
std::string UStringToStd(const UString& str)
{
#ifdef VIX_SYS_WINDOWS
UConverter cv;
return cv.to_bytes(str);
#else
return UString(str);
#endif
}
UString UStringFromCharArray(const char* data)
{
#ifdef VIX_SYS_WINDOWS
UConverter cv;
return cv.from_bytes(data);
#else
return UString(data);
#endif
}
bool SDLGameWindow::VInit()
{
/* Initialize SDL
*/
if (SDL_Init(SDL_INIT_TIMER | SDL_INIT_GAMECONTROLLER) != 0) {
DebugPrintF(VTEXT("SDL Failed to Initialize"));
return false;
}
/*Create the SDL_Window handle*/
#ifdef UNICODE
UConverter convert;
std::string title = convert.to_bytes(m_params.title);
#else
std::string title = m_params.title;
#endif
m_windowHandle = SDL_CreateWindow(title.c_str(),
m_params.x <= 0 ? SDL_WINDOWPOS_CENTERED : m_params.x,
m_params.y <= 0 ? SDL_WINDOWPOS_CENTERED : m_params.y,
m_params.width,
m_params.height,
SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_SHOWN);
if (!m_windowHandle) {
SDL_Quit();
DebugPrintF(VTEXT("Failed to created SDL_Window handle"));
return false;
}
#ifdef VIX_SYS_WINDOWS
SDL_SysWMinfo info;
SDL_VERSION(&info.version);
if (SDL_GetWindowWMInfo(m_windowHandle, &info))
{
m_nativeHandle = info.info.win.window;
}
#endif
#ifdef VIX_SYS_LINUX //for now
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_COMPATIBILITY);
/*create OpenGL context*/
m_context = SDL_GL_CreateContext(m_windowHandle);
if (!m_context) {
SDL_Quit();
DebugPrintF(VTEXT("Failed to create SDL_GL_Context handle"));
return false;
}
#endif
m_mouseState = new SDLMouseState;
m_keyboardState = new SDLKeyboardState;
m_controllerState = new SDLControllerState;
m_running = true;
return true;
}
bool GLShader::VInitFromString(const UString& path)
{
#if defined UNICODE && defined VIX_SYS_WINDOWS
UConverter cv;
std::string _source = cv.to_bytes(m_info.raw.c_str());
const GLchar* source = _source.c_str();
#else
const GLchar* source = (const GLchar*)m_info.raw.c_str();
#endif
if (!LoadShader(source)) {
if (CheckError(error)) {
DebugPrintF(VTEXT("Failed to init shader from source\n"));
return true;
}
}
return false;
}
void Model::init_model(UString filePath)
{
std::string _path;
#if defined(VIX_SYS_WINDOWS) && defined(UNICODE)
UConverter cv;
_path = cv.to_bytes(filePath);
#else
_path = filePath;
#endif
Assimp::Importer imp;
const aiScene* scene = imp.ReadFile(_path,
aiProcess_CalcTangentSpace |
aiProcess_Triangulate |
aiProcess_JoinIdenticalVertices |
aiProcess_SortByPType |
aiProcess_GenUVCoords);
if(!scene) {
// DebugPrintF(VTEXT("ASSIMP: Error could not read file [%s]"), _path);
return;
}
size_t numMeshes = scene->mNumMeshes;
aiString diffuse;
aiString bump;
for(size_t i = 0; i < numMeshes; i++)
{
aiMesh* mesh = scene->mMeshes[i];
size_t matIndex = mesh->mMaterialIndex;
aiMaterial* mat = scene->mMaterials[matIndex];
aiGetMaterialTexture(mat, aiTextureType_DIFFUSE, 0, &diffuse);
aiGetMaterialTexture(mat, aiTextureType_HEIGHT, 0, &bump);
aiColor4D color;
aiGetMaterialColor(mat, AI_MATKEY_COLOR_DIFFUSE, &color);
printf("MATCOLOR [%f, %f, %f, %f]\n", color.r, color.g, color.b, color.a);
printf("MATTEXT [DIFFUSE: %s]\n", diffuse.data);
printf("MATTEXT [BUMP: %s]\n", bump.data);
/*INIT MODEL CENTROID, SIZE, MIN, AND MAX*/
/*USED FOR COLLIDER*/
aiVector3D min, max, center;
FindMeshCenter(mesh, center, min, max);
m_min = Vec3(min.x, min.y, min.z);
m_max = Vec3(max.x, max.y, max.z);
m_size = m_max - m_min;
m_centroid = Vec3(center.x, center.y, center.z);
InitMesh(mesh);
}
if(diffuse.C_Str()) {
UString texPath = Vixen::UStringFromCharArray(diffuse.data);
m_texture = new GLTexture(texPath);
}
if(bump.C_Str()) {
UString texPath = Vixen::UStringFromCharArray(bump.data);
m_bump = new GLTexture(texPath);
}
m_initialized = true;
}
