设置缺省环境光照亮度

runtime/scene/monkey/monkey.gltf

@@ -1,6 +1,6 @@
 {
 	"asset":{
-		"generator":"Khronos glTF Blender I/O v4.3.47",
+		"generator":"Khronos glTF Blender I/O v5.0.21",
 		"version":"2.0"
 	},
 	"extensionsUsed":[
@@ -53,7 +53,7 @@
 			"translation":[
 				4.076245307922363,
 				5.903861999511719,
-				-1.0054539442062378
+				2.520627498626709
 			]
 		},
 		{
@@ -66,9 +66,9 @@
 				0.8937962055206299
 			],
 			"translation":[
-				4.200888156890869,
-				2.8001465797424316,
-				3.949000835418701
+				3.8443074226379395,
+				2.5564608573913574,
+				3.6128811836242676
 			]
 		},
 		{
@@ -88,6 +88,12 @@
 			"type":"perspective"
 		}
 	],
+	"materials":[
+		{
+			"doubleSided":true,
+			"name":"Material.002"
+		}
+	],
 	"meshes":[
 		{
 			"name":"Suzanne",
@@ -96,9 +102,11 @@
 					"attributes":{
 						"POSITION":0,
 						"NORMAL":1,
-						"TEXCOORD_0":2
+						"TEXCOORD_0":2,
+						"TANGENT":3
 					},
-					"indices":3
+					"indices":4,
+					"material":0
 				}
 			]
 		}
@@ -107,67 +115,79 @@
 		{
 			"bufferView":0,
 			"componentType":5126,
-			"count":1966,
+			"count":3410,
 			"max":[
-				1.3671875,
-				0.984375,
-				0.8515625
+				1.325934886932373,
+				0.9392362236976624,
+				0.8223199844360352
 			],
 			"min":[
-				-1.3671875,
-				-0.984375,
-				-0.8515625
+				-1.325934886932373,
+				-0.9704862236976624,
+				-0.7782661318778992
 			],
 			"type":"VEC3"
 		},
 		{
 			"bufferView":1,
 			"componentType":5126,
-			"count":1966,
+			"count":3410,
 			"type":"VEC3"
 		},
 		{
 			"bufferView":2,
 			"componentType":5126,
-			"count":1966,
+			"count":3410,
 			"type":"VEC2"
 		},
 		{
 			"bufferView":3,
+			"componentType":5126,
+			"count":3410,
+			"type":"VEC4"
+		},
+		{
+			"bufferView":4,
 			"componentType":5123,
-			"count":2904,
+			"count":11808,
 			"type":"SCALAR"
 		}
 	],
 	"bufferViews":[
 		{
 			"buffer":0,
-			"byteLength":23592,
+			"byteLength":40920,
 			"byteOffset":0,
 			"target":34962
 		},
 		{
 			"buffer":0,
-			"byteLength":23592,
-			"byteOffset":23592,
+			"byteLength":40920,
+			"byteOffset":40920,
 			"target":34962
 		},
 		{
 			"buffer":0,
-			"byteLength":15728,
-			"byteOffset":47184,
+			"byteLength":27280,
+			"byteOffset":81840,
 			"target":34962
 		},
 		{
 			"buffer":0,
-			"byteLength":5808,
-			"byteOffset":62912,
+			"byteLength":54560,
+			"byteOffset":109120,
+			"target":34962
+		},
+		{
+			"buffer":0,
+			"byteLength":23616,
+			"byteOffset":163680,
 			"target":34963
 		}
 	],
 	"buffers":[
 		{
-			"byteLength":68720,
+			"byteLength":187296,
 			"uri":"monkey.bin"
 		}
 	]

source/CMakeLists.txt

@@ -4,6 +4,7 @@
 add_subdirectory(core)
 add_subdirectory(utils)
 add_subdirectory(console)
+add_subdirectory(shaders)
 
 
 #################

source/console/dv_console_main.cpp

@@ -11,17 +11,25 @@
 #include "ui/ui_main.h"
 #include "adapter/adapter_texture.h"
 #include "device/dvc_render_target.h"
+#include "device/dvc_device.h"
+#include "scene/dvc_scene.h"
 
-#include <scene/dvc_scene.h>
-
-int32_t g_screenWidth = 1024;
-int32_t g_screenHeight = 768;
+int32_t g_screenWidth = 2048;
+int32_t g_screenHeight = 1024;
 static SDL_Window* window = NULL;
 AdapterTexture g_adapterTexture;
 SDL_GLContext gl_context;
 davinci::RenderTarget g_renderTarget;
+davinci::AntiAliasingTech g_aaTech = davinci::AntiAliasingTech::AA_None;
 
+int32_t g_canvasWidth = 1024;
+int32_t g_canvasHeight = 512;
+davinci::Device g_device;
 davinci::Scene g_scene;
+int32_t g_mousePosX = 0;
+int32_t g_mousePosY = 0;
+davinci::fVector4 g_mouseColor = davinci::fVector4::BLACK;
+int32_t g_debugMaterialID = 0;
 
 //-------------------------------------------------------------------------------------
 //int main(int argc, char* argv[])
@@ -99,7 +107,7 @@ SDL_AppResult SDL_AppInit(void** appstate, int argc, char* argv[])
 
 	// init davinci
 	g_scene.init();
-	g_renderTarget.init(512, 256);
+	g_renderTarget.init(g_canvasWidth, g_canvasHeight);
 	g_adapterTexture.updateTexture();
 
 	return SDL_APP_CONTINUE;  /* carry on with the program! */
@@ -153,9 +161,23 @@ SDL_AppResult SDL_AppIterate(void* appstate)
 
 	//draw render result
 	g_adapterTexture.updateTexture(0, 0, g_renderTarget.getColorBuffer());
-	g_adapterTexture.updateTexture(512, 0, g_renderTarget.getDepthBuffer());
+	g_adapterTexture.updateTexture(g_canvasWidth, 0, g_renderTarget.getDepthBuffer());
 	g_adapterTexture.draw();
 
+	float mousePosX, mousePosY;
+	SDL_GetMouseState(&mousePosX, &mousePosY);
+
+	g_mousePosX = (int32_t)(mousePosX) % g_canvasWidth;
+	g_mousePosY = g_screenHeight - (int32_t)(mousePosY);
+	if(g_mousePosX>=0 && g_mousePosX < g_canvasWidth && g_mousePosY >=0 && g_mousePosY < g_canvasHeight)
+	{
+		g_mouseColor = g_renderTarget.getColorBuffer().getPixel(g_mousePosX, g_mousePosY);
+	}
+	else
+	{
+		g_mouseColor = davinci::fVector4::BLACK;
+	}
+
 	//draw ui
 	drawMainUI();
 

source/console/ui/ui_main.cpp

@@ -1,5 +1,6 @@
 #include "ui_main.h"
 
+#include <SDL3/SDL.h>
 #include <SDL3/SDL_opengl.h>
 
 #include <imgui/imgui.h>
@@ -7,7 +8,8 @@
 #include "imgui/imgui_impl_opengl3.h"
 
 #include "scene/dvu_load_gltf.h"
-#include "pipe/dvc_render_queue.h"
+#include "pipe/dvc_render_pipe.h"
+#include "device/dvc_device.h"
 #include "device/dvc_render_target.h"
 #include "shader/dvc_shader_interface.h"
 #include "buffer/dvu_dump_buffer.h"
@@ -15,12 +17,22 @@
 #include "scene/dvc_scene_node.h"
 #include "scene/component/dvc_light_component.h"
 #include "../adapter/adapter_texture.h"
-
+#include "standard/dvu_standard_material.h"
+#include "asset/dvc_material.h"
 
 SDL_Window* main_window;
 
+extern davinci::Device g_device;
 extern davinci::Scene g_scene;
 extern davinci::RenderTarget g_renderTarget;
+extern davinci::AntiAliasingTech g_aaTech;
+extern int32_t g_mousePosX;
+extern int32_t g_mousePosY;
+extern davinci::fVector4 g_mouseColor;
+extern int32_t g_debugMaterialID;
+
+typedef std::map<std::string, davinci::MaterialPtr> DebugMaterialMap;
+DebugMaterialMap g_debugMaterialMap;
 
 bool initMainUI(SDL_Window* window, SDL_GLContext gl_context, const char* glsl_version)
 {
@@ -70,10 +82,14 @@ void OpenFileDialogFileCallback(void* userdata, const char* const* filelist, int
 {
 	if (filelist == nullptr || *filelist == nullptr) return;
 
+	g_device.clear();
 	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_device, g_scene))
+	{
+		SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Error", "Open glf scene file error", main_window);
+	}
 }
 
 void drawMainUI()
@@ -94,26 +110,76 @@ void drawMainUI()
 	}
 	if (ImGui::Button("Export"))
 	{
-		davinci_utils::export_mesh_to_obj(g_scene);
+		davinci_utils::export_mesh_to_obj(g_device, g_scene);
 	}
+	const char* aaItem[] = { "none", "MSAA_2X2", "MSAA_4X4"};
+	ImGui::Combo("AntiAliasing", (int*)(&g_aaTech), aaItem, IM_ARRAYSIZE(aaItem));
+
+	const char* materialItems[] = { 
+		"none", 
+		"classic:phong", 
+		"debug:solid_color", 
+		"debug:base_color_texture",
+		"debug:normal_texture",
+		"debug:texture_coordinates_0",
+		"debug:geometry_normal"
+	};
+	ImGui::Combo("DebugMaterial", (int*)(&g_debugMaterialID), materialItems, IM_ARRAYSIZE(materialItems));
+
 	if (ImGui::Button("Render"))
 	{
-		davinci::UniformBuffer uniformBuffer;
+		davinci::RenderPipe pipe(g_device);
+
+		davinci::UniformBuffer& uniformBuffer = pipe.getUniformBuffer();
 		uniformBuffer.updateStandardAttribute(g_scene);
 
 		//find Light node
+		uniformBuffer.setAttribute("ambient_light:color", davinci::fVector3(0.1f, 0.1f, 0.1f));
+
 		davinci::SceneNodeConstPtr lightNode = g_scene.getNodeWithComponent<davinci::LightComponent>();
 		if (lightNode)
 		{
 			uniformBuffer.setAttribute("light0:position", lightNode->getWorldPosition());
+			uniformBuffer.setAttribute("light0:color", davinci::fVector3::WHITE);
 		}
 
-		davinci::RenderQueue queue;
-		queue.build(g_scene);
+		pipe.setAntiAliasingTech(g_aaTech);
+
+		if (g_debugMaterialID == 0) {
+			pipe.setDebugMaterial(nullptr);
+		}
+		else
+		{
+			DebugMaterialMap::iterator it = g_debugMaterialMap.find(materialItems[g_debugMaterialID]);
+			if(it==g_debugMaterialMap.end())
+			{
+				davinci::MaterialPtr debugMaterial = davinci_utils::create_standard_material(&g_device, materialItems[g_debugMaterialID]);
+				if (debugMaterial)
+				{
+					debugMaterial->setupMaterial();
+
+					g_debugMaterialMap[materialItems[g_debugMaterialID]] = debugMaterial;
+					pipe.setDebugMaterial(debugMaterial);
+				}
+			}
+			else
+			{
+				pipe.setDebugMaterial(it->second);
+			}
+		}
+
+
+		g_scene.buildRenderableQueue(pipe);
 
 		g_renderTarget.clear();
-		queue.process(uniformBuffer, g_renderTarget);
+		pipe.process(g_renderTarget);
+
+		//davinci_utils::dump_render_target("d:\\rendertarget", g_renderTarget);
 	}
+	ImGui::Separator();
+	ImVec2 mousePos = ImGui::GetMousePos();
+	ImGui::Text("MousePosition: %d,%d", g_mousePosX, g_mousePosY);
+	ImGui::Text("MouseColor: %.3f,%.3f,%.3f,%.3f", g_mouseColor.x, g_mouseColor.y, g_mouseColor.z, g_mouseColor.w);
 	ImGui::End();
 
 	// Rendering

source/core/CMakeLists.txt

