使用phong材质

source/console/ui/ui_main.cpp

@@ -117,6 +117,7 @@ void drawMainUI()
 
 	const char* materialItems[] = { 
 		"none", 
+		"classic:phong", 
 		"debug:solid_color", 
 		"debug:base_color_texture",
 		"debug:normal_texture",
@@ -137,6 +138,7 @@ void drawMainUI()
 		if (lightNode)
 		{
 			uniformBuffer.setAttribute("light0:position", lightNode->getWorldPosition());
+			uniformBuffer.setAttribute("light0:color", davinci::fVector3::WHITE);
 		}
 
 		pipe.setAntiAliasingTech(g_aaTech);

source/core/include/device/dvc_vertex_desc.h

@@ -22,9 +22,9 @@ public:
 	bool addElement(const std::string& name, VertexElementType elementType, 
 		ComponentType componentType, DataType dataType);
 
-	const Element* getElement(size_t index) const;
-	const Element* getElement(VertexElementType elementType) const;
-	const Element* getElement(const std::string& name) const;
+	const Element* getElementByIndex(size_t index) const;
+	const Element* getElementByType(VertexElementType elementType) const;
+	const Element* getElementByName(const std::string& name) const;
 
 	//total byte size of each vertex
 	size_t vertexByteSize(void) const { return m_vertexSize; }

source/core/include/shader/dvc_shader_interface.h

@@ -28,9 +28,9 @@ class FragementShaderInterface
 public:
 	virtual const char* getName(void) const = 0;
 
-	virtual void begin(const RenderPipe* pipe, MaterialConstPtr material) = 0;
+	virtual bool begin(const RenderPipe* pipe, MaterialConstPtr material, const VertexDesc& veretexDesc) = 0;
 
-	virtual void process(const VertexDesc& veretexDesc, const float32_t* pixelData, fVector4& color) = 0;
+	virtual void process(const float32_t* pixelData, fVector4& color) = 0;
 
 	virtual void end() = 0;
 };

source/core/source/device/dvc_vertex_desc.cpp

@@ -75,7 +75,7 @@ bool VertexDesc::addElement(const std::string& name, VertexElementType elementTy
 	return true;
 }
 
