int main(int argc, char * arg[])
{
//Controls the game loop
bool run=true;
// init everyting - SDL, if it is nonzero we have a problem
if(SDL_Init(SDL_INIT_EVERYTHING) != 0)
{
std::cout << "ERROR SDL_Init " <<SDL_GetError()<< std::endl;
return -1;
}
//Request opengl 4.1 context, Core Context
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK,SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
//Create a window
SDL_Window * window = SDL_CreateWindow(
"SDL", // window title
SDL_WINDOWPOS_CENTERED, // x position, centered
SDL_WINDOWPOS_CENTERED, // y position, centered
640, // width, in pixels
480, // height, in pixels
SDL_WINDOW_OPENGL // flags
);
// Create an OpenGL context associated with the window.
SDL_GLContext glcontext = SDL_GL_CreateContext(window);
//Call our InitOpenGL Function
initOpenGL();
//Set our viewport
setViewport(640,480);
initScene();
//Value to hold the event generated by SDL
SDL_Event event;
//Game Loop
while(run)
{
//While we still have events in the queue
while (SDL_PollEvent(&event)) {
//Get event type
if (event.type == SDL_QUIT || event.type == SDL_WINDOWEVENT_CLOSE) {
//set our boolean which controls the loop to false
run = false;
}
if (event.type==SDL_KEYDOWN){
switch( event.key.keysym.sym )
{
case SDLK_LEFT:
break;
case SDLK_RIGHT:
break;
case SDLK_UP:
break;
case SDLK_DOWN:
break;
default:
break;
}
}
}
//init Scene
update();
//render
render();
//Call swap so that our GL back buffer is displayed
SDL_GL_SwapWindow(window);
}
// clean up, reverse order!!!
cleanUp();
SDL_GL_DeleteContext(glcontext);
SDL_DestroyWindow(window);
SDL_Quit();
return 0;
}
//Program entry point
int main(int argc, char *argv[])
{
UNUSED(argc);
UNUSED(argv);
//paths required by platform code
platform::app_code.app_dll_path = "App.dll";
platform::app_state.record_file = "input.smi";
//Load the application dll
platform_load_app_code(&platform::app_code);
//initialize sdl
if (SDL_Init(SDL_INIT_EVERYTHING) < 0)
{
std::cerr << ERROR_LINE << "SDL Error: Unable to initialize SDL" << std::endl;
}
else
{
std::cout << "SDL initialized"<<std::endl;
}
//SDL version
{
SDL_version ver;
SDL_VERSION(&ver);
std::cout << "SDL version " << (int)ver.major << "." << (int)ver.minor << "." << (int)ver.patch << std::endl;
SDL_GetVersion(&ver);
std::cout << "Linked version " << (int)ver.major << "." << (int)ver.minor << "." << (int)ver.patch << std::endl;
}
//init time
platform_update_time(platform::app_time);
//call app config to get settings
platform::app_code.config(&platform::services.config);
//Set Opengl attributes
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, PLATFORM_GL_VERSION_MAJOR);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, PLATFORM_GL_VERSION_MINOR);
//Set buffer attributes
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, PLATFORM_GL_DOUBLEBUFFER);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, PLATFORM_GL_DEPTHBUFFER);
//Create a window
platform_create_window();
if (!platform::services.config.sdl_window)
{
std::cerr << ERROR_LINE << "Error: Unable to create window" << std::endl;
return -1;
}
else
{
platform::services.config.quit = false;
std::cout << "SDL window " << platform::services.config.width << "x" << platform::services.config.height << " opened" << std::endl;
}
//set OpenGL context
auto sdl_context = SDL_GL_CreateContext(platform::services.config.sdl_window);
// Initialise GLEW
glewExperimental = GL_TRUE;
GLenum glewError = glewInit();
if (glewError != GLEW_OK)
{
std::cerr << ERROR_LINE << "GLEW Error: Unable to initialise glew";
return -1;
}
else
{
std::cout<<"GLEW "<<glewGetString(GLEW_VERSION)<<" Initialised";
}
//Allocate memory for the app
auto base_address = Gigabytes(1);
platform::services.memory = {};
platform::services.memory.permanent_memory_size = Megabytes(8);
platform::services.memory.permanent_memory = platform::os::get_memory(base_address,platform::services.memory.permanent_memory_size);
if (!platform::services.memory.permanent_memory)
{
std::cerr << "\nUnable to allocate enough memory";
return -1;
}
//link memory to app state
platform::app_state.memory = &platform::services.memory;
//call the application startup
platform::app_code.startup(&platform::services);
//run application
#ifdef __EMSCRIPTEN__
emscripten_set_main_loop(platform_update, 0, true);
#else
//run as long as quit is not set to true
while(!platform::services.config.quit)
{
platform_update();
}
#endif
//free resources
SDL_GL_DeleteContext(sdl_context);
SDL_DestroyWindow(platform::services.config.sdl_window);
//exit
return 0;
}
FPlatformOpenGLContext* PlatformCreateOpenGLContext(FPlatformOpenGLDevice* Device, void* InWindowHandle)
{
Device->SharedContext->Context = SDL_GL_CreateContext((SDL_Window*)InWindowHandle);
return Device->SharedContext;
}
int main(int argc, char *argv[])
{
SDL_Window *window;
SDL_GLContext context;
// Slightly different SDL initialization
if ( SDL_Init(SDL_INIT_VIDEO) != 0 ) {
printf("Unable to initialize SDL: %s\n", SDL_GetError());
return 1;
}
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); // *new*
window = SDL_CreateWindow("sdl_fog_density", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 640, 480, SDL_WINDOW_OPENGL);
if ( !window ) {
printf("Unable to create window: %s\n", SDL_GetError());
return 1;
}
context = SDL_GL_CreateContext(window);
// Set the OpenGL state after creating the context with SDL_SetVideoMode
glClearColor( 0, 0, 0, 0 );
glEnable( GL_TEXTURE_2D ); // Needed when we're using the fixed-function pipeline.
glViewport( 0, 0, 640, 480 );
glMatrixMode( GL_PROJECTION );
glPushMatrix(); // just for testing
glLoadIdentity();
glOrtho( 0, 640, 480, 0, -1000, 1000 );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
// Load the OpenGL texture
GLuint texture; // Texture object handle
SDL_Surface *surface; // Gives us the information to make the texture
if ( (surface = IMG_Load("screenshot.png")) ) {
// Check that the image's width is a power of 2
if ( (surface->w & (surface->w - 1)) != 0 ) {
printf("warning: image.bmp's width is not a power of 2\n");
}
// Also check if the height is a power of 2
if ( (surface->h & (surface->h - 1)) != 0 ) {
printf("warning: image.bmp's height is not a power of 2\n");
}
// Have OpenGL generate a texture object handle for us
glGenTextures( 1, &texture );
// Bind the texture object
glBindTexture( GL_TEXTURE_2D, texture );
// Set the texture's stretching properties
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
//SDL_LockSurface(surface);
// Add some greyness
memset(surface->pixels, 0x66, surface->w*surface->h);
// Edit the texture object's image data using the information SDL_Surface gives us
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, surface->w, surface->h, 0,
GL_RGBA, GL_UNSIGNED_BYTE, surface->pixels );
//SDL_UnlockSurface(surface);
}
else {
printf("SDL could not load image.bmp: %s\n", SDL_GetError());
SDL_Quit();
return 1;
}
// Free the SDL_Surface only if it was successfully created
if ( surface ) {
SDL_FreeSurface( surface );
}
// Clear the screen before drawing
glClear( GL_COLOR_BUFFER_BIT );
// Bind the texture to which subsequent calls refer to
glBindTexture( GL_TEXTURE_2D, texture );
glEnable(GL_FOG);
GLfloat fogColor[] = { 1.0, 0.5, 0.5, 0.05 };
glFogfv(GL_FOG_COLOR, fogColor);
glFogf(GL_FOG_DENSITY, 0.2);
glFogi(GL_FOG_MODE, GL_EXP2);
assert(glIsEnabled(GL_FOG));
glBegin( GL_QUADS );
glTexCoord2i( 0, 0 ); glVertex3f( 10, 10, 10 );
glTexCoord2i( 1, 0 ); glVertex3f( 300, 10, 10 );
glTexCoord2i( 1, 1 ); glVertex3f( 300, 128, 10 );
glTexCoord2i( 0, 1 ); glVertex3f( 10, 128, 10 );
glTexCoord2f( 0, 0.5 ); glVertex3f( 410, 10, 5 );
glTexCoord2f( 1, 0.5 ); glVertex3f( 600, 10, 6 );
glTexCoord2f( 1, 1 ); glVertex3f( 630, 200, 7 );
glTexCoord2f( 0.5, 1 ); glVertex3f( 310, 250, 8 );
glEnd();
glBegin( GL_TRIANGLE_STRIP );
glTexCoord2i( 0, 0 ); glVertex3f( 100, 300, 1 );
glTexCoord2i( 1, 0 ); glVertex3f( 300, 300, 1 );
glTexCoord2i( 1, 1 ); glVertex3f( 300, 400, 1 );
glTexCoord2i( 0, 1 ); glVertex3f( 500, 410, 1 );
glEnd();
glDisable(GL_TEXTURE_2D);
glColor3ub(90, 255, 255);
glBegin( GL_QUADS );
glVertex3f( 10, 410, 5 );
glVertex3f( 300, 410, 50 );
glVertex3f( 300, 480, 100 );
glVertex3f( 10, 470, 5 );
glEnd();
glBegin( GL_QUADS );
glColor3f(1.0, 0, 1.0); glVertex3f( 410, 410, 10 );
glColor3f(0, 1.0, 0); glVertex3f( 600, 410, 10 );
glColor3f(0, 0, 1.0); glVertex3f( 600, 480, 10 );
glColor3f(1.0, 1.0, 1.0); glVertex3f( 410, 470, 10 );
glEnd();
SDL_GL_SwapWindow(window);
#if !defined(__EMSCRIPTEN__)
// Wait for 3 seconds to give us a chance to see the image
SDL_Delay(30000);
#endif
// Now we can delete the OpenGL texture and close down SDL
glDeleteTextures( 1, &texture );
SDL_Quit();
return 0;
}
bool OpenGLSdlGraphicsManager::setupMode(uint width, uint height) {
// In case we request a fullscreen mode we will use the mode the user
// has chosen last time or the biggest mode available.
if (_wantsFullScreen) {
if (_desiredFullscreenWidth && _desiredFullscreenHeight) {
// In case only a distinct set of modes is available we check
// whether the requested mode is actually available.
if (!_fullscreenVideoModes.empty()) {
VideoModeArray::const_iterator i = Common::find(_fullscreenVideoModes.begin(),
_fullscreenVideoModes.end(),
VideoMode(_desiredFullscreenWidth, _desiredFullscreenHeight));
// It's not available fall back to default.
if (i == _fullscreenVideoModes.end()) {
_desiredFullscreenWidth = 0;
_desiredFullscreenHeight = 0;
}
}
}
// In case no desired mode has been set we default to the biggest mode
// available or the requested mode in case we don't know any
// any fullscreen modes.
if (!_desiredFullscreenWidth || !_desiredFullscreenHeight) {
if (!_fullscreenVideoModes.empty()) {
VideoModeArray::const_iterator i = _fullscreenVideoModes.end();
--i;
_desiredFullscreenWidth = i->width;
_desiredFullscreenHeight = i->height;
} else {
_desiredFullscreenWidth = width;
_desiredFullscreenHeight = height;
}
}
// Remember our choice.
ConfMan.setInt("last_fullscreen_mode_width", _desiredFullscreenWidth, Common::ConfigManager::kApplicationDomain);
ConfMan.setInt("last_fullscreen_mode_height", _desiredFullscreenHeight, Common::ConfigManager::kApplicationDomain);
// Use our choice.
width = _desiredFullscreenWidth;
height = _desiredFullscreenHeight;
}
// This is pretty confusing since RGBA8888 talks about the memory
// layout here. This is a different logical layout depending on
// whether we run on little endian or big endian. However, we can
// only safely assume that RGBA8888 in memory layout is supported.
// Thus, we chose this one.
const Graphics::PixelFormat rgba8888 =
#ifdef SCUMM_LITTLE_ENDIAN
Graphics::PixelFormat(4, 8, 8, 8, 8, 0, 8, 16, 24);
#else
Graphics::PixelFormat(4, 8, 8, 8, 8, 24, 16, 8, 0);
#endif
#if SDL_VERSION_ATLEAST(2, 0, 0)
if (_glContext) {
notifyContextDestroy();
SDL_GL_DeleteContext(_glContext);
_glContext = nullptr;
}
_window->destroyWindow();
uint32 flags = SDL_WINDOW_OPENGL;
if (_wantsFullScreen) {
flags |= SDL_WINDOW_FULLSCREEN;
} else {
flags |= SDL_WINDOW_RESIZABLE;
}
// Request a OpenGL (ES) context we can use.
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, _glContextProfileMask);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, _glContextMajor);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, _glContextMinor);
if (!_window->createWindow(width, height, flags)) {
// We treat fullscreen requests as a "hint" for now. This means in
// case it is not available we simply ignore it.
if (_wantsFullScreen) {
_window->createWindow(width, height, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
}
if (!_window->getSDLWindow()) {
return false;
}
}
_glContext = SDL_GL_CreateContext(_window->getSDLWindow());
if (!_glContext) {
return false;
}
notifyContextCreate(rgba8888, rgba8888);
int actualWidth, actualHeight;
getWindowDimensions(&actualWidth, &actualHeight);
setActualScreenSize(actualWidth, actualHeight);
_eventSource->resetKeyboardEmulation(actualWidth - 1, actualHeight - 1);
return true;
#else
// WORKAROUND: Working around infamous SDL bugs when switching
// resolutions too fast. This might cause the event system to supply
// incorrect mouse position events otherwise.
// Reference: http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=665779
const uint32 curTime = SDL_GetTicks();
if (_hwScreen && (curTime < _lastVideoModeLoad || curTime - _lastVideoModeLoad < 100)) {
for (int i = 10; i > 0; --i) {
SDL_PumpEvents();
SDL_Delay(10);
}
}
uint32 flags = SDL_OPENGL;
if (_wantsFullScreen) {
flags |= SDL_FULLSCREEN;
} else {
flags |= SDL_RESIZABLE;
}
if (_hwScreen) {
// When a video mode has been setup already we notify the manager that
// the context is about to be destroyed.
// We do this because on Windows SDL_SetVideoMode can destroy and
// recreate the OpenGL context.
notifyContextDestroy();
}
_hwScreen = SDL_SetVideoMode(width, height, 32, flags);
if (!_hwScreen) {
// We treat fullscreen requests as a "hint" for now. This means in
// case it is not available we simply ignore it.
if (_wantsFullScreen) {
_hwScreen = SDL_SetVideoMode(width, height, 32, SDL_OPENGL | SDL_RESIZABLE);
}
}
// Part of the WORKAROUND mentioned above.
_lastVideoModeLoad = SDL_GetTicks();
if (_hwScreen) {
notifyContextCreate(rgba8888, rgba8888);
setActualScreenSize(_hwScreen->w, _hwScreen->h);
_eventSource->resetKeyboardEmulation(_hwScreen->w - 1, _hwScreen->h - 1);
}
// Ignore resize events (from SDL) for a few frames, if this isn't
// caused by a notification from SDL. This avoids bad resizes to a
// (former) resolution for which we haven't processed an event yet.
if (!_gotResize)
_ignoreResizeEvents = 10;
return _hwScreen != nullptr;
#endif
}
int main(int argc, char **argv)
{
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
fprintf(stderr, "Error: Unable to init SDL: %s\n", SDL_GetError());
exit(1);
}
SDL_Window* screen;
SDL_GLContext glcontext;
screen = SDL_CreateWindow("Window Name", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
600, 600,SDL_WINDOW_OPENGL);
glcontext = SDL_GL_CreateContext(screen);
SDL_ShowCursor(false);
GLenum err = glewInit();
if (err != GLEW_OK) fprintf(stderr, "Error: %s", glewGetErrorString(err));
if (!screen) {
fprintf(stderr, "Unable to start video: %s\n", SDL_GetError());
}
setupGL();
light=glm::vec3(0.0,-100.0,20.0);
//setup geometry
geoms.push_back(new CCubeVAO(1000,10,1000,glm::vec3(0,-50,0)));
geoms.push_back(new CCubeVAO(50,50,10,glm::vec3(-100,0,0)));
geoms.push_back(new CCubeVAO(10,10,10,glm::vec3(100,70,-100)));
geoms.push_back(new CCubeVAO(100,10,500,glm::vec3(200,50,-100)));
geoms.push_back(new ImageVAO(tex));
yaw=0;
pit=0;
bool quit=false;
long long count=0;
while(!quit){
input(screen,quit);
render(screen,count++);
}
//cleanup
glUseProgram(0);
for(int x=0;x<geoms.size();x++)
delete geoms.at(x);
glDeleteProgram(program);
glDeleteTextures(1,&tex);
SDL_GL_DeleteContext(glcontext);
}
int main(int argc, char* argv[]) {
if(SDL_Init(SDL_INIT_EVERYTHING) < 0)
{
std::cout << "Could not init SDL 2" << std::endl;
return 0;
}
SDL_Window *mainWindow = SDL_CreateWindow("Game",
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
WINDOW_WIDTH,
WINDOW_HEIGHT,
SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN);
if(!mainWindow)
{
std::cout << "Could not create a window" << std::endl;
return 0;
}
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GLContext mainContext = SDL_GL_CreateContext(mainWindow);
SDL_GL_SetSwapInterval(1);
int value = 0;
SDL_GL_GetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, &value);
std::cout << "SDL_GL_CONTEXT_MAJOR_VERSION: " << value << std::endl;
SDL_GL_GetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, &value);
std::cout << "SDL_GL_CONTEXT_MINOR_VERSION: " << value << std::endl;
struct stat statBuffer = {};
bool loop = true;
GameState gameState = {};
gameState.memory.mainMemorySz = MEGABYTES(128);
gameState.memory.mainMemory = mmap(0,
gameState.memory.mainMemorySz,
PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE,
-1, 0);
gameState.memory.transientMemorySz = GIGABYTES(2);
gameState.memory.transientMemory = mmap(0,
gameState.memory.transientMemorySz,
PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE,
-1, 0);
int currentTime = SDL_GetTicks();
while(loop)
{
int lastTime = currentTime;
currentTime = SDL_GetTicks();
int elapsedTime = currentTime - lastTime;
// NOTE(Brett): Check for the libgame.so and load the newest verion of the functions
stat("libgame.so", &statBuffer);
if(LastLibBuildTime == 0 || (statBuffer.st_mtime > LastLibBuildTime))
{
if(LibHandle)
dlclose(LibHandle);
LibHandle = dlopen("libgame.so", RTLD_GLOBAL);
GameUpdateAndRender = (update_method)dlsym(LibHandle, "UpdateAndRender");
GameSetup = (setup_method)dlsym(LibHandle, "Setup");
LastLibBuildTime = (int)statBuffer.st_mtime;
gameState.initialized = false;
GameSetup(&gameState);
}
SDL_Event event;
while(SDL_PollEvent(&event))
{
if(event.type == SDL_QUIT)
loop = false;
if(event.type == SDL_KEYDOWN)
{
switch(event.key.keysym.sym)
{
case SDLK_ESCAPE:
loop = false;
break;
default:
break;
}
}
}
GameUpdateAndRender(&gameState);
SDL_GL_SwapWindow(mainWindow);
}
return 0;
}
/*
===============
GLimp_SetMode
===============
*/
static rserr_t GLimp_SetMode(int mode, qboolean fullscreen, qboolean noborder)
{
const char *glstring;
int perChannelColorBits;
int colorBits, depthBits, stencilBits;
int samples;
int i = 0;
SDL_Surface *icon = NULL;
Uint32 flags = SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL;
SDL_DisplayMode desktopMode;
int display = 0;
int x = 0, y = 0;
Com_Printf( "Initializing OpenGL display\n");
if ( r_allowResize->integer )
flags |= SDL_WINDOW_RESIZABLE;
/*icon = SDL_CreateRGBSurfaceFrom(
(void *)CLIENT_WINDOW_ICON.pixel_data,
CLIENT_WINDOW_ICON.width,
CLIENT_WINDOW_ICON.height,
CLIENT_WINDOW_ICON.bytes_per_pixel * 8,
CLIENT_WINDOW_ICON.bytes_per_pixel * CLIENT_WINDOW_ICON.width,
#ifdef Q3_LITTLE_ENDIAN
0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000
#else
0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF
#endif
);*/
// If a window exists, note its display index
if( screen != NULL )
display = SDL_GetWindowDisplayIndex( screen );
if( SDL_GetDesktopDisplayMode( display, &desktopMode ) == 0 )
{
displayAspect = (float)desktopMode.w / (float)desktopMode.h;
Com_Printf( "Display aspect: %.3f\n", displayAspect );
}
else
{
Com_Memset( &desktopMode, 0, sizeof( SDL_DisplayMode ) );
Com_Printf( "Cannot determine display aspect, assuming 1.333\n" );
}
Com_Printf( "...setting mode %d:", mode );
if (mode == -2)
{
// use desktop video resolution
if( desktopMode.h > 0 )
{
glConfig.vidWidth = desktopMode.w;
glConfig.vidHeight = desktopMode.h;
}
else
{
glConfig.vidWidth = 640;
glConfig.vidHeight = 480;
Com_Printf( "Cannot determine display resolution, assuming 640x480\n" );
}
//glConfig.windowAspect = (float)glConfig.vidWidth / (float)glConfig.vidHeight;
}
else if ( !R_GetModeInfo( &glConfig.vidWidth, &glConfig.vidHeight, /*&glConfig.windowAspect,*/ mode ) )
{
Com_Printf( " invalid mode\n" );
return RSERR_INVALID_MODE;
}
Com_Printf( " %d %d\n", glConfig.vidWidth, glConfig.vidHeight);
// Center window
if( r_centerWindow->integer && !fullscreen )
{
x = ( desktopMode.w / 2 ) - ( glConfig.vidWidth / 2 );
y = ( desktopMode.h / 2 ) - ( glConfig.vidHeight / 2 );
}
// Destroy existing state if it exists
if( opengl_context != NULL )
{
SDL_GL_DeleteContext( opengl_context );
opengl_context = NULL;
}
if( screen != NULL )
{
SDL_GetWindowPosition( screen, &x, &y );
ri.Printf( PRINT_DEVELOPER, "Existing window at %dx%d before being destroyed\n", x, y );
SDL_DestroyWindow( screen );
screen = NULL;
}
if( fullscreen )
{
flags |= SDL_WINDOW_FULLSCREEN;
glConfig.isFullscreen = qtrue;
}
else
{
if( noborder )
flags |= SDL_WINDOW_BORDERLESS;
glConfig.isFullscreen = qfalse;
}
colorBits = r_colorbits->value;
if ((!colorBits) || (colorBits >= 32))
colorBits = 24;
if (!r_depthbits->value)
depthBits = 24;
else
depthBits = r_depthbits->value;
stencilBits = r_stencilbits->value;
//samples = r_ext_multisample->value;
for (i = 0; i < 16; i++)
{
int testColorBits, testDepthBits, testStencilBits;
// 0 - default
// 1 - minus colorBits
// 2 - minus depthBits
// 3 - minus stencil
if ((i % 4) == 0 && i)
{
// one pass, reduce
switch (i / 4)
{
case 2 :
if (colorBits == 24)
colorBits = 16;
break;
case 1 :
if (depthBits == 24)
depthBits = 16;
else if (depthBits == 16)
depthBits = 8;
case 3 :
if (stencilBits == 24)
stencilBits = 16;
else if (stencilBits == 16)
stencilBits = 8;
}
}
testColorBits = colorBits;
testDepthBits = depthBits;
testStencilBits = stencilBits;
if ((i % 4) == 3)
{ // reduce colorBits
if (testColorBits == 24)
testColorBits = 16;
}
if ((i % 4) == 2)
{ // reduce depthBits
if (testDepthBits == 24)
testDepthBits = 16;
else if (testDepthBits == 16)
testDepthBits = 8;
}
if ((i % 4) == 1)
{ // reduce stencilBits
if (testStencilBits == 24)
testStencilBits = 16;
else if (testStencilBits == 16)
testStencilBits = 8;
else
testStencilBits = 0;
}
if (testColorBits == 24)
perChannelColorBits = 8;
else
perChannelColorBits = 4;
#ifdef __sgi /* Fix for SGIs grabbing too many bits of color */
if (perChannelColorBits == 4)
perChannelColorBits = 0; /* Use minimum size for 16-bit color */
/* Need alpha or else SGIs choose 36+ bit RGB mode */
SDL_GL_SetAttribute( SDL_GL_ALPHA_SIZE, 1);
#endif
SDL_GL_SetAttribute( SDL_GL_RED_SIZE, perChannelColorBits );
SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, perChannelColorBits );
SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, perChannelColorBits );
SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, testDepthBits );
SDL_GL_SetAttribute( SDL_GL_STENCIL_SIZE, testStencilBits );
/*SDL_GL_SetAttribute( SDL_GL_MULTISAMPLEBUFFERS, samples ? 1 : 0 );
SDL_GL_SetAttribute( SDL_GL_MULTISAMPLESAMPLES, samples );*/
if(r_stereo->integer)
{
glConfig.stereoEnabled = qtrue;
SDL_GL_SetAttribute(SDL_GL_STEREO, 1);
}
else
{
glConfig.stereoEnabled = qfalse;
SDL_GL_SetAttribute(SDL_GL_STEREO, 0);
}
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
// If not allowing software GL, demand accelerated
if( !r_allowSoftwareGL->integer )
SDL_GL_SetAttribute( SDL_GL_ACCELERATED_VISUAL, 1 );
if( ( screen = SDL_CreateWindow( CLIENT_WINDOW_TITLE, x, y,
glConfig.vidWidth, glConfig.vidHeight, flags ) ) == 0 )
{
ri.Printf( PRINT_DEVELOPER, "SDL_CreateWindow failed: %s\n", SDL_GetError( ) );
continue;
}
if( fullscreen )
{
SDL_DisplayMode mode;
switch( testColorBits )
{
case 16: mode.format = SDL_PIXELFORMAT_RGB565; break;
case 24: mode.format = SDL_PIXELFORMAT_RGB24; break;
default: ri.Printf( PRINT_DEVELOPER, "testColorBits is %d, can't fullscreen\n", testColorBits ); continue;
}
mode.w = glConfig.vidWidth;
mode.h = glConfig.vidHeight;
mode.refresh_rate = glConfig.displayFrequency = ri.Cvar_VariableIntegerValue( "r_displayRefresh" );
mode.driverdata = NULL;
if( SDL_SetWindowDisplayMode( screen, &mode ) < 0 )
{
ri.Printf( PRINT_DEVELOPER, "SDL_SetWindowDisplayMode failed: %s\n", SDL_GetError( ) );
continue;
}
}
SDL_SetWindowTitle( screen, CLIENT_WINDOW_TITLE );
SDL_SetWindowIcon( screen, icon );
if( ( opengl_context = (QGLContext)SDL_GL_CreateContext( screen ) ) == NULL )
{
Com_Printf( "SDL_GL_CreateContext failed: %s\n", SDL_GetError( ) );
continue;
}
if( SDL_GL_MakeCurrent( screen, opengl_context ) < 0 )
{
Com_Printf( "SDL_GL_MakeCurrent failed: %s\n", SDL_GetError( ) );
continue;
}
SDL_GL_SetSwapInterval( r_swapInterval->integer );
glConfig.colorBits = testColorBits;
glConfig.depthBits = testDepthBits;
glConfig.stencilBits = testStencilBits;
Com_Printf( "Using %d color bits, %d depth, %d stencil display.\n",
glConfig.colorBits, glConfig.depthBits, glConfig.stencilBits );
break;
}
/*SDL_FreeSurface( icon );*/
GLimp_DetectAvailableModes();
glstring = (char *) qglGetString (GL_RENDERER);
Com_Printf( "GL_RENDERER: %s\n", glstring );
return RSERR_OK;
#if 0
const char* glstring;
int sdlcolorbits;
int colorbits, depthbits, stencilbits;
int tcolorbits, tdepthbits, tstencilbits;
int samples;
int i = 0;
Uint32 flags = SDL_WINDOW_OPENGL;
Com_Printf( "Initializing OpenGL display\n");
if ( r_allowResize->integer )
flags |= SDL_WINDOW_RESIZABLE;
if( videoInfo == NULL )
{
static SDL_DisplayMode sVideoInfo;
static SDL_PixelFormat sPixelFormat;
if (SDL_GetCurrentDisplayMode( 0, &sVideoInfo ) < 0)
Com_Error(ERR_FATAL, "SDL_GetCurrentDisplayMode failed : %s\n", SDL_GetError());
// Take a copy of the videoInfo
sPixelFormat.format = sVideoInfo.format;
sPixelFormat.palette = NULL; // Should already be the case
//Com_Memcpy( &sVideoInfo, videoInfo, sizeof( SDL_DisplayMode ) );
sVideoInfo.format = sPixelFormat.format;
videoInfo = &sVideoInfo;
if( videoInfo->h > 0 )
{
glConfig.displayWidth = videoInfo->w;
glConfig.displayHeight = videoInfo->h;
// Guess the display aspect ratio through the desktop resolution
// by assuming (relatively safely) that it is set at or close to
// the display's native aspect ratio
glConfig.displayAspect = (float)videoInfo->w / (float)videoInfo->h;
Com_Printf( "Estimated display aspect: %.3f\n", glConfig.displayAspect );
}
else
{
glConfig.displayWidth = 480;
glConfig.displayHeight = 640;
glConfig.displayAspect = 1.333f;
Com_Printf(
"Cannot estimate display resolution/aspect, assuming 640x480/1.333\n" );
}
}
Com_Printf( "...setting mode %d:", mode );
if (mode == -2)
{
// use desktop video resolution
if( videoInfo->h > 0 )
{
glConfig.vidWidth = videoInfo->w;
glConfig.vidHeight = videoInfo->h;
}
else
{
glConfig.vidWidth = 640;
glConfig.vidHeight = 480;
Com_Printf(
"Cannot determine display resolution, assuming 640x480\n" );
}
glConfig.displayAspect = (float)glConfig.vidWidth / (float)glConfig.vidHeight;
}
else if ( !R_GetModeInfo( &glConfig.vidWidth, &glConfig.vidHeight, /*&glConfig.displayAspect,*/ mode ) )
{
Com_Printf( " invalid mode\n" );
return RSERR_INVALID_MODE;
}
Com_Printf( " %d %d\n", glConfig.vidWidth, glConfig.vidHeight);
if (fullscreen)
{
flags |= SDL_WINDOW_FULLSCREEN;
glConfig.isFullscreen = qtrue;
}
else
{
if (noborder)
flags |= SDL_WINDOW_BORDERLESS;
glConfig.isFullscreen = qfalse;
}
colorbits = r_colorbits->value;
if ((!colorbits) || (colorbits >= 32))
colorbits = 24;
if (!r_depthbits->value)
depthbits = 24;
else
depthbits = r_depthbits->value;
stencilbits = r_stencilbits->value;
//samples = r_ext_multisample->value;
for (i = 0; i < 16; i++)
{
// 0 - default
// 1 - minus colorbits
// 2 - minus depthbits
// 3 - minus stencil
if ((i % 4) == 0 && i)
{
// one pass, reduce
switch (i / 4)
{
case 2 :
if (colorbits == 24)
colorbits = 16;
break;
case 1 :
if (depthbits == 24)
depthbits = 16;
else if (depthbits == 16)
depthbits = 8;
case 3 :
if (stencilbits == 24)
stencilbits = 16;
else if (stencilbits == 16)
stencilbits = 8;
}
}
tcolorbits = colorbits;
tdepthbits = depthbits;
tstencilbits = stencilbits;
if ((i % 4) == 3)
{ // reduce colorbits
if (tcolorbits == 24)
tcolorbits = 16;
}
if ((i % 4) == 2)
{ // reduce depthbits
if (tdepthbits == 24)
tdepthbits = 16;
else if (tdepthbits == 16)
tdepthbits = 8;
}
if ((i % 4) == 1)
{ // reduce stencilbits
if (tstencilbits == 24)
tstencilbits = 16;
else if (tstencilbits == 16)
tstencilbits = 8;
else
tstencilbits = 0;
}
sdlcolorbits = 4;
if (tcolorbits == 24)
sdlcolorbits = 8;
#ifdef __sgi /* Fix for SGIs grabbing too many bits of color */
if (sdlcolorbits == 4)
sdlcolorbits = 0; /* Use minimum size for 16-bit color */
/* Need alpha or else SGIs choose 36+ bit RGB mode */
SDL_GL_SetAttribute( SDL_GL_ALPHA_SIZE, 1);
#endif
SDL_GL_SetAttribute( SDL_GL_RED_SIZE, sdlcolorbits );
SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, sdlcolorbits );
SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, sdlcolorbits );
SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, tdepthbits );
SDL_GL_SetAttribute( SDL_GL_STENCIL_SIZE, tstencilbits );
SDL_GL_SetAttribute( SDL_GL_MULTISAMPLEBUFFERS, samples ? 1 : 0 );
SDL_GL_SetAttribute( SDL_GL_MULTISAMPLESAMPLES, samples );
/*if(r_stereoEnabled->integer)
{
glConfig.stereoEnabled = qtrue;
SDL_GL_SetAttribute(SDL_GL_STEREO, 1);
}
else
{*/
glConfig.stereoEnabled = qfalse;
SDL_GL_SetAttribute(SDL_GL_STEREO, 0);
//}
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
#if 0 // See http://bugzilla.icculus.org/show_bug.cgi?id=3526
// If not allowing software GL, demand accelerated
if( !r_allowSoftwareGL->integer )
{
if( SDL_GL_SetAttribute( SDL_GL_ACCELERATED_VISUAL, 1 ) < 0 )
{
Com_Printf( "Unable to guarantee accelerated "
"visual with libSDL < 1.2.10\n" );
}
}
#endif
if( SDL_GL_SetSwapInterval(r_swapInterval->integer ) < 0 )
Com_Printf( "SDL_GL_SetSwapInterval not supported\n" );
#ifdef USE_ICON
{
SDL_Surface *icon = SDL_CreateRGBSurfaceFrom(
(void *)CLIENT_WINDOW_ICON.pixel_data,
CLIENT_WINDOW_ICON.width,
CLIENT_WINDOW_ICON.height,
CLIENT_WINDOW_ICON.bytes_per_pixel * 8,
CLIENT_WINDOW_ICON.bytes_per_pixel * CLIENT_WINDOW_ICON.width,
#ifdef Q3_LITTLE_ENDIAN
0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000
#else
0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF
#endif
);
SDL_WM_SetIcon( icon, NULL );
SDL_FreeSurface( icon );
}
#endif
SDL_ShowCursor(0);
if (!(window = SDL_CreateWindow(CLIENT_WINDOW_TITLE, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, glConfig.vidWidth, glConfig.vidHeight, flags)))
{
Com_Printf( "SDL_CreateWindow failed: %s\n", SDL_GetError( ) );
continue;
}
opengl_context = SDL_GL_CreateContext(window);
Com_Printf( "Using %d/%d/%d Color bits, %d depth, %d stencil display.\n",
sdlcolorbits, sdlcolorbits, sdlcolorbits, tdepthbits, tstencilbits);
glConfig.colorBits = tcolorbits;
glConfig.depthBits = tdepthbits;
glConfig.stencilBits = tstencilbits;
break;
}
GLimp_DetectAvailableModes();
if (!window)
{
Com_Printf( "Couldn't get a visual\n" );
return RSERR_INVALID_MODE;
}
screen = window;
// FIXME: Defines needed here
glstring = (char *) qglGetString (GL_RENDERER);
Com_Printf( "GL_RENDERER: %s\n", glstring );
return RSERR_OK;
#endif
}
int main(int argc, char **argv){
/* vertices for a triangle */
/* Why does triangle[] = { vec4_new(...) } result in a segfault when returning
* from _mm_load_ps?
*/
/* Just want a sort of 3D object, but not a closed object otherwise it's hard
* to tell what's going on w/ flat shading */
vec4_t object[18];
//+Z face
object[0] = vec4_new(-1, -1, 1, 1);
object[1] = vec4_new(1, -1, 1, 1);
object[2] = vec4_new(1, 1, 1, 1);
object[3] = vec4_new(1, 1, 1, 1);
object[4] = vec4_new(-1, 1, 1, 1);
object[5] = vec4_new(-1, -1, 1, 1);
//+X face
object[6] = vec4_new(1, -1, 1, 1);
object[7] = vec4_new(1, -1, -1, 1);
object[8] = vec4_new(1, 1, -1, 1);
object[9] = vec4_new(1, 1, -1, 1);
object[10] = vec4_new(1, 1, 1, 1);
object[11] = vec4_new(1, -1, 1, 1);
//-X face
object[12] = vec4_new(-1, -1, 1, 1);
object[13] = vec4_new(-1, -1, -1, 1);
object[14] = vec4_new(-1, 1, -1, 1);
object[15] = vec4_new(-1, 1, -1, 1);
object[16] = vec4_new(-1, 1, 1, 1);
object[17] = vec4_new(-1, -1, 1, 1);
if (SDL_Init(SDL_INIT_EVERYTHING) != 0){
fprintf(stderr, "SDL Init error: %s\n", SDL_GetError());
return 1;
}
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
#ifdef DEBUG
SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG);
#endif
SDL_Window *win = SDL_CreateWindow("SSE GL Test", SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED, WIN_WIDTH, WIN_HEIGHT, SDL_WINDOW_OPENGL);
SDL_GLContext context = SDL_GL_CreateContext(win);
if (check_GL_error("Opened win + context")){
SDL_GL_DeleteContext(context);
SDL_DestroyWindow(win);
return 1;
}
glewExperimental = GL_TRUE;
GLenum err = glewInit();
if (err != GLEW_OK){
fprintf(stderr, "GLEW init error %d\n", err);
SDL_GL_DeleteContext(context);
SDL_DestroyWindow(win);
return 1;
}
check_GL_error("Post GLEW init");
#ifdef DEBUG
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
glDebugMessageCallbackARB(gl_debug_callback, NULL);
glDebugMessageControlARB(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE,
0, NULL, GL_TRUE);
#endif
glClearColor(0, 0, 0, 1);
glClearDepth(1);
glEnable(GL_DEPTH_TEST);
//Model's vao and vbo
GLuint model[2];
glGenVertexArrays(1, model);
glBindVertexArray(model[0]);
glGenBuffers(1, model + 1);
glBindBuffer(GL_ARRAY_BUFFER, model[1]);
glBufferData(GL_ARRAY_BUFFER, 4 * 6 * 3 * sizeof(GLfloat), object, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0);
if (check_GL_error("Setup buffers")){
return 1;
}
GLint vshader = make_shader(vert_shader_src, GL_VERTEX_SHADER);
GLint fshader = make_shader(frag_shader_src, GL_FRAGMENT_SHADER);
if (vshader == -1 || fshader == -1){
return 1;
}
GLint program = make_program(vshader, fshader);
if (program == -1){
return 1;
}
glDeleteShader(vshader);
glDeleteShader(fshader);
mat4_t model_mat = mat4_mult(mat4_rotate(45, vec4_new(1, 1, 0, 0)), mat4_scale(2, 2, 2));
model_mat = mat4_mult(mat4_translate(vec4_new(0, 2, -5, 1)), model_mat);
mat4_t view_mat = mat4_look_at(vec4_new(0, 0, 5, 0), vec4_new(0, 0, 0, 0), vec4_new(0, 1, 0, 0));
mat4_t proj_mat = mat4_perspective(75, ((float)WIN_WIDTH) / WIN_HEIGHT, 1, 100);
glUseProgram(program);
GLuint model_unif = glGetUniformLocation(program, "model");
GLuint view_unif = glGetUniformLocation(program, "view");
GLuint proj_unif = glGetUniformLocation(program, "proj");
glUniformMatrix4fv(model_unif, 1, GL_FALSE, (GLfloat*)&model_mat);
glUniformMatrix4fv(view_unif, 1, GL_FALSE, (GLfloat*)&view_mat);
glUniformMatrix4fv(proj_unif, 1, GL_FALSE, (GLfloat*)&proj_mat);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glDrawArrays(GL_TRIANGLES, 0, 18);
SDL_GL_SwapWindow(win);
check_GL_error("Post Draw");
SDL_Event e;
int quit = 0;
while (!quit){
while (SDL_PollEvent(&e)){
if (e.type == SDL_QUIT || e.type == SDL_KEYDOWN){
quit = 1;
}
}
}
glDeleteProgram(program);
glDeleteVertexArrays(1, model);
glDeleteBuffers(1, model + 1);
SDL_GL_DeleteContext(context);
SDL_DestroyWindow(win);
return 0;
}
Window::Window() {
SDL_Init(SDL_INIT_VIDEO);
displayWindow = SDL_CreateWindow("My Game", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_OPENGL);
SDL_GLContext context = SDL_GL_CreateContext(displayWindow);
SDL_GL_MakeCurrent(displayWindow, context);
}
BBSDLContext *bbSDLGraphicsCreateGraphics( int width,int height,int depth,int hz,int flags ) {
int mode;
char * appTitle = bbStringToUTF8String( bbAppTitle );
int windowFlags = 0;
if ((flags & FLAGS_DX) == 0) {
windowFlags = SDL_WINDOW_OPENGL;
}
if (flags & FLAGS_BORDERLESS) windowFlags |= SDL_WINDOW_BORDERLESS;
if( depth ){
windowFlags |= SDL_WINDOW_FULLSCREEN;
mode=MODE_DISPLAY;
} else {
if (flags & FLAGS_FULLSCREEN) {
windowFlags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
}
mode=MODE_WINDOW;
}
if ((flags & FLAGS_DX) == 0) {
if (flags & FLAGS_BACKBUFFER) SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
if (flags & FLAGS_ALPHABUFFER) SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 1);
if (flags & FLAGS_DEPTHBUFFER) SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
if (flags & FLAGS_STENCILBUFFER) SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 1);
}
#ifdef __ANDROID__
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 6);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
#endif
#ifdef __RASPBERRYPI__
int rpi_mode;
int rpi_group;
if (depth && (flags & FLAGS_RPI_TV_FULLSCREEN)) {
bmx_tvservice_get_closest_mode(width, height, hz, &rpi_mode, &rpi_group);
bmx_tvservice_setmode(rpi_mode, rpi_group, width, height);
}
SDL_VideoInit(NULL);
#endif
SDL_Window *window = SDL_CreateWindow(appTitle, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
width, height, windowFlags);
if (window == NULL) {
printf("error... %s\n", SDL_GetError());fflush(stdout);
return NULL;
}
SDL_GLContext context = 0;
if ((flags & FLAGS_DX) == 0) {
SDL_GL_SetSwapInterval(-1);
context = SDL_GL_CreateContext(window);
}
BBSDLContext *bbcontext=(BBSDLContext*)malloc( sizeof(BBSDLContext) );
memset( bbcontext,0,sizeof(BBSDLContext) );
bbcontext->mode=mode;
bbcontext->width=width;
bbcontext->height=height;
#ifdef __RASPBERRYPI__
bbcontext->depth=16;
#else
bbcontext->depth=24;
#endif
bbcontext->hertz=hz;
bbcontext->flags=flags;
bbcontext->sync=-1;
bbcontext->window=window;
bbcontext->context=context;
SDL_GetWindowWMInfo(window, &bbcontext->info);
return bbcontext;
}
int main(int argc, const char * argv[]) {
// Window size
int SCREEN_WIDTH = 800;
int SCREEN_HEIGHT = 600;
SDL_Window *mainwindow; /* Our window handle */
SDL_GLContext maincontext; /* Our opengl context handle */
SDL_Init(SDL_INIT_VIDEO);
mainwindow = SDL_CreateWindow(PROGRAM_NAME, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE);
/* Create our opengl context and attach it to our window */
maincontext = SDL_GL_CreateContext(mainwindow);
/* This makes our buffer swap syncronized with the monitor's vertical refresh */
SDL_GL_SetSwapInterval(1);
player.setColor(0, 1, 0);
myGrid.size = 9;
myGrid.LinesX = 10;
myGrid.LinesY = 10;
myGrid.placeTypes();
myGrid.printTypes();
SDL_Event event;
bool running = true;
// Initialize camera
changeSize(SCREEN_WIDTH, SCREEN_HEIGHT);
while (running) {
Uint32 start = SDL_GetTicks();
//std::cout << "Start: " << start << std::endl;
while (SDL_PollEvent(&event)) {
switch (event.type) {
// Capture any window event
// https://wiki.libsdl.org/SDL_WindowEvent
case SDL_WINDOWEVENT:
switch (event.window.event) {
case SDL_WINDOWEVENT_RESIZED:
int w = event.window.data1;
int h = event.window.data2;
changeSize(w, h);
break;
}
break;
// Handle keyboar events
case SDL_KEYDOWN:
switch (event.key.keysym.sym) {
case SDLK_UP:
std::cout << "Up key pressed" << std::endl;
player.move(1, 0, 0);
std::cout << "Player pos X " << player.posX << std::endl;
break;
case SDLK_DOWN:
std::cout << "Down key pressed" << std::endl;
player.move(-1, 0, 0);
std::cout << "Player pos X " << player.posX << std::endl;
break;
case SDLK_LEFT:
std::cout << "Left key pressed" << std::endl;
player.move(0, 1, 0);
std::cout << "Player pos Y " << player.posY << std::endl;
break;
case SDLK_RIGHT:
std::cout << "Right key pressed" << std::endl;
player.move(0, -1, 0);
std::cout << "Player pos Y " << player.posY << std::endl;
break;
}
break;
case SDL_QUIT:
running = false;
break;
}
}
renderScene(mainwindow);
// Insure that screen update happen no more then 60 fps
//std::cout << "End: " << SDL_GetTicks() << std::endl;
if (1000/60>(SDL_GetTicks() - start)) {
SDL_Delay(1000/60 - (SDL_GetTicks() - start));
}
}
/* Delete our opengl context, destroy our window, and shutdown SDL */
SDL_GL_DeleteContext(maincontext);
SDL_DestroyWindow(mainwindow);
SDL_Quit();
return 0;
}
/* Run Program */
int main (int argc, char** argv) {
//Read input argument
int steps=1000;
double h = 0.1;
if (argc == 1){
printf("USAGE: NumberOfSteps StepSize/Tolerance\nExited.\n");
return 0;
}
if (argc > 1) steps = atoi(argv[1]);
if (argc > 2) h = atof(argv[2]);
printf("Input arguments: %i %f \n", steps, h);
//Check if SDL Initialization is successful
if (SDL_Init(SDL_INIT_VIDEO) != 0) {
return -1;
}
//Create Window
SDL_Window *win = SDL_CreateWindow("Exercise 5, Lorenz Equations",50,50,800,600,SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL);
if (!win) {
fprintf(stderr, "Could not create window: %s\n", SDL_GetError());
}
//Initialize OpenGL
SDL_GLContext context = SDL_GL_CreateContext(win);
if (!context) {
fprintf(stderr, "Could not create OpenGL context: %s\n", SDL_GetError());
}
glViewport(0,0,(GLsizei)800,(GLsizei)600);
glClearColor(1.0f,1.0f,1.0f,1.0f);
glClear(GL_COLOR_BUFFER_BIT);
SDL_GL_SwapWindow(win);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glEnable(GL_DEPTH_TEST);
glFrustum(-100,100,-100,100,0.01,100);
glEnable(GL_POLYGON_OFFSET_FILL);
glPolygonOffset(1,1);
glEnable(GL_LIGHTING);
glShadeModel(GL_SMOOTH);
GLfloat lightcol[] = {0.9,0.9,0.9,1.0};
GLfloat lightamb[] = {0.5,0.5,0.5,1.0};
GLfloat lightpos[] = {20.0,20.0,30.0,1.0};
glLightfv(GL_LIGHT0,GL_AMBIENT,lightamb);
glLightfv(GL_LIGHT0,GL_DIFFUSE,lightcol);
glEnable(GL_LIGHT0);
glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE);
glEnable(GL_RESCALE_NORMAL);
//Init all vectors
double t0 = 0;
double* t = malloc(sizeof(double)*steps);
double* xValues = malloc(sizeof(double)*steps);
double* yValues = malloc(sizeof(double)*steps);
double* zValues = malloc(sizeof(double)*steps);
double* xValues_it = malloc(sizeof(double)*steps);
double* yValues_it = malloc(sizeof(double)*steps);
double* zValues_it = malloc(sizeof(double)*steps);
double xmin = -4;
double xmax = 4;
double ymin = -4;
double ymax = 4;
double xsteps = 21;
double ysteps = 21;
struct Matrix* X = new_Matrix(xsteps,ysteps);
struct Matrix* Y = new_Matrix(xsteps,ysteps);
struct Matrix* Z = new_Matrix(xsteps,ysteps);
meshgrid(xmin,xmax,ymin,ymax,xsteps,ysteps,X,Y);
paraboloid(X,Y,Z);
struct Vector* vec0 = new_Vector(DIM);
vec0->values[0] = 1;
vec0->values[1] = 1;
vec0->values[2] = 2;
vec0->values[3] = 1-0.25;
vec0->values[4] = -1-0.25;
vec0->values[5] = -1;
struct Vector** vec = malloc(sizeof(struct Vector*)*steps);
for (int j=1; j < steps; j++) {
vec[j] = new_Vector(DIM);
}
//find geodesic iteratively
struct Vector** vec_it = malloc(sizeof(struct Vector*)*steps);
vec_it[0] = vec0;
for (int j=1; j < steps; j++) {
vec_it[j] = new_Vector(DIM);
geodesic_step(vec_it[j-1],h,vec_it[j]);
}
for (int j=0; j < steps; j++) {
xValues_it[j] = vec_it[j]->values[0];
yValues_it[j] = vec_it[j]->values[1];
zValues_it[j] = vec_it[j]->values[2];
}
//solve ODE
//adaptive_rk3(geodesic_rhs,t0,vec0,h,t,vec,steps);
euler(geodesic_rhs,t0,vec0,h,t,vec,steps);
for (int j=0; j < steps; j++) {
xValues[j] = vec[j]->values[0];
yValues[j] = vec[j]->values[1];
zValues[j] = vec[j]->values[2];
}
SDL_GL_SwapWindow(win);
/* Look Around Loop */
bool loop = true;
bool wireframe = false;
bool overlay = true;
double xMouse = 0;
double yMouse = 0;
double xpos = 0;
double ypos = 0;
double zpos = 0;
bool mouseDown = false;
double mouseZoom = 0.1;
SDL_Event event;
while (loop) {
while (SDL_PollEvent(&event)) {
if (event.type == SDL_QUIT) {
loop = false;
}
if (event.type== SDL_MOUSEBUTTONDOWN) {
mouseDown = true;
}
if (event.type == SDL_MOUSEBUTTONUP) {
mouseDown = false;
}
if (event.type == SDL_MOUSEMOTION) {
if(mouseDown){
xMouse += 0.5*event.motion.xrel;
yMouse += 0.5*event.motion.yrel;
}
}
if (event.type== SDL_KEYDOWN) {
if(event.key.keysym.scancode == SDL_SCANCODE_W)
ypos += 0.1;
if(event.key.keysym.scancode == SDL_SCANCODE_S)
ypos -= 0.1;
if(event.key.keysym.scancode == SDL_SCANCODE_A)
xpos -= 0.1;
if(event.key.keysym.scancode == SDL_SCANCODE_D)
xpos += 0.1;
if(event.key.keysym.scancode == SDL_SCANCODE_Q)
zpos += 0.1;
if(event.key.keysym.scancode == SDL_SCANCODE_E)
zpos -= 0.1;
if(event.key.keysym.scancode == SDL_SCANCODE_TAB)
wireframe = !wireframe;
if(event.key.keysym.scancode == SDL_SCANCODE_O)
overlay = !overlay;
}
if (event.type== SDL_MOUSEWHEEL) {
if (event.wheel.y < 0)
mouseZoom /= 1.2;
else
mouseZoom *= 1.2;
}
}
//Draw current frame buffer
SDL_GL_SwapWindow(win);
//Prepare next frame buffer
glClearColor( 1.0f, 1.0f, 1.0f, 1.0f );
glClear( GL_COLOR_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glClear(GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslated(xpos, ypos, zpos);
glScaled(mouseZoom,mouseZoom,mouseZoom);
glRotated(-90, 1.0, 0.0, 0.0);
glRotated(-yMouse, 1.0, 0.0, 0.0);
glRotated(-xMouse, 0.0, 0.0, 1.0);
plotAxis3D(-10,10,-10,10,-5,30,0,0,0);
glColor4f(0.2,0.4,0.5,1.0);
glLightfv(GL_LIGHT0,GL_POSITION,lightpos);
if (wireframe) {
glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
surf(X,Y,Z);
} else {
glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
surf(X,Y,Z);
if (overlay) {
glColor4f(0.2,0.2,0.2,1.0);
glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
surf(X,Y,Z);
}
}
glColor4f(0.85,0.85,0.10,1.0);
plotArray3D(xValues,yValues,zValues,steps);
glColor4f(0.9,0.2,0.4,1.0);
plotArray3D(xValues_it,yValues_it,zValues_it,steps);
glColor4f(0.0,0.0,0.0,1.0);
}
//Clean Up Memory
free(t);
for (int j=1; j < steps; j++) {
delete_Vector(vec[j]);
}
free(vec);
free(xValues);
free(yValues);
free(zValues);
delete_Vector(vec0);
delete_Matrix(X);
delete_Matrix(Y);
delete_Matrix(Z);
SDL_GL_DeleteContext(context);
SDL_DestroyWindow(win);
SDL_Quit();
return 0;
}
bool Application::Init(int w, int h) {
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
return EmitSDLError("error initialize SDL");
return false;
}
#ifdef __APPLE__
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
#else
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
#endif
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
window_ = SDL_CreateWindow(nullptr, SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED, w, h, SDL_WINDOW_OPENGL);
gl_context_ = SDL_GL_CreateContext(window_);
if (gl_context_ == nullptr) {
return EmitSDLError("error creating GL context");
}
// Enable vsync
SDL_GL_SetSwapInterval(1);
if (TTF_Init() != 0) {
return EmitSDLError("error initialize font system");
}
std::string resource_folder_name = std::string(kResourceFolderName) + "/";
std::string font_file_name = resource_folder_name + kFontFileName;
font_ = TTF_OpenFont(font_file_name.c_str(), 14);
if (font_ == nullptr) {
std::string message;
message += "error read font ";
message += kFontFileName;
message += "at size " + std::to_string(14);
return EmitSDLError(message.c_str());
}
std::string demo_file_name = resource_folder_name + kDemoFileName;
world_ = ParseWorld((CreateJsonObject(demo_file_name.c_str())));
world_->Start(World::EngineType::kLiquidFun);
// We have two camera setup: the first one for viewing the board and the
// second one for background. The second camera does not move.
cameras_.resize(2);
cameras_[0] =
make_unique<Camera>(Vector3f(0, -50, 650), Vector3f(0, 50, 0),
Vector3f(0, 1, 0), M_PI / 2.0, 1.0, 10.0, 500000.0);
cameras_[1] =
make_unique<Camera>(Vector3f(0, 0, 800), Vector3f(0, 0, 0),
Vector3f(0, 1, 0), M_PI / 2.0, 1.0, 10.0, 500000.0);
poly_drawer_ = make_unique<NodeGroupDrawer<NodeBuldgedDrawer>>(
LoadMesh3DGLProgram(), cameras_[0].get(), Vector2f(w, h));
path_drawer_ = make_unique<NodeGroupDrawer<NodePathDrawer>>(
LoadSimpleGLProgram(), cameras_[0].get(), Vector2f(w, h));
particle_drawer_ = make_unique<NodeGroupDrawer<SphereDrawer>>(
LoadSphereGLProgram(), cameras_[0].get(), Vector2f(w, h));
// Add Node to each group drawer.
for (size_t i = 0; i < world_->GetNumNodes(); ++i) {
auto& collision_shapes = world_->GetNodeByIndex(i)->collision_shapes;
if (collision_shapes.size() == 1 &&
collision_shapes[0]->shape_type == Shape2DType::kDisk) {
particle_drawer_->AddNode(world_->GetNodeByIndex(i));
} else {
poly_drawer_->AddNode(world_->GetNodeByIndex(i));
}
path_drawer_->AddNode(world_->GetNodeByIndex(i));
}
text_drawer_ = make_unique<TextDrawer>(font_);
// Use the fixed camera for background drawing.
canvas_drawer_ = make_unique<CanvasDrawer>(LoadBackgroundGLProgram(),
cameras_[1].get(), Vector2f(w, h));
return true;
}
int
engine_init(void)
{
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS | SDL_INIT_AUDIO)) {
DBG_LOG("Failed to initialize SDL: %s", SDL_GetError());
return -1;
}
SDL_LogSetAllPriority(SDL_LOG_PRIORITY_WARN);
fullscreen = false;
/* require OpenGL 3.2 */
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
// SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
main_win = SDL_CreateWindow(RPG_WINDOW_TITLE,
SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
RPG_OUT_WIDTH, RPG_OUT_HEIGHT, SDL_WINDOW_RESIZABLE | SDL_WINDOW_OPENGL);
if (!main_win) {
DBG_LOG("Failed to create window: %s", SDL_GetError());
goto failure;
}
main_ctx = SDL_GL_CreateContext(main_win);
if (!main_ctx) {
DBG_LOG("Failed to initialize GL context: %s", SDL_GetError());
goto failure;
}
SDL_GL_MakeCurrent(main_win, main_ctx);
/* now that context is created we can initialize GL */
int res = gl3wInit();
if (res != GL3W_OK) {
DBG_LOG("Error opening GL library (%d)", res);
goto failure;
}
if (!gl3wIsSupported(3, 2)) {
DBG_LOG("Error OpenGL 3.2 or later required");
goto failure;
}
/* register published key events */
engine_key_state.left = keystate_register("left");
engine_key_state.right = keystate_register("right");
engine_key_state.up = keystate_register("up");
engine_key_state.down = keystate_register("down");
engine_key_state.button_a = keystate_register("a");
engine_key_state.button_b = keystate_register("b");
engine_key_state.button_x = keystate_register("x");
engine_key_state.button_y = keystate_register("y");
engine_key_state.start = keystate_register("start");
engine_key_state.select = keystate_register("select");
return 0;
failure:
engine_fini();
return -1;
}
int
main(int argc, char *argv[])
{
/* Platform */
int width, height;
const char *font_path;
gui_size font_height;
SDL_Window *win;
SDL_GLContext glContext;
NVGcontext *vg = NULL;
unsigned int started;
unsigned int dt;
/* GUI */
struct gui_input in;
struct gui_font font;
struct demo_gui gui;
if (argc < 2) {
fprintf(stdout,"Missing TTF Font file argument: gui <path>\n");
exit(EXIT_FAILURE);
}
font_path = argv[1];
font_height = 10;
/* SDL */
SDL_Init(SDL_INIT_VIDEO|SDL_INIT_TIMER|SDL_INIT_EVENTS);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
win = SDL_CreateWindow("Demo",
SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
WINDOW_WIDTH, WINDOW_HEIGHT, SDL_WINDOW_OPENGL|SDL_WINDOW_SHOWN);
glContext = SDL_GL_CreateContext(win);
SDL_GetWindowSize(win, &width, &height);
/* OpenGL */
glewExperimental = 1;
if (glewInit() != GLEW_OK)
die("[GLEW] failed setup\n");
glViewport(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT);
/* nanovg */
vg = nvgCreateGLES2(NVG_ANTIALIAS|NVG_DEBUG);
if (!vg) die("[NVG]: failed to init\n");
nvgCreateFont(vg, "fixed", font_path);
nvgFontFace(vg, "fixed");
nvgFontSize(vg, font_height);
nvgTextAlign(vg, NVG_ALIGN_LEFT|NVG_ALIGN_MIDDLE);
/* GUI */
memset(&in, 0, sizeof in);
memset(&gui, 0, sizeof gui);
gui.memory = malloc(MAX_MEMORY);
font.userdata.ptr = vg;
nvgTextMetrics(vg, NULL, NULL, &font.height);
font.width = font_get_width;
init_demo(&gui, &font);
while (gui.running) {
/* Input */
SDL_Event evt;
started = SDL_GetTicks();
gui_input_begin(&in);
while (SDL_PollEvent(&evt)) {
if (evt.type == SDL_WINDOWEVENT) resize(&evt);
else if (evt.type == SDL_QUIT) goto cleanup;
else if (evt.type == SDL_KEYUP) key(&in, &evt, gui_false);
else if (evt.type == SDL_KEYDOWN) key(&in, &evt, gui_true);
else if (evt.type == SDL_MOUSEBUTTONDOWN) btn(&in, &evt, gui_true);
else if (evt.type == SDL_MOUSEBUTTONUP) btn(&in, &evt, gui_false);
else if (evt.type == SDL_MOUSEMOTION) motion(&in, &evt);
else if (evt.type == SDL_TEXTINPUT) text(&in, &evt);
else if (evt.type == SDL_MOUSEWHEEL) gui_input_scroll(&in, evt.wheel.y);
}
gui_input_end(&in);
/* GUI */
SDL_GetWindowSize(win, &width, &height);
run_demo(&gui, &in);
/* Draw */
glClearColor(0.4f, 0.4f, 0.4f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
draw(vg, &gui.queue, width, height);
SDL_GL_SwapWindow(win);
/* Timing */
dt = SDL_GetTicks() - started;
if (dt < DTIME)
SDL_Delay(DTIME - dt);
}
cleanup:
/* Cleanup */
free(gui.memory);
nvgDeleteGLES2(vg);
SDL_GL_DeleteContext(glContext);
SDL_DestroyWindow(win);
SDL_Quit();
return 0;
}
SDL_Surface *
SDL_SetVideoMode(int width, int height, int bpp, Uint32 flags)
{
SDL_DisplayMode desktop_mode;
SDL_DisplayMode mode;
int window_x = SDL_WINDOWPOS_UNDEFINED;
int window_y = SDL_WINDOWPOS_UNDEFINED;
Uint32 window_flags;
Uint32 desktop_format;
Uint32 desired_format;
Uint32 surface_flags;
if (!SDL_GetVideoDevice()) {
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE) < 0) {
return NULL;
}
}
SDL_GetDesktopDisplayMode(&desktop_mode);
if (width == 0) {
width = desktop_mode.w;
}
if (height == 0) {
height = desktop_mode.h;
}
/* See if we can simply resize the existing window and surface */
if (SDL_ResizeVideoMode(width, height, bpp, flags) == 0) {
return SDL_PublicSurface;
}
/* Destroy existing window */
SDL_PublicSurface = NULL;
if (SDL_ShadowSurface) {
SDL_FreeSurface(SDL_ShadowSurface);
SDL_ShadowSurface = NULL;
}
if (SDL_VideoSurface) {
SDL_DelPaletteWatch(SDL_VideoSurface->format->palette,
SDL_VideoPaletteChanged, NULL);
SDL_FreeSurface(SDL_VideoSurface);
SDL_VideoSurface = NULL;
}
if (SDL_VideoContext) {
/* SDL_GL_MakeCurrent(0, NULL); *//* Doesn't do anything */
SDL_GL_DeleteContext(SDL_VideoContext);
SDL_VideoContext = NULL;
}
if (SDL_VideoWindow) {
SDL_GetWindowPosition(SDL_VideoWindow, &window_x, &window_y);
SDL_DestroyWindow(SDL_VideoWindow);
}
/* Set up the event filter */
if (!SDL_GetEventFilter(NULL, NULL)) {
SDL_SetEventFilter(SDL_CompatEventFilter, NULL);
}
/* Create a new window */
window_flags = SDL_WINDOW_SHOWN;
if (flags & SDL_FULLSCREEN) {
window_flags |= SDL_WINDOW_FULLSCREEN;
}
if (flags & SDL_OPENGL) {
window_flags |= SDL_WINDOW_OPENGL;
}
if (flags & SDL_RESIZABLE) {
window_flags |= SDL_WINDOW_RESIZABLE;
}
if (flags & SDL_NOFRAME) {
window_flags |= SDL_WINDOW_BORDERLESS;
}
GetEnvironmentWindowPosition(width, height, &window_x, &window_y);
SDL_SetFullscreenDisplayMode(NULL);
SDL_VideoWindow =
SDL_CreateWindow(wm_title, window_x, window_y, width, height,
window_flags);
if (!SDL_VideoWindow) {
return NULL;
}
SDL_SetWindowIcon(SDL_VideoWindow, SDL_VideoIcon);
window_flags = SDL_GetWindowFlags(SDL_VideoWindow);
surface_flags = 0;
if (window_flags & SDL_WINDOW_FULLSCREEN) {
surface_flags |= SDL_FULLSCREEN;
}
if (window_flags & SDL_WINDOW_OPENGL) {
surface_flags |= SDL_OPENGL;
}
if (window_flags & SDL_WINDOW_RESIZABLE) {
surface_flags |= SDL_RESIZABLE;
}
if (window_flags & SDL_WINDOW_BORDERLESS) {
surface_flags |= SDL_NOFRAME;
}
/* Set up the desired display mode */
desktop_format = desktop_mode.format;
if (desktop_format && ((flags & SDL_ANYFORMAT)
|| (bpp == SDL_BITSPERPIXEL(desktop_format)))) {
desired_format = desktop_format;
} else {
switch (bpp) {
case 0:
if (desktop_format) {
desired_format = desktop_format;
} else {
desired_format = SDL_PIXELFORMAT_RGB888;
}
bpp = SDL_BITSPERPIXEL(desired_format);
break;
case 8:
desired_format = SDL_PIXELFORMAT_INDEX8;
break;
case 15:
desired_format = SDL_PIXELFORMAT_RGB555;
break;
case 16:
desired_format = SDL_PIXELFORMAT_RGB565;
break;
case 24:
desired_format = SDL_PIXELFORMAT_RGB24;
break;
case 32:
desired_format = SDL_PIXELFORMAT_RGB888;
break;
default:
SDL_SetError("Unsupported bpp in SDL_SetVideoMode()");
return NULL;
}
}
mode.format = desired_format;
mode.w = width;
mode.h = height;
mode.refresh_rate = 0;
/* Set the desired display mode */
if (flags & SDL_FULLSCREEN) {
if (SDL_SetFullscreenDisplayMode(&mode) < 0) {
return NULL;
}
}
/* If we're in OpenGL mode, just create a stub surface and we're done! */
if (flags & SDL_OPENGL) {
SDL_VideoContext = SDL_GL_CreateContext(SDL_VideoWindow);
if (!SDL_VideoContext) {
return NULL;
}
if (SDL_GL_MakeCurrent(SDL_VideoWindow, SDL_VideoContext) < 0) {
return NULL;
}
SDL_VideoSurface =
SDL_CreateRGBSurfaceFrom(NULL, width, height, bpp, 0, 0, 0, 0, 0);
if (!SDL_VideoSurface) {
return NULL;
}
SDL_VideoSurface->flags |= surface_flags;
SDL_PublicSurface = SDL_VideoSurface;
return SDL_PublicSurface;
}
/* Create a renderer for the window */
if (SDL_CreateRenderer
(SDL_VideoWindow, -1,
SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTDISCARD) < 0) {
return NULL;
}
SDL_GetRendererInfo(&SDL_VideoRendererInfo);
/* Create a texture for the screen surface */
SDL_VideoTexture =
SDL_CreateTexture(desired_format, SDL_TEXTUREACCESS_STREAMING, width,
height);
if (!SDL_VideoTexture) {
SDL_VideoTexture =
SDL_CreateTexture(desktop_format,
SDL_TEXTUREACCESS_STREAMING, width, height);
}
if (!SDL_VideoTexture) {
return NULL;
}
/* Create the screen surface */
SDL_VideoSurface = CreateVideoSurface(SDL_VideoTexture);
if (!SDL_VideoSurface) {
return NULL;
}
SDL_VideoSurface->flags |= surface_flags;
/* Set a default screen palette */
if (SDL_VideoSurface->format->palette) {
SDL_VideoSurface->flags |= SDL_HWPALETTE;
SDL_DitherColors(SDL_VideoSurface->format->palette->colors,
SDL_VideoSurface->format->BitsPerPixel);
SDL_AddPaletteWatch(SDL_VideoSurface->format->palette,
SDL_VideoPaletteChanged, SDL_VideoSurface);
SDL_SetPaletteColors(SDL_VideoSurface->format->palette,
SDL_VideoSurface->format->palette->colors, 0,
SDL_VideoSurface->format->palette->ncolors);
}
/* Create a shadow surface if necessary */
if ((bpp != SDL_VideoSurface->format->BitsPerPixel)
&& !(flags & SDL_ANYFORMAT)) {
SDL_ShadowSurface =
SDL_CreateRGBSurface(0, width, height, bpp, 0, 0, 0, 0);
if (!SDL_ShadowSurface) {
return NULL;
}
SDL_ShadowSurface->flags |= surface_flags;
/* 8-bit SDL_ShadowSurface surfaces report that they have exclusive palette */
if (SDL_ShadowSurface->format->palette) {
SDL_ShadowSurface->flags |= SDL_HWPALETTE;
if (SDL_VideoSurface->format->palette) {
SDL_SetSurfacePalette(SDL_ShadowSurface,
SDL_VideoSurface->format->palette);
} else {
SDL_DitherColors(SDL_ShadowSurface->format->palette->colors,
SDL_ShadowSurface->format->BitsPerPixel);
}
SDL_AddPaletteWatch(SDL_ShadowSurface->format->palette,
SDL_VideoPaletteChanged, SDL_ShadowSurface);
}
}
SDL_PublicSurface =
(SDL_ShadowSurface ? SDL_ShadowSurface : SDL_VideoSurface);
SDL_VideoFlags = flags;
ClearVideoSurface();
SetupScreenSaver(flags);
/* We're finally done! */
return SDL_PublicSurface;
}
int main(int argc, char* argv[]) {
char* b3dFilePath;
/* camera variables */
float angleX = 0.f, angleY = 0.f;
float positionX = 0.f, positionY = 0.f, positionZ = 0.f;
/* camera movement variables */
float forwardX = 0.f, forwardY = 0.f, forwardZ = 1.f;
float rightX = 1.f, rightY = 0.f, rightZ = 0.f;
/* memory to store only the rotation transform of the view matrix */
float viewRotation[16];
if (argc < 2) b3dFilePath = "test1/test1.b3d";
else b3dFilePath = argv[1];
b3dTest = loadB3DFile(b3dFilePath);
/*
printf("textures:\n");
printf("directory: %s\n", getDirectoryFromFile(b3dTest));
printf("texture count: %d\n", getNumberOfTexturesFromBRUSChunk(getBRUSChunkFromBB3DChunk(getBB3DChunkFromFile(b3dTest))));
*/
SDL_Init(SDL_INIT_VIDEO);
glWindow = SDL_CreateWindow("B3D Lightmap Viewer", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_OPENGL);
glContext = SDL_GL_CreateContext(glWindow);
glActiveTextureARB = SDL_GL_GetProcAddress("glActiveTextureARB");
glClientActiveTextureARB = SDL_GL_GetProcAddress("glClientActiveTextureARB");
keyPress = SDL_GetKeyboardState(NULL);
/* multitexture setup */
/* commentary: possible support for more than 2 texture layers? if necessary. */
textures = loadTextures(b3dTest);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glActiveTextureARB(GL_TEXTURE0_ARB);
glEnable(GL_TEXTURE_2D);
glActiveTextureARB(GL_TEXTURE1_ARB);
glEnable(GL_TEXTURE_2D);
/* OpenGL initial setup */
glClearColor(0.f, 0.f, 0.5f, 1.f);
glEnable(GL_DEPTH_TEST);
glMatrixMode(GL_PROJECTION);
gluPerspective(70.0, 1.333, 10, 10000);
glMatrixMode(GL_MODELVIEW);
/* main loop */
while (!quit) {
int differentialX = 0, differentialY = 0;
int mouseStates = 0;
while (SDL_PollEvent(&event)) {
if (event.type == SDL_QUIT) quit = 1;
}
if (keyPress[SDL_SCANCODE_ESCAPE]) quit = 1;
mouseStates = SDL_GetRelativeMouseState(&differentialX, &differentialY);
/* change camera orientation when mouse dragged */
if (mouseStates & SDL_BUTTON(SDL_BUTTON_LEFT)) {
angleX -= MOUSE_VERTICAL_SENSITIVITY * differentialY;
angleY -= MOUSE_HORIZONTAL_SENSITIVITY * differentialX;
}
/* use existing base vectors in view rotation matrix for movement */
forwardX = viewRotation[2];
forwardY = viewRotation[6];
forwardZ = viewRotation[10];
rightX = viewRotation[0];
rightY = viewRotation[4];
rightZ = viewRotation[8];
/* move camera forward when W pressed */
if (keyPress[SDL_SCANCODE_W]) {
positionX -= CAMERA_SPEED * forwardX;
positionY -= CAMERA_SPEED * forwardY;
positionZ -= CAMERA_SPEED * forwardZ;
}
/* move camera left when A pressed */
if (keyPress[SDL_SCANCODE_A]) {
positionX -= CAMERA_SPEED * rightX;
positionY -= CAMERA_SPEED * rightY;
positionZ -= CAMERA_SPEED * rightZ;
}
/* move camera backward when S pressed */
if (keyPress[SDL_SCANCODE_S]) {
positionX += CAMERA_SPEED * forwardX;
positionY += CAMERA_SPEED * forwardY;
positionZ += CAMERA_SPEED * forwardZ;
}
/* move camera right when D pressed */
if (keyPress[SDL_SCANCODE_D]) {
positionX += CAMERA_SPEED * rightX;
positionY += CAMERA_SPEED * rightY;
positionZ += CAMERA_SPEED * rightZ;
}
/* reset camera position and orientation when R pressed */
if (keyPress[SDL_SCANCODE_R]) {
positionX = 0.f;
positionY = 0.f;
positionZ = 0.f;
angleX = 0.f;
angleY = 0.f;
}
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
/* construct the view matrix */
glLoadIdentity();
glRotatef(-angleX, 1.f, 0.f, 0.f);
glRotatef(-angleY, 0.f, 1.f, 0.f);
glGetFloatv(GL_MODELVIEW_MATRIX, viewRotation);
glTranslatef(-positionX, -positionY, -positionZ);
glScalef(1.f, 1.f, -1.f);
drawB3D(b3dTest);
SDL_GL_SwapWindow(glWindow);
SDL_Delay(16);
}
/* commentary: still need to clear the loaded data from memory */
SDL_DestroyWindow(glWindow);
SDL_Quit();
return 0;
}
static bool
_cg_winsys_display_setup(cg_display_t *display, cg_error_t **error)
{
cg_display_sdl2_t *sdl_display;
const char *(*get_string_func)(GLenum name);
const char *gl_version;
c_return_val_if_fail(display->winsys == NULL, false);
sdl_display = c_slice_new0(cg_display_sdl2_t);
display->winsys = sdl_display;
set_gl_attribs_from_framebuffer_config(&display->onscreen_template->config);
if (display->renderer->driver == CG_DRIVER_GLES2) {
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK,
SDL_GL_CONTEXT_PROFILE_ES);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
} else if (display->renderer->driver == CG_DRIVER_GL3) {
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK,
SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS,
SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG);
}
/* Create a dummy 1x1 window that never gets display so that we can
* create a GL context */
sdl_display->dummy_window =
SDL_CreateWindow("",
0,
0, /* x/y */
1,
1, /* w/h */
SDL_WINDOW_OPENGL | SDL_WINDOW_HIDDEN);
if (sdl_display->dummy_window == NULL) {
_cg_set_error(error,
CG_WINSYS_ERROR,
CG_WINSYS_ERROR_INIT,
"SDL_CreateWindow failed: %s",
SDL_GetError());
goto error;
}
sdl_display->context = SDL_GL_CreateContext(sdl_display->dummy_window);
if (sdl_display->context == NULL) {
_cg_set_error(error,
CG_WINSYS_ERROR,
CG_WINSYS_ERROR_INIT,
"SDL_GL_CreateContext failed: %s",
SDL_GetError());
goto error;
}
/* SDL doesn't seem to provide a way to select between GL and GLES
* and instead it will just pick one itself. We can at least try to
* verify that it picked the one we were expecting by looking at the
* GL version string */
get_string_func = SDL_GL_GetProcAddress("glGetString");
gl_version = get_string_func(GL_VERSION);
switch (display->renderer->driver) {
case CG_DRIVER_GL:
case CG_DRIVER_GL3:
/* The first character of the version string will be a digit if
* it's normal GL */
if (!c_ascii_isdigit(gl_version[0])) {
_cg_set_error(error,
CG_WINSYS_ERROR,
CG_WINSYS_ERROR_INIT,
"The GL driver was requested but SDL is using GLES");
goto error;
}
if (display->renderer->driver == CG_DRIVER_GL3 && gl_version[0] < '3') {
_cg_set_error(error,
CG_WINSYS_ERROR,
CG_WINSYS_ERROR_INIT,
"The GL3 driver was requested but SDL is using "
"GL %c",
gl_version[0]);
goto error;
}
break;
case CG_DRIVER_GLES2:
if (!c_str_has_prefix(gl_version, "OpenGL ES 2") &&
!c_str_has_prefix(gl_version, "OpenGL ES 3")) {
_cg_set_error(error,
CG_WINSYS_ERROR,
CG_WINSYS_ERROR_INIT,
"The GLES2 driver was requested but SDL is "
"not using GLES2 or GLES3");
goto error;
}
break;
default:
c_assert_not_reached();
}
return true;
error:
_cg_winsys_display_destroy(display);
return false;
}
int main(int argc, char *argv[]) {
int done;
SDL_Event event;
int width, height;
struct sth_stash* stash = 0;
FILE* fp = 0;
int datasize;
unsigned char* data;
float sx,sy,dx,dy,lh;
int droidRegular, droidItalic, droidBold, droidJapanese, dejavu;
SDL_Surface* surface;
GLuint texture;
if (SDL_Init(SDL_INIT_EVERYTHING) < 0)
{
fprintf(stderr, "Couldn't initialize SDL: %s\n", SDL_GetError());
return -1;
}
// Init OpenGL
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
#ifdef STH_OPENGL3
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
#endif
width = 800;
height = 600;
SDL_Window* window = SDL_CreateWindow("FontStash Demo", 100, 100, width, height, SDL_WINDOW_OPENGL);
if (!window)
{
fprintf(stderr, "Could not initialise SDL opengl\n");
return -1;
}
SDL_GLContext context = SDL_GL_CreateContext(window);
stash = sth_create(512,512);
if (!stash)
{
fprintf(stderr, "Could not create stash.\n");
return -1;
}
// Load the first truetype font from memory (just because we can).
fp = fopen("DroidSerif-Regular.ttf", "rb");
if (!fp) goto error_add_font;
fseek(fp, 0, SEEK_END);
datasize = (int)ftell(fp);
fseek(fp, 0, SEEK_SET);
data = (unsigned char*)malloc(datasize);
if (data == NULL) goto error_add_font;
fread(data, 1, datasize, fp);
fclose(fp);
fp = 0;
if (!(droidRegular = sth_add_font_from_memory(stash, data)))
goto error_add_font;
// Load the remaining truetype fonts directly.
if (!(droidItalic = sth_add_font(stash,"DroidSerif-Italic.ttf")))
goto error_add_font;
if (!(droidBold = sth_add_font(stash,"DroidSerif-Bold.ttf")))
goto error_add_font;
if (!(droidJapanese = sth_add_font(stash,"DroidSansJapanese.ttf")))
goto error_add_font;
// Load a bitmap font
surface = IMG_Load("dejavu-sans_0.png");
if (surface == NULL)
{
fprintf(stderr, "%s.\n", IMG_GetError());
return -1;
}
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
if (SDL_MUSTLOCK(surface)) SDL_LockSurface(surface);
glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA8, surface->w, surface->h, 0, GL_ALPHA, GL_UNSIGNED_BYTE, surface->pixels);
if (SDL_MUSTLOCK(surface)) SDL_UnlockSurface(surface);
SDL_FreeSurface(surface);
dejavu = sth_add_bitmap_font(stash, 17, -4, 2);
sth_add_glyph_for_char(stash, dejavu, texture, "T", 18, 14, 363, 331, 10, 11, 0, 3, 10);
sth_add_glyph_for_char(stash, dejavu, texture, "h", 18, 14, 225, 382, 8, 11, 1, 3, 10);
sth_add_glyph_for_char(stash, dejavu, texture, "i", 18, 14, 478, 377, 2, 11, 1, 3, 4);
sth_add_glyph_for_char(stash, dejavu, texture, "s", 18, 14, 199, 455, 7, 8, 1, 6, 9);
sth_add_glyph_for_char(stash, dejavu, texture, " ", 18, 14, 66, 185, 1, 1, 0, 14, 5);
sth_add_glyph_for_char(stash, dejavu, texture, "a", 18, 14, 18, 459, 8, 8, 1, 6, 10);
sth_add_glyph_for_char(stash, dejavu, texture, "b", 18, 14, 198, 383, 8, 11, 1, 3, 10);
sth_add_glyph_for_char(stash, dejavu, texture, "t", 18, 14, 436, 377, 5, 11, 1, 3, 6);
sth_add_glyph_for_char(stash, dejavu, texture, "m", 18, 14, 494, 429, 12, 8, 2, 6, 16);
sth_add_glyph_for_char(stash, dejavu, texture, "p", 18, 14, 436, 353, 8, 11, 1, 6, 10);
sth_add_glyph_for_char(stash, dejavu, texture, "f", 18, 14, 442, 377, 5, 11, 1, 3, 7);
sth_add_glyph_for_char(stash, dejavu, texture, "o", 18, 14, 483, 438, 8, 8, 1, 6, 10);
sth_add_glyph_for_char(stash, dejavu, texture, "n", 18, 14, 0, 459, 8, 8, 1, 6, 10);
sth_add_glyph_for_char(stash, dejavu, texture, ".", 18, 14, 285, 476, 2, 3, 1, 11, 6);
done = 0;
while (!done)
{
while (SDL_PollEvent(&event))
{
switch (event.type)
{
case SDL_MOUSEMOTION:
break;
case SDL_MOUSEBUTTONDOWN:
break;
case SDL_KEYDOWN:
if (event.key.keysym.sym == SDLK_ESCAPE)
done = 1;
break;
case SDL_QUIT:
done = 1;
break;
default:
break;
}
}
// Update and render
glViewport(0, 0, width, height);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glClearColor(0.3f, 0.3f, 0.32f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
#ifdef STH_OPENGL3
std::cout << "OpenGL3" << std::endl;
glm::mat4 proj = glm::ortho(0.0f, (GLfloat) width, 0.0f, (GLfloat) height, -1.0f, 1.0f);
sth_projection_matrix(stash, glm::value_ptr(proj));
sth_color(stash, 1.0f, 0.0f, 0.0f, 1.0f);
#else
std::cout << "Immediate OpenGL" << std::endl;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0,width,0,height,-1,1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glColor4ub(255,255,255,255);
#endif
sx = 100; sy = 250;
sth_begin_draw(stash);
dx = sx; dy = sy;
sth_draw_text(stash, droidRegular, 24.0f, dx, dy, "The quick ", &dx);
sth_draw_text(stash, droidItalic, 48.0f, dx, dy, "brown ", &dx);
sth_draw_text(stash, droidRegular, 24.0f, dx, dy, "fox ", &dx);
sth_vmetrics(stash, droidItalic, 24, NULL, NULL, &lh);
dx = sx;
dy -= lh*1.2f;
sth_draw_text(stash, droidItalic, 24.0f, dx, dy, "jumps over ", &dx);
sth_draw_text(stash, droidBold, 24.0f, dx, dy, "the lazy ", &dx);
sth_draw_text(stash, droidRegular, 24.0f, dx, dy, "dog.", &dx);
dx = sx;
dy -= lh*1.2f;
sth_draw_text(stash, droidRegular, 12.0f, dx, dy, "Now is the time for all good men to come to the aid of the party.", &dx);
sth_vmetrics(stash, droidItalic, 12, NULL, NULL, &lh);
dx = sx;
dy -= lh*1.2f*2;
sth_draw_text(stash, droidItalic, 18.0f, dx, dy, "Ég get etið gler án þess að meiða mig.", &dx);
sth_vmetrics(stash, droidItalic, 18, NULL, NULL, &lh);
dx = sx;
dy -= lh*1.2f;
sth_draw_text(stash, droidJapanese, 18.0f, dx, dy, "私はガラスを食べられます。それは私を傷つけません。", &dx);
dx = sx;
dy -= lh*1.2f*2;
sth_draw_text(stash, dejavu, 18.0f, dx, dy, "This is a bitmap font.", &dx);
sth_end_draw(stash);
SDL_GL_SwapWindow(window);
}
sth_delete(stash);
free(data);
SDL_GL_DeleteContext(context);
SDL_Quit();
return 0;
error_add_font:
fprintf(stderr, "Could not add font.\n");
return -1;
}
bool
GLAppSDL::initialize(int argc, char* argv[])
{
if (!AppBaseSDL::initialize(argc, argv))
return false;
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, profile);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, majorVersion);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, minorVersion);
#if defined(DEBUG)
SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG);
#endif
if (profile == SDL_GL_CONTEXT_PROFILE_ES) {
#if 0
int numVideoDrivers = SDL_GetNumVideoDrivers();
int i;
const char** drivers;
drivers = (const char**)SDL_malloc(sizeof(const char*) * numVideoDrivers);
for (i = 0; i < numVideoDrivers; i++) {
drivers[i] = SDL_GetVideoDriver(i);
}
#endif
// Only the indicated platforms pay attention to these hints
// but they could be set on any platform.
#if __WINDOWS__ || __LINUX__
SDL_SetHint(SDL_HINT_OPENGL_ES_DRIVER, "1");
#endif
#if __WINDOWS__
// If using ANGLE copied from Chrome should set to "d3dcompiler_46.dll"
// Should set value via compiler -D definition from gyp file.
SDL_SetHint(SDL_HINT_VIDEO_WIN_D3DCOMPILER, "none");
#endif
}
#if __MACOSX__
SDL_SetHint(SDL_HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK, "1");
#endif
pswMainWindow = SDL_CreateWindow(
szName,
SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
w_width, w_height,
SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE
);
if (pswMainWindow == NULL) {
(void)SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, szName, SDL_GetError(), NULL);
return false;
}
#if __WINDOWS__
// Set the applications own icon in place of the Windows default set by SDL.
// Needs to be done here to avoid change being visible.
setWindowsIcon(pswMainWindow);
#endif
sgcGLContext = SDL_GL_CreateContext(pswMainWindow);
// Work around bug in SDL. It returns a 2.x context when 3.x is requested.
// It does though internally record an error.
const char* error = SDL_GetError();
if (sgcGLContext == NULL
|| (error[0] != '\0'
&& majorVersion >= 3
&& (profile == SDL_GL_CONTEXT_PROFILE_CORE
|| profile == SDL_GL_CONTEXT_PROFILE_COMPATIBILITY))
) {
(void)SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, szName, SDL_GetError(), NULL);
return false;
}
#if __WINDOWS__
if (profile != SDL_GL_CONTEXT_PROFILE_ES)
{
// No choice but to use GLEW for GL on Windows; there is no .lib with static
// bindings. For ES we use one of the hardware vendor SDKs all of which have
// static bindings.
// TODO: Figure out how to support {GLX,WGL}_EXT_create_context_es2_profile
// were there are no static bindings. Need a GLEW equivalent for ES and
// different compile options. Perhaps can borrow function loading stuff
// from SDL's testgles2.c.
// So one build of this library can be linked in to applications using GLEW and
// applications not using GLEW, do not call any GLEW functions directly.
// Call via queried function pointers.
void* glewdll = SDL_LoadObject("glew32.dll");
if (glewdll == NULL) {
std::string sName(szName);
(void)SDL_ShowSimpleMessageBox(
SDL_MESSAGEBOX_ERROR,
szName,
SDL_GetError(),
NULL);
return false;
}
typedef GLenum(GLEWAPIENTRY PFNGLEWINIT)(void);
typedef const GLubyte * GLEWAPIENTRY PFNGLEWGETERRORSTRING(GLenum error);
PFNGLEWINIT* pGlewInit;
PFNGLEWGETERRORSTRING* pGlewGetErrorString;
bool error = true;
#define STR(s) #s
#if defined(_M_IX86)
/* Win32 GLEW uses __stdcall. */
#define DNAMESTR(x,n) STR(_##x##@##n)
#else
/* x64 uses __cdecl. */
#define DNAMESTR(x,n) STR(x)
#endif
pGlewInit = (PFNGLEWINIT*)SDL_LoadFunction(glewdll, DNAMESTR(glewInit,0));
if (pGlewInit != NULL) {
pGlewGetErrorString = (PFNGLEWGETERRORSTRING*)SDL_LoadFunction(
glewdll, DNAMESTR(glewGetErrorString,4));
if (pGlewGetErrorString != NULL) {
error = false;
}
}
if (error) {
std::string sName(szName);
(void)SDL_ShowSimpleMessageBox(
SDL_MESSAGEBOX_ERROR,
szName,
SDL_GetError(),
NULL);
return false;
}
int iResult = pGlewInit();
if (iResult != GLEW_OK) {
std::string sName(szName);
(void)SDL_ShowSimpleMessageBox(
SDL_MESSAGEBOX_ERROR,
szName,
(const char*)pGlewGetErrorString(iResult),
NULL);
return false;
}
}
// SDL wants main() to have this exact signature
extern "C" int main(int argc, char* argv[])
{
// Initialize SDL
if (SDL_Init(SDL_INIT_VIDEO))
{
fprintf(stderr, "SDL_Init: %s\n", SDL_GetError());
return 1;
}
// Plain 32-bit RGBA8 pixel format
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
// Don't need built-in depth buffer, we use our own.
//SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 0);
// Select OpenGL version
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
#ifdef _DEBUG
SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG);
#endif
// Create the window
SDL_Window* window = SDL_CreateWindow("OpenGL", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, WINDOW_WIDTH, WINDOW_HEIGHT, SDL_WINDOW_OPENGL);
if (!window)
{
fprintf(stderr, "SDL_CreateWindow: %s\n", SDL_GetError());
return 1;
}
// Create the OpenGL context
SDL_GLContext context = SDL_GL_CreateContext(window);
if (!context)
{
fprintf(stderr, "SDL_GL_CreateContext: %s\n", SDL_GetError());
return 1;
}
// Initialize OpenGL (must be called before calling any OpenGL functions)
OpenGL_Init();
// DEBUG: print OpenGL version
const GLubyte* version = glGetString(GL_VERSION);
fprintf(stdout, "OpenGL Version: %s\n", version);
//======================== VAO ===============================
// Hook up the vertex and index buffers to a "vertex array object" (VAO)
// VAOs are the closest thing OpenGL has to a "mesh" object.
// VAOs are used to feed data from buffers to thgle inputs of a vertex shader.
//============================================================
//===================== VBO/EBO ===============================
Skybox skyBox = Skybox();
skyBox.load();
TerrainMesh terrainMesh = TerrainMesh(64, 64, 0.0);
terrainMesh.load();
//============================================================
//===================== TEXTURES =============================
//============================================================
//======================= SHADERS ============================
// init terrain shader
ShaderSet terrainShaderSet;
terrainShaderSet.SetVersion("330");
// set uniforms (use preambles here or define them in the shader file, but NOT both)
terrainShaderSet.SetPreamble(
"uniform mat4 iModelViewProjection;\n"
"uniform mat4 iModel;\n"
"uniform mat4 iView;\n"
"uniform vec3 iLightPosition_worldspace;\n"
"uniform sampler2DArray iTextureArray;\n"
);
GLuint* terrainShaderId = terrainShaderSet.AddProgramFromExts({ "a3.vert", "a3.frag" });
// init skybox shader
ShaderSet skyboxShaderSet;
skyboxShaderSet.SetVersion("330");
// set uniforms (use preambles here or define them in the shader file, but NOT both)
skyboxShaderSet.SetPreamble(
"uniform mat4 iProjection;\n"
"uniform mat4 iView;\n"
"uniform samplerCube iSkyBoxCubeTexture;\n"
);
GLuint* skyboxShaderId = skyboxShaderSet.AddProgramFromExts({ "skybox.vert", "skybox.frag" });
//============================================================
//======================== LIGHTS ============================
glm::vec3 light = glm::vec3(4, 40, 4);
//============================================================
//================== BEZIER CURVES ===========================
glm::vec3 xzLength = glm::vec3(32.0, 0.0, 32.0);
glm::vec3 yPull = glm::vec3(0.0, 20.0, 0.0);
glm::vec3 xPull = glm::vec3(20.0, 0.0, 0.0);
CubicBezierCurve bezierCurve1 = CubicBezierCurve(light, xzLength, yPull, yPull);
CubicBezierCurve bezierCurve2 = CubicBezierCurve(bezierCurve1.p3, xzLength, -yPull, -yPull);
CubicBezierCurve bezierCurve3 = CubicBezierCurve(bezierCurve2.p3, -xzLength, xPull, xPull);
CubicBezierCurve bezierCurve4 = CubicBezierCurve(bezierCurve3.p3, -xzLength, -xPull, -xPull);
BezierPath bezierPath = BezierPath(std::vector<CubicBezierCurve>{ bezierCurve1, bezierCurve2, bezierCurve3, bezierCurve4 });
//============================================================
// Begin main loop
double lastTime = 0;
InputHandler inputHandler = InputHandler(window);
Camera camera = Camera(4, 40, 4);
float bezierTime = 0.0;
const float bezierSpeed = 0.001;
while (1)
{
//================= UPDATE USER INPUT ========================
double currentTime = SDL_GetTicks() / 1000.0;
float deltaTime = float(currentTime - lastTime);
if (inputHandler.updateInput(deltaTime) == -1)
{
goto quit;
}
camera.update(inputHandler.getInputData(), deltaTime);
lastTime = currentTime;
//============================================================
//================= COMPUTE MATRICES =========================
// move camera position along bezier curve
glm::vec3 bezPos = bezierPath.getPointAt(bezierTime);
bezierTime += bezierSpeed;
bezierTime = (bezierTime > 1.0) ? 0.0 : bezierTime;
camera.position = bezPos;
// Projection matrix
glm::mat4 Projection = glm::perspective(
camera.FoV,
camera.aspectRatio,
camera.nearClip,
camera.farClip
);
// Or, for an ortho camera :
//glm::mat4 Projection = glm::ortho(-10.0f,10.0f,-10.0f,10.0f,0.0f,100.0f); // In world coordinates
// Camera matrix
glm::mat4 View = glm::lookAt(
camera.position,
camera.position + camera.direction,
camera.up
);
// Model matrix : an identity matrix (model will be at the origin)
glm::mat4 Model = glm::mat4(1.0f);
// Our ModelViewProjection : multiplication of our 3 matrices
glm::mat4 ModelViewProjection = Projection * View * Model; // Remember, matrix multiplication is the other way around
//glm::mat4 ModelViewProjection = MVP;
//============================================================
//================== UPDATE SHADERS ==========================
// Set the color to clear with
//glClearColor(100.0f / 255.0f, 149.0f / 255.0f, 237.0f / 255.0f, 1.0f);
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
// Clear the screen
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//===================== Z-BUFFER =============================
// Enable depth test
glEnable(GL_DEPTH_TEST);
// Accept fragment if it closer to the camera than the former one
glDepthFunc(GL_LESS);
// TERRAIN ======================================================
// Recompile/relink any programs that changed (must be called)
terrainShaderSet.UpdatePrograms();
// set OpenGL's shader program (must be called in loop)
glUseProgram(*terrainShaderId);
// get uniform handles
GLuint iModelViewProjectionLoc = glGetUniformLocation(*terrainShaderId, "iModelViewProjection");
GLuint iModelLoc = glGetUniformLocation(*terrainShaderId, "iModel");
GLuint iViewLoc = glGetUniformLocation(*terrainShaderId, "iView");
GLuint iLightPosition_worldspaceLoc = glGetUniformLocation(*terrainShaderId, "iLightPosition_worldspace");
// send matrix uniforms to shader
if (iModelViewProjectionLoc != -1)
{
glUniformMatrix4fv(iModelViewProjectionLoc, 1, GL_FALSE, &ModelViewProjection[0][0]);
}
if (iModelLoc != -1)
{
glUniformMatrix4fv(iModelLoc, 1, GL_FALSE, &Model[0][0]);
}
if (iViewLoc != -1)
{
glUniformMatrix4fv(iViewLoc, 1, GL_FALSE, &View[0][0]);
}
// pass light position uniform to shader
if (iLightPosition_worldspaceLoc != -1)
{
glUniform3f(iLightPosition_worldspaceLoc, light.x, light.y, light.z);
}
terrainMesh.generateTextureUniform(terrainShaderId, "iTextureArray");
terrainMesh.attachToVAO(0, 1, 2, 3);
terrainMesh.draw();
// SKYBOX ========================================================
// Recompile/relink any programs that changed (must be called)
skyboxShaderSet.UpdatePrograms();
// set OpenGL's shader program (must be called in loop)
glUseProgram(*skyboxShaderId);
// get skybox shader uniform handles
GLuint iSkyBoxViewLoc = glGetUniformLocation(*skyboxShaderId, "iView");
GLuint iSkyBoxProjectionLoc = glGetUniformLocation(*skyboxShaderId, "iProjection");
if (iSkyBoxViewLoc != -1)
{
// remove the translation component of the view matrix
// to make sure the skybox's origin is always at the camera
glm::mat4 newView = glm::mat4(glm::mat3(View));
glUniformMatrix4fv(iSkyBoxViewLoc, 1, GL_FALSE, &newView[0][0]);
}
if (iSkyBoxProjectionLoc != -1)
{
glUniformMatrix4fv(iSkyBoxProjectionLoc, 1, GL_FALSE, &Projection[0][0]);
}
// generate uniforms for object textures
skyBox.generateTextureUniform(skyboxShaderId, "iSkyBoxCubeTexture");
skyBox.attachToVAO(4);
skyBox.draw();
// draw wireframe of mesh
//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
// check for errors
GLenum err2;
while ((err2 = glGetError()) != GL_NO_ERROR) {
std::cerr << "OpenGL error: " << err2 << std::endl;
}
// disable the depth buffer
glDisable(GL_DEPTH_TEST);
// SDL docs: "On Mac OS X make sure you bind 0 to the draw framebuffer before swapping the window, otherwise nothing will happen."
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
// Display the frame of rendering to the window
SDL_GL_SwapWindow(window);
}
quit:
SDL_Quit();
return 0;
}
int main(void) {
/* SDL variables. */
SDL_Event event;
SDL_Window *window;
SDL_GLContext gl_context;
const unsigned int WINDOW_WIDTH = 500, WINDOW_HEIGHT = WINDOW_WIDTH;
double dt, initial_time;
/* OpenGL variables. */
GLint
attribute_coord2d,
ibo_size,
width_location,
height_location,
time_location,
periods_x_location,
periods_y_location,
pi2_location,
program
;
GLuint ibo, vbo;
const char *attribute_name = "coord2d";
const float
periods_x = 10.0,
periods_y = 10.0,
pi2 = 2.0 * acos(-1.0)
;
/* SDL init. */
SDL_Init(SDL_INIT_TIMER | SDL_INIT_VIDEO);
window = SDL_CreateWindow(__FILE__, 0, 0,
WINDOW_WIDTH, WINDOW_HEIGHT, SDL_WINDOW_OPENGL);
gl_context = SDL_GL_CreateContext(window);
glewInit();
/* OpenGL init. */
{
program = common_get_shader_program(vertex_shader_source, fragment_shader_source);
attribute_coord2d = glGetAttribLocation(program, attribute_name);
if (attribute_coord2d == -1) {
fprintf(stderr, "error: attribute_coord2d: %s\n", attribute_name);
return EXIT_FAILURE;
}
height_location = glGetUniformLocation(program, "height");
periods_x_location = glGetUniformLocation(program, "periods_x");
periods_y_location = glGetUniformLocation(program, "periods_y");
pi2_location = glGetUniformLocation(program, "pi2");
time_location = glGetUniformLocation(program, "time");
width_location = glGetUniformLocation(program, "width");
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glUseProgram(program);
glViewport(0, 0, WIDTH, HEIGHT);
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glGenBuffers(1, &ibo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indexes), indexes, GL_STATIC_DRAW);
glGetBufferParameteriv(GL_ELEMENT_ARRAY_BUFFER, GL_BUFFER_SIZE, &ibo_size);
glUniform1f(pi2_location, pi2);
glUniform1f(width_location, WIDTH);
glUniform1f(height_location, HEIGHT);
glUniform1f(periods_x_location, periods_x);
glUniform1f(periods_y_location, periods_y);
}
initial_time = common_get_secs();
common_fps_init();
while (1) {
dt = common_get_secs() - initial_time;
/* OpenGL draw. */
glClear(GL_COLOR_BUFFER_BIT);
glEnableVertexAttribArray(attribute_coord2d);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glVertexAttribPointer(attribute_coord2d, 2, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
glUniform1f(time_location, dt);
glDrawElements(GL_TRIANGLES, ibo_size / sizeof(indexes[0]), GL_UNSIGNED_INT, 0);
glDisableVertexAttribArray(attribute_coord2d);
common_fps_update_and_print();
SDL_GL_SwapWindow(window);
if (SDL_PollEvent(&event) && event.type == SDL_QUIT)
break;
}
/* OpenGL cleanup. */
glDeleteBuffers(1, &ibo);
glDeleteBuffers(1, &vbo);
glDeleteProgram(program);
/* SDL cleanup. */
SDL_GL_DeleteContext(gl_context);
SDL_DestroyWindow(window);
SDL_Quit();
return EXIT_SUCCESS;
}
/*
===================
GLimp_Init
===================
*/
bool GLimp_Init( glimpParms_t parms )
{
common->Printf( "Initializing OpenGL subsystem\n" );
GLimp_PreInit(); // DG: make sure SDL is initialized
// DG: make window resizable
Uint32 flags = SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE;
// DG end
if( parms.fullScreen )
flags |= SDL_WINDOW_FULLSCREEN;
int colorbits = 24;
int depthbits = 24;
int stencilbits = 8;
for( int i = 0; i < 16; i++ )
{
// 0 - default
// 1 - minus colorbits
// 2 - minus depthbits
// 3 - minus stencil
if( ( i % 4 ) == 0 && i )
{
// one pass, reduce
switch( i / 4 )
{
case 2 :
if( colorbits == 24 )
colorbits = 16;
break;
case 1 :
if( depthbits == 24 )
depthbits = 16;
else if( depthbits == 16 )
depthbits = 8;
case 3 :
if( stencilbits == 24 )
stencilbits = 16;
else if( stencilbits == 16 )
stencilbits = 8;
}
}
int tcolorbits = colorbits;
int tdepthbits = depthbits;
int tstencilbits = stencilbits;
if( ( i % 4 ) == 3 )
{
// reduce colorbits
if( tcolorbits == 24 )
tcolorbits = 16;
}
if( ( i % 4 ) == 2 )
{
// reduce depthbits
if( tdepthbits == 24 )
tdepthbits = 16;
else if( tdepthbits == 16 )
tdepthbits = 8;
}
if( ( i % 4 ) == 1 )
{
// reduce stencilbits
if( tstencilbits == 24 )
tstencilbits = 16;
else if( tstencilbits == 16 )
tstencilbits = 8;
else
tstencilbits = 0;
}
int channelcolorbits = 4;
if( tcolorbits == 24 )
channelcolorbits = 8;
SDL_GL_SetAttribute( SDL_GL_RED_SIZE, channelcolorbits );
SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, channelcolorbits );
SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, channelcolorbits );
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, tdepthbits );
SDL_GL_SetAttribute( SDL_GL_STENCIL_SIZE, tstencilbits );
if( r_waylandcompat.GetBool() )
SDL_GL_SetAttribute( SDL_GL_ALPHA_SIZE, 0 );
else
SDL_GL_SetAttribute( SDL_GL_ALPHA_SIZE, channelcolorbits );
SDL_GL_SetAttribute( SDL_GL_STEREO, parms.stereo ? 1 : 0 );
SDL_GL_SetAttribute( SDL_GL_MULTISAMPLEBUFFERS, parms.multiSamples ? 1 : 0 );
SDL_GL_SetAttribute( SDL_GL_MULTISAMPLESAMPLES, parms.multiSamples );
#if SDL_VERSION_ATLEAST(2, 0, 0)
// RB begin
if( r_useOpenGL32.GetInteger() > 0 )
{
glConfig.driverType = GLDRV_OPENGL32_COMPATIBILITY_PROFILE;
SDL_GL_SetAttribute( SDL_GL_CONTEXT_MAJOR_VERSION, 3 );
SDL_GL_SetAttribute( SDL_GL_CONTEXT_MINOR_VERSION, 2 );
}
if( r_debugContext.GetBool() )
{
SDL_GL_SetAttribute( SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG );
}
if( r_useOpenGL32.GetInteger() > 1 )
{
glConfig.driverType = GLDRV_OPENGL32_CORE_PROFILE;
SDL_GL_SetAttribute( SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE );
}
// RB end
// DG: set display num for fullscreen
int windowPos = SDL_WINDOWPOS_UNDEFINED;
if( parms.fullScreen > 0 )
{
if( parms.fullScreen > SDL_GetNumVideoDisplays() )
{
common->Warning( "Couldn't set display to num %i because we only have %i displays",
parms.fullScreen, SDL_GetNumVideoDisplays() );
}
else
{
// -1 because SDL starts counting displays at 0, while parms.fullScreen starts at 1
windowPos = SDL_WINDOWPOS_UNDEFINED_DISPLAY( ( parms.fullScreen - 1 ) );
}
}
// TODO: if parms.fullScreen == -1 there should be a borderless window spanning multiple displays
/*
* NOTE that this implicitly handles parms.fullScreen == -2 (from r_fullscreen -2) meaning
* "do fullscreen, but I don't care on what monitor", at least on my box it's the monitor with
* the mouse cursor.
*/
window = SDL_CreateWindow( GAME_NAME,
windowPos,
windowPos,
parms.width, parms.height, flags );
// DG end
context = SDL_GL_CreateContext( window );
if( !window )
{
common->DPrintf( "Couldn't set GL mode %d/%d/%d: %s",
channelcolorbits, tdepthbits, tstencilbits, SDL_GetError() );
continue;
}
if( SDL_GL_SetSwapInterval( r_swapInterval.GetInteger() ) < 0 )
common->Warning( "SDL_GL_SWAP_CONTROL not supported" );
// RB begin
SDL_GetWindowSize( window, &glConfig.nativeScreenWidth, &glConfig.nativeScreenHeight );
// RB end
glConfig.isFullscreen = ( SDL_GetWindowFlags( window ) & SDL_WINDOW_FULLSCREEN ) == SDL_WINDOW_FULLSCREEN;
#else
glConfig.driverType = GLDRV_OPENGL3X;
SDL_WM_SetCaption( GAME_NAME, GAME_NAME );
if( SDL_GL_SetAttribute( SDL_GL_SWAP_CONTROL, r_swapInterval.GetInteger() ) < 0 )
common->Warning( "SDL_GL_SWAP_CONTROL not supported" );
window = SDL_SetVideoMode( parms.width, parms.height, colorbits, flags );
if( !window )
{
common->DPrintf( "Couldn't set GL mode %d/%d/%d: %s",
channelcolorbits, tdepthbits, tstencilbits, SDL_GetError() );
continue;
}
glConfig.nativeScreenWidth = window->w;
glConfig.nativeScreenHeight = window->h;
glConfig.isFullscreen = ( window->flags & SDL_FULLSCREEN ) == SDL_FULLSCREEN;
#endif
common->Printf( "Using %d color bits, %d depth, %d stencil display\n",
channelcolorbits, tdepthbits, tstencilbits );
glConfig.colorBits = tcolorbits;
glConfig.depthBits = tdepthbits;
glConfig.stencilBits = tstencilbits;
// RB begin
glConfig.displayFrequency = 60;
glConfig.isStereoPixelFormat = parms.stereo;
glConfig.multisamples = parms.multiSamples;
glConfig.pixelAspect = 1.0f; // FIXME: some monitor modes may be distorted
// should side-by-side stereo modes be consider aspect 0.5?
// RB end
break;
}
if( !window )
{
common->Printf( "No usable GL mode found: %s", SDL_GetError() );
return false;
}
#ifdef __APPLE__
glewExperimental = GL_TRUE;
#endif
GLenum glewResult = glewInit();
if( GLEW_OK != glewResult )
{
// glewInit failed, something is seriously wrong
common->Printf( "^3GLimp_Init() - GLEW could not load OpenGL subsystem: %s", glewGetErrorString( glewResult ) );
}
else
{
common->Printf( "Using GLEW %s\n", glewGetString( GLEW_VERSION ) );
}
// DG: disable cursor, we have two cursors in menu (because mouse isn't grabbed in menu)
SDL_ShowCursor( SDL_DISABLE );
// DG end
return true;
}
//" outColor = mix(texture(texKitten, vec2(Texcoord.x + sin(Texcoord.y * 60.0 + time * 2.0) / 30.0, 1.0 - Texcoord.y)) * vec4(0.0, 0.0, 1.0, 1.0), texture(texPuppy, vec2(Texcoord)), factor);"
//" if (Texcoord.x < 1.0 && Texcoord.y < 1.0 || Texcoord.x > 1.0 && Texcoord.y > 1.0)"
//" if((Texcoord.x - 1.0) * (Texcoord.x - 1.0) + (Texcoord.y - 1.0) * (Texcoord.y - 1.0) < 1.0)"
//" float factor = (sin(time * 3.0) + 1.0) / 2.0;"
//" if (Texcoord.y < 0.5)"
//" outColor = mix(texture(texKitten, Texcoord), texture(texPuppy, Texcoord), factor);"
//" else"
//" outColor = mix(texture(texKitten, vec2(Texcoord.x, 1.0 - Texcoord.y)), texture(texPuppy, vec2(Texcoord.x, 1.0 - Texcoord.y)), factor);"
int main(int argc, char *argv[])
{
// Timer for blending the two textures
//auto t_start = std::chrono::high_resolution_clock::now();
// Initialize SDL
SDL_Init(SDL_INIT_VIDEO);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
SDL_Window* window = SDL_CreateWindow("OpenGL tutorial", 100, 100, 800, 600, SDL_WINDOW_OPENGL);
SDL_GLContext context = SDL_GL_CreateContext(window);
// Initialize GLEW
glewExperimental = GL_TRUE;
glewInit();
// Create Vertex Array Object
GLuint vao;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
// Create a Vertex Buffer Object and copy the vertex data to it
GLuint vbo;
glGenBuffers(1, &vbo); // Generate 1 buffer
GLfloat vertices[] = {
// Position Color Texcoords
-1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, // Top-left
1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, // Top-right
1.0f, -1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, // Bottom-right
-1.0f, -1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f // Bottom-left
};
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
// Create an element array
GLuint ebo;
glGenBuffers(1, &ebo); // Generate 1 buffer
GLuint elements[] = {
0, 1, 2,
2, 3, 0
};
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(elements), elements, GL_STATIC_DRAW);
// Create and compile the vertex shader
GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, &vertexSource, NULL);
glCompileShader(vertexShader);
// Create and compile the fragment shader
GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fragmentSource, NULL);
glCompileShader(fragmentShader);
// Link the vertex and fragment shader into a shader program
GLuint shaderProgram = glCreateProgram();
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
glBindFragDataLocation(shaderProgram, 0, "outColor");
glLinkProgram(shaderProgram);
glUseProgram(shaderProgram);
// Specify the layout of the vertex data
// The first number (2, 3, 2 in the attribs below) tell how many floats are needed for each attribute
// N * sizeof(float) this tells the vertex shader how many bytes are incoming per vertex
// The 0 and/or (void*)(N * sizeof(float)) tells how many bytes should be skipped before each attribute
GLint posAttrib = glGetAttribLocation(shaderProgram, "position");
glEnableVertexAttribArray(posAttrib);
glVertexAttribPointer(posAttrib, 2, GL_FLOAT, GL_FALSE, 7 * sizeof(GLfloat), 0);
GLint colAttrib = glGetAttribLocation(shaderProgram, "color");
glEnableVertexAttribArray(colAttrib);
glVertexAttribPointer(colAttrib, 3, GL_FLOAT, GL_FALSE, 7 * sizeof(GLfloat), (void*)(2 * sizeof(GLfloat)));
GLint texAttrib = glGetAttribLocation(shaderProgram, "texcoord");
glEnableVertexAttribArray(texAttrib);
glVertexAttribPointer(texAttrib, 2, GL_FLOAT, GL_FALSE, 7 * sizeof(GLfloat), (void*)(5 * sizeof(GLfloat)));
// Get alpha uniform from fragment shader
//GLint uniTime = glGetUniformLocation(shaderProgram, "time");
// Create texture and load image with SOIL
GLuint textures[2];
glGenTextures(2, textures);
int width, height;
unsigned char* image;
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textures[0]);
image = SOIL_load_image("sample.png", &width, &height, 0, SOIL_LOAD_RGB);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
SOIL_free_image_data(image);
glUniform1i(glGetUniformLocation(shaderProgram, "texKitten"), 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, textures[1]);
image = SOIL_load_image("sample2.png", &width, &height, 0, SOIL_LOAD_RGB);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
SOIL_free_image_data(image);
glUniform1i(glGetUniformLocation(shaderProgram, "texPuppy"), 1);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
SDL_Event windowEvent;
// Error checking
GLint status, status2;
glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &status);
glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &status2);
char buffer1[512], buffer2[512];
glGetShaderInfoLog(vertexShader, 512, NULL, buffer1);
glGetShaderInfoLog(fragmentShader, 512, NULL, buffer2);
std::cout
<< "GL_Error: " << glGetError()
<< "\n Vertex shader status: " << status
<< "\n Vertex shader log: " << buffer1
<< "\n Fragment shader status: " << status2
<< "\n Fragment shader log: " << buffer2
<< std::endl;
while (true)
{
if (SDL_PollEvent(&windowEvent))
{
if (windowEvent.type == SDL_QUIT)
{
break;
}
}
// Clear screen to black
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
// Set the time uniform
//auto t_now = std::chrono::high_resolution_clock::now();
//float time = std::chrono::duration_cast<std::chrono::duration<float>>(t_now - t_start).count();
//glUniform1f(uniTime, time);
// Draw a rectangle from two triangles using 6 vertices
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
// Swap buffers
SDL_GL_SwapWindow(window);
}
glDeleteTextures(2, textures);
glDeleteProgram(shaderProgram);
glDeleteShader(fragmentShader);
glDeleteShader(vertexShader);
glDeleteBuffers(1, &vbo);
glDeleteBuffers(1, &ebo);
glDeleteVertexArrays(1, &vao);
SDL_GL_DeleteContext(context);
SDL_Quit();
return 0;
}
string SDLInit(const char *title, int2 &screensize, bool fullscreen)
{
//SDL_SetMainReady();
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER /* | SDL_INIT_AUDIO*/) < 0)
{
return SDLError("Unable to initialize SDL");
}
SDL_SetEventFilter(SDLHandleAppEvents, nullptr);
DebugLog(-1, "SDL initialized...");
SDL_LogSetAllPriority(SDL_LOG_PRIORITY_WARN);
// on demand now
//extern bool sfxr_init();
//if (!sfxr_init())
// return SDLError("Unable to initialize audio");
#ifdef PLATFORM_MOBILE
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
#else
//certain older Intel HD GPUs and also Nvidia Quadro 1000M don't support 3.1 ? the 1000M is supposed to support 4.2
//SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
//SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
#ifndef WIN32
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG);
#endif
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4);
#endif
//SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 0); // set this if we're in 2D mode for speed on mobile?
SDL_GL_SetAttribute(SDL_GL_RETAINED_BACKING, 1); // because we redraw the screen each frame
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
DebugLog(-1, "SDL about to figure out display mode...");
#ifdef PLATFORM_MOBILE
landscape = screensize.x() >= screensize.y();
int modes = SDL_GetNumDisplayModes(0);
screensize = int2(0);
for (int i = 0; i < modes; i++)
{
SDL_DisplayMode mode;
SDL_GetDisplayMode(0, i, &mode);
//printf("mode: %d %d\n", mode.w, mode.h);
if (landscape ? mode.w > screensize.x() : mode.h > screensize.y())
{
screensize = int2(mode.w, mode.h);
}
}
DebugLog(-1, inttoa(screensize.x()));
DebugLog(-1, inttoa(screensize.y()));
DebugLog(-1, "SDL about to create window...");
_sdl_window = SDL_CreateWindow(title,
0, 0,
screensize.x(), screensize.y(),
SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN | SDL_WINDOW_BORDERLESS);
DebugLog(-1, _sdl_window ? "SDL window passed..." : "SDL window FAILED...");
if (landscape) SDL_SetHint("SDL_HINT_ORIENTATIONS", "LandscapeLeft LandscapeRight");
int ax = 0, ay = 0;
SDL_GetWindowSize(_sdl_window, &ax, &ay);
int2 actualscreensize(ax, ay);
//screenscalefactor = screensize.x / actualscreensize.x; // should be 2 on retina
#ifdef __IOS__
assert(actualscreensize == screensize);
screensize = actualscreensize;
#else
screensize = actualscreensize; // __ANDROID__
DebugLog(-1, inttoa(screensize.x()));
DebugLog(-1, inttoa(screensize.y()));
#endif
#else
_sdl_window = SDL_CreateWindow(title,
SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
screensize.x(), screensize.y(),
SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE |
(fullscreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0));
#endif
if (!_sdl_window)
return SDLError("Unable to create window");
DebugLog(-1, "SDL window opened...");
_sdl_context = SDL_GL_CreateContext(_sdl_window);
DebugLog(-1, _sdl_context ? "SDL context passed..." : "SDL context FAILED...");
if (!_sdl_context) return SDLError("Unable to create OpenGL context");
DebugLog(-1, "SDL OpenGL context created...");
/*
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4);
*/
#ifndef __IOS__
SDL_GL_SetSwapInterval(1); // vsync on
#endif
SDL_JoystickEventState(SDL_ENABLE);
SDL_JoystickUpdate();
for(int i = 0; i < SDL_NumJoysticks(); i++)
{
SDL_Joystick *joy = SDL_JoystickOpen(i);
if (joy)
{
DebugLog(-1, "Detected joystick: %s (%d axes, %d buttons, %d balls, %d hats)\n",
SDL_JoystickName(joy), SDL_JoystickNumAxes(joy), SDL_JoystickNumButtons(joy),
SDL_JoystickNumBalls(joy), SDL_JoystickNumHats(joy));
};
};
starttime = SDL_GetTicks();
lastmillis = starttime - 16; // ensure first frame doesn't get a crazy delta
return "";
}
int main(int argc, char **argv)
{
//Initializes console Position
HWND hWnd = GetConsoleWindow();
MoveWindow(hWnd, 1350, 0, 500, 1000, TRUE);
std::cout << "GameArtsEngine" << std::endl;
//Initializes SDL and gets everything set up
SDL_Init(SDL_INIT_VIDEO);
SDL_Window *window = SDL_CreateWindow("GameArtsEngine", 40, 40, windowWidth, windowHeight, SDL_WINDOW_OPENGL);
SDL_GLContext glcontext = SDL_GL_CreateContext(window);
//Initializes our Glew
glewInit();
//Initializes our Engine
iGAEngine->initGL(windowWidth, windowHeight);
aiString list;
Assimp::Importer imp;
imp.GetExtensionList(list);
std::cout << list.C_Str() << std::endl;
/**************************************ALL THE ONE TIME SCENE SETUP GOES HERE*******************************************/
//Creates a basic Light for our scene --> will eventually be moved to the Engine itself
mainLight = new Light(LIGHT_POINT);
mainLight->setDiffuse(2, 2, 2, 1);
mainLight->setExponent(10);
mainLight->setPosition(-5,25,5);
//Load Textures
defaultTexture = iGAEngine->loadTexture("Assets/Textures/ModelgridTexture.jpg");
//Load Models->Primitives ------------------------ENABLE IF YOU NEED PRIMITIVES---------------------------------
teapodModel = new meshLoader("Assets/Models/Primitives/teapod.dae");
cylinderModel = new meshLoader("Assets/Models/Primitives/cylinder.dae");
sphereModel = new meshLoader("Assets/Models/Primitives/sphere.dae");
cubeModel = new meshLoader("Assets/Models/Primitives/cube.dae");
//Load Models->GameModels
//-----------------------------------------------------------------------------------------SHADERSETUP--------------------------------------------
if (GLEW_ARB_vertex_shader && GLEW_ARB_fragment_shader){
cout << endl << "SHADER LOG: -------------------------------------------------------- BEGIN" << endl;
// Simple Normal Shader without SpecMap
normalShader = new Shader("normal.vert", "normal.frag");
normalShader->useShader();
normalShader->setAttribute1i("diffuseMap0", 0);
normalShader->setAttribute1i("normalMap1", 1);
normalShader->setAttribute1f("SpecularPower", 2.0f);
normalShader->setAttribute4f("Specular", 0.5, 0.5, 0.5, 1.0);
normalShader->setAttribute4f("Ambient", 0.3, 0.3, 0.3, 1.0);
normalShader->setAttribute4f("Diffuse", 1, 1, 1, 1.0);
normalShader->setAttribute3f("fvLightPosition", 50.3f, 18.9f, 27.2f);
// Normal Shader with SpecMap
normalSpecShader = new Shader("normalSpec.vert", "normalSpec.frag");
normalSpecShader->useShader();
normalSpecShader->setAttribute1i("diffuseMap0", 0);
normalSpecShader->setAttribute1i("normalMap1", 1);
normalSpecShader->setAttribute1i("specularMap2", 2);
normalSpecShader->setAttribute1f("SpecularPower", 2.0f);
normalSpecShader->setAttribute4f("Specular", 0.5, 0.5, 0.5, 1.0);
normalSpecShader->setAttribute4f("Ambient", 0.3, 0.3, 0.3, 1.0);
normalSpecShader->setAttribute4f("Diffuse", 1, 1, 1, 1.0);
normalSpecShader->setAttribute3f("fvLightPosition", 50.3f, 18.9f, 27.2f);
// Simple LambertShader with DiffuseMap
diffuseShader = new Shader("lambertDiffuse.vert", "lambertDiffuse.frag");
diffuseShader->useShader();
diffuseShader->setAttribute4f("Ambient", 0.3, 0.3, 0.3, 1.0);
diffuseShader->setAttribute4f("Diffuse", 1, 1, 1, 1.0);
diffuseShader->setAttribute3f("fvLightPosition", 50.3f, 18.9f, 27.2f);
lambertShader_static = new Shader("lambert_static.vert", "lambert_static.frag");
lambertShader_static->useShader();
lambertShader_static->setAttribute4f("Ambient", 0.3, 0.3, 0.3, 1.0);
lambertShader_static->setAttribute4f("Diffuse", 1, 1, 1, 1.0);
lambertShader_static->setAttribute3f("fvLightPosition", 50.3f, 18.9f, 27.2f);
cout << endl << "SHADER LOG: ---------------------------------------------------------- END" << endl;
}
else{
cout << endl << "GLSL not supported" << endl;
}
//-----------------------------------------------------------------------------------------SHADERSETUP--------------------------------------------
/**************************************ALL THE ONE TIME SCENE SETUP GOES HERE*******************************************/
// Main Engine Loop
bool isRunning = true;
SDL_Event event;
while (isRunning )
{
//Gets states of the Mouse and stroes them in the struct
SDL_GetMouseState(&mouseState.x, &mouseState.y);
mouseState.LeftButtonDown = SDL_GetMouseState(NULL, NULL) & SDL_BUTTON(1);
mouseState.MiddleButtonDown = SDL_GetMouseState(NULL, NULL) & SDL_BUTTON(2);
mouseState.RightButtonDown = SDL_GetMouseState(NULL, NULL) & SDL_BUTTON(3);
drawMainScene(window); // calls stuff that needs to update every frame
//Event loop
while (SDL_PollEvent(&event)){
if (event.type == SDL_QUIT)
isRunning = false;
}
if (viewportNavigation())
isRunning = false;
}
delete teapodModel;
delete lambertShader_static;
delete diffuseShader;
delete normalShader;
delete normalSpecShader;
GAEngine::Unitialize();
SDL_Quit();
return 1;
}
bool COpenGL::init()
{
CVideoEngine::init();
const GLint oglfilter = m_VidConfig.m_opengl_filter;
#if SDL_VERSION_ATLEAST(2, 0, 0)
Uint32 flags = SDL_WINDOW_OPENGL;
if(m_VidConfig.Fullscreen)
flags |= SDL_WINDOW_FULLSCREEN;
else
flags |= (SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE);
window = SDL_CreateWindow("Commander Genius",
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
m_VidConfig.m_DisplayRect.w,
m_VidConfig.m_DisplayRect.h,
flags);
glcontext = SDL_GL_CreateContext(window);
// Set clear colour
glClearColor(0,0,0,0);
// Set projection
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
#if defined(TARGET_OS_IPHONE) || defined(TARGET_IPHONE_SIMULATOR) // TODO: dont check for iphone but for opengles
#define glOrtho glOrthof
#endif
glOrtho( 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f );
// Now Initialize modelview matrix
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
// Setup the view port for the first time
#if defined(TARGET_OS_IPHONE) || defined(TARGET_IPHONE_SIMULATOR)
glViewport(0, 0, 480, 320);
#else
setUpViewPort(mAspectCorrectionRect);
#endif
/*Using the standard OpenGL API for specifying a 2D texture
image: glTexImage2D, glSubTexImage2D, glCopyTexImage2D,
and glCopySubTexImage2D. The target for these commands is
GL_TEXTURE_RECTANGLE_ARB though.
This is similar to how the texture cube map functionality uses the 2D
texture image specification API though with its own texture target.
The texture target GL_TEXTURE_RECTANGLE_ARB should also
be used for glGetTexImage, glGetTexLevelParameteriv, and
glGetTexLevelParameterfv.*/
// Enable Texture loading for the blit screen
glEnable(m_texparam);
createTexture(m_texture, oglfilter, m_GamePOTScaleDim.w, m_GamePOTScaleDim.h);
if(m_VidConfig.m_ScaleXFilter <= 1)
{ // In that case we can do a texture based rendering
createTexture(m_texFX, oglfilter, m_GamePOTScaleDim.w, m_GamePOTScaleDim.h, true);
}
#else // not SDL 2.0
// Setup the view port for the first time
setUpViewPort(mAspectCorrectionRect);
// Set clear colour
glClearColor(0,0,0,0);
// Set projection
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
#if defined(TARGET_OS_IPHONE) || defined(TARGET_IPHONE_SIMULATOR) // TODO: dont check for iphone but for opengles
#define glOrtho glOrthof
#endif
glOrtho( 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f );
// Now Initialize modelview matrix
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
/*Using the standard OpenGL API for specifying a 2D texture
image: glTexImage2D, glSubTexImage2D, glCopyTexImage2D,
and glCopySubTexImage2D. The target for these commands is
GL_TEXTURE_RECTANGLE_ARB though.
This is similar to how the texture cube map functionality uses the 2D
texture image specification API though with its own texture target.
The texture target GL_TEXTURE_RECTANGLE_ARB should also
be used for glGetTexImage, glGetTexLevelParameteriv, and
glGetTexLevelParameterfv.*/
// Enable Texture loading for the blit screen
glEnable(m_texparam);
createTexture(m_texture, oglfilter, m_GamePOTScaleDim.w, m_GamePOTScaleDim.h);
//if(m_VidConfig.m_ScaleXFilter <= 1)
{ // In that case we can do a texture based rendering
createTexture(m_texFX, oglfilter, m_GamePOTScaleDim.w, m_GamePOTScaleDim.h, true);
}
/*else
{
createTexture(m_texFX, oglfilter, m_GamePOTScaleDim.w, m_GamePOTScaleDim.h, true);
}*/
#endif
// If there were any errors
int error;
error = glGetError();
if( error != GL_NO_ERROR)
{
gLogging.ftextOut("OpenGL Init(): %d<br>",error);
#if SDL_VERSION_ATLEAST(2, 0, 0)
SDL_DestroyWindow(window);
SDL_GL_DeleteContext(glcontext);
#endif
return false;
}
gLogging.ftextOut("OpenGL Init(): Interface successfully opened!<br>");
GLfloat light_ambient[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat light_diffuse[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat light_specular[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat light_position[] = { 0.0, 0.0, 1.0, 0.0 };
glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
return true;
}
int main(int, char**)
{
// Setup SDL
if (SDL_Init(SDL_INIT_EVERYTHING) != 0)
{
printf("Error: %s\n", SDL_GetError());
return -1;
}
// Setup window
SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
SDL_DisplayMode current;
SDL_GetCurrentDisplayMode(0, ¤t);
SDL_Window *window = SDL_CreateWindow("ImGui SDL2+OpenGL3 example", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 1280, 720, SDL_WINDOW_OPENGL|SDL_WINDOW_RESIZABLE);
SDL_GLContext glcontext = SDL_GL_CreateContext(window);
gl3wInit();
// Setup ImGui binding
ImGui_ImplSdlGL3_Init(window);
// Load Fonts
// (there is a default font, this is only if you want to change it. see extra_fonts/README.txt for more details)
//ImGuiIO& io = ImGui::GetIO();
//io.Fonts->AddFontDefault();
//io.Fonts->AddFontFromFileTTF("../../extra_fonts/Cousine-Regular.ttf", 15.0f);
//io.Fonts->AddFontFromFileTTF("../../extra_fonts/DroidSans.ttf", 16.0f);
//io.Fonts->AddFontFromFileTTF("../../extra_fonts/ProggyClean.ttf", 13.0f);
//io.Fonts->AddFontFromFileTTF("../../extra_fonts/ProggyTiny.ttf", 10.0f);
//io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\ArialUni.ttf", 18.0f, NULL, io.Fonts->GetGlyphRangesJapanese());
bool show_test_window = true;
bool show_another_window = false;
ImVec4 clear_color = ImColor(114, 144, 154);
// Main loop
bool done = false;
while (!done)
{
SDL_Event event;
while (SDL_PollEvent(&event))
{
ImGui_ImplSdlGL3_ProcessEvent(&event);
if (event.type == SDL_QUIT)
done = true;
}
ImGui_ImplSdlGL3_NewFrame();
// 1. Show a simple window
// Tip: if we don't call ImGui::Begin()/ImGui::End() the widgets appears in a window automatically called "Debug"
{
static float f = 0.0f;
ImGui::Text("Hello, world!");
ImGui::SliderFloat("float", &f, 0.0f, 1.0f);
ImGui::ColorEdit3("clear color", (float*)&clear_color);
if (ImGui::Button("Test Window")) show_test_window ^= 1;
if (ImGui::Button("Another Window")) show_another_window ^= 1;
ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / ImGui::GetIO().Framerate, ImGui::GetIO().Framerate);
}
// 2. Show another simple window, this time using an explicit Begin/End pair
if (show_another_window)
{
ImGui::SetNextWindowSize(ImVec2(200,100), ImGuiSetCond_FirstUseEver);
ImGui::Begin("Another Window", &show_another_window);
ImGui::Text("Hello");
ImGui::End();
}
// 3. Show the ImGui test window. Most of the sample code is in ImGui::ShowTestWindow()
if (show_test_window)
{
ImGui::SetNextWindowPos(ImVec2(650, 20), ImGuiSetCond_FirstUseEver);
ImGui::ShowTestWindow(&show_test_window);
}
// Rendering
glViewport(0, 0, (int)ImGui::GetIO().DisplaySize.x, (int)ImGui::GetIO().DisplaySize.y);
glClearColor(clear_color.x, clear_color.y, clear_color.z, clear_color.w);
glClear(GL_COLOR_BUFFER_BIT);
ImGui::Render();
SDL_GL_SwapWindow(window);
}
// Cleanup
ImGui_ImplSdlGL3_Shutdown();
SDL_GL_DeleteContext(glcontext);
SDL_DestroyWindow(window);
SDL_Quit();
return 0;
}
void App::init()
{
SDL_Init(SDL_INIT_EVERYTHING);
window = SDL_CreateWindow("Try hard!", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, screen_width, screen_height, SDL_WINDOW_OPENGL);
SDL_GLContext glContext = SDL_GL_CreateContext(window);
if (glContext == nullptr)
std::cout << "SDLFEL";
GLenum error = glewInit();
if (error != GLEW_OK)
std::cout << "GlewFel!";
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
glClearColor(0.7f, 0.7f, 1.0f, 1.0);
glEnable(GL_DEPTH_TEST);
initShader();
initGaussTex();
importer = new OBJimporter();
importer->loadObj("models/sphere1.obj");
models = importer->CreateTriangleData();
models[0]->createBBox("sphere.txt");
models[0]->addTranslation(vec3(5, 2, -5));
models[0]->initNormalTexture("normalMap.png");
delete importer;
importer = new OBJimporter();
std::vector<Model*> xxx;
importer->loadObj("models/skyBox.obj");
xxx = importer->CreateTriangleData();
xxx[0]->createBBox("box.txt");
xxx[0]->addTranslation(vec3(0, 19, 0));
xxx[0]->Scale(vec3(40,40,40));
models.push_back(xxx[0]);
delete importer;
importer = new OBJimporter();
std::vector<Model*> temp;
importer->loadObj("models/box.obj");
temp = importer->CreateTriangleData();
temp[0]->createBBox("box.txt");
Model* box2;
box2 = new Model(*temp[0]);
Model* box3;
box3 = new Model(*temp[0]);
temp[0]->addTranslation(vec3(3,0,3));
box2->addTranslation(vec3(-18, 10, -18));
box3->addTranslation(vec3(10, 3, -3));
models.push_back(temp[0]);
models.push_back(box2);
models.push_back(box3);
Model* boxTemplate;
/*for (int i = 0; i < 2000; i++) {
boxTemplate = new Model(*models[0]);
boxTemplate->addTranslation(vec3(i % 40 - 20, 5, (int)(i/40)-20));
models.push_back(boxTemplate);
}
for (int i = 0; i < 2000; i++) {
boxTemplate = new Model(*temp[0]);
boxTemplate->addTranslation(vec3(i % 40 - 20, 3, (int)(i / 40) - 20));
models.push_back(boxTemplate);
}*/
unsigned char* Pheightmap = nullptr;
Model* hm = importer->getGround("height_map2.bmp", Pheightmap);
this->terrain = hm;
_player.setHM(Pheightmap);
delete importer;
createScreenQuad();
quadTree = new QuadTree(vec3(-25, 0, 25), 50);
quadTree->buildTree(models);
}