@@ -69,11 +69,17 @@ source_group("source/scene/component" FILES ${DV_CORE_SCENE_COMPONENT_SOURCE_FIL
 #################
 set(DV_CORE_ASSET_INCLUDE_FILES
 	include/asset/dvc_mesh.h
+	include/asset/dvc_image.h
+	include/asset/dvc_texture.h
+	include/asset/dvc_material.h
 )
 source_group("include/asset" FILES ${DV_CORE_ASSET_INCLUDE_FILES})
 
 set(DV_CORE_ASSET_SOURCE_FILES
 	source/asset/dvc_mesh.cpp
+	source/asset/dvc_image.cpp
+	source/asset/dvc_texture.cpp
+	source/asset/dvc_material.cpp
 )
 source_group("source/asset" FILES ${DV_CORE_ASSET_SOURCE_FILES})
 
@@ -81,6 +87,7 @@ source_group("source/asset" FILES ${DV_CORE_ASSET_SOURCE_FILES})
 # device
 #################
 set(DV_CORE_DEVICE_INCLUDE_FILES
+	include/device/dvc_device.h
 	include/device/dvc_buffer.h
 	include/device/dvc_buffer_view.h
 	include/device/dvc_buffer_accessor.h
@@ -92,6 +99,7 @@ set(DV_CORE_DEVICE_INCLUDE_FILES
 source_group("include/device" FILES ${DV_CORE_DEVICE_INCLUDE_FILES})
 
 set(DV_CORE_DEVICE_SOURCE_FILES
+	source/device/dvc_device.cpp
 	source/device/dvc_buffer.cpp
 	source/device/dvc_buffer_view.cpp
 	source/device/dvc_buffer_accessor.cpp
@@ -106,22 +114,24 @@ source_group("source/device" FILES ${DV_CORE_DEVICE_SOURCE_FILES})
 # pipe
 #################
 set(DV_CORE_PIPE_INCLUDE_FILES
-	include/pipe/dvc_render_queue.h
+	include/pipe/dvc_render_pipe.h
 	include/pipe/dvc_renderable.h
 	include/pipe/dvc_renderable_entity.h
-	include/pipe/dvc_render_step_IA.h
-	include/pipe/dvc_render_step_VS.h
-	include/pipe/dvc_render_step_PS.h
+	include/pipe/dvc_render_step0_input_assember.h
+	include/pipe/dvc_render_step1_vertex_shader.h
+	include/pipe/dvc_render_step2_rasterizer.h
+	include/pipe/dvc_render_step3_output_merge.h
 )
 source_group("include/pipe" FILES ${DV_CORE_PIPE_INCLUDE_FILES})
 
 set(DV_CORE_PIPE_SOURCE_FILES
-	source/pipe/dvc_render_queue.cpp
+	source/pipe/dvc_render_pipe.cpp
 	source/pipe/dvc_renderable.cpp
 	source/pipe/dvc_renderable_entity.cpp
-	source/pipe/dvc_render_step_IA.cpp
-	source/pipe/dvc_render_step_VS.cpp
-	source/pipe/dvc_render_step_PS.cpp
+	source/pipe/dvc_render_step0_input_assember.cpp
+	source/pipe/dvc_render_step1_vertex_shader.cpp
+	source/pipe/dvc_render_step2_rasterizer.cpp
+	source/pipe/dvc_render_step3_output_merge.cpp
 )
 source_group("source/pipe" FILES ${DV_CORE_PIPE_SOURCE_FILES})
 
@@ -143,11 +153,13 @@ source_group("source/rasterizer" FILES ${DV_CORE_RASTERIZER_SOURCE_FILES})
 #################
 set(DV_CORE_SHADER_INCLUDE_FILES
 	include/shader/dvc_shader_interface.h
+	include/shader/dvc_shader_functions.h
 )
 source_group("include/shader" FILES ${DV_CORE_SHADER_INCLUDE_FILES})
 
 set(DV_CORE_SHADER_SOURCE_FILES
 	source/shader/dvc_shader_interface.cpp
+	source/shader/dvc_shader_functions.cpp
 )
 source_group("source/shader" FILES ${DV_CORE_SHADER_SOURCE_FILES})
 

source/core/include/asset/dvc_image.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "dvc_pre_declare.h"
+#include "math/dvc_vector2.h"
+#include "math/dvc_vector4.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+class DV_CORE_API Image
+{
+public:
+	int32_t getID(void) const { return m_id; }
+	int32_t getWidth(void) const { return m_width; }
+	int32_t getHeight(void) const { return m_height; }
+	PixelFormat getPixelFormat(void) const { return m_pixelFormat; }
+	DeviceBufferConstPtr getPixelBuffer(void) const { return m_pixelBuffer; }
+
+	fVector4 getPixel(int32_t u, int32_t v) const;
+
+	void clear();
+	
+	bool initWithPixelData(Device& device, int32_t width, int32_t height, 
+		PixelFormat pixelFormat, const uint8_t* data, size_t dataSize);
+
+protected:
+	int32_t m_id;
+	int32_t m_width;
+	int32_t m_height;
+	PixelFormat m_pixelFormat;
+	size_t m_pixelByteSize;
+	DeviceBufferPtr m_pixelBuffer;
+
+public:
+	Image(int32_t id);
+	~Image();
+};
+
+DV_CORE_END_NAMESPACE

source/core/include/asset/dvc_material.h

@@ -0,0 +1,121 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "dvc_pre_declare.h"
+#include "math/dvc_vector2.h"
+#include "math/dvc_vector3.h"
+#include "math/dvc_vector4.h"
+#include "math/dvc_matrix3.h"
+#include "math/dvc_matrix4.h"
+#include "dvc_texture.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+class DV_CORE_API Material
+{
+public:
+	typedef std::variant<int32_t, float32_t, fVector2, fVector3, fVector4, fMatrix3, fMatrix4, TextureInfo> Value;
+
+	struct Param
+	{
+		enum ParamType
+		{
+			PF_Int32,
+			PT_Float,
+			PT_Float2,
+			PT_Float3,
+			PT_Float4,
+			PT_Matrix3,
+			PT_Matrix4,
+			PT_Texture,
+		};
+		std::string name;
+		ParamType type;
+		Value value;
+
+		Param() = delete;
+		Param(int32_t v) : type(PF_Int32), value(v) {  }
+		Param(float32_t v) : type(PT_Float), value(v) {  }
+		Param(const fVector2& v) : type(PT_Float2), value(v) {}
+		Param(const fVector3& v) : type(PT_Float3), value(v) {}
+		Param(const fVector4& v) : type(PT_Float4), value(v) {}
+		Param(const fMatrix3& v) : type(PT_Matrix3), value(v) {}
+		Param(const fMatrix4& v) : type(PT_Matrix4), value(v) {}
+		Param(const TextureInfo& v) : type(PT_Texture), value(v) {}
+	};
+	typedef std::map<std::string, Param> ParamMap;
+
+public:
+	template<typename T>
+	bool setParam(const char* name, const T& value)
+	{
+		ParamMap::iterator it = m_params.find(name);
+		if(it==m_params.end() || (!std::holds_alternative<T>(it->second.value)))
+		{
+			return false;
+		}
+
+		it->second.value = value;
+		return true;
+	}
+
+	template<typename T>
+	bool getParam(const char* name, T& value) const
+	{
+		ParamMap::const_iterator it = m_params.find(name);
+		if(it==m_params.end() || (!std::holds_alternative<T>(it->second.value)))
+		{
+			return false;
+		}
+
+		value = std::get<T>(it->second.value);
+		return true;
+	}
+
+public:
+	int32_t getID(void) const { return m_id; }
+
+	VertexShaderInterface* getVertexShader() const { 
+		return m_vertexShader; 
+	}
+
+	FragementShaderInterface* getFragementShader() const { 
+		return m_fragementShader; 
+	}
+
+	virtual bool setupMaterial();
+	virtual bool pickupParam(const davinci::MaterialConstPtr otherMaterial) { 
+		return true; 
+	}
+
+protected:
+	void setVertexShader(const char* szShaderFile, const char* vertexShaderName);
+	void setFragementShader(const char* szShaderFile, const char* fragementShaderName);
+
+	template<typename T>
+	bool registerParam(const char* name, const T& defaultValue) {
+		if (m_params.find(name) != m_params.end()) return false;
+		m_params.insert(std::make_pair(name, Param(defaultValue)));
+		return true;
+	}
+
+protected:
+	int32_t m_id;
+	std::string m_name;
+
+	VertexShaderInterface* m_vertexShader = nullptr;
+	FragementShaderInterface* m_fragementShader = nullptr;
+
+	std::string m_vertexshaderFile;
+	std::string m_vertexShaderName;
+
+	std::string m_fragementShaderFile;
+	std::string m_fragementShaderName;
+
+	ParamMap m_params;
+public:
+	Material(int32_t id, const char* name);
+	~Material();
+};
+
+DV_CORE_END_NAMESPACE

source/core/include/asset/dvc_mesh.h

@@ -14,12 +14,15 @@ public:
 		PrimitiveType type;
 		PrimitiveAttributes attributes;
 		DeviceBufferAccessorConstPtr indices;
+		MaterialPtr material;
 	};
 	typedef std::shared_ptr<Primitive> PrimitivePtr;
 	typedef std::shared_ptr<const Primitive> PrimitiveConstPtr;
 	typedef std::vector<PrimitivePtr> PrimitiveArray;
 
 public:
+	int32_t getID(void) const { return m_id; }
+
 	const std::string& getName(void) const {
 		return m_name;
 	}
@@ -31,11 +34,12 @@ public:
 	PrimitiveConstPtr getPrimitive(int32_t index) const;
 
 private:
+	int32_t m_id;
 	std::string m_name;
 	PrimitiveArray m_primitiveArray;
 
 public:
-	Mesh(const std::string& name);
+	Mesh(int32_t id, const std::string& name);
 	~Mesh();
 };
 

source/core/include/asset/dvc_texture.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "dvc_pre_declare.h"
+#include "math/dvc_vector2.h"
+#include "math/dvc_vector4.h"
+#include "math/dvc_matrix3.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+class DV_CORE_API Texture
+{
+public:
+	int32_t getID(void) const { return m_id; }
+	ImagePtr getImage(void) const { return m_image; }
+
+	void setImage(const ImagePtr& image) { m_image = image; }
+
+	fVector4 sample(const fVector2& uv) const;
+
+private:
+	int32_t m_id;
+	ImagePtr m_image;
+
+public:
+	Texture(int32_t id);
+	~Texture();
+};
+
+struct TextureInfo
+{
+	TextureConstPtr texture;
+	int32_t texCoord = 0;
+	fMatrix3 uvTransform;
+};
+
+DV_CORE_END_NAMESPACE

source/core/include/device/dvc_buffer.h

@@ -10,6 +10,7 @@ public:
 	void init(size_t _length);
 	void clear(void);
 
+	int32_t getID(void) const { return m_id; }
 	size_t length(void) const { return m_length; }
 
 	const uint8_t* ptr(size_t offseet) const {
@@ -20,12 +21,12 @@ public:
 		return m_ptr + offseet;
 	}
 private:
+	int32_t m_id;
 	uint8_t* m_ptr;
 	size_t m_length;
 
 public:
-	DeviceBuffer();
-	DeviceBuffer(size_t _length);
+	DeviceBuffer(int32_t id, size_t _length);
 	~DeviceBuffer();
 };
 

source/core/include/device/dvc_buffer_accessor.h

@@ -7,6 +7,8 @@ DV_CORE_BEGIN_NAMESPACE
 class DV_CORE_API DeviceBufferAccessor
 {
 public:
+	int32_t getID(void) const { return m_id; }
+
 	const DeviceBufferViewConstPtr getBufferView(void) const {
 		return m_bufferView;
 	}
@@ -39,6 +41,7 @@ public:
 
 
 private:
+	int32_t m_id;
 	DeviceBufferViewConstPtr m_bufferView;
 	size_t m_offset;
 	size_t m_count;
@@ -48,7 +51,7 @@ private:
 	size_t m_elementSize;
 
 public:
-	DeviceBufferAccessor(DeviceBufferViewConstPtr bufferView, size_t offset, size_t count, ComponentType componentType, DataType dataType);
+	DeviceBufferAccessor(int32_t id, DeviceBufferViewConstPtr bufferView, size_t offset, size_t count, ComponentType componentType, DataType dataType);
 	~DeviceBufferAccessor();
 };
 

source/core/include/device/dvc_buffer_view.h

@@ -8,6 +8,8 @@ DV_CORE_BEGIN_NAMESPACE
 class DV_CORE_API DeviceBufferView
 {
 public:
+	int32_t getID(void) const { return m_id; }
+
 	const DeviceBufferConstPtr getBuffer(void) const {
 		return m_buffer;
 	}
@@ -25,13 +27,14 @@ public:
 	}
 
 private:
+	int32_t m_id;
 	DeviceBufferConstPtr m_buffer;
 	size_t m_offset;
 	size_t m_length;
 	size_t m_stride;
 
 public:
-	DeviceBufferView(DeviceBufferConstPtr buffer, size_t offset, size_t length, size_t stride);
+	DeviceBufferView(int32_t id, DeviceBufferConstPtr buffer, size_t offset, size_t length, size_t stride);
 	~DeviceBufferView();
 };
 

source/core/include/device/dvc_device.h

@@ -0,0 +1,75 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "dvc_pre_declare.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+class DV_CORE_API Device
+{
+public:
+	void clear();
+
+public:
+	DeviceBufferPtr newDeviceBuffer(size_t length);
+	DeviceBufferConstPtr getDeviceBuffer(int32_t id) const;
+
+	DeviceBufferViewPtr newDeviceBufferView(DeviceBufferConstPtr buffer, size_t offset, size_t length, size_t stride);
+	DeviceBufferViewPtr getDeviceBufferView(int32_t id) const;
+
+	DeviceBufferAccessorPtr newDeviceBufferAccessor(DeviceBufferViewConstPtr bufferView, size_t offset,
+		size_t count, ComponentType componentType, DataType dataType);
+	DeviceBufferAccessorPtr getDeviceBufferAccessor(int32_t id) const;
+
+	MeshPtr newMeshAsset(const std::string& name);
+	MeshPtr getMesh(int32_t id) const;
+
+	ImagePtr newImageAsset();
+	ImagePtr getImage(int32_t id) const;
+
+	TexturePtr newTextureAsset();
+	TexturePtr getTexture(int32_t id) const;
+
+	template<typename T>
+	MaterialPtr newMaterialAsset(const char* name) {
+		MaterialPtr materialPtr = std::make_shared<T>(nextID(), name);
+		m_materialAssetMap.insert(std::make_pair(materialPtr->getID(), materialPtr));
+		return materialPtr;
+	}
+
+	MaterialPtr getMaterial(int32_t id) const;
+
+private:
+	int32_t nextID() {
+		if (++m_currentID < 0) m_currentID = 0;
+		return m_currentID;
+	}
+private:
+	int32_t m_currentID = 0;
+
+	//device buffer
+	std::map<int32_t, DeviceBufferPtr> m_deviceBufferMap;
+
+	//device buffer view
+	std::map<int32_t, DeviceBufferViewPtr> m_bufferViewMap;
+
+	//device buffer accessor
+	std::map<int32_t, DeviceBufferAccessorPtr> m_bufferAccessorMap;
+
+	//mesh asset resources
+	std::map<int32_t, MeshPtr> m_meshAssetMap;
+
+	//image asset resources
+	std::map<int32_t, ImagePtr> m_imageAssetMap;
+
+	//texture asset resources
+	std::map<int32_t, TexturePtr> m_textureAssetMap;
+
+	//material asset resources
+	std::map<int32_t, MaterialPtr> m_materialAssetMap;
+
+public:
+	Device();
+	~Device();
+};
+DV_CORE_END_NAMESPACE

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/dvc_config.h

@@ -46,7 +46,8 @@ enum VertexElementType
 {
 	VET_UNKNOWN,
 
-	VET_POSITION,
+	VET_POSITION_MODEL, VET_POSITION_WORLD, VET_POSITION_VIEW, VET_POSITION_NDC,
+
 	VET_NORMAL,
 	VET_TANGENT,
 	VET_BINORMAL,
@@ -89,17 +90,27 @@ enum PrimitiveType
 
 enum PixelFormat
 {
-	//96-bit pixel format, 32 bits (float) for red, 32 bits (float) for green, 32 bits (float) for blue
-	PF_FLOAT32_RGB,
+	PF_UNKNOWN,
 
-	/// 128-bit pixel format, 32 bits (float) for red, 32 bits (float) for green, 32 bits (float) for blue, 32 bits (float) for alpha
-	PF_FLOAT32_RGBA,
-	
-	// 32-bit pixel format, 32 bits (float) for red
-	PF_FLOAT32_R,
-	
-	/// 132-bit pixel format, 8 bits (float) for red, 8 bits (float) for green, 8 bits (float) for blue, 8 bits (float) for alpha
+	PF_UINT8_ALPHA,
+	PF_UINT8_RGB,
 	PF_UINT8_RGBA,
+
+	PF_UINT16_ALPHA,
+	PF_UINT16_RGB,
+	PF_UINT16_RGBA,
+
+	PF_FLOAT32_ALPHA,
+	PF_FLOAT32_RGB,
+	PF_FLOAT32_RGBA,
+};
+
+enum AntiAliasingTech
+{
+	AA_None,
+
+	AA_MSAA_2X2,
+	AA_MSAA_4X4,
 };
 
 DV_CORE_END_NAMESPACE

source/core/include/dvc_pre_declare.h

@@ -36,8 +36,22 @@ class Mesh;
 typedef std::shared_ptr<Mesh> MeshPtr;
 typedef std::shared_ptr<const Mesh> MeshConstPtr;
 
+class Image;
+typedef std::shared_ptr<Image> ImagePtr;
+typedef std::shared_ptr<const Image> ImageConstPtr;
+
+class Texture;
+typedef std::shared_ptr<Texture> TexturePtr;
+typedef std::shared_ptr<const Texture> TextureConstPtr;
+
+class Material;
+typedef std::shared_ptr<Material> MaterialPtr;
+typedef std::shared_ptr<const Material> MaterialConstPtr;
+
 class Scene;
 
+class Device;
+
 class SceneNode;
 typedef std::shared_ptr<SceneNode> SceneNodePtr;
 typedef std::shared_ptr<const SceneNode> SceneNodeConstPtr;
@@ -60,13 +74,15 @@ class LightComponent;
 typedef std::shared_ptr<LightComponent> LightComponentPtr;
 typedef std::shared_ptr<const LightComponent> LightComponentConstPtr;
 
-class RenderQueue;
+class RenderPipe;
 
 class Renderable;
 typedef std::shared_ptr<Renderable> RenderablePtr;
 typedef std::shared_ptr<const Renderable> RenderableConstPtr;
+typedef std::vector<RenderableConstPtr> RenderableArray;
 
 class VertexShaderInterface;
+class FragementShaderInterface;
 
 class UniformBuffer;
 

source/core/include/math/dvc_fix_point.h

@@ -159,17 +159,19 @@ public:
 	// special value
 	static DV_CORE_API const ifloat64 kMax;
 	static DV_CORE_API const ifloat64 kMin;
-	static DV_CORE_API const ifloat64 kZero;
-	static DV_CORE_API const ifloat64 kOne;
-	static DV_CORE_API const ifloat64 kTwo;
-	static DV_CORE_API const ifloat64 kThree;
-	static DV_CORE_API const ifloat64 kFour;
-	static DV_CORE_API const ifloat64 kHalf;
-	static DV_CORE_API const ifloat64 kPi;
-	static DV_CORE_API const ifloat64 kPi2;
-	static DV_CORE_API const ifloat64 kPiHalf;
-	static DV_CORE_API const ifloat64 kE;
-	static DV_CORE_API const ifloat64 kNegOne;
+	static DV_CORE_API const ifloat64 kZero;		//0.0
+	static DV_CORE_API const ifloat64 kOne;			//1.0
+	static DV_CORE_API const ifloat64 kTwo;			//2.0
+	static DV_CORE_API const ifloat64 kThree;		//3.0
+	static DV_CORE_API const ifloat64 kFour;		//4.0
+	static DV_CORE_API const ifloat64 kHalf;		//0.5
+	static DV_CORE_API const ifloat64 kQuater;		//0.25
+	static DV_CORE_API const ifloat64 kOneEighth;	//0.125
+	static DV_CORE_API const ifloat64 kPi;			//3.14159265358979323846
+	static DV_CORE_API const ifloat64 kPi2;			//6.2831853071795
+	static DV_CORE_API const ifloat64 kPiHalf;		//1.57079632679489661923
+	static DV_CORE_API const ifloat64 kE;			//2.71828182845904523536
+	static DV_CORE_API const ifloat64 kNegOne;		// -1.0
 
 public:
 	ifloat64() : s3132(0) {}

source/core/include/math/dvc_math_util.h

@@ -8,8 +8,14 @@ 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);
+	static DV_CORE_API size_t PixelSize(PixelFormat pixelFormat);
+	
+	//count the number of bits set in v
+	static DV_CORE_API uint32_t popcount(uint8_t v);
+	static DV_CORE_API uint32_t popcount(uint16_t v);
+	static DV_CORE_API uint32_t popcount(uint32_t v);
 
 	static bool floatEqual(float a, float b,
 		float tolerance = std::numeric_limits<float>::epsilon()) {

source/core/include/math/dvc_matrix3.h

@@ -94,6 +94,45 @@ public:
 	template<typename U> 
 	friend TMatrix3<U> operator * (U fScalar, const TMatrix3<U>& rkMatrix);
 
+public:
+	static inline TMatrix3 makeTrans(T x, T y) {
+		return TMatrix3(
+			1, 0, x,
+			0, 1, y,
+			0, 0, 1);
+	}
+	
+	static inline TMatrix3 makeTrans(const TVector2<T>& pos) {
+		return TMatrix3(
+			1, 0, pos.x,
+			0, 1, pos.y,
+			0, 0, 1);
+	}
+
+	static inline TMatrix3 makeScale(T x, T y) {
+		return TMatrix3(
+			x, 0, 0,
+			0, y, 0,
+			0, 0, 1);
+	}
+
+	static inline TMatrix3 makeScale(const TVector2<T>& scale) {
+		return TMatrix3(
+			scale.x,	0,			0,
+			0,			scale.y,	0,
+			0,			0,			1);
+	}
+
+	//2D rotate, left multiplication 
+	static inline TMatrix3 makeRotate(T angle) {
+		T s = sin(angle);
+		T c = cos(angle);
+		return TMatrix3(
+			c, -s, 0,
+			s, c, 0,
+			0, 0, 1);
+	}
+
 public:
 	// Utilities
 

source/core/include/math/dvc_vector2.h

@@ -51,6 +51,12 @@ public:
 		return *this;
 	}
 
+	inline TVector2& operator = (const T* pScalar) {
+		x = pScalar[0];
+		y = pScalar[1];
+		return *this;
+	}
+
 	inline bool operator == (const TVector2& rkVector) const {
 		return (x == rkVector.x && y == rkVector.y);
 	}

source/core/include/math/dvc_vector3.h

@@ -62,6 +62,13 @@ public:
 		return *this;
 	}
 
+	inline TVector3& operator = (const T* pScalar) {
+		x = pScalar[0];
+		y = pScalar[1];
+		z = pScalar[2];
+		return *this;
+	}
+
 	inline bool operator == (const TVector3& rkVector) const {
 		return (x == rkVector.x && y == rkVector.y && z == rkVector.z);
 	}

source/core/include/math/dvc_vector4.h

@@ -73,6 +73,14 @@ public:
 		return *this;
 	}
 
+	inline TVector4& operator = (const T* pScalar) {
+		x = pScalar[0];
+		y = pScalar[1];
+		z = pScalar[2];
+		w = pScalar[4];
+		return *this;
+	}
+
 	inline bool operator == (const TVector4& rkVector) const {
 		return (x == rkVector.x && y == rkVector.y && z == rkVector.z && w == rkVector.w);
 	}
@@ -227,6 +235,11 @@ public:
 public:
 	// special points
 	static DV_CORE_API const TVector4 ZERO;
+	static DV_CORE_API const TVector4 ONE;
+	static DV_CORE_API const TVector4 UNIT_X;
+	static DV_CORE_API const TVector4 UNIT_Y;
+	static DV_CORE_API const TVector4 UNIT_Z;
+	static DV_CORE_API const TVector4 UNIT_W;
 	static DV_CORE_API const TVector4 WHITE;
 	static DV_CORE_API const TVector4 BLACK;
 	static DV_CORE_API const TVector4 RED;

source/core/include/pipe/dvc_render_pipe.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "device/dvc_device.h"
+#include "scene/dvc_scene.h"
+#include "device/dvc_uniform_buffer.h"
+#include "device/dvc_render_target.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+class DV_CORE_API RenderPipe
+{
+public:
+	Device& getDevice() {
+		return m_device;
+	}
+	const Device& getDevice() const {
+		return m_device;
+	}
+
+	UniformBuffer& getUniformBuffer() {
+		return m_uniformBuffer;
+	}
+	const UniformBuffer& getUniformBuffer() const {
+		return m_uniformBuffer;
+	}
+
+	AntiAliasingTech getAntiAliasingTech() const {
+		return m_aaTech;
+	}
+	void setAntiAliasingTech(AntiAliasingTech aaTech) {
+		m_aaTech = aaTech;
+	}
+
+	MaterialPtr getDebugMaterial() const {
+		return m_debugMaterial;
+	}
+	void setDebugMaterial(MaterialPtr material) {
+		m_debugMaterial = material;
+	}
+
+	void pushRenderable(RenderableConstPtr renderable);
+
+	void process(RenderTarget& renderTarget);
+
+protected:
+	Device& m_device;
+	AntiAliasingTech m_aaTech = AntiAliasingTech::AA_None;
+	UniformBuffer m_uniformBuffer;
+	RenderableArray m_renderableQueue;
+	MaterialPtr m_debugMaterial;
+
+public:
+	RenderPipe(Device& device);
+	~RenderPipe();
+};
+
+DV_CORE_END_NAMESPACE

source/core/include/pipe/dvc_render_queue.h

@@ -1,30 +0,0 @@
-#pragma once
-
-#include "dvc_config.h"
-#include "scene/dvc_scene.h"
-#include "device/dvc_render_target.h"
-
-DV_CORE_BEGIN_NAMESPACE
-
-class DV_CORE_API RenderQueue
-{
-public:
-	void pushRenderable(RenderableConstPtr renderable);
-
-	size_t getRenderableCounts() const {
-		return m_queue.size();
-	}
-	RenderableConstPtr getRenderable(size_t index) const;
-
-	void build(const Scene& scene);
-	void process(UniformBuffer& uniformBuffer, RenderTarget& renderTarget);
-
-protected:
-	std::vector<RenderableConstPtr> m_queue;
-
-public:
-	RenderQueue();
-	~RenderQueue();
-};
-
-DV_CORE_END_NAMESPACE

source/core/include/pipe/dvc_render_step0_input_assember.h

@@ -2,7 +2,7 @@
 
 #include "dvc_config.h"
 #include "math/dvc_matrix4.h"
-#include "dvc_render_queue.h"
+#include "dvc_render_pipe.h"
 
 DV_CORE_BEGIN_NAMESPACE
 
@@ -17,17 +17,14 @@ public:
 		PrimitiveType					primitiveType;
 		PrimitiveAttributes				vertexData;
 		DeviceBufferAccessorConstPtr	indices;
-		VertexShaderInterface*			vs;
+		MaterialConstPtr				material;
 	};
 	typedef std::vector<Node> NodeArray;
 
 public:
-	void process(const RenderQueue& renderQueue);
-	const NodeArray& getNodes(void) const {
-		return m_nodes;
-	}
+	void process(const RenderableArray& renderableArray);
 
-protected:
+public:
 	NodeArray m_nodes;
 };
 

source/core/include/pipe/dvc_render_step1_vertex_shader.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "dvc_config.h"
-#include "dvc_render_step_IA.h"
+#include "dvc_render_step0_input_assember.h"
 #include "device/dvc_uniform_buffer.h"
 #include "device/dvc_vertex_desc.h"
 
@@ -12,6 +12,7 @@ class VertexShaderStep
 public:
 	struct Node
 	{
+		MaterialConstPtr		material;
 		DeviceBufferPtr			vertexBuf;
 		VertexDesc				vertexDesc;
 		size_t					vertexCounts;
@@ -21,14 +22,9 @@ public:
 	typedef std::vector<Node> NodeArray;
 
 public:
-	const NodeArray& getNodes() const { 
-		return m_nodes; 
-	}
-
-public:
-	void process(UniformBuffer& uniformBuffer, const InputAssemberStep::NodeArray& assembedNodeArray);
+	void process(RenderPipe& pipe, const InputAssemberStep::NodeArray& assembedNodeArray);
 	
-protected:
+public:
 	NodeArray m_nodes;
 };
 

source/core/include/pipe/dvc_render_step2_rasterizer.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "dvc_render_step1_vertex_shader.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+class RasterizerStep
+{
+public:
+	struct Fragement
+	{
+		float32_t depth;
+		fVector4 color;
+		uint32_t mask;
+		int32_t next;
+	};
+
+	typedef std::vector<int32_t> StartOffsetArray;
+	typedef std::vector<Fragement> FragementArray;
+
+public:
+	void process(RenderPipe& pipe, const VertexShaderStep::NodeArray& vsNodeArray, AntiAliasingTech aaTech, int32_t canvasWidth, int32_t canvasHeight);
+
+public:
+	StartOffsetArray m_startOffsetArray;
+	FragementArray m_fragementArray;
+};
+
+DV_CORE_END_NAMESPACE

source/core/include/pipe/dvc_render_step3_output_merge.h

