init commit

source/core/CMakeLists.txt

@@ -0,0 +1,207 @@
+
+set(DV_CORE_INCLUDE_FILES
+	include/dvc_config.h
+	include/dvc_pre_declare.h
+)
+source_group("include" FILES ${DV_CORE_INCLUDE_FILES})
+
+#################
+# math
+#################
+set(DV_CORE_MATH_INCLUDE_FILES
+	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/math/dvc_math_util.h
+	include/math/dvc_fixmath.h
+)
+source_group("include/math" FILES ${DV_CORE_MATH_INCLUDE_FILES})
+
+set(DV_CORE_MATH_SOURCE_FILES
+	source/math/dvc_vector2.cpp
+	source/math/dvc_vector3.cpp
+	source/math/dvc_vector4.cpp
+	source/math/dvc_matrix3.cpp
+	source/math/dvc_matrix4.cpp
+	source/math/dvc_math_util.cpp
+)
+source_group("source/math" FILES ${DV_CORE_MATH_SOURCE_FILES})
+
+#################
+# scene
+#################
+set(DV_CORE_SCENE_INCLUDE_FILES
+	include/scene/dvc_scene.h
+	include/scene/dvc_scene_node.h
+)
+source_group("include/scene" FILES ${DV_CORE_SCENE_INCLUDE_FILES})
+
+set(DV_CORE_SCENE_SOURCE_FILES
+	source/scene/dvc_scene.cpp
+	source/scene/dvc_scene_node.cpp
+)
+source_group("source/scene" FILES ${DV_CORE_SCENE_SOURCE_FILES})
+
+#################
+# scene component
+#################
+set(DV_CORE_SCENE_COMPONENT_INCLUDE_FILES
+	include/scene/component/dvc_component.h
+	include/scene/component/dvc_mesh_component.h
+	include/scene/component/dvc_camera_component.h
+	include/scene/component/dvc_light_component.h
+)
+source_group("include/scene/component" FILES ${DV_CORE_SCENE_COMPONENT_INCLUDE_FILES})
+
+set(DV_CORE_SCENE_COMPONENT_SOURCE_FILES
+	source/scene/component/dvc_component.cpp
+	source/scene/component/dvc_mesh_component.cpp
+	source/scene/component/dvc_camera_component.cpp
+	source/scene/component/dvc_light_component.cpp
+)
+source_group("source/scene/component" FILES ${DV_CORE_SCENE_COMPONENT_SOURCE_FILES})
+
+#################
+# asset
+#################
+set(DV_CORE_ASSET_INCLUDE_FILES
+	include/asset/dvc_mesh.h
+)
+source_group("include/asset" FILES ${DV_CORE_ASSET_INCLUDE_FILES})
+
+set(DV_CORE_ASSET_SOURCE_FILES
+	source/asset/dvc_mesh.cpp
+)
+source_group("source/asset" FILES ${DV_CORE_ASSET_SOURCE_FILES})
+
+#################
+# device
+#################
+set(DV_CORE_DEVICE_INCLUDE_FILES
+	include/device/dvc_buffer.h
+	include/device/dvc_buffer_view.h
+	include/device/dvc_buffer_accessor.h
+	include/device/dvc_render_target.h
+	include/device/dvc_pixel_buffer.h
+	include/device/dvc_uniform_buffer.h
+	include/device/dvc_vertex_desc.h
+)
+source_group("include/device" FILES ${DV_CORE_DEVICE_INCLUDE_FILES})
+
+set(DV_CORE_DEVICE_SOURCE_FILES
+	source/device/dvc_buffer.cpp
+	source/device/dvc_buffer_view.cpp
+	source/device/dvc_buffer_accessor.cpp
+	source/device/dvc_render_target.cpp
+	source/device/dvc_pixel_buffer.cpp
+	source/device/dvc_uniform_buffer.cpp
+	source/device/dvc_vertex_desc.cpp
+)
+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_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_rasterizer.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_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_rasterizer_triangle.cpp
+)
+source_group("source/pipe" FILES ${DV_CORE_PIPE_SOURCE_FILES})
+
+#################
+# shader
+#################
+set(DV_CORE_SHADER_INCLUDE_FILES
+	include/shader/dvc_shader_interface.h
+)
+source_group("include/shader" FILES ${DV_CORE_SHADER_INCLUDE_FILES})
+
+set(DV_CORE_SHADER_SOURCE_FILES
+	source/shader/dvc_shader_interface.cpp
+)
+source_group("source/shader" FILES ${DV_CORE_SHADER_SOURCE_FILES})
+
+#################
+# core library
+#################
+include_directories(
+	${DV_AUTO_INCLUDE_PATH}
+	${CMAKE_CURRENT_SOURCE_DIR}/include
+)
+
+add_library(dv_core SHARED 
+	${DV_CORE_INCLUDE_FILES}
+	${DV_CORE_MATH_INCLUDE_FILES}
+	${DV_CORE_MATH_SOURCE_FILES}
+	${DV_CORE_SCENE_INCLUDE_FILES}
+	${DV_CORE_SCENE_SOURCE_FILES}
+	${DV_CORE_SCENE_COMPONENT_INCLUDE_FILES}
+	${DV_CORE_SCENE_COMPONENT_SOURCE_FILES}
+	${DV_CORE_DEVICE_INCLUDE_FILES}
+	${DV_CORE_DEVICE_SOURCE_FILES}
+	${DV_CORE_ASSET_INCLUDE_FILES}
+	${DV_CORE_ASSET_SOURCE_FILES}
+	${DV_CORE_PIPE_INCLUDE_FILES}
+	${DV_CORE_PIPE_SOURCE_FILES}
+	${DV_CORE_SHADER_INCLUDE_FILES}
+	${DV_CORE_SHADER_SOURCE_FILES}
+)
+
+target_compile_definitions(dv_core
+    PRIVATE DV_CORE_EXPORTS
+)
+
+#################
+# copy runtime dll(for debug)
+#################
+add_custom_command(
+	TARGET dv_core POST_BUILD
+	COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_FILE:dv_core> ${CMAKE_BINARY_DIR}/source/console/$<$<CONFIG:Debug>:Debug>$<$<CONFIG:Release>:Release>)
+
+add_custom_command(
+	TARGET dv_core POST_BUILD
+	COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_FILE:dv_core> ${CMAKE_BINARY_DIR}/test/unit/$<$<CONFIG:Debug>:Debug>$<$<CONFIG:Release>:Release>)
+
+add_custom_command(
+	TARGET dv_core POST_BUILD
+	COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_FILE:dv_core> ${CMAKE_BINARY_DIR}/test/rasterization/$<$<CONFIG:Debug>:Debug>$<$<CONFIG:Release>:Release>)
+
+#################
+# install
+#################
+
+install(DIRECTORY include/
+	DESTINATION include/core
+	FILES_MATCHING 
+	PATTERN "*.h"
+)
+
+if(MSVC)
+	install(TARGETS dv_core
+		RUNTIME DESTINATION bin/$<$<CONFIG:Debug>:Debug>$<$<CONFIG:Release>:Release>
+		ARCHIVE DESTINATION lib/$<$<CONFIG:Debug>:Debug>$<$<CONFIG:Release>:Release>
+)
+else(MSVC)
+install(TARGETS dv_core
+	RUNTIME DESTINATION bin
+	ARCHIVE DESTINATION lib
+)
+endif(MSVC)

source/core/include/asset/dvc_mesh.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "dvc_pre_declare.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+class DV_CORE_API Mesh
+{
+public:
+	typedef std::map<VertexElementType, DeviceBufferAccessorConstPtr> PrimitiveAttributes;
+	struct Primitive
+	{
+		PrimitiveType type;
+		PrimitiveAttributes attributes;
+		DeviceBufferAccessorConstPtr indices;
+	};
+	typedef std::shared_ptr<Primitive> PrimitivePtr;
+	typedef std::shared_ptr<const Primitive> PrimitiveConstPtr;
+	typedef std::vector<PrimitivePtr> PrimitiveArray;
+
+public:
+	const std::string& getName(void) const {
+		return m_name;
+	}
+
+	PrimitivePtr newPrimitive(void);
+	int32_t getPrimitiveCounts(void) const {
+		return (int32_t)m_primitiveArray.size();
+	}
+	PrimitiveConstPtr getPrimitive(int32_t index) const;
+
+private:
+	std::string m_name;
+	PrimitiveArray m_primitiveArray;
+
+public:
+	Mesh(const std::string& name);
+	~Mesh();
+};
+
+DV_CORE_END_NAMESPACE

source/core/include/device/dvc_buffer.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "dvc_config.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+class DV_CORE_API DeviceBuffer
+{
+public:
+	void init(size_t _length);
+	void clear(void);
+
+	size_t length(void) const { return m_length; }
+
+	const uint8_t* ptr(size_t offseet) const {
+		return m_ptr + offseet;
+	}
+
+	uint8_t* ptr(size_t offseet) {
+		return m_ptr + offseet;
+	}
+private:
+	uint8_t* m_ptr;
+	size_t m_length;
+
+public:
+	DeviceBuffer();
+	DeviceBuffer(size_t _length);
+	~DeviceBuffer();
+};
+
+DV_CORE_END_NAMESPACE

source/core/include/device/dvc_buffer_accessor.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include "dvc_buffer_view.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+class DV_CORE_API DeviceBufferAccessor
+{
+public:
+	const DeviceBufferViewConstPtr getBufferView(void) const {
+		return m_bufferView;
+	}
+
+	void walk(std::function<bool(const uint8_t*, size_t)> callback, size_t start = 0, size_t end = ((size_t)-1)) const;
+	void walk2(std::function<bool(const uint8_t*, const uint8_t*, size_t)> callback, size_t start = 0, size_t end = ((size_t)-1)) const;
+	void walk3(std::function<bool(const uint8_t*, const uint8_t*, const uint8_t*, size_t)> callback, size_t start = 0, size_t end = ((size_t)-1)) const;
+
+	const uint8_t* getElement(size_t index) const;
+
+	size_t getOffset(void) const {
+		return m_offset;
+	}
+
+	size_t getCount(void) const {
+		return m_count;
+	}
+
+	ComponentType getComponentType(void) const {
+		return m_componentType;
+	}
+
+	DataType getDataType(void) const {
+		return m_dataType;
+	}
+
+	size_t getElementSize(void) const {
+		return m_elementSize;
+	}
+
+
+private:
+	DeviceBufferViewConstPtr m_bufferView;
+	size_t m_offset;
+	size_t m_count;
+	ComponentType m_componentType;
+	DataType m_dataType;
+
+	size_t m_elementSize;
+
+public:
+	DeviceBufferAccessor(DeviceBufferViewConstPtr bufferView, size_t offset, size_t count, ComponentType componentType, DataType dataType);
+	~DeviceBufferAccessor();
+};
+
+
+
+
+DV_CORE_END_NAMESPACE

source/core/include/device/dvc_buffer_view.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include "dvc_buffer.h"
+#include "dvc_pre_declare.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+class DV_CORE_API DeviceBufferView
+{
+public:
+	const DeviceBufferConstPtr getBuffer(void) const {
+		return m_buffer;
+	}
+
+	size_t getOffset(void) const {
+		return m_offset;
+	}
+
+	size_t getLength(void) const {
+		return m_length;
+	}
+
+	size_t getStride(void) const {
+		return m_stride;
+	}
+
+private:
+	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();
+};
+
+DV_CORE_END_NAMESPACE

source/core/include/device/dvc_pixel_buffer.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include "dvc_config.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+template<typename T>
+class PixelBuffer
+{
+public:
+	void init(int width, int height, const T& pixel) {
+		assert(width > 0 && width < 0xFFFF);
+		assert(height > 0 && height < 0xFFFF);
+
+		m_width = width;
+		m_height = height;
+		m_pixelBuffer.resize((size_t)(width * height));
+		clear(pixel);
+	}
+
+	void clear(const T& pixel) {
+		std::fill(m_pixelBuffer.begin(), m_pixelBuffer.end(), pixel);
+	}
+
+	void setPixel(int32_t x, int32_t y, const T& pixel) {
+		assert(x >= 0 && x < m_width);
+		assert(y >= 0 && y < m_height);
+
+		m_pixelBuffer[(size_t)(y * m_width + x)] = pixel;
+	}
+
+	const T& getPixel(int32_t x, int32_t y) const {
+		assert(x >= 0 && x < m_width);
+		assert(y >= 0 && y < m_height);
+
+		return m_pixelBuffer[(size_t)(y * m_width + x)];
+	}
+
+	const T* ptr(void) const {
+		return &(m_pixelBuffer[0]);
+	}
+
+	int32_t getWidth(void) const { return m_width; }
+	int32_t getHeight(void) const { return m_height; }
+
+protected:
+	std::vector<T> m_pixelBuffer;
+	int32_t m_width;
+	int32_t m_height;
+
+public:
+	PixelBuffer() : m_width(0), m_height(0) {}
+};
+
+DV_CORE_END_NAMESPACE

source/core/include/device/dvc_render_target.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "math/dvc_vector4.h"
+#include "dvc_pixel_buffer.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+class DV_CORE_API RenderTarget
+{
+public:
+	void init(int32_t width, int32_t height);
+	void clear();
+	void setPixel(int32_t x, int32_t y, const fVector4& color, float32_t depth);
+
+	int32_t getWidth(void) const { return m_width; }
+	int32_t getHeight(void) const { return m_height; }
+
+	const PixelBuffer<fVector4>& getColorBuffer(void) const { return m_colorBuffer; }
+	const PixelBuffer<float32_t>& getDepthBuffer(void) const { return m_depthBuffer; }
+
+private:
+	int32_t m_width;
+	int32_t m_height;
+	PixelBuffer<fVector4> m_colorBuffer;
+	PixelBuffer<float32_t> m_depthBuffer;
+
+public:
+	RenderTarget();
+	~RenderTarget() {}
+};
+
+DV_CORE_END_NAMESPACE

source/core/include/device/dvc_uniform_buffer.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include "dvc_config.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"
+
+DV_CORE_BEGIN_NAMESPACE
+
+class DV_CORE_API UniformBuffer
+{
+public:
+	struct AttributeValue
+	{
+		std::string name;
+		ComponentType componentType;
+		DataType dataType;
+		void* value;
+	};
+	typedef std::map<std::string, AttributeValue> AttributeMap;
+
+public:
+	void clear();
+
+	void updateStandardAttribute(const Scene& scene);
+
+	void setAttribute(const std::string& name, ComponentType componentType, DataType dataType, const void* value);
+
+	void setAttribute(const std::string& name, const int32_t& value);
+	void setAttribute(const std::string& name, const float32_t& value);
+	void setAttribute(const std::string& name, const fVector2& value);
+	void setAttribute(const std::string& name, const fVector3& value);
+	void setAttribute(const std::string& name, const fVector4& value);
+	void setAttribute(const std::string& name, const fMatrix3& value);
+	void setAttribute(const std::string& name, const fMatrix4& value);
+
+	void* getAttribute(const std::string& name) const;
+
+	void removeAttribute(const std::string& name);
+
+private:
+	void* mallocMemory(size_t size);
+	void freeMemory(void* memory);
+
+protected:
+	AttributeMap m_attributeMap;
+};
+
+DV_CORE_END_NAMESPACE

source/core/include/device/dvc_vertex_desc.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include "dvc_config.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+//Description of a vertex data
+class DV_CORE_API VertexDesc
+{
+public:
+	struct Element
+	{
+		std::string			name;
+		VertexElementType	elementType;
+		ComponentType		componentType;
+		DataType			dataType;
+		size_t				offset;			//byte offset
+		size_t				size;			//byte size
+	};
+
+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;
+
+	//total byte size of each vertex
+	size_t vertexByteSize(void) const { return m_vertexSize; }
+
+private:
+	typedef std::vector< Element > ElementBuf;
+	ElementBuf	m_elements;
+
+	size_t		m_vertexSize;
+
+	std::map< VertexElementType, ElementBuf::size_type> m_elementTypeMap;
+	std::map< std::string, ElementBuf::size_type> m_nameMap;
+
+public:
+	VertexDesc();
+	VertexDesc(const VertexDesc& other);
+	~VertexDesc() {}
+};
+
+DV_CORE_END_NAMESPACE

source/core/include/dvc_config.h

@@ -0,0 +1,105 @@
+#pragma once
+
+#include "dv_config.h"
+
+#ifdef DV_CORE_EXPORTS
+#define DV_CORE_API __declspec(dllexport)
+#else
+#define DV_CORE_API __declspec(dllimport)
+#endif
+
+//core namespace
+#define DV_CORE_BEGIN_NAMESPACE namespace davinci {
+#define DV_CORE_END_NAMESPACE }
+
+//basic types
+DV_CORE_BEGIN_NAMESPACE
+
+enum ComponentType
+{
+	CT_UNKNOWN,
+
+	CT_Int8,
+	CT_Uint8,
+	CT_Int16,
+	CT_Uint16,
+	CT_Int32,
+	CT_Uint32,
+	CT_Float32,
+	CT_Float64,
+};
+
+enum DataType
+{
+	DT_UNKNOWN,
+
+	DT_Scalar,
+	DT_Vec2,
+	DT_Vec3,
+	DT_Vec4,
+	DT_Matrix2,
+	DT_Matrix3,
+	DT_Matrix4,
+};
+
+enum VertexElementType
+{
+	VET_UNKNOWN,
+
+	VET_POSITION,
+	VET_NORMAL,
+	VET_TANGENT,
+	VET_BINORMAL,
+
+	VET_TEXCOORD_0, VET_TEXCOORD_1, VET_TEXCOORD_2, VET_TEXCOORD_3,
+	VET_TEXCOORD_4, VET_TEXCOORD_5,	VET_TEXCOORD_6,	VET_TEXCOORD_7,
+
+	VET_TEXCOORD_LAST=VET_TEXCOORD_7,
+
+	VET_COLOR_0, VET_COLOR_1, VET_COLOR_2, VET_COLOR_3,
+	VET_COLOR_4, VET_COLOR_5, VET_COLOR_6, VET_COLOR_7,
+
+	VET_COLOR_LAST=VET_COLOR_7,
+
+	VET_JOINTS_0, VET_JOINTS_1, VET_JOINTS_2, VET_JOINTS_3,
+	VET_JOINTS_4, VET_JOINTS_5, VET_JOINTS_6, VET_JOINTS_7,
+
+	VET_JOINTS_LAST=VET_JOINTS_7,
+
+	VET_WEIGHTS_0, VET_WEIGHTS_1, VET_WEIGHTS_2, VET_WEIGHTS_3,
+	VET_WEIGHTS_4, VET_WEIGHTS_5, VET_WEIGHTS_6, VET_WEIGHTS_7,
+
+	VET_WEIGHTS_LAST=VET_WEIGHTS_7,
+
+	VET_STANDARD_LAST=VET_WEIGHTS_LAST,
+};
+
+enum PrimitiveType
+{
+	PT_UNKNOWN,
+
+	PT_POINT_LIST,
+	PT_LINE_LIST,
+	PT_LINE_LOOP,
+	PT_LINE_STRIP,
+	PT_TRIANGLE_LIST,
+	PT_TRIANGLE_STRIP,
+	PT_TRIANGLE_FAN,
+};
+
+enum PixelFormat
+{
+	//96-bit pixel format, 32 bits (float) for red, 32 bits (float) for green, 32 bits (float) for blue
+	PF_FLOAT32_RGB,
+
+	/// 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_RGBA,
+};
+
+DV_CORE_END_NAMESPACE

source/core/include/dvc_pre_declare.h

