524 lines
17 KiB
C++
524 lines
17 KiB
C++
//========= Copyright <20> 1996-2008, Valve LLC, All rights reserved. ============
|
||
//
|
||
// Purpose: Main class for the game engine -- osx implementation
|
||
//
|
||
// $NoKeywords: $
|
||
//=============================================================================
|
||
|
||
#ifndef GAMEENGINEOSX_H
|
||
#define GAMEENGINEOSX_H
|
||
|
||
#ifdef __OBJC__
|
||
#define OBJC_ENABLED 1
|
||
#else
|
||
#define OBJC_ENABLED 0
|
||
#endif
|
||
|
||
typedef unsigned char byte;
|
||
|
||
#include "steam/steam_api.h"
|
||
#include "GameEngine.h"
|
||
#include <OpenAL/al.h>
|
||
#include <OpenAL/alc.h>
|
||
#include <OpenGL/OpenGL.h>
|
||
#include <string>
|
||
#include <set>
|
||
#include <map>
|
||
|
||
|
||
|
||
// How big is the vertex buffer for batching lines in total?
|
||
// NOTE: This must be a multiple of the batch size below!!! (crashes will occur if it isn't)
|
||
#define LINE_BUFFER_TOTAL_SIZE 1000
|
||
|
||
// How many lines do we put in the buffer in between flushes?
|
||
//
|
||
// This should be enough smaller than the total size so that draw calls
|
||
// can finish using the data before we wrap around and discard it.
|
||
#define LINE_BUFFER_BATCH_SIZE 250
|
||
|
||
// How big is the vertex buffer for batching points in total?
|
||
// NOTE: This must be a multiple of the batch size below!!! (crashes will occur if it isn't)
|
||
#define POINT_BUFFER_TOTAL_SIZE 1800
|
||
|
||
// How many points do we put in the buffer in between flushes?
|
||
//
|
||
// This should be enough smaller than the total size so that draw calls
|
||
// can finish using the data before we wrap around and discard it.
|
||
#define POINT_BUFFER_BATCH_SIZE 600
|
||
|
||
// How big is the vertex buffer for batching quads in total?
|
||
// NOTE: This must be a multiple of the batch size below!!! (crashes will occur if it isn't)
|
||
#define QUAD_BUFFER_TOTAL_SIZE 1000
|
||
|
||
// How many quads do we put in the buffer in between flushes?
|
||
//
|
||
// This should be enough smaller than the total size so that draw calls
|
||
// can finish using the data before we wrap around and discard it.
|
||
#define QUAD_BUFFER_BATCH_SIZE 250
|
||
|
||
|
||
|
||
|
||
#ifndef DX9MODE
|
||
#define DX9MODE 0 // change to 1 to turn on the DX9 mode
|
||
#endif
|
||
|
||
#if DX9MODE
|
||
#include "../glmgr/dxabstract.h"
|
||
|
||
class CShowPixelsParams
|
||
{
|
||
public:
|
||
GLuint m_srcTexName;
|
||
int m_width,m_height;
|
||
};
|
||
|
||
// Vertex struct for line batches
|
||
struct LineVertex_t
|
||
{
|
||
float x, y, z, rhw;
|
||
DWORD color;
|
||
};
|
||
|
||
|
||
// Vertex struct for point batches
|
||
struct PointVertex_t
|
||
{
|
||
float x, y, z, rhw;
|
||
DWORD color;
|
||
};
|
||
|
||
// Vertex struct for textured quads
|
||
struct TexturedQuadVertex_t
|
||
{
|
||
float x, y, z, rhw;
|
||
DWORD color;
|
||
float u, v; // texture coordinates
|
||
};
|
||
|
||
#endif
|
||
|
||
|
||
class CVoiceContext;
|
||
|
||
class CGameEngineGL : public IGameEngine
|
||
{
|
||
public:
|
||
|
||
// Constructor
|
||
CGameEngineGL();
|
||
|
||
// Destructor
|
||
~CGameEngineGL() { Shutdown(); }
|
||
|
||
// Check if the game engine is initialized ok and ready for use
|
||
bool BReadyForUse() { return m_bEngineReadyForUse; }
|
||
|
||
// Check if the engine is shutting down
|
||
bool BShuttingDown() { return m_bShuttingDown; }
|
||
|
||
// Set the background color
|
||
void SetBackgroundColor( short a, short r, short g, short b );
|
||
|
||
// Start a frame, clear(), beginscene(), etc
|
||
bool StartFrame();
|
||
|
||
// Finish a frame, endscene(), present(), etc.
|
||
void EndFrame();
|
||
|
||
// Shutdown the game engine
|
||
void Shutdown();
|
||
|
||
// Pump messages from the OS
|
||
void MessagePump();
|
||
|
||
// Accessors for game screen size
|
||
int32 GetViewportWidth() { return m_nWindowWidth; }
|
||
int32 GetViewportHeight() { return m_nWindowHeight; }
|
||
|
||
// Function for drawing text to the screen, dwFormat is a combination of flags like DT_LEFT, TEXTPOS_VCENTER etc...
|
||
// on OSX client with DX9MODE=1, the HGAMEFONT is a texture with the glyphs in a 16x16 grid (see "g_glmDebugFontMap" in glmgrbasics.cpp)
|
||
bool BDrawString( HGAMEFONT hFont, RECT rect, DWORD dwColor, DWORD dwFormat, const char *pchText );
|
||
|
||
// Create a new font returning our internal handle value for it (0 means failure)
|
||
HGAMEFONT HCreateFont( int nHeight, int nFontWeight, bool bItalic, const char * pchFont );
|
||
|
||
// Create a new texture returning our internal handle value for it (0 means failure)
|
||
HGAMETEXTURE HCreateTexture( byte *pRGBAData, uint32 uWidth, uint32 uHeight, ETEXTUREFORMAT eTextureFormat = eTextureFormat_RGBA );
|
||
|
||
// update an existing texture
|
||
bool UpdateTexture( HGAMETEXTURE texture, byte *pRGBAData, uint32 uWidth, uint32 uHeight, ETEXTUREFORMAT eTextureFormat );
|
||
|
||
// Draw a line, the engine itself will manage batching these (although you can explicitly flush if you need to)
|
||
bool BDrawLine( float xPos0, float yPos0, DWORD dwColor0, float xPos1, float yPos1, DWORD dwColor1 );
|
||
|
||
// Flush the line buffer
|
||
bool BFlushLineBuffer();
|
||
|
||
// Draw a point, the engine itself will manage batching these (although you can explicitly flush if you need to)
|
||
bool BDrawPoint( float xPos, float yPos, DWORD dwColor );
|
||
|
||
// Flush the point buffer
|
||
bool BFlushPointBuffer();
|
||
|
||
// Draw a filled quad
|
||
bool BDrawFilledRect( float xPos0, float yPos0, float xPos1, float yPos1, DWORD dwColor );
|
||
|
||
// Draw a textured rectangle
|
||
bool BDrawTexturedRect( float xPos0, float yPos0, float xPos1, float yPos1,
|
||
float u0, float v0, float u1, float v1, DWORD dwColor, HGAMETEXTURE hTexture );
|
||
|
||
// Draw a textured arbitrary quad
|
||
bool BDrawTexturedQuad( float xPos0, float yPos0, float xPos1, float yPos1, float xPos2, float yPos2, float xPos3, float yPos3,
|
||
float u0, float v0, float u1, float v1, DWORD dwColor, HGAMETEXTURE hTexture );
|
||
|
||
// Flush any still cached quad buffers
|
||
bool BFlushQuadBuffer();
|
||
|
||
// Get the current state of a key
|
||
bool BIsKeyDown( DWORD dwVK );
|
||
|
||
// Get the first (in some arbitrary order) key down, if any
|
||
bool BGetFirstKeyDown( DWORD *pdwVK );
|
||
|
||
// Return true if there is an active Steam Input device
|
||
bool BIsSteamInputDeviceActive( );
|
||
|
||
// Find the active device
|
||
void FindActiveSteamInputDevice( );
|
||
|
||
// Get the current state of a controller action
|
||
bool BIsControllerActionActive( ECONTROLLERDIGITALACTION dwAction );
|
||
|
||
// Get the current state of a controller action
|
||
void GetControllerAnalogAction( ECONTROLLERANALOGACTION dwAction, float *x, float *y );
|
||
|
||
// Set the current Steam Controller Action set
|
||
void SetSteamControllerActionSet( ECONTROLLERACTIONSET dwActionSet );
|
||
|
||
// Set an Action Set Layer for Steam Input
|
||
virtual void ActivateSteamControllerActionSetLayer( ECONTROLLERACTIONSET dwActionSet );
|
||
virtual void DeactivateSteamControllerActionSetLayer( ECONTROLLERACTIONSET dwActionSet );
|
||
|
||
// Returns whether a given action set layer is active
|
||
virtual bool BIsActionSetLayerActive( ECONTROLLERACTIONSET dwActionSetLayer );
|
||
|
||
// These calls return a string describing which controller button the action is currently bound to
|
||
const char *GetTextStringForControllerOriginDigital( ECONTROLLERACTIONSET dwActionSet, ECONTROLLERDIGITALACTION dwDigitalAction );
|
||
const char *GetTextStringForControllerOriginAnalog( ECONTROLLERACTIONSET dwActionSet, ECONTROLLERANALOGACTION dwDigitalAction );
|
||
|
||
// Set the controller LED Color, if available
|
||
void SetControllerColor( uint8 nColorR, uint8 nColorG, uint8 nColorB, unsigned int nFlags );
|
||
|
||
// Set the trigger effect on DualSense controllers
|
||
void SetTriggerEffect( bool bEnabled );
|
||
|
||
// Trigger a vibration on the controller, if available
|
||
void TriggerControllerVibration( unsigned short nLeftSpeed, unsigned short nRightSpeed );
|
||
|
||
// Trigger haptics on the specified pad of the controller, if available
|
||
void TriggerControllerHaptics( ESteamControllerPad ePad, unsigned short usOnMicroSec, unsigned short usOffMicroSec, unsigned short usRepeat );
|
||
|
||
// Initialize the Steam Input interface
|
||
void InitSteamInput( );
|
||
|
||
// Called each frame to update the Steam Input interface
|
||
void PollSteamInput();
|
||
|
||
// Get current tick count for the game engine
|
||
uint64 GetGameTickCount() { return m_ulGameTickCount; }
|
||
|
||
// Get the tick count elapsed since the previous frame
|
||
// bugbug - We use this time to compute things like thrust and acceleration in the game,
|
||
// so it's important in doesn't jump ahead by large increments... Need a better
|
||
// way to handle that.
|
||
uint64 GetGameTicksFrameDelta() { return m_ulGameTickCount - m_ulPreviousGameTickCount; }
|
||
|
||
// Tell the game engine to update current tick count
|
||
void UpdateGameTickCount();
|
||
|
||
// Tell the game engine to sleep for a bit if needed to limit frame rate
|
||
bool BSleepForFrameRateLimit( uint32 ulMaxFrameRate );
|
||
|
||
// Check if the game engine hwnd currently has focus (and a working d3d device)
|
||
bool BGameEngineHasFocus() { return true; }
|
||
|
||
// Voice chat functions
|
||
virtual HGAMEVOICECHANNEL HCreateVoiceChannel();
|
||
virtual void DestroyVoiceChannel( HGAMEVOICECHANNEL hChannel );
|
||
virtual bool AddVoiceData( HGAMEVOICECHANNEL hChannel, const uint8 *pVoiceData, uint32 uLength );
|
||
|
||
#if DX9MODE
|
||
#else
|
||
void AdjustViewport();
|
||
|
||
#endif
|
||
|
||
// Initialize graphics in either GL or DX9 form
|
||
bool BInitializeGraphics();
|
||
|
||
// Initialize the debug font library
|
||
bool BInitializeCellDbgFont();
|
||
|
||
bool BInitializeAudio();
|
||
|
||
void RunAudio();
|
||
|
||
void UpdateKey( uint32_t vkKey, int nDown );
|
||
|
||
// Tracks whether the engine is ready for use
|
||
bool m_bEngineReadyForUse;
|
||
|
||
// Tracks if we are shutting down
|
||
bool m_bShuttingDown;
|
||
|
||
// Size of the window to display the game in
|
||
int32 m_nWindowWidth;
|
||
int32 m_nWindowHeight;
|
||
|
||
// Current game time in milliseconds
|
||
uint64 m_ulGameTickCount;
|
||
|
||
// Game time at the start of the previous frame
|
||
uint64 m_ulPreviousGameTickCount;
|
||
|
||
#if DX9MODE
|
||
// Windows code transplants--------------------------------------------------------
|
||
|
||
// Resets all the render, texture, and sampler states to our defaults
|
||
void ResetRenderStates();
|
||
|
||
// Create a new vertex buffer returning our internal handle for it (0 means failure)
|
||
HGAMEVERTBUF HCreateVertexBuffer( uint32 nSizeInBytes, DWORD dwUsage, DWORD dwFVF );
|
||
|
||
// Lock an entire vertex buffer with the specified flags
|
||
bool BLockEntireVertexBuffer( HGAMEVERTBUF hVertBuf, void **ppVoid, DWORD dwFlags );
|
||
|
||
// Unlock a vertex buffer
|
||
bool BUnlockVertexBuffer( HGAMEVERTBUF hVertBuf );
|
||
|
||
// Release a vertex buffer and free its resources
|
||
bool BReleaseVertexBuffer( HGAMEVERTBUF hVertBuf );
|
||
|
||
// set vertex decl
|
||
bool BSetVertexDeclaration( IDirect3DVertexDeclaration9 *decl );
|
||
|
||
// Set stream source
|
||
bool BSetStreamSource( uint streamNumber, HGAMEVERTBUF hVertBuf, uint32 uOffset, uint32 uStride );
|
||
|
||
// Set shaders
|
||
bool BSetShaders( IDirect3DVertexShader9 *vsh, IDirect3DPixelShader9 *psh );
|
||
|
||
// Render primitives out of the current stream source
|
||
bool BRenderPrimitive( D3DPRIMITIVETYPE primType, uint32 uStartVertex, uint32 uCount );
|
||
|
||
bool BUberRenderPrimitive( IDirect3DVertexShader9 *vsh,
|
||
IDirect3DPixelShader9 *psh,
|
||
IDirect3DVertexDeclaration9 *decl,
|
||
uint streamNumber,
|
||
HGAMEVERTBUF hVertBuf,
|
||
uint32 uOffset,
|
||
uint32 uStride,
|
||
D3DPRIMITIVETYPE primType,
|
||
uint32 uStartVertex,
|
||
uint32 uCount );
|
||
|
||
// fake hwnd is a WindowRef ( = [m_window windowRef] )
|
||
void *m_hwnd;
|
||
|
||
// IDirect3D9 interface
|
||
IDirect3D9 *m_pD3D9Interface;
|
||
|
||
// IDirect3DDevice9 interface
|
||
IDirect3DDevice9 *m_pD3D9Device;
|
||
|
||
// Presentation parameters - device resets don't happen on OS X, but just for commonality with windows code
|
||
D3DPRESENT_PARAMETERS m_d3dpp;
|
||
|
||
// vertex declarations - one per vertex layout used
|
||
IDirect3DVertexDeclaration9 *m_decl_P4C1; // aka D3DFVF_XYZRHW | D3DFVF_DIFFUSE
|
||
// (4 floats pos, one ubyte4 color) - 20 bytes / vert
|
||
|
||
IDirect3DVertexDeclaration9 *m_decl_P4C1T2; // aka D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1
|
||
// (4 floats pos, one ubyte4 color, 2 floats texc) - 28 bytes / vert
|
||
|
||
// vertex and pixel shaders - one per vertex layout
|
||
IDirect3DVertexShader9 *m_vsh_P4C1;
|
||
IDirect3DVertexShader9 *m_vsh_P4C1T2;
|
||
IDirect3DPixelShader9 *m_psh_P4C1;
|
||
IDirect3DPixelShader9 *m_psh_P4C1T2;
|
||
|
||
|
||
// Color we clear the background of the window to each frame
|
||
DWORD m_dwBackgroundColor;
|
||
|
||
// Next vertex buffer handle value to give out
|
||
HGAMEVERTBUF m_nNextVertBufferHandle;
|
||
|
||
// Map of handles to vertex buffer objects
|
||
struct VertBufData_t
|
||
{
|
||
bool m_bIsLocked;
|
||
IDirect3DVertexBuffer9 * m_pBuffer;
|
||
};
|
||
std::map<HGAMEVERTBUF, VertBufData_t> m_MapVertexBuffers;
|
||
|
||
HGAMETEXTURE m_nNextTextureHandle;
|
||
|
||
// Map of handles to texture objects
|
||
struct TextureData_t
|
||
{
|
||
byte *m_pRGBAData; // We keep a copy of the raw data so we can rebuild textures after a device is lost
|
||
uint32 m_uWidth;
|
||
uint32 m_uHeight;
|
||
LPDIRECT3DTEXTURE9 m_pTexture;
|
||
};
|
||
std::map<HGAMETEXTURE, TextureData_t> m_MapTextures;
|
||
|
||
// Internal vertex buffer for batching line drawing
|
||
HGAMEVERTBUF m_hLineBuffer;
|
||
|
||
// Pointer to actual line buffer memory (valid only while locked)
|
||
LineVertex_t *m_pLineVertexes;
|
||
|
||
// Track how many lines are awaiting flushing in our line buffer
|
||
DWORD m_dwLinesToFlush;
|
||
|
||
// Track where the current batch starts in the vert buffer
|
||
DWORD m_dwLineBufferBatchPos;
|
||
|
||
// Internal vertex buffer for batching point drawing
|
||
HGAMEVERTBUF m_hPointBuffer;
|
||
|
||
// Pointer to actual point buffer memory (valid only while locked)
|
||
PointVertex_t *m_pPointVertexes;
|
||
|
||
// Track how many points are awaiting flushing in our line buffer
|
||
DWORD m_dwPointsToFlush;
|
||
|
||
// Track where the current batch starts in the vert buffer
|
||
DWORD m_dwPointBufferBatchPos;
|
||
|
||
// Vertex buffer for textured quads
|
||
HGAMEVERTBUF m_hQuadBuffer;
|
||
|
||
// Last texture used in drawing a batched quad
|
||
HGAMETEXTURE m_hLastTexture;
|
||
|
||
// Pointer to quad vertex data
|
||
TexturedQuadVertex_t *m_pQuadVertexes;
|
||
|
||
// How many quads are awaiting flushing
|
||
DWORD m_dwQuadsToFlush;
|
||
|
||
// Where does the current batch begin
|
||
DWORD m_dwQuadBufferBatchPos;
|
||
|
||
// White texture used when drawing filled quads
|
||
HGAMETEXTURE m_hTextureWhite;
|
||
|
||
// font stuff
|
||
HGAMEFONT m_nNextFontHandle;
|
||
std::map< HGAMEFONT, HGAMETEXTURE > m_MapGameFonts;
|
||
|
||
//CocoaMgr transplants-------------------------------------------------------------
|
||
GLMDisplayDB *GetDisplayDB ( void );
|
||
void GetRendererInfo ( GLMRendererInfoFields *rendInfoOut );
|
||
PseudoNSGLContextPtr GetNSGLContextForWindow( void* windowref );
|
||
void RenderedSize ( uint &width, uint &height, bool set ); // either set or retrieve rendered size value (from dxabstract)
|
||
void DisplayedSize ( uint &width, uint &height ); // query backbuffer size (window size whether FS or windowed)
|
||
void ShowPixels ( CShowPixelsParams *params ); // present
|
||
|
||
|
||
GLMDisplayDB *m_displayDB;
|
||
#else
|
||
// White texture used when drawing filled quads
|
||
HGAMETEXTURE m_hTextureWhite;
|
||
|
||
// Pointer to actual data for points
|
||
GLfloat *m_rgflPointsData;
|
||
GLubyte *m_rgflPointsColorData;
|
||
|
||
// How many points are outstanding needing flush
|
||
DWORD m_dwPointsToFlush;
|
||
|
||
// Pointer to actual data for lines
|
||
GLfloat *m_rgflLinesData;
|
||
GLubyte *m_rgflLinesColorData;
|
||
|
||
|
||
// How many lines are outstanding needing flush
|
||
DWORD m_dwLinesToFlush;
|
||
|
||
// Pointer to actual data for quads
|
||
GLfloat *m_rgflQuadsData;
|
||
GLubyte *m_rgflQuadsColorData;
|
||
GLfloat *m_rgflQuadsTextureData;
|
||
|
||
// How many lines are outstanding needing flush
|
||
DWORD m_dwQuadsToFlush;
|
||
|
||
// Map of font handles we have given out
|
||
HGAMEFONT m_nNextFontHandle;
|
||
std::map< HGAMEFONT, void* > m_MapGameFonts;
|
||
|
||
// Map of handles to texture objects
|
||
struct TextureData_t
|
||
{
|
||
uint32 m_uWidth;
|
||
uint32 m_uHeight;
|
||
GLuint m_uTextureID;
|
||
};
|
||
std::map<HGAMETEXTURE, TextureData_t> m_MapTextures;
|
||
HGAMETEXTURE m_nNextTextureHandle;
|
||
|
||
// Last bound texture, used to know when we must flush
|
||
HGAMETEXTURE m_hLastTexture;
|
||
#endif
|
||
|
||
// Map of button state, translated to VK for win32.
|
||
std::set< DWORD > m_SetKeysDown;
|
||
|
||
ALCcontext* m_palContext;
|
||
ALCdevice* m_palDevice;
|
||
|
||
// Map of voice handles
|
||
std::map<HGAMEVOICECHANNEL, CVoiceContext* > m_MapVoiceChannel;
|
||
uint32 m_unVoiceChannelCount;
|
||
|
||
#if OBJC_ENABLED
|
||
// any objective-c members go at the end of the class in a block
|
||
// they are invisible to callers in pure C++ files
|
||
// that also means callers in pure C++ files must not try to instantiate or destroy this type of object
|
||
|
||
#if DX9MODE
|
||
#else
|
||
std::map< std::string, GLString * > m_MapStrings;
|
||
#endif
|
||
|
||
NSOpenGLView *m_view;
|
||
NSWindow *m_window;
|
||
#endif
|
||
|
||
// An array of handles to Steam Controller events that player can bind to controls
|
||
InputDigitalActionHandle_t m_ControllerDigitalActionHandles[eControllerDigitalAction_NumActions];
|
||
|
||
// An array of handles to Steam Controller events that player can bind to controls
|
||
InputAnalogActionHandle_t m_ControllerAnalogActionHandles[eControllerAnalogAction_NumActions];
|
||
|
||
// An array of handles to different Steam Controller action set configurations
|
||
InputActionSetHandle_t m_ControllerActionSetHandles[eControllerActionSet_NumSets];
|
||
|
||
// A handle to the currently active Steam Controller.
|
||
InputHandle_t m_ActiveControllerHandle;
|
||
|
||
// Origins for all the Steam Input actions. The 'origin' is where the action is currently bound to,
|
||
// ie 'jump' is currently bound to the Steam Controller 'A' button.
|
||
EInputActionOrigin m_ControllerDigitalActionOrigins[eControllerDigitalAction_NumActions];
|
||
EInputActionOrigin m_ControllerAnalogActionOrigins[eControllerDigitalAction_NumActions];
|
||
|
||
};
|
||
|
||
#endif // GAMEENGINEOSX_H
|