init commit

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