-const VertexDesc::Element* VertexDesc::getElement(size_t index) const
+const VertexDesc::Element* VertexDesc::getElementByIndex(size_t index) const
 {
 	if (index >= m_elements.size())
 	{
@@ -84,24 +84,24 @@ const VertexDesc::Element* VertexDesc::getElement(size_t index) const
 	return &(m_elements[index]);
 }
 
-const VertexDesc::Element* VertexDesc::getElement(VertexElementType type) const
+const VertexDesc::Element* VertexDesc::getElementByType(VertexElementType type) const
 {
 	auto it = m_elementTypeMap.find(type);
 	if (it == m_elementTypeMap.end())
 	{
 		return nullptr;
 	}
-	return getElement(it->second);
+	return getElementByIndex(it->second);
 }
 
-const VertexDesc::Element* VertexDesc::getElement(const std::string& name) const
+const VertexDesc::Element* VertexDesc::getElementByName(const std::string& name) const
 {
 	auto it = m_nameMap.find(name);
 	if (it == m_nameMap.end())
 	{
 		return nullptr;
 	}
-	return getElement(it->second);
+	return getElementByIndex(it->second);
 }
 
 DV_CORE_END_NAMESPACE

source/core/source/pipe/dvc_render_step1_vertex_shader.cpp

@@ -64,7 +64,7 @@ void VertexShaderStep::process(RenderPipe& pipe, const InputAssemberStep::NodeAr
 
 			//TODO: div-zero
 
-			size_t ndcPosOffset = outputNode.vertexDesc.getElement(VET_POSITION_NDC)->offset;
+			size_t ndcPosOffset = outputNode.vertexDesc.getElementByType(VET_POSITION_NDC)->offset;
 			const fVector3* vertexNDCPos = (const fVector3*)(outputVertexMemory+ndcPosOffset);
 
 			outputNode.depth[i] = (std::fabsf(vertexNDCPos->z) - cameraNear) / (cameraFar - cameraNear);

source/core/source/pipe/dvc_render_step2_rasterizer.cpp

@@ -31,10 +31,14 @@ void RasterizerStep::process(RenderPipe& pipe, const VertexShaderStep::NodeArray
 			debugMaterial->pickupParam(node.material);
 		}
 		FragementShaderInterface* fragementShader = debugMaterial ? debugMaterial->getFragementShader() : node.material->getFragementShader();
-		fragementShader->begin(&pipe, debugMaterial ?debugMaterial : node.material);
+		if (!(fragementShader->begin(&pipe, debugMaterial ? debugMaterial : node.material, node.vertexDesc)))
+		{
+			//TODO: shader fallback
+			continue;
+		}
 
 		size_t vertexSize = node.vertexDesc.vertexByteSize();
-		size_t POS_offset = node.vertexDesc.getElement(VET_POSITION_NDC)->offset;
+		size_t POS_offset = node.vertexDesc.getElementByType(VET_POSITION_NDC)->offset;
 
 		for (size_t i = 0; i < node.vertexCounts; i += 3) 
 		{
@@ -69,13 +73,8 @@ void RasterizerStep::process(RenderPipe& pipe, const VertexShaderStep::NodeArray
 						pixelData[j] = MathUtil::lerp3(vertex0[j], vertex1[j], vertex2[j], percentCorrected);
 					}
 
-					//if(dot.first==570 && dot.second==405 )
-					//{
-					//	int a = 0;
-					//}
 					fVector4 color;
-					fragementShader->process(node.vertexDesc, &(pixelData[0]), color);
-
+					fragementShader->process(pixelData.data(), color);
 
 					float32_t depth = MathUtil::lerp3(vertexDepth[0], vertexDepth[1], vertexDepth[2], percentCorrected);
 

source/shaders/standard/fs_classic_phong.cpp

@@ -10,41 +10,70 @@ const char* ClassicFragementShader_Phong::getName(void) const
 	return "classic:phong";
 }
 
-void ClassicFragementShader_Phong::begin(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material)
+bool ClassicFragementShader_Phong::begin(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material, const davinci::VertexDesc& veretexDesc)
 {
 	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")))
+	if(!(material->getParam("u_materialColor", m_materialColor)))
 	{
-		m_ambientLightColor = *p_ambient_light_color;
+		m_materialColor = davinci::fVector4::WHITE;
 	}
-	if (davinci::fVector3* p_light0_position = (davinci::fVector3*)(uniformBuffer.getAttribute("light0:position")))
+	if(!(material->getParam("u_specularShininess", m_specularShininess)))
 	{
-		m_light0Position = *p_light0_position;
+		m_specularShininess = 64.0f;
 	}
-	if (davinci::fVector3* p_light0_color = (davinci::fVector3*)(uniformBuffer.getAttribute("light0:color")))
+	if (!(material->getParam("u_specularStrength", m_specularStrength)))
 	{
-		m_light0Color = *p_light0_color;
+		m_specularStrength = 5.0f;
 	}
 
-	if (davinci::fVector3* p_camera_position = (davinci::fVector3*)(uniformBuffer.getAttribute("camera:eye_pos")))
+	if (const davinci::fVector3* attribute = (davinci::fVector3*)(uniformBuffer.getAttribute("ambient_light:color")))
 	{
-		m_cameraPosition = *p_camera_position;
+		m_ambientLightColor = *attribute;
 	}
+	else
+	{
+		m_ambientLightColor = davinci::fVector3(0.2f, 0.2f, 0.2f);
+	}
+
+	if (const davinci::fVector3* attribute = (davinci::fVector3*)(uniformBuffer.getAttribute("light0:position")))
+	{
+		m_light0Position = *attribute;
+	}
+	else return false;
+
+	if (const davinci::fVector3* attribute = (davinci::fVector3*)(uniformBuffer.getAttribute("light0:color")))
+	{
+		m_light0Color = *attribute;
+	}
+	else return false;
+
+	if (const davinci::fVector3* attribute = (davinci::fVector3*)(uniformBuffer.getAttribute("camera:eye_pos")))
+	{
+		m_cameraPosition = *attribute;
+	}
+	else return false;
+
+	if (const VertexDesc::Element* element = veretexDesc.getElementByType(davinci::VET_POSITION_WORLD))
+	{
+		m_vWorldPosOffset = element->offset / sizeof(float32_t);
+	}
+	else return false;
+
+	if (const VertexDesc::Element* element = veretexDesc.getElementByType(davinci::VET_NORMAL))
+	{
+		m_vNormalOffset = element->offset / sizeof(float32_t);
+	}
+	else return false;
+
+	return true;
 }
 
-void ClassicFragementShader_Phong::process(const davinci::VertexDesc& veretexDesc, const float32_t* pixelData, davinci::fVector4& color)
+void ClassicFragementShader_Phong::process(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 v_worldpos = *((const fVector3*)(pixelData + m_vWorldPosOffset));
+	fVector3 v_normal = *((const fVector3*)(pixelData + m_vNormalOffset));
 
 	fVector3 toLight = m_light0Position - v_worldpos;
 	toLight.normalise();

source/shaders/standard/fs_classic_phong.h

@@ -8,11 +8,10 @@ class ClassicFragementShader_Phong : public davinci::FragementShaderInterface
 public:
 	virtual const char* getName(void) const;
 
-	virtual void begin(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material);
+	virtual bool begin(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material, const davinci::VertexDesc& veretexDesc) override;
+	virtual void process(const float32_t* pixelData, davinci::fVector4& color) override;
+	virtual void end() override;
 
-	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;
@@ -20,8 +19,10 @@ private:
 	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_light0Position;
+	davinci::fVector3 m_light0Color;
+	davinci::fVector3 m_cameraPosition;
 
-	davinci::fVector3 m_cameraPosition = davinci::fVector3::ZERO;
+	size_t m_vWorldPosOffset;
+	size_t m_vNormalOffset;
 };

source/shaders/standard/fs_debug_geometry_normal.cpp

@@ -5,29 +5,37 @@
 #include "shader/dvc_shader_functions.h"
 #include "pipe/dvc_render_pipe.h"
 
+using namespace davinci;
+
 const char* DebugFragementShader_GeometryNormal::getName(void) const
 {
 	return "debug:geometry_normal";
 }
 
-void DebugFragementShader_GeometryNormal::begin(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material)
+bool DebugFragementShader_GeometryNormal::begin(const RenderPipe* pipe, MaterialConstPtr material, const VertexDesc& veretexDesc)
 {
 	m_pipe = pipe;
-	m_material = material;
+
+	if (const VertexDesc::Element* element = veretexDesc.getElementByType(VET_NORMAL))
+	{
+		m_vNormalOffset = element->offset / sizeof(float32_t);
+	}
+	else return false;
+
+	return true;
 }
 
-void DebugFragementShader_GeometryNormal::process(const davinci::VertexDesc& veretexDesc, const float32_t* pixelData, davinci::fVector4& color)
+void DebugFragementShader_GeometryNormal::process(const float32_t* pixelData, fVector4& color)
 {
-	const davinci::UniformBuffer& uniformBuffer = m_pipe->getUniformBuffer();
+	const 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)));
+	fVector3 v_normal = *((const fVector3*)(pixelData + m_vNormalOffset));
 
