bool ofFbo::checkGLSupport() {
#ifndef TARGET_OPENGLES
if(CheckExtension("GL_EXT_framebuffer_object")){
ofLog(OF_LOG_VERBOSE,"FBO supported");
}else{
ofLog(OF_LOG_ERROR, "FBO not supported by this graphics card");
return false;
}
glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS, &_maxColorAttachments);
glGetIntegerv(GL_MAX_DRAW_BUFFERS, &_maxDrawBuffers);
glGetIntegerv(GL_MAX_SAMPLES, &_maxSamples);
ofLog(OF_LOG_NOTICE, string("ofFbo::checkGLSupport()\n") +
"maxColorAttachments: " + ofToString(_maxColorAttachments) + "\n" +
"maxDrawBuffers: " + ofToString(_maxDrawBuffers) + "\n" +
"maxSamples: " + ofToString(_maxSamples)
);
#else
if(CheckExtension("GL_OES_framebuffer_object")){
ofLog(OF_LOG_VERBOSE,"FBO supported");
}else{
ofLog(OF_LOG_ERROR, "FBO not supported by this graphics card");
return false;
}
string extensions = (char*)glGetString(GL_EXTENSIONS);
ofLog(OF_LOG_VERBOSE,extensions);
#endif
return true;
}
bool ofFbo::checkGLSupport() {
#ifndef TARGET_OPENGLES
if(CheckExtension("GL_EXT_framebuffer_object")){
ofLogVerbose("ofFbo") << "FBO supported";
}else{
ofLogError("ofFbo") << "FBO not supported by this graphics card";
return false;
}
glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS, &_maxColorAttachments);
glGetIntegerv(GL_MAX_DRAW_BUFFERS, &_maxDrawBuffers);
glGetIntegerv(GL_MAX_SAMPLES, &_maxSamples);
ofLogVerbose("ofFbo") << "checkGLSupport()"
<< "maxColorAttachments: " << _maxColorAttachments
<< "maxDrawBuffers: " << _maxDrawBuffers
<< "maxSamples: " << _maxSamples;
#else
if(CheckExtension("GL_OES_framebuffer_object")){
ofLogVerbose("ofFbo") << "FBO supported";
}else{
ofLogError("ofFbo") << "FBO not supported by this graphics card";
return false;
}
string extensions = (char*)glGetString(GL_EXTENSIONS);
ofLogVerbose("ofFbo") << extensions;
#endif
return true;
}
void ParticleInstancingRenderer::Initialize() {
// Initialize can be called at any time - don't actually initialize
// more than once.
if (is_initialized)
return;
is_initialized = true;
extensions_supported = false;
// check for the extensions that are required
GLboolean shader4_supported = CheckExtension("GL_EXT_gpu_shader4");
if (shader4_supported)
debug2 << "ParticleInstancingRenderer: Extension GL_EXT_gpu_shader4 supported" << endl;
else
debug2 << "ParticleInstancingRenderer: Extension GL_EXT_gpu_shader4 not supported" << endl;
GLboolean tbo_supported = CheckExtension("GL_EXT_texture_buffer_object");
if (tbo_supported)
debug2 << "ParticleInstancingRenderer: Extension GL_EXT_texture_buffer_object supported" << endl;
else
debug2 << "ParticleInstancingRenderer: Extension GL_EXT_texture_buffer_object not supported" << endl;
extensions_supported = (shader4_supported && tbo_supported);
if (extensions_supported) {
debug1 << "ParticleInstancingRenderer: Necessary extensions supported, "
<< "using the new Molecule plot implementation." << endl;
}
else
{
debug1 << "ParticleInstancingRenderer: Necessary extensions not supported, "
<< "using the old Molecule plot implementation." << endl;
}
// don't do any more if the extensions aren't supported
if (!extensions_supported)
return;
//
GLint max_texture_buffer_size;
glGetIntegerv(GL_MAX_TEXTURE_BUFFER_SIZE_EXT, &max_texture_buffer_size);
debug1 << "maximal texture buffer size " << FormatBytes(max_texture_buffer_size) << endl;
size_t instances_position_radius = size_t(max_texture_buffer_size) / (4*sizeof(float));
size_t instances_color = size_t(max_texture_buffer_size) / (4*sizeof(unsigned char));
instanced_batch_size = std::min(instances_position_radius, instances_color);
debug1 << "ParticleInstancingRenderer: Max number of instances "
<< instanced_batch_size << " = "
<< instanced_batch_size / 1000000.0f << " million" << endl;
GenerateAndBuildTBO();
BuildSphereGeometryVBOs();
BuildShaders();
}
bool ccFBOUtils::CheckShadersAvailability()
{
bool bARBShadingLanguage = CheckExtension("GL_ARB_shading_language_100");
bool bARBShaderObjects = CheckExtension("GL_ARB_shader_objects");
bool bARBVertexShader = CheckExtension("GL_ARB_vertex_shader");
bool bARBFragmentShader = CheckExtension("GL_ARB_fragment_shader");
bool bShadersSupported = bARBShadingLanguage &&
bARBShaderObjects &&
bARBVertexShader &&
bARBFragmentShader;
return bShadersSupported;
}
DWORD CPrecacheManager::OnLoadFile(DWORD size, void *data)
{
VERIFY_MESSAGE_SIZE(size, sizeof(LOADFILEEXTPARAMS));
LOADFILEEXTPARAMS *lfep = (LOADFILEEXTPARAMS *)data;
CHashString hszFileResource( lfep->fileName );
if( CheckExtension( lfep->fileName ) )
{
RESOURCEMAP::iterator itr = m_ResourceMap.find( hszFileResource.GetUniqueID() );
if( itr == m_ResourceMap.end() )
{
// A new resource, add the entry to the map
RESOURCEINFO tmpInfo;
tmpInfo.m_bLoaded = true;
tmpInfo.m_iRefCount = 1;
m_ResourceMap[hszFileResource.GetUniqueID()] = tmpInfo;
// Add the new resource to the current Precache file if it exists
if( m_PrecacheStack.size() != 0 )
{
m_PrecacheStack.front()->AddResource( &hszFileResource );
}
}
}
return MSG_HANDLED_PROCEED;
}
void AnimManager_loadAll( AnimManager *am ) {
if( am ) {
struct dirent *entry = NULL;
DIR *anim_dir = opendir( AnimDirectory );
while( ( entry = readdir( anim_dir ) ) ) {
const char *file = entry->d_name;
if( CheckExtension( file, "json" ) ) {
str32 anim_name;
// remove '.json. extension from name
int filename_n = strlen( file );
strncpy( anim_name, file, filename_n - 5 );
anim_name[filename_n-5] = 0;
// find anim that match the name
Anim *a = AnimManager_gets( am, anim_name );
if( a ) {
str64 anim_path;
strcpy( anim_path, AnimDirectory );
strcat( anim_path, file );
Anim_loadFromFile( a, anim_path );
}
}
}
}
}
static int
VMwareXineramaIsActive(ClientPtr client)
{
xXineramaIsActiveReply rep;
ExtensionEntry *ext;
ScrnInfoPtr pScrn;
VMWAREPtr pVMWARE;
REQUEST_SIZE_MATCH(xXineramaIsActiveReq);
if (!(ext = CheckExtension(PANORAMIX_PROTOCOL_NAME))) {
return BadMatch;
}
pScrn = ext->extPrivate;
pVMWARE = VMWAREPTR(pScrn);
rep.type = X_Reply;
rep.length = 0;
rep.sequenceNumber = client->sequence;
rep.state = pVMWARE->xinerama;
if(client->swapped) {
register int n;
_swaps(&rep.sequenceNumber, n);
_swapl(&rep.length, n);
_swapl(&rep.state, n);
}
WriteToClient(client, sizeof(xXineramaIsActiveReply), (char *) &rep);
return client->noClientException;
}
void
VMwareXinerama_ExtInit(ScrnInfoPtr pScrn)
{
ExtensionEntry *myext;
VMWAREPtr pVMWARE = VMWAREPTR(pScrn);
#ifdef PANORAMIX
if(!noPanoramiXExtension) {
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"Built-in Xinerama active, not initializing VMware Xinerama\n");
pVMWARE->xinerama = FALSE;
return;
}
#endif
if (!(myext = CheckExtension(PANORAMIX_PROTOCOL_NAME))) {
if (!(myext = AddExtension(PANORAMIX_PROTOCOL_NAME, 0, 0,
VMwareXineramaDispatch,
SVMwareXineramaDispatch,
VMwareXineramaResetProc,
StandardMinorOpcode))) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"Failed to add VMware Xinerama extension.\n");
return;
}
pVMWARE->xinerama = TRUE;
myext->extPrivate = pScrn;
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"Initialized VMware Xinerama extension.\n");
}
}
void ShowHelp(const wchar_t *fullfilename,const wchar_t *topic, bool CmdLine)
{
if (CmdLine || CheckExtension(fullfilename))
{
const wchar_t *Topic=topic;
if (NULL == Topic)
Topic=GetMsg(MDefaultTopic);
Info.ShowHelp(fullfilename,Topic,FHELP_CUSTOMFILE);
}
}
/* wrapper for CheckOpenglVersion and CheckExtension, also used by macros
*/
GLboolean CheckVersionExtension(const char *name)
{
if (name && name[0] && name[0]>='0' && name[0]<='9') { /* GL version query */
int major,minor;
if (sscanf( name, "%d.%d", &major, &minor ) != 2)
return GL_FALSE;
return (CheckOpenglVersion(major,minor));
} else {
return (CheckExtension(name));
}
}
static int
VMwareXineramaQueryScreens(ClientPtr client)
{
xXineramaQueryScreensReply rep;
ExtensionEntry *ext;
ScrnInfoPtr pScrn;
VMWAREPtr pVMWARE;
REQUEST_SIZE_MATCH(xXineramaQueryScreensReq);
if (!(ext = CheckExtension(PANORAMIX_PROTOCOL_NAME))) {
return BadMatch;
}
pScrn = ext->extPrivate;
pVMWARE = VMWAREPTR(pScrn);
rep.type = X_Reply;
rep.sequenceNumber = client->sequence;
rep.number = pVMWARE->xinerama ? pVMWARE->xineramaNumOutputs : 0;
rep.length = rep.number * sz_XineramaScreenInfo >> 2;
if(client->swapped) {
register int n;
_swaps(&rep.sequenceNumber, n);
_swapl(&rep.length, n);
_swapl(&rep.number, n);
}
WriteToClient(client, sizeof(xXineramaQueryScreensReply), (char *)&rep);
if(pVMWARE->xinerama) {
xXineramaScreenInfo scratch;
int i;
for(i = 0; i < pVMWARE->xineramaNumOutputs; i++) {
scratch.x_org = pVMWARE->xineramaState[i].x_org;
scratch.y_org = pVMWARE->xineramaState[i].y_org;
scratch.width = pVMWARE->xineramaState[i].width;
scratch.height = pVMWARE->xineramaState[i].height;
if(client->swapped) {
register int n;
_swaps(&scratch.x_org, n);
_swaps(&scratch.y_org, n);
_swaps(&scratch.width, n);
_swaps(&scratch.height, n);
}
WriteToClient(client, sz_XineramaScreenInfo, (char *)&scratch);
}
}
return client->noClientException;
}
// Open an Archive.
CArchive* CArchive::Open( const VFS_String& strAbsoluteFileName )
{
// Try to open the Archive.
CArchive* pArchive = new CArchive( CheckExtension( strAbsoluteFileName ) );
// Invalid Archive?
if( !pArchive->IsValid() )
{
delete pArchive;
return NULL;
}
return pArchive;
}
bool ShowHelp(const wchar_t *fullfilename,const wchar_t *topic, bool CmdLine, bool ShowError)
{
if (fullfilename && (CmdLine || CheckExtension(fullfilename)))
{
const wchar_t *Topic=topic;
if (NULL == Topic)
Topic=GetMsg(MDefaultTopic);
return Info.ShowHelp(fullfilename,Topic,FHELP_CUSTOMFILE|(ShowError?0:FHELP_NOSHOWERROR))?true:false;
}
return false;
}
void WiredCodec::FeelExtension(list<t_LibInfo> Info)
{
list<t_LibInfo>::const_iterator iterLibInfo;
for (iterLibInfo = Info.begin(); iterLibInfo != Info.end(); iterLibInfo++)
{
if ((*iterLibInfo).CodecMask & DECODE)
if (!_DecodeExtList.empty())
{
if (CheckExtension((*iterLibInfo).Extension, _DecodeExtList))
_DecodeExtList.push_back((*iterLibInfo).Extension);
}
else
_DecodeExtList.push_back((*iterLibInfo).Extension);
if ((*iterLibInfo).CodecMask & ENCODE)
if (!_EncodeExtList.empty())
{
if (CheckExtension((*iterLibInfo).Extension, _EncodeExtList))
_EncodeExtList.push_back((*iterLibInfo).Extension);
}
else
_EncodeExtList.push_back((*iterLibInfo).Extension);
}
}
// это HLF-файл?
// первая строка hlf всегда начинается с ".Language="
BOOL IsHlf(void)
{
BOOL ret=FALSE;
struct EditorInfo ei={sizeof(EditorInfo)};
Info.EditorControl(-1,ECTL_GETINFO,0,&ei);
bool CheckedHlf=true;
if (Opt.CheckMaskFile)
{
wchar_t *FileName=GetEditorFileName();
if (FileName)
{
if (!CheckExtension(FileName))
CheckedHlf=false;
delete[] FileName;
}
}
if (CheckedHlf)
{
memset(&esp,-1,sizeof(esp));
egs.StringNumber=-1;
intptr_t total=(ei.TotalLines<3)?ei.TotalLines:3;
if (total>2)
{
for (esp.CurLine=0; esp.CurLine<total; esp.CurLine++)
{
Info.EditorControl(-1,ECTL_SETPOSITION,0,&esp);
Info.EditorControl(-1,ECTL_GETSTRING,0,&egs);
if (!FSF.LStrnicmp(L".Language=",egs.StringText,10))
{
// доп.проверка
if (FindTopic(true,false))
ret=TRUE;
break;
}
}
RestorePosition(&ei);
}
}
return ret;
}
static int
VMwareXineramaGetScreenSize(ClientPtr client)
{
REQUEST(xPanoramiXGetScreenSizeReq);
WindowPtr pWin;
xPanoramiXGetScreenSizeReply rep;
register int n;
ExtensionEntry *ext;
ScrnInfoPtr pScrn;
VMWAREPtr pVMWARE;
int rc;
REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
if (rc != Success)
return rc;
if (!(ext = CheckExtension(PANORAMIX_PROTOCOL_NAME))) {
return BadMatch;
}
pScrn = ext->extPrivate;
pVMWARE = VMWAREPTR(pScrn);
rep.type = X_Reply;
rep.length = 0;
rep.sequenceNumber = client->sequence;
rep.width = pVMWARE->xineramaState[stuff->screen].width;
rep.height = pVMWARE->xineramaState[stuff->screen].height;
rep.window = stuff->window;
rep.screen = stuff->screen;
if(client->swapped) {
_swaps(&rep.sequenceNumber, n);
_swapl(&rep.length, n);
_swapl(&rep.width, n);
_swapl(&rep.height, n);
_swapl(&rep.window, n);
_swapl(&rep.screen, n);
}
WriteToClient(client, sizeof(xPanoramiXGetScreenSizeReply), (char *)&rep);
return client->noClientException;
}
intptr_t WINAPI ProcessEditorInputW(const ProcessEditorInputInfo *InputInfo)
{
LPWSTR FileName=NULL;
BOOL Result=FALSE;
if (Opt.ProcessEditorInput)
{
if (InputInfo->Rec.EventType==KEY_EVENT && InputInfo->Rec.Event.KeyEvent.bKeyDown && inputrecord_compare(InputInfo->Rec,Opt.RecKey))
{
Info.EditorControl(-1,ECTL_GETINFO,0,&ei);
size_t FileNameSize=Info.EditorControl(-1,ECTL_GETFILENAME,0,0);
if (FileNameSize)
{
FileName=new wchar_t[FileNameSize];
if (FileName)
{
Info.EditorControl(-1,ECTL_GETFILENAME,FileNameSize,FileName);
}
}
if (CheckExtension(FileName))
{
ShowCurrentHelpTopic();
Result=TRUE;
}
}
}
if (FileName)
{
delete[] FileName;
}
return Result;
}
intptr_t WINAPI ProcessEditorInputW(const ProcessEditorInputInfo *InputInfo)
{
BOOL Result=FALSE;
if (Opt.ProcessEditorInput)
{
if (InputInfo->Rec.EventType==KEY_EVENT && InputInfo->Rec.Event.KeyEvent.bKeyDown && inputrecord_compare(InputInfo->Rec,Opt.RecKey))
{
Info.EditorControl(-1,ECTL_GETINFO,0,&ei);
wchar_t *FileName=GetEditorFileName();
if (IsHlf() || (Opt.CheckMaskFile && CheckExtension(FileName)))
{
if (ShowCurrentHelpTopic())
Result=TRUE;
}
if (FileName)
delete[] FileName;
}
}
return Result;
}
/*************************************************************************
InitializeExtensions()
Sets up all of the extensions needed. Returns false if a required
extension isn't supported.
*************************************************************************/
bool InitializeExtensions()
{
if (CheckExtension("GL_ARB_multitexture"))
{
pglMultiTexCoord2f = (PFNGLMULTITEXCOORD2FARBPROC) wglGetProcAddress("glMultiTexCoord2f");
pglActiveTexture = (PFNGLCLIENTACTIVETEXTUREARBPROC) wglGetProcAddress("glActiveTexture");
pglClientActiveTexture = (PFNGLACTIVETEXTUREARBPROC) wglGetProcAddress("glClientActiveTexture");
}
else
{
MessageBox(g_hwnd, "This program requires multitexturing, which is not supported by your hardware", "ERROR", MB_OK);
return false;
}
if (CheckExtension("GL_EXT_point_parameters"))
{
pglPointParameterfvEXT = (PFNGLPOINTPARAMETERFVEXTPROC) wglGetProcAddress("glPointParameterfvEXT");
}
if (CheckExtension("WGL_EXT_swap_control"))
{
pwglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC) wglGetProcAddress("wglSwapIntervalEXT");
}
if (!CheckExtension("GL_EXT_bgra"))
{
MessageBox(g_hwnd, "This program requires the BGRA pixel storage format, which is not supported by your hardware", "ERROR", MB_OK);
return false;
}
g_useTextureCompression = CheckExtension("GL_ARB_texture_compression");
g_useEdgeClamp = CheckExtension("GL_EXT_texture_edge_clamp");
g_useSGISMipmapGeneration = CheckExtension("GL_SGIS_generate_mipmap");
return true;
} // end InitializeExtensions()
// Check the File Existence.
VFS_BOOL CArchive::Exists( const VFS_String& strAbsoluteFileName )
{
return VFS_EXISTS( CheckExtension( strAbsoluteFileName ) );
}
bool ccFBOUtils::CheckVAAvailability()
{
return CheckExtension("GL_ARB_vertex_array_object");
}
glbsp_ret_e GlbspCheckInfo(nodebuildinfo_t *info,
volatile nodebuildcomms_t *comms)
{
cur_comms = comms;
SetErrorMsg("(Unknown Problem)");
info->same_filenames = FALSE;
info->missing_output = FALSE;
if (!info->input_file || info->input_file[0] == 0)
{
SetErrorMsg("Missing input filename !");
return GLBSP_E_BadArgs;
}
if (CheckExtension(info->input_file, "gwa"))
{
SetErrorMsg("Input file cannot be GWA (contains nothing to build)");
return GLBSP_E_BadArgs;
}
if (!info->output_file || info->output_file[0] == 0)
{
GlbspFree(info->output_file);
info->output_file = GlbspStrDup(ReplaceExtension(
info->input_file, "gwa"));
info->gwa_mode = TRUE;
info->missing_output = TRUE;
}
else /* has output filename */
{
if (CheckExtension(info->output_file, "gwa"))
info->gwa_mode = TRUE;
}
if (UtilStrCaseCmp(info->input_file, info->output_file) == 0)
{
info->load_all = TRUE;
info->same_filenames = TRUE;
}
if (info->no_prune && info->pack_sides)
{
info->pack_sides = FALSE;
SetErrorMsg("-noprune and -packsides cannot be used together");
return GLBSP_E_BadInfoFixed;
}
if (info->gwa_mode && info->force_normal)
{
info->force_normal = FALSE;
SetErrorMsg("-forcenormal used, but GWA files don't have normal nodes");
return GLBSP_E_BadInfoFixed;
}
if (info->no_normal && info->force_normal)
{
info->force_normal = FALSE;
SetErrorMsg("-forcenormal and -nonormal cannot be used together");
return GLBSP_E_BadInfoFixed;
}
if (info->factor <= 0 || info->factor > 32)
{
info->factor = DEFAULT_FACTOR;
SetErrorMsg("Bad factor value !");
return GLBSP_E_BadInfoFixed;
}
if (info->spec_version <= 0 || info->spec_version > 5)
{
info->spec_version = 2;
SetErrorMsg("Bad GL-Nodes version number !");
return GLBSP_E_BadInfoFixed;
}
else if (info->spec_version == 4)
{
info->spec_version = 5;
SetErrorMsg("V4 GL-Nodes is not supported");
return GLBSP_E_BadInfoFixed;
}
if (info->block_limit < 1000 || info->block_limit > 64000)
{
info->block_limit = DEFAULT_BLOCK_LIMIT;
SetErrorMsg("Bad blocklimit value !");
return GLBSP_E_BadInfoFixed;
}
return GLBSP_E_OK;
}
glbsp_ret_e GlbspParseArgs(nodebuildinfo_t *info,
volatile nodebuildcomms_t *comms,
const char ** argv, int argc)
{
const char *opt_str;
int num_files = 0;
int got_output = FALSE;
cur_comms = comms;
SetErrorMsg("(Unknown Problem)");
while (argc > 0)
{
if (argv[0][0] != '-')
{
// --- ORDINARY FILENAME ---
if (got_output)
{
SetErrorMsg("Input filenames must precede the -o option");
cur_comms = NULL;
return GLBSP_E_BadArgs;
}
if (CheckExtension(argv[0], "gwa"))
{
SetErrorMsg("Input file cannot be GWA (contains nothing to build)");
cur_comms = NULL;
return GLBSP_E_BadArgs;
}
if (num_files >= 1)
{
AddExtraFile(info, GlbspStrDup(argv[0]));
}
else
{
GlbspFree(info->input_file);
info->input_file = GlbspStrDup(argv[0]);
}
num_files++;
argv++; argc--;
continue;
}
// --- AN OPTION ---
opt_str = &argv[0][1];
// handle GNU style options beginning with '--'
if (opt_str[0] == '-')
opt_str++;
if (UtilStrCaseCmp(opt_str, "o") == 0)
{
if (got_output)
{
SetErrorMsg("The -o option cannot be used more than once");
cur_comms = NULL;
return GLBSP_E_BadArgs;
}
if (num_files >= 2)
{
SetErrorMsg("Cannot use -o with multiple input files.");
cur_comms = NULL;
return GLBSP_E_BadArgs;
}
if (argc < 2 || argv[1][0] == '-')
{
SetErrorMsg("Missing filename for the -o option");
cur_comms = NULL;
return GLBSP_E_BadArgs;
}
GlbspFree(info->output_file);
info->output_file = GlbspStrDup(argv[1]);
got_output = TRUE;
argv += 2; argc -= 2;
continue;
}
if (UtilStrCaseCmp(opt_str, "factor") == 0 ||
UtilStrCaseCmp(opt_str, "c") == 0)
{
if (argc < 2)
{
SetErrorMsg("Missing factor value");
cur_comms = NULL;
return GLBSP_E_BadArgs;
}
info->factor = (int) strtol(argv[1], NULL, 10);
argv += 2; argc -= 2;
continue;
}
if (tolower(opt_str[0]) == 'v' && isdigit(opt_str[1]))
{
info->spec_version = (opt_str[1] - '0');
argv++; argc--;
continue;
}
if (UtilStrCaseCmp(opt_str, "maxblock") == 0 ||
UtilStrCaseCmp(opt_str, "b") == 0)
{
if (argc < 2)
{
SetErrorMsg("Missing maxblock value");
cur_comms = NULL;
return GLBSP_E_BadArgs;
}
info->block_limit = (int) strtol(argv[1], NULL, 10);
argv += 2; argc -= 2;
continue;
}
HANDLE_BOOLEAN2("q", "quiet", quiet)
HANDLE_BOOLEAN2("f", "fast", fast)
HANDLE_BOOLEAN2("w", "warn", mini_warnings)
HANDLE_BOOLEAN2("p", "pack", pack_sides)
HANDLE_BOOLEAN2("n", "normal", force_normal)
HANDLE_BOOLEAN2("xr", "noreject", no_reject)
HANDLE_BOOLEAN2("xp", "noprog", no_progress)
HANDLE_BOOLEAN2("m", "mergevert", merge_vert)
HANDLE_BOOLEAN2("u", "prunesec", prune_sect)
HANDLE_BOOLEAN2("y", "windowfx", window_fx)
HANDLE_BOOLEAN2("s", "skipselfref", skip_self_ref)
HANDLE_BOOLEAN2("xu", "noprune", no_prune)
HANDLE_BOOLEAN2("xn", "nonormal", no_normal)
// to err is human...
HANDLE_BOOLEAN("noprogress", no_progress)
HANDLE_BOOLEAN("packsides", pack_sides)
HANDLE_BOOLEAN("prunesect", prune_sect)
// ignore these options for backwards compatibility
if (UtilStrCaseCmp(opt_str, "fresh") == 0 ||
UtilStrCaseCmp(opt_str, "keepdummy") == 0 ||
UtilStrCaseCmp(opt_str, "keepsec") == 0 ||
UtilStrCaseCmp(opt_str, "keepsect") == 0)
{
argv++; argc--;
continue;
}
// backwards compatibility
HANDLE_BOOLEAN("forcegwa", gwa_mode)
HANDLE_BOOLEAN("forcenormal", force_normal)
HANDLE_BOOLEAN("loadall", load_all)
// The -hexen option is only kept for backwards compatibility
HANDLE_BOOLEAN("hexen", force_hexen)
SetErrorMsg("Unknown option: %s", argv[0]);
cur_comms = NULL;
return GLBSP_E_BadArgs;
}
cur_comms = NULL;
return GLBSP_E_OK;
}
static void CheckParms( void )
/****************************/
{
char *defext;
CheckExtension( CmdLineParms.InFileName, "rc" );
CheckPass2Only();
/* was an EXE file name given */
if( CmdLineParms.InExeFileName[0] == '\0' ) {
if (CmdLineParms.NoResFile) {
strncpy( CmdLineParms.InExeFileName, CmdLineParms.InFileName, _MAX_PATH );
} else {
MakeFileName( CmdLineParms.InFileName,
CmdLineParms.InExeFileName, "exe" );
}
} else {
CheckExtension( CmdLineParms.InExeFileName, "exe" );
}
/* was an output RES file name given */
if( CmdLineParms.PreprocessOnly ) {
defext = "lst";
} else {
defext = "res";
}
if( CmdLineParms.OutResFileName[0] == '\0' ) {
MakeFileName( CmdLineParms.InFileName,
CmdLineParms.OutResFileName, defext );
} else {
CheckExtension( CmdLineParms.OutResFileName, defext );
}
/* was an output EXE file name given */
if( CmdLineParms.OutExeFileName[0] == '\0' ) {
strncpy( CmdLineParms.OutExeFileName, CmdLineParms.InExeFileName, _MAX_PATH );
} else {
CheckExtension( CmdLineParms.OutExeFileName, "exe" );
}
/* check for the existance of the input files */
if (! (CmdLineParms.Pass2Only && CmdLineParms.NoResFile) ) {
if( access( CmdLineParms.InFileName, F_OK ) != 0 ) {
RcFatalError( ERR_CANT_FIND_FILE, CmdLineParms.InFileName );
}
}
if( !CmdLineParms.Pass1Only && !CmdLineParms.PreprocessOnly ) {
if( access( CmdLineParms.InExeFileName, F_OK ) != 0 ) {
RcFatalError( ERR_CANT_FIND_FILE, CmdLineParms.InExeFileName );
}
}
if( CmdLineParms.GenAutoDep && CmdLineParms.MSResFormat ) {
RcFatalError( ERR_OPT_NOT_VALID_TOGETHER, "-ad", "-zm" );
}
if( CmdLineParms.TargetOS == RC_TARGET_OS_WIN32 ) {
switch( CmdLineParms.MBCharSupport ) {
case DB_SIMPLIFIED_CHINESE:
strcpy( CmdLineParms.CodePageFile, "936.uni" );
break;
case DB_TRADITIONAL_CHINESE:
strcpy( CmdLineParms.CodePageFile, "950.uni" );
break;
case DB_KANJI:
strcpy( CmdLineParms.CodePageFile, "kanji.uni" );
break;
case DB_WANSUNG_KOREAN:
strcpy( CmdLineParms.CodePageFile, "949.uni" );
break;
}
}
if( CmdLineParms.PreprocessOnly && CmdLineParms.NoPreprocess ) {
RcFatalError( ERR_OPT_NOT_VALID_TOGETHER, "-o", "-zn" );
}
} /* CheckParms */
void gl_LoadExtensions()
{
InitContext();
CollectExtensions();
const char *version = Args->CheckValue("-glversion");
const char *glversion = (const char*)glGetString(GL_VERSION);
if (version == NULL)
{
version = glversion;
}
else
{
double v1 = strtod(version, NULL);
double v2 = strtod(glversion, NULL);
if (v2 < v1) version = glversion;
else Printf("Emulating OpenGL v %s\n", version);
}
float gl_version = (float)strtod(version, NULL) + 0.01f;
// Don't even start if it's lower than 2.0 or no framebuffers are available (The framebuffer extension is needed for glGenerateMipmapsEXT!)
if ((gl_version < 2.0f || !CheckExtension("GL_EXT_framebuffer_object")) && gl_version < 3.0f)
{
I_FatalError("Unsupported OpenGL version.\nAt least OpenGL 2.0 with framebuffer support is required to run " GAMENAME ".\n");
}
// add 0.01 to account for roundoff errors making the number a tad smaller than the actual version
gl.glslversion = strtod((char*)glGetString(GL_SHADING_LANGUAGE_VERSION), NULL) + 0.01f;
gl.vendorstring = (char*)glGetString(GL_VENDOR);
// first test for optional features
if (CheckExtension("GL_ARB_texture_compression")) gl.flags |= RFL_TEXTURE_COMPRESSION;
if (CheckExtension("GL_EXT_texture_compression_s3tc")) gl.flags |= RFL_TEXTURE_COMPRESSION_S3TC;
if ((gl_version >= 3.3f || CheckExtension("GL_ARB_sampler_objects")) && !Args->CheckParm("-nosampler"))
{
gl.flags |= RFL_SAMPLER_OBJECTS;
}
// The minimum requirement for the modern render path are GL 3.0 + uniform buffers. Also exclude the Linux Mesa driver at GL 3.0 because it errors out on shader compilation.
if (gl_version < 3.0f || (gl_version < 3.1f && (!CheckExtension("GL_ARB_uniform_buffer_object") || strstr(gl.vendorstring, "X.Org") != nullptr)))
{
gl.legacyMode = true;
gl.lightmethod = LM_LEGACY;
gl.buffermethod = BM_LEGACY;
gl.glslversion = 0;
gl.flags |= RFL_NO_CLIP_PLANES;
}
else
{
gl.legacyMode = false;
gl.lightmethod = LM_DEFERRED;
gl.buffermethod = BM_DEFERRED;
if (gl_version < 4.f)
{
#ifdef _WIN32
if (strstr(gl.vendorstring, "ATI Tech"))
{
gl.flags |= RFL_NO_CLIP_PLANES; // gl_ClipDistance is horribly broken on ATI GL3 drivers for Windows.
}
#endif
}
else if (gl_version < 4.5f)
{
// don't use GL 4.x features when running a GL 3.x context.
if (CheckExtension("GL_ARB_buffer_storage"))
{
// work around a problem with older AMD drivers: Their implementation of shader storage buffer objects is piss-poor and does not match uniform buffers even closely.
// Recent drivers, GL 4.4 don't have this problem, these can easily be recognized by also supporting the GL_ARB_buffer_storage extension.
if (CheckExtension("GL_ARB_shader_storage_buffer_object"))
{
// Shader storage buffer objects are broken on current Intel drivers.
if (strstr(gl.vendorstring, "Intel") == NULL)
{
gl.flags |= RFL_SHADER_STORAGE_BUFFER;
}
}
gl.flags |= RFL_BUFFER_STORAGE;
gl.lightmethod = LM_DIRECT;
gl.buffermethod = BM_PERSISTENT;
}
}
else
{
// Assume that everything works without problems on GL 4.5 drivers where these things are core features.
gl.flags |= RFL_SHADER_STORAGE_BUFFER | RFL_BUFFER_STORAGE;
gl.lightmethod = LM_DIRECT;
gl.buffermethod = BM_PERSISTENT;
}
if (gl_version >= 4.3f || CheckExtension("GL_ARB_invalidate_subdata")) gl.flags |= RFL_INVALIDATE_BUFFER;
if (gl_version >= 4.3f || CheckExtension("GL_KHR_debug")) gl.flags |= RFL_DEBUG;
const char *lm = Args->CheckValue("-lightmethod");
if (lm != NULL)
{
if (!stricmp(lm, "deferred") && gl.lightmethod == LM_DIRECT) gl.lightmethod = LM_DEFERRED;
}
lm = Args->CheckValue("-buffermethod");
if (lm != NULL)
{
if (!stricmp(lm, "deferred") && gl.buffermethod == BM_PERSISTENT) gl.buffermethod = BM_DEFERRED;
}
}
int v;
if (!gl.legacyMode && !(gl.flags & RFL_SHADER_STORAGE_BUFFER))
{
glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, &v);
gl.maxuniforms = v;
glGetIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE, &v);
gl.maxuniformblock = v;
glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &v);
gl.uniformblockalignment = v;
}
else
{
gl.maxuniforms = 0;
gl.maxuniformblock = 0;
gl.uniformblockalignment = 0;
}
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &gl.max_texturesize);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
if (gl.legacyMode)
{
// fudge a bit with the framebuffer stuff to avoid redundancies in the main code. Some of the older cards do not have the ARB stuff but the calls are nearly identical.
FUDGE_FUNC(glGenerateMipmap, EXT);
FUDGE_FUNC(glGenFramebuffers, EXT);
FUDGE_FUNC(glBindFramebuffer, EXT);
FUDGE_FUNC(glDeleteFramebuffers, EXT);
FUDGE_FUNC(glFramebufferTexture2D, EXT);
FUDGE_FUNC(glGenerateMipmap, EXT);
FUDGE_FUNC(glGenFramebuffers, EXT);
FUDGE_FUNC(glBindFramebuffer, EXT);
FUDGE_FUNC(glDeleteFramebuffers, EXT);
FUDGE_FUNC(glFramebufferTexture2D, EXT);
FUDGE_FUNC(glFramebufferRenderbuffer, EXT);
FUDGE_FUNC(glGenRenderbuffers, EXT);
FUDGE_FUNC(glDeleteRenderbuffers, EXT);
FUDGE_FUNC(glRenderbufferStorage, EXT);
FUDGE_FUNC(glBindRenderbuffer, EXT);
FUDGE_FUNC(glCheckFramebufferStatus, EXT);
gl_PatchMenu();
}
}
//--------------------------------------------------------------
// Name: CGL_APP::Init - public
// Description: Initiate an OpenGL application
// Arguments: -iX, iY: the upperleft position of the window
// -iWidth, iHeight: the dimensions of the window
// -iBPP: the pixel depth of the window (usually 16 or 32)
// -szTitle: the title to appear in the window's titlebar
// -icon: a resource ID for a program application icon (defaults to NULL)
// -menu: a resource ID for a menu (defaults to NULL)
// Return Value: A boolean variable: -true: successful window initiation
// -false: unsuccessful window initiation
//--------------------------------------------------------------
bool CGL_APP::Init( int iX, int iY, int iWidth, int iHeight, int iBPP,
const char* szTitle, WORD icon, WORD menu )
{
WNDCLASS winclass; //The windows class structure
unsigned int uiPixelFormat; //Hold the correct match for the pixel format
//initiate the program log
g_log.Init( "program log.html" );
if( m_timer.Init( ) )
g_log.Write( LOG_PLAINTEXT, "Performance timer has been initialized" );
else
g_log.Write( LOG_PLAINTEXT, "Multimedia timer has been initialized" );
//record the dimensions in the class's members
m_iWidth = iWidth;
m_iHeight= iHeight;
m_iBPP = iBPP;
//customize the window's parameters
m_hInstance = GetModuleHandle( NULL ); //get the window's instance
winclass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; //redraw the window on resize
winclass.lpfnWndProc = WindowProc; //handle the WINPROC messages
winclass.cbClsExtra = 0; //no extra win data
winclass.cbWndExtra = 0; //no extra win data
winclass.hInstance = m_hInstance; //get the window's instance
winclass.hIcon = LoadIcon( NULL, MAKEINTRESOURCE( icon ) );//load an icon
winclass.hCursor = LoadCursor( NULL, IDC_ARROW ); //load the mouse pointer
winclass.lpszMenuName = MAKEINTRESOURCE( menu ); //load the menu
winclass.hbrBackground= ( HBRUSH )GetStockObject( BLACK_BRUSH );//no background required for OpenGL stuff
winclass.lpszClassName= APP_CLASSNAME; //set the class name
//register the window class
if( !RegisterClass(&winclass ) )
{
g_log.Write( LOG_FAILURE, "WINDOW FAILURE: could not register class" );
return false;
}
//ruh-roh, something screwed up
else
g_log.Write( LOG_SUCCESS, "WINDOW SUCCESS: class registered" );
//create the window
if( !( m_hWnd=CreateWindowEx( WS_EX_CLIENTEDGE, //the extended style for the window
APP_CLASSNAME, //the class name
szTitle, //the window's title
WS_SYSMENU | WS_BORDER | WS_CAPTION | WS_VISIBLE,
iX, iY, //the window's position
m_iWidth, //calculate the window's width
m_iHeight, //calculate the window's height
NULL, //no parent window
NULL, //no menu needed
m_hInstance, //the window's instance
NULL ) ) ) //nothing to pass to WM_CREATE
{
//the window could not be created
Shutdown( );
g_log.Write( LOG_FAILURE, "WINDOW ERROR: window could not be created" );
return false;
}
//get the pixel format's description
static PIXELFORMATDESCRIPTOR pfd=
{
sizeof( PIXELFORMATDESCRIPTOR ), //Get the size of the structure
1, //Version number
PFD_DRAW_TO_WINDOW | //Format must support Windows
PFD_SUPPORT_OPENGL | //Format must support OpenGL
PFD_DOUBLEBUFFER, //Must support Double Buffering
PFD_TYPE_RGBA, //Request a RGBA (red,green,blue,alpha) format
m_iBPP, //Select the bits per pixel
0, 0, 0, 0, 0, 0, //Color bits ignored
0, //No alpha buffer
0, //shift bit ignored
0, //No accumulation buffer (advanced)
0, 0, 0, 0, //Accumulation bits ignored
32, //16 bit Z-Buffer (Depth Buffer)
0, //No Stencil Buffer (advanced)
0, //No Auxiliary Buffer (advanced)
PFD_MAIN_PLANE, //The main drawing layer
0, //Reserved area
0, 0, 0 //Layer masks ignored
};
//get a handle to the device context
if( !( m_hDC= GetDC( m_hWnd ) ) )
{
//no device context for us
Shutdown( );
MessageBox( m_hWnd, "Could not create a OpenGL device context", "RENDERER ERROR", MB_OK | MB_ICONSTOP );
return false;
}
//find a compatible pixel format
if(!(uiPixelFormat= ChoosePixelFormat(m_hDC, &pfd)))
{
//no suitable pixel format
Shutdown( );
MessageBox( m_hWnd, "Could not find a suitable pixel format", "RENDERER ERROR", MB_OK | MB_ICONSTOP );
return false;
}
//set the previously found pixel format
if( !SetPixelFormat( m_hDC, uiPixelFormat, &pfd ) )
{
//could not set the pixel format
Shutdown( );
MessageBox( m_hWnd, "Could not set pixel format", "RENDERER ERROR", MB_OK | MB_ICONSTOP );
return false;
}
//get a handle to the application's rendering context
if( !( m_hRC= wglCreateContext( m_hDC ) ) )
{
//could not get OpenGL support
Shutdown( );
MessageBox( m_hWnd, "Could not create the OpenGL rendering context", "RENDERER ERROR", MB_OK | MB_ICONSTOP );
return false;
}
//set the device and rendering context to our window (activating OpenGL)
if( !wglMakeCurrent( m_hDC, m_hRC ) )
{
//could not activate OpenGL
Shutdown( );
MessageBox( m_hWnd, "Could not activate the OpenGL rendering context", "RENDERER ERROR", MB_OK | MB_ICONSTOP );
return false;
}
glShadeModel( GL_SMOOTH ); //Enable smooth shading (so you can't see the individual polygons of a primitive, best shown when drawing a sphere)
glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
glClearDepth( 1.0 ); //Depth buffer setup
glDepthFunc( GL_LEQUAL ); //The type of depth testing to do (LEQUAL==less than or equal to)
glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST ); //The nicest perspective look
ShowWindow( m_hWnd, SW_SHOW ); //Show the window
SetForegroundWindow( m_hWnd ); //Give the window a high priority
SetFocus( m_hWnd ); //Sets the keyboard's focus to the window
//setup the program's perspective view
ResizeScene( m_iWidth, m_iHeight );
m_szSupportedGLExtensions= ( char* )glGetString( GL_EXTENSIONS );
if( CheckExtension( "GL_ARB_multitexture" ) )
{
glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &m_iNumTextureUnits);
if(m_iNumTextureUnits > 1)
m_bCanMultitexture= true;
else
m_bCanMultitexture= false;
}
else
m_bCanMultitexture= false;
glActiveTextureARB = ( PFNGLACTIVETEXTUREARBPROC ) wglGetProcAddress( "glActiveTextureARB" );
glClientActiveTextureARB= ( PFNGLCLIENTACTIVETEXTUREARBPROC )wglGetProcAddress( "glClientActiveTextureARB" );
glMultiTexCoord2fARB = ( PFNGLMULTITEXCOORD2FARBPROC ) wglGetProcAddress( "glMultiTexCoord2fARB" );
glMultiTexCoord2dARB = ( PFNGLMULTITEXCOORD2DARBPROC ) wglGetProcAddress( "glMultiTexCoord2dARB" );
g_log.Write( LOG_RENDERER, "Multitexturing has been initiated, and your video card supports %d texture units", m_iNumTextureUnits );
if( CheckExtension( "GL_EXT_compiled_vertex_array" ) )
m_bCanCVA= true;
else
m_bCanCVA= false;
CheckExtension( "GL_CLAMP_TO_EDGE" );
//configure the volumetric fog system
if( CheckExtension( "GL_EXT_fog_coord" ) )
glFogCoordfEXT= ( PFNGLFOGCOORDFEXTPROC )wglGetProcAddress( "glFogCoordfEXT" );
glLockArraysEXT = ( PFNGLLOCKARRAYSEXTPROC ) wglGetProcAddress( "glLockArraysEXT" );
glUnlockArraysEXT= ( PFNGLUNLOCKARRAYSEXTPROC )wglGetProcAddress( "glUnlockArraysEXT" );
m_bActive= APP_ACTIVE;
g_log.Write( LOG_SUCCESS, "WINDOW SUCCESS: A %dx%dx%d window has been created", m_iWidth, m_iHeight, m_iBPP);
return true;
}
bool GetNextImage()
{
HANDLE Search;
WIN32_FIND_DATA FindData;
int i = 0, j, Total = 0, FileNamePos = -1;
TCHAR *Ext, *CurName;
Search = FindFirstFile(L"*.*", &FindData);
CurName = wcsrchr(CurFileName, '\\');
if (CurName == NULL) {
CurName = CurFileName;
}
else {
CurName++; // Skip the '\'
}
do {
if (!_wcsicmp(FindData.cFileName, L".") || !_wcsicmp(FindData.cFileName, L".."))
continue;
Ext = GetExtension(FindData.cFileName);
if (Ext == NULL)
continue;
for (j = 0; ExtList[j] != NULL; j++) {
if (CheckExtension(FindData.cFileName, ExtList[j])) {
if (!_wcsicmp(FindData.cFileName, CurName))
FileNamePos = Total;
Total++;
break;
}
}
} while (FindNextFile(Search, &FindData));
FindClose(Search);
Search = FindFirstFile(L"*.*", &FindData);
if (Total == 0 || FileNamePos == -1)
return false;
if (FileNamePos == Total-1)
FileNamePos = -1;
do {
if (!_wcsicmp(FindData.cFileName, L".") || !_wcsicmp(FindData.cFileName, L".."))
continue;
Ext = GetExtension(FindData.cFileName);
if (Ext == NULL)
continue;
for (j = 0; ExtList[j] != NULL; j++) {
if (CheckExtension(FindData.cFileName, ExtList[j])) {
if (FileNamePos == i-1) {
wcscpy(OpenFileName, FindData.cFileName);
i++;
break;
}
i++;
break;
}
}
} while (FindNextFile(Search, &FindData));
FindClose(Search);
return true;
}
bool ccFBOUtils::CheckFBOAvailability()
{
return CheckExtension("GL_EXT_framebuffer_object");
}
/* Rectangle, left, right(not inclusive), top, bottom(not inclusive). */
OpenGL_Blitter::OpenGL_Blitter(int scanlines, ShaderType pixshader, const int screen_w, const int screen_h, int *rs, int *gs, int *bs, int *as) : gl_screen_w(screen_w), gl_screen_h(screen_h)
{
try
{
const char *extensions;
const char *vendor;
const char *renderer;
const char *version;
uint32 version_h;
MaxTextureSize = 0;
SupportNPOT = false;
SupportARBSync = false;
PixelFormat = 0;
PixelType = 0;
for(unsigned i = 0; i < 4; i++)
textures[i] = 0;
rgb_mask = 0;
using_scanlines = 0;
last_w = 0;
last_h = 0;
OSDLastWidth = 0;
OSDLastHeight = 0;
shader = NULL;
DummyBlack = NULL;
DummyBlackSize = 0;
#define LFG(x) if(!(p_##x = (x##_Func) SDL_GL_GetProcAddress(#x))) { throw MDFN_Error(0, _("Error getting proc address for: %s\n"), #x); }
#define LFGN(x) p_##x = (x##_Func) SDL_GL_GetProcAddress(#x)
LFG(glGetError);
LFG(glBindTexture);
LFGN(glColorTableEXT);
LFG(glTexImage2D);
LFG(glBegin);
LFG(glVertex2f);
LFG(glTexCoord2f);
LFG(glEnd);
LFG(glEnable);
LFG(glBlendFunc);
LFG(glGetString);
LFG(glViewport);
LFG(glGenTextures);
LFG(glDeleteTextures);
LFG(glTexParameteri);
LFG(glClearColor);
LFG(glLoadIdentity);
LFG(glClear);
LFG(glMatrixMode);
LFG(glDisable);
LFG(glPixelStorei);
LFG(glTexSubImage2D);
LFG(glFinish);
LFG(glOrtho);
LFG(glPixelTransferf);
LFG(glColorMask);
LFG(glTexEnvf);
LFG(glGetIntegerv);
LFG(glTexGend);
LFG(glRasterPos2i);
LFG(glDrawPixels);
LFG(glPixelZoom);
LFG(glAccum);
LFG(glClearAccum);
LFG(glGetTexLevelParameteriv);
LFG(glPushMatrix);
LFG(glPopMatrix);
LFG(glRotated);
LFG(glScalef);
LFG(glReadPixels);
vendor = (const char *)p_glGetString(GL_VENDOR);
renderer = (const char *)p_glGetString(GL_RENDERER);
version = (const char *)p_glGetString(GL_VERSION);
{
int major = 0, minor = 0;
trio_sscanf(version, "%d.%d", &major, &minor);
if(minor < 0) minor = 0;
if(minor > 255) minor = 255;
version_h = (major << 8) | minor;
//printf("%08x\n", version_h);
}
MDFN_printf(_("OpenGL Implementation: %s %s %s\n"), vendor, renderer, version);
extensions = (const char*)p_glGetString(GL_EXTENSIONS);
MDFN_printf(_("Checking extensions:\n"));
MDFN_indent(1);
SupportNPOT = FALSE;
SupportARBSync = false;
if(CheckExtension(extensions, "GL_ARB_texture_non_power_of_two"))
{
MDFN_printf(_("GL_ARB_texture_non_power_of_two found.\n"));
SupportNPOT = TRUE;
}
if(CheckExtension(extensions, "GL_ARB_sync"))
{
MDFN_printf(_("GL_ARB_sync found.\n"));
LFG(glFenceSync);
LFG(glIsSync);
LFG(glDeleteSync);
LFG(glClientWaitSync);
LFG(glWaitSync);
LFG(glGetInteger64v);
LFG(glGetSynciv);
SupportARBSync = true;
}
MDFN_indent(-1);
// x,y specify LOWER left corner of the viewport.
p_glViewport(0, 0, gl_screen_w, gl_screen_h);
p_glGenTextures(4, &textures[0]);
p_glGenTextures(1, &rgb_mask);
using_scanlines = 0;
shader = NULL;
if(pixshader != SHADER_NONE)
{
LFG(glCreateShaderObjectARB);
LFG(glShaderSourceARB);
LFG(glCompileShaderARB);
LFG(glCreateProgramObjectARB);
LFG(glAttachObjectARB);
LFG(glLinkProgramARB);
LFG(glUseProgramObjectARB);
LFG(glUniform1fARB);
LFG(glUniform2fARB);
LFG(glUniform3fARB);
LFG(glUniform1iARB);
LFG(glUniform2iARB);
LFG(glUniform3iARB);
LFG(glUniformMatrix2fvARB);
LFG(glActiveTextureARB);
LFG(glGetInfoLogARB);
LFG(glGetUniformLocationARB);
LFG(glDeleteObjectARB);
LFG(glDetachObjectARB);
LFG(glGetObjectParameterivARB);
shader = new OpenGL_Blitter_Shader(this, pixshader);
SupportNPOT = 0; // Our pixel shaders don't work right with NPOT textures(for them to do so would probably necessitate rewriting them to use texelFetch)
p_glActiveTextureARB(GL_TEXTURE0_ARB);
}
// printf here because pixel shader code will set SupportNPOT to 0
if(SupportNPOT)
MDFN_printf(_("Using non-power-of-2 sized textures.\n"));
else
MDFN_printf(_("Using power-of-2 sized textures.\n"));
if(scanlines)
{
int slcount;
using_scanlines = scanlines;
p_glBindTexture(GL_TEXTURE_2D, textures[1]);
p_glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
p_glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
uint8 *buf=(uint8*)malloc(64 * (256 * 2) * 4);
slcount = 0;
for(int y=0;y<(256 * 2);y++)
{
for(int x=0;x<64;x++)
{
int sl_alpha;
if(slcount)
sl_alpha = 0xFF - (0xFF * abs(scanlines) / 100);
else
sl_alpha = 0xFF;
buf[y*64*4+x*4]=0;
buf[y*64*4+x*4+1]=0;
buf[y*64*4+x*4+2]=0;
buf[y*64*4+x*4+3] = sl_alpha;
//buf[y*256+x]=(y&1)?0x00:0xFF;
}
slcount ^= 1;
}
p_glPixelStorei(GL_UNPACK_ROW_LENGTH, 64);
p_glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 64, 256 * 2, 0, GL_RGBA,GL_UNSIGNED_BYTE,buf);
free(buf);
}
p_glBindTexture(GL_TEXTURE_2D, textures[3]);
p_glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
p_glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
p_glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP);
p_glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP);
p_glBindTexture(GL_TEXTURE_2D, textures[0]);
p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
//p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, 0x812F);
//p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, 0x812F);
p_glBindTexture(GL_TEXTURE_2D, textures[2]);
p_glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP);
p_glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP);
p_glEnable(GL_TEXTURE_2D);
p_glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // Background color to black.
p_glMatrixMode(GL_MODELVIEW);
p_glLoadIdentity();
p_glFinish();
p_glDisable(GL_TEXTURE_1D);
p_glDisable(GL_FOG);
p_glDisable(GL_LIGHTING);
p_glDisable(GL_LOGIC_OP);
p_glDisable(GL_DITHER);
p_glDisable(GL_COLOR_MATERIAL);
p_glDisable(GL_NORMALIZE);
p_glDisable(GL_SCISSOR_TEST);
p_glDisable(GL_STENCIL_TEST);
p_glDisable(GL_ALPHA_TEST);
p_glDisable(GL_DEPTH_TEST);
p_glPixelTransferf(GL_RED_BIAS, 0);
p_glPixelTransferf(GL_GREEN_BIAS, 0);
p_glPixelTransferf(GL_BLUE_BIAS, 0);
p_glPixelTransferf(GL_ALPHA_BIAS, 0);
p_glPixelTransferf(GL_RED_SCALE, 1);
p_glPixelTransferf(GL_GREEN_SCALE, 1);
p_glPixelTransferf(GL_BLUE_SCALE, 1);
p_glPixelTransferf(GL_ALPHA_SCALE, 1);
p_glPixelTransferf(GL_MAP_COLOR, GL_FALSE);
p_glOrtho(0, gl_screen_w, gl_screen_h, 0, -1.0, 1.0);
last_w = 0;
last_h = 0;
OSDLastWidth = OSDLastHeight = 0;
MDFN_printf(_("Checking maximum texture size...\n"));
MDFN_indent(1);
p_glBindTexture(GL_TEXTURE_2D, textures[0]);
// Assume maximum texture width is the same as maximum texture height to greatly simplify things
MaxTextureSize = 32768;
while(MaxTextureSize)
{
GLint width_test = 0;
p_glTexImage2D(GL_PROXY_TEXTURE_2D, 0, GL_RGBA, MaxTextureSize, MaxTextureSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
p_glGetTexLevelParameteriv(GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width_test);
if((unsigned int)width_test == MaxTextureSize)
break;
MaxTextureSize >>= 1;
}
MDFN_printf(_("Apparently it is at least: %d x %d\n"), MaxTextureSize, MaxTextureSize);
if(MaxTextureSize < 256)
{
MDFN_printf(_("Warning: Maximum texture size is reported as being less than 256, but we can't handle that.\n"));
MaxTextureSize = 256;
}
DummyBlack = NULL;
DummyBlackSize = 0;
MDFN_indent(-1);
if(!CheckAlternateFormat(version_h))
{
#ifdef LSB_FIRST
*rs = 0;
*gs = 8;
*bs = 16;
*as = 24;
#else
*rs = 24;
*gs = 16;
*bs = 8;
*as = 0;
#endif
PixelFormat = GL_RGBA;
PixelType = GL_UNSIGNED_BYTE;
MDFN_printf(_("Using GL_RGBA, GL_UNSIGNED_BYTE for texture source data.\n"));
}
else
{
*as = 24;
*rs = 16;
*gs = 8;
*bs = 0;
PixelFormat = GL_BGRA;
PixelType = GL_UNSIGNED_INT_8_8_8_8_REV;
MDFN_printf(_("Using GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV for texture source data.\n"));
}
}
catch(...)
{
Cleanup();
throw;
}
}
// This is responsible for binding our qgl function pointers to the
// appropriate GL stuff.
void QGL_Init() {
common->Printf( "...initializing QGL\n" );
#define GLF_0( r, n ) qgl ## n = gl ## n;
#define GLF_V0( n ) qgl ## n = gl ## n;
#define GLF_1( r, n, t1, p1 ) qgl ## n = gl ## n;
#define GLF_V1( n, t1, p1 ) qgl ## n = gl ## n;
#define GLF_V2( n, t1, p1, t2, p2 ) qgl ## n = gl ## n;
#define GLF_3( r, n, t1, p1, t2, p2, t3, p3 ) qgl ## n = gl ## n;
#define GLF_V3( n, t1, p1, t2, p2, t3, p3 ) qgl ## n = gl ## n;
#define GLF_V4( n, t1, p1, t2, p2, t3, p3, t4, p4 ) qgl ## n = gl ## n;
#define GLF_V5( n, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5 ) qgl ## n = gl ## n;
#define GLF_V6( n, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6 ) qgl ## n = gl ## n;
#define GLF_V7( n, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7 ) qgl ## n = gl ## n;
#define GLF_V8( n, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8 ) qgl ## n = gl ## n;
#define GLF_V9( n, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9 ) qgl ## n = gl ## n;
#define GLF_V10( n, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10 ) qgl ## n = gl ## n;
#include "qgl_functions.h"
#undef GLF_0
#undef GLF_V0
#undef GLF_1
#undef GLF_V1
#undef GLF_V2
#undef GLF_3
#undef GLF_V3
#undef GLF_V4
#undef GLF_V5
#undef GLF_V6
#undef GLF_V7
#undef GLF_V8
#undef GLF_V9
#undef GLF_V10
qglActiveTextureARB = NULL;
qglClientActiveTextureARB = NULL;
qglMultiTexCoord2fARB = NULL;
qglLockArraysEXT = NULL;
qglUnlockArraysEXT = NULL;
qglPointParameterfEXT = NULL;
qglPointParameterfvEXT = NULL;
qglPNTrianglesiATI = NULL;
qglPNTrianglesfATI = NULL;
#ifdef _WIN32
qwglSwapIntervalEXT = NULL;
#else
qglXSwapIntervalSGI = NULL;
#endif
common->Printf( "Initializing OpenGL extensions\n" );
// GL_S3_s3tc
glConfig.textureCompression = TC_NONE;
if ( CheckExtension( "GL_EXT_texture_compression_s3tc" ) ) {
if ( r_ext_compressed_textures->integer ) {
glConfig.textureCompression = TC_EXT_COMP_S3TC;
common->Printf( "...using GL_EXT_texture_compression_s3tc\n" );
} else {
glConfig.textureCompression = TC_NONE;
common->Printf( "...ignoring GL_EXT_texture_compression_s3tc\n" );
}
} else if ( CheckExtension( "GL_S3_s3tc" ) ) {
if ( r_ext_compressed_textures->integer ) {
glConfig.textureCompression = TC_S3TC;
common->Printf( "...using GL_S3_s3tc\n" );
} else {
glConfig.textureCompression = TC_NONE;
common->Printf( "...ignoring GL_S3_s3tc\n" );
}
} else {
common->Printf( "...GL_S3_s3tc not found\n" );
}
// GL_ARB_multitexture
if ( CheckExtension( "GL_ARB_multitexture" ) ) {
if ( r_ext_multitexture->integer ) {
qglMultiTexCoord2fARB = ( void ( APIENTRY* )( GLenum target, GLfloat s, GLfloat t ) )GLimp_GetProcAddress( "glMultiTexCoord2fARB" );
qglActiveTextureARB = ( void ( APIENTRY* )( GLenum target ) )GLimp_GetProcAddress( "glActiveTextureARB" );
qglClientActiveTextureARB = ( void ( APIENTRY* )( GLenum target ) )GLimp_GetProcAddress( "glClientActiveTextureARB" );
if ( qglActiveTextureARB ) {
qglGetIntegerv( GL_MAX_TEXTURE_UNITS_ARB, &glConfig.maxActiveTextures );
if ( glConfig.maxActiveTextures > 1 ) {
common->Printf( "...using GL_ARB_multitexture\n" );
} else {
qglMultiTexCoord2fARB = NULL;
qglActiveTextureARB = NULL;
qglClientActiveTextureARB = NULL;
common->Printf( "...not using GL_ARB_multitexture, < 2 texture units\n" );
}
}
} else {
common->Printf( "...ignoring GL_ARB_multitexture\n" );
}
} else {
common->Printf( "...GL_ARB_multitexture not found\n" );
}
// GL_EXT_texture_env_add
glConfig.textureEnvAddAvailable = false;
if ( CheckExtension( "GL_EXT_texture_env_add" ) ) {
if ( r_ext_texture_env_add->integer ) {
glConfig.textureEnvAddAvailable = true;
common->Printf( "...using GL_EXT_texture_env_add\n" );
} else {
glConfig.textureEnvAddAvailable = false;
common->Printf( "...ignoring GL_EXT_texture_env_add\n" );
}
} else {
common->Printf( "...GL_EXT_texture_env_add not found\n" );
}
#ifdef _WIN32
// WGL_EXT_swap_control
if ( CheckExtension( "WGL_EXT_swap_control" ) ) {
if ( r_ext_gamma_control->integer ) {
qwglSwapIntervalEXT = ( BOOL ( WINAPI* )( int ) )GLimp_GetProcAddress( "wglSwapIntervalEXT" );
if ( qwglSwapIntervalEXT ) {
common->Printf( "...using WGL_EXT_swap_control\n" );
r_swapInterval->modified = true; // force a set next frame
} else {
common->Printf( "...WGL_EXT_swap_control not found\n" );
}
} else {
common->Printf( "...ignoring WGL_EXT_swap_control\n" );
}
} else {
common->Printf( "...WGL_EXT_swap_control not found\n" );
}
#else
// GLX_SGI_swap_control
if ( CheckSystemExtension( "GLX_SGI_swap_control" ) ) {
qglXSwapIntervalSGI = ( int ( * )( int interval ) )GLimp_GetProcAddress( "glXSwapIntervalSGI" );
common->Printf( "...using GLX_SGI_swap_control\n" );
} else {
common->Printf( "... GLX_SGI_swap_control not found\n" );
}
#endif
// GL_EXT_compiled_vertex_array
if ( CheckExtension( "GL_EXT_compiled_vertex_array" ) ) {
if ( r_ext_compiled_vertex_array->integer ) {
common->Printf( "...using GL_EXT_compiled_vertex_array\n" );
qglLockArraysEXT = ( void ( APIENTRY* )( int, int ) )GLimp_GetProcAddress( "glLockArraysEXT" );
qglUnlockArraysEXT = ( void ( APIENTRY* )() )GLimp_GetProcAddress( "glUnlockArraysEXT" );
if ( !qglLockArraysEXT || !qglUnlockArraysEXT ) {
common->FatalError( "bad getprocaddress" );
}
} else {
common->Printf( "...ignoring GL_EXT_compiled_vertex_array\n" );
}
} else {
common->Printf( "...GL_EXT_compiled_vertex_array not found\n" );
}
if ( CheckExtension( "GL_EXT_point_parameters" ) ) {
if ( r_ext_point_parameters->integer ) {
common->Printf( "...using GL_EXT_point_parameters\n" );
qglPointParameterfEXT = ( void ( APIENTRY* )( GLenum, GLfloat ) )GLimp_GetProcAddress( "glPointParameterfEXT" );
qglPointParameterfvEXT = ( void ( APIENTRY* )( GLenum, const GLfloat* ) )GLimp_GetProcAddress( "glPointParameterfvEXT" );
if ( !qglPointParameterfEXT || !qglPointParameterfvEXT ) {
common->FatalError( "bad getprocaddress" );
}
} else {
common->Printf( "...ignoring GL_EXT_point_parameters\n" );
}
} else {
common->Printf( "...GL_EXT_point_parameters not found\n" );
}
// GL_NV_fog_distance
glConfig.NVFogAvailable = false;
glConfig.NVFogMode = 0;
if ( CheckExtension( "GL_NV_fog_distance" ) ) {
if ( r_ext_NV_fog_dist->integer ) {
glConfig.NVFogAvailable = true;
common->Printf( "...using GL_NV_fog_distance\n" );
} else {
common->Printf( "...ignoring GL_NV_fog_distance\n" );
}
} else {
common->Printf( "...GL_NV_fog_distance not found\n" );
}
// GL_EXT_texture_filter_anisotropic
if ( CheckExtension( "GL_EXT_texture_filter_anisotropic" ) ) {
if ( r_ext_texture_filter_anisotropic->integer ) {
glConfig.anisotropicAvailable = true;
common->Printf( "...using GL_EXT_texture_filter_anisotropic\n" );
} else {
common->Printf( "...ignoring GL_EXT_texture_filter_anisotropic\n" );
}
} else {
common->Printf( "... GL_EXT_texture_filter_anisotropic not found\n" );
}
// GL_ATI_pn_triangles - ATI PN-Triangles
if ( CheckExtension( "GL_ATI_pn_triangles" ) ) {
if ( r_ext_ATI_pntriangles->integer ) {
common->Printf( "...using GL_ATI_pn_triangles\n" );
qglPNTrianglesiATI = ( PFNGLPNTRIANGLESIATIPROC )GLimp_GetProcAddress( "glPNTrianglesiATI" );
qglPNTrianglesfATI = ( PFNGLPNTRIANGLESFATIPROC )GLimp_GetProcAddress( "glPNTrianglesfATI" );
if ( !qglPNTrianglesiATI || !qglPNTrianglesfATI ) {
common->FatalError( "bad getprocaddress 0" );
}
} else {
common->Printf( "...ignoring GL_ATI_pn_triangles\n" );
}
} else {
common->Printf( "...GL_ATI_pn_triangles not found\n" );
}
// check logging
QGL_EnableLogging( !!r_logFile->integer );
}
