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

重构材质系统

Browse Source
This commit is contained in:
jinchao
2025-12-03 23:38:08 +08:00
parent bf62257884
commit 3c0e177905
47 changed files with 755 additions and 1151 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/shaders/standard/CMakeLists.txt
+7 -5
View File
@@ -1,17 +1,19 @@
add_library(dv_standard_shaders SHARED
dll_main.cpp
vs_standard.h
vs_standard.inc
vs_standard.cpp
fs_debug_solid_color.h
fs_debug_solid_color.cpp
fs_debug_base_color.h
fs_debug_base_color.cpp
fs_debug_normal_texture.h
fs_debug_normal_texture.cpp
fs_debug_show_texture.h
fs_debug_show_texture.cpp
fs_debug_texture_coordinates.h
fs_debug_texture_coordinates.cpp
fs_debug_geometry_normal.h
fs_debug_geometry_normal.cpp
fs_classic_phong.h
fs_classic_phong.cpp
fs_pbr_gltf.h
fs_pbr_gltf.cpp
)
add_definitions(-DDV_SHADER_EXPORTS)
source/shaders/standard/dll_main.cpp
+14 -8
View File
@@ -3,10 +3,11 @@
#include "vs_standard.h"
#include "fs_debug_solid_color.h"
#include "fs_debug_base_color.h"
#include "fs_debug_normal_texture.h"
#include "fs_debug_show_texture.h"
#include "fs_debug_texture_coordinates.h"
#include "fs_debug_geometry_normal.h"
#include "fs_classic_phong.h"
#include "fs_pbr_gltf.h"
class StandardShaderInterface : public davinci::ShaderFileInterface
{
@@ -28,16 +29,21 @@ public:
public:
StandardShaderInterface()
{
registerVertexShader(new StandardVertexShader<false , false>());
registerVertexShader(new StandardVertexShader<true , false>());
registerVertexShader(new StandardVertexShader<false , true>());
registerVertexShader(new StandardVertexShader<true , true>());
registerVertexShader(new StandardVertexShader(false , false , false));
registerVertexShader(new StandardVertexShader(false , false , true));
registerVertexShader(new StandardVertexShader(false , true , false));
registerVertexShader(new StandardVertexShader(false , true , true));
registerVertexShader(new StandardVertexShader(true , false , false));
registerVertexShader(new StandardVertexShader(true , false , true));
registerVertexShader(new StandardVertexShader(true , true , false));
registerVertexShader(new StandardVertexShader(true , true , true));
registerFragementShader(new DebugFragementShader_SolidColor());
registerFragementShader(new DebugFragementShader_BaseColor());
registerFragementShader(new DebugFragementShader_NormalTexture());
registerFragementShader(new DebugFragementShader_ShowTexture());
registerFragementShader(new DebugFragementShader_TextureCoordinates());
registerFragementShader(new DebugFragementShader_GeometryNormal());
registerFragementShader(new ClassicFragementShader_Phong());
registerFragementShader(new PbrFragementShader_GLTF());
}
~StandardShaderInterface()
source/shaders/standard/fs_classic_phong.cpp
+77
View File
@@ -0,0 +1,77 @@
#include "fs_classic_phong.h"
#include "asset/dvc_material.h"
#include "pipe/dvc_render_pipe.h"
#include "shader/dvc_shader_functions.h"
using namespace davinci;
const char* ClassicFragementShader_Phong::getName(void) const
{
return "classic:phong";
}
void ClassicFragementShader_Phong::begin(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material)
{
m_pipe = pipe;
const davinci::UniformBuffer& uniformBuffer = m_pipe->getUniformBuffer();
material->getParam("u_materialColor", m_materialColor);
material->getParam("u_specularShininess", m_specularShininess);
material->getParam("u_specularStrength", m_specularStrength);
if (davinci::fVector3* p_ambient_light_color = (davinci::fVector3*)(uniformBuffer.getAttribute("ambient_light:color")))
{
m_ambientLightColor = *p_ambient_light_color;
}
if (davinci::fVector3* p_light0_position = (davinci::fVector3*)(uniformBuffer.getAttribute("light0:position")))
{
m_light0Position = *p_light0_position;
}
if (davinci::fVector3* p_light0_color = (davinci::fVector3*)(uniformBuffer.getAttribute("light0:color")))
{
m_light0Color = *p_light0_color;
}
if (davinci::fVector3* p_camera_position = (davinci::fVector3*)(uniformBuffer.getAttribute("camera:eye_pos")))
{
m_cameraPosition = *p_camera_position;
}
}
void ClassicFragementShader_Phong::process(const davinci::VertexDesc& veretexDesc, const float32_t* pixelData, davinci::fVector4& color)
{
const VertexDesc::Element* v_worldpos_Element = veretexDesc.getElement(davinci::VET_POSITION_WORLD);
fVector3 v_worldpos = v_worldpos_Element ? *((const fVector3*)(pixelData + (v_worldpos_Element->offset / sizeof(float32_t)))) : fVector3::ZERO;
const VertexDesc::Element* v_normal_Element = veretexDesc.getElement(davinci::VET_NORMAL);
fVector3 v_normal = v_normal_Element ? *((const fVector3*)(pixelData + (v_normal_Element->offset / sizeof(float32_t)))) : fVector3::UNIT_Z;
fVector3 toLight = m_light0Position - v_worldpos;
toLight.normalise();
fVector3 toCamera = m_cameraPosition - v_worldpos;
toCamera.normalise();
float32_t ndotl = toLight.dotProduct(v_normal);
fVector3 vR = 2 * ndotl*v_normal - toLight;
float32_t rdotv = vR.dotProduct(toCamera);
fVector3 colAmbient = m_ambientLightColor * m_materialColor.xyz();
fVector3 colDiffuse = shader::max(0.0f, ndotl) * m_light0Color * m_materialColor.xyz();
float32_t specular = shader::step(0.f, ndotl) * m_specularStrength * shader::pow(shader::max(0.0f, rdotv), m_specularShininess);
fVector3 colSpecular = specular * m_light0Color;
fVector3 final = fVector3::BLACK;
final += colAmbient;
final += colDiffuse;
final += colSpecular;
color = fVector4(final.saturate(), 1.0f);
}
void ClassicFragementShader_Phong::end()
{
}
source/shaders/standard/fs_classic_phong.h
+27
View File
@@ -0,0 +1,27 @@
#pragma once
#include "dvc_config.h"
#include "shader/dvc_shader_interface.h"
class ClassicFragementShader_Phong : public davinci::PixelShaderInterface
{
public:
virtual const char* getName(void) const;
virtual void begin(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material);
virtual void process(const davinci::VertexDesc& veretexDesc, const float32_t* pixelData,
davinci::fVector4& color);
virtual void end();
private:
const davinci::RenderPipe* m_pipe = nullptr;
davinci::fVector4 m_materialColor = davinci::fVector4::WHITE;
float32_t m_specularShininess = 64.0f;
float32_t m_specularStrength = 5.0f;
davinci::fVector3 m_ambientLightColor = davinci::fVector3(0.2f, 0.2f, 0.2f);
davinci::fVector3 m_light0Position = davinci::fVector3::ZERO;
davinci::fVector3 m_light0Color = davinci::fVector3::WHITE;
davinci::fVector3 m_cameraPosition = davinci::fVector3::ZERO;
};
source/shaders/standard/fs_debug_base_color.cpp
-29
View File
@@ -1,29 +0,0 @@
#include "fs_debug_base_color.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"
const char* DebugFragementShader_BaseColor::getName(void) const
{
return "debug:base_color";
}
void DebugFragementShader_BaseColor::prepare(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material)
{
m_pipe = pipe;
m_material = material;
}
void DebugFragementShader_BaseColor::process(const davinci::VertexDesc& veretexDesc, const float32_t* pixelData, davinci::fVector4& color)
{
const davinci::UniformBuffer& uniformBuffer = m_pipe->getUniformBuffer();
const davinci::VertexDesc::Element* v_uv_Element = veretexDesc.getElement("v_uv");
const davinci::fVector2* v_uv = (const davinci::fVector2*)(pixelData + (v_uv_Element->offset / sizeof(float32_t)));
davinci::fVector4 u_baseColor = davinci::shader::texture2D(*m_pipe, m_material->getBaseColorTexture(), (*v_uv), davinci::fVector4::WHITE);
color = davinci::fVector4(u_baseColor.xyz(), 1);
}
source/shaders/standard/fs_debug_geometry_normal.cpp
+6 -1
View File
@@ -10,7 +10,7 @@ const char* DebugFragementShader_GeometryNormal::getName(void) const
return "debug:geometry_normal";
}
void DebugFragementShader_GeometryNormal::prepare(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material)
void DebugFragementShader_GeometryNormal::begin(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material)
{
m_pipe = pipe;
m_material = material;
@@ -26,5 +26,10 @@ void DebugFragementShader_GeometryNormal::process(const davinci::VertexDesc& ver
davinci::fVector3 normalColor = *v_normal;
normalColor.normalise();
normalColor = normalColor * 0.5f + 0.5f;
color = davinci::fVector4(normalColor, 1);
}
void DebugFragementShader_GeometryNormal::end()
{
}
source/shaders/standard/fs_debug_geometry_normal.h
+3 -1
View File
@@ -8,11 +8,13 @@ class DebugFragementShader_GeometryNormal : public davinci::PixelShaderInterface
public:
virtual const char* getName(void) const;
virtual void prepare(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material);
virtual void begin(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material);
virtual void process(const davinci::VertexDesc& veretexDesc, const float32_t* pixelData,
davinci::fVector4& color);
virtual void end();
private:
const davinci::RenderPipe* m_pipe = nullptr;
davinci::MaterialConstPtr m_material;
source/shaders/standard/fs_debug_normal_texture.cpp
-29
View File
@@ -1,29 +0,0 @@
#include "fs_debug_normal_texture.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"
const char* DebugFragementShader_NormalTexture::getName(void) const
{
return "debug:normal_texture";
}
void DebugFragementShader_NormalTexture::prepare(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material)
{
m_pipe = pipe;
m_material = material;
}
void DebugFragementShader_NormalTexture::process(const davinci::VertexDesc& veretexDesc, const float32_t* pixelData, davinci::fVector4& color)
{
const davinci::UniformBuffer& uniformBuffer = m_pipe->getUniformBuffer();
const davinci::VertexDesc::Element* v_uv_Element = veretexDesc.getElement("v_uv");
const davinci::fVector2* v_uv = (const davinci::fVector2*)(pixelData + (v_uv_Element->offset / sizeof(float32_t)));
davinci::fVector4 u_baseColor = davinci::shader::texture2D(*m_pipe, m_material->getNormalTexture(), (*v_uv), davinci::fVector4::WHITE);
color = davinci::fVector4(u_baseColor.xyz(), 1);
}
source/shaders/standard/fs_debug_show_texture.cpp
+37
View File
@@ -0,0 +1,37 @@
#include "fs_debug_show_texture.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"
const char* DebugFragementShader_ShowTexture::getName(void) const
{
return "debug:show_texture";
}
void DebugFragementShader_ShowTexture::begin(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material)
{
m_pipe = pipe;
m_material = material;
material->getParam("u_textureInfo", m_textureInfo);
}
void DebugFragementShader_ShowTexture::process(const davinci::VertexDesc& veretexDesc, const float32_t* pixelData, davinci::fVector4& color)
{
const davinci::UniformBuffer& uniformBuffer = m_pipe->getUniformBuffer();
const davinci::VertexDesc::Element* v_uv_Element = veretexDesc.getElement("v_uv");
const davinci::fVector2* v_uv = (const davinci::fVector2*)(pixelData + (v_uv_Element->offset / sizeof(float32_t)));
davinci::fVector4 textureColor = davinci::shader::texture2D(*m_pipe,
m_textureInfo, (*v_uv), davinci::fVector4::WHITE);
color = textureColor;
}
void DebugFragementShader_ShowTexture::end()
{
m_material.reset();
m_textureInfo.texture.reset();
}
source/shaders/standard/fs_debug_normal_texture.h → source/shaders/standard/fs_debug_show_texture.h
+7 -2
View File
@@ -2,18 +2,23 @@
#include "dvc_config.h"
#include "shader/dvc_shader_interface.h"
#include "asset/dvc_material.h"
class DebugFragementShader_NormalTexture : public davinci::PixelShaderInterface
class DebugFragementShader_ShowTexture : public davinci::PixelShaderInterface
{
public:
virtual const char* getName(void) const;
virtual void prepare(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material);
virtual void begin(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material);
virtual void process(const davinci::VertexDesc& veretexDesc, const float32_t* pixelData,
davinci::fVector4& color);
virtual void end();
private:
const davinci::RenderPipe* m_pipe = nullptr;
davinci::MaterialConstPtr m_material;
davinci::TextureInfo m_textureInfo;
};
source/shaders/standard/fs_debug_solid_color.cpp
+9 -4
View File
@@ -1,16 +1,21 @@
#include "fs_debug_solid_color.h"
#include "asset/dvc_material.h"
const char* DebugFragementShader_SolidColor::getName(void) const
{
return "debug:solid_color";
}
void DebugFragementShader_SolidColor::prepare(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material)
void DebugFragementShader_SolidColor::begin(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material)
{
material->getParam("u_solidColor", m_solidColor);
}
void DebugFragementShader_SolidColor::process(const davinci::VertexDesc& veretexDesc, const float32_t* pixelData, davinci::fVector4& color)
void DebugFragementShader_SolidColor::process( const davinci::VertexDesc& veretexDesc, const float32_t* pixelData, davinci::fVector4& color)
{
color = m_solidColor;
}
void DebugFragementShader_SolidColor::end()
{
color = davinci::fVector4::RED;
}
source/shaders/standard/fs_debug_solid_color.h
+6 -1
View File
@@ -8,8 +8,13 @@ class DebugFragementShader_SolidColor : public davinci::PixelShaderInterface
public:
virtual const char* getName(void) const;
virtual void prepare(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material);
virtual void begin(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material);
virtual void process(const davinci::VertexDesc& veretexDesc, const float32_t* pixelData,
davinci::fVector4& color);
virtual void end();
private:
davinci::fVector4 m_solidColor = davinci::fVector4::WHITE;
};
source/shaders/standard/fs_debug_texture_coordinates.cpp
+7 -1
View File
@@ -10,10 +10,12 @@ const char* DebugFragementShader_TextureCoordinates::getName(void) const
return "debug:texture_coordinates";
}
void DebugFragementShader_TextureCoordinates::prepare(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material)
void DebugFragementShader_TextureCoordinates::begin(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material)
{
m_pipe = pipe;
m_material = material;
material->getParam("u_texCoord", m_texCoord);
}
void DebugFragementShader_TextureCoordinates::process(const davinci::VertexDesc& veretexDesc, const float32_t* pixelData, davinci::fVector4& color)
@@ -29,3 +31,7 @@ void DebugFragementShader_TextureCoordinates::process(const davinci::VertexDesc&
color = davinci::fVector4(uv_x, uv_y, 0, 1);
}
void DebugFragementShader_TextureCoordinates::end()
{
}
source/shaders/standard/fs_debug_texture_coordinates.h
+5 -1
View File
@@ -8,12 +8,16 @@ class DebugFragementShader_TextureCoordinates : public davinci::PixelShaderInter
public:
virtual const char* getName(void) const;
virtual void prepare(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material);
virtual void begin(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material);
virtual void process(const davinci::VertexDesc& veretexDesc, const float32_t* pixelData,
davinci::fVector4& color);
virtual void end();
private:
const davinci::RenderPipe* m_pipe = nullptr;
davinci::MaterialConstPtr m_material;
int32_t m_texCoord=0;
};
source/shaders/standard/fs_pbr_gltf.cpp
+25
View File
@@ -0,0 +1,25 @@
#include "fs_pbr_gltf.h"
#include "pipe/dvc_render_pipe.h"
using namespace davinci;
const char* PbrFragementShader_GLTF::getName(void) const
{
return "pbr:gltf";
}
void PbrFragementShader_GLTF::begin(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material)
{
m_pipe = pipe;
const davinci::UniformBuffer& uniformBuffer = m_pipe->getUniformBuffer();
}
void PbrFragementShader_GLTF::process(const davinci::VertexDesc& veretexDesc, const float32_t* pixelData, davinci::fVector4& color)
{
color = fVector4::BLUE;
}
void PbrFragementShader_GLTF::end()
{
}
source/shaders/standard/fs_debug_base_color.h → source/shaders/standard/fs_pbr_gltf.h
+5 -2
View File
@@ -3,17 +3,20 @@
#include "dvc_config.h"
#include "shader/dvc_shader_interface.h"
class DebugFragementShader_BaseColor : public davinci::PixelShaderInterface
class PbrFragementShader_GLTF : public davinci::PixelShaderInterface
{
public:
virtual const char* getName(void) const;
virtual void prepare(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material);
virtual void begin(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material);
virtual void process(const davinci::VertexDesc& veretexDesc, const float32_t* pixelData,
davinci::fVector4& color);
virtual void end();
private:
const davinci::RenderPipe* m_pipe = nullptr;
davinci::MaterialConstPtr m_material;
};
source/shaders/standard/vs_standard.cpp
+123
View File
@@ -0,0 +1,123 @@
#include "vs_standard.h"
#include "device/dvc_buffer_accessor.h"
#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"
StandardVertexShader::StandardVertexShader(bool withWorldPos, bool withNormal, bool withTexCoord0)
: m_withWorldPos(withWorldPos)
, m_withNormal(withNormal)
, m_withTexCoord0(withTexCoord0)
{
m_name = "standard";
m_inputAccessors[davinci::VET_POSITION_MODEL] = nullptr;
m_outputVertexDesc.addElement("v_ndc_pos", davinci::VET_POSITION_NDC, davinci::CT_Float32, davinci::DT_Vec3);
if (withWorldPos)
{
m_outputVertexDesc.addElement("v_world_pos", davinci::VET_POSITION_WORLD, davinci::CT_Float32, davinci::DT_Vec3);
}
m_name += withWorldPos ? "+worldpos" : "-worldpos";
if (withNormal)
{
m_inputAccessors[davinci::VET_NORMAL] = nullptr;
m_outputVertexDesc.addElement("v_normal", davinci::VET_NORMAL, davinci::CT_Float32, davinci::DT_Vec3);
}
m_name += withNormal ? "+normal" : "-normal";
if (withTexCoord0)
{
m_inputAccessors[davinci::VET_TEXCOORD_0] = nullptr;
m_outputVertexDesc.addElement("v_uv", davinci::VET_TEXCOORD_0, davinci::CT_Float32, davinci::DT_Vec2);
}
m_name += withTexCoord0 ? "+uv0" : "-uv0";
}
StandardVertexShader::~StandardVertexShader()
{
}
void StandardVertexShader::begin(const davinci::RenderPipe* pipe, SetInputAttributeFunc setInputAttributeFunc)
{
m_pipe = pipe;
for (auto& pair : m_inputAccessors)
{
pair.second = setInputAttributeFunc(pair.first);
}
assert(getInputAccessor(davinci::VET_POSITION_MODEL));
assert((!m_withNormal) || getInputAccessor(davinci::VET_NORMAL));
assert((!m_withTexCoord0) || getInputAccessor(davinci::VET_TEXCOORD_0));
}
void StandardVertexShader::process(size_t index, float32_t* outputVertex)
{
static const float 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};
const davinci::UniformBuffer& uniformBuffer = m_pipe->getUniformBuffer();
davinci::DeviceBufferAccessorConstPtr inputPosition = getInputAccessor(davinci::VET_POSITION_MODEL);
davinci::DeviceBufferAccessorConstPtr inputNormal = m_withNormal ? getInputAccessor(davinci::VET_NORMAL) : nullptr;
davinci::DeviceBufferAccessorConstPtr inputTexcoord0 = m_withTexCoord0 ? getInputAccessor(davinci::VET_TEXCOORD_0) : nullptr;
davinci::fVector3 a_position(inputPosition ? (const float32_t*)(inputPosition->getElement(index)) : DEFAULT_POSITION);
davinci::fVector3 a_normal(inputNormal ? (const float32_t*)(inputNormal->getElement(index)) : DEFAULT_NORMAL);
davinci::fVector2 a_uv(inputTexcoord0 ? (const float32_t*)(inputTexcoord0->getElement(index)) : DEFAULT_TEXCOORD0);
davinci::fMatrix4 mat_world = davinci::fMatrix4::IDENTITY;
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*)(uniformBuffer.getAttribute("camera:view_proj_mat")))
{
mat_camera_view_proj = *p_mat_camera_view_proj;
}
davinci::fVector3 vertexWorldPos = mat_world * a_position;
//output NDC position
{
davinci::fVector3 vertexNDCPos = mat_camera_view_proj * vertexWorldPos;
memcpy((char*)outputVertex + m_outputVertexDesc.getElement(davinci::VET_POSITION_NDC)->offset, &vertexNDCPos, sizeof(davinci::fVector3));
}
//output world position
if (m_withWorldPos)
{
memcpy((char*)outputVertex + m_outputVertexDesc.getElement(davinci::VET_POSITION_WORLD)->offset, &vertexWorldPos, sizeof(davinci::fVector3));
}
//output normal
if (m_withNormal)
{
davinci::fMatrix4 matNormal = davinci::fMatrix4::IDENTITY;
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();
memcpy((char*)outputVertex + m_outputVertexDesc.getElement(davinci::VET_NORMAL)->offset, &v_normal, sizeof(davinci::fVector3));
}
//output uv0
if (m_withTexCoord0)
{
memcpy((char*)outputVertex + m_outputVertexDesc.getElement(davinci::VET_TEXCOORD_0)->offset, &a_uv, sizeof(float32_t) * 2);
}
}
void StandardVertexShader::end()
{
}
source/shaders/standard/vs_standard.h
+34 -24
View File
@@ -4,38 +4,48 @@
#include "shader/dvc_shader_interface.h"
template<bool WithNormal, bool WithUV>
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::RenderPipe* pipe, SetInputAttributeFunc setInputAttributeFunc);
virtual void process(size_t index, void* outputVertex, davinci::fVector3& vertexWorldPos);
virtual const char* getName(void) const {
return m_name.c_str();
}
virtual const davinci::VertexDesc& getOutputVertexDesc() const {
return m_outputVertexDesc;
}
virtual size_t getOutputVertexByteSize(void) const {
return m_outputVertexDesc.vertexByteSize();
}
virtual void begin(const davinci::RenderPipe* pipe, SetInputAttributeFunc setInputAttributeFunc);
virtual void process(size_t index, float32_t* outputVertex);
virtual void end();
protected:
davinci::DeviceBufferAccessorConstPtr getInputAccessor(davinci::VertexElementType elementType) const {
auto it = m_inputAccessors.find(elementType);
if (it != m_inputAccessors.end()) {
return it->second;
}
return nullptr;
}
private:
const davinci::RenderPipe* m_pipe = nullptr;
std::string m_name;
bool m_withWorldPos = false;
bool m_withNormal = false;
bool m_withTexCoord0 = false;
typedef std::map<davinci::VertexElementType, davinci::DeviceBufferAccessorConstPtr> InputAccessorMap;
InputAccessorMap m_inputAccessors;
davinci::VertexDesc m_outputVertexDesc;
using InputBufferMembers = decltype(std::tuple_cat(
std::tuple<davinci::DeviceBufferAccessorConstPtr>(),
std::conditional_t<WithNormal, std::tuple<davinci::DeviceBufferAccessorConstPtr>, std::tuple<>>{},
std::conditional_t<WithUV, std::tuple<davinci::DeviceBufferAccessorConstPtr>, std::tuple<>>{}
));
InputBufferMembers m_inputAccessors;
static constexpr int32_t iPOSITION() { return 0; };
static constexpr int32_t iNORMAL() { return 1; };
static constexpr int32_t iUV() { return WithNormal+1; };
//davinci::DeviceBufferAccessorConstPtr& getPositionAccessor();
//davinci::DeviceBufferAccessorConstPtr& getNormalAccessor();
//davinci::DeviceBufferAccessorConstPtr& getUVAccessor();
public:
StandardVertexShader();
StandardVertexShader(bool withWorldPos, bool withNormal, bool withTexCoord0);
virtual ~StandardVertexShader();
};
#include "vs_standard.inc"
source/shaders/standard/vs_standard.inc
-181
View File
@@ -1,181 +0,0 @@
#include "device/dvc_buffer_accessor.h"
#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"
template<bool WithNormal, bool WithUV>
StandardVertexShader<WithNormal, WithUV>::StandardVertexShader()
{
m_outputVertexDesc.addElement("v_position", davinci::VET_POSITION, davinci::CT_Float32, davinci::DT_Vec3);
if constexpr(WithNormal)
m_outputVertexDesc.addElement("v_normal", davinci::VET_NORMAL, davinci::CT_Float32, davinci::DT_Vec3);
if constexpr(WithUV)
m_outputVertexDesc.addElement("v_uv", davinci::VET_TEXCOORD_0, davinci::CT_Float32, davinci::DT_Vec2);
}
template<bool WithNormal, bool WithUV>
StandardVertexShader<WithNormal, WithUV>::~StandardVertexShader()
{
}
template<std::size_t N>
struct CompileTimeString {
std::array<char, N> data{};
std::size_t size = 0;
constexpr void append(const char* str, std::size_t len) {
for (std::size_t i = 0; i < len; ++i) {
data[size++] = str[i];
}
}
constexpr void append(const char* str) {
while (*str) {
data[size++] = *str++;
}
}
constexpr const char* c_str() const { return data.data(); }
constexpr std::string_view view() const { return {data.data(), size}; }
};
template<bool WithNormal, bool WithUV>
constexpr auto buildNameString()
{
constexpr const char* prefix = "standard";
constexpr const char* normalString = WithNormal ? "+normal" : "-normal";
constexpr const char* uvString = WithUV ? "+uv" : "-uv";
constexpr std::size_t total_len = std::char_traits<char>::length(prefix)
+ std::char_traits<char>::length(normalString)
+ std::char_traits<char>::length(uvString);
CompileTimeString<total_len> result;
result.append(prefix);
result.append(normalString);
result.append(uvString);
result.append(""); // null terminator
return result;
}
template<bool WithNormal, bool WithUV>
const char* StandardVertexShader<WithNormal, WithUV>::getName(void) const
{
static constexpr auto strName = buildNameString<WithNormal, WithUV>();
const char* p = strName.c_str();
return p;
}
template<bool WithNormal, bool WithUV>
const davinci::VertexDesc& StandardVertexShader<WithNormal, WithUV>::getOutputVertexDesc() const
{
return m_outputVertexDesc;
}
template<bool WithNormal, bool WithUV>
size_t StandardVertexShader<WithNormal, WithUV>::getOutputVertexByteSize(void) const
{
return m_outputVertexDesc.vertexByteSize();
}
template<bool WithNormal, bool WithUV>
void StandardVertexShader<WithNormal, WithUV>::prepare(const davinci::RenderPipe* pipe, SetInputAttributeFunc setInputAttributeFunc)
{
m_pipe = pipe;
std::get<iPOSITION()>(m_inputAccessors) = setInputAttributeFunc(davinci::VET_POSITION);
if constexpr(WithNormal)
std::get<iNORMAL()>(m_inputAccessors) = setInputAttributeFunc(davinci::VET_NORMAL);
if constexpr(WithUV)
std::get<iUV()>(m_inputAccessors) = setInputAttributeFunc(davinci::VET_TEXCOORD_0);
}
/*
template<bool WithNormal, bool WithUV>
davinci::DeviceBufferAccessorConstPtr& StandardVertexShader<WithNormal, WithUV>::getPositionAccessor()
{
return std::get<0>(m_inputAccessors);
}
template<bool WithNormal, bool WithUV>
davinci::DeviceBufferAccessorConstPtr& StandardVertexShader<WithNormal, WithUV>::getNormalAccessor()
{
if constexpr(WithNormal)
return std::get<1>(m_inputAccessors);
else
return nullptr;
}
template<bool WithNormal, bool WithUV>
davinci::DeviceBufferAccessorConstPtr& StandardVertexShader<WithNormal, WithUV>::getUVAccessor()
{
if constexpr(WithUV)
return std::get<WithNormal+1>(m_inputAccessors);
else
return nullptr;
}
*/
template<bool WithNormal, bool WithUV>
void StandardVertexShader<WithNormal, WithUV>::process(size_t index, void* outputVertex, davinci::fVector3& vertexWorldPos)
{
static const float 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};
const davinci::UniformBuffer& uniformBuffer = m_pipe->getUniformBuffer();
davinci::DeviceBufferAccessorConstPtr inputPosition = std::get<0>(m_inputAccessors);
davinci::DeviceBufferAccessorConstPtr inputNormal = nullptr;
if constexpr(WithNormal)
inputNormal = std::get<iNORMAL()>(m_inputAccessors);
davinci::DeviceBufferAccessorConstPtr inputUV = nullptr;
if constexpr(WithUV)
inputUV = std::get<iUV()>(m_inputAccessors);
davinci::fVector3 a_position(inputPosition ? (const float32_t*)(inputPosition->getElement(index)) : DEFAULT_POSITION);
davinci::fVector3 a_normal(inputNormal ? (const float32_t*)(inputNormal->getElement(index)) : DEFAULT_NORMAL);
davinci::fVector2 a_uv(inputUV ? (const float32_t*)(inputUV->getElement(index)) : DEFAULT_TEXCOORD0);
davinci::fMatrix4 mat_world = davinci::fMatrix4::IDENTITY;
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*)(uniformBuffer.getAttribute("camera:view_proj_mat")))
{
mat_camera_view_proj = *p_mat_camera_view_proj;
}
vertexWorldPos = mat_world * a_position;
davinci::fVector3 v_position = mat_camera_view_proj * vertexWorldPos;
int32_t outputOffset=0;
memcpy((char*)outputVertex + m_outputVertexDesc.getElement(outputOffset++)->offset, &v_position, sizeof(davinci::fVector3));
if constexpr(WithNormal)
{
davinci::fMatrix4 matNormal = davinci::fMatrix4::IDENTITY;
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();
memcpy((char*)outputVertex + m_outputVertexDesc.getElement(outputOffset++)->offset, &v_normal, sizeof(davinci::fVector3));
}
if constexpr(WithUV)
{
memcpy((char*)outputVertex + m_outputVertexDesc.getElement(outputOffset++)->offset, &a_uv, sizeof(float32_t) * 2);
}
}