phaneron/Kelsidavis-WoWee
1
0
Fork 0
mirror of https://github.com/Kelsidavis/WoWee.git synced 2026-04-17 01:23:51 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

make start on ubuntu intel video cards

Browse source
This commit is contained in:
Paul 2026-03-22 21:47:12 +03:00
parent 7565019dc9
commit 027640189a
8 changed files with 170 additions and 44 deletions
Download patch file Download diff file Expand all files Collapse all files

96
src/rendering/m2_renderer.cpp
View file

@ -366,6 +366,41 @@ bool M2Renderer::initialize(VkContext* ctx, VkDescriptorSetLayout perFrameLayout
vkCreateDescriptorPool(device, &ci, nullptr, &boneDescPool_);
}
// Create a small identity-bone SSBO + descriptor set so that non-animated
// draws always have a valid set 2 bound. The Intel ANV driver segfaults
// on vkCmdDrawIndexed when a declared descriptor set slot is unbound.
{
// Single identity matrix (bone 0 = identity)
glm::mat4 identity(1.0f);
VkBufferCreateInfo bci{VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO};
bci.size = sizeof(glm::mat4);
bci.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
VmaAllocationCreateInfo aci{};
aci.usage = VMA_MEMORY_USAGE_CPU_TO_GPU;
aci.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
VmaAllocationInfo allocInfo{};
vmaCreateBuffer(ctx->getAllocator(), &bci, &aci,
&dummyBoneBuffer_, &dummyBoneAlloc_, &allocInfo);
if (allocInfo.pMappedData) {
memcpy(allocInfo.pMappedData, &identity, sizeof(identity));
}
dummyBoneSet_ = allocateBoneSet();
if (dummyBoneSet_) {
VkDescriptorBufferInfo bufInfo{};
bufInfo.buffer = dummyBoneBuffer_;
bufInfo.offset = 0;
bufInfo.range = sizeof(glm::mat4);
VkWriteDescriptorSet write{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET};
write.dstSet = dummyBoneSet_;
write.dstBinding = 0;
write.descriptorCount = 1;
write.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
write.pBufferInfo = &bufInfo;
vkUpdateDescriptorSets(device, 1, &write, 0, nullptr);
}
}
// --- Pipeline layouts ---
// Main M2 pipeline layout: set 0 = perFrame, set 1 = material, set 2 = bones
@ -746,6 +781,9 @@ void M2Renderer::shutdown() {
if (ribbonPipelineLayout_) { vkDestroyPipelineLayout(device, ribbonPipelineLayout_, nullptr); ribbonPipelineLayout_ = VK_NULL_HANDLE; }
// Destroy descriptor pools and layouts
if (dummyBoneBuffer_) { vmaDestroyBuffer(alloc, dummyBoneBuffer_, dummyBoneAlloc_); dummyBoneBuffer_ = VK_NULL_HANDLE; }
// dummyBoneSet_ is freed implicitly when boneDescPool_ is destroyed
dummyBoneSet_ = VK_NULL_HANDLE;
if (materialDescPool_) { vkDestroyDescriptorPool(device, materialDescPool_, nullptr); materialDescPool_ = VK_NULL_HANDLE; }
if (boneDescPool_) { vkDestroyDescriptorPool(device, boneDescPool_, nullptr); boneDescPool_ = VK_NULL_HANDLE; }
if (materialSetLayout_) { vkDestroyDescriptorSetLayout(device, materialSetLayout_, nullptr); materialSetLayout_ = VK_NULL_HANDLE; }
@ -812,7 +850,11 @@ VkDescriptorSet M2Renderer::allocateMaterialSet() {
ai.descriptorSetCount = 1;
ai.pSetLayouts = &materialSetLayout_;
VkDescriptorSet set = VK_NULL_HANDLE;
vkAllocateDescriptorSets(vkCtx_->getDevice(), &ai, &set);
VkResult result = vkAllocateDescriptorSets(vkCtx_->getDevice(), &ai, &set);
if (result != VK_SUCCESS) {
LOG_ERROR("M2Renderer: material descriptor set allocation failed (", result, ")");
return VK_NULL_HANDLE;
}
return set;
}
@ -822,7 +864,11 @@ VkDescriptorSet M2Renderer::allocateBoneSet() {
ai.descriptorSetCount = 1;
ai.pSetLayouts = &boneSetLayout_;
VkDescriptorSet set = VK_NULL_HANDLE;
vkAllocateDescriptorSets(vkCtx_->getDevice(), &ai, &set);
VkResult result = vkAllocateDescriptorSets(vkCtx_->getDevice(), &ai, &set);
if (result != VK_SUCCESS) {
LOG_ERROR("M2Renderer: bone descriptor set allocation failed (", result, ")");
return VK_NULL_HANDLE;
}
return set;
}
@ -1303,6 +1349,10 @@ bool M2Renderer::loadModel(const pipeline::M2Model& model, uint32_t modelId) {
gpuModel.indexBuffer = buf.buffer;
gpuModel.indexAlloc = buf.allocation;
}
if (!gpuModel.vertexBuffer || !gpuModel.indexBuffer) {
LOG_ERROR("M2Renderer::loadModel: GPU buffer upload failed for model ", modelId);
}
}
// Load ALL textures from the model into a local vector.
@ -1751,6 +1801,7 @@ bool M2Renderer::loadModel(const pipeline::M2Model& model, uint32_t modelId) {
}
models[modelId] = std::move(gpuModel);
spatialIndexDirty_ = true; // Map may have rehashed — refresh cachedModel pointers
LOG_DEBUG("Loaded M2 model: ", model.name, " (", models[modelId].vertexCount, " vertices, ",
models[modelId].indexCount / 3, " triangles, ", models[modelId].batches.size(), " batches)");
@ -2504,6 +2555,7 @@ void M2Renderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet, const
uint32_t currentModelId = UINT32_MAX;
const M2ModelGPU* currentModel = nullptr;
bool currentModelValid = false;
// State tracking
VkPipeline currentPipeline = VK_NULL_HANDLE;
@ -2519,6 +2571,12 @@ void M2Renderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet, const
float fadeAlpha;
};
// Validate per-frame descriptor set before any Vulkan commands
if (!perFrameSet) {
LOG_ERROR("M2Renderer::render: perFrameSet is VK_NULL_HANDLE — skipping M2 render");
return;
}
// Bind per-frame descriptor set (set 0) — shared across all draws
vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
pipelineLayout_, 0, 1, &perFrameSet, 0, nullptr);
@ -2528,6 +2586,13 @@ void M2Renderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet, const
currentPipeline = opaquePipeline_;
bool opaquePass = true; // Pass 1 = opaque, pass 2 = transparent (set below for second pass)
// Bind dummy bone set (set 2) so non-animated draws have a valid binding.
// Animated instances override this with their real bone set per-instance.
if (dummyBoneSet_) {
vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
pipelineLayout_, 2, 1, &dummyBoneSet_, 0, nullptr);
}
for (const auto& entry : sortedVisible_) {
if (entry.index >= instances.size()) continue;
auto& instance = instances[entry.index];
@ -2535,14 +2600,17 @@ void M2Renderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet, const
// Bind vertex + index buffers once per model group
if (entry.modelId != currentModelId) {
currentModelId = entry.modelId;
currentModelValid = false;
auto mdlIt = models.find(currentModelId);
if (mdlIt == models.end()) continue;
currentModel = &mdlIt->second;
if (!currentModel->vertexBuffer) continue;
if (!currentModel->vertexBuffer || !currentModel->indexBuffer) continue;
currentModelValid = true;
VkDeviceSize offset = 0;
vkCmdBindVertexBuffers(cmd, 0, 1, &currentModel->vertexBuffer, &offset);
vkCmdBindIndexBuffer(cmd, currentModel->indexBuffer, 0, VK_INDEX_TYPE_UINT16);
}
if (!currentModelValid) continue;
const M2ModelGPU& model = *currentModel;
@ -2785,7 +2853,6 @@ void M2Renderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet, const
continue;
}
vkCmdPushConstants(cmd, pipelineLayout_, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(pc), &pc);
vkCmdDrawIndexed(cmd, batch.indexCount, 1, batch.indexStart, 0, 0);
lastDrawCallCount++;
}
@ -2799,6 +2866,7 @@ void M2Renderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet, const
currentModelId = UINT32_MAX;
currentModel = nullptr;
currentModelValid = false;
// Reset pipeline to opaque so the first transparent bind always sets explicitly
currentPipeline = opaquePipeline_;
@ -2817,14 +2885,17 @@ void M2Renderer::render(VkCommandBuffer cmd, VkDescriptorSet perFrameSet, const
// `!opaquePass && !rawTransparent → continue` handles opaque skipping)
if (entry.modelId != currentModelId) {
currentModelId = entry.modelId;
currentModelValid = false;
auto mdlIt = models.find(currentModelId);
if (mdlIt == models.end()) continue;
currentModel = &mdlIt->second;
if (!currentModel->vertexBuffer) continue;
if (!currentModel->vertexBuffer || !currentModel->indexBuffer) continue;
currentModelValid = true;
VkDeviceSize offset = 0;
vkCmdBindVertexBuffers(cmd, 0, 1, &currentModel->vertexBuffer, &offset);
vkCmdBindIndexBuffer(cmd, currentModel->indexBuffer, 0, VK_INDEX_TYPE_UINT16);
}
if (!currentModelValid) continue;
const M2ModelGPU& model = *currentModel;
@ -4168,6 +4239,21 @@ void M2Renderer::clear() {
}
if (boneDescPool_) {
vkResetDescriptorPool(device, boneDescPool_, 0);
// Re-allocate the dummy bone set (invalidated by pool reset)
dummyBoneSet_ = allocateBoneSet();
if (dummyBoneSet_ && dummyBoneBuffer_) {
VkDescriptorBufferInfo bufInfo{};
bufInfo.buffer = dummyBoneBuffer_;
bufInfo.offset = 0;
bufInfo.range = sizeof(glm::mat4);
VkWriteDescriptorSet write{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET};
write.dstSet = dummyBoneSet_;
write.dstBinding = 0;
write.descriptorCount = 1;
write.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
write.pBufferInfo = &bufInfo;
vkUpdateDescriptorSets(device, 1, &write, 0, nullptr);
}
}
}
models.clear();

