int main(int argc, char** argv) {
for (int i = 0; i < M.GetLayers(); i++)
{
M.Show(i);
printf("\n");
}
current_elevator_i = M.getElevatorI();
current_elevator_j = M.getElevatorJ();
fvc = read_obj("flashlight.obj", fv, ftv, fn);
initGLUT(&argc, argv);
initGLEW();
initOpenGL();
glutKeyboardFunc(Movement);
glutWarpPointer(200, 200);
glutMotionFunc(MouseActiveMotion);
glutPassiveMotionFunc(MouseMotion);
glutMouseFunc(MouseButtons);
glutMainLoop();
freeVAO();
freeVBO();
cleanShaders();
return 0;
}
int main(int argc, char *argv[]) {
int rc;
int exit_application = 0;
initBBSpecific();
initOpenGL(screen_cxt);
while (closeApplication == 0) {
handleEvent();
render();
}
//Stop requesting events from libscreen
screen_stop_events(screen_cxt);
//Shut down BPS library for this process
bps_shutdown();
//Use utility code to terminate EGL setup
bbutil_terminate();
//Destroy libscreen context
screen_destroy_context(screen_cxt);
return 0;
}
int main(int argc, char *argv[]){
// OpenGL initialization
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH | GLUT_ALPHA);
//
glutInitWindowSize(640,480);
//
glutCreateWindow("OpenGL");
//
initOpenGL();
GLenum err = glewInit();
if(GLEW_OK != err){
printf("Error: %s", glewGetErrorString(err));
}
// display scene
glutDisplayFunc(drawScene);
// choose function when window reshape
glutReshapeFunc( reshapeScreen );
glutKeyboardFunc(keyDown);
glutKeyboardUpFunc(keyUp);
glutSpecialFunc(specialKeyDown);
glutSpecialUpFunc(specialKeyUp);
//Mouse
glutMouseFunc(mouseFunction);
glutMainLoop();
return 0;
}
int main(int argc, char **argv){
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
//glutInitWindowSize(750, 500);
glutInitWindowSize(glutWindowWidth, glutWindowHeight);
glutInitWindowPosition(100, 100);
glutCreateWindow("Room Navigator");
floorPix[0].readBMPFile("FloorWood01.bmp");
boundaryWallPix[0].readBMPFile("WallBrick02.bmp");
innerWallPix[0].readBMPFile("WallWood01.bmp");
doorPix[0].readBMPFile("Door01L.bmp");
doorPix[1].readBMPFile("Door01R.bmp");
initOpenGL();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMouseFunc(mouse);
glutMotionFunc(mouseMotionHandler);
glutKeyboardFunc(keyboard);
glutSpecialFunc(functionKeys);
glutTimerFunc(1000.0 / FPS, timer, 0);
glutMainLoop();
return 0;
}
void Application::createDisplay(uint width, uint height,
uint redBits, uint greenBits, uint blueBits,
uint alphaBits, uint depthBits, uint stencilBits,
DisplayMode mode, const std::string &title)
{
GLboolean status;
status = glfwOpenWindow(width, height, redBits, greenBits, blueBits,
alphaBits, depthBits, stencilBits,
mode == DISP_FULLSCREEN ? GLFW_FULLSCREEN : GLFW_WINDOW);
if(status == GL_FALSE)
{
throw APIError("Failed to create display.");
}
// fetch window size (fixes X11 fullscreen bug)
glfwGetWindowSize(reinterpret_cast<int*>(&displayWidth_),
reinterpret_cast<int*>(&displayHeight_));
glfwSetWindowTitle(title.c_str()); // title is set separately
initOpenGL();
setOrthoView();
// register the callbacks (after a window is open)
glfwSetKeyCallback(Application::keyCallback);
//glfwSetCharCallback(Application::charCallback);
glfwSetMouseButtonCallback(Application::mouseButtonCallback);
glfwSetMousePosCallback(Application::mouseMoveCallback);
glfwSetMouseWheelCallback(Application::mouseWheelCallback);
quit_ = false;
}
int main( void ) {
if( init() == -1 ) {
return EXIT_FAILURE;
}
initOpenGL();
initData();
while( !glfwWindowShouldClose( window ) ) {
Time::update();
mainCamera->update();
mainLight->update();
draw();
glfwPollEvents();
}
// Close OpenGL window and terminate GLFW
glfwTerminate();
delete mainCamera;
delete mainLight;
delete diffuse;
delete depth;
delete passthrough;
delete mesh;
delete texture;
MeshLoader::clearAll();
return EXIT_SUCCESS;
}
int main()
{
initOpenGL();
createWindow(300,300);
return 0;
}
int main(int argc, char *argv[]) {
// Initialize GLUT and open a window.
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowSize(800, 600);
glutCreateWindow(argv[0]);
// Register a bunch of callbacks for GLUT events.
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMotionFunc(mouseMove);
glutMouseFunc(mouseClick);
glutKeyboardFunc(keyboard);
// Setup OpenGL
initOpenGL();
// Initialize our robot.
if (argc > 1) {
std::vector<Pose> poses;
readPoseFile(argv[1], poses);
robot.setPoses(poses);
}
// Schedule the first animation callback ASAP.
glutTimerFunc(0, animate, 0);
// Pass control to GLUT.
glutMainLoop();
// Will never be reached.
return 0;
}
// Initialize variables and call initalizations for the window and openGL
void init() {
initWindow();
initOpenGL();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
//init SDL, OpenGL and game stuff here
bool initGame()
{
//Initialize SDL
if( SDL_Init( SDL_INIT_EVERYTHING ) < 0 )
{
return false;
}
//Create Window
if( SDL_SetVideoMode( SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP, SDL_OPENGL ) == NULL )
{
return false;
}
//Initialize OpenGL
if( initOpenGL() == false )
{
return false;
}
if (loadContent() == false)
{
return false;
}
//Set caption
SDL_WM_SetCaption( "Dragon City", NULL );
return true;
}
int main(int argc, char **argv) {
glutInit(&argc, argv);
/*Setting up The Display
/ -RGB color model + Alpha Channel = GLUT_RGBA
*/
glutInitDisplayMode(GLUT_RGBA|GLUT_DEPTH | GLUT_DOUBLE );
//Configure Window Postion
glutInitWindowPosition(50, 25);
//Configure Window Size
glutInitWindowSize(WINDOW_W,WINDOW_H);
//Create Window
glutCreateWindow("Hello OpenGL Shaders");
//Call to the drawing function
glutDisplayFunc(draw);
glutIdleFunc(draw);
glutReshapeFunc(changeSize);
glutKeyboardFunc(processNormalKeys);
glutMotionFunc(mouseCallback);
initOpenGL();
setShaders();
// Loop require by OpenGL
glutMainLoop();
return 0;
}
openni::Status SampleViewer::init(int argc, char **argv)
{
openni::VideoMode videoMode1 = m_depth1.getVideoMode();
openni::VideoMode videoMode2 = m_depth2.getVideoMode();
if (videoMode1.getResolutionX() != videoMode2.getResolutionX() ||
videoMode1.getResolutionY() != videoMode2.getResolutionY())
{
printf("Streams need to match resolution.\n");
return openni::STATUS_ERROR;
}
m_width = videoMode1.getResolutionX();
m_height = videoMode1.getResolutionY();
m_streams = new openni::VideoStream*[2];
m_streams[0] = &m_depth1;
m_streams[1] = &m_depth2;
// Texture map init
m_nTexMapX = MIN_CHUNKS_SIZE(m_width, TEXTURE_SIZE);
m_nTexMapY = MIN_CHUNKS_SIZE(m_height, TEXTURE_SIZE);
m_pTexMap = new openni::RGB888Pixel[m_nTexMapX * m_nTexMapY];
return initOpenGL(argc, argv);
}
int Server::initSDL()
{
SDL_Init(SDL_INIT_EVERYTHING);
Uint32 windowFlags;
//if (Settings::getWindowState() == FULLSCREEN) windowFlags = SDL_WINDOW_OPENGL | SDL_WINDOW_ALLOW_HIGHDPI | SDL_WINDOW_FULLSCREEN;
windowFlags = SDL_WINDOW_OPENGL | SDL_WINDOW_ALLOW_HIGHDPI;
//else if (Settings::getWindowState() == BORDERLESS) windowFlags = SDL_WINDOW_OPENGL | SDL_WINDOW_ALLOW_HIGHDPI | SDL_WINDOW_BORDERLESS;
displayWindow = SDL_CreateWindow("Rune Server", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 800, 600, windowFlags);
displayContext = SDL_GL_CreateContext(displayWindow);
SDL_GL_MakeCurrent(displayWindow, displayContext);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_COMPATIBILITY);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 32);
initOpenGL();
//resizeWindow(800, 600);
SDL_SetRelativeMouseMode(SDL_FALSE);
return 0;
}
void Graphics::init(int screen_width, int screen_height, const char* windowTitle, const char* iconSrc)
{
m_Screen_Width = screen_width;
m_Screen_Height = screen_height;
SDL_Init(SDL_INIT_EVERYTHING);
if(iconSrc != NULL)
{
SDL_Surface* icon = SDL_LoadBMP(iconSrc);
SDL_SetWindowIcon(m_Window, icon);
}
m_Window = SDL_CreateWindow("", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, m_Screen_Width, m_Screen_Height, SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL );
if(m_Window == NULL)
{
Log::write(AL::LOG_ERROR, "GraphicsManager", std::string("Error while creating window: ") + SDL_GetError());
}
if(windowTitle != NULL)
{
SDL_SetWindowTitle(m_Window, windowTitle);
}
initOpenGL();
Log::write(AL::LOG_INFORMATION, "GraphicsManager", "Initialized Window and OpenGL.");
}
void OpenGL::debugOpenGL(int argc,char** argv, GLuint vertexBuffId){
//Debugging variabes
spacing = 0.12;
vertexPos = new float[3 * debugNo * debugNo * debugNo];
int count = 0;
for(int i = 0; i < debugNo; i++){
for(int j = 0; j < debugNo; j++){
for(int k = 0; k < debugNo; k++){
vertexPos[3 * count] = (float)i * spacing;
vertexPos[3 * count + 1] = (float)j * spacing;
vertexPos[3 * count + 2] = (float)k * spacing;
count++;
}
}
}
//Initializing opengl
initOpenGL(argc, argv);
//Initializing a vertex array and binding it to use it
glGenBuffers(1, &vertexBuffId);
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffId);
glBufferData(GL_ARRAY_BUFFER, sizeof(float)*3*debugNo*debugNo*debugNo, vertexPos, GL_DYNAMIC_DRAW);
//Setting up the shaders
setShaders();
//GLUT main loop
glutMainLoop();
}
xdl_int XdevLOpenGLWGL::create(XdevLWindow* window) {
if(window == NULL) {
XDEVL_MODULE_ERROR("Parameter invalid.\n");
return ERR_ERROR;
}
m_window = window;
m_wnd = static_cast<HWND>(m_window->getInternal(XdevLInternalName("WIN32_HWND")));
if ( m_wnd == NULL) {
XDEVL_MODULE_ERROR("Get WIN32_HWND failed.\n");
return ERR_ERROR;
}
if (initOpenGL() == ERR_ERROR) {
XDEVL_MODULE_ERROR("Failed to initialize OpenGL.\n");
return ERR_ERROR;
}
// Set vertical syncronisation.
setVSync(getVSync());
// TODO: This shouldn't be done maybe because it changes the initial state of the OpenGL context.
glClearColor(1.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
SwapBuffers(m_DC);
return ERR_OK;
}
openni::Status SampleViewer::init(int argc, char **argv)
{
openni::VideoMode depthVideoMode;
openni::VideoMode colorVideoMode;
if (m_depthStream.isValid() && m_colorStream.isValid())
{
depthVideoMode = m_depthStream.getVideoMode();
colorVideoMode = m_colorStream.getVideoMode();
int depthWidth = depthVideoMode.getResolutionX();
int depthHeight = depthVideoMode.getResolutionY();
int colorWidth = colorVideoMode.getResolutionX();
int colorHeight = colorVideoMode.getResolutionY();
if (depthWidth == colorWidth &&
depthHeight == colorHeight)
{
m_width = depthWidth;
m_height = depthHeight;
}
else
{
printf("Error - expect color and depth to be in same resolution: D: %dx%d, C: %dx%d\n",
depthWidth, depthHeight,
colorWidth, colorHeight);
return openni::STATUS_ERROR;
}
}
else if (m_depthStream.isValid())
{
depthVideoMode = m_depthStream.getVideoMode();
m_width = depthVideoMode.getResolutionX();
m_height = depthVideoMode.getResolutionY();
}
else if (m_colorStream.isValid())
{
colorVideoMode = m_colorStream.getVideoMode();
m_width = colorVideoMode.getResolutionX();
m_height = colorVideoMode.getResolutionY();
}
else
{
printf("Error - expects at least one of the streams to be valid...\n");
return openni::STATUS_ERROR;
}
m_streams = new openni::VideoStream*[2];
m_streams[0] = &m_depthStream;
m_streams[1] = &m_colorStream;
// Texture map init
m_nTexMapX = MIN_CHUNKS_SIZE(m_width, TEXTURE_SIZE);
m_nTexMapY = MIN_CHUNKS_SIZE(m_height, TEXTURE_SIZE);
m_pTexMap = new openni::RGB888Pixel[m_nTexMapX * m_nTexMapY];
return initOpenGL(argc, argv);
}
xdl_int XdevLOpenGLWGL::reset() {
shutdown();
if(initOpenGL() == ERR_ERROR)
return ERR_ERROR;
return ERR_OK;
}
bool AppDelegate::applicationDidFinishLaunching()
{
initOpenGL();
initDirector();
initMultiResolution();
createAndRunScene();
return true;
}
int main(int argc, char** argv){
angle = 0.0f;
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutCreateWindow("Drawing a Tetrahedron");
initOpenGL();
glutDisplayFunc(mydisplay);
glutReshapeFunc(reshape);
glutTimerFunc(100, processTimer, 10);
glutMainLoop();
}
// Initialize variables and call initalizations for the window, openGL, and textures
void init() {
clockwise = true;
rotVel = 0.5;
negRotVel = rotVel * -1.0;
initFaces();
initWindow();
initOpenGL();
initTextures();
}
int main(){
initOpenGL(400,400);
init_events();
main_test();
std::cout << "Testing mem corruption\n";
int * i = new int[12345];
delete i;
std::cout << "OK\n";
return 0;
}
int main(int argc, char** argv){
globalEngine = new Engine();
globalCamera = new Camera();
initGLUT(&argc, argv);
initGLEW();
loadModels();
initOpenGL();
glutMainLoop();
return 0;
}
int main(int argc, char** argv) {
initOpenGL();
loadAssets();
handleInput();
renderFrame();
while (window.IsOpened()) {
window.Display();
}
return 0;
}
int main(int argc, char **argv)
{
initOpenGL();
initBSGUI();
createUI();
runMe();
shutdownBSGUI();
SDL_Quit();
return 0;
}
int main(int argc, char *argv[]) {
std::cout << "Initializing Effect Master 3000..." << std::endl;
signal(SIGINT, SignalHandler);
EffectManager *mgr = EffectManager::getInstance();
Environment *env = mgr->getEnvironment();
env->loadConfig("effectmaster.conf");
if (!createWindow("Effect Master 3000", env->getScreenWidth(), env->getScreenHeight(), env->isFullscreen()) ||
!initOpenGL(env->getScreenWidth(), env->getScreenHeight())) {
std::cout << "Error creating window!" << std::endl;
exit(1);
}
GLenum err = glewInit();
if (GLEW_OK != err) {/* Problem: glewInit failed, something is seriously wrong. */
std::cout << "Error initializing GLEW: " << glewGetErrorString(err) << std::endl;
exit(1);
}
int fps = env->getFps();
int msPerFrame = 1000/fps;
int passedMS = msPerFrame;
unsigned int frameStart = 0;
int rest = 0;
std::cout << "Initialization done!" << std::endl;
mgr->init();
while(!done) {
passedMS = SDL_GetTicks() - frameStart;
frameStart = SDL_GetTicks();
mgr->animate(passedMS);
mgr->draw();
SDL_GL_SwapBuffers();
userInput();
rest = msPerFrame - (SDL_GetTicks() - frameStart);
if (rest < 0 )
rest = 0;
SDL_Delay(rest);
}
std::cout << "Shutting down Effect Master 3000..." << std::endl;
delete env;
delete mgr;
return 0;
}
// Initialize variables and call initalizations for the window, openGL, and textures
void init() {
rotX = rotY = rotZ = 0;
rotAmt = 0.5;
// Each axis will have no rotation when first initalized.
AxisRotation tmp = {false, false};
for( int i = 0; i < 3; i++ ) {
movingRotation[i] = tmp;
}
initWindow();
initOpenGL();
initTextures();
}
///////////////////////////////////////////////////////////////////////////////
//
// tlb_gui function
//
// author: Shaun Gruenig, Hannah Aker, Kelsey Bellew
//
// description: This is a helper function that initializes the GUI and then
// calls the function to print the TLB.
//
//
///////////////////////////////////////////////////////////////////////////////
void tlb_gui()
{
ScreenWidth = 200;
ScreenHeight = TLB_SIZE * 30;
glutInit ( & ( *superargc ), ( *superargv ) );
glutSetOption ( GLUT_ACTION_ON_WINDOW_CLOSE,
GLUT_ACTION_CONTINUE_EXECUTION );
initOpenGL();
glutDisplayFunc ( draw_tlb );
glutMainLoop();
}
///////////////////////////////////////////////////////////////////////////////
//
// pt_gui function
//
// author: Shaun Gruenig, Hannah Aker, Kelsey Bellew
//
// description: This is a helper function that initializes the GUI and then
// calls the function to print the page table.
//
//
///////////////////////////////////////////////////////////////////////////////
void pt_gui()
{
ScreenWidth = 240;
ScreenHeight = ptvec.size() / 2 * 30;
glutInit ( & ( *superargc ), ( *superargv ) );
glutSetOption ( GLUT_ACTION_ON_WINDOW_CLOSE,
GLUT_ACTION_CONTINUE_EXECUTION );
initOpenGL();
glutDisplayFunc ( draw_pt );
glutMainLoop();
}
///////////////////////////////////////////////////////////////////////////////
//
// mem_gui function
//
// author: Shaun Gruenig, Hannah Aker, Kelsey Bellew
//
// description: This is a helper function that initializes the GUI and then
// calls the function to print the physical memory.
//
//
///////////////////////////////////////////////////////////////////////////////
void mem_gui()
{
ScreenWidth = 8 * 130;
ScreenHeight = memvec.size() / 8 * 25;
glutInit ( & ( *superargc ), ( *superargv ) );
glutSetOption ( GLUT_ACTION_ON_WINDOW_CLOSE,
GLUT_ACTION_CONTINUE_EXECUTION );
initOpenGL();
glutDisplayFunc ( draw_mem );
glutMainLoop();
}
