void writeString( const std::string& sKey, const std::string& sData ) { Key( sKey ).writeString( sData ); }
void ListGroups(bool bDetailed = false) { for (auto It = HighPerformanceEnable.CreateConstIterator(); It; ++It) { UE_LOG(LogStatGroupEnableManager, Display, TEXT(" %d default %d %s"), !!It.Value().CurrentEnable, !!It.Value().DefaultEnable, *(It.Key().ToString())); if (bDetailed) { for (auto ItInner = It.Value().NamesInThisGroup.CreateConstIterator(); ItInner; ++ItInner) { UE_LOG(LogStatGroupEnableManager, Display, TEXT(" %d %s"), !ItInner.Value()->IsNone(), *ItInner.Key().ToString()); } for( auto ItInner = It.Value().AlwaysEnabledNamesInThisGroup.CreateConstIterator(); ItInner; ++ItInner ) { UE_LOG( LogStatGroupEnableManager, Display, TEXT( " (always enabled) %s" ), *ItInner.Key().ToString() ); } } } }
FgKeepBest() : m_valid(false), m_key(Key()), // Avoid initialization warnings m_val(Val()) {}
Key Key::int_key (int key) { int id = int_key_map.add_name (key, key); dl_assert (id != -1, "bug"); Key res = Key (id * 2 + 1); return res; }
void USkeletalMeshComponent::TickAnimation(float DeltaTime) { SCOPE_CYCLE_COUNTER(STAT_AnimTickTime); if (SkeletalMesh != NULL) { if (AnimScriptInstance != NULL) { // Tick the animation AnimScriptInstance->UpdateAnimation(DeltaTime * GlobalAnimRateScale); // TODO @LinaH - I've hit access violations due to AnimScriptInstance being NULL after this, probably due to // AnimNotifies? Please take a look and fix as we discussed. Temporary fix: if (AnimScriptInstance != NULL) { // now all tick/trigger/kismet is done // add MorphTarget Curves from Kismet driven or any other source // and overwrite if it exists // Tick always should maintain this list, not Evaluate for( auto Iter = MorphTargetCurves.CreateConstIterator(); Iter; ++Iter ) { float *CurveValPtr = AnimScriptInstance->MorphTargetCurves.Find(Iter.Key()); if ( CurveValPtr ) { // override the value if Kismet request was made *CurveValPtr = Iter.Value(); } else { AnimScriptInstance->MorphTargetCurves.Add(Iter.Key(), Iter.Value()); } } //Update material parameters if(AnimScriptInstance->MaterialParameterCurves.Num() > 0) { for( auto Iter = AnimScriptInstance->MaterialParameterCurves.CreateConstIterator(); Iter; ++Iter ) { FName ParameterName = Iter.Key(); float ParameterValue = Iter.Value(); for(int32 MaterialIndex = 0; MaterialIndex < GetNumMaterials(); ++MaterialIndex) { UMaterialInterface* MaterialInterface = GetMaterial(MaterialIndex); if (MaterialInterface) { float TestValue; //not used but needed for GetScalarParameterValue call if(MaterialInterface->GetScalarParameterValue(ParameterName,TestValue)) { UMaterialInstanceDynamic* DynamicMaterial = Cast<UMaterialInstanceDynamic>(MaterialInterface); if(!DynamicMaterial) //Is it already a UMaterialInstanceDynamic (ie we used it last tick) { DynamicMaterial = CreateAndSetMaterialInstanceDynamic(MaterialIndex); } DynamicMaterial->SetScalarParameterValue(ParameterName, ParameterValue); //Assume that we only set the parameter on one of the materials, remove this break //if that is no longer desired break; } } } } } } } } }
static bool UpdateCachedLocalizationStates(const TMap<FLocalizationServiceTranslationIdentifier, TSharedRef<FOneSkyLocalizationServiceState, ESPMode::ThreadSafe>, FDefaultSetAllocator, FLocalizationServiceTranslationIdentifierKeyFuncs<TSharedRef<FOneSkyLocalizationServiceState, ESPMode::ThreadSafe>>>& InResults) { FOneSkyLocalizationServiceModule& OneSkyLocalizationService = FOneSkyLocalizationServiceModule::Get(); for (auto It = InResults.CreateConstIterator(); It; ++It) { TSharedRef<FOneSkyLocalizationServiceState, ESPMode::ThreadSafe> State = OneSkyLocalizationService.GetProvider().GetStateInternal(It.Key()); State->SetState(It.Value()->GetState()); State->SetTranslation(It.Value()->GetTranslationString()); State->TimeStamp = FDateTime::Now(); } return InResults.Num() > 0; }
Key Key::any_key() { return Key (0); }
/* ==================== Load ==================== */ VOID EChunk::Load(const VOID* data) { GUARD(EChunk::Load); // build the vertex buffer mVBPtr = GNEW(VertexBuffer); CHECK(mVBPtr); { DVT vertexes[] = { {0.0, 0.0, 0.0, 0.0, 1.0}, {CHUNK_STRIDE, 0.0, 0.0, 1.0, 1.0}, {CHUNK_STRIDE, CHUNK_STRIDE, 0.0, 1.0, 0.0}, {0.0, CHUNK_STRIDE, 0.0, 0.0, 0.0}, }; GDataPtr vd_ptr = GNEW(GData); CHECK(vd_ptr); vd_ptr->Size(3*sizeof(U32) + 3*sizeof(U8) + sizeof(vertexes)); U8*data_ptr = (U8*)vd_ptr->Ptr(); *(U32*)data_ptr = MAKEFOURCC('G','V','B','O'); data_ptr += sizeof(U32); *(U32*)data_ptr = sizeof(vertexes)/sizeof(DVT); data_ptr += sizeof(U32); *(U32*)data_ptr = sizeof(DVT); data_ptr += sizeof(U32); *(U8*)data_ptr = 2; data_ptr += sizeof(U8); *(U8*)data_ptr = VertexBuffer::VT_3F; data_ptr += sizeof(U8); *(U8*)data_ptr = VertexBuffer::VT_2F; data_ptr += sizeof(U8); ::memcpy(data_ptr, vertexes, sizeof(vertexes)); data_ptr += sizeof(vertexes); mVBPtr->Load(vd_ptr.Ptr()); } // build the index mIBPtr = GNEW(IndexBuffer); CHECK(mIBPtr); { const U16 indexes[] = { 3, 0, 2, 2, 0, 1 }; GDataPtr id_ptr = GNEW(GData); CHECK(id_ptr); id_ptr->Size(3*sizeof(U32) + sizeof(indexes)); U8*data_ptr = (U8*)id_ptr->Ptr(); *(U32*)data_ptr = MAKEFOURCC('G','I','B','O'); data_ptr += sizeof(U32); *(U32*)data_ptr = sizeof(indexes)/sizeof(U16); data_ptr += sizeof(U32); *(U32*)data_ptr = sizeof(U16); data_ptr += sizeof(U32); ::memcpy(data_ptr, indexes, sizeof(indexes)); data_ptr += sizeof(indexes); mIBPtr->Load(id_ptr.Ptr()); } // build the shaders Str shader_name = "shader/chunk.xml"; mShaderKey = Key::Find(shader_name.c_str()); if(mShaderKey == NULL) { Shader*shader = GNEW(Shader); CHECK(shader); shader->Load(GLoad(shader_name.c_str())); mShaderKey = GNEW(Key(shader_name.c_str(), shader)); CHECK(mShaderKey); } // load the data U8*data_ptr = (U8*)data; // check the chunk header CHECK(*(U32*)data_ptr == (MAKEFOURCC('G','C','H','K'))); data_ptr += sizeof(U32); // get the layer U32 num_layer = *(U32*)data_ptr; data_ptr += sizeof(U32); for(U32 k = 0; k < num_layer; k++) { Layer layer; layer.total = 0; // get the primitive layer.primitive = GNEW(Primitive); CHECK(layer.primitive); layer.primitive->SetType(Primitive::PT_TRIANGLES); layer.primitive->SetVertexBuffer(mVBPtr.Ptr()); layer.primitive->SetIndexBuffer(mIBPtr.Ptr()); layer.primitive->SetConstant("gWVP",GNEW(Constant(Matrix()))); // get the color texture Str texture_name; U32 len = *(U32*)data_ptr; data_ptr += sizeof(U32); texture_name.resize(len, 0); memcpy(&texture_name[0], data_ptr, len*sizeof(CHAR)); data_ptr += len*sizeof(CHAR); KeyPtr texture_key_ptr = Key::Find(texture_name.c_str()); if(texture_key_ptr == NULL) { const Image* image = Image::Load(GLoad(texture_name.c_str())); CHECK(image); BaseTexture* base_texture = GNEW(Texture); CHECK(base_texture); base_texture->Load(image); texture_key_ptr = GNEW(Key(texture_name.c_str(), base_texture)); CHECK(texture_key_ptr); } mKeys.push_back(texture_key_ptr); layer.primitive->SetConstant("gColorTex",GNEW(Constant((BaseTexture*)texture_key_ptr->Ptr()))); layer.name = texture_name; // get the scale st F32 s = *(F32*)data_ptr; data_ptr += sizeof(F32); F32 t = *(F32*)data_ptr; data_ptr += sizeof(F32); layer.primitive->SetConstant("gScaleST",GNEW(Constant(Vector4(s,t,0,0)))); layer.st.set(s, t); // get the alpha U32 width = *(U32*)data_ptr; data_ptr += sizeof(U32); U32 height = *(U32*)data_ptr; data_ptr += sizeof(U32); if(width==U2P(ALPHA_STRIDE) && height==U2P(ALPHA_STRIDE)) { layer.alpha.resize(width*height*sizeof(U8)); ::memcpy(&layer.alpha[0], data_ptr, width*height*sizeof(U8)); data_ptr += width*height*sizeof(U8); } else { U8 alpha = *(U8*)data_ptr; data_ptr += sizeof(U8); width = U2P(ALPHA_STRIDE); height = U2P(ALPHA_STRIDE); layer.alpha.resize(width*height*sizeof(U8),alpha); } if(k==0) { mMask.resize(width*height); for(U32 j = 0; j < height; j++) { for( U32 i = 0; i < width; i++) { U8& alpha = layer.alpha[i+j*width]; U8& mask = mMask[i+j*width]; if(alpha <= 127) { alpha = (U8)((F32)alpha/127.0f*255.0f); mask = 0; } else { alpha = (U8)((F32)(alpha-128)/127.0f*255.0f); mask = 1; } layer.total += alpha; } } } else { for(U32 j = 0; j < height; j++) { for( U32 i = 0; i < width; i++) { layer.total += layer.alpha[i+j*width]; } } } BaseTexture *alpha_texture = GNEW(Texture); CHECK(alpha_texture); layer.primitive->SetConstant("gAlphaTex",GNEW(Constant(alpha_texture))); layer.texture = alpha_texture; // load the shader if(k==0) layer.primitive->SetShader(dynamic_cast<Shader*>(mShaderKey->Ptr()), "base"); else layer.primitive->SetShader(dynamic_cast<Shader*>(mShaderKey->Ptr()), "layer"); // add the layer to the table mLayers.push_back(layer); } // update the layer Update(); UNGUARD; }
/* ==================== Find ==================== */ U32 EChunk::Find(const CHAR* name, const Vector2& st) { GUARD(EChunk::Find); CHECK(name); // searche the layer table for(U32 i = 0; i < mLayers.size(); i++) { if(mLayers[i].name == name && mLayers[i].st == st) return i; } // create the new layer Layer layer; layer.name = name; layer.st = st; layer.alpha.resize(U2P(ALPHA_STRIDE)*U2P(ALPHA_STRIDE), 0); layer.total = 0; // create the new primitive layer.primitive = GNEW(Primitive); CHECK(layer.primitive); layer.primitive->SetType(Primitive::PT_TRIANGLES); layer.primitive->SetVertexBuffer(mVBPtr.Ptr()); layer.primitive->SetIndexBuffer(mIBPtr.Ptr()); layer.primitive->SetConstant("gWVP",GNEW(Constant(Matrix()))); // get the color texture KeyPtr texture_key_ptr = Key::Find(name); if(texture_key_ptr == NULL) { const Image* image = Image::Load(GLoad(name)); CHECK(image); BaseTexture* base_texture = GNEW(Texture); CHECK(base_texture); base_texture->Load(image); texture_key_ptr = GNEW(Key(name, base_texture)); CHECK(texture_key_ptr); } mKeys.push_back(texture_key_ptr); layer.primitive->SetConstant("gColorTex",GNEW(Constant((BaseTexture*)texture_key_ptr->Ptr()))); // set the scale st layer.primitive->SetConstant("gScaleST",GNEW(Constant(Vector4(st[0],st[1],0,0)))); // set the alpha U32 width = U2P(ALPHA_STRIDE); U32 height = U2P(ALPHA_STRIDE); Image* image = GNEW(Image); CHECK(image); image->Width(width); image->Height(height); image->PixelFormat(PF_ALPHA); image->DataType(DT_UNSIGNED_BYTE); image->MipmapCount(1); image->Mipmap(0,&layer.alpha[0],width*height*sizeof(U8)); BaseTexture *alpha_texture = GNEW(Texture); CHECK(alpha_texture); alpha_texture->Load(image); layer.primitive->SetConstant("gAlphaTex",GNEW(Constant(alpha_texture))); layer.texture = alpha_texture; // load the shader layer.primitive->SetShader(dynamic_cast<Shader*>(mShaderKey->Ptr()), "layer"); // add the layer to the table mLayers.push_back(layer); return mLayers.size() - 1; UNGUARD; }
std::vector<Key> subKeys( const std::string& sKey ) { return Key( sKey ).subKeys(); }
int readInt( const std::string& sKey ) { return Key( sKey ).readInt(); }
bool keyExists( const std::string& sKey ) { return Key( sKey ).exists(); }
void deepFindData( const char* cszKey, const std::string& sFindValueName, std::vector<std::string>& vsResults ) { deepFindData( Key(cszKey), sFindValueName, vsResults ); }
void writeString( const std::string& sKey, const std::string& sValueName, const std::string& sData ) { Key( sKey ).writeString( sValueName, sData ); }
void FAudioComponentVisualizer::DrawVisualization( const UActorComponent* Component, const FSceneView* View, FPrimitiveDrawInterface* PDI ) { if(View->Family->EngineShowFlags.AudioRadius) { const UAudioComponent* AudioComp = Cast<const UAudioComponent>(Component); if(AudioComp != NULL) { const FTransform& Transform = AudioComp->ComponentToWorld; TMultiMap<EAttenuationShape::Type, FAttenuationSettings::AttenuationShapeDetails> ShapeDetailsMap; AudioComp->CollectAttenuationShapesForVisualization(ShapeDetailsMap); FVector Translation = Transform.GetTranslation(); FVector UnitXAxis = Transform.GetUnitAxis( EAxis::X ); FVector UnitYAxis = Transform.GetUnitAxis( EAxis::Y ); FVector UnitZAxis = Transform.GetUnitAxis( EAxis::Z ); for ( auto It = ShapeDetailsMap.CreateConstIterator(); It; ++It ) { FColor AudioOuterRadiusColor(255, 153, 0); FColor AudioInnerRadiusColor(216, 130, 0); const FAttenuationSettings::AttenuationShapeDetails& ShapeDetails = It.Value(); switch(It.Key()) { case EAttenuationShape::Box: if (ShapeDetails.Falloff > 0.f) { DrawOrientedWireBox( PDI, Translation, UnitXAxis, UnitYAxis, UnitZAxis, ShapeDetails.Extents + FVector(ShapeDetails.Falloff), AudioOuterRadiusColor, SDPG_World); DrawOrientedWireBox( PDI, Translation, UnitXAxis, UnitYAxis, UnitZAxis, ShapeDetails.Extents, AudioInnerRadiusColor, SDPG_World); } else { DrawOrientedWireBox( PDI, Translation, UnitXAxis, UnitYAxis, UnitZAxis, ShapeDetails.Extents, AudioOuterRadiusColor, SDPG_World); } break; case EAttenuationShape::Capsule: if (ShapeDetails.Falloff > 0.f) { DrawWireCapsule( PDI, Translation, UnitXAxis, UnitYAxis, UnitZAxis, AudioOuterRadiusColor, ShapeDetails.Extents.Y + ShapeDetails.Falloff, ShapeDetails.Extents.X + ShapeDetails.Falloff, 25, SDPG_World); DrawWireCapsule( PDI, Translation, UnitXAxis, UnitYAxis, UnitZAxis, AudioInnerRadiusColor, ShapeDetails.Extents.Y, ShapeDetails.Extents.X, 25, SDPG_World); } else { DrawWireCapsule( PDI, Translation, UnitXAxis, UnitYAxis, UnitZAxis, AudioOuterRadiusColor, ShapeDetails.Extents.Y, ShapeDetails.Extents.X, 25, SDPG_World); } break; case EAttenuationShape::Cone: { FTransform Origin = Transform; Origin.SetScale3D(FVector(1.f)); Origin.SetTranslation(Translation - (UnitXAxis * ShapeDetails.ConeOffset)); if (ShapeDetails.Falloff > 0.f || ShapeDetails.Extents.Z > 0.f) { float ConeRadius = ShapeDetails.Extents.X + ShapeDetails.Falloff + ShapeDetails.ConeOffset; float ConeAngle = ShapeDetails.Extents.Y + ShapeDetails.Extents.Z; DrawWireSphereCappedCone(PDI, Origin, ConeRadius, ConeAngle, 16, 4, 10, AudioOuterRadiusColor, SDPG_World); ConeRadius = ShapeDetails.Extents.X + ShapeDetails.ConeOffset; ConeAngle = ShapeDetails.Extents.Y; DrawWireSphereCappedCone(PDI, Origin, ConeRadius, ConeAngle, 16, 4, 10, AudioInnerRadiusColor, SDPG_World ); } else { const float ConeRadius = ShapeDetails.Extents.X + ShapeDetails.ConeOffset; const float ConeAngle = ShapeDetails.Extents.Y; DrawWireSphereCappedCone(PDI, Origin, ConeRadius, ConeAngle, 16, 4, 10, AudioOuterRadiusColor, SDPG_World ); } } break; case EAttenuationShape::Sphere: if (ShapeDetails.Falloff > 0.f) { DrawWireSphereAutoSides(PDI, Translation, AudioOuterRadiusColor, ShapeDetails.Extents.X + ShapeDetails.Falloff, SDPG_World); DrawWireSphereAutoSides(PDI, Translation, AudioInnerRadiusColor, ShapeDetails.Extents.X, SDPG_World); } else { DrawWireSphereAutoSides(PDI, Translation, AudioOuterRadiusColor, ShapeDetails.Extents.X, SDPG_World); } break; default: check(false); } } } } }
void UCrowdManager::DebugTick() const { #if WITH_RECAST if (DetourCrowd == NULL || DetourAgentDebug == NULL) { return; } for (auto It = ActiveAgents.CreateConstIterator(); It; ++It) { const FCrowdAgentData& AgentData = It.Value(); if (AgentData.IsValid()) { UpdateSelectedDebug(It.Key(), AgentData.AgentIndex); } } // on screen debugging const dtCrowdAgent* SelectedAgent = DetourAgentDebug->idx >= 0 ? DetourCrowd->getAgent(DetourAgentDebug->idx) : NULL; if (SelectedAgent && CrowdDebugDrawing::bDebugSelectedActors) { if (CrowdDebugDrawing::bDrawDebugCorners) { DrawDebugCorners(SelectedAgent); } if (CrowdDebugDrawing::bDrawDebugCollisionSegments) { DrawDebugCollisionSegments(SelectedAgent); } if (CrowdDebugDrawing::bDrawDebugPath) { DrawDebugPath(SelectedAgent); } if (CrowdDebugDrawing::bDrawDebugVelocityObstacles) { DrawDebugVelocityObstacles(SelectedAgent); } if (CrowdDebugDrawing::bDrawDebugPathOptimization) { DrawDebugPathOptimization(SelectedAgent); } if (CrowdDebugDrawing::bDrawDebugNeighbors) { DrawDebugNeighbors(SelectedAgent); } } if (CrowdDebugDrawing::bDrawDebugBoundaries) { DrawDebugSharedBoundary(); } // vislog debugging if (CrowdDebugDrawing::bDebugVisLog) { for (auto It = ActiveAgents.CreateConstIterator(); It; ++It) { const ICrowdAgentInterface* IAgent = It.Key(); const UObject* AgentOb = IAgent ? Cast<const UObject>(IAgent) : NULL; const AActor* LogOwner = AgentOb ? Cast<const AActor>(AgentOb->GetOuter()) : NULL; const FCrowdAgentData& AgentData = It.Value(); const dtCrowdAgent* CrowdAgent = AgentData.IsValid() ? DetourCrowd->getAgent(AgentData.AgentIndex) : NULL; if (CrowdAgent && LogOwner) { FString LogData = DetourAgentDebug->agentLog.FindRef(AgentData.AgentIndex); if (LogData.Len() > 0) { UE_VLOG(LogOwner, LogCrowdFollowing, Log, *LogData); } { FVector P0 = Recast2UnrealPoint(CrowdAgent->npos); for (int32 Idx = 0; Idx < CrowdAgent->ncorners; Idx++) { FVector P1 = Recast2UnrealPoint(&CrowdAgent->cornerVerts[Idx * 3]); UE_VLOG_SEGMENT(LogOwner, LogCrowdFollowing, Log, P0 + CrowdDebugDrawing::Offset, P1 + CrowdDebugDrawing::Offset, CrowdDebugDrawing::Corner, TEXT("")); UE_VLOG_BOX(LogOwner, LogCrowdFollowing, Log, FBox::BuildAABB(P1 + CrowdDebugDrawing::Offset, FVector(2, 2, 2)), CrowdDebugDrawing::Corner, TEXT("%d"), CrowdAgent->cornerFlags[Idx]); P0 = P1; } } ARecastNavMesh* RecastNavData = Cast<ARecastNavMesh>(MyNavData); if (RecastNavData) { for (int32 Idx = 0; Idx < CrowdAgent->corridor.getPathCount(); Idx++) { dtPolyRef PolyRef = CrowdAgent->corridor.getPath()[Idx]; TArray<FVector> PolyPoints; RecastNavData->GetPolyVerts(PolyRef, PolyPoints); UE_VLOG_CONVEXPOLY(LogOwner, LogCrowdFollowing, Verbose, PolyPoints, FColor::Cyan, TEXT("")); } } if (CrowdAgent->ncorners && (CrowdAgent->cornerFlags[CrowdAgent->ncorners - 1] & DT_STRAIGHTPATH_OFFMESH_CONNECTION)) { FVector P0 = Recast2UnrealPoint(&CrowdAgent->cornerVerts[(CrowdAgent->ncorners - 1) * 3]); UE_VLOG_SEGMENT(LogOwner, LogCrowdFollowing, Log, P0, P0 + CrowdDebugDrawing::Offset * 2.0f, CrowdDebugDrawing::CornerLink, TEXT("")); } if (CrowdAgent->corridor.hasNextFixedCorner()) { FVector P0 = Recast2UnrealPoint(CrowdAgent->corridor.getNextFixedCorner()); UE_VLOG_BOX(LogOwner, LogCrowdFollowing, Log, FBox::BuildAABB(P0 + CrowdDebugDrawing::Offset, FVector(10, 10, 10)), CrowdDebugDrawing::CornerFixed, TEXT("")); } if (CrowdAgent->corridor.hasNextFixedCorner2()) { FVector P0 = Recast2UnrealPoint(CrowdAgent->corridor.getNextFixedCorner2()); UE_VLOG_BOX(LogOwner, LogCrowdFollowing, Log, FBox::BuildAABB(P0 + CrowdDebugDrawing::Offset, FVector(10, 10, 10)), CrowdDebugDrawing::CornerFixed, TEXT("")); } for (int32 Idx = 0; Idx < CrowdAgent->boundary.getSegmentCount(); Idx++) { const float* s = CrowdAgent->boundary.getSegment(Idx); const int32 SegFlags = CrowdAgent->boundary.getSegmentFlags(Idx); const FColor Color = (SegFlags & DT_CROWD_BOUNDARY_IGNORE) ? CrowdDebugDrawing::CollisionSegIgnored : (dtTriArea2D(CrowdAgent->npos, s, s + 3) < 0.0f) ? CrowdDebugDrawing::CollisionSeg1 : CrowdDebugDrawing::CollisionSeg0; FVector Pt0 = Recast2UnrealPoint(s); FVector Pt1 = Recast2UnrealPoint(s + 3); UE_VLOG_SEGMENT_THICK(LogOwner, LogCrowdFollowing, Log, Pt0 + CrowdDebugDrawing::Offset, Pt1 + CrowdDebugDrawing::Offset, Color, 3.0f, TEXT("")); } } } } DetourAgentDebug->agentLog.Reset(); #endif // WITH_RECAST }
/** Convert entity to xml dom document \param preferAttrib - if true (default) generate attributes, else elements ... <attr name="atrname" val="atrVal"/> ... vs <atrname>atrVal<atrname/> \param skipEmpty - if true (default) skip empty values \param upperCase - if true - uppercase all tags (default is false) \return Dom document reference */ QDomDocument& RecordBase::GetDom ( bool preferAttrib, bool skipEmpty, bool upperCase ) { QString idTag(kTagID); QString attrTag(kTagAttr); QString nameTag(kTagName); QString valTag(kTagValue); QString entName(EntityName()); if (upperCase) { entName = entName.toUpper(); idTag = idTag.toUpper(); attrTag = attrTag.toUpper(); nameTag = nameTag.toUpper(); valTag = valTag.toUpper(); } if (_xmlDoc) delete _xmlDoc; QDomElement root; _xmlDoc = new QDomDocument; root = _xmlDoc->createElement(entName); _xmlDoc->appendChild(root); // append id attrib to root root.setAttribute(idTag, Key()); // enumerate fields for (quint32 i(1); i < Count(); i++) { QString name = Field(i); QString v = Value(i).toString().trimmed(); if (v.length() > 0 || (v.length() == 0 && !skipEmpty)) { if (upperCase) name = name.toUpper(); if (preferAttrib) { QDomElement elem = _xmlDoc->createElement(attrTag); elem.setAttribute(nameTag, name); elem.setAttribute(valTag , v); root.appendChild (elem); } else // use elements { QDomElement elem = _xmlDoc->createElement(name); QDomText txt = _xmlDoc->createTextNode(v); elem.appendChild(txt); root.appendChild(elem); } } } return *_xmlDoc; }
void UCrowdManager::Tick(float DeltaTime) { SCOPE_CYCLE_COUNTER(STAT_AI_Crowd_Tick); INC_DWORD_STAT_BY(STAT_AI_Crowd_NumAgents, ActiveAgents.Num()); #if WITH_RECAST if (DetourCrowd) { int32 NumActive = DetourCrowd->cacheActiveAgents(); if (NumActive) { MyNavData->BeginBatchQuery(); for (auto It = ActiveAgents.CreateIterator(); It; ++It) { // collect position and velocity FCrowdAgentData& AgentData = It.Value(); if (AgentData.IsValid()) { PrepareAgentStep(It.Key(), AgentData, DeltaTime); } } // corridor update from previous step { SCOPE_CYCLE_COUNTER(STAT_AI_Crowd_StepCorridorTime); DetourCrowd->updateStepCorridor(DeltaTime, DetourAgentDebug); } // regular steps { SCOPE_CYCLE_COUNTER(STAT_AI_Crowd_StepPathsTime); DetourCrowd->updateStepPaths(DeltaTime, DetourAgentDebug); } { SCOPE_CYCLE_COUNTER(STAT_AI_Crowd_StepProximityTime); DetourCrowd->updateStepProximityData(DeltaTime, DetourAgentDebug); PostProximityUpdate(); } { SCOPE_CYCLE_COUNTER(STAT_AI_Crowd_StepNextPointTime); DetourCrowd->updateStepNextMovePoint(DeltaTime, DetourAgentDebug); PostMovePointUpdate(); } { SCOPE_CYCLE_COUNTER(STAT_AI_Crowd_StepSteeringTime); DetourCrowd->updateStepSteering(DeltaTime, DetourAgentDebug); } { SCOPE_CYCLE_COUNTER(STAT_AI_Crowd_StepAvoidanceTime); DetourCrowd->updateStepAvoidance(DeltaTime, DetourAgentDebug); } if (bResolveCollisions) { SCOPE_CYCLE_COUNTER(STAT_AI_Crowd_StepCollisionsTime); DetourCrowd->updateStepMove(DeltaTime, DetourAgentDebug); } { SCOPE_CYCLE_COUNTER(STAT_AI_Crowd_StepComponentsTime); UpdateAgentPaths(); } { SCOPE_CYCLE_COUNTER(STAT_AI_Crowd_StepNavLinkTime); DetourCrowd->updateStepOffMeshVelocity(DeltaTime, DetourAgentDebug); } // velocity updates { SCOPE_CYCLE_COUNTER(STAT_AI_Crowd_StepMovementTime); for (auto It = ActiveAgents.CreateIterator(); It; ++It) { const FCrowdAgentData& AgentData = It.Value(); if (AgentData.bIsSimulated && AgentData.IsValid()) { UCrowdFollowingComponent* CrowdComponent = Cast<UCrowdFollowingComponent>(It.Key()); if (CrowdComponent && CrowdComponent->IsCrowdSimulationEnabled()) { ApplyVelocity(CrowdComponent, AgentData.AgentIndex); } } } } MyNavData->FinishBatchQuery(); #if WITH_EDITOR // normalize samples only for debug drawing purposes DetourAvoidanceDebug->normalizeSamples(); #endif } } #endif // WITH_RECAST }
void QueryConnectedDevices() { // grab the list of devices via adb FString StdOut; if (!ExecuteAdbCommand(TEXT("devices -l"), &StdOut, nullptr)) { return; } // separate out each line TArray<FString> DeviceStrings; StdOut = StdOut.Replace(TEXT("\r"), TEXT("\n")); StdOut.ParseIntoArray(&DeviceStrings, TEXT("\n"), true); // a list containing all devices found this time, so we can remove anything not in this list TArray<FString> CurrentlyConnectedDevices; for (int32 StringIndex = 0; StringIndex < DeviceStrings.Num(); ++StringIndex) { const FString& DeviceString = DeviceStrings[StringIndex]; // skip over non-device lines if (DeviceString.StartsWith("* ") || DeviceString.StartsWith("List ")) { continue; } // grab the device serial number int32 TabIndex; if (!DeviceString.FindChar(TCHAR(' '), TabIndex)) { continue; } FAndroidDeviceInfo NewDeviceInfo; NewDeviceInfo.SerialNumber = DeviceString.Left(TabIndex); const FString DeviceState = DeviceString.Mid(TabIndex + 1).Trim(); NewDeviceInfo.bUnauthorizedDevice = DeviceState == TEXT("unauthorized"); // add it to our list of currently connected devices CurrentlyConnectedDevices.Add(NewDeviceInfo.SerialNumber); // move on to next device if this one is already a known device if (DeviceMap.Contains(NewDeviceInfo.SerialNumber)) { continue; } if (NewDeviceInfo.bUnauthorizedDevice) { NewDeviceInfo.DeviceName = TEXT("Unauthorized - enable USB debugging"); } else { // grab the Android version const FString AndroidVersionCommand = FString::Printf(TEXT("-s %s shell getprop ro.build.version.release"), *NewDeviceInfo.SerialNumber); if (!ExecuteAdbCommand(*AndroidVersionCommand, &NewDeviceInfo.HumanAndroidVersion, nullptr)) { continue; } NewDeviceInfo.HumanAndroidVersion = NewDeviceInfo.HumanAndroidVersion.Replace(TEXT("\r"), TEXT("")).Replace(TEXT("\n"), TEXT("")); NewDeviceInfo.HumanAndroidVersion.Trim().TrimTrailing(); // grab the Android SDK version const FString SDKVersionCommand = FString::Printf(TEXT("-s %s shell getprop ro.build.version.sdk"), *NewDeviceInfo.SerialNumber); FString SDKVersionString; if (!ExecuteAdbCommand(*SDKVersionCommand, &SDKVersionString, nullptr)) { continue; } NewDeviceInfo.SDKVersion = FCString::Atoi(*SDKVersionString); if (NewDeviceInfo.SDKVersion <= 0) { NewDeviceInfo.SDKVersion = INDEX_NONE; } // get the GL extensions string (and a bunch of other stuff) const FString ExtensionsCommand = FString::Printf(TEXT("-s %s shell dumpsys SurfaceFlinger"), *NewDeviceInfo.SerialNumber); if (!ExecuteAdbCommand(*ExtensionsCommand, &NewDeviceInfo.GLESExtensions, nullptr)) { continue; } // grab the GL ES version FString GLESVersionString; const FString GLVersionCommand = FString::Printf(TEXT("-s %s shell getprop ro.opengles.version"), *NewDeviceInfo.SerialNumber); if (!ExecuteAdbCommand(*GLVersionCommand, &GLESVersionString, nullptr)) { continue; } NewDeviceInfo.GLESVersion = FCString::Atoi(*GLESVersionString); // parse the device model FParse::Value(*DeviceString, TEXT("model:"), NewDeviceInfo.Model); if (NewDeviceInfo.Model.IsEmpty()) { FString ModelCommand = FString::Printf(TEXT("-s %s shell getprop ro.product.model"), *NewDeviceInfo.SerialNumber); FString RoProductModel; ExecuteAdbCommand(*ModelCommand, &RoProductModel, nullptr); const TCHAR* Ptr = *RoProductModel; FParse::Line(&Ptr, NewDeviceInfo.Model); } // parse the device name FParse::Value(*DeviceString, TEXT("device:"), NewDeviceInfo.DeviceName); if (NewDeviceInfo.DeviceName.IsEmpty()) { FString DeviceCommand = FString::Printf(TEXT("-s %s shell getprop ro.product.device"), *NewDeviceInfo.SerialNumber); FString RoProductDevice; ExecuteAdbCommand(*DeviceCommand, &RoProductDevice, nullptr); const TCHAR* Ptr = *RoProductDevice; FParse::Line(&Ptr, NewDeviceInfo.DeviceName); } } // add the device to the map { FScopeLock ScopeLock(DeviceMapLock); FAndroidDeviceInfo& SavedDeviceInfo = DeviceMap.Add(NewDeviceInfo.SerialNumber); SavedDeviceInfo = NewDeviceInfo; } } // loop through the previously connected devices list and remove any that aren't still connected from the updated DeviceMap TArray<FString> DevicesToRemove; for (auto It = DeviceMap.CreateConstIterator(); It; ++It) { if (!CurrentlyConnectedDevices.Contains(It.Key())) { DevicesToRemove.Add(It.Key()); } } { // enter the critical section and remove the devices from the map FScopeLock ScopeLock(DeviceMapLock); for (auto It = DevicesToRemove.CreateConstIterator(); It; ++It) { DeviceMap.Remove(*It); } } }
void UCrowdManager::UpdateAgentPaths() { UNavigationSystem* NavSys = Cast<UNavigationSystem>(GetOuter()); ARecastNavMesh* RecastNavData = Cast<ARecastNavMesh>(MyNavData); FPImplRecastNavMesh* PImplNavMesh = RecastNavData ? RecastNavData->RecastNavMeshImpl : NULL; if (PImplNavMesh == NULL) { return; } const dtCrowdAgentAnimation* AgentAnims = DetourCrowd->getAgentAnims(); for (auto It = ActiveAgents.CreateIterator(); It; ++It) { FCrowdAgentData& AgentData = It.Value(); if (AgentData.bIsSimulated && AgentData.IsValid()) { UCrowdFollowingComponent* CrowdComponent = nullptr; const dtCrowdAgent* Agent = DetourCrowd->getAgent(AgentData.AgentIndex); dtPolyRef AgentPolyRef = Agent->corridor.getFirstPoly(); // look for newly triggered smart links const dtCrowdAgentAnimation& AnimInfo = AgentAnims[AgentData.AgentIndex]; if (AnimInfo.active) { AgentPolyRef = AnimInfo.polyRef; if (AnimInfo.t == 0) { const uint32 NavLinkId = PImplNavMesh->GetLinkUserId(AnimInfo.polyRef); INavLinkCustomInterface* CustomLink = NavSys->GetCustomLink(NavLinkId); if (CustomLink) { FVector EndPt = Recast2UnrealPoint(AnimInfo.endPos); // switch to waiting state DetourCrowd->setAgentWaiting(AgentData.AgentIndex); DetourCrowd->resetAgentVelocity(AgentData.AgentIndex); // start using smart link CrowdComponent = (CrowdComponent ? CrowdComponent : (UCrowdFollowingComponent*)Cast<const UCrowdFollowingComponent>(It.Key())); if (CrowdComponent) { CrowdComponent->StartUsingCustomLink(CustomLink, EndPt); } } } } // look for poly updates if (AgentPolyRef != AgentData.PrevPoly) { CrowdComponent = (CrowdComponent ? CrowdComponent : (UCrowdFollowingComponent*)Cast<const UCrowdFollowingComponent>(It.Key())); if (CrowdComponent) { CrowdComponent->OnNavNodeChanged(AgentPolyRef, AgentData.PrevPoly, Agent->corridor.getPathCount()); AgentData.PrevPoly = AgentPolyRef; } } } } }
Key Key::string_key (const string &key) { int id = string_key_map.add_name (key, key); dl_assert (id != -1, "bug"); Key res = Key (id * 2 + 2); return res; }
void KeySig::read(XmlReader& e) { _sig = KeySigEvent(); // invalidate _sig int subtype = 0; while (e.readNextStartElement()) { const QStringRef& tag(e.name()); if (tag == "KeySym") { KeySym ks; while (e.readNextStartElement()) { const QStringRef& tag(e.name()); if (tag == "sym") { QString val(e.readElementText()); bool valid; SymId id = SymId(val.toInt(&valid)); if (!valid) id = Sym::name2id(val); if (score()->mscVersion() <= 114) { if (valid) id = KeySig::convertFromOldId(val.toInt(&valid)); else id = Sym::oldName2id(val); } ks.sym = id; } else if (tag == "pos") ks.spos = e.readPoint(); else e.unknown(); } _sig.keySymbols().append(ks); } else if (tag == "showCourtesySig") _showCourtesy = e.readInt(); else if (tag == "showNaturals") // obsolete e.readInt(); else if (tag == "accidental") _sig.setKey(Key(e.readInt())); else if (tag == "natural") // obsolete e.readInt(); else if (tag == "custom") { e.readInt(); _sig.setCustom(true); } else if (tag == "mode") { QString m(e.readElementText()); if (m == "none") _sig.setMode(KeyMode::NONE); else if (m == "major") _sig.setMode(KeyMode::MAJOR); else if (m == "minor") _sig.setMode(KeyMode::MINOR); else _sig.setMode(KeyMode::UNKNOWN); } else if (tag == "subtype") subtype = e.readInt(); else if (!Element::readProperties(e)) e.unknown(); } // for backward compatibility if (!_sig.isValid()) _sig.initFromSubtype(subtype); if (_sig.custom() && _sig.keySymbols().empty()) _sig.setMode(KeyMode::NONE); }
BinarySearchTree<Key, Value>::BinarySearchTree () { m_root=CreateNode(Key(), Value()); }
Key AllegroInput::convertToKey(int scancode, int unicode) { int keysym; bool pad = false; switch(scancode) { case KEY_ESC: keysym = Key::ESCAPE; break; case KEY_ALT: keysym = Key::LEFT_ALT; break; case KEY_ALTGR: keysym = Key::RIGHT_ALT; break; case KEY_LSHIFT: keysym = Key::LEFT_SHIFT; break; case KEY_RSHIFT: keysym = Key::RIGHT_SHIFT; break; case KEY_LCONTROL: keysym = Key::LEFT_CONTROL; break; case KEY_RCONTROL: keysym = Key::RIGHT_CONTROL; break; case KEY_LWIN: keysym = Key::LEFT_META; break; case KEY_RWIN: keysym = Key::RIGHT_META; break; case KEY_INSERT: keysym = Key::INSERT; break; case KEY_HOME: keysym = Key::HOME; break; case KEY_PGUP: keysym = Key::PAGE_UP; break; case KEY_PGDN: keysym = Key::PAGE_DOWN; break; case KEY_DEL: keysym = Key::DELETE; break; case KEY_DEL_PAD: keysym = Key::DELETE; pad = true; break; case KEY_END: keysym = Key::END; break; case KEY_CAPSLOCK: keysym = Key::CAPS_LOCK; break; case KEY_BACKSPACE: keysym = Key::BACKSPACE; break; case KEY_F1: keysym = Key::F1; break; case KEY_F2: keysym = Key::F2; break; case KEY_F3: keysym = Key::F3; break; case KEY_F4: keysym = Key::F4; break; case KEY_F5: keysym = Key::F5; break; case KEY_F6: keysym = Key::F6; break; case KEY_F7: keysym = Key::F7; break; case KEY_F8: keysym = Key::F8; break; case KEY_F9: keysym = Key::F9; break; case KEY_F10: keysym = Key::F10; break; case KEY_F11: keysym = Key::F11; break; case KEY_F12: keysym = Key::F12; break; case KEY_PRTSCR: keysym = Key::PRINT_SCREEN; break; case KEY_PAUSE: keysym = Key::PAUSE; break; case KEY_SCRLOCK: keysym = Key::SCROLL_LOCK; break; case KEY_NUMLOCK: keysym = Key::NUM_LOCK; break; case KEY_LEFT: keysym = Key::LEFT; break; case KEY_RIGHT: keysym = Key::RIGHT; break; case KEY_UP: keysym = Key::UP; break; case KEY_DOWN: keysym = Key::DOWN; break; case KEY_ENTER_PAD: pad = true; case KEY_ENTER: keysym = Key::ENTER; break; default: keysym = unicode; } Key k = Key(keysym); return k; //Now, THAT was fun to code! =D =D =D }
void CSettingTypeEnhancements::Delete (uint32_t Index ) { stdstr_f Key("Enhancement%d%s",Index,m_PostFix); m_EnhancementIniFile->SaveString(m_SectionIdent->c_str(),Key.c_str(),NULL); }
void UActorComponent::PostEditUndo() { // Objects marked pending kill don't call PostEditChange() from UObject::PostEditUndo(), // so they can leave an EditReregisterContexts entry around if they are deleted by an undo action. if( IsPendingKill() ) { // The reregister context won't bother attaching components that are 'pending kill'. FComponentReregisterContext* ReregisterContext = nullptr; if (EditReregisterContexts.RemoveAndCopyValue(this, ReregisterContext)) { delete ReregisterContext; } else { // This means there are likely some stale elements left in there now, strip them out for (auto It(EditReregisterContexts.CreateIterator()); It; ++It) { if (!It.Key().IsValid()) { It.RemoveCurrent(); } } } } else { bIsBeingDestroyed = false; Owner = GetTypedOuter<AActor>(); bCanUseCachedOwner = true; // Let the component be properly registered, after it was restored. if (Owner) { Owner->AddOwnedComponent(this); } TArray<UObject*> Children; GetObjectsWithOuter(this, Children); for (UObject* Child : Children) { if (UActorComponent* ChildComponent = Cast<UActorComponent>(Child)) { if (ChildComponent->Owner) { ChildComponent->Owner->RemoveOwnedComponent(ChildComponent); } ChildComponent->Owner = Owner; if (Owner) { Owner->AddOwnedComponent(ChildComponent); } } } if (GetWorld()) { GetWorld()->UpdateActorComponentEndOfFrameUpdateState(this); } } Super::PostEditUndo(); }
int main(int argc, char ** argv) { size_t n = atoi(argv[1]); size_t m = atoi(argv[2]); DB::Arena pool; std::vector<Key> data(n); std::cerr << "sizeof(Key) = " << sizeof(Key) << ", sizeof(Value) = " << sizeof(Value) << std::endl; { Stopwatch watch; DB::ReadBufferFromFileDescriptor in1(STDIN_FILENO); DB::CompressedReadBuffer in2(in1); std::string tmp; for (size_t i = 0; i < n && !in2.eof(); ++i) { DB::readStringBinary(tmp, in2); data[i] = Key(pool.insert(tmp.data(), tmp.size()), tmp.size()); } watch.stop(); std::cerr << std::fixed << std::setprecision(2) << "Vector. Size: " << n << ", elapsed: " << watch.elapsedSeconds() << " (" << n / watch.elapsedSeconds() << " elem/sec.)" << std::endl; } if (!m || m == 1) { Stopwatch watch; //using Map = HashMap<Key, Value>; /// Saving the hash accelerates the resize by about 2 times, and the overall performance by 6-8%. using Map = HashMapWithSavedHash<Key, Value, DefaultHash<Key>, Grower>; Map map; Map::iterator it; bool inserted; for (size_t i = 0; i < n; ++i) { map.emplace(data[i], it, inserted); if (inserted) it->second = 0; ++it->second; } watch.stop(); std::cerr << std::fixed << std::setprecision(2) << "HashMap (CityHash64). Size: " << map.size() << ", elapsed: " << watch.elapsedSeconds() << " (" << n / watch.elapsedSeconds() << " elem/sec.)" #ifdef DBMS_HASH_MAP_COUNT_COLLISIONS << ", collisions: " << map.getCollisions() #endif << std::endl; } if (!m || m == 2) { Stopwatch watch; using Map = HashMapWithSavedHash<Key, Value, FastHash64, Grower>; Map map; Map::iterator it; bool inserted; for (size_t i = 0; i < n; ++i) { map.emplace(data[i], it, inserted); if (inserted) it->second = 0; ++it->second; } watch.stop(); std::cerr << std::fixed << std::setprecision(2) << "HashMap (FastHash64). Size: " << map.size() << ", elapsed: " << watch.elapsedSeconds() << " (" << n / watch.elapsedSeconds() << " elem/sec.)" #ifdef DBMS_HASH_MAP_COUNT_COLLISIONS << ", collisions: " << map.getCollisions() #endif << std::endl; } if (!m || m == 3) { Stopwatch watch; using Map = HashMapWithSavedHash<Key, Value, CrapWow, Grower>; Map map; Map::iterator it; bool inserted; for (size_t i = 0; i < n; ++i) { map.emplace(data[i], it, inserted); if (inserted) it->second = 0; ++it->second; } watch.stop(); std::cerr << std::fixed << std::setprecision(2) << "HashMap (CrapWow). Size: " << map.size() << ", elapsed: " << watch.elapsedSeconds() << " (" << n / watch.elapsedSeconds() << " elem/sec.)" #ifdef DBMS_HASH_MAP_COUNT_COLLISIONS << ", collisions: " << map.getCollisions() #endif << std::endl; } if (!m || m == 4) { Stopwatch watch; using Map = HashMapWithSavedHash<Key, Value, SimpleHash, Grower>; Map map; Map::iterator it; bool inserted; for (size_t i = 0; i < n; ++i) { map.emplace(data[i], it, inserted); if (inserted) it->second = 0; ++it->second; } watch.stop(); std::cerr << std::fixed << std::setprecision(2) << "HashMap (SimpleHash). Size: " << map.size() << ", elapsed: " << watch.elapsedSeconds() << " (" << n / watch.elapsedSeconds() << " elem/sec.)" #ifdef DBMS_HASH_MAP_COUNT_COLLISIONS << ", collisions: " << map.getCollisions() #endif << std::endl; } if (!m || m == 5) { Stopwatch watch; std::unordered_map<Key, Value, DefaultHash<Key> > map; for (size_t i = 0; i < n; ++i) ++map[data[i]]; watch.stop(); std::cerr << std::fixed << std::setprecision(2) << "std::unordered_map. Size: " << map.size() << ", elapsed: " << watch.elapsedSeconds() << " (" << n / watch.elapsedSeconds() << " elem/sec.)" << std::endl; } if (!m || m == 6) { Stopwatch watch; google::dense_hash_map<Key, Value, DefaultHash<Key> > map; map.set_empty_key(Key("\0", 1)); for (size_t i = 0; i < n; ++i) ++map[data[i]]; watch.stop(); std::cerr << std::fixed << std::setprecision(2) << "google::dense_hash_map. Size: " << map.size() << ", elapsed: " << watch.elapsedSeconds() << " (" << n / watch.elapsedSeconds() << " elem/sec.)" << std::endl; } if (!m || m == 7) { Stopwatch watch; google::sparse_hash_map<Key, Value, DefaultHash<Key> > map; for (size_t i = 0; i < n; ++i) ++map[data[i]]; watch.stop(); std::cerr << std::fixed << std::setprecision(2) << "google::sparse_hash_map. Size: " << map.size() << ", elapsed: " << watch.elapsedSeconds() << " (" << n / watch.elapsedSeconds() << " elem/sec.)" << std::endl; } return 0; }
void USkeleton::Serialize( FArchive& Ar ) { DECLARE_SCOPE_CYCLE_COUNTER( TEXT("USkeleton::Serialize"), STAT_Skeleton_Serialize, STATGROUP_LoadTime ); Super::Serialize(Ar); if( Ar.UE4Ver() >= VER_UE4_REFERENCE_SKELETON_REFACTOR ) { Ar << ReferenceSkeleton; } if (Ar.UE4Ver() >= VER_UE4_FIX_ANIMATIONBASEPOSE_SERIALIZATION) { // Load Animation RetargetSources if (Ar.IsLoading()) { int32 NumOfRetargetSources; Ar << NumOfRetargetSources; FName RetargetSourceName; FReferencePose RetargetSource; for (int32 Index=0; Index<NumOfRetargetSources; ++Index) { Ar << RetargetSourceName; Ar << RetargetSource; AnimRetargetSources.Add(RetargetSourceName, RetargetSource); } } else { int32 NumOfRetargetSources = AnimRetargetSources.Num(); Ar << NumOfRetargetSources; for (auto Iter = AnimRetargetSources.CreateIterator(); Iter; ++Iter) { Ar << Iter.Key(); Ar << Iter.Value(); } } } else { // this is broken, but we have to keep it to not corrupt content. for (auto Iter = AnimRetargetSources.CreateIterator(); Iter; ++Iter) { Ar << Iter.Key(); Ar << Iter.Value(); } } if (Ar.UE4Ver() < VER_UE4_SKELETON_GUID_SERIALIZATION) { RegenerateGuid(); } else { Ar << Guid; } // If we should be using smartnames, serialize the mappings if(Ar.UE4Ver() >= VER_UE4_SKELETON_ADD_SMARTNAMES) { SmartNames.Serialize(Ar); } #if WITH_EDITORONLY_DATA if (Ar.UE4Ver() < VER_UE4_SKELETON_ASSET_PROPERTY_TYPE_CHANGE) { PreviewAttachedAssetContainer.SaveAttachedObjectsFromDeprecatedProperties(); } #endif }
Household_Index * Get_GE (int cell, int index) { Key (cell, index); return (Get_GE (&key)); }
void writeInt( const std::string& sKey, const std::string& sValueName, int nData ) { Key( sKey ).writeInt( sValueName, nData ); }