//main sprawdzanie argumentow i wywolanie funkcji
int main(int argc, char** argv) {
int i;
for (i = 1; i < argc; i++) {
if (strcmp("-w", argv[i]) == 0) w = 1;
if (strcmp("-v", argv[i]) == 0) v = 1;
}
exeName=argv[0];
parseExtensions();
checkDir(argv);
return (EXIT_SUCCESS);
}
bool GLPlatformContext::supportsGLExtension(const String& name)
{
static HashSet<String> supportedExtensions;
if (!supportedExtensions.size()) {
String rawExtensions = reinterpret_cast<const char*>(::glGetString(GL_EXTENSIONS));
supportedExtensions = parseExtensions(rawExtensions);
}
if (supportedExtensions.contains(name))
return true;
return false;
}
TGen::OpenGL::Renderer::Renderer()
: colorFromVertex(true)
, lastShader(NULL)
#ifdef _GFX_KEEP_DEPRECATED
, lastVb(NULL)
, lastIb(NULL)
#endif
, lastVb2(NULL)
, lastIb2(NULL)
, lastVb1(-1)
, lastIb1(-1)
, ibReadOffset(0)
, vbReadOffset(0)
, indexBufferFormatSize(0)
, lastFBO(-1)
, lastBoundFBO(NULL)
, hasCoordElements(NULL)
, hasNormalElements(NULL)
, hasColorElements(NULL)
, hasEdgeElements(NULL)
, textureCoordGenU(TGen::TextureCoordGenBase)
, textureCoordGenV(TGen::TextureCoordGenBase)
, currentWinding(TGen::FaceWindingCCW)
{
TGen::OpenGL::BindFunctions(); // will be needed if we're running on a sucky platform with old OpenGL (Windows, I'm looking at you...)
parseExtensions();
readCaps();
checkCompatibility();
textureUnitTargets = new GLenum[caps.maxTextureUnits];
textureUnitTextures = new TGen::Texture*[caps.maxTextureUnits];
for (int i = 0; i < caps.maxTextureUnits; ++i) {
textureUnitTargets[i] = GL_NONE;
textureUnitTextures[i] = NULL;
if (i < 8)
hasTexCoordUnitElements[i] = false;
}
glEnable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glEnable(GL_TEXTURE_2D);
glEnable(GL_CULL_FACE);
glFrontFace(GL_CCW);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
}
bool GLPlatformContext::supportsGLXExtension(Display* display, const String& name)
{
static HashSet<String> supportedExtensions;
if (!supportedExtensions.size()) {
if (!display)
return false;
String rawExtensions = glXQueryExtensionsString(display, DefaultScreen(display));
supportedExtensions = parseExtensions(rawExtensions);
}
if (supportedExtensions.contains(name))
return true;
return false;
}
bool GLPlatformContext::supportsEGLExtension(EGLDisplay display, const String& name)
{
static HashSet<String> supportedExtensions;
if (!supportedExtensions.size()) {
if (display == EGL_NO_DISPLAY)
return false;
String rawExtensions = reinterpret_cast<const char*>(eglQueryString(display, EGL_EXTENSIONS));
supportedExtensions = parseExtensions(rawExtensions);
}
if (supportedExtensions.contains(name))
return true;
return false;
}
bool Client::parseLogin(const rapidjson::Value &result, int *code)
{
if (!m_rpcId.setId(result["id"].GetString())) {
*code = 1;
return false;
}
# ifndef XMRIG_PROXY_PROJECT
m_nicehash = m_url.isNicehash();
# endif
if (result.HasMember("extensions")) {
parseExtensions(result["extensions"]);
}
const bool rc = parseJob(result["job"], code);
m_jobs = 0;
return rc;
}
std::string
RenderingDevices::xml()
{
// We cache the results
if(m_hasRenderingInformation) {
std::cout << m_xml<<std::endl;
return m_xml;
}
std::stringstream xml;
xml << " <renderingDevices>\n";
DIR* dir = opendir( "/tmp/.X11-unix" );
if( dir == NULL ) {
if( m_logger != NULL ) {
m_logger( m_logger_data, 0, package.c_str(),
"opendir failed: %s.", strerror( errno ) );
}
xml << " <error>INTERNAL_ERROR</error>\n";
}
else {
struct dirent* entry = NULL;
while( (entry = readdir( dir )) != NULL ) {
if( entry->d_name[0] != 'X' ) {
continue;
}
std::string display_id = ":" + std::string( entry->d_name ).substr(1);
Display* display = XOpenDisplay( display_id.c_str() );
if( display == NULL ) {
xml << " <renderingDevice id=\"" << display_id << "\">\n";
xml << " <error>FAILED_TO_OPEN_DISPLAY</error>\n";
xml << " </renderingDevice>\n";
continue;
}
#ifdef TINIA_AMAZON
int screen_count = 1;
#else
int screen_count = ScreenCount ( display );
#endif
XCloseDisplay( display );
if( screen_count < 1 ) {
xml << " <renderingDevice id=\"" << display_id << "\">\n";
xml << " <error>NO_SCREENS</error>\n";
xml << " </renderingDevice>\n";
continue;
}
for(int screen=0; screen<screen_count; screen++) {
std::stringstream screen_id_ss;
screen_id_ss << display_id << '.' << screen;
std::string screen_id = screen_id_ss.str();
xml << " <renderingDevice id=\"" << screen_id << "\">\n";
OffscreenGL gl( m_logger, m_logger_data );
if( !gl.setupContext( screen_id ) || !gl.bindContext() ) {
switch ( gl.state() ) {
case OffscreenGL::STATE_INSUFFICIENT_GLX:
xml << " <error>INSUFFICIENT_GLX</error>\n";
break;
case OffscreenGL::STATE_X_ERROR:
xml << " <error>X_ERROR</error>\n";
break;
default:
xml << " <error>INTERNAL_ERROR</error>\n";
break;
}
}
else {
int glx_major = 0;
int glx_minor = 0;
glXQueryVersion( gl.display(), &glx_major, &glx_minor );
xml << " <glx major=\"" << glx_major
<< "\" minor=\"" << glx_minor
<< "\" direct=\"" << (glXIsDirect(gl.display(), gl.context())==True?'1':'0')
<< "\">\n";
xml << " <client>\n";
xml << " <vendor>" << glXGetClientString( gl.display(), GLX_VENDOR ) << "</vendor>\n";
xml << " <version>" << glXGetClientString( gl.display(), GLX_VERSION ) << "</version>\n";
xml << " </client>\n";
xml << " <server>\n";
xml << " <vendor>" << glXQueryServerString( gl.display(), screen, GLX_VENDOR ) << "</vendor>\n";
xml << " <version>" << glXQueryServerString( gl.display(), screen, GLX_VERSION ) << "</version>\n";
xml << " </server>\n";
std::list<std::string> glx_extensions = parseExtensions( glXQueryExtensionsString( gl.display(), screen ) );
for( std::list<std::string>::iterator it=glx_extensions.begin(); it!=glx_extensions.end(); ++it ) {
//xml << " <extension>" << *it << "</extension>\n";
}
xml << " </glx>\n";
GLint gl_major = 0;
glGetIntegerv( GL_MAJOR_VERSION, &gl_major );
GLint gl_minor = 0;
glGetIntegerv( GL_MINOR_VERSION, &gl_minor );
xml << " <opengl major=\"" << gl_major
<< "\" minor=\"" << gl_minor
<< "\">\n";
xml << " <vendor>" << (const char*)glGetString( GL_VENDOR ) << "</vendor>\n";
xml << " <version>" << (const char*)glGetString( GL_VERSION ) << "</version>\n";
xml << " <renderer>" << (const char*)glGetString( GL_RENDERER) << "</renderer>\n";
if( gl_major >= 2 ) {
xml << " <glsl><version>"
<< (const char*)glGetString( GL_SHADING_LANGUAGE_VERSION )
<< "</version></glsl>\n";
}
std::list<std::string> gl_extensions = parseExtensions( (const char*)glGetString( GL_EXTENSIONS ) );
for( std::list<std::string>::iterator it=gl_extensions.begin(); it!=gl_extensions.end(); ++it ) {
//xml << " <extension>" << *it << "</extension>\n";
}
xml << " </opengl>\n";
}
xml << " </renderingDevice>\n";
}
}
closedir( dir );
}
xml << " </renderingDevices>\n";
m_hasRenderingInformation = true;
m_xml = xml.str();
return xml.str();
}
std::vector<std::string> PlayerFileDialogServiceWin::openMultipleInternal(const std::string &title,
const std::string &directory,
const std::string &extensions,
bool isMulti) const
{
std::u16string u16title;
cocos2d::StringUtils::UTF8ToUTF16(title, u16title);
WCHAR basedir[MAX_PATH + 1];
if (directory.length())
{
std::u16string u16directory;
cocos2d::StringUtils::UTF8ToUTF16(directory, u16directory);
wcscpy_s(basedir, (WCHAR*)u16directory.c_str());
}
else
{
GetCurrentDirectory(MAX_PATH, basedir);
}
size_t buffsize = MAX_PATH;
if (isMulti) buffsize = MAX_PATH * 64;
WCHAR *buff = new WCHAR[buffsize + 1];
memset(buff, 0, sizeof(WCHAR) * (buffsize + 1));
OPENFILENAME ofn = {0};
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = _hwnd;
ofn.lpstrFilter = parseExtensions(extensions);
ofn.lpstrTitle = (LPCTSTR)u16title.c_str();
ofn.lpstrInitialDir = basedir;
ofn.Flags = OFN_DONTADDTORECENT | OFN_ENABLESIZING | OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY | OFN_LONGNAMES;
if (isMulti) ofn.Flags |= OFN_ALLOWMULTISELECT | OFN_EXPLORER;
ofn.lpstrFile = buff;
ofn.nMaxFile = buffsize;
vector<std::string> result;
BOOL ret = GetOpenFileName(&ofn);
delete[] ofn.lpstrFilter;
if (!ret)
{
// user cancel dialog, GetOpenFileName() will return FALSE
DWORD err = CommDlgExtendedError();
if (err)
{
CCLOG("PlayerFileDialogServiceWin::openMultipleInternal() - failed, title (%s), error code = %u", title.c_str(), err);
}
delete[] buff;
return result;
}
if (isMulti)
{
WORD offset = 0;
std::string path;
while (buff[offset] != '\0')
{
std::string filename;
std::u16string u16filename((char16_t*)(buff + offset));
cocos2d::StringUtils::UTF16ToUTF8(u16filename, filename);
if (offset == 0)
{
path = filename;
if (path[path.length() - 1] != '\\')
{
path.append("\\");
}
}
else
{
result.push_back(path + filename);
}
offset += u16filename.length() + 1;
}
}
else
{
std::string path;
cocos2d::StringUtils::UTF16ToUTF8((char16_t*)buff, path);
result.push_back(path);
}
delete[] buff;
return result;
}
