int main(int argc, char* argv[])
{
;
MANAGER.init(argc, argv);
GlutUI::Window & mainWindow = MANAGER.createWindow(640,480, "TestWindow");
GlutUI::Panel & mainPanel = MANAGER.createPanel(mainWindow, 640,480, "TestPanel");
std::cout << std::string((char *) glGetString(GL_VENDOR)) << std::endl;
std::cout << std::string((char *) glGetString(GL_RENDERER)) << std::endl;
std::cout << "OpenGL " << std::string((char *) glGetString(GL_VERSION)) << std::endl;
std::cout << "====================================================" << std::endl;
Scene::World world = Scene::createWorld();
mainPanel.setWorld(&world);
GlutUI::Button & testButton = MANAGER.createButton(mainPanel, 40, 20, 10, 10, "TestButton");
Scene::Grid * gridXZ = new Scene::Grid();
world.addObject(gridXZ);
gridXZ->setTy(-5);
Scene::Grid * gridXY = new Scene::Grid();
world.addObject(gridXY);
gridXY->setRotx(90);
gridXY->setTz(-5);
Scene::Grid * gridYZ = new Scene::Grid();
world.addObject(gridYZ);
gridYZ->setRotz(90);
gridYZ->setTx(-5);
mainPanel.setWorld(&world);
mainPanel.setCamera(new Scene::Camera());
GlutUI::Controls::Mouse(mainPanel.getCamera());
MANAGER.drawElements();
return 0;
}
int main(int argc, char* argv[])
{
MANAGER.init(argc, argv);
int windowWidth = 256;
int windowHeight = 256;
GlutUI::Window & mainWindow = MANAGER.createWindow(windowWidth, windowHeight, "Render Window");
GlutUI::Panel & mainPanel = MANAGER.createPanel(mainWindow, windowWidth, windowHeight, "Render Panel");
Scene::World world = Scene::createWorld();
std::cout << std::string((char *)glGetString(GL_VENDOR)) << std::endl;
std::cout << std::string((char *)glGetString(GL_RENDERER)) << std::endl;
std::cout << "OpenGL " << std::string((char *)glGetString(GL_VERSION)) << std::endl;
std::cout << "====================================================" << std::endl;
Scene::Shader* rainbowShader = new Scene::Shader("shaders/rainbow_vert.glsl", "shaders/rainbow_frag.glsl");
//char* fileName = argv[1];
char* fileName = "models/sphere.off";
Scene::MeshObject* meshObject = new Scene::MeshObject(fileName);
world.assignShader(meshObject, rainbowShader);
meshObject->readGeom();
world.addObject(meshObject);
float xMin = meshObject->xMin();
float xMax = meshObject->xMax();
float yMin = meshObject->yMin();
float yMax = meshObject->yMax();
float zMin = meshObject->zMin();
float zMax = meshObject->zMax();
float xSpan = xMax - xMin;
float ySpan = yMax - yMin;
float zSpan = zMax - zMin;
float xMid = (xMin + xMax) / 2;
float yMid = (yMin + yMax) / 2;
float zMid = (zMin + zMax) / 2;
meshObject->setTx(-xMid);
meshObject->setTy(-yMid);
meshObject->setTz(-zMid);
float s = 0.5;
float xAxisMin = -s*xSpan;
float yAxisMin = -s*ySpan;
float zAxisMin = -s*zSpan;
float xAxisMax = s*xSpan;
float yAxisMax = s*ySpan;
float zAxisMax = s*zSpan;
Scene::Arrow * xAxis = new Scene::Arrow(glm::vec3(xAxisMin, yAxisMin, zAxisMin), glm::vec3(xAxisMax, yAxisMin, zAxisMin), glm::vec4(1, 0, 0, 1));
Scene::Arrow * yAxis = new Scene::Arrow(glm::vec3(xAxisMin, yAxisMin, zAxisMin), glm::vec3(xAxisMin, yAxisMax, zAxisMin), glm::vec4(0, 1, 0, 1));
Scene::Arrow * zAxis = new Scene::Arrow(glm::vec3(xAxisMin, yAxisMin, zAxisMin), glm::vec3(xAxisMin, yAxisMin, zAxisMax), glm::vec4(0, 0, 1, 1));
world.addObject(xAxis);
world.addObject(yAxis);
world.addObject(zAxis);
float maxSpan = std::max({ xSpan, ySpan, zSpan });
float minSpan = std::min({ xSpan, ySpan, zSpan });
s = 1.5;
Scene::Camera * cam = new Scene::Camera();
if (xSpan == minSpan) {
cam->setThe(-90);
cam->setTz(xMid + s * maxSpan);
}
else if (ySpan == minSpan) {
cam->setPhi(90);
cam->setThe(90);
cam->setTz(yMid + s * maxSpan);
}
else {
cam->setTz(zMid + s * maxSpan);
}
world.addObject(cam);
mainPanel.setWorld(&world);
mainPanel.setCamera(cam);
mainPanel.setMeshObject(meshObject);
GlutUI::Controls::Keyboard keyboard(&mainPanel);
GlutUI::Controls::Mouse mouse(&mainPanel, mainPanel.getCamera(), mainPanel.getMeshObject());
/*std::set<int> f11 = meshObject->adjacency(11);
std::set<int> f23 = meshObject->adjacency(23);
std::set<int> vSet;
for (auto it = f11.begin(); it != f11.end(); it++) {
for (int i = 0; i < 3; i++) {
vSet.insert(meshObject->faces(*it)[i]);
}
}
for (auto it = f23.begin(); it != f23.end(); it++) {
for (int i = 0; i < 3; i++) {
vSet.insert(meshObject->faces(*it)[i]);
}
}
for (auto it = vSet.begin(); it != vSet.end(); it++) {
printf("\n%i: ", *it);
std::set<int> asdf = meshObject->adjacency(*it);
for (auto i = asdf.begin(); i != asdf.end(); i++) {
printf("(%i,%i,%i) ", meshObject->faces(*i)[0], meshObject->faces(*i)[1], meshObject->faces(*i)[2]);
}
}
meshObject->collapse(11, 23, Scene::BINARY_APPROXIMATION_METHOD);
std::set<int> f11New = meshObject->adjacency(11);
std::set<int> vSetNew;
for (auto it = f11New.begin(); it != f11New.end(); it++) {
for (int i = 0; i < 3; i++) {
vSetNew.insert(meshObject->faces(*it)[i]);
}
}
printf("\n\n");
for (auto it = vSetNew.begin(); it != vSetNew.end(); it++) {
printf("\n%i: ", *it);
std::set<int> asdf = meshObject->adjacency(*it);
for (auto i = asdf.begin(); i != asdf.end(); i++) {
printf("(%i,%i,%i) ", meshObject->faces(*i)[0], meshObject->faces(*i)[1], meshObject->faces(*i)[2]);
}
}*/
///////////////////////////////////////
///// Keyboard Hotkey Assignments /////
///////////////////////////////////////
int bmpCounter = 0;
float complexityMultiplier = 1.0 / 32.0;
float complexityIncrement = 1.0 / 16.0;
auto alambda = [&]() {
if (meshObject->format() == "off") {
meshObject->collapseRandomEdge(Scene::MIDPOINT_APPROXIMATION_METHOD);
}
};
auto slambda = [&]() {
if (meshObject->format() == "off") {
int nVV = meshObject->nVisibleVertices();
int n = fmax(1, nVV / 100);
printf("Random edge midpoint collapsing %i times...\n", n);
for (int i = 0; i < n; i++) meshObject->collapseRandomEdge(Scene::MIDPOINT_APPROXIMATION_METHOD);
}
};
auto zlambda = [&]() {
if (meshObject->format() == "off"){
meshObject->quadricSimplify();
}
};
auto xlambda = [&]() {
if (meshObject->format() == "off") {
int nCP = meshObject->nCollapsablePairs();
int n = sqrt(nCP) / 2;
if (n == 0) n = fmin(nCP, 1);
printf("%i ", n);
for (int i = 0; i < n; i++) {
meshObject->quadricSimplify();
}
}
};
auto nlambda = [&]() {
printf("Writing progressive mesh data to %s\n", meshObject->outFileName());
meshObject->makeProgressiveMeshFile();
};
auto mlambda = [&]() {
if (meshObject->format() == "off") {
int collapseCount = 0;
for (int i = 0; i < meshObject->nVertices(); i++) {
if (collapseCount % 10 == 0) printf("Pairs Collapsed: %i\r", collapseCount);
meshObject->quadricSimplify();
collapseCount++;
}
//printf("Pairs Collapsed: %i\n", collapseCount);
printf("\nMaking Progressive Mesh File: %s\n", meshObject->outFileName());
meshObject->makeProgressiveMeshFile();
}
};
auto pluslambda = [&]() {
if (meshObject->format() == "offpm") {
if (meshObject->complexity() < meshObject->nVertices()) {
//std::string bmpName = fileName + std::to_string(bmpCounter) + ".bmp";
//SaveAsBMP(bmpName.c_str());
//bmpCounter++;
meshObject->collapseTo((1.0f + complexityMultiplier)*meshObject->complexity());
}
}
};
auto minuslambda = [&]() {
if (meshObject->format() == "offpm") meshObject->collapseTo((1.0 - complexityMultiplier)*meshObject->complexity());
};
auto rbracketlambda = [&]() {
if (meshObject->format() == "offpm") {
if (meshObject->complexity() < meshObject->nVertices()) {
//std::string bmpName = fileName + std::to_string(bmpCounter) + ".bmp";
//SaveAsBMP(bmpName.c_str());
//bmpCounter++;
meshObject->collapseTo(meshObject->complexity() + complexityIncrement);
}
}
};
auto lbracketlambda = [&]() {
if (meshObject->format() == "offpm") meshObject->collapseTo(meshObject->complexity() - complexityIncrement);
};
auto ilambda = [&]() {
std::string bmpName = fileName + std::to_string(bmpCounter) + ".bmp";
SaveAsBMP(bmpName.c_str());
bmpCounter++;
};
auto quotelambda = [&]() {
complexityMultiplier += 1.0 / 256.0;
printf("Complexity Multiplier:_%f_____\r", complexityMultiplier);
};
auto colonlambda = [&]() {
complexityMultiplier = fmax(0.0, complexityMultiplier - 1.0 / 256);
printf("Complexity Multiplier:_%f_____\r", complexityMultiplier);
};
auto slashlambda = [&]() {
complexityIncrement += 1.0 / 256.0;
printf("Complexity Increment:__%f_____\r", complexityIncrement);
};
auto periodlambda = [&]() {
complexityIncrement = fmin(0.0, complexityIncrement - 1.0 / 256.0);
printf("Complexity Increment:__%f_____\r", complexityIncrement);
};
auto tlambda = [&]() {
meshObject->toggleDrawMode();
};
auto ylambda = [&]() {
meshObject->toggleCustomColors();
};
keyboard.register_hotkey('\'', quotelambda);
keyboard.register_hotkey(';', colonlambda);
keyboard.register_hotkey('/', slashlambda);
keyboard.register_hotkey('.', periodlambda);
keyboard.register_hotkey(']', rbracketlambda);
keyboard.register_hotkey('[', lbracketlambda);
keyboard.register_hotkey('i', ilambda);
keyboard.register_hotkey('=', pluslambda);
keyboard.register_hotkey('-', minuslambda);
keyboard.register_hotkey('a', alambda);
keyboard.register_hotkey('s', slambda);
keyboard.register_hotkey('x', xlambda);
keyboard.register_hotkey('z', zlambda);
keyboard.register_hotkey('t', tlambda);
keyboard.register_hotkey('y', ylambda);
keyboard.register_hotkey('n', nlambda);
keyboard.register_hotkey('m', mlambda);
MANAGER.drawElements();
return 0;
}