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

增加材质和纹理

Browse Source
This commit is contained in:
jinchao
2025-10-26 20:07:32 +08:00
parent f847154ba2
commit 8db6f7b115
45 changed files with 1124 additions and 281 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/shader/test_pixel_shader.cpp
+92 -41
View File
@@ -1,79 +1,130 @@
#include "test_pixel_shader.h"
#include "device/dvc_device.h"
#include "device/dvc_uniform_buffer.h"
#include "asset/dvc_texture.h"
#include "shader/dvc_shader_functions.h"
#include "pipe/dvc_render_pipe.h"
using namespace davinci;
const char* TestPixelShader::getName(void) const
{
return "test";
}
void TestPixelShader::prepare(const davinci::UniformBuffer* uniformBuffer, SetInputAttributeFunc setInputAttributeFunc)
void TestPixelShader::prepare(const RenderPipe* pipe, SetInputAttributeFunc setInputAttributeFunc)
{
m_pipe = pipe;
}
void TestPixelShader::process(const davinci::VertexDesc& veretexDesc, const float32_t* pixelData, davinci::fVector4& color)
void TestPixelShader::process(const VertexDesc& veretexDesc, const float32_t* pixelData, 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::UniformBuffer& uniformBuffer = m_pipe->getUniformBuffer();
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 VertexDesc::Element* v_normal_Element = veretexDesc.getElement("v_normal");
const fVector3* v_normal = (const 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 VertexDesc::Element* v_uv_Element = veretexDesc.getElement("v_uv");
const fVector2* v_uv = (const fVector2*)(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)));
const VertexDesc::Element* v_toCamera_Element = veretexDesc.getElement("v_toCamera");
const fVector3* v_toCamera = (const fVector3*)(pixelData + (v_toCamera_Element->offset / sizeof(float32_t)));
const davinci::VertexDesc::Element* v_toLight_Element = veretexDesc.getElement("v_toLight");
const davinci::fVector3* v_toLight = (const davinci::fVector3*)(pixelData + (v_toLight_Element->offset / sizeof(float32_t)));
const VertexDesc::Element* v_toLight_Element = veretexDesc.getElement("v_toLight");
const fVector3* v_toLight = (const fVector3*)(pixelData + (v_toLight_Element->offset / sizeof(float32_t)));
const davinci::VertexDesc::Element* v_color0_Element = veretexDesc.getElement("v_color0");
const davinci::fVector3* v_color0 = (const davinci::fVector3*)(pixelData + (v_color0_Element->offset / sizeof(float32_t)));
const VertexDesc::Element* v_tangent_Element = veretexDesc.getElement("v_tangent");
const fVector3* v_tangent = (const fVector3*)(pixelData + (v_tangent_Element->offset / sizeof(float32_t)));
const VertexDesc::Element* v_binormal_Element = veretexDesc.getElement("v_binormal");
const fVector3* v_binormal = (const fVector3*)(pixelData + (v_binormal_Element->offset / sizeof(float32_t)));
const VertexDesc::Element* v_wposition_Element = veretexDesc.getElement("v_wposition");
const fVector3* v_wposition = (const fVector3*)(pixelData + (v_wposition_Element->offset / sizeof(float32_t)));
fMatrix3 tbnMatrix = fMatrix3(
v_tangent->x, v_binormal->x, v_normal->x,
v_tangent->y, v_binormal->y, v_normal->y,
v_tangent->z, v_binormal->z, v_normal->z);
davinci::fVector3 light0_position = davinci::fVector3::ZERO;
if (davinci::fVector3* p_light0_position = (davinci::fVector3*)(uniformBuffer.getAttribute("light0:position")))
{
light0_position = *p_light0_position;
}
//davinci::fVector3 camera_position = davinci::fVector3::ZERO;
//if (davinci::fVector3* p_camera_position = (davinci::fVector3*)(uniformBuffer.getAttribute("camera:eye_pos")))
//{
// camera_position = *p_camera_position;
//}
fVector3 lp = light0_position - *v_wposition;
fVector3 vLight = lp.normalise() * tbnMatrix;
fVector3 u_ambientColor = fVector3(0.2, 0.2, 0.2);
fVector3 u_matColor = fVector3(1.0, 1.0, 1.0);
fVector3 u_lightColor = fVector3(1.0, 1.0, 1.0);
fVector4 u_textureColor = shader::texture2D(*m_pipe, "material:pbr:base_color_texture", *v_uv, fVector4::WHITE);
const fVector4 defaultNormal = fVector4(0.5f, 0.5f, 1.0f, 1.0f);
fVector4 u_normalColor = shader::texture2D(*m_pipe, "material:pbr:normal_texture", *v_uv, defaultNormal);
//----------------
fVector3 vN = fVector3::UNIT_Z;// u_normalColor.xyz() * 2.0f - fVector3::ONE;
vN.normalise();
//vector vL = normalize(v_toLight);
davinci::fVector3 vL = *v_toLight;
fVector3 vL =vLight;
vL.normalise();
//vector vV = normalize(v_toCamera);
davinci::fVector3 vV = *v_toCamera;
fVector3 vV = *v_toCamera;
vV.normalise();
//vector vN = normalize(v_normal);
davinci::fVector3 vN = *v_normal;
vN.normalise();
float ndotl = vL.dotProduct(vN);
//vector vR = 2 * dot(vL, vN)*vN - vL;
davinci::fVector3 vR = 2 * vL.dotProduct(vN) * vN - vL;
fVector3 vR = 2 * ndotl * vN - vL;
float rdotv = vR.dotProduct(vV);
//vector vH = normalize(vL + vV);
davinci::fVector3 vH = vL + vV;
vH.normalise();
//fVector3 vH = vL + vV;
//vH.normalise();
davinci::fVector3 u_ambientColor = davinci::fVector3(0.2, 0.2, 0.2);
davinci::fVector3 u_matColor = davinci::fVector3(0.7, 0.7, 0.7);
davinci::fVector3 u_lightColor = davinci::fVector3(1.0, 1.0, 1.0);
//color colAmbient = u_ambientColor*u_matColor;
davinci::fVector3 colAmbient = u_ambientColor * u_matColor;
fVector3 colAmbient = u_ambientColor * u_matColor;
//float ndotl = max(dot(vN, vL), 0);
float32_t ndotl = std::max(vN.dotProduct(vL), 0.0f);
//float32_t ndotl = std::max(vN.dotProduct(vL), 0.0f);
//color colDiff = ndotl * u_matColor * u_lightColor;
davinci::fVector3 colDiff = ndotl * u_matColor * u_lightColor;
fVector3 colDiff = shader::max(0.0f, ndotl) * u_matColor* u_lightColor;
//float spec = max(dot(vN, vH), 0);
float32_t spec = std::max(vN.dotProduct(vH), 0.0f);
//float32_t spec = std::max(vR.dotProduct(vV), 0.0f)*1.0;
//color colSpec = step(0, ndotl) * pow(spec, 64) * u_matColor * u_lightColor;
davinci::fVector3 colSpec = (ndotl < 0.f ? 0.0 : 1.0) * std::powf(spec, 64.f) * u_matColor * u_lightColor;
const float _m = 1.0f;
float spec = shader::step(0.0f, ndotl) * shader::pow(shader::max(0.0f, rdotv), 32.f);
fVector3 colSpec = spec * u_matColor* u_lightColor;
//color final = colAmbient + colDiff + colSpec;
davinci::fVector3 final = colAmbient +colDiff +colSpec;
//davinci::fVector3 final = *v_color0;
fVector3 final = fVector3::BLACK;// (colAmbient + colDiff + colSpec)* u_textureColor.xyz();
//color = davinci::fVector4::RED;
color = davinci::fVector4(final.saturate(), 1.0f);// davinci::fVector4::RED;
final += colAmbient;
final += colDiff;
final += colSpec;
final *= u_textureColor.xyz();
//fVector3 final = (colAmbient +colDiff +colSpec)*u_textureColor.xyz();
//color = fVector4::RED;
color = fVector4(final.saturate(), 1.0f);// fVector4::RED;
}
const char* SolidColorPixelShader::getName(void) const
@@ -81,12 +132,12 @@ const char* SolidColorPixelShader::getName(void) const
return "solid";
}
void SolidColorPixelShader::prepare(const davinci::UniformBuffer* uniformBuffer, SetInputAttributeFunc setInputAttributeFunc)
void SolidColorPixelShader::prepare(const RenderPipe* pipe, SetInputAttributeFunc setInputAttributeFunc)
{
}
void SolidColorPixelShader::process(const davinci::VertexDesc& veretexDesc, const float32_t* pixelData, davinci::fVector4& color)
void SolidColorPixelShader::process(const VertexDesc& veretexDesc, const float32_t* pixelData, fVector4& color)
{
color = davinci::fVector4::RED;
color = fVector4::RED;
}
test/shader/test_pixel_shader.h
+4 -2
View File
@@ -8,10 +8,12 @@ class TestPixelShader : public davinci::PixelShaderInterface
public:
virtual const char* getName(void) const;
virtual void prepare(const davinci::UniformBuffer* uniformBuffer, SetInputAttributeFunc setInputAttributeFunc);
virtual void prepare(const davinci::RenderPipe* pipe, SetInputAttributeFunc setInputAttributeFunc);
virtual void process(const davinci::VertexDesc& veretexDesc, const float32_t* pixelData,
davinci::fVector4& color);
private:
const davinci::RenderPipe* m_pipe = nullptr;
};
class SolidColorPixelShader : public davinci::PixelShaderInterface
@@ -19,7 +21,7 @@ class SolidColorPixelShader : public davinci::PixelShaderInterface
public:
virtual const char* getName(void) const;
virtual void prepare(const davinci::UniformBuffer* uniformBuffer, SetInputAttributeFunc setInputAttributeFunc);
virtual void prepare(const davinci::RenderPipe* pipe, SetInputAttributeFunc setInputAttributeFunc);
virtual void process(const davinci::VertexDesc& veretexDesc, const float32_t* pixelData,
davinci::fVector4& color);
test/shader/test_vertex_shader.cpp
+33 -20
View File
@@ -3,6 +3,7 @@
#include "math/dvc_vector2.h"
#include "math/dvc_vector3.h"
#include "math/dvc_matrix4.h"
#include "pipe/dvc_render_pipe.h"
#include "device/dvc_uniform_buffer.h"
TestVertexShader::TestVertexShader()
@@ -18,7 +19,9 @@ TestVertexShader::TestVertexShader()
//output vector v_toLight = vector(0,0,0)
m_outputVertexDesc.addElement("v_toLight", davinci::VET_UNKNOWN, davinci::CT_Float32, davinci::DT_Vec3);
m_outputVertexDesc.addElement("v_color0", davinci::VET_UNKNOWN, davinci::CT_Float32, davinci::DT_Vec3);
m_outputVertexDesc.addElement("v_tangent", davinci::VET_TANGENT, davinci::CT_Float32, davinci::DT_Vec3);
m_outputVertexDesc.addElement("v_binormal", davinci::VET_BINORMAL, davinci::CT_Float32, davinci::DT_Vec3);
m_outputVertexDesc.addElement("v_wposition", davinci::VET_UNKNOWN, davinci::CT_Float32, davinci::DT_Vec3);
}
TestVertexShader::~TestVertexShader()
@@ -41,9 +44,9 @@ const davinci::VertexDesc& TestVertexShader::getOutputVertexDesc() const
return m_outputVertexDesc;
}
void TestVertexShader::prepare(const davinci::UniformBuffer* uniformBuffer, SetInputAttributeFunc setInputAttributeFunc)
void TestVertexShader::prepare(const davinci::RenderPipe* pipe, SetInputAttributeFunc setInputAttributeFunc)
{
m_uniformBuffer = uniformBuffer;
m_pipe = pipe;
//point a_position = vector(0, 0, 0) [[ string attribute="POSITION"]],
m_POSITION = setInputAttributeFunc(davinci::VET_POSITION);
@@ -52,7 +55,7 @@ void TestVertexShader::prepare(const davinci::UniformBuffer* uniformBuffer, SetI
//float a_uv[2] = {0,0} [[ string attribute="TEXCOORD_0"]],
m_TEXCOORD_0 = setInputAttributeFunc(davinci::VET_TEXCOORD_0);
//
m_COLOR_0 = setInputAttributeFunc(davinci::VET_COLOR_0);
m_TANGENT = setInputAttributeFunc(davinci::VET_TANGENT);
}
void TestVertexShader::process(size_t index, void* outputVertex, davinci::fVector3& vertexWorldPos)
@@ -60,7 +63,9 @@ void TestVertexShader::process(size_t index, void* outputVertex, davinci::fVecto
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 };
static const float32_t DEFAULT_TANGENT[] = { 1.f, 0.f, 0.f };
const davinci::UniformBuffer& uniformBuffer = m_pipe->getUniformBuffer();
davinci::fVector3 a_position(m_POSITION ? (const float32_t*)(m_POSITION->getElement(index)) : DEFAULT_POSITION);
@@ -68,28 +73,28 @@ void TestVertexShader::process(size_t index, void* outputVertex, davinci::fVecto
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::fVector3 a_tangent(m_TANGENT ? (const float32_t*)(m_TANGENT->getElement(index)) : DEFAULT_TANGENT);
davinci::fMatrix4 mat_world = davinci::fMatrix4::IDENTITY;
if (davinci::fMatrix4* p_mat_world = (davinci::fMatrix4*)(m_uniformBuffer->getAttribute("self:world_transform")))
if (davinci::fMatrix4* p_mat_world = (davinci::fMatrix4*)(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")))
if (davinci::fMatrix4* p_mat_camera_view_proj = (davinci::fMatrix4*)(uniformBuffer.getAttribute("camera:view_proj_mat")))
{
mat_camera_view_proj = *p_mat_camera_view_proj;
}
davinci::fVector3 camera_position = davinci::fVector3::ZERO;
if (davinci::fVector3* p_camera_position = (davinci::fVector3*)(m_uniformBuffer->getAttribute("camera:eye_pos")))
if (davinci::fVector3* p_camera_position = (davinci::fVector3*)(uniformBuffer.getAttribute("camera:eye_pos")))
{
camera_position = *p_camera_position;
}
davinci::fVector3 light0_position = davinci::fVector3::ZERO;
if (davinci::fVector3* p_light0_position = (davinci::fVector3*)(m_uniformBuffer->getAttribute("light0:position")))
if (davinci::fVector3* p_light0_position = (davinci::fVector3*)(uniformBuffer.getAttribute("light0:position")))
{
light0_position = *p_light0_position;
}
@@ -98,23 +103,30 @@ void TestVertexShader::process(size_t index, void* outputVertex, davinci::fVecto
davinci::fVector3 v_position = mat_camera_view_proj * temp1;
davinci::fMatrix4 matNormal = davinci::fMatrix4::IDENTITY;
if (davinci::fMatrix4* p_mat_normal = (davinci::fMatrix4*)(m_uniformBuffer->getAttribute("self:world_transform_inverse_trans")))
if (davinci::fMatrix4* p_mat_normal = (davinci::fMatrix4*)(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_tangent = (matNormal * davinci::fVector4(a_tangent, 0)).xyz().normalise();
davinci::fVector3 v_binormal = v_normal.crossProduct(v_tangent).normalise();
davinci::fVector3 v_color_0 = a_color_0;
davinci::fMatrix3 tbnMatrix = davinci::fMatrix3(
v_tangent.x, v_binormal.x, v_normal.x,
v_tangent.y, v_binormal.y, v_normal.y,
v_tangent.z, v_binormal.z, v_normal.z);
davinci::fVector3 v_to_camera = (camera_position - temp1).normalise();
davinci::fVector3 v_to_light = (light0_position - temp1).normalise();
davinci::fVector3 v_to_camera = (camera_position - temp1).normalise() * tbnMatrix;
davinci::fVector3 v_to_light = (light0_position - temp1).normalise() * tbnMatrix;
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, &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));
memcpy((char*)outputVertex + m_outputVertexDesc.getElement(5)->offset, &v_tangent, sizeof(davinci::fVector3));
memcpy((char*)outputVertex + m_outputVertexDesc.getElement(6)->offset, &v_binormal, sizeof(davinci::fVector3));
memcpy((char*)outputVertex + m_outputVertexDesc.getElement(7)->offset, &temp1, sizeof(davinci::fVector3));
vertexWorldPos = mat_world * a_position;
}
@@ -122,7 +134,6 @@ void TestVertexShader::process(size_t index, void* outputVertex, davinci::fVecto
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);
}
@@ -147,9 +158,9 @@ const davinci::VertexDesc& StandardVertexShader::getOutputVertexDesc() const
return m_outputVertexDesc;
}
void StandardVertexShader::prepare(const davinci::UniformBuffer* uniformBuffer, SetInputAttributeFunc setInputAttributeFunc)
void StandardVertexShader::prepare(const davinci::RenderPipe* pipe, SetInputAttributeFunc setInputAttributeFunc)
{
m_uniformBuffer = uniformBuffer;
m_pipe = pipe;
//point a_position = vector(0, 0, 0) [[ string attribute="POSITION"]],
m_POSITION = setInputAttributeFunc(davinci::VET_POSITION);
@@ -159,16 +170,18 @@ void StandardVertexShader::process(size_t index, void* outputVertex, davinci::fV
{
static const float DEFAULT_POSITION[] = {0.f, 0.f, 0.f};
const davinci::UniformBuffer& uniformBuffer = m_pipe->getUniformBuffer();
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")))
if (davinci::fMatrix4* p_mat_world = (davinci::fMatrix4*)(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")))
if (davinci::fMatrix4* p_mat_camera_view_proj = (davinci::fMatrix4*)(uniformBuffer.getAttribute("camera:view_proj_mat")))
{
mat_camera_view_proj = *p_mat_camera_view_proj;
}
test/shader/test_vertex_shader.h
+6 -5
View File
@@ -13,16 +13,17 @@ public:
virtual const davinci::VertexDesc& getOutputVertexDesc() const;
virtual size_t getOutputVertexByteSize(void) const;
virtual void prepare(const davinci::UniformBuffer* uniformBuffer, SetInputAttributeFunc setInputAttributeFunc);
virtual void prepare(const davinci::RenderPipe* pipe, SetInputAttributeFunc setInputAttributeFunc);
virtual void process(size_t index, void* outputVertex, davinci::fVector3& vertexWorldPos);
private:
const davinci::UniformBuffer* m_uniformBuffer;
const davinci::RenderPipe* m_pipe = nullptr;
davinci::DeviceBufferAccessorConstPtr m_POSITION;
davinci::DeviceBufferAccessorConstPtr m_NORMAL;
davinci::DeviceBufferAccessorConstPtr m_TEXCOORD_0;
davinci::DeviceBufferAccessorConstPtr m_COLOR_0;
davinci::DeviceBufferAccessorConstPtr m_TANGENT;
davinci::VertexDesc m_outputVertexDesc;
@@ -37,11 +38,11 @@ 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 prepare(const davinci::RenderPipe* pipe, SetInputAttributeFunc setInputAttributeFunc);
virtual void process(size_t index, void* outputVertex, davinci::fVector3& vertexWorldPos);
private:
const davinci::UniformBuffer* m_uniformBuffer = nullptr;
const davinci::RenderPipe* m_pipe = nullptr;
davinci::DeviceBufferAccessorConstPtr m_POSITION;
davinci::VertexDesc m_outputVertexDesc;