mirror of
https://github.com/AquariaOSE/Aquaria.git
synced 2024-12-25 06:05:45 +00:00
6dc1c1e8d1
- HTTP networking support, mods can be downloaded via the builtin downloader. All network activity runs in a seperate thread, which is started as soon as any network activity is requested. - The master server is hard-coded to fg.wzff.de/aqmods/ if not specified otherwise; this setting can be overridden in the config file. - The mod selector screen is now a grid-view for much better navigation; also works with joystick. - VFS code is functionally similar to the old molebox-packed release for win32. The game could also have its data shipped in a Zip file or any other kind of archive. - It is still possible to build without VFS support, but then the mod downloader and soft-patching will not be available. The full commit history can be found here: https://github.com/fgenesis/Aquaria_clean/compare/master...vfs The most important commit messages follow: [...] This replaces all std::ifstream with InStream, and fopen(), ... with vfopen(), ... Some code is #ifdef'd for better performance and less memory-copying. VFILE is defined to whatever type of file is in use: - FILE if BBGE_BUILD_VFS is not defined - tttvfs::VFSFile if it is. Other changes: - [un]packFile() is now unused and obsolete. That code has not been adjusted to use VFILE. - glpng can now load from a memory buffer. - TinyXML uses the VFS for reading operations now. - The rather clunky binary stream loading of glfont2 got replaced with ByteBuffer, which gets its data in one block (necessary to use the VFS without implementing a somewhat STL-compliant std::ifstream replacement.) ------------- Implement loading mods from zip files. ------------- Implement soft-patching game data files. (Replacing textures/audio/... on the fly) ------------- Misc bits: - Extended GUI focus handling a bit - Fixed weirdness in texture loading... not sure but this seems more correct to me. Actually, considering that the texture will have its native size after restarting the game, the lines removed with this commit seem pretty useless.
390 lines
11 KiB
C++
390 lines
11 KiB
C++
/*
|
|
Copyright (C) 2007, 2010 - Bit-Blot
|
|
|
|
This file is part of Aquaria.
|
|
|
|
Aquaria is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License
|
|
as published by the Free Software Foundation; either version 2
|
|
of the License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
See the GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*/
|
|
#include "Shader.h"
|
|
#ifdef BBGE_BUILD_WINDOWS
|
|
#include <sys/stat.h>
|
|
#endif
|
|
|
|
#ifdef BBGE_BUILD_SHADERS
|
|
// GL_ARB_shader_objects
|
|
PFNGLCREATEPROGRAMOBJECTARBPROC glCreateProgramObjectARB = NULL;
|
|
PFNGLDELETEOBJECTARBPROC glDeleteObjectARB = NULL;
|
|
PFNGLUSEPROGRAMOBJECTARBPROC glUseProgramObjectARB = NULL;
|
|
PFNGLCREATESHADEROBJECTARBPROC glCreateShaderObjectARB = NULL;
|
|
PFNGLSHADERSOURCEARBPROC glShaderSourceARB = NULL;
|
|
PFNGLCOMPILESHADERARBPROC glCompileShaderARB = NULL;
|
|
PFNGLGETOBJECTPARAMETERIVARBPROC glGetObjectParameterivARB = NULL;
|
|
PFNGLATTACHOBJECTARBPROC glAttachObjectARB = NULL;
|
|
PFNGLGETINFOLOGARBPROC glGetInfoLogARB = NULL;
|
|
PFNGLLINKPROGRAMARBPROC glLinkProgramARB = NULL;
|
|
PFNGLGETUNIFORMLOCATIONARBPROC glGetUniformLocationARB = NULL;
|
|
PFNGLUNIFORM4FARBPROC glUniform4fARB = NULL;
|
|
PFNGLUNIFORM1IARBPROC glUniform1iARB = NULL;
|
|
#endif
|
|
|
|
bool Shader::_wasInited = false;
|
|
bool Shader::_useShaders = false;
|
|
|
|
void Shader::staticInit()
|
|
{
|
|
if (_wasInited)
|
|
return;
|
|
|
|
_wasInited = true;
|
|
debugLog("Initializing shaders...");
|
|
|
|
#if defined(BBGE_BUILD_SHADERS) && defined(BBGE_BUILD_OPENGL)
|
|
char *ext = (char*)glGetString( GL_EXTENSIONS );
|
|
|
|
if( strstr( ext, "GL_ARB_shading_language_100" ) == NULL )
|
|
{
|
|
//This extension string indicates that the OpenGL Shading Language,
|
|
// version 1.00, is supported.
|
|
debugLog("GL_ARB_shading_language_100 extension was not found");
|
|
/*
|
|
MessageBox(NULL,"GL_ARB_shading_language_100 extension was not found",
|
|
"ERROR",MB_OK|MB_ICONEXCLAMATION);
|
|
*/
|
|
goto end;
|
|
}
|
|
|
|
if( strstr( ext, "GL_ARB_shader_objects" ) == NULL )
|
|
{
|
|
debugLog("GL_ARB_shader_objects extension was not found");
|
|
goto end;
|
|
}
|
|
else
|
|
{
|
|
#ifdef BBGE_BUILD_GLFW
|
|
glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC)glfwGetProcAddress("glCreateProgramObjectARB");
|
|
glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC)glfwGetProcAddress("glDeleteObjectARB");
|
|
glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC)glfwGetProcAddress("glUseProgramObjectARB");
|
|
glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)glfwGetProcAddress("glCreateShaderObjectARB");
|
|
glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)glfwGetProcAddress("glShaderSourceARB");
|
|
glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC)glfwGetProcAddress("glCompileShaderARB");
|
|
glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC)glfwGetProcAddress("glGetObjectParameterivARB");
|
|
glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC)glfwGetProcAddress("glAttachObjectARB");
|
|
glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC)glfwGetProcAddress("glGetInfoLogARB");
|
|
glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC)glfwGetProcAddress("glLinkProgramARB");
|
|
glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC)glfwGetProcAddress("glGetUniformLocationARB");
|
|
glUniform4fARB = (PFNGLUNIFORM4FARBPROC)glfwGetProcAddress("glUniform4fARB");
|
|
glUniform1iARB = (PFNGLUNIFORM1IARBPROC)glfwGetProcAddress("glUniform1iARB");
|
|
#endif
|
|
|
|
#ifdef BBGE_BUILD_SDL
|
|
glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC)SDL_GL_GetProcAddress("glCreateProgramObjectARB");
|
|
glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC)SDL_GL_GetProcAddress("glDeleteObjectARB");
|
|
glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC)SDL_GL_GetProcAddress("glUseProgramObjectARB");
|
|
glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)SDL_GL_GetProcAddress("glCreateShaderObjectARB");
|
|
glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)SDL_GL_GetProcAddress("glShaderSourceARB");
|
|
glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC)SDL_GL_GetProcAddress("glCompileShaderARB");
|
|
glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC)SDL_GL_GetProcAddress("glGetObjectParameterivARB");
|
|
glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC)SDL_GL_GetProcAddress("glAttachObjectARB");
|
|
glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC)SDL_GL_GetProcAddress("glGetInfoLogARB");
|
|
glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC)SDL_GL_GetProcAddress("glLinkProgramARB");
|
|
glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC)SDL_GL_GetProcAddress("glGetUniformLocationARB");
|
|
glUniform4fARB = (PFNGLUNIFORM4FARBPROC)SDL_GL_GetProcAddress("glUniform4fARB");
|
|
glUniform1iARB = (PFNGLUNIFORM1IARBPROC)SDL_GL_GetProcAddress("glUniform1iARB");
|
|
#endif
|
|
|
|
if( !glCreateProgramObjectARB || !glDeleteObjectARB || !glUseProgramObjectARB ||
|
|
!glCreateShaderObjectARB || !glCreateShaderObjectARB || !glCompileShaderARB ||
|
|
!glGetObjectParameterivARB || !glAttachObjectARB || !glGetInfoLogARB ||
|
|
!glLinkProgramARB || !glGetUniformLocationARB || !glUniform4fARB ||
|
|
!glUniform1iARB )
|
|
{
|
|
glCreateProgramObjectARB = 0;
|
|
debugLog("One or more GL_ARB_shader_objects functions were not found");
|
|
goto end;
|
|
}
|
|
}
|
|
|
|
// everything fine when we are here
|
|
_useShaders = true;
|
|
|
|
#endif
|
|
|
|
end:
|
|
|
|
if (_useShaders)
|
|
debugLog("Shader support enabled.");
|
|
else
|
|
debugLog("Shader support not enabled.");
|
|
}
|
|
|
|
Shader::Shader()
|
|
{
|
|
loaded = false;
|
|
mode = 0;
|
|
#ifdef BBGE_BUILD_OPENGL
|
|
g_vertexShader = 0;
|
|
g_fragmentShader = 0;
|
|
g_programObj = 0;
|
|
vx = vy = vz = vw = 0;
|
|
g_location_texture = 0;
|
|
g_location_mode = 0;
|
|
g_location_value = 0;
|
|
#endif
|
|
}
|
|
|
|
Shader::~Shader()
|
|
{
|
|
#ifdef BBGE_BUILD_SHADERS
|
|
if (!_useShaders)
|
|
return;
|
|
if (g_vertexShader)
|
|
glDeleteObjectARB( g_vertexShader );
|
|
if (g_fragmentShader)
|
|
glDeleteObjectARB( g_fragmentShader );
|
|
if (g_programObj)
|
|
glDeleteObjectARB( g_programObj );
|
|
#endif
|
|
}
|
|
|
|
bool Shader::isLoaded()
|
|
{
|
|
return loaded;
|
|
}
|
|
|
|
void Shader::setMode(int mode)
|
|
{
|
|
this->mode = mode;
|
|
}
|
|
|
|
void Shader::setValue(float x, float y, float z, float w)
|
|
{
|
|
vx = x;
|
|
vy = y;
|
|
vz = z;
|
|
vw = w;
|
|
}
|
|
|
|
unsigned char *readShaderFile( const char *fileName )
|
|
{
|
|
debugLog("readShaderFile()");
|
|
#ifdef BBGE_BUILD_WINDOWS
|
|
FILE *file = fopen( fileName, "r" ); // FIXME: should this code ever be re-activated, adjust to VFS! -- fg
|
|
|
|
if( file == NULL )
|
|
{
|
|
errorLog("Cannot open shader file!");
|
|
return 0;
|
|
}
|
|
|
|
struct _stat fileStats;
|
|
|
|
if( _stat( fileName, &fileStats ) != 0 )
|
|
{
|
|
errorLog("Cannot get file stats for shader file!");
|
|
return 0;
|
|
}
|
|
|
|
|
|
unsigned char *buffer = new unsigned char[fileStats.st_size];
|
|
|
|
int bytes = fread( buffer, 1, fileStats.st_size, file );
|
|
|
|
buffer[bytes] = 0;
|
|
|
|
fclose( file );
|
|
|
|
debugLog("End readShaderFile()");
|
|
|
|
return buffer;
|
|
|
|
#else
|
|
debugLog("End readShaderFile()");
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
void Shader::reload()
|
|
{
|
|
load(vertFile, fragFile);
|
|
}
|
|
|
|
void Shader::bind()
|
|
{
|
|
#ifdef BBGE_BUILD_SHADERS
|
|
if (!_useShaders)
|
|
return;
|
|
glUseProgramObjectARB( g_programObj );
|
|
if( g_location_texture != -1 )
|
|
glUniform1iARB( g_location_texture, 0 );
|
|
if ( g_location_mode )
|
|
glUniform1iARB( g_location_mode, mode);
|
|
if ( g_location_value )
|
|
glUniform4fARB( g_location_value, vx, vy, vz, vw);
|
|
#endif
|
|
}
|
|
|
|
void Shader::unbind()
|
|
{
|
|
#ifdef BBGE_BUILD_SHADERS
|
|
if (!_useShaders)
|
|
return;
|
|
glUseProgramObjectARB( NULL );
|
|
#endif
|
|
}
|
|
|
|
void Shader::load(const std::string &file, const std::string &fragFile)
|
|
{
|
|
staticInit();
|
|
loaded = false;
|
|
|
|
#ifdef BBGE_BUILD_SHADERS
|
|
if(!_useShaders)
|
|
return;
|
|
|
|
debugLog("Shader::load("+file+", "+fragFile+")");
|
|
|
|
g_location_texture = 0;
|
|
g_location_mode = 0;
|
|
g_location_value = 0;
|
|
|
|
try
|
|
{
|
|
|
|
debugLog("Shader::load 1");
|
|
this->vertFile = file;
|
|
this->fragFile = fragFile;
|
|
//
|
|
// If the required extension is present, get the addresses of its
|
|
// functions that we wish to use...
|
|
//
|
|
|
|
const char *vertexShaderStrings[1];
|
|
const char *fragmentShaderStrings[1];
|
|
GLint bVertCompiled;
|
|
GLint bFragCompiled;
|
|
GLint bLinked;
|
|
char str[4096];
|
|
|
|
//
|
|
// Create the vertex shader...
|
|
//
|
|
|
|
debugLog("Shader::load 2");
|
|
|
|
g_vertexShader = glCreateShaderObjectARB( GL_VERTEX_SHADER_ARB );
|
|
|
|
unsigned char *vertexShaderAssembly = readShaderFile( file.c_str() );
|
|
vertexShaderStrings[0] = (char*)vertexShaderAssembly;
|
|
glShaderSourceARB( g_vertexShader, 1, vertexShaderStrings, NULL );
|
|
glCompileShaderARB( g_vertexShader);
|
|
delete[] vertexShaderAssembly;
|
|
|
|
glGetObjectParameterivARB( g_vertexShader, GL_OBJECT_COMPILE_STATUS_ARB,
|
|
&bVertCompiled );
|
|
if( bVertCompiled == false )
|
|
//if (true)
|
|
{
|
|
glGetInfoLogARB(g_vertexShader, sizeof(str), NULL, str);
|
|
std::ostringstream os;
|
|
os << "Vertex Shader Compile Error: " << str;
|
|
debugLog(os.str());
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Create the fragment shader...
|
|
//
|
|
|
|
debugLog("Shader::load 3");
|
|
|
|
g_fragmentShader = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB );
|
|
|
|
unsigned char *fragmentShaderAssembly = readShaderFile( fragFile.c_str() );
|
|
fragmentShaderStrings[0] = (char*)fragmentShaderAssembly;
|
|
glShaderSourceARB( g_fragmentShader, 1, fragmentShaderStrings, NULL );
|
|
glCompileShaderARB( g_fragmentShader );
|
|
delete[] fragmentShaderAssembly;
|
|
|
|
glGetObjectParameterivARB( g_fragmentShader, GL_OBJECT_COMPILE_STATUS_ARB,
|
|
&bFragCompiled );
|
|
if( bFragCompiled == false )
|
|
{
|
|
glGetInfoLogARB( g_fragmentShader, sizeof(str), NULL, str );
|
|
std::ostringstream os;
|
|
os << "Fragment Shader Compile Error: " << str;
|
|
debugLog(os.str());
|
|
return;
|
|
}
|
|
|
|
debugLog("Shader::load 4");
|
|
|
|
//
|
|
// Create a program object and attach the two compiled shaders...
|
|
//
|
|
|
|
|
|
g_programObj = glCreateProgramObjectARB();
|
|
|
|
if (!g_programObj || !g_vertexShader || !g_fragmentShader)
|
|
{
|
|
debugLog("programObj / vertexShader / fragmentShader problem");
|
|
return;
|
|
}
|
|
|
|
glAttachObjectARB( g_programObj, g_vertexShader );
|
|
glAttachObjectARB( g_programObj, g_fragmentShader );
|
|
|
|
//
|
|
// Link the program object and print out the info log...
|
|
//
|
|
|
|
glLinkProgramARB( g_programObj );
|
|
glGetObjectParameterivARB( g_programObj, GL_OBJECT_LINK_STATUS_ARB, &bLinked );
|
|
|
|
debugLog("Shader::load 5");
|
|
|
|
if( bLinked == false )
|
|
{
|
|
glGetInfoLogARB( g_programObj, sizeof(str), NULL, str );
|
|
std::ostringstream os;
|
|
os << "Shader Linking Error: " << str;
|
|
debugLog(os.str());
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Locate some parameters by name so we can set them later...
|
|
//
|
|
|
|
debugLog("Shader::load 6");
|
|
|
|
g_location_texture = glGetUniformLocationARB( g_programObj, "tex" );
|
|
g_location_mode = glGetUniformLocationARB( g_programObj, "mode" );
|
|
g_location_value = glGetUniformLocationARB( g_programObj, "value" );
|
|
|
|
debugLog("Shader::load 7");
|
|
|
|
loaded = true;
|
|
}
|
|
catch(...)
|
|
{
|
|
debugLog("caught exception in shader::load");
|
|
loaded = false;
|
|
}
|
|
#endif
|
|
debugLog("End Shader::load()");
|
|
}
|
|
|