C++ GLWindow类代码示例

 static void CharFunc(GLFWwindow* window, int c) {
     GLWindow* glwnd = (GLWindow*)glfwGetWindowUserPointer(window);
     
     input::KeyEventArgs args;
     args.key    = c;
     args.state  = input::Press;
     args.isIME  = true;
     args.flag   = g_key_flag;
     
     glwnd->onKeyEvent().raise(glwnd, args);
 }

void Display::upCB(Fl_Button* w, Display* d)
{
	Map* m = d->getMap();
	GLWindow* win = d->getGWin();
	//std::cout << d->tile_x <<d->tile_y<< std::endl;
	if (d->tile_y == 0)
		d->tile_y = m->getRow()-1;
	else
		d->tile_y--;
	win->setColor(d->tile_x, d->tile_y);
	win->redraw();
}

void Display::createCB(Fl_Button* w, Display* c){
	Map* m = c->getMap();
	c->tile_x = c->tile_y = 0;
	m->setSize(c->r,c->c,c->x,c->y);
	//std::cout << c->max << std::endl;
	m->setRange(c->max, c->min);
	m->createMap();
	GLWindow* win = c->getGWin();
	win->setColor(c->tile_x, c->tile_y);
	win->setMap(m);
	win->redraw();
}

void Display::rightCB(Fl_Button* w, Display* d)
{
	Map* m = d->getMap();
	GLWindow* win = d->getGWin();
	//std::cout << d->tile_x <<d->tile_y<< std::endl;
	if (d->tile_x == m->getCol() - 1)
		d->tile_x = 0;
	else
		d->tile_x++;
	win->setColor(d->tile_x, d->tile_y);
	win->redraw();
}

		void frameDraw(const uint32_t id)
		{
			eq::Channel::frameDraw(id);

			GLWindow* glwindow =
					dynamic_cast<GLWindow*> (getWindow()->getOSWindow());

			if (glwindow)
				glwindow->getWidget()->paintGL();
			else
				Widget::static_draw(this);
		}

    static void MousePosFunc(GLFWwindow* window, int x, int y) {
        GLWindow* glwnd = (GLWindow*)glfwGetWindowUserPointer(window);

        input::MouseEventArgs args;
        args.button = input::Nothing;
        args.state  = input::Move;
        args.flag   = g_key_flag;
        args.x      = x;
        args.y      = y;

        glwnd->onMouseEvent().raise(glwnd, args);
    }

    static void MouseButtonFunc(GLFWwindow* window, int btn, int state) {
        GLWindow* glwnd = (GLWindow*)glfwGetWindowUserPointer(window);

        input::MouseEventArgs args;
        args.button = glfw_to_ukn_mouse(btn);
        args.state  = glfw_to_ukn_mouse_state(state);
        args.flag   = g_key_flag;

        // retrieve mouse pos
        glfwGetCursorPos(window, &args.x, &args.y);

        glwnd->onMouseEvent().raise(glwnd, args);
    }

    static void ScrollFunc(GLFWwindow* window, double a, double b) {
        GLWindow* glwnd = (GLWindow*)glfwGetWindowUserPointer(window);
        
        input::MouseEventArgs args;
        args.button = input::Nothing;
        args.state  = input::Wheel;
        args.flag   = g_key_flag;
        args.x      = a;
        args.y      = b;
        args.wheel  = 0;

        glwnd->onMouseEvent().raise(glwnd, args);
    }

static gint expose (GtkWidget *widget, GdkEventExpose *event, gpointer data)
{
  GLWindow *wnd = (GLWindow*)data;

#ifndef _WIN32
  if (event->count > 0)
    return TRUE;
#endif

  if (!g_pParentWnd->IsSleeping ())
    wnd->OnExpose ();

  return TRUE;
}

