void RecordMonitorThread::run()
{
//printf("RecordMonitorThread::run 1 %d\n", getpid());
while(!done) {
// Wait for next frame
//SET_TRACE
output_lock->lock("RecordMonitorThread::run");
if(done) {
unlock_input();
return;
}
//SET_TRACE
new_output_frame();
//SET_TRACE
render_frame();
//SET_TRACE
record_monitor->scope_thread->process(output_frame);
//SET_TRACE
show_output_frame();
//SET_TRACE
unlock_input();
// Get next frame
ready = 1;
}
}
void RawDecoder::recv(pktbuf* pb)
{
rtphdr* rh = (rtphdr*)pb->dp;
int hdrsize = sizeof(rtphdr) + hdrlen();
u_char* bp = pb->dp + hdrsize;
int cc = pb->len - hdrsize;
/* using jpeg header */
const jpeghdr* p = (const jpeghdr*)(rh + 1);
int inw = p->width << 3;
int inh = p->height << 3;
if (inw_ != inw || inh_ != inh) {
resize(inw, inh);
}
/* use jpeg reassembler to reassemble packets */
bp = reasm_.reassemble(rh, bp, cc);
/* update whole frame now */
memset(rvts_, now_, nblk_);
if (bp != 0) {
render_frame(bp);
}
pb->release();
}
//render a frame for the game
void game_render_frame_mono(int flip)
{
gr_set_current_canvas(&Screen_3d_window);
render_frame(0);
update_cockpits();
if (Newdemo_state == ND_STATE_PLAYBACK)
Game_mode = Newdemo_game_mode;
if (PlayerCfg.CockpitMode[1]==CM_FULL_COCKPIT || PlayerCfg.CockpitMode[1]==CM_STATUS_BAR)
render_gauges();
if (Newdemo_state == ND_STATE_PLAYBACK)
Game_mode = GM_NORMAL;
gr_set_current_canvas(&Screen_3d_window);
game_draw_hud_stuff();
#ifdef NETWORK
if (netplayerinfo_on && Game_mode & GM_MULTI)
show_netplayerinfo();
#endif
}
//
// FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
// PURPOSE: Processes messages for the main window.
//
// WM_COMMAND - process the application menu
// WM_PAINT - Paint the main window
// WM_DESTROY - post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
//PAINTSTRUCT ps;
//HDC hdc;
switch (message)
{
case WM_PAINT:
//hdc = BeginPaint(hWnd, &ps);
if (nullptr != d3d)
{
render_frame();
}
//EndPaint(hWnd, &ps);
break;
case WM_KEYDOWN:
if (VK_ESCAPE == wParam)
{
DestroyWindow(hWnd);
}
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
void T3DControl::render(Trendercontext *rc, const TObjectRenderStatus *status, bool isrecording)
{
if (!G_isvisible()) return;
if (!rc->G_viewport()->G_showcontrols()) return;
if (!G_3DCosmos().G_showcontrols()) return;
double x0=position->G3_x();
double y0=position->G3_y();
double sx=G_controlsizex();
double sy=G_controlsizey();
rc->enablelight(status->enablelight);
rc->SetBlendType(status->currentobjectblendtype);
rc->EnableDepthMask(status->currentobjectdepthmask!=DepthMaskDisable);
rc->EnableDepthTest(status->currentobjectdepthtest!=DepthTestDisable);
rc->set_orientation(+1);
if ((G_canselect())&&(G_isactive()))
{
rc->set_color(0.0,0.4,0.0,1.0);
render_frame(rc,x0-G_textsize()/5,y0-G_textsize()/5,sx+2*G_textsize()/5,sy+2*G_textsize()/5,G_offset());
}
rc->set_color(color->G_R(),color->G_G(),color->G_B(),color->G_A());
render_impl(rc,status);
}
void T3DControl_Check::render_impl(Trendercontext *rc, const TObjectRenderStatus *status)
{
double x0=G_controlposx();
double y0=G_controlposy();
double z0=G_offset();
double sx=G_sizeunit();
double sy=G_sizeunit();
RenderGenericBackGround(rc);
if (checked->G_val())
{
rc->set_color(rendercolor.G_R(),rendercolor.G_G(),rendercolor.G_B(),rendercolor.G_A());
glLineWidth(2.0f);
glBegin(GL_LINES);
glVertex3d(x0,y0,z0);
glVertex3d(x0+sx,y0+sy,z0);
glVertex3d(x0+sx,y0,z0);
glVertex3d(x0,y0+sy,z0);
glEnd();
}
rc->set_color(rendercolor.G_R(),rendercolor.G_G(),rendercolor.G_B(),rendercolor.G_A());
render_frame(rc,x0,y0,sx,sy,z0+G_offset());
}
void process_x_render_pipe()
{
char c;
while(TEMP_FAILURE_RETRY(read(x_render_pipe[0], &c, 1)) == 1);
render_frame();
}
//called for every client
void *client_thread(void *t) {
int fd = *(int*)t;
free(t); //free argument int
FILE *stream = fdopen(fd, "r");
char buff[BUFSIZE];
buff[BUFSIZE-1] = '\0';
if (streaming) { //locked by some stream -> tell client
if (DEBUG) fprintf(stderr, "> Animation rejected. Server streaming.\n");
puts_tcp_stream(LOLD_SYM_BSY "\n\0", stream);
} else { //accept client
puts_tcp_stream(LOLD_SYM_OK "\n\0", stream);
//read head - task or stream?
//tcp_recv_string(fd, 100, buff);
fgets(buff, BUFSIZE-1, stream);
if (strncmp(buff, LOLD_SYM_TSK, LOLD_SYM_TSK_LEN)==0) //task
read_task(stream);
else if (strncmp(buff, LOLD_SYM_STM, LOLD_SYM_STM_LEN)==0) { //streaming
streaming = 1;
read_stream(stream);
render_frame(device, EMPTY_FRAME); // clear lolshield
streaming = 0;
} else { //invalid
puts_tcp_stream(LOLD_SYM_ERR "\n\0", stream);
}
}
//close file and socket, exit thread
fclose(stream);
close(fd);
pthread_exit(NULL);
}
bool render_screen(bool immediate)
{
bool v = false;
int cnt;
render_ok = false;
if (minimized || picasso_on || monitor_off || dx_islost ())
return render_ok;
cnt = 0;
while (wait_render) {
sleep_millis (1);
cnt++;
if (cnt > 500)
return render_ok;
}
#if 0
flushymin = 0;
flushymax = currentmode->amiga_height;
//EnterCriticalSection (&screen_cs);
if (currentmode->flags & DM_D3D) {
v = D3D_renderframe (immediate);
#endif
v = render_frame(immediate);
#if 0
} else if (currentmode->flags & DM_SWSCALE) {
S2X_render ();
v = true;
} else if (currentmode->flags & DM_DDRAW) {
v = true;
}
#endif
render_ok = v;
//LeaveCriticalSection (&screen_cs);
return render_ok;
}
// the entry point for any Windows program
int WINAPI WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
HWND hWnd;
WNDCLASSEX wc;
ZeroMemory(&wc, sizeof(WNDCLASSEX));
wc.cbSize = sizeof(WNDCLASSEX);
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = WindowProc;
wc.hInstance = hInstance;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.lpszClassName = "WindowClass";
RegisterClassEx(&wc);
hWnd = CreateWindowEx(0,
"WindowClass",
"Our Direct3D Program",
WS_OVERLAPPEDWINDOW,
0, 0,
SCREEN_WIDTH, SCREEN_HEIGHT,
NULL,
NULL,
hInstance,
NULL);
ShowWindow(hWnd, nCmdShow);
// set up and initialize Direct3D
initD3D(hWnd);
// enter the main loop:
MSG msg;
while(TRUE)
{
while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
if(msg.message == WM_QUIT)
break;
render_frame();
}
// clean up DirectX and COM
cleanD3D();
return msg.wParam;
}
//read stream, just act as proxy to lolshield
void read_stream(FILE *stream) {
char buff[BUFSIZE];
buff[BUFSIZE-1] = '\0';
if (DEBUG) fprintf(stderr, "> Stream started.\n");
//set fgets non-blocking
int fd = fileno(stream);
int flags = fcntl(fd, F_GETFL, 0);
flags |= O_NONBLOCK;
fcntl(fd, F_SETFL, flags);
//read frames until 10 sec nothing happens
long last_frame_time = time(NULL);
while(1) {
if (time(NULL)>last_frame_time+10) {
if (DEBUG) fprintf(stderr, "> Stream Timeout. Kill stream.\n");
puts_tcp_stream(LOLD_SYM_ERR"\n\0", stream); //timeout
return;
}
if (fgets(buff, BUFSIZE-1, stream) == NULL) { //nothing in buffer?
sleep_ms(30);
continue;
}
//assume there is some input -> new time
last_frame_time = time(NULL);
//end of frames
if (strncmp(buff, LOLD_SYM_END"\0", LOLD_SYM_END_LEN) == 0)
break;
char *save_ptr;
strtok_r(buff,"\n", &save_ptr); //strip newline
//check frame (9 comma sep ints?)
int commas=0;
for (unsigned int i=0; i<strlen(buff); i++)
if (buff[i]==',')
commas++;
if (commas!=8) {
if (DEBUG) fprintf(stderr, "> Invalid stream frame. Kill stream.\n");
puts_tcp_stream(LOLD_SYM_ERR"\n\0", stream); //invalid frame
return;
}
render_frame(device, buff); //directly output frame
}
if (DEBUG) fprintf(stderr, "> Stream ended.\n");
puts_tcp_stream(LOLD_SYM_OK"\n\0", stream); //ok
}
DWORD WINAPI mainThread()
{
while (TRUE)
{
render_frame();
//Sleep(10);
}
return 0;
}
int main(int argc, char **argv) {
init_sdl();
init_opengl();
while (1) {
render_frame();
handle_input();
}
return 0;
}
static void display_loop ()
{
struct timeval tv1, tv2; /* for timing */
int Time_taken ;
float Point1[2] ;
float Point2[2] ;
float Point3[2] ;
double Terrain_height ;
/* do terrain following */
Point1[0]=(float)User.X ;
Point1[1]=(float)User.Y ;
Point2[0]=(float)User.X+(MOVE_STEP*5*cos(User.Z_angle)) ;
Point2[1]=(float)User.Y+(MOVE_STEP*5*sin(User.Z_angle)) ;
Point3[0]=(float)User.X-(MOVE_STEP*5*cos(User.Z_angle)) ;
Point3[1]=(float)User.Y-(MOVE_STEP*5*sin(User.Z_angle)) ;
if
(HeteroTerrain(Point1,H,Lacunarity,Octaves,Offset)>
HeteroTerrain(Point2,H,Lacunarity,Octaves,Offset) )
{
Terrain_height=HeteroTerrain(Point1,H,Lacunarity,Octaves,Offset) ;
}
else
{
Terrain_height=HeteroTerrain(Point2,H,Lacunarity,Octaves,Offset) ;
}
if
(HeteroTerrain(Point3,H,Lacunarity,Octaves,Offset) > Terrain_height)
{
Terrain_height=HeteroTerrain(Point3,H,Lacunarity,Octaves,Offset) ;
}
User.Z=Terrain_height ;
/* get the start time */
gettimeofday(&tv1, (struct timezone*)0);
/* render the image */
render_frame() ;
/* get the end time */
gettimeofday(&tv2, (struct timezone*)0);
Time_taken = (tv2.tv_sec - tv1.tv_sec) * 1000000 + tv2.tv_usec - tv1.tv_usec;
printf ("INFO: Time taken=%i usecs\n",Time_taken) ;
}
int medlisp_update_screen()
{
int vn;
if (!render_3d_in_big_window)
for (vn=0;vn<N_views;vn++)
if (Views[vn]->ev_changed || (Update_flags & (UF_WORLD_CHANGED|UF_VIEWPOINT_MOVED|UF_ED_STATE_CHANGED))) {
draw_world(Views[vn]->ev_canv,Views[vn],Cursegp,Big_depth);
Views[vn]->ev_changed = 0;
}
if (Update_flags & (UF_WORLD_CHANGED|UF_GAME_VIEW_CHANGED|UF_ED_STATE_CHANGED)) {
grs_canvas temp_canvas;
grs_canvas *render_canv,*show_canv;
if (render_3d_in_big_window) {
gr_init_sub_canvas(&temp_canvas,canv_offscreen,0,0,
LargeView.ev_canv->cv_bitmap.bm_w,LargeView.ev_canv->cv_bitmap.bm_h);
render_canv = &temp_canvas;
show_canv = LargeView.ev_canv;
}
else {
render_canv = VR_offscreen_buffer;
show_canv = Canv_editor_game;
}
gr_set_current_canvas(render_canv);
render_frame(0);
Assert(render_canv->cv_bitmap.bm_w == show_canv->cv_bitmap.bm_w &&
render_canv->cv_bitmap.bm_h == show_canv->cv_bitmap.bm_h);
ui_mouse_hide();
gr_bm_ubitblt(show_canv->cv_bitmap.bm_w,show_canv->cv_bitmap.bm_h,
0,0,0,0,&render_canv->cv_bitmap,&show_canv->cv_bitmap);
ui_mouse_show();
}
Update_flags=UF_NONE; //clear flags
return 1;
}
void T3DControl_Scalar::render_impl(Trendercontext *rc, const TObjectRenderStatus *status)
{
double x0=G_controlposx();
double y0=G_controlposy();
double z0=G_offset();
double sx=sizex->G_val();
double sy=G_sizeunit();
double vl=value->G_val();
int digitcount=decimalcount->G_intval();
RenderGenericBackGround(rc);
TCHAR formatstr[100];
CString str;
_stprintf_s(formatstr,99,_qstr("%%0.%dlf"),digitcount);
str.Format(formatstr,vl);
rc->set_color(rendercolor.G_R(),rendercolor.G_G(),rendercolor.G_B(),rendercolor.G_A());
rc->rendertext(DEFAULT_FONT,&Tvertex(x0+sy/10,y0+sy/4,z0),
&Tvector(G_textsize(),0,0),
&Tvector(0,G_textsize(),0),str,0);
rc->set_color(rendercolor.G_R(),rendercolor.G_G(),rendercolor.G_B(),rendercolor.G_A());
render_frame(rc,x0,y0,sx,sy,z0+G_offset());
//draw range
x0=G_controlposx()+sizex->G_val()+G_sizeunit()/5;
y0=y0+sy/2;
sx=rangesizex->G_val()-G_sizeunit()/5;
if (sx>0)
{
double x1=sx*(value->G_val()-vmin->G_val())/(vmax->G_val()-vmin->G_val());
if (x1<0) x1=0;if (x1>sx) x1=sx;
x1+=x0;
glLineWidth(2.0f);
glBegin(GL_LINES);
glVertex3d(x0,y0,z0);
glVertex3d(x0+sx,y0,z0);
glVertex3d(x1,y0-sy/4,z0);
glVertex3d(x1,y0+sy/4,z0);
glEnd();
}
}
void
VideoMixer::process()
{
const auto now = std::chrono::system_clock::now();
const auto diff = now - lastProcess_;
const auto delay = FRAME_DURATION - diff;
if (delay.count() > 0)
std::this_thread::sleep_for(delay);
lastProcess_ = now;
VideoFrame& output = getNewFrame();
try {
output.reserve(VIDEO_PIXFMT_YUYV422, width_, height_);
} catch (const std::bad_alloc& e) {
RING_ERR("VideoFrame::allocBuffer() failed");
return;
}
yuv422_clear_to_black(output);
{
auto lock(rwMutex_.read());
int i = 0;
for (const auto& x : sources_) {
/* thread stop pending? */
if (!loop_.isRunning())
return;
// make rendered frame temporarily unavailable for update()
// to avoid concurrent access.
std::unique_ptr<VideoFrame> input;
x->atomic_swap_render(input);
if (input)
render_frame(output, *input, i);
x->atomic_swap_render(input);
++i;
}
}
publishFrame();
}
void render_animation_frames(int n, ...)
{
int i, f = 0;
frame_delay = 300;
va_list arguments;
va_start(arguments, n);
for ( i = 0; i <= frame % n; i++ )
{
f = va_arg(arguments, int);
}
render_frame(charset[f]);
va_end ( arguments );
}
void android_main(struct android_app *state)
{
struct engine engine;
// Make sure glue isn't stripped.
app_dummy();
memset(&engine, 0, sizeof(engine));
state->userData = &engine;
state->onAppCmd = engine_handle_cmd;
state->onInputEvent = engine_handle_input;
engine.app = state;
// loop waiting for stuff to do.
while (1) {
// Read all pending events.
int ident;
int events;
struct android_poll_source *source;
// If not animating, we will block forever waiting for events.
// If animating, we loop until all events are read, then continue
// to draw the next frame of animation.
while ((ident =
ALooper_pollAll(0, NULL,
&events,
(void **) &source)) >= 0) {
// Process this event.
if (source != NULL) {
source->process(state, source);
}
// Check if we are exiting.
if (state->destroyRequested != 0) {
LOGI("Engine thread destroy requested!");
engine_term_display(&engine);
return;
}
}
render_frame(&engine);
}
}
void T3DControl_List::render_impl(Trendercontext *rc, const TObjectRenderStatus *status)
{
QString str;
double x0=G_controlposx();
double y0=G_controlposy();
double z0=G_offset();
double sx=sizex->G_val();
TSC_color *backcol=G_scene()->G_backcolor();
TQXColor col_foreground(rendercolor.G_R(),rendercolor.G_G(),rendercolor.G_B(),rendercolor.G_A());
TQXColor col_background(backcol->G_R(),backcol->G_G(),backcol->G_B(),backcol->G_A());
TQXColor selcl1=3*col_background+col_foreground;
TQXColor selcl2=selcl1.IntensIncr(0.25)+0.2*TQXColor(0.0,1.0,0.0);
int linecount=county->G_intval();
double unity=G_sizeunit();
RenderGenericBackGround(rc);
for (int i=0; i<list->G_size(); i++)
if ((i-offset>=0)&&(i-offset<linecount))
{
double yps=y0+unity/10+unity*(linecount-1-(i-offset));
if (i==selectidx->G_intval())
{
rc->set_color((rendercolor.G_R()+backcol->G_R())/2,(rendercolor.G_G()+backcol->G_G())/2,(rendercolor.G_B()+backcol->G_B())/2,(rendercolor.G_A()+backcol->G_A())/2);
render_rect2(rc,x0,yps,sx,unity,z0,selcl1,selcl2);
}
list->get(i)->tostring(str);
rc->set_color(rendercolor.G_R(),rendercolor.G_G(),rendercolor.G_B(),rendercolor.G_A());
rc->rendertext(DEFAULT_FONT,&Tvertex(x0+unity/10,yps+unity/4,z0+G_offset()),
&Tvector(G_textsize(),0,0),
&Tvector(0,G_textsize(),0),str,0);
}
rc->set_color(rendercolor.G_R(),rendercolor.G_G(),rendercolor.G_B(),rendercolor.G_A());
render_frame(rc,x0,y0,sx,unity*linecount,z0+G_offset());
}
void T3DControl_Edit::render_impl(Trendercontext *rc, const TObjectRenderStatus *status)
{
double x0=G_controlposx();
double y0=G_controlposy();
double z0=G_offset();
double sx=sizex->G_val();
double sy=G_sizeunit();
RenderGenericBackGround(rc);
QString str;
str=content->G_string();
if (G_isactive())
str+=_qstr("|");
rc->set_color(rendercolor.G_R(),rendercolor.G_G(),rendercolor.G_B(),rendercolor.G_A());
rc->rendertext(DEFAULT_FONT,&Tvertex(x0+sy/10,y0+sy/4,z0),
&Tvector(G_textsize(),0,0),
&Tvector(0,G_textsize(),0),str,0);
rc->set_color(rendercolor.G_R(),rendercolor.G_G(),rendercolor.G_B(),rendercolor.G_A());
render_frame(rc,x0,y0,sx,sy,z0+G_offset());
}
void gfx_unlock_picasso (bool dorender)
{
#ifdef DEBUG_SHOW_SCREEN
printf("gfx_unlock_picasso dorender=%d\n", dorender);
#endif
#if 0
if (!rtg_locked)
EnterCriticalSection (&screen_cs);
#endif
rtg_locked = false;
if (dorender) {
//render_screen(1);
// FIXME: check what mode parameter is supposed to do
//show_screen(0);
if (render_frame(false)) {
show_screen_maybe(true);
}
}
}
int medlisp_update_screen()
{
int vn;
#if 1 //def OGL
Update_flags = UF_ALL;
#endif
if (!render_3d_in_big_window)
for (vn=0;vn<N_views;vn++)
if (Views[vn]->ev_changed || (Update_flags & (UF_WORLD_CHANGED|UF_VIEWPOINT_MOVED|UF_ED_STATE_CHANGED))) {
draw_world(Views[vn]->ev_canv,Views[vn],Cursegp,Big_depth);
Views[vn]->ev_changed = 0;
}
if (Update_flags & (UF_WORLD_CHANGED|UF_GAME_VIEW_CHANGED|UF_ED_STATE_CHANGED)) {
grs_canvas *render_canv,*show_canv;
if (render_3d_in_big_window) {
render_canv = LargeView.ev_canv;
show_canv = LargeView.ev_canv;
}
else {
render_canv = Canv_editor_game;
show_canv = Canv_editor_game;
}
gr_set_current_canvas(render_canv);
render_frame(0, 0);
Assert(render_canv->cv_bitmap.bm_w == show_canv->cv_bitmap.bm_w &&
render_canv->cv_bitmap.bm_h == show_canv->cv_bitmap.bm_h);
}
Update_flags=UF_NONE; //clear flags
return 1;
}
// Initialize rendering components and render a frame.
IRendererController::Status initialize_and_render_frame()
{
// Construct an abort switch that will allow to abort initialization or rendering.
RendererControllerAbortSwitch abort_switch(*m_renderer_controller);
// Create the texture store.
TextureStore texture_store(
*m_project.get_scene(),
m_params.child("texture_store"));
// Initialize OSL's shading system.
if (!initialize_osl_shading_system(texture_store, abort_switch) ||
abort_switch.is_aborted())
{
// If it wasn't an abort, it was a failure.
return
abort_switch.is_aborted()
? m_renderer_controller->get_status()
: IRendererController::AbortRendering;
}
// Let scene entities perform their pre-render actions. Don't proceed if that failed.
// This is done before creating renderer components because renderer components need
// to access the scene's render data such as the scene's bounding box.
OnRenderBeginRecorder recorder;
if (!m_project.get_scene()->on_render_begin(m_project, nullptr, recorder, &abort_switch) ||
abort_switch.is_aborted())
{
recorder.on_render_end(m_project);
return m_renderer_controller->get_status();
}
// Create renderer components.
RendererComponents components(
m_project,
m_params,
m_tile_callback_factory,
texture_store,
*m_texture_system,
*m_shading_system);
if (!components.create())
{
recorder.on_render_end(m_project);
return IRendererController::AbortRendering;
}
// Print renderer components settings.
components.print_settings();
// Report whether Embree is used or not.
#ifdef APPLESEED_WITH_EMBREE
const bool use_embree = m_params.get_optional<bool>("use_embree", false);
m_project.set_use_embree(use_embree);
#else
const bool use_embree = false;
#endif
if (use_embree)
RENDERER_LOG_INFO("using Intel Embree ray tracing kernel.");
else RENDERER_LOG_INFO("using built-in ray tracing kernel.");
// Updating the trace context causes ray tracing acceleration structures to be updated or rebuilt.
m_project.update_trace_context();
// Load the checkpoint if any.
Frame& frame = *m_project.get_frame();
const size_t pass_count = m_params.get_optional<size_t>("passes", 1);
if (!frame.load_checkpoint(&components.get_shading_result_framebuffer_factory(), pass_count))
{
recorder.on_render_end(m_project);
return IRendererController::AbortRendering;
}
// Let renderer components perform their pre-render actions. Don't proceed if that failed.
if (!components.on_render_begin(recorder, &abort_switch) ||
abort_switch.is_aborted())
{
recorder.on_render_end(m_project);
return m_renderer_controller->get_status();
}
// Execute the main rendering loop.
const auto status = render_frame(components, abort_switch);
// Perform post-render actions.
recorder.on_render_end(m_project);
// End light path recording.
const CanvasProperties& props = m_project.get_frame()->image().properties();
m_project.get_light_path_recorder().finalize(
props.m_canvas_width,
props.m_canvas_height);
// Print texture store performance statistics.
RENDERER_LOG_DEBUG("%s", texture_store.get_statistics().to_string().c_str());
return status;
}
void fs_ml_render_iteration() {
static int first = 1;
if (first) {
first = 0;
initialize_opengl_sync();
}
if (g_fs_ml_vblank_sync) {
render_iteration_vsync();
}
else if (g_fs_ml_benchmarking) {
update_frame();
render_frame();
swap_opengl_buffers();
}
else {
// when vsync is off, we wait until a new frame is ready and
// then we display it immediately
if (fs_ml_is_quitting()) {
// but when the emulation is quitting, we can't expect any new
// frames so there's no point waiting for them. Instead, we just
// sleep a bit to throttle the frame rate for the quit animation
fs_ml_usleep(10000);
} else {
// wait max 33 ms to allow the user interface to work even if
// the emu hangs
// int64_t dest_time = fs_get_real_time() + 33 * 1000;
int64_t end_time = fs_condition_get_wait_end_time(33 * 1000);
int64_t check_time = 0;
fs_mutex_lock(g_frame_available_mutex);
// fs_log("cond wait until %lld\n", end_time);
while (g_rendered_frame == g_available_frame) {
fs_condition_wait_until(
g_frame_available_cond, g_frame_available_mutex, end_time);
check_time = fs_condition_get_wait_end_time(0);
if (check_time >= end_time) {
// fs_log("timed out at %lld\n", check_time);
break;
} else {
// fs_log("wake-up at %lld (end_time = %lld)\n", check_time, end_time);
}
}
fs_mutex_unlock(g_frame_available_mutex);
}
update_frame();
render_frame();
swap_opengl_buffers();
//gl_finish();
}
if (g_fs_ml_video_screenshot_path) {
fs_mutex_lock(g_fs_ml_video_screenshot_mutex);
if (g_fs_ml_video_screenshot_path) {
save_screenshot_of_opengl_framebuffer(
g_fs_ml_video_screenshot_path);
g_free(g_fs_ml_video_screenshot_path);
g_fs_ml_video_screenshot_path = NULL;
}
fs_mutex_unlock(g_fs_ml_video_screenshot_mutex);
}
if (g_fs_ml_video_post_render_function) {
g_fs_ml_video_post_render_function();
}
}
static void render_iteration_vsync() {
if (g_fs_ml_video_sync_low_latency) {
int current_frame_at_start = g_available_frame;
//int64_t t1 = fs_ml_monotonic_time();
int sleep_time = 0;
int time_left = g_estimated_upload_render_duration;
int64_t t = fs_emu_monotonic_time();
if (g_fs_ml_target_frame_time > 0) {
sleep_time = g_estimated_next_vblank_time - t - time_left;
}
if (sleep_time > g_fs_ml_target_frame_time - time_left) {
sleep_time = 0;
}
if (sleep_time > 0) {
fs_ml_usleep(sleep_time);
}
if (g_available_frame > current_frame_at_start) {
//printf("low latency %d\n", g_available_frame);
}
else {
//printf("...\n");
}
}
update_frame();
CHECK_GL_ERROR_MSG("update_frame");
render_frame();
CHECK_GL_ERROR_MSG("render_frame");
//opengl_fence(FENCE_SET);
//glFlush();
//opengl_fence(FENCE_WAIT);
//int64_t upload_render_time = fs_ml_monotonic_time() - t1;
//printf("urt %lld\n", upload_render_time);
opengl_swap_synchronous();
g_measured_vblank_time = fs_ml_monotonic_time();
g_vblank_count++;
fs_mutex_lock(g_vblank_mutex);
g_measured_vblank_times[g_vblank_index] = g_measured_vblank_time;
g_vblank_index = (g_vblank_index + 1) % VBLANK_COUNT;
fs_mutex_unlock(g_vblank_mutex);
// FIXME: adjust g_measured_vblank_time based on historical data (smooth out
// irregularities) and save the result in g_adjusted_vblank_time
g_adjusted_vblank_time = g_measured_vblank_time;
g_sleep_until_vsync_last_time = g_adjusted_vblank_time;
g_estimated_next_vblank_time = g_adjusted_vblank_time + \
g_fs_ml_target_frame_time;
// g_start_new_frame_cond is used to signal that a new frame can be
// generated when the emulation is running in sync - this is not used
// when only display flipping is synced to vblank
fs_mutex_lock(g_start_new_frame_mutex);
g_start_new_frame = 1;
fs_condition_signal(g_start_new_frame_cond);
fs_mutex_unlock(g_start_new_frame_mutex);
}
//this is for system-level keys, such as help, etc.
//returns 1 if screen changed
int HandleSystemKey(int key)
{
if (!Player_is_dead)
switch (key)
{
#ifdef DOOR_DEBUGGING
case KEY_LAPOSTRO+KEY_SHIFTED:
dump_door_debugging_info();
return 1;
#endif
case KEY_ESC:
{
int choice;
choice=nm_messagebox( NULL, 2, TXT_YES, TXT_NO, TXT_ABORT_GAME );
if (choice == 0)
window_close(Game_wind);
return 1;
}
// fleshed these out because F1 and F2 aren't sequenctial keycodes on mac -- MWA
KEY_MAC(case KEY_COMMAND+KEY_SHIFTED+KEY_1:)
case KEY_SHIFTED+KEY_F1:
select_next_window_function(0);
return 1;
KEY_MAC(case KEY_COMMAND+KEY_SHIFTED+KEY_2:)
case KEY_SHIFTED+KEY_F2:
select_next_window_function(1);
return 1;
}
switch (key)
{
KEY_MAC( case KEY_COMMAND+KEY_P: )
case KEY_PAUSE:
do_game_pause(); break;
#ifdef macintosh
case KEY_COMMAND + KEY_SHIFTED + KEY_3:
#endif
case KEY_PRINT_SCREEN:
{
if (PlayerCfg.PRShot)
{
gr_set_current_canvas(NULL);
render_frame(0, 0);
//gr_set_curfont(MEDIUM2_FONT);
//gr_printf(SWIDTH-FSPACX(92),SHEIGHT-LINE_SPACING,"DXX-Rebirth\n");
gr_flip();
save_screen_shot(0);
}
else
{
game_render_frame_mono(0);
if(GameArg.DbgUseDoubleBuffer)
gr_flip();
save_screen_shot(0);
}
break;
}
KEY_MAC(case KEY_COMMAND+KEY_1:)
case KEY_F1: if (Game_mode & GM_MULTI) show_netgame_help(); else show_help(); break;
KEY_MAC(case KEY_COMMAND+KEY_2:)
case KEY_F2:
{
do_options_menu();
break;
}
KEY_MAC(case KEY_COMMAND+KEY_3:)
case KEY_F3:
if (!Player_is_dead && Viewer->type==OBJ_PLAYER) //if (!(Guided_missile[Player_num] && Guided_missile[Player_num]->type==OBJ_WEAPON && Guided_missile[Player_num]->id==GUIDEDMISS_ID && Guided_missile[Player_num]->signature==Guided_missile_sig[Player_num] && PlayerCfg.GuidedInBigWindow))
{
toggle_cockpit();
}
break;
KEY_MAC(case KEY_COMMAND+KEY_5:)
case KEY_F5:
if ( Newdemo_state == ND_STATE_RECORDING )
newdemo_stop_recording();
else if ( Newdemo_state == ND_STATE_NORMAL )
newdemo_start_recording();
break;
#ifdef NETWORK
KEY_MAC(case KEY_COMMAND+KEY_ALTED+KEY_4:)
case KEY_ALTED + KEY_F4:
Show_reticle_name = (Show_reticle_name+1)%2;
break;
KEY_MAC(case KEY_COMMAND+KEY_7:)
case KEY_F7:
Show_kill_list = (Show_kill_list+1) % ((Game_mode & GM_TEAM) ? 4 : 3);
if (Game_mode & GM_MULTI)
multi_sort_kill_list();
break;
KEY_MAC(case KEY_COMMAND+KEY_8:)
case KEY_F8:
multi_send_message_start();
break;
case KEY_F9:
case KEY_F10:
case KEY_F11:
case KEY_F12:
multi_send_macro(key);
break; // send taunt macros
#if defined(__APPLE__) || defined(macintosh)
case KEY_9 + KEY_COMMAND:
multi_send_macro(KEY_F9);
break;
case KEY_0 + KEY_COMMAND:
multi_send_macro(KEY_F10);
break;
case KEY_1 + KEY_COMMAND + KEY_CTRLED:
multi_send_macro(KEY_F11);
break;
case KEY_2 + KEY_COMMAND + KEY_CTRLED:
multi_send_macro(KEY_F12);
break;
#endif
case KEY_SHIFTED + KEY_F9:
case KEY_SHIFTED + KEY_F10:
case KEY_SHIFTED + KEY_F11:
case KEY_SHIFTED + KEY_F12:
multi_define_macro(key);
break; // redefine taunt macros
#if defined(__APPLE__) || defined(macintosh)
case KEY_9 + KEY_SHIFTED + KEY_COMMAND:
multi_define_macro(KEY_F9);
break;
case KEY_0 + KEY_SHIFTED + KEY_COMMAND:
multi_define_macro(KEY_F10);
break;
case KEY_1 + KEY_SHIFTED + KEY_COMMAND + KEY_CTRLED:
multi_define_macro(KEY_F11);
break;
case KEY_2 + KEY_SHIFTED + KEY_COMMAND + KEY_CTRLED:
multi_define_macro(KEY_F12);
break;
#endif
#endif
KEY_MAC(case KEY_COMMAND+KEY_SHIFTED+KEY_S:)
KEY_MAC(case KEY_COMMAND+KEY_ALTED+KEY_2:)
case KEY_ALTED+KEY_F2:
if (!Player_is_dead)
state_save_all(0, NULL, 0); // 0 means not between levels.
break;
KEY_MAC(case KEY_COMMAND+KEY_S:)
case KEY_ALTED+KEY_F1:
if (!Player_is_dead)
state_save_all(0, NULL, 1);
break;
KEY_MAC(case KEY_COMMAND+KEY_O:)
KEY_MAC(case KEY_COMMAND+KEY_ALTED+KEY_3:)
case KEY_ALTED+KEY_F3:
if (!((Game_mode & GM_MULTI) && !(Game_mode & GM_MULTI_COOP)))
state_restore_all(1, 0, NULL);
break;
KEY_MAC(case KEY_COMMAND+KEY_SHIFTED+KEY_4:)
case KEY_F4 + KEY_SHIFTED:
do_escort_menu();
break;
KEY_MAC(case KEY_COMMAND+KEY_SHIFTED+KEY_ALTED+KEY_4:)
case KEY_F4 + KEY_SHIFTED + KEY_ALTED:
change_guidebot_name();
break;
/*
* Jukebox hotkeys -- MD2211, 2007
* Now for all music
* ==============================================
*/
case KEY_ALTED + KEY_SHIFTED + KEY_F9:
KEY_MAC(case KEY_COMMAND+KEY_E:)
if (GameCfg.MusicType == MUSIC_TYPE_REDBOOK)
{
songs_stop_all();
RBAEjectDisk();
}
break;
case KEY_ALTED + KEY_SHIFTED + KEY_F10:
KEY_MAC(case KEY_COMMAND+KEY_UP:)
KEY_MAC(case KEY_COMMAND+KEY_DOWN:)
songs_pause_resume();
break;
case KEY_MINUS + KEY_ALTED:
case KEY_ALTED + KEY_SHIFTED + KEY_F11:
KEY_MAC(case KEY_COMMAND+KEY_LEFT:)
songs_play_level_song( Current_level_num, -1 );
break;
case KEY_EQUAL + KEY_ALTED:
case KEY_ALTED + KEY_SHIFTED + KEY_F12:
KEY_MAC(case KEY_COMMAND+KEY_RIGHT:)
songs_play_level_song( Current_level_num, 1 );
break;
default:
return 0;
break;
}
return 1;
}
int HandleDemoKey(int key)
{
switch (key) {
KEY_MAC(case KEY_COMMAND+KEY_1:)
case KEY_F1: show_newdemo_help(); break;
KEY_MAC(case KEY_COMMAND+KEY_2:)
case KEY_F2: do_options_menu(); break;
KEY_MAC(case KEY_COMMAND+KEY_3:)
case KEY_F3:
if (Viewer->type == OBJ_PLAYER)
toggle_cockpit();
break;
KEY_MAC(case KEY_COMMAND+KEY_4:)
case KEY_F4: Newdemo_show_percentage = !Newdemo_show_percentage; break;
case KEY_F6: Show_network_stats = ! Show_network_stats; break;
KEY_MAC(case KEY_COMMAND+KEY_7:)
case KEY_F7:
#ifdef NETWORK
Show_kill_list = (Show_kill_list+1) % ((Newdemo_game_mode & GM_TEAM) ? 4 : 3);
#endif
break;
case KEY_ESC:
if (GameArg.SysAutoDemo)
{
int choice;
choice = nm_messagebox( NULL, 2, TXT_YES, TXT_NO, TXT_ABORT_AUTODEMO );
if (choice == 0)
GameArg.SysAutoDemo = 0;
else
break;
}
newdemo_stop_playback();
break;
case KEY_UP:
Newdemo_vcr_state = ND_STATE_PLAYBACK;
break;
case KEY_DOWN:
Newdemo_vcr_state = ND_STATE_PAUSED;
break;
case KEY_LEFT:
newdemo_single_frame_time = GameTime64;
Newdemo_vcr_state = ND_STATE_ONEFRAMEBACKWARD;
break;
case KEY_RIGHT:
newdemo_single_frame_time = GameTime64;
Newdemo_vcr_state = ND_STATE_ONEFRAMEFORWARD;
break;
case KEY_CTRLED + KEY_RIGHT:
newdemo_goto_end(0);
break;
case KEY_CTRLED + KEY_LEFT:
newdemo_goto_beginning();
break;
KEY_MAC(case KEY_COMMAND+KEY_P:)
case KEY_PAUSE:
do_game_pause();
break;
#ifdef macintosh
case KEY_COMMAND + KEY_SHIFTED + KEY_3:
#endif
case KEY_PRINT_SCREEN:
{
if (PlayerCfg.PRShot)
{
gr_set_current_canvas(NULL);
render_frame(0, 0);
//gr_set_curfont(MEDIUM2_FONT);
//gr_printf(SWIDTH-FSPACX(92),SHEIGHT-LINE_SPACING,"DXX-Rebirth\n");
gr_flip();
save_screen_shot(0);
}
else
{
int old_state;
old_state = Newdemo_show_percentage;
Newdemo_show_percentage = 0;
game_render_frame_mono(0);
if (GameArg.DbgUseDoubleBuffer)
gr_flip();
save_screen_shot(0);
Newdemo_show_percentage = old_state;
}
break;
}
#ifndef NDEBUG
case KEY_DEBUGGED + KEY_I:
Newdemo_do_interpolate = !Newdemo_do_interpolate;
HUD_init_message(HM_DEFAULT, "Demo playback interpolation %s", Newdemo_do_interpolate?"ON":"OFF");
break;
case KEY_DEBUGGED + KEY_K: {
int how_many, c;
char filename[FILENAME_LEN], num[16];
newmenu_item m[6];
filename[0] = '\0';
m[ 0].type = NM_TYPE_TEXT; m[ 0].text = "output file name";
m[ 1].type = NM_TYPE_INPUT;m[ 1].text_len = 8; m[1].text = filename;
c = newmenu_do( NULL, NULL, 2, m, NULL, NULL );
if (c == -2)
break;
strcat(filename, DEMO_EXT);
num[0] = '\0';
m[ 0].type = NM_TYPE_TEXT; m[ 0].text = "strip how many bytes";
m[ 1].type = NM_TYPE_INPUT;m[ 1].text_len = 16; m[1].text = num;
c = newmenu_do( NULL, NULL, 2, m, NULL, NULL );
if (c == -2)
break;
how_many = atoi(num);
if (how_many <= 0)
break;
newdemo_strip_frames(filename, how_many);
break;
}
#endif
default:
return 0;
}
return 1;
}
void fs_emu_video_render_function() {
static int initialized_menu = 0;
if (!initialized_menu) {
// render menu once (without really showing it, so all menu
// resources are initialized and loaded, -prevents flickering
// when really opening the menu later
fs_emu_render_menu(g_menu_transition);
initialized_menu = 1;
}
if (g_fs_emu_video_debug) {
int quarter_height = fs_ml_video_height() / 4;
fs_gl_viewport(0, quarter_height, fs_ml_video_width(),
fs_ml_video_height() - quarter_height);
}
else {
fs_gl_viewport(0, 0, fs_ml_video_width(), fs_ml_video_height());
}
// FIXME: can perhaps remove this soon..
fs_emu_video_render_mutex_lock();
int in_menu = fs_emu_menu_is_active();
if (in_menu && g_menu_transition_target < 1.0) {
g_menu_transition_target = 1.0;
}
if (!in_menu && g_menu_transition_target > 0.0) {
g_menu_transition_target = 0.0;
}
// FIXME: ideally, we would use time-based animation - for now, we use a
// simple frame-based animation
if (g_menu_transition < g_menu_transition_target) {
if (g_menu_transition_target == 1.0) {
g_menu_transition += 0.10;
}
}
if (g_menu_transition > g_menu_transition_target) {
if (g_menu_transition_target == 0.0) {
g_menu_transition -= 0.10;
}
}
if (g_menu_transition > 1.0) {
g_menu_transition = 1.0;
}
else if (g_menu_transition < 0.0) {
g_menu_transition = 0.0;
}
int matrix_pushed = 0;
double t0_x = 0.0;
double t0_y = 0.0;
double t0_z = -2.42;
double r0_a = 0.0;
double t1_x = -0.31;
//double t1_y = -0.04;
double t1_y = 0.0;
double t1_z = -3.7;
double r1_a = 30.0;
int perspective = 0;
if (g_menu_transition == 0.0) {
perspective = 0;
fs_gl_ortho();
//glTranslated(1920.0 / 2.0, 1080.0 / 2.0, 0.0);
//glScaled(1920.0 / 2.0, 1080.0 / 2.0, 1.0);
}
else {
perspective = 1;
glClearColor(0.1, 0.1, 0.1, 1.0);
glClear(GL_DEPTH_BUFFER_BIT);
CHECK_GL_ERROR();
fs_gl_ortho_hd();
// transition y-coordinate between floor and wall
int splt = 361;
fs_gl_blending(FALSE);
fs_gl_texturing(FALSE);
GLfloat color[] = {
39.0 / 255.0, 44.0 / 255.0, 51.0 / 255.0, 1.0,
39.0 / 255.0, 44.0 / 255.0, 51.0 / 255.0, 1.0,
0.0, 0.0, 0.0, 1.0,
0.0, 0.0, 0.0, 1.0,
0.0, 0.0, 0.0, 1.0,
0.0, 0.0, 0.0, 1.0,
0.0, 0.0, 0.0, 1.0,
0.0, 0.0, 0.0, 1.0,
0.0, 0.0, 0.0, 1.0,
0.0, 0.0, 0.0, 1.0,
20.0 / 255.0, 22.0 / 255.0, 26.0 / 255.0, 1.0,
20.0 / 255.0, 22.0 / 255.0, 26.0 / 255.0, 1.0
};
GLfloat vert[] = {
0, splt, -0.9,
1920, splt, -0.9,
1920, 1020, -0.9,
0, 1020, -0.9,
0, 1020, -0.9,
1920, 1020, -0.9,
1920, 1080, -0.9,
0, 1080, -0.9,
0, 0, -0.9,
1920, 0, -0.9,
1920, splt, -0.9,
0, splt, -0.9
};
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glColorPointer(4, GL_FLOAT, 0, color);
glVertexPointer(3, GL_FLOAT, 0, vert);
glDrawArrays(GL_TRIANGLE_FAN, 0, 12);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
CHECK_GL_ERROR();
fs_gl_perspective();
double t_x = t0_x + (t1_x - t0_x) * g_menu_transition;
double t_y = t0_y + (t1_y - t0_y) * g_menu_transition;
double t_z = t0_z + (t1_z - t0_z) * g_menu_transition;
double r_a = r0_a + (r1_a - r0_a) * g_menu_transition;
glPushMatrix();
matrix_pushed = 1;
glScaled(16.0 / 9.0, 1.0, 1.0);
glTranslated(t_x, t_y, t_z);
glRotated(r_a, 0.0, 1.0, 0.0);
CHECK_GL_ERROR();
}
if (perspective) {
render_glow(g_menu_transition);
}
if (perspective) {
glPushMatrix();
glTranslatef(0.0, -2.0, 0.0);
//glTranslatef(0.0, -1.0, 0.0);
//glScalef(1.0, -1.0, 1.0);
glScalef(1.0, -0.5, 1.0);
glTranslatef(0.0, -1.0, 0.0);
CHECK_GL_ERROR();
render_frame(0.33, perspective);
CHECK_GL_ERROR();
render_gloss(g_menu_transition * 0.66);
CHECK_GL_ERROR();
glPopMatrix();
CHECK_GL_ERROR();
}
render_frame(1.0, perspective);
if (perspective) {
render_gloss(g_menu_transition);
}
/*
if (fs_emu_is_paused()) {
render_pause_fade();
}
*/
if (matrix_pushed) {
glPopMatrix();
CHECK_GL_ERROR();
matrix_pushed = 0;
}
fs_emu_acquire_gui_lock();
fs_emu_render_chat();
//if (fs_emu_menu_is_active()) {
if (g_menu_transition > 0.0) {
fs_emu_render_menu(g_menu_transition);
}
fs_emu_render_dialog();
fs_emu_release_gui_lock();
if (g_fs_emu_hud_mode && fs_emu_netplay_enabled()) {
fs_gl_ortho_hd();
fs_gl_texturing(0);
fs_gl_blending(1);
fs_gl_color4f(0.0, 0.0, 0.0, 0.5);
GLfloat vert[] = {
0, 1030,
1920, 1030,
1920, 1080,
0, 1080
};
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(2, GL_FLOAT, 0, vert);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glDisableClientState(GL_VERTEX_ARRAY);
CHECK_GL_ERROR();
#if 0
glBegin(GL_QUADS);
glVertex2f(0, 1030);
glVertex2f(1920, 1030);
fs_gl_color4f(0.0, 0.0, 0.0, 0.0);
glVertex2f(1920, 1030 - 50);
glVertex2f(0, 1030 - 50);
glEnd();
#endif
fs_emu_font *menu_font = fs_emu_font_get_menu();
char *str;
for (int i = 0; i < MAX_PLAYERS; i++) {
fs_emu_player *player = g_fs_emu_players + i;
int x = i * 1920 / 6 + 20;
int y = 1038;
int rendered_tag = 0;
if (player->tag && player->tag[0]) {
str = g_strdup_printf("%s", player->tag);
fs_emu_font_render(menu_font, str, x, y,
1.0, 1.0, 1.0, 1.0);
g_free(str);
rendered_tag = 1;
}
if (rendered_tag || player->ping) {
str = g_strdup_printf("%03d", player->ping);
fs_emu_font_render(menu_font, str, x + 100, y,
1.0, 1.0, 1.0, 1.0);
g_free(str);
}
if (rendered_tag || player->lag) {
str = g_strdup_printf("%03d", player->lag);
fs_emu_font_render(menu_font, str, x + 200, y,
1.0, 1.0, 1.0, 1.0);
g_free(str);
}
}
}
if (g_fs_emu_video_debug) {
int quarter_height = fs_ml_video_height() / 4;
fs_gl_viewport(0, 0, fs_ml_video_width(), quarter_height);
CHECK_GL_ERROR();
fs_emu_set_texture(NULL);
CHECK_GL_ERROR();
static GLuint debug_texture = 0;
static uint32_t *debug_texture_data = NULL;
if (debug_texture == 0) {
debug_texture_data = g_malloc0(256 * 256 * 4);
glGenTextures(1, &debug_texture);
CHECK_GL_ERROR();
fs_gl_bind_texture(debug_texture);
#ifndef HAVE_GLES
fs_gl_unpack_row_length(0);
#endif
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0,
GL_RGBA, GL_UNSIGNED_BYTE, NULL);
CHECK_GL_ERROR();
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_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
GL_CLAMP_TO_EDGE);
CHECK_GL_ERROR();
}
else {
fs_gl_bind_texture(debug_texture);
CHECK_GL_ERROR();
}
memset(debug_texture_data, 0x00, 256 * 256 * 4);
CHECK_GL_ERROR();
fs_emu_video_render_debug_info(debug_texture_data);
CHECK_GL_ERROR();
fs_emu_audio_render_debug_info(debug_texture_data);
CHECK_GL_ERROR();
#ifndef HAVE_GLES
fs_gl_unpack_row_length(0);
#endif
CHECK_GL_ERROR();
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 256, 256,
GL_RGBA, GL_UNSIGNED_BYTE, debug_texture_data);
CHECK_GL_ERROR();
fs_gl_ortho_hd();
fs_gl_texturing(1);
fs_gl_blending(0);
fs_gl_color4f(1.0, 1.0, 1.0, 1.0);
GLfloat tex[] = {
0.0, 0.0,
1.0, 0.0,
1.0, 1.0,
0.0, 1.0
};
GLfloat vert[] = {
0, 0,
1920, 0,
1920, 1080,
0, 1080
};
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0, tex);
glVertexPointer(2, GL_FLOAT, 0, vert);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
CHECK_GL_ERROR();
glPushMatrix();
glScalef(1.0, 4.0, 1.0);
fs_emu_font *menu_font = fs_emu_font_get_menu();
char *str;
/*
str = g_strdup_printf("%d", fs_emu_get_audio_frequency());
fs_emu_font_render(menu_font, str, 1920 / 2 + 20, 3,
1.0, 1.0, 1.0, 1.0);
g_free(str);
*/
str = g_strdup_printf("%0.1f",
fs_emu_audio_get_measured_avg_buffer_fill(0) / 1000.0);
fs_emu_font_render(menu_font, str, 1920 / 2 + 220, 3,
1.0, 1.0, 1.0, 1.0);
g_free(str);
str = g_strdup_printf("%d", g_fs_emu_audio_buffer_underruns);
fs_emu_font_render(menu_font, str, 1920 / 2 + 420, 3,
1.0, 1.0, 1.0, 1.0);
g_free(str);
fs_emu_font_render(menu_font, "EMU", 20, 3, 1.0, 1.0, 1.0, 1.0);
str = g_strdup_printf("%0.1f", fs_emu_get_average_emu_fps());
fs_emu_font_render(menu_font, str, 220, 3, 1.0, 1.0, 1.0, 1.0);
g_free(str);
str = g_strdup_printf("%d", g_fs_emu_lost_frames);
fs_emu_font_render(menu_font, str, 420, 3, 1.0, 1.0, 1.0, 1.0);
g_free(str);
str = g_strdup_printf("%d", g_fs_emu_repeated_frames);
fs_emu_font_render(menu_font, str, 620, 3, 1.0, 1.0, 1.0, 1.0);
g_free(str);
fs_emu_font_render(menu_font, "SYS", 20, 140, 1.0, 1.0, 1.0, 1.0);
str = g_strdup_printf("%0.1f", fs_emu_get_average_sys_fps());
fs_emu_font_render(menu_font, str, 220, 140, 1.0, 1.0, 1.0, 1.0);
g_free(str);
str = g_strdup_printf("%d", g_fs_emu_lost_vblanks);
fs_emu_font_render(menu_font, str, 420, 140, 1.0, 1.0, 1.0, 1.0);
g_free(str);
glPopMatrix();
CHECK_GL_ERROR();
}
if (fs_emu_is_quitting()) {
handle_quit_sequence();
}
fs_emu_video_render_mutex_unlock();
}
//28.
// the entry point for any Windows program
//29.
int WINAPI WinMain(HINSTANCE hInstance,
//30.
HINSTANCE hPrevInstance,
//31.
LPSTR lpCmdLine,
//32.
int nCmdShow)
//33.
{
//34.
HWND hWnd;
//35.
WNDCLASSEX wc;
//36.
//37.
ZeroMemory(&wc, sizeof(WNDCLASSEX));
//38.
//39.
wc.cbSize = sizeof(WNDCLASSEX);
//40.
wc.style = CS_HREDRAW | CS_VREDRAW;
//41.
wc.lpfnWndProc = WindowProc;
//42.
wc.hInstance = hInstance;
//43.
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
//44.
// wc.hbrBackground = (HBRUSH)COLOR_WINDOW; // not needed any more
//45.
wc.lpszClassName = "WindowClass";
//46.
//47.
RegisterClassEx(&wc);
//48.
//49.
hWnd = CreateWindowEx(NULL,
//50.
"WindowClass",
//51.
"Our Direct3D Program",
//52.
WS_EX_TOPMOST | WS_POPUP, // fullscreen values
//53.
0, 0, // the starting x and y positions should be 0
//54.
SCREEN_WIDTH, SCREEN_HEIGHT, // set the window to 640 x 480
//55.
NULL,
//56.
NULL,
//57.
hInstance,
//58.
NULL);
//59.
//60.
ShowWindow(hWnd, nCmdShow);
//61.
//62.
// set up and initialize Direct3D
//63.
initD3D(hWnd);
//64.
//65.
// enter the main loop:
//66.
//67.
MSG msg;
//68.
//69.
while(TRUE)
//70.
{
//71.
while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
//72.
{
//73.
TranslateMessage(&msg);
//74.
DispatchMessage(&msg);
//75.
}
//76.
//77.
if(msg.message == WM_QUIT)
//78.
break;
//79.
//80.
render_frame();
//81.
//82.
// check the 'escape' key
//83.
if(KEY_DOWN(VK_ESCAPE))
//84.
PostMessage(hWnd, WM_DESTROY, 0, 0);
//85.
}
//86.
//87.
// clean up DirectX and COM
//88.
cleanD3D();
//89.
//90.
return msg.wParam;
//91.
}