@@ -0,0 +1,87 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "dvc_render_step2_rasterizer.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+class OutputMergerStep
+{
+public:
+	void process(const RasterizerStep::StartOffsetArray& startOffsetArray, const RasterizerStep::FragementArray& fragementArray,
+		AntiAliasingTech aaTech, RenderTarget& renderTarget);
+
+private:
+	void mergeFragement_without_AA(int32_t x, int32_t y,
+		const std::multimap<float32_t, int32_t>& fragementArrayMap,
+		const RasterizerStep::FragementArray& fragementArray, RenderTarget& renderTarget);
+	
+	template<int32_t kSampleSize, uint32_t kSampleMask>
+	void mergeFragement_with_AA(int32_t x, int32_t y,
+		const std::multimap<float32_t, int32_t>& fragementArrayMap,
+		const RasterizerStep::FragementArray& fragementArray, RenderTarget& renderTarget);
+};
+
+template<int32_t kSampleSize, uint32_t kSampleMask>
+void OutputMergerStep::mergeFragement_with_AA(int32_t x, int32_t y, const std::multimap<float32_t, int32_t>& fragementArrayMap,
+	const RasterizerStep::FragementArray& fragementArray, RenderTarget& renderTarget)
+{
+	if (fragementArrayMap.empty())
+	{
+		return;
+	}
+	else if (fragementArrayMap.size() == 1)
+	{
+		const RasterizerStep::Fragement& fragement = fragementArray[fragementArrayMap.begin()->second];
+
+		fVector4 finalColor = fragement.color;
+		finalColor.w = MathUtil::popcount((uint16_t)(fragement.mask & kSampleMask)) / (float32_t)kSampleSize;
+
+		renderTarget.setPixel(x, y, finalColor, fragement.depth);
+	}
+	else
+	{
+		std::array<int32_t, kSampleSize> samples;
+		samples.fill(-1);
+
+		float finalDepth = 0;
+		std::multimap<float32_t, int32_t>::const_iterator it, end = fragementArrayMap.end();
+		for (it = fragementArrayMap.begin(); it != end; ++it)
+		{
+			const RasterizerStep::Fragement& fragement = fragementArray[it->second];
+			for (int32_t k = 0; k < kSampleSize; k++)
+			{
+				if ((fragement.mask & (1 << k)) != 0)
+				{
+					samples[k] = it->second;
+				}
+			}
+			finalDepth = fragement.depth;
+		}
+
+		fVector3 finalColor(0.f, 0.f, 0.f);
+		int32_t bitCounts = 0;
+		for (int32_t k = 0; k < kSampleSize; k++)
+		{
+			int32_t fragementID = samples[k];
+			if (fragementID < 0 || fragementID >= fragementArray.size()) continue;
+
+			const RasterizerStep::Fragement& fragement = fragementArray[fragementID];
+			finalColor += fragement.color.xyz();
+			bitCounts++;
+		}
+
+		if (bitCounts == 0)
+		{
+			return;
+		}
+		if (bitCounts > 1)
+		{
+			finalColor /= (float32_t)bitCounts;
+		}
+		float32_t finalAlpha = bitCounts / (float32_t)kSampleSize;
+		renderTarget.setPixel(x, y, fVector4(finalColor, finalAlpha), finalDepth);
+	}
+}
+
+DV_CORE_END_NAMESPACE

source/core/include/pipe/dvc_render_step_PS.h

@@ -1,15 +0,0 @@
-#pragma once
-
-#include "dvc_config.h"
-#include "dvc_render_step_VS.h"
-
-DV_CORE_BEGIN_NAMESPACE
-
-class PixelShaderStep
-{
-public:
-	void process(const VertexShaderStep::NodeArray& vsNodeArray, RenderTarget& renderTarget);
-
-};
-
-DV_CORE_END_NAMESPACE

source/core/include/pipe/dvc_renderable.h

@@ -2,7 +2,7 @@
 
 #include "dvc_config.h"
 #include "math/dvc_matrix4.h"
-#include "pipe/dvc_render_step_IA.h"
+#include "pipe/dvc_render_step0_input_assember.h"
 
 DV_CORE_BEGIN_NAMESPACE
 

source/core/include/rasterizer/dvc_rasterizer_triangle.h

@@ -10,7 +10,9 @@ class DV_CORE_API Rasterizer
 {
 	//Draw Triangle with Larrabee
 public:
-	typedef std::function<void(const std::pair<int32_t, int32_t>& pos, const fVector3& percent)> DrawTriangleCallback;
+	typedef std::function<
+		void(const std::pair<int32_t, int32_t>& pos, const fVector3& percent, uint32_t mask)
+	> DrawTriangleCallback;
 
 	struct DebugParam
 	{
@@ -27,9 +29,10 @@ public:
 	};
 
 	//Larrabee algorithm
-	static void drawTriangleLarrabee(int32_t canvasWidth, int32_t canvasHeight,
+	static void drawTriangleLarrabee(AntiAliasingTech aaTech, int32_t canvasWidth, int32_t canvasHeight,
 		const fVector2& v0, const fVector2& v1, const fVector2& v2, 
-		DrawTriangleCallback callback, bool ccw=true, const DebugParam* debugParam=nullptr);
+		DrawTriangleCallback callback, bool ccw=true, 
+		const DebugParam* debugParam=nullptr);
 
 public:
 	//BoundingBox algorithm

source/core/include/scene/component/dvc_camera_component.h

@@ -18,7 +18,7 @@ public:
 	};
 public:
 	virtual const std::string& getTypeName() const { return typeName(); }
-	virtual void render(const fMatrix4& transParent, RenderQueue& queue) const;
+	virtual void buildRenderableQueue(const fMatrix4& transParent, RenderPipe& pipe) const;
 
 	fVector3 getEye(void) const;
 	fVector3 getLookat(void) const;

source/core/include/scene/component/dvc_component.h

@@ -9,7 +9,7 @@ class DV_CORE_API SceneComponent
 {
 public:
 	virtual const std::string& getTypeName() const = 0;
-	virtual void render(const fMatrix4& transParent, RenderQueue& queue) const;
+	virtual void buildRenderableQueue(const fMatrix4& transParent, RenderPipe& pipe) const;
 
 protected:
 	SceneNodePtr m_owner;

source/core/include/scene/component/dvc_light_component.h

@@ -27,7 +27,7 @@ public:
 	};
 public:
 	virtual const std::string& getTypeName() const { return typeName(); }
-	virtual void render(const fMatrix4& transParent, RenderQueue& queue) const;
+	virtual void buildRenderableQueue(const fMatrix4& transParent, RenderPipe& pipe) const;
 
 	void setLightDefine(const LightDefine& lightDefine);
 protected:

source/core/include/scene/component/dvc_mesh_component.h

@@ -9,7 +9,7 @@ class DV_CORE_API MeshComponent : public SceneComponent
 {
 public:
 	virtual const std::string& getTypeName() const { return typeName(); }
-	virtual void render(const fMatrix4& transParent, RenderQueue& queue) const;
+	virtual void buildRenderableQueue(const fMatrix4& transParent, RenderPipe& pipe) const;
 
 	void setMesh(MeshConstPtr mesh);
 

source/core/include/scene/dvc_scene.h

@@ -11,35 +11,10 @@ public:
 	void init(void);
 	void clear(void);
 
-public:
-	DeviceBufferPtr newDeviceBuffer(void);
-	int32_t getDeviceBufferCounts(void) const {
-		return (int32_t)m_deviceBufferArray.size();
-	}
-	DeviceBufferConstPtr getDeviceBuffer(int32_t index) const;
-
-	DeviceBufferViewPtr newDeviceBufferView(DeviceBufferConstPtr buffer, size_t offset, size_t length, size_t stride);
-	int32_t getDeviceBufferViewCounts(void) const {
-		return (int32_t)m_bufferViewArray.size();
-	}
-	DeviceBufferViewPtr getDeviceBufferView(int32_t index) const;
-
-	DeviceBufferAccessorPtr newDeviceBufferAccessor(DeviceBufferViewConstPtr bufferView, size_t offset,
-		size_t count, ComponentType componentType, DataType dataType);
-	int32_t getDeviceBufferAccessorCounts(void) const {
-		return (int32_t)m_bufferAccessorArray.size();
-	}
-	DeviceBufferAccessorPtr getDeviceBufferAccessor(int32_t index) const;
-
-	int32_t pushNewMeshAsset(MeshPtr mesh);
-	int32_t getMeshCounts(void) const {
-		return (int32_t)m_meshArray.size();
-	}
-	MeshConstPtr getMesh(int32_t index) const;
-
 public:
 	SceneNodePtr newSceneNode(const std::string& name);
 	SceneNodePtr getRootSceneNode() const;
+	void buildRenderableQueue(RenderPipe& pipe) const;
 
 public:
 	template<typename ComponentType>
@@ -79,14 +54,6 @@ public:
 protected:
 	SceneNodePtr m_rootSceneNode;
 
-	//device resources
-	std::vector<DeviceBufferPtr> m_deviceBufferArray;
-	std::vector<DeviceBufferViewPtr> m_bufferViewArray;
-	std::vector<DeviceBufferAccessorPtr> m_bufferAccessorArray;
-
-	//asset resources
-	std::vector<MeshPtr> m_meshArray;
-
 public:
 	Scene();
 	~Scene();

source/core/include/scene/dvc_scene_node.h

@@ -55,7 +55,7 @@ public:
 	}
 
 public:
-	void buildRenderQueue(const fMatrix4& transParent, RenderQueue& queue);
+	void buildRenderableQueue(const fMatrix4& transParent, RenderPipe& pipe);
 
 protected:
 	std::string m_name;

source/core/include/shader/dvc_shader_functions.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "dvc_pre_declare.h"
+#include "math/dvc_vector2.h"
+#include "math/dvc_vector4.h"
+#include "asset/dvc_material.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+class shader
+{
+public:
+	template<typename T>
+	static inline int32_t step(const T& edge, const T& x) {
+		return (x >= edge) ? 1 : 0;
+	}
+
+	template<typename T>
+	static inline T max(const T& a, const T& b) {
+		return (a > b) ? a : b;
+	}
+
+	template<typename T>
+	static inline T pow(const T& base, const T& exponent) {
+		return std::pow(base, exponent);
+	}
+	
+	template<typename T>
+	static inline T min(const T& a, const T& b) {
+		return (a < b) ? a : b;
+	}
+
+	static DV_CORE_API fVector4 texture2D(const RenderPipe& pipe, const TextureInfo& texturePtr, const fVector2& uv, const fVector4& defaultValue);
+};
+
+DV_CORE_END_NAMESPACE

source/core/include/shader/dvc_shader_interface.h

@@ -2,6 +2,7 @@
 
 #include "dvc_config.h"
 #include "dvc_pre_declare.h"
+#include "math/dvc_vector2.h"
 #include "math/dvc_vector3.h"
 #include "math/dvc_vector4.h"
 #include "device/dvc_vertex_desc.h"
@@ -15,27 +16,30 @@ public:
 	virtual const VertexDesc& getOutputVertexDesc() const = 0;
 
 	typedef std::function<DeviceBufferAccessorConstPtr(VertexElementType)> SetInputAttributeFunc;
-	virtual void prepare(const UniformBuffer* uniformBuffer, SetInputAttributeFunc setInputAttributeFunc) = 0;
+	virtual void begin(const RenderPipe* pipe, SetInputAttributeFunc setInputAttributeFunc) = 0;
 
-	virtual void process(size_t index, void* outputVertex, fVector3& vertexWorldPos) = 0;
+	virtual void process(size_t index, float32_t* outputVertex) = 0;
+
+	virtual void end() = 0;
 };
 
-class PixelShaderInterface
+class FragementShaderInterface
 {
 public:
 	virtual const char* getName(void) const = 0;
 
-	typedef std::function<size_t(const std::string&)> SetInputAttributeFunc;
-	virtual void prepare(const UniformBuffer* uniformBuffer, SetInputAttributeFunc setInputAttributeFunc) = 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;
 };
 
 class ShaderFileInterface
 {
 public:
 	virtual VertexShaderInterface* getVertexShader(const char* szName) = 0;
-	virtual PixelShaderInterface* getPixelShader(const char* szName) = 0;
+	virtual FragementShaderInterface* getFragementShader(const char* szName) = 0;
 };
 
 typedef ShaderFileInterface* (*ShaderFileInterfaceFunc)();

source/core/source/asset/dvc_image.cpp

@@ -0,0 +1,79 @@
+#include "asset/dvc_image.h"
+#include "math/dvc_math_util.h"
+#include "device/dvc_device.h"
+#include "device/dvc_buffer.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+Image::Image(int32_t id)
+	: m_id(id)
+{
+}
+
+Image::~Image()
+{
+}
+
+void Image::clear()
+{
+	m_width = 0;
+	m_height = 0;
+	m_pixelFormat = PF_UNKNOWN;
+	m_pixelByteSize = 0;
+	m_pixelBuffer = nullptr;
+}
+
+fVector4 Image::getPixel(int32_t u, int32_t v) const
+{
+	if(u<0 || u>=m_width || v<0 || v>=m_height)
+	{
+		return fVector4::ZERO;
+	}
+
+	const uint8_t* p = (const uint8_t*)(m_pixelBuffer->ptr(0)) + (v * m_width + u) * m_pixelByteSize;
+	switch (m_pixelFormat)
+	{
+		case PF_UINT8_ALPHA:
+			return fVector4(0, 0, 0, p[0] / 255.0f);
+		case PF_UINT8_RGB:
+			return fVector4(p[0] / 255.0f, p[1] / 255.0f, p[2] / 255.0f, 1.0f);
+		case PF_UINT8_RGBA:
+			return fVector4(p[0] / 255.0f, p[1] / 255.0f, p[2] / 255.0f, p[3] / 255.0f);
+		case PF_FLOAT32_ALPHA:
+			return fVector4(0, 0, 0, *((const float*)p));
+		case PF_FLOAT32_RGB:
+		{
+			const float* fp = (const float*)p;
+			return fVector4(fp[0], fp[1], fp[2], 1.0f);
+		}
+		case PF_FLOAT32_RGBA:
+		{
+			const float* fp = (const float*)p;
+			return fVector4(fp[0], fp[1], fp[2], fp[3]);
+		}
+	default:
+		return fVector4::ZERO;
+	}
+}
+
+bool Image::initWithPixelData(Device& device, int32_t width, int32_t height, 
+	PixelFormat pixelFormat, const uint8_t* data, size_t dataSize)
+{
+	clear();
+
+	size_t pixelByteSize = MathUtil::PixelSize(pixelFormat);
+	if (dataSize != pixelByteSize*width*height)
+	{
+		return false;
+	}
+
+	m_width = width;
+	m_height = height;
+	m_pixelFormat = pixelFormat;
+	m_pixelByteSize = pixelByteSize;
+	m_pixelBuffer = device.newDeviceBuffer(dataSize);
+	memcpy(m_pixelBuffer->ptr(0), data, dataSize);
+	return true;
+}
+
+DV_CORE_END_NAMESPACE

source/core/source/asset/dvc_material.cpp

@@ -0,0 +1,55 @@
+#include "asset/dvc_material.h"
+#include "shader/dvc_shader_interface.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+Material::Material(int32_t id, const char* name)
+	: m_id(id)
+	, m_name(name)
+{
+}
+
+Material::~Material()
+{
+}
+
+void Material::setVertexShader(const char* szShaderFile, const char* vertexShaderName)
+{
+	m_vertexshaderFile = szShaderFile;
+	m_vertexShaderName = vertexShaderName;
+}
+
+void Material::setFragementShader(const char* szShaderFile, const char* fragementShaderName)
+{
+	m_fragementShaderFile = szShaderFile;
+	m_fragementShaderName = fragementShaderName;
+}
+
+bool Material::setupMaterial()
+{
+	ShaderFileInterface* shaderInterface = davinci::LoadShaderFile(m_vertexshaderFile.c_str());
+	if (shaderInterface == nullptr)
+	{
+		return false;
+	}
+	m_vertexShader = shaderInterface->getVertexShader(m_vertexShaderName.c_str());
+	if (!m_vertexShader)
+	{
+		return false;
+	}
+
+	shaderInterface = davinci::LoadShaderFile(m_fragementShaderFile.c_str());
+	if (shaderInterface == nullptr)
+	{
+		return false;
+	}
+
+	m_fragementShader = shaderInterface->getFragementShader(m_fragementShaderName.c_str());
+	if (!m_fragementShader)
+	{
+		return false;
+	}
+	return true;
+}
+
+DV_CORE_END_NAMESPACE

source/core/source/asset/dvc_mesh.cpp

@@ -2,8 +2,9 @@
 
 DV_CORE_BEGIN_NAMESPACE
 
-Mesh::Mesh(const std::string& name)
-	: m_name(name)
+Mesh::Mesh(int32_t id, const std::string& name)
+	: m_id(id)
+	, m_name(name)
 {
 }
 

source/core/source/asset/dvc_texture.cpp

@@ -0,0 +1,33 @@
+#include "asset/dvc_texture.h"
+#include "math/dvc_math_util.h"
+#include "device/dvc_device.h"
+#include "device/dvc_buffer.h"
+#include "asset/dvc_image.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+Texture::Texture(int32_t id)
+	: m_id(id)
+{
+}
+
+Texture::~Texture()
+{
+}
+
+fVector4 Texture::sample(const fVector2& uv) const
+{
+	fVector4 color = fVector4::ZERO;
+	if (!m_image) return color;
+
+	float uv_x = uv.x - std::floor(uv.x);
+	float uv_y = uv.y - std::floor(uv.y);
+
+
+	int32_t u = uv_x * m_image->getWidth();
+	int32_t v = uv_y * m_image->getHeight();
+
+	return m_image->getPixel(u, v);
+}
+
+DV_CORE_END_NAMESPACE

source/core/source/device/dvc_buffer.cpp

@@ -2,14 +2,9 @@
 
 DV_CORE_BEGIN_NAMESPACE
 
