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;
}
