//transform the x, y position on the screen into the corresponding 3D world position
void produceRay(int x_I, int y_I, Vec3Df * origin, Vec3Df * dest)
{
int viewport[4];
double modelview[16];
double projection[16];
glGetDoublev(GL_MODELVIEW_MATRIX, modelview); //recuperer matrices
glGetDoublev(GL_PROJECTION_MATRIX, projection); //recuperer matrices
glGetIntegerv(GL_VIEWPORT, viewport);//viewport
int y_new = viewport[3] - y_I;
double x, y, z;
gluUnProject(x_I, y_new, 0, modelview, projection, viewport, &x, &y, &z);
origin->p[0]=float(x);
origin->p[1]=float(y);
origin->p[2]=float(z);
gluUnProject(x_I, y_new, 1, modelview, projection, viewport, &x, &y, &z);
dest->p[0]=float(x);
dest->p[1]=float(y);
dest->p[2]=float(z);
}
ofVec3f ofkUnProjectionHelper::getProjectionPoint(float ofScreenPosX, float ofScreenPosY, const GLdouble *model, const GLdouble *proj, const GLint *viewPort)
{
ofVec3f res;
// ---------------- SETTING MATRIX ---------------- //
glViewport(viewPort[0], viewPort[1], viewPort[2], viewPort[3]);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadMatrixd(proj);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadMatrixd(model);
// ---------------- DRAW and pickup points --------------- //
//Enable Depth
glEnable(GL_DEPTH_TEST);
//DEpth Buffer Clear
glClear(GL_DEPTH_BUFFER_BIT);
//Once Render one Plane to Draw Depth Buffer
ofEnableAlphaBlending();
ofSetColor(255, 255, 255, 0);
ofFill();
ofRect(-10000, -10000, 20000, 20000);
//-> FUNC
double objX;
double objY;
double objZ;
float z;
//-> FUNC
glReadPixels(ofScreenPosX, viewPort[3] - ofScreenPosY ,1,1,GL_DEPTH_COMPONENT,GL_FLOAT,&z);
gluUnProject(ofScreenPosX, viewPort[3] - ofScreenPosY ,z,model, proj, viewPort,&objX,&objY,&objZ);
res.x = objX;
res.y = objY;
res.z = 0.0; // Actually , we'll get small number in objZ , I guess it's computation Error of double
glClear(GL_DEPTH_BUFFER_BIT);
glDisable(GL_DEPTH_TEST);
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
return res;
}
nVec3 nRenderer::getRay(nVec2 screenPos) {
double x = screenPos.x;
double y = screenPos.y;
GLint viewport[4];
GLfloat winX, winY;
GLdouble posX, posY, posZ;
glGetIntegerv(GL_VIEWPORT, viewport);
winX = x;
winY = y;
gluUnProject(winX, winY, 1, (/*objectMatrix * */viewMatrix).matrix, projectionMatrix.matrix, viewport, &posX, &posY, &posZ);
return nVec3(posX, posY, posZ).normalize();
}
// get intersection with plane for "trackball" style rotation
static vec planar_coords(GLdouble mx, GLdouble my)
{
GLdouble ax,ay,az;
gluUnProject(mx,my,0,ab_glm,ab_glp,ab_glv,&ax,&ay,&az);
vec m = vec((float)ax,(float)ay,(float)az) - ab_eye;
// intersect the point with the trackball plane
GLfloat t = (ab_planedist - ab_zoom) / (ab_eyedir * m);
vec d = ab_eye + m*t;
return vec(d*ab_up,d*ab_out,0.0);
}
// Uses the last GL matrices set in set_perspective to project a point from
// screen coordinates to the agent's region.
void LLViewerCamera::projectScreenToPosAgent(const S32 screen_x, const S32 screen_y, LLVector3* pos_agent) const
{
GLdouble x, y, z;
gluUnProject(
GLdouble(screen_x), GLdouble(screen_y), 0.0,
gGLModelView, gGLProjection, (GLint*)gGLViewport,
&x,
&y,
&z );
pos_agent->setVec( (F32)x, (F32)y, (F32)z );
}
void motion(int x, int y) {
if(mudaCurva) {
realy=matrizViewport[3] - (GLint) y - 1;
gluUnProject((GLdouble) x, (GLdouble) realy, winz,
matrizModelview, matrizProjecao, matrizViewport,
&wx, &wy, &wz);
vertices[vcx][vcy][0]=wx;
vertices[vcx][vcy][1]=wy;
vertices[vcx][vcy][2]=wz;
glutPostRedisplay();
}
}
void DEMGenerator::convert(int screenX, int screenY, int* indexX, int* worldY, int* indexZ) {
GLint viewport[4]; // Where The Viewport Values Will Be Stored
GLdouble projection[16]; // Where The 16 Doubles Of The Projection Matrix Are To Be Stored
GLdouble modelview[16]; // Where The 16 Doubles Of The Modelview Matrix Are To Be Stored
GLfloat windowX, windowY;
glGetIntegerv(GL_VIEWPORT, viewport);
glGetDoublev(GL_MODELVIEW_MATRIX, modelview);
glGetDoublev(GL_PROJECTION_MATRIX, projection);
windowX = screenX;
windowY = viewport[3] - screenY;
GLdouble pos1X, pos1Y, pos1Z;
GLdouble pos2X, pos2Y, pos2Z;
gluUnProject( windowX, windowY, 0.0, modelview, projection, viewport, &pos1X, &pos1Y, &pos1Z);
gluUnProject( windowX, windowY, 1.0, modelview, projection, viewport, &pos2X, &pos2Y, &pos2Z);
Vec3f directionVec(pos1X - pos2X, pos1Y - pos2Y, pos1Z - pos2Z);
Vec3f directionOrigin(pos1X, pos1Y, pos1Z);
float t = -directionOrigin.y / directionVec.y;
float x = directionOrigin.x + (t * directionVec.x);
float z = directionOrigin.z + (t * directionVec.z);
float offset = this->gridWidth * this->cellSize / 2;
x += offset;
z += offset;
x /= this->cellSize;
z /= this->cellSize;
(*indexX) = x;
(*worldY) = 0;
(*indexZ) = z;
}
void transpose(void)
{
GLdouble model[16];
GLdouble proj[16];
GLint view[4];
GLdouble posz0[3];
GLdouble posz1[3];
glGetDoublev(GL_MODELVIEW_MATRIX, model);
glGetDoublev(GL_PROJECTION_MATRIX, proj);
glGetIntegerv(GL_VIEWPORT, view);
gluUnProject(0, 0, 0, model, proj, view,
posz0 + 0, posz0 + 1, posz0 + 2);
gluUnProject(0, 0, 1, model, proj, view, posz1 + 0, posz1 + 1, posz1 + 2);
map_intersection(g_env->realpos00, posz0, posz1);
gluUnProject(0, g_env->winy, 0, model, proj, view,
posz0 + 0, posz0 + 1, posz0 + 2);
gluUnProject(0, g_env->winy, 1, model, proj, view,
posz1 + 0, posz1 + 1, posz1 + 2);
map_intersection(g_env->realpos0y, posz0, posz1);
gluUnProject(g_env->winx, g_env->winy, 0, model, proj, view,
posz0 + 0, posz0 + 1, posz0 + 2);
gluUnProject(g_env->winx, g_env->winy, 1, model, proj, view,
posz1 + 0, posz1 + 1, posz1 + 2);
map_intersection(g_env->realposxy, posz0, posz1);
}
void G308_Geometry::isOnClick(GLfloat winX, GLfloat winY){
GLint viewport[4];
GLdouble modelview[16];
GLdouble projection[16];
GLfloat winZ = 0;
//printf(" ( %f %f ) ", winX, winY);
glGetDoublev( GL_MODELVIEW_MATRIX, modelview );
glGetDoublev( GL_PROJECTION_MATRIX, projection );
glGetIntegerv( GL_VIEWPORT, viewport );
winX = (float)winX;
winY = (float)viewport[3] - (float)winY;
winZ = selectBuf[1]/4294967295.0;
printf(" (( %f )) ", winZ);
GLdouble worldX, worldY, worldZ;
gluUnProject( winX, winY, winZ, modelview, projection, viewport, &worldX, &worldY, &worldZ);
//printf(" ( %f %f %f ) ", worldX, worldY, worldZ);
//if (sel_vrt>)
GLfloat distance, min_distance;
// number of the closest vertex
int cnt=1;
// distance between the pressed point and the first vertex of selected triangle
min_distance = (m_pVertexArray[m_pTriangles[sel_vrt].v1].x-worldX)*(m_pVertexArray[m_pTriangles[sel_vrt].v1].x-worldX) +
(m_pVertexArray[m_pTriangles[sel_vrt].v1].y-worldY)*(m_pVertexArray[m_pTriangles[sel_vrt].v1].y-worldY) +
(m_pVertexArray[m_pTriangles[sel_vrt].v1].z-worldZ)*(m_pVertexArray[m_pTriangles[sel_vrt].v1].z-worldZ);
// distance to the second vertex
distance = (m_pVertexArray[m_pTriangles[sel_vrt].v2].x-worldX)*(m_pVertexArray[m_pTriangles[sel_vrt].v2].x-worldX) +
(m_pVertexArray[m_pTriangles[sel_vrt].v2].y-worldY)*(m_pVertexArray[m_pTriangles[sel_vrt].v2].y-worldY) +
(m_pVertexArray[m_pTriangles[sel_vrt].v2].z-worldZ)*(m_pVertexArray[m_pTriangles[sel_vrt].v2].z-worldZ);
if (distance>min_distance) {
min_distance = distance;
cnt=2;
}
// third vertex of a triangle
distance = (m_pVertexArray[m_pTriangles[sel_vrt].v3].x-worldX)*(m_pVertexArray[m_pTriangles[sel_vrt].v3].x-worldX) +
(m_pVertexArray[m_pTriangles[sel_vrt].v3].y-worldY)*(m_pVertexArray[m_pTriangles[sel_vrt].v3].y-worldY) +
(m_pVertexArray[m_pTriangles[sel_vrt].v3].z-worldZ)*(m_pVertexArray[m_pTriangles[sel_vrt].v3].z-worldZ);
if (distance>min_distance) cnt=3;
sel_cnt = cnt;
int num_vrt;
if (sel_cnt==1) num_vrt=m_pTriangles[sel_vrt].v1;
else if (sel_cnt==2) num_vrt=m_pTriangles[sel_vrt].v2;
else if (sel_cnt==3) num_vrt=m_pTriangles[sel_vrt].v3;
printf(" {{ %d }} ", num_vrt);
}
static void unproject (double x2, double y2, double *x3, double *y3, double *z3)
{
double mv[16];
double pm[16];
int vp[4];
glGetDoublev (GL_MODELVIEW_MATRIX, mv);
glGetDoublev (GL_PROJECTION_MATRIX, pm);
glGetIntegerv (GL_VIEWPORT, vp);
gluUnProject (x2, y2, 0.0,
mv, pm, vp,
x3, y3, z3);
}
void worldSpaceCoords(double& x, double& y, double z)
{
GLdouble modelMatrix[16];
GLdouble projMatrix[16];
GLint viewport[4];
glGetIntegerv(GL_VIEWPORT, viewport);
glGetDoublev(GL_MODELVIEW_MATRIX, modelMatrix);
glGetDoublev(GL_PROJECTION_MATRIX, projMatrix);
GLdouble nx, ny, nz;
gluUnProject(x, viewport[1]+viewport[3]-y, 0, modelMatrix, projMatrix, viewport, &nx, &ny, &nz);
GLdouble fx, fy, fz;
gluUnProject(x, viewport[1]+viewport[3]-y, 1, modelMatrix, projMatrix, viewport, &fx, &fy, &fz);
if(nz == fz) return;
GLfloat t = (nz - z) / (nz - fz);
x = nx + (fx - nx) * t;
y = ny + (fy - ny) * t;
}
float2 MouseToSpace2(int x, int y, int windowResY, float zoom, float2 camPos) //return float2(-scn.camPos.x+ (tmx/scn.zoom), -scn.camPos.y+ (-tmy/scn.zoom));
{
GLdouble model[16], proj[16];
GLint view[4];
glGetDoublev(GL_MODELVIEW_MATRIX, model);
glGetDoublev(GL_PROJECTION_MATRIX, proj);
glGetIntegerv(GL_VIEWPORT, view);
GLdouble tmx, tmy, tmz;
gluUnProject(x, windowResY - y, 0, model, proj, view, &tmx, &tmy, &tmz);
return float2(-camPos.x + (tmx/zoom), -camPos.y + (-tmy/zoom));
};
void mouse (int x, int y) {
/* Maps a mouse (x,y) back to world coordinates */
GLdouble projection[16], modelview[16];
GLint viewport[4];
glLoadIdentity();
glGetDoublev(GL_MODELVIEW_MATRIX, modelview);
glGetDoublev(GL_PROJECTION_MATRIX, projection);
glGetIntegerv(GL_VIEWPORT, viewport);
gluUnProject ((double)x, (double)500-y-1, (double)0.0,
modelview, projection, viewport,
&tx, &ty, &tz);
}
void
motion(int x, int y)
{
GLdouble objx, objy, objz;
gluUnProject(x, height - y, 0.95,
modelMatrix, projMatrix, viewport,
&objx, &objy, &objz);
overlaySphere.x = objx;
overlaySphere.y = objy;
overlaySphere.z = objz;
glutPostOverlayRedisplay();
}
float * getRayFromMouse(int x, int y)
{
GLint viewport[4];
GLdouble modelview[16];
GLdouble projection[16];
GLfloat winX, winY;
GLdouble posXs, posYs, posZs;
GLdouble posXe, posYe, posZe;
glGetDoublev(GL_MODELVIEW_MATRIX, modelview);
glGetDoublev(GL_PROJECTION_MATRIX, projection);
glGetIntegerv(GL_VIEWPORT, viewport);
winX = (float)x;
winY = (float)viewport[3] - (float)y;
//glReadPixels(x, int(winY), 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &winZ);
gluUnProject(winX, winY, 0.0f, modelview, projection, viewport, &posXs, &posYs, &posZs);
gluUnProject(winX, winY, 1.0f, modelview, projection, viewport, &posXe, &posYe, &posZe);
float coords[6] = { posXs, posYs, posZs, posXe, posYe, posZe };
return coords;
}
////////////////////////////////////////////////////////////////////////////
///
/// @fn bool Vue::convertirClotureAVirtuelle(int x, int y, const math::Plan3D& plan, glm::dvec3& point) const
///
/// Cette fonction permet de transformer un point (donné en coordonnées
/// d'affichage) en coordonnées virtuelles étant donné un certain plan sur
/// lequel doit se trouver le point. Elle utilise les fonction d'OpenGL
/// donc cette fonction s'applique peu importe la position de la caméra.
///
/// @param[in] x : La position @a X du point en coordonnée
/// d'affichage.
/// @param[in] y : La position @a Y du point en coordonnée
/// d'affichage.
/// @param[in] plan : Le plan sur lequel on veut trouver la position
/// correspondante en virtuel.
/// @param[in, out] point : point transformé @a (x,y) le @a z est le même
/// que le plan
///
/// @return Faux s'il est impossible de convertir le point en virtuel
/// puisque le plan est parallèle à la direction de la caméra, vrai
/// autrement.
///
////////////////////////////////////////////////////////////////////////////
bool Vue::convertirClotureAVirtuelle(int x, int y, const math::Plan3D& plan, glm::dvec3& point) const
{
//Initialisation de variables.
const GLdouble MinZ{ 0.0 };
const GLdouble MaxZ{ 1.0 };
// Lire la matrice de modélisation et de visualisation.
glm::dmat4 matriceModelisation;
glGetDoublev(GL_MODELVIEW_MATRIX, glm::value_ptr(matriceModelisation));
// Lire la matrice de projection.
glm::dmat4 matriceProjection;
glGetDoublev(GL_PROJECTION_MATRIX, glm::value_ptr(matriceProjection));
// Lire la clôture.
glm::ivec4 cloture;
glGetIntegerv(GL_VIEWPORT, glm::value_ptr(cloture));
// Premier point.
glm::dvec3 point1;
gluUnProject(
x, cloture[3] - y, MinZ,
glm::value_ptr(matriceModelisation), glm::value_ptr(matriceProjection), glm::value_ptr(cloture),
&point1[0], &point1[1], &point1[2]
);
// Deuxième point.
glm::dvec3 point2;
gluUnProject(
x, cloture[3] - y, MaxZ,
glm::value_ptr(matriceModelisation), glm::value_ptr(matriceProjection), glm::value_ptr(cloture),
&point2[0], &point2[1], &point2[2]
);
// On construit la droite.
math::Droite3D DroiteCoupe{ point1, point2 };
return DroiteCoupe.intersection(plan, point);
}
void
CClipVolume::_Create()
{
glPushAttrib(GL_CURRENT_BIT);
// specify the clip planes
for(int cp = 0; cp < iNrOfClipPlanes; cp++)
glClipPlane(GL_CLIP_PLANE0 + cp, ppdClipPlanes[cp]);
static double pdModelview[16];
static double pdProjection[16];
static int piViewport[4];
glGetDoublev(GL_MODELVIEW_MATRIX, pdModelview);
glGetDoublev(GL_PROJECTION_MATRIX, pdProjection);
glGetIntegerv(GL_VIEWPORT, piViewport);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fid);
glClear(GL_COLOR_BUFFER_BIT);
glUseProgramObjectARB(pidClipVolume);
SET_1F_VALUE_BY_NAME(pidClipVolume, "fWindowWidth", (float)piViewport[2]);
SET_1F_VALUE_BY_NAME(pidClipVolume, "fWindowHeight", (float)piViewport[3]);
SET_1I_VALUE_BY_NAME(pidClipVolume, "iNrOfClipPlanes", iNrOfClipPlanes);
double dX, dY, dZ;
double dW = (double)piViewport[2];
double dH = (double)piViewport[3];
glBegin(GL_QUADS);
gluUnProject(0.0, 0.0, 0.5, pdModelview, pdProjection, piViewport, &dX, &dY, &dZ); glVertex3d(dX, dY, dZ);
gluUnProject(dW, 0.0, 0.5, pdModelview, pdProjection, piViewport, &dX, &dY, &dZ); glVertex3d(dX, dY, dZ);
gluUnProject(dW, dH, 0.5, pdModelview, pdProjection, piViewport, &dX, &dY, &dZ); glVertex3d(dX, dY, dZ);
gluUnProject(0.0, dH, 0.5, pdModelview, pdProjection, piViewport, &dX, &dY, &dZ); glVertex3d(dX, dY, dZ);
glEnd();
// glUseProgramObjectARB(0);
glPopAttrib(); // glPushAttrib(GL_CURRENT_BIT);
}
void recoverClick(int iX, int iY, double &oX, double &oY){
// http://www.3dbuzz.com/forum/threads/191296-OpenGL-gluUnProject-ScreenCoords-to-WorldCoords-problem
GLdouble posX1, posY1, posZ1, posX2, posY2, posZ2, modelview[16], projection[16];
GLint viewport[4];
// Get matrices
glGetDoublev(GL_MODELVIEW_MATRIX, modelview);
glGetDoublev(GL_PROJECTION_MATRIX, projection);
glGetIntegerv(GL_VIEWPORT, viewport);
// Create ray
gluUnProject(iX, viewport[1] + viewport[3] - iY, 0, modelview, projection, viewport, &posX1, &posY1, &posZ1); // Near plane
gluUnProject(iX, viewport[1] + viewport[3] - iY, 1, modelview, projection, viewport, &posX2, &posY2, &posZ2); // Far plane
// This is a little bit hacky. The top of the discs is .5 above the board.
//This offset keeps the mouse in the plane of the top of the disc.
GLfloat t = (posZ1 - z_distance - 0.5) / (posZ1 - posZ2);
// so here are the desired (x, y) coordinates
oX = (posX1 + (posX2 - posX1) * t) / scale;
oY = (posY1 + (posY2 - posY1) * t) / scale;
}
void GetMouseRay(sVector3 &pos1, sVector3 &pos2, sVector3 &dir) {
int myX, myY;
glfwGetMousePos(&myX,&myY);
gCamera.Render();
double mvmatrix[16];
double projmatrix[16];
int viewport[4];
double dx,dy,dz;
glGetIntegerv(GL_VIEWPORT, viewport);
glGetDoublev(GL_MODELVIEW_MATRIX,mvmatrix);
glGetDoublev(GL_PROJECTION_MATRIX, projmatrix);
double mouseY = viewport[3] - myY;
gluUnProject((double)myX, (double)mouseY, 0.0, mvmatrix, projmatrix, viewport, &dx, &dy, &dz);
pos1 = sVector3((float)dx,(float)dy,(float)dz);
gluUnProject((double)myX, (double)mouseY, 1.0, mvmatrix, projmatrix, viewport, &dx, &dy, &dz);
pos2 = sVector3((float)dx,(float)dy,(float)dz);
float x,y,z, mag;
x = pos2.x - pos1.x;
y = pos2.y - pos1.y;
z = pos2.z - pos1.z;
mag = sqrt(x*x + y*y + z * z);
x/= mag;
y/= mag;
z/= mag;
dir = sVector3(x,y,z);
}
Point unproject(const Point &point, const GLMatrix &modelview, const GLMatrix &projection)
{
GLint viewport[4];
glGetIntegerv(GL_VIEWPORT,viewport);
Point unproj;
// Invert y when unprojecting
gluUnProject(point.x,viewport[3] - point.y,point.z,modelview.v,projection.v,viewport,&unproj.x,&unproj.y,&unproj.z);
return unproj;
}
void PickableObject::mousePress(tgt::MouseEvent* mouseEve, tgt::Camera* sceneCamera){
isClicked_ = true;
pressedButton_ = mouseEve->button();
oldScreenPosition_ = tgt::ivec2(mouseEve->x(), mouseEve->viewport().y - mouseEve->y());
newScreenPosition_ = tgt::ivec2(mouseEve->x(), mouseEve->viewport().y - mouseEve->y());
//GLint deltaX, deltaY;
GLint viewport[4];
GLdouble modelview[16];
GLdouble projection[16];
GLdouble posX, posY, posZ;
//deltaX = newScreenPosition_.x - oldScreenPosition_.x;
//deltaY = newScreenPosition_.y - oldScreenPosition_.y;
tgt::mat4 projection_tgt = sceneCamera->getProjectionMatrix(mouseEve->viewport());
tgt::mat4 modelview_tgt = sceneCamera->getViewMatrix();
for (int i = 0; i < 4; ++i) {
modelview[i+0] = modelview_tgt[i].x;
modelview[i+4] = modelview_tgt[i].y;
modelview[i+8] = modelview_tgt[i].z;
modelview[i+12] = modelview_tgt[i].w;
projection[i+0] = projection_tgt[i].x;
projection[i+4] = projection_tgt[i].y;
projection[i+8] = projection_tgt[i].z;
projection[i+12] = projection_tgt[i].w;
}
viewport[0] = 0;
viewport[1] = 0;
viewport[2] = static_cast<GLint>(renderTargetDimensions_.x);
viewport[3] = static_cast<GLint>(renderTargetDimensions_.y);
GLfloat WindowPosZ;
glReadPixels(oldScreenPosition_.x, oldScreenPosition_.y, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &WindowPosZ);
LGL_ERROR;
gluUnProject(oldScreenPosition_.x, oldScreenPosition_.y, WindowPosZ, modelview, projection, viewport, &posX, &posY, &posZ);
LGL_ERROR;
oldWorldPosition_ = tgt::vec3(static_cast<float>(posX), static_cast<float>(posY), static_cast<float>(posZ));
newWorldPosition_ = tgt::vec3(static_cast<float>(posX), static_cast<float>(posY), static_cast<float>(posZ));
mouseEve->accept();
}
Vector3<> SimObjectRenderer::projectClick(int x, int y)
{
GLdouble mvmatrix[16];
GLdouble projmatrix[16];
for(int i = 0; i < 16; ++i)
{
mvmatrix[i] = (GLdouble) cameraTransformation[i];
projmatrix[i] = (GLdouble) projection[i];
}
GLdouble tx, ty, tz;
gluUnProject((GLdouble)(x),(GLdouble)(height - y), 1.0, mvmatrix, projmatrix, viewport, &tx, &ty, &tz);
return Vector3<>(float(tx), float(ty), float(tz));
}
void ViewUnProject(int xi, int yi, float depth, point * v)
{
GLint viewPort[4];
GLdouble modelMatrix[16];
GLdouble projMatrix[16];
glGetIntegerv(GL_VIEWPORT, viewPort);
glGetDoublev(GL_MODELVIEW_MATRIX, modelMatrix);
glGetDoublev(GL_PROJECTION_MATRIX, projMatrix);
yi = viewPort[3] - yi - 1;
GLdouble wx, wy, wz;
gluUnProject((GLdouble) xi, (GLdouble) yi, (GLdouble) depth,
modelMatrix, projMatrix, viewPort, &wx, &wy, &wz);
pMAKE(wx, wy, wz, *v);
}
void MouseRayTestData::CalculateRay(const Camera &cam)
{
double matModelView[16], matProjection[16];
int viewport[4];
glGetDoublev( GL_MODELVIEW_MATRIX, matModelView );
glGetDoublev( GL_PROJECTION_MATRIX, matProjection );
glGetIntegerv( GL_VIEWPORT, viewport );
double winX = (double)cam.m_mouseX;
double winY = viewport[3] - (double)cam.m_mouseY;
gluUnProject(winX, winY, 0.0, matModelView, matProjection, viewport, &m_start.x, &m_start.y, &m_start.z);
gluUnProject(winX, winY, 1.0, matModelView, matProjection, viewport, &m_end.x, &m_end.y, &m_end.z);
Vec3d v2 = m_end - m_start;
Vec3d pt2 = m_start + v2*m_lastT;
m_point = pt2;
m_dir = m_end - m_start;
m_dir.Normalize();
}
void PickableObject::mouseMove(tgt::MouseEvent* mouseEve, tgt::Camera* sceneCamera){
newScreenPosition_ = tgt::ivec2(mouseEve->x(), mouseEve->viewport().y - mouseEve->y());
GLint deltaX, deltaY;
GLint viewport[4];
GLdouble modelview[16];
GLdouble projection[16];
GLdouble winX, winY, winZ;
GLdouble posX, posY, posZ;
deltaX = newScreenPosition_.x - oldScreenPosition_.x;
deltaY = newScreenPosition_.y - oldScreenPosition_.y;
tgt::mat4 projection_tgt = sceneCamera->getProjectionMatrix(mouseEve->viewport());
tgt::mat4 modelview_tgt = sceneCamera->getViewMatrix();
for (int i = 0; i < 4; ++i) {
modelview[i+0] = modelview_tgt[i].x;
modelview[i+4] = modelview_tgt[i].y;
modelview[i+8] = modelview_tgt[i].z;
modelview[i+12] = modelview_tgt[i].w;
projection[i+0] = projection_tgt[i].x;
projection[i+4] = projection_tgt[i].y;
projection[i+8] = projection_tgt[i].z;
projection[i+12] = projection_tgt[i].w;
}
viewport[0] = 0;
viewport[1] = 0;
viewport[2] = static_cast<GLint>(renderTargetDimensions_.x);
viewport[3] = static_cast<GLint>(renderTargetDimensions_.y);
posX = oldWorldPosition_.x;
posY = oldWorldPosition_.y;
posZ = oldWorldPosition_.z;
LGL_ERROR;
gluProject(posX, posY, posZ, modelview, projection, viewport, &winX, &winY, &winZ);
winX = winX + deltaX;
winY = winY + deltaY;
LGL_ERROR;
gluUnProject( winX, winY, winZ, modelview, projection, viewport, &posX, &posY, &posZ);
LGL_ERROR;
newWorldPosition_ = tgt::vec3(static_cast<float>(posX), static_cast<float>(posY), static_cast<float>(posZ));
mouseEve->accept();
}
bool
HdxIntersector::Result::_ResolveHit(int index, int x, int y, float z,
HdxIntersector::Hit* hit) const
{
unsigned char const* primIds = _primIds.get();
unsigned char const* instanceIds = _instanceIds.get();
unsigned char const* elementIds = _elementIds.get();
GfVec3d hitPoint(0,0,0);
gluUnProject(x, y, z,
_params.viewMatrix.GetArray(),
_params.projectionMatrix.GetArray(),
&_viewport[0],
&((hitPoint)[0]),
&((hitPoint)[1]),
&((hitPoint)[2]));
int idIndex = index*4;
int primId = HdxRenderSetupTask::DecodeIDRenderColor(&primIds[idIndex]);
hit->objectId = _index->GetRprimPathFromPrimId(primId);
if (!hit->IsValid()) {
return false;
}
int instanceIndex = HdxRenderSetupTask::DecodeIDRenderColor(
&instanceIds[idIndex]);
int elementIndex = HdxRenderSetupTask::DecodeIDRenderColor(
&elementIds[idIndex]);
bool rprimValid = _index->GetSceneDelegateAndInstancerIds(hit->objectId,
&(hit->delegateId),
&(hit->instancerId));
if (!TF_VERIFY(rprimValid, "%s\n", hit->objectId.GetText())) {
return false;
}
hit->worldSpaceHitPoint = GfVec3f(hitPoint);
hit->ndcDepth = float(z);
hit->instanceIndex = instanceIndex;
hit->elementIndex = elementIndex;
if (TfDebug::IsEnabled(HDX_INTERSECT)) {
std::cout << *hit << std::endl;
}
return true;
}
void MyTorus::worldCoord(int x, int y, int z, Vector3d &v) {
#if RETINA_DISPLAY
x *= 2;
y *= 2;
#endif
GLint viewport[4];
glGetIntegerv(GL_VIEWPORT,viewport);
std::cout << "x: "<< x << " - y: " << y << " - z: " << z<< std::endl;
std::cout << viewport[0] << " " << viewport[1] << " " << viewport[2] << " " << viewport[3] << std::endl;
GLdouble M[16], P[16];
glGetDoublev(GL_PROJECTION_MATRIX,P);
glGetDoublev(GL_MODELVIEW_MATRIX,M);
gluUnProject(x,viewport[3]-1-y,z,M,P,viewport,&v[0],&v[1],&v[2]);
}
void
motion(int x, int y)
{
GLdouble objx, objy, objz;
if (selectedPoint != ~0) {
gluUnProject(x, winHeight - y, 0.95,
modelMatrix, projMatrix, viewport,
&objx, &objy, &objz);
grid[selectedPoint * 3 + 0] = objx;
grid[selectedPoint * 3 + 1] = objy;
glutPostRedisplay();
}
}
nVec3 nRenderer::pick(nVec2 screenPos) {
double x = screenPos.x;
double y = screenPos.y;
GLint viewport[4];
GLfloat winX, winY, winZ;
GLdouble posX, posY, posZ;
glGetIntegerv(GL_VIEWPORT, viewport);
winX = x;
winY = y;//(double)viewport[3] - y;
glReadPixels(x, int(winY), 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &winZ);
//cout<<"depth = "<<winZ<<endl;
gluUnProject(winX, winY, winZ, (/*objectMatrix * */viewMatrix).matrix, projectionMatrix.matrix, viewport, &posX, &posY, &posZ);
return nVec3(posX, posY, posZ);
}
void mouse(int button, int state, int x, int y) {
switch (button) {
case GLUT_LEFT_BUTTON:
if (state == GLUT_DOWN) {
realy = matrizViewport[3] - (GLint) y - 1;
gluUnProject ((GLdouble) x, (GLdouble) realy, 0.0,
matrizModelview, matrizProjecao, matrizViewport,
&wx0, &wy0, &wz0);
gluUnProject ((GLdouble) x, (GLdouble) realy, 1.0,
matrizModelview, matrizProjecao, matrizViewport,
&wx1, &wy1, &wz1);
vx=wx1-wx0;
vy=wy1-wy0;
vz=wz1-wz0;
proximidade();
glutPostRedisplay();
}
else {
mudaCurva=0;
}
break;
}
}
