C++ GHOST_Rect类代码示例

GPG_Canvas::GPG_Canvas(GHOST_IWindow* window)
: GPC_Canvas(0, 0), m_window(window)
{
	if (m_window)
	{
		GHOST_Rect bnds;
		m_window->getClientBounds(bnds);
		this->Resize(bnds.getWidth(), bnds.getHeight());
	}
}

bool ofxFenster::setupOpenGL(int l, int t, int w, int h, int screenMode) {
	STR_String title("window");
	GHOST_TWindowState state=GHOST_kWindowStateNormal;
	if(screenMode==OF_FULLSCREEN) {
		isFullscreen=true;
		state=GHOST_kWindowStateFullScreen;
	}

	win = GHOST_ISystem::getSystem()->createWindow(title, l, t, w, h, state, GHOST_kDrawingContextTypeOpenGL, false, false);

	if (!win) {
		ofLog(OF_LOG_ERROR, "HOUSTON WE GOT A PROBLEM! could not create window");
		return false;
	}

	//get background color. not working yet because opengl renderer does not exist yet, so fill with black
	//float * bgPtr = ofBgColorPtr();
	//bgColor.set(bgPtr[0]*255,bgPtr[1]*255,bgPtr[2]*255, bgPtr[3]*255);
	//bClearAuto = ofbClearBg();

	setActive();

	bgColor.set(0,0,0);
	//ofClear(bgColor.r, bgColor.g, bgColor.b, bgColor.a);

	//update sizes
	GHOST_Rect rect;
	win->getClientBounds(rect);
	height=rect.getHeight();
	width=rect.getWidth();
	pos.x=rect.m_l;
	pos.y=rect.m_t;

	//initial clear
	glClearColor(.55, .55, .55, 0.0);
	glClear(GL_COLOR_BUFFER_BIT);
	setDragAndDrop(true);
	setup();
	return true;
}

bool GPG_Application::processEvent(GHOST_IEvent* event)
{
	bool handled = true;

	switch (event->getType())
	{
		case GHOST_kEventUnknown:
			break;

		case GHOST_kEventButtonDown:
			handled = handleButton(event, true);
			break;

		case GHOST_kEventButtonUp:
			handled = handleButton(event, false);
			break;
			
		case GHOST_kEventWheel:
			handled = handleWheel(event);
			break;

		case GHOST_kEventCursorMove:
			handled = handleCursorMove(event);
			break;

		case GHOST_kEventKeyDown:
			handleKey(event, true);
			break;

		case GHOST_kEventKeyUp:
			handleKey(event, false);
			break;


		case GHOST_kEventWindowClose:
		case GHOST_kEventQuit:
			m_exitRequested = KX_EXIT_REQUEST_OUTSIDE;
			break;

		case GHOST_kEventWindowActivate:
			handled = false;
			break;
		case GHOST_kEventWindowDeactivate:
			handled = false;
			break;

		// The player now runs as often as it can (repsecting vsync and fixedtime).
		// This allows the player to break 100fps, but this code is being left here
		// as reference. (see EngineNextFrame)
		//case GHOST_kEventWindowUpdate:
		//	{
		//		GHOST_IWindow* window = event->getWindow();
		//		if (!m_system->validWindow(window)) break;
		//		// Update the state of the game engine
		//		if (m_kxsystem && !m_exitRequested)
		//		{
		//			// Proceed to next frame
		//			window->activateDrawingContext();

		//			// first check if we want to exit
		//			m_exitRequested = m_ketsjiengine->GetExitCode();
		//
		//			// kick the engine
		//			bool renderFrame = m_ketsjiengine->NextFrame();
		//			if (renderFrame)
		//			{
		//				// render the frame
		//				m_ketsjiengine->Render();
		//			}
		//		}
		//		m_exitString = m_ketsjiengine->GetExitString();
		//	}
		//	break;
		//
		case GHOST_kEventWindowSize:
			{
			GHOST_IWindow* window = event->getWindow();
			if (!m_system->validWindow(window)) break;
			if (m_canvas) {
				GHOST_Rect bnds;
				window->getClientBounds(bnds);
				m_canvas->Resize(bnds.getWidth(), bnds.getHeight());
				m_ketsjiengine->Resize();
			}
			}
			break;
		
		default:
			handled = false;
			break;
	}
	return handled;
}

