//----------------------------------------------------------------------------------------------------
void GBJoypad::Update()
{
PROFILE( "Joypad::Update" );
// ________
// 7| |
// 6| |
// __________ 5| |
// / ________ 4| Joypad |
// / / | Chip |
// Down |__|Start___ 3| |
// Up |__|Select__ 2| |
// Left |__|B_______ 1| |
// Right|__|A_______ 0|________|
// By default, input will poll high (ignoring bits 4 and 5)
m_u8StateRegister |= 0xcf;
// Check if we need to poll the input
if( 0x30 != ( m_u8StateRegister & 0x30 ) )
{
int buttons = 0;
if( 0 == ( m_u8StateRegister & 0x20 ) )
{
buttons |= ( m_u32KeyStatus & ButtonA );
buttons |= ( m_u32KeyStatus & ButtonB );
buttons |= ( m_u32KeyStatus & ButtonSelect );
buttons |= ( m_u32KeyStatus & ButtonStart );
}
else if( 0 == ( m_u8StateRegister & 0x10 ) )
{
// Shift right by four to offset the upper bits of the bitmask into the lower four bits of the register
buttons |= ( m_u32KeyStatus & ButtonRight ) >> 4;
buttons |= ( m_u32KeyStatus & ButtonLeft ) >> 4;
buttons |= ( m_u32KeyStatus & ButtonUp ) >> 4;
buttons |= ( m_u32KeyStatus & ButtonDown ) >> 4;
}
bool Shader::Load(Deserializer& source)
{
PROFILE(LoadShader);
Graphics* graphics = GetSubsystem<Graphics>();
if (!graphics)
return false;
// Load the shader source code and resolve any includes
timeStamp_ = 0;
String shaderCode;
if (!ProcessSource(shaderCode, source))
return false;
// Comment out the unneeded shader function
vsSourceCode_ = shaderCode;
psSourceCode_ = shaderCode;
CommentOutFunction(vsSourceCode_, "void PS(");
CommentOutFunction(psSourceCode_, "void VS(");
// OpenGL: rename either VS() or PS() to main(), comment out vertex attributes in pixel shaders
#ifdef URHO3D_OPENGL
vsSourceCode_.Replace("void VS(", "void main(");
psSourceCode_.Replace("void PS(", "void main(");
psSourceCode_.Replace("attribute ", "// attribute ");
#endif
// If variations had already been created, release them and require recompile
for (HashMap<StringHash, SharedPtr<ShaderVariation> >::Iterator i = vsVariations_.Begin(); i != vsVariations_.End(); ++i)
i->second_->Release();
for (HashMap<StringHash, SharedPtr<ShaderVariation> >::Iterator i = psVariations_.Begin(); i != psVariations_.End(); ++i)
i->second_->Release();
RefreshMemoryUse();
return true;
}
void CSimpleColorMapFactory::BuildNode(CPlanetaryMapNode *pNode)
{
PROFILE("CSimpleColorMapFactory::BuildNode", 3);
// Initialize the color map
builder.pb.Init(HEIGHT_MAP_WIDTH, HEIGHT_MAP_WIDTH, 1);
unsigned char *pBuffer = (unsigned char *)builder.pb.GetBuffer();
for(int y=0; y<HEIGHT_MAP_WIDTH; y++)
{
int nCoord = (y+1)*BORDER_MAP_WIDTH + 1;
for(int x=0; x<HEIGHT_MAP_WIDTH; x++)
{
float fAltitude = builder.coord[nCoord++].GetHeight() - pNode->GetPlanetaryMap()->GetRadius();
float fHeight = fAltitude / pNode->GetPlanetaryMap()->GetMaxHeight();
fHeight = (m_vColors.size()-1) * CMath::Clamp(0.001f, 0.999f, (fHeight+1.0f) * 0.5f);
int nHeight = (int)fHeight;
float fRatio = fHeight - nHeight;
CColor c = m_vColors[nHeight] * (1-fRatio) + m_vColors[nHeight+1] * fRatio;
*pBuffer++ = c.r;
*pBuffer++ = c.g;
*pBuffer++ = c.b;
}
}
}
void NavigationMesh::CollectGeometries(Vector<NavigationGeometryInfo>& geometryList)
{
PROFILE(CollectNavigationGeometry);
// Get Navigable components from child nodes, not from whole scene. This makes it possible to partition
// the scene into several navigation meshes
PODVector<Navigable*> navigables;
node_->GetComponents<Navigable>(navigables, true);
HashSet<Node*> processedNodes;
for (unsigned i = 0; i < navigables.Size(); ++i)
{
if (navigables[i]->IsEnabledEffective())
CollectGeometries(geometryList, navigables[i]->GetNode(), processedNodes, navigables[i]->IsRecursive());
}
// Get offmesh connections
Matrix3x4 inverse = node_->GetWorldTransform().Inverse();
PODVector<OffMeshConnection*> connections;
node_->GetComponents<OffMeshConnection>(connections, true);
for (unsigned i = 0; i < connections.Size(); ++i)
{
OffMeshConnection* connection = connections[i];
if (connection->IsEnabledEffective() && connection->GetEndPoint())
{
const Matrix3x4& transform = connection->GetNode()->GetWorldTransform();
NavigationGeometryInfo info;
info.component_ = connection;
info.boundingBox_ = BoundingBox(Sphere(transform.Translation(), connection->GetRadius())).Transformed(inverse);
geometryList.Push(info);
}
}
}
void GoldenJokerState::Update()
{
PROFILE(__FUNCTION__);
if(ENGINE->GetProcessManager()->GetNumQueueProcesses())
{
return;
}
if(GetCurrentError())
{
return;
}
if(!global_quit)
{
POKER_GAME->GoldenJokerUpdateDrawHand();
if (POKER_GAME->GoldenJokerStage == 3)
{
if (!POKER_GAME->GoldenJokerHeldProcessEnd)
ENGINE->GetProcessManager()->AddProcessToQueue(new GoldenJokerHeldsProcess);
else
OBJECT_HANDLER->GetObject2D("GoldenJokerMsg")->SetVisible(true);
}
if (POKER_GAME->GoldenJokerStage == 4)
ENGINE->GetProcessManager()->AddProcessToQueue(new GoldenJokerCardProcess);
if (POKER_GAME->GoldenJokerStage == 5)
{
OBJECT_HANDLER->GetObject2D("GoldenJokerMsg")->SetVisible(false);
ENGINE->StateTransition("HiloGamble");
}
}
}
void Viewport::Render( ) const
{
PROFILE( __FUNCTION__, "Render" );
XFX_PLACE_DEVICE_LOCK;
Renderer::Instance( ).BeginFrame( );
DWORD oldwr = 0;
if( r_wireframe->AsInt( ) )
{
oldwr = Renderer::Instance( ).State( Renderer::SM_FILLMODE );
Renderer::Instance( ).State( Renderer::SM_FILLMODE, D3DFILL_WIREFRAME );
}
gGetApplication( ).Render( );
if( r_wireframe->AsInt( ) )
{
Renderer::Instance( ).State( Renderer::SM_FILLMODE, oldwr );
}
Renderer::Instance( ).EndFrame( );
}
_XFX_BEGIN
//
// Resource
//
HRESULT Resource::LoadFile( const String& file )
{
PROFILE( __FUNCTION__, "General" );
mFilename = file;
mPhysicalPath.clear( );
gMess( "Loading %s from file \"%s\"...", mName.c_str( ), file.c_str( ) );
unsigned long filesize;
HRESULT hr;
if( FAILED( hr = FileSystem::Instance( ).FindFile( file, NULL, &mPhysicalPath ) ) ||
FAILED( hr = FileSystem::Instance( ).GetFileSize( file, filesize ) ) )
{
gError( "Can't open file \"%s\"", file.c_str( ) );
return hr;
}
boost::scoped_array< BYTE > pbuf( new BYTE[ filesize ] );
FileSystem::Instance( ).ReadFile( file, pbuf.get( ) );
if( FAILED( hr = LoadMemory( pbuf.get( ), filesize ) ) )
gError( "Loading %s from file \"%s\" failed!", mName.c_str( ), file.c_str( ) );
return hr;
}
/**
* input_ is available only on server or on the local client, not for
* remote tanks.
*/
void Tank::frameMove(float dt)
{
PROFILE(Tank::frameMove);
setSleeping(false);
Controllable::frameMove(dt);
// Weapon firing code is handled on client for local player only
// to have immediate feedback. Remote players receive weapon
// feedback by received state.
bool firing = false;
if (getLocation() == CL_SERVER_SIDE ||
(getLocation() == CL_CLIENT_SIDE && isLocallyControlled()))
{
firing |= weapon_system_[0]->handleInput(input_.fire1_);
firing |= weapon_system_[1]->handleInput(input_.fire2_);
firing |= weapon_system_[2]->handleInput(input_.fire3_);
firing |= weapon_system_[3]->handleInput(input_.fire4_);
}
if (getLocation() != CL_REPLAY_SIM)
{
for(unsigned w=0; w < NUM_WEAPON_SLOTS; w++)
{
weapon_system_[w]->frameMove(dt);
}
}
if (is_locally_controlled_ && getLocation() == CL_CLIENT_SIDE)
{
frameMoveTurret(dt, true);
}
frameMoveTurret(dt, false);
if (is_locally_controlled_ || getLocation() == CL_SERVER_SIDE)
{
// remote tanks don't have accurate wheel info, and no extra
// dampening needed anyway
handleExtraDampening();
// Don't calc tire physics for uncontrolled objects on client.
frameMoveTires(dt);
}
if (location_ == CL_SERVER_SIDE)
{
/// heal logic
if (!firing &&
params_.get<bool>("tank.heal_skill") &&
getGlobalLinearVel().length() < s_params.get<float>("server.logic.tank_heal_velocity_threshold") &&
getOwner() != UNASSIGNED_SYSTEM_ADDRESS)
{
startHealing();
} else
{
stopHealing();
}
// object is positioned by visual on client side. Avoid redundant
// positioning
positionCarriedObject();
if (firing)
{
setInvincible(false);
}
}
}
bool Shader::Load(Deserializer& source)
{
PROFILE(LoadShader);
Graphics* graphics = GetSubsystem<Graphics>();
if (!graphics)
return false;
vsSourceCodeLength_ = 0;
psSourceCodeLength_ = 0;
SharedPtr<XMLFile> xml(new XMLFile(context_));
if (!xml->Load(source))
return false;
XMLElement shaders = xml->GetRoot("shaders");
if (!shaders)
{
LOGERROR("No shaders element in " + source.GetName());
return false;
}
{
PROFILE(ParseShaderDefinition);
if (!vsParser_.Parse(VS, shaders))
{
LOGERROR("VS: " + vsParser_.GetErrorMessage());
return false;
}
if (!psParser_.Parse(PS, shaders))
{
LOGERROR("PS: " + psParser_.GetErrorMessage());
return false;
}
}
String path, fileName, extension;
SplitPath(GetName(), path, fileName, extension);
{
PROFILE(LoadShaderSource);
if (!ProcessSource(vsSourceCode_, vsSourceCodeLength_, path + fileName + ".vert"))
return false;
if (!ProcessSource(psSourceCode_, psSourceCodeLength_, path + fileName + ".frag"))
return false;
}
// If variations had already been created, release them and set new source code
/// \todo Should also update defines
for (HashMap<StringHash, SharedPtr<ShaderVariation> >::Iterator i = vsVariations_.Begin(); i != vsVariations_.End(); ++i)
{
i->second_->Release();
i->second_->SetSourceCode(vsSourceCode_, vsSourceCodeLength_);
}
for (HashMap<StringHash, SharedPtr<ShaderVariation> >::Iterator i = psVariations_.Begin(); i != psVariations_.End(); ++i)
{
i->second_->Release();
i->second_->SetSourceCode(psSourceCode_, psSourceCodeLength_);
}
SetMemoryUse(sizeof(Shader) + 2 * sizeof(ShaderParser) + (vsVariations_.Size() + psVariations_.Size()) *
sizeof(ShaderVariation));
return true;
}
bool TextureCube::SetData(CubeMapFace face, unsigned level, int x, int y, int width, int height, const void* data)
{
PROFILE(SetTextureData);
if (!object_ || !graphics_)
{
LOGERROR("No texture created, can not set data");
return false;
}
if (!data)
{
LOGERROR("Null source for setting data");
return false;
}
if (level >= levels_)
{
LOGERROR("Illegal mip level for setting data");
return false;
}
if (graphics_->IsDeviceLost())
{
LOGWARNING("Texture data assignment while device is lost");
dataPending_ = true;
return true;
}
if (IsCompressed())
{
x &= ~3;
y &= ~3;
}
int levelWidth = GetLevelWidth(level);
int levelHeight = GetLevelHeight(level);
if (x < 0 || x + width > levelWidth || y < 0 || y + height > levelHeight || width <= 0 || height <= 0)
{
LOGERROR("Illegal dimensions for setting data");
return false;
}
graphics_->SetTextureForUpdate(this);
bool wholeLevel = x == 0 && y == 0 && width == levelWidth && height == levelHeight;
unsigned format = GetSRGB() ? GetSRGBFormat(format_) : format_;
if (!IsCompressed())
{
if (wholeLevel)
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level, format, width, height, 0, GetExternalFormat(format_),
GetDataType(format_), data);
else
glTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level, x, y, width, height, GetExternalFormat(format_),
GetDataType(format_), data);
}
else
{
if (wholeLevel)
glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level, format, width, height, 0,
GetDataSize(width, height), data);
else
glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level, x, y, width, height, format,
GetDataSize(width, height), data);
}
graphics_->SetTexture(0, 0);
return true;
}
virtual void HandleMessage(const CMessage& msg, bool UNUSED(global))
{
switch (msg.GetType())
{
case MT_Interpolate:
{
PROFILE("Position::Interpolate");
const CMessageInterpolate& msgData = static_cast<const CMessageInterpolate&> (msg);
float rotY = m_RotY.ToFloat();
if (rotY != m_InterpolatedRotY)
{
float delta = rotY - m_InterpolatedRotY;
// Wrap delta to -M_PI..M_PI
delta = fmodf(delta + (float)M_PI, 2*(float)M_PI); // range -2PI..2PI
if (delta < 0) delta += 2*(float)M_PI; // range 0..2PI
delta -= (float)M_PI; // range -M_PI..M_PI
// Clamp to max rate
float deltaClamped = clamp(delta, -m_RotYSpeed*msgData.deltaSimTime, +m_RotYSpeed*msgData.deltaSimTime);
// Calculate new orientation, in a peculiar way in order to make sure the
// result gets close to m_orientation (rather than being n*2*M_PI out)
m_InterpolatedRotY = rotY + deltaClamped - delta;
// update the visual XZ rotation
if (m_InWorld)
{
m_LastInterpolatedRotX = m_InterpolatedRotX;
m_LastInterpolatedRotZ = m_InterpolatedRotZ;
UpdateXZRotation();
}
UpdateMessageSubscriptions();
}
break;
}
case MT_TurnStart:
{
m_LastInterpolatedRotX = m_InterpolatedRotX;
m_LastInterpolatedRotZ = m_InterpolatedRotZ;
if (m_InWorld && (m_LastX != m_X || m_LastZ != m_Z))
UpdateXZRotation();
// Store the positions from the turn before
m_PrevX = m_LastX;
m_PrevZ = m_LastZ;
m_LastX = m_X;
m_LastZ = m_Z;
m_LastYDifference = entity_pos_t::Zero();
// warn when a position change also causes a territory change under the entity
if (m_InWorld)
{
player_id_t newTerritory;
CmpPtr<ICmpTerritoryManager> cmpTerritoryManager(GetSystemEntity());
if (cmpTerritoryManager)
newTerritory = cmpTerritoryManager->GetOwner(m_X, m_Z);
else
newTerritory = INVALID_PLAYER;
if (newTerritory != m_Territory)
{
m_Territory = newTerritory;
CMessageTerritoryPositionChanged msg(GetEntityId(), m_Territory);
GetSimContext().GetComponentManager().PostMessage(GetEntityId(), msg);
}
}
else if (m_Territory != INVALID_PLAYER)
{
m_Territory = INVALID_PLAYER;
CMessageTerritoryPositionChanged msg(GetEntityId(), m_Territory);
GetSimContext().GetComponentManager().PostMessage(GetEntityId(), msg);
}
break;
}
case MT_TerrainChanged:
case MT_WaterChanged:
{
AdvertiseInterpolatedPositionChanges();
break;
}
case MT_Deserialized:
{
Deserialized();
break;
}
}
}
void CCmpPathfinder::UpdateGrid()
{
CmpPtr<ICmpTerrain> cmpTerrain(GetSimContext(), SYSTEM_ENTITY);
if (!cmpTerrain)
return; // error
// If the terrain was resized then delete the old grid data
if (m_Grid && m_MapSize != cmpTerrain->GetTilesPerSide())
{
SAFE_DELETE(m_Grid);
SAFE_DELETE(m_ObstructionGrid);
m_TerrainDirty = true;
}
// Initialise the terrain data when first needed
if (!m_Grid)
{
m_MapSize = cmpTerrain->GetTilesPerSide();
m_Grid = new Grid<TerrainTile>(m_MapSize, m_MapSize);
m_ObstructionGrid = new Grid<u8>(m_MapSize, m_MapSize);
}
CmpPtr<ICmpObstructionManager> cmpObstructionManager(GetSimContext(), SYSTEM_ENTITY);
bool obstructionsDirty = cmpObstructionManager->Rasterise(*m_ObstructionGrid);
if (obstructionsDirty && !m_TerrainDirty)
{
PROFILE("UpdateGrid obstructions");
// Obstructions changed - we need to recompute passability
// Since terrain hasn't changed we only need to update the obstruction bits
// and can skip the rest of the data
// TODO: if ObstructionManager::SetPassabilityCircular was called at runtime
// (which should probably never happen, but that's not guaranteed),
// then TILE_OUTOFBOUNDS will change and we can't use this fast path, but
// currently it'll just set obstructionsDirty and we won't notice
for (u16 j = 0; j < m_MapSize; ++j)
{
for (u16 i = 0; i < m_MapSize; ++i)
{
TerrainTile& t = m_Grid->get(i, j);
u8 obstruct = m_ObstructionGrid->get(i, j);
if (obstruct & ICmpObstructionManager::TILE_OBSTRUCTED_PATHFINDING)
t |= 1;
else
t &= (TerrainTile)~1;
if (obstruct & ICmpObstructionManager::TILE_OBSTRUCTED_FOUNDATION)
t |= 2;
else
t &= (TerrainTile)~2;
}
}
++m_Grid->m_DirtyID;
}
else if (obstructionsDirty || m_TerrainDirty)
{
PROFILE("UpdateGrid full");
// Obstructions or terrain changed - we need to recompute passability
// TODO: only bother recomputing the region that has actually changed
CmpPtr<ICmpWaterManager> cmpWaterManager(GetSimContext(), SYSTEM_ENTITY);
// TOOD: these bits should come from ICmpTerrain
CTerrain& terrain = GetSimContext().GetTerrain();
// avoid integer overflow in intermediate calculation
const u16 shoreMax = 32767;
// First pass - find underwater tiles
Grid<bool> waterGrid(m_MapSize, m_MapSize);
for (u16 j = 0; j < m_MapSize; ++j)
{
for (u16 i = 0; i < m_MapSize; ++i)
{
fixed x, z;
TileCenter(i, j, x, z);
bool underWater = cmpWaterManager && (cmpWaterManager->GetWaterLevel(x, z) > terrain.GetExactGroundLevelFixed(x, z));
waterGrid.set(i, j, underWater);
}
}
// Second pass - find shore tiles
Grid<u16> shoreGrid(m_MapSize, m_MapSize);
for (u16 j = 0; j < m_MapSize; ++j)
{
for (u16 i = 0; i < m_MapSize; ++i)
{
// Find a land tile
if (!waterGrid.get(i, j))
{
if ((i > 0 && waterGrid.get(i-1, j)) || (i > 0 && j < m_MapSize-1 && waterGrid.get(i-1, j+1)) || (i > 0 && j > 0 && waterGrid.get(i-1, j-1))
|| (i < m_MapSize-1 && waterGrid.get(i+1, j)) || (i < m_MapSize-1 && j < m_MapSize-1 && waterGrid.get(i+1, j+1)) || (i < m_MapSize-1 && j > 0 && waterGrid.get(i+1, j-1))
|| (j > 0 && waterGrid.get(i, j-1)) || (j < m_MapSize-1 && waterGrid.get(i, j+1))
)
{ // If it's bordered by water, it's a shore tile
shoreGrid.set(i, j, 0);
}
else
{
shoreGrid.set(i, j, shoreMax);
}
}
}
}
// Expand influences on land to find shore distance
for (u16 y = 0; y < m_MapSize; ++y)
{
u16 min = shoreMax;
for (u16 x = 0; x < m_MapSize; ++x)
{
if (!waterGrid.get(x, y))
{
u16 g = shoreGrid.get(x, y);
if (g > min)
shoreGrid.set(x, y, min);
else if (g < min)
min = g;
++min;
}
}
for (u16 x = m_MapSize; x > 0; --x)
{
if (!waterGrid.get(x-1, y))
{
u16 g = shoreGrid.get(x-1, y);
if (g > min)
shoreGrid.set(x-1, y, min);
else if (g < min)
min = g;
++min;
}
}
}
for (u16 x = 0; x < m_MapSize; ++x)
{
u16 min = shoreMax;
for (u16 y = 0; y < m_MapSize; ++y)
{
if (!waterGrid.get(x, y))
{
u16 g = shoreGrid.get(x, y);
if (g > min)
shoreGrid.set(x, y, min);
else if (g < min)
min = g;
++min;
}
}
for (u16 y = m_MapSize; y > 0; --y)
{
if (!waterGrid.get(x, y-1))
{
u16 g = shoreGrid.get(x, y-1);
if (g > min)
shoreGrid.set(x, y-1, min);
else if (g < min)
min = g;
++min;
}
}
}
// Apply passability classes to terrain
for (u16 j = 0; j < m_MapSize; ++j)
{
for (u16 i = 0; i < m_MapSize; ++i)
{
fixed x, z;
TileCenter(i, j, x, z);
TerrainTile t = 0;
u8 obstruct = m_ObstructionGrid->get(i, j);
fixed height = terrain.GetExactGroundLevelFixed(x, z);
fixed water;
if (cmpWaterManager)
water = cmpWaterManager->GetWaterLevel(x, z);
fixed depth = water - height;
fixed slope = terrain.GetSlopeFixed(i, j);
fixed shoredist = fixed::FromInt(shoreGrid.get(i, j));
if (obstruct & ICmpObstructionManager::TILE_OBSTRUCTED_PATHFINDING)
t |= 1;
if (obstruct & ICmpObstructionManager::TILE_OBSTRUCTED_FOUNDATION)
t |= 2;
if (obstruct & ICmpObstructionManager::TILE_OUTOFBOUNDS)
{
// If out of bounds, nobody is allowed to pass
for (size_t n = 0; n < m_PassClasses.size(); ++n)
t |= m_PassClasses[n].m_Mask;
}
else
{
for (size_t n = 0; n < m_PassClasses.size(); ++n)
{
if (!m_PassClasses[n].IsPassable(depth, slope, shoredist))
t |= m_PassClasses[n].m_Mask;
}
}
std::string moveClass = terrain.GetMovementClass(i, j);
if (m_TerrainCostClassTags.find(moveClass) != m_TerrainCostClassTags.end())
t |= COST_CLASS_MASK(m_TerrainCostClassTags[moveClass]);
m_Grid->set(i, j, t);
}
}
m_TerrainDirty = false;
++m_Grid->m_DirtyID;
}
}
inline void Density::symmetrize_density_matrix()
{
PROFILE("sirius::Density::symmetrize_density_matrix");
auto& sym = unit_cell_.symmetry();
int ndm = ctx_.num_mag_comp();
mdarray<double_complex, 4> dm(unit_cell_.max_mt_basis_size(), unit_cell_.max_mt_basis_size(),
ndm, unit_cell_.num_atoms());
dm.zero();
int lmax = unit_cell_.lmax();
int lmmax = Utils::lmmax(lmax);
mdarray<double, 2> rotm(lmmax, lmmax);
double alpha = 1.0 / double(sym.num_mag_sym());
for (int i = 0; i < sym.num_mag_sym(); i++) {
int pr = sym.magnetic_group_symmetry(i).spg_op.proper;
auto eang = sym.magnetic_group_symmetry(i).spg_op.euler_angles;
int isym = sym.magnetic_group_symmetry(i).isym;
SHT::rotation_matrix(lmax, eang, pr, rotm);
auto spin_rot_su2 = SHT::rotation_matrix_su2(sym.magnetic_group_symmetry(i).spin_rotation);
for (int ia = 0; ia < unit_cell_.num_atoms(); ia++) {
auto& atom_type = unit_cell_.atom(ia).type();
int ja = sym.sym_table(ia, isym);
for (int xi1 = 0; xi1 < unit_cell_.atom(ia).mt_basis_size(); xi1++) {
int l1 = atom_type.indexb(xi1).l;
int lm1 = atom_type.indexb(xi1).lm;
int o1 = atom_type.indexb(xi1).order;
for (int xi2 = 0; xi2 < unit_cell_.atom(ia).mt_basis_size(); xi2++) {
int l2 = atom_type.indexb(xi2).l;
int lm2 = atom_type.indexb(xi2).lm;
int o2 = atom_type.indexb(xi2).order;
std::array<double_complex, 3> dm_rot_spatial = {0, 0, 0};
for (int j = 0; j < ndm; j++) {
for (int m3 = -l1; m3 <= l1; m3++) {
int lm3 = Utils::lm_by_l_m(l1, m3);
int xi3 = atom_type.indexb().index_by_lm_order(lm3, o1);
for (int m4 = -l2; m4 <= l2; m4++) {
int lm4 = Utils::lm_by_l_m(l2, m4);
int xi4 = atom_type.indexb().index_by_lm_order(lm4, o2);
dm_rot_spatial[j] += density_matrix_(xi3, xi4, j, ja) * rotm(lm1, lm3) * rotm(lm2, lm4) * alpha;
}
}
}
/* magnetic symmetrization */
if (ndm == 1) {
dm(xi1, xi2, 0, ia) += dm_rot_spatial[0];
} else {
double_complex spin_dm[2][2] = {
{dm_rot_spatial[0], dm_rot_spatial[2]},
{std::conj(dm_rot_spatial[2]), dm_rot_spatial[1]}
};
/* spin blocks of density matrix are: uu, dd, ud
the mapping from linear index (0, 1, 2) of density matrix components is:
for the first spin index: k & 1, i.e. (0, 1, 2) -> (0, 1, 0)
for the second spin index: min(k, 1), i.e. (0, 1, 2) -> (0, 1, 1)
*/
for (int k = 0; k < ndm; k++) {
for (int is = 0; is < 2; is++) {
for (int js = 0; js < 2; js++) {
dm(xi1, xi2, k, ia) += spin_rot_su2(k & 1, is) * spin_dm[is][js] * std::conj(spin_rot_su2(std::min(k, 1), js));
}
}
}
}
}
}
}
}
dm >> density_matrix_;
if (ctx_.control().print_checksum_ && ctx_.comm().rank() == 0) {
auto cs = dm.checksum();
print_checksum("density_matrix", cs);
//for (int ia = 0; ia < unit_cell_.num_atoms(); ia++) {
// auto cs = mdarray<double_complex, 1>(&dm(0, 0, 0, ia), dm.size(0) * dm.size(1) * dm.size(2)).checksum();
// DUMP("checksum(density_matrix(%i)): %20.14f %20.14f", ia, cs.real(), cs.imag());
//}
}
}
// Return a string representation of a VAProfile
const char *string_of_VAProfile(VAProfile profile)
{
switch (profile) {
#define PROFILE(profile) \
case VAProfile##profile: return "VAProfile" #profile
PROFILE(MPEG2Simple);
PROFILE(MPEG2Main);
PROFILE(MPEG4Simple);
PROFILE(MPEG4AdvancedSimple);
PROFILE(MPEG4Main);
PROFILE(H264Baseline);
PROFILE(H264Main);
PROFILE(H264High);
PROFILE(VC1Simple);
PROFILE(VC1Main);
PROFILE(VC1Advanced);
#undef PROFILE
default: break;
}
return "<unknown>";
}
void cApplication::fileWatching()
{
PROFILE(_T("fileWatching"));
_getCore()->fileWatching();
}
bool TextureCube::SetData(CubeMapFace face, unsigned level, int x, int y, int width, int height, const void* data)
{
PROFILE(SetTextureData);
if (!object_)
{
LOGERROR("No texture created, can not set data");
return false;
}
if (!data)
{
LOGERROR("Null source for setting data");
return false;
}
if (level >= levels_)
{
LOGERROR("Illegal mip level for setting data");
return false;
}
if (graphics_->IsDeviceLost())
{
LOGWARNING("Texture data assignment while device is lost");
dataPending_ = true;
return true;
}
if (IsCompressed())
{
x &= ~3;
y &= ~3;
}
int levelWidth = GetLevelWidth(level);
int levelHeight = GetLevelHeight(level);
if (x < 0 || x + width > levelWidth || y < 0 || y + height > levelHeight || width <= 0 || height <= 0)
{
LOGERROR("Illegal dimensions for setting data");
return false;
}
D3DLOCKED_RECT d3dLockedRect;
RECT d3dRect;
d3dRect.left = x;
d3dRect.top = y;
d3dRect.right = x + width;
d3dRect.bottom = y + height;
DWORD flags = 0;
if (level == 0 && x == 0 && y == 0 && width == levelWidth && height == levelHeight && pool_ == D3DPOOL_DEFAULT)
flags |= D3DLOCK_DISCARD;
if (FAILED(((IDirect3DCubeTexture9*)object_)->LockRect((D3DCUBEMAP_FACES)face, level, &d3dLockedRect, (flags &
D3DLOCK_DISCARD) ? 0 : &d3dRect, flags)))
{
LOGERROR("Could not lock texture");
return false;
}
if (IsCompressed())
{
height = (height + 3) >> 2;
y >>= 2;
}
unsigned char* src = (unsigned char*)data;
unsigned rowSize = GetRowDataSize(width);
// GetRowDataSize() returns CPU-side (source) data size, so need to convert for X8R8G8B8
if (format_ == D3DFMT_X8R8G8B8)
rowSize = rowSize / 3 * 4;
// Perform conversion from RGB / RGBA as necessary
switch (format_)
{
default:
for (int i = 0; i < height; ++i)
{
unsigned char* dest = (unsigned char*)d3dLockedRect.pBits + i * d3dLockedRect.Pitch;
memcpy(dest, src, rowSize);
src += rowSize;
}
break;
case D3DFMT_X8R8G8B8:
for (int i = 0; i < height; ++i)
{
unsigned char* dest = (unsigned char*)d3dLockedRect.pBits + i * d3dLockedRect.Pitch;
for (int j = 0; j < width; ++j)
{
*dest++ = src[2]; *dest++ = src[1]; *dest++ = src[0]; *dest++ = 255;
src += 3;
}
}
break;
case D3DFMT_A8R8G8B8:
for (int i = 0; i < height; ++i)
{
unsigned char* dest = (unsigned char*)d3dLockedRect.pBits + i * d3dLockedRect.Pitch;
for (int j = 0; j < width; ++j)
{
*dest++ = src[2]; *dest++ = src[1]; *dest++ = src[0]; *dest++ = src[3];
src += 4;
}
}
break;
}
((IDirect3DCubeTexture9*)object_)->UnlockRect((D3DCUBEMAP_FACES)face, level);
return true;
}
void DebugRenderer::Render()
{
if (!HasContent())
return;
Graphics* graphics = GetSubsystem<Graphics>();
// Engine does not render when window is closed or device is lost
assert(graphics && graphics->IsInitialized() && !graphics->IsDeviceLost());
PROFILE(RenderDebugGeometry);
ShaderVariation* vs = graphics->GetShader(VS, "Basic", "VERTEXCOLOR");
ShaderVariation* ps = graphics->GetShader(PS, "Basic", "VERTEXCOLOR");
unsigned numVertices = (lines_.Size() + noDepthLines_.Size()) * 2 + (triangles_.Size() + noDepthTriangles_.Size()) * 3;
// Resize the vertex buffer if too small or much too large
if (vertexBuffer_->GetVertexCount() < numVertices || vertexBuffer_->GetVertexCount() > numVertices * 2)
vertexBuffer_->SetSize(numVertices, MASK_POSITION | MASK_COLOR, true);
float* dest = (float*)vertexBuffer_->Lock(0, numVertices, true);
if (!dest)
return;
for (unsigned i = 0; i < lines_.Size(); ++i)
{
const DebugLine& line = lines_[i];
dest[0] = line.start_.x_;
dest[1] = line.start_.y_;
dest[2] = line.start_.z_;
((unsigned&)dest[3]) = line.color_;
dest[4] = line.end_.x_;
dest[5] = line.end_.y_;
dest[6] = line.end_.z_;
((unsigned&)dest[7]) = line.color_;
dest += 8;
}
for (unsigned i = 0; i < noDepthLines_.Size(); ++i)
{
const DebugLine& line = noDepthLines_[i];
dest[0] = line.start_.x_;
dest[1] = line.start_.y_;
dest[2] = line.start_.z_;
((unsigned&)dest[3]) = line.color_;
dest[4] = line.end_.x_;
dest[5] = line.end_.y_;
dest[6] = line.end_.z_;
((unsigned&)dest[7]) = line.color_;
dest += 8;
}
for (unsigned i = 0; i < triangles_.Size(); ++i)
{
const DebugTriangle& triangle = triangles_[i];
dest[0] = triangle.v1_.x_;
dest[1] = triangle.v1_.y_;
dest[2] = triangle.v1_.z_;
((unsigned&)dest[3]) = triangle.color_;
dest[4] = triangle.v2_.x_;
dest[5] = triangle.v2_.y_;
dest[6] = triangle.v2_.z_;
((unsigned&)dest[7]) = triangle.color_;
dest[8] = triangle.v3_.x_;
dest[9] = triangle.v3_.y_;
dest[10] = triangle.v3_.z_;
((unsigned&)dest[11]) = triangle.color_;
dest += 12;
}
for (unsigned i = 0; i < noDepthTriangles_.Size(); ++i)
{
const DebugTriangle& triangle = noDepthTriangles_[i];
dest[0] = triangle.v1_.x_;
dest[1] = triangle.v1_.y_;
dest[2] = triangle.v1_.z_;
((unsigned&)dest[3]) = triangle.color_;
dest[4] = triangle.v2_.x_;
dest[5] = triangle.v2_.y_;
dest[6] = triangle.v2_.z_;
((unsigned&)dest[7]) = triangle.color_;
dest[8] = triangle.v3_.x_;
dest[9] = triangle.v3_.y_;
dest[10] = triangle.v3_.z_;
((unsigned&)dest[11]) = triangle.color_;
dest += 12;
}
vertexBuffer_->Unlock();
graphics->SetBlendMode(BLEND_REPLACE);
graphics->SetColorWrite(true);
graphics->SetCullMode(CULL_NONE);
graphics->SetDepthWrite(true);
graphics->SetScissorTest(false);
graphics->SetStencilTest(false);
graphics->SetShaders(vs, ps);
graphics->SetShaderParameter(VSP_MODEL, Matrix3x4::IDENTITY);
graphics->SetShaderParameter(VSP_VIEWPROJ, projection_ * view_);
graphics->SetShaderParameter(PSP_MATDIFFCOLOR, Color(1.0f, 1.0f, 1.0f, 1.0f));
graphics->SetVertexBuffer(vertexBuffer_);
unsigned start = 0;
unsigned count = 0;
if (lines_.Size())
{
count = lines_.Size() * 2;
graphics->SetDepthTest(CMP_LESSEQUAL);
graphics->Draw(LINE_LIST, start, count);
start += count;
}
if (noDepthLines_.Size())
{
count = noDepthLines_.Size() * 2;
graphics->SetDepthTest(CMP_ALWAYS);
graphics->Draw(LINE_LIST, start, count);
start += count;
}
graphics->SetBlendMode(BLEND_ALPHA);
if (triangles_.Size())
{
count = triangles_.Size() * 3;
graphics->SetDepthTest(CMP_LESSEQUAL);
graphics->Draw(TRIANGLE_LIST, start, count);
start += count;
}
if (noDepthTriangles_.Size())
{
count = noDepthTriangles_.Size() * 3;
graphics->SetDepthTest(CMP_ALWAYS);
graphics->Draw(TRIANGLE_LIST, start, count);
}
}
bool Technique::Load(Deserializer& source)
{
PROFILE(LoadTechnique);
SharedPtr<XMLFile> xml(new XMLFile(context_));
if (!xml->Load(source))
return false;
XMLElement rootElem = xml->GetRoot();
if (rootElem.HasAttribute("sm3"))
isSM3_ = rootElem.GetBool("sm3");
unsigned numPasses = 0;
XMLElement passElem = rootElem.GetChild("pass");
while (passElem)
{
if (passElem.HasAttribute("name"))
{
StringHash nameHash(passElem.GetAttribute("name"));
Pass* newPass = CreatePass(nameHash);
++numPasses;
if (passElem.HasAttribute("vs"))
newPass->SetVertexShader(passElem.GetAttribute("vs"));
if (passElem.HasAttribute("ps"))
newPass->SetPixelShader(passElem.GetAttribute("ps"));
if (passElem.HasAttribute("lighting"))
{
String lighting = passElem.GetAttributeLower("lighting");
newPass->SetLightingMode((PassLightingMode)GetStringListIndex(lighting.CString(), lightingModeNames,
LIGHTING_UNLIT));
}
if (passElem.HasAttribute("blend"))
{
String blend = passElem.GetAttributeLower("blend");
newPass->SetBlendMode((BlendMode)GetStringListIndex(blend.CString(), blendModeNames, BLEND_REPLACE));
}
if (passElem.HasAttribute("depthtest"))
{
String depthTest = passElem.GetAttributeLower("depthtest");
if (depthTest == "false")
newPass->SetDepthTestMode(CMP_ALWAYS);
else
newPass->SetDepthTestMode((CompareMode)GetStringListIndex(depthTest.CString(), compareModeNames, CMP_LESS));
}
if (passElem.HasAttribute("depthwrite"))
newPass->SetDepthWrite(passElem.GetBool("depthwrite"));
if (passElem.HasAttribute("alphamask"))
newPass->SetAlphaMask(passElem.GetBool("alphamask"));
}
else
LOGERROR("Missing pass name");
passElem = passElem.GetNext("pass");
}
// Calculate memory use
unsigned memoryUse = sizeof(Technique) + numPasses * sizeof(Pass);
SetMemoryUse(memoryUse);
return true;
}
int main()
{
PROFILER_INIT();
FrameList frameList(10); // Keep a history of up to 100 frames (might be used by some modules)
// Modules
//BackgroundModelling_simple::BackgroundModel backgroundModel;
BackgroundModelling::BackgroundModel backgroundModel;
ForegroundProcessing::ForegroundProcessor foregroundProcessor;
Identification::Identifier identifier;
Prediction::Kalman kalmanFilter;
Evaluation evaluate(&frameList, 20);
// Init
foregroundProcessor.setAlgortihm(ForegroundProcessing::SLOW); //Use slow, toggle shadows in the init command
foregroundProcessor.init(3, 2, 125, 4, false);
foregroundProcessor.initShadow(0.5, 0.5, 0.3, 0.99);
identifier.init(Identification::Ultimate);
evaluate.readXML2FrameList("clip1.xml");
//evaluate.readXML2FrameList("CAVIAR1/fosne2gt.xml");
int waitForBGConvergence = 60;
// Load frame source
//frameList.open("CAVIAR1/OneStopNoEnter2front.mpg");
//frameList.open("clip1.mpeg");
frameList.open("camera1.mov");
//frameList.open("Renova_20080420_083025_Cam10_0000.mpeg");
//Record video
VideoWriter demo("trackingDemo.mpeg", CV_FOURCC('P','I','M','1'), 20, frameList.movieSize*2);
// Create windows
namedWindow("Info",CV_WINDOW_AUTOSIZE);
namedWindow("Background",CV_WINDOW_AUTOSIZE);
namedWindow("Foreground",CV_WINDOW_AUTOSIZE);
namedWindow("Tracking",CV_WINDOW_AUTOSIZE);
namedWindow("Raw image", CV_WINDOW_AUTOSIZE);
//namedWindow("BackgroundModel",CV_WINDOW_AUTOSIZE);
namedWindow("Evaluation", CV_WINDOW_AUTOSIZE);
while (frameList.queryNextFrame())
{
PROFILER_RESET();
sampleDown(frameList.getLatestFrame().image, frameList.getLatestFrame().image, 1); // Speed up by sampling down the image
// Do the nessecary processing
backgroundModel.update(frameList.getFrames()); PROFILE("BackgroundModel");
if (frameList.getCurrentFrameNumber() > waitForBGConvergence) //Wait for convergence
foregroundProcessor.segmentForeground(frameList.getLatestFrame()); PROFILE("ForegroundSeg.");
identifier.identify(frameList.getFrames()); PROFILE("Identification");
kalmanFilter.predict(frameList.getLatestFrame()); PROFILE("Kalman Prediction");
evaluate.currentFrame(); PROFILE("Evaluation");
// Display result
frameList.display("Tracking");
frameList.displayBackground("Background");
if (frameList.getCurrentFrameNumber() > waitForBGConvergence) //Wait for convergence
frameList.displayForeground("Foreground");
evaluate.displayInfo("Evaluation");
// Give the GUI time to render
waitKey(1); PROFILE("Display");
// Write current frame (and info) to file
demo << frameList.getLatestFrame().demoImage;
// Optional pause between each frame
//stepWiseFromFrame(frameList, 55);
PROFILE("QueryNextFrame");
PROFILE_TOTALTIME();
PROFILE("FPS");
PROFILE_FPS();
// Evaluate accuracy and precision
evaluate.MOTA();
evaluate.MOTP();
// Display info
frameList.displayInfo("Info");
}
evaluate.displaySequenceInfo("Evaluation");
waitKey(0);
return 0;
}
bool Animation::Load(Deserializer& source)
{
PROFILE(LoadAnimation);
unsigned memoryUse = sizeof(Animation);
// Check ID
if (source.ReadFileID() != "UANI")
{
LOGERROR(source.GetName() + " is not a valid animation file");
return false;
}
// Read name and length
animationName_ = source.ReadString();
animationNameHash_ = animationName_;
length_ = source.ReadFloat();
tracks_.Clear();
unsigned tracks = source.ReadUInt();
tracks_.Resize(tracks);
memoryUse += tracks * sizeof(AnimationTrack);
// Read tracks
for (unsigned i = 0; i < tracks; ++i)
{
AnimationTrack& newTrack = tracks_[i];
newTrack.name_ = source.ReadString();
newTrack.nameHash_ = newTrack.name_;
newTrack.channelMask_ = source.ReadUByte();
unsigned keyFrames = source.ReadUInt();
newTrack.keyFrames_.Resize(keyFrames);
memoryUse += keyFrames * sizeof(AnimationKeyFrame);
// Read keyframes of the track
for (unsigned j = 0; j < keyFrames; ++j)
{
AnimationKeyFrame& newKeyFrame = newTrack.keyFrames_[j];
newKeyFrame.time_ = source.ReadFloat();
if (newTrack.channelMask_ & CHANNEL_POSITION)
newKeyFrame.position_ = source.ReadVector3();
if (newTrack.channelMask_ & CHANNEL_ROTATION)
newKeyFrame.rotation_ = source.ReadQuaternion();
if (newTrack.channelMask_ & CHANNEL_SCALE)
newKeyFrame.scale_ = source.ReadVector3();
}
}
// Optionally read triggers from an XML file
ResourceCache* cache = GetSubsystem<ResourceCache>();
String xmlName = ReplaceExtension(GetName(), ".xml");
if (cache->Exists(xmlName))
{
XMLFile* file = cache->GetResource<XMLFile>(xmlName);
if (file)
{
XMLElement rootElem = file->GetRoot();
XMLElement triggerElem = rootElem.GetChild("trigger");
while (triggerElem)
{
if (triggerElem.HasAttribute("normalizedtime"))
AddTrigger(triggerElem.GetFloat("normalizedtime"), true, triggerElem.GetVariant());
else if (triggerElem.HasAttribute("time"))
AddTrigger(triggerElem.GetFloat("time"), false, triggerElem.GetVariant());
triggerElem = triggerElem.GetNext("trigger");
}
memoryUse += triggers_.Size() * sizeof(AnimationTriggerPoint);
}
}
SetMemoryUse(memoryUse);
return true;
}
void CustomGeometry::Commit()
{
PROFILE(CommitCustomGeometry);
unsigned totalVertices = 0;
boundingBox_.Clear();
for (unsigned i = 0; i < vertices_.Size(); ++i)
{
totalVertices += vertices_[i].Size();
for (unsigned j = 0; j < vertices_[i].Size(); ++j)
boundingBox_.Merge(vertices_[i][j].position_);
}
vertexBuffer_->SetSize(totalVertices, elementMask_);
if (totalVertices)
{
unsigned char* dest = (unsigned char*)vertexBuffer_->Lock(0, totalVertices, true);
if (dest)
{
unsigned vertexStart = 0;
for (unsigned i = 0; i < vertices_.Size(); ++i)
{
unsigned vertexCount = 0;
for (unsigned j = 0; j < vertices_[i].Size(); ++j)
{
*((Vector3*)dest) = vertices_[i][j].position_;
dest += sizeof(Vector3);
if (elementMask_ & MASK_NORMAL)
{
*((Vector3*)dest) = vertices_[i][j].normal_;
dest += sizeof(Vector3);
}
if (elementMask_ & MASK_COLOR)
{
*((unsigned*)dest) = vertices_[i][j].color_;
dest += sizeof(unsigned);
}
if (elementMask_ & MASK_TEXCOORD1)
{
*((Vector2*)dest) = vertices_[i][j].texCoord_;
dest += sizeof(Vector2);
}
if (elementMask_ & MASK_TANGENT)
{
*((Vector4*)dest) = vertices_[i][j].tangent_;
dest += sizeof(Vector4);
}
++vertexCount;
}
geometries_[i]->SetVertexBuffer(0, vertexBuffer_, elementMask_);
geometries_[i]->SetDrawRange(primitiveTypes_[i], 0, 0, vertexStart, vertexCount);
vertexStart += vertexCount;
}
vertexBuffer_->Unlock();
}
else
LOGERROR("Failed to lock custom geometry vertex buffer");
}
else
{
for (unsigned i = 0; i < geometries_.Size(); ++i)
{
geometries_[i]->SetVertexBuffer(0, vertexBuffer_, elementMask_);
geometries_[i]->SetDrawRange(primitiveTypes_[i], 0, 0, 0, 0);
}
}
vertexBuffer_->ClearDataLost();
}
void CDecalRData::BuildArrays()
{
PROFILE("decal build");
const SDecal& decal = m_Decal->m_Decal;
// TODO: Currently this constructs an axis-aligned bounding rectangle around
// the decal. It would be more efficient for rendering if we excluded tiles
// that are outside the (non-axis-aligned) decal rectangle.
ssize_t i0, j0, i1, j1;
m_Decal->CalcVertexExtents(i0, j0, i1, j1);
// Construct vertex data arrays
CmpPtr<ICmpWaterManager> cmpWaterManager(*g_Game->GetSimulation2(), SYSTEM_ENTITY);
m_Array.SetNumVertices((i1-i0+1)*(j1-j0+1));
m_Array.Layout();
VertexArrayIterator<CVector3D> Position = m_Position.GetIterator<CVector3D>();
VertexArrayIterator<SColor4ub> DiffuseColor = m_DiffuseColor.GetIterator<SColor4ub>();
VertexArrayIterator<float[2]> UV = m_UV.GetIterator<float[2]>();
const CLightEnv& lightEnv = g_Renderer.GetLightEnv();
bool cpuLighting = (g_Renderer.GetRenderPath() == CRenderer::RP_FIXED);
for (ssize_t j = j0; j <= j1; ++j)
{
for (ssize_t i = i0; i <= i1; ++i)
{
CVector3D pos;
m_Decal->m_Terrain->CalcPosition(i, j, pos);
if (decal.m_Floating && cmpWaterManager)
pos.Y = std::max(pos.Y, cmpWaterManager->GetExactWaterLevel(pos.X, pos.Z));
*Position = pos;
++Position;
CVector3D normal;
m_Decal->m_Terrain->CalcNormal(i, j, normal);
*DiffuseColor = cpuLighting ? lightEnv.EvaluateTerrainDiffuseScaled(normal) : lightEnv.EvaluateTerrainDiffuseFactor(normal);
++DiffuseColor;
// Map from world space back into decal texture space
CVector3D inv = m_Decal->GetInvTransform().Transform(pos);
(*UV)[0] = 0.5f + (inv.X - decal.m_OffsetX) / decal.m_SizeX;
(*UV)[1] = 0.5f - (inv.Z - decal.m_OffsetZ) / decal.m_SizeZ; // flip V to match our texture convention
++UV;
}
}
m_Array.Upload();
m_Array.FreeBackingStore();
// Construct index arrays for each terrain tile
m_IndexArray.SetNumVertices((i1-i0)*(j1-j0)*6);
m_IndexArray.Layout();
VertexArrayIterator<u16> Index = m_IndexArray.GetIterator();
u16 base = 0;
ssize_t w = i1-i0+1;
for (ssize_t dj = 0; dj < j1-j0; ++dj)
{
for (ssize_t di = 0; di < i1-i0; ++di)
{
bool dir = m_Decal->m_Terrain->GetTriangulationDir(i0+di, j0+dj);
if (dir)
{
*Index++ = u16(((dj+0)*w+(di+0))+base);
*Index++ = u16(((dj+0)*w+(di+1))+base);
*Index++ = u16(((dj+1)*w+(di+0))+base);
*Index++ = u16(((dj+0)*w+(di+1))+base);
*Index++ = u16(((dj+1)*w+(di+1))+base);
*Index++ = u16(((dj+1)*w+(di+0))+base);
}
else
{
*Index++ = u16(((dj+0)*w+(di+0))+base);
*Index++ = u16(((dj+0)*w+(di+1))+base);
*Index++ = u16(((dj+1)*w+(di+1))+base);
*Index++ = u16(((dj+1)*w+(di+1))+base);
*Index++ = u16(((dj+1)*w+(di+0))+base);
*Index++ = u16(((dj+0)*w+(di+0))+base);
}
}
}
m_IndexArray.Upload();
m_IndexArray.FreeBackingStore();
}
bool CNetTurnManager::Update(float frameLength, size_t maxTurns)
{
m_DeltaTime += frameLength;
// If we haven't reached the next turn yet, do nothing
if (m_DeltaTime < 0)
return false;
NETTURN_LOG((L"Update current=%d ready=%d\n", m_CurrentTurn, m_ReadyTurn));
// Check that the next turn is ready for execution
if (m_ReadyTurn <= m_CurrentTurn)
{
// Oops, we wanted to start the next turn but it's not ready yet -
// there must be too much network lag.
// TODO: complain to the user.
// TODO: send feedback to the server to increase the turn length.
// Reset the next-turn timer to 0 so we try again next update but
// so we don't rush to catch up in subsequent turns.
// TODO: we should do clever rate adjustment instead of just pausing like this.
m_DeltaTime = 0;
return false;
}
maxTurns = std::max((size_t)1, maxTurns); // always do at least one turn
for (size_t i = 0; i < maxTurns; ++i)
{
// Check that we've reached the i'th next turn
if (m_DeltaTime < 0)
break;
// Check that the i'th next turn is still ready
if (m_ReadyTurn <= m_CurrentTurn)
break;
NotifyFinishedOwnCommands(m_CurrentTurn + COMMAND_DELAY);
m_CurrentTurn += 1; // increase the turn number now, so Update can send new commands for a subsequent turn
// Clean up any destroyed entities since the last turn (e.g. placement previews
// or rally point flags generated by the GUI). (Must do this before the time warp
// serialization.)
m_Simulation2.FlushDestroyedEntities();
// Save the current state for rewinding, if enabled
if (m_TimeWarpNumTurns && (m_CurrentTurn % m_TimeWarpNumTurns) == 0)
{
PROFILE("time warp serialization");
std::stringstream stream;
m_Simulation2.SerializeState(stream);
m_TimeWarpStates.push_back(stream.str());
}
// Put all the client commands into a single list, in a globally consistent order
std::vector<SimulationCommand> commands;
for (std::map<u32, std::vector<SimulationCommand> >::iterator it = m_QueuedCommands[0].begin(); it != m_QueuedCommands[0].end(); ++it)
{
commands.insert(commands.end(), it->second.begin(), it->second.end());
}
m_QueuedCommands.pop_front();
m_QueuedCommands.resize(m_QueuedCommands.size() + 1);
m_Replay.Turn(m_CurrentTurn-1, m_TurnLength, commands);
NETTURN_LOG((L"Running %d cmds\n", commands.size()));
m_Simulation2.Update(m_TurnLength, commands);
NotifyFinishedUpdate(m_CurrentTurn);
// Set the time for the next turn update
m_DeltaTime -= m_TurnLength / 1000.f;
}
return true;
}
void CollisionShape::UpdateShape()
{
PROFILE(UpdateCollisionShape);
ReleaseShape();
if (!physicsWorld_)
return;
if (node_)
{
Vector3 newWorldScale = node_->GetWorldScale();
switch (shapeType_)
{
case SHAPE_BOX:
shape_ = new btBoxShape(ToBtVector3(size_ * 0.5f));
shape_->setLocalScaling(ToBtVector3(newWorldScale));
break;
case SHAPE_SPHERE:
shape_ = new btSphereShape(size_.x_ * 0.5f);
shape_->setLocalScaling(ToBtVector3(newWorldScale));
break;
case SHAPE_STATICPLANE:
shape_ = new btStaticPlaneShape(btVector3(0.0f, 1.0f, 0.0f), 0.0f);
break;
case SHAPE_CYLINDER:
shape_ = new btCylinderShape(btVector3(size_.x_ * 0.5f, size_.y_ * 0.5f, size_.x_ * 0.5f));
shape_->setLocalScaling(ToBtVector3(newWorldScale));
break;
case SHAPE_CAPSULE:
shape_ = new btCapsuleShape(size_.x_ * 0.5f, Max(size_.y_ - size_.x_, 0.0f));
shape_->setLocalScaling(ToBtVector3(newWorldScale));
break;
case SHAPE_CONE:
shape_ = new btConeShape(size_.x_ * 0.5f, size_.y_);
shape_->setLocalScaling(ToBtVector3(newWorldScale));
break;
case SHAPE_TRIANGLEMESH:
size_ = size_.Abs();
if (model_)
{
// Check the geometry cache
Pair<Model*, unsigned> id = MakePair(model_.Get(), lodLevel_);
HashMap<Pair<Model*, unsigned>, SharedPtr<CollisionGeometryData> >& cache = physicsWorld_->GetTriMeshCache();
HashMap<Pair<Model*, unsigned>, SharedPtr<CollisionGeometryData> >::Iterator j = cache.Find(id);
if (j != cache.End())
geometry_ = j->second_;
else
{
geometry_ = new TriangleMeshData(model_, lodLevel_);
// Check if model has dynamic buffers, do not cache in that case
if (!HasDynamicBuffers(model_, lodLevel_))
cache[id] = geometry_;
}
TriangleMeshData* triMesh = static_cast<TriangleMeshData*>(geometry_.Get());
shape_ = new btScaledBvhTriangleMeshShape(triMesh->shape_, ToBtVector3(newWorldScale * size_));
// Watch for live reloads of the collision model to reload the geometry if necessary
SubscribeToEvent(model_, E_RELOADFINISHED, HANDLER(CollisionShape, HandleModelReloadFinished));
}
break;
case SHAPE_CONVEXHULL:
size_ = size_.Abs();
if (customGeometryID_ && GetScene())
{
Node* node = GetScene()->GetNode(customGeometryID_);
CustomGeometry* custom = node ? node->GetComponent<CustomGeometry>() : 0;
if (custom)
{
geometry_ = new ConvexData(custom);
ConvexData* convex = static_cast<ConvexData*>(geometry_.Get());
shape_ = new btConvexHullShape((btScalar*)convex->vertexData_.Get(), convex->vertexCount_, sizeof(Vector3));
shape_->setLocalScaling(ToBtVector3(newWorldScale * size_));
LOGINFO("Set convexhull from customgeometry");
}
else
LOGWARNING("Could not find custom geometry component from node ID " + String(customGeometryID_) + " for convex shape creation");
}
else if (model_)
{
// Check the geometry cache
Pair<Model*, unsigned> id = MakePair(model_.Get(), lodLevel_);
HashMap<Pair<Model*, unsigned>, SharedPtr<CollisionGeometryData> >& cache = physicsWorld_->GetConvexCache();
HashMap<Pair<Model*, unsigned>, SharedPtr<CollisionGeometryData> >::Iterator j = cache.Find(id);
if (j != cache.End())
geometry_ = j->second_;
else
{
geometry_ = new ConvexData(model_, lodLevel_);
// Check if model has dynamic buffers, do not cache in that case
if (!HasDynamicBuffers(model_, lodLevel_))
cache[id] = geometry_;
}
ConvexData* convex = static_cast<ConvexData*>(geometry_.Get());
shape_ = new btConvexHullShape((btScalar*)convex->vertexData_.Get(), convex->vertexCount_, sizeof(Vector3));
shape_->setLocalScaling(ToBtVector3(newWorldScale * size_));
SubscribeToEvent(model_, E_RELOADFINISHED, HANDLER(CollisionShape, HandleModelReloadFinished));
}
break;
case SHAPE_TERRAIN:
size_ = size_.Abs();
{
Terrain* terrain = GetComponent<Terrain>();
if (terrain && terrain->GetHeightData())
{
geometry_ = new HeightfieldData(terrain);
HeightfieldData* heightfield = static_cast<HeightfieldData*>(geometry_.Get());
shape_ = new btHeightfieldTerrainShape(heightfield->size_.x_, heightfield->size_.y_,
heightfield->heightData_.Get(), 1.0f, heightfield->minHeight_, heightfield->maxHeight_, 1, PHY_FLOAT,
false);
shape_->setLocalScaling(ToBtVector3(Vector3(heightfield->spacing_.x_, 1.0f, heightfield->spacing_.z_) *
newWorldScale * size_));
}
}
break;
default:
break;
}
if (shape_)
{
shape_->setUserPointer(this);
shape_->setMargin(margin_);
}
cachedWorldScale_ = newWorldScale;
}
if (physicsWorld_)
physicsWorld_->CleanupGeometryCache();
recreateShape_ = false;
}
bool UiModule::HandleEvent(event_category_id_t category_id, event_id_t event_id, Foundation::EventDataInterface* data)
{
PROFILE(UiModule_HandleEvent);
QString category = service_category_identifiers_.keys().value(service_category_identifiers_.values().indexOf(category_id));
if (category == "Framework")
{
switch (event_id)
{
case Foundation::NETWORKING_REGISTERED:
{
if (!event_query_categories_.contains("NetworkState"))
event_query_categories_ << "NetworkState";
SubscribeToEventCategories();
break;
}
case Foundation::WORLD_STREAM_READY:
{
ProtocolUtilities::WorldStreamReadyEvent *event_data = dynamic_cast<ProtocolUtilities::WorldStreamReadyEvent *>(data);
if (event_data)
current_world_stream_ = event_data->WorldStream;
break;
}
default:
break;
}
}
else if (category == "NetworkState")
{
switch (event_id)
{
case ProtocolUtilities::Events::EVENT_CONNECTION_FAILED:
{
PublishConnectionState(Failed);
break;
}
case ProtocolUtilities::Events::EVENT_SERVER_DISCONNECTED:
{
PublishConnectionState(Disconnected);
break;
}
case ProtocolUtilities::Events::EVENT_SERVER_CONNECTED:
{
// Udp connection has been established, we are still loading object so lets not change UI layer yet
// to connected state. See Scene categorys EVENT_CONTROLLABLE_ENTITY case for real UI switch.
break;
}
default:
break;
}
}
else if (category == "Console")
{
switch (event_id)
{
case Console::Events::EVENT_CONSOLE_TOGGLE:
{
ui_console_manager_->ToggleConsole();
break;
}
case Console::Events::EVENT_CONSOLE_PRINT_LINE:
{
Console::ConsoleEventData* console_data=dynamic_cast<Console::ConsoleEventData*>(data);
ui_console_manager_->QueuePrintRequest(QString(console_data->message.c_str()));
break;
}
default:
break;
}
}
else if (category == "Scene")
{
switch (event_id)
{
case Scene::Events::EVENT_CONTROLLABLE_ENTITY:
{
PublishConnectionState(Connected);
break;
}
default:
break;
}
}
return false;
}
int av_vdpau_get_profile(AVCodecContext *avctx, VdpDecoderProfile *profile)
{
#define PROFILE(prof) \
do { \
*profile = prof; \
return 0; \
} while (0)
switch (avctx->codec_id) {
case AV_CODEC_ID_MPEG1VIDEO: PROFILE(VDP_DECODER_PROFILE_MPEG1);
case AV_CODEC_ID_MPEG2VIDEO:
switch (avctx->profile) {
case FF_PROFILE_MPEG2_MAIN: PROFILE(VDP_DECODER_PROFILE_MPEG2_MAIN);
case FF_PROFILE_MPEG2_SIMPLE: PROFILE(VDP_DECODER_PROFILE_MPEG2_SIMPLE);
default: return AVERROR(EINVAL);
}
case AV_CODEC_ID_H263: PROFILE(VDP_DECODER_PROFILE_MPEG4_PART2_ASP);
case AV_CODEC_ID_MPEG4:
switch (avctx->profile) {
case FF_PROFILE_MPEG4_SIMPLE: PROFILE(VDP_DECODER_PROFILE_MPEG4_PART2_SP);
case FF_PROFILE_MPEG4_ADVANCED_SIMPLE: PROFILE(VDP_DECODER_PROFILE_MPEG4_PART2_ASP);
default: return AVERROR(EINVAL);
}
case AV_CODEC_ID_H264:
switch (avctx->profile) {
case FF_PROFILE_H264_CONSTRAINED_BASELINE:
case FF_PROFILE_H264_BASELINE: PROFILE(VDP_DECODER_PROFILE_H264_BASELINE);
case FF_PROFILE_H264_MAIN: PROFILE(VDP_DECODER_PROFILE_H264_MAIN);
case FF_PROFILE_H264_HIGH: PROFILE(VDP_DECODER_PROFILE_H264_HIGH);
default: return AVERROR(EINVAL);
}
case AV_CODEC_ID_WMV3:
case AV_CODEC_ID_VC1:
switch (avctx->profile) {
case FF_PROFILE_VC1_SIMPLE: PROFILE(VDP_DECODER_PROFILE_VC1_SIMPLE);
case FF_PROFILE_VC1_MAIN: PROFILE(VDP_DECODER_PROFILE_VC1_MAIN);
case FF_PROFILE_VC1_ADVANCED: PROFILE(VDP_DECODER_PROFILE_VC1_ADVANCED);
default: return AVERROR(EINVAL);
}
}
return AVERROR(EINVAL);
}
void Constraint::CreateConstraint()
{
PROFILE(CreateConstraint);
cachedWorldScale_ = node_->GetWorldScale();
ReleaseConstraint();
ownBody_ = GetComponent<RigidBody>();
btRigidBody* ownBody = ownBody_ ? ownBody_->GetBody() : 0;
btRigidBody* otherBody = otherBody_ ? otherBody_->GetBody() : 0;
// If no physics world available now mark for retry later
if (!physicsWorld_ || !ownBody)
{
retryCreation_ = true;
return;
}
if (!otherBody)
otherBody = &btTypedConstraint::getFixedBody();
Vector3 ownBodyScaledPosition = position_ * cachedWorldScale_ - ownBody_->GetCenterOfMass();
Vector3 otherBodyScaledPosition = otherBody_ ? otherPosition_ * otherBody_->GetNode()->GetWorldScale() -
otherBody_->GetCenterOfMass() : otherPosition_;
switch (constraintType_)
{
case CONSTRAINT_POINT:
{
constraint_ = new btPoint2PointConstraint(*ownBody, *otherBody, ToBtVector3(ownBodyScaledPosition),
ToBtVector3(otherBodyScaledPosition));
}
break;
case CONSTRAINT_HINGE:
{
btTransform ownFrame(ToBtQuaternion(rotation_), ToBtVector3(ownBodyScaledPosition));
btTransform otherFrame(ToBtQuaternion(otherRotation_), ToBtVector3(otherBodyScaledPosition));
constraint_ = new btHingeConstraint(*ownBody, *otherBody, ownFrame, otherFrame);
}
break;
case CONSTRAINT_SLIDER:
{
btTransform ownFrame(ToBtQuaternion(rotation_), ToBtVector3(ownBodyScaledPosition));
btTransform otherFrame(ToBtQuaternion(otherRotation_), ToBtVector3(otherBodyScaledPosition));
constraint_ = new btSliderConstraint(*ownBody, *otherBody, ownFrame, otherFrame, false);
}
break;
case CONSTRAINT_CONETWIST:
{
btTransform ownFrame(ToBtQuaternion(rotation_), ToBtVector3(ownBodyScaledPosition));
btTransform otherFrame(ToBtQuaternion(otherRotation_), ToBtVector3(otherBodyScaledPosition));
constraint_ = new btConeTwistConstraint(*ownBody, *otherBody, ownFrame, otherFrame);
}
break;
default:
break;
}
if (constraint_)
{
constraint_->setUserConstraintPtr(this);
constraint_->setEnabled(IsEnabledEffective());
ownBody_->AddConstraint(this);
if (otherBody_)
otherBody_->AddConstraint(this);
ApplyLimits();
physicsWorld_->GetWorld()->addConstraint(constraint_, disableCollision_);
}
recreateConstraint_ = false;
framesDirty_ = false;
retryCreation_ = false;
}
void OgreMeshAsset::CreateKdTree()
{
meshData.Clear();
normals.clear();
uvs.clear();
subMeshTriangleCounts.clear();
for(unsigned short i = 0; i < ogreMesh->getNumSubMeshes(); ++i)
{
Ogre::SubMesh *submesh = ogreMesh->getSubMesh(i);
assert(submesh);
Ogre::VertexData *vertexData = submesh->useSharedVertices ? ogreMesh->sharedVertexData : submesh->vertexData;
assert(vertexData);
const Ogre::VertexElement *posElem = vertexData->vertexDeclaration->findElementBySemantic(Ogre::VES_POSITION);
if (!posElem)
{
subMeshTriangleCounts.push_back(0);
continue; // No position element. Ignore this submesh.
}
Ogre::HardwareVertexBufferSharedPtr vbufPos = vertexData->vertexBufferBinding->getBuffer(posElem->getSource());
unsigned char *pos = (unsigned char*)vbufPos->lock(Ogre::HardwareBuffer::HBL_READ_ONLY);
assert(pos);
size_t posOffset = posElem->getOffset();
size_t posSize = vbufPos->getVertexSize();
// Texcoord element is not mandatory
unsigned char *texCoord = 0;
size_t texOffset = 0;
size_t texSize = 0;
Ogre::HardwareVertexBufferSharedPtr vbufTex;
const Ogre::VertexElement *texElem = vertexData->vertexDeclaration->findElementBySemantic(Ogre::VES_TEXTURE_COORDINATES);
if (texElem)
{
vbufTex = vertexData->vertexBufferBinding->getBuffer(texElem->getSource());
// Check if the texcoord buffer is different than the position buffer, in that case lock it separately
if (vbufTex != vbufPos)
texCoord = static_cast<unsigned char*>(vbufTex->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
else
texCoord = pos;
texOffset = texElem->getOffset();
texSize = vbufTex->getVertexSize();
}
Ogre::IndexData *indexData = submesh->indexData;
Ogre::HardwareIndexBufferSharedPtr ibuf = indexData->indexBuffer;
u32 *pLong = (u32*)ibuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY);
u16 *pShort = (u16*)pLong;
const bool use32BitIndices = (ibuf->getType() == Ogre::HardwareIndexBuffer::IT_32BIT);
for(unsigned j = 0; j+2 < indexData->indexCount; j += 3)
{
unsigned i0, i1, i2;
if (use32BitIndices)
{
i0 = pLong[j];
i1 = pLong[j+1];
i2 = pLong[j+2];
}
else
{
i0 = pShort[j];
i1 = pShort[j+1];
i2 = pShort[j+2];
}
float3 v0 = *(float3*)(pos + posOffset + i0 * posSize);
float3 v1 = *(float3*)(pos + posOffset + i1 * posSize);
float3 v2 = *(float3*)(pos + posOffset + i2 * posSize);
Triangle t(v0, v1, v2);
meshData.AddObjects(&t, 1);
if (texElem)
{
uvs.push_back(*((float2*)(texCoord + texOffset + i0 * texSize)));
uvs.push_back(*((float2*)(texCoord + texOffset + i1 * texSize)));
uvs.push_back(*((float2*)(texCoord + texOffset + i2 * texSize)));
}
float3 edge1 = v1 - v0;
float3 edge2 = v2 - v0;
float3 normal = edge1.Cross(edge2);
normal.Normalize();
normals.push_back(normal);
}
subMeshTriangleCounts.push_back((int)(indexData->indexCount / 3));
vbufPos->unlock();
if (!vbufTex.isNull() && vbufTex != vbufPos)
vbufTex->unlock();
ibuf->unlock();
}
{
PROFILE(OgreMeshAsset_KdTree_Build);
meshData.Build();
}
}
//------------------------------------------------------------------------------------------------------
//
// FUNCTION: GetHotKeyInt(TCHAR* pszHotKeyVal)
//
// PURPOSE : returns either the integer value of the keyboard mapping for the hot key or -1 if it
// doesn't exist.
//
//------------------------------------------------------------------------------------------------------
int CvXMLLoadUtility::GetHotKeyInt(const TCHAR* pszHotKeyVal)
{
// SPEEDUP
PROFILE("GetHotKeyInt");
int i;
struct CvKeyBoardMapping
{
TCHAR szDefineString[25];
int iIntVal;
};
const int iNumKeyBoardMappings=108;
const CvKeyBoardMapping asCvKeyBoardMapping[iNumKeyBoardMappings] =
{
{"KB_ESCAPE",FInputDevice::KB_ESCAPE},
{"KB_0",FInputDevice::KB_0},
{"KB_1",FInputDevice::KB_1},
{"KB_2",FInputDevice::KB_2},
{"KB_3",FInputDevice::KB_3},
{"KB_4",FInputDevice::KB_4},
{"KB_5",FInputDevice::KB_5},
{"KB_6",FInputDevice::KB_6},
{"KB_7",FInputDevice::KB_7},
{"KB_8",FInputDevice::KB_8},
{"KB_9",FInputDevice::KB_9},
{"KB_MINUS",FInputDevice::KB_MINUS}, /* - on main keyboard */
{"KB_A",FInputDevice::KB_A},
{"KB_B",FInputDevice::KB_B},
{"KB_C",FInputDevice::KB_C},
{"KB_D",FInputDevice::KB_D},
{"KB_E",FInputDevice::KB_E},
{"KB_F",FInputDevice::KB_F},
{"KB_G",FInputDevice::KB_G},
{"KB_H",FInputDevice::KB_H},
{"KB_I",FInputDevice::KB_I},
{"KB_J",FInputDevice::KB_J},
{"KB_K",FInputDevice::KB_K},
{"KB_L",FInputDevice::KB_L},
{"KB_M",FInputDevice::KB_M},
{"KB_N",FInputDevice::KB_N},
{"KB_O",FInputDevice::KB_O},
{"KB_P",FInputDevice::KB_P},
{"KB_Q",FInputDevice::KB_Q},
{"KB_R",FInputDevice::KB_R},
{"KB_S",FInputDevice::KB_S},
{"KB_T",FInputDevice::KB_T},
{"KB_U",FInputDevice::KB_U},
{"KB_V",FInputDevice::KB_V},
{"KB_W",FInputDevice::KB_W},
{"KB_X",FInputDevice::KB_X},
{"KB_Y",FInputDevice::KB_Y},
{"KB_Z",FInputDevice::KB_Z},
{"KB_EQUALS",FInputDevice::KB_EQUALS},
{"KB_BACKSPACE",FInputDevice::KB_BACKSPACE},
{"KB_TAB",FInputDevice::KB_TAB},
{"KB_LBRACKET",FInputDevice::KB_LBRACKET},
{"KB_RBRACKET",FInputDevice::KB_RBRACKET},
{"KB_RETURN",FInputDevice::KB_RETURN}, /* Enter on main keyboard */
{"KB_LCONTROL",FInputDevice::KB_LCONTROL},
{"KB_SEMICOLON",FInputDevice::KB_SEMICOLON},
{"KB_APOSTROPHE",FInputDevice::KB_APOSTROPHE},
{"KB_GRAVE",FInputDevice::KB_GRAVE}, /* accent grave */
{"KB_LSHIFT",FInputDevice::KB_LSHIFT},
{"KB_BACKSLASH",FInputDevice::KB_BACKSLASH},
{"KB_COMMA",FInputDevice::KB_COMMA},
{"KB_PERIOD",FInputDevice::KB_PERIOD},
{"KB_SLASH",FInputDevice::KB_SLASH},
{"KB_RSHIFT",FInputDevice::KB_RSHIFT},
{"KB_NUMPADSTAR",FInputDevice::KB_NUMPADSTAR},
{"KB_LALT",FInputDevice::KB_LALT},
{"KB_SPACE",FInputDevice::KB_SPACE},
{"KB_CAPSLOCK",FInputDevice::KB_CAPSLOCK},
{"KB_F1",FInputDevice::KB_F1},
{"KB_F2",FInputDevice::KB_F2},
{"KB_F3",FInputDevice::KB_F3},
{"KB_F4",FInputDevice::KB_F4},
{"KB_F5",FInputDevice::KB_F5},
{"KB_F6",FInputDevice::KB_F6},
{"KB_F7",FInputDevice::KB_F7},
{"KB_F8",FInputDevice::KB_F8},
{"KB_F9",FInputDevice::KB_F9},
{"KB_F10",FInputDevice::KB_F10},
{"KB_NUMLOCK",FInputDevice::KB_NUMLOCK},
{"KB_SCROLL",FInputDevice::KB_SCROLL},
{"KB_NUMPAD7",FInputDevice::KB_NUMPAD7},
{"KB_NUMPAD8",FInputDevice::KB_NUMPAD8},
{"KB_NUMPAD9",FInputDevice::KB_NUMPAD9},
{"KB_NUMPADMINUS",FInputDevice::KB_NUMPADMINUS},
{"KB_NUMPAD4",FInputDevice::KB_NUMPAD4},
{"KB_NUMPAD5",FInputDevice::KB_NUMPAD5},
{"KB_NUMPAD6",FInputDevice::KB_NUMPAD6},
{"KB_NUMPADPLUS",FInputDevice::KB_NUMPADPLUS},
{"KB_NUMPAD1",FInputDevice::KB_NUMPAD1},
{"KB_NUMPAD2",FInputDevice::KB_NUMPAD2},
{"KB_NUMPAD3",FInputDevice::KB_NUMPAD3},
{"KB_NUMPAD0",FInputDevice::KB_NUMPAD0},
{"KB_NUMPADPERIOD",FInputDevice::KB_NUMPADPERIOD},
{"KB_F11",FInputDevice::KB_F11},
{"KB_F12",FInputDevice::KB_F12},
{"KB_NUMPADEQUALS",FInputDevice::KB_NUMPADEQUALS},
{"KB_AT",FInputDevice::KB_AT},
{"KB_UNDERLINE",FInputDevice::KB_UNDERLINE},
{"KB_COLON",FInputDevice::KB_COLON},
{"KB_NUMPADENTER",FInputDevice::KB_NUMPADENTER},
{"KB_RCONTROL",FInputDevice::KB_RCONTROL},
{"KB_VOLUMEDOWN",FInputDevice::KB_VOLUMEDOWN},
{"KB_VOLUMEUP",FInputDevice::KB_VOLUMEUP},
{"KB_NUMPADCOMMA",FInputDevice::KB_NUMPADCOMMA},
{"KB_NUMPADSLASH",FInputDevice::KB_NUMPADSLASH},
{"KB_SYSRQ",FInputDevice::KB_SYSRQ},
{"KB_RALT",FInputDevice::KB_RALT},
{"KB_PAUSE",FInputDevice::KB_PAUSE},
{"KB_HOME",FInputDevice::KB_HOME},
{"KB_UP",FInputDevice::KB_UP},
{"KB_PGUP",FInputDevice::KB_PGUP},
{"KB_LEFT",FInputDevice::KB_LEFT},
{"KB_RIGHT",FInputDevice::KB_RIGHT},
{"KB_END",FInputDevice::KB_END},
{"KB_DOWN",FInputDevice::KB_DOWN},
{"KB_PGDN",FInputDevice::KB_PGDN},
{"KB_INSERT",FInputDevice::KB_INSERT},
{"KB_DELETE",FInputDevice::KB_DELETE},
};
for (i=0;i<iNumKeyBoardMappings;i++)
{
if (strcmp(asCvKeyBoardMapping [i].szDefineString, pszHotKeyVal) == 0)
{
return asCvKeyBoardMapping[i].iIntVal;
}
}
return -1;
}
bool OgreMeshAsset::DeserializeFromData(const u8 *data_, size_t numBytes, bool allowAsynchronous)
{
PROFILE(OgreMeshAsset_LoadFromFileInMemory);
/// Force an unload of this data first.
Unload();
/// @todo Duplicate allowAsynchronous code in OgreMeshAsset and TextureAsset.
if ((OGRE_THREAD_SUPPORT == 0) || !assetAPI->Cache() || assetAPI->IsHeadless() || IsAssimpFileType() ||
assetAPI->GetFramework()->HasCommandLineParameter("--noAsyncAssetLoad") ||
assetAPI->GetFramework()->HasCommandLineParameter("--no_async_asset_load")) /**< @todo Remove support for the deprecated underscore version at some point. */
{
allowAsynchronous = false;
}
QString cacheDiskSource;
if (allowAsynchronous)
{
cacheDiskSource = assetAPI->Cache()->FindInCache(Name());
if (cacheDiskSource.isEmpty())
allowAsynchronous = false;
}
// Asynchronous loading
// 1. AssetAPI allows a asynch load. This is false when called from LoadFromFile(), LoadFromCache() etc.
// 2. We have a rendering window for Ogre as Ogre::ResourceBackgroundQueue does not work otherwise. Its not properly initialized without a rendering window.
// 3. The Ogre we are building against has thread support.
if (allowAsynchronous)
{
// We can only do threaded loading from disk, and not any disk location but only from asset cache.
// local:// refs will return empty string here and those will fall back to the non-threaded loading.
// Do not change this to do DiskCache() as that directory for local:// refs will not be a known resource location for ogre.
QFileInfo fileInfo(cacheDiskSource);
std::string sanitatedAssetRef = fileInfo.fileName().toStdString();
//! \todo - Should we set this somewhere for async path?: ogreMesh->setAutoBuildEdgeLists(false);
loadTicket_ = Ogre::ResourceBackgroundQueue::getSingleton().load(Ogre::MeshManager::getSingleton().getResourceType(),
sanitatedAssetRef, OgreRenderer::OgreRenderingModule::CACHE_RESOURCE_GROUP, false, 0, 0, this);
return true;
}
if (!data_)
{
LogError("OgreMeshAsset::DeserializeFromData: Cannot deserialize from null input data");
return false;
}
// Synchronous loading
if (ogreMesh.isNull())
{
ogreMesh = Ogre::MeshManager::getSingleton().createManual(
AssetAPI::SanitateAssetRef(this->Name()).toStdString(), Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
if (ogreMesh.isNull())
{
LogError("OgreMeshAsset::DeserializeFromData: Failed to create mesh " + Name());
return false;
}
ogreMesh->setAutoBuildEdgeLists(false);
}
// Convert file to Ogre mesh using assimp
if (IsAssimpFileType())
{
#ifdef ASSIMP_ENABLED
emit ExternalConversionRequested(this, data_, numBytes);
return true;
#else
LogError(QString("OgreMeshAsset::DeserializeFromData: cannot convert " + Name() + " to Ogre mesh. OpenAssetImport is not enabled."));
return false;
#endif
}
try
{
std::vector<u8> tempData(data_, data_ + numBytes);
#include "DisableMemoryLeakCheck.h"
Ogre::DataStreamPtr stream(new Ogre::MemoryDataStream((void*)&tempData[0], numBytes, false));
#include "EnableMemoryLeakCheck.h"
Ogre::MeshSerializer serializer;
serializer.importMesh(stream, ogreMesh.getPointer()); // Note: importMesh *adds* submeshes to an existing mesh. It doesn't replace old ones.
}
catch (Ogre::Exception &e)
{
LogError(QString("OgreMeshAsset::DeserializeFromData: Ogre::MeshSerializer::importMesh failed when loading asset '" + Name() + "': ") + e.what());
if(IsAssimpFileType())
LogError(QString("OgreMeshAsset::DeserializeFromData: cannot convert " + Name() + " to Ogre mesh. OpenAssetImport is not enabled."));
return false;
}
if (GenerateMeshData())
{
// We did a synchronous load, must call AssetLoadCompleted here.
assetAPI->AssetLoadCompleted(Name());
return true;
}
else
return false;
}
