/*!
Key action eventhandler sets the modifier key state & forewards the event to
the slKeyPress function.
*/
static void onKeyAction(GLFWwindow* window, int GLFWKey, int scancode, int action, int mods)
{
SLKey key = mapKeyToSLKey(GLFWKey);
if (action==GLFW_PRESS)
{ switch (key)
{ case KeyCtrl: modifiers = (SLKey)(modifiers|KeyCtrl); return;
case KeyAlt: modifiers = (SLKey)(modifiers|KeyAlt); return;
case KeyShift: modifiers = (SLKey)(modifiers|KeyShift); return;
}
} else
if (action==GLFW_RELEASE)
{ switch (key)
{ case KeyCtrl: modifiers = (SLKey)(modifiers&~KeyCtrl); return;
case KeyAlt: modifiers = (SLKey)(modifiers&~KeyAlt); return;
case KeyShift: modifiers = (SLKey)(modifiers&~KeyShift); return;
}
}
// Special treatment for ESC key
if (key == KeyEsc && action==GLFW_RELEASE)
{
if (fullscreen)
{ fullscreen = !fullscreen;
glfwSetWindowSize(window, scrWidth, scrHeight);
glfwSetWindowPos(window, 10, 30);
} else
if (slKeyPress(svIndex, key, modifiers)) // ESC during RT stops it and returns false
{ onClose(window);
glfwSetWindowShouldClose(window, GL_TRUE);
}
} else
// Toggle fullscreen mode
if (key == KeyF9 && action==GLFW_PRESS)
{
fullscreen = !fullscreen;
if (fullscreen )
{ GLFWmonitor* primary = glfwGetPrimaryMonitor();
const GLFWvidmode* mode = glfwGetVideoMode(primary);
glfwSetWindowSize(window, mode->width, mode->height);
glfwSetWindowPos(window, 0, 0);
} else
{ glfwSetWindowSize(window, scrWidth, scrHeight);
glfwSetWindowPos(window, 10, 30);
}
} else
{
if (action==GLFW_PRESS)
slKeyPress(svIndex, key, modifiers);
else if (action==GLFW_RELEASE)
slKeyRelease(svIndex, key, modifiers);
}
}
static int luaWindow_set_position(lua_State* L){
auto window = reinterpret_cast<GLFWwindow*>(lua_touserdata(L, lua_upvalueindex(1)));
int x = lua_tointeger(L, 1);
int y = lua_tointeger(L, 2);
glfwSetWindowPos(window, x, y);
return 0;
}
//vec2 cur;
void initgl()
{
glfwInit();
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
glfwWindowHint(GLFW_SAMPLES, 4);
window = glfwCreateWindow(screenWidth, screenHeight, "LearnOpenGL", nullptr, nullptr); // Windowed
glfwMakeContextCurrent(window);
// Set the required callback functions
glfwSetKeyCallback(window, key_callback);
#ifndef RAWMOUSE
glfwSetCursorPosCallback(window, mouse_callback);
#endif
glfwSetScrollCallback(window, scroll_callback);
// Options
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
// Initialize GLEW to setup the OpenGL Function pointers
glewExperimental = GL_TRUE;
glewInit();
// Define the viewport dimensions
glViewport(0, 0, screenWidth, screenHeight);
// Setup some OpenGL options
glEnable(GL_DEPTH_TEST);
glfwSetWindowPos(window, 780, 280);
}
void Graphics::SetWindowPosition(const IntVector2& position)
{
if(window2_)
glfwSetWindowPos(window2_,position.x_, position.y_);
else
position_ = position; // Sets as initial position for OpenWindow()
}
void Display::Create(const std::string& title, int width, int height)
{
s_title = title;
s_width = width;
s_height = height;
glfwSetErrorCallback(error_callback);
if (!glfwInit())
{
std::cerr << "GLFW failed to initialize!" << std::endl;
Destroy();
exit(1);
}
glfwDefaultWindowHints();
glfwWindowHint(GLFW_VISIBLE, GL_FALSE);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
s_pWindow = glfwCreateWindow(width, height, title.c_str(), NULL, NULL);
const GLFWvidmode* vidmode = glfwGetVideoMode(glfwGetPrimaryMonitor());
glfwSetWindowPos(s_pWindow, (vidmode->width - width) / 2, (vidmode->height - height) / 2);
glfwMakeContextCurrent(s_pWindow);
if (glewInit() != GLEW_OK)
{
std::cerr << "GLEW failed to initialize!" << std::endl;
exit(1);
}
glfwShowWindow(s_pWindow);
}
//----------
void ofxSplashScreen::begin(float minimumDuration) {
if (!this->image.isAllocated()) {
ofLogError("ofxSplashScreen") << "Cannot show splash screen since no image has been loaded";
return;
}
this->endTime = ofGetElapsedTimef() + minimumDuration;
this->appWindow = glfwGetCurrentContext();
glfwHideWindow(this->appWindow);
glfwWindowHint(GLFW_DECORATED, GL_FALSE);
this->splashScreenWindow = glfwCreateWindow(this->image.getWidth(), this->image.getHeight(), "ofxSplashScreen", NULL, this->appWindow);
glfwSetWindowPos(this->splashScreenWindow, (ofGetScreenWidth() - this->image.getWidth()) / 2.0f, (ofGetScreenHeight() - this->image.getHeight()) / 2.0f);
glfwWindowHint(GLFW_DECORATED, GL_TRUE);
glfwMakeContextCurrent(this->splashScreenWindow);
//set the drawing matrices to normalised coordinates
ofSetMatrixMode(OF_MATRIX_PROJECTION);
ofLoadIdentityMatrix();
ofSetMatrixMode(OF_MATRIX_MODELVIEW);
ofLoadIdentityMatrix();
//draw the images
ofClear(0,0,0);
this->image.update();
this->image.draw(-1,-1,2,2);
glfwSwapBuffers(this->splashScreenWindow);
glFlush();
//set the context back to main for rest of setup
glfwMakeContextCurrent(this->appWindow);
ofSetupScreen();
}
int sp_init_glfw(t_env *e)
{
glfwSetErrorCallback(error_callback);
glfwInit();
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
glfwWindowHint(GLFW_SAMPLES, 2);
#ifdef MAC_OS_MODE
glfwWindowHint(GLFW_DOUBLEBUFFER, GL_TRUE);
#endif
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
glfwWindowHint(GLFW_OPENGL_PROFILE, OPENGL_PROFILE);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
e->win = glfwCreateWindow(WIN_WIDTHI, WIN_HEIGHTI, "Scop", NULL, NULL);
if (!e->win)
{
glfwTerminate();
return (ERROR("glfwCreateWindow"));
}
#ifndef MAC_OS_MODE
glfwSetWindowPos(e->win, 1000, 0);
#endif
glfwSetWindowFocusCallback(e->win, &focus_callback);
glfwSetKeyCallback(e->win, key_callback);
glfwMakeContextCurrent(e->win);
if (!INIT_GLEW)
return (ERROR("glewInit()"));
glViewport(0, 0, WIN_WIDTHI, WIN_HEIGHTI);
glEnable(GL_DEPTH_TEST);
return (0);
}
void VogueWindow::InitializeWindowContext(GLFWwindow* window)
{
/* Window resize callback */
glfwSetWindowSizeCallback(window, WindowResizeCallback);
/* Window close message callback */
glfwSetWindowCloseCallback(window, WindowCloseCallback);
/* Input callbacks */
glfwSetKeyCallback(window, KeyCallback);
glfwSetCharCallback(window, CharacterCallback);
glfwSetMouseButtonCallback(window, MouseButtonCallback);
glfwSetScrollCallback(window, MouseScrollCallback);
/* Center on screen */
const GLFWvidmode* vidmode = glfwGetVideoMode(glfwGetPrimaryMonitor());
glfwGetWindowSize(window, &m_windowWidth, &m_windowHeight);
glfwSetWindowPos(window, (vidmode->width - m_windowWidth) / 2, (vidmode->height - m_windowHeight) / 2);
/* Make the window's context current */
glfwMakeContextCurrent(window);
glfwSwapInterval(m_pVogueSettings->m_vsync);
/* Force resize */
WindowResizeCallback(window, m_windowWidth, m_windowHeight);
/* Show the window */
glfwShowWindow(window);
}
static void setGraphics(int w, int h)
{
glfwSetWindowSize(w, h);
GLFWvidmode desktopMode;
glfwGetDesktopMode( &desktopMode );
glfwSetWindowPos( (desktopMode.Width-w)/2,(desktopMode.Height-h)/2 );
}
Init() {
if(!glfwInit()) {
std::cerr << "\nCould not initialize glfw!";
return;
}
glfwOpenWindowHint(GLFW_WINDOW_NO_RESIZE, true);
if(!glfwOpenWindow(screenSizeX, screenSizeY, 8, 8, 8, 8, 8, 8, GLFW_WINDOW)) {
std::cerr << "\nCould not open the window!";
glfwTerminate();
return;
}
glfwSetWindowTitle("Colorful Game of Life");
glfwSetWindowPos(350, 150);
glfwSwapInterval(0);
glfwSetTime(0);
if(gl3wInit() != 0) {
std::cerr << "\nCould not initialize gl3w!";
glfwTerminate();
return;
}
}
GLPresenter::GLPresenter(DeckLinkCapture &capture, int w, int h, int hz) :
data_size(w*h*2),
capture(capture), running(true), fullscreen(false), useVsync(false), rgbFull(false),
texId(0), displayList(0),
convertUYVY(NULL),
buffer(NULL), buffer2(NULL),
reqW(w), reqH(h), reqHz(hz),
frameIndex(0), drawnFrameIndex(0), aspect(16.0/9.0), oneToNScaleFactor(-1.0)
{
self = this;
sprintf(prepend, "#define FRAME_WIDTH %d\n#define FRAME_HEIGHT %d\n", reqW, reqH);
RT_ASSERT(glfwInit() == GL_TRUE, "Failed to initalize GLFW.");
RT_ASSERT(glfwOpenWindow(w, h, 0, 0, 0, 0, 0, 0, GLFW_WINDOW) == GL_TRUE, "Failed to open GLFW window.");
string title("PtBi ");
title += VER_STRING;
glfwSetWindowTitle(title.c_str());
glfwSetWindowPos(10, 10);
dataPointers[0] = malloc(data_size);
dataPointers[1] = malloc(data_size);
glewInit();
checkExtensions();
ilInit();
glfwDisable(GLFW_AUTO_POLL_EVENTS);
glfwSwapInterval(0);
glfwSetWindowCloseCallback(closeCallback);
glfwSetWindowSizeCallback(resizeCallback);
glfwSetMousePosCallback(mousePosCallback);
glfwSetKeyCallback(keyCallback);
hdc = wglGetCurrentDC();
hrc = wglGetCurrentContext();
initGL();
convertUYVY = new GLFragmentProgram("shaders/uyvy_to_rgb_smooth.glsl", getShaderPrependString());
buffer = new GLRenderTexture(getW(), getH(), GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE);
buffer->setFilterMode(GL_LINEAR);
buffer2 = new GLRenderTexture(getW(), getH(), GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE);
buffer2->setFilterMode(GL_LINEAR);
scalingManager = new ScalingManager(*this);
aaManager = new AAManager(*this);
ipManager = new IPManager(*this);
keyBinding = new KeyBinding(this);
capture.registerDisplayListener(this);
hwnd = GetForegroundWindow();
RT_GL_ASSERT("Error during GL initialization.");
reshape(reqW, reqH);
}
void drawSplashScreen(const std::string &filename){
if(splashScreen.ID) gl::DeleteTextures(1, &splashScreen.ID);
else {
ResourceLoader loader;
loader.reloadShader("ApplyFBO");
splashScreen = loader.loadImage(filename);
glfwShowWindow(Global::main.window);
glfwSetWindowPos(Global::main.window, Global::main.screenSize.x/2.f - splashScreen.width/2, Global::main.screenSize.y/2.f - splashScreen.height/2);
glfwSetWindowSize(Global::main.window, splashScreen.width, splashScreen.height);
}
gl::Viewport(0, 0, splashScreen.width, splashScreen.height);
gl::ClearColor(0.f, 0.f, 0.f, 0.f);
gl::Clear(gl::COLOR_BUFFER_BIT);
gl::DepthMask(gl::FALSE_);
gl::Enable(gl::BLEND);
gl::BlendFunc(gl::SRC_ALPHA, gl::ONE_MINUS_SRC_ALPHA);
gl::BindBuffer(gl::ARRAY_BUFFER, 0);
gl::DisableVertexAttribArray(0);
gl::BindFramebuffer(gl::DRAW_FRAMEBUFFER, 0);
auto shader = assets::getShader("ApplyFBO");
shader.bind();
float width = Global::main.size.x;
float height = Global::main.size.y;
shader.texture("uTexture", splashScreen.ID);
drawScreen();
glfwSwapBuffers(Global::main.window);
CHECK_FOR_ERRORS
}
int main() {
glfwSetErrorCallback(error_callback);
if (!glfwInit())
return -1;
glfwDefaultWindowHints();
glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
window = glfwCreateWindow(WIDTH, HEIGHT, "", NULL, NULL);
if (!window) {
glfwTerminate();
return -1;
}
glfwSetKeyCallback(window, key_callback);
glfwSetMouseButtonCallback(window, mouse_callback);
const GLFWvidmode* vidmode = glfwGetVideoMode(glfwGetPrimaryMonitor());
glfwSetWindowPos(window, (vidmode->width - WIDTH) / 2, (vidmode->height - HEIGHT) / 2);
glfwMakeContextCurrent(window);
glfwSwapInterval(1);
glfwShowWindow(window);
loop();
glfwDestroyWindow(window);
glfwTerminate();
return 0;
}
/*! This function initializes CX functionality. It should probably only be called once, at program start.
\param config The intial CX configuration.
\return `true` if intialization was successful, `false` if there was an error. If there was an error, it should be logged.
*/
bool initializeCX(CX_InitConfiguation config) {
if (config.clockPrecisionTestIterations < 10000) {
config.clockPrecisionTestIterations = 10000;
}
#if OF_VERSION_MAJOR == 0 && OF_VERSION_MINOR == 9 && OF_VERSION_PATCH >= 0
ofInit();
#else //Older versions...
ofSetWorkingDirectoryToDefault();
#endif
ofSetEscapeQuitsApp(false);
CX::Instances::Log.captureOFLogMessages(config.captureOFLogMessages);
CX::Instances::Log.levelForAllModules(CX_Logger::Level::LOG_ALL);
CX::Instances::Log.levelForModule(CX_Logger::Level::LOG_NOTICE, "ofShader"); //Try to eliminate some of the verbose shader gobbeldygook.
CX::Private::learnOpenGLVersion(); //Should come before reopenWindow.
bool openedSucessfully = CX::reopenWindow(config.windowConfig); //or for the first time.
if (!openedSucessfully) {
CX::Instances::Log.error("CX_EntryPoint") << "The window was not opened successfully.";
} else {
// Set up the clock
CX::Instances::Clock.setup(nullptr, true, config.clockPrecisionTestIterations);
CX::Instances::Input.pollEvents(); //Do this so that the window is at least minimally responding and doesn't get killed by the OS.
//This must happen after the window is configured because it relies on GLFW.
if (config.framePeriodEstimationInterval != CX_Millis(0)) {
CX::Instances::Disp.estimateFramePeriod(config.framePeriodEstimationInterval);
CX::Instances::Log.notice("CX_EntryPoint") << "Estimated frame period for display: " << CX::Instances::Disp.getFramePeriod().millis() << " ms.";
}
setupKeyboardShortcuts();
// Set up sound
CX::Instances::SoundPlayer.setup(&CX::Instances::SoundStream);
CX::Instances::SoundRecorder.setup(&CX::Instances::SoundStream);
//This is temporary: I think there's an oF bug about it
#if OF_VERSION_MAJOR == 0 && OF_VERSION_MINOR == 8
glfwSetWindowPos(CX::Private::glfwContext, 200, 200);
#endif
}
CX::Instances::Log.verbose() << endl << endl << "### End of startup logging data ###" << endl << endl;
CX::Instances::Log.flush(); //Flush logs after setup, so user can see if any errors happened during setup.
CX::Instances::Log.levelForAllModules(CX_Logger::Level::LOG_NOTICE);
CX::Instances::Log.levelForModule(CX_Logger::Level::LOG_WARNING, "ofFbo"); //It isn't clear that this should be here, but the fbos
//are really verbose when allocated and it is a lot of gibberish.
return openedSucessfully;
}
void Screen::Open(uint16 width, uint16 height, bool fullscreen) {
// Abrimos la ventana
glfwOpenWindowHint(GLFW_WINDOW_NO_RESIZE, GL_TRUE);
glfwOpenWindow(int(width), int(height), 8, 8, 8, 8, 0, 0, fullscreen ? GLFW_FULLSCREEN : GLFW_WINDOW );
if ( !fullscreen )
glfwSetWindowPos((GetDesktopWidth()-width)/2, (GetDesktopHeight()-height)/2);
glfwSetWindowCloseCallback(GLFWwindowclosefun(CloseCallback));
glfwSwapInterval(1);
SetTitle("");
opened = true;
// Inicializamos OpenGL
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
// Configuramos viewport
glViewport(0,0,width,height);
this->width = width;
this->height = height;
// Configuramos matriz de proyeccion
glMatrixMode(GL_PROJECTION);
glOrtho(0,width,height,0,0,1000);
// Configuramos matriz de modelado
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// Inicializamos temporizador
lastTime = glfwGetTime();
elapsed = 0;
}
// --------------------------------------------------------------------------------------------------------------------
void window::position(int x, int y)
{
if (is_open())
{
glfwSetWindowPos(_internal->_window, x, y);
}
}
int main(void)
{
int i, result;
Thread threads[] =
{
{ NULL, "Red", 1.f, 0.f, 0.f, 0 },
{ NULL, "Green", 0.f, 1.f, 0.f, 0 },
{ NULL, "Blue", 0.f, 0.f, 1.f, 0 }
};
const int count = sizeof(threads) / sizeof(Thread);
if (!glfwInit())
{
fprintf(stderr, "Failed to initialize GLFW: %s\n",
glfwErrorString(glfwGetError()));
exit(EXIT_FAILURE);
}
for (i = 0; i < count; i++)
{
threads[i].window = glfwCreateWindow(200, 200,
GLFW_WINDOWED,
threads[i].title,
NULL);
if (!threads[i].window)
{
fprintf(stderr, "Failed to open GLFW window: %s\n",
glfwErrorString(glfwGetError()));
exit(EXIT_FAILURE);
}
glfwSetWindowPos(threads[i].window, 200 + 250 * i, 200);
if (thrd_create(&threads[i].id, thread_main, threads + i) !=
thrd_success)
{
fprintf(stderr, "Failed to create secondary thread\n");
exit(EXIT_FAILURE);
}
}
while (running)
{
assert(glfwGetCurrentContext() == NULL);
glfwWaitEvents();
for (i = 0; i < count; i++)
{
if (glfwGetWindowParam(threads[i].window, GLFW_CLOSE_REQUESTED))
running = GL_FALSE;
}
}
for (i = 0; i < count; i++)
thrd_join(threads[i].id, &result);
exit(EXIT_SUCCESS);
}
void Window::updateWindowShape()
{
if (_screenId == -1)
{
glfwSetWindowPos(_window->get(), _windowRect[0], _windowRect[1]);
glfwSetWindowSize(_window->get(), _windowRect[2], _windowRect[3]);
}
}
void ctx_fullscreen(struct context *ctx)
{
glfwSetWindowPos(ctx->win, 0, 0);
glfwSetWindowSize(ctx->win, ctx->vidmode->width, ctx->vidmode->height);
ctx->winw = ctx->vidmode->width;
ctx->winh = ctx->vidmode->height;
}
void resize( int x, int y )
{
w = (x <= 0 ? 0 : x);
h = (y <= 0 ? 1 : y);
glfwSetWindowSize( window, w, h );
glfwSetWindowPos( window, ( screen_w - w ) / 2, ( screen_h - h ) / 2 );
}
/////////////////////////////////////////////////////////
// offsetMess
//
/////////////////////////////////////////////////////////
void gemglfw2window :: offsetMess(int x, int y)
{
m_xoffset = x;
m_yoffset = y;
if(makeCurrent()){
glfwSetWindowPos(x, y);
}
}
int main(void)
{
int i, result;
Thread threads[] =
{
{ NULL, "Red", 1.f, 0.f, 0.f, 0 },
{ NULL, "Green", 0.f, 1.f, 0.f, 0 },
{ NULL, "Blue", 0.f, 0.f, 1.f, 0 }
};
const int count = sizeof(threads) / sizeof(Thread);
glfwSetErrorCallback(error_callback);
if (!glfwInit())
exit(EXIT_FAILURE);
glfwWindowHint(GLFW_VISIBLE, GL_FALSE);
for (i = 0; i < count; i++)
{
threads[i].window = glfwCreateWindow(200, 200,
threads[i].title,
NULL, NULL);
if (!threads[i].window)
{
glfwTerminate();
exit(EXIT_FAILURE);
}
glfwSetWindowPos(threads[i].window, 200 + 250 * i, 200);
glfwShowWindow(threads[i].window);
if (thrd_create(&threads[i].id, thread_main, threads + i) !=
thrd_success)
{
fprintf(stderr, "Failed to create secondary thread\n");
glfwTerminate();
exit(EXIT_FAILURE);
}
}
while (running)
{
glfwWaitEvents();
for (i = 0; i < count; i++)
{
if (glfwWindowShouldClose(threads[i].window))
running = GL_FALSE;
}
}
for (i = 0; i < count; i++)
thrd_join(threads[i].id, &result);
exit(EXIT_SUCCESS);
}
JNIEXPORT void JNICALL Java_com_badlogic_jglfw_Glfw_glfwSetWindowPos(JNIEnv* env, jclass clazz, jlong window, jint x, jint y) {
//@line:740
glfwSetWindowPos((GLFWwindow*)window, x, y);
}
void* LinuxWindowImpl::create(const WindowSettings& settings)
{
ensureGLFWInit();
GLFWwindow* wndwHandle;
glfwWindowHint(GLFW_ALPHA_BITS, settings.useBlending ? 8 : 0);
glfwWindowHint(GLFW_DEPTH_BITS, settings.useDepthBuffer ? 16 : 0);
glfwWindowHint(GLFW_STENCIL_BITS, settings.useStencilBuffer ? 8 : 0);
glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_API);
int majorVer = settings.contextVersionMajor == 0 ? 4 : settings.contextVersionMajor,
minorVer = settings.contextVersionMajor == 0 ? 4 : settings.contextVersionMinor;
do
{
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, majorVer);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, minorVer);
wndwHandle = glfwCreateWindow(settings.size.w, settings.size.h, settings.title.c_str(), settings.fullScreen ? glfwGetPrimaryMonitor() : NULL, NULL);
if (--minorVer < 0)
{
--majorVer;
minorVer = 9;
}
} while (!wndwHandle && majorVer > 0);
if (!wndwHandle)
{
std::cout << "Failed to create an OpenGL context! Exiting..." <<std::endl;
std::exit(EXIT_FAILURE);
}
++windowRefs;
glfwMakeContextCurrent(wndwHandle);
glfwSetWindowPos(wndwHandle, settings.position.x, settings.position.y);
glfwSwapInterval(settings.useVsync ? 1 : 0);
std::cout << "glew init might produces GL_INVALID_ENUM error. Just ignore it" << std::endl;
glewExperimental = GL_TRUE;
oglCheck(glewInit());
if(majorVer >= 3)
{
GLuint vertexArray;
glGenVertexArrays(1, &vertexArray);
glBindVertexArray(vertexArray);
}
return static_cast<void*>(wndwHandle);
}
virtual void SetUp(void) {
glfwInit();
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE);
window = glfwCreateWindow(TEST_WIDTH, TEST_HEIGHT, "gtest", nullptr, nullptr);
glfwSetWindowPos(window, 300, 300);
glfwMakeContextCurrent(window);
ASSERT_EQ(GLEW_OK, glewInit());
PHYSFS_init("gtest");
PHYSFS_addToSearchPath("data", true);
}
/* do__set_window_position
*
* opengl-client.api type: { session: Session, x: Int, y: Int } -> Void
* opengl-client-driver.api type: (Session, Int, Int) -> Void
*/
static Val do__set_window_position (Task* task, Val arg)
{
int i0 = GET_TUPLE_SLOT_AS_INT( arg, 1);
int i1 = GET_TUPLE_SLOT_AS_INT( arg, 2);
glfwSetWindowPos( /*x*/i0, /*y*/i1 );
return HEAP_VOID;
}
int Init(bool a_bSetFullScreen, unsigned int a_uiWidth, unsigned int a_uiHeight, int a_uiPosX, int a_uiPosY)
{
Monitor = glfwGetMonitors(aiNumOfMonitors);
Mode = glfwGetVideoMode(Monitor[0]);
glfwWindowHint(GLFW_RED_BITS, Mode->redBits);
glfwWindowHint(GLFW_GREEN_BITS, Mode->greenBits);
glfwWindowHint(GLFW_BLUE_BITS, Mode->blueBits);
glfwWindowHint(GLFW_REFRESH_RATE, Mode->refreshRate);
if (a_bSetFullScreen)
Window = glfwCreateWindow(Mode->width, Mode->height, "The Solar System", Monitor[0], nullptr);
else
{
Window = glfwCreateWindow(a_uiWidth, a_uiHeight, "The Solar System", nullptr, nullptr);
if (a_uiPosX == -1)
a_uiPosX = (Mode->width - a_uiWidth) / 2;
if (a_uiPosY == -1)
a_uiPosY = (Mode->height - a_uiHeight) / 2;
glfwSetWindowPos(Window, a_uiPosX, a_uiPosY);
}
if (Window == nullptr)
{
glfwTerminate();
return -2;
}
//make the glfw window
glfwMakeContextCurrent(Window);
if (ogl_LoadFunctions() == ogl_LOAD_FAILED)
{
glfwDestroyWindow(Window);
glfwTerminate();
return -3;
}
// Parses the version of OpenGL and prints it
auto major = ogl_GetMajorVersion();
auto minor = ogl_GetMinorVersion();
printf_s("GL: %i.%i\n", major, minor);
//initialize all of our gizmos and set up the virtual camera
Gizmos::create();
SetView({ 10, 0, 0 }, { 0, 0, 0 }, { 0, 1, 0 });
Projection = glm::perspective(glm::pi<float>() * 0.25f, 16 / 9.f, 0.001f, 1000.f);
glClearColor(0.5f, 0.5f, 0.5f, 1);//set the clear color
glEnable(GL_DEPTH_TEST); // enables the depth buffer
return 0;
}
// width, height 生成時のサイズ
// full_screen true: フルスクリーン
// dynamic_size true: ウインドウサイズにあわせて画面を変更
AppEnv::AppEnv(const int width, const int height,
const bool full_screen, const bool dynamic_size) :
dynamic_window_size_(dynamic_size),
window_(width, height, false, full_screen),
window_size_(width, height),
current_window_size_(window_size_),
viewport_ofs_(0, 0),
viewport_size_(width, height),
bg_color_(0, 0, 0, 0),
key_page_(0),
mouse_left_press_(false),
mouse_right_press_(false),
mouse_pos_(0, 0),
mouse_last_pos_(0, 0),
mouse_current_pos_(0, 0),
buttons_page_(0)
{
DOUT << "AppEnv()" << std::endl;
// Windowを画面の中央へ移動
const auto* video_mode = glfwGetVideoMode(glfwGetPrimaryMonitor());
glfwSetWindowPos(window_(), (video_mode->width - width) / 2, (video_mode->height - height) / 2);
// GLFWのハンドルに自分自身を登録
glfwSetWindowUserPointer(window_(), this);
// ウインドウのサイズ変更
glfwSetWindowSizeCallback(window_(), changeWindowSize);
// キーが押された時に呼ばれる関数を登録
glfwSetCharCallback(window_(), createCharaInfo);
glfwSetKeyCallback(window_(), createKeyInfo);
// マウスイベント
glfwSetMouseButtonCallback(window_(), mouseButtonCallback);
glfwSetCursorPosCallback(window_(), mouseMoveCallback);
// GamePad
gamepads_ = initGamePad();
glEnable(GL_POINT_SMOOTH);
glEnable(GL_LINE_SMOOTH);
// Windowの表示開始
glfwShowWindow(window_());
if (full_screen) {
// フルスクリーンはモニタによって解像度がまちまちなので、viewportで補正
int width, height;
glfwGetFramebufferSize(window_(), &width, &height);
DOUT << "framebuffer size:" << width << "," << height << std::endl;
dynamicViewport(width, height);
}
}
int PCRender::Init(SWindow *win) {
GLint vpos_loc, tbuf_loc;
m_sWindow = win;
if (m_iWidth * m_iHeight > 0) {
glfwSetWindowSize(m_sWindow, m_iWidth, m_iHeight);
GLFWvidmode *mode = (GLFWvidmode*)glfwGetVideoMode(glfwGetPrimaryMonitor());
glfwSetWindowPos(m_sWindow, (mode->width-m_iWidth)/2, (mode->height-m_iHeight)/2);
}
glfwMakeContextCurrent(m_sWindow);
gladLoadGLLoader((GLADloadproc)glfwGetProcAddress);
glGenBuffers(1, &m_vertexBuffer);
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
m_shaderProgram = MakeShaderProgram(vs, fs);
if (m_shaderProgram == 0u) {
return -1;
}
vpos_loc = glGetAttribLocation(m_shaderProgram , "vertexIn");
glEnableVertexAttribArray(vpos_loc);
glVertexAttribPointer(vpos_loc, 2, GL_FLOAT, GL_FALSE,
sizeof(float) * 4, (void*) 0);
tbuf_loc = glGetAttribLocation(m_shaderProgram , "textureIn");
glEnableVertexAttribArray(tbuf_loc);
glVertexAttribPointer(tbuf_loc, 2, GL_FLOAT, GL_FALSE,
sizeof(float) * 4, (void*) (sizeof(float) * 2));
//Init Texture
glGenTextures(3, m_textures);
glBindTexture(GL_TEXTURE_2D, m_textures[0]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_2D, m_textures[1]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_2D, m_textures[2]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glfwMakeContextCurrent(NULL);
return 0;
}
int main(int argc, char **argv){
t = 0.;
glfwInit();
/* glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3); */
/* glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 2); */
/* glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); */
glfwOpenWindow(500,500,0,0,0,0,0,0,GLFW_WINDOW);
glfwSetWindowPos(50,100);
glfwSetWindowTitle("halfshadow triangle");
createshader();
glfwSwapInterval(1);
glClearColor(0.,0.,0.5,1.); /* blue background */
create_VBO();
/* prepare_rectangle(); */
while(glfwGetWindowParam(GLFW_OPENED)){
glClear(GL_COLOR_BUFFER_BIT);
glUseProgram(shader_program);
univar = sin(4.*t);
/* this is called after glUseProgram() is called. */
uniID = glGetUniformLocation(shader_program,"uniID");
glUniform1f(uniID,univar);
glUniform3f(glGetUniformLocation(shader_program,"uniform2"),sin(3.*t),sin(t),cos(t));
int index = glGetAttribLocation(shader_program,"myatr");
glVertexAttrib3f(index,1.,0.,0.);
time_evolution_triangle();
draw_VBO();
glfwSwapBuffers();
}
glfwTerminate();
return 0;
}
