void* render_thread(void* p)
{
/* egl init */
int width = 512, height = 512;
struct wl_egl_window* p_wl_egl_window
= (struct wl_egl_window*)wl_egl_window_create(window->p_wl_surface, width, height);
if (!p_wl_egl_window) {
printf("wl_egl_window_create error\n");
}
egl = egl_init((EGLNativeDisplayType)window->p_wl_display,
(EGLNativeWindowType)p_wl_egl_window);
/* init */
init_gl();
print_gles_env();
while(1) {
draw();
eglSwapBuffers(egl->display, egl->surface);
FPS();
}
return NULL;
}
ENTRYPOINT void init_cube21(ModeInfo *mi)
{
cube21_conf *cp;
if(!cube21) {
cube21 = (cube21_conf *)calloc(MI_NUM_SCREENS(mi), sizeof(cube21_conf));
if(!cube21) return;
}
cp = &cube21[MI_SCREEN(mi)];
cp->trackball = gltrackball_init (False);
if(!cp->texp) {
init_posc(cp);
make_texture(cp);
}
if ((cp->glx_context = init_GL(mi)) != NULL) {
init_gl(mi);
init_cp(cp);
reshape_cube21(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
} else {
MI_CLEARWINDOW(mi);
}
}
static int Init()
{
nInitedSubsytems = SDL_WasInit(SDL_INIT_VIDEO);
if (!(nInitedSubsytems & SDL_INIT_VIDEO)) {
SDL_InitSubSystem(SDL_INIT_VIDEO);
}
nGamesWidth = nVidImageWidth;
nGamesHeight = nVidImageHeight;
nRotateGame = 0;
if (bDrvOkay) {
// Get the game screen size
BurnDrvGetVisibleSize(&nGamesWidth, &nGamesHeight);
if (BurnDrvGetFlags() & BDF_ORIENTATION_VERTICAL) {
printf("Vertical\n");
nRotateGame = 1;
}
if (BurnDrvGetFlags() & BDF_ORIENTATION_FLIPPED) {
printf("Flipped\n");
bFlipped = true;
}
}
if (!nRotateGame) {
nTextureWidth = GetTextureSize(nGamesWidth);
nTextureHeight = GetTextureSize(nGamesHeight);
} else {
nTextureWidth = GetTextureSize(nGamesHeight);
nTextureHeight = GetTextureSize(nGamesWidth);
}
nSize = 2;
bVidScanlines = 0;
RECT test_rect;
test_rect.left = 0;
test_rect.right = nGamesWidth;
test_rect.top = 0;
test_rect.bottom = nGamesHeight;
printf("correctx before %d, %d\n", test_rect.right, test_rect.bottom);
VidSScaleImage(&test_rect);
printf("correctx after %d, %d\n", test_rect.right, test_rect.bottom);
screen = SDL_SetVideoMode(test_rect.right * nSize,
test_rect.bottom * nSize, 32, SDL_OPENGL);
SDL_WM_SetCaption("FB Alpha", NULL);
// Initialize the buffer surfaces
BlitFXInit();
// Init opengl
init_gl();
return 0;
}
/*! initializes the engine in console + graphical mode
*/
void engine::init(const char* ico) {
engine::mode = engine::GRAPHICAL;
m->print(msg::MDEBUG, "engine.cpp", "initializing albion 2 engine in console + graphical mode");
// initialize sdl
atexit(SDL_Quit);
if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE) == -1) {
m->print(msg::MERROR, "engine.cpp", "can't init SDL: %s", SDL_GetError());
exit(1);
}
else {
m->print(msg::MDEBUG, "engine.cpp", "sdl initialized");
}
// load opengl library
SDL_GL_LoadLibrary(NULL);
// get video info
video_info = SDL_GetVideoInfo();
if(!video_info) {
m->print(msg::MDEBUG, "engine.cpp", "video query failed: %s", SDL_GetError());
exit(1);
}
// not working any more?
//m->print(msg::MDEBUG, "engine.cpp", "amount of available video memory: %u kb", video_info->video_mem);
// set some flags
engine::flags |= SDL_HWPALETTE;
engine::flags |= SDL_OPENGL;
engine::flags |= SDL_DOUBLEBUF;
/*if(video_info->hw_available) {
//engine::flags |= SDL_HWSURFACE;
m->print(msg::MDEBUG, "engine.cpp", "using hardware surface");
}
else {
//engine::flags |= SDL_SWSURFACE;
m->print(msg::MDEBUG, "engine.cpp", "using software surface");
}*/
engine::flags |= SDL_HWSURFACE;
if(fullscreen) {
engine::flags |= SDL_FULLSCREEN;
m->print(msg::MDEBUG, "engine.cpp", "fullscreen enabled");
}
else {
m->print(msg::MDEBUG, "engine.cpp", "fullscreen disabled");
}
engine::flags |= SDL_HWACCEL;
// gl attributes
switch(depth) {
case 16:
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 6);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
break;
case 24:
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
break;
case 32:
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
break;
default:
if(depth < 16) {
m->print(msg::MERROR, "engine.cpp", "init(): to low depth, please use at least a depth of 16bit!");
return;
}
else { // depth > 16
m->print(msg::MERROR, "engine.cpp", "init(): unknown depth of %ubit! engine will run in 16bit mode!", depth);
depth = 16;
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 6);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
}
break;
}
SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, depth);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, zbuffer);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, stencil);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1);
// ... load icon before SDL_SetVideoMode
if(ico != NULL) load_ico(ico);
// create screen
engine::height = height;
engine::width = width;
engine::depth = depth;
screen = SDL_SetVideoMode(width, height, depth, flags);
if(screen == NULL) {
m->print(msg::MERROR, "engine.cpp", "can't set video mode: %s", SDL_GetError());
exit(1);
}
else {
m->print(msg::MDEBUG, "engine.cpp", "video mode set: w%u h%u d%u", width,
height, depth);
}
int tmp = 0;
SDL_GL_GetAttribute(SDL_GL_BUFFER_SIZE, &tmp);
m->print(msg::MDEBUG, "engine.cpp", "color depth set to %d bits", tmp);
SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &tmp);
m->print(msg::MDEBUG, "engine.cpp", "z buffer set to %d bits", tmp);
SDL_GL_GetAttribute(SDL_GL_STENCIL_SIZE, &tmp);
m->print(msg::MDEBUG, "engine.cpp", "stencil buffer set to %d bits", tmp);
SDL_GL_GetAttribute(SDL_GL_DOUBLEBUFFER, &tmp);
m->print(msg::MDEBUG, "engine.cpp", "double buffering %s", tmp == 1 ? "enabled" : "disabled");
g->set_surface(screen);
// print out some opengl informations
m->print(msg::MDEBUG, "engine.cpp", "vendor: %s", glGetString(GL_VENDOR));
m->print(msg::MDEBUG, "engine.cpp", "renderer: %s", glGetString(GL_RENDERER));
m->print(msg::MDEBUG, "engine.cpp", "version: %s", glGetString(GL_VERSION));
// enable key repeat
if((SDL_EnableKeyRepeat(key_repeat, SDL_DEFAULT_REPEAT_INTERVAL))) {
m->print(msg::MDEBUG, "engine.cpp", "setting keyboard repeat failed: %s",
SDL_GetError());
exit(1);
}
else {
m->print(msg::MDEBUG, "engine.cpp", "keyboard repeat set");
}
// initialize ogl
init_gl();
m->print(msg::MDEBUG, "engine.cpp", "opengl initialized");
// resize stuff
resize_window();
// reserve memory for position and rotation ...
engine::position = new vertex3();
engine::rotation = new vertex3();
// create extension class object
exts = new ext(engine::mode, m);
// set flip state of core class to true if fbos are supported
if(exts->is_fbo_support()) {
c->set_flip(true);
}
// create render to texture object
r = new rtt(m, c, g, exts, screen->w, screen->h);
// print out informations about additional threads
omp_set_num_threads(thread_count);
thread_count = omp_get_max_threads();
thread_count == 1 ? m->print(msg::MDEBUG, "engine.cpp", "using one single thread!") :
m->print(msg::MDEBUG, "engine.cpp", "using %u threads!", thread_count);
// if GL_RENDERER is that damn m$ gdi driver, exit a2e ...
// no official support for this crappy piece of software ...
if(strcmp((const char*)glGetString(GL_RENDERER), "GDI Generic") == 0) {
m->print(msg::MERROR, "engine.cpp", "A2E doesn't support the MS GDI Generic driver!\nGo and install one of these (that match your grapic card):\nhttp://www.ati.com http://www.nvidia.com http://www.matrox.com http://www.3dlabs.com http://www.intel.com");
SDL_Delay(10000);
exit(1);
}
// set standard texture filtering
t->set_filtering(engine::filtering);
// check if hdrr is technically possible
if(hdr && !exts->is_shader_support() && !exts->is_fbo_support()) {
hdr = false;
}
m->print(msg::MDEBUG, "engine.cpp", "HDR-Rendering is %s!", (hdr ? "enabled" : "disabled"));
}
int main(int argc, char** argv)
{
if(argc != 2)
usage(argv[0]);
FILE* infile = fopen(argv[1], "r");
if(infile == NULL)
{
perror("Error opening input file");
return EXIT_FAILURE;
}
System* sys = load_system(infile);
if(sys == NULL)
{
printf("Loading input file failed\n");
return EXIT_FAILURE;
}
init_simulation(sys);
state.sys = sys;
state.views = malloc(sys->nplanets * sizeof(PlanetView));
for(int i = 0; i < sys->nplanets; i++)
state.views[i].radius = pow(sys->planets[i].mass / DENSITY_FACTOR, 1.0f/3.0f);
state.scale = 1.0f;
Vector* fst_pos = &sys->planets[0].position;
vector_copy(state.pos, *fst_pos);
state.pos[1] += 1.1f*get_planet_radius(0);
state.pos[0] -= get_planet_radius(0);
state.rot_x = 90.0f;
state.locked_planet = -1;
state.hours_per_sec = DEFAULT_SIMULATION_SPEED;
state.time_step = sys->time_step;
state.paused = true;
state.trails_enabled = true;
if(SDL_Init(SDL_INIT_VIDEO) < 0)
die("SDL initialization failed");
atexit(SDL_Quit);
const SDL_VideoInfo* videoInfo = SDL_GetVideoInfo();
if(!videoInfo)
die("Could not get video information");
int videoFlags = SDL_OPENGL | SDL_HWPALETTE | SDL_RESIZABLE | SDL_HWSURFACE | SDL_HWACCEL;
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4);
surface = SDL_SetVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP, videoFlags);
if(!surface)
{
printf("Surface creation failed, trying to disable anti-aliasing...\n");
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 0);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 0);
surface = SDL_SetVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP, videoFlags);
}
if(!surface)
die("Changing video mode failed");
init_gl();
init_viewport();
SDL_ShowCursor(0);
SDL_WM_GrabInput(SDL_GRAB_ON);
SDL_Event event;
while(SDL_PollEvent(&event))
; /* ignore spurious mouse events at startup */
bool window_is_active = true;
int step = 0;
while (true)
{
Uint32 next_update = SDL_GetTicks() + FRAME_INTERVAL;
while (SDL_PollEvent(&event))
{
switch(event.type)
{
case SDL_ACTIVEEVENT:
window_is_active = event.active.gain;
break;
case SDL_VIDEORESIZE:
surface = SDL_SetVideoMode(event.resize.w,
event.resize.h,
SCREEN_BPP, videoFlags);
if(!surface)
die("Lost video surface during resize");
init_viewport();
break;
case SDL_KEYDOWN:
handle_keypress(&event.key.keysym);
break;
case SDL_MOUSEMOTION:
handle_mouse(&event.motion);
break;
case SDL_QUIT:
goto out;
default:
break;
}
}
update();
if(window_is_active)
{
draw_scene();
glFlush();
SDL_GL_SwapBuffers();
}
if(!state.paused)
{
for(int i = 0; i < (state.hours_per_sec * 3600.0f / FRAME_INTERVAL) / state.time_step; i++)
{
if((step % TRAILS_INTERVAL) == 0)
update_trails();
simulate_one_step(sys, step++, state.time_step);
}
}
Sint32 delta = next_update - SDL_GetTicks();
if(delta > 0)
SDL_Delay(delta);
}
out:
return 0;
}
BOOL create_gl_window(LPCWSTR title, int width, int height, int bits, bool is_fullscreen)
{
GLuint pixel_format;
WNDCLASS wc;
DWORD dwExStyle;
DWORD dwStyle;
RECT windowRect;
windowRect.left = 0L;
windowRect.right = (long)width;
windowRect.top = 0L;
windowRect.bottom = (long)height;
fullscreen = is_fullscreen;
hInstance = GetModuleHandle(nullptr);
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wc.lpfnWndProc = (WNDPROC)WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hIcon = LoadIcon(nullptr, IDI_WINLOGO);
wc.hCursor = LoadCursor(nullptr, IDC_ARROW);
wc.hbrBackground = nullptr;
wc.lpszMenuName = nullptr;
wc.lpszClassName = WND_CLASSNAME;
if (!RegisterClass(&wc))
{
MessageBox(nullptr, L"Could not register window class", L"Create window Error", MB_OK | MB_ICONINFORMATION);
return FALSE;
}
if (fullscreen)
{
DEVMODE dmScreenSettings;
memset(&dmScreenSettings, 0, sizeof(DEVMODE));
dmScreenSettings.dmSize = sizeof(dmScreenSettings);
dmScreenSettings.dmPelsWidth = width;
dmScreenSettings.dmPelsHeight = height;
dmScreenSettings.dmBitsPerPel = bits;
dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
if (ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
{
if (MessageBox(nullptr, L"The requested fullscreen mode not supported by\nyour video card.\nUse windowed mode instead?",
L"Create window Error", MB_YESNO | MB_ICONEXCLAMATION) == IDYES)
fullscreen = false;
else
{
MessageBox(nullptr, L"Program will now close", L"Create window Error", MB_OK | MB_ICONSTOP);
return FALSE;
}
}
}
if (fullscreen)
{
dwExStyle = WS_EX_APPWINDOW;
dwStyle = WS_POPUP;
ShowCursor(FALSE);
}
else
{
dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
dwStyle = WS_OVERLAPPEDWINDOW;
}
AdjustWindowRectEx(&windowRect, dwStyle, FALSE, dwExStyle);
/* Creating window */
if (!(hWnd = CreateWindowEx(dwExStyle,
WND_CLASSNAME,
title,
dwStyle | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
0UL, 0UL,
windowRect.right - windowRect.left,
windowRect.bottom - windowRect.top,
nullptr,
nullptr,
hInstance,
nullptr)))
{
kill_gl_window();
MessageBox(nullptr, L"Window creation failed", L"Create window Error", MB_OK | MB_ICONEXCLAMATION);
return FALSE;
}
/* Pixel Format Descriptor */
static PIXELFORMATDESCRIPTOR pfd =
{
sizeof(PIXELFORMATDESCRIPTOR),
1,
PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
PFD_TYPE_RGBA,
bits,
0, 0, 0, 0, 0, 0,
0,
0,
0,
0, 0, 0, 0,
DEPTH_BITS, // 32-bit Z-buffer (depth buffer)
0,
0,
PFD_MAIN_PLANE,
0,
0, 0, 0
};
if (!(hDC = GetDC(hWnd)))
{
kill_gl_window();
MessageBox(nullptr, L"Can't create a GL Device Context.", L"Create window Error", MB_OK | MB_ICONEXCLAMATION);
return FALSE;
}
if (!(pixel_format = ChoosePixelFormat(hDC, &pfd)))
{
kill_gl_window();
MessageBox(nullptr, L"Can't find suitable pixel format.", L"Create window Error", MB_OK | MB_ICONEXCLAMATION);
return FALSE;
}
if (!SetPixelFormat(hDC, pixel_format, &pfd))
{
kill_gl_window();
MessageBox(nullptr, L"Can't set pixel format.", L"Create window Error", MB_OK | MB_ICONEXCLAMATION);
return FALSE;
}
if (!(hRC = wglCreateContext(hDC)))
{
kill_gl_window();
MessageBox(nullptr, L"Can't create GL Rendering Context.", L"Create window Error", MB_OK | MB_ICONEXCLAMATION);
return FALSE;
}
if (!wglMakeCurrent(hDC, hRC))
{
kill_gl_window();
MessageBox(nullptr, L"Can't activate GL Rendering Context.", L"Create window Error", MB_OK | MB_ICONEXCLAMATION);
return FALSE;
}
ShowWindow(hWnd, SW_SHOW);
SetForegroundWindow(hWnd);
SetFocus(hWnd);
resize_gl_scene((GLsizei)width, (GLsizei)height);
if (!init_gl())
{
kill_gl_window();
MessageBox(nullptr, L"Initialization failed", L"Create window Error", MB_OK | MB_ICONEXCLAMATION);
return FALSE;
}
return TRUE;
}
void setup_scene_gl(Scene *s)
{
init_gl(s);
setup_programs_gl(s, s->objs);
}
int
main( int argc, char *argv[ ] )
{
cmd_args args;
if( !args.parse( argc, (const char**)argv ) ) {
return 1;
}
//setup glut
glutInit( &argc, argv );
glutInitDisplayMode( GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA );
glutInitWindowSize( 640, 480 );
glutCreateWindow( "Flock of Birds Demo" );
//setup gl
init_gl( );
//set callbacks
glutKeyboardFunc( handle_keyboard );
glutReshapeFunc( handle_resize );
glutDisplayFunc( render );
glutIdleFunc( render );
#if ENABLE_FBB
fob::hemisphere hemisphere = fob::DOWN;
fob::port_speed speed = args.speed;
//talk to flock
flock.open( args.serial, hemisphere, speed, args.sleep_ms );
if( !flock ) {
std::cerr << "fatal: " << flock.get_error( ) << std::endl;
return 1;
}
//get a list of birds connected to the machine
fob::bird_list& birds = flock.get_birds( );
p_birds = &flock.get_birds( );
num_birds = birds.size( );
if( num_birds > MAX_ENTS ) num_birds = MAX_ENTS;
#else
unsigned int num_birds = 1;
#endif
#if ENABLE_FBB
//for each bird, set that we want position and orientation
for( unsigned int i = 0; i < birds.size( ); ++i ) {
if( !birds[ i ]->set_mode( fob::POSITION | fob::ORIENTATION | fob::BUTTONS ) ) {
std::cerr << "fatal: " << flock.get_error( ) << std::endl;
return 1;
}
}
#endif
//setup the camera
cam.set_position( 0.0, 100.0, 0.0 );
cam.set_look_right( math::vector3( 0.0, 0.0, 0.0 ), math::vector3::X_AXIS );
#if ENABLE_FBB
//set the flock flying
flock.fly( );
atexit( handle_exit );
//let the bird start up . . .
sleep( 1 );
#endif
//create the button sphere
sphere = gluNewQuadric( );
//start glut
glutMainLoop( );
//no errors
return 0;
}
int main( int argc, char **argv )
{
if ( use_gui )
{
printf("init_sdl()\n");
if ( init_sdl() ) return 1;
printf("init_gl()\n");
init_gl();
}
printf("init_fft()\n");
init_fft();
#ifdef USE_FIFO
printf("init_mpd()\n");
if ( init_mpd() ) return 1;
#endif
#ifdef USE_ALSA
printf("init_alsa()\n");
if ( init_alsa() ) return 1;
#endif
if ( use_serial )
{
printf("init_serial()\n");
if ( init_serial() ) use_serial = FALSE;
}
init_lights();
init_table();
pthread_t sample_thread;
pthread_create(&sample_thread, NULL, &get_samples, NULL);
while ( !done )
{
// check to see if we have a new sample
if (new_sample == 1)
{
// we are going to process this sample, it is no longer new
pthread_mutex_lock(&sample_mutex);
new_sample = 0;
pthread_mutex_unlock(&sample_mutex);
do_fft();
detect_beats();
assign_lights();
//assign_cells();
if ( use_gui )
{
if (handle_sdl_events()) return 1;
draw_all();
}
if ( use_serial ) send_serial_fpga();
}
usleep(5000);
}
return 0;
}
int main(int argc, char *argv[])
{
struct opt_data opts; optproc(argc, argv, &opts);
if(audio_init(&opts) < 0) exit(1);
if(opts.w < 0 && opts.h < 0) opts.w = opts.h = 512;
else if(opts.w < 0) opts.w = opts.h;
else if(opts.h < 0) opts.h = opts.w;
int ret;
ret = init_drm(&opts, 512);
if (ret) {
printf("failed to initialize DRM\n");
return ret;
}
ret = init_gbm();
if (ret) {
printf("failed to initialize GBM\n");
return ret;
}
ret = init_egl();
if (ret) {
printf("failed to initialize EGL\n");
return ret;
}
// call init_gl
//init_gl(&opts, drm.mode->hdisplay, drm.mode->vdisplay);
init_gl(&opts, opts.w, opts.h); //TODO: better dealing with our great big screen
eglSwapBuffers(gl.display, gl.surface);
struct gbm_bo *bo = gbm_surface_lock_front_buffer(gbm.surface);
fb = drm_fb_get_from_bo(bo);
/* set mode: */
ret = drmModeSetCrtc(drm.fd, drm.crtc_id, fb->fb_id, 0, 0,
&drm.connector_id, 1, drm.mode);
if (ret) {
printf("failed to set mode: %s\n", strerror(errno));
return ret;
}
// turn off line buffering on input and echoing of characters
struct termios term;
tcgetattr(STDIN_FILENO, &save_term);
tcgetattr(STDIN_FILENO, &term);
term.c_lflag &= ~(ICANON|ECHO);
tcsetattr(STDIN_FILENO, TCSANOW, &term);
atexit(shutdown_cleanup);
drmVBlank vbl;
/* Get current count first hopefully also sync up with blank too*/
vbl.request.type = DRM_VBLANK_RELATIVE;
vbl.request.sequence = 1;
ret = drmWaitVBlank(drm.fd, &vbl);
if (ret != 0) {
printf("drmWaitVBlank (relative, event) failed ret: %i\n", ret);
return -1;
}
printf("starting msc: %d\n", vbl.request.sequence);
/* Queue an event for frame + 1 */
vbl.request.type = DRM_VBLANK_RELATIVE | DRM_VBLANK_EVENT;
vbl.request.sequence = 1;
vbl.request.signal = NULL;
ret = drmWaitVBlank(drm.fd, &vbl);
if (ret != 0) {
printf("drmWaitVBlank (relative, event) failed ret: %i\n", ret);
return -1;
}
struct pollfd pfds[] = {
{drm.fd, POLLIN | POLLPRI, 0 },
{STDIN_FILENO, POLLIN, 0 },
};
int debug_maxsrc = 0, debug_pal = 0, show_mandel = 0, show_fps_hist = 0;
bool done = false;
while (!done) {
render_frame(debug_maxsrc, debug_pal, show_mandel, show_fps_hist);
while (waiting_for_flip) { // TODO: input handling
ret = poll(pfds, 2, -1);
if (ret < 0) {
printf("poll err: %s\n", strerror(errno));
return ret;
} else if (ret == 0) {
printf("poll timeout!\n");
done = true;
break;
}
if (pfds[1].revents) {
char buf[128];
int cnt = read(STDIN_FILENO, buf, sizeof(buf));
if(buf[0] == 27) done = true;
else if(buf[0] == '1') debug_maxsrc = !debug_maxsrc;
else if(buf[0] == '2') debug_pal = !debug_pal;
else if(buf[0] == '3') show_mandel = !show_mandel;
else if(buf[0] == '4') show_fps_hist = !show_fps_hist;
//continue;
}
if(pfds[0].revents)
drmHandleEvent(drm.fd, &evctx);
}
/* release last buffer to render on again: */
gbm_surface_release_buffer(gbm.surface, bo);
bo = next_bo;
}
audio_shutdown();
return ret;
}
// ---------------------------------------------------------------------------
void OSXWindowImpl::on_init()
{
init_gl();
init_glfont();
aglUpdateContext(mGLContext);
}
int
main (int argc, char **argv)
{
int i;
double now;
feenableexcept(FE_INVALID|FE_DIVBYZERO|FE_OVERFLOW);
init_sdl_gl_flags (WIDTH, HEIGHT, 0);
srandom (time (NULL));
init_gl (&argc, argv);
glEnable (GL_LIGHTING);
glEnable (GL_DEPTH_TEST);
glEnable (GL_AUTO_NORMAL);
glEnable (GL_NORMALIZE);
glClearDepth (1);
glViewport (0, 0, WIDTH, HEIGHT);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
gluPerspective (60, (GLfloat) WIDTH/(GLfloat) HEIGHT, .1, 1000);
glClearColor (0, 0, 0, 0);
glMatrixMode (GL_MODELVIEW);
SDL_ShowCursor (1);
makeImages ();
glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
glGenTextures (1, texName);
makeTexture (texName[0], groundtexture.texturesize,
(GLubyte ***) groundtexture.tex);
glTexGeni (GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
glTexGeni (GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
glBlendFunc (GL_SRC_ALPHA, GL_ONE);
gndcounter = 1;
read_terrain ();
player.p.x = 0;
player.p.y = 0;
player.p.z = ground_height (&player.p);
player.loc = detect_plane (&player.p);
player.movtype = GROUNDED;
player.speed = 100;
player.mass = 1;
vset (&player.vel, 0, 0, 0);
player.turnspeed = DTOR (180);
player.theta = DTOR (0);
player.camdist = 15;
player.lasttime = get_secs ();
player.moving = NO;
playercamera.phi = DTOR (0);
playercamera.theta_difference = 0;
while (1) {
process_input ();
if (mousebutton[1] == 0
&& mousebutton[2] == 0
&& mousebutton[3] == 0) {
SDL_ShowCursor (1);
} else {
SDL_ShowCursor (0);
}
movement ();
if (paused == NO) {
for (i = 0; i < 1; i++) {
moving ();
now = get_secs ();
player.lasttime = now;
}
}
process_mouse ();
draw ();
now = get_secs ();
player.lasttime = now;
SDL_Delay (10);
}
return (0);
}
int main(int argc, char **argv) {
init_glut(&argc, argv);
init_gl();
glutMainLoop();
return 0;
}
void init()
{
input_handler = 0;
init_keytable();
//_ui_events.reserve(40);
_ui_key = 0;
WNDCLASS wc = { 0 };
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wc.lpfnWndProc = wnd_proc;
wc.hInstance = GetModuleHandle(0);
wc.hIcon = LoadIcon(0, IDI_WINLOGO);
wc.hCursor = LoadCursor(0, IDC_ARROW);
wc.lpszClassName = "shiva_wc";
if (!RegisterClass(&wc)) {
TRACE("Failed to register window class\n");
return;
}
init_gl();
DWORD style = WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_OVERLAPPEDWINDOW;
DWORD xstyle = WS_EX_APPWINDOW;
PIXELFORMATDESCRIPTOR pfd = {
sizeof(PIXELFORMATDESCRIPTOR), 1, PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
PFD_TYPE_RGBA, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 0, 0, PFD_MAIN_PLANE, 0, 0, 0, 0
};
if (0/*fulscreen*/) {
style = WS_POPUP | WS_MAXIMIZE;
xstyle |= WS_EX_TOPMOST;
DEVMODE deviceMode = { 0 };
deviceMode.dmSize = sizeof(DEVMODE);
EnumDisplaySettings(0, ENUM_CURRENT_SETTINGS, &deviceMode);
if (ChangeDisplaySettings(&deviceMode, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL) {
TRACE("Failed to set fullscreen window");
}
}
RECT wr = { 0, 0, 800, 600 };
AdjustWindowRectEx(&wr, style, 0, xstyle);
int w = wr.right - wr.left;
int h = wr.bottom - wr.top;
wnd = CreateWindowEx(xstyle, wc.lpszClassName, "OpenVG", style, 10, 10, w, h, 0, 0, wc.hInstance, 0);
if (!wnd) {
TRACE("Failed to create system window!\n");
return;
}
dc = GetDC(wnd);
int pixelFormat;
BOOL valid;
UINT numFormats;
int iAttributes[] = {
WGL_DRAW_TO_WINDOW_ARB, GL_TRUE,
WGL_SUPPORT_OPENGL_ARB, GL_TRUE,
WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB,
WGL_COLOR_BITS_ARB, 24,
WGL_ALPHA_BITS_ARB, 8,
WGL_DEPTH_BITS_ARB, 24,
WGL_STENCIL_BITS_ARB, 8,
WGL_DOUBLE_BUFFER_ARB, GL_TRUE,
0, 0 };
// WGL_SAMPLE_BUFFERS_ARB, GL_TRUE,
// WGL_SAMPLES_ARB, 4, // Check For 4x Multisampling
if (wglChoosePixelFormatARB == NULL)
{
if (wglGetCurrentContext() == NULL) {
//
MessageBoxA(0, (char*)glGetString(GL_VERSION), "Context lost", 0);
}
MessageBoxA(0, (char*)glGetString(GL_VERSION), "Cannot find extension, wglChoosePixelFormatARB", 0);
}
else
{
valid = wglChoosePixelFormatARB(dc, iAttributes, 0, 1, &pixelFormat, &numFormats);
int pf = ChoosePixelFormat(dc, &pfd);
BOOL ok = SetPixelFormat(dc, pixelFormat, &pfd);
}
int attr[] = {
WGL_CONTEXT_MAJOR_VERSION_ARB, 1,
WGL_CONTEXT_MINOR_VERSION_ARB, 2,
WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB,
WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_CORE_PROFILE_BIT_ARB,
WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_DEBUG_BIT_ARB,
0
};
if (wglCreateContextAttribsARB == NULL)
{
MessageBoxA(0, (char*)glGetString(GL_VERSION), "Cannot find extension, wglCreateContextAttribsARB", 0);
return;
}
glrc = wglCreateContextAttribsARB(dc, 0, attr);
/*
for (int i = 0; i < 2; ++i) {
GLuint swap_group = 1;
if (!wglJoinSwapGroupNV(context.channels[i].dc, swap_group)) {
TRACE("ERROR: failed to join sawp group");
}
if (!wglBindSwapBarrierNV(swap_group, 1)) {
TRACE("ERROR: failed to bind sawp barrier");
}
}
*/
// set channel 0 to current so graphics can initiate correctly
wglMakeCurrent(dc, glrc);
glDebugMessageCallbackARB = (PFGLDEBUGMESSAGECALLBACKARB) wglGetProcAddress("glDebugMessageCallbackARB");
if (glDebugMessageCallbackARB == NULL)
{
MessageBoxA(0, (char*)glGetString(GL_VERSION), "Unimplemented glDebugMessageCallbackARB", 0);
}
else
{
glDebugMessageCallbackARB(&gl_debug_msg_proc, 0);
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
}
ShowWindow(wnd, SW_SHOW);
UpdateWindow(wnd);
vgCreateContextSH(800, 600);
}
int
main(int argc, char **argv)
{
struct sigaction sigint;
struct display display = { 0 };
struct window window = { 0 };
int i, ret = 0;
window.display = &display;
display.window = &window;
window.window_size.width = 250;
window.window_size.height = 250;
for (i = 1; i < argc; i++) {
if (strcmp("-f", argv[i]) == 0)
window.fullscreen = 1;
else if (strcmp("-o", argv[i]) == 0)
window.opaque = 1;
else if (strcmp("-h", argv[i]) == 0)
usage(EXIT_SUCCESS);
else
usage(EXIT_FAILURE);
}
display.display = wl_display_connect(NULL);
assert(display.display);
display.registry = wl_display_get_registry(display.display);
wl_registry_add_listener(display.registry,
®istry_listener, &display);
wl_display_dispatch(display.display);
init_egl(&display, window.opaque);
create_surface(&window);
init_gl(&window);
display.cursor_surface =
wl_compositor_create_surface(display.compositor);
sigint.sa_handler = signal_int;
sigemptyset(&sigint.sa_mask);
sigint.sa_flags = SA_RESETHAND;
sigaction(SIGINT, &sigint, NULL);
while (running && ret != -1)
ret = wl_display_dispatch(display.display);
fprintf(stderr, "simple-egl exiting\n");
destroy_surface(&window);
fini_egl(&display);
wl_surface_destroy(display.cursor_surface);
if (display.cursor_theme)
wl_cursor_theme_destroy(display.cursor_theme);
if (display.shell)
wl_shell_destroy(display.shell);
if (display.compositor)
wl_compositor_destroy(display.compositor);
wl_registry_destroy(display.registry);
wl_display_flush(display.display);
wl_display_disconnect(display.display);
return 0;
}
int main(int argc, char **argv)
{
opt_data opts; optproc(argc, argv, &opts);
if(audio_init(&opts) < 0) exit(1);
int x = 0, y = 0, w, h;
if(opts.w < 0 && opts.h < 0) opts.w = opts.h = 512;
else if(opts.w < 0) opts.w = opts.h;
else if(opts.h < 0) opts.h = opts.w;
w = opts.w; h = opts.h;
XEvent event;
dpy = XOpenDisplay( NULL );
if(dpy == NULL) {
printf("Error: couldn't open display %s\n", getenv("DISPLAY"));
exit(EXIT_FAILURE);
}
int glx_major, glx_minor;
if(!glXQueryVersion(dpy, &glx_major, &glx_minor)) {
printf("GLX extension missing!\n");
XCloseDisplay(dpy);
exit(EXIT_FAILURE);
}
printf("GLX version %i.%i\n", glx_major, glx_minor);
int glxErrBase, glxEventBase;
glXQueryExtension(dpy, &glxErrBase, &glxEventBase);
printf("GLX: errorBase = %i, eventBase = %i\n", glxErrBase, glxEventBase);
Window xwin, root;
int numReturned;
GLXFBConfig *fbConfigs;
fbConfigs = glXChooseFBConfig( dpy, DefaultScreen(dpy), fbattrib, &numReturned );
if(fbConfigs == NULL) { //TODO: handle this?
printf("No suitable fbconfigs!\n");
exit(EXIT_FAILURE);
}
XVisualInfo *vinfo = glXGetVisualFromFBConfig( dpy, fbConfigs[0] );
root = DefaultRootWindow(dpy);
/* window attributes */
XSetWindowAttributes attrs;
attrs.background_pixel = 0;
attrs.border_pixel = 0;
attrs.colormap = XCreateColormap(dpy, root, vinfo->visual, AllocNone);
//attrs.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
attrs.event_mask = StructureNotifyMask | KeyPressMask;
unsigned long mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
xwin = XCreateWindow(dpy, root, x, y, w, h,
0, vinfo->depth, InputOutput,
vinfo->visual, mask, &attrs);
XFree(vinfo);
// Set hints and properties:
{
XSizeHints sizehints;
sizehints.x = x;
sizehints.y = y;
sizehints.width = w;
sizehints.height = h;
sizehints.flags = USSize | USPosition;
XSetNormalHints(dpy, xwin, &sizehints);
XSetStandardProperties(dpy, xwin, "Julia-vis", "Julia-vis",
None, (char **)NULL, 0, &sizehints);
}
/* Create a GLX context for OpenGL rendering */
GLXContext context = glXCreateNewContext(dpy, fbConfigs[0], GLX_RGBA_TYPE, NULL, True );
#if 0
GLXContext context = 0;
glXCreateContextAttribsARBProc glXCreateContextAttribsARB = 0;
glXCreateContextAttribsARB = (glXCreateContextAttribsARBProc)glXGetProcAddressARB( (const GLubyte *) "glXCreateContextAttribsARB" );
if(strstr(glXQueryExtensionsString(dpy, 0), "GLX_ARB_create_context") || !glXCreateContextAttribsARB) {
printf("glXCreateContextAttribsARB() not found ... using old-style GLX context\n");
context = glXCreateNewContext(dpy, fbConfigs[0], GLX_RGBA_TYPE, 0, True);
} else {
const int context_attribs[] = {
GLX_RENDER_TYPE, GLX_RGBA_TYPE,
GLX_CONTEXT_MAJOR_VERSION_ARB, 2,
GLX_CONTEXT_MINOR_VERSION_ARB, 1,
None
};
context = glXCreateContextAttribsARB(dpy, fbConfigs[0], NULL, True, context_attribs);
}
if(context == NULL) {
printf("Failed to create context!\n");
return EXIT_FAILURE;
}
#endif
glxWin = glXCreateWindow(dpy, fbConfigs[0], xwin, NULL );
XMapWindow(dpy, xwin);
XIfEvent(dpy, &event, WaitForNotify, (XPointer) xwin);
glXMakeContextCurrent(dpy, glxWin, glxWin, context);
init_gl(&opts, w, h);
if(strstr(glXQueryExtensionsString(dpy, 0), "GLX_MESA_swap_control")) {
PFNGLXSWAPINTERVALMESAPROC swap_interval = glXGetProcAddressARB("glXSwapIntervalMESA");
swap_interval(1);
opts.draw_rate = 300;
}
if(strstr(glXQueryExtensionsString(dpy, 0), "GLX_INTEL_swap_event")) {
glXSelectEvent(dpy, glxWin, GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK);
have_intel_swap_event = GL_TRUE;
}
int debug_maxsrc = 0, debug_pal = 0, show_mandel = 0, show_fps_hist = 0;
if(have_intel_swap_event)
render_frame(debug_maxsrc, debug_pal, show_mandel, show_fps_hist);
while(1) {
if(!have_intel_swap_event) render_frame(debug_maxsrc, debug_pal, show_mandel, show_fps_hist);
int clear_key = 1;
while (XPending(dpy) > 0)
{
XNextEvent(dpy, &event);
if(event.type == glxEventBase + GLX_BufferSwapComplete) {
render_frame(debug_maxsrc, debug_pal, show_mandel, show_fps_hist);
continue;
}
switch (event.type) {
case Expose:
/* we'll redraw below */
break;
/*case ConfigureNotify:
window_w = event.xconfigure.width;
window_h = event.xconfigure.height;
if (surface_type == EGL_WINDOW_BIT)
reshape(window_w, window_h);
break;*/
case KeyPress:
{
clear_key = 0;
char buffer[10];
int r, code;
code = XLookupKeysym(&event.xkey, 0);
if (code == XK_F1) {
debug_maxsrc = !debug_maxsrc;
} else if (code == XK_F2) {
debug_pal = !debug_pal;
} else if (code == XK_F3) {
show_mandel = !show_mandel;
} else if (code == XK_F4) {
show_fps_hist = !show_fps_hist;
} else {
code = XLookupKeysym(&event.xkey, 1);
if(code == XK_Escape) {
goto glx_main_loop_quit;
}
}
}
break;
default:
//printf("Bar %i!\n", event.type);
break;
}
}
}
glx_main_loop_quit:
audio_shutdown();
XDestroyWindow(dpy, xwin);
XCloseDisplay(dpy);
return 0;
}
//----------------------------------------------------------------------
int main(int argc, char** argv)
{
printf("Hello, OpenCL\n");
// Parse command line options
//
int use_gpu = 1;
for(int i = 0; i < argc && argv; i++)
{
if(!argv[i])
continue;
if(strstr(argv[i], "cpu"))
use_gpu = 0;
else if(strstr(argv[i], "gpu"))
use_gpu = 1;
}
printf("Parameter detect %s device\n",use_gpu==1?"GPU":"CPU");
//Setup our GLUT window and OpenGL related things
//glut callback functions are setup here too
init_gl(argc, argv);
//initialize our CL object, this sets up the context
example = new CL(use_gpu);
//load and build our CL program from the file
//#include "part2.cl" //std::string kernel_source is defined in this file
example->loadProgram("part2.cl");
//initialize our particle system with positions, velocities and color
int num = NUM_PARTICLES;
std::vector<Vec4> pos(num);
std::vector<Vec4> vel(num);
std::vector<Vec4> color(num);
//fill our vectors with initial data
for(int i = 0; i < num; i++)
{
//distribute the particles in a random circle around z axis
float rad = rand_float(.2, .5);
float x = rad*sin(2*3.14 * i/num);
float z = 0.0f;// -.1 + .2f * i/num;
float y = rad*cos(2*3.14 * i/num);
pos[i] = Vec4(x, y, z, 1.0f);
//give some initial velocity
//float xr = rand_float(-.1, .1);
//float yr = rand_float(1.f, 3.f);
//the life is the lifetime of the particle: 1 = alive 0 = dead
//as you will see in part2.cl we reset the particle when it dies
float life_r = rand_float(0.f, 1.f);
vel[i] = Vec4(0.0, 0.0, 3.0f, life_r);
//just make them red and full alpha
color[i] = Vec4(1.0f, 0.0f,0.0f, 1.0f);
}
//our load data function sends our initial values to the GPU
example->loadData(pos, vel, color);
//initialize the kernel
example->popCorn();
//this starts the GLUT program, from here on out everything we want
//to do needs to be done in glut callback functions
glutMainLoop();
}
int main(int argc, char** argv)
{
// Create a configuration object, and set the values to the defaults
configuration config;
config.num_threads = NUM_THREADS;
config.video.screen_width = SCREEN_WIDTH;
config.video.screen_height = SCREEN_HEIGHT;
config.video.screen_depth = SCREEN_DEPTH;
config.video.frames_per_second = FPS;
config.input.influence_radius = INFLUENCE_RADIUS;
config.flock.size = NUM_BOIDS;
config.flock.max_velocity = MAX_BOID_VELOCITY;
config.flock.min_separation = MIN_BOID_SEPARATION;
config.flock.max_steering_force = MAX_BOID_STEERING_FORCE;
config.flock.neighborhood_radius = NEIGHBORHOOD_RADIUS;
// Parse arguments
int i;
for(i = 1; i < argc; i++)
{
if(strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0)
return print_help();
else if(strcmp(argv[i], "--width") == 0)
config.video.screen_width = atoi(argv[++i]);
else if(strcmp(argv[i], "--height") == 0)
config.video.screen_height = atoi(argv[++i]);
else if(strcmp(argv[i], "--depth") == 0)
config.video.screen_depth = atoi(argv[++i]);
else if(strcmp(argv[i], "--fps") == 0)
config.video.frames_per_second = atoi(argv[++i]);
else if(strcmp(argv[i], "-ir") == 0 || strcmp(argv[i], "--influence-radius") == 0)
config.input.influence_radius = atoi(argv[++i]);
else if(strcmp(argv[i], "-fc") == 0 || strcmp(argv[i], "--flock-count") == 0)
config.flock.size = atoi(argv[++i]);
else if(strcmp(argv[i], "-fs") == 0 || strcmp(argv[i], "--flock-separation") == 0)
config.flock.min_separation = atoi(argv[++i]);
else if(strcmp(argv[i], "-fv") == 0 || strcmp(argv[i], "--flock-velocity") == 0)
config.flock.max_velocity = atoi(argv[++i]);
else if(strcmp(argv[i], "-fn") == 0 || strcmp(argv[i], "--flock-neighborhood") == 0)
config.flock.neighborhood_radius = atoi(argv[++i]);
else if(strcmp(argv[i], "-t") == 0 || strcmp(argv[i], "--num-threads") == 0)
config.num_threads = atoi(argv[++i]);
}
srand(time(NULL));
// Init SDL and create our screen
if(SDL_Init(SDL_INIT_VIDEO) < 0) printf("Unable to initialize SDL. %s\n", SDL_GetError());
SDL_Event event;
int flags = SDL_OPENGL;
// Attempt to set the video mode
SDL_Surface* screen = SDL_SetVideoMode(config.video.screen_width, config.video.screen_height,
config.video.screen_depth, flags);
if(!screen) printf("Unable to set video mode.\n");
// Set the window caption
SDL_WM_SetCaption("tinyflock", NULL);
// Create our flock
boid* flock = create_flock(&config);
init_gl(config.video.screen_width, config.video.screen_height);
vector cursor_pos;
vector_init_scalar(&cursor_pos, 0);
int cursor_interaction = 0;
int run = 1;
int update_count = 0;
int frame_count = 0;
flock_update_args update_args = {&run, flock, &config, &cursor_pos, &cursor_interaction, &update_count };
SDL_Thread* update = SDL_CreateThread(flock_update_thread, (void*)&update_args);
status_args stat_args = {&run, &frame_count, &update_count};
SDL_Thread* status = SDL_CreateThread(status_thread, (void*)&stat_args);
// If the frame limit is not greater than 0, don't delay between frames at all.
float delay = (1000 / config.video.frames_per_second);
while(run)
{
run = handle_events(&event, &cursor_pos, &cursor_interaction);
flock_render(flock, &config, screen);
SDL_Delay(delay);
frame_count++;
}
SDL_WaitThread(update, NULL);
SDL_WaitThread(status, NULL);
destroy_flock(flock);
SDL_Quit();
return 0;
}
int main (int argc, char** argv)
{
/*---------------------- Initialize OpenGL and OpenCL ----------------------*/
if (init_gl(argc,argv,&glinfo, window_size, "RT") != 0){
std::cerr << "Failed to initialize GL" << std::endl;
exit(1);
} else {
std::cout << "Initialized GL succesfully" << std::endl;
}
if (init_cl(glinfo,&clinfo) != CL_SUCCESS){
std::cerr << "Failed to initialize CL" << std::endl;
exit(1);
} else {
std::cout << "Initialized CL succesfully" << std::endl;
}
print_cl_info(clinfo);
/* Initialize device interface */
if (device.initialize(clinfo)) {
std::cerr << "Failed to initialize device interface" << std::endl;
exit(1);
}
/* Initialize generic gpu library */
DeviceFunctionLibrary::initialize(clinfo);
/*---------------------- Create shared GL-CL texture ----------------------*/
gl_tex = create_tex_gl(window_size[0],window_size[1]);
tex_id = device.new_memory();
DeviceMemory& tex_mem = device.memory(tex_id);
if (tex_mem.initialize_from_gl_texture(gl_tex)) {
std::cerr << "Failed to create memory object from gl texture" << std::endl;
exit(1);
}
/*---------------------- Set up scene ---------------------------*/
frames = 15;
const std::string pack = "pack1OBJ";
// const std::string pack = "pack2OBJ";
double wave_attenuation = 1.f;
scenes.resize(frames);
for (uint32_t i = 0; i < frames ; ++i) {
scenes[i].initialize();
std::stringstream grid_path,visual_path;
grid_path << "models/obj/" << pack << "/gridFluid" << i+1 << ".obj";
mesh_id grid_mid = scenes[i].load_obj_file_as_aggregate(grid_path.str());
object_id grid_oid = scenes[i].add_object(grid_mid);
Object& grid = scenes[i].object(grid_oid);
grid.mat.diffuse = White;
grid.mat.reflectiveness = 0.95f;
grid.mat.refractive_index = 1.5f;
grid.geom.setScale(makeVector(1.f,wave_attenuation,1.f));
/* ---- Solids ------ */
// visual_path << "models/obj/" << pack << "/visual" << visual_frame << ".obj";
// mesh_id visual_mid = scenes[i].load_obj_file_as_aggregate(visual_path.str());
// object_id visual_oid = scenes[i].geometry.add_object(visual_mid);
// Object& visual = scenes[i].geometry.object(visual_oid);
// visual.mat.diffuse = Red;
// for (uint32_t j = 0; j < bridge_parts ; ++j) {
// std::stringstream bridge_path;
// bridge_path << "models/obj/" << pack << "/bridge" << j << i+1 << ".obj";
// mesh_id bridge_mid = scenes[i].load_obj_file_as_aggregate(bridge_path.str());
// object_id bridge_oid = scenes[i].geometry.add_object(bridge_mid);
// Object& bridge = scenes[i].geometry.object(bridge_oid);
// bridge.mat.diffuse = Green;
// }
// mesh_id teapot_mesh_id = scenes[i].load_obj_file_as_aggregate("models/obj/teapot2.obj");
// mesh_id teapot_mesh_id = scenes[i].load_obj_file_as_aggregate("models/obj/teapot-low_res.obj");
// object_id teapot_obj_id = scenes[i].geometry.add_object(teapot_mesh_id);
// Object& teapot_obj = scenes[i].geometry.object(teapot_obj_id);
// teapot_obj.geom.setPos(makeVector(-1.f,0.f,0.f));
// teapot_obj.geom.setScale(makeVector(3.f,3.f,3.f));
// teapot_obj.mat.diffuse = Green;
// teapot_obj.mat.shininess = 1.f;
// teapot_obj.mat.reflectiveness = 0.3f;
/* ------------------*/
// scenes[i].set_accelerator_type(KDTREE_ACCELERATOR);
scenes[i].set_accelerator_type(BVH_ACCELERATOR);
scenes[i].create_aggregate_mesh();
scenes[i].create_aggregate_accelerator();
Mesh& scene_mesh = scenes[i].get_aggregate_mesh();
if (scenes[i].transfer_aggregate_mesh_to_device()
|| scenes[i].transfer_aggregate_accelerator_to_device())
std::cerr << "Failed to transfer scene info to device"<< std::endl;
/*---------------------- Print scene data ----------------------*/
std::cerr << "Scene " << i << " stats: " << std::endl;
std::cerr << "\tTriangle count: " << scene_mesh.triangleCount() << std::endl;
std::cerr << "\tVertex count: " << scene_mesh.vertexCount() << std::endl;
std::cerr << std::endl;
}
/*---------------------- Set initial Camera paramaters -----------------------*/
camera.set(makeVector(0,3,-30), makeVector(0,0,1), makeVector(0,1,0), M_PI/4.,
window_size[0] / (float)window_size[1]);
/*---------------------------- Set tile size ------------------------------*/
best_tile_size = clinfo.max_compute_units * clinfo.max_work_item_sizes[0];
best_tile_size *= 64;
best_tile_size = std::min(pixel_count, best_tile_size);
/*---------------------- Initialize ray bundles -----------------------------*/
int32_t ray_bundle_size = best_tile_size * 4;
if (ray_bundle_1.initialize(ray_bundle_size)) {
std::cerr << "Error initializing ray bundle 1" << std::endl;
std::cerr.flush();
exit(1);
}
if (ray_bundle_2.initialize(ray_bundle_size)) {
std::cerr << "Error initializing ray bundle 2" << std::endl;
std::cerr.flush();
exit(1);
}
std::cout << "Initialized ray bundles succesfully" << std::endl;
/*---------------------- Initialize hit bundle -----------------------------*/
int32_t hit_bundle_size = ray_bundle_size;
if (hit_bundle.initialize(hit_bundle_size)) {
std::cerr << "Error initializing hit bundle" << std::endl;
std::cerr.flush();
exit(1);
}
std::cout << "Initialized hit bundle succesfully" << std::endl;
/*----------------------- Initialize cubemap ---------------------------*/
if (cubemap.initialize("textures/cubemap/Path/posx.jpg",
"textures/cubemap/Path/negx.jpg",
"textures/cubemap/Path/posy.jpg",
"textures/cubemap/Path/negy.jpg",
"textures/cubemap/Path/posz.jpg",
"textures/cubemap/Path/negz.jpg")) {
std::cerr << "Failed to initialize cubemap." << std::endl;
exit(1);
}
std::cerr << "Initialized cubemap succesfully." << std::endl;
/*------------------------ Initialize FrameBuffer ---------------------------*/
if (framebuffer.initialize(window_size)) {
std::cerr << "Error initializing framebuffer." << std::endl;
exit(1);
}
std::cout << "Initialized framebuffer succesfully." << std::endl;
/* ------------------ Initialize ray tracer kernel ----------------------*/
if (tracer.initialize()){
std::cerr << "Failed to initialize tracer." << std::endl;
return 0;
}
std::cerr << "Initialized tracer succesfully." << std::endl;
/* ------------------ Initialize Primary Ray Generator ----------------------*/
if (prim_ray_gen.initialize()) {
std::cerr << "Error initializing primary ray generator." << std::endl;
exit(1);
}
std::cout << "Initialized primary ray generator succesfully." << std::endl;
/* ------------------ Initialize Secondary Ray Generator ----------------------*/
if (sec_ray_gen.initialize()) {
std::cerr << "Error initializing secondary ray generator." << std::endl;
exit(1);
}
sec_ray_gen.set_max_rays(ray_bundle_1.count());
std::cout << "Initialized secondary ray generator succesfully." << std::endl;
/*------------------------ Initialize RayShader ---------------------------*/
if (ray_shader.initialize()) {
std::cerr << "Error initializing ray shader." << std::endl;
exit(1);
}
std::cout << "Initialized ray shader succesfully." << std::endl;
/*----------------------- Enable timing in all clases -------------------*/
framebuffer.timing(true);
prim_ray_gen.timing(true);
sec_ray_gen.timing(true);
tracer.timing(true);
ray_shader.timing(true);
/*------------------------- Count mem usage -----------------------------------*/
int32_t total_cl_mem = 0;
total_cl_mem += pixel_count * 4; /* 4bpp texture */
// for (uint32_t i = 0; i < frames; ++i)
// total_cl_mem += scene_info[i].size();
total_cl_mem += ray_bundle_1.mem().size() + ray_bundle_2.mem().size();
total_cl_mem += hit_bundle.mem().size();
total_cl_mem += cubemap.positive_x_mem().size() * 6;
total_cl_mem += framebuffer.image_mem().size();
std::cout << "\nMemory stats: " << std::endl;
std::cout << "\tTotal opencl mem usage: "
<< total_cl_mem/1e6 << " MB." << std::endl;
// for (uint32_t i = 0; i < frames; ++i)
// std::cout << "\tScene " << i << " mem usage: " << scene_info[i].size()/1e6 << " MB." << std::endl;
std::cout << "\tFramebuffer+Tex mem usage: "
<< (framebuffer.image_mem().size() + pixel_count * 4)/1e6
<< " MB."<< std::endl;
std::cout << "\tCubemap mem usage: "
<< (cubemap.positive_x_mem().size()*6)/1e6
<< " MB."<< std::endl;
std::cout << "\tRay mem usage: "
<< (ray_bundle_1.mem().size()*2)/1e6
<< " MB."<< std::endl;
std::cout << "\tRay hit info mem usage: "
<< hit_bundle.mem().size()/1e6
<< " MB."<< std::endl;
/* !! ---------------------- Test area ---------------- */
std::cerr << std::endl;
std::cerr << "Misc info: " << std::endl;
std::cerr << "Tile size: " << best_tile_size << std::endl;
std::cerr << "Tiles: " << pixel_count / (float)best_tile_size << std::endl;
std::cerr << "color_cl size: "
<< sizeof(color_cl)
<< std::endl;
std::cerr << "directional_light_cl size: "
<< sizeof(directional_light_cl)
<< std::endl;
std::cerr << "ray_cl size: "
<< sizeof(ray_cl)
<< std::endl;
std::cerr << "sample_cl size: "
<< sizeof(sample_cl)
<< std::endl;
std::cerr << "sample_trace_info_cl size: "
<< sizeof(sample_trace_info_cl)
<< std::endl;
/*------------------------ Set GLUT and misc functions -----------------------*/
rt_time.snap_time();
seq_time.snap_time();
glutKeyboardFunc(gl_key);
glutMotionFunc(gl_mouse);
glutDisplayFunc(gl_loop);
glutIdleFunc(gl_loop);
glutMainLoop();
clinfo.release_resources();
return 0;
}
//----------------------------------------------------------------------
int main(int argc, char** argv)
{
int i, j, k;
double r_ij;
FILE *XYZ_file, *p_file;
std::ifstream IN_file;
std::string buffer;
std::string IN_filename = "in";
std::string OUT_filename ="out";
std::string XYZ_filename = "xyz";
parameters param;
state stat;
Vector sumaP;
/* Load data */
IN_file.open(IN_filename);
IN_file >> param.n;
std::getline(IN_file, buffer);
IN_file >> param.m;
std::getline(IN_file, buffer);
IN_file >> param.e;
std::getline(IN_file, buffer);
IN_file >> param.R;
std::getline(IN_file, buffer);
IN_file >> param.f;
std::getline(IN_file, buffer);
IN_file >> param.L;
std::getline(IN_file, buffer);
IN_file >> param.a;
std::getline(IN_file, buffer);
IN_file >> stat.T;
std::getline(IN_file, buffer);
IN_file >> param.tau;
std::getline(IN_file, buffer);
IN_file >> param.So;
std::getline(IN_file, buffer);
IN_file >> param.Sd;
std::getline(IN_file, buffer);
IN_file >> param.Sout;
std::getline(IN_file, buffer);
IN_file >> param.Sxyz;
std::getline(IN_file, buffer);
IN_file.close();
param.L = param.L * param.a*(param.n - 1);
/* Okreslanie stanu poczatkowego ukladu */
srand(time_t(NULL));
param.N = (int) pow(param.n, 3);
stat.r = new Vector[param.N];
stat.p = new Vector[param.N];
stat.F_p = new Vector[param.N];
stat.F_s = new Vector[param.N];
printf("init \n");
for (i = 0; i < param.n; i++){
for (j = 0; j < param.n; j++){
for (k = 0; k < param.n; k++){
stat.r[i + j*param.n + k*param.n*param.n].x = (i - (param.n - 1) / 2.f)*param.a + (j - (param.n - 1) / 2) * param.a / 2.f + (k - (param.n - 1) / 2)*param.a / 2.f;
stat.r[i + j*param.n + k*param.n*param.n].y = (j - (param.n - 1) / 2)*param.a*sqrt(3.f) / 2 + (k - (param.n - 1) / 2)*param.a*sqrt(3.f) / 6;
stat.r[i + j*param.n + k*param.n*param.n].z = (k - (param.n - 1) / 2)*param.a * sqrt(2.f / 3.f);
}
}
}
/* XYZ_file = fopen( XYZ_filename.c_str(), "w");
fprintf(XYZ_file, "%d\n", param.N);
fprintf(XYZ_file, "STEP:\t%d\n", param.N);
for (i = 0; i < param.N; i++){
fprintf(XYZ_file, "Ar\t%f\t%f\t%f\n", stat.r[i].x, stat.r[i].y, stat.r[i].z);
}
fprintf(XYZ_file, "\n", param.N);
*/
printf("p \n");
for (i = 0; i < param.N; i++){
stat.r[i].r = sqrt(pow(stat.r[i].x, 2) + pow(stat.r[i].y, 2) + pow(stat.r[i].z, 2));
stat.p[i].x = znak()*sqrt(2*param.m*(-K_B*stat.T*log(r0_1()) / 2));
stat.p[i].y = znak()*sqrt(2*param.m*(-K_B*stat.T*log(r0_1()) / 2));
stat.p[i].z = znak()*sqrt(2*param.m*(-K_B*stat.T*log(r0_1()) / 2));
stat.p[i].r = sqrt(pow(stat.p[i].x, 2) + pow(stat.p[i].y, 2) + pow(stat.p[i].z, 2));
}
sumaP.x = 0;
sumaP.y = 0;
sumaP.z = 0;
printf("sum p \n");
for (i = 0; i < param.N; i++){
sumaP.x += stat.p[i].x;
sumaP.y += stat.p[i].y;
sumaP.z += stat.p[i].z;
stat.F_s[i].x = 0;
stat.F_s[i].y = 0;
stat.F_s[i].z = 0;
stat.F_p[i].x = 0;
stat.F_p[i].y = 0;
stat.F_p[i].z = 0;
}
p_file = fopen( "p", "w");
/*
for (i = 0; i < param.N; i++){
stat.p[i].x -= sumaP.x / (double) param.N;
stat.p[i].y -= sumaP.y / (double) param.N;
stat.p[i].z -= sumaP.z / (double) param.N;
fprintf(p_file, "%f\t%f\t%f\n", stat.p[i].x, stat.p[i].y, stat.p[i].z);
}
*/
fclose(p_file);
/* Initial state */
stat.V_p = 0;
stat.V_s = 0;
printf("main \n");
for (i = 0; i < param.N; i++){
/*
if (stat.r[i].r >= param.L){
stat.V_s += param.f*pow(stat.r[i].r - param.L, 2) / 2;
stat.F_s[i].x += param.f*(param.L - stat.r[i].r)* stat.r[i].x / stat.r[i].r;
stat.F_s[i].y += param.f*(param.L - stat.r[i].r)* stat.r[i].y / stat.r[i].r;
stat.F_s[i].z += param.f*(param.L - stat.r[i].r)* stat.r[i].z / stat.r[i].r;
}
*/
for (j = i; j < param.N; j++){
if (i != j){
r_ij = sqrt(pow(stat.r[i].x - stat.r[j].x, 2) + pow(stat.r[i].y - stat.r[j].y, 2) + pow(stat.r[i].z - stat.r[j].z, 2));
stat.V_p += param.e*(pow(param.R / r_ij, 12) - 2 * pow(param.R / r_ij, 6));
stat.F_p[i].x += 12 * param.e*(pow(param.R / r_ij, 12) - pow(param.R / r_ij, 6))*(stat.r[i].x - stat.r[j].x) / pow(r_ij, 2);
stat.F_p[j].x -= stat.F_p[i].x;
stat.F_p[i].y += 12 * param.e*(pow(param.R / r_ij, 12) - pow(param.R / r_ij, 6))*(stat.r[i].y - stat.r[j].y) / pow(r_ij, 2);
stat.F_p[j].y -= stat.F_p[i].y;
stat.F_p[i].z += 12 * param.e*(pow(param.R / r_ij, 12) - pow(param.R / r_ij, 6))*(stat.r[i].z - stat.r[j].z) / pow(r_ij, 2);
stat.F_p[j].z -= stat.F_p[i].z;
}
}
printf("%d/%d\r",i,param.N);
}
printf("\n");
//--------------------------------------------------------------------
printf("Hello, OpenCL\n");
//Setup our GLUT window and OpenGL related things
//glut callback functions are setup here too
init_gl(argc, argv);
//initialize our CL object, this sets up the context
example = new CL();
//load and build our CL program from the file
#include "part2.cl" //std::string kernel_source is defined in this file
example->loadProgram(kernel_source);
//initialize our particle system with positions, velocities and color
int num = NUM_PARTICLES;
std::vector<Vec4> pos(num);
std::vector<Vec4> color(num);
std::vector<Vec4> F_p(num);
std::vector<Vec4> F_s(num);
std::vector<Vec4> Mom(num);
//fill our vectors with initial data
for(int i = 0; i < num; i++)
{
pos[i].x = stat.r[i].x;
pos[i].y = stat.r[i].y;
pos[i].z = stat.r[i].z;
pos[i].w = 1.0f;
F_p[i].x = stat.F_p[i].x;
F_p[i].y = stat.F_p[i].y;
F_p[i].z = stat.F_p[i].z;
F_p[i].w = 1.0f;
F_s[i].x = stat.F_s[i].x;
F_s[i].y = stat.F_s[i].y;
F_s[i].z = stat.F_s[i].z;
F_s[i].w = 1.0f;
Mom[i].x = stat.p[i].x;
Mom[i].y = stat.p[i].y;
Mom[i].z = stat.p[i].z;
Mom[i].w = 1.0f;
color[i] = Vec4(1.0f, 0.0f,0.0f, 1.0f);
}
//our load data function sends our initial values to the GPU
example->loadData(pos, color, F_p, F_s, Mom);
//initialize the kernel
example->popCorn();
//this starts the GLUT program, from here on out everything we want
//to do needs to be done in glut callback functions
glutMainLoop();
}
void init_stuff()
{
int i;
int seed;
chdir(DATA_DIR);
#ifndef WINDOWS
setlocale(LC_NUMERIC,"en_US");
#endif
init_translatables();
//create_error_mutex();
init_globals();
init_crc_tables();
init_zip_archives();
cache_system_init(MAX_CACHE_SYSTEM);
init_texture_cache();
init_vars();
read_config();
file_check_datadir();
#ifdef LOAD_XML
//Well, the current version of the map editor doesn't support having a datadir - will add that later ;-)
load_translatables();
#endif
#ifdef LINUX
#ifdef GTK2
init_filters();
#else
file_selector = create_fileselection();
#endif
#endif //LINUX
init_gl();
window_resize();
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
// glDepthFunc(GL_LEQUAL);
glEnable(GL_TEXTURE_2D);
glShadeModel(GL_SMOOTH);
glFrontFace(GL_CCW);
glCullFace(GL_BACK);
glEnable(GL_NORMALIZE);
glClearColor( 0.0, 0.0, 0.0, 0.0 );
glClearStencil(0);
seed = time (NULL);
srand (seed);
init_texture_cache();
init_particles ();
init_e3d_cache();
init_2d_obj_cache();
for(i=0; i<256; i++)
tile_list[i]=0;
for (i = 0; i < MAX_LIGHTS; i++)
lights_list[i] = NULL;
new_map(256,256);
load_all_tiles();
//lights setup
build_global_light_table();
build_sun_pos_table();
reset_material();
init_lights();
//disable_local_lights();
//clear_error_log();
// Setup the new eye candy system
#ifdef EYE_CANDY
ec_init();
#endif //EYE_CANDY
init_gl_extensions();
if(have_multitexture)
#ifdef NEW_TEXTURES
ground_detail_text = load_texture_cached("./textures/ground_detail.bmp", tt_mesh);
#else /* NEW_TEXTURES */
ground_detail_text = load_texture_cache ("./textures/ground_detail.bmp",255);
#endif /* NEW_TEXTURES */
//load the fonts texture
init_fonts();
#ifdef NEW_TEXTURES
icons_text=load_texture_cached("./textures/gamebuttons.bmp", tt_gui);
buttons_text=load_texture_cached("./textures/buttons.bmp", tt_gui);
#else /* NEW_TEXTURES */
icons_text=load_texture_cache("./textures/gamebuttons.bmp",0);
buttons_text=load_texture_cache("./textures/buttons.bmp",0);
#endif /* NEW_TEXTURES */
//get the application home dir
have_multitexture=0;//debug only
#ifndef LINUX
GetCurrentDirectory(sizeof(exec_path),exec_path);
#else
exec_path[0]='.';exec_path[1]='/';exec_path[2]=0;
#endif
init_browser();
if(SDL_InitSubSystem(SDL_INIT_TIMER)<0)
{
char str[120];
snprintf(str, sizeof(str), "Couldn't initialize the timer: %s\n", SDL_GetError());
log_error(__FILE__, __LINE__, str);
SDL_Quit();
exit(1);
}
SDL_SetTimer (1000/(18*4), my_timer);
SDL_EnableUNICODE(1);
//we might want to do this later.
// creating windows
display_browser();
toggle_window(browser_win);
display_o3dow();
toggle_window(o3dow_win);
display_replace_window();
toggle_window(replace_window_win);
display_edit_window();
toggle_window(edit_window_win);
create_particles_window ();
}
/**
* main
*
* TODO: Write function block once this is cleaned up.
*/
int main(int argc, char** argv)
{
/*
* Local Variables.
*/
SDL_Event transient_event;
SCREEN *screen;
MATCH_STATE *match_state;
Uint32 frame_start_time;
Uint32 frame_time_taken_ms;
Uint32 physics_time_delta;
Uint32 last_physics_update;
Uint32 ai_time_delta;
Uint32 last_ai_update;
Uint32 ms_per_frame;
int rc;
StrMap *config_table;
Uint32 last_animation_update = 0;
Uint32 animation_ms_per_frame;
int max_fps;
FONT *font;
char disc_graphic_file[MAX_CONFIG_VALUE_LEN + 1];
char grass_tile_file[MAX_CONFIG_VALUE_LEN + 1];
char o_xml_file[MAX_CONFIG_VALUE_LEN + 1];
char d_xml_file[MAX_CONFIG_VALUE_LEN + 1];
int ii;
SDL_Color white = {0xFF, 0xFF, 0xFF, 0x00};
/*
* Begin logging.
*/
DT_INIT_LOG;
/*
* TODO: Move loading and retrieving constants using defaults from the config
* file to a different folder, code file. Simple api.
*/
load_config_to_str_map("config.txt", &config_table);
if (!get_config_value_int(config_table,
cv_animation_ms_per_frame,
(int *)&animation_ms_per_frame))
{
game_exit("Programmer error: animation ms per frame not handled in cfg.");
}
if (!get_config_value_int(config_table, cv_max_fps, &max_fps))
{
game_exit("Programmer error: max fps not handled in cfg.");
}
ms_per_frame = (int) MILLISECONDS_PER_SECOND / max_fps;
if (!get_config_value_str(config_table, cv_disc_graphic, (char *)disc_graphic_file))
{
game_exit("Programmer error: disc graphic not handled in cfg.");
}
if (!get_config_value_str(config_table, cv_grass_tile_filename, (char *)grass_tile_file))
{
game_exit("Programmer error: grass tile graphic not handled in cfg.");
}
if (!get_config_value_str(config_table, cv_o_xml_file, (char *)o_xml_file))
{
game_exit("Programmer error: O XML file not handled in cfg.");
}
if (!get_config_value_str(config_table, cv_d_xml_file, (char *)d_xml_file))
{
game_exit("Programmer error: D XML file not handled in cfg.");
}
DT_DEBUG_LOG("Config file loaded\n");
/*
* Create the screen object and use it to initialise the window system.
*/
screen = create_screen();
rc = init_window_system(screen, SCREEN_WIDTH, SCREEN_HEIGHT, BPP);
if (INIT_OK != rc)
{
game_exit("Window system could not be initialised.");
}
DT_DEBUG_LOG("Graphics subsystem created and initialized\n");
/*
* Initialise Audio subsystem
*/
rc = init_audio_subsystem(config_table);
if (INIT_AUDIO_SYSTEM_OK != rc)
{
/*
* Don't exit just because we can't output audio. The audio code will
* handle this case.
*/
DT_DEBUG_LOG("Audio subsystem could not be initialised\n");
}
else
{
DT_DEBUG_LOG("Audio subsystem created and initialized\n");
}
/*
* Initialise the opengl components of the screen.
*/
rc = init_gl(screen);
if (GL_INIT_OK != rc)
{
game_exit("Could not do opengl initialisation.");
}
DT_DEBUG_LOG("OpenGL setup complete\n");
/*
* TODO: Proper font management system where more than one font can be loaded
*
* Create the font object that is going to be used to write text throughout
* the game.
*/
rc = create_font("..\\..\\resources\\Fonts\\LucidaSansRegular.ttf",
&font,
30,
TTF_STYLE_NORMAL,
white);
if (BUILD_FONT_OK != rc)
{
game_exit("Could not load up LucidaSansRegular font.");
}
DT_DEBUG_LOG("Lucida sans regular font loaded\n");
/*
* TODO: Constants to move from here.
*
* Create a new match state object before starting the game loop.
*/
match_state = create_match_state(15,
60 * 60,
disc_graphic_file,
grass_tile_file,
o_xml_file,
d_xml_file,
create_o_automaton_states,
create_automaton_events);
if (NULL == match_state)
{
game_exit("Failed to create match state.");
}
init_pitch(match_state->pitch);
DT_DEBUG_LOG("Match state created and initialized\n");
/*
* Scale the pitch by an arbitrary amount to account for the otherwise small
* scaling.
*/
scale_camera(match_state->camera_handler, 10.0f);
/*
* Load the animation data.
*/
rc = load_animation_data(match_state->animation_handler);
if (LOAD_ANIMATION_DATA_OK != rc)
{
game_exit("Failed to load animation data.");
}
DT_DEBUG_LOG("Animation data loaded\n");
/*
* Initialise the timings
*/
last_physics_update = SDL_GetTicks();
last_ai_update = SDL_GetTicks();
/*
* Initialise and start a new match.
*/
start_match(match_state);
// @@@DAT testing
throw_multi_player_ai_event_by_name(match_state->teams,
match_state->players_per_team,
match_state->teams[0]->players[0]->automaton,
AUTOMATON_EVENT_PULL_THROWN);
/*
* Game loop
*/
while(true)
{
/*
* Frame time is tracked so that we can determine how long to wait before
* displaying the next frame. i.e. to fix the FPS.
*/
frame_start_time = SDL_GetTicks();
/*
* Look at disc
*/
look_at_location(match_state->camera_handler,
match_state->disc->position.x,
match_state->disc->position.y,
screen);
/*
* While there are events to process, do so.
*/
while(SDL_PollEvent(&transient_event))
{
/*
* First check whether it is an SDL_QUIT event. If so then exit with
* message.
*/
if (transient_event.type == SDL_QUIT)
{
destroy_match_state(match_state);
game_exit("User requested exit via SDL_QUIT event.");
}
else if ((transient_event.type == SDL_KEYDOWN) ||
(transient_event.type == SDL_KEYUP))
{
/*
* The event was the user either depressing or releasing a key so call
* to the keyboard event handler to deal with the event.
*/
handle_keyboard_event(&(transient_event.key),
transient_event.type,
match_state,
screen);
}
else if ((transient_event.type == SDL_MOUSEBUTTONDOWN) ||
(transient_event.type == SDL_MOUSEBUTTONUP))
{
/*
* The event was the user either depressing or releasing a mouse button
* so pass to the mouse button event handler to deal with it. This
* includes the mouse wheel moving.
*/
handle_mousebutton_event(&(transient_event.button), match_state);
}
}
/*
* Perform an update on all the ai objects.
*/
ai_time_delta = SDL_GetTicks() - last_ai_update;
process_all_player_ai(match_state->teams,
match_state->players_per_team,
ai_time_delta);
last_ai_update = SDL_GetTicks();
/*
* Process the automaton timed event queue to see if any events need to be
* popped.
*/
pop_all_timed_events(match_state->automaton_handler->timed_event_queue,
SDL_GetTicks(),
match_state);
/*
* Do physics processing. This updates the positions of all moving entities
* in the game.
*
* WARNING - If this takes longer than the amount of time allocated per
* frame then there might be 'interesting' problems in the frame refresh.
*/
physics_time_delta = SDL_GetTicks() - last_physics_update;
calculate_positions(match_state,
physics_time_delta);
last_physics_update = SDL_GetTicks();
/*
* Having moved all of the objects to their new positions we need to
* detect collisions and verify the new locations.
*
* At the end of this function the positions of all objects will have been
* updated.
*/
detect_and_handle_collisions(match_state->teams,
match_state->players_per_team,
match_state->disc);
/*
* Update the camera object.
*/
update_camera_position(match_state);
/*
* TODO: Is this management of animations sufficient?
*
* Update the animation frame counters.
*/
if (SDL_GetTicks() - last_animation_update >= animation_ms_per_frame)
{
last_animation_update = SDL_GetTicks();
for (ii = 0; ii < match_state->players_per_team; ii++)
{
increment_animation_frame_counter(match_state->teams[0]->players[ii],
match_state->animation_handler);
increment_animation_frame_counter(match_state->teams[1]->players[ii],
match_state->animation_handler);
}
}
/*
* If the frame has taken less than the maximum allowed amount of time to
* render then delay the screen update.
*/
frame_time_taken_ms = SDL_GetTicks() - frame_start_time;
if (frame_time_taken_ms < ms_per_frame)
{
SDL_Delay(ms_per_frame - frame_time_taken_ms);
}
/*
* Redraw the screen.
*/
redraw_screen(screen, match_state, font);
}
return(0);
}
int
main(int argc, char **argv)
{
struct sigaction sigint;
struct display display = { 0 };
struct window window = { 0 };
int i, ret = 0;
window.display = &display;
display.window = &window;
window.window_size.width = 250;
window.window_size.height = 250;
window.buffer_size = 32;
window.frame_sync = 1;
for (i = 1; i < argc; i++) {
if (strcmp("-f", argv[i]) == 0)
window.fullscreen = 1;
else if (strcmp("-o", argv[i]) == 0)
window.opaque = 1;
else if (strcmp("-s", argv[i]) == 0)
window.buffer_size = 16;
else if (strcmp("-b", argv[i]) == 0)
window.frame_sync = 0;
else if (strcmp("-h", argv[i]) == 0)
usage(EXIT_SUCCESS);
else
usage(EXIT_FAILURE);
}
display.display = wl_display_connect(NULL);
assert(display.display);
display.registry = wl_display_get_registry(display.display);
wl_registry_add_listener(display.registry,
®istry_listener, &display);
wl_display_dispatch(display.display);
init_egl(&display, &window);
create_surface(&window);
init_gl(&window);
display.cursor_surface =
wl_compositor_create_surface(display.compositor);
sigint.sa_handler = signal_int;
sigemptyset(&sigint.sa_mask);
sigint.sa_flags = SA_RESETHAND;
sigaction(SIGINT, &sigint, NULL);
/* The mainloop here is a little subtle. Redrawing will cause
* EGL to read events so we can just call
* wl_display_dispatch_pending() to handle any events that got
* queued up as a side effect. */
while (running && ret != -1) {
wl_display_dispatch_pending(display.display);
redraw(&window, NULL, 0);
}
fprintf(stderr, "simple-egl exiting\n");
destroy_surface(&window);
fini_egl(&display);
wl_surface_destroy(display.cursor_surface);
if (display.cursor_theme)
wl_cursor_theme_destroy(display.cursor_theme);
if (display.shell)
xdg_shell_destroy(display.shell);
if (display.compositor)
wl_compositor_destroy(display.compositor);
wl_registry_destroy(display.registry);
wl_display_flush(display.display);
wl_display_disconnect(display.display);
return 0;
}
/* Main plugin stuff */
const VisPluginInfo *get_plugin_info (void)
{
static VisActorPlugin actor = {
.requisition = lv_nebulus_requisition,
.palette = lv_nebulus_palette,
.render = lv_nebulus_render,
.vidoptions.depth = VISUAL_VIDEO_DEPTH_GL
};
static VisPluginInfo info = {
.type = VISUAL_PLUGIN_TYPE_ACTOR,
.plugname = "nebulus",
.name = "Nebulus",
.author = N_("Original by: Pascal Brochart <*****@*****.**> and many others, Port and maintaince by: Dennis Smit <*****@*****.**>"),
.version = "1.0",
.about = N_("Libvisual nebulus plugin"),
.help = N_("This plugin shows multiple visual effect using openGL"),
.license = VISUAL_PLUGIN_LICENSE_GPL,
.init = lv_nebulus_init,
.cleanup = lv_nebulus_cleanup,
.events = lv_nebulus_events,
.plugin = VISUAL_OBJECT (&actor)
};
VISUAL_VIDEO_ATTR_OPTIONS_GL_ENTRY(actor.vidoptions, VISUAL_GL_ATTRIBUTE_RED_SIZE, 5);
VISUAL_VIDEO_ATTR_OPTIONS_GL_ENTRY(actor.vidoptions, VISUAL_GL_ATTRIBUTE_GREEN_SIZE, 5);
VISUAL_VIDEO_ATTR_OPTIONS_GL_ENTRY(actor.vidoptions, VISUAL_GL_ATTRIBUTE_BLUE_SIZE, 5);
VISUAL_VIDEO_ATTR_OPTIONS_GL_ENTRY(actor.vidoptions, VISUAL_GL_ATTRIBUTE_DEPTH_SIZE, 16);
VISUAL_VIDEO_ATTR_OPTIONS_GL_ENTRY(actor.vidoptions, VISUAL_GL_ATTRIBUTE_DOUBLEBUFFER, 1);
VISUAL_VIDEO_ATTR_OPTIONS_GL_ENTRY(actor.vidoptions, VISUAL_GL_ATTRIBUTE_RGBA, 1);
return &info;
}
static int lv_nebulus_init (VisPluginData *plugin)
{
NebulusPrivate *priv;
#if ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
#endif
visual_return_val_if_fail (plugin != NULL, -1);
priv = visual_mem_new0 (NebulusPrivate, 1);
visual_object_set_private (VISUAL_OBJECT (plugin), priv);
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxtexsize);
if (maxtexsize < 256) {
visual_log (VISUAL_LOG_CRITICAL, _("Nebulus: max texture size is lower than 256"));
return -1;
}
if (tunnel_first)
precalculate_tunnel();
priv->pcmbuf = visual_buffer_new_allocate (1024 * sizeof (float));
visual_video_init (&child_image);
visual_video_init (&energy_image);
visual_video_init (&tentacle_image);
visual_video_init (&tunnel_image);
visual_video_init (&twist_image);
visual_video_init (&background_image);
init_gl();
return 0;
}
struct rtb_window *
rtb_window_open_under(struct rutabaga *r, intptr_t parent,
int w, int h, const char *title)
{
struct rtb_style_data stdata;
struct rtb_window *self;
assert(r);
assert(h > 0);
assert(w > 0);
assert(!r->win);
self = window_impl_open(r, w, h, title, parent);
if (!self)
goto err_window_impl;
init_gl();
if (RTB_SUBCLASS(RTB_SURFACE(self), rtb_surface_init, &super))
goto err_surface_init;
self->w = w;
self->h = h;
self->surface = RTB_SURFACE(self);
stdata = rtb_style_get_defaults();
self->style_list = stdata.style;
self->style_fonts = calloc(stdata.nfonts, sizeof(*self->style_fonts));
if (shaders_init(self))
goto err_shaders;
if (ibos_init(self))
goto err_ibos;
if (rtb_font_manager_init(&self->font_manager,
self->dpi.x, self->dpi.y))
goto err_font;
rtb_elem_set_layout(RTB_ELEMENT(self), rtb_layout_vpack_top);
self->on_event = win_event;
self->mark_dirty = mark_dirty;
self->attached = attached;
self->flags = RTB_ELEM_CLICK_FOCUS;
/* for core profiles */
glGenVertexArrays(1, &self->vao);
glBindVertexArray(self->vao);
self->rtb = r;
r->win = self;
self->mouse.current_cursor = RTB_MOUSE_CURSOR_DEFAULT;
return self;
err_font:
ibos_fini(self);
err_ibos:
shaders_fini(self);
err_shaders:
err_surface_init:
window_impl_close(self);
err_window_impl:
return NULL;
}
void * glclient_thread(void * arg)
{
server_thread_args_t * a = (server_thread_args_t *)arg;
static graphics_context_t gc;
static struct js_event joy;
int joy_fd;
static char button[32];
glclient_context_t *glcc = a->user_context_ptr;
joy_fd = open(glcc->joy_dev, O_RDONLY);
if (joy_fd == -1)
{
printf("Error: Joystick device open\n");
}
if (joy_fd != -1)
{
fcntl(joy_fd, F_SETFL, O_NONBLOCK);
}
gls_init(a);
gls_cmd_get_context();
gc.screen_width = glsc_global.screen_width;
gc.screen_height = glsc_global.screen_height;
printf("width:%d height:%d\n",glsc_global.screen_width,glsc_global.screen_height);
init_gl(&gc);
float aspect = (float)gc.screen_width / (float)gc.screen_height;
mat_perspective(proj_mat, aspect, 0.1f, 1024.0f, 60.0f);
glUniform4fv(gc.uloc_light, 1, light_pos);
srand(0x12345678);
int j;
for (j = 0; j < 1024; j++)
{
obj[j].z = randf() * 8.0f - 10.0f;
obj[j].x = (randf() * 2.0f - 1.0f) * obj[j].z;
obj[j].y = (randf() * 1.0f - 0.5f) * obj[j].z;
obj[j].dx = randf() * 0.0f - 0.0f;
obj[j].dy = randf() * 0.0f - 0.0f;
obj[j].dz = randf() * 0.0f - 0.0f;
obj[j].rx = randf() * 6.28;
obj[j].ry = randf() * 6.28;
obj[j].rz = randf() * 6.28;
obj[j].drx = randf() * 0.1f - 0.05f;
obj[j].dry = randf() * 0.1f - 0.05f;
obj[j].drz = randf() * 0.1f - 0.05f;
}
float x = 1.57f;
float y = 0.0f;
float z = -2.0f;
int k = 1;
int i;
for (i = 0; i < 432000; i++)
{
struct timeval times, timee;
gettimeofday(×, NULL);
if (joy_fd != -1)
{
while (read(joy_fd, &joy, sizeof(struct js_event)) == sizeof(struct js_event))
{
if ((joy.type & JS_EVENT_BUTTON) == JS_EVENT_BUTTON)
{
button[joy.number] = joy.value;
}
}
if (button[4] > 0)
{
y += 0.01f;
}
if (button[6] > 0)
{
y += -0.01f;
}
if (button[5] > 0)
{
x += 0.01f * aspect;
}
if (button[7] > 0)
{
x += -0.01f * aspect;
}
if (button[12] > 0)
{
z += -0.01f;
}
if (button[13] > 0)
{
k++;
k = (k > 45) ? 45 : k;
}
if (button[14] > 0)
{
z += 0.01f;
}
if (button[15] > 0)
{
k--;
k = (k < 1) ? 1 : k;
}
}
glUseProgram(gc.program);
glBindBuffer(GL_ARRAY_BUFFER, gc.vbo_pos);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, gc.vbo_ind);
glEnableVertexAttribArray(gc.vloc_pos);
glEnableVertexAttribArray(gc.vloc_nor);
glEnableVertexAttribArray(gc.vloc_tex);
glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
for (j = 0; j < k; j++)
{
obj[j].rx += obj[j].drx;
obj[j].ry += obj[j].dry;
obj[j].rz += obj[j].drz;
if (j == 0)
{
obj[j].x = 0.0f;
obj[j].y = 0.0f;
obj[j].z = z;
obj[j].rx = -y;
obj[j].ry = x;
obj[j].rz = 0.0f;
}
mat_identity(model_mat);
mat_translate(model_mat, obj[j].x, obj[j].y, obj[j].z);
mat_rotate_x(model_mat, obj[j].rx);
mat_rotate_y(model_mat, obj[j].ry);
mat_rotate_z(model_mat, obj[j].rz);
mat_copy(nor_mat, model_mat);
mat_invert(nor_mat);
mat_transpose(nor_mat);
glUniformMatrix4fv(gc.uloc_nor, 1, GL_FALSE, nor_mat);
mat_copy(obj[j].nor_mat, nor_mat);
mat_copy(modelproj_mat, proj_mat);
mat_mul(modelproj_mat, model_mat);
glUniformMatrix4fv(gc.uloc_model, 1, GL_FALSE, modelproj_mat);
mat_copy(obj[j].modelproj_mat, modelproj_mat);
glDrawElements(GL_TRIANGLES, sizeof(ind_model) / sizeof(GLushort), GL_UNSIGNED_SHORT, 0);
}
glDisableVertexAttribArray(gc.vloc_tex);
glDisableVertexAttribArray(gc.vloc_nor);
glDisableVertexAttribArray(gc.vloc_pos);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
gls_cmd_flip(i);
gettimeofday(&timee, NULL);
//printf("%d:%f ms ", i, get_diff_time(times, timee) * 1000.0f);
}
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
gls_cmd_flip(i);
release_gl(&gc);
gls_free();
if (joy_fd != -1)
{
close(joy_fd);
}
pthread_exit(NULL);
}
