void renderThread(int argc, char **argv) {
// Prepare viewport
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT);
// Setup
setup();
// Turn on Alpha blending
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
// Clear the background
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
int textureCounter = 0;
//Load the the resources (textures)
for (uint i = 1; i < argc ; i++){
std::string argument = std::string(argv[i]);
if (argument == "-x" || argument == "-y" ||
argument == "-w" || argument == "--width" ||
argument == "-h" || argument == "--height" ) {
i++;
} else if ( argument == "--square" ||
argument == "-l" ||
argument == "--life-coding" ) {
} else if ( argument == "-m" ) {
bCursor = true;
cursor.init();
} else if ( argument == "-s" || argument == "--sec") {
i++;
argument = std::string(argv[i]);
timeLimit = getFloat(argument);
std::cout << "Will exit in " << timeLimit << " seconds." << std::endl;
} else if ( argument == "-o" ){
i++;
argument = std::string(argv[i]);
if( haveExt(argument,"png") ){
outputFile = argument;
std::cout << "Will save screenshot to " << outputFile << " on exit." << std::endl;
} else {
std::cout << "At the moment screenshots only support PNG formats" << std::endl;
}
} else if (argument.find("-") == 0) {
std::string parameterPair = argument.substr(argument.find_last_of('-')+1);
i++;
argument = std::string(argv[i]);
Texture* tex = new Texture();
if( tex->load(argument) ){
textures[parameterPair] = tex;
std::cout << "Loading " << argument << " as the following uniform: " << std::endl;
std::cout << " uniform sampler2D " << parameterPair << "; // loaded"<< std::endl;
std::cout << " uniform vec2 " << parameterPair << "Resolution;"<< std::endl;
}
} else if ( haveExt(argument,"png") || haveExt(argument,"PNG") ||
haveExt(argument,"jpg") || haveExt(argument,"JPG") ||
haveExt(argument,"jpeg") || haveExt(argument,"JPEG") ) {
Texture* tex = new Texture();
if( tex->load(argument) ){
std::string name = "u_tex"+getString(textureCounter);
textures[name] = tex;
std::cout << "Loading " << argument << " as the following uniform: " << std::endl;
std::cout << " uniform sampler2D " << name << "; // loaded"<< std::endl;
std::cout << " uniform vec2 " << name << "Resolution;"<< std::endl;
textureCounter++;
}
}
}
// Render Loop
while (isGL() && bPlay) {
// Update
updateGL();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Draw
draw();
// Swap the buffers
renderGL();
if ( timeLimit > 0.0 && getTime() > timeLimit ) {
onKeyPress('s');
bPlay = false;
}
}
}
// Main program
//============================================================================
int main(int argc, char **argv){
// Load files to watch
struct stat st;
for (uint i = 1; i < argc ; i++){
std::string argument = std::string(argv[i]);
if ( iFrag == -1 && ( haveExt(argument,"frag") || haveExt(argument,"fs") ) ) {
int ierr = stat(argument.c_str(), &st);
if (ierr != 0) {
std::cerr << "Error watching file " << argv[i] << std::endl;
} else {
WatchFile file;
file.type = "fragment";
file.path = argument;
file.lastChange = st.st_mtime;
files.push_back(file);
iFrag = files.size()-1;
}
} else if ( iVert == -1 && ( haveExt(argument,"vert") || haveExt(argument,"vs") ) ) {
int ierr = stat(argument.c_str(), &st);
if (ierr != 0) {
std::cerr << "Error watching file " << argument << std::endl;
} else {
WatchFile file;
file.type = "vertex";
file.path = argument;
file.lastChange = st.st_mtime;
files.push_back(file);
iVert = files.size()-1;
}
} else if ( iGeom == -1 &&
( haveExt(argument,"ply") || haveExt(argument,"PLY") ||
haveExt(argument,"obj") || haveExt(argument,"OBJ") ) ) {
int ierr = stat(argument.c_str(), &st);
if (ierr != 0) {
std::cerr << "Error watching file " << argument << std::endl;
} else {
WatchFile file;
file.type = "geometry";
file.path = argument;
file.lastChange = st.st_mtime;
files.push_back(file);
iGeom = files.size()-1;
}
} else if ( haveExt(argument,"png") || haveExt(argument,"PNG") ||
haveExt(argument,"jpg") || haveExt(argument,"JPG") ||
haveExt(argument,"jpeg") || haveExt(argument,"JPEG") ){
int ierr = stat(argument.c_str(), &st);
if (ierr != 0) {
// std::cerr << "Error watching file " << argument << std::endl;
} else {
WatchFile file;
file.type = "image";
file.path = argument;
file.lastChange = st.st_mtime;
files.push_back(file);
}
}
}
// If no shader
if( iFrag == -1 && iVert == -1 && iGeom == -1) {
std::cerr << "Usage: " << argv[0] << " shader.frag [shader.vert] [mesh.(obj/.ply)] [texture.(png/jpg)] [-textureNameA texture.(png/jpg)] [-u] [-x x] [-y y] [-w width] [-h height] [-l/--livecoding] [--square] [-s seconds] [-o screenshot.png]\n";
return EXIT_FAILURE;
}
// Fork process with a shared variable
//
int shmId = shmget(IPC_PRIVATE, sizeof(bool), 0666);
pid_t pid = fork();
iHasChanged = (int *) shmat(shmId, NULL, 0);
switch(pid) {
case -1: //error
break;
case 0: // child
{
*iHasChanged = -1;
watchThread();
}
break;
default:
{
// Initialize openGL context
initGL(argc,argv);
// OpenGL Render Loop
renderThread(argc,argv);
// Kill the iNotify watcher once you finish
kill(pid, SIGKILL);
onExit();
}
break;
}
shmctl(shmId, IPC_RMID, NULL);
return 0;
}
bool TextureCube::load(const std::string &_path, bool _vFlip) {
// Init
glGenTextures(1, &m_id);
glBindTexture(GL_TEXTURE_CUBE_MAP, m_id);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
#ifndef PLATFORM_RPI
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
#endif
int sh_samples = 0;
if (haveExt(_path,"png") || haveExt(_path,"PNG") ||
haveExt(_path,"jpg") || haveExt(_path,"JPG") ||
haveExt(_path,"jpeg") || haveExt(_path,"JPEG")) {
unsigned char* data = loadPixels(_path, &m_width, &m_height, RGB, false);
// LOAD FACES
Face<unsigned char> **faces = new Face<unsigned char>*[6];
if (m_height > m_width) {
if (m_width/6 == m_height) {
// Vertical Row
splitFacesFromVerticalRow<unsigned char>(data, m_width, m_height, faces);
}
else {
// Vertical Cross
splitFacesFromVerticalCross<unsigned char>(data, m_width, m_height, faces);
// adjust NEG_Z face
if (_vFlip) {
faces[5]->flipHorizontal();
faces[5]->flipVertical();
}
}
}
else {
if (m_width/2 == m_height) {
// Equilateral
splitFacesFromEquilateral<unsigned char>(data, m_width, m_height, faces);
}
else if (m_width/6 == m_height) {
// Horizontal Row
splitFacesFromHorizontalRow<unsigned char>(data, m_width, m_height, faces);
}
else {
// Horizontal Cross
splitFacesFromHorizontalCross<unsigned char>(data, m_width, m_height, faces);
}
}
for (int i = 0; i < 6; i++) {
faces[i]->upload();
sh_samples += faces[i]->calculateSH(SH);
}
delete[] data;
for(int i = 0; i < 6; ++i) {
delete[] faces[i]->data;
delete faces[i];
}
delete[] faces;
}
else if (haveExt(_path, "hdr") || haveExt(_path,"HDR")) {
float* data = loadFloatPixels(_path, &m_width, &m_height, false);
// LOAD FACES
Face<float> **faces = new Face<float>*[6];
if (m_height > m_width) {
if (m_width/6 == m_height) {
// Vertical Row
splitFacesFromVerticalRow<float>(data, m_width, m_height, faces);
}
else {
// Vertical Cross
splitFacesFromVerticalCross<float>(data, m_width, m_height, faces);
// adjust NEG_Z face
if (_vFlip) {
faces[5]->flipHorizontal();
faces[5]->flipVertical();
}
}
}
else {
if (m_width/2 == m_height) {
// Equilatera
splitFacesFromEquilateral<float>(data, m_width, m_height, faces);
}
else if (m_width/6 == m_height) {
// Horizontal Row
splitFacesFromHorizontalRow<float>(data, m_width, m_height, faces);
}
else {
// Horizontal Cross
splitFacesFromHorizontalCross<float>(data, m_width, m_height, faces);
}
}
for (int i = 0; i < 6; i++) {
faces[i]->upload();
sh_samples += faces[i]->calculateSH(SH);
}
delete[] data;
for(int i = 0; i < 6; ++i) {
delete[] faces[i]->data;
delete faces[i];
}
delete[] faces;
}
for (int i = 0; i < 9; i++) {
SH[i] = SH[i] * (32.0f / (float)sh_samples);
}
glGenerateMipmap(GL_TEXTURE_CUBE_MAP);
glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
m_path = _path;
return true;
}