-	davinci::fVector3 normalColor = *v_normal;
+	fVector3 normalColor = v_normal;
 	normalColor.normalise();
 
 	normalColor = normalColor * 0.5f + 0.5f;
-	color = davinci::fVector4(normalColor, 1);
+	color = fVector4(normalColor, 1);
 }
 
 void DebugFragementShader_GeometryNormal::end()

source/shaders/standard/fs_debug_geometry_normal.h

@@ -8,14 +8,11 @@ class DebugFragementShader_GeometryNormal : public davinci::FragementShaderInter
 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();
+	virtual bool begin(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material, const davinci::VertexDesc& veretexDesc) override;
+	virtual void process(const float32_t* pixelData, davinci::fVector4& color) override;
+	virtual void end() override;
 
 private:
 	const davinci::RenderPipe* m_pipe = nullptr;
-	davinci::MaterialConstPtr m_material;
+	size_t m_vNormalOffset;
 };

source/shaders/standard/fs_debug_show_texture.cpp

@@ -5,33 +5,40 @@
 #include "shader/dvc_shader_functions.h"
 #include "pipe/dvc_render_pipe.h"
 
+using namespace davinci;
+
 const char* DebugFragementShader_ShowTexture::getName(void) const
 {
 	return "debug:show_texture";
 }
 
-void DebugFragementShader_ShowTexture::begin(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material)
+bool DebugFragementShader_ShowTexture::begin(const RenderPipe* pipe, MaterialConstPtr material, const VertexDesc& veretexDesc)
 {
 	m_pipe = pipe;
-	m_material = material;
 
-	material->getParam("u_textureInfo", m_textureInfo);
+	if (!(material->getParam("u_textureInfo", m_textureInfo)))
+	{
+		return false;
+	}
+
+	if (const VertexDesc::Element* element = veretexDesc.getElementByType(static_cast<VertexElementType>(VET_TEXCOORD_0+m_textureInfo.texCoord)))
+	{
+		m_vTextureCoordinateOffset = element->offset / sizeof(float32_t);
+	}
+	else return false;
+
+	return true;
 }
 