-DeviceBuffer::DeviceBuffer()
-	: m_ptr(nullptr)
-	, m_length(0)
-{
-}
-
-DeviceBuffer::DeviceBuffer(size_t _length)
-	: m_ptr(nullptr)
+DeviceBuffer::DeviceBuffer(int32_t id, size_t _length)
+	: m_id(id)
+	, m_ptr(nullptr)
 	, m_length(0)
 {
 	init(_length);

source/core/source/device/dvc_buffer_accessor.cpp

@@ -3,8 +3,9 @@
 
 DV_CORE_BEGIN_NAMESPACE
 
-DeviceBufferAccessor::DeviceBufferAccessor(DeviceBufferViewConstPtr bufferView, size_t offset, size_t count, ComponentType componentType, DataType dataType)
-	: m_bufferView(bufferView)
+DeviceBufferAccessor::DeviceBufferAccessor(int32_t id, DeviceBufferViewConstPtr bufferView, size_t offset, size_t count, ComponentType componentType, DataType dataType)
+	: m_id(id)
+	, m_bufferView(bufferView)
 	, m_offset(offset)
 	, m_count(count)
 	, m_componentType(componentType)
@@ -25,10 +26,11 @@ void DeviceBufferAccessor::walk(std::function<bool(const uint8_t*, size_t)> call
 
 	DeviceBufferConstPtr buffer = m_bufferView->getBuffer();
 	const uint8_t* ptr = buffer->ptr(m_bufferView->getOffset()) + m_offset;
+	const size_t step = m_bufferView->getStride() > 0 ? m_bufferView->getStride() : m_elementSize;
 
 	size_t startIndex = start;
 	size_t endIndex = (end == ((size_t)-1)) ? m_count : end;
-	for (size_t index = startIndex; index < endIndex; index++, ptr+=m_elementSize)
+	for (size_t index = startIndex; index < endIndex; index++, ptr+=step)
 	{
 		if (callback(ptr, index))
 		{
@@ -44,12 +46,13 @@ void DeviceBufferAccessor::walk2(std::function<bool(const uint8_t*, const uint8_
 
 	DeviceBufferConstPtr buffer = m_bufferView->getBuffer();
 	const uint8_t* ptr = buffer->ptr(m_bufferView->getOffset()) + m_offset;
+	const size_t step = m_bufferView->getStride() > 0 ? m_bufferView->getStride() : m_elementSize;
 
 	size_t startIndex = start;
 	size_t endIndex = (end == ((size_t)-1)) ? m_count : end;
-	for (size_t index = startIndex; index < endIndex; index+=2, ptr+=m_elementSize*2)
+	for (size_t index = startIndex; index < endIndex; index+=2, ptr+=step*2)
 	{
-		if (callback(ptr, ((index + 1) < endIndex) ? (ptr + m_elementSize) : nullptr, index))
+		if (callback(ptr, ((index + 1) < endIndex) ? (ptr + step) : nullptr, index))
 		{
 			break;
 		}
@@ -63,14 +66,15 @@ void DeviceBufferAccessor::walk3(std::function<bool(const uint8_t*, const uint8_
 
 	DeviceBufferConstPtr buffer = m_bufferView->getBuffer();
 	const uint8_t* ptr = buffer->ptr(m_bufferView->getOffset()) + m_offset;
+	const size_t step = m_bufferView->getStride() > 0 ? m_bufferView->getStride() : m_elementSize;
 
 	size_t startIndex = start;
 	size_t endIndex = (end == ((size_t)-1)) ? m_count : end;
-	for (size_t index = startIndex; index < endIndex; index += 3, ptr += m_elementSize * 3)
+	for (size_t index = startIndex; index < endIndex; index += 3, ptr += step * 3)
 	{
 		if(callback(ptr, 
-			((index + 1) < endIndex) ? (ptr + m_elementSize) : nullptr, 
-			((index + 2) < endIndex) ? (ptr + m_elementSize*2) : nullptr,
+			((index + 1) < endIndex) ? (ptr + step) : nullptr, 
+			((index + 2) < endIndex) ? (ptr + step*2) : nullptr,
 			index))
 		{
 			break;
@@ -85,7 +89,9 @@ const uint8_t* DeviceBufferAccessor::getElement(size_t index) const
 	}
 
 	DeviceBufferConstPtr buffer = m_bufferView->getBuffer();
-	const uint8_t* pData = buffer->ptr(m_bufferView->getOffset()) + m_offset + index * m_elementSize;
+	const uint8_t* pData = buffer->ptr(m_bufferView->getOffset()) 
+		+ m_offset 
+		+ index * (m_bufferView->getStride()>0 ? m_bufferView->getStride(): m_elementSize);
 
 	return pData;
 }

source/core/source/device/dvc_buffer_view.cpp

@@ -2,8 +2,9 @@
 
 DV_CORE_BEGIN_NAMESPACE
 
-DeviceBufferView::DeviceBufferView(DeviceBufferConstPtr buffer, size_t offset, size_t length, size_t stride)
-	: m_buffer(buffer)
+DeviceBufferView::DeviceBufferView(int32_t id, DeviceBufferConstPtr buffer, size_t offset, size_t length, size_t stride)
+	: m_id(id)
+	, m_buffer(buffer)
 	, m_offset(offset)
 	, m_length(length)
 	, m_stride(stride)

source/core/source/device/dvc_device.cpp

@@ -0,0 +1,148 @@
+#include "device/dvc_device.h"
+#include "device/dvc_buffer.h"
+#include "device/dvc_buffer_view.h"
+#include "device/dvc_buffer_accessor.h"
+#include "asset/dvc_mesh.h"
+#include "asset/dvc_image.h"
+#include "asset/dvc_texture.h"
+#include "asset/dvc_material.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+Device::Device()
+{
+}
+
+Device::~Device()
+{
+	clear();
+}
+
+void Device::clear(void)
+{
+	//clear assets
+	m_meshAssetMap.clear();
+	m_imageAssetMap.clear();
+
+	//clear device resources
+	m_bufferAccessorMap.clear();
+	m_bufferViewMap.clear();
+	m_deviceBufferMap.clear();
+}
+
+DeviceBufferPtr Device::newDeviceBuffer(size_t length)
+{
+	DeviceBufferPtr deviceBuffer = std::make_shared<DeviceBuffer>(nextID(), length);
+
+	m_deviceBufferMap.insert(std::make_pair(deviceBuffer->getID(), deviceBuffer));
+	return deviceBuffer;
+}
+
+DeviceBufferConstPtr Device::getDeviceBuffer(int32_t id) const
+{
+	std::map<int32_t, DeviceBufferPtr>::const_iterator it = m_deviceBufferMap.find(id);
+	if(it==m_deviceBufferMap.end())
+	{
+		return nullptr;
+	}
+	return it->second;
+}
+
+DeviceBufferViewPtr Device::newDeviceBufferView(DeviceBufferConstPtr buffer, size_t offset, size_t length, size_t stride)
+{
+	DeviceBufferViewPtr deviceBufferView = std::make_shared<DeviceBufferView>(nextID(), buffer, offset, length, stride);
+	m_bufferViewMap.insert(std::make_pair(deviceBufferView->getID(), deviceBufferView));
+	return deviceBufferView;
+}
+
+DeviceBufferViewPtr Device::getDeviceBufferView(int32_t id) const
+{
+	std::map<int32_t, DeviceBufferViewPtr>::const_iterator it = m_bufferViewMap.find(id);
+	if(it==m_bufferViewMap.end())
+	{
+		return nullptr;
+	}
+	return it->second;
+}
+
+DeviceBufferAccessorPtr Device::newDeviceBufferAccessor(DeviceBufferViewConstPtr bufferView, size_t offset,
+	size_t count, ComponentType componentType, DataType dataType)
+{
+	DeviceBufferAccessorPtr deviceBufferAccessor = std::make_shared<DeviceBufferAccessor>(
+		nextID(), bufferView, offset, count, componentType, dataType);
+	m_bufferAccessorMap.insert(std::make_pair(deviceBufferAccessor->getID(), deviceBufferAccessor));
+	return deviceBufferAccessor;
+}
+
+DeviceBufferAccessorPtr Device::getDeviceBufferAccessor(int32_t id) const
+{
+	std::map<int32_t, DeviceBufferAccessorPtr>::const_iterator it = m_bufferAccessorMap.find(id);
+	if(it==m_bufferAccessorMap.end())
+	{
+		return nullptr;
+	}
+	return it->second;
+}
+
+MeshPtr Device::newMeshAsset(const std::string& name)
+{
+	MeshPtr meshPtr = std::make_shared<davinci::Mesh>(nextID(), name);
+	m_meshAssetMap.insert(std::make_pair(meshPtr->getID(), meshPtr));
+	return meshPtr;
+}
+
+MeshPtr Device::getMesh(int32_t id) const
+{
+	std::map<int32_t, MeshPtr>::const_iterator it = m_meshAssetMap.find(id);
+	if(it==m_meshAssetMap.end())
+	{
+		return nullptr;
+	}
+	return it->second;
+}
+
+ImagePtr Device::newImageAsset()
+{
+	ImagePtr imagePtr = std::make_shared<Image>(nextID());
+	m_imageAssetMap.insert(std::make_pair(imagePtr->getID(), imagePtr));
+	return imagePtr;
+}
+
+ImagePtr Device::getImage(int32_t id) const
+{
+	std::map<int32_t, ImagePtr>::const_iterator it = m_imageAssetMap.find(id);
+	if(it==m_imageAssetMap.end())
+	{
+		return nullptr;
+	}
+	return it->second;
+}
+
+TexturePtr Device::newTextureAsset()
+{
+	TexturePtr texturePtr = std::make_shared<Texture>(nextID());
+	m_textureAssetMap.insert(std::make_pair(texturePtr->getID(), texturePtr));
+	return texturePtr;
+}
+
+TexturePtr Device::getTexture(int32_t id) const
+{
+	std::map<int32_t, TexturePtr>::const_iterator it = m_textureAssetMap.find(id);
+	if(it==m_textureAssetMap.end())
+	{
+		return nullptr;
+	}
+	return it->second;
+}
+
+MaterialPtr Device::getMaterial(int32_t id) const
+{
+	std::map<int32_t, MaterialPtr>::const_iterator it = m_materialAssetMap.find(id);
+	if(it==m_materialAssetMap.end())
+	{
+		return nullptr;
+	}
+	return it->second;
+}
+
+DV_CORE_END_NAMESPACE

source/core/source/device/dvc_render_target.cpp

@@ -16,7 +16,7 @@ void RenderTarget::init(int32_t width, int32_t height)
 
 void RenderTarget::clear()
 {
-	m_colorBuffer.clear(fVector4::BLACK);
+	m_colorBuffer.clear(fVector4(0.f, 0.f, 0.f, 0.f));
 	m_depthBuffer.clear(std::numeric_limits<float32_t>::max());
 }
 
@@ -24,9 +24,6 @@ void RenderTarget::setPixel(int32_t x, int32_t y, const fVector4& color, float32
 {
 	if (x < 0 || x >= m_width || y < 0 || y >= m_height) return;
 
-	if (depth > m_depthBuffer.getPixel(x, y)) {
-		return;
-	}
 	m_colorBuffer.setPixel(x, y, color);
 	m_depthBuffer.setPixel(x, y, depth);
 }

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/math/dvc_fix_point.cpp

@@ -10,6 +10,8 @@ const ifloat64 ifloat64::kTwo{ INT64_C(2) << kShift };
 const ifloat64 ifloat64::kThree{ INT64_C(3) << ifloat64::kShift };
 const ifloat64 ifloat64::kFour{ INT64_C(4) << ifloat64::kShift };
 const ifloat64 ifloat64::kHalf{ INT64_C(1) << (ifloat64::kShift-1) };
+const ifloat64 ifloat64::kQuater{ INT64_C(1) << (ifloat64::kShift - 2) };
+const ifloat64 ifloat64::kOneEighth{ INT64_C(1) << (ifloat64::kShift - 3) };
 const ifloat64 ifloat64::kPi{ INT64_C(0x3243f6a89) }; //static_cast<int64_t>(std::round(M_PI * kFloatScale));
 const ifloat64 ifloat64::kPi2{ INT64_C(0x6487ed511) };
 const ifloat64 ifloat64::kPiHalf{ INT64_C(0x1921fb544) };

source/core/source/math/dvc_math_util.cpp

@@ -11,6 +11,31 @@ const float MathUtil::PI_DIV4 = float(0.25 * PI);
 const float MathUtil::fDeg2Rad = PI / float(180.0);
 const float MathUtil::fRad2Deg = float(180.0) / PI;
 
+static const uint8_t kBitsSetTable256[256] =
+{
+#define B2(n) n,     n+1,     n+1,     n+2
+#define B4(n) B2(n), B2(n+1), B2(n+1), B2(n+2)
+#define B6(n) B4(n), B4(n+1), B4(n+1), B4(n+2)
+
+	B6(0), B6(1), B6(1), B6(2)
+};
+
+uint32_t MathUtil::popcount(uint8_t v)
+{
+	return kBitsSetTable256[v];
+}
+
+uint32_t MathUtil::popcount(uint16_t v)
+{
+	return kBitsSetTable256[v & 0xff] + kBitsSetTable256[(v >> 8) & 0xff];
+}
+
+uint32_t MathUtil::popcount(uint32_t v)
+{
+	return kBitsSetTable256[v & 0xff] + kBitsSetTable256[(v >> 8) & 0xff] +
+		kBitsSetTable256[(v >> 16) & 0xff] + kBitsSetTable256[v >> 24];
+}
+
 size_t MathUtil::ComponentSize(ComponentType ct)
 {
 	switch (ct)
@@ -64,6 +89,35 @@ size_t MathUtil::DataTypeSize(DataType dt)
 	return 0;
 }
 
+size_t MathUtil::PixelSize(PixelFormat pixelFormat)
+{
+	switch (pixelFormat)
+	{
+	case PixelFormat::PF_UINT8_ALPHA:
+		return 1;
+	case PixelFormat::PF_UINT8_RGB:
+		return 3;
+	case PixelFormat::PF_UINT8_RGBA:
+		return 4;
+	case PixelFormat::PF_UINT16_ALPHA:
+		return 2;
+	case PixelFormat::PF_UINT16_RGB:
+		return 6;
+	case PixelFormat::PF_UINT16_RGBA:
+		return 8;
+	case PixelFormat::PF_FLOAT32_ALPHA:
+		return 4;
+	case PixelFormat::PF_FLOAT32_RGB:
+		return 12;
+	case PixelFormat::PF_FLOAT32_RGBA:
+		return 16;
+	default:
+		break;
+	}
+	assert(false);
+	return 0;
+}
+
 float MathUtil::unitRandom(void)
 {
 	return float(rand()) / RAND_MAX;

source/core/source/math/dvc_vector4.cpp

@@ -4,6 +4,11 @@ DV_CORE_BEGIN_NAMESPACE
 
 
 const fVector4 fVector4::ZERO(0, 0, 0, 0);
+const fVector4 fVector4::ONE(1, 1, 1, 1);
+const fVector4 fVector4::UNIT_X(1, 0, 0, 0);
+const fVector4 fVector4::UNIT_Y(0, 1, 0, 0);
+const fVector4 fVector4::UNIT_Z(0, 0, 1, 0);
+const fVector4 fVector4::UNIT_W(0, 0, 0, 1);
 const fVector4 fVector4::WHITE(1, 1, 1, 1);
 const fVector4 fVector4::BLACK(0, 0, 0, 1);
 const fVector4 fVector4::RED(1, 0, 0, 1);

source/core/source/pipe/dvc_render_pipe.cpp

@@ -0,0 +1,47 @@
+#include "pipe/dvc_render_pipe.h"
+#include "scene/dvc_scene_node.h"
+#include "pipe/dvc_render_step0_input_assember.h"
+#include "pipe/dvc_render_step1_vertex_shader.h"
+#include "pipe/dvc_render_step2_rasterizer.h"
+#include "pipe/dvc_render_step3_output_merge.h"
+#include "scene/component/dvc_camera_component.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+RenderPipe::RenderPipe(Device& device)
+	: m_device(device)
+	, m_aaTech(AntiAliasingTech::AA_None)
+{
+
+}
+
+RenderPipe::~RenderPipe()
+{
+
+}
+
+void RenderPipe::pushRenderable(RenderableConstPtr renderable)
+{
+	m_renderableQueue.push_back(renderable);
+}
+
+void RenderPipe::process(RenderTarget& renderTarget)
+{
+	//Assembere input
+	InputAssemberStep IA;
+	IA.process(m_renderableQueue);
+
+	//Vertex shader
+	VertexShaderStep VS;
+	VS.process(*this, IA.m_nodes);
+
+	//Pixel shader
+	RasterizerStep rasterizerStep;
+	rasterizerStep.process(*this, VS.m_nodes, m_aaTech, renderTarget.getWidth(), renderTarget.getHeight());
+
+	//Output Merge
+	OutputMergerStep OM;
+	OM.process(rasterizerStep.m_startOffsetArray, rasterizerStep.m_fragementArray, m_aaTech, renderTarget);
+}
+
+DV_CORE_END_NAMESPACE

source/core/source/pipe/dvc_render_queue.cpp

@@ -1,56 +0,0 @@
-#include "pipe/dvc_render_queue.h"
-#include "scene/dvc_scene_node.h"
-#include "pipe/dvc_render_step_IA.h"
-#include "pipe/dvc_render_step_VS.h"
-#include "pipe/dvc_render_step_PS.h"
-#include "scene/component/dvc_camera_component.h"
-
-DV_CORE_BEGIN_NAMESPACE
-
-RenderQueue::RenderQueue()
-{
-
-}
-
-RenderQueue::~RenderQueue()
-{
-
-}
-
-void RenderQueue::pushRenderable(RenderableConstPtr renderable)
-{
-	m_queue.push_back(renderable);
-}
-
-RenderableConstPtr RenderQueue::getRenderable(size_t index) const
-{
-	assert(index < m_queue.size());
-	if (index < m_queue.size())
-	{
-		return m_queue[index];
-	}
-	return nullptr;
-}
-
-void RenderQueue::build(const Scene& scene)
-{
-	//Build render queue
-	scene.getRootSceneNode()->buildRenderQueue(fMatrix4::IDENTITY, *this);
-}
-
-void RenderQueue::process(UniformBuffer& uniformBuffer, RenderTarget& renderTarget)
-{
-	//Assembere input
-	InputAssemberStep IA;
-	IA.process(*this);
-
-	//Vertex shader
-	VertexShaderStep VS;
-	VS.process(uniformBuffer, IA.getNodes());
-
-	//Pixel shader
-	PixelShaderStep PS;
-	PS.process(VS.getNodes(), renderTarget);
-}
-
-DV_CORE_END_NAMESPACE

source/core/source/pipe/dvc_render_step0_input_assember.cpp

@@ -1,14 +1,14 @@
-#include "pipe/dvc_render_step_IA.h"
+#include "pipe/dvc_render_step0_input_assember.h"
 #include "pipe/dvc_renderable.h"
 
 DV_CORE_BEGIN_NAMESPACE
 
-void InputAssemberStep::process(const RenderQueue& renderQueue)
+void InputAssemberStep::process(const RenderableArray& renderableArray)
 {
-	size_t counts = renderQueue.getRenderableCounts();
+	size_t counts = renderableArray.size();
 	for (size_t i = 0; i < counts; i++)
 	{
-		RenderableConstPtr renderable = renderQueue.getRenderable(i);
+		RenderableConstPtr renderable = renderableArray[i];
 		if (renderable)
 		{
 			Node node;

source/core/source/pipe/dvc_render_step1_vertex_shader.cpp

@@ -0,0 +1,82 @@
+#include "pipe/dvc_render_step1_vertex_shader.h"
+#include "shader/dvc_shader_interface.h"
+#include "device/dvc_buffer_accessor.h"
+#include "math/dvc_math_util.h"
+#include "asset/dvc_material.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+void VertexShaderStep::process(RenderPipe& pipe, const InputAssemberStep::NodeArray& assembedNodeArray)
+{
+	Device& device = pipe.getDevice();
+	UniformBuffer& uniformBuffer = pipe.getUniformBuffer();
+
+	const fVector3* eyePos = (const fVector3*)(uniformBuffer.getAttribute("camera:eye_pos"));
+	const fMatrix4* cameraView = (const fMatrix4*)(uniformBuffer.getAttribute("camera:view_mat"));
+	float32_t cameraNear = *((const float32_t*)(uniformBuffer.getAttribute("camera:near")));
+	float32_t cameraFar = *((const float32_t*)(uniformBuffer.getAttribute("camera:far")));
+
+	//int debug_index = 0;
+	InputAssemberStep::NodeArray::const_iterator it, end = assembedNodeArray.end();
+	for (it = assembedNodeArray.begin(); it != end; ++it)
+	{
+		const InputAssemberStep::Node& inputNode = *it;
+
+		//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);
+
+		VertexShaderInterface* vs = pipe.getDebugMaterial() ? pipe.getDebugMaterial()->getVertexShader(): inputNode.material->getVertexShader();
+		vs->begin(&pipe,
+			[inputNode](VertexElementType type) -> DeviceBufferAccessorConstPtr
+			{
+				InputAssemberStep::PrimitiveAttributes::const_iterator it = inputNode.vertexData.find(type);
+				if (it != inputNode.vertexData.end())
+				{
+					return it->second;
+				}
+				return nullptr;
+			}
+		);
+
+		size_t vertexCounts = inputNode.indices->getCount();
+		size_t outputVertexByteSize = vs->getOutputVertexDesc().vertexByteSize();
+
+		Node outputNode;
+		outputNode.material = inputNode.material;
+		outputNode.vertexCounts = vertexCounts;
+		outputNode.vertexDesc = vs->getOutputVertexDesc();
+		outputNode.vertexBuf = device.newDeviceBuffer(outputVertexByteSize * vertexCounts);
+		outputNode.depth.resize(vertexCounts);
+		outputNode.invZ.resize(vertexCounts);
+
+		for (size_t i = 0; i < vertexCounts; i++)
+		{
+			uint16_t index = *((const uint16_t*)(inputNode.indices->getElement(i)));
+
+			uint8_t* outputVertexMemory = (uint8_t*)(outputNode.vertexBuf->ptr(i * outputVertexByteSize));
+			vs->process(index, (float32_t*)outputVertexMemory);
+
+			//TODO: clip
+
+
+			//TODO: div-zero
+
+			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);
+			float32_t cameraSpaceZ = vertexNDCPos->z;
+			outputNode.invZ[i] = 1.f/std::fabsf(vertexNDCPos->z);
+		}
+
+		m_nodes.push_back(outputNode);
+
+		vs->end();
+	}
+
+}
+
+DV_CORE_END_NAMESPACE

source/core/source/pipe/dvc_render_step2_rasterizer.cpp

@@ -1,30 +1,44 @@
-#include "pipe/dvc_render_step_PS.h"
+#include "pipe/dvc_render_step2_rasterizer.h"
 #include "shader/dvc_shader_interface.h"
 #include "device/dvc_buffer.h"
 #include "rasterizer/dvc_rasterizer_triangle.h"
 #include "math/dvc_math_util.h"
+#include "asset/dvc_material.h"
+#include "asset/dvc_texture.h"
 
 DV_CORE_BEGIN_NAMESPACE
 
-void PixelShaderStep::process(const VertexShaderStep::NodeArray& vsNodeArray, RenderTarget& renderTarget)
+void RasterizerStep::process(RenderPipe& pipe, const VertexShaderStep::NodeArray& vsNodeArray, AntiAliasingTech aaTech, int32_t canvasWidth, int32_t canvasHeight)
 {
-	ShaderFileInterface* shaderInterface = davinci::LoadShaderFile("TestShader.dll");
-	PixelShaderInterface* pixelShader = shaderInterface->getPixelShader("xxx");
-
-	int32_t targetWidth = renderTarget.getWidth();
-	int32_t targetHeight = renderTarget.getHeight();
+	Device& device = pipe.getDevice();
+	UniformBuffer& uniformBuffer = pipe.getUniformBuffer();
 
 	fMatrix4 view_trans =
-		fMatrix4::makeTrans(targetWidth / 2.f, targetHeight / 2.f, 0.f) *
-		fMatrix4::makeScale(targetWidth / 2.f, targetHeight / 2.f, 1.f);
+		fMatrix4::makeTrans(canvasWidth / 2.f, canvasHeight / 2.f, 0.f) *
+		fMatrix4::makeScale(canvasWidth / 2.f, canvasHeight / 2.f, 1.f);
+
+	m_startOffsetArray.resize(canvasWidth* canvasHeight, -1);
+
+	MaterialPtr debugMaterial = pipe.getDebugMaterial();
 
 	VertexShaderStep::NodeArray::const_iterator it, end = vsNodeArray.end();
 	for (it = vsNodeArray.begin(); it != end; ++it)
 	{
 		const VertexShaderStep::Node& node = *it;
 
+		if (debugMaterial)
+		{
+			debugMaterial->pickupParam(node.material);
+		}
+		FragementShaderInterface* fragementShader = debugMaterial ? debugMaterial->getFragementShader() : node.material->getFragementShader();
+		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)->offset;
+		size_t POS_offset = node.vertexDesc.getElementByType(VET_POSITION_NDC)->offset;
 
 		for (size_t i = 0; i < node.vertexCounts; i += 3) 
 		{
@@ -39,9 +53,10 @@ void PixelShaderStep::process(const VertexShaderStep::NodeArray& vsNodeArray, Re
 			std::vector<float32_t> invZ = { node.invZ[i + 0], node.invZ[i + 1], node.invZ[i + 2] };
 			std::vector<float32_t> vertexDepth = { node.depth[i+0], node.depth[i + 1], node.depth[i + 2]};
 
-			Rasterizer::drawTriangleLarrabee(targetWidth, targetHeight, pos0.xy(), pos1.xy(), pos2.xy(),
-				[pixelShader, vertex0, vertex1, vertex2, invZ, vertexDepth, &node, &renderTarget]
-				(const std::pair<int32_t, int32_t>& dot, const fVector3& percent)
+			Rasterizer::drawTriangleLarrabee(aaTech,
+				canvasWidth, canvasHeight, pos0.xy(), pos1.xy(), pos2.xy(),
+				[this, canvasWidth, fragementShader, vertex0, vertex1, vertex2, invZ, vertexDepth, &node]
+				(const std::pair<int32_t, int32_t>& dot, const fVector3& percent, uint32_t mask)
 				{
 					fVector3 percentCorrected(percent);
 
@@ -59,14 +74,23 @@ void PixelShaderStep::process(const VertexShaderStep::NodeArray& vsNodeArray, Re
 					}
 
 					fVector4 color;
-					pixelShader->process(node.vertexDesc, &(pixelData[0]), color);
+					fragementShader->process(pixelData.data(), color);
 
 					float32_t depth = MathUtil::lerp3(vertexDepth[0], vertexDepth[1], vertexDepth[2], percentCorrected);
 
 					int32_t x = dot.first;
 					int32_t y = dot.second;
-					renderTarget.setPixel(x, y, color, depth);
-				}				
+					int32_t currentOffset = m_startOffsetArray[x + y * canvasWidth];
+
+					m_startOffsetArray[x + y * canvasWidth] = (int32_t)(m_fragementArray.size());
+
+					Fragement newFragment;
+					newFragment.color = color;
+					newFragment.depth = depth;
+					newFragment.mask = mask;
+					newFragment.next = currentOffset;
+					this->m_fragementArray.push_back(newFragment);
+				},true			
 			);
 		}
 	}

source/core/source/pipe/dvc_render_step3_output_merge.cpp

@@ -0,0 +1,54 @@
+#include "pipe/dvc_render_step3_output_merge.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+void OutputMergerStep::process(const RasterizerStep::StartOffsetArray& startOffsetArray, const RasterizerStep::FragementArray& fragementArray,
+	AntiAliasingTech aaTech, RenderTarget& renderTarget)
+{
+	int32_t canvasWidth = renderTarget.getWidth();
+	int32_t canvasHeight = renderTarget.getHeight();
+
+	for (int32_t y = 0; y < canvasHeight; y++)
+	{
+		for (int32_t x = 0; x < canvasWidth; x++)
+		{
+			int32_t fragementID = startOffsetArray[y * canvasWidth + x];
+			std::multimap<float32_t, int32_t> fragementArrayMap;
+
+			while (fragementID >=0 && fragementID < (int32_t)fragementArray.size())
+			{
+				const RasterizerStep::Fragement& fragement = fragementArray[fragementID];
+				fragementArrayMap.insert(std::make_pair(-fragement.depth, fragementID));
+				fragementID = fragement.next;
+			}
+
+			if (aaTech == AntiAliasingTech::AA_None)
+			{
+				mergeFragement_without_AA(x, y, fragementArrayMap, fragementArray, renderTarget);
+			}
+			else if (aaTech == AntiAliasingTech::AA_MSAA_2X2)
+			{
+				mergeFragement_with_AA<4, 0xF>(x, y, fragementArrayMap, fragementArray, renderTarget);
+			}
+			else if (aaTech == AntiAliasingTech::AA_MSAA_4X4)
+			{
+				mergeFragement_with_AA<16, 0xFFFF>(x, y, fragementArrayMap, fragementArray, renderTarget);
+			}
+		}
+	}
+}
+
+void OutputMergerStep::mergeFragement_without_AA(int32_t x, int32_t y, const std::multimap<float32_t, int32_t>& fragementArrayMap,
+	const RasterizerStep::FragementArray& fragementArray, RenderTarget& renderTarget)
+{
+	if (fragementArrayMap.empty())
+	{
+		return;
+	}
+
+	const RasterizerStep::Fragement& firstFragement = fragementArray[fragementArrayMap.rbegin()->second];
+	renderTarget.setPixel(x, y, firstFragement.color, firstFragement.depth);
+}
+
+DV_CORE_END_NAMESPACE
+

source/core/source/pipe/dvc_render_step_VS.cpp

@@ -1,84 +0,0 @@
-#include "pipe/dvc_render_step_VS.h"
-#include "shader/dvc_shader_interface.h"
-#include "device/dvc_buffer_accessor.h"
-#include "math/dvc_math_util.h"
-
-DV_CORE_BEGIN_NAMESPACE
-
-void VertexShaderStep::process(UniformBuffer& uniformBuffer, const InputAssemberStep::NodeArray& assembedNodeArray)
-{
-	ShaderFileInterface* shaderInterface = davinci::LoadShaderFile("TestShader.dll");
-	VertexShaderInterface* standardVS = shaderInterface->getVertexShader("xxxx");
-
-	const fVector3* eyePos = (const fVector3*)(uniformBuffer.getAttribute("camera:eye_pos"));
-	const fMatrix4* cameraView = (const fMatrix4*)(uniformBuffer.getAttribute("camera:view_mat"));
-	float32_t cameraNear = *((const float32_t*)(uniformBuffer.getAttribute("camera:near")));
-	float32_t cameraFar = *((const float32_t*)(uniformBuffer.getAttribute("camera:far")));
-
-	//int debug_index = 0;
-	InputAssemberStep::NodeArray::const_iterator it, end = assembedNodeArray.end();
-	for (it = assembedNodeArray.begin(); it != end; ++it)
-	{
-		const InputAssemberStep::Node& inputNode = *it;
-
-		//update self uniform value
-		uniformBuffer.setAttribute("self:world_transform", inputNode.transform);
-
-		standardVS->prepare(&uniformBuffer,
-			[inputNode](VertexElementType type) -> DeviceBufferAccessorConstPtr
-			{
-				InputAssemberStep::PrimitiveAttributes::const_iterator it = inputNode.vertexData.find(type);
-				if (it != inputNode.vertexData.end())
-				{
-					return it->second;
-				}
-				return nullptr;
-			}
-		);
-
-		size_t vertexCounts = inputNode.indices->getCount();
-
-		Node outputNode;
-		outputNode.vertexCounts = vertexCounts;
-		outputNode.vertexDesc = standardVS->getOutputVertexDesc();
-		outputNode.vertexBuf = std::make_shared<DeviceBuffer>(outputNode.vertexDesc.vertexByteSize() * vertexCounts);
-		outputNode.depth.resize(vertexCounts);
-		outputNode.invZ.resize(vertexCounts);
-
-		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
-			}
-
-			fVector3 vertexWorldPos;
-			void* outputVertexMemory = outputNode.vertexBuf->ptr(i* outputNode.vertexDesc.vertexByteSize());
-			standardVS->process(index, outputVertexMemory, vertexWorldPos);
-
-			//TODO: clip
-
-
-			//TODO: div-zero
-			fVector3 cameraSpacePos = (*cameraView) * vertexWorldPos;
-			outputNode.depth[i] = (std::fabsf(cameraSpacePos.z) - cameraNear) / (cameraFar - cameraNear);
-
-			float32_t cameraSpaceZ = cameraSpacePos.z;
-			outputNode.invZ[i] = 1.f/std::fabsf(cameraSpacePos.z);
-		}
-
-		m_nodes.push_back(outputNode);
-	}
-
-}
-
-DV_CORE_END_NAMESPACE

source/core/source/pipe/dvc_renderable_entity.cpp

@@ -15,6 +15,7 @@ bool RenderableEntity::buildAssemberNode(InputAssemberStep::Node& node) const
 	node.transform = m_worldTransform;
 	node.vertexData = m_primitive->attributes;
 	node.indices = m_primitive->indices;
+	node.material = m_primitive->material;
 
 	return true;
 }

source/core/source/rasterizer/dvc_rasterizer_triangle.cpp

@@ -20,22 +20,27 @@ inline bool operator==(const bool3_t& arr, bool value)
 
 struct DrawTriangleParam
 {
-	bool		ccw;
-	fVector2	verts[3];
-	float32_t	bbox_min_x;
-	float32_t	bbox_max_x;
-	float32_t	bbox_min_y;
-	float32_t	bbox_max_y;
-	bool3_t		tlBorder;
-	float32_t	area;
-	iFloat3		edgesDX, edgesDY;
-	iFloat3		halfEdge;
+	AntiAliasingTech	aaTech;
+	bool				ccw;
+	fVector2			verts[3];
+	float32_t			bbox_min_x;
+	float32_t			bbox_max_x;
+	float32_t			bbox_min_y;
+	float32_t			bbox_max_y;
+	bool3_t				tlBorder;
+	float32_t			area;
+	iFloat3				edgesDX, edgesDY;
+
+	iFloat3				halfEdge;
+	iFloat3				quaterEdge;
+	iFloat3				oneEighthEdge;
+
 	Rasterizer::DebugParam	debugParam;
 };
 
 enum { MIN_TILE_WIDTH_IN_PIXELS = 64 };
 
-void _fillPixel(const DrawTriangleParam& param, int32_t xLB, int32_t yLB, Rasterizer::DrawTriangleCallback callback)
+void _fillPixel(const DrawTriangleParam& param, int32_t xLB, int32_t yLB, uint32_t mask, Rasterizer::DrawTriangleCallback callback)
 {
 	fVector2 pixel(xLB + 0.5f, yLB + 0.5f);
 	const fVector2 v0(param.verts[0]), v1(param.verts[1]), v2(param.verts[2]);
@@ -46,42 +51,140 @@ void _fillPixel(const DrawTriangleParam& param, int32_t xLB, int32_t yLB, Raster
 
 	fVector3 t = fVector3(w0 / param.area, (param.ccw ? w1 : w2) / param.area, (param.ccw ? w2 : w1) / param.area);
 
-	callback(std::make_pair(xLB, yLB), t);
+	callback(std::make_pair(xLB, yLB), t, mask);
 }
 
 void _fillTile(const DrawTriangleParam& param, int32_t currentTileSize, 
 	int32_t xLB, int32_t yLB, Rasterizer::DrawTriangleCallback callback)
 {
-	if (currentTileSize == 1)
-	{
-		_fillPixel(param, xLB, yLB, callback);
-		return;
-	}
-
 	for (int32_t yIndex = yLB; yIndex < yLB + currentTileSize; yIndex++)
 	{
 		for (int32_t xIndex = xLB; xIndex < xLB + currentTileSize; xIndex++)
 		{
-			_fillPixel(param, xIndex, yIndex, callback);
+			_fillPixel(param, xIndex, yIndex, ~0, callback);
 		}
 	}
 }
 
-void _drawPixel(DrawTriangleParam& param, 
+void _drawPixel_without_AA(DrawTriangleParam& param,
 	int32_t xLB, int32_t yLB, const iFloat3& edgesLB, const bool3_t& intersectant,
 	Rasterizer::DrawTriangleCallback callback)
 {
 	iFloat3 centerEdges(edgesLB);
 	centerEdges.add(param.halfEdge);
 
-	bool insideTriangle = 
+	bool insideTriangle =
 		(centerEdges.x > 0 || (param.tlBorder[0] && centerEdges.x == 0)) &&
 		(centerEdges.y > 0 || (param.tlBorder[1] && centerEdges.y == 0)) &&
 		(centerEdges.z > 0 || (param.tlBorder[2] && centerEdges.z == 0));
 
 	if (insideTriangle)
 	{
-		_fillPixel(param, xLB, yLB, callback);
+		_fillPixel(param, xLB, yLB, ~0, callback);
+	}
+}
+
+void _drawPixel_with_MSAA2X2(DrawTriangleParam& param,
+	int32_t x, int32_t y, const iFloat3& edgesLB, const bool3_t& intersectant,
+	Rasterizer::DrawTriangleCallback callback)
+{
+	// 2x2 MSAA;
+	iFloat3 sampleEdgesDX(param.edgesDX);
+	sampleEdgesDX.mul(iFloat::kHalf);
+
+	iFloat3 sampleEdgesDY(param.edgesDY);
+	sampleEdgesDY.mul(iFloat::kHalf);
+
+	iFloat3 firstSampleEdges(edgesLB);
+	firstSampleEdges.add(param.quaterEdge); // 0.25f
+
+	iFloat3 rowEdges(firstSampleEdges);
+
+	uint32_t mask = 0;
+	for (int32_t yIndex = 0; yIndex < 2; yIndex++)
+	{
+		iFloat3 sampleEdges(rowEdges);
+
+		for (int32_t xIndex = 0; xIndex < 2; xIndex++)
+		{
+			bool sampleInsideTriangle =
+				(sampleEdges.x > 0 || (param.tlBorder[0] && sampleEdges.x == 0)) &&
+				(sampleEdges.y > 0 || (param.tlBorder[1] && sampleEdges.y == 0)) &&
+				(sampleEdges.z > 0 || (param.tlBorder[2] && sampleEdges.z == 0));
+
+			if (sampleInsideTriangle)
+			{
+				mask |= (1 << (yIndex * 2 + xIndex));
+			}
+
+			sampleEdges.sub(sampleEdgesDY);
+		}
+
+		rowEdges.add(sampleEdgesDX);
+	}
+
+	_fillPixel(param, x, y, mask, callback);
+}
+
+void _drawPixel_with_MSAA4X4(DrawTriangleParam& param,
+	int32_t x, int32_t y, const iFloat3& edgesLB, const bool3_t& intersectant,
+	Rasterizer::DrawTriangleCallback callback)
+{
+	// 4x4 MSAA;
+	iFloat3 sampleEdgesDX(param.edgesDX);
+	sampleEdgesDX.mul(iFloat::kQuater);
+
+	iFloat3 sampleEdgesDY(param.edgesDY);
+	sampleEdgesDY.mul(iFloat::kQuater);
+
+	iFloat3 firstSampleEdges(edgesLB);
+	firstSampleEdges.add(param.oneEighthEdge); // 0.125f
+
+	iFloat3 rowEdges(firstSampleEdges);
+
+	uint32_t mask = 0;
+	for (int32_t yIndex = 0; yIndex < 4; yIndex++)
+	{
+		iFloat3 sampleEdges(rowEdges);
+		
+		for (int32_t xIndex = 0; xIndex < 4; xIndex++)
+		{
+			bool sampleInsideTriangle =
+				(sampleEdges.x > 0 || (param.tlBorder[0] && sampleEdges.x == 0)) &&
+				(sampleEdges.y > 0 || (param.tlBorder[1] && sampleEdges.y == 0)) &&
+				(sampleEdges.z > 0 || (param.tlBorder[2] && sampleEdges.z == 0));
+
+			if (sampleInsideTriangle)
+			{
+				mask |= (1 << (yIndex * 4 + xIndex));
+			}
+
+			sampleEdges.sub(sampleEdgesDY);
+		}
+
+		rowEdges.add(sampleEdgesDX);
+	}
+
+	_fillPixel(param, x, y, mask, callback);
+}
+
+void _drawPixel(DrawTriangleParam& param, 
+	int32_t xLB, int32_t yLB, const iFloat3& edgesLB, const bool3_t& intersectant,
+	Rasterizer::DrawTriangleCallback callback)
+{
+	switch (param.aaTech)
+	{
+	case AntiAliasingTech::AA_MSAA_4X4:
+		_drawPixel_with_MSAA4X4(param, xLB, yLB, edgesLB, intersectant, callback);
+		break;
+
+	case AntiAliasingTech::AA_MSAA_2X2:
+		_drawPixel_with_MSAA2X2(param, xLB, yLB, edgesLB, intersectant, callback);
+		break;
+
+	case AntiAliasingTech::AA_None:
+	default:
+		_drawPixel_without_AA(param, xLB, yLB, edgesLB, intersectant, callback);
 	}
 }
 
@@ -198,7 +301,7 @@ void _drawTriangle_Tile(DrawTriangleParam& param, int32_t currentTileSize,
 	}
 }
 
-void Rasterizer::drawTriangleLarrabee(int32_t canvasWidth, int32_t canvasHeight, 
+void Rasterizer::drawTriangleLarrabee(AntiAliasingTech aaTech, int32_t canvasWidth, int32_t canvasHeight,
 	const fVector2& v0, const fVector2& v1, const fVector2& v2, 
 	DrawTriangleCallback callback, bool ccw, const DebugParam* debugParam)
 {
@@ -225,6 +328,7 @@ void Rasterizer::drawTriangleLarrabee(int32_t canvasWidth, int32_t canvasHeight,
 	tileSize /= 4;
 
 	DrawTriangleParam param;
+	param.aaTech = aaTech;
 	int32_t widthInTiles = canvasWidth / tileSize;
 
 	//Whether the three input vertices are in the agreed clockwise order or not, 
@@ -285,7 +389,10 @@ void Rasterizer::drawTriangleLarrabee(int32_t canvasWidth, int32_t canvasHeight,
 		size_t v_end = (v + 1) % 3;
 		param.edgesDX[v] = vertices[v_end].x - vertices[v].x;
 		param.edgesDY[v] = vertices[v_end].y - vertices[v].y;
+
 		param.halfEdge[v] = (param.edgesDX[v]- param.edgesDY[v]) * iFloat::kHalf;
+		param.quaterEdge[v] = (param.edgesDX[v] - param.edgesDY[v]) * iFloat::kQuater;
+		param.oneEighthEdge[v] = (param.edgesDX[v] - param.edgesDY[v]) * iFloat::kOneEighth;
 
 		tileEdgesDX[v] = param.edgesDX[v] * tileSize;
 		tileEdgesDY[v] = param.edgesDY[v] * tileSize;
@@ -374,8 +481,6 @@ void Rasterizer::drawTriangleLarrabee(int32_t canvasWidth, int32_t canvasHeight,
 	}
 
 	iFloat3 rowEdges(edgesFirstLB);
-
-	int32_t tile_row_start = first_tile_y * tileSize + first_tile_x;
 	int32_t yLB = first_tile_y * tileSize;
 
 	for (int32_t tile_y = first_tile_y; tile_y <= last_tile_y; tile_y++)
@@ -384,7 +489,6 @@ void Rasterizer::drawTriangleLarrabee(int32_t canvasWidth, int32_t canvasHeight,
 		iFloat3 tileEdgesReject(edgesReject);
 		iFloat3 tileEdgesAccept(edgesAccept);
 
-		int32_t tile_i = tile_row_start;
 		int32_t xLB = first_tile_x * tileSize;
 
 		for (int32_t tile_x = first_tile_x; tile_x <= last_tile_x; tile_x++) 
@@ -414,7 +518,6 @@ void Rasterizer::drawTriangleLarrabee(int32_t canvasWidth, int32_t canvasHeight,
 			edgesTileLB.sub(tileEdgesDY);
 			tileEdgesReject.sub(tileEdgesDY);
 			tileEdgesAccept.sub(tileEdgesDY);
-			tile_i++;
 			xLB += tileSize;
 		}
 
@@ -422,7 +525,6 @@ void Rasterizer::drawTriangleLarrabee(int32_t canvasWidth, int32_t canvasHeight,
 		rowEdges.add(tileEdgesDX);
 		edgesReject.add(tileEdgesDX);
 		edgesAccept.add(tileEdgesDX);
-		tile_row_start += widthInTiles;
 		yLB += tileSize;
 	}
 
@@ -505,7 +607,7 @@ void Rasterizer::drawTriangleBoundingBox(int32_t canvasWidth, int32_t canvasHeig
 
 			fVector3 t = fVector3(w0 / area, (ccw ? w1 : w2) / area, (ccw ? w2 : w1) / area);
 
-			callback(std::make_pair(x, y), t);
+			callback(std::make_pair(x, y), t, ~0);
 		}
 	}
 }

source/core/source/scene/component/dvc_camera_component.cpp

@@ -51,7 +51,7 @@ void CameraComponent::setCameraDefine(const CameraComponent::CameraDefine& camer
 	m_viewProjMatrix = matProj * matView;
 }
 
-void CameraComponent::render(const fMatrix4& transParent, RenderQueue& queue) const
+void CameraComponent::buildRenderableQueue(const fMatrix4& transParent, RenderPipe& pipe) const
 {
 
 }

source/core/source/scene/component/dvc_component.cpp

@@ -13,7 +13,7 @@ SceneComponent::~SceneComponent()
 
 }
 
-void SceneComponent::render(const fMatrix4& transParent, RenderQueue& queue) const
+void SceneComponent::buildRenderableQueue(const fMatrix4& transParent, RenderPipe& pipe) const
 {
 
 }

source/core/source/scene/component/dvc_light_component.cpp

@@ -24,7 +24,7 @@ void LightComponent::setLightDefine(const LightDefine& lightDefine)
 	m_define = lightDefine;
 }
 
-void LightComponent::render(const fMatrix4& transParent, RenderQueue& queue) const
+void LightComponent::buildRenderableQueue(const fMatrix4& transParent, RenderPipe& pipe) const
 {
 
 }

source/core/source/scene/component/dvc_mesh_component.cpp

@@ -1,7 +1,7 @@
 #include "scene/component/dvc_mesh_component.h"
 #include "asset/dvc_mesh.h"
 #include "pipe/dvc_renderable_entity.h"
-#include "pipe/dvc_render_queue.h"
+#include "pipe/dvc_render_pipe.h"
 
 DV_CORE_BEGIN_NAMESPACE
 
@@ -27,9 +27,9 @@ void MeshComponent::setMesh(MeshConstPtr mesh)
 	m_mesh = mesh;
 }
 
-void MeshComponent::render(const fMatrix4& transParent, RenderQueue& queue) const
+void MeshComponent::buildRenderableQueue(const fMatrix4& transParent, RenderPipe& pipe) const
 {
-	SceneComponent::render(transParent, queue);
+	SceneComponent::buildRenderableQueue(transParent, pipe);
 
 	int32_t primitiveCounts = m_mesh->getPrimitiveCounts();
 	for (int32_t i = 0; i < primitiveCounts; i++)
@@ -37,7 +37,7 @@ void MeshComponent::render(const fMatrix4& transParent, RenderQueue& queue) cons
 		Mesh::PrimitiveConstPtr primitivePtr = m_mesh->getPrimitive(i);
 
 		RenderablePtr renderable = std::make_shared<RenderableEntity>(primitivePtr, transParent);
-		queue.pushRenderable(renderable);
+		pipe.pushRenderable(renderable);
 	}
 }
 

source/core/source/scene/dvc_scene.cpp

@@ -1,8 +1,5 @@
 #include "scene/dvc_scene.h"
 #include "scene/dvc_scene_node.h"
-#include "device/dvc_buffer.h"
-#include "device/dvc_buffer_view.h"
-#include "device/dvc_buffer_accessor.h"
 #include "scene/component/dvc_camera_component.h"
 
 DV_CORE_BEGIN_NAMESPACE
@@ -33,79 +30,6 @@ void Scene::clear(void)
 		m_rootSceneNode->clear();
 	}
 	m_rootSceneNode = nullptr;
-
-	//clear assets
-	m_meshArray.clear();
-
-	//clear device resources
-	m_bufferAccessorArray.clear();
-	m_bufferViewArray.clear();
-	m_deviceBufferArray.clear();
-}
-
-DeviceBufferPtr Scene::newDeviceBuffer()
-{
-	DeviceBufferPtr deviceBuffer = std::make_shared<DeviceBuffer>();
-	m_deviceBufferArray.push_back(deviceBuffer);
-	return deviceBuffer;
-}
-
-DeviceBufferConstPtr Scene::getDeviceBuffer(int32_t index) const
-{
-	if (index < 0 || index >= m_deviceBufferArray.size())
-	{
-		return nullptr;
-	}
-	return m_deviceBufferArray[index];
-}
-
-DeviceBufferViewPtr Scene::newDeviceBufferView(DeviceBufferConstPtr buffer, size_t offset, size_t length, size_t stride)
-{
-	DeviceBufferViewPtr deviceBufferView = std::make_shared<DeviceBufferView>(buffer, offset, length, stride);
-	m_bufferViewArray.push_back(deviceBufferView);
-	return deviceBufferView;
-}
-
-DeviceBufferViewPtr Scene::getDeviceBufferView(int32_t index) const
-{
-	if (index < 0 || index >= m_bufferViewArray.size())
-	{
-		return nullptr;
-	}
-	return m_bufferViewArray[index];
-}
-
-DeviceBufferAccessorPtr Scene::newDeviceBufferAccessor(DeviceBufferViewConstPtr bufferView, size_t offset,
-	size_t count, ComponentType componentType, DataType dataType)
-{
-	DeviceBufferAccessorPtr deviceBufferAccessor = std::make_shared<DeviceBufferAccessor>(
-		bufferView, offset, count, componentType, dataType);
-	m_bufferAccessorArray.push_back(deviceBufferAccessor);
-	return deviceBufferAccessor;
-}
-
-DeviceBufferAccessorPtr Scene::getDeviceBufferAccessor(int32_t index) const
-{
-	if (index < 0 || index >= m_bufferAccessorArray.size())
-	{
-		return nullptr;
-	}
-	return m_bufferAccessorArray[index];
-}
-
-int32_t Scene::pushNewMeshAsset(MeshPtr mesh)
-{
-	m_meshArray.push_back(mesh);
-	return (int32_t)(m_meshArray.size());
-}
-
-MeshConstPtr Scene::getMesh(int32_t index) const
-{
-	if (index < 0 || index >= m_meshArray.size())
-	{
-		return nullptr;
-	}
-	return m_meshArray[index];
 }
 
 SceneNodePtr Scene::newSceneNode(const std::string& name)
@@ -120,4 +44,9 @@ SceneNodePtr Scene::getRootSceneNode(void) const
 	return m_rootSceneNode;
 }
 
+void Scene::buildRenderableQueue(RenderPipe& pipe) const
+{
+	getRootSceneNode()->buildRenderableQueue(fMatrix4::IDENTITY, pipe);
+}
+
 DV_CORE_END_NAMESPACE

source/core/source/scene/dvc_scene_node.cpp

@@ -89,18 +89,18 @@ SceneComponentConstPtr SceneNode::getComponent(size_t index) const
 	return m_componentArray[index];
 }
 
-void SceneNode::buildRenderQueue(const fMatrix4& transParent, RenderQueue& queue)
+void SceneNode::buildRenderableQueue(const fMatrix4& transParent, RenderPipe& pipe)
 {
 	fMatrix4 transform = m_transform * transParent;
 
 	for (auto component : m_componentArray)
 	{
-		component->render(transform, queue);
+		component->buildRenderableQueue(transform, pipe);
 	}
 
 	for (auto child : m_childen) 
 	{
-		child->buildRenderQueue(transform, queue);
+		child->buildRenderableQueue(transform, pipe);
 	}
 }
 

source/core/source/shader/dvc_shader_functions.cpp

@@ -0,0 +1,15 @@
+#include "shader/dvc_shader_functions.h"
+#include "pipe/dvc_render_pipe.h"
+#include "asset/dvc_texture.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+fVector4 shader::texture2D(const RenderPipe& pipe, const TextureInfo& textureInfo, const fVector2& uv, const fVector4& defaultValue)
+{
+	if (!(textureInfo.texture)) return defaultValue;
+	fVector3 uvTransform = textureInfo.uvTransform * fVector3(uv, 1);
+	return textureInfo.texture->sample(uvTransform.xy());
+}
+
+
+DV_CORE_END_NAMESPACE

source/dv_config.h.in

@@ -30,12 +30,14 @@
 #include <memory>
 #include <string>
 #include <vector>
+#include <array>
 #include <list>
 #include <set>
 #include <map>
 #include <unordered_map>
 #include <functional>
 #include <algorithm>
+#include <variant>
 
 #ifdef DV_SYS_WINDOWS
 	#define snprintf _snprintf 

source/shaders/CMakeLists.txt

@@ -0,0 +1,4 @@
+#################
+# sub dictionary
+#################
+add_subdirectory(standard)

source/shaders/standard/CMakeLists.txt

@@ -0,0 +1,36 @@
+add_library(dv_standard_shaders SHARED
+	dll_main.cpp
+	vs_standard.h
+	vs_standard.cpp
+	fs_debug_solid_color.h
+	fs_debug_solid_color.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)
+
+target_include_directories(dv_standard_shaders
+PRIVATE
+	${DV_AUTO_INCLUDE_PATH}
+	${DV_CORE_INCLUDE_PATH}
+)
+
+target_link_libraries(dv_standard_shaders
+	dv_core
+)
+
+#################
+# copy runtime dll(for debug)
+#################
+add_custom_command(
+	TARGET dv_standard_shaders POST_BUILD
+	COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_FILE:dv_standard_shaders> ${CMAKE_BINARY_DIR}/source/console/$<$<CONFIG:Debug>:Debug>$<$<CONFIG:Release>:Release>/)

source/shaders/standard/dll_main.cpp

@@ -0,0 +1,88 @@
+#include "dv_config.h"
+#include "shader/dvc_shader_interface.h"
+
+#include "vs_standard.h"
+#include "fs_debug_solid_color.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
+{
+public:
+	virtual davinci::VertexShaderInterface* getVertexShader(const char* szName) override
+	{
+		auto it = m_vertexShaderMap.find(szName);
+		if (it != m_vertexShaderMap.end()) return it->second;
+		return nullptr;
+	}
+
+	virtual davinci::FragementShaderInterface* getFragementShader(const char* szName) override
+	{
+		auto it = m_fragementShaderMap.find(szName);
+		if (it != m_fragementShaderMap.end()) return it->second;
+		return nullptr;
+	}
+
+public:
+	StandardShaderInterface()
+	{
+		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_ShowTexture());
+		registerFragementShader(new DebugFragementShader_TextureCoordinates());
+		registerFragementShader(new DebugFragementShader_GeometryNormal());
+		registerFragementShader(new ClassicFragementShader_Phong());
+		registerFragementShader(new PbrFragementShader_GLTF());
+	}
+
+	~StandardShaderInterface()
+	{
+		for (auto it = m_vertexShaderMap.begin(); it != m_vertexShaderMap.end(); ++it)
+		{
+			delete it->second;
+		}
+		m_vertexShaderMap.clear();
+
+		for (auto it = m_fragementShaderMap.begin(); it != m_fragementShaderMap.end(); ++it)
+		{
+			delete it->second;
+		}
+		m_fragementShaderMap.clear();
+	}
+
+private:
+	void registerVertexShader(davinci::VertexShaderInterface* vertexShader)
+	{
+		m_vertexShaderMap.insert(std::make_pair(vertexShader->getName(), vertexShader));
+	}
+	void registerFragementShader(davinci::FragementShaderInterface* fragementShader)
+	{
+		m_fragementShaderMap.insert(std::make_pair(fragementShader->getName(), fragementShader));
+	}
+
+private:
+	std::map<std::string, davinci::VertexShaderInterface*> m_vertexShaderMap;
+	std::map<std::string, davinci::FragementShaderInterface*> m_fragementShaderMap;
+};
+
+extern "C"
+{
+
+__declspec(dllexport) davinci::ShaderFileInterface* ShaderFileInterface()
+{
+	static StandardShaderInterface theInterface;
+	return &theInterface;
+}
+
+}

source/shaders/standard/fs_classic_phong.cpp

@@ -0,0 +1,106 @@
+#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";
+}
+
+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();
+
+	if(!(material->getParam("u_materialColor", m_materialColor)))
+	{
+		m_materialColor = davinci::fVector4::WHITE;
+	}
+	if(!(material->getParam("u_specularShininess", m_specularShininess)))
+	{
+		m_specularShininess = 64.0f;
+	}
+	if (!(material->getParam("u_specularStrength", m_specularStrength)))
+	{
+		m_specularStrength = 5.0f;
+	}
+
+	if (const davinci::fVector3* attribute = (davinci::fVector3*)(uniformBuffer.getAttribute("ambient_light:color")))
+	{
+		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 float32_t* pixelData, davinci::fVector4& color)
+{
+	fVector3 v_worldpos = *((const fVector3*)(pixelData + m_vWorldPosOffset));
+	fVector3 v_normal = *((const fVector3*)(pixelData + m_vNormalOffset));
+
+	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

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "shader/dvc_shader_interface.h"
+
+class ClassicFragementShader_Phong : public davinci::FragementShaderInterface
+{
+public:
+	virtual const char* getName(void) const;
+
+	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::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 m_light0Color;
+	davinci::fVector3 m_cameraPosition;
+
+	size_t m_vWorldPosOffset;
+	size_t m_vNormalOffset;
+};

source/shaders/standard/fs_debug_geometry_normal.cpp

@@ -0,0 +1,43 @@
+#include "fs_debug_geometry_normal.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* DebugFragementShader_GeometryNormal::getName(void) const
+{
+	return "debug:geometry_normal";
+}
+
+bool DebugFragementShader_GeometryNormal::begin(const RenderPipe* pipe, MaterialConstPtr material, const VertexDesc& veretexDesc)
+{
+	m_pipe = pipe;
+
+	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 float32_t* pixelData, fVector4& color)
+{
+	const UniformBuffer& uniformBuffer = m_pipe->getUniformBuffer();
+
+	fVector3 v_normal = *((const fVector3*)(pixelData + m_vNormalOffset));
+
+	fVector3 normalColor = v_normal;
+	normalColor.normalise();
+
+	normalColor = normalColor * 0.5f + 0.5f;
+	color = fVector4(normalColor, 1);
+}
+
+void DebugFragementShader_GeometryNormal::end()
+{
+}

source/shaders/standard/fs_debug_geometry_normal.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "shader/dvc_shader_interface.h"
+
+class DebugFragementShader_GeometryNormal : public davinci::FragementShaderInterface
+{
+public:
+	virtual const char* getName(void) const;
+
+	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;
+	size_t m_vNormalOffset;
+};

source/shaders/standard/fs_debug_show_texture.cpp

@@ -0,0 +1,44 @@
+#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"
+
+using namespace davinci;
+
+const char* DebugFragementShader_ShowTexture::getName(void) const
+{
+	return "debug:show_texture";
+}
+
+bool DebugFragementShader_ShowTexture::begin(const RenderPipe* pipe, MaterialConstPtr material, const VertexDesc& veretexDesc)
+{
+	m_pipe = pipe;
+
+	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 float32_t* pixelData, fVector4& color)
+{
+	const fVector2* v_TextureCoordinate = (const fVector2*)(pixelData + m_vTextureCoordinateOffset);
+
+	fVector4 textureColor = shader::texture2D(*m_pipe, m_textureInfo, (*v_TextureCoordinate), fVector4::WHITE);
+
+	color = textureColor;
+}
+void DebugFragementShader_ShowTexture::end()
+{
+	m_textureInfo.texture.reset();
+}

source/shaders/standard/fs_debug_show_texture.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "shader/dvc_shader_interface.h"
+#include "asset/dvc_material.h"
+
+class DebugFragementShader_ShowTexture : public davinci::FragementShaderInterface
+{
+public:
+	virtual const char* getName(void) const;
+
+	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::TextureInfo m_textureInfo;
+	size_t m_vTextureCoordinateOffset;
+};

source/shaders/standard/fs_debug_solid_color.cpp

@@ -0,0 +1,27 @@
+#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";
+}
+
+bool DebugFragementShader_SolidColor::begin(const RenderPipe* pipe, MaterialConstPtr material, const VertexDesc& veretexDesc)
+{
+	if (!(material->getParam("u_solidColor", m_solidColor)))
+	{
+		m_solidColor = davinci::fVector4::WHITE; 
+	}
+	return true;
+}
+
+void DebugFragementShader_SolidColor::process(const float32_t* pixelData, fVector4& color)
+{
+	color = m_solidColor;
+}
+
+void DebugFragementShader_SolidColor::end()
+{
+}

source/shaders/standard/fs_debug_solid_color.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "shader/dvc_shader_interface.h"
+
+class DebugFragementShader_SolidColor : public davinci::FragementShaderInterface
+{
+public:
+	virtual const char* getName(void) const;
+
+	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

@@ -0,0 +1,46 @@
+#include "fs_debug_texture_coordinates.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* DebugFragementShader_TextureCoordinates::getName(void) const
+{
+	return "debug:texture_coordinates";
+}
+
+bool DebugFragementShader_TextureCoordinates::begin(const RenderPipe* pipe, MaterialConstPtr material, const VertexDesc& veretexDesc)
+{
+	m_pipe = pipe;
+
+	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 float32_t* pixelData, fVector4& color)
+{
+	const fVector2* v_uv = (const fVector2*)(pixelData + m_vTextureCoordinateOffset);
+
+	fVector2 uv = *v_uv;
+	float uv_x = uv.x - std::floor(uv.x);
+	float uv_y = uv.y - std::floor(uv.y);
+
+	color = fVector4(uv_x, uv_y, 0, 1);
+}
+
+void DebugFragementShader_TextureCoordinates::end()
+{
+}

source/shaders/standard/fs_debug_texture_coordinates.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "shader/dvc_shader_interface.h"
+
+class DebugFragementShader_TextureCoordinates : public davinci::FragementShaderInterface
+{
+public:
+	virtual const char* getName(void) const;
+
+	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;
+
+	int32_t m_texCoord=0;
+	size_t m_vTextureCoordinateOffset;
+};

source/shaders/standard/fs_pbr_gltf.cpp

@@ -0,0 +1,26 @@
+#include "fs_pbr_gltf.h"
+#include "pipe/dvc_render_pipe.h"
+
+using namespace davinci;
+
+const char* PbrFragementShader_GLTF::getName(void) const
+{
+	return "pbr:gltf";
+}
+
+bool PbrFragementShader_GLTF::begin(const RenderPipe* pipe, MaterialConstPtr material, const VertexDesc& veretexDesc)
+{
+	m_pipe = pipe;
+	const UniformBuffer& uniformBuffer = m_pipe->getUniformBuffer();
+	return true;
+}
+
+void PbrFragementShader_GLTF::process(const float32_t* pixelData, fVector4& color)
+{
+	color = fVector4::BLUE;
+}
+
+void PbrFragementShader_GLTF::end()
+{
+}
+

source/shaders/standard/fs_pbr_gltf.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "shader/dvc_shader_interface.h"
+
+class PbrFragementShader_GLTF : public davinci::FragementShaderInterface
+{
+public:
+	virtual const char* getName(void) const;
+
+	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;
+
+};

source/shaders/standard/vs_standard.cpp

@@ -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.getElementByType(davinci::VET_POSITION_NDC)->offset, &vertexNDCPos, sizeof(davinci::fVector3));
+	}
+
+	//output world position
+	if (m_withWorldPos)
+	{
+		memcpy((char*)outputVertex + m_outputVertexDesc.getElementByType(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.getElementByType(davinci::VET_NORMAL)->offset, &v_normal, sizeof(davinci::fVector3));
+	}
+
+	//output uv0
+	if (m_withTexCoord0)	
+	{
+		memcpy((char*)outputVertex + m_outputVertexDesc.getElementByType(davinci::VET_TEXCOORD_0)->offset, &a_uv, sizeof(float32_t) * 2);
+	}
+}
+
+void StandardVertexShader::end()
+{
+
+}

source/shaders/standard/vs_standard.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "shader/dvc_shader_interface.h"
+
+
+class StandardVertexShader : public davinci::VertexShaderInterface
+{
+public:
+	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;
+
+public:
+	StandardVertexShader(bool withWorldPos, bool withNormal, bool withTexCoord0);
+	virtual ~StandardVertexShader();
+};

source/utils/CMakeLists.txt

@@ -30,6 +30,32 @@ set(DV_UTILS_SCENE_SOURCE_FILES
 )
 source_group("source/scene" FILES ${DV_UTILS_SCENE_SOURCE_FILES})
 
+#################
+# camera
+#################
+set(DV_UTILS_CAMERA_INCLUDE_FILES
+	include/camera/dvu_default_camera.h
+)
+source_group("include/camera" FILES ${DV_UTILS_CAMERA_INCLUDE_FILES})
+
+set(DV_UTILS_CAMERA_SOURCE_FILES
+	source/camera/dvu_default_camera.cpp
+)
+source_group("source/camera" FILES ${DV_UTILS_CAMERA_SOURCE_FILES})
+
+#################
+# standard asserts
+#################
+set(DV_UTILS_STANDARD_INCLUDE_FILES
+	include/standard/dvu_standard_material.h
+)
+source_group("include/standard" FILES ${DV_UTILS_STANDARD_INCLUDE_FILES})
+
+set(DV_UTILS_STANDARD_SOURCE_FILES
+	source/standard/dvu_standard_material.cpp
+)
+source_group("source/standard" FILES ${DV_UTILS_STANDARD_SOURCE_FILES})
+
 include_directories(
 	${DV_AUTO_INCLUDE_PATH}
 	${DV_CORE_INCLUDE_PATH}
@@ -43,6 +69,10 @@ add_library(dv_utils SHARED
 	${DV_UTILS_SCENE_SOURCE_FILES}
 	${DV_UTILS_BUFFER_INCLUDE_FILES}
 	${DV_UTILS_BUFFER_SOURCE_FILES}
+	${DV_UTILS_CAMERA_INCLUDE_FILES}
+	${DV_UTILS_CAMERA_SOURCE_FILES}
+	${DV_UTILS_STANDARD_INCLUDE_FILES}
+	${DV_UTILS_STANDARD_SOURCE_FILES}
 )
 
 target_link_libraries(dv_utils 

source/utils/include/camera/dvu_default_camera.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include "dvu_config.h"
+#include "scene/dvc_scene.h"
+
+DV_UTILS_BEGIN_NAMESPACE
+
+bool DV_UTILS_API create_default_camera(davinci::Scene& scene);
+
+DV_UTILS_END_NAMESPACE

source/utils/include/scene/dvu_load_gltf.h

@@ -1,12 +1,13 @@
 #pragma once
 
 #include "dvu_config.h"
+#include "device/dvc_device.h"
 #include "scene/dvc_scene.h"
 
 DV_UTILS_BEGIN_NAMESPACE
 
-bool DV_UTILS_API load_scene_from_gltf(const char* szSceneFiles, davinci::Scene& scene);
+bool DV_UTILS_API load_scene_from_gltf(const char* szSceneFiles, davinci::Device& device, davinci::Scene& scene);
 
-bool DV_UTILS_API export_mesh_to_obj(const davinci::Scene& scene);
+bool DV_UTILS_API export_mesh_to_obj(const davinci::Device& device, const davinci::Scene& scene);
 
 DV_UTILS_END_NAMESPACE

source/utils/include/standard/dvu_standard_material.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include "dvu_config.h"
+#include "dvc_config.h"
+#include "dvc_pre_declare.h"
+
+DV_UTILS_BEGIN_NAMESPACE
+
+davinci::MaterialPtr DV_UTILS_API create_standard_material(davinci::Device* device, const char* name);
+
+DV_UTILS_END_NAMESPACE

source/utils/source/buffer/dvu_dump_buffer.cpp

@@ -17,8 +17,10 @@ bool dump_pixel_buffer(const char* filename, int32_t width, int32_t height,
 	case davinci::PF_UINT8_RGBA:
 		color_type = PNG_COLOR_TYPE_RGB_ALPHA;  break;
 	case davinci::PF_FLOAT32_RGB:
+	case davinci::PF_UINT8_RGB:
 		color_type = PNG_COLOR_TYPE_RGB; break;
-	case davinci::PF_FLOAT32_R:
+	case davinci::PF_FLOAT32_ALPHA:
+	case davinci::PF_UINT8_ALPHA:
 		color_type = PNG_COLOR_TYPE_GRAY; break;
 	default:
 		//not support yet!
@@ -54,9 +56,14 @@ bool dump_pixel_buffer(const char* filename, int32_t width, int32_t height,
 	png_write_info(png_ptr, info_ptr);
 
 	//integer pixelformat
-	if (davinci::PF_UINT8_RGBA == pixelFormat) {
-		for (int32_t y = 0; y < height; y++) {
-			const uint32_t* p = (const uint32_t*)pixelData + (height - 1 - y) * width;
+	if (davinci::PF_UINT8_RGBA == pixelFormat || 
+		davinci::PF_UINT8_RGB == pixelFormat || 
+		davinci::PF_UINT8_ALPHA == pixelFormat) 
+	{
+		size_t pixelSize = davinci::MathUtil::PixelSize(pixelFormat);
+		for (int32_t y = 0; y < height; y++) 
+		{
+			const uint8_t* p = (const uint8_t*)pixelData + (height - 1 - y) * width * pixelSize;
 			png_write_rows(png_ptr, (png_bytepp)&p, 1);
 		}
 	}
@@ -165,7 +172,7 @@ bool dump_render_target(const char* baseFilename, const davinci::RenderTarget& r
 	_snprintf(szFileName, 256, "%s_depth.png", baseFilename);
 	dump_pixel_buffer(szFileName, 
 		renderTarget.getWidth(), renderTarget.getHeight(), 
-		&(depth_data[0]), davinci::PF_FLOAT32_R
+		&(depth_data[0]), davinci::PF_FLOAT32_ALPHA
 	);
 
 	return true;

source/utils/source/camera/dvu_default_camera.cpp

@@ -0,0 +1,55 @@
+#include "camera/dvu_default_camera.h"
+#include "scene/dvc_scene_node.h"
+#include "scene/component/dvc_camera_component.h"
+
+#include "math/dvc_matrix4.h"
+#include "math/dvc_vector3.h"
+#include "math/dvc_vector4.h"
+
+DV_UTILS_BEGIN_NAMESPACE
+
+bool create_default_camera(davinci::Scene& scene)
+{
+	//------default camera define
+	static const davinci::fVector4 kDefaultCameraRotation(
+		-0.20997299253940582f, 0.3857799470424652f, 0.09062844514846802f, 0.8937962055206299f);
+	static const davinci::fVector3 kDefaultCameraTranslation(
+		7.358891487121582f, 4.958309173583984f, 6.925790786743164f);
+	static const float kDefaultCameraAspectRatio = 1.7777777777777777f;
+	static const float kDefaultCamaraFov = 0.39959652046304894f;
+	static const float kDefaultCameraNearClip = 0.1f;
+	static const float kDefaultCameraFarClip = 100.f;
+	//-----default camera define
+
+
+	//create camera scene node
+	davinci::SceneNodePtr sceneNode = scene.newSceneNode("__DEFAULT_CAMERA__");
+
+	//transform
+	davinci::fMatrix4 transform = davinci::fMatrix4::IDENTITY;
+
+	//rotation
+	transform = davinci::fMatrix4::makeRotate(kDefaultCameraRotation) * transform;
+
+	//translation
+	transform = davinci::fMatrix4::makeTrans(kDefaultCameraTranslation) * transform;
+	sceneNode->setTransform(transform);
+
+	//camera define
+	davinci::CameraComponent::CameraDefine cameraDefine;
+	cameraDefine.aspect = kDefaultCameraAspectRatio;
+	cameraDefine.fov = kDefaultCamaraFov;
+	cameraDefine.nearClip = kDefaultCameraNearClip;
+	cameraDefine.farClip = kDefaultCameraFarClip;
+
+	//camera component
+	davinci::CameraComponentPtr cameraComponent = std::make_shared<davinci::CameraComponent>(sceneNode);
+	cameraComponent->setCameraDefine(cameraDefine);
+	sceneNode->addComponent(std::dynamic_pointer_cast<davinci::SceneComponent>(cameraComponent));
+
+	//add to scene root node
+	scene.getRootSceneNode()->addChild(sceneNode);
+	return true;
+}
+
+DV_UTILS_END_NAMESPACE

source/utils/source/scene/dvu_load_gltf.cpp

@@ -1,14 +1,27 @@
+//
+// https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html
+//
 #include "scene/dvu_load_gltf.h"
+#include "camera/dvu_default_camera.h"
 #include "scene/dvc_scene.h"
 #include "scene/dvc_scene_node.h"
 #include "scene/component/dvc_mesh_component.h"
 #include "scene/component/dvc_camera_component.h"
 #include "scene/component/dvc_light_component.h"
+#include "device/dvc_device.h"
 #include "device/dvc_buffer_accessor.h"
 #include "asset/dvc_mesh.h"
+#include "asset/dvc_image.h"
+#include "asset/dvc_texture.h"
+#include "asset/dvc_material.h"
+
 #include "math/dvc_vector3.h"
 #include "math/dvc_vector4.h"
 
+#include "buffer/dvu_dump_buffer.h"
+
+#include "standard/dvu_standard_material.h"
+
 #include <tiny_gltf.h>
 
 #include <string>
@@ -90,6 +103,25 @@ davinci::PrimitiveType _getPrimitiveTypeFromGltf(int gltfModelType)
 	}
 }
 
+davinci::PixelFormat _getPixelFormatFromGltf(int32_t gltfComponent, int32_t gltfPixelType)
+{
+	if (gltfPixelType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE)
+	{
+		if (gltfComponent == 1) return davinci::PF_UINT8_ALPHA;
+		else if (gltfComponent == 3) return davinci::PF_UINT8_RGB;
+		else if (gltfComponent == 4) return davinci::PF_UINT8_RGBA;
+		else return davinci::PF_UNKNOWN;
+	}
+	else if (gltfPixelType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT)
+	{
+		if (gltfComponent == 1) return davinci::PF_UINT16_ALPHA;
+		else if (gltfComponent == 3) return davinci::PF_UINT16_RGB;
+		else if (gltfComponent == 4) return davinci::PF_UINT16_RGBA;
+		else return davinci::PF_UNKNOWN;
+	}
+	else return davinci::PF_UNKNOWN;
+}
+
 //from "POSITION/NORMAL/..." to VET_***
 davinci::VertexElementType _getElementTypeFromGltf(const std::string& gltfElementType)
 {
@@ -106,7 +138,7 @@ davinci::VertexElementType _getElementTypeFromGltf(const std::string& gltfElemen
 
 	if (gltfElementType == "POSITION")
 	{
-		return davinci::VET_POSITION;
+		return davinci::VET_POSITION_MODEL;
 	}
 	else if(gltfElementType == "NORMAL")
 	{
@@ -128,47 +160,301 @@ davinci::VertexElementType _getElementTypeFromGltf(const std::string& gltfElemen
 	return davinci::VET_UNKNOWN;
 }
 
-bool _loadDeviceBuffer(const tinygltf::Model& gltfModel, davinci::Scene& scene)
+davinci::DeviceBufferAccessorPtr _createFloat32BufferAccessorFromNormalizedIntegerType(
+	davinci::Device& device, 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();
+	size_t bufferSize = elementCounts * davinci::MathUtil::ComponentSize(davinci::ComponentType::CT_Float32) * davinci::MathUtil::DataTypeSize(dataType);
+	davinci::DeviceBufferPtr newBuffer = device.newDeviceBuffer(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 = device.newDeviceBufferView(newBuffer, 0, bufferSize, 0);
+	return device.newDeviceBufferAccessor(newBufferViewer, 0, elementCounts, davinci::ComponentType::CT_Float32, dataType);
+}
+
+davinci::DeviceBufferAccessorPtr _createSupportedPrimitiveAttributeBufferAccessor(
+	davinci::Device& device, 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_MODEL:
+	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(device, 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(device, 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(device, 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(tinygltf::Model& gltfModel, davinci::Device& device, davinci::Scene& scene)
 {
 	for (size_t i = 0; i < gltfModel.buffers.size(); i++) 
 	{
-		const tinygltf::Buffer& gltfBuffer = gltfModel.buffers[i];
+		tinygltf::Buffer& gltfBuffer = gltfModel.buffers[i];
 
-		davinci::DeviceBufferPtr deviceBufferPtr = scene.newDeviceBuffer();
-		deviceBufferPtr->init(gltfBuffer.data.size());
+		davinci::DeviceBufferPtr deviceBufferPtr = device.newDeviceBuffer(gltfBuffer.data.size());
 
 		//fill data
 		memcpy(deviceBufferPtr->ptr(0), gltfBuffer.data.data(), gltfBuffer.data.size());
+
+		//set davinci id
+		gltfBuffer.extensions.insert(std::make_pair("DAVINCI_ID", tinygltf::Value((int32_t)deviceBufferPtr->getID())));
 	}
 	return true;
 }
 
-bool _loadBufferView(const tinygltf::Model& gltfModel, davinci::Scene& scene)
+bool _loadBufferView(tinygltf::Model& gltfModel, davinci::Device& device, davinci::Scene& scene)
 {
 	for (size_t i = 0; i < gltfModel.bufferViews.size(); i++) 
 	{
-		const tinygltf::BufferView& gltfBufferView = gltfModel.bufferViews[i];
-		int32_t bufferIndex = gltfBufferView.buffer;
-		davinci::DeviceBufferConstPtr deviceBufferPtr = scene.getDeviceBuffer(bufferIndex);
+		tinygltf::BufferView& gltfBufferView = gltfModel.bufferViews[i];
+		tinygltf::Buffer& gltfBuffer = gltfModel.buffers[gltfBufferView.buffer];
+		int32_t bufferID = gltfBuffer.extensions["DAVINCI_ID"].GetNumberAsInt();
+
+		davinci::DeviceBufferConstPtr deviceBufferPtr = device.getDeviceBuffer(bufferID);
 		if (deviceBufferPtr == nullptr)
 		{
 			return false;
 		}
-		davinci::DeviceBufferViewPtr bufferViewPtr = scene.newDeviceBufferView(
+		davinci::DeviceBufferViewPtr bufferViewPtr = device.newDeviceBufferView(
 			deviceBufferPtr, gltfBufferView.byteOffset, gltfBufferView.byteLength, gltfBufferView.byteStride);
+		gltfBufferView.extensions.insert(std::make_pair("DAVINCI_ID", tinygltf::Value((int32_t)bufferViewPtr->getID())));
 	}
 
 	return true;
 }
 
-bool _loadBufferAccessor(const tinygltf::Model& gltfModel, davinci::Scene& scene)
+bool _loadBufferAccessor(tinygltf::Model& gltfModel, davinci::Device& device, davinci::Scene& scene)
 {
 	for (size_t i = 0; i < gltfModel.accessors.size(); i++) 
 	{
-		const tinygltf::Accessor& gltfAccessor = gltfModel.accessors[i];
+		tinygltf::Accessor& gltfAccessor = gltfModel.accessors[i];
+		tinygltf::BufferView& gltfBufferView = gltfModel.bufferViews[gltfAccessor.bufferView];
+		int32_t bufferViewID = gltfBufferView.extensions["DAVINCI_ID"].GetNumberAsInt();
 
-		int32_t bufferViewIndex = gltfAccessor.bufferView;
-		davinci::DeviceBufferViewPtr deviceBufferView = scene.getDeviceBufferView(bufferViewIndex);
+		davinci::DeviceBufferViewPtr deviceBufferView = device.getDeviceBufferView(bufferViewID);
 		if (deviceBufferView==nullptr)
 		{
 			return false;
@@ -186,20 +472,22 @@ bool _loadBufferAccessor(const tinygltf::Model& gltfModel, davinci::Scene& scene
 			return false;
 		}
 
-		davinci::DeviceBufferAccessorPtr bufferAccessor = scene.newDeviceBufferAccessor(
+		davinci::DeviceBufferAccessorPtr bufferAccessor = device.newDeviceBufferAccessor(
 			deviceBufferView, gltfAccessor.byteOffset, gltfAccessor.count, componentType, dataType);
+		gltfAccessor.extensions.insert(std::make_pair("DAVINCI_ID", tinygltf::Value((int32_t)bufferAccessor->getID())));
 	}
 
 	return true;
 }
 
-bool _loadMesh(const tinygltf::Model& gltfModel, davinci::Scene& scene)
+bool _loadMesh(tinygltf::Model& gltfModel, davinci::Device& device, davinci::Scene& scene)
 {
 	for (size_t i=0; i<gltfModel.meshes.size(); i++) 
 	{
-		const tinygltf::Mesh& gltfMesh = gltfModel.meshes[i];
+		tinygltf::Mesh& gltfMesh = gltfModel.meshes[i];
 
-		davinci::MeshPtr mesh = std::make_shared<davinci::Mesh>(gltfMesh.name);
+		davinci::MeshPtr mesh = device.newMeshAsset(gltfMesh.name);
+		gltfMesh.extensions.insert(std::make_pair("DAVINCI_ID", tinygltf::Value((int32_t)mesh->getID())));
 
 		for (size_t j=0; j<gltfMesh.primitives.size(); j++)
 		{
@@ -208,31 +496,226 @@ bool _loadMesh(const tinygltf::Model& gltfModel, davinci::Scene& scene)
 			davinci::Mesh::PrimitivePtr primitive = mesh->newPrimitive();
 			primitive->type = _getPrimitiveTypeFromGltf(gltfPrimitive.mode);
 
+			//apply attributes
 			std::map<std::string, int>::const_iterator it(gltfPrimitive.attributes.begin());
 			std::map<std::string, int>::const_iterator itEnd(gltfPrimitive.attributes.end());
 			for (; it != itEnd; it++) 
 			{
 				davinci::VertexElementType vetype = _getElementTypeFromGltf(it->first);
+				int32_t gltfAccessIndex = it->second;
+				if (gltfAccessIndex < 0 || gltfAccessIndex >= gltfModel.accessors.size())
+				{
+					return false;
+				}
+				tinygltf::Accessor& gltfAccessor = gltfModel.accessors[gltfAccessIndex];
+				int32_t accessorID = gltfAccessor.extensions["DAVINCI_ID"].GetNumberAsInt();
 				
-				int32_t gltfAccessor = it->second;
-				davinci::DeviceBufferAccessorPtr deviceBufferAccessor = scene.getDeviceBufferAccessor(gltfAccessor);
+				davinci::DeviceBufferAccessorPtr deviceBufferAccessor = device.getDeviceBufferAccessor(accessorID);
 				if (deviceBufferAccessor ==nullptr)
 				{
 					return false;
 				}
 
+				//convert to supported primitive buffer(float32)
+				deviceBufferAccessor = _createSupportedPrimitiveAttributeBufferAccessor(device, scene, vetype, deviceBufferAccessor);
+				if (deviceBufferAccessor == nullptr)
+				{
+					return false;
+				}
+
 				primitive->attributes.insert(std::make_pair(vetype, deviceBufferAccessor));
 			}
 
-			davinci::DeviceBufferAccessorPtr indicesBufferAccessor = scene.getDeviceBufferAccessor(gltfPrimitive.indices);
+			//apply indices
+			if (gltfPrimitive.indices < 0 || gltfPrimitive.indices >= gltfModel.accessors.size())
+			{
+				return false;
+			}
+			tinygltf::Accessor& gltfIndicesAccessor = gltfModel.accessors[gltfPrimitive.indices];
+			int32_t accessorID = gltfIndicesAccessor.extensions["DAVINCI_ID"].GetNumberAsInt();
+			davinci::DeviceBufferAccessorPtr indicesBufferAccessor = device.getDeviceBufferAccessor(accessorID);
 			if (indicesBufferAccessor == nullptr)
 			{
 				return false;
 			}
+			bool isSupportedType = _isSupportedIndicesType(indicesBufferAccessor);
+			if (!isSupportedType)
+			{
+				return false;
+			}
+
 			primitive->indices = indicesBufferAccessor;
+
+			//apply material
+			if (gltfPrimitive.material >= 0 && gltfPrimitive.material < gltfModel.materials.size())
+			{
+				tinygltf::Material& gltfMaterial = gltfModel.materials[gltfPrimitive.material];
+				int32_t materialID = gltfMaterial.extensions["DAVINCI_ID"].GetNumberAsInt();
+				davinci::MaterialPtr materialPtr = device.getMaterial(materialID);
+				if (materialPtr == nullptr)
+				{
+					return false;
+				}
+				primitive->material = materialPtr;
+			}
+			else
+			{
+				davinci::MaterialPtr materialPtr = create_standard_material(&device, "classic:phong");
+				materialPtr->setParam("u_materialColor", davinci::fVector4::WHITE);
+				materialPtr->setParam("u_specularShininess", 32.f);
+				materialPtr->setupMaterial();
+
+				primitive->material = materialPtr;
+			}
+		}
+	}
+	return true;
+}
+
+bool _loadTexture(tinygltf::Model& gltfModel, davinci::Device& device, davinci::Scene& scene)
+{
+	for (size_t i = 0; i < gltfModel.images.size(); i++)
+	{
+		tinygltf::Image& gltfImage = gltfModel.images[i];
+
+		davinci::ImagePtr imagePtr = device.newImageAsset();
+		imagePtr->initWithPixelData(device, gltfImage.width, gltfImage.height,
+			_getPixelFormatFromGltf(gltfImage.component, gltfImage.pixel_type), gltfImage.image.data(), gltfImage.image.size());
+
+		gltfImage.extensions.insert(std::make_pair("DAVINCI_ID", tinygltf::Value((int32_t)imagePtr->getID())));
+	}
+
+	for (size_t i = 0; i < gltfModel.textures.size(); i++)
+	{
+		tinygltf::Texture& gltfTexture = gltfModel.textures[i];
+		if (gltfTexture.source < 0 || gltfTexture.source >= (int)gltfModel.images.size())
+		{
+			continue;
+		}
+		tinygltf::Image& gltfImage = gltfModel.images[gltfTexture.source];
+		if (gltfImage.width <= 0 || gltfImage.height <= 0 || gltfImage.component <= 0 || gltfImage.component > 4)
+		{
+			continue;
 		}
 
-		scene.pushNewMeshAsset(mesh);
+		int32_t imageID = gltfImage.extensions["DAVINCI_ID"].GetNumberAsInt();
+		davinci::ImagePtr imagePtr = device.getImage(imageID);
+
+		davinci::TexturePtr texturePtr = device.newTextureAsset();
+		texturePtr->setImage(imagePtr);
+
+		gltfTexture.extensions.insert(std::make_pair("DAVINCI_ID", tinygltf::Value((int32_t)texturePtr->getID())));
+	}
+	return true;
+}
+
+davinci::TexturePtr _getTexturePtr(tinygltf::Model& gltfModel, davinci::Device& device, int gltfTextureIndex)
+{
+	if (gltfTextureIndex < 0 || gltfTextureIndex >= gltfModel.textures.size()) return nullptr;
+	tinygltf::Texture& gltfTexture = gltfModel.textures[gltfTextureIndex];
+
+	int32_t textureID = gltfTexture.extensions["DAVINCI_ID"].GetNumberAsInt();
+	return device.getTexture(textureID);
+}
+
+davinci::fVector4 _getVector4FromDoubleArray(const std::vector<double>& doubleArray)
+{
+	if (doubleArray.size() != 4) return davinci::fVector4::ONE;
+	return davinci::fVector4((float32_t)doubleArray[0], (float32_t)doubleArray[1], (float32_t)doubleArray[2], (float32_t)doubleArray[3]);
+}
+
+davinci::fMatrix3 _getTextureTransform(const tinygltf::ExtensionMap& gltfTextureInfoExternsionMap)
+{
+	davinci::fMatrix3 textureTransform = davinci::fMatrix3::IDENTITY;
+	
+	auto transformExternsions = gltfTextureInfoExternsionMap.find("KHR_texture_transform");
+	if (transformExternsions != gltfTextureInfoExternsionMap.end())
+	{
+		davinci::fVector2 scale = davinci::fVector2::ONE;
+		const tinygltf::Value& scaleArray = transformExternsions->second.Get("scale");
+		if (scaleArray.IsArray() && scaleArray.ArrayLen()>=2 && 
+			scaleArray.Get(0).IsNumber() && scaleArray.Get(1).IsNumber())
+		{
+			scale = davinci::fVector2(
+				(float32_t)(scaleArray.Get(0).GetNumberAsDouble()),
+				(float32_t)(scaleArray.Get(1).GetNumberAsDouble())
+			);
+		}
+
+		float32_t rotate = 0.f;
+		const tinygltf::Value& rotationValue = transformExternsions->second.Get("rotation");
+		if (rotationValue.IsNumber())
+		{
+			rotate = (float32_t)rotationValue.GetNumberAsDouble();
+		}
+
+		davinci::fVector2 offset = davinci::fVector2::ZERO;
+		const tinygltf::Value& offsetArray = transformExternsions->second.Get("offset");
+		if (offsetArray.IsArray() && offsetArray.ArrayLen()>=2 && 
+			offsetArray.Get(0).IsNumber() && offsetArray.Get(1).IsNumber())
+		{
+			offset = davinci::fVector2(
+				(float32_t)(offsetArray.Get(0).GetNumberAsDouble()),
+				(float32_t)(offsetArray.Get(1).GetNumberAsDouble())
+			);
+		}
+
+		textureTransform = davinci::fMatrix3::makeTrans(offset) * 
+			davinci::fMatrix3::makeRotate(rotate) * davinci::fMatrix3::makeScale(scale);
+	}
+
+	return textureTransform;
+}
+
+bool _loadMaterial(tinygltf::Model& gltfModel, davinci::Device& device, davinci::Scene& scene)
+{
+	for (size_t i = 0; i < gltfModel.materials.size(); i++)
+	{
+		tinygltf::Material& gltfMaterial = gltfModel.materials[i];
+
+		//create new material
+		davinci::MaterialPtr materialPtr = create_standard_material(&device, "pbr:gltf");
+
+		//apply matellic roughness info
+		const tinygltf::PbrMetallicRoughness& gltfPBRMetllicRoughness = gltfMaterial.pbrMetallicRoughness;
+
+		//base color texture
+		const tinygltf::TextureInfo& gltfBaseColorTextureInfo = gltfPBRMetllicRoughness.baseColorTexture;
+		davinci::TextureInfo baseColorTextureInfo = davinci::TextureInfo{
+			_getTexturePtr(gltfModel, device, gltfBaseColorTextureInfo.index),
+			gltfBaseColorTextureInfo.texCoord,
+			_getTextureTransform(gltfBaseColorTextureInfo.extensions)
+		};
+		materialPtr->setParam("u_baseColorTextureInfo", baseColorTextureInfo);
+
+		//matallic & roughness texture
+		const tinygltf::TextureInfo& gltfMetalicRoughnessTextureInfo = gltfPBRMetllicRoughness.metallicRoughnessTexture;
+		davinci::TextureInfo metalicRoughnessTextureInfo = davinci::TextureInfo{
+			_getTexturePtr(gltfModel, device, gltfMetalicRoughnessTextureInfo.index),
+			gltfMetalicRoughnessTextureInfo.texCoord,
+			_getTextureTransform(gltfMetalicRoughnessTextureInfo.extensions),
+		};
+		materialPtr->setParam("u_metalicRoughnessTextureInfo", baseColorTextureInfo);
+		materialPtr->setParam("u_metalicFactor", static_cast<float32_t>(gltfPBRMetllicRoughness.metallicFactor));
+		materialPtr->setParam("u_roughnessFactor", static_cast<float32_t>(gltfPBRMetllicRoughness.roughnessFactor));
+
+		//normal texture
+		const tinygltf::NormalTextureInfo& gltfNormalTextureInfo = gltfMaterial.normalTexture;
+		davinci::TextureInfo normalTextureInfo = davinci::TextureInfo{
+			_getTexturePtr(gltfModel, device, gltfNormalTextureInfo.index),
+			gltfNormalTextureInfo.texCoord,
+			_getTextureTransform(gltfNormalTextureInfo.extensions),
+		};
+		materialPtr->setParam("u_normalTextureInfo", normalTextureInfo);
+		materialPtr->setParam("u_normalTextureScale", static_cast<float32_t>(gltfMaterial.normalTexture.scale));
+
+		//load shader
+		if (!(materialPtr->setupMaterial()))
+		{
+			return false;
+		}
+		
+		gltfMaterial.extensions.insert(std::make_pair("DAVINCI_ID", tinygltf::Value((int32_t)materialPtr->getID())));
 	}
 	return true;
 }
@@ -294,8 +777,7 @@ bool _loadLightExternsion(const tinygltf::Model& gltfModel, std::vector<davinci:
 	return true;
 }
 
-
-bool _loadSceneNodes(const tinygltf::Model& gltfModel, davinci::Scene& scene, const std::vector<davinci::LightComponent::LightDefine>& lightsArray)
+bool _loadSceneNodes(tinygltf::Model& gltfModel, davinci::Device& device, davinci::Scene& scene, const std::vector<davinci::LightComponent::LightDefine>& lightsArray)
 {
 	std::vector<std::pair<bool, davinci::SceneNodePtr>> sceneNodeArray;
 
@@ -321,12 +803,24 @@ bool _loadSceneNodes(const tinygltf::Model& gltfModel, davinci::Scene& scene, co
 		{
 			transform = davinci::fMatrix4::makeTrans(gltfNode.translation[0], gltfNode.translation[1], gltfNode.translation[2]) * transform;
 		}
+		if(!gltfNode.matrix.empty())
+		{
+			davinci::fMatrix4 matrix(
+				gltfNode.matrix[0], gltfNode.matrix[1], gltfNode.matrix[2], gltfNode.matrix[3],
+				gltfNode.matrix[4], gltfNode.matrix[5], gltfNode.matrix[6], gltfNode.matrix[7],
+				gltfNode.matrix[8], gltfNode.matrix[9], gltfNode.matrix[10], gltfNode.matrix[11],
+				gltfNode.matrix[12], gltfNode.matrix[13], gltfNode.matrix[14], gltfNode.matrix[15]);
+			transform = matrix.transpose() * transform;
+		}
 		sceneNode->setTransform(transform);
 
 		//add mesh component
 		if (gltfNode.mesh != -1)
 		{
-			davinci::MeshConstPtr meshPtr = scene.getMesh(gltfNode.mesh);
+			tinygltf::Mesh& gltfMesh = gltfModel.meshes[gltfNode.mesh];
+			int32_t meshID = gltfMesh.extensions["DAVINCI_ID"].GetNumberAsInt();
+
+			davinci::MeshConstPtr meshPtr = device.getMesh(meshID);
 			if (meshPtr)
 			{
 				davinci::MeshComponentPtr meshComponet = std::make_shared<davinci::MeshComponent>(sceneNode);
@@ -434,7 +928,7 @@ bool _loadSceneNodes(const tinygltf::Model& gltfModel, davinci::Scene& scene, co
 	return true;
 }
 
-bool load_scene_from_gltf(const char* szSceneFiles, davinci::Scene& scene)
+bool load_scene_from_gltf(const char* szSceneFiles, davinci::Device& device, davinci::Scene& scene)
 {
 	std::filesystem::path sceneFilePath = std::filesystem::path(szSceneFiles);
 
@@ -445,7 +939,10 @@ bool load_scene_from_gltf(const char* szSceneFiles, davinci::Scene& scene)
 	}
 
 	tinygltf::Model gltfModel;
+	
 	tinygltf::TinyGLTF gltf_ctx;
+	gltf_ctx.SetPreserveImageChannels(true);
+
 	std::string err;
 	std::string warn;
 	bool ret = false;
@@ -479,25 +976,37 @@ bool load_scene_from_gltf(const char* szSceneFiles, davinci::Scene& scene)
 	//dump to davinci scene
 
 	//load device buffer
-	if (!_loadDeviceBuffer(gltfModel, scene))
+	if (!_loadDeviceBuffer(gltfModel, device, scene))
 	{
 		return false;
 	}
 
 	//load buffer view
-	if (!_loadBufferView(gltfModel, scene))
+	if (!_loadBufferView(gltfModel, device, scene))
 	{
 		return false;
 	}
 
 	//load buffer accessor
-	if (!_loadBufferAccessor(gltfModel, scene))
+	if (!_loadBufferAccessor(gltfModel, device, scene))
+	{
+		return false;
+	}
+
+	//load texture
+	if (!_loadTexture(gltfModel, device, scene))
+	{
+		return false;
+	}
+
+	//load material
+	if (!_loadMaterial(gltfModel, device, scene))
 	{
 		return false;
 	}
 
 	//load mesh
-	if (!_loadMesh(gltfModel, scene))
+	if (!_loadMesh(gltfModel, device, scene))
 	{
 		return false;
 	}
@@ -510,22 +1019,29 @@ bool load_scene_from_gltf(const char* szSceneFiles, davinci::Scene& scene)
 	}
 
 	//load scene nodes
-	if (!_loadSceneNodes(gltfModel, scene, lightDefine))
+	if (!_loadSceneNodes(gltfModel, device, scene, lightDefine))
 	{
 		return false;
 	}
 
+	//create default camera
+	davinci::SceneNodeConstPtr cameraNode = scene.getNodeWithComponent<davinci::CameraComponent>();
+	if (cameraNode.get()==nullptr)
+	{
+		create_default_camera(scene);
+	}
+
 	return true;
 }
 
 
-bool export_mesh_to_obj(const davinci::Scene& scene)
+bool export_mesh_to_obj(const davinci::Device& device, const davinci::Scene& scene)
 {
-
-	int32_t meshCounts = scene.getMeshCounts();
+#if 0
+	int32_t meshCounts = device.getMeshCounts();
 	for (int32_t meshIndex = 0; meshIndex < meshCounts; meshIndex++)
 	{
-		davinci::MeshConstPtr mesh = scene.getMesh(meshIndex);
+		davinci::MeshConstPtr mesh = device.getMesh(meshIndex);
 
 		const std::string& meshName = mesh->getName();
 		if (meshName.empty()) {
@@ -589,30 +1105,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)
 				{
@@ -659,6 +1154,7 @@ bool export_mesh_to_obj(const davinci::Scene& scene)
 
 		fclose(fp);
 	}
+#endif
 	return true;
 }
 

source/utils/source/standard/dvu_standard_material.cpp

@@ -0,0 +1,174 @@
+#include "standard/dvu_standard_material.h"
+#include "device/dvc_device.h"
+#include "asset/dvc_material.h"
+
+DV_UTILS_BEGIN_NAMESPACE
+
+class PbrGltfMaterial : public davinci::Material
+{
+public:
+	PbrGltfMaterial(int32_t id, const char* name) : davinci::Material(id, name)
+	{
+		setVertexShader("dv_standard_shaders.dll", "standard+worldpos+normal+uv0");
+		setFragementShader("dv_standard_shaders.dll", "pbr:gltf");
+
+		registerParam<davinci::TextureInfo>("u_baseColorTextureInfo", {});
+		registerParam<davinci::TextureInfo>("u_metalicRoughnessTextureInfo", {});
+		registerParam<float32_t>("u_metalicFactor", 1.f);
+		registerParam<float32_t>("u_roughnessFactor", 1.f);
+		registerParam<davinci::TextureInfo>("u_normalTextureInfo", {});
+		registerParam<float32_t>("u_normalTextureScale", 1.f);
+	}
+};
+
+class PhongMaterial : public davinci::Material
+{
+public:
+	PhongMaterial(int32_t id, const char* name) : davinci::Material(id, name)
+	{
+		setVertexShader("dv_standard_shaders.dll", "standard+worldpos+normal-uv0");
+		setFragementShader("dv_standard_shaders.dll", "classic:phong");
+
+		registerParam<davinci::fVector4>("u_materialColor", davinci::fVector4::GRAY);
+		registerParam<float32_t>("u_specularShininess", 64.f);
+		registerParam<float32_t>("u_specularStrength", 5.f);
+	}
+	virtual bool pickupParam(const davinci::MaterialConstPtr orginalMaterial) override
+	{
+		return true;
+	}
+};
+
+class SolidColorMaterial : public davinci::Material
+{
+public:
+	SolidColorMaterial(int32_t id, const char* name) : davinci::Material(id, name)
+	{
+		setVertexShader("dv_standard_shaders.dll", "standard-worldpos-normal-uv0");
+		setFragementShader("dv_standard_shaders.dll", "debug:solid_color");
+
+		registerParam<davinci::fVector4>("u_solidColor", davinci::fVector4::WHITE);
+	}
+	virtual bool pickupParam(const davinci::MaterialConstPtr orginalMaterial) override
+	{
+		return true;
+	}
+};
+
+class BaseColorTextureMaterial : public davinci::Material
+{
+public:
+	BaseColorTextureMaterial(int32_t id, const char* name) : davinci::Material(id, name)
+	{
+		setVertexShader("dv_standard_shaders.dll", "standard+worldpos-normal+uv0");
+		setFragementShader("dv_standard_shaders.dll", "debug:show_texture");
+
+		registerParam<davinci::TextureInfo>("u_textureInfo", {});
+	}
+	virtual bool pickupParam(const davinci::MaterialConstPtr orginalMaterial) override
+	{
+		davinci::TextureInfo baseColorTextureInfo;
+		if (!(orginalMaterial->getParam("u_baseColorTextureInfo", baseColorTextureInfo)))
+		{
+			return false;
+		}
+
+		this->setParam("u_textureInfo", baseColorTextureInfo);
+		return true;
+	}
+};
+
+class NormalTextureMaterial : public davinci::Material
+{
+public:
+	NormalTextureMaterial(int32_t id, const char* name) : davinci::Material(id, name)
+	{
+		setVertexShader("dv_standard_shaders.dll", "standard+worldpos-normal+uv0");
+		setFragementShader("dv_standard_shaders.dll", "debug:show_texture");
+
+		registerParam<davinci::TextureInfo>("u_textureInfo", {});
+	}
+	virtual bool pickupParam(const davinci::MaterialConstPtr orginalMaterial) override
+	{
+		davinci::TextureInfo normalTextureInfo;
+		if (!(orginalMaterial->getParam("u_normalTextureInfo", normalTextureInfo)))
+		{
+			return false;
+		}
+
+		this->setParam("u_textureInfo", normalTextureInfo);
+		return true;
+	}
+};
+
+class TextureCoordinates0Material : public davinci::Material
+{
+public:
+	TextureCoordinates0Material(int32_t id, const char* name) : davinci::Material(id, name)
+	{
+		setVertexShader("dv_standard_shaders.dll", "standard+worldpos-normal+uv0");
+		setFragementShader("dv_standard_shaders.dll", "debug:texture_coordinates");
+
+		registerParam<int32_t>("u_texCoord", 0);
+	}
+	virtual bool pickupParam(const davinci::MaterialConstPtr orginalMaterial) override
+	{
+		return true;
+	}
+};
+
+class GeometryNormalMaterial : public davinci::Material
+{
+public:
+	GeometryNormalMaterial(int32_t id, const char* name) : davinci::Material(id, name)
+	{
+		setVertexShader("dv_standard_shaders.dll", "standard+worldpos+normal-uv0");
+		setFragementShader("dv_standard_shaders.dll", "debug:geometry_normal");
+	}
+	virtual bool pickupParam(const davinci::MaterialConstPtr orginalMaterial) override
+	{
+		return true;
+	}
+};
+
+davinci::MaterialPtr create_standard_material(davinci::Device* device, const char* name)
+{
+	if(strcmp(name, "pbr:gltf")==0)
+	{
+		davinci::MaterialPtr materialPtr = device->newMaterialAsset<PbrGltfMaterial>(name);
+		return materialPtr;
+	}
+	else if(strcmp(name, "classic:phong")==0)
+	{
+		davinci::MaterialPtr materialPtr = device->newMaterialAsset<PhongMaterial>(name);
+		return materialPtr;
+	}
+	else if(strcmp(name, "debug:solid_color")==0)
+	{
+		davinci::MaterialPtr materialPtr = device->newMaterialAsset<SolidColorMaterial>(name);
+		return materialPtr;
+	}
+	else if (strcmp(name, "debug:base_color_texture")==0)
+	{
+		davinci::MaterialPtr materialPtr = device->newMaterialAsset<BaseColorTextureMaterial>(name);
+		return materialPtr;
+	}
+	else if (strcmp(name, "debug:normal_texture")==0)
+	{
+		davinci::MaterialPtr materialPtr = device->newMaterialAsset<NormalTextureMaterial>(name);
+		return materialPtr;
+	}
+	else if (strcmp(name, "debug:texture_coordinates_0")==0)
+	{
+		davinci::MaterialPtr materialPtr = device->newMaterialAsset<TextureCoordinates0Material>(name);
+		return materialPtr;
+	}
+	else if (strcmp(name, "debug:geometry_normal")==0)
+	{
+		davinci::MaterialPtr materialPtr = device->newMaterialAsset<GeometryNormalMaterial>(name);
+		return materialPtr;
+	}
+	return nullptr;
+}
+
+DV_UTILS_END_NAMESPACE

test/CMakeLists.txt

@@ -2,5 +2,4 @@ set(GTest_DIR $ENV{LIBRARIES_SDK_ROOT}/gtest/lib/cmake/GTest)
 find_package(GTest CONFIG REQUIRED)
 
 add_subdirectory(unit)
-add_subdirectory(shader)
 add_subdirectory(rasterization)

test/rasterization/CMakeLists.txt

@@ -8,6 +8,8 @@ add_executable(dvt_rasterization WIN32
     dvr_main.cpp
     dvr_triangle.h
     dvr_triangle.cpp
+	dvr_canvas.h
+	dvr_canvas.cpp
 )
 
 set_property(TARGET dvt_rasterization PROPERTY FOLDER "test")

test/rasterization/dvr_canvas.cpp

@@ -0,0 +1,83 @@
+#include "dvr_canvas.h"
+
+#include <array>
+
+#define SDL_MAIN_USE_CALLBACKS 1  /* use the callbacks instead of main() */
+#include <SDL3/SDL.h>
+
+void Canvas::reset(int32_t width, int32_t height)
+{
+	m_width = width;
+	m_height = height;
+	m_pixels.resize(m_width * m_height);
+
+	for (int32_t i = 0; i < m_width * m_height; i++)
+	{
+		m_pixels[i].fragementID = -1;
+		m_pixels[i].mask = 0;
+		m_pixels[i].color = davinci::fVector3::BLACK;
+	}
+
+	m_fragementArray.clear();
+}
+
+void Canvas::_insertTriangle(const Triangle& triangle)
+{
+	for (size_t i = 0; i < triangle.m_pixels.size(); i++)
+	{
+		const Triangle::Pixel trianglePixel = triangle.m_pixels[i];
+		Pixel& pixel = m_pixels[trianglePixel.y * m_width + trianglePixel.x];
+
+		Fragement newFragement;
+		newFragement.id = (int32_t)m_fragementArray.size();
+		newFragement.color = triangle.m_pixelColor;
+		newFragement.mask = trianglePixel.mask;
+		newFragement.next = pixel.fragementID;
+
+		pixel.fragementID = newFragement.id;
+		m_fragementArray.push_back(newFragement);
+	}
+}
+
+void Canvas::_update_without_AA()
+{
+	for (size_t i = 0; i < m_pixels.size(); i++)
+	{
+		Pixel& pixel = m_pixels[i];
+		if (pixel.fragementID < 0) continue;
+
+		const Fragement& fragement = m_fragementArray[pixel.fragementID];
+		pixel.mask = fragement.mask;
+		pixel.color = fragement.color;
+		pixel.alpha = 1.f;
+	}
+}
+
+void Canvas::update(davinci::AntiAliasingTech aaTech, const TriangleArray& triangleArray, const Triangle* pActionTriangle)
+{
+	reset(m_width, m_height);
+
+	for (size_t i = 0; i < triangleArray.size(); i++)
+	{
+		const Triangle& triangle = triangleArray[i];
+		_insertTriangle(triangle);
+	}
+
+	if (pActionTriangle != nullptr)
+	{
+		_insertTriangle(*pActionTriangle);
+	}
+
+	if (aaTech == davinci::AntiAliasingTech::AA_None)
+	{
+		_update_without_AA();
+	}
+	else if (aaTech == davinci::AntiAliasingTech::AA_MSAA_2X2)
+	{
+		_update_with_AA<4>();
+	}
+	else if ( aaTech == davinci::AntiAliasingTech::AA_MSAA_4X4)
+	{
+		_update_with_AA<16>();
+	}
+}