@@ -0,0 +1,73 @@
+#pragma once
+
+#include <vector>
+
+// Pre-declare classes
+
+DV_CORE_BEGIN_NAMESPACE
+
+template <typename T>
+class TVector2;
+
+template <typename T>
+class TVector3;
+
+template <typename T>
+class TVector4;
+
+template <typename T>
+class TMatrix4;
+
+class DeviceBuffer;
+typedef std::shared_ptr<DeviceBuffer> DeviceBufferPtr;
+typedef std::shared_ptr<const DeviceBuffer> DeviceBufferConstPtr;
+
+class DeviceBufferView;
+typedef std::shared_ptr<DeviceBufferView> DeviceBufferViewPtr;
+typedef std::shared_ptr<const DeviceBufferView> DeviceBufferViewConstPtr;
+
+class DeviceBufferAccessor;
+typedef std::shared_ptr<DeviceBufferAccessor> DeviceBufferAccessorPtr;
+typedef std::shared_ptr<const DeviceBufferAccessor> DeviceBufferAccessorConstPtr;
+
+class RenderTarget;
+
+class Mesh;
+typedef std::shared_ptr<Mesh> MeshPtr;
+typedef std::shared_ptr<const Mesh> MeshConstPtr;
+
+class Scene;
+
+class SceneNode;
+typedef std::shared_ptr<SceneNode> SceneNodePtr;
+typedef std::shared_ptr<const SceneNode> SceneNodeConstPtr;
+typedef std::vector<SceneNodePtr> SceneNodeArray;
+
+class SceneComponent;
+typedef std::shared_ptr<SceneComponent> SceneComponentPtr;
+typedef std::shared_ptr<const SceneComponent> SceneComponentConstPtr;
+typedef std::vector<SceneComponentPtr> SceneComponentArray;
+
+class MeshComponent;
+typedef std::shared_ptr<MeshComponent> MeshComponentPtr;
+typedef std::shared_ptr<const MeshComponent> MeshComponentConstPtr;
+
+class CameraComponent;
+typedef std::shared_ptr<CameraComponent> CameraComponentPtr;
+typedef std::shared_ptr<const CameraComponent> CameraComponentConstPtr;
+
+class LightComponent;
+typedef std::shared_ptr<LightComponent> LightComponentPtr;
+typedef std::shared_ptr<const LightComponent> LightComponentConstPtr;
+
+class RenderQueue;
+
+class Renderable;
+typedef std::shared_ptr<Renderable> RenderablePtr;
+typedef std::shared_ptr<const Renderable> RenderableConstPtr;
+
+class VertexShaderInterface;
+
+class UniformBuffer;
+
+DV_CORE_END_NAMESPACE

source/core/include/math/dvc_fixmath.h

@@ -0,0 +1,98 @@
+#pragma once
+
+#include "dvc_config.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+typedef int64_t ifloat_t;
+//typedef int64_t ifloat2_t[2];
+//typedef int64_t ifloat3_t[3];
+
+#define IFLOAT_SHIFT (16)
+#define IFLOAT_SCALE ((float64_t)(1<<IFLOAT_SHIFT))
+
+//-------------------------------------------------------------------------------------
+inline ifloat_t ifloat_init(float32_t a)
+{
+	return (ifloat_t)((float64_t)a * IFLOAT_SCALE + 0.5);
+}
+
+//-------------------------------------------------------------------------------------
+inline ifloat_t ifloat_init(int32_t a)
+{
+	return (int64_t)(a)<< IFLOAT_SHIFT;
+}
+
+//-------------------------------------------------------------------------------------
+inline float32_t ifloat_get_float(ifloat_t a)
+{
+	return (float32_t)((float64_t)a/ IFLOAT_SCALE);
+}
+
+//-------------------------------------------------------------------------------------
+inline ifloat_t ifloat_multiply(ifloat_t a, ifloat_t b)
+{
+	return (ifloat_t)((a * b) >> IFLOAT_SHIFT);
+}
+
+//-------------------------------------------------------------------------------------
+//inline void ifloat3_add(ifloat3_t& a, const ifloat3_t& b)
+//{
+//	a[0] += b[0]; a[1] += b[1]; a[2] += b[2];
+//}
+
+//-------------------------------------------------------------------------------------
+//inline void ifloat3_sub(ifloat3_t& a, const ifloat3_t& b)
+//{
+//	a[0] -= b[0]; a[1] -= b[1]; a[2] -= b[2];
+//}
+
+//-------------------------------------------------------------------------------------
+//inline void ifloat3_cpy(ifloat3_t& a, const ifloat3_t& b)
+//{
+//	a[0] = b[0]; a[1] = b[1]; a[2] = b[2];
+//}
+
+//-------------------------------------------------------------------------------------
+struct ifloat2_t
+{
+	ifloat_t x, y;
+
+	ifloat2_t() : x(0ll), y(0ll) {}
+	ifloat2_t(const ifloat2_t& other) : x(other.x), y(other.y) {}
+	ifloat2_t(float32_t _x, float32_t _y) : x(ifloat_init(_x)), y(ifloat_init(_y)) {}
+};
+
+struct ifloat3_t
+{
+	ifloat_t x, y, z;
+
+	inline void add(const ifloat3_t& other) {
+		x += other.x;
+		y += other.y;
+		z += other.z;
+	}
+
+	inline void sub(const ifloat3_t& other) {
+		x -= other.x;
+		y -= other.y;
+		z -= other.z;
+	}
+
+	inline ifloat_t operator [] (const size_t i) const {
+		return *(&x + i);
+	}
+
+	inline ifloat_t& operator [] (const size_t i) {
+		return *(&x + i);
+	}
+
+	ifloat3_t() : x(0ll), y(0ll), z(0ll) {}
+	ifloat3_t(const ifloat3_t& other) : x(other.x), y(other.y), z(other.z) {}
+	ifloat3_t(float32_t _x, float32_t _y, float32_t _z) : x(ifloat_init(_x)), y(ifloat_init(_y)), z(ifloat_init(_z)) {}
+	ifloat3_t(ifloat_t _x, ifloat_t _y, ifloat_t _z) : x(_x), y(_y), z(_z) {}
+};
+
+
+DV_CORE_END_NAMESPACE
+

source/core/include/math/dvc_math_util.h

@@ -0,0 +1,141 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "dvc_pre_declare.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+class MathUtil
+{
+public:
+	static size_t ComponentSize(ComponentType ct);
+	static size_t DataTypeSize(DataType dt);
+
+	static bool floatEqual(float a, float b,
+		float tolerance = std::numeric_limits<float>::epsilon()) {
+		return std::abs(b - a) <= tolerance;
+	}
+
+	//Square root function.
+	static float sqrt(float f) {
+		return std::sqrt(f);
+	}
+
+	//min
+	template<typename V>
+	static V min2(const V& v1, const V& v2) {
+		return (v1 < v2) ? v1 : v2;
+	}
+
+	template<typename V>
+	static V min3(const V& v1, const V& v2, const V& v3) {
+		return (v1 < v2) ? ((v1 < v3) ? v1 : v3) : ((v2 < v3) ? v2 : v3);
+	}
+
+	//max
+	template<typename V>
+	static V max2(const V& v1, const V& v2) {
+		return (v1 > v2) ? v1 : v2;
+	}
+
+	template<typename V>
+	static V max3(const V& v1, const V& v2, const V& v3) {
+		return (v1 > v2) ? ((v1 > v3) ? v1 : v3) : ((v2 > v3) ? v2 : v3);
+	}
+
+	/* Simulate the shader function lerp which performers linear interpolation
+	given 3 parameters v0, v1 and t the function returns the value of (1 - t)* v0 + t * v1.
+	where v0 and v1 are matching vector or scalar types and t can be either a scalar or a
+	vector of the same type as a and b.
+	*/
+	template <typename V, typename T> 
+	static V lerp(const V& v0, const V& v1, const T& t) {
+		return v0 * (1 - t) + v1 * t;
+	}
+
+	template <typename V, typename T>
+	static V lerp3(const V& v0, const V& v1, const V& v2, const T& t) {
+		return v0 * t[0] + v1 * t[1] + v2 * t[2];
+	}
+
+	// A random number in the range from [0,1]
+	static float DV_CORE_API unitRandom(void);
+	// A random number in the range from [low, high].
+	static float rangeRandom(float low, float high) {
+		return (high - low)*unitRandom() + low;
+	}
+	static int32_t rangeRandom(int32_t low, int32_t high) {
+		return ((high - low) >= RAND_MAX) ? ((rand()<<16|rand()) % (high - low) + low) : (rand() % (high - low) + low);
+	}
+	//clamps the specified value within the range of min to max.
+	template <typename T>
+	static T saturate(T v, const T& min=(T)0, const T& max=(T)1) {
+		return (v < min) ? min : ((v > max) ? max : v);
+	}
+
+	//cosine function
+	static float cos(float a) {
+		return std::cos(a);
+	}
+	//Sine function
+	static float sin(float a) {
+		return std::sin(a);
+	}
+
+	//return a right-handed, look-at matrix.
+	template<typename T>
+	static TMatrix4<T> lookatRH(const TVector3<T>& eye, const TVector3<T>& lookat, const TVector3<T>& up);
+
+	//return a right-handed perspective projection matrix based on a field of view.
+	template<typename T>
+	static TMatrix4<T> perspectiveFovRH(T fov, T aspect, T zNear, T zFar);
+
+	static DV_CORE_API const float POS_INFINITY;
+	static DV_CORE_API const float NEG_INFINITY;
+	static DV_CORE_API const float PI;
+	static DV_CORE_API const float PI_X2;
+	static DV_CORE_API const float PI_DIV2;
+	static DV_CORE_API const float PI_DIV4;
+	static DV_CORE_API const float fDeg2Rad;
+	static DV_CORE_API const float fRad2Deg;
+};
+
+//-------------------------------------------------------------------------------------
+template<typename T>
+TMatrix4<T> MathUtil::lookatRH(const TVector3<T>& eye, const TVector3<T>& lookat, const TVector3<T>& up)
+{
+	assert(lookat != eye);
+	assert(up != TVector3<T>::ZERO);
+
+	TVector3<T> zaxis = (eye - lookat).normalise();
+	TVector3<T> xaxis = up.crossProduct(zaxis).normalise();
+	TVector3<T> yaxis = zaxis.crossProduct(xaxis).normalise();
+
+	return TMatrix4<T>(
+		xaxis.x, xaxis.y, xaxis.z, -xaxis.dotProduct(eye),
+		yaxis.x, yaxis.y, yaxis.z, -yaxis.dotProduct(eye),
+		zaxis.x, zaxis.y, zaxis.z, -zaxis.dotProduct(eye),
+		0, 0, 0, 1.f);
+}
+
+//-------------------------------------------------------------------------------------
+template<typename T>
+TMatrix4<T> MathUtil::perspectiveFovRH(T fov, T aspect, T zNear, T zFar)
+{
+	assert(zNear > T(0) && zFar > T(0));
+	assert(!MathUtil::floatEqual(fov, T(0),		T(0.00001) * 2));
+	assert(!MathUtil::floatEqual(aspect, T(0),	T(0.00001)));
+	assert(!MathUtil::floatEqual(zNear, zFar,	T(0.00001)));
+
+	T cotanHalfFovy = T(1.0) / tanf(fov * T(0.5));
+
+	return TMatrix4<T>(
+		cotanHalfFovy / aspect,	0,				0,						0,
+		0,						cotanHalfFovy,	0,						0,
+		0,						0,				-zFar / (zFar - zNear),	-(zFar * zNear) / (zFar - zNear),
+		0,						0,				T(-1),					0
+	);
+}
+
+DV_CORE_END_NAMESPACE
+

source/core/include/math/dvc_matrix3.h

@@ -0,0 +1,294 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "dvc_pre_declare.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+template<typename T>
+class TMatrix3
+{
+protected:
+	/* The matrix entries, indexed by [row][col].
+        | m[0][0]  m[0][1]  m[0][2] |
+		| m[1][0]  m[1][1]  m[1][2] |
+		| m[2][0]  m[2][1]  m[2][2] |
+	*/
+	union {
+		T m[3][3];
+		T _m[9];
+	};
+
+public:
+	// constructor, It does NOT initialize the matrix for efficiency.
+	TMatrix3() {}
+	inline explicit TMatrix3(const T arr[3][3]) {
+		memcpy(m, arr, 9 * sizeof(T));
+	}
+	inline TMatrix3(const TMatrix3& rkMatrix) {
+		memcpy(m, rkMatrix.m, 9 * sizeof(T));
+	}
+	TMatrix3(
+		T m00, T m01, T m02,
+		T m10, T m11, T m12,
+		T m20, T m21, T m22)
+	{
+		m[0][0] = m00; m[0][1] = m01; m[0][2] = m02;
+		m[1][0] = m10; m[1][1] = m11; m[1][2] = m12;
+		m[2][0] = m20; m[2][1] = m21; m[2][2] = m22;
+	}
+
+public:
+	inline const T* operator[] (size_t iRow) const {
+		assert(iRow < 3);
+		return m[iRow];
+	}
+
+	inline T* operator[] (size_t iRow) {
+		assert(iRow < 3);
+		return m[iRow];
+	}
+public:
+	// Operations
+	inline TMatrix3& operator = (const TMatrix3& rkMatrix) {
+		memcpy(m, rkMatrix.m, 9 * sizeof(T));
+		return *this;
+	}
+
+	bool operator == (const TMatrix3& rkMatrix) const;
+	inline bool operator != (const TMatrix3& rkMatrix) const {
+		return !operator==(rkMatrix);
+	}
+
+	// return  this + rkMatrix
+	TMatrix3 operator + (const TMatrix3& rkMatrix) const;
+
+	// return this - Matrix
+	TMatrix3 operator - (const TMatrix3& rkMatrix) const;
+
+	// return this * rkMatrix
+	TMatrix3 operator * (const TMatrix3& rkMatrix) const;
+
+	// return -this
+	TMatrix3 operator - () const;
+
+	/*  Matrix * Vector
+         | m[0][0]  m[0][1]  m[0][2] |   |x|
+         | m[1][0]  m[1][1]  m[1][2] | * |y|
+         | m[2][0]  m[2][1]  m[2][2] |   |z|
+	*/
+	TVector3<T> operator * (const TVector3<T>& rkVector) const;
+
+	/* Vector * Matrix
+                | m[0][0]  m[0][1]  m[0][2] |
+    [x, y, z] * | m[1][0]  m[1][1]  m[1][2] |
+                | m[2][0]  m[2][1]  m[2][2] |
+	*/
+	template<typename U>
+	friend TVector3<U> operator * (const TVector3<U>& rkVector, const TMatrix3<U>& rkMatrix);
+
+	/// Matrix * scalar
+	TMatrix3 operator * (T fScalar) const;
+
+	/// Scalar * matrix
+	template<typename U> 
+	friend TMatrix3<U> operator * (U fScalar, const TMatrix3<U>& rkMatrix);
+
+public:
+	// Utilities
+
+	//return this^T
+	TMatrix3 transpose(void) const;
+	//rkInverse = this^{-1}?? return false mean no solution
+	bool inverse(TMatrix3& rkInverse, T fTolerance = 1e-06f) const;
+	//return this^{-1}, return ZERO if no solution
+	TMatrix3 inverse(T fTolerance = 1e-06f) const;
+
+public:
+	static DV_CORE_API const TMatrix3 ZERO;
+	static DV_CORE_API const TMatrix3 IDENTITY;
+};
+
+//-------------------------------------------------------------------------------------
+template<typename T>
+bool TMatrix3<T>::operator== (const TMatrix3<T>& rkMatrix) const
+{
+	for (size_t iRow = 0; iRow < 3; iRow++) {
+		for (size_t iCol = 0; iCol < 3; iCol++) {
+			if (m[iRow][iCol] != rkMatrix.m[iRow][iCol])
+				return false;
+		}
+	}
+
+	return true;
+}
+
+//-------------------------------------------------------------------------------------
+template<typename T>
+TMatrix3<T> TMatrix3<T>::operator + (const TMatrix3<T>& rkMatrix) const
+{
+	TMatrix3<T> kSum;
+	for (size_t iRow = 0; iRow < 3; iRow++) {
+		for (size_t iCol = 0; iCol < 3; iCol++) {
+			kSum.m[iRow][iCol] = m[iRow][iCol] + rkMatrix.m[iRow][iCol];
+		}
+	}
+	return kSum;
+}
+
+//-------------------------------------------------------------------------------------
+template<typename T>
+TMatrix3<T> TMatrix3<T>::operator - (const TMatrix3<T>& rkMatrix) const
+{
+	TMatrix3<T> kDiff;
+	for (size_t iRow = 0; iRow < 3; iRow++) {
+		for (size_t iCol = 0; iCol < 3; iCol++) {
+			kDiff.m[iRow][iCol] = m[iRow][iCol] - rkMatrix.m[iRow][iCol];
+		}
+	}
+	return kDiff;
+}
+
+//-------------------------------------------------------------------------------------
+template<typename T>
+TMatrix3<T> TMatrix3<T>::operator * (const TMatrix3<T>& rkMatrix) const
+{
+	TMatrix3<T> kProd;
+	for (size_t iRow = 0; iRow < 3; iRow++) {
+		for (size_t iCol = 0; iCol < 3; iCol++) {
+			kProd.m[iRow][iCol] =
+				m[iRow][0] * rkMatrix.m[0][iCol] +
+				m[iRow][1] * rkMatrix.m[1][iCol] +
+				m[iRow][2] * rkMatrix.m[2][iCol];
+		}
+	}
+	return kProd;
+}
+
+//-------------------------------------------------------------------------------------
+template<typename T>
+TMatrix3<T> TMatrix3<T>::operator - () const
+{
+	TMatrix3<T> kNeg;
+	for (size_t i = 0; i < 9; i++) {
+		kNeg._m[i] = -_m[i];
+	}
+	return kNeg;
+}
+
+//-------------------------------------------------------------------------------------
+template<typename T>
+TVector3<T> TMatrix3<T>::operator* (const TVector3<T>& rkPoint) const
+{
+	TVector3<T> kProd(
+		m[0][0] * rkPoint[0] + m[0][1] * rkPoint[1] + m[0][2] * rkPoint[2],
+		m[1][0] * rkPoint[0] + m[1][1] * rkPoint[1] + m[1][2] * rkPoint[2],
+		m[2][0] * rkPoint[0] + m[2][1] * rkPoint[1] + m[2][2] * rkPoint[2]);
+
+	return kProd;
+}
+
+//-------------------------------------------------------------------------------------
+template<typename T>
+inline TVector3<T> operator* (const TVector3<T>& rkPoint, const TMatrix3<T>& rkMatrix)
+{
+	TVector3<T> kProd(
+		rkPoint[0] * rkMatrix.m[0][0] + rkPoint[1] * rkMatrix.m[1][0] + rkPoint[2] * rkMatrix.m[2][0],
+		rkPoint[0] * rkMatrix.m[0][1] + rkPoint[1] * rkMatrix.m[1][1] + rkPoint[2] * rkMatrix.m[2][1],
+		rkPoint[0] * rkMatrix.m[0][2] + rkPoint[1] * rkMatrix.m[1][2] + rkPoint[2] * rkMatrix.m[2][2]);
+
+	return kProd;
+}
+
+//-------------------------------------------------------------------------------------
+template<typename T>
+TMatrix3<T> TMatrix3<T>::operator* (T fScalar) const
+{
+	TMatrix3<T> kProd;
+	for (size_t iRow = 0; iRow < 3; iRow++) {
+		for (size_t iCol = 0; iCol < 3; iCol++)
+			kProd[iRow][iCol] = fScalar * m[iRow][iCol];
+	}
+	return kProd;
+}
+
+//-------------------------------------------------------------------------------------
+template<typename T>
+TMatrix3<T> operator* (T fScalar, const TMatrix3<T>& rkMatrix)
+{
+	TMatrix3<T> kProd;
+	for (size_t iRow = 0; iRow < 3; iRow++) {
+		for (size_t iCol = 0; iCol < 3; iCol++)
+			kProd[iRow][iCol] = fScalar * rkMatrix.m[iRow][iCol];
+	}
+	return kProd;
+}
+
+//-------------------------------------------------------------------------------------
+template<typename T>
+TMatrix3<T> TMatrix3<T>::transpose(void) const
+{
+	TMatrix3<T> kTranspose;
+	for (size_t iRow = 0; iRow < 3; iRow++) {
+		for (size_t iCol = 0; iCol < 3; iCol++)
+			kTranspose[iRow][iCol] = m[iCol][iRow];
+	}
+	return kTranspose;
+}
+
+//-------------------------------------------------------------------------------------
+template<typename T>
+bool TMatrix3<T>::inverse(TMatrix3<T>& rkInverse, T fTolerance) const
+{
+	// Invert a 3x3 using cofactors.  This is about 8 times faster than
+	// the Numerical Recipes code which uses Gaussian elimination.
+
+	rkInverse[0][0] = m[1][1] * m[2][2] -
+		m[1][2] * m[2][1];
+	rkInverse[0][1] = m[0][2] * m[2][1] -
+		m[0][1] * m[2][2];
+	rkInverse[0][2] = m[0][1] * m[1][2] -
+		m[0][2] * m[1][1];
+	rkInverse[1][0] = m[1][2] * m[2][0] -
+		m[1][0] * m[2][2];
+	rkInverse[1][1] = m[0][0] * m[2][2] -
+		m[0][2] * m[2][0];
+	rkInverse[1][2] = m[0][2] * m[1][0] -
+		m[0][0] * m[1][2];
+	rkInverse[2][0] = m[1][0] * m[2][1] -
+		m[1][1] * m[2][0];
+	rkInverse[2][1] = m[0][1] * m[2][0] -
+		m[0][0] * m[2][1];
+	rkInverse[2][2] = m[0][0] * m[1][1] -
+		m[0][1] * m[1][0];
+
+	T fDet =
+		m[0][0] * rkInverse[0][0] +
+		m[0][1] * rkInverse[1][0] +
+		m[0][2] * rkInverse[2][0];
+
+	if (std::abs(fDet) <= fTolerance)
+		return false;
+
+	T fInvDet = T(1.0) / fDet;
+	for (size_t iRow = 0; iRow < 3; iRow++) {
+		for (size_t iCol = 0; iCol < 3; iCol++)
+			rkInverse[iRow][iCol] *= fInvDet;
+	}
+
+	return true;
+}
+
+//-------------------------------------------------------------------------------------
+template<typename T>
+TMatrix3<T> TMatrix3<T>::inverse(T fTolerance) const
+{
+	TMatrix3<T> kInverse = TMatrix3<T>::ZERO;
+	inverse(kInverse, fTolerance);
+	return kInverse;
+}
+
+typedef TMatrix3<float32_t> fMatrix3;
+
+DV_CORE_END_NAMESPACE
+

