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
test/rasterization/dvr_canvas.cpp
+1 -1
View File
@@ -15,7 +15,7 @@ void Canvas::reset(int32_t width, int32_t height)
{
m_pixels[i].fragementID = -1;
m_pixels[i].mask = 0;
m_pixels[i].color = 0;
m_pixels[i].color = davinci::fVector3::BLACK;
}
m_fragementArray.clear();
test/shader/dll_main.cpp
+21 -3
View File
@@ -9,13 +9,31 @@ class TestShaderInterface : public davinci::ShaderFileInterface
public:
virtual davinci::VertexShaderInterface* getVertexShader(const char* szName)
{
static TestVertexShader testVertexShader;
return &testVertexShader;
if (strcmp(szName, "standard") == 0)
{
static StandardVertexShader standardVertexShader;
return &standardVertexShader;
}
else if (strcmp(szName, "test") == 0)
{
static TestVertexShader testVertexShader;
return &testVertexShader;
}
return nullptr;
}
virtual davinci::PixelShaderInterface* getPixelShader(const char* szName)
{
static SolidColorPixelShader solidColorPixelShader;
static TestPixelShader testPixelShader;
return &testPixelShader;
if(strcmp(szName, solidColorPixelShader.getName()) == 0)
{
return &solidColorPixelShader;
}
else if (strcmp(szName, testPixelShader.getName()) == 0)
{
return &testPixelShader;
}
return nullptr;
}
};
test/shader/test_pixel_shader.cpp
+25 -9
View File
@@ -2,7 +2,7 @@
const char* TestPixelShader::getName(void) const
{
return "test_pixel_shader";
return "test";
}
void TestPixelShader::prepare(const davinci::UniformBuffer* uniformBuffer, SetInputAttributeFunc setInputAttributeFunc)
@@ -12,14 +12,14 @@ void TestPixelShader::prepare(const davinci::UniformBuffer* uniformBuffer, SetIn
void TestPixelShader::process(const davinci::VertexDesc& veretexDesc, const float32_t* pixelData, davinci::fVector4& color)
{
const davinci::VertexDesc::Element* v_position_Element = veretexDesc.getElement("v_position");
const davinci::fVector3* v_position = (const davinci::fVector3*)(pixelData + (v_position_Element->offset / sizeof(float32_t)));
//const davinci::VertexDesc::Element* v_position_Element = veretexDesc.getElement("v_position");
//const davinci::fVector3* v_position = (const davinci::fVector3*)(pixelData + (v_position_Element->offset / sizeof(float32_t)));
const davinci::VertexDesc::Element* v_normal_Element = veretexDesc.getElement("v_normal");
const davinci::fVector3* v_normal = (const davinci::fVector3*)(pixelData + (v_normal_Element->offset / sizeof(float32_t)));
const davinci::VertexDesc::Element* v_uv_Element = veretexDesc.getElement("v_uv");
const float32_t* v_uv = (const float32_t*)(pixelData + (v_uv_Element->offset / sizeof(float32_t)));
//const davinci::VertexDesc::Element* v_uv_Element = veretexDesc.getElement("v_uv");
//const float32_t* v_uv = (const float32_t*)(pixelData + (v_uv_Element->offset / sizeof(float32_t)));
const davinci::VertexDesc::Element* v_toCamera_Element = veretexDesc.getElement("v_toCamera");
const davinci::fVector3* v_toCamera = (const davinci::fVector3*)(pixelData + (v_toCamera_Element->offset / sizeof(float32_t)));
@@ -49,9 +49,9 @@ void TestPixelShader::process(const davinci::VertexDesc& veretexDesc, const floa
davinci::fVector3 vH = vL + vV;
vH.normalise();
davinci::fVector3 u_ambientColor = davinci::fVector3(0.1, 0.1, 0.1);
davinci::fVector3 u_ambientColor = davinci::fVector3(0.2, 0.2, 0.2);
davinci::fVector3 u_matColor = davinci::fVector3(1.0, 0.5, 0.7);
davinci::fVector3 u_matColor = davinci::fVector3(0.7, 0.7, 0.7);
davinci::fVector3 u_lightColor = davinci::fVector3(1.0, 1.0, 1.0);
@@ -69,8 +69,24 @@ void TestPixelShader::process(const davinci::VertexDesc& veretexDesc, const floa
davinci::fVector3 colSpec = (ndotl < 0.f ? 0.0 : 1.0) * std::powf(spec, 64.f) * u_matColor * u_lightColor;
//color final = colAmbient + colDiff + colSpec;
davinci::fVector3 final = colAmbient + colDiff + colSpec;
davinci::fVector3 final = colAmbient +colDiff +colSpec;
//davinci::fVector3 final = *v_color0;
//color = davinci::fVector4::RED;
color = davinci::fVector4(final.saturate(), 1.0f);// davinci::fVector4::RED;
}
}
const char* SolidColorPixelShader::getName(void) const
{
return "solid";
}
void SolidColorPixelShader::prepare(const davinci::UniformBuffer* uniformBuffer, SetInputAttributeFunc setInputAttributeFunc)
{
}
void SolidColorPixelShader::process(const davinci::VertexDesc& veretexDesc, const float32_t* pixelData, davinci::fVector4& color)
{
color = davinci::fVector4::RED;
}
test/shader/test_pixel_shader.h
+12 -1
View File
@@ -12,4 +12,15 @@ public:
virtual void process(const davinci::VertexDesc& veretexDesc, const float32_t* pixelData,
davinci::fVector4& color);
};
};
class SolidColorPixelShader : public davinci::PixelShaderInterface
{
public:
virtual const char* getName(void) const;
virtual void prepare(const davinci::UniformBuffer* uniformBuffer, SetInputAttributeFunc setInputAttributeFunc);
virtual void process(const davinci::VertexDesc& veretexDesc, const float32_t* pixelData,
davinci::fVector4& color);
};
test/shader/test_vertex_shader.cpp
+81 -21
View File
@@ -28,7 +28,7 @@ TestVertexShader::~TestVertexShader()
const char* TestVertexShader::getName(void) const
{
return "test_vertex_shader";
return "test";
}
size_t TestVertexShader::getOutputVertexByteSize(void) const
@@ -57,21 +57,18 @@ void TestVertexShader::prepare(const davinci::UniformBuffer* uniformBuffer, SetI
void TestVertexShader::process(size_t index, void* outputVertex, davinci::fVector3& vertexWorldPos)
{
static const float DEFAULT_POSITION[] = {0.f, 0.f, 0.f};
static const float DEFAULT_NORMAL[] = { 0.f, 0.f, 0.f };
static const float DEFAULT_TEXCOORD0[] = { 0.f, 0.f};
static const uint16_t DEFAULT_COLOR0[] = { 0, 0, 0 };
static const float32_t DEFAULT_POSITION[] = {0.f, 0.f, 0.f};
static const float32_t DEFAULT_NORMAL[] = { 0.f, 0.f, 0.f };
static const float32_t DEFAULT_TEXCOORD0[] = { 0.f, 0.f};
static const float32_t DEFAULT_COLOR0[] = { 0.f, 0.f, 0.f };
davinci::fVector3 a_position(m_POSITION ? (const float*)(m_POSITION->getElement(index)) : DEFAULT_POSITION);
davinci::fVector3 a_normal(m_NORMAL ? (const float*)(m_NORMAL->getElement(index)) : DEFAULT_NORMAL);
const float32_t* a_texcoord_0(m_TEXCOORD_0 ? (const float*)(m_TEXCOORD_0->getElement(index)) : DEFAULT_TEXCOORD0);
const uint16_t* color0 = m_COLOR_0 ? (const uint16_t*)(m_COLOR_0->getElement(index)) : DEFAULT_COLOR0;
davinci::fVector3 a_position(m_POSITION ? (const float32_t*)(m_POSITION->getElement(index)) : DEFAULT_POSITION);
davinci::fVector3 a_color_0(
color0[0] / float(std::numeric_limits<uint16_t>::max()),
color0[1] / float(std::numeric_limits<uint16_t>::max()),
color0[2] / float(std::numeric_limits<uint16_t>::max())
);
davinci::fVector3 a_normal(m_NORMAL ? (const float32_t*)(m_NORMAL->getElement(index)) : DEFAULT_NORMAL);
davinci::fVector2 a_uv(m_TEXCOORD_0 ? (const float32_t*)(m_TEXCOORD_0->getElement(index)) : DEFAULT_TEXCOORD0);
davinci::fVector3 a_color_0(m_COLOR_0 ? (const float32_t*)(m_COLOR_0->getElement(index)) : DEFAULT_COLOR0);
davinci::fMatrix4 mat_world = davinci::fMatrix4::IDENTITY;
if (davinci::fMatrix4* p_mat_world = (davinci::fMatrix4*)(m_uniformBuffer->getAttribute("self:world_transform")))
@@ -100,19 +97,21 @@ void TestVertexShader::process(size_t index, void* outputVertex, davinci::fVecto
davinci::fVector3 temp1 = mat_world * a_position;
davinci::fVector3 v_position = mat_camera_view_proj * temp1;
davinci::fVector3 v_normal = a_normal;
davinci::fMatrix4 matNormal = davinci::fMatrix4::IDENTITY;
if (davinci::fMatrix4* p_mat_normal = (davinci::fMatrix4*)(m_uniformBuffer->getAttribute("self:world_transform_inverse_trans")))
{
matNormal = *p_mat_normal;
}
davinci::fVector3 v_normal = (matNormal * davinci::fVector4(a_normal, 0)).xyz().normalise();
davinci::fVector3 v_color_0 = a_color_0;
float32_t v_uv[2];
memcpy(v_uv, a_texcoord_0, sizeof(float32_t) * 2);
davinci::fVector3 v_to_camera = (camera_position - v_position).normalise();
davinci::fVector3 v_to_light = (light0_position - v_position).normalise();
davinci::fVector3 v_to_camera = (camera_position - temp1).normalise();
davinci::fVector3 v_to_light = (light0_position - temp1).normalise();
memcpy((char*)outputVertex + m_outputVertexDesc.getElement(0)->offset, &v_position, sizeof(davinci::fVector3));
memcpy((char*)outputVertex + m_outputVertexDesc.getElement(1)->offset, &v_normal, sizeof(davinci::fVector3));
memcpy((char*)outputVertex + m_outputVertexDesc.getElement(2)->offset, v_uv, sizeof(float32_t) * 2);
memcpy((char*)outputVertex + m_outputVertexDesc.getElement(2)->offset, &a_uv, sizeof(float32_t) * 2);
memcpy((char*)outputVertex + m_outputVertexDesc.getElement(3)->offset, &v_to_camera, sizeof(davinci::fVector3));
memcpy((char*)outputVertex + m_outputVertexDesc.getElement(4)->offset, &v_to_light, sizeof(davinci::fVector3));
memcpy((char*)outputVertex + m_outputVertexDesc.getElement(5)->offset, &v_color_0, sizeof(davinci::fVector3));
@@ -120,3 +119,64 @@ void TestVertexShader::process(size_t index, void* outputVertex, davinci::fVecto
vertexWorldPos = mat_world * a_position;
}
StandardVertexShader::StandardVertexShader()
{
m_uniformBuffer = nullptr;
//output point v_position = point(0, 0, 0) [[ string attribute="POSITION"]],
m_outputVertexDesc.addElement("v_position", davinci::VET_POSITION, davinci::CT_Float32, davinci::DT_Vec3);
}
StandardVertexShader::~StandardVertexShader()
{
}
const char* StandardVertexShader::getName(void) const
{
return "standard";
}
size_t StandardVertexShader::getOutputVertexByteSize(void) const
{
return m_outputVertexDesc.vertexByteSize();
}
const davinci::VertexDesc& StandardVertexShader::getOutputVertexDesc() const
{
return m_outputVertexDesc;
}
void StandardVertexShader::prepare(const davinci::UniformBuffer* uniformBuffer, SetInputAttributeFunc setInputAttributeFunc)
{
m_uniformBuffer = uniformBuffer;
//point a_position = vector(0, 0, 0) [[ string attribute="POSITION"]],
m_POSITION = setInputAttributeFunc(davinci::VET_POSITION);
}
void StandardVertexShader::process(size_t index, void* outputVertex, davinci::fVector3& vertexWorldPos)
{
static const float DEFAULT_POSITION[] = {0.f, 0.f, 0.f};
davinci::fVector3 a_position(m_POSITION ? (const float32_t*)(m_POSITION->getElement(index)) : DEFAULT_POSITION);
davinci::fMatrix4 mat_world = davinci::fMatrix4::IDENTITY;
if (davinci::fMatrix4* p_mat_world = (davinci::fMatrix4*)(m_uniformBuffer->getAttribute("self:world_transform")))
{
mat_world = *p_mat_world;
}
davinci::fMatrix4 mat_camera_view_proj = davinci::fMatrix4::IDENTITY;
if (davinci::fMatrix4* p_mat_camera_view_proj = (davinci::fMatrix4*)(m_uniformBuffer->getAttribute("camera:view_proj_mat")))
{
mat_camera_view_proj = *p_mat_camera_view_proj;
}
davinci::fVector3 temp1 = mat_world * a_position;
davinci::fVector3 v_position = mat_camera_view_proj * temp1;
memcpy((char*)outputVertex + m_outputVertexDesc.getElement(0)->offset, &v_position, sizeof(davinci::fVector3));
vertexWorldPos = mat_world * a_position;
}
test/shader/test_vertex_shader.h
+19
View File
@@ -31,3 +31,22 @@ public:
virtual ~TestVertexShader();
};
class StandardVertexShader : public davinci::VertexShaderInterface
{
public:
virtual const char* getName(void) const;
virtual const davinci::VertexDesc& getOutputVertexDesc() const;
virtual size_t getOutputVertexByteSize(void) const;
virtual void prepare(const davinci::UniformBuffer* uniformBuffer, SetInputAttributeFunc setInputAttributeFunc);
virtual void process(size_t index, void* outputVertex, davinci::fVector3& vertexWorldPos);
private:
const davinci::UniformBuffer* m_uniformBuffer = nullptr;
davinci::DeviceBufferAccessorConstPtr m_POSITION;
davinci::VertexDesc m_outputVertexDesc;
public:
StandardVertexShader();
virtual ~StandardVertexShader();
};