/******************************************************
Handle mouse events
*******************************************************/
void HandleMouse(int button,int state,int x,int y)
{
int i,maxselect = 100,nhits = 0;
GLuint selectlist[100];
if (state == GLUT_DOWN) {
glSelectBuffer(maxselect,selectlist);
glRenderMode(GL_SELECT);
glInitNames();
glPushName(-1);
glPushMatrix();
MakeCamera(TRUE,x,y);
MakeGeometry();
glPopMatrix();
nhits = glRenderMode(GL_RENDER);
if (button == GLUT_LEFT_BUTTON) {
} else if (button == GLUT_MIDDLE_BUTTON) {
} /* Right button events are passed to menu handlers */
if (nhits == -1)
fprintf(stderr,"Select buffer overflow\n");
if (nhits > 0) {
fprintf(stderr,"\tPicked %d objects: ",nhits);
for (i=0;i<nhits;i++)
fprintf(stderr,"%d ",selectlist[4*i+3]);
fprintf(stderr,"\n");
}
}
}
/**************************************************************
This is the basic display callback routine
It creates the geometry, lighting, and viewing position
In this case it rotates the camera around the scene
***************************************************************/
void Display(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix();
MakeCamera(FALSE,0,0);
MakeLighting();
MakeGeometry();
glPopMatrix();
//glFlush(); This isn't necessary for double buffers
glutSwapBuffers();
}
/*
This is the basic display callback routine
It creates the geometry, lighting, and viewing position
In this case it rotates the camera around the scene
*/
void Display(void)
{
XYZ r,eyepos;
double dist,ratio,radians,scale,wd2,ndfl;
double left,right,top,bottom;
/* Do we need to recreate the list ? */
if (geometrydirty != NOTDIRTY) {
MakeGeometry();
geometrydirty = NOTDIRTY;
}
/* Clip to avoid extreme stereo */
near = 0.1;
far = 1000;
if (stereo)
near = camera.focallength / 5;
/* Misc stuff */
ratio = camera.screenwidth / (double)camera.screenheight;
radians = DTOR * camera.aperture / 2;
wd2 = near * tan(radians);
ndfl = near / camera.focallength;
/* Clear the buffers */
glDrawBuffer(GL_BACK_LEFT);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if (stereo) {
glDrawBuffer(GL_BACK_RIGHT);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
if (stereo) {
/* Derive the two eye positions */
CROSSPROD(camera.vd,camera.vu,r);
Normalise(&r);
r.x *= camera.eyesep / 2.0;
r.y *= camera.eyesep / 2.0;
r.z *= camera.eyesep / 2.0;
eyepos = VectorAdd(camera.vp,r);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
left = - ratio * wd2 - 0.5 * camera.eyesep * ndfl;
right = ratio * wd2 - 0.5 * camera.eyesep * ndfl;
top = wd2;
bottom = - wd2;
glFrustum(left,right,bottom,top,near,far);
glMatrixMode(GL_MODELVIEW);
glDrawBuffer(GL_BACK_RIGHT);
glLoadIdentity();
gluLookAt(eyepos.x,eyepos.y,eyepos.z,
eyepos.x + camera.vd.x,
eyepos.y + camera.vd.y,
eyepos.z + camera.vd.z,
camera.vu.x,camera.vu.y,camera.vu.z);
MakeLighting();
glCallList(1);
eyepos = VectorSub(r,camera.vp);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
left = - ratio * wd2 + 0.5 * camera.eyesep * ndfl;
right = ratio * wd2 + 0.5 * camera.eyesep * ndfl;
top = wd2;
bottom = - wd2;
glFrustum(left,right,bottom,top,near,far);
glMatrixMode(GL_MODELVIEW);
glDrawBuffer(GL_BACK_LEFT);
glLoadIdentity();
gluLookAt(eyepos.x,eyepos.y,eyepos.z,
eyepos.x + camera.vd.x,
eyepos.y + camera.vd.y,
eyepos.z + camera.vd.z,
camera.vu.x,camera.vu.y,camera.vu.z);
MakeLighting();
glCallList(1);
} else {
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
left = - ratio * wd2;
right = ratio * wd2;
top = wd2;
bottom = - wd2;
glFrustum(left,right,bottom,top,near,far);
glMatrixMode(GL_MODELVIEW);
glDrawBuffer(GL_BACK_LEFT);
glLoadIdentity();
gluLookAt(camera.vp.x,camera.vp.y,camera.vp.z,
camera.vp.x + camera.vd.x,
camera.vp.y + camera.vd.y,
camera.vp.z + camera.vd.z,
camera.vu.x,camera.vu.y,camera.vu.z);
MakeLighting();
glCallList(1);
}
/* glFlush(); This isn't necessary for double buffers */
glutSwapBuffers();
if (record || windowdump) {
WindowDump(camera.screenwidth,camera.screenheight,stereo);
windowdump = FALSE;
}
if (demomode && iterationdepth < 1000) {
iterationdepth++;
geometrydirty = ADDONE;
if (debug)
fprintf(stderr,"Iteration: %d\n",iterationdepth);
}
}
util::json::Object MakeRoute(const std::vector<PhantomNodes> &segment_end_coordinates,
const std::vector<std::vector<PathData>> &unpacked_path_segments,
const std::vector<bool> &source_traversed_in_reverse,
const std::vector<bool> &target_traversed_in_reverse) const
{
std::vector<guidance::RouteLeg> legs;
std::vector<guidance::LegGeometry> leg_geometries;
auto number_of_legs = segment_end_coordinates.size();
legs.reserve(number_of_legs);
leg_geometries.reserve(number_of_legs);
for (auto idx : util::irange<std::size_t>(0UL, number_of_legs))
{
const auto &phantoms = segment_end_coordinates[idx];
const auto &path_data = unpacked_path_segments[idx];
const bool reversed_source = source_traversed_in_reverse[idx];
const bool reversed_target = target_traversed_in_reverse[idx];
auto leg_geometry = guidance::assembleGeometry(
BaseAPI::facade, path_data, phantoms.source_phantom, phantoms.target_phantom);
auto leg = guidance::assembleLeg(facade, path_data, leg_geometry, phantoms.source_phantom,
phantoms.target_phantom, reversed_target, parameters.steps);
if (parameters.steps)
{
auto steps = guidance::assembleSteps(
BaseAPI::facade, path_data, leg_geometry, phantoms.source_phantom,
phantoms.target_phantom, reversed_source, reversed_target);
/* Perform step-based post-processing.
*
* Using post-processing on basis of route-steps for a single leg at a time
* comes at the cost that we cannot count the correct exit for roundabouts.
* We can only emit the exit nr/intersections up to/starting at a part of the leg.
* If a roundabout is not terminated in a leg, we will end up with a
*enter-roundabout
* and exit-roundabout-nr where the exit nr is out of sync with the previous enter.
*
* | S |
* * *
* ----* * ----
* T
* ----* * ----
* V * *
* | |
* | |
*
* Coming from S via V to T, we end up with the legs S->V and V->T. V-T will say to
*take
* the second exit, even though counting from S it would be the third.
* For S, we only emit `roundabout` without an exit number, showing that we enter a
*roundabout
* to find a via point.
* The same exit will be emitted, though, if we should start routing at S, making
* the overall response consistent.
*/
guidance::trimShortSegments(steps, leg_geometry);
leg.steps = guidance::postProcess(std::move(steps));
leg.steps = guidance::collapseTurns(std::move(leg.steps));
leg.steps = guidance::assignRelativeLocations(std::move(leg.steps), leg_geometry,
phantoms.source_phantom,
phantoms.target_phantom);
leg_geometry = guidance::resyncGeometry(std::move(leg_geometry), leg.steps);
}
leg_geometries.push_back(std::move(leg_geometry));
legs.push_back(std::move(leg));
}
auto route = guidance::assembleRoute(legs);
boost::optional<util::json::Value> json_overview;
if (parameters.overview != RouteParameters::OverviewType::False)
{
const auto use_simplification =
parameters.overview == RouteParameters::OverviewType::Simplified;
BOOST_ASSERT(use_simplification ||
parameters.overview == RouteParameters::OverviewType::Full);
auto overview = guidance::assembleOverview(leg_geometries, use_simplification);
json_overview = MakeGeometry(overview.begin(), overview.end());
}
std::vector<util::json::Value> step_geometries;
for (const auto idx : util::irange<std::size_t>(0UL, legs.size()))
{
auto &leg_geometry = leg_geometries[idx];
std::transform(
legs[idx].steps.begin(), legs[idx].steps.end(), std::back_inserter(step_geometries),
[this, &leg_geometry](const guidance::RouteStep &step) {
if (parameters.geometries == RouteParameters::GeometriesType::Polyline)
{
return static_cast<util::json::Value>(
json::makePolyline(leg_geometry.locations.begin() + step.geometry_begin,
leg_geometry.locations.begin() + step.geometry_end));
}
BOOST_ASSERT(parameters.geometries == RouteParameters::GeometriesType::GeoJSON);
return static_cast<util::json::Value>(json::makeGeoJSONGeometry(
leg_geometry.locations.begin() + step.geometry_begin,
leg_geometry.locations.begin() + step.geometry_end));
});
}
return json::makeRoute(route,
json::makeRouteLegs(std::move(legs), std::move(step_geometries)),
std::move(json_overview));
}
void display() {
double nearp = 0.1;
double farp = 10000;
XYZ r;
double dist, ratio, radians, scale, wd2, ndfl;
double left, right, top, bottom;
/* Clip to avoid extreme stereo */
#ifdef STEREO_3D
nearp = camera.focallength / 5;
#endif
/* Misc stuff */
ratio = camera.screenwidth / (double)camera.screenheight;
radians = DTOR * camera.aperture / 2;
wd2 = nearp * tan(radians);
ndfl = nearp / camera.focallength;
glDrawBuffer(GL_BACK);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
#ifdef STEREO_3D
update();
/* Derive the two eye positions */
CROSSPROD(camera.vd,camera.vu,r);
Normalise(&r);
r.x *= camera.eyesep / 2.0;
r.y *= camera.eyesep / 2.0;
r.z *= camera.eyesep / 2.0;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
left = - ratio * wd2 - 0.5 * camera.eyesep * ndfl;
right = ratio * wd2 - 0.5 * camera.eyesep * ndfl;
top = wd2;
bottom = - wd2;
glFrustum(left,right,bottom,top,nearp,farp);
glMatrixMode(GL_MODELVIEW);
glDrawBuffer(GL_BACK);
#ifdef INVERT_STEREO
glViewport (
camera.screenwidth / 2, 0,
camera.screenwidth / 2, camera.screenheight);
#else
glViewport (
0, 0,
camera.screenwidth / 2, camera.screenheight);
#endif
glLoadIdentity();
gluLookAt(camera.vp.x + r.x,camera.vp.y + r.y,camera.vp.z + r.z,
camera.vp.x + r.x + camera.vd.x,
camera.vp.y + r.y + camera.vd.y,
camera.vp.z + r.z + camera.vd.z,
camera.vu.x,camera.vu.y,camera.vu.z);
glTranslatef(-0.5f, -0.5f, -2.0f);
MakeLighting();
MakeGeometry();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
left = - ratio * wd2 + 0.5 * camera.eyesep * ndfl;
right = ratio * wd2 + 0.5 * camera.eyesep * ndfl;
top = wd2;
bottom = - wd2;
glFrustum(left,right,bottom,top,nearp,farp);
glMatrixMode(GL_MODELVIEW);
glDrawBuffer(GL_BACK);
#ifdef INVERT_STEREO
glViewport (
0, 0,
camera.screenwidth / 2, camera.screenheight);
#else
glViewport (
camera.screenwidth / 2, 0,
camera.screenwidth / 2, camera.screenheight);
#endif
// glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
gluLookAt(camera.vp.x - r.x,camera.vp.y - r.y,camera.vp.z - r.z,
camera.vp.x - r.x + camera.vd.x,
camera.vp.y - r.y + camera.vd.y,
camera.vp.z - r.z + camera.vd.z,
camera.vu.x,camera.vu.y,camera.vu.z);
glTranslatef(-0.5f, -0.5f, -2.0f);
MakeLighting();
MakeGeometry();
glutSwapBuffers();
glutPostRedisplay();
#else
update();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
left = - ratio * wd2;
right = ratio * wd2;
top = wd2;
bottom = - wd2;
glFrustum(left,right,bottom,top,nearp,farp);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(camera.vp.x,camera.vp.y,camera.vp.z,
camera.vp.x + camera.vd.x,
camera.vp.y + camera.vd.y,
camera.vp.z + camera.vd.z,
camera.vu.x,camera.vu.y,camera.vu.z);
glTranslatef(-0.5f, -0.5f, -2.0f);
MakeLighting();
MakeGeometry();
glutSwapBuffers();
glutPostRedisplay();
#endif // STEREO_3D
}
static void LoadThemeFrame(Magick::Image& img, const std::string& path, Rect& plc)
{
img.read(path.c_str());
Point sz = plc.Size();
img.zoom( MakeGeometry(sz.x, sz.y) );
}
void draw_s2fishdome(CAMERA cam) {
// draw a fisheye / warped projection of the geometry
double r, near, far;
XYZ vp, vd, vr, vl;
XYZ vright, vleft, vup;
// Calculate various view vectors
vp = cam.vp;
vd = cam.vd;
vr = CrossProduct(vd,cam.vu);
vl = CrossProduct(cam.vu,vd);
vd = ArbitraryRotate(vd,cam.fishrotate,vr);
vup = CrossProduct(vr,vd);
vright = VectorAdd(vr,vd);
vleft = VectorAdd(vl,vd);
near = VectorLength(_s2priv_pmin(),_s2priv_pmax()) / 100;
far = MAX(cam.focallength,VectorLength(_s2priv_pmin(),
_s2priv_pmax())) * 20;
// Left
glDrawBuffer(GL_BACK);
glReadBuffer(GL_BACK);
glViewport(0,0,TEXTURESIZE,TEXTURESIZE);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
s2Perspective(90.0,1.0,near,far);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
s2LookAt(vp.x,vp.y,vp.z,vp.x+vleft.x,vp.y+vleft.y,vp.z+vleft.z,vup.x,vup.y,vup.z);
MakeLighting();
MakeMaterial();
MakeGeometry(FALSE, FALSE);
glBindTexture(GL_TEXTURE_2D,walltextureid[2]);
glCopyTexSubImage2D(GL_TEXTURE_2D,0,0,0,0,0,TEXTURESIZE,TEXTURESIZE);
// Right
glDrawBuffer(GL_BACK);
glReadBuffer(GL_BACK);
glViewport(0,0,TEXTURESIZE,TEXTURESIZE);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
s2Perspective(90.0,1.0,near,far);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
s2LookAt(vp.x,vp.y,vp.z,vp.x+vright.x,vp.y+vright.y,vp.z+vright.z,vup.x,vup.y,vup.z);
MakeLighting();
MakeMaterial();
MakeGeometry(FALSE, FALSE);
glBindTexture(GL_TEXTURE_2D,walltextureid[3]);
glCopyTexSubImage2D(GL_TEXTURE_2D,0,0,0,0,0,TEXTURESIZE,TEXTURESIZE);
// Top
glDrawBuffer(GL_BACK);
glReadBuffer(GL_BACK);
glViewport(0,0,TEXTURESIZE,TEXTURESIZE);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
s2Perspective(90.0,1.0,near,far);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
s2LookAt(vp.x,vp.y,vp.z,vp.x+vup.x,vp.y+vup.y,vp.z+vup.z,-vright.x,-vright.y,-vright.z);
MakeLighting();
MakeMaterial();
MakeGeometry(FALSE, FALSE);
glBindTexture(GL_TEXTURE_2D,walltextureid[0]);
glCopyTexSubImage2D(GL_TEXTURE_2D,0,0,0,0,0,TEXTURESIZE,TEXTURESIZE);
// Bottom
glDrawBuffer(GL_BACK);
glReadBuffer(GL_BACK);
glViewport(0,0,TEXTURESIZE,TEXTURESIZE);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
s2Perspective(90.0,1.0,near,far);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
s2LookAt(vp.x,vp.y,vp.z,vp.x-vup.x,vp.y-vup.y,vp.z-vup.z,-vleft.x,-vleft.y,-vleft.z);
MakeLighting();
MakeMaterial();
MakeGeometry(FALSE, FALSE);
glBindTexture(GL_TEXTURE_2D,walltextureid[1]);
glCopyTexSubImage2D(GL_TEXTURE_2D,0,0,0,0,0,TEXTURESIZE,TEXTURESIZE);
// Remember the graphics state and return it at the end
glPushAttrib(GL_ALL_ATTRIB_BITS);
glDisable(GL_LIGHTING);
glDisable(GL_ALPHA_TEST);
glDisable(GL_COLOR_MATERIAL);
glDisable(GL_DITHER);
//glDisable(GL_FOG);
glDisable(GL_LINE_SMOOTH);
glDisable(GL_LINE_STIPPLE);
glDisable(GL_SCISSOR_TEST);
glDisable(GL_STENCIL_TEST);
// Setup projections for the dome
glDrawBuffer(GL_BACK);
if (_s2fd_options->dometype == WARPMAP)
glClearColor(0.0,0.0,0.0,0.0);
else
glClearColor(0.05,0.05,0.05,0.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glViewport(0,0,_s2fd_options->screenwidth,_s2fd_options->screenheight);
r = _s2fd_options->screenwidth / (double)_s2fd_options->screenheight;
switch (_s2fd_options->dometype) {
case TRUNCTOP:
case TRUNCBOTTOM:
glOrtho(-r*0.75,r*0.75,-0.75,0.75,0.1,10.0);
break;
case HSPHERICAL:
glOrtho(-r*0.75,r*0.75,-0.75,0.75,0.1,10.0);
break;
case VSPHERICAL:
case WARPMAP:
default:
glOrtho(-r,r,-1.0,1.0,0.1,10.0);
break;
}
// Create camera projection for dome
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
switch (_s2fd_options->dometype) {
case TRUNCBOTTOM:
s2LookAt(0.0,-1.0,0.25,0.0,0.0,0.25,0.0,0.0,1.0);
break;
case TRUNCTOP:
s2LookAt(0.0,-1.0,-0.25,0.0,0.0,-0.25,0.0,0.0,1.0);
break;
case HSPHERICAL:
case VSPHERICAL:
case WARPMAP:
default:
s2LookAt(0.0,-1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0);
break;
}
// Finally draw the dome geometry
glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
glColor3f(1.0,1.0,1.0);
DrawDome(TRUE,FALSE);
_s2_fadeinout();
DrawExtras();
glPopAttrib();
}
