357 lines
8.8 KiB
C++
357 lines
8.8 KiB
C++
// Copyright (C) 2003-2008 Dolphin Project.
|
|
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, version 2.0.
|
|
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License 2.0 for more details.
|
|
|
|
// A copy of the GPL 2.0 should have been included with the program.
|
|
// If not, see http://www.gnu.org/licenses/
|
|
|
|
// Official SVN repository and contact information can be found at
|
|
// http://code.google.com/p/dolphin-emu/
|
|
|
|
// several global utilities not really tied to core emulation
|
|
#ifndef _GLOBALS_H
|
|
#define _GLOBALS_H
|
|
|
|
#define LOGGING
|
|
|
|
#include "Common.h"
|
|
#include "x64Emitter.h"
|
|
|
|
#ifdef _WIN32
|
|
|
|
#include <windows.h>
|
|
#include <windowsx.h>
|
|
#include <mmsystem.h>
|
|
|
|
#include "resource.h"
|
|
|
|
void OpenConsole();
|
|
void CloseConsole();
|
|
|
|
#define GLEW_STATIC
|
|
|
|
#include "GL/glew.h"
|
|
#include "GL/wglew.h"
|
|
#include "GL/gl.h"
|
|
#include "GL/glext.h"
|
|
|
|
#else // linux basic definitions
|
|
|
|
#define ARRAYSIZE(A) (sizeof(A)/sizeof((A)[0]))
|
|
#define I_NEED_OS2_H // HAXXOR
|
|
//#include <GL/glew.h>
|
|
#include <GL/glxew.h>
|
|
#include <GL/gl.h>
|
|
//#include <GL/glx.h>
|
|
#define __inline inline
|
|
|
|
#include <sys/timeb.h> // ftime(), struct timeb
|
|
|
|
inline unsigned long timeGetTime()
|
|
{
|
|
#ifdef _WIN32
|
|
_timeb t;
|
|
_ftime(&t);
|
|
#else
|
|
timeb t;
|
|
ftime(&t);
|
|
#endif
|
|
|
|
return (unsigned long)(t.time*1000+t.millitm);
|
|
}
|
|
|
|
struct RECT
|
|
{
|
|
int left, top;
|
|
int right, bottom;
|
|
};
|
|
|
|
#endif // linux basic definitions
|
|
|
|
#include <Cg/cg.h>
|
|
#include <Cg/cgGL.h>
|
|
|
|
#ifndef GL_DEPTH24_STENCIL8_EXT // allows FBOs to support stencils
|
|
#define GL_DEPTH_STENCIL_EXT 0x84F9
|
|
#define GL_UNSIGNED_INT_24_8_EXT 0x84FA
|
|
#define GL_DEPTH24_STENCIL8_EXT 0x88F0
|
|
#define GL_TEXTURE_STENCIL_SIZE_EXT 0x88F1
|
|
#endif
|
|
|
|
// several macros
|
|
#ifndef SAFE_DELETE_ARRAY
|
|
#define SAFE_DELETE_ARRAY(x) if( (x) != NULL ) { delete[] (x); (x) = NULL; }
|
|
#endif
|
|
#ifndef SAFE_RELEASE
|
|
#define SAFE_RELEASE(x) if( (x) != NULL ) { (x)->Release(); (x) = NULL; }
|
|
#endif
|
|
|
|
#define SAFE_RELEASE_CGPROG(x) { if( (x) != NULL ) { cgDestroyProgram(x); x = NULL; } }
|
|
#define SAFE_RELEASE_PROG(x) { if( (x) != 0 ) { glDeleteProgramsARB(1, &(x)); x = 0; } }
|
|
#define SAFE_RELEASE_TEX(x) { if( (x) != 0 ) { glDeleteTextures(1, &(x)); x = 0; } }
|
|
#define SAFE_RELEASE_BUF(x) { if( (x) != 0 ) { glDeleteBuffers(1, &(x)); x = 0; } }
|
|
|
|
#define FORIT(it, v) for(it = (v).begin(); it != (v).end(); ++(it))
|
|
|
|
#define ERROR_LOG __Log
|
|
|
|
#ifdef _DEBUG
|
|
#define INFO_LOG if( g_Config.iLog & 1 ) __Log
|
|
#define PRIM_LOG if( g_Config.iLog & 2 ) __Log
|
|
#define DEBUG_LOG __Log
|
|
#else
|
|
#define INFO_LOG(...)
|
|
#define PRIM_LOG(...)
|
|
#define DEBUG_LOG(...)
|
|
#endif
|
|
|
|
#define GL_REPORT_ERROR() { err = glGetError(); if( err != GL_NO_ERROR ) { ERROR_LOG("%s:%d: gl error 0x%x\n", __FILE__, (int)__LINE__, err); HandleGLError(); } }
|
|
|
|
#ifdef _DEBUG
|
|
#define GL_REPORT_ERRORD() { GLenum err = glGetError(); if( err != GL_NO_ERROR ) { ERROR_LOG("%s:%d: gl error 0x%x\n", __FILE__, (int)__LINE__, err); HandleGLError(); } }
|
|
#else
|
|
#define GL_REPORT_ERRORD()
|
|
#endif
|
|
|
|
#ifndef ARRAY_SIZE
|
|
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
|
|
#endif
|
|
|
|
#define BEGINSAVELOAD char *optr=ptr;
|
|
#define SAVELOAD(what,size) memcpy((void*)((save)?(void*)(ptr):(void*)(what)),(void*)((save)?(void*)(what):(void*)(ptr)),(size)); ptr+=(size);
|
|
#define ENDSAVELOAD return ptr-optr;
|
|
|
|
struct TEXTUREFMT
|
|
{
|
|
TEXTUREFMT(GLenum format, GLenum type) : type(type), format(format) {}
|
|
GLenum type, format;
|
|
};
|
|
|
|
extern int frameCount;
|
|
extern int lut3to8[8];
|
|
extern int lut4to8[16];
|
|
extern int lut5to8[32];
|
|
extern int lut6to8[64];
|
|
extern float lutu8tosfloat[256];
|
|
extern float lutu8toufloat[256];
|
|
extern float luts8tosfloat[256];
|
|
|
|
#define NUMWNDRES 6
|
|
extern int g_Res[NUMWNDRES][2];
|
|
|
|
#define CONF_LOG 1
|
|
#define CONF_PRIMLOG 2
|
|
#define CONF_SAVETEXTURES 4
|
|
#define CONF_SAVETARGETS 8
|
|
|
|
struct Config
|
|
{
|
|
Config();
|
|
void Load();
|
|
void Save();
|
|
|
|
int iAdapter;
|
|
int iFSResolution;
|
|
int iMultisampleMode;
|
|
|
|
int iPostprocessEffect;
|
|
int iCompileDLsLevel;
|
|
|
|
int iLog; // CONF_ bits
|
|
bool bFullscreen;
|
|
bool bWireFrame;
|
|
bool bOverlayStats;
|
|
bool bDumpTextures;
|
|
bool bOldCard;
|
|
bool bShowShaderErrors;
|
|
//enhancements
|
|
bool bForceFiltering;
|
|
bool bForceMaxAniso;
|
|
|
|
bool bPreUpscale;
|
|
int iPreUpscaleFilter;
|
|
|
|
bool bTruform;
|
|
int iTruformLevel;
|
|
|
|
int iWindowedRes;
|
|
int aa; // anti-aliasing level
|
|
|
|
char psProfile[16];
|
|
char vsProfile[16];
|
|
|
|
int iSaveTargetId;
|
|
|
|
char texDumpPath[280];
|
|
};
|
|
|
|
extern Config g_Config;
|
|
|
|
struct Statistics
|
|
{
|
|
int numPrimitives;
|
|
|
|
int numPixelShadersCreated;
|
|
int numPixelShadersAlive;
|
|
int numVertexShadersCreated;
|
|
int numVertexShadersAlive;
|
|
|
|
int numTexturesCreated;
|
|
int numTexturesAlive;
|
|
|
|
int numRenderTargetsCreated;
|
|
int numRenderTargetsAlive;
|
|
|
|
int numDListsCalled;
|
|
int numDListsCreated;
|
|
int numDListsAlive;
|
|
|
|
int numJoins;
|
|
|
|
struct ThisFrame
|
|
{
|
|
int numBPLoads;
|
|
int numCPLoads;
|
|
int numXFLoads;
|
|
|
|
int numBPLoadsInDL;
|
|
int numCPLoadsInDL;
|
|
int numXFLoadsInDL;
|
|
|
|
int numDLs;
|
|
int numDLPrims;
|
|
int numPrims;
|
|
int numShaderChanges;
|
|
int numBadCommands; //hope this always is zero ;)
|
|
};
|
|
ThisFrame thisFrame;
|
|
void ResetFrame();
|
|
};
|
|
|
|
extern Statistics stats;
|
|
|
|
#define STATISTICS
|
|
|
|
#ifdef STATISTICS
|
|
#define INCSTAT(a) (a)++;
|
|
#define ADDSTAT(a,b) (a)+=(b);
|
|
#define SETSTAT(a,x) (a)=(int)(x);
|
|
#else
|
|
#define INCSTAT(a) ;
|
|
#define ADDSTAT(a,b) ;
|
|
#define SETSTAT(a,x) ;
|
|
#endif
|
|
|
|
void DebugLog(const char* _fmt, ...);
|
|
void __Log(const char *format, ...);
|
|
void __Log(int type, const char *format, ...);
|
|
void SysMessage(const char *fmt, ...);
|
|
void HandleGLError();
|
|
|
|
void InitLUTs();
|
|
bool SaveJPEG(const char* filename, int image_width, int image_height, const void* pdata, int quality);
|
|
bool SaveTGA(const char* filename, int width, int height, void* pdata);
|
|
bool SaveTexture(const char* filename, u32 textarget, u32 tex, int width, int height);
|
|
|
|
#if defined(_MSC_VER) && !defined(__x86_64__) && !defined(_M_X64)
|
|
void * memcpy_amd(void *dest, const void *src, size_t n);
|
|
unsigned char memcmp_mmx(const void* src1, const void* src2, int cmpsize);
|
|
#define memcpy_gc memcpy_amd
|
|
#define memcmp_gc memcmp_mmx
|
|
#else
|
|
#define memcpy_gc memcpy
|
|
#define memcmp_gc memcmp
|
|
#endif
|
|
|
|
//#define RAM_MASK 0x1FFFFFF
|
|
|
|
#include "main.h"
|
|
|
|
inline u8 *Memory_GetPtr(u32 _uAddress)
|
|
{
|
|
return g_VideoInitialize.pGetMemoryPointer(_uAddress);//&g_pMemory[_uAddress & RAM_MASK];
|
|
}
|
|
|
|
inline u8 Memory_Read_U8(u32 _uAddress)
|
|
{
|
|
return *(u8*)g_VideoInitialize.pGetMemoryPointer(_uAddress);//g_pMemory[_uAddress & RAM_MASK];
|
|
}
|
|
|
|
inline u16 Memory_Read_U16(u32 _uAddress)
|
|
{
|
|
return Common::swap16(*(u16*)g_VideoInitialize.pGetMemoryPointer(_uAddress));
|
|
//return _byteswap_ushort(*(u16*)&g_pMemory[_uAddress & RAM_MASK]);
|
|
}
|
|
|
|
inline u32 Memory_Read_U32(u32 _uAddress)
|
|
{
|
|
return Common::swap32(*(u32*)g_VideoInitialize.pGetMemoryPointer(_uAddress));
|
|
//return _byteswap_ulong(*(u32*)&g_pMemory[_uAddress & RAM_MASK]);
|
|
}
|
|
|
|
inline float Memory_Read_Float(u32 _uAddress)
|
|
{
|
|
union {u32 i; float f;} temp;
|
|
temp.i = Memory_Read_U32(_uAddress);
|
|
return temp.f;
|
|
}
|
|
|
|
////
|
|
// profiling
|
|
///
|
|
|
|
extern int g_bWriteProfile; // global variable to enable/disable profiling (if DVPROFILE is defined)
|
|
|
|
// IMPORTANT: For every Reigster there must be an End
|
|
void DVProfRegister(const char* pname); // first checks if this profiler exists in g_listProfilers
|
|
void DVProfEnd(u32 dwUserData);
|
|
void DVProfWrite(const char* pfilename, u32 frames = 0);
|
|
void DVProfClear(); // clears all the profilers
|
|
|
|
//#define DVPROFILE // comment out to disable profiling
|
|
|
|
#if defined(DVPROFILE) && (defined(_WIN32)||defined(WIN32))
|
|
|
|
#ifdef _MSC_VER
|
|
|
|
#ifndef __PRETTY_FUNCTION__
|
|
#define __PRETTY_FUNCTION__ __FUNCTION__
|
|
#endif
|
|
|
|
#endif
|
|
|
|
#define DVSTARTPROFILE() DVProfileFunc _pf(__PRETTY_FUNCTION__);
|
|
|
|
class DVProfileFunc
|
|
{
|
|
public:
|
|
u32 dwUserData;
|
|
DVProfileFunc(const char* pname) { DVProfRegister(pname); dwUserData = 0; }
|
|
DVProfileFunc(const char* pname, u32 dwUserData) : dwUserData(dwUserData) { DVProfRegister(pname); }
|
|
~DVProfileFunc() { DVProfEnd(dwUserData); }
|
|
};
|
|
|
|
#else
|
|
|
|
#define DVSTARTPROFILE()
|
|
|
|
class DVProfileFunc
|
|
{
|
|
public:
|
|
u32 dwUserData;
|
|
__forceinline DVProfileFunc(const char* pname) {}
|
|
__forceinline DVProfileFunc(const char* pname, u32 dwUserData) { }
|
|
~DVProfileFunc() {}
|
|
};
|
|
|
|
#endif
|
|
|
|
#endif
|