source/core/include/math/dvc_matrix4.h

@@ -0,0 +1,463 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "dvc_pre_declare.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+template<typename T>
+class TMatrix4
+{
+protected:
+	/* 
+        | m[0][0]  m[0][1]  m[0][2]  m[0][3] |
+        | m[1][0]  m[1][1]  m[1][2]  m[1][3] |
+		| m[2][0]  m[2][1]  m[2][2]  m[2][3] |
+		| m[3][0]  m[3][1]  m[3][2]  m[3][3] |
+	*/
+	union {
+		T m[4][4];
+		T _m[16];
+	};
+public:
+	// constructor, It does NOT initialize the matrix for efficiency.
+	TMatrix4() {}
+	inline explicit TMatrix4(const T arr[4][4]) {
+		memcpy(m, arr, 16 * sizeof(T));
+	}
+	inline TMatrix4(const TMatrix4& rkMatrix) {
+		memcpy(m, rkMatrix.m, 16 * sizeof(T));
+	}
+	TMatrix4(
+		T m00, T m01, T m02, T m03,
+		T m10, T m11, T m12, T m13,
+		T m20, T m21, T m22, T m23,
+		T m30, T m31, T m32, T m33)
+	{
+		m[0][0] = m00; m[0][1] = m01; m[0][2] = m02; m[0][3] = m03;
+		m[1][0] = m10; m[1][1] = m11; m[1][2] = m12; m[1][3] = m13;
+		m[2][0] = m20; m[2][1] = m21; m[2][2] = m22; m[2][3] = m23;
+		m[3][0] = m30; m[3][1] = m31; m[3][2] = m32; m[3][3] = m33;
+	}
+
+public:
+	inline const T* operator[] (size_t iRow) const {
+		assert(iRow < 4);
+		return m[iRow];
+	}
+
+	inline T* operator[] (size_t iRow) {
+		assert(iRow < 4);
+		return m[iRow];
+	}
+
+public:
+	// Operators
+	inline TMatrix4& operator = (const TMatrix4& rkMatrix) {
+		memcpy(m, rkMatrix.m, 16 * sizeof(T));
+		return *this;
+	}
+
+	bool operator == (const TMatrix4& rkMatrix) const;
+	inline bool operator != (const TMatrix4& rkMatrix) const {
+		return !operator==(rkMatrix);
+	}
+
+	// return this + m2
+	TMatrix4 operator + (const TMatrix4 &m2) const;
+	// return this - m2
+	TMatrix4 operator - (const TMatrix4 &m2) const;
+	//return this * m2
+	TMatrix4 operator * (const TMatrix4 &m2) const;
+	//return this * scalar
+	inline TMatrix4 operator*(T scalar) const {
+		return TMatrix4(
+			scalar*m[0][0], scalar*m[0][1], scalar*m[0][2], scalar*m[0][3],
+			scalar*m[1][0], scalar*m[1][1], scalar*m[1][2], scalar*m[1][3],
+			scalar*m[2][0], scalar*m[2][1], scalar*m[2][2], scalar*m[2][3],
+			scalar*m[3][0], scalar*m[3][1], scalar*m[3][2], scalar*m[3][3]);
+	}
+
+	/// return scalar * matrix
+	friend TMatrix4 operator* (T scalar, const TMatrix4& rkMatrix) {
+		return TMatrix4(
+			scalar*rkMatrix[0][0], scalar*rkMatrix[0][1], scalar*rkMatrix[0][2], scalar*rkMatrix[0][3],
+			scalar*rkMatrix[1][0], scalar*rkMatrix[1][1], scalar*rkMatrix[1][2], scalar*rkMatrix[1][3],
+			scalar*rkMatrix[2][0], scalar*rkMatrix[2][1], scalar*rkMatrix[2][2], scalar*rkMatrix[2][3],
+			scalar*rkMatrix[3][0], scalar*rkMatrix[3][1], scalar*rkMatrix[3][2], scalar*rkMatrix[3][3]);
+	}
+
+	// return -this
+	TMatrix4 operator - () const	{
+		return TMatrix4(
+			-m[0][0], -m[0][1], -m[0][2], -m[0][3],
+			-m[1][0], -m[1][1], -m[1][2], -m[1][3],
+			-m[2][0], -m[2][1], -m[2][2], -m[2][3],
+			-m[3][0], -m[3][1], -m[3][2], -m[3][3]);
+	}
+
+	/*  return Matrix * fVector4
+          | m[0][0]  m[0][1]  m[0][2]  m[0][3] |   |x|
+          | m[1][0]  m[1][1]  m[1][2]  m[1][3] | * |y|
+          | m[2][0]  m[2][1]  m[2][2]  m[2][3] |   |z|
+          | m[3][0]  m[3][1]  m[3][2]  m[3][3] |   |w|
+	*/	
+	inline TVector4<T> operator * (const TVector4<T>& v) const {
+		return TVector4<T>(
+			(m[0][0] * v.x + m[0][1] * v.y) + (m[0][2] * v.z + m[0][3] * v.w),
+			(m[1][0] * v.x + m[1][1] * v.y) + (m[1][2] * v.z + m[1][3] * v.w),
+			(m[2][0] * v.x + m[2][1] * v.y) + (m[2][2] * v.z + m[2][3] * v.w),
+			(m[3][0] * v.x + m[3][1] * v.y) + (m[3][2] * v.z + m[3][3] * v.w)
+		);
+	}
+
+	/*
+		Transforms the given 3-D vector by the matrix, projecting the
+		result back into <i>w</i> = 1.
+		@note
+		This means that the initial <i>w</i> is considered to be 1.0,
+		and then all the tree elements of the resulting 3-D vector are
+		divided by the resulting <i>w</i>.
+	*/
+	inline TVector3<T> operator * (const TVector3<T> &v) const {
+		TVector3<T> r;
+		T fInvW = 1.0f / (m[3][0] * v.x + m[3][1] * v.y + m[3][2] * v.z + m[3][3]);
+
+		r.x = (m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z + m[0][3]) * fInvW;
+		r.y = (m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z + m[1][3]) * fInvW;
+		r.z = (m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z + m[2][3]) * fInvW;
+		return r;
+	}
+
+	/* return fVector4 * Matrix
+                 | m[0][0]  m[0][1]  m[0][2]  m[0][3] |
+     [x,y,z,w] * | m[1][0]  m[1][1]  m[1][2]  m[1][3] |
+                 | m[2][0]  m[2][1]  m[2][2]  m[2][3] |
+                 | m[3][0]  m[3][1]  m[3][2]  m[3][3] |
+	*/	
+	friend TVector4<T> operator * (const TVector4<T>& v, const TMatrix4& mat) {
+		return TVector4<T>(
+			(v.x*mat[0][0] + v.y*mat[1][0]) + (v.z*mat[2][0] + v.w*mat[3][0]),
+			(v.x*mat[0][1] + v.y*mat[1][1]) + (v.z*mat[2][1] + v.w*mat[3][1]),
+			(v.x*mat[0][2] + v.y*mat[1][2]) + (v.z*mat[2][2] + v.w*mat[3][2]),
+			(v.x*mat[0][3] + v.y*mat[1][3]) + (v.z*mat[2][3] + v.w*mat[3][3])
+		);
+	}
+
+	friend TVector3<T> operator * (const TVector3<T>& v, const TMatrix4& mat) {
+		TVector3<T> r;
+		T fInvW = 1.0f / (mat.m[0][3] * v.x + mat.m[1][3] * v.y + mat.m[2][3] * v.z + mat.m[3][3]);
+
+		r.x = (mat.m[0][0] * v.x + mat.m[1][0] * v.y + mat.m[2][0] * v.z + mat.m[3][0]) * fInvW;
+		r.y = (mat.m[0][1] * v.x + mat.m[1][1] * v.y + mat.m[2][1] * v.z + mat.m[3][1]) * fInvW;
+		r.z = (mat.m[0][2] * v.x + mat.m[1][2] * v.y + mat.m[2][2] * v.z + mat.m[3][2]) * fInvW;
+		return r;
+	}
+public:
+	static inline TMatrix4 makeTrans(T x, T y, T z) {
+		return TMatrix4(
+			1, 0, 0, x,
+			0, 1, 0, y,
+			0, 0, 1, z,
+			0, 0, 0, 1);
+	}
+	
+	static inline TMatrix4 makeTrans(const TVector3<T>& pos) {
+		return TMatrix4(
+			1, 0, 0, pos.x,
+			0, 1, 0, pos.y,
+			0, 0, 1, pos.z,
+			0, 0, 0, 1);
+	}
+
+	static inline TMatrix4 makeScale(T x, T y, T z) {
+		return TMatrix4(
+			x, 0, 0, 0,
+			0, y, 0, 0,
+			0, 0, z, 0,
+			0, 0, 0, 1);
+	}
+
+	//rotate matrix(x), left multiplication 
+	static inline TMatrix4 makeRotate_X(T angle) {
+		T s = sin(angle);
+		T c = cos(angle);
+		return TMatrix4(
+			1, 0, 0, 0,
+			0, c, -s, 0,
+			0, s, c, 0,
+			0, 0, 0, 1);
+	}
+
+	//rotate matrix(y), left multiplication 
+	static inline TMatrix4 makeRotate_Y(T angle) {
+		T s = sin(angle);
+		T c = cos(angle);
+		return TMatrix4(
+			c, 0, s, 0,
+			0, 1, 0, 0,
+			-s, 0, c, 0,
+			0, 0, 0, 1);
+	}
+
+	//rotate matrix(z), left multiplication 
+	static inline TMatrix4 makeRotate_Z(T angle) {
+		T s = sin(angle);
+		T c = cos(angle);
+		return TMatrix4(
+			c, -s, 0, 0,
+			s, c, 0, 0,
+			0, 0, 1, 0,
+			0, 0, 0, 1);
+	}
+
+	//rotate matrix(rotate angle about the v axis), left multiplication 
+	static TMatrix4 makeRotate(const TVector3<T>& v, T angle) {
+		T c = cos(angle);
+		T s = sin(angle);
+		TMatrix4<T> result;
+
+		TVector3<T> axis = v.normalise();
+
+		result[0][0] = c + (T(1) - c) * axis.x * axis.x;
+		result[1][0] = (T(1) - c) * axis.x * axis.y + s * axis.z;
+		result[2][0] = (T(1) - c) * axis.x * axis.z - s * axis.y;
+		result[3][0] = T(0);
+
+		result[0][1] = (T(1) - c) * axis.y * axis.x - s * axis.z;
+		result[1][1] = c + (T(1) - c) * axis.y * axis.y;
+		result[2][1] = (T(1) - c) * axis.y * axis.z + s * axis.x;
+		result[3][1] = T(0);
+
+		result[0][2] = (T(1) - c) * axis.z * axis.x + s * axis.y;
+		result[1][2] = (T(1) - c) * axis.z * axis.y - s * axis.x;
+		result[2][2] = c + (T(1) - c) * axis.z * axis.z;
+		result[3][2] = T(0);
+
+		result[0][3] = 0;
+		result[1][3] = 0;
+		result[2][3] = 0;
+		result[3][3] = T(1);
+
+		return result;
+	}
+
+	//rotate matrix(from quaternion)
+	static TMatrix4 makeRotate(const TVector4<T>& q) {
+		TMatrix4<T> result;
+
+		T qxx(q.x * q.x);
+		T qyy(q.y * q.y);
+		T qzz(q.z * q.z);
+		T qxz(q.x * q.z);
+		T qxy(q.x * q.y);
+		T qyz(q.y * q.z);
+		T qwx(q.w * q.x);
+		T qwy(q.w * q.y);
+		T qwz(q.w * q.z);
+
+		result[0][0] = T(1) - T(2) * (qyy + qzz);
+		result[1][0] = T(2) * (qxy + qwz);
+		result[2][0] = T(2) * (qxz - qwy);
+		result[3][0] = 0;
+
+		result[0][1] = T(2) * (qxy - qwz);
+		result[1][1] = T(1) - T(2) * (qxx + qzz);
+		result[2][1] = T(2) * (qyz + qwx);
+		result[3][1] = 0;
+
+		result[0][2] = T(2) * (qxz + qwy);
+		result[1][2] = T(2) * (qyz - qwx);
+		result[2][2] = T(1) - T(2) * (qxx + qyy);
+		result[3][2] = 0;
+
+		result[0][3] = 0;
+		result[1][3] = 0;
+		result[2][3] = 0;
+		result[3][3] = T(1);
+
+		return result;
+	}
+
+	inline TMatrix4 transpose(void) const {
+		return TMatrix4(
+			m[0][0], m[1][0], m[2][0], m[3][0],
+			m[0][1], m[1][1], m[2][1], m[3][1],
+			m[0][2], m[1][2], m[2][2], m[3][2],
+			m[0][3], m[1][3], m[2][3], m[3][3]);
+	}
+
+	//return this^{-1}, return ZERO if no solution
+	TMatrix4 inverse(void) const;
+
+public:
+	static DV_CORE_API const TMatrix4 ZERO;
+	static DV_CORE_API const TMatrix4 IDENTITY;
+
+};
+
+//-------------------------------------------------------------------------------------
+template<typename T>
+bool TMatrix4<T>::operator == (const TMatrix4<T>& m2) const {
+	if (
+		m[0][0] != m2.m[0][0] || m[0][1] != m2.m[0][1] || m[0][2] != m2.m[0][2] || m[0][3] != m2.m[0][3] ||
+		m[1][0] != m2.m[1][0] || m[1][1] != m2.m[1][1] || m[1][2] != m2.m[1][2] || m[1][3] != m2.m[1][3] ||
+		m[2][0] != m2.m[2][0] || m[2][1] != m2.m[2][1] || m[2][2] != m2.m[2][2] || m[2][3] != m2.m[2][3] ||
+		m[3][0] != m2.m[3][0] || m[3][1] != m2.m[3][1] || m[3][2] != m2.m[3][2] || m[3][3] != m2.m[3][3])
+		return false;
+	return true;
+}
+
+//-------------------------------------------------------------------------------------
+template<typename T>
+TMatrix4<T> TMatrix4<T>::operator * (const TMatrix4<T>& m2) const
+{
+	TMatrix4<T> r;
+	r.m[0][0] = m[0][0] * m2.m[0][0] + m[0][1] * m2.m[1][0] + m[0][2] * m2.m[2][0] + m[0][3] * m2.m[3][0];
+	r.m[0][1] = m[0][0] * m2.m[0][1] + m[0][1] * m2.m[1][1] + m[0][2] * m2.m[2][1] + m[0][3] * m2.m[3][1];
+	r.m[0][2] = m[0][0] * m2.m[0][2] + m[0][1] * m2.m[1][2] + m[0][2] * m2.m[2][2] + m[0][3] * m2.m[3][2];
+	r.m[0][3] = m[0][0] * m2.m[0][3] + m[0][1] * m2.m[1][3] + m[0][2] * m2.m[2][3] + m[0][3] * m2.m[3][3];
+
+	r.m[1][0] = m[1][0] * m2.m[0][0] + m[1][1] * m2.m[1][0] + m[1][2] * m2.m[2][0] + m[1][3] * m2.m[3][0];
+	r.m[1][1] = m[1][0] * m2.m[0][1] + m[1][1] * m2.m[1][1] + m[1][2] * m2.m[2][1] + m[1][3] * m2.m[3][1];
+	r.m[1][2] = m[1][0] * m2.m[0][2] + m[1][1] * m2.m[1][2] + m[1][2] * m2.m[2][2] + m[1][3] * m2.m[3][2];
+	r.m[1][3] = m[1][0] * m2.m[0][3] + m[1][1] * m2.m[1][3] + m[1][2] * m2.m[2][3] + m[1][3] * m2.m[3][3];
+
+	r.m[2][0] = m[2][0] * m2.m[0][0] + m[2][1] * m2.m[1][0] + m[2][2] * m2.m[2][0] + m[2][3] * m2.m[3][0];
+	r.m[2][1] = m[2][0] * m2.m[0][1] + m[2][1] * m2.m[1][1] + m[2][2] * m2.m[2][1] + m[2][3] * m2.m[3][1];
+	r.m[2][2] = m[2][0] * m2.m[0][2] + m[2][1] * m2.m[1][2] + m[2][2] * m2.m[2][2] + m[2][3] * m2.m[3][2];
+	r.m[2][3] = m[2][0] * m2.m[0][3] + m[2][1] * m2.m[1][3] + m[2][2] * m2.m[2][3] + m[2][3] * m2.m[3][3];
+
+	r.m[3][0] = m[3][0] * m2.m[0][0] + m[3][1] * m2.m[1][0] + m[3][2] * m2.m[2][0] + m[3][3] * m2.m[3][0];
+	r.m[3][1] = m[3][0] * m2.m[0][1] + m[3][1] * m2.m[1][1] + m[3][2] * m2.m[2][1] + m[3][3] * m2.m[3][1];
+	r.m[3][2] = m[3][0] * m2.m[0][2] + m[3][1] * m2.m[1][2] + m[3][2] * m2.m[2][2] + m[3][3] * m2.m[3][2];
+	r.m[3][3] = m[3][0] * m2.m[0][3] + m[3][1] * m2.m[1][3] + m[3][2] * m2.m[2][3] + m[3][3] * m2.m[3][3];
+
+	return r;
+}
+
+//-------------------------------------------------------------------------------------
+template<typename T>
+TMatrix4<T> TMatrix4<T>::operator + (const TMatrix4<T>& m2) const
+{
+	TMatrix4<T> r;
+
+	r.m[0][0] = m[0][0] + m2.m[0][0];
+	r.m[0][1] = m[0][1] + m2.m[0][1];
+	r.m[0][2] = m[0][2] + m2.m[0][2];
+	r.m[0][3] = m[0][3] + m2.m[0][3];
+
+	r.m[1][0] = m[1][0] + m2.m[1][0];
+	r.m[1][1] = m[1][1] + m2.m[1][1];
+	r.m[1][2] = m[1][2] + m2.m[1][2];
+	r.m[1][3] = m[1][3] + m2.m[1][3];
+
+	r.m[2][0] = m[2][0] + m2.m[2][0];
+	r.m[2][1] = m[2][1] + m2.m[2][1];
+	r.m[2][2] = m[2][2] + m2.m[2][2];
+	r.m[2][3] = m[2][3] + m2.m[2][3];
+
+	r.m[3][0] = m[3][0] + m2.m[3][0];
+	r.m[3][1] = m[3][1] + m2.m[3][1];
+	r.m[3][2] = m[3][2] + m2.m[3][2];
+	r.m[3][3] = m[3][3] + m2.m[3][3];
+
+	return r;
+}
+
+//-------------------------------------------------------------------------------------
+template<typename T>
+TMatrix4<T> TMatrix4<T>::operator - (const TMatrix4<T>& m2) const
+{
+	TMatrix4<T> r;
+	r.m[0][0] = m[0][0] - m2.m[0][0];
+	r.m[0][1] = m[0][1] - m2.m[0][1];
+	r.m[0][2] = m[0][2] - m2.m[0][2];
+	r.m[0][3] = m[0][3] - m2.m[0][3];
+
+	r.m[1][0] = m[1][0] - m2.m[1][0];
+	r.m[1][1] = m[1][1] - m2.m[1][1];
+	r.m[1][2] = m[1][2] - m2.m[1][2];
+	r.m[1][3] = m[1][3] - m2.m[1][3];
+
+	r.m[2][0] = m[2][0] - m2.m[2][0];
+	r.m[2][1] = m[2][1] - m2.m[2][1];
+	r.m[2][2] = m[2][2] - m2.m[2][2];
+	r.m[2][3] = m[2][3] - m2.m[2][3];
+
+	r.m[3][0] = m[3][0] - m2.m[3][0];
+	r.m[3][1] = m[3][1] - m2.m[3][1];
+	r.m[3][2] = m[3][2] - m2.m[3][2];
+	r.m[3][3] = m[3][3] - m2.m[3][3];
+
+	return r;
+}
+
+//-------------------------------------------------------------------------------------
+template<typename T>
+TMatrix4<T> TMatrix4<T>::inverse(void) const
+{
+	T m00 = m[0][0], m01 = m[0][1], m02 = m[0][2], m03 = m[0][3];
+	T m10 = m[1][0], m11 = m[1][1], m12 = m[1][2], m13 = m[1][3];
+	T m20 = m[2][0], m21 = m[2][1], m22 = m[2][2], m23 = m[2][3];
+	T m30 = m[3][0], m31 = m[3][1], m32 = m[3][2], m33 = m[3][3];
+
+	T v0 = m20 * m31 - m21 * m30;
+	T v1 = m20 * m32 - m22 * m30;
+	T v2 = m20 * m33 - m23 * m30;
+	T v3 = m21 * m32 - m22 * m31;
+	T v4 = m21 * m33 - m23 * m31;
+	T v5 = m22 * m33 - m23 * m32;
+
+	T t00 = +(v5 * m11 - v4 * m12 + v3 * m13);
+	T t10 = -(v5 * m10 - v2 * m12 + v1 * m13);
+	T t20 = +(v4 * m10 - v2 * m11 + v0 * m13);
+	T t30 = -(v3 * m10 - v1 * m11 + v0 * m12);
+
+	T invDet = 1 / (t00 * m00 + t10 * m01 + t20 * m02 + t30 * m03);
+
+	T d00 = t00 * invDet;
+	T d10 = t10 * invDet;
+	T d20 = t20 * invDet;
+	T d30 = t30 * invDet;
+
+	T d01 = -(v5 * m01 - v4 * m02 + v3 * m03) * invDet;
+	T d11 = +(v5 * m00 - v2 * m02 + v1 * m03) * invDet;
+	T d21 = -(v4 * m00 - v2 * m01 + v0 * m03) * invDet;
+	T d31 = +(v3 * m00 - v1 * m01 + v0 * m02) * invDet;
+
+	v0 = m10 * m31 - m11 * m30;
+	v1 = m10 * m32 - m12 * m30;
+	v2 = m10 * m33 - m13 * m30;
+	v3 = m11 * m32 - m12 * m31;
+	v4 = m11 * m33 - m13 * m31;
+	v5 = m12 * m33 - m13 * m32;
+
+	T d02 = +(v5 * m01 - v4 * m02 + v3 * m03) * invDet;
+	T d12 = -(v5 * m00 - v2 * m02 + v1 * m03) * invDet;
+	T d22 = +(v4 * m00 - v2 * m01 + v0 * m03) * invDet;
+	T d32 = -(v3 * m00 - v1 * m01 + v0 * m02) * invDet;
+
+	v0 = m21 * m10 - m20 * m11;
+	v1 = m22 * m10 - m20 * m12;
+	v2 = m23 * m10 - m20 * m13;
+	v3 = m22 * m11 - m21 * m12;
+	v4 = m23 * m11 - m21 * m13;
+	v5 = m23 * m12 - m22 * m13;
+
+	T d03 = -(v5 * m01 - v4 * m02 + v3 * m03) * invDet;
+	T d13 = +(v5 * m00 - v2 * m02 + v1 * m03) * invDet;
+	T d23 = -(v4 * m00 - v2 * m01 + v0 * m03) * invDet;
+	T d33 = +(v3 * m00 - v1 * m01 + v0 * m02) * invDet;
+
+	return TMatrix4<T>(
+		d00, d01, d02, d03,
+		d10, d11, d12, d13,
+		d20, d21, d22, d23,
+		d30, d31, d32, d33);
+}
+
+typedef TMatrix4<float32_t> fMatrix4;
+
+DV_CORE_END_NAMESPACE
+

