init commit

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
+