// ウインドウの位置を取得
Vec2i AppEnv::windowPosition() {
int x_pos;
int y_pos;
glfwGetWindowPos(window_(), &x_pos, &y_pos);
return Vec2i(x_pos, y_pos);
}
void key_callback( GLFWwindow* window, int key, int scancode, int action, int mods )
{
if (action != GLFW_PRESS)
return;
if (key == GLFW_KEY_ESCAPE && mods == 0)
glfwSetWindowShouldClose(window, GLFW_TRUE);
if ((key == GLFW_KEY_ENTER && mods == GLFW_MOD_ALT) ||
(key == GLFW_KEY_F11 && mods == GLFW_MOD_ALT))
{
if (glfwGetWindowMonitor(window))
{
glfwSetWindowMonitor(window, NULL,
windowed_xpos, windowed_ypos,
windowed_width, windowed_height, 0);
}
else
{
GLFWmonitor* monitor = glfwGetPrimaryMonitor();
if (monitor)
{
const GLFWvidmode* mode = glfwGetVideoMode(monitor);
glfwGetWindowPos(window, &windowed_xpos, &windowed_ypos);
glfwGetWindowSize(window, &windowed_width, &windowed_height);
glfwSetWindowMonitor(window, monitor, 0, 0, mode->width, mode->height, mode->refreshRate);
}
}
}
}
// --------------------------------------------------------------------------------------------------------------------
void window::position(int* x, int* y) const
{
if (is_open())
{
glfwGetWindowPos(_internal->_window, x, y);
}
}
int main(int argc, char** argv)
{
int x, y, width;
GLuint texture;
glfwSetErrorCallback(error_callback, NULL);
if (!glfwInit())
exit(EXIT_FAILURE);
windows[0] = open_window("First", NULL, OFFSET, OFFSET);
if (!windows[0])
{
glfwTerminate();
exit(EXIT_FAILURE);
}
// This is the one and only time we create a texture
// It is created inside the first context, created above
// It will then be shared with the second context, created below
texture = create_texture();
glfwGetWindowPos(windows[0], &x, &y);
glfwGetWindowSize(windows[0], &width, NULL);
// Put the second window to the right of the first one
windows[1] = open_window("Second", windows[0], x + width + OFFSET, y);
if (!windows[1])
{
glfwTerminate();
exit(EXIT_FAILURE);
}
// Set drawing color for both contexts
glfwMakeContextCurrent(windows[0]);
glColor3f(0.6f, 0.f, 0.6f);
glfwMakeContextCurrent(windows[1]);
glColor3f(0.6f, 0.6f, 0.f);
glfwMakeContextCurrent(windows[0]);
while (!glfwWindowShouldClose(windows[0]) &&
!glfwWindowShouldClose(windows[1]))
{
glfwMakeContextCurrent(windows[0]);
draw_quad(texture);
glfwMakeContextCurrent(windows[1]);
draw_quad(texture);
glfwSwapBuffers(windows[0]);
glfwSwapBuffers(windows[1]);
glfwWaitEvents();
}
glfwTerminate();
exit(EXIT_SUCCESS);
}
static int luaWindow_position(lua_State* L){
int x, y;
auto window = reinterpret_cast<GLFWwindow*>(lua_touserdata(L, lua_upvalueindex(1)));
glfwGetWindowPos(window, &x, &y);
lua_pushinteger(L, x);
lua_pushinteger(L, y);
return 2;
}
static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
{
if (action != GLFW_PRESS)
return;
switch (key)
{
case GLFW_KEY_UP:
{
if (swap_interval + 1 > swap_interval)
set_swap_interval(window, swap_interval + 1);
break;
}
case GLFW_KEY_DOWN:
{
if (swap_tear)
{
if (swap_interval - 1 < swap_interval)
set_swap_interval(window, swap_interval - 1);
}
else
{
if (swap_interval - 1 >= 0)
set_swap_interval(window, swap_interval - 1);
}
break;
}
case GLFW_KEY_ESCAPE:
glfwSetWindowShouldClose(window, 1);
break;
case GLFW_KEY_F11:
case GLFW_KEY_ENTER:
{
static int x, y, width, height;
if (mods != GLFW_MOD_ALT)
return;
if (glfwGetWindowMonitor(window))
glfwSetWindowMonitor(window, NULL, x, y, width, height, 0);
else
{
GLFWmonitor* monitor = glfwGetPrimaryMonitor();
const GLFWvidmode* mode = glfwGetVideoMode(monitor);
glfwGetWindowPos(window, &x, &y);
glfwGetWindowSize(window, &width, &height);
glfwSetWindowMonitor(window, monitor,
0, 0, mode->width, mode->height,
mode->refreshRate);
}
break;
}
}
}
glm::ivec2 Window::position() const
{
if (!m_window)
return glm::ivec2();
int x, y;
glfwGetWindowPos(m_window, &x, &y);
return glm::ivec2(x, y);
}
bool CGlfwProxy::_createOpengl()
{
if (!glfwInit())
return -1;
m_glWnd = glfwCreateWindow(640, 480, "Hello World", NULL, NULL);
if (!m_glWnd)
{
glfwTerminate();
return -1;
}
glfwMakeContextCurrent(m_glWnd);
PrintInfo();
int w, h;
glfwGetWindowSize(m_glWnd, &w, &h);
int x, y;
glfwGetWindowPos(m_glWnd, &x, &y);
glfwSetWindowTitle(m_glWnd, "OK,this is a window.");
HWND hdl = glfwGetWin32Window(m_glWnd);
LONG style = ::GetWindowLong(hdl, GWL_STYLE);
style &= (~WS_BORDER);
style &= (~WS_CAPTION);
style &= (~WS_DLGFRAME);
style &= (~WS_SYSMENU);
style &= (~WS_THICKFRAME);
style &= (~WS_MINIMIZEBOX);
style &= (~WS_MAXIMIZEBOX);
::SetWindowLong(hdl, GWL_STYLE, style);
glfwSetMouseButtonCallback(m_glWnd, MouseBtnFunc);
glfwSetCursorPosCallback(m_glWnd, MouseMoveFunc);
glfwSetScrollCallback(m_glWnd, MouseWheelFunc);
glfwSetKeyCallback(m_glWnd, KeyFunc);
//
CFInput::InputEventLsnr_Debug lsnr;
CFInput::CInputMngr::Ins().RegisterEventLsnr(CFInput::MouseDown, &lsnr);
CFInput::CInputMngr::Ins().RegisterEventLsnr(CFInput::MouseUp, &lsnr);
CFInput::CInputMngr::Ins().RegisterEventLsnr(CFInput::MouseMove, &lsnr);
CFInput::CInputMngr::Ins().RegisterEventLsnr(CFInput::MouseWheel, &lsnr);
CFInput::CInputMngr::Ins().RegisterEventLsnr(CFInput::KeyDown, &lsnr);
CFInput::CInputMngr::Ins().RegisterEventLsnr(CFInput::KeyUp, &lsnr);
//
return true;
}
void PlayerWin::relaunch()
{
int x = 0;
int y = 0;
GLViewImpl* view = dynamic_cast<GLViewImpl*>(Director::getInstance()->getOpenGLView());
glfwGetWindowPos(view->getWindow(), &x, &y);
_project.setWindowOffset(Vec2(x, y));
openNewPlayerWithProjectConfig(_project);
quit();
}
static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
{
printf("%0.2f Key %s\n",
glfwGetTime(),
action == GLFW_PRESS ? "pressed" : "released");
if (action != GLFW_PRESS)
return;
switch (key)
{
case GLFW_KEY_I:
glfwIconifyWindow(window);
break;
case GLFW_KEY_M:
glfwMaximizeWindow(window);
break;
case GLFW_KEY_R:
glfwRestoreWindow(window);
break;
case GLFW_KEY_ESCAPE:
glfwSetWindowShouldClose(window, GLFW_TRUE);
break;
case GLFW_KEY_F11:
case GLFW_KEY_ENTER:
{
if (mods != GLFW_MOD_ALT)
return;
if (glfwGetWindowMonitor(window))
{
glfwSetWindowMonitor(window, NULL,
windowed_xpos, windowed_ypos,
windowed_width, windowed_height,
0);
}
else
{
GLFWmonitor* monitor = glfwGetPrimaryMonitor();
if (monitor)
{
const GLFWvidmode* mode = glfwGetVideoMode(monitor);
glfwGetWindowPos(window, &windowed_xpos, &windowed_ypos);
glfwGetWindowSize(window, &windowed_width, &windowed_height);
glfwSetWindowMonitor(window, monitor,
0, 0, mode->width, mode->height,
mode->refreshRate);
}
}
break;
}
}
}
JNIEXPORT jint JNICALL Java_com_badlogic_jglfw_Glfw_glfwGetWindowY(JNIEnv* env, jclass clazz, jlong window) {
//@line:751
int x = 0;
int y = 0;
glfwGetWindowPos((GLFWwindow*)window, &x, &y);
return y;
}
// mouse
bool BaseWindow::MouseEvent(double x, double y)
{
int sx = 0, sy = 0;
int w = 0, h = 0;
glfwGetWindowPos(m_window, &sx, &sy);
glfwGetWindowSize(m_window, &w, &h);
int ex = sx + w;
int ey = sy + h;
return x >= sx && x <= ex && y >= sy && y <= ey;
}
Window::Window(RootObjectWeakPtr root)
: BaseObject(root)
{
_type = "window";
ScenePtr scene = dynamic_pointer_cast<Scene>(root.lock());
GlWindowPtr w = scene->getNewSharedWindow();
if (w.get() == nullptr)
return;
_window = w;
_isInitialized = setProjectionSurface();
if (!_isInitialized)
Log::get() << Log::WARNING << "Window::" << __FUNCTION__ << " - Error while creating the Window" << Log::endl;
else
Log::get() << Log::MESSAGE << "Window::" << __FUNCTION__ << " - Window created successfully" << Log::endl;
_viewProjectionMatrix = glm::ortho(-1.f, 1.f, -1.f, 1.f);
setEventsCallbacks();
registerAttributes();
showCursor(false);
// Get the default window size and position
glfwGetWindowPos(_window->get(), &_windowRect[0], &_windowRect[1]);
glfwGetFramebufferSize(_window->get(), &_windowRect[2], &_windowRect[3]);
// Create the render FBO
glGetError();
glGenFramebuffers(1, &_renderFbo);
setupRenderFBO();
glBindFramebuffer(GL_FRAMEBUFFER, _renderFbo);
GLenum _status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (_status != GL_FRAMEBUFFER_COMPLETE)
Log::get() << Log::WARNING << "Window::" << __FUNCTION__ << " - Error while initializing render framebuffer object: " << _status << Log::endl;
else
Log::get() << Log::MESSAGE << "Window::" << __FUNCTION__ << " - Render framebuffer object successfully initialized" << Log::endl;
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// And the read framebuffer
setupReadFBO();
}
Window::Window(unsigned int width, unsigned int height, const char* title) {
bool initStatus = glfwInit();
ASSERT(initStatus, "could not initialize GLFW3");
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, true);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
handle_ = glfwCreateWindow(width, height, title, NULL, NULL);
if (!handle_) {
glfwTerminate();
ASSERT(false, "could not create a GLFW Window");
}
glfwMakeContextCurrent(handle_);
glfwGetWindowPos(handle_, &position_.x, &position_.y);
Vec2i size;
glfwGetWindowSize(handle_, &size.x, &size.y);
size_.x = static_cast<unsigned int>(size.x);
size_.y = static_cast<unsigned int>(size.y);
}
EApp::EApp(std::function<void(void)> startUp, int w, int h) : end(false), close([&]() {
end = true;
}), quit(s_quit) {
if (eApp) {
throw Exceptions::AppAlreadyConstructed();
} else {
eApp = this;
msgQueue = EMsgQueue::create();
glfwInit();
handle = glfwCreateWindow(w, h, "", 0, 0);
glfwSetWindowCloseCallback(handle, CloseCallback);
glfwSetWindowSizeCallback(handle, ResizeCallback);
glfwSetCursorPosCallback(handle, CursorPosCallback);
coreThread = new std::thread([&](std::function<void(void)> startUp, int w, int h) {
glfwMakeContextCurrent(handle);
glfwSwapInterval(0);
glewInit();
glEnable(GL_SCISSOR_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, w, 0, h);
glTranslated(0, h, 0);
glScaled(1, -1, 1);
glMatrixMode(GL_MODELVIEW);
int px, py;
glfwGetWindowPos(handle, &px, &py);
eRootWindow = new EMainWindow(px, py, w, h);
s_quit.connect(loop.quit);
startUp();
loop.exec();
close();
}, startUp, w, h);
}
}
Window::Window(int w, int h, const char *t, GLFWmonitor *m, GLFWwindow *s, const Hint &hint)
:isEnable(false), X(x), Y(y), Width(this->w), Height(this->h), fbWidth(fbw), fbHeight(fbh), Title(title)
{
hint.apply();
if(!(wnd = glfwCreateWindow(w, h, t, m, s)))
{
std::cerr << "Createting Window is failed.\n";
std::cerr << "Window '" << t << "' is not enable.\n";
return;
}
glfwSetWindowUserPointer(wnd, this);
glfwSetWindowPosCallback(wnd, position);
glfwSetWindowSizeCallback(wnd, size);
glfwSetFramebufferSizeCallback(wnd, fbsize);
isEnable = true;
++glfw_window_count;
glfwGetWindowPos (wnd, &x, &y);
glfwGetWindowSize (wnd, &this->w, &this->h);
glfwGetFramebufferSize(wnd, &fbw, &fbh);
title = t;
}
void widget_move(int16 x, int16 y)
{
ui.screen.newmousepos.x = x;
ui.screen.newmousepos.y = y;
if(ui.moving){
int windowx, windowy;
glfwGetWindowPos(get_the_window(),&windowx, &windowy);
glfwSetWindowPos(get_the_window(),x + windowx - ui.screen.mouseclick.x, y + windowy - ui.screen.mouseclick.y);
}
else{
if(focused){
if(focused->action & WIDGET_MOVING){
int16 tempx = x - ui.screen.mousepos.x ;
int16 tempy = y - ui.screen.mousepos.y ;
if(focused->pos.x + tempx <= 0 || focused->pos.y + tempy <= 0)
return;
if(focused->pos.x + focused->width + tempx>= get_screen_width() +400|| focused->pos.y + focused->height + tempy >= get_screen_height() + 400)
return;
focused->pos.x = focused->pos.x + tempx ;
focused->pos.y = focused->pos.y + tempy ;
widget_position_update(focused);
}
if(widget_rect_contains(focused))
widget_mouse_over(focused);
}
else{
if(ui.root)
widget_mouse_over(ui.root);
}
}
}
void Window::setupRenderFBO()
{
glfwGetWindowPos(_window->get(), &_windowRect[0], &_windowRect[1]);
glfwGetFramebufferSize(_window->get(), &_windowRect[2], &_windowRect[3]);
glBindFramebuffer(GL_FRAMEBUFFER, _renderFbo);
if (!_depthTexture)
{
_depthTexture = make_shared<Texture_Image>(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 512, 512, 0, GL_DEPTH_COMPONENT, GL_FLOAT, nullptr);
glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, _depthTexture->getTexId(), 0);
}
else
{
_depthTexture->setAttribute("resizable", {1});
_depthTexture->setAttribute("size", {_windowRect[2], _windowRect[3]});
_depthTexture->setAttribute("resizable", {0});
}
if (!_colorTexture)
{
_colorTexture = make_shared<Texture_Image>();
_colorTexture->setAttribute("filtering", {0});
_colorTexture->reset(GL_TEXTURE_2D, 0, GL_SRGB8_ALPHA8, _windowRect[2], _windowRect[3], 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, _colorTexture->getTexId(), 0);
}
else
{
_colorTexture->setAttribute("resizable", {1});
_colorTexture->setAttribute("size", {_windowRect[2], _windowRect[3]});
_colorTexture->setAttribute("resizable", {0});
}
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
void Screen::fullscreen(bool full)
{
if ( full )
{
batb->log << "batb->screen->fullscreen( true )" << std::endl;
// save this before going fullscreen
glfwGetWindowSize( glfw_window, &nonfullscreen_wth_, &nonfullscreen_hth_ );
glfwGetWindowPos( glfw_window, &nonfullscreen_xpos_, &nonfullscreen_ypos_ );
// full screen on
glfw_monitor = glfwGetPrimaryMonitor();
auto mode = glfwGetVideoMode( glfw_monitor );
glfwSetWindowMonitor( glfw_window, glfw_monitor, 0, 0, mode->width, mode->height, mode->refreshRate);
}
else
{
batb->log << "batb->screen->fullscreen( false )" << std::endl;
// back to window with previos pos and size
glfw_monitor = nullptr;
glfwSetWindowMonitor( glfw_window, glfw_monitor, nonfullscreen_xpos_, nonfullscreen_ypos_, nonfullscreen_wth_, nonfullscreen_hth_, 0 );
}
}
static void glfw_key_callback(GLFWwindow* window, int key, int scancode, int action, int mods) {
if (action == GLFW_PRESS) {
if (key == GLFW_KEY_ESCAPE) {
glfwSetWindowShouldClose(window, GLFW_TRUE);
} else if (key == GLFW_KEY_F11 || key == GLFW_KEY_ENTER && mods == GLFW_MOD_ALT) {
static int last_window_xpos, last_window_ypos;
static int last_window_width, last_window_height;
VK_CHECK(vkDeviceWaitIdle(vk.device));
GLFWmonitor* monitor = glfwGetWindowMonitor(window);
if (monitor == nullptr) {
glfwGetWindowPos(window, &last_window_xpos, &last_window_ypos);
last_window_width = window_width;
last_window_height = window_height;
monitor = glfwGetPrimaryMonitor();
const GLFWvidmode* mode = glfwGetVideoMode(monitor);
glfwSetWindowMonitor(window, monitor, 0, 0, mode->width, mode->height, mode->refreshRate);
} else {
glfwSetWindowMonitor(window, nullptr, last_window_xpos, last_window_ypos, last_window_width, last_window_height, 0);
}
}
}
}
void VCInteropWindowGetPos( int* x, int* y )
{
glfwGetWindowPos(VCWindow::Instance->GLFWWindowHandle, x, y);
}
glm::ivec2 kit::Window::getPosition()
{
glm::ivec2 returner;
glfwGetWindowPos(this->m_glfwHandle, &returner.x, &returner.y);
return returner;
}
bool positionInWindow(GLFWwindow *window, double mouseX, double mouseY) {
int windowX, windowY;
glfwGetWindowPos(window, &windowX, &windowY);
return (mouseX > 0 && mouseX < WINDOW_WIDTH) && (mouseY > 0 && mouseY < WINDOW_HEIGHT);
}
void Window::setPosition(const Vec2i& position) {
glfwSetWindowPos(handle_, position.x, position.y);
glfwGetWindowPos(handle_, &position_.x, &position_.y);
return;
}
vec2i CWindow::GetPosition() const
{
vec2i Position;
glfwGetWindowPos(WindowHandle, &Position.X, &Position.Y);
return Position;
}
void call(GLFWwindow* window, int* xpos, int* ypos) {
return glfwGetWindowPos(window, xpos, ypos);
}
int Window::GetPosY() const {
int* x = 0;
int* y = 0;
glfwGetWindowPos(window, x, y);
return (*y);
}
int main(int argc, char** argv)
{
int ch;
GLFWwindow* windows[2];
GLuint texture, program, vertex_buffer;
GLint mvp_location, vpos_location, color_location, texture_location;
srand((unsigned int) time(NULL));
glfwSetErrorCallback(error_callback);
if (!glfwInit())
exit(EXIT_FAILURE);
while ((ch = getopt(argc, argv, "d")) != -1)
{
switch (ch)
{
case 'd':
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GLFW_TRUE);
break;
}
}
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
windows[0] = glfwCreateWindow(400, 400, "First", NULL, NULL);
if (!windows[0])
{
glfwTerminate();
exit(EXIT_FAILURE);
}
glfwSetKeyCallback(windows[0], key_callback);
glfwMakeContextCurrent(windows[0]);
// Only enable vsync for the first of the windows to be swapped to
// avoid waiting out the interval for each window
glfwSwapInterval(1);
// The contexts are created with the same APIs so the function
// pointers should be re-usable between them
gladLoadGLLoader((GLADloadproc) glfwGetProcAddress);
if (GLAD_GL_KHR_debug)
{
glDebugMessageCallback(debug_callback, NULL);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL, GL_TRUE);
}
// Create the OpenGL objects inside the first context, created above
// All objects will be shared with the second context, created below
{
int x, y;
char pixels[16 * 16];
GLuint vertex_shader, fragment_shader;
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
for (y = 0; y < 16; y++)
{
for (x = 0; x < 16; x++)
pixels[y * 16 + x] = rand() % 256;
}
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, 16, 16, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, pixels);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
vertex_shader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertex_shader, 1, &vertex_shader_text, NULL);
glCompileShader(vertex_shader);
fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragment_shader, 1, &fragment_shader_text, NULL);
glCompileShader(fragment_shader);
program = glCreateProgram();
glAttachShader(program, vertex_shader);
glAttachShader(program, fragment_shader);
glLinkProgram(program);
mvp_location = glGetUniformLocation(program, "MVP");
color_location = glGetUniformLocation(program, "color");
texture_location = glGetUniformLocation(program, "texture");
vpos_location = glGetAttribLocation(program, "vPos");
glGenBuffers(1, &vertex_buffer);
glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
}
glUseProgram(program);
glUniform1i(texture_location, 0);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, texture);
glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
glEnableVertexAttribArray(vpos_location);
glVertexAttribPointer(vpos_location, 2, GL_FLOAT, GL_FALSE,
sizeof(vertices[0]), (void*) 0);
windows[1] = glfwCreateWindow(400, 400, "Second", NULL, windows[0]);
if (!windows[1])
{
glfwTerminate();
exit(EXIT_FAILURE);
}
// Place the second window to the right of the first
{
int xpos, ypos, left, right, width;
glfwGetWindowSize(windows[0], &width, NULL);
glfwGetWindowFrameSize(windows[0], &left, NULL, &right, NULL);
glfwGetWindowPos(windows[0], &xpos, &ypos);
glfwSetWindowPos(windows[1], xpos + width + left + right, ypos);
}
glfwSetKeyCallback(windows[1], key_callback);
glfwMakeContextCurrent(windows[1]);
// While objects are shared, the global context state is not and will
// need to be set up for each context
glUseProgram(program);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, texture);
glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
glEnableVertexAttribArray(vpos_location);
glVertexAttribPointer(vpos_location, 2, GL_FLOAT, GL_FALSE,
sizeof(vertices[0]), (void*) 0);
while (!glfwWindowShouldClose(windows[0]) &&
!glfwWindowShouldClose(windows[1]))
{
int i;
const vec3 colors[2] =
{
{ 0.3f, 0.4f, 1.f },
{ 0.8f, 0.4f, 1.f }
};
for (i = 0; i < 2; i++)
{
int width, height;
mat4x4 mvp;
glfwGetFramebufferSize(windows[i], &width, &height);
glfwMakeContextCurrent(windows[i]);
glViewport(0, 0, width, height);
mat4x4_ortho(mvp, 0.f, 1.f, 0.f, 1.f, 0.f, 1.f);
glUniformMatrix4fv(mvp_location, 1, GL_FALSE, (const GLfloat*) mvp);
glUniform3fv(color_location, 1, colors[i]);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glfwSwapBuffers(windows[i]);
}
glfwWaitEvents();
}
glfwTerminate();
exit(EXIT_SUCCESS);
}
Vector2i Window::getPosition()
{
int x = -1, y = -1;
glfwGetWindowPos(s_window, &x, &y);
return Vector2i(x, y);
}
int main()
{
GLFWwindow *window;
char *userptr = "userptr";
glfwSetErrorCallback(errorcb);
assert(glfwInit() == GL_TRUE);
assert(!strcmp(glfwGetVersionString(), "3.2.1 JS WebGL Emscripten"));
assert(glfwGetCurrentContext() == NULL);
{
int major, minor, rev;
glfwGetVersion(&major, &minor, &rev);
assert(major == 3);
assert(minor == 2);
assert(rev == 1);
}
{
int count, x, y, w, h;
GLFWmonitor **monitors = glfwGetMonitors(&count);
assert(count == 1);
for (int i = 0; i < count; ++i) {
assert(monitors[i] != NULL);
}
assert(glfwGetPrimaryMonitor() != NULL);
glfwGetMonitorPos(monitors[0], &x, &y);
glfwGetMonitorPhysicalSize(monitors[0], &w, &h);
assert(glfwGetMonitorName(monitors[0]) != NULL);
glfwSetMonitorCallback(monitcb);
// XXX: not implemented
// assert(glfwGetVideoModes(monitors[0], &count) != NULL);
// assert(glfwGetVideoMode(monitors[0]) != NULL);
// glfwSetGamma(monitors[0], 1.0f);
// assert(glfwGetGammaRamp(monitors[0]) != NULL);
// glfwSetGammaRamp(monitors[0], ramp);
}
{
int x, y, w, h;
glfwDefaultWindowHints();
glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
window = glfwCreateWindow(640, 480, "glfw3.c", NULL, NULL);
assert(window != NULL);
glfwSetWindowPosCallback(window, wposicb);
glfwSetWindowSizeCallback(window, wsizecb);
glfwSetWindowCloseCallback(window, wcloscb);
glfwSetWindowRefreshCallback(window, wrfrscb);
glfwSetWindowFocusCallback(window, wfocucb);
glfwSetWindowIconifyCallback(window, wiconcb);
glfwSetFramebufferSizeCallback(window, wfsizcb);
assert(glfwWindowShouldClose(window) == 0);
glfwSetWindowShouldClose(window, 1);
assert(glfwWindowShouldClose(window) == 1);
glfwSetWindowTitle(window, "test");
glfwSetWindowTitle(window, "glfw3.c");
// XXX: not implemented
// glfwSetWindowPos(window, 1, 1);
glfwGetWindowPos(window, &x, &y); // stub
glfwGetWindowSize(window, &w, &h);
assert(w == 640 && h == 480);
glfwSetWindowSize(window, 1, 1);
glfwGetWindowSize(window, &w, &h);
assert(w == 1 && h == 1);
glfwSetWindowSize(window, 640, 480);
glfwGetFramebufferSize(window, &w, &h);
// XXX: not implemented
// glfwIconifyWindow(window);
// glfwRestoreWindow(window);
// glfwShowWindow(window);
// glfwHideWindow(window);
assert(glfwGetWindowMonitor(window) == NULL);
glfwDestroyWindow(window);
window = glfwCreateWindow(640, 480, "glfw3.c", glfwGetPrimaryMonitor(), NULL);
assert(window != NULL);
assert(glfwGetWindowMonitor(window) == glfwGetPrimaryMonitor());
glfwDestroyWindow(window);
window = glfwCreateWindow(640, 480, "glfw3.c", NULL, NULL);
assert(window != NULL);
assert(glfwGetWindowAttrib(window, GLFW_CLIENT_API) == GLFW_OPENGL_ES_API);
assert(glfwGetWindowUserPointer(window) == NULL);
glfwSetWindowUserPointer(window, userptr);
assert(glfwGetWindowUserPointer(window) == userptr);
}
{
double x, y;
glfwSetKeyCallback(window, wkeypcb);
glfwSetCharCallback(window, wcharcb);
glfwSetMouseButtonCallback(window, wmbutcb);
glfwSetCursorPosCallback(window, wcurpcb);
glfwSetCursorEnterCallback(window, wcurecb);
glfwSetScrollCallback(window, wscrocb);
// XXX: stub, events come immediatly
// glfwPollEvents();
// glfwWaitEvents();
assert(glfwGetInputMode(window, GLFW_CURSOR) == GLFW_CURSOR_NORMAL);
// XXX: not implemented
// glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
glfwGetKey(window, GLFW_KEY_A);
glfwGetMouseButton(window, 0);
glfwGetCursorPos(window, &x, &y);
// XXX: not implemented
// glfwSetCursorPos(window, 0, 0);
}
{
// XXX: not implemented
// glfwJoystickPresent(joy);
// glfwGetJoystickAxes(joy, &count);
// glfwGetJoystickButtons(joy, &count);
// glfwGetJoystickName(joy);
}
{
// XXX: not implemented
// glfwSetClipboardString(window, "string");
// glfwGetClipboardString(window);
}
{
glfwGetTime();
glfwSetTime(0);
}
{
glfwMakeContextCurrent(window); // stub
assert(glfwGetCurrentContext() == window);
glfwSwapBuffers(window); // stub
glfwSwapInterval(0); // stub
}
{
assert(glfwExtensionSupported("nonexistant") == 0);
assert(glfwGetProcAddress("nonexistant") == NULL);
}
glfwTerminate();
#ifdef REPORT_RESULT
REPORT_RESULT(1);
#endif
return 0;
}