-void DebugFragementShader_ShowTexture::process(const davinci::VertexDesc& veretexDesc, const float32_t* pixelData, davinci::fVector4& color)
+void DebugFragementShader_ShowTexture::process(const float32_t* pixelData, fVector4& color)
 {
-	const davinci::UniformBuffer& uniformBuffer = m_pipe->getUniformBuffer();
+	const fVector2* v_TextureCoordinate = (const fVector2*)(pixelData + m_vTextureCoordinateOffset);
 
-	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);
+	fVector4 textureColor = shader::texture2D(*m_pipe, m_textureInfo, (*v_TextureCoordinate), fVector4::WHITE);
 
 	color = textureColor;
 }
 void DebugFragementShader_ShowTexture::end()
 {
-	m_material.reset();
 	m_textureInfo.texture.reset();
 }

source/shaders/standard/fs_debug_show_texture.h

@@ -9,16 +9,13 @@ class DebugFragementShader_ShowTexture : public davinci::FragementShaderInterfac
 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();
+	virtual bool begin(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material, const davinci::VertexDesc& veretexDesc) override;
+	virtual void process(const float32_t* pixelData, davinci::fVector4& color) override;
+	virtual void end() override;
 
 private:
 	const davinci::RenderPipe* m_pipe = nullptr;
-	davinci::MaterialConstPtr m_material;
 
 	davinci::TextureInfo m_textureInfo;
+	size_t m_vTextureCoordinateOffset;
 };

source/shaders/standard/fs_debug_solid_color.cpp

@@ -1,17 +1,23 @@
 #include "fs_debug_solid_color.h"
 #include "asset/dvc_material.h"
 
+using namespace davinci;
+
 const char* DebugFragementShader_SolidColor::getName(void) const
 {
 	return "debug:solid_color";
 }
 
-void DebugFragementShader_SolidColor::begin(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material)
+bool DebugFragementShader_SolidColor::begin(const RenderPipe* pipe, MaterialConstPtr material, const VertexDesc& veretexDesc)
 {
-	material->getParam("u_solidColor", m_solidColor);
+	if (!(material->getParam("u_solidColor", m_solidColor)))
+	{
+		m_solidColor = davinci::fVector4::WHITE; 
+	}
+	return true;
 }
 
-void DebugFragementShader_SolidColor::process( const davinci::VertexDesc& veretexDesc, const float32_t* pixelData, davinci::fVector4& color)
+void DebugFragementShader_SolidColor::process(const float32_t* pixelData, fVector4& color)
 {
 	color = m_solidColor;
 }

source/shaders/standard/fs_debug_solid_color.h

@@ -8,12 +8,9 @@ class DebugFragementShader_SolidColor : public davinci::FragementShaderInterface
 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();
+	virtual bool begin(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material, const davinci::VertexDesc& veretexDesc) override;
+	virtual void process(const float32_t* pixelData, davinci::fVector4& color) override;
+	virtual void end() override;
 
 private:
 	davinci::fVector4 m_solidColor = davinci::fVector4::WHITE;

source/shaders/standard/fs_debug_texture_coordinates.cpp

@@ -5,31 +5,40 @@
 #include "shader/dvc_shader_functions.h"
 #include "pipe/dvc_render_pipe.h"
 
+using namespace davinci;
+
 const char* DebugFragementShader_TextureCoordinates::getName(void) const
 {
 	return "debug:texture_coordinates";
 }
 
-void DebugFragementShader_TextureCoordinates::begin(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material)
+bool DebugFragementShader_TextureCoordinates::begin(const RenderPipe* pipe, MaterialConstPtr material, const VertexDesc& veretexDesc)
 {
 	m_pipe = pipe;
-	m_material = material;
 
-	material->getParam("u_texCoord", m_texCoord);
+	if (!(material->getParam("u_texCoord", m_texCoord)))
+	{
+		m_texCoord = 0;
+	}
+
+	if (const VertexDesc::Element* element = veretexDesc.getElementByType(static_cast<VertexElementType>(VET_TEXCOORD_0+m_texCoord)))
+	{
+		m_vTextureCoordinateOffset = element->offset / sizeof(float32_t);
+	}
+	else return false;
+
+	return true;
 }
 