34
src/rendering/terrain_manager.cpp
View file

@ -562,7 +562,17 @@ std::shared_ptr<PendingTile> TerrainManager::prepareTile(int x, int y) {
// Pre-load WMO doodads (M2 models inside WMO)
if (!workerRunning.load()) return nullptr;
if (!wmoModel.doodadSets.empty() && !wmoModel.doodads.empty()) {
// Skip WMO doodads if this placement was already prepared by another tile's worker.
// This prevents 15+ copies of Stormwind's ~6000 doodads from being parsed
// simultaneously, which was the primary cause of OOM during world load.
bool wmoAlreadyPrepared = false;
if (placement.uniqueId != 0) {
std::lock_guard<std::mutex> lock(preparedWmoUniqueIdsMutex_);
wmoAlreadyPrepared = !preparedWmoUniqueIds_.insert(placement.uniqueId).second;
}
if (!wmoAlreadyPrepared && !wmoModel.doodadSets.empty() && !wmoModel.doodads.empty()) {
glm::mat4 wmoMatrix(1.0f);
wmoMatrix = glm::translate(wmoMatrix, pos);
wmoMatrix = glm::rotate(wmoMatrix, rot.z, glm::vec3(0, 0, 1));
@ -575,6 +585,7 @@ std::shared_ptr<PendingTile> TerrainManager::prepareTile(int x, int y) {
setsToLoad.push_back(placement.doodadSet);
}
std::unordered_set<uint32_t> loadedDoodadIndices;
std::unordered_set<uint32_t> wmoPreparedModelIds; // within-WMO model dedup
for (uint32_t setIdx : setsToLoad) {
const auto& doodadSet = wmoModel.doodadSets[setIdx];
for (uint32_t di = 0; di < doodadSet.count; di++) {
@ -599,15 +610,16 @@ std::shared_ptr<PendingTile> TerrainManager::prepareTile(int x, int y) {
uint32_t doodadModelId = static_cast<uint32_t>(std::hash<std::string>{}(m2Path));
// Skip file I/O if model already uploaded from a previous tile
// Skip file I/O if model already uploaded or already prepared within this WMO
bool modelAlreadyUploaded = false;
{
std::lock_guard<std::mutex> lock(uploadedM2IdsMutex_);
modelAlreadyUploaded = uploadedM2Ids_.count(doodadModelId) > 0;
}
bool modelAlreadyPreparedInWmo = !wmoPreparedModelIds.insert(doodadModelId).second;
pipeline::M2Model m2Model;
if (!modelAlreadyUploaded) {
if (!modelAlreadyUploaded && !modelAlreadyPreparedInWmo) {
std::vector<uint8_t> m2Data = assetManager->readFile(m2Path);
if (m2Data.empty()) continue;
@ -1404,7 +1416,11 @@ void TerrainManager::unloadTile(int x, int y) {
wmoRenderer->removeInstances(fit->wmoInstanceIds);
}
for (uint32_t uid : fit->tileUniqueIds) placedDoodadIds.erase(uid);
for (uint32_t uid : fit->tileWmoUniqueIds) placedWmoIds.erase(uid);
for (uint32_t uid : fit->tileWmoUniqueIds) {
placedWmoIds.erase(uid);
std::lock_guard<std::mutex> lock(preparedWmoUniqueIdsMutex_);
preparedWmoUniqueIds_.erase(uid);
}
finalizingTiles_.erase(fit);
return;
}
@ -1425,6 +1441,8 @@ void TerrainManager::unloadTile(int x, int y) {
}
for (uint32_t uid : tile->wmoUniqueIds) {
placedWmoIds.erase(uid);
std::lock_guard<std::mutex> lock(preparedWmoUniqueIdsMutex_);
preparedWmoUniqueIds_.erase(uid);
}
// Remove M2 doodad instances
@ -1509,6 +1527,10 @@ void TerrainManager::unloadAll() {
std::lock_guard<std::mutex> lock(uploadedM2IdsMutex_);
uploadedM2Ids_.clear();
}
{
std::lock_guard<std::mutex> lock(preparedWmoUniqueIdsMutex_);
preparedWmoUniqueIds_.clear();
}
LOG_INFO("Unloading all terrain tiles");
loadedTiles.clear();
@ -1561,6 +1583,10 @@ void TerrainManager::softReset() {
std::lock_guard<std::mutex> lock(uploadedM2IdsMutex_);
uploadedM2Ids_.clear();
}
{
std::lock_guard<std::mutex> lock(preparedWmoUniqueIdsMutex_);
preparedWmoUniqueIds_.clear();
}
// Clear tile cache — keys are (x,y) without map name, so stale entries from
// a different map with overlapping coordinates would produce wrong geometry.