413 lines
8.8 KiB
C++
413 lines
8.8 KiB
C++
|
|
/*****************************************************************************
|
|
* name: cl_cin_console.cpp
|
|
*
|
|
* desc: video and cinematic playback interface for Xbox (using Bink)
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#include "client.h"
|
|
#include "../win32/win_local.h"
|
|
#include "../win32/win_input.h"
|
|
#include "BinkVideo.h"
|
|
|
|
#define XBOX_VIDEO_PATH "d:\\base\\video\\"
|
|
|
|
BinkVideo bVideo; // bink video object
|
|
connstate_t previousState = CA_UNINITIALIZED; // previous cinematic state
|
|
|
|
struct CinematicData
|
|
{
|
|
char filename[MAX_OSPATH]; // No path, no extension
|
|
int x, y, w, h; // Dimensions
|
|
int bits; // Flags (loop, silent, shader)
|
|
};
|
|
|
|
// We have a fixed lookup table of all cinematics that can be played
|
|
// Video handles are just indices into the array. An entry is not
|
|
// considered initialized until its width is nonzero
|
|
CinematicData cinFiles[] = {
|
|
// Opening logos
|
|
{ "logos", 0, 0, 0, 0, 0 },
|
|
|
|
// Planet shaders
|
|
{ "cos", 0, 0, 0, 0, 0 },
|
|
{ "bakura", 0, 0, 0, 0, 0 },
|
|
{ "blenjeel", 0, 0, 0, 0, 0 },
|
|
{ "chandrila", 0, 0, 0, 0, 0 },
|
|
{ "core", 0, 0, 0, 0, 0 },
|
|
{ "ast", 0, 0, 0, 0, 0 },
|
|
{ "dosunn", 0, 0, 0, 0, 0 },
|
|
{ "krildor", 0, 0, 0, 0, 0 },
|
|
{ "narkreeta", 0, 0, 0, 0, 0 },
|
|
{ "ordman", 0, 0, 0, 0, 0 },
|
|
{ "tanaab", 0, 0, 0, 0, 0 },
|
|
{ "tatooine", 0, 0, 0, 0, 0 },
|
|
{ "yalara", 0, 0, 0, 0, 0 },
|
|
{ "zonju", 0, 0, 0, 0, 0 },
|
|
|
|
// Others
|
|
// { "jk1", 0, 0, 0, 0, 0 },
|
|
// { "jk2", 0, 0, 0, 0, 0 },
|
|
// { "jk3", 0, 0, 0, 0, 0 },
|
|
// { "jk4", 0, 0, 0, 0, 0 },
|
|
// { "jk5", 0, 0, 0, 0, 0 },
|
|
};
|
|
|
|
const int cinNumFiles = sizeof(cinFiles) / sizeof(cinFiles[0]);
|
|
static int currentHandle = -1;
|
|
|
|
/********
|
|
CIN_CloseAllVideos
|
|
Stops all currently running videos
|
|
*********/
|
|
void CIN_CloseAllVideos(void)
|
|
{
|
|
// Stop the current bink video
|
|
bVideo.Stop();
|
|
currentHandle = -1;
|
|
}
|
|
|
|
/********
|
|
CIN_StopCinematic
|
|
|
|
handle - Not used
|
|
return - FMV status
|
|
|
|
Stops the current cinematic
|
|
*********/
|
|
e_status CIN_StopCinematic(int handle)
|
|
{
|
|
assert( handle == currentHandle );
|
|
currentHandle = -1;
|
|
|
|
if(previousState != CA_UNINITIALIZED)
|
|
{
|
|
cls.state = previousState;
|
|
previousState = CA_UNINITIALIZED;
|
|
}
|
|
if(bVideo.GetStatus() != NS_BV_STOPPED)
|
|
{
|
|
bVideo.Stop();
|
|
}
|
|
return FMV_EOF;
|
|
}
|
|
|
|
/********
|
|
CIN_RunCinematic
|
|
|
|
handle - Ensure that the supplied cinematic is the one running
|
|
return - FMV status
|
|
|
|
Fetch and decompress the pending frame
|
|
*********/
|
|
e_status CIN_RunCinematic (int handle)
|
|
{
|
|
if (handle < 0 || handle >= cinNumFiles || !cinFiles[handle].w)
|
|
{
|
|
assert( 0 );
|
|
return FMV_EOF;
|
|
}
|
|
|
|
// If we weren't playing a movie, or playing the wrong one - start up
|
|
if (handle != currentHandle)
|
|
{
|
|
CIN_StopCinematic(currentHandle);
|
|
if (!bVideo.Start(
|
|
va(XBOX_VIDEO_PATH "%s.bik", cinFiles[handle].filename),
|
|
cinFiles[handle].x, cinFiles[handle].y,
|
|
cinFiles[handle].w, cinFiles[handle].h))
|
|
{
|
|
return FMV_EOF;
|
|
}
|
|
|
|
if (cinFiles[handle].bits & CIN_loop)
|
|
{
|
|
bVideo.SetLooping(true);
|
|
}
|
|
else
|
|
{
|
|
bVideo.SetLooping(false);
|
|
}
|
|
|
|
if (cinFiles[handle].bits & CIN_silent)
|
|
{
|
|
bVideo.SetMasterVolume(0);
|
|
}
|
|
else
|
|
{
|
|
bVideo.SetMasterVolume(32768); // Default Bink volume
|
|
}
|
|
|
|
if (!(cinFiles[handle].bits & CIN_shader))
|
|
{
|
|
previousState = cls.state;
|
|
cls.state = CA_CINEMATIC;
|
|
}
|
|
|
|
currentHandle = handle;
|
|
}
|
|
|
|
// Normal case does nothing here
|
|
if(bVideo.GetStatus() == NS_BV_STOPPED)
|
|
{
|
|
return FMV_EOF;
|
|
}
|
|
else
|
|
{
|
|
return FMV_PLAY;
|
|
}
|
|
}
|
|
|
|
/********
|
|
CIN_PlayCinematic
|
|
|
|
arg0 - filename of bink video
|
|
xpos - x origin
|
|
ypos - y origin
|
|
width - width of the movie window
|
|
height - height of the movie window
|
|
bits - CIN flags
|
|
psAudioFile - audio file for movie (not used)
|
|
|
|
Starts playing the given bink video file
|
|
*********/
|
|
#ifdef _JK2MP
|
|
int CIN_PlayCinematic( const char *arg0, int xpos, int ypos, int width, int height, int bits)
|
|
#else
|
|
int CIN_PlayCinematic( const char *arg0, int xpos, int ypos, int width, int height, int bits, const char *psAudioFile /* = NULL */)
|
|
#endif
|
|
{
|
|
// char name[MAX_OSPATH];
|
|
char arg[MAX_OSPATH];
|
|
char* nameonly;
|
|
int handle;
|
|
|
|
// get a local copy of the name
|
|
strcpy(arg,arg0);
|
|
|
|
// remove path, find in list
|
|
nameonly = COM_SkipPath(arg);
|
|
for (handle = 0; handle < cinNumFiles; ++handle)
|
|
{
|
|
if (!Q_stricmp(cinFiles[handle].filename, nameonly))
|
|
break;
|
|
}
|
|
|
|
// Don't have the requested movie in our table?
|
|
if (handle == cinNumFiles)
|
|
{
|
|
Com_Printf( "ERROR: Movie file %s not found!\n", nameonly );
|
|
return -1;
|
|
}
|
|
|
|
// Store off information about the movie in the right place. Don't
|
|
// actually play them movie, CIN_RunCinematic takes care of that.
|
|
cinFiles[handle].x = xpos;
|
|
cinFiles[handle].y = ypos;
|
|
cinFiles[handle].w = width;
|
|
cinFiles[handle].h = height;
|
|
cinFiles[handle].bits = bits;
|
|
currentHandle = -1;
|
|
return handle;
|
|
}
|
|
|
|
/*********
|
|
CIN_SetExtents
|
|
|
|
handle - handle to a video (not used)
|
|
x - x origin for window
|
|
y - y origin for window
|
|
w - width for window
|
|
h - height for window
|
|
*********/
|
|
void CIN_SetExtents (int handle, int x, int y, int w, int h)
|
|
{
|
|
if (handle < 0 || handle >= cinNumFiles)
|
|
return;
|
|
|
|
cinFiles[handle].x = x;
|
|
cinFiles[handle].y = y;
|
|
cinFiles[handle].w = w;
|
|
cinFiles[handle].h = h;
|
|
|
|
if (handle == currentHandle)
|
|
bVideo.SetExtents(x,y,w,h);
|
|
}
|
|
|
|
/********
|
|
CIN_DrawCinematic
|
|
|
|
handle - handle to a video (not used)
|
|
|
|
Updates the current frame of the current video
|
|
*********/
|
|
void CIN_DrawCinematic (int handle)
|
|
{
|
|
assert( handle == currentHandle );
|
|
|
|
bVideo.Run();
|
|
}
|
|
|
|
/*********
|
|
SCR_DrawCinematic
|
|
*********/
|
|
void SCR_DrawCinematic (void)
|
|
{
|
|
CIN_DrawCinematic(currentHandle);
|
|
}
|
|
/*********
|
|
SCR_RunCinematic
|
|
*********/
|
|
void SCR_RunCinematic (void)
|
|
{
|
|
// This is called every frame, even when we're not playing a movie
|
|
if (currentHandle > 0 && currentHandle < cinNumFiles)
|
|
CIN_RunCinematic(currentHandle);
|
|
}
|
|
|
|
/*********
|
|
SCR_StopCinematic
|
|
*********/
|
|
#ifdef _JK2MP
|
|
void SCR_StopCinematic(void)
|
|
#else
|
|
void SCR_StopCinematic(qboolean bAllowRefusal /* = qfalse */)
|
|
#endif
|
|
{
|
|
CIN_StopCinematic(currentHandle);
|
|
}
|
|
|
|
/*********
|
|
CIN_UploadCinematic
|
|
|
|
handle - (not used)
|
|
|
|
This function can be used to render a frame of a movie, if
|
|
it needs to be done outside of CA_CINEMATIC. For example,
|
|
a menu background or wall texture.
|
|
*********/
|
|
void CIN_UploadCinematic(int handle)
|
|
{
|
|
int w, h;
|
|
byte* data;
|
|
|
|
assert( handle == currentHandle );
|
|
|
|
if(!bVideo.Ready()) {
|
|
return;
|
|
}
|
|
|
|
w = bVideo.GetBinkWidth();
|
|
h = bVideo.GetBinkHeight();
|
|
data = (byte*)bVideo.GetBinkData();
|
|
|
|
// handle is actually being used to pick from scratchImages in
|
|
// this function - we only have two on Xbox, let's just use one.
|
|
//re.UploadCinematic( w, h, data, handle, 1);
|
|
re.UploadCinematic( w, h, data, 0, 1);
|
|
}
|
|
|
|
/*********
|
|
CIN_PlayAllFrames
|
|
|
|
arg - bink video filename
|
|
x - x origin for movie
|
|
y - y origin for movie
|
|
w - width of the movie
|
|
h - height of the movie
|
|
systemBits - bit rate for movie
|
|
keyBreakAllowed - if true, button press will end playback
|
|
|
|
Plays the target movie in full
|
|
*********/
|
|
bool CIN_PlayAllFrames( const char *arg, int x, int y, int w, int h, int systemBits, bool keyBreakAllowed )
|
|
{
|
|
bool retval;
|
|
Key_ClearStates();
|
|
|
|
#ifdef _JK2MP
|
|
int Handle = CIN_PlayCinematic(arg, x, y, w, h, systemBits);
|
|
#else
|
|
int Handle = CIN_PlayCinematic(arg, x, y, w, h, systemBits, NULL);
|
|
#endif
|
|
if (Handle != -1)
|
|
{
|
|
while (CIN_RunCinematic(Handle) == FMV_PLAY && !(keyBreakAllowed && kg.anykeydown))
|
|
{
|
|
SCR_UpdateScreen ();
|
|
IN_Frame ();
|
|
Com_EventLoop ();
|
|
}
|
|
#ifdef _XBOX
|
|
while (CIN_RunCinematic(Handle) == FMV_PLAY && !(keyBreakAllowed && !kg.anykeydown))
|
|
{
|
|
SCR_UpdateScreen ();
|
|
IN_Frame ();
|
|
Com_EventLoop ();
|
|
}
|
|
#endif
|
|
CIN_StopCinematic(Handle);
|
|
}
|
|
|
|
retval =(keyBreakAllowed && kg.anykeydown);
|
|
Key_ClearStates();
|
|
return retval;
|
|
}
|
|
|
|
/*********
|
|
CIN_Init
|
|
Initializes cinematic system
|
|
*********/
|
|
void CIN_Init(void)
|
|
{
|
|
// Allocate Memory for Bink System
|
|
bVideo.AllocateXboxMem();
|
|
}
|
|
|
|
/********
|
|
CIN_Shutdown
|
|
Shutdown the cinematic system
|
|
********/
|
|
void CIN_Shutdown(void)
|
|
{
|
|
// Free Memory for the Bink System
|
|
bVideo.FreeXboxMem();
|
|
}
|
|
|
|
|
|
/***** Possible FIXME *****/
|
|
/***** The following function may need to be implemented *****/
|
|
/***** BEGIN *****/
|
|
void CL_PlayCinematic_f(void)
|
|
{
|
|
char *arg;
|
|
|
|
arg = Cmd_Argv(1);
|
|
CIN_PlayAllFrames(arg, 48, 36, 544, 408, 0, true);
|
|
}
|
|
|
|
qboolean CL_IsRunningInGameCinematic(void)
|
|
{
|
|
// Nothing
|
|
return qfalse;
|
|
}
|
|
|
|
qboolean CL_CheckPendingCinematic(void)
|
|
{
|
|
// Nothing
|
|
return qfalse;
|
|
}
|
|
|
|
void CL_PlayInGameCinematic_f(void)
|
|
{
|
|
// Nothing
|
|
}
|
|
|
|
qboolean CL_InGameCinematicOnStandBy(void)
|
|
{
|
|
// Nothing
|
|
return qfalse;
|
|
}
|
|
/***** END *****/
|
|
|