source/core/include/math/dvc_vector2.h

@@ -0,0 +1,239 @@
+#pragma once
+
+#include "dvc_config.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+template<typename T>
+class TVector2
+{
+public:
+	T x, y;
+
+public:
+	// Construct
+	TVector2() : x(0), y(0) { }
+	TVector2(T _x, T _y) : x(_x), y(_y){ }
+	inline explicit TVector2(const T s) : x(s), y(s) { }
+	inline explicit TVector2(const T f[2]) : x(f[0]), y(f[1]) { }
+	inline explicit TVector2(T* const f) : x(f[0]), y(f[1]) { }
+	inline explicit TVector2(const int32_t f[2]) : x((T)f[0]), y((T)f[1]) { }
+
+public:
+	inline T operator [] (const size_t i) const {
+		assert(i < 2);
+		return *(&x + i);
+	}
+
+	inline T& operator [] (const size_t i) {
+		assert(i < 2);
+		return *(&x + i);
+	}
+
+	inline T* ptr(void) {
+		return &x;
+	}
+
+	inline const T* ptr(void) const {
+		return &x;
+	}
+public:
+	// Operations
+	inline TVector2& operator = (const TVector2& rkVector) {
+		x = rkVector.x;
+		y = rkVector.y;
+		return *this;
+	}
+
+	inline TVector2& operator = (const T fScalar) {
+		x = fScalar;
+		y = fScalar;
+		return *this;
+	}
+
+	inline bool operator == (const TVector2& rkVector) const {
+		return (x == rkVector.x && y == rkVector.y);
+	}
+
+	inline bool operator != (const TVector2& rkVector) const {
+		return (x != rkVector.x || y != rkVector.y);
+	}
+
+public:
+	// Arithmetic operations
+	inline TVector2 operator + (const TVector2& rkVector) const {
+		return TVector2( x + rkVector.x, y + rkVector.y);
+	}
+
+	inline TVector2 operator - (const TVector2& rkVector) const {
+		return TVector2( x - rkVector.x, y - rkVector.y);
+	}
+
+	inline TVector2 operator * (const T fScalar) const {
+		return TVector2( x * fScalar, y * fScalar);
+	}
+
+	inline TVector2 operator * (const TVector2& rhs) const {
+		return TVector2(x * rhs.x, y * rhs.y);
+	}
+
+	inline TVector2 operator / (const T fScalar) const {
+		assert(fScalar != 0.0);
+		return TVector2(x / fScalar, y / fScalar);
+	}
+
+	inline TVector2 operator / (const TVector2& rhs) const {
+		return TVector2( x / rhs.x, y / rhs.y);
+	}
+
+	inline const TVector2& operator + () const {
+		return *this;
+	}
+
+	inline TVector2 operator - () const {
+		return TVector2(-x, -y);
+	}
+
+public:
+	// overloaded operators to help TVector2
+	inline friend TVector2 operator * (const T fScalar, const TVector2& rkVector) {
+		return TVector2(fScalar * rkVector.x, fScalar * rkVector.y);
+	}
+
+	inline friend TVector2 operator / (const T fScalar, const TVector2& rkVector) {
+		return TVector2( fScalar / rkVector.x, fScalar / rkVector.y);
+	}
+
+	inline friend TVector2 operator + (const TVector2& lhs, const T rhs) {
+		return TVector2( lhs.x + rhs, lhs.y + rhs);
+	}
+
+	inline friend TVector2 operator + (const T lhs, const TVector2& rhs) {
+		return TVector2( lhs + rhs.x, lhs + rhs.y);
+	}
+
+	inline friend TVector2 operator - (const TVector2& lhs, const T rhs) {
+		return TVector2( lhs.x - rhs, lhs.y - rhs);
+	}
+
+	inline friend TVector2 operator - (const T lhs, const TVector2& rhs) {
+		return TVector2( lhs - rhs.x, lhs - rhs.y);
+	}
+
+public:
+	// arithmetic updates
+	inline TVector2& operator += (const TVector2& rkVector) {
+		x += rkVector.x;
+		y += rkVector.y;
+		return *this;
+	}
+
+	inline TVector2& operator += (const T fScaler) {
+		x += fScaler;
+		y += fScaler;
+		return *this;
+	}
+
+	inline TVector2& operator -= (const TVector2& rkVector) {
+		x -= rkVector.x;
+		y -= rkVector.y;
+		return *this;
+	}
+
+	inline TVector2& operator -= (const T fScaler) {
+		x -= fScaler;
+		y -= fScaler;
+		return *this;
+	}
+
+	inline TVector2& operator *= (const T fScalar) {
+		x *= fScalar;
+		y *= fScalar;
+		return *this;
+	}
+
+	inline TVector2& operator *= (const TVector2& rkVector) {
+		x *= rkVector.x;
+		y *= rkVector.y;
+		return *this;
+	}
+
+	inline TVector2& operator /= (const T fScalar) {
+		assert(fScalar != 0.0);
+
+		x /= fScalar;
+		y /= fScalar;
+		return *this;
+	}
+
+	inline TVector2& operator /= (const TVector2& rkVector) {
+		x /= rkVector.x;
+		y /= rkVector.y;
+		return *this;
+	}
+
+	inline bool operator < (const TVector2& rhs) const {
+		return (x < rhs.x && y < rhs.y);
+	}
+
+	inline bool operator > (const TVector2& rhs) const {
+		return (x > rhs.x && y > rhs.y);
+	}
+
+public:
+	inline T length(void) const {
+		return MathUtil::sqrt(x * x + y * y);
+	}
+
+	inline T squaredLength(void) const {
+		return x * x + y * y;
+	}
+
+	inline T distance(const TVector2& rhs) const {
+		return (*this - rhs).length();
+	}
+
+	inline T squaredDistance(const TVector2& rhs) const {
+		return (*this - rhs).squaredLength();
+	}
+
+	inline T dotProduct(const TVector2& vec) const {
+		return x * vec.x + y * vec.y;
+	}
+
+	inline T crossProduct(const TVector2& rkVector) const {
+		return x * rkVector.y - y * rkVector.x;
+	}
+
+	inline TVector2& normalise(void) {
+		T fLength = length();
+		if (fLength > 0.0f) {
+			T invLength = T(1.0) / fLength;
+			x *= invLength;
+			y *= invLength;
+		}
+
+		return *this;
+	}
+
+	inline TVector2& saturate(void) {
+		x = MathUtil::saturate(x);
+		y = MathUtil::saturate(y);
+
+		return *this;
+	}
+public:
+	// special points
+	static DV_CORE_API const TVector2 ZERO;
+	static DV_CORE_API const TVector2 ONE;
+	static DV_CORE_API const TVector2 UNIT_X;
+	static DV_CORE_API const TVector2 UNIT_Y;
+	static DV_CORE_API const TVector2 NEGATIVE_UNIT_X;
+	static DV_CORE_API const TVector2 NEGATIVE_UNIT_Y;
+	static DV_CORE_API const TVector2 UNIT_SCALE;
+};
+
+
+typedef TVector2<float32_t> fVector2;
+
+DV_CORE_END_NAMESPACE

source/core/include/math/dvc_vector3.h

@@ -0,0 +1,289 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "dvc_pre_declare.h"
+#include "dvc_math_util.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+template<typename T>
+class TVector3
+{
+public:
+	T x, y, z;
+
+public:
+	// Construct
+	TVector3() : x(0.), y(0.), z(0.) { }
+	TVector3(T _x, T _y, T _z) : x(_x), y(_y), z(_z){ }
+	TVector3(const TVector2<T>& _xy, T _z) : x(_xy.x), y(_xy.y), z(_z) { }
+	TVector3(T _x, const TVector2<T>& _yz) : x(_x), y(_yz.x), z(_yz.y) { }
+	inline explicit TVector3(const T s) : x(s), y(s), z(s) { }
+	inline explicit TVector3(const T f[3]) : x(f[0]), y(f[1]), z(f[2]) { }
+	inline explicit TVector3(T* const f) : x(f[0]), y(f[1]), z(f[2]) { }
+	inline explicit TVector3(const int32_t f[3]) : x((T)f[0]), y((T)f[1]), z((T)f[2]) {}
+
+public:
+	inline T operator [] (const size_t i) const {
+		assert(i < 3);
+		return *(&x + i);
+	}
+
+	inline T& operator [] (const size_t i) {
+		assert(i < 3);
+		return *(&x + i);
+	}
+
+	inline T* ptr(void) {
+		return &x;
+	}
+
+	inline const T* ptr(void) const {
+		return &x;
+	}
+
+	inline TVector2<T> xy(void) const { return TVector2<T>(x, y); }
+	inline TVector2<T> xz(void) const { return TVector2<T>(x, z); }
+	inline TVector2<T> yz(void) const { return TVector2<T>(y, z); }
+
+public:
+	// Operations
+	inline TVector3& operator = (const TVector3& rkVector) {
+		x = rkVector.x;
+		y = rkVector.y;
+		z = rkVector.z;
+		return *this;
+	}
+
+	inline TVector3& operator = (const T fScalar) {
+		x = fScalar;
+		y = fScalar;
+		z = fScalar;
+		return *this;
+	}
+
+	inline bool operator == (const TVector3& rkVector) const {
+		return (x == rkVector.x && y == rkVector.y && z == rkVector.z);
+	}
+
+	inline bool operator != (const TVector3& rkVector) const {
+		return (x != rkVector.x || y != rkVector.y || z != rkVector.z);
+	}
+
+public:
+	// Arithmetic operations
+	inline TVector3 operator + (const TVector3& rkVector) const {
+		return TVector3( x + rkVector.x, y + rkVector.y, z + rkVector.z);
+	}
+
+	inline TVector3 operator - (const TVector3& rkVector) const {
+		return TVector3( x - rkVector.x, y - rkVector.y, z - rkVector.z);
+	}
+
+	inline TVector3 operator * (const T fScalar) const {
+		return TVector3( x * fScalar, y * fScalar, z * fScalar);
+	}
+
+	inline TVector3 operator * (const TVector3& rhs) const {
+		return TVector3(x * rhs.x, y * rhs.y, z * rhs.z);
+	}
+
+	inline TVector3 operator / (const T fScalar) const {
+		assert(fScalar != 0.0);
+		return TVector3(x / fScalar, y / fScalar, z / fScalar);
+	}
+
+	inline TVector3 operator / (const TVector3& rhs) const {
+		return TVector3( x / rhs.x, y / rhs.y, z / rhs.z);
+	}
+
+	inline const TVector3& operator + () const {
+		return *this;
+	}
+
+	inline TVector3 operator - () const {
+		return TVector3(-x, -y, -z);
+	}
+
+public:
+	// overloaded operators to help TVector3
+	inline friend TVector3 operator * (const T fScalar, const TVector3& rkVector) {
+		return TVector3(fScalar * rkVector.x, fScalar * rkVector.y, fScalar * rkVector.z);
+	}
+
+	inline friend TVector3 operator / (const T fScalar, const TVector3& rkVector) {
+		return TVector3( fScalar / rkVector.x, fScalar / rkVector.y, fScalar / rkVector.z);
+	}
+
+	inline friend TVector3 operator + (const TVector3& lhs, const T rhs) {
+		return TVector3( lhs.x + rhs, lhs.y + rhs, lhs.z + rhs);
+	}
+
+	inline friend TVector3 operator + (const T lhs, const TVector3& rhs) {
+		return TVector3( lhs + rhs.x, lhs + rhs.y, lhs + rhs.z);
+	}
+
+	inline friend TVector3 operator - (const TVector3& lhs, const T rhs) {
+		return TVector3( lhs.x - rhs, lhs.y - rhs, lhs.z - rhs);
+	}
+
+	inline friend TVector3 operator - (const T lhs, const TVector3& rhs) {
+		return TVector3( lhs - rhs.x, lhs - rhs.y, lhs - rhs.z);
+	}
+
+	inline friend TVector3 reflect(const TVector3& incident, const TVector3& normal) {
+		return incident - 2.f * normal.dotProduct(incident) * normal;
+	}
+public:
+	// arithmetic updates
+	inline TVector3& operator += (const TVector3& rkVector) {
+		x += rkVector.x;
+		y += rkVector.y;
+		z += rkVector.z;
+		return *this;
+	}
+
+	inline TVector3& operator += (const T fScaler) {
+		x += fScaler;
+		y += fScaler;
+		z += fScaler;
+		return *this;
+	}
+
+	inline TVector3& operator -= (const TVector3& rkVector) {
+		x -= rkVector.x;
+		y -= rkVector.y;
+		z -= rkVector.z;
+		return *this;
+	}
+
+	inline TVector3& operator -= (const T fScaler) {
+		x -= fScaler;
+		y -= fScaler;
+		z -= fScaler;
+		return *this;
+	}
+
+	inline TVector3& operator *= (const T fScalar) {
+		x *= fScalar;
+		y *= fScalar;
+		z *= fScalar;
+		return *this;
+	}
+
+	inline TVector3& operator *= (const TVector3& rkVector) {
+		x *= rkVector.x;
+		y *= rkVector.y;
+		z *= rkVector.z;
+		return *this;
+	}
+
+	inline TVector3& operator /= (const T fScalar) {
+		assert(fScalar != 0.0);
+
+		x /= fScalar;
+		y /= fScalar;
+		z /= fScalar;
+		return *this;
+	}
+
+	inline TVector3& operator /= (const TVector3& rkVector) {
+		x /= rkVector.x;
+		y /= rkVector.y;
+		z /= rkVector.z;
+		return *this;
+	}
+
+	inline bool operator < (const TVector3& rhs) const {
+		return (x < rhs.x && y < rhs.y && z < rhs.z);
+	}
+
+	inline bool operator > (const TVector3& rhs) const {
+		return (x > rhs.x && y > rhs.y && z > rhs.z);
+	}
+
+public:
+	inline T length(void) const {
+		return MathUtil::sqrt(x * x + y * y + z * z);
+	}
+
+	inline T squaredLength(void) const {
+		return x * x + y * y + z * z;
+	}
+
+	inline T distance(const TVector3& rhs) const {
+		return (*this - rhs).length();
+	}
+
+	inline T squaredDistance(const TVector3& rhs) const {
+		return (*this - rhs).squaredLength();
+	}
+
+	inline T dotProduct(const TVector3& vec) const {
+		return x * vec.x + y * vec.y + z * vec.z;
+	}
+
+	inline TVector3 crossProduct(const TVector3& rkVector) const {
+		return TVector3(
+			y * rkVector.z - z * rkVector.y,
+			z * rkVector.x - x * rkVector.z,
+			x * rkVector.y - y * rkVector.x);
+	}
+
+	inline TVector3& normalise(void) {
+		T fLength = length();
+		if (fLength > 0.0f) {
+			T invLength = 1.f / fLength;
+			x *= invLength;
+			y *= invLength;
+			z *= invLength;
+		}
+
+		return *this;
+	}
+
+	inline TVector3 normalise(void) const {
+		TVector3 result(x,y,z);
+
+		T fLength = length();
+		if (fLength > 0.0f) {
+			T invLength = 1.f / fLength;
+			result.x *= invLength;
+			result.y *= invLength;
+			result.z *= invLength;
+		}
+
+		return result;
+	}
+
+	inline TVector3& saturate(void) {
+		x = MathUtil::saturate(x);
+		y = MathUtil::saturate(y);
+		z = MathUtil::saturate(z);
+
+		return *this;
+	}
+
+public:
+	// special points
+	static DV_CORE_API const TVector3 ZERO;
+	static DV_CORE_API const TVector3 ONE;
+	static DV_CORE_API const TVector3 UNIT_X;
+	static DV_CORE_API const TVector3 UNIT_Y;
+	static DV_CORE_API const TVector3 UNIT_Z;
+	static DV_CORE_API const TVector3 NEGATIVE_UNIT_X;
+	static DV_CORE_API const TVector3 NEGATIVE_UNIT_Y;
+	static DV_CORE_API const TVector3 NEGATIVE_UNIT_Z;
+	static DV_CORE_API const TVector3 UNIT_SCALE;
+	static DV_CORE_API const TVector3 WHITE;
+	static DV_CORE_API const TVector3 BLACK;
+	static DV_CORE_API const TVector3 RED;
+	static DV_CORE_API const TVector3 GREEN;
+	static DV_CORE_API const TVector3 BLUE;
+	static DV_CORE_API const TVector3 PURPLE;
+	static DV_CORE_API const TVector3 GRAY;
+};
+
+typedef TVector3<float32_t> fVector3;
+
+DV_CORE_END_NAMESPACE

