Example #1
0
/*!
 *  \fn DWORD PMD::pmcheckwlan()
 *  \ingroup win32backend
 *  \public
 *  \brief Public function to encapsulate the checking of all WLAN interfaces.
 *  \retval 1 : At least one monitor mode card found.
 *  \retval 0 : No monitor mode cards found.
 *  \retval -1 : The process is broken.
 *  \retval -2 : Monitor mode found but could not be stopped.
 *  \retval -3 : Monitor mode found and stopped.
 */
DWORD PMD::pmcheckwlan() {
	
	DWORD rtn = -1;

	createConnect();
	setInterfaceList();

	
	for (pInterfaceList->dwIndex = 0; pInterfaceList->dwIndex < pInterfaceList->dwNumberOfItems; pInterfaceList->dwIndex++)
	{
		getInterfaceCapability();
		
		rtn = queryInterface();
		
		if (rtn == 1) {
			if (stopMonitorMode() == ERROR_SUCCESS) {
				printf ("Monitor mode stopped~\n");
				rtn = -3;
			}
			else  {
				printf ("Monitor mode failed to stop!\n");
				rtn = -2;
			}
			cleanup();
          	return rtn;
        }
		
	}
	
	cleanup();
	return rtn;
}
    void createBrowser()
    {
        createControl (&CLSID_WebBrowser);
        browser = (IWebBrowser2*) queryInterface (&IID_IWebBrowser2);

        if (IConnectionPointContainer* connectionPointContainer
                = (IConnectionPointContainer*) queryInterface (&IID_IConnectionPointContainer))
        {
            connectionPointContainer->FindConnectionPoint (DIID_DWebBrowserEvents2, &connectionPoint);

            if (connectionPoint != nullptr)
            {
                WebBrowserComponent* const owner = dynamic_cast <WebBrowserComponent*> (getParentComponent());
                jassert (owner != nullptr);

                EventHandler* handler = new EventHandler (*owner);
                connectionPoint->Advise (handler, &adviseCookie);
                handler->Release();
            }
        }
    }
