41-Shader类代码设计

Shader类代码设计

内容：
1、Shader类与DefaultShader类
2、GPU改造： drawElement/vertexShaderStage/screenMapping/perspectiveDivision
3、Raster改造： 统一绘制接口

shader.h

#pragma once
#include "../global/base.h"
#include "dataStructures.h"
#include "bufferObject.h"

class Shader {
public:
	Shader() {}
	~Shader() {}
	virtual VsOutput vertexShader(
		//VAO当中的bindingMap
		const std::map<uint32_t, BindingDescription>& bindingMap,

		//VBO当中的bindingMap
		const std::map<uint32_t,BufferObject*>& bufferMap,

		//当前要处理的顶点的index
		const uint32_t& index
	) = 0;

	virtual void fragmentShader(const VsOutput& input, FsOutput& output) = 0;

	//tool functions
public:
	//建议先看在VertexShader函数中如何使用，再看逻辑
	math::vec4f getVector(
		const std::map<uint32_t, BindingDescription>& bindingMap,
		const std::map<uint32_t, BufferObject*>& bufferMap,
		const uint32_t& attributeLocation,//当前属性的编号
		const uint32_t& index);//当前顶点编号

	RGBA vectorToRGBA(const math::vec4f& v) {
		RGBA color;
		color.mR = v.x * 255.0;
		color.mG = v.y * 255.0;
		color.mB = v.z * 255.0;
		color.mA = v.w * 255.0;

		return color;
	}
};

shader.cpp

##include "shader.h"

math::vec4f Shader::getVector(
	const std::map<uint32_t, BindingDescription>& bindingMap,
	const std::map<uint32_t, BufferObject*>& bufferMap,
	const uint32_t& attributeLocation,
	const uint32_t& index) {

	//1 取出本属性的Description
	auto bindingIter = bindingMap.find(attributeLocation);
	if (bindingIter == bindingMap.end()) {
		assert(false);
	}

	auto bindingDescription = bindingIter->second;

	//2 取出本属性所在的vbo
	auto vboID = bindingDescription.mVboId;
	auto vboIter = bufferMap.find(vboID);
	if (vboIter == bufferMap.end()) {
		assert(false);
	}

	BufferObject* vbo = vboIter->second;

	//3 计算数据在vbo中的偏移量
	uint32_t dataOffset = bindingDescription.mStride * index + bindingDescription.mOffset;
	uint32_t dataSize = bindingDescription.mItemSize * sizeof(float);

	const byte* buffer = vbo->getBuffer() + dataOffset;

	math::vec4f result;

	//拷贝出需要的数据，最多4个float
	memcpy(&result, buffer, dataSize);

	return result;
}

defaultShader.h

#pragma once
#include "../shader.h"
#include "../../math/math.h"

class DefaultShader:public Shader {
public:
	DefaultShader();
	~DefaultShader();

	VsOutput vertexShader(
		const std::map<uint32_t, BindingDescription>& bindingMap,
		const std::map<uint32_t, BufferObject*>& bufferMap,
		const uint32_t& index
	)override;

	void fragmentShader(const VsOutput& input, FsOutput& output)override;

public:
	//uniforms
	math::mat4f mModelMatrix;
	math::mat4f mViewMatrix;
	math::mat4f mProjectionMatrix;
};

defaultShader.cpp

#include "defaultShader.h"


DefaultShader::DefaultShader() {}
DefaultShader::~DefaultShader() {}

VsOutput DefaultShader::vertexShader(
	const std::map<uint32_t, BindingDescription>& bindingMap,
	const std::map<uint32_t, BufferObject*>& bufferMap,
	const uint32_t& index
) {
	VsOutput output;

	//取出Attribute数值
	math::vec4f position = getVector(bindingMap, bufferMap, 0, index);

	//变化为齐次坐标 
	position.w = 1.0f;
	math::vec4f color = getVector(bindingMap, bufferMap, 1, index);

	math::vec2f uv = getVector(bindingMap, bufferMap, 2, index);

	output.mPosition = mProjectionMatrix * mViewMatrix * mModelMatrix * position;
	output.mColor = color;
	output.mUV = uv;

	return output;
}

void DefaultShader::fragmentShader(const VsOutput& input, FsOutput& output) {
	output.mPixelPos.x = static_cast<int>(input.mPosition.x);
	output.mPixelPos.y = static_cast<int>(input.mPosition.y);
	output.mDepth = input.mPosition.z;
	output.mColor = vectorToRGBA(input.mColor);
}

