josh/dwss
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge branch 'shaders'

Browse Source
This commit is contained in:
Josh Holtrop 2011-10-11 12:18:11 -04:00
commit afd1d1a7b8
25 changed files with 286 additions and 1142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.gitignore vendored
View File

@ -1,3 +1,4 @@
dwss
modes.h
LoadFile-gen.inc
cfs.cc
cfs.h

9
.gitmodules vendored Normal file
View File

@ -0,0 +1,9 @@
[submodule "wfobj"]
path = wfobj
url = ../util/wfobj.git
[submodule "cfs_gen"]
path = cfs_gen
url = ../util/cfs_gen.git
[submodule "glslUtil"]
path = glslUtil
url = ../util/glslUtil.git

88
FileLoader.h
View File

@ -1,88 +0,0 @@
#ifndef FILELOADER_H
#define FILELOADER_H FILELOADER_H
#include <string>
#include <iostream>
class FileLoader
{
public:
class Path
{
public:
std::string fullPath;
std::string shortPath;
Path() { }
Path(const std::string & full_path,
const std::string & short_path)
: fullPath(full_path), shortPath(short_path) { }
std::string toString() const
{
std::string ret;
if (shortPath != "")
ret += shortPath + ",";
if (fullPath != "")
ret += fullPath;
return ret;
}
};
class Buffer
{
public:
char * data;
int size;
Buffer(int sz)
{
size = sz;
data = new char[size];
_refcnt = new int;
*_refcnt = 1;
m_alloced = true;
}
Buffer(char * data, int sz)
{
size = sz;
this->data = data;
m_alloced = false;
}
void copy(const Buffer & other)
{
data = other.data;
size = other.size;
m_alloced = other.m_alloced;
if (m_alloced)
{
_refcnt = other._refcnt;
(*_refcnt)++;
}
}
Buffer(const Buffer & other) { copy(other); }
Buffer & operator=(const Buffer & other)
{
copy(other);
return *this;
}
~Buffer()
{
if (m_alloced)
{
(*_refcnt)--;
if (*_refcnt < 1)
{
delete _refcnt;
delete data;
}
}
}
protected:
int * _refcnt;
bool m_alloced;
};
virtual int getSize(const Path & path) = 0;
virtual Buffer load(const Path & path) = 0;
};
#endif

48
LoadFile.cc
View File

@ -1,48 +0,0 @@
#include <iostream>
#include "LoadFile.h"
using namespace std;
/* The data section is generated by a perl script. The contents of the
* included file are part of this logical program unit, which is why it
* is directly included instead of compiling it separately.
*/
#include "LoadFile-gen.inc"
LoadFile::LoadFile()
{
for (unsigned int i = 0;
i < sizeof(LoadFileData)/sizeof(LoadFileData[0]);
i++)
{
m_filemap[LoadFileData[i].filename] = &LoadFileData[i];
}
}
FileLoader::Buffer LoadFile::load(const FileLoader::Path & path)
{
map<string, fileref_t *>::iterator it = m_filemap.find(path.shortPath);
if (it == m_filemap.end())
{
cerr << "Warning: LoadFile::load("
<< path.shortPath << ") did not find file"
<< endl;
return Buffer(0);
}
return Buffer((char *) it->second->data, it->second->length);
}
int LoadFile::getSize(const FileLoader::Path & path)
{
map<string, fileref_t *>::iterator it = m_filemap.find(path.shortPath);
if (it == m_filemap.end())
return 0;
return it->second->length;
}

25
LoadFile.h
View File

@ -1,25 +0,0 @@
#ifndef LOADFILE_H
#define LOADFILE_H
#include <map>
#include <string>
#include "FileLoader.h"
typedef struct {
const char * filename;
unsigned char * data;
int length;
} fileref_t;
class LoadFile : public FileLoader
{
public:
LoadFile();
int getSize(const Path & path);
Buffer load(const Path & path);
protected:
std::map< std::string, fileref_t * > m_filemap;
};
#endif

68
LogoBox.cc
View File

@ -1,68 +0,0 @@
/*
* Author: Josh Holtrop
* DornerWorks ScreenSaver
* This module can be used to create "LogoBox" objects
* which consist of a 3D DW logo
*/
#include <GL/gl.h>
#include "WFObj.h"
#include "LogoBox.h"
#include "LoadFile.h"
#include <string.h> /* memcpy() */
#include <iostream>
using namespace std;
static GLuint _logoList = 0;
static GLuint _drawList;
static LoadFile loadFile;
static float _width, _depth, _height;
/*
* construct a LogoBox object
* The first time the constructor is called it loads the
* Alias Wavefront object model. Subsequent calls will
* reuse the same module.
*/
LogoBox::LogoBox()
{
if (_logoList == 0)
{
WFObj obj(loadFile);
if (obj.load(FileLoader::Path("", "dwlogo.obj")))
{
_logoList = obj.render(false);
if (_logoList == 0)
{
cerr << "Error rendering dwlogo.obj" << endl;
}
const float * aabb = obj.getAABB();
float c_x = (aabb[0] + aabb[3]) / 2.0f;
float c_y = (aabb[1] + aabb[4]) / 2.0f;
float c_z = (aabb[2] + aabb[5]) / 2.0f;
_width = aabb[3] - aabb[0];
_depth = aabb[4] - aabb[1];
_height = aabb[5] - aabb[2];
_drawList = glGenLists(1);
glNewList(_drawList, GL_COMPILE);
glPushMatrix();
glTranslatef(-c_x, -c_y, -c_z);
glCallList(_logoList);
glPopMatrix();
glEndList();
}
else
{
cerr << "Error loading dwlogo.obj" << endl;
}
}
m_drawList = _drawList;
m_width = _width;
m_depth = _depth;
m_height = _height;
}

