/******************************************************************************
@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)
*****************************************************************************/