gpu.h

#pragma once
#include "../global/base.h"
#include "frameBuffer.h"
#include "../application/application.h"
#include "../math/math.h"
#include "dataStructures.h"
#include "bufferObject.h"
#include "vao.h"
#include "shader.h"

#define sgl GPU::getInstance()

/*
* class GPU：
* 模拟GPU的绘图行为以及算法等
*/
class GPU {
public:
	static GPU* getInstance();
	GPU();

	~GPU();

	//接受外界传入的bmp对应的内存指针以及窗体的宽/高
	void initSurface(const uint32_t& width, const uint32_t& height, void* buffer = nullptr);

	//清除画布内容
	void clear();

	//打印状态机
	void printVAO(const uint32_t& vaoID);

	uint32_t genBuffer();
	void deleteBuffer(const uint32_t& bufferID);
	void bindBuffer(const uint32_t& bufferType, const uint32_t& bufferID);
	void bufferData(const uint32_t& bufferType, size_t dataSize, void* data);

	uint32_t genVertexArray();
	void deleteVertexArray(const uint32_t& vaoID);
	void bindVertexArray(const uint32_t& vaoID);
	void vertexAttributePointer(
		const uint32_t& binding,
		const uint32_t& itemSize,
		const uint32_t& stride,
		const uint32_t& offset);

	void useProgram(Shader* shader);

	void drawElement(const uint32_t& drawMode, const uint32_t& first, const uint32_t& count);

private:
	void vertexShaderStage(
		std::vector<VsOutput>& vsOutputs,
		const VertexArrayObject* vao,
		const BufferObject* ebo,
		const uint32_t first,
		const uint32_t count);

	void perspectiveDivision(VsOutput& vsOutput);
	void screenMapping(VsOutput& vsOutput);

private:
	static GPU* mInstance;
	FrameBuffer* mFrameBuffer{ nullptr };

	//VBO相关/EBO也存在内部
	uint32_t mCurrentVBO{ 0 };
	uint32_t mCurrentEBO{ 0 };
	uint32_t mBufferCounter{ 0 };
	std::map<uint32_t, BufferObject*> mBufferMap;

	//VAO相关
	uint32_t mCurrentVAO{ 0 };
	uint32_t mVaoCounter{ 0 };
	std::map<uint32_t, VertexArrayObject*> mVaoMap;

	Shader* mShader{ nullptr };
	math::mat4f mScreenMatrix;
};

gpu.cpp

#include "gpu.h"
#include "raster.h"

GPU* GPU::mInstance = nullptr;
GPU* GPU::getInstance() {
	if (!mInstance) {
		mInstance = new GPU();
	}

	return mInstance;
}

GPU::GPU() {}

GPU::~GPU() {
	if (mFrameBuffer) {
		delete mFrameBuffer;
	}

	for (auto iter : mBufferMap) {
		delete iter.second;
	}
	mBufferMap.clear();

	for (auto iter : mVaoMap) {
		delete iter.second;
	}
	mVaoMap.clear();
}

void GPU::initSurface(const uint32_t& width, const uint32_t& height, void* buffer) {
	mFrameBuffer = new FrameBuffer(width, height, buffer);
	mScreenMatrix = math::screenMatrix<float>(width - 1, height - 1);
}

void GPU::clear() {
	size_t pixelSize = mFrameBuffer->mWidth * mFrameBuffer->mHeight;
	std::fill_n(mFrameBuffer->mColorBuffer, pixelSize, RGBA(0, 0, 0, 0));
}

void GPU::printVAO(const uint32_t& vaoID) {
	auto iter = mVaoMap.find(vaoID);
	if (iter != mVaoMap.end()) {
		iter->second->print();
	}
}

uint32_t GPU::genBuffer() {
	mBufferCounter++;
	mBufferMap.insert(std::make_pair(mBufferCounter, new BufferObject()));

	return mBufferCounter;
}

void GPU::deleteBuffer(const uint32_t& bufferID) {
	auto iter = mBufferMap.find(bufferID);
	if (iter != mBufferMap.end()) {
		delete iter->second;
	}
	else {
		return;
	}

	mBufferMap.erase(iter);
}

void GPU::bindBuffer(const uint32_t& bufferType, const uint32_t& bufferID) {
	if (bufferType == ARRAY_BUFFER) {
		mCurrentVBO = bufferID;
	}
	else if (bufferType == ELEMENT_ARRAY_BUFFER) {
		mCurrentEBO = bufferID;
	}
}

