bool
MM_EnvironmentBase::saveObjects(omrobjectptr_t objectPtr)
{
void *heapBase = getExtensions()->heap->getHeapBase();
void *heapTop = getExtensions()->heap->getHeapTop();
Assert_MM_true((heapBase <= objectPtr) && (heapTop > objectPtr));
Assert_MM_true((heapBase <= objectPtr) && (heapTop > objectPtr));
Assert_MM_true(_omrVMThread->_savedObject1 != objectPtr);
Assert_MM_true(_omrVMThread->_savedObject2 != objectPtr);
if (NULL == _omrVMThread->_savedObject1) {
_omrVMThread->_savedObject1 = objectPtr;
return true;
} else {
Assert_MM_true((heapBase <= _omrVMThread->_savedObject1) && (heapTop > _omrVMThread->_savedObject1));
}
if (NULL == _omrVMThread->_savedObject2) {
_omrVMThread->_savedObject2 = objectPtr;
return true;
} else {
Assert_MM_true((heapBase <= _omrVMThread->_savedObject2) && (heapTop > _omrVMThread->_savedObject2));
}
Assert_MM_unreachable();
return false;
}
void
MM_EnvironmentStandard::flushGCCaches()
{
#if defined(OMR_GC_CONCURRENT_SCAVENGER)
if (getExtensions()->concurrentScavenger) {
if (MUTATOR_THREAD == getThreadType()) {
if (NULL != getExtensions()->scavenger) {
getExtensions()->scavenger->threadFinalReleaseCopyCaches(this, this);
}
}
}
#endif /* OMR_GC_CONCURRENT_SCAVENGER */
}
void
QueryGeometry::flushDeletedQueryObjects( unsigned int contextID, double /*currentTime*/, double& availableTime )
{
// if no time available don't try to flush objects.
if (availableTime<=0.0) return;
const osg::Timer& timer = *osg::Timer::instance();
osg::Timer_t start_tick = timer.tick();
double elapsedTime = 0.0;
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(s_mutex_deletedQueryObjectCache);
const osg::Drawable::Extensions* extensions = getExtensions( contextID, true );
QueryObjectList& qol = s_deletedQueryObjectCache[contextID];
for(QueryObjectList::iterator titr=qol.begin();
titr!=qol.end() && elapsedTime<availableTime;
)
{
extensions->glDeleteQueries( 1L, &(*titr ) );
titr = qol.erase(titr);
elapsedTime = timer.delta_s(start_tick,timer.tick());
}
}
availableTime -= elapsedTime;
}
void GraphicsContext3D::readPixelsAndConvertToBGRAIfNecessary(int x, int y, int width, int height, unsigned char* pixels)
{
// NVIDIA drivers have a bug where calling readPixels in BGRA can return the wrong values for the alpha channel when the alpha is off for the context.
if (!m_attrs.alpha && getExtensions()->isNVIDIA()) {
::glReadPixels(x, y, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
#if USE(ACCELERATE)
vImage_Buffer src;
src.height = height;
src.width = width;
src.rowBytes = width * 4;
src.data = pixels;
vImage_Buffer dest;
dest.height = height;
dest.width = width;
dest.rowBytes = width * 4;
dest.data = pixels;
// Swap pixel channels from RGBA to BGRA.
const uint8_t map[4] = { 2, 1, 0, 3 };
vImagePermuteChannels_ARGB8888(&src, &dest, map, kvImageNoFlags);
#else
int totalBytes = width * height * 4;
for (int i = 0; i < totalBytes; i += 4)
std::swap(pixels[i], pixels[i + 2]);
#endif
} else
::glReadPixels(x, y, width, height, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, pixels);
}
QueryData genOsqueryExtensions(QueryContext& context) {
QueryData results;
ExtensionList extensions;
if (getExtensions(extensions).ok()) {
for (const auto& extension : extensions) {
Row r;
r["uuid"] = TEXT(extension.first);
r["name"] = extension.second.name;
r["version"] = extension.second.version;
r["sdk_version"] = extension.second.sdk_version;
r["path"] = getExtensionSocket(extension.first);
r["type"] = (extension.first == 0) ? "core" : "extension";
results.push_back(r);
}
}
const auto& modules = RegistryFactory::getModules();
for (const auto& module : modules) {
Row r;
r["uuid"] = TEXT(module.first);
r["name"] = module.second.name;
r["version"] = module.second.version;
r["sdk_version"] = module.second.sdk_version;
r["path"] = module.second.path;
r["type"] = "module";
results.push_back(r);
}
return results;
}
ESContext::ESContext(EGLDisplay & display, EGLSurface & surface, EGLConfig & config)
: eglDisplay(nullptr), eglContext(nullptr), eglSurface(nullptr)
{
EGLint attribList[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE, EGL_NONE
};
//create context
eglContext = eglCreateContext(display, config, EGL_NO_CONTEXT, attribList);
if (eglContext == EGL_NO_CONTEXT) {
destroy();
std::cout << "Failed to get an EGL context!" <<std::endl;
return;
}
//make context current
if(!eglMakeCurrent(display, surface, surface, eglContext)) {
std::cout << "Failed to make render context current!" << std::endl;
return;
}
//get extensions
getExtensions();
//get function bindings here
if (!getBindings()) {
std::cout << "Failed to get all function bindings!" << std::endl;
}
//setup members
eglDisplay = display;
eglSurface = surface;
}
// This method calls the lambdas that were collected
// when the flags were registered. The lambda will decide
// if the extension is kept in the list or drops out.
// In a second pass the prerequisites are checked
// and an error message may be printed.
void ConversionJob::frontendExtensionInit() {
// reset extensions list in case extensions changed, we do not want duplicates
extensionList.clear();
// register all extensions that should be registered
for(auto it = extensions.begin(); it != extensions.end(); ++it) {
if(it->second(*this)) {
extensionList.push_back(it->first);
// collect the kidnapped headers and add them to the list
for(auto kidnappedHeader : it->first->getKidnappedHeaderList()) {
addSystemHeadersDirectory(kidnappedHeader);
}
// add additional include directories
for(auto includeDir : it->first->getIncludeDirList()) {
addIncludeDirectory(includeDir);
}
}
}
// check pre-requisites
for(auto ext : getExtensions()) {
auto isMissing = ext->isPrerequisiteMissing(*this);
if(isMissing) {
std::cerr << "Prerequisite for an extension is missing:\n" << *isMissing << std::endl;
assert_fail() << "Aborting due to frontend extension prerequisite error.";
}
}
}
void GraphicsContext3D::validateAttributes()
{
Extensions3D* extensions = getExtensions();
if (m_attrs.stencil) {
const char* packedDepthStencilExtension = isGLES2Compliant() ? "GL_OES_packed_depth_stencil" : "GL_EXT_packed_depth_stencil";
if (extensions->supports(packedDepthStencilExtension)) {
extensions->ensureEnabled(packedDepthStencilExtension);
// Force depth if stencil is true.
m_attrs.depth = true;
} else
m_attrs.stencil = false;
}
if (m_attrs.antialias) {
bool isValidVendor = true;
// Currently in Mac we only turn on antialias if vendor is NVIDIA,
// or if ATI and on 10.7.2 and above.
const char* vendor = reinterpret_cast<const char*>(::glGetString(GL_VENDOR));
if (!std::strstr(vendor, "NVIDIA") && !(std::strstr(vendor, "ATI") && systemAllowsMultisamplingOnATICards()))
isValidVendor = false;
if (!isValidVendor || !extensions->supports("GL_ANGLE_framebuffer_multisample") || isGLES2Compliant())
m_attrs.antialias = false;
else
extensions->ensureEnabled("GL_ANGLE_framebuffer_multisample");
}
}
void
MM_EnvironmentBase::restoreObjects(omrobjectptr_t *objectPtrIndirect)
{
void *heapBase = getExtensions()->heap->getHeapBase();
void *heapTop = getExtensions()->heap->getHeapTop();
if (NULL != _omrVMThread->_savedObject2) {
Assert_MM_true((heapBase <= _omrVMThread->_savedObject2) && (heapTop > _omrVMThread->_savedObject2));
*objectPtrIndirect = (omrobjectptr_t)_omrVMThread->_savedObject2;
_omrVMThread->_savedObject2 = NULL;
} else if (NULL != _omrVMThread->_savedObject1) {
Assert_MM_true((heapBase <= _omrVMThread->_savedObject1) && (heapTop > _omrVMThread->_savedObject1));
*objectPtrIndirect = (omrobjectptr_t)_omrVMThread->_savedObject1;
_omrVMThread->_savedObject1 = NULL;
} else {
Assert_MM_unreachable();
}
}
void Extensions3DOpenGLCommon::initializeAvailableExtensions()
{
String extensionsString = getExtensions();
Vector<String> availableExtensions;
extensionsString.split(' ', availableExtensions);
for (size_t i = 0; i < availableExtensions.size(); ++i)
m_availableExtensions.add(availableExtensions[i]);
m_initializedAvailableExtensions = true;
}
bool
MM_EnvironmentBase::tryAcquireExclusiveVMAccessForGC(MM_Collector *collector)
{
MM_GCExtensionsBase *extensions = getExtensions();
uintptr_t collectorAccessCount = collector->getExclusiveAccessCount();
_exclusiveAccessBeatenByOtherThread = false;
while(_omrVMThread != extensions->gcExclusiveAccessThreadId) {
if(NULL == extensions->gcExclusiveAccessThreadId) {
/* there is a chance the thread can win the race to acquiring exclusive for GC */
omrthread_monitor_enter(extensions->gcExclusiveAccessMutex);
if(NULL == extensions->gcExclusiveAccessThreadId) {
/* thread is the winner and will request the GC */
extensions->gcExclusiveAccessThreadId = _omrVMThread;
}
omrthread_monitor_exit(extensions->gcExclusiveAccessMutex);
}
if(_omrVMThread != extensions->gcExclusiveAccessThreadId) {
/* thread was not the winner for requesting a GC - allow the GC to proceed and wait for it to complete */
Assert_MM_true(NULL != extensions->gcExclusiveAccessThreadId);
uintptr_t accessMask;
_envLanguageInterface->releaseCriticalHeapAccess(&accessMask);
/* there is a chance the GC will already have executed at this point or other threads will re-win and re-execute. loop until the
* thread sees that no more GCs are being requested.
*/
omrthread_monitor_enter(extensions->gcExclusiveAccessMutex);
while(NULL != extensions->gcExclusiveAccessThreadId) {
omrthread_monitor_wait(extensions->gcExclusiveAccessMutex);
}
omrthread_monitor_exit(extensions->gcExclusiveAccessMutex);
_envLanguageInterface->reacquireCriticalHeapAccess(accessMask);
/* May have been beaten to a GC, but perhaps not the one we wanted. Check and if in fact the collection we intended has been
* completed, we will not acquire exclusive access.
*/
if(collector->getExclusiveAccessCount() != collectorAccessCount) {
return false;
}
}
}
/* thread is the winner for requesting a GC (possibly through recursive calls). proceed with acquiring exclusive access. */
Assert_MM_true(_omrVMThread == extensions->gcExclusiveAccessThreadId);
this->acquireExclusiveVMAccess();
collector->incrementExclusiveAccessCount();
GC_OMRVMInterface::flushCachesForGC(this);
return true;
}
GraphicsContext3D::GraphicsContext3D(GraphicsContext3D::Attributes attrs, HostWindow* hostWindow, bool renderDirectlyToHostWindow)
: m_currentWidth(0)
, m_currentHeight(0)
, m_hostWindow(hostWindow)
, m_context(BlackBerry::Platform::Graphics::createWebGLContext())
, m_extensions(adoptPtr(new Extensions3DOpenGL(this)))
, m_attrs(attrs)
, m_texture(0)
, m_fbo(0)
, m_depthStencilBuffer(0)
, m_boundFBO(0)
, m_activeTexture(GL_TEXTURE0)
, m_boundTexture0(0)
, m_multisampleFBO(0)
, m_multisampleDepthStencilBuffer(0)
, m_multisampleColorBuffer(0)
{
if (!renderDirectlyToHostWindow) {
#if USE(ACCELERATED_COMPOSITING)
m_compositingLayer = WebGLLayerWebKitThread::create();
#endif
makeContextCurrent();
Extensions3D* extensions = getExtensions();
if (!extensions->supports("GL_IMG_multisampled_render_to_texture"))
m_attrs.antialias = false;
// Create a texture to render into.
::glGenTextures(1, &m_texture);
::glBindTexture(GL_TEXTURE_2D, m_texture);
::glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
::glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
::glBindTexture(GL_TEXTURE_2D, 0);
// Create an FBO.
::glGenFramebuffers(1, &m_fbo);
::glBindFramebuffer(GL_FRAMEBUFFER, m_fbo);
if (m_attrs.stencil || m_attrs.depth)
::glGenRenderbuffers(1, &m_depthStencilBuffer);
m_boundFBO = m_fbo;
#if USE(ACCELERATED_COMPOSITING)
static_cast<WebGLLayerWebKitThread*>(m_compositingLayer.get())->setWebGLContext(this);
#endif
}
// FIXME: If GraphicsContext3D is created with renderDirectlyToHostWindow == true,
// makeContextCurrent() will make the shared context current.
makeContextCurrent();
// FIXME: Do we need to enable GL_VERTEX_PROGRAM_POINT_SIZE with GL ES2? See PR #120141.
::glClearColor(0, 0, 0, 0);
}
ExtensionList registeredExtensions(int attempts = 3) {
ExtensionList extensions;
for (int i = 0; i < attempts; ++i) {
if (getExtensions(socket_path, extensions).ok()) {
break;
}
}
return extensions;
}
void GraphicsContext3D::validateAttributes()
{
validateDepthStencil("GL_OES_packed_depth_stencil");
if (m_attrs.antialias) {
Extensions3D* extensions = getExtensions();
if (!extensions->supports("GL_IMG_multisampled_render_to_texture"))
m_attrs.antialias = false;
}
}
bool FritzingWindow::saveAs(const QString & filename, bool readOnly) {
DebugDialog::debug(QString("current path: %1").arg(QDir::currentPath()));
QString fileExt;
QString path;
QString untitledBase = untitledFileName();
if(readOnly) {
path = defaultSaveFolder() + "/" + QFileInfo(filename).fileName();
}
else if(filename.startsWith(untitledBase, Qt::CaseInsensitive)) {
path = defaultSaveFolder() + "/" + filename;
}
else if(filename.isNull() || filename.isEmpty()) {
path = defaultSaveFolder();
}
else {
path = filename;
}
DebugDialog::debug(QString("current file: %1").arg(filename));
QString newFilename = FolderUtils::getSaveFileName(
this,
tr("Specify a file name"),
path,
getExtensionString(),
&fileExt
);
if (newFilename.isEmpty()) return false; // Cancel pressed
if (readOnly && (newFilename.compare(filename, Qt::CaseInsensitive) == 0)) {
QMessageBox::warning(NULL, QObject::tr("Fritzing"),
QObject::tr("The file '%1' is read-only; please use a different filename.")
.arg(newFilename) );
return false;
}
FileProgressDialog progress("Saving...", 0, this);
QStringList extensions = getExtensions();
bool hasExtension = false;
foreach (QString extension, extensions) {
if(alreadyHasExtension(newFilename, extension)) {
hasExtension = true;
break;
}
}
if (!hasExtension) {
newFilename += extensions[0];
}
return saveAsAux(newFilename);
}
core::ProgramPtr ConversionJob::applyPostProcessing(core::NodeManager& manager, core::ProgramPtr& program) const {
// strip of OMP annotation since those may contain references to local nodes
core::visitDepthFirstOnce(program, [](const core::NodePtr& cur) { cur->remAnnotation(omp::BaseAnnotation::KEY); });
// maybe a visitor wants to manipulate the IR translation unit
for(auto extension : getExtensions()) {
program = extension->IRVisit(program);
}
// return instance within global manager
return core::transform::utils::migrate(program, manager);
}
std::pair<char, bool> CSMWorld::ScriptContext::getMemberType (const std::string& name,
const std::string& id) const
{
/// \todo invalidate locals cache on change to scripts
std::string id2 = Misc::StringUtils::lowerCase (id);
int index = mData.getScripts().searchId (id2);
bool reference = false;
if (index==-1)
{
// ID is not a script ID. Search for a matching referenceable instead.
index = mData.getReferenceables().searchId (id2);
if (index!=-1)
{
// Referenceable found.
int columnIndex = mData.getReferenceables().findColumnIndex (Columns::ColumnId_Script);
id2 = Misc::StringUtils::lowerCase (mData.getReferenceables().
getData (index, columnIndex).toString().toUtf8().constData());
if (!id2.empty())
{
// Referenceable has a script -> use it.
index = mData.getScripts().searchId (id2);
reference = true;
}
}
}
if (index==-1)
return std::make_pair (' ', false);
std::map<std::string, Compiler::Locals>::iterator iter = mLocals.find (id2);
if (iter==mLocals.end())
{
Compiler::Locals locals;
Compiler::NullErrorHandler errorHandler;
std::istringstream stream (mData.getScripts().getRecord (index).get().mScriptText);
Compiler::QuickFileParser parser (errorHandler, *this, locals);
Compiler::Scanner scanner (errorHandler, stream, getExtensions());
scanner.scan (parser);
iter = mLocals.insert (std::make_pair (id2, locals)).first;
}
return std::make_pair (iter->second.getType (Misc::StringUtils::lowerCase (name)), reference);
}
bool Display::getConfigAttrib(const Config *configuration, EGLint attribute, EGLint *value)
{
switch (attribute)
{
case EGL_BUFFER_SIZE: *value = configuration->bufferSize; break;
case EGL_ALPHA_SIZE: *value = configuration->alphaSize; break;
case EGL_BLUE_SIZE: *value = configuration->blueSize; break;
case EGL_GREEN_SIZE: *value = configuration->greenSize; break;
case EGL_RED_SIZE: *value = configuration->redSize; break;
case EGL_DEPTH_SIZE: *value = configuration->depthSize; break;
case EGL_STENCIL_SIZE: *value = configuration->stencilSize; break;
case EGL_CONFIG_CAVEAT: *value = configuration->configCaveat; break;
case EGL_CONFIG_ID: *value = configuration->configID; break;
case EGL_LEVEL: *value = configuration->level; break;
case EGL_NATIVE_RENDERABLE: *value = configuration->nativeRenderable; break;
case EGL_NATIVE_VISUAL_ID: *value = configuration->nativeVisualID; break;
case EGL_NATIVE_VISUAL_TYPE: *value = configuration->nativeVisualType; break;
case EGL_SAMPLES: *value = configuration->samples; break;
case EGL_SAMPLE_BUFFERS: *value = configuration->sampleBuffers; break;
case EGL_SURFACE_TYPE: *value = configuration->surfaceType; break;
case EGL_TRANSPARENT_TYPE: *value = configuration->transparentType; break;
case EGL_TRANSPARENT_BLUE_VALUE: *value = configuration->transparentBlueValue; break;
case EGL_TRANSPARENT_GREEN_VALUE: *value = configuration->transparentGreenValue; break;
case EGL_TRANSPARENT_RED_VALUE: *value = configuration->transparentRedValue; break;
case EGL_BIND_TO_TEXTURE_RGB: *value = configuration->bindToTextureRGB; break;
case EGL_BIND_TO_TEXTURE_RGBA: *value = configuration->bindToTextureRGBA; break;
case EGL_MIN_SWAP_INTERVAL: *value = configuration->minSwapInterval; break;
case EGL_MAX_SWAP_INTERVAL: *value = configuration->maxSwapInterval; break;
case EGL_LUMINANCE_SIZE: *value = configuration->luminanceSize; break;
case EGL_ALPHA_MASK_SIZE: *value = configuration->alphaMaskSize; break;
case EGL_COLOR_BUFFER_TYPE: *value = configuration->colorBufferType; break;
case EGL_RENDERABLE_TYPE: *value = configuration->renderableType; break;
case EGL_MATCH_NATIVE_PIXMAP: *value = false; UNIMPLEMENTED(); break;
case EGL_CONFORMANT: *value = configuration->conformant; break;
case EGL_MAX_PBUFFER_WIDTH: *value = configuration->maxPBufferWidth; break;
case EGL_MAX_PBUFFER_HEIGHT: *value = configuration->maxPBufferHeight; break;
case EGL_MAX_PBUFFER_PIXELS: *value = configuration->maxPBufferPixels; break;
case EGL_OPTIMAL_SURFACE_ORIENTATION_ANGLE:
if (!getExtensions().surfaceOrientation)
{
return false;
}
*value = configuration->optimalOrientation;
break;
default:
return false;
}
return true;
}
float Utilities::getMaxAnisotropy() {
auto extensions = getExtensions();
if (extensions.cend() != extensions.find(anisotropyExtension)) {
float maxAnisotropyLevel;
glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &maxAnisotropyLevel);
if (isError()) {
throw RuntimeErrorException(__FILE__, __LINE__, "unable to acquire renderer back-end information");
}
return maxAnisotropyLevel;
} else {
return getMinAnisotropy();
}
}
void
MM_EnvironmentStandard::flushNonAllocationCaches()
{
MM_EnvironmentBase::flushNonAllocationCaches();
#if defined(OMR_GC_MODRON_SCAVENGER)
if (getExtensions()->scavengerEnabled) {
if (MUTATOR_THREAD == getThreadType()) {
flushRememberedSet();
}
}
#endif /* OMR_GC_MODRON_SCAVENGER */
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_WindowsPbufferPeerInfo_nCreate
(JNIEnv *env, jobject self, jobject peer_info_handle,
jint width, jint height, jobject pixel_format,
jobject pixelFormatCaps, jobject pBufferAttribs)
{
int origin_x = 0; int origin_y = 0;
HWND dummy_hwnd;
HDC dummy_hdc;
HPBUFFERARB Pbuffer;
HDC Pbuffer_dc;
WGLExtensions extensions;
const int *pBufferAttribs_ptr;
WindowsPeerInfo *peer_info = (WindowsPeerInfo *)(*env)->GetDirectBufferAddress(env, peer_info_handle);
int pixel_format_id;
if ( pBufferAttribs != NULL ) {
pBufferAttribs_ptr = (const int *)(*env)->GetDirectBufferAddress(env, pBufferAttribs);
} else {
pBufferAttribs_ptr = NULL;
}
if (!getExtensions(env, &extensions, pixel_format, pixelFormatCaps))
return;
dummy_hwnd = createDummyWindow(origin_x, origin_y);
if (dummy_hwnd == NULL) {
throwException(env, "Could not create dummy window");
return;
}
dummy_hdc = GetDC(dummy_hwnd);
pixel_format_id = findPixelFormatOnDC(env, dummy_hdc, origin_x, origin_y, pixel_format, pixelFormatCaps, false, false, true, false);
if (pixel_format_id == -1) {
closeWindow(&dummy_hwnd, &dummy_hdc);
return;
}
Pbuffer = extensions.wglCreatePbufferARB(dummy_hdc, pixel_format_id, width, height, pBufferAttribs_ptr);
closeWindow(&dummy_hwnd, &dummy_hdc);
if (Pbuffer == NULL) {
throwException(env, "Could not create Pbuffer");
return;
}
Pbuffer_dc = extensions.wglGetPbufferDCARB(Pbuffer);
if (Pbuffer_dc == NULL) {
extensions.wglDestroyPbufferARB(Pbuffer);
throwException(env, "Could not get Pbuffer DC");
return;
}
peer_info->u.pbuffer.extensions = extensions;
peer_info->u.pbuffer.pbuffer = Pbuffer;
peer_info->drawable_hdc = Pbuffer_dc;
}
void GraphicsContext3D::getIntegerv(GC3Denum pname, GC3Dint* value)
{
// Need to emulate MAX_FRAGMENT/VERTEX_UNIFORM_VECTORS and MAX_VARYING_VECTORS
// because desktop GL's corresponding queries return the number of components
// whereas GLES2 return the number of vectors (each vector has 4 components).
// Therefore, the value returned by desktop GL needs to be divided by 4.
makeContextCurrent();
switch (pname) {
#if !PLATFORM(IOS)
case MAX_FRAGMENT_UNIFORM_VECTORS:
::glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, value);
*value /= 4;
break;
case MAX_VERTEX_UNIFORM_VECTORS:
::glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS, value);
*value /= 4;
break;
case MAX_VARYING_VECTORS:
::glGetIntegerv(GL_MAX_VARYING_FLOATS, value);
*value /= 4;
break;
#endif
case MAX_TEXTURE_SIZE:
::glGetIntegerv(MAX_TEXTURE_SIZE, value);
if (getExtensions()->requiresRestrictedMaximumTextureSize())
*value = std::min(4096, *value);
break;
case MAX_CUBE_MAP_TEXTURE_SIZE:
::glGetIntegerv(MAX_CUBE_MAP_TEXTURE_SIZE, value);
if (getExtensions()->requiresRestrictedMaximumTextureSize())
*value = std::min(1024, *value);
break;
default:
::glGetIntegerv(pname, value);
}
}
void
MM_EnvironmentBase::allocationFailureEndReportIfRequired(MM_AllocateDescription *allocDescription)
{
if (_allocationFailureReported) {
MM_GCExtensionsBase *extensions = getExtensions();
OMRPORT_ACCESS_FROM_OMRPORT(_portLibrary);
TRIGGER_J9HOOK_MM_PRIVATE_FAILED_ALLOCATION_COMPLETED(
extensions->privateHookInterface,
getOmrVMThread(),
omrtime_hires_clock(),
J9HOOK_MM_PRIVATE_FAILED_ALLOCATION_COMPLETED,
allocDescription->getAllocationSucceeded() ? TRUE : FALSE,
allocDescription->getBytesRequested());
Trc_MM_AllocationFailureEnd(getLanguageVMThread(),
extensions->heap->getApproximateActiveFreeMemorySize(MEMORY_TYPE_NEW),
extensions->heap->getActiveMemorySize(MEMORY_TYPE_NEW),
extensions->heap->getApproximateActiveFreeMemorySize(MEMORY_TYPE_OLD),
extensions->heap->getActiveMemorySize(MEMORY_TYPE_OLD),
(extensions->largeObjectArea ? extensions->heap->getApproximateActiveFreeLOAMemorySize(MEMORY_TYPE_OLD) : 0),
(extensions->largeObjectArea ? extensions->heap->getActiveLOAMemorySize(MEMORY_TYPE_OLD) : 0));
Trc_OMRMM_AllocationFailureEnd(getOmrVMThread(),
extensions->heap->getApproximateActiveFreeMemorySize(MEMORY_TYPE_NEW),
extensions->heap->getActiveMemorySize(MEMORY_TYPE_NEW),
extensions->heap->getApproximateActiveFreeMemorySize(MEMORY_TYPE_OLD),
extensions->heap->getActiveMemorySize(MEMORY_TYPE_OLD),
(extensions->largeObjectArea ? extensions->heap->getApproximateActiveFreeLOAMemorySize(MEMORY_TYPE_OLD) : 0),
(extensions->largeObjectArea ? extensions->heap->getActiveLOAMemorySize(MEMORY_TYPE_OLD) : 0));
if (J9_EVENT_IS_HOOKED(extensions->privateHookInterface, J9HOOK_MM_PRIVATE_ALLOCATION_FAILURE_END)) {
MM_CommonGCEndData commonData;
extensions->heap->initializeCommonGCEndData(this, &commonData);
ALWAYS_TRIGGER_J9HOOK_MM_PRIVATE_ALLOCATION_FAILURE_END(
extensions->privateHookInterface,
getOmrVMThread(),
omrtime_hires_clock(),
J9HOOK_MM_PRIVATE_ALLOCATION_FAILURE_END,
getExclusiveAccessTime(),
&commonData,
allocDescription);
}
_allocationFailureReported = false;
}
}
void Utilities::setSampler(TextureType target, const TextureSampler& sampler) {
clearError();
GLenum target_gl;
switch (target) {
case TextureType::_2D:
target_gl = GL_TEXTURE_2D;
break;
case TextureType::_1D:
target_gl = GL_TEXTURE_1D;
break;
default:
throw UnhandledSwitchCaseException(__FILE__, __LINE__);
}
if (isError()) {
return;
}
GLint addressModeS_gl = toOpenGL(sampler.getAddressModeS()),
addressModeT_gl = toOpenGL(sampler.getAddressModeT());
glTexParameteri(target_gl, GL_TEXTURE_WRAP_S, addressModeS_gl);
glTexParameteri(target_gl, GL_TEXTURE_WRAP_T, addressModeT_gl);
if (isError()) {
return;
}
GLint minFilter_gl, magFilter_gl;
toOpenGL(sampler.getMinFilter(), sampler.getMagFilter(), sampler.getMipMapFilter(),
minFilter_gl, magFilter_gl);
glTexParameteri(target_gl, GL_TEXTURE_MIN_FILTER, minFilter_gl);
glTexParameteri(target_gl, GL_TEXTURE_MAG_FILTER, magFilter_gl);
if (isError()) {
return;
}
if (TextureType::_2D == target) {
auto extensions = getExtensions();
if (extensions.cend() != extensions.find(anisotropyExtension)) {
float anisotropyLevel = Ego::Math::constrain(sampler.getAnisotropyLevel(), getMinAnisotropy(), getMaxAnisotropy());
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, anisotropyLevel);
if (isError()) {
return;
}
}
}
}
void
MM_EnvironmentBase::allocationFailureStartReportIfRequired(MM_AllocateDescription *allocDescription, uintptr_t flags)
{
if (!_allocationFailureReported) {
MM_GCExtensionsBase *extensions = getExtensions();
OMRPORT_ACCESS_FROM_OMRPORT(_portLibrary);
Trc_MM_AllocationFailureStart(getLanguageVMThread(),
extensions->heap->getApproximateActiveFreeMemorySize(MEMORY_TYPE_NEW),
extensions->heap->getActiveMemorySize(MEMORY_TYPE_NEW),
extensions->heap->getApproximateActiveFreeMemorySize(MEMORY_TYPE_OLD),
extensions->heap->getActiveMemorySize(MEMORY_TYPE_OLD),
(extensions->largeObjectArea ? extensions->heap->getApproximateActiveFreeLOAMemorySize(MEMORY_TYPE_OLD) : 0),
(extensions->largeObjectArea ? extensions->heap->getActiveLOAMemorySize(MEMORY_TYPE_OLD) : 0),
allocDescription->getBytesRequested());
Trc_OMRMM_AllocationFailureStart(getOmrVMThread(),
extensions->heap->getApproximateActiveFreeMemorySize(MEMORY_TYPE_NEW),
extensions->heap->getActiveMemorySize(MEMORY_TYPE_NEW),
extensions->heap->getApproximateActiveFreeMemorySize(MEMORY_TYPE_OLD),
extensions->heap->getActiveMemorySize(MEMORY_TYPE_OLD),
(extensions->largeObjectArea ? extensions->heap->getApproximateActiveFreeLOAMemorySize(MEMORY_TYPE_OLD) : 0),
(extensions->largeObjectArea ? extensions->heap->getActiveLOAMemorySize(MEMORY_TYPE_OLD) : 0),
allocDescription->getBytesRequested());
if (J9_EVENT_IS_HOOKED(extensions->privateHookInterface, J9HOOK_MM_PRIVATE_ALLOCATION_FAILURE_START)) {
MM_CommonGCStartData commonData;
extensions->heap->initializeCommonGCStartData(this, &commonData);
ALWAYS_TRIGGER_J9HOOK_MM_PRIVATE_ALLOCATION_FAILURE_START(
extensions->privateHookInterface,
getOmrVMThread(),
omrtime_hires_clock(),
J9HOOK_MM_PRIVATE_ALLOCATION_FAILURE_START,
allocDescription->getBytesRequested(),
&commonData,
flags,
allocDescription->getTenuredFlag());
}
_allocationFailureReported = true;
}
}
void BaseRouter::requestHandshake(const dtn::data::EID &destination, NodeHandshake &request)
{
ibrcommon::RWLock l(getExtensionMutex(), ibrcommon::RWMutex::LOCK_READONLY);
// walk through all extensions to process the contents of the response
const BaseRouter::extension_list& extensions = getExtensions();
// process this handshake using the NodeHandshakeExtension
_nh_extension.requestHandshake(destination, request);
// process this handshake using the retransmission extension
_retransmission_extension.requestHandshake(destination, request);
for (BaseRouter::extension_list::const_iterator iter = extensions.begin(); iter != extensions.end(); ++iter)
{
RoutingExtension &extension = (**iter);
extension.requestHandshake(destination, request);
}
}
std::ostream& ConversionJob::printTo(std::ostream& out) const {
out << "~~~~~~CONVERSION SETUP~~~~~~\n";
out << "input files: \n" << files << std::endl;
out << "flags: \n"
<< "PrintDiag " << hasOption(ConversionSetup::PrintDiag) << "\n"
<< "WinCrossCompile " << hasOption(ConversionSetup::WinCrossCompile) << "\n"
<< "TAG_MPI " << hasOption(ConversionSetup::TAG_MPI) << "\n"
<< "ProgressBar " << hasOption(ConversionSetup::ProgressBar) << "\n"
<< "NoWarnings " << hasOption(ConversionSetup::NoWarnings) << "\n"
<< "NoDefaultExtensions " << hasOption(ConversionSetup::NoDefaultExtensions) << "\n" << std::endl;
out << "interceptions: \n" << getInterceptedNameSpacePatterns() << std::endl;
out << "crosscompilation dir: \n" << getCrossCompilationSystemHeadersDir() << std::endl;
out << "include dirs: \n" << getIncludeDirectories() << std::endl;
out << "definitions: \n" << getDefinitions() << std::endl;
out << "libraries: \n" << libs << std::endl;
out << "standard: \n" << getStandard() << std::endl;
out << "number of registered extensions: \n" << getExtensions().size() << std::endl;
out << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
return out;
}
void GLWidget::initializeGL()
{
if(!getExtensions())
{
fprintf(stderr,"Error: %s.\n","Open OpenGL Extensions Error!!!");
exit(-1);
}
qglClearColor(Qt::gray);
glClearDepth(1.0);
glShadeModel(GL_FLAT);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);
setLight();
setFog();
t = startTimer(50);
}
JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_WindowsDisplay_nGetPbufferCapabilities
(JNIEnv *env, jobject self, jobject pixel_format)
{
int caps = 0;
WGLExtensions extensions;
if (!getExtensions(env, &extensions, pixel_format, NULL))
return 0;
if (isPbufferSupported(&extensions))
caps |= org_lwjgl_opengl_Pbuffer_PBUFFER_SUPPORTED;
if (extensions.WGL_ARB_render_texture)
caps |= org_lwjgl_opengl_Pbuffer_RENDER_TEXTURE_SUPPORTED;
if (extensions.WGL_NV_render_texture_rectangle)
caps |= org_lwjgl_opengl_Pbuffer_RENDER_TEXTURE_RECTANGLE_SUPPORTED;
if (extensions.WGL_NV_render_depth_texture)
caps |= org_lwjgl_opengl_Pbuffer_RENDER_DEPTH_TEXTURE_SUPPORTED;
return caps;
}
Codec* Codec::getCodec(const String& extension)
{
String lwrcase = extension;
StringUtil::toLowerCase(lwrcase);
CodecList::const_iterator i = msMapCodecs.find(lwrcase);
if (i == msMapCodecs.end())
{
String formats_str;
if(msMapCodecs.empty())
formats_str = "There are no formats supported (no codecs registered).";
else
formats_str = "Supported formats are: " + StringConverter::toString(getExtensions()) + ".";
OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
"Can not find codec for '" + extension + "' image format.\n" +
formats_str,
"Codec::getCodec");
}
return i->second;
}
