void MainForm::insertLight(engine::ILight* light, HTREEITEM parentItem) { std::string lightName; switch( light->getType() ) { case engine::ltAmbient: lightName = strformat( "Ambient %X", (unsigned int)(light) ); break; case engine::ltPoint: lightName = strformat( "Point %X", (unsigned int)(light) ); break; case engine::ltSpot: lightName = strformat( "Spot %X", (unsigned int)(light) ); break; case engine::ltDirectional: lightName = strformat( "Directional %X", (unsigned int)(light) ); break; default: lightName = strformat( "Unidentified %X", (unsigned int)(light) ); break; } HTREEITEM lightItem = assetGraph.InsertItem( lightName.c_str(), 7, 7, parentItem, TVI_LAST ); assert( lightItem != NULL ); assetGraph.SetItemData( lightItem, (DWORD)( light ) ); }
CreateCareer::CreateCareer(Career* career) { _endOfActivity = false; _career = career; // create window _window = Gameplay::iGui->createWindow( "CreateCareer" ); assert( _window ); // retrieve hot controls _heightBox = _window->getPanel()->find( "Height" )->getEdit(); assert( _heightBox ); _weightBox = _window->getPanel()->find( "Weight" )->getEdit(); assert( _weightBox ); _facePicture = _window->getPanel()->find( "FacePicture" )->getWindow(); assert( _facePicture ); _faceDescription = _window->getPanel()->find( "FaceDescription" )->getStaticText(); assert( _faceDescription ); // setup editboxes _heightBox->setText( strformat( "%4.2f", _career->getVirtues()->appearance.height ).c_str() ); _weightBox->setText( strformat( "%4.2f", _career->getVirtues()->appearance.weight ).c_str() ); // retrieve slider controls _predPool = _window->getPanel()->find( "PredPool" ); assert( _predPool && _predPool->getSlider() ); _predPerception = _window->getPanel()->find( "PredPerception" ); assert( _predPerception && _predPerception->getSlider() ); _predEndurance = _window->getPanel()->find( "PredEndurance" ); assert( _predEndurance && _predEndurance->getSlider() ); _predTracking = _window->getPanel()->find( "PredTracking" ); assert( _predTracking && _predTracking->getSlider() ); _predRigging = _window->getPanel()->find( "PredRigging" ); assert( _predRigging && _predRigging->getSlider() ); _malfunctions = _window->getPanel()->find( "MalfunctionCheckBox" ); assert( _malfunctions && _malfunctions->getButton() ); // setup predisposition _predPool->getSlider()->setLowerLimit( 0.0f ); _predPool->getSlider()->setUpperLimit( 2.0f ); _predPool->getSlider()->setPosition( 0.0f ); _predPerception->getSlider()->setLowerLimit( 0.0f ); _predPerception->getSlider()->setUpperLimit( 1.0f ); _predPerception->getSlider()->setPosition( 0.5f ); _predEndurance->getSlider()->setLowerLimit( 0.0f ); _predEndurance->getSlider()->setUpperLimit( 1.0f ); _predEndurance->getSlider()->setPosition( 0.5f ); _predTracking->getSlider()->setLowerLimit( 0.0f ); _predTracking->getSlider()->setUpperLimit( 1.0f ); _predTracking->getSlider()->setPosition( 0.5f ); _predRigging->getSlider()->setLowerLimit( 0.0f ); _predRigging->getSlider()->setUpperLimit( 1.0f ); _predRigging->getSlider()->setPosition( 0.5f ); updateFaceGui(); }
static void resolveNamelessFrame(Frame* frame) { // frame is nameless? if( strcmp( frame->getName(), "" ) == 0 ) { delete[] frame->Name; // frame has a parent? if( frame->getParent() ) { std::string frameName = strformat( "%s_child%d", frame->getParent()->getName(), getChildId( frame ) ); frame->Name = new char[ frameName.length() + 1]; strcpy( frame->Name, frameName.c_str() ); } else { std::string frameName = "Root"; frame->Name = new char[ frameName.length() + 1]; strcpy( frame->Name, frameName.c_str() ); } } // pass sibling & childrens if( frame->pFrameSibling ) resolveNamelessFrame( static_cast<Frame*>( frame->pFrameSibling ) ); if( frame->pFrameFirstChild ) resolveNamelessFrame( static_cast<Frame*>( frame->pFrameFirstChild ) ); }
int main(int argc, char** argv) { (void)argc; (void)argv; if ( 0 ) { char* test = strformat( "Hello, %s", argv[0] ); printf( "%s\n", test ); strfree( test ); } if ( 1 ) { disruptorKill( "benchmark" ); } { int fd; bool child; if ( 1 ) fd = fork(); else fd = 0; child = (fd == 0); if ( 1 ) { disruptorMsg m; disruptor* d = disruptorCreate( "benchmark", (child ? "clientB" : "clientA"), 16*1024 ); disruptorPrintf( d, "hello, world!" ); disruptorPrintf( d, "hello again, world!" ); while ( (m = disruptorRecv( d )) ) { int64_t time = msgGetTimestamp( d, m ); int senderId = msgGetSenderId( d, m ); const char* sender = msgGetSender( d, m ); size_t size = msgGetSize( d, m ); char* msg = msgGetData( d, m ); printf( "received time=%lld sender=%s size=%d msg=%s\n", time, sender, (int)size, msg ); } disruptorRelease( d ); } if ( !child ) { int signal; wait( &signal ); } } return 0; }
inline std::string number_and_format::format() const { switch (m_format) { default: case XML_INT_FORMAT_DECIMAL: return strformat("%d", (UINT32)m_value); case XML_INT_FORMAT_DECIMAL_POUND: return strformat("#%d", (UINT32)m_value); case XML_INT_FORMAT_HEX_DOLLAR: return strformat("$%X", (UINT32)m_value); case XML_INT_FORMAT_HEX_C: return strformat("0x%X", (UINT32)m_value); } }
cell_t Native_StrFormatEx(IPluginContext *pContext, const cell_t *params) { char *buf, *fmt; size_t res; int arg = 4; pContext->LocalToString(params[1], &buf); pContext->LocalToString(params[3], &fmt); res = strformat(buf, static_cast<size_t>(params[2]), fmt, pContext, params, &arg); return static_cast<cell_t>(res); }
EffectHLSL::EffectHLSL(const char* fxName) { Effect::HLSLI hlslI = _hlslMap.find( fxName ); assert( hlslI != _hlslMap.end() ); _name = hlslI->first; _effect = hlslI->second; _bufferSize = 0; // enumerate arguments unsigned int numArguments = _hlslConfig->findParams( strformat( "effect.%s.argument*", fxName ).c_str() ); paramid_t* items = new paramid_t[numArguments]; _hlslConfig->copyParamResult( items ); std::string argumentDesc; for( unsigned int i=0; i<numArguments; i++ ) { argumentDesc = _hlslConfig->gets( items[i] ); Argument argument( argumentDesc.c_str() ); argument.offset = _bufferSize; _bufferSize += argument.size; _arguments.push_back( argument ); } delete items; _buffer = new char[_bufferSize]; memset( _buffer, 0, _bufferSize ); // read flags memset( &_flags, 0, sizeof( Flags ) ); _flags.camera = _hlslConfig->getv( strformat( "effect.%s.camera", fxName ).c_str(), false ); _flags.lightPalette = _hlslConfig->getv( strformat( "effect.%s.lightPalette", fxName ).c_str(), 0 ); _flags.material = _hlslConfig->getv( strformat( "effect.%s.material", fxName ).c_str(), false ); _flags.world = _hlslConfig->getv( strformat( "effect.%s.world", fxName ).c_str(), false ); _flags.iWorld = _hlslConfig->getv( strformat( "effect.%s.iWorld", fxName ).c_str(), false ); _flags.worldViewProj = _hlslConfig->getv( strformat( "effect.%s.worldViewProj", fxName ).c_str(), false ); _flags.baseTexture = _hlslConfig->getv( strformat( "effect.%s.baseTexture", fxName ).c_str(), false ); _flags.normalMap = _hlslConfig->getv( strformat( "effect.%s.normalMap", fxName ).c_str(), false ); _flags.environmentMap = _hlslConfig->getv( strformat( "effect.%s.environmentMap", fxName ).c_str(), false ); }
void getstr(char *str)//读取规范字符串 { int i = 0; while (1) { str[i] = getchar(); if (str[i] == '\n') { str[i] ='\0'; break; } i++; } strformat(str); }
void MainForm::lightMapCallback(float progress, void* userData) { MainForm* __this = reinterpret_cast<MainForm*>( userData ); std::string text = strformat( "Calculate lightmaps...%3.2f%%", progress * 100 ); __this->consoleBox.SetWindowText( text.c_str() ); MSG msg; if( PeekMessage( &msg, __this->m_hWnd, 0, 0, PM_REMOVE ) ) { DispatchMessage( &msg ); } }
void Gameplay::setMusicVolume(float volume) { assert( volume >= 0 ); assert( volume <= 1 ); volume = volume < 0 ? 0 : ( volume > 1 ? 1 : volume ); // initialize fade gain TiXmlElement* xmlSound = Gameplay::iGameplay->getConfigElement( "sound" ); assert( xmlSound ); xmlSound->SetAttribute( "musicVolume", strformat( "%4.2f", volume ).c_str() ); _config->SaveFile(); // update sound if( _soundTrack ) _soundTrack->setGain( volume ); }
void CameraEffect::setPfx(engine::PostEffectType pfxType) { assert( Engine::instance->isPfxSupported( pfxType ) ); _currentEffect = pfxType; switch( _currentEffect ) { case engine::pfxMotionBlur: if( _newImage ) _newImage->release(); if( _prevImage ) _prevImage->release(); _newImage = Texture::createRenderTarget( _renderTarget->getWidth(), _renderTarget->getHeight(), 32, strformat( "%s_newImageBuffer", _renderTarget->getName() ).c_str() ); _prevImage = Texture::createRenderTarget( _renderTarget->getWidth(), _renderTarget->getHeight(), 32, strformat( "%s_prevImageBuffer", _renderTarget->getName() ).c_str() ); _prevIsEmpty = true; break; case engine::pfxDOF: if( _newImage ) _newImage->release(); _newImage = Texture::createRenderTarget( _renderTarget->getWidth(), _renderTarget->getHeight(), 32, strformat( "%s_newImageBuffer", _renderTarget->getName() ).c_str() ); break; case engine::pfxBloom: if( _newImage ) _newImage->release(); _newImage = Texture::createRenderTarget( _renderTarget->getWidth(), _renderTarget->getHeight(), 32, strformat( "%s_newImageBuffer", _renderTarget->getName() ).c_str() ); break; } }
cell_t Native_StrFormat(IPluginContext *pContext, const cell_t *params) { char *buf, *fmt, *destbuf; cell_t start_addr, end_addr, maxparam; size_t res, maxlen; int arg = 4; bool copy = false; char *__copy_buf; pContext->LocalToString(params[1], &destbuf); pContext->LocalToString(params[3], &fmt); maxlen = static_cast<size_t>(params[2]); start_addr = params[1]; end_addr = params[1] + maxlen; maxparam = params[0]; for (cell_t i = 3; i <= maxparam; i++) { if ((params[i] >= start_addr) && (params[i] <= end_addr)) { copy = true; break; } } if (copy) { if (maxlen > sizeof(g_formatbuf)) { __copy_buf = g_extrabuf.GetWithSize(maxlen); } else { __copy_buf = g_formatbuf; } } buf = (copy) ? __copy_buf : destbuf; res = strformat(buf, maxlen, fmt, pContext, params, &arg); if (copy) { memcpy(destbuf, __copy_buf, res + 1); } return static_cast<cell_t>(res); }
void MainForm::insertAtomic(engine::IAtomic* atomic, HTREEITEM parentItem) { HTREEITEM atomicItem = assetGraph.InsertItem( strformat( "Atomic 0x%X", (unsigned int)(atomic) ).c_str(), 3, 3, parentItem, TVI_LAST ); assert( atomicItem != NULL ); assetGraph.SetItemData( atomicItem, (DWORD)( atomic ) ); if( atomic->getGeometry() ) { insertGeometry( atomic->getGeometry(), atomicItem ); } }
void MainForm::insertSector(engine::IBSPSector* sector, HTREEITEM parentItem) { HTREEITEM sectorItem = assetGraph.InsertItem( strformat( "Sector %X", (unsigned int)(sector) ).c_str(), 6, 6, parentItem, TVI_LAST ); assert( sectorItem != NULL ); assetGraph.SetItemData( sectorItem, (DWORD)( sector ) ); // insert geometry if( sector->getGeometry() ) { insertGeometry( sector->getGeometry(), sectorItem ); } }
int tell_folks(string targets, string message) { object *obs; obs = opie_p(targets, FT_FindPlayer FT_FindLiving ); if( !obs ) { notify_fail( "Who? What? Where?" ); return 0; } message = strformat( message, sprintf("%s tells you: ", PNAME)); map_array(obs, #'tell_object, message); printf("Sent to %d object%s.\n", sizeof(obs), (sizeof(obs)==1) ? "": "s"); return 1; }
void ServerServiceSync::updateWindowTitle() { string strTitle = strformat("ServerService %d",getLocalPort()); strTitle = Platform::utf8ToGbk(strTitle); Platform::setWindowTitle(strTitle.c_str()); ////////////////////////////////////////////////////////////////////////// //google::protobuf::Message* newQuery = createMessage("LoginCmd.RequestRegisterGameServer"); //assert(newQuery != NULL); //LoginCmd::RequestRegisterGameServer::default_instance(); //LoginCmd::RequestRegisterGameServer cmd; //LoginCmd::RequestRegisterGameServer* pMsg = (LoginCmd::RequestRegisterGameServer*)createMessage("LoginCmd.RequestRegisterGameServer"); //pMsg->set_id(1); //IterateProtoFile("ProtoSvrLogin.proto"); }
bool ServerServiceAsync::onInitialise() { // 初始化minidump MiniDump::InitMiniDump("./crashlog/", mName.c_str()); // 初始化日志 string strLogFile = strformat("./log/%s/%s", mName.c_str(), mName.c_str()); ServerLogger::getInstance().start(strLogFile.c_str(), "super", true); loadConfig(); mLocalPort = 7102; // 开启服务 addTimer(new TimerForMain); start( getLocalPort() ); updateWindowTitle(); LOGI("开始监听端口 %d", getLocalPort()); return true; }
void EngineInfo::OnTimer(UINT nIDEvent) { if( nIDEvent == 1 ) { engine::IEngine* iEngine; if( askInterfaceT( "Engine", &iEngine ) ) { engine::RenderStatictics* statistics = iEngine->getStatictics(); GetDlgItem( IDC_FPS )->SetWindowText( strformat( "%2.1f", fps ).c_str() ); GetDlgItem( IDC_BSP_TOTAL )->SetWindowText( strformat( "%d", statistics->bspTotal ).c_str() ); GetDlgItem( IDC_BSP_RENDERED )->SetWindowText( strformat( "%d", statistics->bspRendered ).c_str() ); GetDlgItem( IDC_ATOMICS_RENDERED )->SetWindowText( strformat( "%d", statistics->atomicsRendered ).c_str() ); GetDlgItem( IDC_ALPHA_RENDERED )->SetWindowText( strformat( "%d", statistics->alphaObjectsRendered ).c_str() ); GetDlgItem( IDC_SHADER_CACHE_HITS )->SetWindowText( strformat( "%d", statistics->shaderCacheHits ).c_str() ); } } CDialog::OnTimer(nIDEvent); }
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 cosmac_device::device_start() { // resolve callbacks m_read_wait.resolve_safe(0); m_read_clear.resolve_safe(0); m_read_ef1.resolve(); m_read_ef2.resolve(); m_read_ef3.resolve(); m_read_ef4.resolve(); m_write_q.resolve_safe(); m_read_dma.resolve_safe(0); m_write_dma.resolve_safe(); m_write_sc.resolve_safe(); // get our address spaces m_program = &space(AS_PROGRAM); m_direct = &m_program->direct(); m_io = &space(AS_IO); // register our state for the debugger state_add(STATE_GENPC, "GENPC", m_pc).callimport().callexport().noshow(); state_add(STATE_GENFLAGS, "GENFLAGS", m_flagsio).mask(0x7).callimport().callexport().noshow().formatstr("%3s"); state_add(COSMAC_P, "P", m_p).mask(0xf); state_add(COSMAC_X, "X", m_x).mask(0xf); state_add(COSMAC_D, "D", m_d); state_add(COSMAC_B, "B", m_b); state_add(COSMAC_T, "T", m_t); state_add(COSMAC_I, "I", m_i).mask(0xf); state_add(COSMAC_N, "N", m_n).mask(0xf); std::string tempstr; for (int regnum = 0; regnum < 16; regnum++) state_add(COSMAC_R0 + regnum, strformat(tempstr, "R%x", regnum).c_str(), m_r[regnum]); state_add(COSMAC_DF, "DF", m_df).mask(0x1).noshow(); state_add(COSMAC_IE, "IE", m_ie).mask(0x1).noshow(); state_add(COSMAC_Q, "Q", m_q).mask(0x1).noshow(); // register our state for saving save_item(NAME(m_op)); save_item(NAME(m_flagsio)); save_item(NAME(m_state)); save_item(NAME(m_mode)); save_item(NAME(m_pmode)); save_item(NAME(m_irq)); save_item(NAME(m_dmain)); save_item(NAME(m_dmaout)); save_item(NAME(m_ef)); save_item(NAME(m_d)); save_item(NAME(m_b)); save_item(NAME(m_r)); save_item(NAME(m_p)); save_item(NAME(m_x)); save_item(NAME(m_n)); save_item(NAME(m_i)); save_item(NAME(m_t)); save_item(NAME(m_df)); save_item(NAME(m_ie)); save_item(NAME(m_q)); // set our instruction counter m_icountptr = &m_icount; }
// --------------------------------------------------------------------------- // // ----------- bool bXMapStringProcessing::process_str(strprocess_prm* prm, bool silent){ _bTrace_("bXMapStringProcessing::process_str(strprocess_prm*,bool)",true); int j,err=0,fidx; char val[__MESSAGE_STRING_LENGTH_MAX__]; char buffer[__MESSAGE_STRING_LENGTH_MAX__*3+1]; bArray sel(*(_gapp->selMgr()->elements())); bGenericGeoElement* o; b_message_string(kXMapStringProcessingProcessMessageID,val,getbundle(),1); bProgressWait wt("",val,true,true,sel.count()); int fpos=0; int flen=formatinfo(prm->fmt,&fpos); for(int i=1;i<=sel.count();i++){ if(!wt.set_progress(i)){ break; } sel.get(i,&o); buffer[0]=0; // Concat for(j=1;j<=prm->arr->count()-1;j++){ prm->arr->get(j,&fidx); val[0]=0; if(o->getValue(fidx,val)==false){ _te_("o->getValue for field "+fidx); err++; break; } if(strncat(buffer,val,__MESSAGE_STRING_LENGTH_MAX__*3)==NULL){ _te_("strncat "+buffer+"+"+val); err++; break; } if(strncat(buffer,prm->sep,__MESSAGE_STRING_LENGTH_MAX__*3)==NULL){ _te_("strncat "+buffer+"+"+prm->sep); err++; break; } } prm->arr->get(prm->arr->count(),&fidx); val[0]=0; if(o->getValue(fidx,val)==false){ _te_("o->getValue for field "+fidx); err++; } else if(strncat(buffer,val,__MESSAGE_STRING_LENGTH_MAX__*3)==NULL){ _te_("strncat "+buffer+"+"+val); err++; } // Case switch(prm->cas){ case kStrProcessCaseLower: strlower(buffer); break; case kStrProcessCaseUpper: strupper(buffer); break; case kStrProcessCaseFUpper: strlower(buffer); strupperfcs(buffer); break; case kStrProcessCaseFWUpper: strlower(buffer); strupperfcw(buffer); break; } // Replace if(strlen(prm->srch)>0){ strrep(buffer,prm->srch,prm->repl); } // Format if(flen>0){ strformat(prm->fmt,buffer,fpos,flen); } // Affect if(o->setValue(prm->target,buffer)==false){ _te_("o->setValue "+buffer+" for field "+fidx); err++; } } if(err){ b_message_string(kXMapStringProcessingErrorsOccursID,val,getbundle(),0); b_message_string(kXMapStringProcessingReadLogID,buffer,getbundle(),0); bAlertStop alrt(val,buffer,silent); } return(true); }
int ClientHandlerPrivmsg(PCLIENT pClient, char* strCommand, char* strParams) { if(CompareIRCAddressNick(strParams,c_strBouncerName)) { char *strAction,*str; pClient->cMessageMode = CMM_PRIVMSG; strAction = strParams+strlen(c_strBouncerName)+1; if(*strAction == ':') strAction++; str = strAction; do { if(*str == ' ') { *(str++) = '\0'; break; } else if(*str == '\r' || *str == '\n') { *str = '\0'; break; } *str = toupper(*str); ++str; } while(*str); { struct tagCLIENTHANDLER* pHandler; HASH_LOOKUP(CLIENTHANDLER_HASH,g_hashClientHandlers,strAction,pHandler); if(pHandler && ( !(pHandler->nFlags & CHF_BOUNCER) || (!(pHandler->nFlags & CHF_ADMIN) && (!pClient->pUser->strAllowedCommands || !ConfigFindVar(pClient->pUser->strAllowedCommands,pHandler->strAction))) || (pHandler->nFlags & CHF_ADMIN && !pClient->bAdmin) ) ) pHandler = 0; if(pHandler) { sprintf(strCommand,"msg %s %s",c_strBouncerName,pHandler->strAction); pHandler->pProc(pClient,strCommand,str); } else ClientMessage(pClient,"Unknown command \"%s\"\r\n",strAction); } pClient->cMessageMode = CMM_DEFAULT; return 1; } { char* strArg[2]; if(SplitIRCParams(strParams,strArg,sizeof(strArg)/sizeof(*strArg),1) == sizeof(strArg)/sizeof(*strArg)) { if(pClient->pProfile) { PPROFILE pProfile = pClient->pProfile; PPROFILECHANNEL pProfileChannel; HASHLIST_LOOKUP(PROFILE_PROFILECHANNEL_HASHLIST,pProfile->hashlistProfileChannels,strArg[0],pProfileChannel); if(pProfileChannel) { PCLIENT pCurClient; unsigned short sLength; sLength = strformat(g_strOutBuffer,sizeof(g_strOutBuffer),":%s!~%s@%s PRIVMSG %s :%s\r\n",pClient->strNick,pClient->pUser->strName,iptoa(pClient->pConnection->nIP),strArg[0],strArg[1]); for(pCurClient = pProfile->listClients.pFirst; pCurClient; pCurClient = pCurClient->llProfile.pNext) if(pCurClient != pClient) ConnectionSend(pCurClient->pConnection,g_strOutBuffer,sLength); ProfileLogMsgCreate(0,pProfileChannel,++pProfile->nLogID,g_strOutBuffer,sLength,PLMF_TIMESTAMP|PLMF_ADJUSTNICKLEN); } } } } return 0; }
bool CMyString::MyStringFormat( const char* key,std::vector<lite::Variant> &vlvariant,std::string &StringFormat) { std::map<std::string,strInfo*>::iterator iter = m_smystringinfo.find(key); if (iter!=m_smystringinfo.end()) { char strBuff[MAX_PATH]={}; std::string strformat(iter->second->s_strValue); if (iter->second->bparamcount != vlvariant.size()) { rfalse(2,1,"[%s]参数数量不一致",key); return false; } if (vlvariant.size() == 0) //无参数 直接返回 { StringFormat = iter->second->s_strValue; return true; } std::string::iterator iterstr = strformat.begin(); unsigned int paramindex = 0; while(iterstr != strformat.end()) { if (paramindex > vlvariant.size()) { rfalse(1,1,"[%s] 字符串参数数量错误",key); return false; } if (*iterstr == '%') { if (*(iterstr+1) == 'd') { if (vlvariant[paramindex].dataType != lite::Variant::VT_I32_24) { rfalse(1,1,"%s 参数类型错误 %d个参数类型为%d",key,paramindex+1,vlvariant[paramindex].dataType); return false; } iterstr++; char nstr[10]={}; itoa(vlvariant[paramindex],nstr,10); StringFormat +=nstr; paramindex++; } else if (*(iterstr+1) == 's') { if (vlvariant[paramindex].dataType != lite::Variant::VT_STRING) { rfalse(1,1,"%s 参数类型错误 %d个参数类型为%d",key,paramindex+1,vlvariant[paramindex].dataType); return false; } iterstr++; StringFormat +=vlvariant[paramindex]; paramindex++; } } else { StringFormat += *iterstr; } iterstr++; } //rfalse(StringFormat.c_str()); return true; } return false; }
void dsp32c_device::device_start() { m_output_pins_changed.resolve_safe(); // get our address spaces m_program = &space(AS_PROGRAM); m_direct = &m_program->direct(); // register our state for the debugger std::string tempstr; state_add(STATE_GENPC, "GENPC", m_r[15]).noshow(); state_add(STATE_GENPCBASE, "GENPCBASE", m_ppc).noshow(); state_add(STATE_GENSP, "GENSP", m_r[21]).noshow(); state_add(STATE_GENFLAGS, "GENFLAGS", m_iotemp).callimport().callexport().formatstr("%6s").noshow(); state_add(DSP32_PC, "PC", m_r[15]).mask(0xffffff); for (int regnum = 0; regnum <= 14; regnum++) state_add(DSP32_R0 + regnum, strformat(tempstr, "R%d", regnum).c_str(), m_r[regnum]).mask(0xffffff); state_add(DSP32_R15, "R15", m_r[17]).mask(0xffffff); state_add(DSP32_R16, "R16", m_r[18]).mask(0xffffff); state_add(DSP32_R17, "R17", m_r[19]).mask(0xffffff); state_add(DSP32_R18, "R18", m_r[20]).mask(0xffffff); state_add(DSP32_R19, "R19", m_r[21]).mask(0xffffff); state_add(DSP32_R20, "R20", m_r[24]).mask(0xffffff); state_add(DSP32_R21, "R21", m_r[25]).mask(0xffffff); state_add(DSP32_R22, "R22", m_r[29]).mask(0xffffff); state_add(DSP32_PIN, "PIN", m_pin).mask(0xffffff); state_add(DSP32_POUT, "POUT", m_pout).mask(0xffffff); state_add(DSP32_IVTP, "IVTP", m_ivtp).mask(0xffffff); state_add(DSP32_A0, "A0", m_a[0]).formatstr("%8s"); state_add(DSP32_A1, "A1", m_a[1]).formatstr("%8s"); state_add(DSP32_A2, "A2", m_a[2]).formatstr("%8s"); state_add(DSP32_A3, "A3", m_a[3]).formatstr("%8s"); state_add(DSP32_DAUC, "DAUC", m_r[26]).mask(0xff); state_add(DSP32_PAR, "PAR", m_par); state_add(DSP32_PDR, "PDR", m_pdr); state_add(DSP32_PIR, "PIR", m_pir); state_add(DSP32_PCR, "PCR", m_iotemp).mask(0x3ff).callimport(); state_add(DSP32_EMR, "EMR", m_emr); state_add(DSP32_ESR, "ESR", m_esr); state_add(DSP32_PCW, "PCW", m_pcw); state_add(DSP32_PIOP, "PIOP", m_piop); state_add(DSP32_IBUF, "IBUF", m_ibuf); state_add(DSP32_ISR, "ISR", m_isr); state_add(DSP32_OBUF, "OBUF", m_obuf); state_add(DSP32_OSR, "OSR" , m_osr); state_add(DSP32_IOC, "IOC", m_r[27]).mask(0xfffff); // register our state for saving save_item(NAME(m_r)); save_item(NAME(m_pin)); save_item(NAME(m_pout)); save_item(NAME(m_ivtp)); save_item(NAME(m_nzcflags)); save_item(NAME(m_vflags)); save_item(NAME(m_a)); save_item(NAME(m_NZflags)); save_item(NAME(m_VUflags)); save_item(NAME(m_abuf)); save_item(NAME(m_abufreg)); save_item(NAME(m_abufVUflags)); save_item(NAME(m_abufNZflags)); save_item(NAME(m_abufcycle)); save_item(NAME(m_abuf_index)); save_item(NAME(m_mbufaddr)); save_item(NAME(m_mbufdata)); save_item(NAME(m_par)); save_item(NAME(m_pare)); save_item(NAME(m_pdr)); save_item(NAME(m_pdr2)); save_item(NAME(m_pir)); save_item(NAME(m_pcr)); save_item(NAME(m_emr)); save_item(NAME(m_esr)); save_item(NAME(m_pcw)); save_item(NAME(m_piop)); save_item(NAME(m_ibuf)); save_item(NAME(m_isr)); save_item(NAME(m_obuf)); save_item(NAME(m_osr)); save_item(NAME(m_lastpins)); save_item(NAME(m_ppc)); }
char buf[256]; va_list args; va_start(args,fmt); VSNPRINTF(buf, sizeof(buf), fmt, args); va_end(args); return std::string(buf); } CONFIG(std::string, CamModeName).defaultValue(""); CONFIG(int, CamMode) .defaultValue(CCameraHandler::CAMERA_MODE_SPRING) .description(strformat("Defines the used camera. Options are:\n%i = FPS\n%i = Overhead\n%i = Spring\n%i = RotOverhead\n%i = Free\n%i = Overview", (int)CCameraHandler::CAMERA_MODE_FIRSTPERSON, (int)CCameraHandler::CAMERA_MODE_OVERHEAD, (int)CCameraHandler::CAMERA_MODE_SPRING, (int)CCameraHandler::CAMERA_MODE_ROTOVERHEAD, (int)CCameraHandler::CAMERA_MODE_FREE, (int)CCameraHandler::CAMERA_MODE_OVERVIEW )) .minimumValue(0) .maximumValue(CCameraHandler::CAMERA_MODE_LAST - 1); CONFIG(float, CamTimeFactor) .defaultValue(1.0f) .minimumValue(0.0f) .description("Scales the speed of camera transitions, e.g. zooming or position change."); CONFIG(float, CamTimeExponent) .defaultValue(4.0f) .minimumValue(0.0f) .description("Camera transitions happen at lerp(old, new, timeNorm ^ CamTimeExponent).");
void Geometry::captureMeshData(bool captureShaders) { assert( _mesh->OriginalMeshData.Type == D3DXMESHTYPE_MESH ); // release previous structures if( _vertices ) delete[] _vertices; if( _normals ) delete[] _normals; if( _triangles ) delete[] _triangles; int i; for( i=0; i<engine::maxPrelightLayers; i++ ) { if( _prelights[i] ) { delete[] _prelights[i]; _prelights[i] = NULL; } } for( i=0; i<engine::maxTextureLayers; i++ ) { if( _uvs[i] ) { delete[] _uvs[i]; _uvs[i] = NULL; } } if( _shaders && captureShaders ) { for( i=0; i<_numShaders; i++ ) _shaders[i]->release(); delete[] _shaders; } if( _skinnedVertices ) delete[] _skinnedVertices; _numVertices = _mesh->OriginalMeshData.pMesh->GetNumVertices(); _numTriangles = _mesh->OriginalMeshData.pMesh->GetNumFaces(); _numShaders = _mesh->NumMaterials; _numPrelights = 0; _numUVSets = 0; _sharedShaders = false; // retrieve vertex declaration D3DVERTEXELEMENT9 vertexDeclaration[MAX_FVF_DECL_SIZE]; _dxCR( _mesh->OriginalMeshData.pMesh->GetDeclaration( vertexDeclaration ) ); // analyze vertex declaration _numUVSets = dxGetNumUVs( vertexDeclaration ); _numPrelights = dxGetNumPrelights( vertexDeclaration ); // create device-independent storage _vertices = new Vector[_numVertices]; _normals = new Vector[_numVertices]; _triangles = new Triangle[_numTriangles]; for( int i=0; i<engine::maxPrelightLayers; i++ ) { if( i < _numPrelights ) _prelights[i] = new Color[_numVertices]; else _prelights[i] = NULL; } for( i=0; i<engine::maxTextureLayers; i++ ) { if( i < _numUVSets ) _uvs[i] = new Flector[_numVertices]; else _uvs[i] = NULL; } // retrieve geometry data char* vertexData = (char*)( _mesh->lockVertexBuffer( D3DLOCK_READONLY ) ); char* indexData = (char*)( _mesh->lockIndexBuffer( D3DLOCK_READONLY ) ); DWORD* attrData = (DWORD*)( _mesh->lockAttributeBuffer( D3DLOCK_READONLY ) ); int offset = 0; int j, uvId, prelightId; for( i=0; i<_numVertices; i++ ) { j = prelightId = uvId = 0; while( j<MAX_FVF_DECL_SIZE && vertexDeclaration[j].Stream != 0xFF ) { switch( vertexDeclaration[j].Usage ) { case D3DDECLUSAGE_POSITION: _vertices[i] = *((Vector*)(vertexData+offset)); break; case D3DDECLUSAGE_NORMAL: _normals[i] = *((Vector*)(vertexData+offset)); break; case D3DDECLUSAGE_COLOR: _prelights[prelightId][i] = *((Color*)(vertexData+offset)); prelightId++; break; case D3DDECLUSAGE_TEXCOORD: _uvs[uvId][i] = *((Flector*)(vertexData+offset)); uvId++; break; case D3DDECLUSAGE_BLENDWEIGHT: break; case D3DDECLUSAGE_BLENDINDICES: break; case D3DDECLUSAGE_TANGENT: case D3DDECLUSAGE_BINORMAL: case D3DDECLUSAGE_TESSFACTOR: case D3DDECLUSAGE_POSITIONT: case D3DDECLUSAGE_FOG: case D3DDECLUSAGE_DEPTH: case D3DDECLUSAGE_SAMPLE: break; default: assert( !"shouldn't be here!" ); } offset += dxGetDeclTypeSize( static_cast<D3DDECLTYPE>( vertexDeclaration[j].Type ) ); j++; } } offset = 0; for( i=0; i<_numTriangles; i++ ) { _triangles[i].set( *(WORD*)(indexData+offset), *(WORD*)(indexData+offset+sizeof(WORD)), *(WORD*)(indexData+offset+sizeof(WORD)*2), attrData[i] ); offset += sizeof(WORD)*3; } _mesh->unlockVertexBuffer(); _mesh->unlockIndexBuffer(); _mesh->unlockAttributeBuffer(); // recalculate bounding box _boundingBox.calculate( _numVertices, _vertices ); _boundingSphere.calculate( _numVertices, _vertices ); if( captureShaders ) { _shaders = new Shader*[_numShaders]; memset( _shaders, 0, sizeof(Shader*) * _numShaders ); for( i=0; i<_numShaders; i++ ) { Texture* texture = NULL; if( _mesh->pMaterials[i].pTextureFilename != NULL ) { TextureI textureI = Texture::textures.find( Texture::getTextureNameFromFilePath( _mesh->pMaterials[i].pTextureFilename ) ); if( textureI != Texture::textures.end() ) { texture = textureI->second; } else { texture = Texture::createTexture( _mesh->pMaterials[i].pTextureFilename ); texture->setMagFilter( engine::ftLinear ); texture->setMinFilter( engine::ftLinear ); texture->setMipFilter( engine::ftLinear ); } } Shader* shader = new Shader( texture != NULL ? 1 : 0, strformat( "%s_shader_%d", _name.c_str(), i ).c_str() ); if( texture ) shader->setLayerTexture( 0, texture ); shader->setFlags( shader->getFlags() | engine::sfCaching | engine::sfLighting ); shader->setDiffuseColor( Vector4f( _mesh->pMaterials[i].MatD3D.Diffuse.r, _mesh->pMaterials[i].MatD3D.Diffuse.g, _mesh->pMaterials[i].MatD3D.Diffuse.b, _mesh->pMaterials[i].MatD3D.Diffuse.a ) ); shader->setSpecularColor( Vector4f( _mesh->pMaterials[i].MatD3D.Specular.r, _mesh->pMaterials[i].MatD3D.Specular.g, _mesh->pMaterials[i].MatD3D.Specular.b, _mesh->pMaterials[i].MatD3D.Specular.a ) ); shader->setSpecularPower( _mesh->pMaterials[i].MatD3D.Power ); setShader( i, shader ); } } _vertexDeclaration = dxGetVertexDeclaration( _numUVSets, _numPrelights ); // allocate space for software skinning _skinnedVertices = NULL; if( _mesh->pSkinInfo ) _skinnedVertices = new Vector[_numVertices]; }
void CreateCareer::messageCallback(gui::Message* message, void* userData) { CreateCareer* __this = reinterpret_cast<CreateCareer*>( userData ); if( message->event == gui::onButtonClick ) { if( strcmp( message->origin->getName(), "ContinueButton" ) == 0 ) { bool correctionApplied = false; // read height float value = float( atof( __this->_heightBox->getText() ) ); if( value < 170 ) value = 170, correctionApplied = true; if( value > 190 ) value = 190, correctionApplied = true; __this->_career->getVirtues()->appearance.height = value; if( correctionApplied ) { __this->_heightBox->setText( strformat( "%4.2f", __this->_career->getVirtues()->appearance.height ).c_str() ); Gameplay::iGameplay->pushActivity( new Messagebox( Gameplay::iLanguage->getUnicodeString(69) ) ); return; } // read weight value = float( atof( __this->_weightBox->getText() ) ); if( value < 50 ) value = 50, correctionApplied = true; if( value > 110 ) value = 110, correctionApplied = true; __this->_career->getVirtues()->appearance.weight = value; if( correctionApplied ) { __this->_weightBox->setText( strformat( "%4.2f", __this->_career->getVirtues()->appearance.weight ).c_str() ); Gameplay::iGameplay->pushActivity( new Messagebox( Gameplay::iLanguage->getUnicodeString(70) ) ); return; } // read predispositions __this->_career->getVirtues()->predisp.perception = __this->_predPerception->getSlider()->getPosition(); __this->_career->getVirtues()->predisp.endurance = __this->_predEndurance->getSlider()->getPosition(); __this->_career->getVirtues()->predisp.tracking = __this->_predTracking->getSlider()->getPosition(); __this->_career->getVirtues()->predisp.rigging = __this->_predRigging->getSlider()->getPosition(); // startup skills #ifdef GAMEPLAY_DEMOVERSION // rande-up predispositions (due to restrictions of skill nature) if( __this->_career->getVirtues()->predisp.perception > 0.99f ) __this->_career->getVirtues()->predisp.perception = 0.99f; if( __this->_career->getVirtues()->predisp.endurance > 0.99f ) __this->_career->getVirtues()->predisp.endurance = 0.99f; if( __this->_career->getVirtues()->predisp.tracking > 0.99f ) __this->_career->getVirtues()->predisp.tracking = 0.99f; if( __this->_career->getVirtues()->predisp.rigging > 0.99f ) __this->_career->getVirtues()->predisp.rigging = 0.99f; // setup skills for demo mode __this->_career->getVirtues()->setPerceptionSkill( __this->_career->getVirtues()->predisp.perception ); __this->_career->getVirtues()->setEnduranceSkill( __this->_career->getVirtues()->predisp.endurance ); __this->_career->getVirtues()->setTrackingSkill( __this->_career->getVirtues()->predisp.tracking ); __this->_career->getVirtues()->setRiggingSkill( __this->_career->getVirtues()->predisp.rigging ); #else __this->_career->getVirtues()->skills.perception = 0; __this->_career->getVirtues()->skills.endurance = 0; __this->_career->getVirtues()->skills.tracking = 0; __this->_career->getVirtues()->skills.rigging = 0; #endif // read malfunctions __this->_career->getVirtues()->equipment.malfunctions = ( __this->_malfunctions->getTextureRect().left > 0 ); // generate startup gears __this->generateStartupGearStock(); // decision to finalize Gameplay::iGameplay->addCareer( __this->_career ); Gameplay::iGameplay->saveCareers(); __this->_endOfActivity = true; } else if( strcmp( message->origin->getName(), "CancelButton" ) == 0 ) { __this->_endOfActivity = true; } else if( strcmp( message->origin->getName(), "MalfunctionCheckBox" ) == 0 ) { if( message->origin->getTextureRect().left > 0 ) { message->origin->setTextureRect( gui::Rect( 0,0,32,32 ) ); } else { message->origin->setTextureRect( gui::Rect( 32,0,64,32 ) ); } } else if( strcmp( message->origin->getName(), "PrevFace" ) == 0 ) { if( __this->_career->getVirtues()->appearance.face == 0 ) { __this->_career->getVirtues()->appearance.face = ( database::Face::getNumRecords() - 1 ); } else { __this->_career->getVirtues()->appearance.face--; } __this->updateFaceGui(); } else if( strcmp( message->origin->getName(), "NextFace" ) == 0 ) { if( __this->_career->getVirtues()->appearance.face == database::Face::getNumRecords() - 1 ) { __this->_career->getVirtues()->appearance.face = 0; } else { __this->_career->getVirtues()->appearance.face++; } __this->updateFaceGui(); } } else if( message->event == gui::onSlide ) { if( message->origin == __this->_predPool ) { float distributed = __this->_predPerception->getSlider()->getPosition() + __this->_predEndurance->getSlider()->getPosition() + __this->_predTracking->getSlider()->getPosition() + __this->_predRigging->getSlider()->getPosition(); __this->_predPool->getSlider()->setPosition( 2.0f - distributed ); } else { __this->updatePredisposition( message->origin ); } } }
void ServerServiceAsync::updateWindowTitle() { string strTitle = strformat("ServerService %d",getLocalPort()); strTitle = Platform::utf8ToGbk(strTitle); Platform::setWindowTitle(strTitle.c_str()); }
cheat_entry::cheat_entry(cheat_manager &manager, symbol_table &globaltable, const char *filename, xml_data_node &cheatnode) : m_manager(manager), m_next(nullptr), m_symbols(&manager.machine(), &globaltable), m_state(SCRIPT_STATE_OFF), m_numtemp(DEFAULT_TEMP_VARIABLES), m_argindex(0) { // reset scripts try { // pull the variable count out ahead of things int tempcount = xml_get_attribute_int(&cheatnode, "tempvariables", DEFAULT_TEMP_VARIABLES); if (tempcount < 1) throw emu_fatalerror("%s.xml(%d): invalid tempvariables attribute (%d)\n", filename, cheatnode.line, tempcount); // allocate memory for the cheat m_numtemp = tempcount; // get the description const char *description = xml_get_attribute_string(&cheatnode, "desc", nullptr); if (description == nullptr || description[0] == 0) throw emu_fatalerror("%s.xml(%d): empty or missing desc attribute on cheat\n", filename, cheatnode.line); m_description = description; // create the symbol table m_symbols.add("argindex", symbol_table::READ_ONLY, &m_argindex); for (int curtemp = 0; curtemp < tempcount; curtemp++) { m_symbols.add(strformat("temp%d", curtemp).c_str(), symbol_table::READ_WRITE); } // read the first comment node xml_data_node *commentnode = xml_get_sibling(cheatnode.child, "comment"); if (commentnode != nullptr) { // set the value if not NULL if (commentnode->value != nullptr && commentnode->value[0] != 0) m_comment.assign(commentnode->value); // only one comment is kept commentnode = xml_get_sibling(commentnode->next, "comment"); if (commentnode != nullptr) osd_printf_warning("%s.xml(%d): only one comment node is retained; ignoring additional nodes\n", filename, commentnode->line); } // read the first parameter node xml_data_node *paramnode = xml_get_sibling(cheatnode.child, "parameter"); if (paramnode != nullptr) { // load this parameter m_parameter.reset(global_alloc(cheat_parameter(manager, m_symbols, filename, *paramnode))); // only one parameter allowed paramnode = xml_get_sibling(paramnode->next, "parameter"); if (paramnode != nullptr) osd_printf_warning("%s.xml(%d): only one parameter node allowed; ignoring additional nodes\n", filename, paramnode->line); } // read the script nodes for (xml_data_node *scriptnode = xml_get_sibling(cheatnode.child, "script"); scriptnode != nullptr; scriptnode = xml_get_sibling(scriptnode->next, "script")) { // load this entry auto curscript = global_alloc(cheat_script(manager, m_symbols, filename, *scriptnode)); // if we have a script already for this slot, it is an error std::unique_ptr<cheat_script> &slot = script_for_state(curscript->state()); if (slot != nullptr) osd_printf_warning("%s.xml(%d): only one on script allowed; ignoring additional scripts\n", filename, scriptnode->line); else slot.reset(curscript); } } catch (emu_fatalerror &) { // call our destructor to clean up and re-throw this->~cheat_entry(); throw; } }
Spectator::Spectator(Crowd* crowd, engine::IClump* cloneSource, Enclosure* enclosure) : Character( crowd, cloneSource->clone( "Spectator" ) ) { assert( crowd ); _name = "Spectator"; _enclosure = enclosure; // choose texture unsigned int id = unsigned int( getCore()->getRandToolkit()->getUniform( 0, 7 ) ); id = id < 1 ? 1 : ( id > 6 ? 6 : id ); _texture = Gameplay::iEngine->getTexture( strformat( "crowdmale0%d", id ).c_str() ); assert( _texture ); // setup LODs float LOD0min = 0.0f; float LOD0max = 500.0f; float LOD1min = 500.0f; float LOD1max = 1000.0f; float LOD2min = 1000.0f; float LOD2max = 3000.0f; float LOD3min = 3000.0f; float LOD3max = 100000.0f; callback::AtomicL atomicL; _clump->forAllAtomics( callback::enumerateAtomics, &atomicL ); for( callback::AtomicI atomicI = atomicL.begin(); atomicI != atomicL.end(); atomicI++ ) { // LOD0 if( strcmp( "character01_head01_04_Secondery_character02", (*atomicI)->getFrame()->getName() ) == 0 ) { _clump->setLOD( *atomicI, LOD0max, LOD0min ); (*atomicI)->setRenderCallback( onRenderAtomic, this ); } // LOD1 if( strcmp( "character01_head01_04_Secondery_character01_LOD1", (*atomicI)->getFrame()->getName() ) == 0 ) { _clump->setLOD( *atomicI, LOD1max, LOD1min ); (*atomicI)->setRenderCallback( onRenderAtomic, this ); } // LOD2 if( strcmp( "character01_head01_04_Secondery_character01_LOD2", (*atomicI)->getFrame()->getName() ) == 0 ) { _clump->setLOD( *atomicI, LOD2max, LOD2min ); (*atomicI)->setRenderCallback( onRenderAtomic, this ); } // LOD2 if( strcmp( "character01_head01_04_Secondery_character01_LOD3", (*atomicI)->getFrame()->getName() ) == 0 ) { _clump->setLOD( *atomicI, LOD3max, LOD3min ); (*atomicI)->setRenderCallback( onRenderAtomic, this ); } } // place actor _clump->getFrame()->setPos( enclosure->place() ); // choose random direction for an actor _clump->getFrame()->getLTM(); _clump->getFrame()->rotateRelative( Vector3f(0,1,0), getCore()->getRandToolkit()->getUniform(-180,180) ); _clump->getFrame()->getLTM(); // setup idle action _action = new Character::Idle( _clump, &idleSequence, 0.2f, 1.0f ); // setup wish _wish = wishRelax; _relaxTime = getCore()->getRandToolkit()->getUniform( wishRelaxTimeMin, wishRelaxTimeMax ); _endOfWish = false; }