void GPU::bufferData(const uint32_t& bufferType, size_t dataSize, void* data) {
	uint32_t bufferID = 0;
	if (bufferType == ARRAY_BUFFER) {
		bufferID = mCurrentVBO;
	}
	else if (bufferType == ELEMENT_ARRAY_BUFFER) {
		bufferID = mCurrentEBO;
	}
	else {
		assert(false);
	}

	auto iter = mBufferMap.find(bufferID);
	if (iter == mBufferMap.end()) {
		assert(false);
	}

	BufferObject* bufferObject = iter->second;
	bufferObject->setBufferData(dataSize, data);
}

uint32_t GPU::genVertexArray() {
	mVaoCounter++;
	mVaoMap.insert(std::make_pair(mVaoCounter, new VertexArrayObject()));

	return mVaoCounter;
}

void GPU::deleteVertexArray(const uint32_t& vaoID) {
	auto iter = mVaoMap.find(vaoID);
	if (iter != mVaoMap.end()) {
		delete iter->second;
	}
	else {
		return;
	}

	mVaoMap.erase(iter);
}

void GPU::bindVertexArray(const uint32_t& vaoID) {
	mCurrentVAO = vaoID;
}

void GPU::vertexAttributePointer(
	const uint32_t& binding,
	const uint32_t& itemSize,
	const uint32_t& stride,
	const uint32_t& offset)
{
	auto iter = mVaoMap.find(mCurrentVAO);
	if (iter == mVaoMap.end()) {
		assert(false);
	}

	auto vao = iter->second;
	vao->set(binding, mCurrentVBO, itemSize, stride, offset);
}

void GPU::useProgram(Shader* shader) {
	mShader = shader;
}

void GPU::drawElement(const uint32_t& drawMode, const uint32_t& first, const uint32_t& count) {
	if (mCurrentVAO == 0 || mShader == nullptr || count == 0) {
		return;
	}

	//1 get vao
	auto vaoIter = mVaoMap.find(mCurrentVAO);
	if (vaoIter == mVaoMap.end()) {
		std::cerr << "Error: current vao is invalid!" << std::endl;
		return;
	}

	const VertexArrayObject* vao = vaoIter->second;
	auto bindingMap = vao->getBindingMap();

	//2 get ebo
	auto eboIter = mBufferMap.find(mCurrentEBO);
	if (eboIter == mBufferMap.end()) {
		std::cerr << "Error: current ebo is invalid!" << std::endl;
		return;
	}

	const BufferObject* ebo = eboIter->second;

	std::vector<VsOutput> vsOutputs{};
	vertexShaderStage(vsOutputs, vao, ebo, first, count);

	if (vsOutputs.empty()) return;

	for (auto& output : vsOutputs) {
		perspectiveDivision(output);
	}

	for (auto& output : vsOutputs) {
		screenMapping(output);
	}

	std::vector<VsOutput> rasterOutputs;
	Raster::rasterize(rasterOutputs, drawMode, vsOutputs);


	if (rasterOutputs.empty()) return;

	FsOutput fsOutput;
	uint32_t pixelPos = 0;
	for (uint32_t i = 0; i < rasterOutputs.size(); ++i) {
		mShader->fragmentShader(rasterOutputs[i], fsOutput);
		pixelPos = fsOutput.mPixelPos.y * mFrameBuffer->mWidth + fsOutput.mPixelPos.x;
		mFrameBuffer->mColorBuffer[pixelPos] = fsOutput.mColor;
	}
}

void GPU::vertexShaderStage(
	std::vector<VsOutput>& vsOutputs,
	const VertexArrayObject* vao,
	const BufferObject* ebo,
	const uint32_t first,
	const uint32_t count) {
	auto bindingMap = vao->getBindingMap();
	byte* indicesData = ebo->getBuffer();

	uint32_t index = 0;
	for (uint32_t i = first; i < first + count; ++i) {
		//  ȡEbo е i  index
		size_t indicesOffset = i * sizeof(uint32_t);
		memcpy(&index, indicesData + indicesOffset, sizeof(uint32_t));

		VsOutput output = mShader->vertexShader(bindingMap, mBufferMap, index);
		vsOutputs.push_back(output);
	}
}