-void DebugFragementShader_TextureCoordinates::process(const davinci::VertexDesc& veretexDesc, const float32_t* pixelData, davinci::fVector4& color)
+void DebugFragementShader_TextureCoordinates::process(const float32_t* pixelData, fVector4& color)
 {
-	const davinci::UniformBuffer& uniformBuffer = m_pipe->getUniformBuffer();
+	const fVector2* v_uv = (const fVector2*)(pixelData + m_vTextureCoordinateOffset);
 
-	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::fVector2 uv = *v_uv;
+	fVector2 uv = *v_uv;
 	float uv_x = uv.x - std::floor(uv.x);
 	float uv_y = uv.y - std::floor(uv.y);
 
-	color = davinci::fVector4(uv_x, uv_y, 0, 1);
+	color = fVector4(uv_x, uv_y, 0, 1);
 }
 
 void DebugFragementShader_TextureCoordinates::end()

source/shaders/standard/fs_debug_texture_coordinates.h

@@ -8,16 +8,13 @@ class DebugFragementShader_TextureCoordinates : public davinci::FragementShaderI
 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();
+	virtual bool begin(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material, const davinci::VertexDesc& veretexDesc) override;
+	virtual void process(const float32_t* pixelData, davinci::fVector4& color) override;
+	virtual void end() override;
 
 private:
 	const davinci::RenderPipe* m_pipe = nullptr;
-	davinci::MaterialConstPtr m_material;
 
 	int32_t m_texCoord=0;
+	size_t m_vTextureCoordinateOffset;
 };

source/shaders/standard/fs_pbr_gltf.cpp

@@ -8,13 +8,14 @@ const char* PbrFragementShader_GLTF::getName(void) const
 	return "pbr:gltf";
 }
 
-void PbrFragementShader_GLTF::begin(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material)
+bool PbrFragementShader_GLTF::begin(const RenderPipe* pipe, MaterialConstPtr material, const VertexDesc& veretexDesc)
 {
 	m_pipe = pipe;
-	const davinci::UniformBuffer& uniformBuffer = m_pipe->getUniformBuffer();
+	const UniformBuffer& uniformBuffer = m_pipe->getUniformBuffer();
+	return true;
 }
 
-void PbrFragementShader_GLTF::process(const davinci::VertexDesc& veretexDesc, const float32_t* pixelData, davinci::fVector4& color)
+void PbrFragementShader_GLTF::process(const float32_t* pixelData, fVector4& color)
 {
 	color = fVector4::BLUE;
 }

source/shaders/standard/fs_pbr_gltf.h

@@ -8,12 +8,9 @@ class PbrFragementShader_GLTF : public davinci::FragementShaderInterface
 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();
+	virtual bool begin(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material, const davinci::VertexDesc& veretexDesc) override;
+	virtual void process(const float32_t* pixelData, davinci::fVector4& color) override;
+	virtual void end() override;
 
 private:
 	const davinci::RenderPipe* m_pipe = nullptr;

source/shaders/standard/vs_standard.cpp

@@ -89,13 +89,13 @@ void StandardVertexShader::process(size_t index, float32_t* outputVertex)
 	//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));
+		memcpy((char*)outputVertex + m_outputVertexDesc.getElementByType(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));
+		memcpy((char*)outputVertex + m_outputVertexDesc.getElementByType(davinci::VET_POSITION_WORLD)->offset, &vertexWorldPos, sizeof(davinci::fVector3));
 	}
 
 	//output normal
@@ -107,13 +107,13 @@ void StandardVertexShader::process(size_t index, float32_t* outputVertex)
 			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));
+		memcpy((char*)outputVertex + m_outputVertexDesc.getElementByType(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);
+		memcpy((char*)outputVertex + m_outputVertexDesc.getElementByType(davinci::VET_TEXCOORD_0)->offset, &a_uv, sizeof(float32_t) * 2);
 	}
 }
 

source/utils/source/standard/dvu_standard_material.cpp

@@ -29,7 +29,7 @@ public:
 		setVertexShader("dv_standard_shaders.dll", "standard+worldpos+normal-uv0");
 		setFragementShader("dv_standard_shaders.dll", "classic:phong");
 
-		registerParam<davinci::fVector4>("u_materialColor", davinci::fVector4::GREEN);
+		registerParam<davinci::fVector4>("u_materialColor", davinci::fVector4::GRAY);
 		registerParam<float32_t>("u_specularShininess", 64.f);
 		registerParam<float32_t>("u_specularStrength", 5.f);
 	}