int main(int argc, char** argv)
{
	GLWindow window;

	ShaderInfo shadersText[] = { {GL_VERTEX_SHADER, "Source/GLSLShaders/text.vert" },
				{GL_FRAGMENT_SHADER, "Source/GLSLShaders/text.frag" }};

	SDL_Color textCol;
	textCol.r = 36;
	textCol.g = 133;
	textCol.b = 12;
	textCol.a = 255;
	window.RegisterTextRenderer(shadersText, 2, "Source/Resources/Fonts/helvetica.ttf", 14, textCol);

	glm::vec3 eye(0.0f, -15.0f, 15.0f);
	glm::vec3 center(0.0f, 0.0f, 0.0f);
	glm::vec3 up(0.0f, 15.0f, 15.0f);
	std::shared_ptr<Camera> cam(new Camera(eye, center, up, 45.0f, (float)WIDTH/ (float)HEIGHT, 1.0f, 100.0f));

	std::shared_ptr<CameraKeyMoveHandler> cameraKeyMoveHandler(new CameraKeyMoveHandler(cam.get()));
	window.RegisterEventHandler(cameraKeyMoveHandler.get());
	window.RegisterRenderHandler(cameraKeyMoveHandler.get());

	std::shared_ptr<CameraMouseMoveHandler> cameraMouseMoveHandler(new CameraMouseMoveHandler(cam.get(), glm::vec3(0.0f, 0.0f, 0.0f)));
	window.RegisterEventHandler(cameraMouseMoveHandler.get());

	std::shared_ptr<ShaderProgramManager> shaderManager(new ShaderProgramManager(window, cam.get()));
	window.RegisterEventHandler(shaderManager.get());
	window.RegisterRenderHandler(shaderManager.get());

	window.MainLoop();

	return 0;
}

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);

    QSurfaceFormat fmt;
    fmt.setDepthBufferSize(24);
//    fmt.setVersion(3, 3);
//    fmt.setProfile(QSurfaceFormat::CoreProfile);
    QSurfaceFormat::setDefaultFormat(fmt);

    GLWindow w;
    w.show();

    return a.exec();
}

// workaround for issue seen on Windows 7 with NVIDIA 
void triggerStereo()
{
    // attributes for an OpenGL stereo window
    GLWindow::Attributes attributes;
    attributes[WGL_STEREO_ARB] = GL_TRUE;

    // create and destroy a small stereo window: this is here to work around
    // an issue with windows failing to switch to quad-buffer mode (although
    // the window is successfully created and reports a stereo pixel format)
    // note: the window is invisible (not shown) but typically causes the
    // windows desktop to flash briefly (first run only) as stereo activates
    GLWindow window;
    window.create( 0, "", 0, 0, 0, 8, 8, 0, 0, DefWindowProc, 0, attributes );
    window.destroy();
}

int main(int argc, char** argv) {
    auto glversion = gl::getAvailableVersion();
    auto major = GL_GET_MAJOR_VERSION(glversion);
    auto minor = GL_GET_MINOR_VERSION(glversion);

    if (glversion < GL_MAKE_VERSION(4, 1)) {
        MessageBoxA(nullptr, "Interface requires OpenGL 4.1 or higher", "Unsupported", MB_OK);
        return 0;
    }
    QGuiApplication app(argc, argv);

    bool quitting = false;
    // FIXME need to handle window closing message so that we can stop the timer
    GLWindow* window = new GLWindow();
    window->create();
    window->show();
    window->setSurfaceType(QSurface::OpenGLSurface);
    window->setFormat(getDefaultOpenGLSurfaceFormat());
    bool contextCreated = false;
    QTimer* timer = new QTimer();
    QObject::connect(timer, &QTimer::timeout, [&] {
        if (quitting) {
            return;
        }
        if (!contextCreated) {
            window->createContext();
            contextCreated = true;
        }
        if (!window->makeCurrent()) {
            throw std::runtime_error("Failed");
        }
        glClearColor(1.0f, 0.0f, 1.0f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);
        window->swapBuffers();
        window->doneCurrent();
    });
    // FIXME need to handle window closing message so that we can stop the timer
    QObject::connect(&app, &QCoreApplication::aboutToQuit, [&] {
        quitting = true;
        QObject::disconnect(timer, &QTimer::timeout, nullptr, nullptr);
        timer->stop();
        timer->deleteLater();
    });

    timer->setInterval(15);
    timer->setSingleShot(false);
    timer->start();
    app.exec();
    return 0;
}

/* Main Method */
int CALLBACK WinMain(HINSTANCE current_instance_handle,HINSTANCE previous_instance_handle,LPSTR arguments,int show_command)
{
	std::ofstream log;
	GLWindow      window;
	

	log.open("./Debug/output.log",std::ofstream::ate);
	std::cout.rdbuf(log.rdbuf());

	
	/* Initialize the window and run it's message loop. */
	if(!window.init())
	{
		return 1;
	}

	window.setBackgroundColour(Strixa::Graphics::Colour(0,0,0,100));
	window.maximize();

    return window();
}

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);

#if defined(Q_WS_X11)
    XInitThreads();
#endif

    GLWindow *glwindow = new GLWindow();
    glwindow->create();
    glwindow->setWindowState(Qt::WindowNoState);
    glwindow->showFullScreen();
    glwindow->resume();

    int result = a.exec();

    glwindow->destroy();
    delete glwindow;

    //QCoreApplication::setAttribute(Qt::AA_NativeWindows, true);
    //QCoreApplication::setAttribute(Qt::AA_ImmediateWidgetCreation, true);

    //return a.exec();

    return result;
}