// Called whenever the window size changes
void Window::reshapeCallback(int new_width, int new_height)
{
width = new_width;
height = new_height;
limit = width * height * 3 - 2;
delete[] pixels;
delete[] zbuffer;
pixels = new float[width * height * 3];
zbuffer = new float[(width + 1) * (height + 1)];
viewport = Projection::viewport(0, 0, width, height);
viewport.print("view port");
projection = Projection::perspective(60, double(width) / double(height), 1.0, 1000.0);
projection.print("projection");
//Matrix4d t;
//t.makeTranslate(0, 0, -20);
//projection = projection * t;
// calculate scaling matrix for bunny
double x = (bunny_xmax - bunny_xmin) / 2;
double y = (bunny_ymax - bunny_ymin) / 2;
double z = (bunny_zmax - bunny_zmin) / 2;
double a = z / y;
double ymax = 20 / (a + 1 / tan(30 * M_PI / 180));
double sy = ymax / y; // scaling factor according to y
double xmax = ymax * (double)width / (double)height; //scaling factor according to x
double sx = xmax / x;
double min = sy < sx ? sy : sx;
scale_bunny.makeScale(min, min, min);
// calculate scaling matrix for dragon
x = (dragon_xmax - dragon_xmin) / 2;
y = (dragon_ymax - dragon_ymin) / 2;
z = (dragon_zmax - dragon_zmin) / 2;
a = z / y;
ymax = 20 / (a + 1 / tan(30 * M_PI / 180));
xmax = ymax * (double)width / (double)height;
sy = ymax / y;
sx = xmax / x;
min = sy < sx ? sy : sx;
scale_dragon.makeScale(min, min, min);
//scale_dragon.print("scaling matrix for dragon:");
}
void Window::keyboardCallback(unsigned char key, int, int)
{
switch (key){
case '1':
bunny = true;
break;
case '2':
bunny = false;
break;
case 's':
temp.makeScale(0.9, 0.9, 0.9);
scaling.multiply(temp);
break;
case 'S':
temp.makeScale(1.1, 1.1, 1.1);
scaling.multiply(temp);
break;
case 27:
exit(0);
}
}
void Window::mouseMotionProcess(int x, int y){
Vector3d direction;
double pixel_diff;
double rot_angle, zoom_factor;
Vector3d curPoint;
curPoint = trackBallMapping(x, y);
switch (movement){
case control::ROTATION:
{
if (!lightControl){
direction = curPoint - lastPoint;
double velocity = direction.magnitude();
if (velocity > 0.0001){
Vector3d rotAxis = lastPoint * curPoint;
rotAxis.normalize();
rot_angle = velocity * ROTSCALE;
Matrix4d r;
r.makeRotate(rot_angle, rotAxis);
rotation = r * rotation;
rotate_mt->setMatrix(rotation);
}
}
}
break;
case control::SCALING:
{
pixel_diff = curPoint[1] - lastPoint[1];
zoom_factor = 1.0 + pixel_diff * ZOOMSCALE;
if (!lightControl){
Matrix4d s;
s.makeScale(zoom_factor, zoom_factor, zoom_factor);
scaling = scaling * s;
scaling_mt->setMatrix(scaling);
displayCallback();
}
else{
spotLight.setCutOff(spotLight.getCutOff() * zoom_factor);
}
}
break;
}
lastPoint = curPoint;
}
Matrix4d Window::calculateScalingMatrix(int w, int h, Coordinate3d min, Coordinate3d max){
double x = (max.x - min.x) / 2;
double y = (max.y - min.y) / 2;
double z = (max.z - min.z) / 2;
//cout << "x : " << x << " y : " << y << " z : " << z << endl;
double a = z / y;
double ymax = 20 / (a + 1 / tan(30 * M_PI / 180));
double sy = ymax / y;
double xmax = ymax * double(w) / double(h);
double sx = xmax / x;
double factor = sy < sx ? sy : sx;
Matrix4d s;
s.makeScale(factor, factor, factor);
return s;
}
void BuildingConstructor::construct() {
GLdouble currentMaxH = maxH;
GLdouble currentMinH = minH;
GLdouble xTranslation = ((double) rand() * 0.5) / (double) RAND_MAX;
GLdouble zTranslation = ((double) rand() * 0.5) / (double) RAND_MAX;
GLdouble xScaling = 2.0;
GLdouble zScaling = 2.0;
GLdouble rotationAngle = 90.0;
GLdouble lotBias = 0.02;
Matrix4d translation;
Matrix4d scaling;
Matrix4d rotation;
Matrix4d rotation90;
Building* building = NULL;
GLdouble scaleMax = 0.90;
GLdouble scaleMin = 0.5;
double colorH = 1.0;
double colorL = 0.90;
double r = (double) rand() * (colorH + 1.0 - colorL) / (double) RAND_MAX + colorL;
double g = (double) rand() * (colorH + 1.0 - colorL) / (double) RAND_MAX + colorL;
double b = (double) rand() * (colorH + 1.0 - colorL) / (double) RAND_MAX + colorL;
GLuint buildingChoice = rand() * (3 + 1) / RAND_MAX;
GLuint roofChoice = rand() * (5 - 4 + 1) / RAND_MAX + 4;
std::cerr << "buildingChoice: " << buildingChoice << " roofChoice: " << roofChoice << std::endl;
rotation.identity();
rotation90.makeRotateY(rotationAngle);
switch (choice) {
// medium buildings
case 0:
while (buildingChoice == 1) {
buildingChoice = rand() * (3 + 1) / RAND_MAX;
}
std::cerr << "hhhh" << std::endl;
xScaling = (double) rand() * (3.0 + 1.0 - 2.0) / (double) RAND_MAX + 2.0;
zScaling = (double) rand() * (3.0 + 1.0 - 2.0) / (double) RAND_MAX + 2.0;
translation.makeTranslate(xTranslation, 0.0, zTranslation);
scaling.makeScale(xScaling, currentMaxH, zScaling);
building = new Building(buildingChoice, roofChoice, r, g, b, texture, xScaling, currentMaxH, zScaling, translation * scaling);
root->addChild(building->getRoot());
break;
// mid towards out buildings
case 1:
buildingChoice = rand() * (3 + 1 - 1) / RAND_MAX + 1;
xScaling = zScaling = (double) rand() * (1.0 + 1.0 - 0.5) / (double) RAND_MAX + 0.5;
for (int count = 0; count < layerCount - 1; ++count) {
currentMaxH -= ((double) rand() * (scaleMax - scaleMin)) / (double) RAND_MAX + scaleMin;;
xScaling += 0.3;
zScaling += 0.3;
if (xScaling > 3.0 || zScaling > 3.0) {
break;
}
// std::cerr << "zScaling: " << zScaling << std::endl;
scaling.makeScale(xScaling, currentMaxH, zScaling);
building = new Building(buildingChoice, roofChoice, r, g, b, texture, xScaling, currentMaxH, zScaling, scaling);
root->addChild(building->getRoot());
}
break;
// tall buildings with rotation
case 2:
scaling.makeScale(3.0, 1.0, 3.0);
buildingChoice = rand() * (3 + 1 - 1) / RAND_MAX + 1;
building = new Building(buildingChoice, roofChoice, r, g, b, texture, 3.0, 1.0, 3.0, scaling);
root->addChild(building->getRoot());
translation.makeTranslate(xTranslation, 0.0, zTranslation);
scaling.makeScale(xScaling, currentMaxH, zScaling);
building = new Building(buildingChoice, roofChoice, r, g, b, texture, xScaling, currentMaxH, zScaling, translation * scaling);
root->addChild(building->getRoot());
//t s m
xTranslation = 0.5 - lotBias;
zTranslation = 0.0;
zScaling = ((double) rand() * (currentMaxH - currentMinH)) / (double) RAND_MAX + currentMinH;
for (int count = 0; count < layerCount - 1; ++count) {
currentMaxH -= ((double) rand() * (scaleMax - scaleMin)) / (double) RAND_MAX + scaleMin;;
rotation = rotation90 * rotation;
zScaling = ((double) rand() * (scaleMax - scaleMin)) / (double) RAND_MAX + scaleMin;
// std::cerr << "zScaling: " << zScaling << std::endl;
scaling.makeScale(xScaling, currentMaxH, zScaling);
translation.makeTranslate(xTranslation, 0.0, 0.0);
building = new Building(buildingChoice, roofChoice, r, g, b, texture, xScaling, currentMaxH, zScaling, rotation * translation * scaling);
root->addChild(building->getRoot());
}
break;
default:
break;
}
}