void GPU::perspectiveDivision(VsOutput& vsOutput) {
	float oneOverW = 1.0f / vsOutput.mPosition.w;

	vsOutput.mPosition *= oneOverW;
	vsOutput.mPosition.w = 1.0f;

	//// ޼ ë  
	//if (vsOutput.mPosition.x < -1.0f) {
	//	vsOutput.mPosition.x = -1.0f;
	//}

	//if (vsOutput.mPosition.x > 1.0f) {
	//	vsOutput.mPosition.x = 1.0f;
	//}

	//if (vsOutput.mPosition.y < -1.0f) {
	//	vsOutput.mPosition.y = -1.0f;
	//}

	//if (vsOutput.mPosition.y > 1.0f) {
	//	vsOutput.mPosition.y = 1.0f;
	//}

	//if (vsOutput.mPosition.z < -1.0f) {
	//	vsOutput.mPosition.z = -1.0f;
	//}

	//if (vsOutput.mPosition.z > 1.0f) {
	//	vsOutput.mPosition.z = 1.0f;
	//}
}

void GPU::screenMapping(VsOutput& vsOutput) {
	vsOutput.mPosition = mScreenMatrix * vsOutput.mPosition;
}

raster.h

#pragma once
#include "../global/base.h"
#include "dataStructures.h"

/*
* class Raster
* 对外提供静态函数接口，传入离散的图元点，返回光栅化后的像素数组
*/
class Raster {
public:
	Raster();
	~Raster();

	static void rasterize(
		std::vector<VsOutput>& results,
		const uint32_t& drawMode,
		const std::vector<VsOutput>& inputs
	);

private:
	static void rasterizeLine(
		std::vector<VsOutput>& results,
		const VsOutput& v0,
		const VsOutput& v1
	);

	static void interpolantLine(const VsOutput& v0, const VsOutput& v1, VsOutput& target);

	static void rasterizeTriangle(
		std::vector<VsOutput>& results,
		const VsOutput& v0,
		const VsOutput& v1,
		const VsOutput& v2
	);

	static void interpolantTriangle(const VsOutput& v0, const VsOutput& v1, const VsOutput& v2, VsOutput& p);

};

raster.cpp

#include "raster.h"
#include "../math/math.h"
#include "dataStructures.h"

Raster::Raster() {}

Raster::~Raster() {}

void Raster::rasterize(
	std::vector<VsOutput>& results,
	const uint32_t& drawMode,
	const std::vector<VsOutput>& inputs) {

	if (drawMode == DRAW_LINES) {
		for (uint32_t i = 0; i < inputs.size(); i += 2) {
			rasterizeLine(results, inputs[i], inputs[i + 1]);
		}
	}

	if (drawMode == DRAW_TRIANGLES) {
		for (uint32_t i = 0; i < inputs.size(); i += 3) {
			rasterizeTriangle(results, inputs[i], inputs[i + 1], inputs[i + 2]);
		}
	}
}

void Raster::rasterizeLine(
	std::vector<VsOutput>& results,
	const VsOutput& v0,
	const VsOutput& v1) {

	VsOutput start = v0;
	VsOutput end = v1;

	//1 保证x方向是从小到大的
	if (start.mPosition.x > end.mPosition.x) {
		auto tmp = start;
		start = end;
		end = tmp;
	}

	results.push_back(start);

	//2 保证y方向也是从小到大，如果需要翻转，必须记录
	bool flipY = false;
	if (start.mPosition.y > end.mPosition.y) {
		start.mPosition.y *= -1.0f;
		end.mPosition.y *= -1.0f;
		flipY = true;
	}

	//3 保证斜率在0-1之间，如果需要调整，必须记录
	int deltaX = static_cast<int>(end.mPosition.x - start.mPosition.x);
	int deltaY = static_cast<int>(end.mPosition.y - start.mPosition.y);

	bool swapXY = false;
	if (deltaX < deltaY) {
		std::swap(start.mPosition.x, start.mPosition.y);
		std::swap(end.mPosition.x, end.mPosition.y);
		std::swap(deltaX, deltaY);
		swapXY = true;
	}

	//4 brensenham
	int currentX = static_cast<int>(start.mPosition.x);
	int currentY = static_cast<int>(start.mPosition.y);

	int resultX = 0;
	int resultY = 0;

	VsOutput currentVsOutput;
	int p = 2 * deltaY - deltaX;

	for (int i = 0; i < deltaX; ++i) {
		if (p >= 0) {
			currentY += 1;
			p -= 2 * deltaX;
		}

		currentX += 1;
		p += 2 * deltaY;

		//处理新xy，flip and swap

		resultX = currentX;
		resultY = currentY;
		if (swapXY) {
			std::swap(resultX, resultY);
		}

		if (flipY) {
			resultY *= -1;
		}

		//产生新顶点
		currentVsOutput.mPosition.x = resultX;
		currentVsOutput.mPosition.y = resultY;

		interpolantLine(start, end, currentVsOutput);

		results.push_back(currentVsOutput);
	}

}

