static void buildTree(SampleNode *pRoot) { SampleNode *pVisualRoot, *pFood, *pNonFood, *pStreams, *pAudio; pVisualRoot = createNode(pRoot, "root", "root"); pFood = createNode(pVisualRoot, "food", "Some food"); createNode(pFood, "parsley", "tasty herb"); createNode(pFood, "salad", "eat a lot of it!"); pNonFood = createNode(pVisualRoot, "non-food", "tech stuff"); pAudio = createNode(pNonFood, "audio", "ask Lawo"); createGain(pAudio); createVolume(pAudio); createFormat(pAudio); createNode(pAudio, "dangling", NULL); pStreams = createNode(pNonFood, "streams", "see 'em move"); pStreams->node.pSchemaIdentifiers = stringDup("de.l-s-b.emberplus.samples.streams"); pStreams->fields |= GlowFieldFlag_SchemaIdentifier; createStream1(pStreams); createStream2(pStreams); createStream3(pStreams); createStream4(pStreams); }
int Z_Init(void) { zoneMutex = Sys_CreateMutex("ZONE_MUTEX"); // Create the first volume. createVolume(MEMORY_VOLUME_SIZE); return true; }
Experimental3DVolume::Experimental3DVolume(vtkImageData *image) : m_alternativeImage(0), m_finiteDifferenceGradientEstimator(0), m_4DLinearRegressionGradientEstimator(0) { createImage(image); createVolumeRayCastFunctions(); createVoxelShaders(); createMappers(); createProperty(); createVolume(); }
bool Application::setup() { Ogre::OverlayManager::getSingleton().getByName("InfoPanel")->show(); m_NXOgreScene->getMaterial(0)->setStaticFriction(0.5); m_NXOgreScene->getMaterial(0)->setDynamicFriction(0.5); m_NXOgreScene->getMaterial(0)->setRestitution(0.1); createCharacter(); createVolume(); createBasicScenary(); createTriangleMeshes(); createConvexes(); return true; }
// OpenGL initialization void Engine::initialize() { std::cout << "INITA" << std::endl; /* _GUIContext = _window->openglContext(); _GLContext = new QOpenGLContext(); */ _GUIContext = _window->openglContext(); _GLContext = new QOpenGLContext(); _format = new QSurfaceFormat(); _format->setRenderableType(QSurfaceFormat::RenderableType::OpenGL); _format->setMajorVersion(3); _format->setMinorVersion(3); _format->setProfile(QSurfaceFormat::OpenGLContextProfile::CompatibilityProfile); _GLContext->setFormat(*_format); _GLContext->create(); if(_GLContext->isValid()) std::cout << "_GLContext is valid." << std::endl; else std::cout << "_GLContext is not valid." << std::endl; if(_GLContext->makeCurrent(_window)) std::cout << "Made current: _GLContext" << std::endl; else std::cout << "Didn't make current: _GLContext" << std::endl; _window->openglContext()->format().setRenderableType(QSurfaceFormat::RenderableType::OpenGL); _window->openglContext()->format().setProfile(QSurfaceFormat::OpenGLContextProfile::CompatibilityProfile); _window->openglContext()->format().setMajorVersion(3); _window->openglContext()->format().setMinorVersion(3); std::cout << "GL info: " << glGetString(GL_VERSION) << std::endl; //_GUIContext->makeCurrent(_window); /* QSurfaceFormat f = _window->openglContext()->format(); f.setVersion(3, 3); f.setProfile(QSurfaceFormat::CompatibilityProfile); _window->openglContext()->setFormat(f); */ _GLFunctions = _window->openglContext()->functions(); //GLuint hej; //_qlFunctions->glGenFramebuffers(1, &hej); t = 0; _program = new QOpenGLShaderProgram(); _program->addShaderFromSourceCode(QOpenGLShader::Vertex, vertexShader); _program->addShaderFromSourceCode(QOpenGLShader::Fragment, fragmentShader); _program->bindAttributeLocation("vertices", 0); _program->link(); connect(_window->openglContext(), SIGNAL(aboutToBeDestroyed()), this, SLOT(cleanup()), Qt::DirectConnection); createVolume(1,1,1,1); if(_window->openglContext()->isValid()) std::cout << "_window->openglContext() is valid." << std::endl; else std::cout << "_window->openglContext() is not valid." << std::endl; // GLuint fboHandle; // glGenFramebuffers(1, &fboHandle); // glBindFramebuffer(GL_FRAMEBUFFER, fboHandle); }
void *Z_Malloc(size_t size, int tag, void *user) { memblock_t *start, *iter; memvolume_t *volume; if (tag < PU_APPSTATIC || tag > PU_PURGELEVEL) { App_Log(DE2_LOG_WARNING, "Z_Malloc: Invalid purgelevel %i, cannot allocate memory.", tag); return NULL; } if (!size) { // You can't allocate "nothing." return NULL; } lockZone(); // Align to pointer size. size = ALIGNED(size); // Account for size of block header. size += sizeof(memblock_t); // Iterate through memory volumes until we can find one with enough free // memory. (Note: we *will *find one that's large enough.) for (volume = volumeRoot; ; volume = volume->next) { uint numChecked = 0; dd_bool gotoNextVolume = false; if (volume == NULL) { // We've run out of volumes. Let's allocate a new one // with enough memory. size_t newVolumeSize = MEMORY_VOLUME_SIZE; if (newVolumeSize < size + 0x1000) newVolumeSize = size + 0x1000; // with some spare memory volume = createVolume(newVolumeSize); } if (isVolumeTooFull(volume)) { // We should skip this one. continue; } DENG_ASSERT(volume->zone); // Scan through the block list looking for the first free block of // sufficient size, throwing out any purgable blocks along the // way. if (tag == PU_APPSTATIC || tag == PU_GAMESTATIC) { // Appstatic allocations may be around for a long time so make sure // they don't litter the volume. Their own rover will keep them as // tightly packed as possible. iter = volume->zone->staticRover; } else { // Everything else is allocated using the rover. iter = volume->zone->rover; } assert(iter->prev); // Back up a little to see if we have some space available nearby. start = iter = rewindRover(volume, iter, 3, size); numChecked = 0; // If the start is in a sequence, move it to the beginning of the // entire sequence. Sequences are handled as a single unpurgable entity, // so we can stop checking at its start. if (start->seqFirst) { start = start->seqFirst; } // We will scan ahead until we find something big enough. for ( ; !(isFreeBlock(iter) && iter->size >= size); numChecked++) { // Check for purgable blocks we can dispose of. if (!isFreeBlock(iter)) { if (iter->tag >= PU_PURGELEVEL) { memblock_t *old = iter; iter = iter->prev; // Step back. #ifdef LIBDENG_FAKE_MEMORY_ZONE freeBlock(old->area, &start); #else freeBlock((byte *) old + sizeof(memblock_t), &start); #endif } else { if (iter->seqFirst) { // This block is part of a sequence of blocks, none of // which can be purged. Skip the entire sequence. iter = iter->seqFirst->seqLast; } } } // Move to the next block. iter = advanceBlock(volume, iter); // Ensure that iter will eventually touch start. assert(!start->seqFirst || start->seqFirst == start || !start->seqFirst->prev->seqFirst || start->seqFirst->prev->seqFirst == start->seqFirst->prev->seqLast); if (iter == start && numChecked > 0) { // Scanned all the way through, no suitable space found. gotoNextVolume = true; App_Log(DE2_LOG_DEBUG, "Z_Malloc: gave up on volume after %i checks", numChecked); break; } } // At this point we've found/created a big enough block or we are // skipping this volume entirely. if (gotoNextVolume) continue; // Found a block big enough. if (iter->size - size > MINFRAGMENT) { splitFreeBlock(iter, size); } #ifdef LIBDENG_FAKE_MEMORY_ZONE iter->areaSize = size - sizeof(memblock_t); iter->area = M_Malloc(iter->areaSize); #endif if (user) { iter->user = user; // mark as an in use block #ifdef LIBDENG_FAKE_MEMORY_ZONE *(void **) user = iter->area; #else *(void **) user = (void *) ((byte *) iter + sizeof(memblock_t)); #endif } else { // An owner is required for purgable blocks. DENG_ASSERT(tag < PU_PURGELEVEL); iter->user = MEMBLOCK_USER_ANONYMOUS; // mark as in use, but unowned } iter->tag = tag; if (tag == PU_MAPSTATIC) { // Level-statics are linked into unpurgable sequences so they can // be skipped en masse. iter->seqFirst = iter; iter->seqLast = iter; if (iter->prev->seqFirst) { iter->seqFirst = iter->prev->seqFirst; iter->seqFirst->seqLast = iter; } } else { // Not part of a sequence. iter->seqLast = iter->seqFirst = NULL; } // Next allocation will start looking here, at the rover. if (tag == PU_APPSTATIC || tag == PU_GAMESTATIC) { volume->zone->staticRover = advanceBlock(volume, iter); } else { volume->zone->rover = advanceBlock(volume, iter); } // Keep tabs on how much memory is used. volume->allocatedBytes += iter->size; iter->volume = volume; iter->id = LIBDENG_ZONEID; unlockZone(); #ifdef LIBDENG_FAKE_MEMORY_ZONE return iter->area; #else return (void *) ((byte *) iter + sizeof(memblock_t)); #endif } }
int zuluCryptRunTest( void ) { uid_t uid = getuid() ; seteuid( 0 ) ; setgid( uid ) ; setgroups( 1,&uid ) ; setegid( uid ) ; setuid( uid ) ; if( _loop_device_module_is_not_present() ){ printf( "\nWARNING: \"loop\" kernel module does not appear to be loaded\n" ) ; printf( "tests and opening of encrypted containers in files will fail if the module was not built into the kernel\n\n" ) ; } createTestImages() ; createKeyFiles() ; __printLine() ; createVolume( luksTestVolume,"create a luks type volume using a key: ","-p","luks" ) ; __printLine() ; checkIfDeviceIsLuks( luksTestVolume ) ; __printLine() ; createHeaderBackup( luksTestVolume,"create luks header backup: " ) ; __printLine() ; restoreHeaderBackup( luksTestVolume,"restore luks header from backup: " ) ; __printLine() ; createVolume( plainTestVolume,"create a plain type volume using a key: ","-p","plain" ) ; __printLine() ; openVolume( plainTestVolume,"open a plain volume with a key: ","-p" ); closeVolume( plainTestVolume,"closing a plain volume: " ) ; __printLine() ; openVolume( plainTestVolume,"open a plain volume with a keyfile: ","-f" ); closeVolume( plainTestVolume,"closing a plain volume: " ) ; __printLine() ; openVolumeWithPlugIn( plainTestVolume,"open a plain volume using a plugin: " ) ; closeVolume( plainTestVolume,"closing a plain volume: " ) ; __printLine() ; openVolume( luksTestVolume,"open a luks volume with a key: ","-p" ); closeVolume( luksTestVolume,"closing a luks volume: " ) ; __printLine() ; openVolume( luksTestVolume,"open a luks volume with a keyfile: ","-f" ); closeVolume( luksTestVolume,"closing a luks volume: " ) ; __printLine() ; openVolumeWithPlugIn( luksTestVolume,"open a luks volume using a plugin: " ) ; closeVolume( luksTestVolume,"closing a luks volume: " ) ; __printLine() ; checkKeySlotsInUse( luksTestVolume ) ; __printLine() ; addKeysToLuks( luksTestVolume ) ; __printLine() ; checkKeySlotsInUse( luksTestVolume ) ; __printLine() ; removeKeysFromLuksVolume( luksTestVolume ) ; checkKeySlotsInUse( luksTestVolume ) ; __printLine() ; checkForOpenedMappers() ; EXIT( 0,NULL ) ; return 0 ; }