39
SConstruct
View File

@ -1,16 +1,18 @@
# vim:syntax=python
import os
import re
from subprocess import *
install_dir = '/usr/lib/gnome-screensaver/gnome-screensaver'
desktop_dir = os.getenv('HOME') + '/.local/share/applications/screensavers'
load_files = ['logo/dwlogo.obj', 'logo/dwlogo.mtl']
load_files = ['logo/dwlogo.obj', 'logo/dwlogo.mtl', Glob('shaders/*')]
env = Environment(CPPPATH = ['.'])
env.ParseConfig("pkg-config --cflags --libs glib-2.0 gdk-2.0 atk gtk+-2.0 gtkglext-1.0")
env.Append(CPPFLAGS = ['-Isrc', '-DGL_GLEXT_PROTOTYPES'])
genLoadFile = Builder(action = 'perl genLoadFile.pl --root=logo $SOURCES')
env.Append(BUILDERS = {'LoadFile' : genLoadFile})
# modes builder
def gen_modes(target, source, env):
f = open(str(target[0]), 'w')
@ -22,10 +24,35 @@ def gen_modes(target, source, env):
genModes = Builder(action = gen_modes)
env.Append(BUILDERS = {'Modes' : genModes})
sources = [Glob('*.c'), Glob('*.cc'), Glob('LoadFile/*.cc'), Glob('modes/*.cc')]
# CFS builder
env.LoadFile('LoadFile-gen.inc', load_files)
env.Depends('LoadFile-gen.inc', 'genLoadFile.pl')
def CFS(target, source, env):
source_list = []
for s in source:
source_list.append(str(s))
Popen(['./cfs_gen/cfs_gen.py', str(target[0])] + source_list).wait()
return None
def CFS_emitter(target, source, env):
target.append(re.sub(r'\.cc?', '.h', str(target[0])))
return target, source
env.Append(BUILDERS = {'CFS' : Builder(action = CFS, emitter = CFS_emitter)})
# source file list
sources = [
'cfs.cc',
Glob('src/*.c'),
Glob('src/*.cc'),
Glob('LoadFile/*.cc'),
Glob('modes/*.cc'),
Glob('wfobj/WFObj.cc'),
Glob('glslUtil/*.c'),
]
env.CFS('cfs.cc', load_files)
env.Depends('cfs.cc', 'cfs_gen/cfs_gen.py')
env.Modes('modes.h', Glob('modes/*.h'))

18
TextureLoader.h
View File

@ -1,18 +0,0 @@
#ifndef TEXTURELOADER_H
#define TEXTURELOADER_H TEXTURELOADER_H
#include <string>
#include <GL/gl.h>
#include "FileLoader.h"
class TextureLoader
{
public:
virtual GLuint load(
const FileLoader::Path & path,
FileLoader & fileLoader, bool mipmaps = true,
int mode = GL_DECAL, int quality = 1) = 0;
};
#endif

706
WFObj.cc
View File

