增加材质和纹理

source/core/CMakeLists.txt

@@ -69,11 +69,17 @@ source_group("source/scene/component" FILES ${DV_CORE_SCENE_COMPONENT_SOURCE_FIL
 #################
 set(DV_CORE_ASSET_INCLUDE_FILES
 	include/asset/dvc_mesh.h
+	include/asset/dvc_image.h
+	include/asset/dvc_texture.h
+	include/asset/dvc_material.h
 )
 source_group("include/asset" FILES ${DV_CORE_ASSET_INCLUDE_FILES})
 
 set(DV_CORE_ASSET_SOURCE_FILES
 	source/asset/dvc_mesh.cpp
+	source/asset/dvc_image.cpp
+	source/asset/dvc_texture.cpp
+	source/asset/dvc_material.cpp
 )
 source_group("source/asset" FILES ${DV_CORE_ASSET_SOURCE_FILES})
 
@@ -81,6 +87,7 @@ source_group("source/asset" FILES ${DV_CORE_ASSET_SOURCE_FILES})
 # device
 #################
 set(DV_CORE_DEVICE_INCLUDE_FILES
+	include/device/dvc_device.h
 	include/device/dvc_buffer.h
 	include/device/dvc_buffer_view.h
 	include/device/dvc_buffer_accessor.h
@@ -92,6 +99,7 @@ set(DV_CORE_DEVICE_INCLUDE_FILES
 source_group("include/device" FILES ${DV_CORE_DEVICE_INCLUDE_FILES})
 
 set(DV_CORE_DEVICE_SOURCE_FILES
+	source/device/dvc_device.cpp
 	source/device/dvc_buffer.cpp
 	source/device/dvc_buffer_view.cpp
 	source/device/dvc_buffer_accessor.cpp
@@ -145,11 +153,13 @@ source_group("source/rasterizer" FILES ${DV_CORE_RASTERIZER_SOURCE_FILES})
 #################
 set(DV_CORE_SHADER_INCLUDE_FILES
 	include/shader/dvc_shader_interface.h
+	include/shader/dvc_shader_functions.h
 )
 source_group("include/shader" FILES ${DV_CORE_SHADER_INCLUDE_FILES})
 
 set(DV_CORE_SHADER_SOURCE_FILES
 	source/shader/dvc_shader_interface.cpp
+	source/shader/dvc_shader_functions.cpp
 )
 source_group("source/shader" FILES ${DV_CORE_SHADER_SOURCE_FILES})
 

source/core/include/asset/dvc_image.h

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

source/core/include/asset/dvc_material.h

@@ -0,0 +1,113 @@
+#pragma once
+
+#include "dvc_config.h"
+#include "dvc_pre_declare.h"
+#include "math/dvc_vector4.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+class DV_CORE_API Material
+{
+public:
+	struct TextureInfo
+	{
+		TextureConstPtr texture;
+		int32_t texCoord = 0;
+	};
+
+public:
+	int32_t getID(void) const { return m_id; }
+
+	void setBaseColorTexture(const TextureConstPtr& texture, int32_t texCoord, const fVector4& baseColorfactor) { 
+		m_baseColorTexture.texture = texture; 
+		m_baseColorTexture.texCoord = texCoord;
+		m_baseColorFactor = baseColorfactor; 
+	}
+	const TextureInfo& getBaseColorTexture() const { 
+		return m_baseColorTexture; 
+	}
+
+	const fVector4& getBaseColorFactor() const { 
+		return m_baseColorFactor; 
+	}
+
+	void setMetallicRoughnessTexture(const TextureConstPtr& texture, int32_t texCoord, float32_t metallicFactor=1.f, float32_t roughnessFactor=1.f ) { 
+		m_metallicRoughnessTexture.texture = texture; 
+		m_metallicRoughnessTexture.texCoord = texCoord;
+		m_metallicFactor = metallicFactor;
+		m_roughnessFactor = roughnessFactor;
+	}
+
+	const TextureInfo& getMetallicRoughnessTexture() const { 
+		return m_metallicRoughnessTexture; 
+	}
+
+	float32_t getMetallicFactor() const { 
+		return m_metallicFactor; 
+	}
+
+	float32_t getRoughnessFactor() const { 
+		return m_roughnessFactor; 
+	}
+
+	void setNormalTexture(const TextureConstPtr& texture, int32_t texCoord, float32_t scale=1.f) { 
+		m_normalTexture.texture = texture; 
+		m_normalTexture.texCoord = texCoord;
+		m_normalScale = scale;
+	}
+
+	const TextureInfo& getNormalTexture() const { 
+		return m_normalTexture; 
+	}
+
+	float32_t getNormalScale() const { 
+		return m_normalScale; 
+	}
+
+	VertexShaderInterface* getVertexShader() const { 
+		return m_vertexShader; 
+	}
+
+	PixelShaderInterface* getPixelShader() const { 
+		return m_pixelShader; 
+	}
+
+public:
+	bool loadShader();
+
+protected:
+	int32_t m_id;
+
+	/*The base color texture. 
+	* The first three components (RGB) MUST be encoded with the sRGB transfer function. 
+	*/
+	TextureInfo m_baseColorTexture;
+	fVector4 m_baseColorFactor = fVector4::ONE;
+
+	/*The metallic - roughness texture.
+	* The metalness values are sampled from the B channel.
+	* The roughness values are sampled from the G channel.
+	*/
+	TextureInfo m_metallicRoughnessTexture;
+	float32_t m_metallicFactor = 1.0f;
+	float32_t m_roughnessFactor = 1.0f;
+
+	/*The normal texture.
+	*/
+	TextureInfo m_normalTexture;
+	/*The scalar parameter applied to each normal vector of the texture. 
+	* This value scales the normal vector in X and Y directions using the formula: 
+	*	scaledNormal = (normalize<sampled normal texture value> * 2.0 - 1.0) * vec3(<normal scale>, <normal scale>, 1.0).
+	*/
+	float32_t m_normalScale = 1.0f; 
+
+protected:
+	VertexShaderInterface* m_vertexShader = nullptr;
+	PixelShaderInterface* m_pixelShader = nullptr;
+
+public:
+	Material(int32_t id);
+	~Material();
+};
+
+DV_CORE_END_NAMESPACE

source/core/include/asset/dvc_mesh.h

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

source/core/include/asset/dvc_texture.h

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

source/core/include/device/dvc_buffer.h

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

source/core/include/device/dvc_buffer_accessor.h

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

source/core/include/device/dvc_buffer_view.h

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

source/core/include/device/dvc_device.h

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

source/core/include/dvc_config.h

@@ -89,17 +89,19 @@ enum PrimitiveType
 
 enum PixelFormat
 {
-	//96-bit pixel format, 32 bits (float) for red, 32 bits (float) for green, 32 bits (float) for blue
-	PF_FLOAT32_RGB,
+	PF_UNKNOWN,
 
-	/// 128-bit pixel format, 32 bits (float) for red, 32 bits (float) for green, 32 bits (float) for blue, 32 bits (float) for alpha
-	PF_FLOAT32_RGBA,
-	
-	// 32-bit pixel format, 32 bits (float) for red
-	PF_FLOAT32_R,
-	
-	/// 132-bit pixel format, 8 bits (float) for red, 8 bits (float) for green, 8 bits (float) for blue, 8 bits (float) for alpha
+	PF_UINT8_ALPHA,
+	PF_UINT8_RGB,
 	PF_UINT8_RGBA,
+
+	PF_UINT16_ALPHA,
+	PF_UINT16_RGB,
+	PF_UINT16_RGBA,
+
+	PF_FLOAT32_ALPHA,
+	PF_FLOAT32_RGB,
+	PF_FLOAT32_RGBA,
 };
 
 enum AntiAliasingTech

source/core/include/dvc_pre_declare.h

@@ -36,8 +36,22 @@ class Mesh;
 typedef std::shared_ptr<Mesh> MeshPtr;
 typedef std::shared_ptr<const Mesh> MeshConstPtr;
 
+class Image;
+typedef std::shared_ptr<Image> ImagePtr;
+typedef std::shared_ptr<const Image> ImageConstPtr;
+
+class Texture;
+typedef std::shared_ptr<Texture> TexturePtr;
+typedef std::shared_ptr<const Texture> TextureConstPtr;
+
+class Material;
+typedef std::shared_ptr<Material> MaterialPtr;
+typedef std::shared_ptr<const Material> MaterialConstPtr;
+
 class Scene;
 
+class Device;
+
 class SceneNode;
 typedef std::shared_ptr<SceneNode> SceneNodePtr;
 typedef std::shared_ptr<const SceneNode> SceneNodeConstPtr;
@@ -68,6 +82,7 @@ typedef std::shared_ptr<const Renderable> RenderableConstPtr;
 typedef std::vector<RenderableConstPtr> RenderableArray;
 
 class VertexShaderInterface;
+class PixelShaderInterface;
 
 class UniformBuffer;
 

source/core/include/math/dvc_math_util.h

@@ -10,6 +10,7 @@ class MathUtil
 public:
 	static DV_CORE_API size_t ComponentSize(ComponentType ct);
 	static DV_CORE_API size_t DataTypeSize(DataType dt);
+	static DV_CORE_API size_t PixelSize(PixelFormat pixelFormat);
 	
 	//count the number of bits set in v
 	static DV_CORE_API uint32_t popcount(uint8_t v);

source/core/include/math/dvc_vector4.h

@@ -235,6 +235,11 @@ public:
 public:
 	// special points
 	static DV_CORE_API const TVector4 ZERO;
+	static DV_CORE_API const TVector4 ONE;
+	static DV_CORE_API const TVector4 UNIT_X;
+	static DV_CORE_API const TVector4 UNIT_Y;
+	static DV_CORE_API const TVector4 UNIT_Z;
+	static DV_CORE_API const TVector4 UNIT_W;
 	static DV_CORE_API const TVector4 WHITE;
 	static DV_CORE_API const TVector4 BLACK;
 	static DV_CORE_API const TVector4 RED;

source/core/include/pipe/dvc_render_pipe.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "dvc_config.h"
+#include "device/dvc_device.h"
 #include "scene/dvc_scene.h"
 #include "device/dvc_uniform_buffer.h"
 #include "device/dvc_render_target.h"
@@ -10,9 +11,18 @@ DV_CORE_BEGIN_NAMESPACE
 class DV_CORE_API RenderPipe
 {
 public:
+	Device& getDevice() {
+		return m_device;
+	}
+	const Device& getDevice() const {
+		return m_device;
+	}
 	UniformBuffer& getUniformBuffer() {
 		return m_uniformBuffer;
 	}
+	const UniformBuffer& getUniformBuffer() const {
+		return m_uniformBuffer;
+	}
 	AntiAliasingTech getAntiAliasingTech() const {
 		return m_aaTech;
 	}
@@ -24,12 +34,13 @@ public:
 	void process(RenderTarget& renderTarget);
 
 protected:
-	AntiAliasingTech m_aaTech;
+	Device& m_device;
+	AntiAliasingTech m_aaTech = AntiAliasingTech::AA_None;
 	UniformBuffer m_uniformBuffer;
 	RenderableArray m_renderableQueue;
 
 public:
-	RenderPipe();
+	RenderPipe(Device& device);
 	~RenderPipe();
 };
 

source/core/include/pipe/dvc_render_step0_input_assember.h

@@ -17,7 +17,7 @@ public:
 		PrimitiveType					primitiveType;
 		PrimitiveAttributes				vertexData;
 		DeviceBufferAccessorConstPtr	indices;
-		VertexShaderInterface*			vs;
+		MaterialConstPtr				material;
 	};
 	typedef std::vector<Node> NodeArray;
 

source/core/include/pipe/dvc_render_step1_vertex_shader.h

@@ -12,6 +12,7 @@ class VertexShaderStep
 public:
 	struct Node
 	{
+		MaterialConstPtr		material;
 		DeviceBufferPtr			vertexBuf;
 		VertexDesc				vertexDesc;
 		size_t					vertexCounts;
@@ -21,7 +22,7 @@ public:
 	typedef std::vector<Node> NodeArray;
 
 public:
-	void process(UniformBuffer& uniformBuffer, const InputAssemberStep::NodeArray& assembedNodeArray);
+	void process(RenderPipe& pipe, const InputAssemberStep::NodeArray& assembedNodeArray);
 	
 public:
 	NodeArray m_nodes;

source/core/include/pipe/dvc_render_step2_rasterizer.h

@@ -20,7 +20,7 @@ public:
 	typedef std::vector<Fragement> FragementArray;
 
 public:
-	void process(const VertexShaderStep::NodeArray& vsNodeArray, AntiAliasingTech aaTech, int32_t canvasWidth, int32_t canvasHeight);
+	void process(RenderPipe& pipe, const VertexShaderStep::NodeArray& vsNodeArray, AntiAliasingTech aaTech, int32_t canvasWidth, int32_t canvasHeight);
 
 public:
 	StartOffsetArray m_startOffsetArray;

source/core/include/scene/dvc_scene.h

@@ -11,32 +11,6 @@ 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;
@@ -80,14 +54,6 @@ public:
 protected:
 	SceneNodePtr m_rootSceneNode;
 
-	//device resources
-	std::vector<DeviceBufferPtr> m_deviceBufferArray;
-	std::vector<DeviceBufferViewPtr> m_bufferViewArray;
-	std::vector<DeviceBufferAccessorPtr> m_bufferAccessorArray;
-
-	//asset resources
-	std::vector<MeshPtr> m_meshArray;
-
 public:
 	Scene();
 	~Scene();

source/core/include/shader/dvc_shader_functions.h

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

source/core/include/shader/dvc_shader_interface.h

@@ -2,6 +2,7 @@
 
 #include "dvc_config.h"
 #include "dvc_pre_declare.h"
+#include "math/dvc_vector2.h"
 #include "math/dvc_vector3.h"
 #include "math/dvc_vector4.h"
 #include "device/dvc_vertex_desc.h"
@@ -15,7 +16,7 @@ public:
 	virtual const VertexDesc& getOutputVertexDesc() const = 0;
 
 	typedef std::function<DeviceBufferAccessorConstPtr(VertexElementType)> SetInputAttributeFunc;
-	virtual void prepare(const UniformBuffer* uniformBuffer, SetInputAttributeFunc setInputAttributeFunc) = 0;
+	virtual void prepare(const RenderPipe* pipe, SetInputAttributeFunc setInputAttributeFunc) = 0;
 
 	virtual void process(size_t index, void* outputVertex, fVector3& vertexWorldPos) = 0;
 };
@@ -26,7 +27,7 @@ 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 prepare(const RenderPipe* pipe, SetInputAttributeFunc setInputAttributeFunc) = 0;
 
 	virtual void process(const VertexDesc& veretexDesc, const float32_t* pixelData, fVector4& color) = 0;
 };

source/core/source/asset/dvc_image.cpp

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

source/core/source/asset/dvc_material.cpp

@@ -0,0 +1,24 @@
+#include "asset/dvc_material.h"
+#include "shader/dvc_shader_interface.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+Material::Material(int32_t id)
+	: m_id(id)
+{
+}
+
+Material::~Material()
+{
+}
+
+bool Material::loadShader()
+{
+	ShaderFileInterface* shaderInterface = davinci::LoadShaderFile("TestShader.dll");
+	m_vertexShader = shaderInterface->getVertexShader("test");
+	m_pixelShader = shaderInterface->getPixelShader("test");
+
+	return true;
+}
+
+DV_CORE_END_NAMESPACE

source/core/source/asset/dvc_mesh.cpp

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

source/core/source/asset/dvc_texture.cpp

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

source/core/source/device/dvc_buffer.cpp

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

source/core/source/device/dvc_buffer_accessor.cpp

@@ -3,8 +3,9 @@
 
 DV_CORE_BEGIN_NAMESPACE
 
-DeviceBufferAccessor::DeviceBufferAccessor(DeviceBufferViewConstPtr bufferView, size_t offset, size_t count, ComponentType componentType, DataType dataType)
-	: m_bufferView(bufferView)
+DeviceBufferAccessor::DeviceBufferAccessor(int32_t id, DeviceBufferViewConstPtr bufferView, size_t offset, size_t count, ComponentType componentType, DataType dataType)
+	: m_id(id)
+	, m_bufferView(bufferView)
 	, m_offset(offset)
 	, m_count(count)
 	, m_componentType(componentType)

source/core/source/device/dvc_buffer_view.cpp

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

source/core/source/device/dvc_device.cpp

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

source/core/source/math/dvc_math_util.cpp

@@ -89,6 +89,35 @@ size_t MathUtil::DataTypeSize(DataType dt)
 	return 0;
 }
 
+size_t MathUtil::PixelSize(PixelFormat pixelFormat)
+{
+	switch (pixelFormat)
+	{
+	case PixelFormat::PF_UINT8_ALPHA:
+		return 1;
+	case PixelFormat::PF_UINT8_RGB:
+		return 3;
+	case PixelFormat::PF_UINT8_RGBA:
+		return 4;
+	case PixelFormat::PF_UINT16_ALPHA:
+		return 2;
+	case PixelFormat::PF_UINT16_RGB:
+		return 6;
+	case PixelFormat::PF_UINT16_RGBA:
+		return 8;
+	case PixelFormat::PF_FLOAT32_ALPHA:
+		return 4;
+	case PixelFormat::PF_FLOAT32_RGB:
+		return 12;
+	case PixelFormat::PF_FLOAT32_RGBA:
+		return 16;
+	default:
+		break;
+	}
+	assert(false);
+	return 0;
+}
+
 float MathUtil::unitRandom(void)
 {
 	return float(rand()) / RAND_MAX;

source/core/source/math/dvc_vector4.cpp

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

source/core/source/pipe/dvc_render_pipe.cpp

@@ -8,7 +8,9 @@
 
 DV_CORE_BEGIN_NAMESPACE
 
-RenderPipe::RenderPipe()
+RenderPipe::RenderPipe(Device& device)
+	: m_device(device)
+	, m_aaTech(AntiAliasingTech::AA_None)
 {
 
 }
@@ -31,11 +33,11 @@ void RenderPipe::process(RenderTarget& renderTarget)
 
 	//Vertex shader
 	VertexShaderStep VS;
-	VS.process(m_uniformBuffer, IA.m_nodes);
+	VS.process(*this, IA.m_nodes);
 
 	//Pixel shader
 	RasterizerStep rasterizerStep;
-	rasterizerStep.process(VS.m_nodes, m_aaTech, renderTarget.getWidth(), renderTarget.getHeight());
+	rasterizerStep.process(*this, VS.m_nodes, m_aaTech, renderTarget.getWidth(), renderTarget.getHeight());
 
 	//Output Merge
 	OutputMergerStep OM;

source/core/source/pipe/dvc_render_step1_vertex_shader.cpp

@@ -2,13 +2,14 @@
 #include "shader/dvc_shader_interface.h"
 #include "device/dvc_buffer_accessor.h"
 #include "math/dvc_math_util.h"
+#include "asset/dvc_material.h"
 
 DV_CORE_BEGIN_NAMESPACE
 
-void VertexShaderStep::process(UniformBuffer& uniformBuffer, const InputAssemberStep::NodeArray& assembedNodeArray)
+void VertexShaderStep::process(RenderPipe& pipe, const InputAssemberStep::NodeArray& assembedNodeArray)
 {
-	ShaderFileInterface* shaderInterface = davinci::LoadShaderFile("TestShader.dll");
-	VertexShaderInterface* standardVS = shaderInterface->getVertexShader("test");
+	Device& device = pipe.getDevice();
+	UniformBuffer& uniformBuffer = pipe.getUniformBuffer();
 
 	const fVector3* eyePos = (const fVector3*)(uniformBuffer.getAttribute("camera:eye_pos"));
 	const fMatrix4* cameraView = (const fMatrix4*)(uniformBuffer.getAttribute("camera:view_mat"));
@@ -27,7 +28,8 @@ void VertexShaderStep::process(UniformBuffer& uniformBuffer, const InputAssember
 		fMatrix4 worldInverseTrans = inputNode.transform.inverse().transpose();
 		uniformBuffer.setAttribute("self:world_transform_inverse_trans", worldInverseTrans);
 
-		standardVS->prepare(&uniformBuffer,
+		VertexShaderInterface* vs = inputNode.material->getVertexShader();
+		vs->prepare(&pipe,
 			[inputNode](VertexElementType type) -> DeviceBufferAccessorConstPtr
 			{
 				InputAssemberStep::PrimitiveAttributes::const_iterator it = inputNode.vertexData.find(type);
@@ -42,9 +44,10 @@ void VertexShaderStep::process(UniformBuffer& uniformBuffer, const InputAssember
 		size_t vertexCounts = inputNode.indices->getCount();
 
 		Node outputNode;
+		outputNode.material = inputNode.material;
 		outputNode.vertexCounts = vertexCounts;
-		outputNode.vertexDesc = standardVS->getOutputVertexDesc();
-		outputNode.vertexBuf = std::make_shared<DeviceBuffer>(outputNode.vertexDesc.vertexByteSize() * vertexCounts);
+		outputNode.vertexDesc = vs->getOutputVertexDesc();
+		outputNode.vertexBuf = device.newDeviceBuffer(outputNode.vertexDesc.vertexByteSize() * vertexCounts);
 		outputNode.depth.resize(vertexCounts);
 		outputNode.invZ.resize(vertexCounts);
 
@@ -54,7 +57,7 @@ void VertexShaderStep::process(UniformBuffer& uniformBuffer, const InputAssember
 
 			fVector3 vertexWorldPos;
 			void* outputVertexMemory = outputNode.vertexBuf->ptr(i* outputNode.vertexDesc.vertexByteSize());
-			standardVS->process(index, outputVertexMemory, vertexWorldPos);
+			vs->process(index, outputVertexMemory, vertexWorldPos);
 
 			//TODO: clip
 

source/core/source/pipe/dvc_render_step2_rasterizer.cpp

@@ -3,13 +3,17 @@
 #include "device/dvc_buffer.h"
 #include "rasterizer/dvc_rasterizer_triangle.h"
 #include "math/dvc_math_util.h"
+#include "asset/dvc_material.h"
+#include "asset/dvc_texture.h"
 
 DV_CORE_BEGIN_NAMESPACE
 
-void RasterizerStep::process(const VertexShaderStep::NodeArray& vsNodeArray, AntiAliasingTech aaTech, int32_t canvasWidth, int32_t canvasHeight)
+void RasterizerStep::process(RenderPipe& pipe, const VertexShaderStep::NodeArray& vsNodeArray, AntiAliasingTech aaTech, int32_t canvasWidth, int32_t canvasHeight)
 {
-	ShaderFileInterface* shaderInterface = davinci::LoadShaderFile("TestShader.dll");
-	PixelShaderInterface* pixelShader = shaderInterface->getPixelShader("test");
+	//ShaderFileInterface* shaderInterface = davinci::LoadShaderFile("TestShader.dll");
+	//PixelShaderInterface* pixelShader = shaderInterface->getPixelShader("test");
+	Device& device = pipe.getDevice();
+	UniformBuffer& uniformBuffer = pipe.getUniformBuffer();
 
 	fMatrix4 view_trans =
 		fMatrix4::makeTrans(canvasWidth / 2.f, canvasHeight / 2.f, 0.f) *
@@ -22,6 +26,19 @@ void RasterizerStep::process(const VertexShaderStep::NodeArray& vsNodeArray, Ant
 	{
 		const VertexShaderStep::Node& node = *it;
 
+		if (node.material->getBaseColorTexture().texture)
+		{
+			uniformBuffer.setAttribute("material:pbr:base_color_texture", node.material->getBaseColorTexture().texture->getID());
+		}
+
+		if (node.material->getNormalTexture().texture)
+		{
+			uniformBuffer.setAttribute("material:pbr:normal_texture", node.material->getNormalTexture().texture->getID());
+		}
+
+		PixelShaderInterface* pixelShader = node.material->getPixelShader();
+		pixelShader->prepare(&pipe, nullptr);
+
 		size_t vertexSize = node.vertexDesc.vertexByteSize();
 		size_t POS_offset = node.vertexDesc.getElement(VET_POSITION)->offset;
 

source/core/source/pipe/dvc_renderable_entity.cpp

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

source/core/source/scene/dvc_scene.cpp

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

source/core/source/shader/dvc_shader_functions.cpp

@@ -0,0 +1,18 @@
+#include "shader/dvc_shader_functions.h"
+#include "pipe/dvc_render_pipe.h"
+#include "asset/dvc_texture.h"
+
+DV_CORE_BEGIN_NAMESPACE
+
+fVector4 shader::texture2D(const RenderPipe& pipe, const char* textName, const fVector2& uv, const fVector4& defaultValue)
+{
+	davinci::fVector4 textureColor = defaultValue;
+	const int32_t* textureID = (const int32_t* )(pipe.getUniformBuffer().getAttribute(textName));
+	if (textureID != nullptr)
+	{
+		textureColor = pipe.getDevice().getTexture(*textureID)->sample(uv);
+	}
+	return textureColor;
+}
+
+DV_CORE_END_NAMESPACE