source/core/include/math/dvc_vector4.h

@@ -0,0 +1,249 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "dvc_pre_declare.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+template<typename T>
+class TVector4
+{
+public:
+	T x, y, z, w;
+
+public:
+	// Construct
+	TVector4() : x(0.f), y(0.f), z(0.f), w(0.f) { }
+	TVector4(T _x, T _y, T _z, T _w) : x(_x), y(_y), z(_z), w(_w){ }
+	TVector4(const TVector3<T>& _xyz, T _w) : x(_xyz.x), y(_xyz.y), z(_xyz.z), w(_w) { }
+	inline explicit TVector4(const T s) : x(s), y(s), z(s), w(s) { }
+	inline explicit TVector4(const T f[4]) : x(f[0]), y(f[1]), z(f[2]), w(f[3]) { }
+	inline explicit TVector4(T* const f) : x(f[0]), y(f[1]), z(f[2]), w(f[3]) { }
+	inline explicit TVector4(const int32_t f[4]) : x((T)f[0]), y((T)f[1]), z((T)f[2]), w((T)f[3]) { }
+	//inline explicit TVector4(const uint8_t* f)
+	//	: x((T)(f[0] / T(std::numeric_limits<uint8_t>::max())))
+	//	, y((T)(f[1] / T(std::numeric_limits<uint8_t>::max())))
+	//	, z((T)(f[2] / T(std::numeric_limits<uint8_t>::max())))
+	//	, w((T)(f[3] / T(std::numeric_limits<uint8_t>::max())))
+	//{
+	//}
+	//inline explicit TVector4(const uint16_t* f)
+	//	: x((T)(f[0] / T(std::numeric_limits<uint16_t>::max())))
+	//	, y((T)(f[1] / T(std::numeric_limits<uint16_t>::max())))
+	//	, z((T)(f[2] / T(std::numeric_limits<uint16_t>::max())))
+	//	, w((T)(f[3] / T(std::numeric_limits<uint16_t>::max())))
+	//{
+	//}
+public:
+	inline T operator [] (const size_t i) const {
+		assert(i < 4);
+		return *(&x + i);
+	}
+
+	inline T& operator [] (const size_t i) {
+		assert(i < 4);
+		return *(&x + i);
+	}
+
+	inline T* ptr(void) {
+		return &x;
+	}
+
+	inline const T* ptr(void) const {
+		return &x;
+	}
+
+	inline TVector3<T> xyz(void) const { return TVector3<T>(x, y, z); }
+
+public:
+	// Operations
+	inline TVector4& operator = (const TVector4& rkVector) {
+		x = rkVector.x;
+		y = rkVector.y;
+		z = rkVector.z;
+		w = rkVector.w;
+		return *this;
+	}
+
+	inline TVector4& operator = (const T fScalar) {
+		x = fScalar;
+		y = fScalar;
+		z = fScalar;
+		w = fScalar;
+		return *this;
+	}
+
+	inline bool operator == (const TVector4& rkVector) const {
+		return (x == rkVector.x && y == rkVector.y && z == rkVector.z && w == rkVector.w);
+	}
+
+	inline bool operator != (const TVector4& rkVector) const {
+		return (x != rkVector.x || y != rkVector.y || z != rkVector.z || w != rkVector.w);
+	}
+
+public:
+	// Arithmetic operations
+	inline TVector4 operator + (const TVector4& rkVector) const {
+		return TVector4( x + rkVector.x, y + rkVector.y, z + rkVector.z, w + rkVector.w);
+	}
+
+	inline TVector4 operator - (const TVector4& rkVector) const {
+		return TVector4( x - rkVector.x, y - rkVector.y, z - rkVector.z, w - rkVector.w);
+	}
+
+	inline TVector4 operator * (const T fScalar) const {
+		return TVector4( x * fScalar, y * fScalar, z * fScalar, w * fScalar);
+	}
+
+	inline TVector4 operator * (const TVector4& rhs) const {
+		return TVector4(x * rhs.x, y * rhs.y, z * rhs.z, w * rhs.w);
+	}
+
+	inline TVector4 operator / (const T fScalar) const {
+		assert(fScalar != 0.0);
+		return TVector4(x / fScalar, y / fScalar, z / fScalar, w / fScalar);
+	}
+
+	inline TVector4 operator / (const TVector4& rhs) const {
+		return TVector4( x / rhs.x, y / rhs.y, z / rhs.z, w / rhs.w);
+	}
+
+	inline const TVector4& operator + () const {
+		return *this;
+	}
+
+	inline TVector4 operator - () const {
+		return TVector4(-x, -y, -z, -w);
+	}
+
+public:
+	// overloaded operators to help TVector4
+	inline friend TVector4 operator * (const T fScalar, const TVector4& rkVector) {
+		return TVector4(fScalar * rkVector.x, fScalar * rkVector.y, fScalar * rkVector.z, fScalar * rkVector.w);
+	}
+
+	inline friend TVector4 operator / (const T fScalar, const TVector4& rkVector) {
+		return TVector4( fScalar / rkVector.x, fScalar / rkVector.y, fScalar / rkVector.z, fScalar / rkVector.w);
+	}
+
+	inline friend TVector4 operator + (const TVector4& lhs, const T rhs) {
+		return TVector4( lhs.x + rhs, lhs.y + rhs, lhs.z + rhs, lhs.w + rhs);
+	}
+
+	inline friend TVector4 operator + (const T lhs, const TVector4& rhs) {
+		return TVector4( lhs + rhs.x, lhs + rhs.y, lhs + rhs.z, lhs + rhs.w);
+	}
+
+	inline friend TVector4 operator - (const TVector4& lhs, const T rhs) {
+		return TVector4( lhs.x - rhs, lhs.y - rhs, lhs.z - rhs, lhs.w - rhs);
+	}
+
+	inline friend TVector4 operator - (const T lhs, const TVector4& rhs) {
+		return TVector4( lhs - rhs.x, lhs - rhs.y, lhs - rhs.z, lhs - rhs.z);
+	}
+
+public:
+	// arithmetic updates
+	inline TVector4& operator += (const TVector4& rkVector) {
+		x += rkVector.x;
+		y += rkVector.y;
+		z += rkVector.z;
+		w += rkVector.w;
+		return *this;
+	}
+
+	inline TVector4& operator += (const T fScaler) {
+		x += fScaler;
+		y += fScaler;
+		z += fScaler;
+		w += fScaler;
+		return *this;
+	}
+
+	inline TVector4& operator -= (const TVector4& rkVector) {
+		x -= rkVector.x;
+		y -= rkVector.y;
+		z -= rkVector.z;
+		w -= rkVector.w;
+		return *this;
+	}
+
+	inline TVector4& operator -= (const T fScaler) {
+		x -= fScaler;
+		y -= fScaler;
+		z -= fScaler;
+		w -= fScaler;
+		return *this;
+	}
+
+	inline TVector4& operator *= (const T fScalar) {
+		x *= fScalar;
+		y *= fScalar;
+		z *= fScalar;
+		w *= fScalar;
+		return *this;
+	}
+
+	inline TVector4& operator *= (const TVector4& rkVector) {
+		x *= rkVector.x;
+		y *= rkVector.y;
+		z *= rkVector.z;
+		w *= rkVector.w;
+		return *this;
+	}
+
+	inline TVector4& operator /= (const T fScalar) {
+		assert(fScalar != 0.0);
+
+		x /= fScalar;
+		y /= fScalar;
+		z /= fScalar;
+		w /= fScalar;
+		return *this;
+	}
+
+	inline TVector4& operator /= (const TVector4& rkVector) {
+		x /= rkVector.x;
+		y /= rkVector.y;
+		z /= rkVector.z;
+		w /= rkVector.w;
+		return *this;
+	}
+
+	inline bool operator < (const TVector4& rhs) const {
+		return (x < rhs.x && y < rhs.y && z < rhs.z && w < rhs.w);
+	}
+
+	inline bool operator > (const TVector4& rhs) const {
+		return (x > rhs.x && y > rhs.y && z > rhs.z && w > rhs.w);
+	}
+
+public:
+
+	inline T dotProduct(const TVector4& vec) const {
+		return (x * vec.x + y * vec.y) + (z * vec.z + w * vec.w);
+	}
+
+	inline TVector4& saturate(void) {
+		x = MathUtil::saturate(x);
+		y = MathUtil::saturate(y);
+		z = MathUtil::saturate(z);
+		w = MathUtil::saturate(w);
+
+		return *this;
+	}
+public:
+	// special points
+	static DV_CORE_API const TVector4 ZERO;
+	static DV_CORE_API const TVector4 WHITE;
+	static DV_CORE_API const TVector4 BLACK;
+	static DV_CORE_API const TVector4 RED;
+	static DV_CORE_API const TVector4 GREEN;
+	static DV_CORE_API const TVector4 BLUE;
+	static DV_CORE_API const TVector4 PURPLE;
+	static DV_CORE_API const TVector4 GRAY;
+};
+
+typedef TVector4<float32_t> fVector4;
+
+DV_CORE_END_NAMESPACE

source/core/include/pipe/dvc_rasterizer.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "math/dvc_vector2.h"
+#include "math/dvc_vector3.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+class DV_CORE_API Rasterizer
+{
+	//Draw Line
+public:
+	typedef std::function<void(const std::pair<int32_t, int32_t>&, float)> DrawLineCallback;
+
+	//Bresenham's line algorithm
+	static void drawLine(int32_t canvasWidth, int32_t canvasHeight, 
+		const fVector2& start, const fVector2& end, 
+		DrawLineCallback callback);
+
+	//Draw Triangle
+public:
+	typedef std::function<void(const std::pair<int32_t, int32_t>& pos, const fVector3& percent)> DrawTriangleCallback;
+
+	//Larrabee algorithm
+	static void drawTriangleLarrabee(int32_t canvasWidth, int32_t canvasHeight,
+		const fVector2& v0, const fVector2& v1, const fVector2& v2, 
+		DrawTriangleCallback callback, bool ccw=true);
+
+	//Scaleline algorithm
+	static void drawTriangleScanline(int32_t canvasWidth, int32_t canvasHeight,
+		const fVector3& v0, const fVector3& v1, const fVector3& v2,
+		DrawTriangleCallback callback);
+};
+
+DV_CORE_END_NAMESPACE

source/core/include/pipe/dvc_render_queue.h

@@ -0,0 +1,30 @@
+#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_step_IA.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "math/dvc_matrix4.h"
+#include "dvc_render_queue.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+class InputAssemberStep
+{
+public:
+	typedef std::map<VertexElementType, DeviceBufferAccessorConstPtr> PrimitiveAttributes;
+
+	struct Node
+	{
+		fMatrix4						transform;
+		PrimitiveType					primitiveType;
+		PrimitiveAttributes				vertexData;
+		DeviceBufferAccessorConstPtr	indices;
+		VertexShaderInterface*			vs;
+	};
+	typedef std::vector<Node> NodeArray;
+
+public:
+	void process(const RenderQueue& renderQueue);
+	const NodeArray& getNodes(void) const {
+		return m_nodes;
+	}
+
+protected:
+	NodeArray m_nodes;
+};
+
+
+DV_CORE_END_NAMESPACE

source/core/include/pipe/dvc_render_step_PS.h

@@ -0,0 +1,15 @@
+#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_render_step_VS.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "dvc_render_step_IA.h"
+#include "device/dvc_uniform_buffer.h"
+#include "device/dvc_vertex_desc.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+class VertexShaderStep
+{
+public:
+	struct Node
+	{
+		DeviceBufferPtr			vertexBuf;
+		VertexDesc				vertexDesc;
+		size_t					vertexCounts;
+		std::vector<float32_t>	depth;
+		std::vector<float32_t>	invZ;
+	};
+	typedef std::vector<Node> NodeArray;
+
+public:
+	const NodeArray& getNodes() const { 
+		return m_nodes; 
+	}
+
+public:
+	void process(UniformBuffer& uniformBuffer, const InputAssemberStep::NodeArray& assembedNodeArray);
+	
+protected:
+	NodeArray m_nodes;
+};
+
+DV_CORE_END_NAMESPACE

source/core/include/pipe/dvc_renderable.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "math/dvc_matrix4.h"
+#include "pipe/dvc_render_step_IA.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+class Renderable
+{
+public:
+	virtual bool buildAssemberNode(InputAssemberStep::Node& node) const = 0;
+
+protected:
+	fMatrix4 m_worldTransform;
+
+public:
+	Renderable(const fMatrix4& worldTransform);
+};
+
+DV_CORE_END_NAMESPACE

source/core/include/pipe/dvc_renderable_entity.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "dvc_renderable.h"
+#include "asset/dvc_mesh.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+class RenderableEntity : public Renderable
+{
+public:
+	virtual bool buildAssemberNode(InputAssemberStep::Node& node) const;
+
+protected:
+	Mesh::PrimitiveConstPtr m_primitive;
+
+public:
+	RenderableEntity(Mesh::PrimitiveConstPtr primitive, const fMatrix4& worldTransform);
+};
+
+DV_CORE_END_NAMESPACE

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

@@ -0,0 +1,52 @@
+#pragma once
+
+#include "dvc_component.h"
+#include "math/dvc_vector3.h"
+#include "math/dvc_matrix4.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+class DV_CORE_API CameraComponent : public SceneComponent
+{
+public:
+	struct CameraDefine
+	{
+		float32_t fov;
+		float32_t aspect;
+		float32_t nearClip;
+		float32_t farClip;
+	};
+public:
+	virtual const std::string& getTypeName() const { return typeName(); }
+	virtual void render(const fMatrix4& transParent, RenderQueue& queue) const;
+
+	fVector3 getEye(void) const;
+	fVector3 getLookat(void) const;
+	fVector3 getUp(void) const;
+
+	void setCameraDefine(const CameraDefine& cameraDefine);
+	CameraDefine getCameraDefine() const {
+		return m_cameraDefine;
+	}
+
+	const fMatrix4& getViewMatrix(void) const {
+		return m_viewMatrix;
+	}
+
+	const fMatrix4& getViewProjMatrix(void) const {
+		return m_viewProjMatrix;
+	}
+
+protected:
+	CameraDefine m_cameraDefine;
+	fMatrix4 m_viewMatrix;
+	fMatrix4 m_viewProjMatrix;
+
+public:
+	CameraComponent(SceneNodePtr owner);
+	virtual ~CameraComponent();
+
+	static const std::string& typeName();
+};
+
+DV_CORE_END_NAMESPACE

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

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "math/dvc_matrix4.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+class DV_CORE_API SceneComponent
+{
+public:
+	virtual const std::string& getTypeName() const = 0;
+	virtual void render(const fMatrix4& transParent, RenderQueue& queue) const;
+
+protected:
+	SceneNodePtr m_owner;
+
+public:
+	SceneComponent(SceneNodePtr owner);
+	virtual ~SceneComponent();
+};
+
+DV_CORE_END_NAMESPACE

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

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "dvc_component.h"
+#include "math/dvc_vector3.h"
+//#include 
+
+DV_CORE_BEGIN_NAMESPACE
+
+class DV_CORE_API LightComponent : public SceneComponent
+{
+public:
+	enum LightType
+	{
+		LT_Point,
+		LT_Directional,
+		LT_Spot,
+	};
+	struct LightDefine
+	{
+		LightType	type;
+		fVector3	color;		//default is "1.0, 1.0, 1.0"
+		float32_t	intensity;	//default is "1.0"
+		float32_t	range;		//default is "-1", means infinite
+
+		float32_t	innerConeAngle;	//only for spot light, default is 0
+		float32_t	outerConeAngle;	//only for spot light, default is PI/4.0
+	};
+public:
+	virtual const std::string& getTypeName() const { return typeName(); }
+	virtual void render(const fMatrix4& transParent, RenderQueue& queue) const;
+
+	void setLightDefine(const LightDefine& lightDefine);
+protected:
+	LightDefine m_define;
+
+public:
+	LightComponent(SceneNodePtr owner);
+	virtual ~LightComponent();
+
+	static const std::string& typeName();
+};
+
+DV_CORE_END_NAMESPACE

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

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "dvc_component.h"
+#include "dvc_pre_declare.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+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;
+
+	void setMesh(MeshConstPtr mesh);
+
+protected:
+	MeshConstPtr m_mesh;
+
+public:
+	MeshComponent(SceneNodePtr owner);
+	virtual ~MeshComponent();
+
+	static const std::string& typeName();
+};
+
+DV_CORE_END_NAMESPACE

source/core/include/scene/dvc_scene.h

@@ -0,0 +1,95 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "dvc_pre_declare.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+class DV_CORE_API Scene
+{
+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;
+
+public:
+	template<typename ComponentType>
+	SceneNodeConstPtr getNodeWithComponent(const char* name = nullptr) const
+	{
+		return getNodeWithComponent<ComponentType>(name, getRootSceneNode());
+	}
+
+	template<typename ComponentType>
+	SceneNodeConstPtr getNodeWithComponent(const char* name, SceneNodeConstPtr node) const
+	{
+		size_t counts = node->getChildCounts();
+		for (size_t i = 0; i < counts; i++)
+		{
+			SceneNodeConstPtr childNodePtr = node->getChild(i);
+			if (name != nullptr && childNodePtr->getName() != name)
+			{
+				continue;
+			}
+
+			std::shared_ptr<const ComponentType> component = childNodePtr->getComponent<ComponentType>();
+			if (component)
+			{
+				return childNodePtr;
+			}
+
+			//get from child
+			SceneNodeConstPtr cameraNode = getNodeWithComponent<ComponentType>(name, childNodePtr);
+			if (cameraNode != nullptr)
+			{
+				return cameraNode;
+			}
+		}
+		return nullptr;
+	}
+
+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();
+};
+
+DV_CORE_END_NAMESPACE