static void View(GHOST_IWindow* window, bool stereo, int eye = 0)
{
    window->activateDrawingContext();
    GHOST_Rect bnds;
    int noOfScanlines = 0, lowerScanline = 0;
    int verticalBlankingInterval = 32;  // hard coded for testing purposes, display device dependant
    float left, right, bottom, top;
    float nearplane, farplane, zeroPlane, distance;
    float eyeSeparation = 0.62f;
    window->getClientBounds(bnds);

    // viewport
    if(stereo)
    {
        if(nVidiaWindows)
        {
            // handled by nVidia driver so act as normal (explicitly put here since
            // it -is- stereo)
            glViewport(0, 0, bnds.getWidth(), bnds.getHeight());
        }
        else
        {   // generic cross platform above-below stereo
            noOfScanlines = (bnds.getHeight() - verticalBlankingInterval) / 2;
            switch(eye)
            {
            case LEFT_EYE:
                // upper half of window
                lowerScanline = bnds.getHeight() - noOfScanlines;
                break;
            case RIGHT_EYE:
                // lower half of window
                lowerScanline = 0;
                break;
            }
        }
    }
    else
    {
        noOfScanlines = bnds.getHeight();
        lowerScanline = 0;
    }

    glViewport(0, lowerScanline, bnds.getWidth(), noOfScanlines);

    // projection
    left = -6.0;
    right = 6.0;
    bottom = -4.8f;
    top = 4.8f;
    nearplane = 5.0;
    farplane = 60.0;

    if(stereo)
    {
        zeroPlane = 0.0;
        distance = 14.5;
        switch(eye)
        {
        case LEFT_EYE:
            StereoProjection(left, right, bottom, top, nearplane, farplane, zeroPlane, distance, -eyeSeparation / 2.0);
            break;
        case RIGHT_EYE:
            StereoProjection(left, right, bottom, top, nearplane, farplane, zeroPlane, distance, eyeSeparation / 2.0);
            break;
        }
    }
    else
    {
//		left = -w;
//		right = w;
//		bottom = -h;
//		top = h;
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        glFrustum(left, right, bottom, top, 5.0, 60.0);
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        glTranslatef(0.0, 0.0, -40.0);

    }

    glClearColor(.2f,0.0f,0.0f,0.0f);
}

	bool 