void Raster::interpolantLine(const VsOutput& v0, const VsOutput& v1, VsOutput& target) {
	float weight = 1.0f;
	if (v1.mPosition.x != v0.mPosition.x) {
		//用x做比例
		weight = (float)(target.mPosition.x - v0.mPosition.x) / (float)(v1.mPosition.x - v0.mPosition.x);
	}else if (v1.mPosition.y != v0.mPosition.y) {
		//用y做比例
		weight = (float)(target.mPosition.y - v0.mPosition.y) / (float)(v1.mPosition.y - v0.mPosition.y);
	}

	target.mColor = math::lerp(v0.mColor, v1.mColor, weight);
	target.mUV = math::lerp(v0.mUV, v1.mUV, weight);
}

void Raster::rasterizeTriangle(
	std::vector<VsOutput>& results,
	const VsOutput& v0,
	const VsOutput& v1,
	const VsOutput& v2) {
	int maxX = static_cast<int>(std::max(v0.mPosition.x, std::max(v1.mPosition.x, v2.mPosition.x)));
	int minX = static_cast<int>(std::min(v0.mPosition.x, std::min(v1.mPosition.x, v2.mPosition.x)));
	int maxY = static_cast<int>(std::max(v0.mPosition.y, std::max(v1.mPosition.y, v2.mPosition.y)));
	int minY = static_cast<int>(std::min(v0.mPosition.y, std::min(v1.mPosition.y, v2.mPosition.y)));

	math::vec2f pv0, pv1, pv2;
	VsOutput result;
	for (int i = minX; i <= maxX; ++i) {
		for (int j = minY; j <= maxY; ++j) {
			pv0 = math::vec2f(v0.mPosition.x - i, v0.mPosition.y - j);
			pv1 = math::vec2f(v1.mPosition.x - i, v1.mPosition.y - j);
			pv2 = math::vec2f(v2.mPosition.x - i, v2.mPosition.y - j);

			auto cross1 = math::cross(pv0, pv1);
			auto cross2 = math::cross(pv1, pv2);
			auto cross3 = math::cross(pv2, pv0);

			bool negativeAll = cross1 <= 0 && cross2 <= 0 && cross3 <= 0;
			bool positiveAll = cross1 >= 0 && cross2 >= 0 && cross3 >= 0;

			if (negativeAll || positiveAll) {
				result.mPosition.x = i;
				result.mPosition.y = j;
				interpolantTriangle(v0, v1, v2, result);

				results.push_back(result);
			}
		}
	}
}

void Raster::interpolantTriangle(const VsOutput& v0, const VsOutput& v1, const VsOutput& v2, VsOutput& p) {
	auto e1 = math::vec2f(v1.mPosition.x - v0.mPosition.x, v1.mPosition.y - v0.mPosition.y);
	auto e2 = math::vec2f(v2.mPosition.x - v0.mPosition.x, v2.mPosition.y - v0.mPosition.y);
	float sumArea = std::abs(math::cross(e1, e2));

	auto pv0 = math::vec2f(v0.mPosition.x - p.mPosition.x, v0.mPosition.y - p.mPosition.y);
	auto pv1 = math::vec2f(v1.mPosition.x - p.mPosition.x, v1.mPosition.y - p.mPosition.y);
	auto pv2 = math::vec2f(v2.mPosition.x - p.mPosition.x, v2.mPosition.y - p.mPosition.y);
	//计算v0的权重

	float v0Area = std::abs(math::cross(pv1, pv2));
	float v1Area = std::abs(math::cross(pv0, pv2));
	float v2Area = std::abs(math::cross(pv0, pv1));

	float weight0 = v0Area / sumArea;
	float weight1 = v1Area / sumArea;
	float weight2 = v2Area / sumArea;

	//对于颜色的插值
	p.mColor = math::lerp(v0.mColor, v1.mColor, v2.mColor, weight0, weight1, weight2);

	//对于uv坐标的插值
	p.mUV = math::lerp(v0.mUV, v1.mUV, v2.mUV, weight0, weight1, weight2);
}