Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0613· OpenAIAi2 WildChat-4.8M (AI2)

ue4 的FstaticMeshVertexBuffer::InitResource() 函数,怎么找到静态模型的根引用

  1. User

    ue4 的FstaticMeshVertexBuffer::InitResource() 函数,怎么找到静态模型的根引用

  2. Assistant

    在UE4中,要找到静态模型的根引用,可以使用以下方法:

    1. 首先,获取到模型的UStaticMeshComponent组件的引用。
    UStaticMeshComponent* StaticMeshComponent = ...; // 获取到静态模型组件的引用
    
    1. 然后,通过静态模型组件的GetStaticMesh()函数获取到静态模型资源的引用。
    UStaticMesh* StaticMesh = StaticMeshComponent->GetStaticMesh();
    
    1. 最后,通过静态模型资源的GetRenderData()函数获取到渲染数据集合,从中获取顶点缓冲区的引用。
    FStaticMeshRenderData* RenderData = StaticMesh->GetRenderData();
    FStaticMeshVertexBuffer& VertexBuffer = RenderData->VertexBuffer;
    

    现在,你可以在FStaticMeshVertexBuffer::InitResource()函数中使用VertexBuffer引用来对顶点缓冲区进行初始化操作了。

    请注意,上述代码只是一个示例,具体的使用会根据你的需求和上下文略有不同。

  3. User

    /**

    • MoveTemp will cast a reference to an rvalue reference.
    • This is UE's equivalent of std::move except that it will not compile when passed an rvalue or
    • const object, because we would prefer to be informed when MoveTemp will have no effect. */ template FORCEINLINE typename TRemoveReference::Type&& MoveTemp(T&& Obj) 解释一下Ue4这个 Movetemp 方法, 在 iostore 这里 LoadedContainer.PackageCount = ContainerHeader.PackageCount; LoadedContainer.StoreEntries = MoveTemp(ContainerHeader.StoreEntries); 是 做什么用?
  4. Assistant

    MoveTemp是Unreal Engine 4中用于转换引用为右值引用(rvalue reference)的模板函数。它与std::move类似,但有一些额外的保护措施来确保不会意外地移动右值或常量对象。

    具体来说,对于一个类型为T的参数Obj,MoveTemp会将其转换为typename TRemoveReference<T>::Type&&,即T去除引用后再添加右值引用。这将允许你将传递给MoveTemp的值作为右值引用的方式来使用或移动。

    对于你提供的代码示例:

    LoadedContainer.PackageCount = ContainerHeader.PackageCount;
    LoadedContainer.StoreEntries = MoveTemp(ContainerHeader.StoreEntries);
    

    这里的MoveTemp函数用于将ContainerHeader.StoreEntries的值转换为右值引用,并将其移动给LoadedContainer.StoreEntries。这可以用来实现高效的资源转移或避免不必要的复制或赋值操作。

    需要注意的是,使用MoveTemp时要确保被移动的对象不再使用,因为它的状态可能会被修改或丢失。

  5. User

    void LoadContainers(TArrayView Containers) { TRACE_CPUPROFILER_EVENT_SCOPE(LoadContainers);

    	int32 ContainersToLoad = 0;
    
    	for (const FIoDispatcherMountedContainer& Container : Containers)
    	{
    		if (Container.ContainerId.IsValid())
    		{
    			++ContainersToLoad;
    		}
    	}
    
    	if (!ContainersToLoad)
    	{
    		return;
    	}
    
    	TAtomic<int32> Remaining(ContainersToLoad);
    
    	FEvent* Event = FPlatformProcess::GetSynchEventFromPool();
    	FIoBatch IoBatch = IoDispatcher.NewBatch();
    
    	for (const FIoDispatcherMountedContainer& Container : Containers)
    	{
    		const FIoContainerId& ContainerId = Container.ContainerId;
    		if (!ContainerId.IsValid())
    		{
    			continue;
    		}
    
    		TUniquePtr<FLoadedContainer>& LoadedContainerPtr = LoadedContainers.FindOrAdd(ContainerId);
    		if (!LoadedContainerPtr)
    		{
    			LoadedContainerPtr.Reset(new FLoadedContainer);
    		}
    		FLoadedContainer& LoadedContainer = *LoadedContainerPtr;
    		if (LoadedContainer.bValid && LoadedContainer.Order >= Container.Environment.GetOrder())
    		{
    			UE_LOG(LogStreaming, Log, TEXT("Skipping loading mounted container ID '0x%llX', already loaded with higher order"), ContainerId.Value());
    			if (--Remaining == 0)
    			{
    				Event->Trigger();
    			}
    			continue;
    		}
    
    		UE_LOG(LogStreaming, Log, TEXT("Loading mounted container ID '0x%llX'"), ContainerId.Value());
    		LoadedContainer.bValid = true;
    		LoadedContainer.Order = Container.Environment.GetOrder();
    
    		FIoChunkId HeaderChunkId = CreateIoChunkId(ContainerId.Value(), 0, EIoChunkType::ContainerHeader);
    		IoBatch.ReadWithCallback(HeaderChunkId, FIoReadOptions(), IoDispatcherPriority_High, [this, &Remaining, Event, &LoadedContainer](TIoStatusOr<FIoBuffer> Result)
    		{
    			// Execution method Thread will run the async block synchronously when multithreading is NOT supported
    			const EAsyncExecution ExecutionMethod = FPlatformProcess::SupportsMultithreading() ? EAsyncExecution::TaskGraph : EAsyncExecution::Thread;
    
    			Async(ExecutionMethod, [this, &Remaining, Event, IoBuffer = Result.ConsumeValueOrDie(), &LoadedContainer]()
    			{
    				LLM_SCOPE(ELLMTag::AsyncLoading);
    
    				FMemoryReaderView Ar(MakeArrayView(IoBuffer.Data(), IoBuffer.DataSize()));
    
    				FContainerHeader ContainerHeader;
    				Ar << ContainerHeader;
    
    				const bool bHasContainerLocalNameMap = ContainerHeader.Names.Num() > 0;
    				if (bHasContainerLocalNameMap)
    				{
    					TRACE_CPUPROFILER_EVENT_SCOPE(LoadContainerNameMap);
    					LoadedContainer.ContainerNameMap.Reset(new FNameMap());
    					LoadedContainer.ContainerNameMap->Load(ContainerHeader.Names, ContainerHeader.NameHashes, FMappedName::EType::Container);
    				}
    
    				LoadedContainer.PackageCount = ContainerHeader.PackageCount;
    				LoadedContainer.StoreEntries = MoveTemp(ContainerHeader.StoreEntries);
    				{
    					TRACE_CPUPROFILER_EVENT_SCOPE(AddPackages);
    					FScopeLock Lock(&PackageNameMapsCritical);
    
    					TArrayView<FPackageStoreEntry> StoreEntries(reinterpret_cast<FPackageStoreEntry*>(LoadedContainer.StoreEntries.GetData()), LoadedContainer.PackageCount);
    
    					int32 Index = 0;
    					StoreEntriesMap.Reserve(StoreEntriesMap.Num() + LoadedContainer.PackageCount);
    					for (FPackageStoreEntry& ContainerEntry : StoreEntries)
    					{
    						const FPackageId& PackageId = ContainerHeader.PackageIds[Index];
    
    						FPackageStoreEntry*& GlobalEntry = StoreEntriesMap.FindOrAdd(PackageId);
    						if (!GlobalEntry)
    						{
    							GlobalEntry = &ContainerEntry;
    						}
    						++Index;
    					}
    
    					{
    						TRACE_CPUPROFILER_EVENT_SCOPE(LoadPackageStoreLocalization);
    						const FSourceToLocalizedPackageIdMap* LocalizedPackages = nullptr;
    						for (const FString& CultureName : CurrentCultureNames)
    						{
    							LocalizedPackages = ContainerHeader.CulturePackageMap.Find(CultureName);
    							if (LocalizedPackages)
    							{
    								break;
    							}
    						}
    
    						if (LocalizedPackages)
    						{
    							for (auto& Pair : *LocalizedPackages)
    							{
    								const FPackageId& SourceId = Pair.Key;
    								const FPackageId& LocalizedId = Pair.Value;
    								RedirectsPackageMap.Emplace(SourceId, LocalizedId);
    							}
    						}
    					}
    
    					{
    						TRACE_CPUPROFILER_EVENT_SCOPE(LoadPackageStoreRedirects);
    						for (const TPair<FPackageId, FPackageId>& Redirect : ContainerHeader.PackageRedirects)
    						{
    							RedirectsPackageMap.Emplace(Redirect.Key, Redirect.Value);
    						}
    					}
    				}
    
    				if (--Remaining == 0)
    				{
    					Event->Trigger();
    				}
    			});
    		});
    	}
    
    	IoBatch.Issue();
    	Event->Wait();
    	FPlatformProcess::ReturnSynchEventToPool(Event);
    
    	ApplyRedirects(RedirectsPackageMap);
    }  解释一下这段代码
    
  6. Assistant

    这段代码是一个载入已挂载容器的函数LoadContainers的实现。下面是对该代码的解释:

    1. 首先,函数遍历传入的Containers数组,对每个容器进行计数,以确定需要加载的容器数量。
    for (const FIoDispatcherMountedContainer& Container : Containers)
    {
        if (Container.ContainerId.IsValid())
        {
            ++ContainersToLoad;
        }
    }
    
    1. 如果待加载的容器数量为0,则直接返回,不做任何操作。
    if (!ContainersToLoad)
    {
        return;
    }
    
    1. 创建一个计数器Remaining,用于跟踪剩余待加载的容器数量。同时创建一个同步事件Event,用于在所有容器加载完成后触发。
    TAtomic<int32> Remaining(ContainersToLoad);
    FEvent* Event = FPlatformProcess::GetSynchEventFromPool();
    
    1. 创建一个批次IoBatch,用于将IO操作合并,并在合适的时机执行。
    FIoBatch IoBatch = IoDispatcher.NewBatch();
    
    1. 对传入的每个容器进行处理。
    for (const FIoDispatcherMountedContainer& Container : Containers)
    {
        ...
    }
    
    1. 检查当前容器的容器ID是否有效,若无效则跳过处理。
    const FIoContainerId& ContainerId = Container.ContainerId;
    if (!ContainerId.IsValid())
    {
        continue;
    }
    
    1. 在LoadedContainers映射中查找当前容器ID的加载容器指针,并在不存在时创建一个新的加载容器对象。
    TUniquePtr<FLoadedContainer>& LoadedContainerPtr = LoadedContainers.FindOrAdd(ContainerId);
    if (!LoadedContainerPtr)
    {
        LoadedContainerPtr.Reset(new FLoadedContainer);
    }
    
    1. 检查当前已加载的容器是否有效且其顺序是否大于等于传入容器的环境顺序。如果是,则跳过加载。
    FLoadedContainer& LoadedContainer = *LoadedContainerPtr;
    if (LoadedContainer.bValid && LoadedContainer.Order >= Container.Environment.GetOrder())
    {
        // 已加载且顺序高于传入环境顺序,跳过加载
        if (--Remaining == 0)
        {
            Event->Trigger();
        }
        continue;
    }
    
    1. 输出日志表示开始加载容器。
    UE_LOG(LogStreaming, Log, TEXT("Loading mounted container ID '0x%llX'"), ContainerId.Value());
    
    1. 将加载容器的有效性标记为true,并设置其顺序为传入容器的环境顺序。
    LoadedContainer.bValid = true;
    LoadedContainer.Order = Container.Environment.GetOrder();
    
    1. 创建一个头块的IoChunkId用于读取容器头信息,并在IO操作完成后使用回调函数处理返回结果。
    FIoChunkId HeaderChunkId = CreateIoChunkId(ContainerId.Value(), 0, EIoChunkType::ContainerHeader);
    IoBatch.ReadWithCallback(HeaderChunkId, FIoReadOptions(), IoDispatcherPriority_High, [this, &Remaining, Event, &LoadedContainer](TIoStatusOr<FIoBuffer> Result)
    {
        ...
    });
    
    1. 在回调函数内,根据IO操作的结果创建一个FMemoryReaderView,并使用它来读取并解析容器头信息。
    Async(ExecutionMethod, [this, &Remaining, Event, IoBuffer = Result.ConsumeValueOrDie(), &LoadedContainer]()
    {
        LLM_SCOPE(ELLMTag::AsyncLoading);
    
        FMemoryReaderView Ar(MakeArrayView(IoBuffer.Data(), IoBuffer.DataSize()));
    
        FContainerHeader ContainerHeader;
        Ar << ContainerHeader;
    
        ...
    });
    
    1. 在解析容器头信息的过程中,首先检查容器是否包含了本地名称映射表。如果有,则加载并创建一个FNameMap对象。
    const bool bHasContainerLocalNameMap = ContainerHeader.Names.Num() > 0;
    if (bHasContainerLocalNameMap)
    {
        LoadedContainer.ContainerNameMap.Reset(new FNameMap());
        LoadedContainer.ContainerNameMap->Load(ContainerHeader.Names, ContainerHeader.NameHashes, FMappedName::EType::Container);
    }
    
    1. 移动容器头信息中的PackageCount和StoreEntries到LoadedContainer对象中。
    LoadedContainer.PackageCount = ContainerHeader.PackageCount;
    LoadedContainer.StoreEntries = MoveTemp(ContainerHeader.StoreEntries);
    
    1. 在临界区中,将StoreEntries添加到全局的StoreEntriesMap中,并根据PackageId映射FPackageStoreEntry。
    FScopeLock Lock(&PackageNameMapsCritical);
    
    TArrayView<FPackageStoreEntry> StoreEntries(reinterpret_cast<FPackageStoreEntry*>(LoadedContainer.StoreEntries.GetData()), LoadedContainer.PackageCount);
    
    int32 Index = 0;
    StoreEntriesMap.Reserve(StoreEntriesMap.Num() + LoadedContainer.PackageCount);
    for (FPackageStoreEntry& ContainerEntry : StoreEntries)
    {
        const FPackageId& PackageId = ContainerHeader.PackageIds[Index];
    
        FPackageStoreEntry*& GlobalEntry = StoreEntriesMap.FindOrAdd(PackageId);
        if (!GlobalEntry)
        {
            GlobalEntry = &ContainerEntry;
        }
        ++Index;
    }
    
    1. 加载本地化的包映射和重定向映射,并将它们存储在RedirectsPackageMap中。
    const FSourceToLocalizedPackageIdMap* LocalizedPackages = nullptr;
    for (const FString& CultureName : CurrentCultureNames)
    {
        LocalizedPackages = ContainerHeader.CulturePackageMap.Find(CultureName);
        if (LocalizedPackages)
        {
            break;
        }
    }
    
    if (LocalizedPackages)
    {
        for (auto& Pair : *LocalizedPackages)
        {
            const FPackageId& SourceId = Pair.Key;
            const FPackageId& LocalizedId = Pair.Value;
            RedirectsPackageMap.Emplace(SourceId, LocalizedId);
        }
    }
    
    for (const TPair<FPackageId, FPackageId>& Redirect : ContainerHeader.PackageRedirects)
    {
        RedirectsPackageMap.Emplace(Redirect.Key, Redirect.Value);
    }
    
    1. 对每个容器的处理完成后,通过减少Remaining计数器,如果计数器变为0,则触发同步事件Event。
    if (--Remaining == 0)
    {
        Event->Trigger();
    }
    
    1. 发出IO批次,将之前合并的IO操作一起发起。
    IoBatch.Issue();
    
    1. 等待同步事件的触发,即所有容器加载完成后,进行下一步操作。
    Event->Wait();
    
    1. 将同步事件返回到事件池中。
    FPlatformProcess::ReturnSynchEventToPool(Event);
    
    1. 应用重定向映射到全局的包映射表RedirectsPackageMap。
    ApplyRedirects(RedirectsPackageMap);
    

    以上就是对该段代码的解释。该函数的作用是根据传入的已挂载容器信息,加载并处理每个容器的头信息,并存储在LoadedContainers映射表中,同时将一些包的本地化和重定向信息存储在RedirectsPackageMap中。

  7. User

    FMemoryReaderView Ar(MakeArrayView(IoBuffer.Data(), IoBuffer.DataSize()));

    				FContainerHeader ContainerHeader;
    				Ar << ContainerHeader;
    
  8. Assistant

    这部分代码的作用是使用创建的IoBuffer来创建一个FMemoryReaderView对象Ar,然后使用Ar对象来从IoBuffer中读取数据,并将读取的数据存储到ContainerHeader对象中。

    首先,使用MakeArrayView函数将IoBuffer.Data()转换为TArrayView<uint8>,并指定数据的大小为IoBuffer.DataSize(),创建了一个包含IoBuffer数据的视图。

    FMemoryReaderView Ar(MakeArrayView(IoBuffer.Data(), IoBuffer.DataSize()));
    

    然后,使用<<操作符和Ar对象从视图中读取数据,并将其存储到ContainerHeader变量中,以便进一步处理。

    FContainerHeader ContainerHeader;
    Ar << ContainerHeader;
    

    这样,通过FMemoryReaderView和<<操作符,将IoBuffer中的数据解析为ContainerHeader对象的字段,以便后续对数据进行处理和使用。

  9. User

    struct FPackageStoreEntry { uint64 ExportBundlesSize; int32 ExportCount; int32 ExportBundleCount; uint32 LoadOrder; uint32 Pad; TPackageStoreEntryCArrayView ImportedPackages; }; 分别代表什么

  10. Assistant

    FPackageStoreEntry结构体的字段代表了存储在包存储中的每个包的相关信息。下面是对每个字段的解释:

    • ExportBundlesSize:

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.