BSP_GhostTestApp3D::
processEvent(
	GHOST_IEvent* event
){

	bool handled = false;

	switch(event->getType()) {
		case GHOST_kEventWindowSize:
		case GHOST_kEventWindowActivate:
			UpdateFrame();
		case GHOST_kEventWindowUpdate:
			DrawPolies();
			handled = true;
			break;
		case GHOST_kEventButtonDown:
		{
			int x,y;
			m_system->getCursorPosition(x,y);


			int wx,wy;
			m_window->screenToClient(x,y,wx,wy);

			GHOST_TButtonMask button = 
				static_cast<GHOST_TEventButtonData *>(event->getData())->button;
			
			if (button == GHOST_kButtonMaskLeft) {
				m_rotation_settings[m_current_object].m_moving = true;
				m_rotation_settings[m_current_object].x_old = x;
				m_rotation_settings[m_current_object].y_old = y;	
			} else 
			if (button == GHOST_kButtonMaskRight) {
				m_translation_settings[m_current_object].m_moving = true;
				m_translation_settings[m_current_object].x_old = x;
				m_translation_settings[m_current_object].y_old = y;	
			} else 
		
			m_window->invalidate();
			handled = true;
			break;

		}

		case GHOST_kEventButtonUp:
		{

			GHOST_TButtonMask button = 
				static_cast<GHOST_TEventButtonData *>(event->getData())->button;
			
			if (button == GHOST_kButtonMaskLeft) {
				m_rotation_settings[m_current_object].m_moving = false;
				m_rotation_settings[m_current_object].x_old = 0;
				m_rotation_settings[m_current_object].y_old = 0;

		} else 
			if (button == GHOST_kButtonMaskRight) {
				m_translation_settings[m_current_object].m_moving = false;
				m_translation_settings[m_current_object].x_old;
				m_translation_settings[m_current_object].y_old;

			}
			m_window->invalidate();
			handled = true;
			break;

		}

		case GHOST_kEventCursorMove:
		{		
			int x,y;
			m_system->getCursorPosition(x,y);	
			int wx,wy;
			m_window->screenToClient(x,y,wx,wy);

			if (m_rotation_settings[m_current_object].m_moving) {
				m_rotation_settings[m_current_object].m_angle_x = MT_Scalar(wx)/20;
				m_rotation_settings[m_current_object].x_old = wx;
				m_rotation_settings[m_current_object].m_angle_y = MT_Scalar(wy)/20;
				m_rotation_settings[m_current_object].y_old = wy;

				m_window->invalidate();
			}
			if (m_translation_settings[m_current_object].m_moving) {

				// project current objects bounding box center into screen space.
				// unproject mouse point into object space using z-value from 
				// projected bounding box center.

				GHOST_Rect bounds;
				m_window->getClientBounds(bounds);

				int w_h = bounds.getHeight();

				y = w_h - wy;
				x = wx;

				double mvmatrix[16];
				double projmatrix[16];
//.........这里部分代码省略.........

void
GHOST_SystemSDL::processEvent(SDL_Event *sdl_event)
{
	GHOST_Event * g_event= NULL;

	switch(sdl_event->type) {
	case SDL_WINDOWEVENT:
		{
			SDL_WindowEvent &sdl_sub_evt= sdl_event->window;
			GHOST_WindowSDL *window= findGhostWindow(SDL_GetWindowFromID(sdl_sub_evt.windowID));
			//assert(window != NULL); // can be NULL on close window.

			switch (sdl_sub_evt.event) {
			case SDL_WINDOWEVENT_EXPOSED:
				g_event= new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowUpdate, window);
				break;
			case SDL_WINDOWEVENT_RESIZED:
				g_event= new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowSize, window);
				break;
			case SDL_WINDOWEVENT_MOVED:
				g_event= new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowMove, window);
				break;
			case SDL_WINDOWEVENT_FOCUS_GAINED:
				g_event= new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowActivate, window);
				break;
			case SDL_WINDOWEVENT_FOCUS_LOST:
				g_event= new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowDeactivate, window);
				break;
			case SDL_WINDOWEVENT_CLOSE:
				g_event= new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowClose, window);
				break;
			}
		}
		break;
	case SDL_QUIT:
		g_event= new GHOST_Event(getMilliSeconds(), GHOST_kEventQuit, NULL);
		break;

	case SDL_MOUSEMOTION:
		{
			SDL_MouseMotionEvent &sdl_sub_evt= sdl_event->motion;
			SDL_Window *sdl_win= SDL_GetWindowFromID(sdl_sub_evt.windowID);
			GHOST_WindowSDL *window= findGhostWindow(sdl_win);
			assert(window != NULL);

			int x_win, y_win;
			SDL_GetWindowPosition(sdl_win, &x_win, &y_win);

			GHOST_TInt32 x_root= sdl_sub_evt.x + x_win;
			GHOST_TInt32 y_root= sdl_sub_evt.y + y_win;

#if 0
			if(window->getCursorGrabMode() != GHOST_kGrabDisable && window->getCursorGrabMode() != GHOST_kGrabNormal)
			{
				GHOST_TInt32 x_new= x_root;
				GHOST_TInt32 y_new= y_root;
				GHOST_TInt32 x_accum, y_accum;
				GHOST_Rect bounds;

				/* fallback to window bounds */
				if(window->getCursorGrabBounds(bounds)==GHOST_kFailure)
					window->getClientBounds(bounds);

				/* could also clamp to screen bounds
				 * wrap with a window outside the view will fail atm  */
				bounds.wrapPoint(x_new, y_new, 8); /* offset of one incase blender is at screen bounds */
				window->getCursorGrabAccum(x_accum, y_accum);

				// cant use setCursorPosition because the mouse may have no focus!
				if(x_new != x_root || y_new != y_root) {
					if (1 ) { //xme.time > m_last_warp) {
						/* when wrapping we don't need to add an event because the
						 * setCursorPosition call will cause a new event after */
						SDL_WarpMouseInWindow(sdl_win, x_new - x_win, y_new - y_win); /* wrap */
						window->setCursorGrabAccum(x_accum + (x_root - x_new), y_accum + (y_root - y_new));
						// m_last_warp= lastEventTime(xme.time);
					} else {
						// setCursorPosition(x_new, y_new); /* wrap but don't accumulate */
						SDL_WarpMouseInWindow(sdl_win, x_new - x_win, y_new - y_win);
					}

					g_event = new GHOST_EventCursor(getMilliSeconds(), GHOST_kEventCursorMove, window, x_new, y_new);
				}
				else {
					g_event = new GHOST_EventCursor(getMilliSeconds(), GHOST_kEventCursorMove, window, x_root + x_accum, y_root + y_accum);
				}
			}
			else
#endif
			{
				g_event= new GHOST_EventCursor(getMilliSeconds(), GHOST_kEventCursorMove, window, x_root, y_root);
			}
			break;
		}
	case SDL_MOUSEBUTTONUP:
	case SDL_MOUSEBUTTONDOWN:
		{
			SDL_MouseButtonEvent &sdl_sub_evt= sdl_event->button;
			GHOST_TButtonMask gbmask= GHOST_kButtonMaskLeft;
			GHOST_TEventType type= (sdl_sub_evt.state==SDL_PRESSED) ? GHOST_kEventButtonDown : GHOST_kEventButtonUp;
//.........这里部分代码省略.........

bool GPG_Application::processEvent(GHOST_IEvent* event)
{
	bool handled = true;

	switch (event->getType())
	{
		case GHOST_kEventUnknown:
			break;

		case GHOST_kEventButtonDown:
			handled = handleButton(event, true);
			break;

		case GHOST_kEventButtonUp:
			handled = handleButton(event, false);
			break;
			
		case GHOST_kEventWheel:
			handled = handleWheel(event);
			break;

		case GHOST_kEventCursorMove:
			handled = handleCursorMove(event);
			break;

		case GHOST_kEventKeyDown:
			handleKey(event, true);
			break;

		case GHOST_kEventKeyUp:
			handleKey(event, false);
			break;


		case GHOST_kEventWindowClose:
		case GHOST_kEventQuit:
			m_exitRequested = KX_EXIT_REQUEST_OUTSIDE;
			break;

		case GHOST_kEventWindowActivate:
			handled = false;
			break;
		case GHOST_kEventWindowDeactivate:
			handled = false;
			break;

		case GHOST_kEventWindowUpdate:
			{
				GHOST_IWindow* window = event->getWindow();
				if (!m_system->validWindow(window)) break;
				// Update the state of the game engine
				if (m_kxsystem && !m_exitRequested)
				{
					// Proceed to next frame
					window->activateDrawingContext();

					// first check if we want to exit
					m_exitRequested = m_ketsjiengine->GetExitCode();
					
					// kick the engine
					bool renderFrame = m_ketsjiengine->NextFrame();
					if (renderFrame)
					{
						// render the frame
						m_ketsjiengine->Render();
					}
				}
				m_exitString = m_ketsjiengine->GetExitString();
			}
			break;
		
		case GHOST_kEventWindowSize:
			{
			GHOST_IWindow* window = event->getWindow();
			if (!m_system->validWindow(window)) break;
			if (m_canvas) {
				GHOST_Rect bnds;
				window->getClientBounds(bnds);
				m_canvas->Resize(bnds.getWidth(), bnds.getHeight());
			}
			}
			break;
		
		default:
			handled = false;
			break;
	}
	return handled;
}

bool ofxFensterManager::processEvent(GHOST_IEvent* event)
{
	if(event->getType()==GHOST_kEventUnknown)
		return false;
	
	GHOST_IWindow* window = event->getWindow();
	bool handled = true;
	
	ofxFenster* win=getFensterByHandler(window);
	
	GHOST_Rect winPos; //why on every process...?
	window->getWindowBounds(winPos);
	
	switch (event->getType())
	{
			//////////////////// MOUSE
        case GHOST_kEventCursorMove:
        {
            GHOST_TEventCursorData* bd=(GHOST_TEventCursorData*)event->getData();
			GHOST_TInt32 x,y;
			window->screenToClient(bd->x, bd->y, x, y);
			
			ofPoint p(x, y);
			p.y -= 1;
			
            if(win->isButtonDown) {
                //win->mouseDragged(bd->x-winPos.m_l, bd->y-winPos.m_t, win->buttonDown);
                win->mouseDragged(p.x, p.y, win->buttonDown);
            } else {
                //win->mouseMoved(bd->x-winPos.m_l, bd->y-winPos.m_t);
                win->mouseMoved(p.x, p.y);
            }
            break;
        }
        case GHOST_kEventWheel:
        {
            break;
        }
        case GHOST_kEventButtonDown:
        {
            GHOST_TEventButtonData* bd=(GHOST_TEventButtonData*)event->getData();
            win->isButtonDown=true;
            win->buttonDown=bd->button;
            win->mousePressed(bd->button);
            break;
        }
        case GHOST_kEventButtonUp:
        {
            GHOST_TEventButtonData* bd=(GHOST_TEventButtonData*)event->getData();
            win->isButtonDown=false;
            win->mouseReleased(bd->button);
            break;
        }
			////////////////// KEYBOARD
        case GHOST_kEventKeyUp:
        {
            int key=handleKeyData((GHOST_TEventKeyData*) event->getData());
            if(key==OF_KEY_ESC)
                break;
            win->keyReleased(key);
            break;
        }
        case GHOST_kEventKeyDown:
        {
            int key=handleKeyData((GHOST_TEventKeyData*) event->getData());
            if(key==OF_KEY_ESC)
                ofExit(0);
            win->keyPressed(key);
            break;
        }
			////////////////// WINDOW
        case GHOST_kEventWindowSize:
        {
            GHOST_Rect rect;
            window->getClientBounds(rect);
            win->windowResized(rect.getWidth(), rect.getHeight());
            break;
        }
        case GHOST_kEventWindowMove:
        {
            GHOST_Rect rect;
            window->getWindowBounds(rect);
			//cout << rect.m_t << endl;
			//GHOST_TInt32 x,y;
			//window->screenToClient(rect.m_l, rect.m_t, x, y);
            win->windowMoved(rect.m_l, rect.m_t);
			
            break;
        }
        case GHOST_kEventWindowUpdate:
        {
            win->draw();
			window->swapBuffers();
            break;
        }
        case GHOST_kEventWindowActivate:
        {
            break;
        }
        case GHOST_kEventWindowDeactivate:
//.........这里部分代码省略.........