Example #3
0
int EntityMgr::findTypesForInterface(iid_t iid) {
    static std::vector<const char*> result;
    result.clear();
    for (unsigned int i=0; i < chunkType.size(); ++i) {
        const char * typeName = chunkType[i].name;
        if (NULL==typeName || chunkType[i].instances.empty()) continue;
        entid_t id = chunkType[i].instances[0];
        IBase * p = queryInterface(id, iid, true);
        if (NULL!=p) result.push_back(typeName);
    }
    strResult = result;
    return strResult.size();
}
Example #4
0
IBase * EntityMgr::queryInterface(const char * entityType, iid_t iid, bool softQuery) {
    int numItems = findByType(entityType);
    IBase * pInt = NULL;
    if (numItems > 0) {
        pInt = queryInterface(entityResult.front(), iid, true);
    }
    if (NULL==pInt && !softQuery) {
        if (numItems==0) throw Exception("core: Entity {type='%s'} not exists", entityType);
        const char * iname = getCore()->getIdName(iid);
        throw Exception("core: Entity {type='%s'} doesn't support Iterface{iid=0x%08X, name='%s'}", entityType, iid, iname);
    }
    return pInt;
}
Example #5
0
/*!
    \since 4.1

    Requests the COM object to perform the action \a verb. The
    possible verbs are returned by verbs().

    The function returns true if the object could perform the action, otherwise returns false.
*/
bool QAxObject::doVerb(const QString &verb)
{
    if (!verbs().contains(verb))
        return false;
    IOleObject *ole = 0;
    queryInterface(IID_IOleObject, (void**)&ole);
    if (!ole)
        return false;

    LONG index = indexOfVerb(verb);

    HRESULT hres = ole->DoVerb(index, 0, 0, 0, 0, 0);

    ole->Release();

    return hres == S_OK;
}
Example #6
0
ImportAsset::ImportAsset(const char* resourcePath)
{
    import::IImport* iImport = NULL;
    queryInterface( "Import", &iImport );

    import::IImportStream* iImportStream = iImport->importRws( resourcePath );
    
    while( iImportStream->getType() != import::itNULL )
    switch( iImportStream->getType() )
    {
    case import::itTexture:
        {
            import::ImportTexture* importData = iImportStream->importTexture();
            // search for texture in current dictionary
            if( Texture::textures.find( importData->name ) == Texture::textures.end() )
            {
                if( strcmp( importData->name, "House01" ) == 0 )
                {
                    int iiii=0;
                }
                // create compatible texture
                Texture* texture = Texture::createDynamicTexture( 
                    importData->width, 
                    importData->height, 
                    importData->depth, 
                    importData->name
                );
                // lock texture top-level surface
                D3DLOCKED_RECT lockedRect;
                texture->iDirect3DTexture()->LockRect( 0, &lockedRect, NULL, 0 );
                // copy pixels
                int offset = 0;
                unsigned char* destPixels = (unsigned char*)(lockedRect.pBits);    
                for( int i=0; i<importData->width*importData->height; i++ )
                {
                    destPixels[offset + 0] = importData->pixels[offset + 2],
                    destPixels[offset + 1] = importData->pixels[offset + 1],
                    destPixels[offset + 2] = importData->pixels[offset + 0],
                    destPixels[offset + 3] = importData->pixels[offset + 3];
                    offset += 4;
                }
                texture->iDirect3DTexture()->UnlockRect( 0 );
                // setup filetering, addressing, etc
                switch( importData->addressMode )
                {
                case import::iamWrap: 
                    texture->setAddressTypeU( engine::atWrap );
                    texture->setAddressTypeV( engine::atWrap );
                    break;
                case import::iamMirror:
                    texture->setAddressTypeU( engine::atMirror );
                    texture->setAddressTypeV( engine::atMirror );
                    break;
                case import::iamClamp:
                    texture->setAddressTypeU( engine::atClamp );
                    texture->setAddressTypeV( engine::atClamp );
                    break;
                case import::iamBorder:
                    texture->setAddressTypeU( engine::atBorder );
                    texture->setAddressTypeV( engine::atBorder );
                    break;
                }
                switch( importData->filterMode )
                {
                case import::ifmNearest:
                    texture->setMagFilter( engine::ftPoint );
                    texture->setMinFilter( engine::ftPoint );
                    texture->setMipFilter( engine::ftNone );
                    break;
                case import::ifmLinear:
                    texture->setMagFilter( engine::ftLinear );
                    texture->setMinFilter( engine::ftLinear );
                    texture->setMipFilter( engine::ftNone );
                    break;
                case import::ifmMipNearest:
                    texture->setMagFilter( engine::ftPoint );
                    texture->setMinFilter( engine::ftPoint );
                    texture->setMipFilter( engine::ftPoint );
                    break;
                case import::ifmMipLinear:
                    texture->setMagFilter( engine::ftPoint );
                    texture->setMinFilter( engine::ftPoint );
                    texture->setMipFilter( engine::ftLinear );
                    break;
                case import::ifmLinearMipNearest:
                    texture->setMagFilter( engine::ftLinear );
                    texture->setMinFilter( engine::ftLinear );
                    texture->setMipFilter( engine::ftPoint );
                    break;
                case import::ifmLinearMipLinear:
                    texture->setMagFilter( engine::ftLinear );
                    texture->setMinFilter( engine::ftLinear );
                    texture->setMipFilter( engine::ftLinear );
                    break;
                }
                // override filtering
                texture->setMagFilter( engine::ftLinear );
                texture->setMinFilter( engine::ftLinear );
                texture->setMipFilter( engine::ftLinear );
                texture->setMaxAnisotropy( 8 );
                /*
                // create normal map
                iImport->createNormalMap(
                    importData->width, 
                    importData->height, 
                    importData->depth, 
                    importData->pixels,
                    importData->stride,
                    true,
                    5.0f
                );
                // create compatible texture
                Texture* normalMap = Texture::createDynamicTexture(
                    importData->width, 
                    importData->height, 
                    importData->depth, 
                    ( std::string( importData->name ) + "_nmap" ).c_str()
                );
                normalMap->setMagFilter( engine::ftLinear );
                normalMap->setMinFilter( engine::ftLinear );
                normalMap->setMipFilter( engine::ftLinear );
                // lock texture top-level surface
                lockedRect;
                normalMap->iDirect3DTexture()->LockRect( 0, &lockedRect, NULL, 0 );
                // copy pixels
                offset = 0;
                destPixels = (unsigned char*)(lockedRect.pBits);    
                for( i=0; i<importData->width*importData->height; i++ )
                {
                    destPixels[offset + 0] = importData->pixels[offset + 2],
                    destPixels[offset + 1] = importData->pixels[offset + 1],
                    destPixels[offset + 2] = importData->pixels[offset + 0],
                    destPixels[offset + 3] = importData->pixels[offset + 3];
                    offset += 4;
                }
                normalMap->iDirect3DTexture()->UnlockRect( 0 );
                */
                // put texture into importer storage
                _textures.insert( TextureT( importData->id, texture ) );
            }
            // release import data
            iImport->release( importData );
        }
        break;
    case import::itMaterial:
        {
            import::ImportMaterial* importData = iImportStream->importMaterial();

            Shader* shader = NULL;
            
            if( importData->textureId == 0 && importData->dualPassTextureId == 0 )
            {
                shader = new Shader( 0, importData->name );
            }
            else if( importData->textureId != 0 && importData->dualPassTextureId == 0 )
            {
                shader = new Shader( 1, importData->name );
                TextureI textureI = _textures.find( importData->textureId );
                if( textureI != _textures.end() ) 
                {
                    shader->setLayerTexture( 0, textureI->second );
                }
                shader->setLayerUV( 0,0 );
                /*
                ::TextureI normalMapI = Texture::textures.find( ( std::string( textureI->second->getName() ) + "_nmap" ).c_str() );
                if( normalMapI != Texture::textures.end() )
                {
                    shader->setNormalMap( normalMapI->second );
                    shader->setNormalMapUV( 0 );
                }
                */
            }
            else
            {
                shader = new Shader( 2, importData->name );
                TextureI textureI = _textures.find( importData->textureId );
                if( textureI != _textures.end() ) 
                {
                    shader->setLayerTexture( 0, textureI->second );
                }
                textureI = _textures.find( importData->dualPassTextureId );
                if( textureI != _textures.end() ) 
                {
                    shader->setLayerTexture( 1, textureI->second );
                }
                shader->setLayerUV( 1,1 );
                switch( importData->dualPassBlendType )
                {
                case import::ImportMaterial::btAdd:
                    shader->setLayerBlending( 1, engine::btAdd );
                    break;
                case import::ImportMaterial::btModulate:
                    shader->setLayerBlending( 1, engine::btModulate );
                    break;
                case import::ImportMaterial::btBlendTextureAlpha:
                    shader->setLayerBlending( 1, engine::btBlendTextureAlpha );
                    break;
                default:
                    shader->setLayerBlending( 1, engine::btOver );
                }

                textureI = _textures.find( importData->textureId );
                assert( textureI != _textures.end() );
                ::TextureI normalMapI = Texture::textures.find( ( std::string( textureI->second->getName() ) + "_nmap" ).c_str() );
                if( normalMapI != Texture::textures.end() )
                {
                    shader->setNormalMap( normalMapI->second );
                    shader->setNormalMapUV( 0 );
                }
            }

            shader->setDiffuseColor( importData->color );
            // put texture into importer storage
            _shaders.insert( ShaderT( importData->id, shader ) );
            // release import data
            iImport->release( importData );
        }
        break;
    case import::itFrame:
        {
            import::ImportFrame* importData = iImportStream->importFrame();

            Frame* frame = new Frame( importData->name );
            frame->TransformationMatrix = wrap( importData->modeling );	
			
            FrameI parentI = _frames.find( importData->parentId );
            if( parentI != _frames.end() ) 
            {
                frame->setParent( parentI->second );
            }
            _frames.insert( FrameT( importData->id, frame ) );
            iImport->release( importData );
        }
        break;
    case import::itGeometry:
        {
            import::ImportGeometry* importData = iImportStream->importGeometry();

            Geometry* geometry = new Geometry(
                importData->numVertices,
                importData->numTriangles,
                importData->numUVs,
                importData->numMaterials,
                ( importData->prelights != NULL ) ? 1 : 0,
                false,
                importData->name
            );

            for( int i=0; i<importData->numVertices; i++ )
            {
                geometry->getVertices()[i] = wrap( importData->vertices[i] );				
                geometry->getNormals()[i] = wrap( importData->normals[i] );
				// rh2lh conversion
                /*
				geometry->getVertices()[i][2] *= -1;
				geometry->getNormals()[i][2] *= -1;
                */
                geometry->getUVSet(0)[i] = wrap( importData->uvs[0][i] );
                if( importData->numUVs > 1 ) 
                {
                    geometry->getUVSet(1)[i] = wrap( importData->uvs[1][i] );
                }
                if( importData->prelights )
                {
                    geometry->getPrelights(0)[i] = wrap( importData->prelights[i] );
                }
            }
            for( i=0; i<importData->numTriangles; i++ )
            {
                /*
                geometry->getTriangles()[i].set(
                    importData->triangles[i].vertexId[0],
					importData->triangles[i].vertexId[2],
					importData->triangles[i].vertexId[1],					
                    importData->triangles[i].materialId
                );
                */
                geometry->getTriangles()[i].set(
                    importData->triangles[i].vertexId[0],
                    importData->triangles[i].vertexId[1],
					importData->triangles[i].vertexId[2],					
                    importData->triangles[i].materialId
                );
            }
            for( i=0; i<importData->numMaterials; i++ )
            {
                ShaderI shaderI = _shaders.find( importData->materials[i] );
                assert( shaderI != _shaders.end() );
                geometry->setShader( i, shaderI->second );
            }
            geometry->instance();
            _geometries.insert( GeometryT( importData->id, geometry ) );
            iImport->release( importData );
        }
        break;
    case import::itAtomic:
        {
            import::ImportAtomic* importData = iImportStream->importAtomic();
            Atomic* atomic = new Atomic;
            FrameI frameI = _frames.find( importData->frameId );
            assert( frameI != _frames.end() );
            atomic->setFrame( frameI->second );
            GeometryI geometryI = _geometries.find( importData->geometryId );
            assert( geometryI != _geometries.end() );
            atomic->setGeometry( geometryI->second );            
            TextureI textureI = _textures.find( importData->lightmapId );
            if( textureI != _textures.end() ) 
            {
                atomic->setLightMap( textureI->second );
            }
            _atomics.insert( AtomicT( importData->id, atomic ) );
            iImport->release( importData );
        }
        break;
    case import::itClump:
        {
            import::ImportClump* importData = iImportStream->importClump();
            Clump* clump = new Clump( importData->name );
            FrameI frameI = _frames.find( importData->frameId );
            assert( frameI != _frames.end() );
            clump->setFrame( frameI->second );
            frameI->second->dirty();
            for( int i=0; i<importData->numAtomics; i++ )
            {
                AtomicI atomicI = _atomics.find( importData->atomics[i] );
                assert( atomicI != _atomics.end() );
                clump->add( atomicI->second );
            }
            for( i=0; i<importData->numLights; i++ )
            {
                LightI lightI = _lights.find( importData->lights[i] );
                assert( lightI != _lights.end() );
                clump->add( lightI->second );
            }
            iImport->release( importData );
            /*
			rh2lh( clump->frame() );
            */
            _clumps.push_back( clump );
        }
        break;
    case import::itWorldSector:
        {
            import::ImportWorldSector* importData = iImportStream->importWorldSector();
            
            BSPI bspI = _bspM.find( importData->worldId ); assert( bspI != _bspM.end() );
            BSPSectorI parentSectorI = _bspSectorM.find( importData->parentId );
            BSPSector* parentSector = NULL;
            if( parentSectorI != _bspSectorM.end() ) parentSector = parentSectorI->second;
            AABB boundingBox;
            boundingBox.inf = wrap( importData->aabbInf );
            boundingBox.sup = wrap( importData->aabbSup );
			// rh2lh conversion
            /*
			float temp = boundingBox.inf[2] * -1;
			boundingBox.inf[2] = boundingBox.sup[2] * -1;
			boundingBox.sup[2] = temp;
            */

            int numPrelights = 0; if( importData->prelights ) numPrelights++;

            Geometry* geometry = NULL;

            if( importData->numVertices && importData->numTriangles )
            {
                geometry = new Geometry( 
                    importData->numVertices, 
                    importData->numTriangles, 
                    importData->numUVs, 
                    bspI->second->getNumShaders(),
                    numPrelights,
                    true,
                    strformat( "BSPSector_%x_Shape", importData->id ).c_str()
                );

                geometry->setShaders( bspI->second->getShaders() );

                for( int i=0; i<importData->numVertices; i++ )
                {
                    geometry->getVertices()[i] = wrap( importData->vertices[i] );
                    geometry->getNormals()[i] = wrap( importData->normals[i] );
					// rh2lh conversion
                    /*
					geometry->getVertices()[i][2] *= -1;
                    geometry->getNormals()[i][2] *= -1;
                    */
                    for( int j=0; j<importData->numUVs; j++ ) geometry->getUVSet(j)[i] = wrap( importData->uvs[j][i] );
                    if( numPrelights ) geometry->getPrelights(0)[i] = wrap( importData->prelights[i] );
                }
                for( i=0; i<importData->numTriangles; i++ )
                {
                    /*
                    geometry->getTriangles()[i].set(
                        importData->triangles[i].vertexId[0],
                        importData->triangles[i].vertexId[2],
						importData->triangles[i].vertexId[1],
                        importData->triangles[i].materialId
                    );
                    */
                    geometry->getTriangles()[i].set(
                        importData->triangles[i].vertexId[0],
                        importData->triangles[i].vertexId[1],
                        importData->triangles[i].vertexId[2],
                        importData->triangles[i].materialId
                    );
                }
                geometry->instance();
            }
            BSPSector* sector = new BSPSector( bspI->second, parentSector, boundingBox, geometry );

            TextureI textureI = _textures.find( importData->lightmapId );
            if( textureI != _textures.end() ) 
            {
                sector->setLightMap( textureI->second );
            }

            _bspSectorM.insert( BSPSectorT( importData->id, sector ) );
            iImport->release( importData );
        };
        break;
    case import::itWorld:
        {
            import::ImportWorld* importData = iImportStream->importWorld();
			AABB boundingBox; 
			boundingBox.inf = wrap( importData->aabbInf );
			boundingBox.sup = wrap( importData->aabbSup );			
			// rh2lh conversion
            /*
			float temp = boundingBox.inf[2] * -1;
			boundingBox.inf[2] = boundingBox.sup[2] * -1;
			boundingBox.sup[2] = temp;
            */

            BSP* bsp = new BSP( 
                importData->name,
                boundingBox, 
                importData->numMaterials 
            );
            for( int i=0; i<importData->numMaterials; i++ )
            {
                ShaderI shaderI = _shaders.find( importData->materials[i] );
                assert( shaderI != _shaders.end() );
                bsp->setShader( i, shaderI->second );
            }
            _bspM.insert( BSPT( importData->id, bsp ) );
            _bsps.push_back( bsp );
            iImport->release( importData );
        };
        break;
    case import::itLight:
        {
            import::ImportLight* importData = iImportStream->importLight();

            engine::LightType lightType;
            switch( importData->type )
            {
            case import::ImportLight::ltAmbient:
                lightType = engine::ltAmbient;
                break;
            case import::ImportLight::ltDirectional:
                lightType = engine::ltDirectional;
                break;
            case import::ImportLight::ltPoint:
                lightType = engine::ltPoint;
                break;
            case import::ImportLight::ltSpot:
                lightType = engine::ltSpot;
                break;
            default:
                assert( !"shouldn't be here!" );
            }

            Light* light = new Light( lightType );
            light->setRange( importData->radius );
            light->setDiffuseColor( importData->color );
            light->setSpecularColor( importData->color );
            light->setPhi( importData->coneAngle );
            light->setTheta( importData->coneAngle );
            light->setAttenuation( Vector3f( 0,0.0001f,0 ) );
            
            FrameI frameI = _frames.find( importData->frameId );
            assert( frameI != _frames.end() );
            light->setFrame( frameI->second );

            _lights.insert( LightT( importData->id, light ) );

            iImport->release( importData );
        }
        break;
    default:
        assert( !"shouldn't be here!" );
    }

    iImport->release( iImportStream );
}
void Gameplay::entityInit(Object * p)
{
    // load config
    _config = new TiXmlDocument( "./cfg/config.xml" );
    _config->LoadFile();

    // read pitch shift option    
    TiXmlElement* xmlSound = Gameplay::iGameplay->getConfigElement( "sound" ); assert( xmlSound );
    int pitchShift;
    xmlSound->Attribute( "pitchShift", &pitchShift );
    _pitchShiftIsEnabled = ( pitchShift != 0 );   

	// read cheats option    
    TiXmlElement* details = Gameplay::iGameplay->getConfigElement( "details" ); assert( details );
    int cheats;
    details->Attribute( "cheats", &cheats );
    _cheatsEnabled = ( cheats != 0 );  

	// read free jumping mode  
    int freemode;
    details->Attribute( "freemode", &freemode );
    _freeModeIsEnabled = ( freemode != 0 ); 

	// read meters / feet mode  
    int units;
    details->Attribute( "units", &units );
    _feetModeIsEnabled = ( units != 0 ); 

    // setup random number generation
    getCore()->getRandToolkit()->setSeed( GetTickCount() );


    // retrieve interfaces
    queryInterface( "Engine", &iEngine ); assert( iEngine );
    queryInterface( "Gui", &iGui ); assert( iGui );
    queryInterface( "Language", &iLanguage ); assert( iLanguage );
    queryInterface( "Input", &iInput ); assert( iInput );
    queryInterface( "Audio", &iAudio ); assert( iAudio );
    if( !iAudio || !iInput || !iLanguage || !iGui || !iEngine )
    {
        throw Exception( "One or more core modules are not found, so gameplay will Crash Right Now!" );
    }

    // check language module
    if( wcscmp( iLanguage->getVersionString(), ::version.getVersionString() ) != 0 )
    {
        // incompatible module? - show no localization data
        iLanguage->reset();
    }

	getCore()->logMessage("Version: %ls (Clean)", ::version.getVersionString());

    // create input device
    _inputDevice = iInput->createInputDevice();
    createActionMap();

    // create physics resources
	foundation = PxCreateFoundation(PX_PHYSICS_VERSION, gDefaultAllocatorCallback, gDefaultErrorCallback);
    gPhysicsSDK = PxCreatePhysics(PX_PHYSICS_VERSION, *foundation, PxTolerancesScale() );
	pxCooking = PxCreateCooking(PX_PHYSICS_VERSION, *foundation, PxCookingParams(PxTolerancesScale()));
	PxInitExtensions(*gPhysicsSDK);

	//PHYSX3
    //NxGetPhysicsSDK()->setParameter( NX_VISUALIZATION_SCALE, 100.0f );
    //NxGetPhysicsSDK()->setParameter( NX_VISUALIZE_ACTOR_AXES, 1 );
    //NxGetPhysicsSDK()->setParameter( NX_VISUALIZE_COLLISION_SHAPES, 1 );
    //NxGetPhysicsSDK()->setParameter( NX_VISUALIZE_COLLISION_STATIC, 1 );
    //NxGetPhysicsSDK()->setParameter( NX_VISUALIZE_COLLISION_DYNAMIC,1 );

    // generate user community events from XML documents
    generateUserCommunityEvents();

    // open index
    TiXmlDocument* index = new TiXmlDocument( "./usr/index.xml" );
    index->LoadFile();

    // enumerate career nodes
    TiXmlNode* child = index->FirstChild();
    if( child ) do 
    {
        if( child->Type() == TiXmlNode::ELEMENT && strcmp( child->Value(), "career" ) == 0 )
        {
            _careers.push_back( new Career( static_cast<TiXmlElement*>( child ) ) );
        }
        child = child->NextSibling();
    }
    while( child != NULL );

    // close index document
    delete index;

    // create career for LICENSED_CHAR
    #ifdef GAMEPLAY_EDITION_ATARI
        createLicensedCareer();
    #endif

    // determine afterfx configuration
    TiXmlElement* video = getConfigElement( "video" ); assert( video );
    int afterfx = 0;
    video->Attribute( "afterfx", &afterfx );

    // create render target
    if( afterfx &&
        iEngine->isPfxSupported( engine::pfxBloom ) &&
        iEngine->isPfxSupported( engine::pfxMotionBlur ) )
    {
        _renderTarget = new AfterFxRT();
    }
    else
    {
        _renderTarget = new SimpleRT();
    }

    // play menu music
    playSoundtrack( "./res/sounds/music/dirty_moleculas_execution.ogg" );

    // evaluation protection
    #ifdef GAMEPLAY_EVALUATION_TIME
        SYSTEMTIME evaluationTime = GAMEPLAY_EVALUATION_TIME;
        SYSTEMTIME latestFileTime;
        if( getLatestFileTimeB( &latestFileTime ) )
        {
            if( isGreaterTime( &latestFileTime, &evaluationTime ) )
            {
                pushActivity( new Messagebox( Gameplay::iLanguage->getUnicodeString( 765 ) ) );
            }
            else
            {
                // startup
                _preloaded = new Preloaded();
                pushActivity( _preloaded );
            }
        }
    #else
        // determine if licence is required to play game
        bool licenceIsRequired = false;
        #ifndef GAMEPLAY_EDITION_ND
            #ifndef GAMEPLAY_EDITION_ATARI
                #ifndef GAMEPLAY_EDITION_POLISH
                    licenceIsRequired = false;
                #endif
            #endif
        #endif

        // startup        
        _preloaded = new Preloaded();
        pushActivity( _preloaded );
    #endif   
}
Example #8
0
	void queryInterface( std::vector< T * > & o_Impls )
	{
		queryInterface(
			typeid( T ).name(),
			reinterpret_cast< std::vector< void * > & >( o_Impls ) );
	}
Example #9
0
	T * queryInterface()
	{
		return reinterpret_cast< T * >(
			queryInterface( typeid( T ).name() ) );
	}