//------------------------------------------------------- void handManagerNode::updateCamToScreenCoords(){ GLdouble model_view[16]; glGetDoublev(GL_MODELVIEW_MATRIX, model_view); GLdouble projection[16]; glGetDoublev(GL_PROJECTION_MATRIX, projection); GLint viewport[4]; glGetIntegerv(GL_VIEWPORT, viewport); GLdouble X, Y, Z; if( seqPin.currentSection.name == "open" || seqPin.currentSection.name == "poke" ){ storePersonPosPin = myPerson.pos; } if( seqFan.currentSection.name == "open" ){ storePersonPosFan = myPerson.pos; } if( seqPin.bPlay ){ gluProject(storePersonPosPin.x - 50, storePersonPosPin.y + 45, storePersonPosPin.z, model_view, projection, viewport, &X, &Y, &Z); myPersonScreenPosPin.set(X, ofGetHeight()-Y, Z); seqPin.setPosition(myPersonScreenPosPin.x, myPersonScreenPosPin.y, 0); } if( seqFan.bPlay ){ gluProject(storePersonPosFan.x-50, storePersonPosFan.y - 180, storePersonPosFan.z, model_view, projection, viewport, &X, &Y, &Z); myPersonScreenPosFan.set(X, ofGetHeight()-Y, Z); seqFan.setPosition(myPersonScreenPosFan.x, myPersonScreenPosFan.y, 0); } }
void RDirNode::calcScreenPos(GLint* viewport, GLdouble* modelview, GLdouble* projection) { static GLdouble screen_x, screen_y, screen_z; gluProject( pos.x, pos.y, 0.0f, modelview, projection, viewport, &screen_x, &screen_y, &screen_z); screen_y = (float)viewport[3] - screen_y; projected_pos.x = screen_x; projected_pos.y = screen_y; gluProject( spos.x, spos.y, 0.0f, modelview, projection, viewport, &screen_x, &screen_y, &screen_z); screen_y = (float)viewport[3] - screen_y; projected_spos.x = screen_x; projected_spos.y = screen_y; static vec2 selected_offset(5.5f, -2.0f); static vec2 unselected_offset(5.5f, -1.0f); if(!gGourceSettings.hide_filenames) { //first pass - calculate positions of names for(std::list<RFile*>::const_iterator it = files.begin(); it!=files.end(); it++) { RFile* f = *it; f->calcScreenPos(viewport, modelview, projection); } } for(std::list<RDirNode*>::const_iterator it = children.begin(); it != children.end(); it++) { RDirNode* node = (*it); node->calcScreenPos(viewport, modelview, projection); } }
static void build_pan_jacobian(BotDefaultViewHandler *dvh, double dq[3], double up[3], double left[3], double A[4]) { ////////////////////////////////////////// // How fast do the screen coordinates for dq change when we // translate dq in the up and left directions? We compute // derivatives numerically with step size eps. double eps = 0.00001; double PM_dq[3]; gluProject(dq[0], dq[1], dq[2], dvh->model_matrix, dvh->projection_matrix, dvh->viewport, &PM_dq[0], &PM_dq[1], &PM_dq[2]); double PM_dq_up[3]; gluProject(dq[0] + up[0]*eps, dq[1] + up[1]*eps, dq[2] + up[2]*eps, dvh->model_matrix, dvh->projection_matrix, dvh->viewport, &PM_dq_up[0], &PM_dq_up[1], &PM_dq_up[2]); double PM_dq_left[3]; gluProject(dq[0] + left[0]*eps, dq[1] + left[1]*eps, dq[2] + left[2]*eps, dvh->model_matrix, dvh->projection_matrix, dvh->viewport, &PM_dq_left[0], &PM_dq_left[1], &PM_dq_left[2]); ////////////////////////////////////////// // Compute the Jacobian of screen coordinate changes with respect // to translation. A[0] = (PM_dq_up[0] - PM_dq[0]) / eps; A[1] = (PM_dq_left[0] - PM_dq[0]) / eps; A[2] = (PM_dq_up[1] - PM_dq[1]) / eps; A[3] = (PM_dq_left[1] - PM_dq[1]) / eps; }
void Gameboard::UpdateSquareScreenCoordinate(){ GLint viewport[4]; GLdouble modelview[16]; GLdouble projection[16]; GLdouble winX, winY, winZ; GLdouble prevwinX, prevwinY, prevwinZ; glGetDoublev(GL_MODELVIEW_MATRIX, modelview); glGetDoublev(GL_PROJECTION_MATRIX, projection); glGetIntegerv(GL_VIEWPORT, viewport); for (unsigned i = 0; i < squaresList.size(); i++) { // attention x correspond aux colonnes (sizez) et y au ligne (sizex... int posX = (int)squaresList[i].getX()* 100 + 50; int posZ = (int)squaresList[i].getZ() * 100 + 50; gluProject(posX, 0, posZ, modelview, projection, viewport, &winX, &winY, &winZ); squaresList[i].setScreencoordX(winX); squaresList[i].setScreencoordY(glutGet(GLUT_WINDOW_HEIGHT) - winY); /*std::cout << "__________________________________________________" << i << std::endl; std::cout << "ligne = " << squaresList[i].getZ() << "posx = " << posX << std::endl; std::cout << "colone = " << squaresList[i].getX() << "posZ = " << posZ << std::endl; std::cout << "squareX = " << squaresList[i].getScreenCoordX() << std::endl; std::cout << "squareY = " << squaresList[i].getScreenCoordY() << std::endl; */ } }
inline float gl_project_get_depth(int x,int y,int z) { double dx,dy,dz; gluProject(x,y,z,mod_matrix,proj_matrix,(GLint*)vport,&dx,&dy,&dz); return((float)dz); }
IoObject *IoSeq_glProject(IoSeq *self, IoObject *locals, IoMessage *m) { IoSeq_assertIsVector(self, locals, m); { float *f = IoSeq_floatPointerOfLength_(self, 3); /* Project the receiver from object to window coordinates. */ GLint viewport[4]; GLdouble mvmatrix[16]; GLdouble projmatrix[16]; GLdouble objx, objy, objz; glGetIntegerv(GL_VIEWPORT, viewport); glGetDoublev(GL_MODELVIEW_MATRIX, mvmatrix); glGetDoublev(GL_PROJECTION_MATRIX, projmatrix); gluProject((GLdouble)(f[0]), (GLdouble)(f[1]), (GLdouble)(f[2]), mvmatrix, projmatrix, viewport, &objx, &objy, &objz); f[0] = objx; f[1] = objy; f[2] = objz; } return self; }
__Vect3D ms_GetScreenCoords(float SceneX, float SceneY, float SceneZ) { __Vect3D RetVect; GLdouble ModelM[16], ProjM[16], Pos[3]; int Viewp[4]; glPushMatrix(); glLoadIdentity(); gl_SetupScene3D(zProgram.WindowWidth, zProgram.WindowHeight); gl_LookAt(zCamera.X, zCamera.Y, zCamera.Z, zCamera.X + zCamera.LX, zCamera.Y + zCamera.LY, zCamera.Z + zCamera.LZ); glScalef(0.005, 0.005, 0.005); glGetDoublev(GL_MODELVIEW_MATRIX, ModelM); glGetDoublev(GL_PROJECTION_MATRIX, ProjM); glGetIntegerv(GL_VIEWPORT, (GLint*)Viewp); gluProject((GLdouble)SceneX, (GLdouble)SceneY, (GLdouble)SceneZ, ModelM, ProjM, (GLint*)Viewp, &Pos[0], &Pos[1], &Pos[2]); Pos[1] = (GLdouble)Viewp[3] - (GLdouble)Pos[1] - 1; RetVect.X = (signed int)Pos[0]; RetVect.Y = (signed int)Pos[1]; RetVect.Z = (signed int)Pos[2]; gl_SetupScene2D(zProgram.WindowWidth, zProgram.WindowHeight); glPopMatrix(); return RetVect; }
void CHapticMouse::Sync3DTo2DCursor() { double X, Y, Z; CRect viewSize; CPoint point; GetClientRect(&viewSize); if (QueryCursorPos(&X, &Y, &Z)) { GLdouble matModel[16]; glGetDoublev(GL_MODELVIEW_MATRIX, matModel); GLdouble matProj[16]; glGetDoublev(GL_PROJECTION_MATRIX, matProj); GLint viewport[16]; glGetIntegerv(GL_VIEWPORT, viewport); GLdouble x, y, z; gluProject(X, Y, Z, matModel, matProj, viewport, &x, &y, &z); point.x = min(max(0, (int) x), viewSize.Width()); point.y = min(max(0, viewSize.Height() - (int) y), viewSize.Height()); } else { // Application does not have a current 3D cursor, center the mouse // pointer in the window point.x = viewSize.Width() / 2; point.y = viewSize.Height() / 2; } // Place the mouse cursor at the computed position ClientToScreen(&point); SetCursorPos(point.x, point.y); }
/*glu.Project(objx, objy, objz, modelMatrixArray, projMatrixArray, viewportArray) -> error, winx, winy, winz */ static int luaglu_project(lua_State *L) { GLdouble winx, winy, winz; GLdouble modelMatrix[16]; GLdouble projMatrix[16]; GLint viewport[4]; int error; luaglu_load_matrix16d(L, 4, modelMatrix); luaglu_load_matrix16d(L, 5, projMatrix); luaglu_load_viewport(L, 6, viewport); error = gluProject(luaL_checknumber(L, 1), luaL_checknumber(L, 2), luaL_checknumber(L, 3), modelMatrix, projMatrix, viewport, &winx, &winy, &winz); lua_pushnumber(L, error); if (error == GL_TRUE) { lua_pushnumber(L, winx); lua_pushnumber(L, winy); lua_pushnumber(L, winz); return 4; } else return 1; }
static void hugsprim_gluProject_4(HugsStackPtr hugs_root) { HsDouble arg1; HsDouble arg2; HsDouble arg3; HsPtr arg4; HsPtr arg5; HsPtr arg6; HsPtr arg7; HsPtr arg8; HsPtr arg9; HsInt32 res1; arg1 = hugs->getDouble(); arg2 = hugs->getDouble(); arg3 = hugs->getDouble(); arg4 = hugs->getPtr(); arg5 = hugs->getPtr(); arg6 = hugs->getPtr(); arg7 = hugs->getPtr(); arg8 = hugs->getPtr(); arg9 = hugs->getPtr(); res1 = gluProject(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); hugs->putInt32(res1); hugs->returnIO(hugs_root,1); }
static int mouse_scroll (BotViewer *viewer, BotEventHandler *ehandler, const double ray_start[3], const double ray_dir[3], const GdkEventScroll *event) { BotDefaultViewHandler *dvh = (BotDefaultViewHandler*) ehandler->user; // scrolling = zoom in and out if ( event->direction == GDK_SCROLL_UP) { zoom_ratio (dvh, 0.9); } else if (event->direction == GDK_SCROLL_DOWN) { zoom_ratio (dvh, 1.1); } // how far from XY plane? double dist = (ray_start[2] - dvh->lastpos[2]) / ray_dir[2]; double dq[] = {ray_start[0] - ray_dir[0]*dist, ray_start[1] - ray_dir[1]*dist, ray_start[2] - ray_dir[2]*dist, 1 }; double PM_dq[3]; gluProject(dq[0], dq[1], dq[2], dvh->model_matrix, dvh->projection_matrix, dvh->viewport, &PM_dq[0], &PM_dq[1], &PM_dq[2]); window_space_pan(dvh, dq, event->x - PM_dq[0], -((dvh->viewport[3] - event->y) - PM_dq[1]), 1); bot_viewer_request_redraw(viewer); return 1; }
void rgl_user2window(int* successptr, int* idata, double* point, double* pixel, double* model, double* proj, int* view) { int success = RGL_FAIL; GLdouble* vertex = pixel; int columns = idata[0]; GLint viewport[4]; Device* device; if (deviceManager && (device = deviceManager->getAnyDevice())) { for (int i=0; i<4; i++) viewport[i] = view[i]; for (int i=0; i<columns; i++) { gluProject(point[0],point[1],point[2],model,proj,viewport, vertex,vertex+1,vertex+2); vertex[0] /= view[2]; vertex[1] /= view[3]; point += 3; vertex += 3; } success = RGL_SUCCESS; } *successptr = success; }
void BSplineSurfaceView::NewPickedObject() { int cx = m_pickedName >> 16; int cy = m_pickedName & 0xFFFF; GLdouble model_view[16]; glGetDoublev(GL_MODELVIEW_MATRIX, model_view); GLdouble projection[16]; glGetDoublev(GL_PROJECTION_MATRIX, projection); GLint viewport[4]; glGetIntegerv(GL_VIEWPORT, viewport); Vertex3d cpWorld = Vertex3d(m_controlPoints[cx][cy]); // control point in world coordinates Vertex3d cpScreen = Vertex3d(); // control point in screen coordinates gluProject(cpWorld.X(),cpWorld.Y(),cpWorld.Z(),model_view,projection,viewport,cpScreen.XRef(),cpScreen.YRef(),cpScreen.ZRef()); // Mouse offset to control point to maintain relative distance. - NOT WORKING m_dragOffsetX = 0;//m_lastMouseX - cpScreen.X(); m_dragOffsetY = 0;//(viewport[3]-m_lastMouseY) - cpScreen.Y(); m_pickedZ = cpScreen.Z(); }
JVector JXMesaCamera::ModelToScreen ( const JVector& pt ) { if (!PrepareMesa()) { return pt; } PrepareTransforms(); GLdouble modelMatrix[16], projMatrix[16]; GLint viewport[4]; glGetDoublev(GL_MODELVIEW_MATRIX, modelMatrix); glGetDoublev(GL_PROJECTION_MATRIX, modelMatrix); glGetIntegerv(GL_VIEWPORT, viewport); JFloat x,y,z; gluProject(pt.GetElement(1), pt.GetElement(2), pt.GetElement(3), modelMatrix, projMatrix, viewport, &x, &y, &z); return JVector(3, x, y, z); }
//=========================================================================== Vector3D gvCamera::objectCoordsToWindowCoords(const Vector3D& pt) const //=========================================================================== { glMatrixMode(GL_PROJECTION); glPushMatrix(); glMatrixMode(GL_MODELVIEW); glPushMatrix(); use(); int viewport[4]; double projection[16]; double modelview[16]; glGetIntegerv(GL_VIEWPORT, viewport); glGetDoublev(GL_PROJECTION_MATRIX, projection); glGetDoublev(GL_MODELVIEW_MATRIX, modelview); Vector3D winpt; int success = gluProject(pt[0], pt[1], pt[2], modelview, projection, viewport, &winpt[0], &winpt[1], &winpt[2]); // It seems that the y value is referring to the opposite edge. @@sbr Fix this! winpt[1] = viewheight_ - winpt[1]; glMatrixMode(GL_PROJECTION); glPopMatrix(); glMatrixMode(GL_MODELVIEW); glPopMatrix(); ALWAYS_ERROR_IF(!success, "gluProject() failed!"); return winpt; }
//=========================================================================== void gvCamera::moveFocalPointRelative(const Vector3D& eyeptrel) //=========================================================================== { // Compute the window z coordinate of the focal point int viewport[4]; double projection[16]; double modelview[16]; glGetIntegerv(GL_VIEWPORT, viewport); glGetDoublev(GL_PROJECTION_MATRIX, projection); glGetDoublev(GL_MODELVIEW_MATRIX, modelview); Vector3D ppp; gluProject(focal_point_[0], focal_point_[1], focal_point_[2], modelview, projection, viewport, &ppp[0], &ppp[1], &ppp[2]); double winz = ppp[2]; // std::cout << "PPP = " << ppp << std::endl; // Interpret the third value of eyeptrel as a relative // amount to move the viewpoint // double objz = eyeptrel[2]; Vector3D pmiddle(viewx_ + viewwidth_/2, viewy_ + viewheight_/2, winz);//(distance_-near_)/(far_-near_)); Vector3D pnew = pmiddle + eyeptrel; Vector3D trpm = eyeCoordsToObjectCoords(pmiddle); Vector3D trpn = eyeCoordsToObjectCoords(pnew); // std::cout << "------------------\n" << pmiddle << pnew << trpm << trpn // << trpn - trpm; focal_point_ -= trpn; focal_point_ += trpm; }
tgt::vec3 GeometryRendererBase::getWindowPos(tgt::vec3 pos, tgt::mat4 pModelview, tgt::mat4 pProjection) const { GLint viewport[4]; GLdouble modelview[16]; GLdouble projection[16]; tgt::mat4 projection_tgt = camera_.getProjectionMatrix() * pProjection; tgt::mat4 modelview_tgt = camera_.getViewMatrix() * pModelview; 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] = idManager_->getRenderTarget()->getSize().x; viewport[3] = idManager_->getRenderTarget()->getSize().y; GLdouble pointProjectedGL[3]; gluProject(pos.x, pos.y, pos.z, modelview, projection, viewport, &pointProjectedGL[0], &pointProjectedGL[1], &pointProjectedGL[2]); return tgt::vec3(static_cast<float>(pointProjectedGL[0]), static_cast<float>(pointProjectedGL[1]), static_cast<float>(pointProjectedGL[2])); }
//====================================================drawNameIn3D======================================// void ccHObject::drawNameIn3D(CC_DRAW_CONTEXT& context) { //绘制窗口 if (!context._win)return; //we display it in the 2D layer in fact! ccBBox bBox = getOwnBB(); if (bBox.isValid()){ ccGLMatrix trans; getAbsoluteGLTransformation(trans); //得到由祖先到当前物体的变换矩阵 const double* MM = context._win->getModelViewMatd(); //viewMat //模型视图矩阵 const double* MP = context._win->getProjectionMatd(); //projMat //投影矩阵 int VP[4]; context._win->getViewportArray(VP); //视口参数 GLdouble xp,yp,zp; CCVector3 C = bBox.getCenter(); //BB的中心为之 trans.apply(C); //实际的位置和显示的位置不同,将变换矩阵作用到中心位置上 gluProject(C.x,C.y,C.z,MM,MP,VP,&xp,&yp,&zp); //根据视图矩阵,投影矩阵和视口参数对BB中心点进行投影 QFont font = context._win->getTextDisplayFont(); //takes rendering zoom into account! //获取字体 //在2D屏幕上显示文本 context._win->displayText( getName(), static_cast<int>(xp), static_cast<int>(yp), ccGenericGLDisplay::ALIGN_HMIDDLE | ccGenericGLDisplay::ALIGN_VMIDDLE, 0.75f, 0, &font); } }
float kScreenUnitPerWorldUnitAtPos ( const KVector & pos ) { GLdouble ox, oy, xx, xy, yx, yy, zx, zy, z, model[16], proj[16]; GLint view[4]; GLdouble px = pos[X], py = pos[Y], pz = pos[Z]; glGetDoublev(GL_PROJECTION_MATRIX, proj); glGetDoublev(GL_MODELVIEW_MATRIX, model); glGetIntegerv(GL_VIEWPORT, (GLint*)view); gluProject(px, py, pz, model, proj, view, &ox, &oy, &z); gluProject(px + 1.0, py, pz, model, proj, view, &xx, &xy, &z); gluProject(px, py + 1.0, pz, model, proj, view, &yx, &yy, &z); gluProject(px, py, pz + 1.0, model, proj, view, &zx, &zy, &z); return (kMax(kMax(kAbs(xx-ox)+kAbs(xy-oy),kAbs(yx-ox)+kAbs(yy-oy)),kAbs(zx-ox)+kAbs(zy-oy))); }
/** * Convert the screen space coordinate (x, y) to the model space coordinate. */ void GLWidget::mouseTo2D(int x,int y, QVector2D &result) { GLint viewport[4]; GLdouble modelview[16]; GLdouble projection[16]; // retrieve the matrices glGetDoublev(GL_MODELVIEW_MATRIX, modelview); glGetDoublev(GL_PROJECTION_MATRIX, projection); glGetIntegerv(GL_VIEWPORT, viewport); // retrieve the projected z-buffer of the origin GLdouble origX, origY, origZ; gluProject(0, 0, 0, modelview, projection, viewport, &origX, &origY, &origZ); // set up the projected point GLfloat winX = (float)x; GLfloat winY = (float)viewport[3] - (float)y; GLfloat winZ = origZ; // unproject the image plane coordinate to the model space GLdouble posX, posY, posZ; gluUnProject(winX, winY, winZ, modelview, projection, viewport, &posX, &posY, &posZ); result.setX(posX); result.setY(posY); }
static Bool facing_screen_p (ModeInfo *mi) { Bool facing_p; GLdouble m[16], p[16], x, y, z; GLint v[4]; glGetDoublev (GL_MODELVIEW_MATRIX, m); glGetDoublev (GL_PROJECTION_MATRIX, p); glGetIntegerv (GL_VIEWPORT, v); /* See if a coordinate 5 units in front of the door is near the center of the screen. */ gluProject (0, -5, 0, m, p, v, &x, &y, &z); x = (x / MI_WIDTH(mi)) - 0.5; y = (y / MI_HEIGHT(mi)) - 0.5; facing_p = (z < 0.9 && x > -0.15 && x < 0.15 && y > -0.15 && y < 0.15); # ifdef DEBUG_MODE glBindTexture(GL_TEXTURE_2D, 0); glDisable (GL_LIGHTING); glColor3f (1, (facing_p ? 1 : 0), 0); glBegin (GL_LINES); glVertex3f (0, 0, 0); glVertex3f (0, -5, 0); glEnd(); if (!MI_IS_WIREFRAME(mi)) glEnable (GL_LIGHTING); # endif /* DEBUG_MODE */ return facing_p; }
vec3 Camera::project(ivec2 vp, vec3 point) const { GLint viewport[4]; GLdouble modelview[16]; GLdouble projection[16]; mat4 projection_glm = getProjectionMatrix(vp); mat4 modelview_glm = getViewMatrix(); for (int i = 0; i < 4; ++i) { modelview[i + 0] = modelview_glm[i].x; modelview[i + 4] = modelview_glm[i].y; modelview[i + 8] = modelview_glm[i].z; modelview[i + 12] = modelview_glm[i].w; projection[i + 0] = projection_glm[i].x; projection[i + 4] = projection_glm[i].y; projection[i + 8] = projection_glm[i].z; projection[i + 12] = projection_glm[i].w; } viewport[0] = 0; viewport[1] = 0; viewport[2] = vp.x; viewport[3] = vp.y; GLdouble pointProjectedGL[3]; gluProject(point.x, point.y, point.z, modelview, projection, viewport, &pointProjectedGL[0], &pointProjectedGL[1], &pointProjectedGL[2]); return vec3(static_cast<float>(pointProjectedGL[0]), static_cast<float>(pointProjectedGL[1]), static_cast<float>(pointProjectedGL[2])); }
void ccHObject::drawNameIn3D(CC_DRAW_CONTEXT& context) { if (!context._win) return; //we display it in the 2D layer in fact! ccBBox bBox = getBB(false,false,m_currentDisplay); if (bBox.isValid()) { const double* MM = context._win->getModelViewMatd(); //viewMat const double* MP = context._win->getProjectionMatd(); //projMat int VP[4]; context._win->getViewportArray(VP); GLdouble xp,yp,zp; CCVector3 C = bBox.getCenter(); gluProject(C.x,C.y,C.z,MM,MP,VP,&xp,&yp,&zp); QFont font = context._win->getTextDisplayFont(); //takes rendering zoom into account! context._win->displayText( getName(), static_cast<int>(xp), static_cast<int>(yp), ccGenericGLDisplay::ALIGN_HMIDDLE | ccGenericGLDisplay::ALIGN_VMIDDLE, 0.75f, 0, &font); } }
void Scene::GetOrthoPosition(void) { glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(-m_width / 2.f, m_width / 2.f, m_height / 2.f, -m_height / 2.f, m_zNear, m_zFar); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); GLint viewport[4]; glGetIntegerv(GL_VIEWPORT, viewport); GLdouble modelview[16]; glGetDoublev(GL_MODELVIEW_MATRIX, modelview); GLdouble projection[16]; glGetDoublev(GL_PROJECTION_MATRIX, projection); GLdouble winX = 0, winY = 0, winZ = 0; gluProject(0, 0, 0, modelview, projection, viewport, &winX, &winY, &winZ); winX = (float)InputManager::GetInstance().GetRawMousePosition().x; winY = (float)InputManager::GetInstance().GetRawMousePosition().y; winY = (float)viewport[3] - winY; GLdouble posX = 0, posY = 0, posZ = 0; gluUnProject(winX, winY, winZ, modelview, projection, viewport, &posX, &posY, &posZ); InputManager::GetInstance().SetOrthoMouse(vec3((float)posX, -(float)posY, 0.f)); }
void ccSphere::drawNameIn3D(CC_DRAW_CONTEXT& context) { if (!context._win) return; //we display it in the 2D layer in fact! ccBBox bBox = getBB(true,false,m_currentDisplay); if (bBox.isValid()) { const double* MM = context._win->getModelViewMatd(); //viewMat const double* MP = context._win->getProjectionMatd(); //projMat int VP[4]; context._win->getViewportArray(VP); GLdouble xp,yp,zp; CCVector3 C = bBox.getCenter(); gluProject(C.x,C.y,C.z,MM,MP,VP,&xp,&yp,&zp); //we want to display this name next to the sphere, and not above it! const ccViewportParameters& params = context._win->getViewportParameters(); int dPix = (int)ceil(params.zoom * m_radius/params.pixelSize); int bkgBorder = QFontMetrics(context._win->getTextDisplayFont()).height()/4+4; context._win->displayText(getName(),(int)xp+dPix+bkgBorder,(int)yp,ccGenericGLDisplay::ALIGN_HLEFT | ccGenericGLDisplay::ALIGN_VMIDDLE,75); } }
void mouse(int button, int state, int x, int y) { GLdouble model[4*4]; GLdouble proj[4*4]; GLint view[4]; /* fix for two-button mice -- left mouse + shift = middle mouse */ if (button == GLUT_LEFT_BUTTON && glutGetModifiers() & GLUT_ACTIVE_SHIFT) button = GLUT_MIDDLE_BUTTON; gltbMouse(button, state, x, y); mouse_state = state; mouse_button = button; if (state == GLUT_DOWN && button == GLUT_MIDDLE_BUTTON) { glGetDoublev(GL_MODELVIEW_MATRIX, model); glGetDoublev(GL_PROJECTION_MATRIX, proj); glGetIntegerv(GL_VIEWPORT, view); gluProject((GLdouble)x, (GLdouble)y, 0.0, model, proj, view, &pan_x, &pan_y, &pan_z); gluUnProject((GLdouble)x, (GLdouble)y, pan_z, model, proj, view, &pan_x, &pan_y, &pan_z); pan_y = -pan_y; } glutPostRedisplay(); }
bool Screen::Project(const vector3d &in, vector3d &out) { GLint o = gluProject(in.x, in.y, in.z, modelMatrix, projMatrix, viewport, &out.x, &out.y, &out.z); out.x = out.x * width * invRealWidth; out.y = GetHeight() - out.y * height * invRealHeight; return (o == GL_TRUE); }
void NavMeshTesterTool::handleRenderOverlay(double* proj, double* model, int* view) { GLdouble x, y, z; // Draw start and end point labels if (m_sposSet && gluProject((GLdouble)m_spos[0], (GLdouble)m_spos[1], (GLdouble)m_spos[2], model, proj, view, &x, &y, &z)) { imguiDrawText((int)x, (int)(y-25), IMGUI_ALIGN_CENTER, "Start", imguiRGBA(0,0,0,220)); } if (m_eposSet && gluProject((GLdouble)m_epos[0], (GLdouble)m_epos[1], (GLdouble)m_epos[2], model, proj, view, &x, &y, &z)) { imguiDrawText((int)x, (int)(y-25), IMGUI_ALIGN_CENTER, "End", imguiRGBA(0,0,0,220)); } }
void drawDetailOverlay(const dtTileCache* tc, const int tx, const int ty, double* proj, double* model, int* view) { dtCompressedTileRef tiles[MAX_LAYERS]; const int ntiles = tc->getTilesAt(tx,ty,tiles,MAX_LAYERS); if (!ntiles) return; const int rawSize = calcLayerBufferSize(tc->getParams()->width, tc->getParams()->height); char text[128]; for (int i = 0; i < ntiles; ++i) { const dtCompressedTile* tile = tc->getTileByRef(tiles[i]); float pos[3]; pos[0] = (tile->header->bmin[0]+tile->header->bmax[0])/2.0f; pos[1] = tile->header->bmin[1]; pos[2] = (tile->header->bmin[2]+tile->header->bmax[2])/2.0f; GLdouble x, y, z; if (gluProject((GLdouble)pos[0], (GLdouble)pos[1], (GLdouble)pos[2], model, proj, view, &x, &y, &z)) { snprintf(text,128,"(%d,%d)/%d", tile->header->tx,tile->header->ty,tile->header->tlayer); imguiDrawText((int)x, (int)y-25, IMGUI_ALIGN_CENTER, text, imguiRGBA(0,0,0,220)); snprintf(text,128,"Compressed: %.1f kB", tile->dataSize/1024.0f); imguiDrawText((int)x, (int)y-45, IMGUI_ALIGN_CENTER, text, imguiRGBA(0,0,0,128)); snprintf(text,128,"Raw:%.1fkB", rawSize/1024.0f); imguiDrawText((int)x, (int)y-65, IMGUI_ALIGN_CENTER, text, imguiRGBA(0,0,0,128)); } } }
int tiledRenderer_get2DCenter(void * trConf , unsigned int column, unsigned int row , float * x2D , float *y2D , float * z2D) { GLint viewport[4]; GLdouble modelview[16]; GLdouble projection[16]; float x3D , y3D , z3D , angleX , angleY , angleZ; tiledRenderer_get3DCenterForTile(trConf , column, row ,&x3D , &y3D , &z3D , &angleX , &angleY , &angleZ); GLdouble posX = x3D , posY = y3D , posZ = z3D; GLdouble winX, winY, winZ=0.0; glGetDoublev( GL_MODELVIEW_MATRIX, modelview ); glGetDoublev( GL_PROJECTION_MATRIX, projection ); glGetIntegerv( GL_VIEWPORT, viewport ); gluProject( posX, posY, posZ , modelview, projection, viewport, &winX, &winY, &winZ); //fprintf(stderr,"Column/Row %u/%u ( %0.2f,%0.2f,%0.2f ) -> %0.2f %0.2f %0.2f\n",column, x3D , y3D , z3D , row , winX , winY , winZ); struct tiledRendererConfiguration * trConfPTR = (struct tiledRendererConfiguration *) trConf; *x2D = winX; *y2D = winY; *z2D = winZ; return 0; }