void I_FinishUpdate (void)
{
int h = 200;
int w = 320;
int step = 512;
unsigned char *srcmain = screens[0].data;
unsigned char *destmain = NULL;
destmain = (unsigned char *)BG_GFX;
for (; h>0; h--)
{
dmaCopy(srcmain, destmain, w);
destmain += step;
srcmain += SCREENWIDTH;
}
// Update the display buffer (flipping video pages if supported)
// If we need to change palette, that implicitely does a flip
if (newpal != NO_PALETTE_CHANGE) {
I_UploadNewPalette(newpal);
newpal = NO_PALETTE_CHANGE;
}
}
//
// I_SetPalette
//
void I_SetPalette (int pal)
{
if (!INITIALISED) return;
if (true_color) {
int lump = W_GetNumForName("PLAYPAL");
const byte *palette = W_CacheLumpNum(lump);
I_SetPaletteTranslation(palette + (3*256)*pal);
W_UnlockLumpNum(lump);
} else
I_UploadNewPalette(pal);
}
void I_FinishUpdate (void)
{
if (I_SkipFrame()) return;
#ifdef MONITOR_VISIBILITY
if (!(SDL_GetAppState()&SDL_APPACTIVE)) {
return;
}
#endif
#ifdef GL_DOOM
if (V_GetMode() == VID_MODEGL) {
// proff 04/05/2000: swap OpenGL buffers
gld_Finish();
return;
}
#endif
/* Vladimir
if (SDL_MUSTLOCK(screen)) {
int h;
byte *src;
byte *dest;
if (SDL_LockSurface(screen) < 0) {
lprintf(LO_INFO,"I_FinishUpdate: %s\n", SDL_GetError());
return;
}
dest=screen->pixels;
src=screens[0].data;
h=screen->h;
for (; h>0; h--)
{
memcpy(dest,src,SCREENWIDTH*V_GetPixelDepth());
dest+=screen->pitch;
src+=screens[0].byte_pitch;
}
SDL_UnlockSurface(screen);
}
*/
/* Update the display buffer (flipping video pages if supported)
* If we need to change palette, that implicitely does a flip */
if (newpal != NO_PALETTE_CHANGE) {
I_UploadNewPalette(newpal);
newpal = NO_PALETTE_CHANGE;
}
// Vladimir SDL_Flip(screen);
//JNI_UpdateRect(screen);
JNI_Flip(screens[0].data, SCREENWIDTH, SCREENHEIGHT, colours);
}
void I_FinishUpdate (void)
{
static u64 lasttic = 0;
u64 now, frametics;
int height, width;
u32 *bufAdr;
int w, h;
/* Update the display buffer (flipping video pages if supported)
* If we need to change palette, that implicitely does a flip */
if (newpal != NO_PALETTE_CHANGE) {
I_UploadNewPalette(newpal);
newpal = NO_PALETTE_CHANGE;
}
height=screens[0].height;
width=screens[0].width;
bufAdr=(u32*)gfxGetFramebuffer(GFX_TOP, GFX_LEFT, NULL, NULL);
for (h=0; h<height; h++)
{
u32 *dest=&bufAdr[239-h];
u8 *src=screens[0].data + (h * screens[0].byte_pitch);
__builtin_prefetch(src);
for (w=0; w<width; w++)
{
*(dest)=palettes[(*src++) + currentPalette];
dest += 240;
}
}
gspWaitForVBlank();
gfxSwapBuffers();
gfxFlushBuffers();
now = svcGetSystemTick();
frametics = now - lasttic;
lasttic = now;
}
void I_FinishUpdate (void)
{
if (I_SkipFrame()) return;
#ifndef GL_DOOM
int h = 200;
int w = 320;
int step = 512;
unsigned char *srcmain = screens[0];
unsigned char *srcsub = screens[1];
unsigned char *destmain = NULL, *destsub = NULL;
// Jefklak 19/11/06 - sub screen rendering
destmain = (unsigned char *)BG_GFX;
if(!gen_console_enable)
destsub = (unsigned char *)BG_GFX_SUB;
for (; h>0; h--)
{
dmaCopy(srcmain, destmain, w);
destmain += step;
srcmain += SCREENWIDTH;
if(!gen_console_enable)
{
// dmaCopy() uses DMA_CR(3) with syncs
dmaCopy(srcsub, destsub, w);
destsub += step;
srcsub += SCREENWIDTH;
}
}
// Update the display buffer (flipping video pages if supported)
// If we need to change palette, that implicitely does a flip
if (newpal != NO_PALETTE_CHANGE) {
I_UploadNewPalette(newpal);
newpal = NO_PALETTE_CHANGE;
}
#else
// proff 04/05/2000: swap OpenGL buffers
gld_Finish();
#endif
}
void I_InitGraphics(void)
{
char titlebuffer[2048];
static int firsttime=1;
if (firsttime)
{
firsttime = 0;
atexit(I_ShutdownGraphics);
lprintf(LO_INFO, "I_InitGraphics: %dx%d\n", SCREENWIDTH, SCREENHEIGHT);
/* Set the video mode */
I_UpdateVideoMode();
/* Initialize palette */
I_UploadNewPalette(0);
/* Initialize the input system */
I_InitInputs();
}
}
void I_FinishUpdate (void)
{
if (I_SkipFrame()) return;
// TODO: use enums for screen numbers and apply them where appropriate
// main game on top screen (TODO: both sides)
I_TranslateFrameBuffer(SCR_FRONT_L, GFX_TOP, GFX_LEFT, -1, -1);
// I_TranslateFrameBuffer(SCR_FRONT_R, GFX_TOP, GFX_RIGHT, -1, -1);
// automap on bottom screen
I_TranslateFrameBuffer(SCR_BOTTOM, GFX_BOTTOM, 0, -1, -1);
/* Update the display buffer (flipping video pages if supported)
* If we need to change palette, that implicitely does a flip */
if (newpal != NO_PALETTE_CHANGE) {
I_UploadNewPalette(newpal);
newpal = NO_PALETTE_CHANGE;
}
gfxFlushBuffers();
gfxSwapBuffers();
gspWaitForVBlank();
}
void I_FinishUpdate (void)
{
//e6y: new mouse code
UpdateGrab();
// The screen wipe following pressing the exit switch on a level
// is noticably jerkier with I_SkipFrame
// if (I_SkipFrame())return;
#ifdef MONITOR_VISIBILITY
if (!(SDL_GetAppState()&SDL_APPACTIVE)) {
return;
}
#endif
#ifdef GL_DOOM
if (V_GetMode() == VID_MODEGL) {
// proff 04/05/2000: swap OpenGL buffers
gld_Finish();
return;
}
#endif
if ((screen_multiply > 1) || SDL_MUSTLOCK(screen)) {
int h;
byte *src;
byte *dest;
if (SDL_LockSurface(screen) < 0) {
lprintf(LO_INFO,"I_FinishUpdate: %s\n", SDL_GetError());
return;
}
// e6y: processing of screen_multiply
if (screen_multiply > 1)
{
R_ProcessScreenMultiply(screens[0].data, screen->pixels,
V_GetPixelDepth(), screens[0].byte_pitch, screen->pitch);
}
else
{
dest=screen->pixels;
src=screens[0].data;
h=screen->h;
for (; h>0; h--)
{
memcpy_fast(dest,src,SCREENWIDTH*V_GetPixelDepth()); //e6y
dest+=screen->pitch;
src+=screens[0].byte_pitch;
}
}
SDL_UnlockSurface(screen);
}
/* Update the display buffer (flipping video pages if supported)
* If we need to change palette, that implicitely does a flip */
if (newpal != NO_PALETTE_CHANGE) {
I_UploadNewPalette(newpal, false);
newpal = NO_PALETTE_CHANGE;
}
#ifdef GL_DOOM
if (vid_8ingl.enabled)
{
gld_Draw8InGL();
}
else
#endif
{
SDL_Flip(screen);
}
}
void I_UpdateVideoMode(void)
{
int init_flags;
if(screen)
{
// video capturing cannot be continued with new screen settings
I_CaptureFinish();
#ifdef GL_DOOM
if (V_GetMode() == VID_MODEGL)
{
gld_CleanMemory();
// hires patches
gld_CleanStaticMemory();
}
#endif
I_InitScreenResolution();
SDL_FreeSurface(screen);
screen = NULL;
#ifdef GL_DOOM
if (vid_8ingl.surface)
{
SDL_FreeSurface(vid_8ingl.surface);
vid_8ingl.surface = NULL;
}
#endif
SMP_Free();
}
// e6y: initialisation of screen_multiply
screen_multiply = render_screen_multiply;
// Initialize SDL with this graphics mode
if (V_GetMode() == VID_MODEGL) {
init_flags = SDL_OPENGL;
} else {
if (use_doublebuffer)
init_flags = SDL_DOUBLEBUF;
else
init_flags = SDL_SWSURFACE;
#ifndef PRBOOM_DEBUG
init_flags |= SDL_HWPALETTE;
#endif
}
if ( desired_fullscreen )
init_flags |= SDL_FULLSCREEN;
// In windowed mode, the window can be resized while the game is
// running. This feature is disabled on OS X, as it adds an ugly
// scroll handle to the corner of the screen.
#ifndef MACOSX
if (!desired_fullscreen)
init_flags |= SDL_RESIZABLE;
#endif
if (sdl_video_window_pos && sdl_video_window_pos[0])
{
char buf[80];
strcpy(buf, "SDL_VIDEO_WINDOW_POS=");
strncat(buf, sdl_video_window_pos, sizeof(buf) - sizeof(buf[0]) - strlen(buf));
putenv(buf);
}
#ifdef GL_DOOM
vid_8ingl.enabled = false;
#endif
if (V_GetMode() == VID_MODEGL)
{
#ifdef GL_DOOM
SDL_GL_SetAttribute( SDL_GL_RED_SIZE, 0 );
SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, 0 );
SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, 0 );
SDL_GL_SetAttribute( SDL_GL_ALPHA_SIZE, 0 );
SDL_GL_SetAttribute( SDL_GL_STENCIL_SIZE, 0 );
SDL_GL_SetAttribute( SDL_GL_ACCUM_RED_SIZE, 0 );
SDL_GL_SetAttribute( SDL_GL_ACCUM_GREEN_SIZE, 0 );
SDL_GL_SetAttribute( SDL_GL_ACCUM_BLUE_SIZE, 0 );
SDL_GL_SetAttribute( SDL_GL_ACCUM_ALPHA_SIZE, 0 );
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
SDL_GL_SetAttribute( SDL_GL_BUFFER_SIZE, gl_colorbuffer_bits );
SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, gl_depthbuffer_bits );
SDL_GL_SetAttribute( SDL_GL_STENCIL_SIZE, 8 );
//e6y: vertical sync
#if !SDL_VERSION_ATLEAST(1, 3, 0)
SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, (gl_vsync ? 1 : 0));
#endif
//e6y: anti-aliasing
gld_MultisamplingInit();
screen = SDL_SetVideoMode(REAL_SCREENWIDTH, REAL_SCREENHEIGHT, gl_colorbuffer_bits, init_flags);
gld_CheckHardwareGamma();
#endif
}
else
{
#ifdef GL_DOOM
if (use_gl_surface)
{
int flags = SDL_OPENGL;
if ( desired_fullscreen )
flags |= SDL_FULLSCREEN;
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
SDL_GL_SetAttribute( SDL_GL_BUFFER_SIZE, gl_colorbuffer_bits );
SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, gl_depthbuffer_bits );
//e6y: vertical sync
#if !SDL_VERSION_ATLEAST(1, 3, 0)
SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, (gl_vsync ? 1 : 0));
#endif
vid_8ingl.surface = SDL_SetVideoMode(
REAL_SCREENWIDTH, REAL_SCREENHEIGHT,
gl_colorbuffer_bits, flags);
if(vid_8ingl.surface == NULL)
I_Error("Couldn't set %dx%d video mode [%s]", REAL_SCREENWIDTH, REAL_SCREENHEIGHT, SDL_GetError());
screen = SDL_CreateRGBSurface(
init_flags & ~SDL_FULLSCREEN,
REAL_SCREENWIDTH, REAL_SCREENHEIGHT,
V_GetNumPixelBits(), 0, 0, 0, 0);
vid_8ingl.screen = screen;
vid_8ingl.enabled = true;
}
else
#endif
{
screen = SDL_SetVideoMode(REAL_SCREENWIDTH, REAL_SCREENHEIGHT, V_GetNumPixelBits(), init_flags);
}
}
if(screen == NULL) {
I_Error("Couldn't set %dx%d video mode [%s]", REAL_SCREENWIDTH, REAL_SCREENHEIGHT, SDL_GetError());
}
SMP_Init();
#if SDL_VERSION_ATLEAST(1, 3, 0)
#ifdef GL_DOOM
if (V_GetMode() == VID_MODEGL)
{
SDL_GL_SetSwapInterval((gl_vsync ? 1 : 0));
}
#endif
#endif
#ifdef GL_DOOM
/*if (V_GetMode() == VID_MODEGL)
gld_MultisamplingCheck();*/
#endif
lprintf(LO_INFO, "I_UpdateVideoMode: 0x%x, %s, %s\n", init_flags, screen->pixels ? "SDL buffer" : "own buffer", SDL_MUSTLOCK(screen) ? "lock-and-copy": "direct access");
// Get the info needed to render to the display
if (screen_multiply==1 && !SDL_MUSTLOCK(screen))
{
screens[0].not_on_heap = true;
screens[0].data = (unsigned char *) (screen->pixels);
screens[0].byte_pitch = screen->pitch;
screens[0].short_pitch = screen->pitch / V_GetModePixelDepth(VID_MODE16);
screens[0].int_pitch = screen->pitch / V_GetModePixelDepth(VID_MODE32);
}
else
{
screens[0].not_on_heap = false;
}
V_AllocScreens();
R_InitBuffer(SCREENWIDTH, SCREENHEIGHT);
// e6y: wide-res
// Need some initialisations before level precache
R_ExecuteSetViewSize();
V_SetPalette(0);
I_UploadNewPalette(0, true);
ST_SetResolution();
AM_SetResolution();
#ifdef GL_DOOM
if (V_GetMode() == VID_MODEGL)
{
int temp;
lprintf(LO_INFO,"SDL OpenGL PixelFormat:\n");
SDL_GL_GetAttribute( SDL_GL_RED_SIZE, &temp );
lprintf(LO_INFO," SDL_GL_RED_SIZE: %i\n",temp);
SDL_GL_GetAttribute( SDL_GL_GREEN_SIZE, &temp );
lprintf(LO_INFO," SDL_GL_GREEN_SIZE: %i\n",temp);
SDL_GL_GetAttribute( SDL_GL_BLUE_SIZE, &temp );
lprintf(LO_INFO," SDL_GL_BLUE_SIZE: %i\n",temp);
SDL_GL_GetAttribute( SDL_GL_STENCIL_SIZE, &temp );
lprintf(LO_INFO," SDL_GL_STENCIL_SIZE: %i\n",temp);
SDL_GL_GetAttribute( SDL_GL_ACCUM_RED_SIZE, &temp );
lprintf(LO_INFO," SDL_GL_ACCUM_RED_SIZE: %i\n",temp);
SDL_GL_GetAttribute( SDL_GL_ACCUM_GREEN_SIZE, &temp );
lprintf(LO_INFO," SDL_GL_ACCUM_GREEN_SIZE: %i\n",temp);
SDL_GL_GetAttribute( SDL_GL_ACCUM_BLUE_SIZE, &temp );
lprintf(LO_INFO," SDL_GL_ACCUM_BLUE_SIZE: %i\n",temp);
SDL_GL_GetAttribute( SDL_GL_ACCUM_ALPHA_SIZE, &temp );
lprintf(LO_INFO," SDL_GL_ACCUM_ALPHA_SIZE: %i\n",temp);
SDL_GL_GetAttribute( SDL_GL_DOUBLEBUFFER, &temp );
lprintf(LO_INFO," SDL_GL_DOUBLEBUFFER: %i\n",temp);
SDL_GL_GetAttribute( SDL_GL_BUFFER_SIZE, &temp );
lprintf(LO_INFO," SDL_GL_BUFFER_SIZE: %i\n",temp);
SDL_GL_GetAttribute( SDL_GL_DEPTH_SIZE, &temp );
lprintf(LO_INFO," SDL_GL_DEPTH_SIZE: %i\n",temp);
SDL_GL_GetAttribute( SDL_GL_MULTISAMPLESAMPLES, &temp );
lprintf(LO_INFO," SDL_GL_MULTISAMPLESAMPLES: %i\n",temp);
SDL_GL_GetAttribute( SDL_GL_MULTISAMPLEBUFFERS, &temp );
lprintf(LO_INFO," SDL_GL_MULTISAMPLEBUFFERS: %i\n",temp);
SDL_GL_GetAttribute( SDL_GL_STENCIL_SIZE, &temp );
lprintf(LO_INFO," SDL_GL_STENCIL_SIZE: %i\n",temp);
gld_Init(SCREENWIDTH, SCREENHEIGHT);
}
if (vid_8ingl.enabled)
{
gld_Init8InGLMode();
}
if (V_GetMode() == VID_MODEGL)
{
M_ChangeFOV();
M_ChangeRenderPrecise();
deh_changeCompTranslucency();
}
#endif
}
