e825f43935
Shader model (desktop or mobile) wasn't really accounted for in the UI. This means that we will get shaders that look like duplicates (same variant). In this work, we pass the current shader model from engine into the frontend and filter out variants of a different shader model. Moreover, for matinfo, we use a specific dbg shader model (matinfo) to indicate it is in that mode. We add UI in matinfo to show the shadermodel. So UI updates as well.
110 lines
3.0 KiB
C++
110 lines
3.0 KiB
C++
/*
|
|
* Copyright (C) 2019 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <matdbg/ShaderInfo.h>
|
|
|
|
#include "CommonWriter.h"
|
|
|
|
#include <filaflat/ChunkContainer.h>
|
|
#include <filaflat/DictionaryReader.h>
|
|
#include <filaflat/MaterialChunk.h>
|
|
#include <filaflat/Unflattener.h>
|
|
|
|
#include <filament/MaterialChunkType.h>
|
|
#include <filament/MaterialEnums.h>
|
|
|
|
#include <backend/DriverEnums.h>
|
|
|
|
namespace filament::matdbg {
|
|
|
|
using namespace backend;
|
|
using namespace filaflat;
|
|
using namespace filamat;
|
|
using namespace utils;
|
|
|
|
size_t getShaderCount(const ChunkContainer& container, ChunkType type) {
|
|
if (!container.hasChunk(type)) {
|
|
return 0;
|
|
}
|
|
|
|
auto [start, end] = container.getChunkRange(type);
|
|
Unflattener unflattener(start, end);
|
|
|
|
uint64_t shaderCount = 0;
|
|
if (!unflattener.read(&shaderCount) || shaderCount == 0) {
|
|
return 0;
|
|
}
|
|
return shaderCount;
|
|
}
|
|
|
|
bool getShaderInfo(const ChunkContainer& container, ShaderInfo* info, ChunkType chunkType) {
|
|
if (!container.hasChunk(chunkType)) {
|
|
return true;
|
|
}
|
|
|
|
MaterialDomain domain;
|
|
if (!read(container, ChunkType::MaterialDomain, reinterpret_cast<uint8_t*>(&domain))) {
|
|
return false;
|
|
}
|
|
|
|
auto [start, end] = container.getChunkRange(chunkType);
|
|
Unflattener unflattener(start, end);
|
|
|
|
uint64_t shaderCount = 0;
|
|
if (!unflattener.read(&shaderCount) || shaderCount == 0) {
|
|
return false;
|
|
}
|
|
|
|
for (uint64_t i = 0; i < shaderCount; i++) {
|
|
uint8_t shaderModelValue;
|
|
Variant variant;
|
|
uint8_t pipelineStageValue;
|
|
uint32_t offsetValue;
|
|
|
|
if (!unflattener.read(&shaderModelValue)) {
|
|
return false;
|
|
}
|
|
|
|
if (!unflattener.read(&variant)) {
|
|
return false;
|
|
}
|
|
|
|
if (!unflattener.read(&pipelineStageValue)) {
|
|
return false;
|
|
}
|
|
|
|
if (!unflattener.read(&offsetValue)) {
|
|
return false;
|
|
}
|
|
|
|
auto stage = ShaderStage(pipelineStageValue);
|
|
if (domain == MaterialDomain::SURFACE) {
|
|
variant = stage == ShaderStage::VERTEX ?
|
|
Variant::filterVariantVertex(variant) :
|
|
Variant::filterVariantFragment(variant);
|
|
}
|
|
*info++ = {
|
|
.shaderModel = ShaderModel(shaderModelValue),
|
|
.variant = variant,
|
|
.pipelineStage = ShaderStage(pipelineStageValue),
|
|
.offset = offsetValue
|
|
};
|
|
}
|
|
return true;
|
|
}
|
|
|
|
} // namespace filament
|