source/core/include/scene/dvc_scene_node.h

@@ -0,0 +1,73 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "math/dvc_matrix4.h"
+#include "math/dvc_vector3.h"
+#include "dvc_pre_declare.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+class DV_CORE_API SceneNode : public std::enable_shared_from_this<SceneNode>
+{
+public:
+	void clear(void);
+	void addChild(SceneNodePtr child);
+	void addComponent(SceneComponentPtr component);
+
+	void setName(const std::string& name);
+	const std::string& getName() const;
+
+	void setParent(SceneNodePtr parent);
+
+	void setTransform(const fMatrix4& transform);
+	const fMatrix4& getTransform() const {
+		return m_transform;
+	}
+	fMatrix4 getWorldTransform() const;
+
+	fVector3 getPosition() const;
+	fVector3 getWorldPosition() const;
+
+	size_t getChildCounts() const {
+		return m_childen.size();
+	}
+
+	SceneNodeConstPtr getChild(size_t index) const;
+
+	size_t getComponentCounts() const {
+		return m_componentArray.size();
+	}
+
+	SceneComponentConstPtr getComponent(size_t index) const;
+
+	template<typename T>
+	const std::shared_ptr<const T> getComponent() const
+	{
+		for (size_t i = 0; i < getComponentCounts(); i++)
+		{
+			auto component = getComponent(i);
+			if (component->getTypeName() == T::typeName())
+			{
+				return std::dynamic_pointer_cast<const T>(component);
+			}
+		}
+		return nullptr;
+	}
+
+public:
+	void buildRenderQueue(const fMatrix4& transParent, RenderQueue& queue);
+
+protected:
+	std::string m_name;
+	fMatrix4 m_transform;
+	SceneNodePtr m_parent;
+	SceneNodeArray m_childen;
+	SceneComponentArray m_componentArray;
+
+public:
+	SceneNode();
+	virtual ~SceneNode();
+};
+
+DV_CORE_END_NAMESPACE
+

source/core/include/shader/dvc_shader_interface.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "dvc_pre_declare.h"
+#include "math/dvc_vector3.h"
+#include "math/dvc_vector4.h"
+#include "device/dvc_vertex_desc.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+class VertexShaderInterface
+{
+public:
+	virtual const char* getName(void) const = 0;
+	virtual const VertexDesc& getOutputVertexDesc() const = 0;
+
+	typedef std::function<DeviceBufferAccessorConstPtr(VertexElementType)> SetInputAttributeFunc;
+	virtual void prepare(const UniformBuffer* uniformBuffer, SetInputAttributeFunc setInputAttributeFunc) = 0;
+
+	virtual void process(size_t index, void* outputVertex, fVector3& vertexWorldPos) = 0;
+};
+
+class PixelShaderInterface
+{
+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 void process(const VertexDesc& veretexDesc, const float32_t* pixelData, fVector4& color) = 0;
+};
+
+class ShaderFileInterface
+{
+public:
+	virtual VertexShaderInterface* getVertexShader(const char* szName) = 0;
+	virtual PixelShaderInterface* getPixelShader(const char* szName) = 0;
+};
+
+typedef ShaderFileInterface* (*ShaderFileInterfaceFunc)();
+
+DV_CORE_API ShaderFileInterface* LoadShaderFile(const char* szShaderFile);
+
+DV_CORE_END_NAMESPACE
+

source/core/source/asset/dvc_mesh.cpp

@@ -0,0 +1,31 @@
+#include "asset/dvc_mesh.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+Mesh::Mesh(const std::string& name)
+	: m_name(name)
+{
+}
+
+Mesh::~Mesh()
+{
+	m_primitiveArray.clear();
+}
+
+Mesh::PrimitivePtr Mesh::newPrimitive(void)
+{
+	PrimitivePtr primitive = std::make_shared<Primitive>();
+	m_primitiveArray.push_back(primitive);
+	return primitive;
+}
+
+Mesh::PrimitiveConstPtr Mesh::getPrimitive(int32_t index) const
+{
+	if (index < 0 || index >= m_primitiveArray.size())
+	{
+		return nullptr;
+	}
+	return m_primitiveArray[index];
+}
+
+DV_CORE_END_NAMESPACE

source/core/source/device/dvc_buffer.cpp

@@ -0,0 +1,43 @@
+#include "device/dvc_buffer.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+DeviceBuffer::DeviceBuffer()
+	: m_ptr(nullptr)
+	, m_length(0)
+{
+}
+
+DeviceBuffer::DeviceBuffer(size_t _length)
+	: m_ptr(nullptr)
+	, m_length(0)
+{
+	init(_length);
+}
+
+DeviceBuffer::~DeviceBuffer()
+{
+	clear();
+}
+
+void DeviceBuffer::init(size_t _length)
+{
+	assert(_length > 0);
+	clear();
+
+	m_ptr = (uint8_t*)malloc(_length);
+	memset(m_ptr, 0, _length);
+	m_length = _length;
+}
+
+void DeviceBuffer::clear(void)
+{
+	if (m_ptr) {
+		free(m_ptr);
+		m_ptr = nullptr;
+	}
+	m_length = 0;
+}
+
+DV_CORE_END_NAMESPACE
+

source/core/source/device/dvc_buffer_accessor.cpp

@@ -0,0 +1,93 @@
+#include "device/dvc_buffer_accessor.h"
+#include "math/dvc_math_util.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+DeviceBufferAccessor::DeviceBufferAccessor(DeviceBufferViewConstPtr bufferView, size_t offset, size_t count, ComponentType componentType, DataType dataType)
+	: m_bufferView(bufferView)
+	, m_offset(offset)
+	, m_count(count)
+	, m_componentType(componentType)
+	, m_dataType(dataType)
+{
+	m_elementSize = MathUtil::DataTypeSize(m_dataType) * MathUtil::ComponentSize(m_componentType);
+}
+
+DeviceBufferAccessor::~DeviceBufferAccessor()
+{
+	m_bufferView.reset();
+}
+
+void DeviceBufferAccessor::walk(std::function<bool(const uint8_t*, size_t)> callback, size_t start, size_t end) const
+{
+	assert(start < m_count);
+	assert((end == ((size_t)-1)) || (end>=start && end <=m_count));
+
+	DeviceBufferConstPtr buffer = m_bufferView->getBuffer();
+	const uint8_t* ptr = buffer->ptr(m_bufferView->getOffset()) + m_offset;
+
+	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)
+	{
+		if (callback(ptr, index))
+		{
+			break;
+		}
+	}
+}
+
+void DeviceBufferAccessor::walk2(std::function<bool(const uint8_t*, const uint8_t*, size_t)> callback, size_t start, size_t end) const
+{
+	assert(start < m_count);
+	assert((end == ((size_t)-1)) || (end >= start && end <= m_count));
+
+	DeviceBufferConstPtr buffer = m_bufferView->getBuffer();
+	const uint8_t* ptr = buffer->ptr(m_bufferView->getOffset()) + m_offset;
+
+	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)
+	{
+		if (callback(ptr, ((index + 1) < endIndex) ? (ptr + m_elementSize) : nullptr, index))
+		{
+			break;
+		}
+	}
+}
+
+void DeviceBufferAccessor::walk3(std::function<bool(const uint8_t*, const uint8_t*, const uint8_t*, size_t)> callback, size_t start, size_t end) const
+{
+	assert(start < m_count);
+	assert((end == ((size_t)-1)) || (end >= start && end <= m_count));
+
+	DeviceBufferConstPtr buffer = m_bufferView->getBuffer();
+	const uint8_t* ptr = buffer->ptr(m_bufferView->getOffset()) + m_offset;
+
+	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)
+	{
+		if(callback(ptr, 
+			((index + 1) < endIndex) ? (ptr + m_elementSize) : nullptr, 
+			((index + 2) < endIndex) ? (ptr + m_elementSize*2) : nullptr,
+			index))
+		{
+			break;
+		}
+	}
+}
+
+const uint8_t* DeviceBufferAccessor::getElement(size_t index) const
+{
+	if (index >= m_count) {
+		return nullptr;
+	}
+
+	DeviceBufferConstPtr buffer = m_bufferView->getBuffer();
+	const uint8_t* pData = buffer->ptr(m_bufferView->getOffset()) + m_offset + index * m_elementSize;
+
+	return pData;
+}
+
+DV_CORE_END_NAMESPACE

source/core/source/device/dvc_buffer_view.cpp

@@ -0,0 +1,21 @@
+#include "device/dvc_buffer_view.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+DeviceBufferView::DeviceBufferView(DeviceBufferConstPtr buffer, size_t offset, size_t length, size_t stride)
+	: m_buffer(buffer)
+	, m_offset(offset)
+	, m_length(length)
+	, m_stride(stride)
+{
+
+}
+
+DeviceBufferView::~DeviceBufferView()
+{
+	m_buffer.reset();
+	m_offset = m_length = m_stride = 0;
+}
+
+DV_CORE_END_NAMESPACE
+

source/core/source/device/dvc_pixel_buffer.cpp

@@ -0,0 +1,5 @@
+#include "device/dvc_pixel_buffer.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+DV_CORE_END_NAMESPACE

source/core/source/device/dvc_render_target.cpp

@@ -0,0 +1,34 @@
+#include "device/dvc_render_target.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+RenderTarget::RenderTarget()
+{
+}
+
+void RenderTarget::init(int32_t width, int32_t height)
+{
+	m_width = width;
+	m_height = height;
+	m_colorBuffer.init(width, height, fVector4::BLACK);
+	m_depthBuffer.init(width, height, std::numeric_limits<float32_t>::max());
+}
+
+void RenderTarget::clear()
+{
+	m_colorBuffer.clear(fVector4::BLACK);
+	m_depthBuffer.clear(std::numeric_limits<float32_t>::max());
+}
+
+void RenderTarget::setPixel(int32_t x, int32_t y, const fVector4& color, float32_t depth)
+{
+	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);
+}
+
+DV_CORE_END_NAMESPACE

source/core/source/device/dvc_uniform_buffer.cpp

@@ -0,0 +1,130 @@
+#include "device/dvc_uniform_buffer.h"
+#include "math/dvc_math_util.h"
+#include "scene/dvc_scene.h"
+#include "scene/dvc_scene_node.h"
+#include "scene/component/dvc_camera_component.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+void UniformBuffer::clear()
+{
+	for (AttributeMap::iterator it = m_attributeMap.begin(); it != m_attributeMap.end(); ++it)
+	{
+		AttributeValue& value = it->second;
+		freeMemory(value.value); value.value = nullptr;
+	}
+	m_attributeMap.clear();
+}
+
+void UniformBuffer::updateStandardAttribute(const Scene& scene)
+{
+	//Find main camera
+	davinci::SceneNodeConstPtr cameraNode = scene.getNodeWithComponent<CameraComponent>();
+	assert(cameraNode.get());
+
+	CameraComponentConstPtr camera = cameraNode->getComponent<CameraComponent>();
+	if (camera)
+	{
+		setAttribute("camera:eye_pos", camera->getEye());
+		setAttribute("camera:near", camera->getCameraDefine().nearClip);
+		setAttribute("camera:far", camera->getCameraDefine().farClip);
+		setAttribute("camera:view_mat", camera->getViewMatrix());
+		setAttribute("camera:view_proj_mat", camera->getViewProjMatrix());
+	}
+}
+
+void UniformBuffer::setAttribute(const std::string& name, ComponentType componentType, DataType dataType, const void* value)
+{
+	size_t valueSize = MathUtil::ComponentSize(componentType) * MathUtil::DataTypeSize(dataType);
+
+	AttributeMap::iterator it = m_attributeMap.find(name);
+	if (it != m_attributeMap.end())
+	{
+		if (it->second.componentType != componentType || it->second.dataType != dataType)
+		{
+			//TODO: error type
+			return;
+		}
+
+		memcpy(it->second.value, value, valueSize);
+		return;
+	}
+
+	//insert new value
+	AttributeValue newValue;
+	newValue.name = name;
+	newValue.componentType = componentType;
+	newValue.dataType = dataType;
+	newValue.value = mallocMemory(valueSize);
+	memcpy(newValue.value, value, valueSize);
+
+	m_attributeMap.insert(std::make_pair(name, newValue));
+}
+
+void UniformBuffer::setAttribute(const std::string& name, const int32_t& value)
+{
+	setAttribute(name, ComponentType::CT_Int32, DataType::DT_Scalar, &value);
+}
+
+void UniformBuffer::setAttribute(const std::string& name, const float32_t& value)
+{
+	setAttribute(name, ComponentType::CT_Float32, DataType::DT_Scalar, &value);
+}
+
+void UniformBuffer::setAttribute(const std::string& name, const fVector2& value)
+{
+	setAttribute(name, ComponentType::CT_Float32, DataType::DT_Vec2, &value);
+}
+
+void UniformBuffer::setAttribute(const std::string& name, const fVector3& value)
+{
+	setAttribute(name, ComponentType::CT_Float32, DataType::DT_Vec3, &value);
+}
+
+void UniformBuffer::setAttribute(const std::string& name, const fVector4& value)
+{
+	setAttribute(name, ComponentType::CT_Float32, DataType::DT_Vec4, &value);
+}
+
+void UniformBuffer::setAttribute(const std::string& name, const fMatrix3& value)
+{
+	setAttribute(name, ComponentType::CT_Float32, DataType::DT_Matrix3, &value);
+}
+
+void UniformBuffer::setAttribute(const std::string& name, const fMatrix4& value)
+{
+	setAttribute(name, ComponentType::CT_Float32, DataType::DT_Matrix4, &value);
+}
+
+void* UniformBuffer::getAttribute(const std::string& name) const
+{
+	AttributeMap::const_iterator it = m_attributeMap.find(name);
+	if (it == m_attributeMap.end())
+	{
+		return nullptr;
+	}
+	return it->second.value;
+}
+
+void UniformBuffer::removeAttribute(const std::string& name)
+{
+	AttributeMap::iterator it = m_attributeMap.find(name);
+	if (it != m_attributeMap.end())
+	{
+		freeMemory(it->second.value); it->second.value = nullptr;
+		m_attributeMap.erase(it);
+		return;
+	}
+}
+
+void* UniformBuffer::mallocMemory(size_t size)
+{
+	return malloc(size);
+}
+
+void UniformBuffer::freeMemory(void* memory)
+{
+	free(memory);
+}
+
+DV_CORE_END_NAMESPACE

source/core/source/device/dvc_vertex_desc.cpp

@@ -0,0 +1,107 @@
+#include "device/dvc_vertex_desc.h"
+#include "math/dvc_math_util.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+VertexDesc::VertexDesc() 
+	: m_vertexSize(0)
+{
+}
+
+VertexDesc::VertexDesc(const VertexDesc& other)
+{
+	m_elements = other.m_elements;
+	m_vertexSize = other.m_vertexSize;
+	m_elementTypeMap = other.m_elementTypeMap;
+	m_nameMap = other.m_nameMap;
+}
+
+bool VertexDesc::addElement(const std::string& name, VertexElementType elementType, ComponentType componentType, DataType dataType)
+{
+	bool defineType = (elementType != VertexElementType::VET_UNKNOWN);
+	bool defineName = (name.length() > 0);
+	assert(defineType || defineName);
+	if (!(defineType || defineName))
+	{
+		return false;
+	}
+
+	bool conflictType = defineType && (m_elementTypeMap.find(elementType) != m_elementTypeMap.end());
+	assert(!conflictType);
+	if (conflictType)
+	{
+		return false;
+	}
+
+	bool conflictName = defineName && (m_nameMap.find(name) != m_nameMap.end());
+	assert(!conflictName);
+	if (conflictName)
+	{
+		return false;
+	}
+
+	assert(componentType != ComponentType::CT_UNKNOWN);
+	if (componentType == ComponentType::CT_UNKNOWN)
+	{
+		return false;
+	}
+
+	assert(dataType != DataType::DT_UNKNOWN);
+	if (dataType == DataType::DT_UNKNOWN)
+	{
+		return false;
+	}
+
+	Element element;
+	element.name = name;
+	element.elementType = elementType;
+	element.componentType = componentType;
+	element.dataType = dataType;
+	element.offset = m_vertexSize;
+	element.size = MathUtil::DataTypeSize(element.dataType) * MathUtil::ComponentSize(element.componentType);
+
+	m_vertexSize += element.size;
+
+	if (defineType)
+	{
+		m_elementTypeMap.insert(std::make_pair(elementType, m_elements.size()));
+	}
+	if (defineName)
+	{
+		m_nameMap.insert(std::make_pair(name, m_elements.size()));
+	}
+
+	m_elements.push_back(element);
+	return true;
+}
+
+const VertexDesc::Element* VertexDesc::getElement(size_t index) const
+{
+	if (index >= m_elements.size())
+	{
+		return nullptr;
+	}
+	return &(m_elements[index]);
+}
+
+const VertexDesc::Element* VertexDesc::getElement(VertexElementType type) const
+{
+	auto it = m_elementTypeMap.find(type);
+	if (it == m_elementTypeMap.end())
+	{
+		return nullptr;
+	}
+	return getElement(it->second);
+}
+
+const VertexDesc::Element* VertexDesc::getElement(const std::string& name) const
+{
+	auto it = m_nameMap.find(name);
+	if (it == m_nameMap.end())
+	{
+		return nullptr;
+	}
+	return getElement(it->second);
+}
+
+DV_CORE_END_NAMESPACE

source/core/source/dvc_module.cpp

@@ -0,0 +1,7 @@
+#include "dv_config.h"
+#include "dvc_prerequisites.h"
+
+DV_CORE_API int foo()
+{
+	return 0;
+}

source/core/source/math/dvc_math_util.cpp

@@ -0,0 +1,72 @@
+#include "math/dvc_math_util.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+const float MathUtil::POS_INFINITY = std::numeric_limits<float>::infinity();
+const float MathUtil::NEG_INFINITY = -std::numeric_limits<float>::infinity();
+const float MathUtil::PI = float(4.0 * atan(1.0));
+const float MathUtil::PI_X2 = float(2.0 * PI);
+const float MathUtil::PI_DIV2 = float(0.5 * PI);
+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;
+
+size_t MathUtil::ComponentSize(ComponentType ct)
+{
+	switch (ct)
+	{
+	case CT_Int8:
+		return sizeof(int8_t);
+	case CT_Uint8:
+		return sizeof(uint8_t);
+	case CT_Int16:
+		return sizeof(int16_t);
+	case CT_Uint16:
+		return sizeof(uint16_t);
+	case CT_Int32:
+		return sizeof(int32_t);
+	case CT_Uint32:
+		return sizeof(uint32_t);
+	case CT_Float32:
+		return sizeof(float32_t);
+	case CT_Float64:
+		return sizeof(float64_t);
+	default:
+		break;
+	}
+
+	assert(false);
+	return 0;
+}
+
+size_t MathUtil::DataTypeSize(DataType dt)
+{
+	switch (dt)
+	{
+	case DT_Scalar:
+		return 1;
+	case DT_Vec2:
+		return 2;
+	case DT_Vec3:
+		return 3;
+	case DT_Vec4:
+		return 4;
+	case DT_Matrix2:
+		return 4;
+	case DT_Matrix3:
+		return 9;
+	case DT_Matrix4:
+		return 16;
+	default:
+		break;
+	}
+	assert(false);
+	return 0;
+}
+
+float MathUtil::unitRandom(void)
+{
+	return float(rand()) / RAND_MAX;
+}
+
+DV_CORE_END_NAMESPACE

source/core/source/math/dvc_matrix3.cpp

