/******************************************************************************
|
|
@file Shell/PVRShell.cpp
|
@copyright Copyright (c) Imagination Technologies Limited.
|
@brief Makes programming for 3D APIs easier by wrapping surface
|
initialization, Texture allocation and other functions for use by a demo.
|
|
******************************************************************************/
|
|
#include <stdio.h>
|
#include <stdlib.h>
|
#include <string.h>
|
#include <stdarg.h>
|
#include <math.h>
|
|
#include "PVRShell.h"
|
#include "PVRShellOS.h"
|
#include "PVRShellAPI.h"
|
#include "PVRShellImpl.h"
|
|
/*! This file simply defines a version string. It can be commented out. */
|
#include "sdkver.h"
|
#ifndef PVRSDK_VERSION
|
#define PVRSDK_VERSION "n.nn.nn.nnnn"
|
#endif
|
|
/*! Define to automatically stop the app after x frames. If negative, run forever. */
|
#ifndef PVRSHELL_QUIT_AFTER_FRAME
|
#define PVRSHELL_QUIT_AFTER_FRAME -1
|
#endif
|
|
/*! Define to automatically stop the app after x amount of seconds. If negative, run forever. */
|
#ifndef PVRSHELL_QUIT_AFTER_TIME
|
#define PVRSHELL_QUIT_AFTER_TIME -1
|
#endif
|
|
/*! Define for the screen shot file name. */
|
#define PVRSHELL_SCREENSHOT_NAME "PVRShell"
|
|
#if defined(_WIN32)
|
#define snprintf _snprintf
|
#endif
|
|
// No Doxygen for CPP files, due to documentation duplication
|
/// @cond NO_DOXYGEN
|
|
// Define DISABLE_SWIPE_MAPPING to disable the PVRShell's simple mapping of swipes to key commands.
|
//#define DISABLE_SWIPE_MAPPING 1
|
/*****************************************************************************
|
** Prototypes
|
*****************************************************************************/
|
static bool StringCopy(char *&pszStr, const char * const pszSrc);
|
|
/****************************************************************************
|
** Class: PVRShell
|
****************************************************************************/
|
|
/*!***********************************************************************
|
@brief Constructor
|
*************************************************************************/
|
PVRShell::PVRShell()
|
{
|
m_pShellInit = NULL;
|
m_pShellData = new PVRShellData;
|
|
m_pShellData->nShellPosX=0;
|
m_pShellData->nShellPosY=0;
|
|
m_pShellData->bFullScreen = false; // note this may be overridden by some OS versions of PVRShell
|
|
m_pShellData->nAASamples= 0;
|
m_pShellData->nColorBPP = 0;
|
m_pShellData->nDepthBPP = 0;
|
|
m_pShellData->nDieAfterFrames = PVRSHELL_QUIT_AFTER_FRAME;
|
m_pShellData->fDieAfterTime = PVRSHELL_QUIT_AFTER_TIME;
|
|
m_pShellData->bNeedPbuffer = false;
|
m_pShellData->bNeedPixmap = false;
|
m_pShellData->bNeedPixmapDisableCopy = false;
|
m_pShellData->bNeedZbuffer = true;
|
m_pShellData->bLockableBackBuffer = false;
|
m_pShellData->bSoftwareRender = false;
|
m_pShellData->bNeedStencilBuffer = false;
|
|
m_pShellData->bNeedAlphaFormatPre = false;
|
m_pShellData->bUsingPowerSaving = true;
|
m_pShellData->bOutputInfo = false;
|
m_pShellData->bNoShellSwapBuffer = false;
|
|
m_pShellData->pszAppName = 0;
|
m_pShellData->pszExitMessage = 0;
|
|
m_pShellData->nSwapInterval = 1;
|
m_pShellData->nInitRepeats = 0;
|
|
m_pShellData->nCaptureFrameStart = -1;
|
m_pShellData->nCaptureFrameStop = -1;
|
m_pShellData->nCaptureFrameScale = 1;
|
|
m_pShellData->nPriority = 2;
|
|
m_pShellData->bForceFrameTime = false;
|
m_pShellData->nFrameTime = 33;
|
|
// Internal Data
|
m_pShellData->bShellPosWasDefault = true;
|
m_pShellData->nShellCurFrameNum = 0;
|
#ifdef PVRSHELL_FPS_OUTPUT
|
m_pShellData->bOutputFPS = false;
|
#endif
|
m_pShellData->bDiscardFrameColor=false;
|
m_pShellData->bDiscardFrameDepth=true;
|
m_pShellData->bDiscardFrameStencil=true;
|
}
|
|
/*!***********************************************************************
|
@brief Destructor
|
*************************************************************************/
|
PVRShell::~PVRShell()
|
{
|
delete m_pShellData;
|
m_pShellData = NULL;
|
}
|
|
// Allow user to set preferences from within InitApplication
|
|
/*!***********************************************************************
|
@brief This function is used to pass preferences to the PVRShell.
|
If used, this function must be called from InitApplication().
|
@param[in] prefName Name of preference to set to value
|
@param[in] value Value
|
@return true for success
|
*************************************************************************/
|
|
bool PVRShell::PVRShellSet(const prefNameBoolEnum prefName, const bool value)
|
{
|
switch(prefName)
|
{
|
case prefFullScreen:
|
m_pShellData->bFullScreen = value;
|
return true;
|
|
case prefPBufferContext:
|
m_pShellData->bNeedPbuffer = value;
|
return true;
|
|
case prefPixmapContext:
|
m_pShellData->bNeedPixmap = value;
|
return true;
|
|
case prefPixmapDisableCopy:
|
m_pShellData->bNeedPixmapDisableCopy = value;
|
return true;
|
|
case prefZbufferContext:
|
m_pShellData->bNeedZbuffer = value;
|
return true;
|
|
case prefLockableBackBuffer:
|
m_pShellData->bLockableBackBuffer = value;
|
return true;
|
|
case prefSoftwareRendering:
|
m_pShellData->bSoftwareRender = value;
|
return true;
|
|
case prefStencilBufferContext:
|
m_pShellData->bNeedStencilBuffer = value;
|
return true;
|
|
case prefAlphaFormatPre:
|
m_pShellData->bNeedAlphaFormatPre = value;
|
return true;
|
|
case prefPowerSaving:
|
m_pShellData->bUsingPowerSaving = value;
|
return true;
|
|
case prefOutputInfo:
|
m_pShellData->bOutputInfo = value;
|
return true;
|
|
case prefNoShellSwapBuffer:
|
m_pShellData->bNoShellSwapBuffer = value;
|
return true;
|
|
case prefForceFrameTime:
|
m_pShellData->bForceFrameTime = value;
|
return true;
|
|
#ifdef PVRSHELL_FPS_OUTPUT
|
case prefOutputFPS:
|
m_pShellData->bOutputFPS = value;
|
return true;
|
#endif
|
|
case prefDiscardColor:
|
m_pShellData->bDiscardFrameColor = value;
|
return true;
|
case prefDiscardDepth:
|
m_pShellData->bDiscardFrameDepth = value;
|
return true;
|
case prefDiscardStencil:
|
m_pShellData->bDiscardFrameStencil = value;
|
return true;
|
default:
|
return m_pShellInit->OsSet(prefName, value);
|
}
|
}
|
|
/*!***********************************************************************
|
@brief This function is used to get parameters from the PVRShell.
|
It can be called from anywhere in the program.
|
@param[in] prefName Name of preference to set to value
|
@return The requested value.
|
*************************************************************************/
|
|
bool PVRShell::PVRShellGet(const prefNameBoolEnum prefName) const
|
{
|
switch(prefName)
|
{
|
case prefFullScreen: return m_pShellData->bFullScreen;
|
case prefIsRotated: return (m_pShellData->nShellDimY > m_pShellData->nShellDimX);
|
case prefPBufferContext: return m_pShellData->bNeedPbuffer;
|
case prefPixmapContext: return m_pShellData->bNeedPixmap;
|
case prefPixmapDisableCopy: return m_pShellData->bNeedPixmapDisableCopy;
|
case prefZbufferContext: return m_pShellData->bNeedZbuffer;
|
case prefLockableBackBuffer: return m_pShellData->bLockableBackBuffer;
|
case prefSoftwareRendering: return m_pShellData->bSoftwareRender;
|
case prefNoShellSwapBuffer: return m_pShellData->bNoShellSwapBuffer;
|
case prefStencilBufferContext: return m_pShellData->bNeedStencilBuffer;
|
case prefAlphaFormatPre: return m_pShellData->bNeedAlphaFormatPre;
|
case prefPowerSaving: return m_pShellData->bUsingPowerSaving;
|
case prefOutputInfo: return m_pShellData->bOutputInfo;
|
case prefForceFrameTime: return m_pShellData->bForceFrameTime;
|
#ifdef PVRSHELL_FPS_OUTPUT
|
case prefOutputFPS: return m_pShellData->bOutputFPS;
|
#endif
|
case prefDiscardColor: return m_pShellData->bDiscardFrameColor;
|
case prefDiscardDepth: return m_pShellData->bDiscardFrameDepth;
|
case prefDiscardStencil: return m_pShellData->bDiscardFrameStencil;
|
default: return false;
|
}
|
}
|
|
/*!***********************************************************************
|
@brief This function is used to pass preferences to the PVRShell.
|
If used, this function must be called from InitApplication().
|
@param[in] prefName Name of preference to set to value
|
@param[in] value Value
|
@return true for success
|
*************************************************************************/
|
|
bool PVRShell::PVRShellSet(const prefNameFloatEnum prefName, const float value)
|
{
|
switch(prefName)
|
{
|
case prefQuitAfterTime:
|
m_pShellData->fDieAfterTime = value;
|
return true;
|
|
default:
|
break;
|
}
|
return false;
|
}
|
|
/*!***********************************************************************
|
@brief This function is used to get parameters from the PVRShell.
|
It can be called from anywhere in the program.
|
@param[in] prefName Name of preference to set to value
|
@return The requested value.
|
*************************************************************************/
|
float PVRShell::PVRShellGet(const prefNameFloatEnum prefName) const
|
{
|
switch(prefName)
|
{
|
case prefQuitAfterTime: return m_pShellData->fDieAfterTime;
|
default: return -1;
|
}
|
}
|
|
/*!***********************************************************************
|
@brief This function is used to pass preferences to the PVRShell.
|
If used, this function must be called from InitApplication().
|
@param[in] prefName Name of preference to set to value
|
@param[in] value Value
|
@return true for success
|
*************************************************************************/
|
bool PVRShell::PVRShellSet(const prefNameIntEnum prefName, const int value)
|
{
|
switch(prefName)
|
{
|
case prefWidth:
|
if(value > 0)
|
{
|
m_pShellData->nShellDimX = value;
|
return true;
|
}
|
return false;
|
|
case prefHeight:
|
if(value > 0)
|
{
|
m_pShellData->nShellDimY = value;
|
return true;
|
}
|
return false;
|
|
case prefPositionX:
|
m_pShellData->bShellPosWasDefault = false;
|
m_pShellData->nShellPosX = value;
|
return true;
|
|
case prefPositionY:
|
m_pShellData->bShellPosWasDefault = false;
|
m_pShellData->nShellPosY = value;
|
return true;
|
|
case prefQuitAfterFrame:
|
m_pShellData->nDieAfterFrames = value;
|
return true;
|
|
case prefInitRepeats:
|
m_pShellData->nInitRepeats = value;
|
return true;
|
|
case prefAASamples:
|
if(value >= 0)
|
{
|
m_pShellData->nAASamples = value;
|
return true;
|
}
|
return false;
|
|
case prefColorBPP:
|
if(value >= 0)
|
{
|
m_pShellData->nColorBPP = value;
|
return true;
|
}
|
return false;
|
|
case prefDepthBPP:
|
if(value >= 0)
|
{
|
m_pShellData->nDepthBPP = value;
|
return true;
|
}
|
return false;
|
|
case prefRotateKeys:
|
{
|
switch((PVRShellKeyRotate)value)
|
{
|
case PVRShellKeyRotateNone:
|
m_pShellInit->m_eKeyMapUP = PVRShellKeyNameUP;
|
m_pShellInit->m_eKeyMapLEFT = PVRShellKeyNameLEFT;
|
m_pShellInit->m_eKeyMapDOWN = PVRShellKeyNameDOWN;
|
m_pShellInit->m_eKeyMapRIGHT = PVRShellKeyNameRIGHT;
|
break;
|
case PVRShellKeyRotate90:
|
m_pShellInit->m_eKeyMapUP = PVRShellKeyNameLEFT;
|
m_pShellInit->m_eKeyMapLEFT = PVRShellKeyNameDOWN;
|
m_pShellInit->m_eKeyMapDOWN = PVRShellKeyNameRIGHT;
|
m_pShellInit->m_eKeyMapRIGHT = PVRShellKeyNameUP;
|
break;
|
case PVRShellKeyRotate180:
|
m_pShellInit->m_eKeyMapUP = PVRShellKeyNameDOWN;
|
m_pShellInit->m_eKeyMapLEFT = PVRShellKeyNameRIGHT;
|
m_pShellInit->m_eKeyMapDOWN = PVRShellKeyNameUP;
|
m_pShellInit->m_eKeyMapRIGHT = PVRShellKeyNameLEFT;
|
break;
|
case PVRShellKeyRotate270:
|
m_pShellInit->m_eKeyMapUP = PVRShellKeyNameRIGHT;
|
m_pShellInit->m_eKeyMapLEFT = PVRShellKeyNameUP;
|
m_pShellInit->m_eKeyMapDOWN = PVRShellKeyNameLEFT;
|
m_pShellInit->m_eKeyMapRIGHT = PVRShellKeyNameDOWN;
|
break;
|
default:
|
return false;
|
}
|
}
|
return true;
|
case prefCaptureFrameStart:
|
m_pShellData->nCaptureFrameStart = value;
|
return true;
|
case prefCaptureFrameStop:
|
m_pShellData->nCaptureFrameStop = value;
|
return true;
|
case prefCaptureFrameScale:
|
m_pShellData->nCaptureFrameScale = value;
|
return true;
|
case prefFrameTimeValue:
|
m_pShellData->nFrameTime = value;
|
return true;
|
default:
|
{
|
if(m_pShellInit->ApiSet(prefName, value))
|
return true;
|
|
return m_pShellInit->OsSet(prefName, value);
|
}
|
}
|
}
|
|
/*!***********************************************************************
|
@brief This function is used to get parameters from the PVRShell.
|
It can be called from anywhere in the program.
|
@param[in] prefName Name of preference to set to value
|
@return The requested value.
|
*************************************************************************/
|
int PVRShell::PVRShellGet(const prefNameIntEnum prefName) const
|
{
|
switch(prefName)
|
{
|
case prefWidth: return m_pShellData->nShellDimX;
|
case prefHeight: return m_pShellData->nShellDimY;
|
case prefPositionX: return m_pShellData->nShellPosX;
|
case prefPositionY: return m_pShellData->nShellPosY;
|
case prefQuitAfterFrame: return m_pShellData->nDieAfterFrames;
|
case prefSwapInterval: return m_pShellData->nSwapInterval;
|
case prefInitRepeats: return m_pShellData->nInitRepeats;
|
case prefAASamples: return m_pShellData->nAASamples;
|
case prefCommandLineOptNum: return m_pShellInit->m_CommandLine.m_nOptLen;
|
case prefColorBPP: return m_pShellData->nColorBPP;
|
case prefDepthBPP: return m_pShellData->nDepthBPP;
|
case prefCaptureFrameStart: return m_pShellData->nCaptureFrameStart;
|
case prefCaptureFrameStop: return m_pShellData->nCaptureFrameStop;
|
case prefCaptureFrameScale: return m_pShellData->nCaptureFrameScale;
|
case prefFrameTimeValue: return m_pShellData->nFrameTime;
|
case prefPriority: return m_pShellData->nPriority;
|
default:
|
{
|
int n;
|
|
if(m_pShellInit->ApiGet(prefName, &n))
|
return n;
|
if(m_pShellInit->OsGet(prefName, &n))
|
return n;
|
return -1;
|
}
|
}
|
}
|
|
/*!***********************************************************************
|
@brief This function is used to pass preferences to the PVRShell.
|
If used, this function must be called from InitApplication().
|
@param[in] prefName Name of preference to set to value
|
@param[in] value Value
|
@return true for success
|
*************************************************************************/
|
bool PVRShell::PVRShellSet(const prefNamePtrEnum prefName, const void * const ptrValue)
|
{
|
PVRSHELL_UNREFERENCED_PARAMETER(prefName);
|
PVRSHELL_UNREFERENCED_PARAMETER(ptrValue);
|
return false;
|
}
|
|
/*!***********************************************************************
|
@brief This function is used to get parameters from the PVRShell.
|
It can be called from anywhere in the program.
|
@param[in] prefName Name of preference to set to value
|
@return The requested value.
|
*************************************************************************/
|
void *PVRShell::PVRShellGet(const prefNamePtrEnum prefName) const
|
{
|
switch(prefName)
|
{
|
case prefNativeWindowType: return m_pShellInit->OsGetNativeWindowType();
|
case prefPointerLocation:
|
if (m_pShellInit->m_bTouching)
|
return m_pShellInit->m_vec2PointerLocation;
|
break;
|
default:
|
{
|
void *p;
|
|
if(m_pShellInit->ApiGet(prefName, &p))
|
return p;
|
if(m_pShellInit->OsGet(prefName, &p))
|
return p;
|
}
|
}
|
return NULL;
|
}
|
|
/*!***********************************************************************
|
@brief This function is used to pass preferences to the PVRShell.
|
If used, this function must be called from InitApplication().
|
@param[in] prefName Name of preference to set to value
|
@param[in] value Value
|
@return true for success
|
*************************************************************************/
|
bool PVRShell::PVRShellSet(const prefNameConstPtrEnum prefName, const void * const ptrValue)
|
{
|
switch(prefName)
|
{
|
case prefAppName:
|
StringCopy(m_pShellData->pszAppName, (char*)ptrValue);
|
return true;
|
case prefExitMessage:
|
StringCopy(m_pShellData->pszExitMessage, (char*)ptrValue);
|
PVRShellOutputDebug("Exit message has been set to: \"%s\".\n", ptrValue);
|
return true;
|
default:
|
break;
|
}
|
return false;
|
}
|
|
/*!***********************************************************************
|
@brief This function is used to get parameters from the PVRShell.
|
It can be called from anywhere in the program.
|
@param[in] prefName Name of preference to set to value
|
@return The requested value.
|
*************************************************************************/
|
const void *PVRShell::PVRShellGet(const prefNameConstPtrEnum prefName) const
|
{
|
switch(prefName)
|
{
|
case prefAppName:
|
return m_pShellData->pszAppName;
|
case prefExitMessage:
|
return m_pShellData->pszExitMessage;
|
case prefReadPath:
|
return m_pShellInit->GetReadPath();
|
case prefWritePath:
|
return m_pShellInit->GetWritePath();
|
case prefCommandLine:
|
return m_pShellInit->m_CommandLine.m_psOrig;
|
case prefCommandLineOpts:
|
return m_pShellInit->m_CommandLine.m_pOpt;
|
case prefVersion:
|
return PVRSDK_VERSION;
|
default:
|
return 0;
|
}
|
}
|
|
/*!***********************************************************************
|
@brief It will be stored as 24-bit per pixel, 8-bit per chanel RGB.
|
The memory should be freed with free() when no longer needed.
|
@param[in] Width size of image to capture (relative to 0,0)
|
@param[in] Height size of image to capture (relative to 0,0)
|
@param[out] pLines receives a pointer to an area of memory containing the screen buffer.
|
@return true for success
|
*************************************************************************/
|
bool PVRShell::PVRShellScreenCaptureBuffer(const int Width, const int Height, unsigned char **pLines)
|
{
|
/* Allocate memory for line */
|
*pLines=(unsigned char *)calloc(Width*Height*3, sizeof(unsigned char));
|
if (!(*pLines)) return false;
|
|
return m_pShellInit->ApiScreenCaptureBuffer(Width, Height, *pLines);
|
}
|
|
/*!***********************************************************************
|
@brief Writes out the image data to a BMP file with basename fname.
|
@details The file written will be fname suffixed with a number to make the file unique.
|
For example, if fname is "abc", this function will attempt
|
to save to "abc0000.bmp"; if that file already exists, it
|
will try "abc0001.bmp", repeating until a new filename is
|
found. The final filename used is returned in ofname.
|
@param[in] fname base of file to save screen to
|
@param[in] Width size of image to capture (relative to 0,0)
|
@param[in] Height size of image to capture (relative to 0,0)
|
@param[in] pLines image data to write out (24bpp, 8-bit per channel RGB)
|
@param[in] ui32PixelReplicate expand pixels through replication (1 = no scale)
|
@param[out] ofname If non-NULL, receives the filename actually used
|
@return true for success
|
*************************************************************************/
|
int PVRShell::PVRShellScreenSave(
|
const char * const fname,
|
const int Width,
|
const int Height,
|
const unsigned char * const pLines,
|
const unsigned int ui32PixelReplicate,
|
char * const ofname)
|
{
|
char *pszFileName;
|
|
/*
|
Choose a filename
|
*/
|
{
|
FILE *file = 0;
|
const char *pszWritePath;
|
int nScreenshotCount;
|
|
pszWritePath = (const char*)PVRShellGet(prefWritePath);
|
|
size_t nFileNameSize = strlen(pszWritePath) + 200;
|
pszFileName = (char*)malloc(nFileNameSize);
|
|
/* Look for the first file name that doesn't already exist */
|
for(nScreenshotCount = 0; nScreenshotCount < 10000; ++nScreenshotCount)
|
{
|
snprintf(pszFileName, nFileNameSize, "%s%s%04d.bmp", pszWritePath, fname, nScreenshotCount);
|
|
file = fopen(pszFileName,"r");
|
if(!file)
|
break;
|
fclose(file);
|
}
|
|
/* If all files already exist, replace the first one */
|
if (nScreenshotCount==10000)
|
{
|
snprintf(pszFileName, nFileNameSize, "%s%s0000.bmp", pszWritePath, fname);
|
PVRShellOutputDebug("PVRShell: *WARNING* : Overwriting %s\n", pszFileName);
|
}
|
|
if(ofname) // requested the output file name
|
{
|
strcpy(ofname, pszFileName);
|
}
|
}
|
|
const int err = PVRShellWriteBMPFile(pszFileName, Width, Height, pLines, ui32PixelReplicate);
|
FREE(pszFileName);
|
if (err)
|
{
|
return 10*err+1;
|
}
|
else
|
{
|
// No problem occurred
|
return 0;
|
}
|
}
|
|
/*!***********************************************************************
|
@brief Swaps the bytes in pBytes from little to big endian (or vice versa)
|
@param[in] pBytes The bytes to swap
|
@param[in] i32ByteNo The number of bytes to swap
|
*************************************************************************/
|
inline void PVRShellByteSwap(unsigned char* pBytes, int i32ByteNo)
|
{
|
int i = 0, j = i32ByteNo - 1;
|
|
while(i < j)
|
{
|
unsigned char cTmp = pBytes[i];
|
pBytes[i] = pBytes[j];
|
pBytes[j] = cTmp;
|
|
++i;
|
--j;
|
}
|
}
|
|
/*!***********************************************************************
|
@brief Writes out the image data to a BMP file with name fname.
|
@param[in] pszFilename file to save screen to
|
@param[in] ui32Width the width of the data
|
@param[in] ui32Height the height of the data
|
@param[in] pImageData image data to write out (24bpp, 8-bit per channel RGB)
|
@return 0 on success
|
*************************************************************************/
|
int PVRShell::PVRShellWriteBMPFile(
|
const char * const pszFilename,
|
const unsigned int ui32Width,
|
const unsigned int ui32Height,
|
const void * const pImageData,
|
const unsigned int ui32PixelReplicate)
|
{
|
#define ByteSwap(x) PVRShellByteSwap((unsigned char*) &x, sizeof(x))
|
|
const int i32BMPHeaderSize = 14; /* The size of a BMP header */
|
const int i32BMPInfoSize = 40; /* The size of a BMP info header */
|
int Result = 1;
|
FILE* fpDumpfile = 0;
|
|
fpDumpfile = fopen(pszFilename, "wb");
|
|
if (fpDumpfile != 0)
|
{
|
const short int word = 0x0001;
|
const char * const byte = (char*) &word;
|
bool bLittleEndian = byte[0] ? true : false;
|
|
unsigned int i32OutBytesPerLine = ui32Width * 3 * ui32PixelReplicate;
|
unsigned int i32OutAlign = 0;
|
|
// round up to a dword boundary
|
if(i32OutBytesPerLine & 3)
|
{
|
i32OutBytesPerLine |= 3;
|
++i32OutBytesPerLine;
|
i32OutAlign = i32OutBytesPerLine - ui32Width * 3 * ui32PixelReplicate;
|
}
|
|
unsigned char *pData = (unsigned char*) pImageData;
|
|
{
|
int ui32RealSize = i32OutBytesPerLine * ui32Height * ui32PixelReplicate;
|
|
// BMP Header
|
unsigned short bfType = 0x4D42;
|
unsigned int bfSize = i32BMPHeaderSize + i32BMPInfoSize + ui32RealSize;
|
unsigned short bfReserved1 = 0;
|
unsigned short bfReserved2 = 0;
|
unsigned int bfOffBits = i32BMPHeaderSize + i32BMPInfoSize;
|
|
// BMP Info Header
|
unsigned int biSize = i32BMPInfoSize;
|
unsigned int biWidth = ui32Width * ui32PixelReplicate;
|
unsigned int biHeight = ui32Height * ui32PixelReplicate;
|
unsigned short biPlanes = 1;
|
unsigned short biBitCount = 24;
|
unsigned int biCompression = 0L;
|
unsigned int biSizeImage = ui32RealSize;
|
unsigned int biXPelsPerMeter = 0;
|
unsigned int biYPelsPerMeter = 0;
|
unsigned int biClrUsed = 0;
|
unsigned int biClrImportant = 0;
|
|
if(!bLittleEndian)
|
{
|
for(unsigned int i = 0; i < ui32Width * ui32Height; ++i)
|
PVRShellByteSwap(pData + (3 * i), 3);
|
|
ByteSwap(bfType);
|
ByteSwap(bfSize);
|
ByteSwap(bfOffBits);
|
ByteSwap(biSize);
|
ByteSwap(biWidth);
|
ByteSwap(biHeight);
|
ByteSwap(biPlanes);
|
ByteSwap(biBitCount);
|
ByteSwap(biCompression);
|
ByteSwap(biSizeImage);
|
}
|
|
// Write Header.
|
fwrite(&bfType , 1, sizeof(bfType) , fpDumpfile);
|
fwrite(&bfSize , 1, sizeof(bfSize) , fpDumpfile);
|
fwrite(&bfReserved1 , 1, sizeof(bfReserved1), fpDumpfile);
|
fwrite(&bfReserved2 , 1, sizeof(bfReserved2), fpDumpfile);
|
fwrite(&bfOffBits , 1, sizeof(bfOffBits) , fpDumpfile);
|
|
// Write info header.
|
fwrite(&biSize , 1, sizeof(biSize) , fpDumpfile);
|
fwrite(&biWidth , 1, sizeof(biWidth) , fpDumpfile);
|
fwrite(&biHeight , 1, sizeof(biHeight) , fpDumpfile);
|
fwrite(&biPlanes , 1, sizeof(biPlanes) , fpDumpfile);
|
fwrite(&biBitCount , 1, sizeof(biBitCount) , fpDumpfile);
|
fwrite(&biCompression , 1, sizeof(biCompression) , fpDumpfile);
|
fwrite(&biSizeImage , 1, sizeof(biSizeImage) , fpDumpfile);
|
fwrite(&biXPelsPerMeter , 1, sizeof(biXPelsPerMeter), fpDumpfile);
|
fwrite(&biYPelsPerMeter , 1, sizeof(biYPelsPerMeter), fpDumpfile);
|
fwrite(&biClrUsed , 1, sizeof(biClrUsed) , fpDumpfile);
|
fwrite(&biClrImportant , 1, sizeof(biClrImportant) , fpDumpfile);
|
}
|
|
// Write image.
|
for(unsigned int nY = 0; nY < ui32Height; ++nY)
|
{
|
const unsigned char * pRow = &pData[3 * ui32Width * nY];
|
for(unsigned int nRepY = 0; nRepY < ui32PixelReplicate; ++nRepY)
|
{
|
for(unsigned int nX = 0; nX < ui32Width; ++nX)
|
{
|
const unsigned char * pPixel = &pRow[3 * nX];
|
for(unsigned int nRepX = 0; nRepX < ui32PixelReplicate; ++nRepX)
|
{
|
fwrite(pPixel, 1, 3, fpDumpfile);
|
}
|
}
|
|
fwrite("\0\0\0\0", i32OutAlign, 1, fpDumpfile);
|
}
|
}
|
|
// Last but not least close the file.
|
fclose(fpDumpfile);
|
|
Result = 0;
|
}
|
else
|
{
|
PVRShellOutputDebug("PVRShell: Failed to open \"%s\" for writing screen dump.\n", pszFilename);
|
}
|
|
return Result;
|
}
|
|
/*!***********************************************************************
|
@brief The number itself should be considered meaningless; an
|
application should use this function to determine how much
|
time has passed between two points (e.g. between each
|
frame).
|
@return A value which increments once per millisecond.
|
*************************************************************************/
|
unsigned long PVRShell::PVRShellGetTime()
|
{
|
if(m_pShellData->bForceFrameTime)
|
{
|
// Return a "time" value based on the current frame number
|
return (unsigned long) m_pShellData->nShellCurFrameNum * m_pShellData->nFrameTime;
|
}
|
else
|
{
|
// Read timer from a platform dependant function
|
return m_pShellInit->OsGetTime();
|
}
|
}
|
|
/*!***********************************************************************
|
@brief Check if a key was pressed. The keys on various devices
|
are mapped to the PVRShell-supported keys (listed in @a PVRShellKeyName) in
|
a platform-dependent manner, since most platforms have different input
|
devices. Check the <a href="modules.html">Modules page</a> for your OS
|
for details on how the enum values map to your device's key code input.
|
@param[in] key Code of the key to test
|
@return true if key was pressed
|
*************************************************************************/
|
bool PVRShell::PVRShellIsKeyPressed(const PVRShellKeyName key)
|
{
|
if(!m_pShellInit)
|
return false;
|
|
return m_pShellInit->DoIsKeyPressed(key);
|
}
|
|
// class PVRShellCommandLine
|
|
/*!***********************************************************************
|
@brief Constructor
|
*************************************************************************/
|
PVRShellCommandLine::PVRShellCommandLine()
|
{
|
memset(this, 0, sizeof(*this));
|
}
|
|
/*!***********************************************************************
|
@brief Destructor
|
*************************************************************************/
|
PVRShellCommandLine::~PVRShellCommandLine()
|
{
|
delete [] m_psOrig;
|
delete [] m_psSplit;
|
FREE(m_pOpt);
|
}
|
|
/*!***********************************************************************
|
@brief Set command-line options to pStr
|
@param[in] pStr Input string
|
*************************************************************************/
|
void PVRShellCommandLine::Set(const char *pStr)
|
{
|
delete [] m_psOrig;
|
m_psOrig = 0;
|
|
if(pStr)
|
{
|
size_t len = strlen(pStr)+1;
|
m_psOrig = new char[len];
|
strcpy(m_psOrig, pStr);
|
}
|
}
|
|
/*!***********************************************************************
|
@brief Prepend command-line options to m_psOrig
|
@param[in] pStr Input string
|
*************************************************************************/
|
void PVRShellCommandLine::Prefix(const char *pStr)
|
{
|
if(!m_psOrig)
|
Set(pStr);
|
else if(!pStr)
|
return;
|
else
|
{
|
char *pstmp = m_psOrig;
|
size_t lenA = strlen(pStr);
|
size_t TotalLen = lenA + 1 + strlen(m_psOrig);
|
|
m_psOrig = new char[TotalLen + 1];
|
|
strcpy(m_psOrig, pStr);
|
m_psOrig[lenA] = ' ';
|
strcpy(m_psOrig + lenA + 1, pstmp);
|
m_psOrig[TotalLen] = '\0';
|
|
delete[] pstmp;
|
}
|
}
|
|
/*!***********************************************************************
|
@brief Prepend command-line options to m_psOrig from a file
|
@param[in] pFileName Input string
|
*************************************************************************/
|
bool PVRShellCommandLine::PrefixFromFile(const char *pFileName)
|
{
|
char* nl;
|
FILE *pFile = fopen(pFileName, "rb");
|
|
if(pFile)
|
{
|
// Get the file size
|
fseek(pFile, 0, SEEK_END);
|
long m_Size = ftell(pFile) + 2;
|
fseek(pFile, 0, SEEK_SET);
|
|
char *pFullFile = new char[m_Size];
|
|
if(pFullFile)
|
{
|
size_t offset = 0;
|
while(fgets(pFullFile + offset, (int) (m_Size - offset), pFile))
|
{
|
offset = strlen(pFullFile);
|
|
// Replace new lines with spaces
|
nl = strrchr(pFullFile, '\r');
|
if(nl) *nl = ' ';
|
|
nl = strrchr(pFullFile, '\n');
|
if(nl) *nl = ' ';
|
}
|
|
pFullFile[offset] = '\0';
|
Prefix(pFullFile);
|
|
delete[] pFullFile;
|
fclose(pFile);
|
return true;
|
}
|
|
fclose(pFile);
|
}
|
|
return false;
|
}
|
|
/*!***********************************************************************
|
@brief Parse m_psOrig for command-line options and store them in m_pOpt
|
*************************************************************************/
|
void PVRShellCommandLine::Parse()
|
{
|
size_t len;
|
int nIn, nOut;
|
bool bInQuotes;
|
SCmdLineOpt opt;
|
|
if(!m_psOrig)
|
return;
|
|
// Delete/free up any options we may have parsed recently
|
delete [] m_psSplit;
|
FREE(m_pOpt);
|
|
// Take a copy to be edited
|
len = strlen(m_psOrig) + 1;
|
m_psSplit = new char[len];
|
|
// Break the command line into options
|
bInQuotes = false;
|
opt.pArg = NULL;
|
opt.pVal = NULL;
|
nIn = -1;
|
nOut = 0;
|
|
do
|
{
|
++nIn;
|
if(m_psOrig[nIn] == '"')
|
{
|
bInQuotes = !bInQuotes;
|
}
|
else
|
{
|
if(bInQuotes && m_psOrig[nIn] != 0)
|
{
|
if(!opt.pArg)
|
opt.pArg = &m_psSplit[nOut];
|
|
m_psSplit[nOut++] = m_psOrig[nIn];
|
}
|
else
|
{
|
switch(m_psOrig[nIn])
|
{
|
case '=':
|
m_psSplit[nOut++] = 0;
|
opt.pVal = &m_psSplit[nOut];
|
break;
|
|
case ' ':
|
case '\t':
|
case '\0':
|
m_psSplit[nOut++] = 0;
|
if(opt.pArg || opt.pVal)
|
{
|
// Increase list length if necessary
|
if(m_nOptLen == m_nOptMax)
|
m_nOptMax = m_nOptMax * 2 + 1;
|
SCmdLineOpt* pTmp = (SCmdLineOpt*)realloc(m_pOpt, m_nOptMax * sizeof(*m_pOpt));
|
if(!pTmp)
|
{
|
FREE(m_pOpt);
|
return;
|
}
|
|
m_pOpt = pTmp;
|
|
// Add option to list
|
m_pOpt[m_nOptLen++] = opt;
|
opt.pArg = NULL;
|
opt.pVal = NULL;
|
}
|
break;
|
|
default:
|
if(!opt.pArg)
|
opt.pArg = &m_psSplit[nOut];
|
|
m_psSplit[nOut++] = m_psOrig[nIn];
|
break;
|
}
|
}
|
}
|
} while(m_psOrig[nIn]);
|
}
|
|
/*!***********************************************************************
|
@brief Apply the command-line options to shell
|
@param[in] shell
|
*************************************************************************/
|
void PVRShellCommandLine::Apply(PVRShell &shell)
|
{
|
int i;
|
const char *arg, *val;
|
|
for(i = 0; i < m_nOptLen; ++i)
|
{
|
arg = m_pOpt[i].pArg;
|
val = m_pOpt[i].pVal;
|
|
if(!arg)
|
continue;
|
|
if(val)
|
{
|
if(_stricmp(arg, "-width") == 0)
|
{
|
shell.PVRShellSet(prefWidth, atoi(val));
|
}
|
else if(_stricmp(arg, "-height") == 0)
|
{
|
shell.PVRShellSet(prefHeight, atoi(val));
|
}
|
else if(_stricmp(arg, "-aasamples") == 0)
|
{
|
shell.PVRShellSet(prefAASamples, atoi(val));
|
}
|
else if(_stricmp(arg, "-fullscreen") == 0)
|
{
|
shell.PVRShellSet(prefFullScreen, (atoi(val) != 0));
|
}
|
else if(_stricmp(arg, "-sw") == 0)
|
{
|
shell.PVRShellSet(prefSoftwareRendering, (atoi(val) != 0));
|
}
|
else if(_stricmp(arg, "-quitafterframe") == 0 || _stricmp(arg, "-qaf") == 0)
|
{
|
shell.PVRShellSet(prefQuitAfterFrame, atoi(val));
|
}
|
else if(_stricmp(arg, "-quitaftertime") == 0 || _stricmp(arg, "-qat") == 0)
|
{
|
shell.PVRShellSet(prefQuitAfterTime, (float)atof(val));
|
}
|
else if(_stricmp(arg, "-posx") == 0)
|
{
|
shell.PVRShellSet(prefPositionX, atoi(val));
|
}
|
else if(_stricmp(arg, "-posy") == 0)
|
{
|
shell.PVRShellSet(prefPositionY, atoi(val));
|
}
|
else if(_stricmp(arg, "-vsync") == 0)
|
{
|
shell.PVRShellSet(prefSwapInterval, atoi(val));
|
}
|
else if(_stricmp(arg, "-powersaving") == 0 || _stricmp(arg, "-ps") == 0)
|
{
|
shell.PVRShellSet(prefPowerSaving, (atoi(val) != 0));
|
}
|
else if(_stricmp(arg, "-colourbpp") == 0 || _stricmp(arg, "-colorbpp") == 0 ||_stricmp(arg, "-cbpp") == 0)
|
{
|
shell.PVRShellSet(prefColorBPP, atoi(val));
|
}
|
else if(_stricmp(arg, "-depthbpp") == 0 || _stricmp(arg, "-dbpp") == 0)
|
{
|
shell.PVRShellSet(prefDepthBPP, atoi(val));
|
}
|
else if(_stricmp(arg, "-rotatekeys") == 0)
|
{
|
shell.PVRShellSet(prefRotateKeys, atoi(val));
|
}
|
else if(_stricmp(arg, "-c") == 0)
|
{
|
const char* pDash = strchr(val, '-');
|
|
shell.PVRShellSet(prefCaptureFrameStart, atoi(val));
|
|
if(!pDash)
|
shell.PVRShellSet(prefCaptureFrameStop, atoi(val));
|
else
|
shell.PVRShellSet(prefCaptureFrameStop, atoi(pDash + 1));
|
}
|
else if(_stricmp(arg, "-screenshotscale") == 0)
|
{
|
shell.PVRShellSet(prefCaptureFrameScale, atoi(val));
|
}
|
else if(_stricmp(arg, "-priority") == 0)
|
{
|
shell.PVRShellSet(prefPriority, atoi(val));
|
}
|
else if(_stricmp(arg, "-config") == 0)
|
{
|
shell.PVRShellSet(prefRequestedConfig, atoi(val));
|
}
|
else if(_stricmp(arg, "-display") == 0)
|
{
|
shell.PVRShellSet(prefNativeDisplay, atoi(val));
|
}
|
else if(_stricmp(arg, "-forceframetime") == 0 || _stricmp(arg, "-fft") == 0)
|
{
|
shell.PVRShellSet(prefForceFrameTime, true);
|
shell.PVRShellSet(prefFrameTimeValue, atoi(val));
|
}
|
else if(_stricmp(arg, "-discardframeall") == 0)
|
{
|
shell.PVRShellSet(prefDiscardColor, (atoi(val) != 0));
|
shell.PVRShellSet(prefDiscardDepth, (atoi(val) != 0));
|
shell.PVRShellSet(prefDiscardStencil, (atoi(val) != 0));
|
}
|
else if(_stricmp(arg, "-discardframecolor") == 0 || _stricmp(arg, "-discardframecolour") == 0)
|
{
|
shell.PVRShellSet(prefDiscardColor, (atoi(val) != 0));
|
}
|
else if(_stricmp(arg, "-discardframedepth") == 0)
|
{
|
shell.PVRShellSet(prefDiscardDepth, (atoi(val) != 0));
|
}
|
else if(_stricmp(arg, "-discardframestencil") == 0)
|
{
|
shell.PVRShellSet(prefDiscardStencil, (atoi(val) != 0));
|
}
|
}
|
else
|
{
|
if(_stricmp(arg, "-version") == 0)
|
{
|
shell.PVRShellOutputDebug("Version: \"%s\"\n", shell.PVRShellGet(prefVersion));
|
}
|
#ifdef PVRSHELL_FPS_OUTPUT
|
else if(_stricmp(arg, "-fps") == 0)
|
{
|
shell.PVRShellSet(prefOutputFPS, true);
|
}
|
#endif
|
else if(_stricmp(arg, "-info") == 0)
|
{
|
shell.PVRShellSet(prefOutputInfo, true);
|
}
|
else if(_stricmp(arg, "-forceframetime") == 0 || _stricmp(arg, "-fft") == 0)
|
{
|
shell.PVRShellSet(prefForceFrameTime, true);
|
}
|
}
|
}
|
}
|
|
// @Class PVRShellInit
|
|
/*!***********************************************************************
|
@brief Constructor
|
*************************************************************************/
|
PVRShellInit::PVRShellInit()
|
{
|
memset(this, 0, sizeof(*this));
|
}
|
|
/*!***********************************************************************
|
@brief Destructor
|
*************************************************************************/
|
PVRShellInit::~PVRShellInit()
|
{
|
Deinit();
|
|
delete [] m_pReadPath;
|
m_pReadPath = NULL;
|
|
delete [] m_pWritePath;
|
m_pWritePath = NULL;
|
}
|
|
/*!***********************************************************************
|
@brief PVRShell deinitialisation.
|
@param[in] Shell
|
*************************************************************************/
|
void PVRShellInit::Deinit()
|
{
|
if(m_pShell)
|
{
|
// Is the App currently running?
|
if(m_eState > ePVRShellInitApp && m_eState < ePVRShellExit)
|
{
|
// If so force it to go through the exit procedure
|
if(m_eState < ePVRShellReleaseView)
|
m_eState = ePVRShellReleaseView;
|
|
// Class the App as done
|
gShellDone = true;
|
|
// Run through the exiting states
|
while(Run()){};
|
}
|
|
delete m_pShell;
|
m_pShell = 0;
|
}
|
}
|
|
/*!***********************************************************************
|
@brief PVRShell Initialisation.
|
@Function Init
|
@param[in] Shell
|
@return True on success and false on failure
|
*************************************************************************/
|
bool PVRShellInit::Init()
|
{
|
Deinit();
|
|
m_pShell = NewDemo();
|
|
if(!m_pShell)
|
return false;
|
|
m_pShell->m_pShellInit = this;
|
|
// set default direction key mappings
|
m_eKeyMapDOWN = PVRShellKeyNameDOWN;
|
m_eKeyMapLEFT = PVRShellKeyNameLEFT;
|
m_eKeyMapUP = PVRShellKeyNameUP;
|
m_eKeyMapRIGHT = PVRShellKeyNameRIGHT;
|
nLastKeyPressed = PVRShellKeyNameNull;
|
|
OsInit();
|
|
gShellDone = false;
|
m_eState = ePVRShellInitApp;
|
return true;
|
}
|
|
/*!***********************************************************************
|
@brief Receives the command-line from the application.
|
@param[in] str A string containing the command-line
|
*************************************************************************/
|
void PVRShellInit::CommandLine(const char *str)
|
{
|
m_CommandLine.Set(str);
|
}
|
|
/*!***********************************************************************
|
@brief Receives the command-line from the application.
|
@param[in] argc Number of strings in argv
|
@param[in] argv An array of strings
|
*************************************************************************/
|
void PVRShellInit::CommandLine(int argc, char **argv)
|
{
|
size_t tot, len;
|
char *buf;
|
int i;
|
|
tot = 0;
|
for(i = 0; i < argc; ++i)
|
tot += strlen(argv[i]);
|
|
if(!tot)
|
{
|
CommandLine((char*) "");
|
return;
|
}
|
|
// Add room for spaces and the \0
|
tot += argc;
|
|
buf = new char[tot];
|
tot = 0;
|
for(i = 0; i < argc; ++i)
|
{
|
len = strlen(argv[i]);
|
strncpy(&buf[tot], argv[i], len);
|
tot += len;
|
buf[tot++] = ' ';
|
}
|
buf[tot-1] = 0;
|
|
CommandLine(buf);
|
|
delete [] buf;
|
}
|
|
/*!***********************************************************************
|
@brief Return 'true' if the specific key has been pressed.
|
@param[in] key The key we're querying for
|
*************************************************************************/
|
bool PVRShellInit::DoIsKeyPressed(const PVRShellKeyName key)
|
{
|
if(key == nLastKeyPressed)
|
{
|
nLastKeyPressed = PVRShellKeyNameNull;
|
return true;
|
}
|
else
|
{
|
return false;
|
}
|
}
|
|
/*!***********************************************************************
|
@brief Used by the OS-specific code to tell the Shell that a key has been pressed.
|
@param[in] nKey The key that has been pressed
|
*************************************************************************/
|
void PVRShellInit::KeyPressed(PVRShellKeyName nKey)
|
{
|
nLastKeyPressed = nKey;
|
}
|
|
/*!***********************************************************************
|
@brief Used by the OS-specific code to tell the Shell that a touch has began at a location.
|
@param[in] vec2Location The position of a click/touch on the screen when it first touches
|
*************************************************************************/
|
void PVRShellInit::TouchBegan(const float vec2Location[2])
|
{
|
m_bTouching = true;
|
m_vec2PointerLocationStart[0] = m_vec2PointerLocation[0] = vec2Location[0];
|
m_vec2PointerLocationStart[1] = m_vec2PointerLocation[1] = vec2Location[1];
|
}
|
|
/*!***********************************************************************
|
@brief Used by the OS-specific code to tell the Shell that a touch has began at a location.
|
@param[in] vec2Location The position of the pointer/touch pressed on the screen
|
*************************************************************************/
|
void PVRShellInit::TouchMoved(const float vec2Location[2])
|
{
|
if(m_bTouching)
|
{
|
m_vec2PointerLocation[0] = vec2Location[0];
|
m_vec2PointerLocation[1] = vec2Location[1];
|
}
|
}
|
|
/*!***********************************************************************
|
@brief Used by the OS-specific code to tell the Shell that the current touch has ended at a location.
|
@param[in] vec2Location The position of the pointer/touch on the screen when it is released
|
*************************************************************************/
|
void PVRShellInit::TouchEnded(const float vec2Location[2])
|
{
|
if(m_bTouching)
|
{
|
m_bTouching = false;
|
m_vec2PointerLocationEnd[0] = m_vec2PointerLocation[0] = vec2Location[0];
|
m_vec2PointerLocationEnd[1] = m_vec2PointerLocation[1] = vec2Location[1];
|
|
#if !defined(DISABLE_SWIPE_MAPPING)
|
float fX = m_vec2PointerLocationEnd[0] - m_vec2PointerLocationStart[0];
|
float fY = m_vec2PointerLocationEnd[1] - m_vec2PointerLocationStart[1];
|
float fTmp = fX * fX + fY * fY;
|
|
if(fTmp > 0.005f)
|
{
|
fTmp = 1.0f / sqrt(fTmp);
|
fY *= fTmp;
|
float fAngle = acos(fY);
|
|
const float pi = 3.1415f;
|
const float pi_half = pi * 0.5f;
|
const float error = 0.25f;
|
|
if(fAngle < error)
|
KeyPressed(m_eKeyMapDOWN);
|
else if(fAngle > (pi - error))
|
KeyPressed(m_eKeyMapUP);
|
else if(fAngle > (pi_half - error) && fAngle < (pi_half + error))
|
KeyPressed((fX < 0) ? m_eKeyMapLEFT : m_eKeyMapRIGHT);
|
}
|
else if(fTmp < 0.09f)
|
{
|
if (m_vec2PointerLocationEnd[0] <= 0.3f) // Left half of the screen
|
KeyPressed(PVRShellKeyNameACTION1);
|
else if (m_vec2PointerLocationEnd[0] >= 0.7f) // Right half of the screen
|
KeyPressed(PVRShellKeyNameACTION2);
|
}
|
#endif
|
}
|
}
|
|
/*!***********************************************************************
|
@brief Used by the OS-specific code to tell the Shell where to read external files from
|
@return A path the application is capable of reading from
|
*************************************************************************/
|
const char* PVRShellInit::GetReadPath() const
|
{
|
return m_pReadPath;
|
}
|
|
/*!***********************************************************************
|
@brief Used by the OS-specific code to tell the Shell where to write to
|
@return A path the applications is capable of writing to
|
*************************************************************************/
|
const char* PVRShellInit::GetWritePath() const
|
{
|
return m_pWritePath;
|
}
|
|
/*!****************************************************************************
|
@brief Sets the default app name (to be displayed by the OS)
|
@param[in] str The application name
|
*******************************************************************************/
|
void PVRShellInit::SetAppName(const char * const str)
|
{
|
const char *pName = strrchr(str, PVRSHELL_DIR_SYM);
|
|
if(pName)
|
{
|
++pName;
|
}
|
else
|
{
|
pName = str;
|
}
|
m_pShell->PVRShellSet(prefAppName, pName);
|
}
|
|
/*!***********************************************************************
|
@brief Set the path to where the application expects to read from.
|
@param[in] str The read path
|
*************************************************************************/
|
void PVRShellInit::SetReadPath(const char * const str)
|
{
|
m_pReadPath = new char[strlen(str)+1];
|
|
if(m_pReadPath)
|
{
|
strcpy(m_pReadPath, str);
|
char* lastSlash = strrchr(m_pReadPath, PVRSHELL_DIR_SYM);
|
|
if(lastSlash)
|
lastSlash[1] = 0;
|
}
|
}
|
|
/*!***********************************************************************
|
@brief Set the path to where the application expects to write to.
|
@param[in] str The write path
|
*************************************************************************/
|
void PVRShellInit::SetWritePath(const char * const str)
|
{
|
m_pWritePath = new char[strlen(str)+1];
|
|
if(m_pWritePath)
|
{
|
strcpy(m_pWritePath, str);
|
char* lastSlash = strrchr(m_pWritePath, PVRSHELL_DIR_SYM);
|
|
if(lastSlash)
|
lastSlash[1] = 0;
|
}
|
}
|
|
#ifdef PVRSHELL_FPS_OUTPUT
|
/*****************************************************************************
|
@fn FpsUpdate
|
@brief Calculates a value for frames-per-second (FPS).
|
@details This is only compiled in to the application if PVRSHELL_FPS_OUTPUT is defined.
|
*****************************************************************************/
|
void PVRShellInit::FpsUpdate()
|
{
|
unsigned int ui32TimeDelta, ui32Time;
|
|
ui32Time = m_pShell->PVRShellGetTime();
|
++m_i32FpsFrameCnt;
|
ui32TimeDelta = ui32Time - m_i32FpsTimePrev;
|
|
if(ui32TimeDelta >= 1000)
|
{
|
float fFPS = 1000.0f * (float) m_i32FpsFrameCnt / (float) ui32TimeDelta;
|
|
m_pShell->PVRShellOutputDebug("PVRShell: frame %d, FPS %.1f.\n",
|
m_pShell->m_pShellData->nShellCurFrameNum, fFPS);
|
|
m_i32FpsFrameCnt = 0;
|
m_i32FpsTimePrev = ui32Time;
|
}
|
}
|
#endif
|
|
/*****************************************************************************
|
@brief Main message loop / render loop
|
@return false when the app should quit
|
*****************************************************************************/
|
bool PVRShellInit::Run()
|
{
|
static unsigned long StartTime = 0;
|
|
switch(m_eState)
|
{
|
case ePVRShellInitApp:
|
{
|
// Make sure the shell isn't done
|
gShellDone = false;
|
|
// Prepend command-line options from PVRShellCL.txt
|
const char * const pCL = "PVRShellCL.txt";
|
const char *pPath = (const char*) m_pShell->PVRShellGet(prefReadPath);
|
size_t nSize = strlen(pPath) + strlen(pCL) + 1;
|
char *pString = new char[nSize];
|
|
if(pString)
|
{
|
snprintf(pString, nSize, "%s%s", pPath, pCL);
|
|
if(!m_CommandLine.PrefixFromFile(pString))
|
{
|
delete[] pString;
|
pPath = (const char*) m_pShell->PVRShellGet(prefWritePath);
|
nSize = strlen(pPath) + strlen(pCL) + 1;
|
pString = new char[nSize];
|
|
snprintf(pString, nSize, "%s%s", pPath, pCL);
|
|
if(m_CommandLine.PrefixFromFile(pString))
|
m_pShell->PVRShellOutputDebug("Loaded command-line options from %s.\n", pString);
|
}
|
else
|
m_pShell->PVRShellOutputDebug("Loaded command-line options from %s.\n", pString);
|
|
delete[] pString;
|
}
|
|
// Parse the command-line
|
m_CommandLine.Parse();
|
|
#if defined(_DEBUG)
|
m_pShell->PVRShellOutputDebug("PVRShell command line: %d/%d\n", m_CommandLine.m_nOptLen, m_CommandLine.m_nOptMax);
|
for(int i = 0; i < m_CommandLine.m_nOptLen; ++i)
|
{
|
m_pShell->PVRShellOutputDebug("CL %d: \"%s\"\t= \"%s\".\n", i,
|
m_CommandLine.m_pOpt[i].pArg ? m_CommandLine.m_pOpt[i].pArg : "",
|
m_CommandLine.m_pOpt[i].pVal ? m_CommandLine.m_pOpt[i].pVal : "");
|
}
|
#endif
|
// Call InitApplication
|
if(!m_pShell->InitApplication())
|
{
|
m_eState = ePVRShellExit;
|
return true;
|
}
|
|
m_eState = ePVRShellInitInstance;
|
return true;
|
}
|
case ePVRShellInitInstance:
|
{
|
m_CommandLine.Apply(*m_pShell);
|
|
// Output non-api specific data if required
|
OutputInfo();
|
|
// Perform OS initialisation
|
if(!OsInitOS())
|
{
|
m_pShell->PVRShellOutputDebug("InitOS failed!\n");
|
m_eState = ePVRShellQuitApp;
|
return true;
|
}
|
|
// Initialize the 3D API
|
if(!OsDoInitAPI())
|
{
|
m_pShell->PVRShellOutputDebug("InitAPI failed!\n");
|
m_eState = ePVRShellReleaseOS;
|
gShellDone = true;
|
return true;
|
}
|
|
// Output api specific data if required
|
OutputAPIInfo();
|
|
// Initialise the app
|
if(!m_pShell->InitView())
|
{
|
m_pShell->PVRShellOutputDebug("InitView failed!\n");
|
m_eState = ePVRShellReleaseAPI;
|
gShellDone = true;
|
return true;
|
}
|
|
if(StartTime==0)
|
{
|
StartTime = OsGetTime();
|
}
|
|
m_eState = ePVRShellRender;
|
return true;
|
}
|
case ePVRShellRender:
|
{
|
// Main message loop:
|
if(!m_pShell->RenderScene())
|
break;
|
|
ApiRenderComplete();
|
OsRenderComplete();
|
|
#ifdef PVRSHELL_FPS_OUTPUT
|
if(m_pShell->m_pShellData->bOutputFPS)
|
FpsUpdate();
|
#endif
|
int nCurrentFrame = m_pShell->m_pShellData->nShellCurFrameNum;
|
|
if(DoIsKeyPressed(PVRShellKeyNameScreenshot) || (nCurrentFrame >= m_pShell->m_pShellData->nCaptureFrameStart && nCurrentFrame <= m_pShell->m_pShellData->nCaptureFrameStop))
|
{
|
unsigned char *pBuf;
|
const int nWidth = m_pShell->PVRShellGet(prefWidth);
|
const int nHeight = m_pShell->PVRShellGet(prefHeight);
|
if(m_pShell->PVRShellScreenCaptureBuffer(nWidth, nHeight, &pBuf))
|
{
|
if(m_pShell->PVRShellScreenSave(PVRSHELL_SCREENSHOT_NAME, nWidth, nHeight, pBuf, m_pShell->m_pShellData->nCaptureFrameScale) != 0)
|
{
|
m_pShell->PVRShellSet(prefExitMessage, "Screen-shot save failed.\n");
|
}
|
}
|
else
|
{
|
m_pShell->PVRShellSet(prefExitMessage, "Screen capture failed.\n");
|
}
|
FREE(pBuf);
|
}
|
|
if(DoIsKeyPressed(PVRShellKeyNameQUIT))
|
gShellDone = true;
|
|
if(gShellDone)
|
break;
|
|
/* Quit if maximum number of allowed frames is reached */
|
if((m_pShell->m_pShellData->nDieAfterFrames>=0) && (nCurrentFrame >= m_pShell->m_pShellData->nDieAfterFrames))
|
break;
|
|
/* Quit if maximum time is reached */
|
if((m_pShell->m_pShellData->fDieAfterTime>=0.0f) && (((OsGetTime()-StartTime)*0.001f) >= m_pShell->m_pShellData->fDieAfterTime))
|
break;
|
|
m_pShell->m_pShellData->nShellCurFrameNum++;
|
return true;
|
}
|
|
case ePVRShellReleaseView:
|
m_pShell->ReleaseView();
|
|
case ePVRShellReleaseAPI:
|
OsDoReleaseAPI();
|
|
case ePVRShellReleaseOS:
|
OsReleaseOS();
|
|
if(!gShellDone && m_pShell->m_pShellData->nInitRepeats)
|
{
|
--m_pShell->m_pShellData->nInitRepeats;
|
m_eState = ePVRShellInitInstance;
|
return true;
|
}
|
|
m_eState = ePVRShellQuitApp;
|
return true;
|
|
case ePVRShellQuitApp:
|
// Final app tidy-up
|
m_pShell->QuitApplication();
|
m_eState = ePVRShellExit;
|
|
case ePVRShellExit:
|
OsExit();
|
StringCopy(m_pShell->m_pShellData->pszAppName, 0);
|
StringCopy(m_pShell->m_pShellData->pszExitMessage, 0);
|
return false;
|
}
|
|
m_eState = (EPVRShellState)(m_eState + 1);
|
return true;
|
}
|
|
/*!***********************************************************************
|
@brief When prefOutputInfo is set to true this function outputs
|
various pieces of non-API dependent information via
|
PVRShellOutputDebug.
|
*************************************************************************/
|
void PVRShellInit::OutputInfo()
|
{
|
if(m_pShell->PVRShellGet(prefOutputInfo))
|
{
|
m_pShell->PVRShellOutputDebug("\n");
|
m_pShell->PVRShellOutputDebug("App name: %s\n" , m_pShell->PVRShellGet(prefAppName));
|
m_pShell->PVRShellOutputDebug("SDK version: %s\n" , m_pShell->PVRShellGet(prefVersion));
|
m_pShell->PVRShellOutputDebug("\n");
|
m_pShell->PVRShellOutputDebug("Read path: %s\n" , m_pShell->PVRShellGet(prefReadPath));
|
m_pShell->PVRShellOutputDebug("Write path: %s\n" , m_pShell->PVRShellGet(prefWritePath));
|
m_pShell->PVRShellOutputDebug("\n");
|
m_pShell->PVRShellOutputDebug("Command-line: %s\n" , m_pShell->PVRShellGet(prefCommandLine));
|
m_pShell->PVRShellOutputDebug("\n");
|
m_pShell->PVRShellOutputDebug("Power saving: %s\n" , m_pShell->PVRShellGet(prefPowerSaving) ? "On" : "Off");
|
m_pShell->PVRShellOutputDebug("AA Samples requested: %i\n", m_pShell->PVRShellGet(prefAASamples));
|
m_pShell->PVRShellOutputDebug("Fullscreen: %s\n", m_pShell->PVRShellGet(prefFullScreen) ? "Yes" : "No");
|
m_pShell->PVRShellOutputDebug("PBuffer requested: %s\n", m_pShell->PVRShellGet(prefPBufferContext) ? "Yes" : "No");
|
m_pShell->PVRShellOutputDebug("ZBuffer requested: %s\n", m_pShell->PVRShellGet(prefZbufferContext) ? "Yes" : "No");
|
m_pShell->PVRShellOutputDebug("Stencil buffer requested: %s\n", m_pShell->PVRShellGet(prefStencilBufferContext) ? "Yes" : "No");
|
|
if(m_pShell->PVRShellGet(prefColorBPP) > 0)
|
m_pShell->PVRShellOutputDebug("Colour buffer size requested: %i\n", m_pShell->PVRShellGet(prefColorBPP));
|
if(m_pShell->PVRShellGet(prefDepthBPP) > 0)
|
m_pShell->PVRShellOutputDebug("Depth buffer size requested: %i\n", m_pShell->PVRShellGet(prefDepthBPP));
|
|
m_pShell->PVRShellOutputDebug("Software rendering requested: %s\n", m_pShell->PVRShellGet(prefSoftwareRendering) ? "Yes" : "No");
|
m_pShell->PVRShellOutputDebug("Swap Interval requested: %i\n", m_pShell->PVRShellGet(prefSwapInterval));
|
|
if(m_pShell->PVRShellGet(prefInitRepeats) > 0)
|
m_pShell->PVRShellOutputDebug("No of Init repeats: %i\n", m_pShell->PVRShellGet(prefInitRepeats));
|
|
if(m_pShell->PVRShellGet(prefQuitAfterFrame) != -1)
|
m_pShell->PVRShellOutputDebug("Quit after frame: %i\n", m_pShell->PVRShellGet(prefQuitAfterFrame));
|
|
if(m_pShell->PVRShellGet(prefQuitAfterTime) != -1.0f)
|
m_pShell->PVRShellOutputDebug("Quit after time: %f\n", m_pShell->PVRShellGet(prefQuitAfterTime));
|
}
|
}
|
|
/****************************************************************************
|
** Local code
|
****************************************************************************/
|
/*!***********************************************************************
|
@brief This function copies pszSrc into pszStr.
|
@param[out] pszStr The string to copy pszSrc into
|
@param[in] pszSrc The source string to copy
|
*************************************************************************/
|
static bool StringCopy(char *&pszStr, const char * const pszSrc)
|
{
|
size_t len;
|
|
FREE(pszStr);
|
|
if(!pszSrc)
|
return true;
|
|
len = strlen(pszSrc)+1;
|
pszStr = (char*)malloc(len);
|
if(!pszStr)
|
return false;
|
|
strcpy(pszStr, pszSrc);
|
return true;
|
}
|
|
/// @endcond
|
//NO_DOXYGEN
|
|
/*****************************************************************************
|
End of file (PVRShell.cpp)
|
*****************************************************************************/
|
