bool SceneLoader::doCamera(istream &str, string &name)
{
if (!getName(str, "camera", name))
return false;
SceneGroup *n = new SceneGroup();
groups[name] = n;
n->_name = name;
n->_camera = new ParametricCamera();
do {
int state = findOpenOrClosedParen(str);
if (state == ERROR) {
SetCameraDefaults(n);
return false;
} else if (state == CLOSED) {
SetCameraDefaults(n);
return true;
}
else if (state == OPEN)
{
string cmd;
vector<ParametricValue*> values;
string sides = "lrbtnf";
int side = 0;
if (readCommand(str, cmd)) {
if (cmd == "perspective") {
if (getValues(str, values) < 1) {
*err << "Perspective with no parameters at ";
errLine(str.tellg());
} else {
cleanAfter(values, 1);
n->_camera->_perspective = values[0];
}
}
else if (cmd.size() == 1 && (side = (int)sides.find(cmd)) != string::npos) {
if (getValues(str, values) < 1) {
*err << "l with no parameters at ";
errLine(str.tellg());
} else {
cleanAfter(values, 1);
n->_camera->_frustum[side] = values[0];
}
}
else
{
*err << "Error: command " << cmd << " not recognized at ";
errLine(str.tellg());
}
findCloseParen(str);
}
}
} while (true);
}
bool SceneLoader::doSphere(istream &str, string &name)
{
if (!getName(str, "sphere", name))
return false;
SceneGroup *n = new SceneGroup();
groups[name] = n;
n->_name = name;
n->_sphere = new ParametricSphere();
do {
int state = findOpenOrClosedParen(str);
if (state == ERROR) {
SetSphereDefaults(n);
return false;
} else if (state == CLOSED) {
SetSphereDefaults(n);
return true;
} else if (state == OPEN)
{
string cmd;
vector<ParametricValue*> values;
if (readCommand(str, cmd)) {
if (cmd == "radius") {
if (getValues(str, values) < 1) {
*err << "Type with no parameters at ";
errLine(str.tellg());
} else {
cleanAfter(values, 1);
n->_sphere->_radius = values[0];
}
} else if (cmd == "material") {
string matName = getString(str);
if (matName.empty()) {
*err << "No material name after material command at ";
errLine(str.tellg());
} else if (materials[matName] == NULL) {
*err << "Unknown material " << matName << " referenced at ";
errLine(str.tellg());
} else {
n->_sphere->_material = materials[matName];
}
} else {
*err << "Error: command " << cmd << " not recognized at ";
errLine(str.tellg());
}
findCloseParen(str);
}
}
} while (true);
}
bool SceneLoader::doSurface(istream &str, string& name) {
name = getString(str);
if (name.empty()) {
*err << "Couldn't read surface name at "; errLine(str.tellg());
return false;
}
if (_savedColors[name] != NULL) {
*err << "Illegal re-use of surface name \"" << name << "\" at ";
curPos(*err,str.tellg());
*err << endl;
return false;
}
do {
int state = findOpenOrClosedParen(str);
if (state == ERROR)
return false;
else if (state == CLOSED)
return true;
else if (state == OPEN) {
string cmd;
vector<ParametricValue*> values;
if (readCommand(str, cmd)) {
if (cmd == "rgb") {
int numv = getValues(str, values);
if (numv < 3) {
*err << "rgb with not enough args at "; errLine(str.tellg());
} else {
cleanAfter(values, 3);
Color *c = new Color();
for (int i = 0; i < 3; i++) {
c->_color[i] = values[i];
}
_savedColors[name] = c;
}
} else if (cmd == "bitmap") {
// something with loading textures
string file = getQuoted(str);
_savedTextures[name] = file;
}
findCloseParen(str);
}
}
} while (true);
}
bool SceneLoader::doLight(istream &str, string &name)
{
if (!getName(str, "light", name))
return false;
SceneGroup *n = new SceneGroup();
groups[name] = n;
n->_name = name;
n->_light = new ParametricLight();
do {
int state = findOpenOrClosedParen(str);
if (state == ERROR) {
SetLightDefaults(n);
return false;
} else if (state == CLOSED) {
SetLightDefaults(n);
return true;
}
else if (state == OPEN)
{
string cmd;
vector<ParametricValue*> values;
if (readCommand(str, cmd)) {
if (cmd == "type") {
if (getValues(str, values) < 1) {
*err << "Type with no parameters at ";
errLine(str.tellg());
} else {
cleanAfter(values, 1);
n->_light->_type = values[0];
}
} else if (cmd == "falloff") {
if (getValues(str, values) < 1) {
*err << "Falloff with no parameters at ";
errLine(str.tellg());
} else {
cleanAfter(values, 1);
n->_light->_falloff = values[0];
}
} else if (cmd == "deaddistance") {
if (getValues(str, values) < 1) {
*err << "deaddistance with no parameters at ";
errLine(str.tellg());
} else {
cleanAfter(values, 1);
n->_light->_deadDistance = values[0];
}
} else if (cmd == "angularfalloff") {
if (getValues(str, values) < 1) {
*err << "angularfalloff with no parameters at ";
errLine(str.tellg());
} else {
cleanAfter(values, 1);
n->_light->_angularFalloff = values[0];
}
} else if (cmd == "color") {
if (getValues(str, values) < 3) {
*err << "color with insufficient parameters at ";
errLine(str.tellg());
} else {
cleanAfter(values, 3);
n->_light->_color = new ParametricColor();
n->_light->_color->_color[0] = values[0];
n->_light->_color->_color[1] = values[1];
n->_light->_color->_color[2] = values[2];
}
} else {
*err << "Error: command " << cmd << " not recognized at ";
errLine(str.tellg());
}
findCloseParen(str);
}
}
} while (true);
}
bool SceneLoader::doMaterial(istream &str, string &name)
{
name = getString(str);
if (name.empty()) {
*err << "Couldn't read material name at ";
errLine(str.tellg());
return false;
}
if (materials[name] != NULL) {
*err << "Illegal re-use of name \"" << name << "\" at ";
errLine(str.tellg());
return false;
}
map<string, int> indices;
indices["ka"] = MAT_KA;
indices["kd"] = MAT_KD;
indices["ks"] = MAT_KS;
indices["ksp"] = MAT_KSP;
indices["ksm"] = MAT_KSM;
indices["kt"] = MAT_KT;
indices["ktn"] = MAT_KTN;
ParametricMaterial *n = new ParametricMaterial();
materials[name] = n;
do {
int state = findOpenOrClosedParen(str);
if (state == ERROR) {
SetMaterialDefaults(n);
return false;
} else if (state == CLOSED) {
SetMaterialDefaults(n);
return true;
}
else if (state == OPEN)
{
string cmd;
vector<ParametricValue*> values;
if (readCommand(str, cmd)) {
if (cmd == "color") {
if (getValues(str, values) < 3) {
*err << "Color with insufficent parameters at ";
errLine(str.tellg());
} else {
cleanAfter(values, 3);
n->_vec3 = new ParametricColor();
for (int ci = 0; ci < 3; ci++)
n->_vec3->_color[ci] = values[ci];
}
} else if (indices.find(cmd) != indices.end()) {
if (getValues(str, values) < 1) {
*err << cmd << " with no parameters at ";
errLine(str.tellg());
} else {
cleanAfter(values, 1);
n->_coefficients[indices[cmd]] = values[0];
}
} else {
*err << "Error: command " << cmd << " not recognized at ";
errLine(str.tellg());
}
findCloseParen(str);
}
}
} while (true);
}
SceneInstance* SceneLoader::doI(istream &str, string &name)
{
name = getString(str);
if (name.empty()) {
*err << "Couldn't read instance name at ";
errLine(str.tellg());
return NULL;
}
string var = getString(str);
if (groups[var] == NULL)
{
*err << "Instancing node " << var << " which doesn't exist yet at ";
curPos(*err,str.tellg());
*err << endl;
return NULL;
}
SceneInstance *n = new SceneInstance();
instances.push_back(n); //nodes[name] = n;
n->_name = name;
n->_child = groups[var];
do {
int state = findOpenOrClosedParen(str);
if (state == ERROR)
return NULL;
else if (state == CLOSED)
return n;
else if (state == OPEN)
{
string cmd;
vector<ParametricValue*> values;
if (readCommand(str, cmd)) {
if (cmd == "R") // load rotations
{
int numv = getValues(str, values);
Rotate *r = NULL;
if (numv < 1) {
*err << "R with no args at ";
errLine(str.tellg());
} else if (numv < 4) {
cleanAfter(values, 1);
r = new Rotate();
r->angle = values[0];
} else {
cleanAfter(values, 4);
r = new Rotate();
r->angle = values[0];
for (int i = 0; i < 3; i++)
r->axis[i] = values[i+1];
}
if (r != NULL)
n->_transforms.push_back(r);
}
else if (cmd == "Xform")
{
int numv = getValues(str, values);
GeneralTransform *g = NULL;
if (numv < 9) {
*err << "Xform with too few parameters at ";
errLine(str.tellg());
} else if (numv < 16) { // 2d
cleanAfter(values, 9);
g = new GeneralTransform();
for (int i = 0; i < 9; i++)
g->matrix.push_back(values[i]);
} else {
cleanAfter(values, 16);
g = new GeneralTransform();
for (int i = 0; i < 16; i++)
g->matrix.push_back(values[i]);
}
if (g != NULL)
n->_transforms.push_back(g);
}
else if (cmd == "T")
{
int numv = getValues(str, values);
Translate *t = NULL;
if (numv < 2) {
*err << "T with too few parameters at ";
errLine(str.tellg());
} else if (numv == 2) {
t = new Translate();
for (int i = 0; i < 2; i++)
t->translate[i] = values[i];
} else {
cleanAfter(values, 3);
t = new Translate();
for (int i = 0; i < 3; i++)
t->translate[i] = values[i];
}
if (t != NULL)
n->_transforms.push_back(t);
}
else if (cmd == "S")
{
int numv = getValues(str, values);
Scale *s = NULL;
if (numv < 2) {
*err << "S with too few parameters at ";
errLine(str.tellg());
} else if (numv == 2) {
s = new Scale();
for (int i = 0; i < 2; i++)
s->scale[i] = values[i];
} else {
s = new Scale();
for (int i = 0; i < 3; i++)
s->scale[i] = values[i];
}
if (s != NULL)
n->_transforms.push_back(s);
}
else if (cmd == "color")
{
int numv = getValues(str, values);
ParametricColor *c = NULL;
if (numv < 3) {
*err << "color with too few parameters at ";
errLine(str.tellg());
} else {
cleanAfter(values, 3);
c = new ParametricColor();
for (int i = 0; i < 3; i++)
c->_color[i] = values[i];
}
if (c != NULL)
n->_color = c;
}
else if (cmd == "lod")
{
int numv = getValues(str, values);
LOD *l = NULL;
if (numv < 1) {
*err << "lod with no parameters at ";
errLine(str.tellg());
} else {
//cout << "got lod" << endl;
cleanAfter(values, 1);
l = new LOD();
l->_level = values[0];
}
if (l != NULL)
n->_lod = l;
}
else
{
*err << "Error: command " << cmd << " not recognized at ";
curPos(*err,str.tellg());
*err << endl;
}
findCloseParen(str);
}
}
} while (true);
}
bool SceneLoader::doM(istream &str, string &name) {
name = getString(str);
if (name.empty())
return false;
if (groups[name] != NULL) {
*err << "Illegal re-use of group name \"" << name << "\" at ";
curPos(*err,str.tellg());
*err << endl;
return false;
}
SceneGroup *n = new SceneGroup();
n->_poly = new Polygon();
n->_name = name;
groups[name] = n;
vector<Vertex> temp;
do {
int state = findOpenOrClosedParen(str);
if (state == ERROR)
return false;
else if (state == CLOSED)
return true;
else if (state == OPEN) {
string cmd;
vector<ParametricValue*> values;
if (readCommand(str, cmd)) {
if (cmd == "v") {
int numv = getValues(str, values);
if (numv < 1) {
*err << "v with no args at "; errLine(str.tellg());
} else if (numv < 3) {
*err << "v with not enough args at "; errLine(str.tellg());
} else {
cleanAfter(values, 3);
double x, y, z;
x = values[0]->getValue();
y = values[1]->getValue();
z = values[2]->getValue();
temp.push_back(Vertex(x, y, z));
}
} else if (cmd == "f") {
/*
bool texFlag = false;
str.get(); // get rid of white space
char nextChar = str.peek();
if (!((nextChar >= '0') && (nextChar <= '9'))) {
string fcmd;
findOpenParen(str);
if (readCommand(str, fcmd)) {
if (fcmd == "surf") {
//load the texture
string textureName;
textureName = getString(str);
texFlag = true;
std::cout << "texture accquired: " + _savedTextures[textureName] << std::endl;
n->_poly->setTexName(_savedTextures[textureName]);
}
}
}
if (!texFlag) {
n->_poly->setTexName("noTexture");
}
*/
string line;
getline(str, line);
std::cout << line << std::endl;
stringstream ss(stringstream::in | stringstream::out);
ss.str(line);
while (!ss.eof()) {
std::cout << "in loop" << std::endl;
string elem;
ss >> elem;
std::cout << "elem: " + elem << std::endl;
if (elem == ")") {
break;
}
string tempVertIndex = "";
int elemIndex;
for (elemIndex = 0; elemIndex < elem.size(); elemIndex++) {
if (elem[elemIndex] == '(') {
break;
} else {
tempVertIndex = tempVertIndex + elem[elemIndex];
}
}
size_t endIndex = elem.size() - elemIndex - 2;
string texCoords = elem.substr(elemIndex + 1, endIndex);
std::cout << texCoords << std::endl; ////
endIndex = texCoords.find(",");
string sTempVal = "";
string tTempVal = "";
for (int i = 0; i < texCoords.size(); i++) {
if (texCoords[i] == ',' ) {
endIndex = texCoords.size() - i - 1;
tTempVal = texCoords.substr(i + 1, endIndex);
std::cout << "tTempVal: " + tTempVal << std::endl; ////
break;
}
sTempVal = sTempVal + texCoords[i];
}
char s[sizeof(sTempVal)];
char t[sizeof(tTempVal)];
for (int i = 0; i < sTempVal.size(); i++) {
s[i] = sTempVal[i];
}
for (int i = 0; i < tTempVal.size(); i++) {
t[i] = tTempVal[i];
}
double sVal = atof(s);
double tVal = atof(t);
vec2 textureCoord = vec2(sVal, tVal);
char tVIndex[sizeof(tempVertIndex)];
for (int i = 0; i < tempVertIndex.size(); i++) {
tVIndex[i] = tempVertIndex[i];
}
int vertIndex = atoi(tVIndex) - 1;
//std::cout << "textureCoord: " << textureCoord << std::endl;
//std::cout << "vertIndex: " << temp[vertIndex].getPos() << std::endl;
n->_poly->addTexCoordinate(textureCoord);
temp[vertIndex].setTextureCoord(textureCoord);
n->_poly->addVertex(temp[vertIndex]);
std::cout << "why? :( " << std::endl;
}
std::cout << "mesh added" << std::endl;
str.putback(')');
std::cout << "pushed ) back" << std::endl;
}
/*else {
*err << "invalid args for f"; errLine(str.tellg());
}
} else {
int numv = getValues(str, values);
if (numv < 1) {
*err << "f with no args at "; errLine(str.tellg());
} else if (numv < 3) {
*err << "f with not enough args at "; errLine(str.tellg());
} else {
for (int i = 0; i < numv; i++) {
int vertIndex = values[i]->getValue() - 1;
std::cout << temp[vertIndex].getPos() << std::endl;
n->_poly->addVertex(&temp[vertIndex]);
}
}
}
*/
findCloseParen(str);
}
}