@ -1,706 +0,0 @@
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <ctype.h> // isspace()
#include <string.h> // strlen()
#include <GL/gl.h>
#include <vector>
#include <string>
#include <map>
#include <iostream>
#include <fstream>
#include <sstream>
#include "WFObj.h"
using namespace std;
#define WHITESPACE " \n\r\t\v"
//#define DEBUGGL
/****** static functions ******/
static string trimString(string s)
{
size_t lastpos = s.find_last_not_of(WHITESPACE);
if (lastpos == string::npos)
return "";
s.erase(lastpos + 1);
s.erase(0, s.find_first_not_of(WHITESPACE));
return s;
}
static string stripFirstToken(string & input)
{
size_t firstnonspace = input.find_first_not_of(WHITESPACE);
if (firstnonspace == string::npos)
return "";
size_t spaceafter = input.find_first_of(WHITESPACE, firstnonspace);
string token = input.substr(firstnonspace, spaceafter - firstnonspace);
input.erase(0, spaceafter);
return token;
}
static vector<string> splitString(const string & str, char delim)
{
vector<string> ret;
string s = str;
size_t pos;
while ( (pos = s.find(delim)) != string::npos )
{
string t = s.substr(0, pos);
ret.push_back(t);
s.erase(0, pos + 1);
}
if (s != "")
ret.push_back(s);
return ret;
}
static string basePath(const string & str)
{
string path = str;
size_t pos;
if ( (pos = path.find_last_of("/\\")) != string::npos )
{
path.erase(pos + 1);
return path;
}
return "";
}
//#define DEBUG_GL_ERROR
#ifdef DEBUG_GL_ERROR
#define checkGLError() checkGLErrorLine(__FUNCTION__, __LINE__)
static void checkGLErrorLine(const char * function, int line)
{
GLenum err = glGetError();
if (err != 0)
{
cerr << "gl error in " << function
<< ": " << err << " (0x" << hex << err << ") at line "
<< dec << line << endl;
}
}
#else
#define checkGLError()
#endif
/****** WFObj functions ******/
WFObj::WFObj()
{
init();
}
WFObj::WFObj(FileLoader & fileLoader)
{
init(&fileLoader);
}
WFObj::WFObj(TextureLoader & textureLoader)
{
init(NULL, &textureLoader);
}
WFObj::WFObj(FileLoader & fileLoader, TextureLoader & textureLoader)
{
init(&fileLoader, &textureLoader);
}
void WFObj::init (FileLoader * fileLoader,
TextureLoader * textureLoader)
{
m_fileLoader = fileLoader;
if (m_fileLoader == NULL)
{
m_fileLoader = new WFFileLoader();
m_iCreatedFileLoader = true;
}
else
{
m_iCreatedFileLoader = false;
}
m_textureLoader = textureLoader;
}
WFObj::~WFObj()
{
if (m_iCreatedFileLoader)
delete m_fileLoader;
}
void WFObj::clear()
{
m_data = std::vector< std::vector<std::string> >();
m_loadedVertex = false;
}
bool WFObj::load(const FileLoader::Path & path)
{
clear();
FileLoader::Buffer buff = m_fileLoader->load(path);
if (buff.size <= 0)
return false;
m_path = path;
string str(buff.data, buff.size);
stringstream istr(str, ios_base::in);
load(istr, buff.size);
return true;
}
bool WFObj::load(std::istream & istr, unsigned int size)
{
char buf[size+1];
string buildup;
while (istr.good())
{
istr.getline(buf, size+1);
string input = trimString(buf);
int sz = input.size();
if (sz == 0 || input[0] == '#')
continue;
if (input[sz-1] == '\\')
{
input[sz-1] = ' ';
buildup = input;
continue;
}
if (buildup != "")
input = buildup + input;
buildup = "";
processInputLine(input);
}
return true;
}
void WFObj::processInputLine(const std::string & input)
{
string line = input;
vector<string> lineParts;
for (;;)
{
string token = stripFirstToken(line);
if (token == "")
break;
lineParts.push_back(token);
}
if (lineParts.size() > 0)
m_data.push_back(lineParts);
}
GLuint WFObj::render(bool doTextureInfo, bool enableBlending)
{
checkGLError();
GLuint list = glGenLists(1);
glNewList(list, GL_COMPILE);
int len = m_data.size();
enum { VERTEX, VERTEX_TEXTURE, VERTEX_NORMAL, VERTEX_TYPES };
vector<Vertex> vertices[VERTEX_TYPES];
int numVertsLast = 0;
bool inFace = false;
bool inMaterial = false;
string currentMaterialName;
WFMtl material(this);
for (int i = 0; i < len; i++)
{
string type = m_data[i][0];
if (type == "v")
{
Vertex v = readVertex(m_data[i]);
updateAABB(v.getData());
vertices[VERTEX].push_back(v);
}
else if (type == "vt")
vertices[VERTEX_TEXTURE].push_back(readVertex(m_data[i]));
else if (type == "vn")
vertices[VERTEX_NORMAL].push_back(readVertex(m_data[i]));
else if (type == "f")
{
int numVerts = m_data[i].size() - 1;
if (inFace && (numVerts != numVertsLast || numVertsLast > 4))
{
#ifdef DEBUGGL
cout << "glEnd()" << endl;
#endif
glEnd();
inFace = false;
}
if (!inFace)
{
if (numVerts == 3)
{
#ifdef DEBUGGL
cout << "glBegin(GL_TRIANGLES)" << endl;
#endif
glBegin(GL_TRIANGLES);
}
else if (numVerts == 4)
{
#ifdef DEBUGGL
cout << "glBegin(GL_QUADS)" << endl;
#endif
glBegin(GL_QUADS);
}
else
{
#ifdef DEBUGGL
cout << "glBegin(GL_POLYGON)" << endl;
#endif
glBegin(GL_POLYGON);
}
inFace = true;
}
for (int v = 1; v <= numVerts; v++)
{
int vertexIndices[3] = {0, 0, 0};
parseVertexIndices(m_data[i][v], vertexIndices);
for (int j = 0; j < 3; j++)
{
if (vertexIndices[j] < 0)
vertexIndices[j] += vertices[j].size() + 1;
}
bool valid = true;
for (int j = 0; j < 3; j++)
{
if (vertexIndices[j] > (int) vertices[j].size())
{
valid = false;
break;
}
}
if (vertexIndices[VERTEX] <= 0)
valid = false;
if (!valid)
continue;
if (vertexIndices[VERTEX_NORMAL] != 0)
{
/* a normal is present */
#ifdef DEBUGGL
cout << " glNormal3f(" <<
vertices[VERTEX_NORMAL][vertexIndices[VERTEX_NORMAL]-1]
[0] << ", " <<
vertices[VERTEX_NORMAL][vertexIndices[VERTEX_NORMAL]-1]
[1] << ", " <<
vertices[VERTEX_NORMAL][vertexIndices[VERTEX_NORMAL]-1]
[2] << ")" << endl;
#endif
glNormal3fv(vertices[VERTEX_NORMAL]
[vertexIndices[VERTEX_NORMAL]-1].getData());
}
if (vertexIndices[VERTEX_TEXTURE] != 0)
{
/* a texture coordinate is present */
#ifdef DEBUGGL
cout << " glTexCoord2f(" <<
vertices[VERTEX_TEXTURE][vertexIndices[VERTEX_TEXTURE]-1]
[0] << ", " <<
vertices[VERTEX_TEXTURE][vertexIndices[VERTEX_TEXTURE]-1]
[1] << ')' << endl;
#endif
glTexCoord2fv(vertices[VERTEX_TEXTURE]
[vertexIndices[VERTEX_TEXTURE]-1].getData());
}
#ifdef DEBUGGL
cout << " glVertex3f(" <<
vertices[VERTEX][vertexIndices[VERTEX]-1][0] << ", " <<
vertices[VERTEX][vertexIndices[VERTEX]-1][1] << ", " <<
vertices[VERTEX][vertexIndices[VERTEX]-1][2] << ")" <<
" [" << vertexIndices[VERTEX] << "]" << endl;
#endif
glVertex3fv(vertices[VERTEX][vertexIndices[VERTEX]-1].getData());
}
numVertsLast = numVerts;
}
else if (type == "usemtl")
{
if (inFace)
{
#ifdef DEBUGGL
cout << "glEnd()" << endl;
#endif
glEnd();
inFace = false;
}
if (inMaterial)
{
material.renderEnd(currentMaterialName, doTextureInfo,
enableBlending);
inMaterial = false;
}
if (m_data[i].size() >= 2)
{
currentMaterialName = m_data[i][1];
material.renderBegin(currentMaterialName, doTextureInfo,
enableBlending);
inMaterial = true;
}
}
else if (type == "mtllib")
{
if (m_data[i].size() >= 2)
{
FileLoader::Path path(
basePath(m_path.fullPath) + m_data[i][1],
m_data[i][1]);
material.load(path);
}
}
}
if (inFace)
{
#ifdef DEBUGGL
cout << "glEnd()" << endl;
#endif
glEnd();
inFace = false;
}
if (inMaterial)
{
material.renderEnd(currentMaterialName, doTextureInfo, enableBlending);
inMaterial = false;
}
glEndList();
checkGLError();
return list;
}
void WFObj::updateAABB(const float * const vertex)
{
if (m_loadedVertex)
{
if (vertex[0] < m_aabb[0])
m_aabb[0] = vertex[0];
else if (vertex[0] > m_aabb[3])
m_aabb[3] = vertex[0];
if (vertex[1] < m_aabb[1])
m_aabb[1] = vertex[1];
else if (vertex[1] > m_aabb[4])
m_aabb[4] = vertex[1];
if (vertex[2] < m_aabb[2])
m_aabb[2] = vertex[2];
else if (vertex[2] > m_aabb[5])
m_aabb[5] = vertex[2];
}
else
{
m_aabb[0] = m_aabb[3] = vertex[0];
m_aabb[1] = m_aabb[4] = vertex[1];
m_aabb[2] = m_aabb[5] = vertex[2];
m_loadedVertex = true;
}
m_width = m_aabb[3] - m_aabb[0];
m_depth = m_aabb[4] - m_aabb[1];
m_height = m_aabb[5] - m_aabb[2];
}
WFObj::Vertex WFObj::readVertex(const vector<string> & parts)
{
int partslen = parts.size();
Vertex v;
for (int i = 1; i < partslen && i <= 4; i++)
{
sscanf(parts[i].c_str(), "%f", &v[i - 1]);
}
return v;
}
void WFObj::parseVertexIndices(const string & vtxref, int * ret)
{
vector<string> parts = splitString(vtxref, '/');
int num = parts.size();
for (int i = 0; i < num && i < 3; i++)
sscanf(parts[i].c_str(), "%d", ret + i);
}
/****** WFMtl functions ******/
void WFObj::WFMtl::clear()
{
m_data = map< string, vector< vector<string> > >();
m_currentMaterialName = "";
m_attributesPushed = false;
}
bool WFObj::WFMtl::load(const FileLoader::Path & path)
{
clear();
FileLoader::Buffer buff = m_obj->m_fileLoader->load(path);
if (buff.size <= 0)
return false;
m_path = path;
string str(buff.data, buff.size);
stringstream istr(str, ios_base::in);
load(istr, buff.size);
return true;
}
bool WFObj::WFMtl::load(std::istream & istr, unsigned int size)
{
char buf[size+1];
string buildup;
while (istr.good())
{
istr.getline(buf, size+1);
string input = trimString(buf);
int sz = input.size();
if (sz == 0 || input[0] == '#')
continue;
if (input[sz-1] == '\\')
{
input[sz-1] = ' ';
buildup = input;
continue;
}
if (buildup != "")
input = buildup + input;
buildup = "";
processInputLine(input);
}
return true;
}
void WFObj::WFMtl::processInputLine(const std::string & input)
{
string line = input;
vector<string> lineParts;
for (;;)
{
string token = stripFirstToken(line);
if (token == "")
break;
lineParts.push_back(token);
}
if (lineParts.size() > 0)
{
if ( (lineParts.size() >= 2) && (lineParts[0] == "newmtl") )
{
m_currentMaterialName = lineParts[1];
}
else if (m_currentMaterialName != "")
{
m_data[m_currentMaterialName].push_back(lineParts);
}
}
}
void WFObj::WFMtl::renderBegin(const string & mtlname, bool doTextureInfo,
bool enableBlending)
{
map< string, vector< vector<string> > >::iterator it = m_data.find(mtlname);
if (it == m_data.end())
return;
vector< vector<string> > & stmts = it->second;
int num_stmts = stmts.size();
bool foundTexture = false;
bool didSomething = false;
checkGLError();
for (int i = 0; i < num_stmts; i++)
{
string & type = stmts[i][0];
if (type == "Ka") /* set ambient color */
{
if ( (stmts[i].size() == 4) && (stmts[i][1] != "spectral") )
{
pushAttributes();
float mat[4] = {0.0f, 0.0f, 0.0f, 1.0f};
for (int j = 0; j < 3; j++)
sscanf(stmts[i][j+1].c_str(), "%f", &mat[j]);
#ifdef DEBUGGL
cout << " glMaterialfv(GL_FRONT, GL_AMBIENT, {";
for (int j = 0; j < 4; j++)
cout << mat[j] << (j < 3 ? ", " : "})");
cout << endl;
#endif
glMaterialfv(GL_FRONT, GL_AMBIENT, mat);
didSomething = true;
}
}
else if (type == "Kd") /* set diffuse color */
{
if ( (stmts[i].size() == 4) && (stmts[i][1] != "spectral") )
{
pushAttributes();
float mat[4] = {0.0f, 0.0f, 0.0f, 1.0f};
for (int j = 0; j < 3; j++)
sscanf(stmts[i][j+1].c_str(), "%f", &mat[j]);
#ifdef DEBUGGL
cout << " glMaterialfv(GL_FRONT, GL_DIFFUSE, {";
for (int j = 0; j < 4; j++)
cout << mat[j] << (j < 3 ? ", " : "})");
cout << endl;
#endif
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat);
didSomething = true;
}
}
else if (type == "Ks") /* set specular color */
{
if ( (stmts[i].size() == 4) && (stmts[i][1] != "spectral") )
{
pushAttributes();
float mat[4] = {0.0f, 0.0f, 0.0f, 1.0f};
for (int j = 0; j < 3; j++)
sscanf(stmts[i][j+1].c_str(), "%f", &mat[j]);
#ifdef DEBUGGL
cout << " glMaterialfv(GL_FRONT, GL_SPECULAR, {";
for (int j = 0; j < 4; j++)
cout << mat[j] << (j < 3 ? ", " : "})");
cout << endl;
#endif
glMaterialfv(GL_FRONT, GL_SPECULAR, mat);
didSomething = true;
}
}
else if (type == "Ns") /* set shininess */
{
if (stmts[i].size() == 2)
{
pushAttributes();
GLfloat shininess = 0.0f;
sscanf(stmts[i][1].c_str(), "%f", &shininess);
#ifdef DEBUGGL
cout << " glMaterialf(GL_FRONT, GL_SHININESS, "
<< shininess << ")" << endl;
#endif
glMaterialf(GL_FRONT, GL_SHININESS, shininess);
didSomething = true;
}
}
else if (type == "map_Kd") /* load a diffuse texture */
{
if (doTextureInfo)
{
if (stmts[i].size() == 2)
{
if (m_obj->m_textureLoader != NULL)
{
FileLoader::Path path(
basePath(m_path.fullPath + stmts[i][1]),
stmts[i][1]);
GLuint tex = m_obj->m_textureLoader->load(path,
*m_obj->m_fileLoader);
if (tex > 0)
{
pushAttributes(); /* jh 2009-11-16 */
#ifdef DEBUGGL
cout << " glBindTexture(GL_TEXTURE_2D, " << tex << ")" << endl;
#endif
glBindTexture(GL_TEXTURE_2D, tex);
foundTexture = true;
didSomething = true;
}
}
}
}
}
}
checkGLError();
if (didSomething)
{
pushAttributes();
if (doTextureInfo)
{
if (enableBlending)
{
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
}
if (foundTexture)
{
#ifdef DEBUGGL
cout << " glEnable(GL_TEXTURE_2D)" << endl;
#endif
glEnable(GL_TEXTURE_2D);
}
else
{
#ifdef DEBUGGL
cout << " glDisable(GL_TEXTURE_2D)" << endl;
#endif
glDisable(GL_TEXTURE_2D);
}
}
}
checkGLError();
}
void WFObj::WFMtl::pushAttributes()
{
if (m_attributesPushed)
return;
m_attributesPushed = true;
#ifdef DEBUGGL
cout << " glPushAttrib(GL_LIGHTING_BIT | GL_TEXTURE_BIT | GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT)"
<< endl;
#endif
checkGLError();
glPushAttrib(GL_LIGHTING_BIT | GL_TEXTURE_BIT | GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT);
checkGLError();
}
void WFObj::WFMtl::renderEnd(const string & mtlname, bool doTextureInfo,
bool enableBlending)
{
map< string, vector< vector<string> > >::iterator it = m_data.find(mtlname);
if (it == m_data.end())
return;
if (m_attributesPushed)
{
#ifdef DEBUGGL
cout << " glPopAttrib()" << endl;
#endif
checkGLError();
glPopAttrib();
checkGLError();
m_attributesPushed = false;
}
}
/****** WFFileLoader functions ******/
int WFObj::WFFileLoader::getSize(const Path & path)
{
struct stat st;
if (path.fullPath == "")
return -1;
if (stat(path.fullPath.c_str(), &st))
return -2;
return st.st_size;
}
FileLoader::Buffer WFObj::WFFileLoader::load(const Path & path)
{
int size = getSize(path);
if (size > 0)
{
int fd = open(path.fullPath.c_str(), O_RDONLY);
if (fd > 0)
{
Buffer buf(size);
int num_read = read(fd, buf.data, size);
close(fd);
if (num_read > 0)
return buf;
}
}
return Buffer(0);
}