@@ -0,0 +1,9 @@
+#include "math/dvc_matrix3.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+const fMatrix3 fMatrix3::ZERO(0, 0, 0, 0, 0, 0, 0, 0, 0);
+const fMatrix3 fMatrix3::IDENTITY(1, 0, 0, 0, 1, 0, 0, 0, 1);
+
+DV_CORE_END_NAMESPACE
+

source/core/source/math/dvc_matrix4.cpp

@@ -0,0 +1,9 @@
+#include "math/dvc_matrix4.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+const fMatrix4 fMatrix4::ZERO(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+const fMatrix4 fMatrix4::IDENTITY(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
+
+DV_CORE_END_NAMESPACE
+

source/core/source/math/dvc_vector2.cpp

@@ -0,0 +1,15 @@
+#include "math/dvc_vector2.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+const fVector2 fVector2::ZERO(0, 0);
+const fVector2 fVector2::ONE(0, 0);
+const fVector2 fVector2::UNIT_X(1, 0);
+const fVector2 fVector2::UNIT_Y(0, 1);
+const fVector2 fVector2::NEGATIVE_UNIT_X(-1, 0);
+const fVector2 fVector2::NEGATIVE_UNIT_Y(0, -1);
+const fVector2 fVector2::UNIT_SCALE(1, 1);
+
+DV_CORE_END_NAMESPACE
+
+

source/core/source/math/dvc_vector3.cpp

@@ -0,0 +1,24 @@
+#include "math/dvc_vector3.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+const fVector3 fVector3::ZERO(0, 0, 0);
+const fVector3 fVector3::ONE(1, 1, 1);
+const fVector3 fVector3::UNIT_X(1, 0, 0);
+const fVector3 fVector3::UNIT_Y(0, 1, 0);
+const fVector3 fVector3::UNIT_Z(0, 0, 1);
+const fVector3 fVector3::NEGATIVE_UNIT_X(-1, 0, 0);
+const fVector3 fVector3::NEGATIVE_UNIT_Y(0, -1, 0);
+const fVector3 fVector3::NEGATIVE_UNIT_Z(0, 0, -1);
+const fVector3 fVector3::UNIT_SCALE(1, 1, 1);
+const fVector3 fVector3::WHITE(1, 1, 1);
+const fVector3 fVector3::BLACK(0, 0, 0);
+const fVector3 fVector3::RED(1, 0, 0);
+const fVector3 fVector3::GREEN(0, 1, 0);
+const fVector3 fVector3::BLUE(0, 0, 1);
+const fVector3 fVector3::PURPLE(1, 0, 1);
+const fVector3 fVector3::GRAY(0.5f, 0.5f, 0.5f);
+
+DV_CORE_END_NAMESPACE
+
+

source/core/source/math/dvc_vector4.cpp

@@ -0,0 +1,16 @@
+#include "math/dvc_vector4.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+
+const fVector4 fVector4::ZERO(0, 0, 0, 0);
+const fVector4 fVector4::WHITE(1, 1, 1, 1);
+const fVector4 fVector4::BLACK(0, 0, 0, 1);
+const fVector4 fVector4::RED(1, 0, 0, 1);
+const fVector4 fVector4::GREEN(0, 1, 0, 1);
+const fVector4 fVector4::BLUE(0, 0, 1, 1);
+const fVector4 fVector4::PURPLE(1, 0, 1, 1);
+const fVector4 fVector4::GRAY(0.5f, 0.5f, 0.5f, 1);
+
+DV_CORE_END_NAMESPACE
+

source/core/source/pipe/dvc_rasterizer_triangle.cpp

@@ -0,0 +1,496 @@
+#include "pipe/dvc_rasterizer.h"
+#include "math/dvc_fixmath.h"
+#include "math/dvc_math_util.h"
+
+/*
+https://github.com/nlguillemot/vigilant-system
+https://wiki.joak.org/public:cs:rasterization_on_larrabee
+*/
+
+DV_CORE_BEGIN_NAMESPACE
+
+//-------------------------------------------------------------------------------------
+struct DrawTriangleParam
+{
+	int32_t		widthInTiles;
+	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;
+	bool		tlBorder[3];
+	float32_t	area;
+	ifloat3_t	edgesDX, edgesDY;
+};
+
+//-------------------------------------------------------------------------------------
+enum { TILE_WIDTH_IN_PIXELS = 64, COARSE_BLOCK_WIDTH_IN_PIXELS = 16, FINE_BLOCK_WIDTH_IN_PIXELS = 4 };
+
+//-------------------------------------------------------------------------------------
+void _drawTriangle_Fine(int32_t tile_id, int32_t coarse_id, int32_t fine_id,
+	const DrawTriangleParam& param, const ifloat3_t& edges0, uint32_t testEdgeMask, 
+	Rasterizer::DrawTriangleCallback callback)
+{
+	ifloat3_t pixelEdges(edges0);
+
+	const fVector2 v0(param.verts[0]), v1(param.verts[1]), v2(param.verts[2]);
+	const bool edgeMask[3] = { (testEdgeMask & 1) != 0 , (testEdgeMask & 2) != 0 , (testEdgeMask & 4) != 0 };
+
+	int32_t fine_start_x = (tile_id % param.widthInTiles) * TILE_WIDTH_IN_PIXELS 
+		+ (coarse_id % 4) * COARSE_BLOCK_WIDTH_IN_PIXELS + (fine_id % 4) * FINE_BLOCK_WIDTH_IN_PIXELS;
+
+	int32_t fine_start_y = (tile_id / param.widthInTiles) * TILE_WIDTH_IN_PIXELS 
+		+ (coarse_id / 4) * COARSE_BLOCK_WIDTH_IN_PIXELS + (fine_id / 4)*FINE_BLOCK_WIDTH_IN_PIXELS;
+
+	for (int32_t y_index=0, y= fine_start_y; y_index < 4; y_index++, y++) 
+	{
+		ifloat3_t edgesRow(pixelEdges);
+
+		for (int32_t x_index = 0, x=fine_start_x; x_index < 4; x_index++, x++) 
+		{
+			bool rejected =
+				(edgeMask[0] && (edgesRow.x < 0 || (!param.tlBorder[0] && edgesRow.x == 0))) ||
+				(edgeMask[1] && (edgesRow.y < 0 || (!param.tlBorder[1] && edgesRow.y == 0))) ||
+				(edgeMask[2] && (edgesRow.z < 0 || (!param.tlBorder[2] && edgesRow.z == 0)));
+					
+			if (!rejected) 
+			{
+				fVector2 pixel(x + 0.5f, y + 0.5f);
+
+				float32_t w0 = (v2 - v1).crossProduct(pixel - v2);
+				float32_t w1 = (v0 - v2).crossProduct(pixel - v0);
+				float32_t w2 = (v1 - v0).crossProduct(pixel - v1);
+
+				fVector3 t = fVector3(w0 / param.area, (param.ccw ? w1 : w2) / param.area, (param.ccw ? w2 : w1) / param.area);
+
+				callback(std::make_pair(x, y), t);
+			}
+			edgesRow.sub(param.edgesDY);
+		}
+		pixelEdges.add(param.edgesDX);
+	}
+}
+
+//-------------------------------------------------------------------------------------
+void _drawTriangle_Coarse(int32_t tile_id, int32_t coarse_id,
+	DrawTriangleParam& param, const ifloat3_t& edges0, uint32_t testEdgeMask, 
+	Rasterizer::DrawTriangleCallback callback)
+{
+	const ifloat3_t blockEdgesDX(
+		param.edgesDX.x * FINE_BLOCK_WIDTH_IN_PIXELS, 
+		param.edgesDX.y * FINE_BLOCK_WIDTH_IN_PIXELS, 
+		param.edgesDX.z * FINE_BLOCK_WIDTH_IN_PIXELS 
+	);
+	const ifloat3_t blockEdgesDY(
+		param.edgesDY.x * FINE_BLOCK_WIDTH_IN_PIXELS,
+		param.edgesDY.y * FINE_BLOCK_WIDTH_IN_PIXELS, 
+		param.edgesDY.z * FINE_BLOCK_WIDTH_IN_PIXELS 
+	);
+	const bool edgeMask[3] = { (testEdgeMask & 1) != 0 , (testEdgeMask & 2) != 0 , (testEdgeMask & 4) != 0 };
+
+	ifloat3_t blockReject(edges0);
+	ifloat3_t blockAccept(edges0);
+	ifloat3_t blockEdges(edges0);
+
+	for (size_t v = 0; v < 3; v++) 
+	{
+		if (edgeMask[v])
+		{	
+			if (blockEdgesDX[v] > 0) blockReject[v] += blockEdgesDX[v];
+			else if (blockEdgesDX[v] < 0) blockAccept[v] += blockEdgesDX[v];
+
+			if (blockEdgesDY[v] > 0) blockAccept[v] -= blockEdgesDY[v];
+			else if (blockEdgesDY[v] < 0) blockReject[v] -= blockEdgesDY[v];
+		}
+	}
+
+	int32_t block_start_x = (tile_id % param.widthInTiles) * TILE_WIDTH_IN_PIXELS + (coarse_id % 4) * COARSE_BLOCK_WIDTH_IN_PIXELS;
+	int32_t block_start_y = (tile_id / param.widthInTiles) * TILE_WIDTH_IN_PIXELS + (coarse_id / 4) * COARSE_BLOCK_WIDTH_IN_PIXELS;
+
+	for (int32_t y_index = 0; y_index < 4; y_index++) 
+	{
+		if (block_start_y + y_index * FINE_BLOCK_WIDTH_IN_PIXELS > param.bbox_max_y)
+		{
+			break;
+		}
+
+		if (block_start_y + (y_index + 1)*FINE_BLOCK_WIDTH_IN_PIXELS >= param.bbox_min_y) 
+		{
+			ifloat3_t edgesRow(blockEdges);
+			ifloat3_t edgesRowReject, edgesRowAccept;
+
+			for (size_t v = 0; v < 3; v++) 
+			{
+				if (edgeMask[v])
+				{
+					edgesRowReject[v] = blockReject[v];
+					edgesRowAccept[v] = blockAccept[v];
+				}
+			}
+			for (int32_t x_index = 0; x_index < 4; x_index++) 
+			{
+				if (block_start_x + x_index * FINE_BLOCK_WIDTH_IN_PIXELS > param.bbox_max_x) break;
+				if (block_start_x + (x_index + 1)*FINE_BLOCK_WIDTH_IN_PIXELS >= param.bbox_min_x) 
+				{
+					bool rejected = 
+						(edgeMask[0] && (edgesRowReject[0] < 0 || (!param.tlBorder[0] && edgesRowReject[0] == 0))) ||
+						(edgeMask[1] && (edgesRowReject[1] < 0 || (!param.tlBorder[1] && edgesRowReject[1] == 0))) ||
+						(edgeMask[2] && (edgesRowReject[2] < 0 || (!param.tlBorder[2] && edgesRowReject[2] == 0)));
+
+					if (!rejected) 
+					{
+						uint32_t newTestEdgeMask = testEdgeMask;
+						for (size_t v = 0; v < 3; v++) 
+						{
+							if (edgeMask[v])
+							{
+								if (edgesRowAccept[v] > 0 || (edgesRowAccept[v] == 0 && param.tlBorder[v])) 
+								{
+									newTestEdgeMask &= ~(1 << v);
+								}
+							}
+						}
+
+						_drawTriangle_Fine(tile_id, coarse_id, y_index * 4 + x_index, param, edgesRow, newTestEdgeMask, callback);
+					}
+				}
+
+				edgesRow.sub(blockEdgesDY);
+				for (size_t v = 0; v < 3; v++) 
+				{
+					if (edgeMask[v])
+					{
+						edgesRowReject[v] -= blockEdgesDY[v];
+						edgesRowAccept[v] -= blockEdgesDY[v];
+					}
+				}
+			}
+		}
+
+		blockEdges.add(blockEdgesDX);
+		for (size_t v = 0; v < 3; v++) 
+		{
+			if (edgeMask[v])
+			{
+				blockReject[v] += blockEdgesDX[v];
+				blockAccept[v] += blockEdgesDX[v];
+			}
+		}
+	}
+}
+
+//-------------------------------------------------------------------------------------
+void _drawTriangle_Title(int32_t tile_id,
+	DrawTriangleParam& param, const ifloat3_t& edges0, uint32_t testEdgeMask, 
+	Rasterizer::DrawTriangleCallback callback)
+{
+	const ifloat3_t blockEdgesDX( 
+		param.edgesDX[0] * COARSE_BLOCK_WIDTH_IN_PIXELS, 
+		param.edgesDX[1] * COARSE_BLOCK_WIDTH_IN_PIXELS,
+		param.edgesDX[2] * COARSE_BLOCK_WIDTH_IN_PIXELS
+	);
+
+	const ifloat3_t blockEdgesDY(
+		param.edgesDY[0] * COARSE_BLOCK_WIDTH_IN_PIXELS, 
+		param.edgesDY[1] * COARSE_BLOCK_WIDTH_IN_PIXELS, 
+		param.edgesDY[2] * COARSE_BLOCK_WIDTH_IN_PIXELS 
+	);
+	const bool edgeMask[3] = { (testEdgeMask & 1) != 0 , (testEdgeMask & 2) != 0 , (testEdgeMask & 4) != 0 };
+
+	ifloat3_t blockReject(edges0);
+	ifloat3_t blockAccept(edges0);
+	ifloat3_t blockEdges(edges0);
+
+	for (size_t v = 0; v < 3; v++) 
+	{
+		if (edgeMask[v])
+		{
+			if (blockEdgesDX[v] > 0) blockReject[v] += blockEdgesDX[v];
+			else if (blockEdgesDX[v] < 0) blockAccept[v] += blockEdgesDX[v];
+
+			if (blockEdgesDY[v] > 0) blockAccept[v] -= blockEdgesDY[v];
+			else if (blockEdgesDY[v] < 0) blockReject[v] -= blockEdgesDY[v];
+		}
+	}
+
+	int32_t block_start_x = (tile_id % param.widthInTiles) * TILE_WIDTH_IN_PIXELS;
+	int32_t block_start_y = (tile_id / param.widthInTiles) * TILE_WIDTH_IN_PIXELS;
+
+	for (int32_t y_index = 0; y_index < 4; y_index++) 
+	{
+		if (block_start_y + y_index * COARSE_BLOCK_WIDTH_IN_PIXELS > param.bbox_max_y)
+		{
+			break;
+		}
+
+		if (block_start_y + (y_index + 1)*COARSE_BLOCK_WIDTH_IN_PIXELS >= param.bbox_min_y) 
+		{
+			ifloat3_t edges(blockEdges);
+			ifloat3_t edgesRowReject, edgesRowAccept;
+
+			for (size_t v = 0; v < 3; v++) 
+			{
+				if (edgeMask[v])
+				{
+					edgesRowReject[v] = blockReject[v];
+					edgesRowAccept[v] = blockAccept[v];
+				}
+			}
+
+			for (int32_t x_index = 0; x_index < 4; x_index++) 
+			{
+				if (block_start_x + x_index * COARSE_BLOCK_WIDTH_IN_PIXELS > param.bbox_max_x)
+				{
+					break;
+				}
+
+				if (block_start_x + (x_index + 1)*COARSE_BLOCK_WIDTH_IN_PIXELS >= param.bbox_min_x) 
+				{
+					bool rejected = 
+						(edgeMask[0] && (edgesRowReject[0] < 0 || (!param.tlBorder[0] && edgesRowReject[0] == 0))) ||
+						(edgeMask[1] && (edgesRowReject[1] < 0 || (!param.tlBorder[1] && edgesRowReject[1] == 0))) ||
+						(edgeMask[2] && (edgesRowReject[2] < 0 || (!param.tlBorder[2] && edgesRowReject[2] == 0)));
+
+					if (!rejected) 
+					{
+						uint32_t newTestEdgeMask = testEdgeMask;
+						for (size_t v = 0; v < 3; v++) 
+						{
+							if (edgeMask[v])
+							{
+								if (edgesRowAccept[v] > 0 || (edgesRowAccept[v] == 0 && param.tlBorder[v])) 
+								{
+									newTestEdgeMask &= ~(1 << v);
+								}
+							}
+						}
+
+						_drawTriangle_Coarse(tile_id, y_index * 4 + x_index, param, edges, newTestEdgeMask, callback);
+					}
+				}
+
+				edges.sub(blockEdgesDY);
+
+				for (size_t v = 0; v < 3; v++) 
+				{
+					if (edgeMask[v])
+					{
+						edgesRowReject[v] -= blockEdgesDY[v];
+						edgesRowAccept[v] -= blockEdgesDY[v];
+					}
+				}
+			}
+		}
+
+		blockEdges.add(blockEdgesDX);
+		for (size_t v = 0; v < 3; v++) 
+		{
+			if (edgeMask[v])
+			{
+				blockReject[v] += blockEdgesDX[v];
+				blockAccept[v] += blockEdgesDX[v];
+			}
+		}
+	}
+}
+
+//-------------------------------------------------------------------------------------
+void Rasterizer::drawTriangleLarrabee(int32_t canvasWidth, int32_t canvasHeight, 
+	const fVector2& v0, const fVector2& v1, const fVector2& v2, 
+	DrawTriangleCallback callback, bool ccw)
+{
+	assert(canvasWidth >= TILE_WIDTH_IN_PIXELS && canvasHeight >= TILE_WIDTH_IN_PIXELS);
+	assert(canvasWidth%TILE_WIDTH_IN_PIXELS == 0 && canvasHeight%TILE_WIDTH_IN_PIXELS == 0);
+
+	DrawTriangleParam param;
+	param.widthInTiles = canvasWidth / TILE_WIDTH_IN_PIXELS;
+
+	//ccw
+	bool isCCW = (v1 - v0).crossProduct(v2 - v1)>0;
+	if (isCCW != ccw) return;
+
+	param.ccw = ccw;
+	param.verts[0] = v0;
+	param.verts[1] = ccw ? v1 : v2;
+	param.verts[2] = ccw ? v2 : v1;
+	param.area = (param.verts[1] - param.verts[0]).crossProduct(param.verts[2] - param.verts[1]);
+
+	ifloat2_t vertices[3];
+	for (size_t i = 0; i < 3; i++) 
+	{
+		vertices[i] = ifloat2_t(param.verts[i].x, param.verts[i].y);
+	}
+
+	//get window coordinates bounding box
+	param.bbox_min_x = MathUtil::min3(v0.x, v1.x, v2.x);
+	param.bbox_max_x = MathUtil::max3(v0.x, v1.x, v2.x);
+	param.bbox_min_y = MathUtil::min3(v0.y, v1.y, v2.y);
+	param.bbox_max_y = MathUtil::max3(v0.y, v1.y, v2.y);
+
+	//canvas size
+	ifloat_t iCanvasWidth = ifloat_init(canvasWidth);
+	ifloat_t iCanvasHeight = ifloat_init(canvasHeight);
+
+	// clip triangles that are fully outside the scissor rect (scissor rect = whole window)
+	if (param.bbox_max_x < 0 || param.bbox_max_y < 0 || param.bbox_min_x >= canvasWidth || param.bbox_min_y >= canvasHeight) 
+	{
+		return;
+	}
+	if (param.bbox_min_x < 0) param.bbox_min_x = 0;
+	if (param.bbox_min_y < 0) param.bbox_min_y = 0;
+	if (param.bbox_max_x > canvasWidth - 1.f) param.bbox_max_x = canvasWidth - 1.f;
+	if (param.bbox_max_y > canvasHeight - 1.f) param.bbox_max_y = canvasHeight - 1.f;
+
+	// tile range
+	int32_t first_tile_x = (int32_t)(param.bbox_min_x / TILE_WIDTH_IN_PIXELS);
+	int32_t first_tile_y = (int32_t)(param.bbox_min_y / TILE_WIDTH_IN_PIXELS);
+	int32_t last_tile_x = (int32_t)(param.bbox_max_x / TILE_WIDTH_IN_PIXELS);
+	int32_t last_tile_y = (int32_t)(param.bbox_max_y / TILE_WIDTH_IN_PIXELS);
+
+	// evaluate edge equation at the top left tile
+	ifloat_t firstTileX = first_tile_x * ifloat_init(TILE_WIDTH_IN_PIXELS);
+	ifloat_t firstTileY = first_tile_y * ifloat_init(TILE_WIDTH_IN_PIXELS);
+
+	ifloat3_t edges0;
+	ifloat3_t tileEdgesDX, tileEdgesDY, edgesReject, edgesAccept;
+	const ifloat_t kZeroPointFive = ifloat_init(0.5f);
+
+	for (size_t v = 0; v < 3; v++)
+	{
+		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;
+
+		tileEdgesDX[v] = param.edgesDX[v] * TILE_WIDTH_IN_PIXELS;
+		tileEdgesDY[v] = param.edgesDY[v] * TILE_WIDTH_IN_PIXELS;
+
+		//(V0,V1) X (V0, P) = (x1-x0)(py-y0)-(y1-y0)(px-x0)
+		edges0[v] = ifloat_multiply(param.edgesDX[v], (firstTileY + kZeroPointFive - vertices[v].y))
+				  - ifloat_multiply(param.edgesDY[v], (firstTileX + kZeroPointFive - vertices[v].x));
+
+		// Top-left rule: 
+		//   shift top-left edges ever so slightly outward to make the top-left edges be 
+		//   the tie-breakers when rasterizing adjacent triangles
+		if ((vertices[v_end].y == vertices[v].y && vertices[v_end].x < vertices[v].x) ||
+			vertices[v_end].y < vertices[v].y)
+		{
+			param.tlBorder[v] = true;
+		}
+		else
+		{
+			param.tlBorder[v] = false;
+		}
+
+		edgesReject[v] = edgesAccept[v] = edges0[v];
+
+		if (tileEdgesDX[v] > 0) edgesReject[v] += tileEdgesDX[v];
+		else if (tileEdgesDX[v] < 0) edgesAccept[v] += tileEdgesDX[v];
+
+		if (tileEdgesDY[v] > 0) edgesAccept[v] -= tileEdgesDY[v];
+		else if (tileEdgesDY[v] < 0) edgesReject[v] -= tileEdgesDY[v];
+	}
+
+	ifloat3_t rowEdges(edges0);
+
+	int32_t tile_row_start = first_tile_y * param.widthInTiles + first_tile_x;
+	for (int32_t tile_y = first_tile_y; tile_y <= last_tile_y; tile_y++)
+	{
+		ifloat3_t edges(rowEdges);
+		ifloat3_t tileEdgesReject(edgesReject);
+		ifloat3_t tileEdgesAccept(edgesAccept);
+
+		int32_t tile_i = tile_row_start;
+		for (int32_t tile_x = first_tile_x; tile_x <= last_tile_x; tile_x++) 
+		{
+			bool rejected =
+				((tileEdgesReject[0] < 0 || (!param.tlBorder[0] && tileEdgesReject[0] == 0))) ||
+				((tileEdgesReject[1] < 0 || (!param.tlBorder[1] && tileEdgesReject[1] == 0))) ||
+				((tileEdgesReject[2] < 0 || (!param.tlBorder[2] && tileEdgesReject[2] == 0)));
+
+			if (!rejected) 
+			{
+				//draw title
+				uint32_t testEdgeMask = 0;
+				for (size_t v = 0; v < 3; v++) 
+				{
+					if (tileEdgesAccept[v] < 0 || (tileEdgesAccept[v] == 0 && !param.tlBorder[v])) 
+					{
+						testEdgeMask += (1 << v);
+					}
+				}
+
+				_drawTriangle_Title(tile_i, param, edges, testEdgeMask, callback);
+			}
+
+			//x setp
+			edges.sub(tileEdgesDY);
+			tileEdgesReject.sub(tileEdgesDY);
+			tileEdgesAccept.sub(tileEdgesDY);
+			tile_i++;
+		}
+
+		//y step
+		rowEdges.add(tileEdgesDX);
+		edgesReject.add(tileEdgesDX);
+		edgesAccept.add(tileEdgesDX);
+		tile_row_start += param.widthInTiles;
+	}
+}
+
+//-------------------------------------------------------------------------------------
+void Rasterizer::drawTriangleScanline(int32_t canvasWidth, int32_t canvasHeight, const fVector3& v0, const fVector3& v1, const fVector3& v2, DrawTriangleCallback callback)
+{
+#if 0
+	//back cull
+	fVector3 edge0 = v2 - v1;
+	fVector3 edge1 = v0 - v2;
+	fVector3 vnormal = edge0.crossProduct(edge1);
+	if (vnormal.z > 0) return;
+
+	fVector3 edge2 = v1 - v0;
+
+	float xmin = MathUtil::min3(v0.x, v1.x, v2.x);
+	float ymin = MathUtil::min3(v0.y, v1.y, v2.y);
+	float xmax = MathUtil::max3(v0.x, v1.x, v2.x);
+	float ymax = MathUtil::max3(v0.y, v1.y, v2.y);
+
+	float area = _edge(v0, v1, v2);
+
+	int32_t x0 = MathUtil::max2(0, (int32_t)std::floor(xmin));
+	int32_t x1 = MathUtil::min2(canvasWidth - 1, (int32_t)std::floor(xmax));
+	int32_t y0 = MathUtil::max2(0, (int32_t)std::floor(ymin));
+	int32_t y1 = MathUtil::min2(canvasHeight - 1, (int32_t)std::floor(ymax));
+
+	for (int32_t y = y0; y <= y1; y++) {
+		for (int32_t x = x0; x <= x1; x++) {
+
+			fVector3 pixel(x + 0.5f, y + 0.5f, 0.f);
+
+			bool overlaps = true;
+
+			float w0 = _edge(v1, v2, pixel);
+			overlaps &= (w0 == 0 ? ((edge0.y == 0 && edge0.x > 0) || edge0.y > 0) : (w0 > 0));
+			if (!overlaps) continue;
+
+			float w1 = _edge(v2, v0, pixel);
+			overlaps &= (w1 == 0 ? ((edge1.y == 0 && edge1.x > 0) || edge1.y > 0) : (w1 > 0));
+			if (!overlaps) continue;
+
+			float w2 = _edge(v0, v1, pixel);
+			overlaps &= (w2 == 0 ? ((edge2.y == 0 && edge2.x > 0) || edge2.y > 0) : (w2 > 0));
+			if (!overlaps) continue;
+
+
+			fVector3 t = fVector3(w0 / area, w1 / area, w2 / area);
+
+			float invZ = MathUtil::lerp3(v0.z, v1.z, v2.z, t);
+			t *= fVector3(v0.z / invZ, v1.z / invZ, v2.z / invZ);
+
+			callback(std::make_pair(x, y), t);
+		}
+	}
+#endif
+}
+
+DV_CORE_END_NAMESPACE

