jinchao/davinci2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

规范模型输入以及测试shader

Browse Source
This commit is contained in:
jinchao
2025-10-09 21:44:59 +08:00
parent 698c1a1099
commit f847154ba2
11 changed files with 436 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/console/ui/ui_main.cpp
+5 -1
View File
@@ -1,5 +1,6 @@
#include "ui_main.h"
#include <SDL3/SDL.h>
#include <SDL3/SDL_opengl.h>
#include <imgui/imgui.h>
@@ -74,7 +75,10 @@ void OpenFileDialogFileCallback(void* userdata, const char* const* filelist, int
g_scene.clear();
const char* szFileName = *filelist;
davinci_utils::load_scene_from_gltf(szFileName, g_scene);
if (!davinci_utils::load_scene_from_gltf(szFileName, g_scene))
{
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Error", "Open glf scene file error", main_window);
}
}
void drawMainUI()
source/core/include/math/dvc_math_util.h
+2 -2
View File
@@ -8,8 +8,8 @@ DV_CORE_BEGIN_NAMESPACE
class MathUtil
{
public:
static size_t ComponentSize(ComponentType ct);
static size_t DataTypeSize(DataType dt);
static DV_CORE_API size_t ComponentSize(ComponentType ct);
static DV_CORE_API size_t DataTypeSize(DataType dt);
//count the number of bits set in v
static DV_CORE_API uint32_t popcount(uint8_t v);
source/core/source/pipe/dvc_render_step1_vertex_shader.cpp
+5 -14
View File
@@ -8,7 +8,7 @@ DV_CORE_BEGIN_NAMESPACE
void VertexShaderStep::process(UniformBuffer& uniformBuffer, const InputAssemberStep::NodeArray& assembedNodeArray)
{
ShaderFileInterface* shaderInterface = davinci::LoadShaderFile("TestShader.dll");
VertexShaderInterface* standardVS = shaderInterface->getVertexShader("xxxx");
VertexShaderInterface* standardVS = shaderInterface->getVertexShader("test");
const fVector3* eyePos = (const fVector3*)(uniformBuffer.getAttribute("camera:eye_pos"));
const fMatrix4* cameraView = (const fMatrix4*)(uniformBuffer.getAttribute("camera:view_mat"));
@@ -24,6 +24,9 @@ void VertexShaderStep::process(UniformBuffer& uniformBuffer, const InputAssember
//update self uniform value
uniformBuffer.setAttribute("self:world_transform", inputNode.transform);
fMatrix4 worldInverseTrans = inputNode.transform.inverse().transpose();
uniformBuffer.setAttribute("self:world_transform_inverse_trans", worldInverseTrans);
standardVS->prepare(&uniformBuffer,
[inputNode](VertexElementType type) -> DeviceBufferAccessorConstPtr
{
@@ -47,19 +50,7 @@ void VertexShaderStep::process(UniformBuffer& uniformBuffer, const InputAssember
for (size_t i = 0; i < vertexCounts; i++)
{
size_t index = 0;
if (inputNode.indices->getComponentType() == CT_Uint16)
{
index = (size_t)(*(uint16_t*)(inputNode.indices->getElement(i)));
}
else if(inputNode.indices->getComponentType() == CT_Uint32)
{
index = (size_t)(*(uint32_t*)(inputNode.indices->getElement(i)));
}
else
{
//error
}
uint16_t index = *((const uint16_t*)(inputNode.indices->getElement(i)));
fVector3 vertexWorldPos;
void* outputVertexMemory = outputNode.vertexBuf->ptr(i* outputNode.vertexDesc.vertexByteSize());
source/core/source/pipe/dvc_render_step2_rasterizer.cpp
+2 -2
View File
@@ -9,7 +9,7 @@ DV_CORE_BEGIN_NAMESPACE
void RasterizerStep::process(const VertexShaderStep::NodeArray& vsNodeArray, AntiAliasingTech aaTech, int32_t canvasWidth, int32_t canvasHeight)
{
ShaderFileInterface* shaderInterface = davinci::LoadShaderFile("TestShader.dll");
PixelShaderInterface* pixelShader = shaderInterface->getPixelShader("xxx");
PixelShaderInterface* pixelShader = shaderInterface->getPixelShader("test");
fMatrix4 view_trans =
fMatrix4::makeTrans(canvasWidth / 2.f, canvasHeight / 2.f, 0.f) *
@@ -75,7 +75,7 @@ void RasterizerStep::process(const VertexShaderStep::NodeArray& vsNodeArray, Ant
newFragment.mask = mask;
newFragment.next = currentOffset;
this->m_fragementArray.push_back(newFragment);
}
},true
);
}
}
source/utils/source/scene/dvu_load_gltf.cpp
+263 -24
View File
@@ -132,6 +132,253 @@ davinci::VertexElementType _getElementTypeFromGltf(const std::string& gltfElemen
return davinci::VET_UNKNOWN;
}
davinci::DeviceBufferAccessorPtr _createFloat32BufferAccessorFromNormalizedIntegerType(davinci::Scene& scene,
davinci::DeviceBufferAccessorPtr inpuptBufferAccesser)
{
size_t elementCounts = inpuptBufferAccesser->getCount();
davinci::ComponentType inputComponentType = inpuptBufferAccesser->getComponentType();
if (inputComponentType != davinci::ComponentType::CT_Uint8 &&
inputComponentType != davinci::ComponentType::CT_Uint16 &&
inputComponentType != davinci::ComponentType::CT_Uint32)
{
return nullptr;
}
davinci::DataType dataType = inpuptBufferAccesser->getDataType();
davinci::DeviceBufferPtr newBuffer = scene.newDeviceBuffer();
size_t bufferSize = elementCounts * davinci::MathUtil::ComponentSize(davinci::ComponentType::CT_Float32) * davinci::MathUtil::DataTypeSize(dataType);
newBuffer->init(bufferSize);
if (dataType == davinci::DataType::DT_Scalar)
{
inpuptBufferAccesser->walk([newBuffer, inputComponentType](const uint8_t* ptr, size_t index)
{
float32_t* target = (float32_t*)(newBuffer->ptr(index * sizeof(float32_t)));
if (inputComponentType == davinci::ComponentType::CT_Uint8)
{
target[0] = ((const uint8_t*)ptr)[0] / (float32_t)0xFF;
}
else if (inputComponentType == davinci::ComponentType::CT_Uint16)
{
target[0] = ((const uint16_t*)ptr)[0] / (float32_t)0xFFFF;
}
else
{
target[0] = ((const uint32_t*)ptr)[0] / (float32_t)0xFFFFFFFF;
}
return false;
}
);
}
else if (dataType == davinci::DataType::DT_Vec2)
{
inpuptBufferAccesser->walk(
[newBuffer, inputComponentType](const uint8_t* ptr, size_t index)
{
float32_t* target = (float32_t*)(newBuffer->ptr(index * sizeof(float32_t) * 2));
if (inputComponentType == davinci::ComponentType::CT_Uint8)
{
target[0] = ((const uint8_t*)ptr)[0] / (float32_t)0xFF;
target[1] = ((const uint8_t*)ptr)[1] / (float32_t)0xFF;
}
else if (inputComponentType == davinci::ComponentType::CT_Uint16)
{
target[0] = ((const uint16_t*)ptr)[0] / (float32_t)0xFFFF;
target[1] = ((const uint16_t*)ptr)[1] / (float32_t)0xFFFF;
}
else
{
target[0] = ((const uint32_t*)ptr)[0] / (float32_t)0xFFFFFFFF;
target[1] = ((const uint32_t*)ptr)[1] / (float32_t)0xFFFFFFFF;
}
return false;
}
);
}
else if (dataType == davinci::DataType::DT_Vec3)
{
inpuptBufferAccesser->walk(
[newBuffer, inputComponentType](const uint8_t* ptr, size_t index)
{
float32_t* target = (float32_t*)(newBuffer->ptr(index * sizeof(float32_t) * 3));
if (inputComponentType == davinci::ComponentType::CT_Uint8)
{
target[0] = ((const uint8_t*)ptr)[0] / (float32_t)0xFF;
target[1] = ((const uint8_t*)ptr)[1] / (float32_t)0xFF;
target[2] = ((const uint8_t*)ptr)[2] / (float32_t)0xFF;
}
else if (inputComponentType == davinci::ComponentType::CT_Uint16)
{
target[0] = ((const uint16_t*)ptr)[0] / (float32_t)0xFFFF;
target[1] = ((const uint16_t*)ptr)[1] / (float32_t)0xFFFF;
target[2] = ((const uint16_t*)ptr)[2] / (float32_t)0xFFFF;
}
else
{
target[0] = ((const uint32_t*)ptr)[0] / (float32_t)0xFFFFFFFF;
target[1] = ((const uint32_t*)ptr)[1] / (float32_t)0xFFFFFFFF;
target[2] = ((const uint32_t*)ptr)[2] / (float32_t)0xFFFFFFFF;
}
return false;
}
);
}
else if (dataType == davinci::DataType::DT_Vec4)
{
inpuptBufferAccesser->walk(
[newBuffer, inputComponentType](const uint8_t* ptr, size_t index)
{
float32_t* target = (float32_t*)(newBuffer->ptr(index * sizeof(float32_t) * 4));
if (inputComponentType == davinci::ComponentType::CT_Uint8)
{
target[0] = ((const uint8_t*)ptr)[0] / (float32_t)0xFF;
target[1] = ((const uint8_t*)ptr)[1] / (float32_t)0xFF;
target[2] = ((const uint8_t*)ptr)[2] / (float32_t)0xFF;
target[3] = ((const uint8_t*)ptr)[3] / (float32_t)0xFF;
}
else if (inputComponentType == davinci::ComponentType::CT_Uint16)
{
target[0] = ((const uint16_t*)ptr)[0] / (float32_t)0xFFFF;
target[1] = ((const uint16_t*)ptr)[1] / (float32_t)0xFFFF;
target[2] = ((const uint16_t*)ptr)[2] / (float32_t)0xFFFF;
target[3] = ((const uint16_t*)ptr)[3] / (float32_t)0xFFFF;
}
else
{
target[0] = ((const uint32_t*)ptr)[0] / (float32_t)0xFFFFFFFF;
target[1] = ((const uint32_t*)ptr)[1] / (float32_t)0xFFFFFFFF;
target[2] = ((const uint32_t*)ptr)[2] / (float32_t)0xFFFFFFFF;
target[3] = ((const uint32_t*)ptr)[3] / (float32_t)0xFFFFFFFF;
}
return false;
}
);
}
davinci::DeviceBufferViewPtr newBufferViewer = scene.newDeviceBufferView(newBuffer, 0, bufferSize, 0);
return scene.newDeviceBufferAccessor(newBufferViewer, 0, elementCounts, davinci::ComponentType::CT_Float32, dataType);
}
davinci::DeviceBufferAccessorPtr _createSupportedPrimitiveAttributeBufferAccessor(
davinci::Scene& scene, davinci::VertexElementType vetType, davinci::DeviceBufferAccessorPtr inpuptBufferAccesser)
{
if (!inpuptBufferAccesser) return nullptr;
davinci::ComponentType componentType = inpuptBufferAccesser->getComponentType();
davinci::DataType dataType = inpuptBufferAccesser->getDataType();
switch (vetType)
{
case davinci::VET_POSITION:
case davinci::VET_NORMAL:
case davinci::VET_BINORMAL:
if (componentType == davinci::ComponentType::CT_Float32 && dataType == davinci::DataType::DT_Vec3)
{
return inpuptBufferAccesser;
}
break;
case davinci::VET_TANGENT:
if (componentType == davinci::ComponentType::CT_Float32 && dataType == davinci::DataType::DT_Vec4)
{
return inpuptBufferAccesser;
}
break;
case davinci::VET_TEXCOORD_0:
case davinci::VET_TEXCOORD_1:
case davinci::VET_TEXCOORD_2:
case davinci::VET_TEXCOORD_3:
case davinci::VET_TEXCOORD_4:
case davinci::VET_TEXCOORD_5:
case davinci::VET_TEXCOORD_6:
case davinci::VET_TEXCOORD_7:
if (dataType == davinci::DataType::DT_Vec2)
{
if (componentType == davinci::ComponentType::CT_Float32)
{
return inpuptBufferAccesser;
}
else if (componentType == davinci::ComponentType::CT_Uint8 || componentType == davinci::ComponentType::CT_Uint16)
{
return _createFloat32BufferAccessorFromNormalizedIntegerType(scene, inpuptBufferAccesser);
}
}
break;
case davinci::VET_COLOR_0:
case davinci::VET_COLOR_1:
case davinci::VET_COLOR_2:
case davinci::VET_COLOR_3:
case davinci::VET_COLOR_4:
case davinci::VET_COLOR_5:
case davinci::VET_COLOR_6:
case davinci::VET_COLOR_7:
if (dataType == davinci::DataType::DT_Vec3 || dataType == davinci::DataType::DT_Vec4)
{
if (componentType == davinci::ComponentType::CT_Float32)
{
return inpuptBufferAccesser;
}
else if (componentType == davinci::ComponentType::CT_Uint8 || componentType == davinci::ComponentType::CT_Uint16)
{
return _createFloat32BufferAccessorFromNormalizedIntegerType(scene, inpuptBufferAccesser);
}
}
break;
case davinci::VET_JOINTS_0:
case davinci::VET_JOINTS_1:
case davinci::VET_JOINTS_2:
case davinci::VET_JOINTS_3:
case davinci::VET_JOINTS_4:
case davinci::VET_JOINTS_5:
case davinci::VET_JOINTS_6:
case davinci::VET_JOINTS_7:
if (dataType == davinci::DataType::DT_Vec4)
{
if (componentType == davinci::ComponentType::CT_Uint8 || componentType == davinci::ComponentType::CT_Uint16)
{
return inpuptBufferAccesser;
}
}
break;
case davinci::VET_WEIGHTS_0:
case davinci::VET_WEIGHTS_1:
case davinci::VET_WEIGHTS_2:
case davinci::VET_WEIGHTS_3:
case davinci::VET_WEIGHTS_4:
case davinci::VET_WEIGHTS_5:
case davinci::VET_WEIGHTS_6:
case davinci::VET_WEIGHTS_7:
if (dataType == davinci::DataType::DT_Vec4)
{
if (componentType == davinci::ComponentType::CT_Float32)
{
return inpuptBufferAccesser;
}
else if (componentType == davinci::ComponentType::CT_Uint8 || componentType == davinci::ComponentType::CT_Uint16)
{
return _createFloat32BufferAccessorFromNormalizedIntegerType(scene, inpuptBufferAccesser);
}
}
break;
default:
break;
}
return nullptr;
}
bool _isSupportedIndicesType(const davinci::DeviceBufferAccessorConstPtr accesserBuffer)
{
if (!accesserBuffer) return false;
davinci::ComponentType componentType = accesserBuffer->getComponentType();
davinci::DataType dataType = accesserBuffer->getDataType();
return componentType == davinci::ComponentType::CT_Uint16 && dataType == davinci::DataType::DT_Scalar;
}
bool _loadDeviceBuffer(const tinygltf::Model& gltfModel, davinci::Scene& scene)
{
for (size_t i = 0; i < gltfModel.buffers.size(); i++)
@@ -225,6 +472,13 @@ bool _loadMesh(const tinygltf::Model& gltfModel, davinci::Scene& scene)
return false;
}
//convert to supported primitive buffer(float32)
deviceBufferAccessor = _createSupportedPrimitiveAttributeBufferAccessor(scene, vetype, deviceBufferAccessor);
if (deviceBufferAccessor == nullptr)
{
return false;
}
primitive->attributes.insert(std::make_pair(vetype, deviceBufferAccessor));
}
@@ -233,6 +487,12 @@ bool _loadMesh(const tinygltf::Model& gltfModel, davinci::Scene& scene)
{
return false;
}
bool isSupportedType = _isSupportedIndicesType(indicesBufferAccessor);
if (!isSupportedType)
{
return false;
}
primitive->indices = indicesBufferAccessor;
}
@@ -609,30 +869,9 @@ bool export_mesh_to_obj(const davinci::Scene& scene)
davinci::DeviceBufferAccessorConstPtr indexBufferAccessor = primitive->indices;
indexBufferAccessor->walk3([=](const uint8_t* ptr0, const uint8_t* ptr1, const uint8_t* ptr2, size_t index) {
uint32_t indice0, indice1, indice2;
if (indexBufferAccessor->getComponentType() == davinci::CT_Uint16)
{
indice0 = *((uint16_t*)ptr0) + 1;
indice1 = *((uint16_t*)ptr1) + 1;
indice2 = *((uint16_t*)ptr2) + 1;
}
else if (indexBufferAccessor->getComponentType() == davinci::CT_Uint32)
{
indice0 = *((uint32_t*)ptr0) + 1;
indice1 = *((uint32_t*)ptr1) + 1;
indice2 = *((uint32_t*)ptr2) + 1;
}
else if (indexBufferAccessor->getComponentType() == davinci::CT_Uint8)
{
indice0 = *((uint8_t*)ptr0) + 1;
indice1 = *((uint8_t*)ptr1) + 1;
indice2 = *((uint8_t*)ptr2) + 1;
}
else
{
//error
return true;
}
uint32_t indice0 = *((uint16_t*)ptr0) + 1;
uint32_t indice1 = *((uint16_t*)ptr1) + 1;
uint32_t indice2 = *((uint16_t*)ptr2) + 1;
if (bHasTex0)
{