96
WFObj.h
View File

@ -1,96 +0,0 @@
#ifndef WFOBJ_H
#define WFOBJ_H
#include "FileLoader.h"
#include "TextureLoader.h"
#include <GL/gl.h>
#include <vector>
#include <string>
#include <map>
class WFObj
{
public:
WFObj();
WFObj(FileLoader & fileLoader);
WFObj(TextureLoader & textureLoader);
WFObj(FileLoader & fileLoader, TextureLoader & textureLoader);
~WFObj();
class WFMtl
{
public:
WFMtl(WFObj * obj) { m_obj = obj; }
bool load(const FileLoader::Path & path);
void renderBegin(const std::string & mtlname,
bool doTextureInfo = true,
bool enableBlending = false);
void renderEnd(const std::string & mtlname,
bool doTextureInfo = true,
bool enableBlending = false);
protected:
/* methods */
void clear();
void processInputLine(const std::string & input);
void pushAttributes();
bool load(std::istream & istr, unsigned int size);
/* variables */
std::map< std::string, std::vector< std::vector<std::string> > > m_data;
std::string m_currentMaterialName;
bool m_attributesPushed;
FileLoader::Path m_path;
WFObj * m_obj;
};
class WFFileLoader : public FileLoader
{
public:
virtual int getSize(const Path & path);
virtual Buffer load(const Path & path);
};
bool load(const FileLoader::Path & path);
GLuint render(bool doTextureInfo = true,
bool enableBlending = false);
const float * const getAABB() { return m_aabb; }
int getWidth() { return m_width; }
int getDepth() { return m_depth; }
int getHeight() { return m_height; }
protected:
/* types */
class Vertex
{
public:
float operator[](int idx) const { return data[idx]; }
float & operator[](int idx) { return data[idx]; }
float * getData() { return data; }
private:
float data[4];
};
/* methods */
void init(FileLoader * fileLoader = NULL,
TextureLoader * textureLoader = NULL);
void clear();
void processInputLine(const std::string & input);
Vertex readVertex(const std::vector<std::string> & parts);
void parseVertexIndices(const std::string & vtxref, int * ret);
void updateAABB(const float * const vertex);
bool load(std::istream & istr, unsigned int size);
/* variables */
std::vector< std::vector<std::string> > m_data;
FileLoader::Path m_path;
float m_aabb[6];
int m_width, m_depth, m_height;
bool m_loadedVertex;
FileLoader * m_fileLoader;
TextureLoader * m_textureLoader;
bool m_iCreatedFileLoader;
};
#endif