source/core/source/pipe/dvc_render_queue.cpp

@@ -0,0 +1,56 @@
+#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_step_IA.cpp

@@ -0,0 +1,25 @@
+#include "pipe/dvc_render_step_IA.h"
+#include "pipe/dvc_renderable.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+void InputAssemberStep::process(const RenderQueue& renderQueue)
+{
+	size_t counts = renderQueue.getRenderableCounts();
+	for (size_t i = 0; i < counts; i++)
+	{
+		RenderableConstPtr renderable = renderQueue.getRenderable(i);
+		if (renderable)
+		{
+			Node node;
+			if (!(renderable->buildAssemberNode(node)))
+			{
+				continue;
+			}
+
+			m_nodes.push_back(node);
+		}
+	}
+}
+
+DV_CORE_END_NAMESPACE

source/core/source/pipe/dvc_render_step_PS.cpp

@@ -0,0 +1,75 @@
+#include "pipe/dvc_render_step_PS.h"
+#include "shader/dvc_shader_interface.h"
+#include "device/dvc_buffer.h"
+#include "pipe/dvc_rasterizer.h"
+#include "math/dvc_math_util.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+void PixelShaderStep::process(const VertexShaderStep::NodeArray& vsNodeArray, RenderTarget& renderTarget)
+{
+	ShaderFileInterface* shaderInterface = davinci::LoadShaderFile("TestShader.dll");
+	PixelShaderInterface* pixelShader = shaderInterface->getPixelShader("xxx");
+
+	int32_t targetWidth = renderTarget.getWidth();
+	int32_t targetHeight = renderTarget.getHeight();
+
+	fMatrix4 view_trans =
+		fMatrix4::makeTrans(targetWidth / 2.f, targetHeight / 2.f, 0.f) *
+		fMatrix4::makeScale(targetWidth / 2.f, targetHeight / 2.f, 1.f);
+
+	VertexShaderStep::NodeArray::const_iterator it, end = vsNodeArray.end();
+	for (it = vsNodeArray.begin(); it != end; ++it)
+	{
+		const VertexShaderStep::Node& node = *it;
+
+		size_t vertexSize = node.vertexDesc.vertexByteSize();
+		size_t POS_offset = node.vertexDesc.getElement(VET_POSITION)->offset;
+
+		for (size_t i = 0; i < node.vertexCounts; i += 3) 
+		{
+			const float32_t* vertex0 = (const float32_t*)(node.vertexBuf->ptr(i * vertexSize));
+			const float32_t* vertex1 = (const float32_t*)(node.vertexBuf->ptr((i+1) * vertexSize));
+			const float32_t* vertex2 = (const float32_t*)(node.vertexBuf->ptr((i+2) * vertexSize));
+
+			fVector3 pos0 = view_trans * (*(const fVector3*)(vertex0 + POS_offset));
+			fVector3 pos1 = view_trans * (*(const fVector3*)(vertex1 + POS_offset));
+			fVector3 pos2 = view_trans * (*(const fVector3*)(vertex2 + POS_offset));
+
+			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)
+				{
+					fVector3 percentCorrected(percent);
+
+					float temp = MathUtil::lerp3(invZ[0], invZ[1], invZ[2], percent);
+					percentCorrected *= fVector3(invZ[0] / temp, invZ[1] / temp, invZ[2] / temp);
+
+					std::vector<float32_t> pixelData;
+
+					const size_t floatCounts = node.vertexDesc.vertexByteSize() / sizeof(float32_t);
+					pixelData.resize(floatCounts);
+
+					for (size_t j = 0; j < floatCounts; j++) 
+					{
+						pixelData[j] = MathUtil::lerp3(vertex0[j], vertex1[j], vertex2[j], percentCorrected);
+					}
+
+					fVector4 color;
+					pixelShader->process(node.vertexDesc, &(pixelData[0]), 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);
+				}				
+			);
+		}
+	}
+}
+
+DV_CORE_END_NAMESPACE

source/core/source/pipe/dvc_render_step_VS.cpp

@@ -0,0 +1,84 @@
+#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.cpp

@@ -0,0 +1,11 @@
+#include "pipe/dvc_renderable.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+Renderable::Renderable(const fMatrix4& worldTransform)
+	: m_worldTransform(worldTransform)
+{
+
+}
+
+DV_CORE_END_NAMESPACE

source/core/source/pipe/dvc_renderable_entity.cpp

@@ -0,0 +1,22 @@
+#include "pipe/dvc_renderable_entity.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+RenderableEntity::RenderableEntity(Mesh::PrimitiveConstPtr primitive, const fMatrix4& worldTransform)
+	: m_primitive(primitive)
+	, Renderable(worldTransform)
+{
+
+}
+
+bool RenderableEntity::buildAssemberNode(InputAssemberStep::Node& node) const
+{
+	node.primitiveType = m_primitive->type;
+	node.transform = m_worldTransform;
+	node.vertexData = m_primitive->attributes;
+	node.indices = m_primitive->indices;
+
+	return true;
+}
+
+DV_CORE_END_NAMESPACE

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

@@ -0,0 +1,59 @@
+#include "scene/component/dvc_camera_component.h"
+#include "math/dvc_math_util.h"
+#include "scene/dvc_scene_node.h"
+#include "math/dvc_matrix4.h"
+#include "math/dvc_vector4.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+CameraComponent::CameraComponent(SceneNodePtr owner)
+	: SceneComponent(owner)
+{
+
+}
+
+CameraComponent::~CameraComponent()
+{
+
+}
+
+const std::string& CameraComponent::typeName()
+{
+	static std::string s_typename = "Camera";
+	return s_typename;
+}
+
+fVector3 CameraComponent::getEye(void) const
+{
+	return m_owner->getWorldPosition();
+}
+
+fVector3 CameraComponent::getLookat(void) const
+{
+	//negative z-axis.
+	fVector4 p = (m_owner->getTransform() * fVector4(0, 0, -1, 1));
+	return p.xyz() / p.w;
+}
+
+fVector3 CameraComponent::getUp(void) const
+{
+	//y-axis
+	return (m_owner->getTransform() * fVector4(0, 1, 0, 0)).xyz();
+}
+
+void CameraComponent::setCameraDefine(const CameraComponent::CameraDefine& cameraDefine)
+{
+	m_cameraDefine = cameraDefine;
+
+	fMatrix4 matView = MathUtil::lookatRH(getEye(), getLookat(), getUp());
+	fMatrix4 matProj = MathUtil::perspectiveFovRH(m_cameraDefine.fov, m_cameraDefine.aspect, m_cameraDefine.nearClip, m_cameraDefine.farClip);
+	m_viewMatrix = matView;
+	m_viewProjMatrix = matProj * matView;
+}
+
+void CameraComponent::render(const fMatrix4& transParent, RenderQueue& queue) const
+{
+
+}
+
+DV_CORE_END_NAMESPACE

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

@@ -0,0 +1,21 @@
+#include "scene/component/dvc_component.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+SceneComponent::SceneComponent(SceneNodePtr owner)
+	: m_owner(owner)
+{
+
+}
+
+SceneComponent::~SceneComponent()
+{
+
+}
+
+void SceneComponent::render(const fMatrix4& transParent, RenderQueue& queue) const
+{
+
+}
+
+DV_CORE_END_NAMESPACE

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

@@ -0,0 +1,33 @@
+#include "scene/component/dvc_light_component.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+LightComponent::LightComponent(SceneNodePtr owner)
+	: SceneComponent(owner)
+{
+
+}
+
+LightComponent::~LightComponent()
+{
+
+}
+
+const std::string& LightComponent::typeName()
+{
+	static std::string s_typename = "Light";
+	return s_typename;
+}
+
+void LightComponent::setLightDefine(const LightDefine& lightDefine)
+{
+	m_define = lightDefine;
+}
+
+void LightComponent::render(const fMatrix4& transParent, RenderQueue& queue) const
+{
+
+}
+
+DV_CORE_END_NAMESPACE
+

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

@@ -0,0 +1,44 @@
+#include "scene/component/dvc_mesh_component.h"
+#include "asset/dvc_mesh.h"
+#include "pipe/dvc_renderable_entity.h"
+#include "pipe/dvc_render_queue.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+MeshComponent::MeshComponent(SceneNodePtr owner)
+	: SceneComponent(owner)
+{
+
+}
+
+MeshComponent::~MeshComponent()
+{
+
+}
+
+const std::string& MeshComponent::typeName()
+{
+	static std::string s_typename = "Mesh";
+	return s_typename;
+}
+
+void MeshComponent::setMesh(MeshConstPtr mesh)
+{
+	m_mesh = mesh;
+}
+
+void MeshComponent::render(const fMatrix4& transParent, RenderQueue& queue) const
+{
+	SceneComponent::render(transParent, queue);
+
+	int32_t primitiveCounts = m_mesh->getPrimitiveCounts();
+	for (int32_t i = 0; i < primitiveCounts; i++)
+	{
+		Mesh::PrimitiveConstPtr primitivePtr = m_mesh->getPrimitive(i);
+
+		RenderablePtr renderable = std::make_shared<RenderableEntity>(primitivePtr, transParent);
+		queue.pushRenderable(renderable);
+	}
+}
+
+DV_CORE_END_NAMESPACE

source/core/source/scene/dvc_scene.cpp

@@ -0,0 +1,123 @@
+#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
+
+Scene::Scene()
+{
+}
+
+Scene::~Scene()
+{
+	clear();
+}
+
+void Scene::init(void)
+{
+	//clear
+	clear();
+
+	//set a new root
+	m_rootSceneNode = std::shared_ptr<SceneNode>(new SceneNode());
+}
+
+void Scene::clear(void)
+{
+	//clear scene nodes
+	if (m_rootSceneNode.get())
+	{
+		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)
+{
+	SceneNodePtr sceneNode = std::make_shared<SceneNode>();
+	sceneNode->setName(name);
+	return sceneNode;
+}
+
+SceneNodePtr Scene::getRootSceneNode(void) const
+{
+	return m_rootSceneNode;
+}
+
+DV_CORE_END_NAMESPACE

source/core/source/scene/dvc_scene_node.cpp

@@ -0,0 +1,108 @@
+#include "scene/dvc_scene_node.h"
+#include "scene/component/dvc_component.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+SceneNode::SceneNode()
+	: m_transform(fMatrix4::IDENTITY)
+{
+
+}
+
+SceneNode::~SceneNode()
+{
+
+}
+
+void SceneNode::setName(const std::string& name)
+{
+	m_name = name;
+}
+
+const std::string& SceneNode::getName() const
+{
+	return m_name;
+}
+
+void SceneNode::clear(void)
+{
+	for (size_t i = 0; i < m_childen.size(); i++)
+	{
+		m_childen[i]->clear();
+	}
+	m_childen.clear();
+}
+
+void SceneNode::addChild(SceneNodePtr child)
+{
+	child->setParent(shared_from_this());
+	m_childen.push_back(child);
+}
+
+void SceneNode::setParent(SceneNodePtr parent)
+{
+	m_parent = parent;
+}
+
+void SceneNode::addComponent(SceneComponentPtr component)
+{
+	m_componentArray.push_back(component);
+}
+
+void SceneNode::setTransform(const fMatrix4& transform)
+{
+	m_transform = transform;
+}
+
+fMatrix4 SceneNode::getWorldTransform() const
+{
+	if (m_parent)
+	{
+		return m_parent->getWorldTransform() * m_transform;
+	}
+	return m_transform;
+}
+
+fVector3 SceneNode::getPosition() const
+{
+	return getTransform() * fVector3::ZERO;
+}
+
+fVector3 SceneNode::getWorldPosition() const
+{
+	return getWorldTransform() * fVector3::ZERO;
+}
+
+SceneNodeConstPtr SceneNode::getChild(size_t index) const
+{
+	if (index >= getChildCounts()) {
+		return nullptr;
+	}
+	return m_childen[index];
+}
+
+SceneComponentConstPtr SceneNode::getComponent(size_t index) const
+{
+	if (index >= getComponentCounts()) {
+		return nullptr;
+	}
+	return m_componentArray[index];
+}
+
+void SceneNode::buildRenderQueue(const fMatrix4& transParent, RenderQueue& queue)
+{
+	fMatrix4 transform = m_transform * transParent;
+
+	for (auto component : m_componentArray)
+	{
+		component->render(transform, queue);
+	}
+
+	for (auto child : m_childen) 
+	{
+		child->buildRenderQueue(transform, queue);
+	}
+}
+
+DV_CORE_END_NAMESPACE
+

source/core/source/shader/dvc_shader_interface.cpp

@@ -0,0 +1,24 @@
+#include "shader/dvc_shader_interface.h"
+
+#include <Windows.h>
+
+DV_CORE_BEGIN_NAMESPACE
+
+ShaderFileInterface* LoadShaderFile(const char* szShaderFile)
+{
+	HMODULE hDllModule = LoadLibraryA(szShaderFile);
+	if (hDllModule == NULL)
+	{
+		return nullptr;
+	}
+
+	ShaderFileInterfaceFunc shaderFileInterfaceFunc = (ShaderFileInterfaceFunc)GetProcAddress(hDllModule, "ShaderFileInterface");
+	if (shaderFileInterfaceFunc == NULL)
+	{
+		return nullptr;
+	}
+
+	return shaderFileInterfaceFunc();
+}
+
+DV_CORE_END_NAMESPACE