1
cfs_gen Submodule

@ -0,0 +1 @@
Subproject commit 6954147f53d57724b7666bf4a1226e17ca64f734

60
genLoadFile.pl
View File

@ -1,60 +0,0 @@
#!/usr/bin/perl
use strict;
use warnings;
use Getopt::Long;
my $root = '.';
GetOptions('root=s' => \$root);
$root = "$root/" if ($root ne '');
my @fileList = @ARGV;
if ($#fileList < 0)
{
print "$0 <fileList>\n";
exit(42);
}
my %fileData;
my $index = 0;
open(OUTPUT, '>', 'LoadFile-gen.inc');
foreach my $fileName (@fileList)
{
local $/;
open(FILE, '<', $fileName);
my $fileContents = <FILE>;
close(FILE);
my $length = length($fileContents);
my @fileContents = split(//, $fileContents);
my $cname = "dat$index";
print OUTPUT "\nstatic unsigned char ${cname} [] = {\n";
for (my $byteNum = 0; $byteNum <= $#fileContents; $byteNum++)
{
print OUTPUT " " if ($byteNum % 12 == 0);
printf OUTPUT ("0x%02x", ord($fileContents[$byteNum]));
print OUTPUT ", " unless ($byteNum == $#fileContents);
print OUTPUT "\n" if ($byteNum % 12 == 11);
}
print OUTPUT "\n};\n";
$index++;
my $shortName = $fileName;
$shortName =~ s/^$root//;
$fileData{$shortName} = [$cname, $length];
}
print OUTPUT "\nfileref_t LoadFileData[] = {\n";
my @fileNames = keys(%fileData);
for (my $fileIndex = 0; $fileIndex <= $#fileNames; $fileIndex++)
{
my $fileName = $fileNames[$fileIndex];
printf OUTPUT (' {"%s", %s, %s}',
$fileName,
$fileData{$fileName}->[0],
$fileData{$fileName}->[1]);
print OUTPUT "," unless ($fileIndex == $#fileNames);
print OUTPUT "\n";
}
print OUTPUT "};\n";
close(OUTPUT);

1
glslUtil Submodule

@ -0,0 +1 @@
Subproject commit 0d78e3cf4f606953087cdccae989f805e07ac0e3

39
shaders/obj.fp Normal file
View File

@ -0,0 +1,39 @@
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
uniform vec4 ambient, diffuse, specular;
uniform float shininess;
varying vec3 pos_i;
varying vec3 normal_i;
void main(void)
{
vec3 n, lightDir;
vec4 color;
float NdotL, RdotEye;
lightDir = normalize(vec3(-0.4, 0, -0.9));
color = vec4(0.2, 0.2, 0.2, 1.0) * ambient; /* ambient light */
n = normalize(normal_i);
NdotL = max(dot(n, -lightDir), 0.0);
if (NdotL > 0.0)
{
/* diffuse component */
color += diffuse * NdotL;
/* specular component */
RdotEye = dot(normalize(-pos_i), normalize(reflect(-lightDir, n)));
if (RdotEye > 0.0)
{
color += clamp(specular * pow(RdotEye, shininess), 0.0, 1.0);
}
}
gl_FragColor = color;
}

13
shaders/obj.vp Normal file
View File

@ -0,0 +1,13 @@
attribute vec3 pos;
attribute vec3 normal;
varying vec3 pos_i;
varying vec3 normal_i;
void main(void)
{
gl_Position = gl_ModelViewProjectionMatrix * vec4(pos, 1);
pos_i = gl_Position.xyz;
normal_i = gl_NormalMatrix * normal;
}

0
GnomeScreensaver.cc → src/GnomeScreensaver.cc
View File

0
GnomeScreensaver.h → src/GnomeScreensaver.h
View File

137
src/LogoBox.cc Normal file
View File

@ -0,0 +1,137 @@
/*
* Author: Josh Holtrop
* DornerWorks ScreenSaver
* This module can be used to create "LogoBox" objects
* which consist of a 3D DW logo
*/
#include <GL/gl.h>
#include <iostream>
#include "wfobj/WFObj.h"
#include "LogoBox.h"
#include "cfs.h"
#include "glslUtil/glslUtil.h"
#include "WFObjLoadFile.h"
using namespace std;
static WFObj obj;
static GLuint program;
static GLint ambient_loc, diffuse_loc, specular_loc, shininess_loc;
enum Locations {
LOC_POSITION,
LOC_NORMAL
};
static float _width, _depth, _height;
static bool loaded = false;
/*
* construct a LogoBox object
* The first time the constructor is called it loads the
* Alias Wavefront object model. Subsequent calls will
* reuse the same module.
*/
LogoBox::LogoBox()
{
if (!loaded)
{
if (obj.load("logo/dwlogo.obj", WFObjLoadFile))
{
const float * aabb = obj.getAABB();
float c_x = (aabb[0] + aabb[3]) / 2.0f;
float c_y = (aabb[1] + aabb[4]) / 2.0f;
float c_z = (aabb[2] + aabb[5]) / 2.0f;
_width = aabb[3] - aabb[0];
_depth = aabb[4] - aabb[1];
_height = aabb[5] - aabb[2];
loaded = loadShaders();
}
else
{
cerr << "Error loading dwlogo.obj" << endl;
}
}
m_width = _width;
m_depth = _depth;
m_height = _height;
}
bool LogoBox::loadShaders()
{
const guAttribBinding bindings[] = {
{LOC_POSITION, "pos"},
{LOC_NORMAL, "normal"},
{0, NULL}
};
const char *v_shader_src = (const char *) getFile("shaders/obj.vp", NULL);
const char *f_shader_src = (const char *) getFile("shaders/obj.fp", NULL);
if (v_shader_src == NULL || f_shader_src == NULL)
{
cerr << "Error reading shader source files" << endl;
return false;
}
program = guMakeProgramFromSource(v_shader_src, f_shader_src, bindings);
if (program == 0)
{
cerr << "Error creating shaders." << endl;
return false;
}
ambient_loc = glGetUniformLocation(program, "ambient");
diffuse_loc = glGetUniformLocation(program, "diffuse");
specular_loc = glGetUniformLocation(program, "specular");
shininess_loc = glGetUniformLocation(program, "shininess");
glUseProgram(program);
/* set up a default material */
glUniform4f(ambient_loc, 0.2, 0.2, 0.2, 1.0);
glUniform4f(diffuse_loc, 1.0, 0.6, 0.0, 1.0);
glUniform4f(specular_loc, 1.0, 1.0, 1.0, 1.0);
glUniform1f(shininess_loc, 85.0);
return true;
}
static void renderMaterial(const WFObj::Material & m)
{
if (m.flags & WFObj::Material::SHININESS_BIT)
glUniform1f(shininess_loc, m.shininess);
if (m.flags & WFObj::Material::AMBIENT_BIT)
glUniform4fv(ambient_loc, 1, &m.ambient[0]);
if (m.flags & WFObj::Material::DIFFUSE_BIT)
glUniform4fv(diffuse_loc, 1, &m.diffuse[0]);
if (m.flags & WFObj::Material::SPECULAR_BIT)
glUniform4fv(specular_loc, 1, &m.specular[0]);
if (m.flags & WFObj::Material::TEXTURE_BIT)
{
cerr << "error: textured materials not implemented yet" << endl;
}
}
void LogoBox::draw()
{
if (!loaded)
return;
obj.bindBuffers();
glUseProgram(program);
glEnableVertexAttribArray(LOC_POSITION);
glEnableVertexAttribArray(LOC_NORMAL);
int stride = obj.getStride();
glVertexAttribPointer(LOC_POSITION, 3, GL_FLOAT, GL_FALSE,
stride, (GLvoid *) obj.getVertexOffset());
glVertexAttribPointer(LOC_NORMAL, 3, GL_FLOAT, GL_FALSE,
stride, (GLvoid *) obj.getNormalOffset());
for (map<string, WFObj::Material>::iterator it = obj.getMaterials().begin();
it != obj.getMaterials().end();
it++)
{
renderMaterial(it->second);
glDrawElements(GL_TRIANGLES, it->second.num_vertices,
GL_UNSIGNED_SHORT,
(GLvoid *) (sizeof(GLushort) * it->second.first_vertex));
}
}

51
LogoBox.h → src/LogoBox.h
View File

@ -1,26 +1,25 @@
/*
* Author: Josh Holtrop
* DornerWorks screensaver
* The LogoBox class
*/
#ifndef LOGOBOX_H
#define LOGOBOX_H
#include <GL/gl.h>
class LogoBox
{
public:
LogoBox();
void draw() { glCallList(m_drawList); }
float getWidth() const { return m_width; }
float getDepth() const { return m_depth; }
float getHeight() const { return m_height; }
protected:
GLuint m_drawList;
float m_width, m_depth, m_height;
};
#endif
/*
* Author: Josh Holtrop
* DornerWorks screensaver
* The LogoBox class
*/
#ifndef LOGOBOX_H
#define LOGOBOX_H
#include <GL/gl.h>
class LogoBox
{
public:
LogoBox();
void draw();
float getWidth() const { return m_width; }
float getDepth() const { return m_depth; }
float getHeight() const { return m_height; }
protected:
bool loadShaders();
float m_width, m_depth, m_height;
};
#endif

16
src/WFObjLoadFile.cc Normal file
View File

@ -0,0 +1,16 @@
#include <string.h> /* memcpy() */
#include "WFObjLoadFile.h"
#include "cfs.h"
bool WFObjLoadFile(const char *fname, WFObj::Buffer & buff)
{
unsigned int length;
const unsigned char *dat = getFile(fname, &length);
if (dat == NULL)
return false;
buff.alloc(length);
memcpy(buff.data, dat, length);
return true;
}

9
src/WFObjLoadFile.h Normal file
View File

@ -0,0 +1,9 @@
#ifndef WFOBJLOADFILE_H
#define WFOBJLOADFILE_H
#include "wfobj/WFObj.h"
bool WFObjLoadFile(const char *fname, WFObj::Buffer & buff);
#endif /* WFOBJLOADFILE_H */

0
dwss.cc → src/dwss.cc
View File

0
gs-theme-window.c → src/gs-theme-window.c
View File

0
gs-theme-window.h → src/gs-theme-window.h
View File

1
wfobj Submodule

@ -0,0 +1 @@
Subproject commit e4dc0f4d3627ab08e20d1be2dce41981e5771cca