企业官网建设流程全解析

最近在尝试一些图形渲染和并行计算项目时，常常感慨于GPU的强大与神秘。作为一名软件开发者，我们习惯了调用CUDA或OpenCL，但对那块黑色芯片内部究竟如何运作，却知之甚少。这种“黑盒”感促使我萌生了一个大胆的想法：能否从最基础的逻辑门开始，亲手搭建一个简易的GPU？这个念头一旦产生便挥之不去，于是，一场历时半年、充满挑战与乐趣的“硬件狂奔”就此开始。本文将完整记录我从零开始设计并实现一个简易GPU的全过程，涵盖从架构设计、Verilog编码、FPGA验证到驱动编写的每一个关键步骤。无论你是对硬件设计感兴趣的软件工程师，还是希望深入理解图形流水线的学生，都能从这篇实战笔记中获得启发和可复现的路径。

1. 项目背景与核心目标

1.1 为什么选择自制GPU？

在深度学习、科学计算和图形渲染领域，GPU（图形处理器）因其强大的并行计算能力已成为不可或缺的硬件。然而，商业GPU架构复杂，其内部细节对于大多数开发者而言是一个“黑箱”。通过自制一个简化版的GPU，可以达到以下几个核心目标：

1. 深入理解图形流水线：从顶点处理、光栅化到像素着色，亲手实现每一个阶段，能从根本上理解现代图形API（如OpenGL、Vulkan）背后的工作原理。
2. 掌握硬件描述语言（HDL）：项目全程使用Verilog HDL进行开发，是学习数字电路设计和FPGA开发的绝佳实践。
3. 贯通软硬件栈：从底层的电路设计，到中间的驱动编写，再到上层的应用测试，完成一次完整的软硬件协同开发体验。
4. 应对定制化计算需求：理解GPU架构后，可以为特定的并行计算任务（如图像处理、矩阵运算）设计更高效的定制化硬件加速器。

1.2 项目定义：我们要做一个什么样的GPU？

考虑到个人实现的可行性，我们不可能复现RTX 4090级别的复杂GPU。本项目的目标是实现一个功能精简、但架构完整的2D渲染GPU。它应具备以下核心特性：

• 渲染目标：输出到VGA显示器，分辨率为640x480 @ 60Hz。
• 图形功能：支持绘制点、线、矩形、三角形（填充），以及简单的位图（Sprite）渲染。
• 内存架构：拥有独立的显存（Frame Buffer），CPU可以通过特定的总线接口（如Wishbone或AXI4-Lite）向GPU发送绘图指令和数据。
• 流水线阶段：包含简化的顶点处理、三角形设置、光栅化、片段着色（此处可简化为颜色输出）等阶段。
• 开发平台：使用FPGA（如Xilinx Artix-7系列）作为硬件载体，使用Verilog进行设计，并通过仿真和上板进行验证。

这个目标既避免了现代GPU中极其复杂的着色器编译器、纹理单元和光追核心，又保留了图形流水线的核心骨架，非常适合学习。

2. 开发环境与工具链准备

“工欲善其事，必先利其器”。硬件开发对工具链的依赖比软件开发更甚，一个稳定、熟悉的开发环境能极大提升效率，减少环境问题带来的困扰。

2.1 硬件平台选择

• FPGA开发板：本项目选用Digilent Basys 3开发板。它基于Xilinx Artix-7 XC7A35T FPGA，拥有足够的逻辑资源（约33k逻辑单元）和I/O接口，板载VGA端口、时钟源和按钮/开关，非常适合作为自制GPU的验证平台。
• 辅助设备：一台支持VGA输入的显示器，以及对应的VGA连接线。

2.2 软件与工具链

1. HDL设计与仿真：

   • 编辑器/IDE：Visual Studio Code + Verilog-HDL/SystemVerilog插件，或专业的Vivado IDE。
   • 仿真工具：Icarus Verilog (iverilog)和GTKWave。这是一个开源、轻量级的仿真组合，适合在编写代码初期进行快速的功能仿真和调试。
   • 波形查看器：GTKWave，用于直观地查看仿真时序波形。

2. 综合与实现：

   • FPGA开发套件：Xilinx Vivado Design Suite（WebPack免费版即可）。这是将我们的Verilog代码“翻译”成FPGA内部电路连接（生成比特流文件）的必备工具。

3. “CPU”与驱动测试：

   • 为了给GPU发送指令，我们需要一个“主机”。这里有两种选择：
     • 软核CPU：在同一个FPGA内，用Vivado IP Integrator创建一个MicroBlaze或RISC-V软核，让它通过AXI总线与我们的GPU模块通信。这种方式最接近真实SoC场景，但设置稍复杂。
     • PC模拟：在验证初期，我们可以用FPGA板上的拨码开关、按钮模拟指令输入，或者更高效地，在PC上用Python/C编写一个简单的“驱动”程序，通过UART串口将绘图指令发送给FPGA上的GPU模块。本项目将采用UART串口通信方案，因为它简单直观，便于调试。

2.3 项目目录结构建议

在开始编码前，建立一个清晰的项目目录结构至关重要。

my_gpu_project/ ├── rtl/ // 存放所有Verilog源代码 │ ├── core/ // GPU核心模块 │ │ ├── gpu_top.v // GPU顶层模块 │ │ ├── vertex_processor.v │ │ ├── rasterizer.v │ │ ├── fragment_shader.v │ │ └── ... │ ├── memory/ // 存储模块 │ │ ├── frame_buffer.v // 显存（双端口RAM） │ │ └── instruction_fifo.v // 指令FIFO │ ├── interface/ // 接口模块 │ │ ├── vga_controller.v // VGA时序生成器 │ │ └── uart_cmd_parser.v // UART指令解析器 │ └── lib/ // 通用组件（如FIFO、时钟分频） ├── sim/ // 仿真相关文件 │ ├── testbench/ // 测试平台 │ │ └── gpu_tb.v │ ├── scripts/ // 仿真脚本（如run.do） │ └── waves/ // 波形文件 ├── constr/ // 约束文件 │ └── basys3.xdc // Basys3板卡的引脚、时钟约束 ├── software/ // 上位机（PC端）测试程序 │ └── host_driver/ // UART通信及绘图指令生成 │ ├── main.py │ └── gpu_protocol.py └── vivado/ // Vivado工程目录（可自动生成） └── my_gpu.xpr

3. GPU核心架构设计与模块拆解

在动手写代码之前，必须对整体架构有清晰的认识。我们的简易GPU采用经典的立即模式渲染（Immediate Mode Rendering）架构，CPU逐条发送绘图命令，GPU接收后立即执行并更新帧缓存。

3.1 系统框图

下图展示了GPU与外部世界的交互关系：

[PC/上位机] --(UART串口)--> [FPGA] | V [UART指令解析器] | V [指令FIFO] --> [GPU核心] | | | V [时钟与复位] [顶点处理器] | | | V [VGA时序控制器] <-- [光栅化器] | | | V [VGA端口] [片段着色器/颜色处理] | V [显存 (Frame Buffer)] | <-- [读写仲裁]

数据流：上位机发送指令 -> UART解析并存入FIFO -> GPU核心从FIFO取指 -> 执行绘图流水线 -> 将像素颜色写入显存对应位置 -> VGA控制器每个时钟周期从显存读取像素颜色并输出到显示器。

3.2 关键模块详解

3.2.1 VGA时序控制器 (vga_controller.v)

这是与显示器交互的基石，不涉及图形计算，只负责生成符合VGA标准的时序信号。

• 输入：主时钟（如Basys3的100MHz），复位信号。
• 输出：
  • vga_hsync,vga_vsync: 行同步和场同步信号。
  • pixel_x,pixel_y: 当前正在输出的像素坐标（相对于屏幕左上角）。
  • video_active: 有效显示区域标志（在消隐区为低电平）。
• 原理：根据VGA 640x480@60Hz的时序参数，使用计数器生成同步脉冲、显示后沿、有效区和显示前沿。pixel_x和pixel_y只在video_active有效时递增。

module vga_controller ( input wire clk, // 100MHz时钟 input wire reset, // 复位信号 output reg vga_hsync, // 行同步 output reg vga_vsync, // 场同步 output reg [9:0] pixel_x, // 当前像素X坐标 (0-799) output reg [9:0] pixel_y, // 当前像素Y坐标 (0-524) output wire video_active // 有效显示区域 ); // VGA 640x480@60Hz 时序参数 (单位：像素时钟周期) parameter H_DISPLAY = 640; parameter H_FRONT_PORCH = 16; parameter H_SYNC_PULSE = 96; parameter H_BACK_PORCH = 48; parameter H_TOTAL = H_DISPLAY + H_FRONT_PORCH + H_SYNC_PULSE + H_BACK_PORCH; // 800 parameter V_DISPLAY = 480; parameter V_FRONT_PORCH = 10; parameter V_SYNC_PULSE = 2; parameter V_BACK_PORCH = 33; parameter V_TOTAL = V_DISPLAY + V_FRONT_PORCH + V_SYNC_PULSE + V_BACK_PORCH; // 525 reg [9:0] h_count; // 行计数器 reg [9:0] v_count; // 场计数器 // 生成 video_active 信号 assign video_active = (h_count < H_DISPLAY) && (v_count < V_DISPLAY); // 像素坐标输出：仅在有效区内赋值 always @(posedge clk) begin if (video_active) begin pixel_x <= h_count; pixel_y <= v_count; end else begin pixel_x <= 10‘d0; pixel_y <= 10’d0; end end // 行计数器和同步信号生成 always @(posedge clk or posedge reset) begin if (reset) begin h_count <= 10‘d0; vga_hsync <= 1’b1; // 同步信号极性需根据显示器调整，通常为负极性 end else begin if (h_count == H_TOTAL - 1) begin h_count <= 10‘d0; end else begin h_count <= h_count + 10’d1; end // 生成 hsync 脉冲 vga_hsync <= !((h_count >= (H_DISPLAY + H_FRONT_PORCH)) && (h_count < (H_DISPLAY + H_FRONT_PORCH + H_SYNC_PULSE))); end end // 场计数器和同步信号生成（类似行逻辑，省略部分细节） // ... endmodule

3.2.2 帧缓存 (frame_buffer.v)

GPU的“画布”，是一个双端口块存储器（Block RAM, BRAM）。

• 端口A（写端口）：由GPU的片段着色器写入，地址由pixel_x和pixel_y计算得出，数据是像素颜色（如RGB332或RGB565格式）。
• 端口B（读端口）：由VGA控制器读取，地址由VGA控制器生成的pixel_x和pixel_y实时计算得出。
• 关键点：双端口操作允许读写同时进行，互不干扰，这是实现实时显示的基础。需要根据FPGA的BRAM资源大小决定颜色深度和分辨率。

module frame_buffer ( input wire clk, // 端口A：写操作 (来自GPU) input wire we_a, input wire [16:0] addr_a, // 地址宽度由分辨率决定：640*480=307200 < 2^19 input wire [7:0] data_a, // 数据宽度，例如8位RGB332 // 端口B：读操作 (来自VGA控制器) input wire [16:0] addr_b, output reg [7:0] data_b ); // 使用Verilog数组模拟BRAM reg [7:0] mem [0:307199]; // 640*480大小的存储器 // 端口A：同步写 always @(posedge clk) begin if (we_a) begin mem[addr_a] <= data_a; end end // 端口B：同步读 always @(posedge clk) begin data_b <= mem[addr_b]; end endmodule

注意：在实际的FPGA项目中，我们通常使用Vivado的IP Catalog来生成一个真正的双端口BRAM IP核，其接口和性能都更优。上述代码仅为行为描述。

3.2.3 指令解析与FIFO (uart_cmd_parser.v,instruction_fifo.v)

• UART解析器：负责接收上位机通过串口发送的字节流，并将其组装成完整的绘图指令。指令格式需要预先定义，例如：
  • 0x01, X_high, X_low, Y_high, Y_low, Color-> 画点指令。
  • 0x02, X0, Y0, X1, Y1, Color-> 画线指令。
  • 0x03, X, Y, Width, Height, Color-> 画矩形指令。
• 指令FIFO：作为一个缓冲队列，解决UART接收速度（较慢）与GPU处理速度（较快）不匹配的问题，防止指令丢失。

3.2.4 GPU核心流水线 (gpu_top.v,rasterizer.v等)

这是最复杂的部分，我们将一个绘图命令（如画三角形）分解为多个阶段。

1. 指令解码：从FIFO中取出指令，解析出操作码（画点、画线、画三角）和操作数（坐标、颜色）。
2. 顶点处理：对于三角形，接收三个顶点坐标。这里可以进行简单的视图变换（本项目暂不涉及）。
3. 三角形设置/光栅化：这是核心算法。以画线（Bresenham算法）和三角形填充（扫描线算法）为例。
   • Bresenham画线算法：效率高，仅使用整数运算。核心是计算决策参数，决定下一个像素是(x+1, y)还是(x+1, y+1)。
   • 三角形扫描线填充：找出三角形Y轴范围，对每一行扫描线，计算与三角形边界的两个交点X_left和X_right，然后填充该行从X_left到X_right的所有像素。
4. 片段处理/着色：对于光栅化生成的每个像素位置（片段），决定其颜色。在本简易GPU中，可以简单地使用指令中指定的固定颜色，或者根据纹理坐标（如果实现）进行查表。

4. 从零开始：第一个可运行版本实战

让我们从绘制一个最简单的图形——一个固定位置的矩形——开始，打通从指令到显示的完整链路。

4.1 步骤一：搭建VGA显示框架

首先，确保VGA控制器和帧缓存能正常工作，在屏幕上显示一个静态的测试图案（如颜色渐变或棋盘格）。

1. 创建Vivado工程，选择Basys3开发板和XC7A35T芯片。
2. 编写vga_controller.v，实现上述时序逻辑。
3. 使用IP Catalog生成一个真正的双端口BRAM。
   • 类型：True Dual Port RAM。
   • 端口宽度：8位（RGB332），深度：307200（640*480）。
   • 操作模式：Write First 或 No Change。
   • 将端口A连接至后续GPU的写逻辑，端口B连接至VGA控制器的读地址。
4. 编写顶层模块，实例化VGA控制器和BRAM，并将BRAM的输出数据转换为模拟的RGB信号（通过FPGA的PMOD接口或板载VGA DAC，Basys3需要外接VGA模块或使用PMOD to VGA适配器）。
5. 添加约束文件，将vga_hsync,vga_vsync,vga_red,vga_green,vga_blue等信号映射到正确的FPGA引脚。
6. 生成比特流并下载到FPGA。此时，如果BRAM初始内容为0，屏幕应为黑色。我们可以写一个简单的初始化模块，在复位时向BRAM中写入一个测试图案（例如，根据坐标(x+y)%2决定黑白，生成棋盘格）。

// 顶层模块示例片段：连接VGA控制器和BRAM module top ( input wire clk_100mhz, input wire reset, output wire vga_hsync, output wire vga_vsync, output wire [3:0] vga_red, // Basys3的VGA DAC是4位每色 output wire [3:0] vga_green, output wire [3:0] vga_blue ); wire [16:0] vga_read_addr; wire [7:0] vga_pixel_data; wire [16:0] gpu_write_addr; wire [7:0] gpu_write_data; wire gpu_write_en; vga_controller u_vga_ctrl ( .clk(clk_25mhz), // 需要25MHz像素时钟，由时钟分频产生 .reset(reset), .vga_hsync(vga_hsync), .vga_vsync(vga_vsync), .pixel_x(/*连接到vga_read_addr的高位*/), .pixel_y(/*连接到vga_read_addr的低位*/), .video_active(/*用于控制RGB输出*/) ); // 将像素坐标转换为线性地址 assign vga_read_addr = vga_pixel_y * 640 + vga_pixel_x; // 实例化BRAM IP核 (端口命名可能不同) blk_mem_gen_0 u_frame_buffer ( .clka(clk_100mhz), .addra(gpu_write_addr), .dina(gpu_write_data), .wea(gpu_write_en), .clkb(clk_25mhz), .addrb(vga_read_addr), .doutb(vga_pixel_data) ); // 将8位RGB332数据转换为12位RGB444 assign vga_red = {vga_pixel_data[7:5], 1‘b0}; // 粗略转换 assign vga_green = {vga_pixel_data[4:2], 1’b0}; assign vga_blue = {vga_pixel_data[1:0], 2‘b00}; // 测试图案生成器模块 (在复位后向BRAM写入棋盘格) test_pattern_gen u_test_gen ( .clk(clk_100mhz), .reset(reset), .fb_addr(gpu_write_addr), .fb_data(gpu_write_data), .fb_we(gpu_write_en) ); endmodule

4.2 步骤二：实现指令接收与解析

接下来，实现UART接收和指令解析，让PC可以控制FPGA。

1. 编写UART接收模块：实现一个标准的参数化UART接收器（如115200波特率，8N1）。
2. 定义绘图指令集：

   // C语言或Python中的定义，需与Verilog解析器一致 #define CMD_DRAW_PIXEL 0x01 #define CMD_DRAW_LINE 0x02 #define CMD_DRAW_RECT 0x03 #define CMD_DRAW_TRI 0x04 #define CMD_CLEAR_SCREEN 0xFF

3. 编写指令解析器：它是一个状态机，根据接收到的字节序列判断当前指令是否完整，然后输出指令有效信号和指令数据包。

   module cmd_parser ( input wire clk, input wire rst, input wire [7:0] uart_rx_data, input wire uart_rx_valid, output reg cmd_valid, output reg [7:0] cmd_opcode, output reg [31:0] cmd_data // 具体格式根据指令定义 ); reg [2:0] state; reg [7:0] byte_buffer [0:7]; reg [3:0] byte_cnt; parameter ST_IDLE = 0, ST_RECV_OPCODE = 1, ST_RECV_DATA = 2, ST_CMD_READY = 3; always @(posedge clk or posedge rst) begin if (rst) begin state <= ST_IDLE; cmd_valid <= 1'b0; end else begin case(state) ST_IDLE: if (uart_rx_valid) begin byte_buffer[0] <= uart_rx_data; cmd_opcode <= uart_rx_data; byte_cnt <= 4'd1; state <= ST_RECV_DATA; end ST_RECV_DATA: if (uart_rx_valid) begin byte_buffer[byte_cnt] <= uart_rx_data; if (byte_cnt == `CMD_BYTE_LEN-1) begin // 根据opcode判断长度 // 组装cmd_data cmd_valid <= 1'b1; state <= ST_CMD_READY; end else begin byte_cnt <= byte_cnt + 1; end end ST_CMD_READY: begin cmd_valid <= 1'b0; state <= ST_IDLE; end endcase end end endmodule

4. 编写上位机测试程序（Python示例）：

   import serial import struct import time class GPUDriver: def __init__(self, port='COM3', baudrate=115200): self.ser = serial.Serial(port, baudrate, timeout=1) time.sleep(2) # 等待串口初始化 def send_cmd(self, opcode, data_bytes): """发送一条指令""" packet = bytes([opcode]) + data_bytes self.ser.write(packet) print(f"Sent: {packet.hex()}") def draw_pixel(self, x, y, color): """发送画点指令""" data = struct.pack('>HHB', x, y, color) # 大端序，2字节x，2字节y，1字节颜色 self.send_cmd(0x01, data) def draw_rect(self, x, y, w, h, color): """发送画矩形指令""" data = struct.pack('>HHHHB', x, y, w, h, color) self.send_cmd(0x03, data) def clear_screen(self, color=0): """清屏""" self.send_cmd(0xFF, bytes([color])) if __name__ == '__main__': gpu = GPUDriver('COM3') gpu.clear_screen(0) # 黑色清屏 time.sleep(0.1) gpu.draw_rect(100, 100, 200, 150, 0xE0) # 画一个红色矩形 (RGB332: 0xE0 = 111_000_00) gpu.ser.close()

4.3 步骤三：实现第一个绘图模块——矩形填充

现在，让GPU核心能够解析并执行画矩形指令。

1. 在GPU顶层模块中，实例化指令解析器和矩形绘制模块。
2. 编写draw_rectangle.v模块：
   • 输入：指令解析器输出的矩形参数（左上角x,y，宽度w，高度h，颜色color）。
   • 输出：向帧缓存的写地址、写数据和写使能信号。
   • 算法：使用两个嵌套循环（for y, for x），遍历矩形内的每一个像素，计算其线性地址，并输出颜色数据。注意：在硬件中，我们使用状态机来实现循环，而不是软件中的for循环。

   module draw_rectangle ( input wire clk, input wire rst, input wire start, input wire [15:0] x, y, w, h, input wire [7:0] color, output reg done, output reg fb_we, output reg [16:0] fb_addr, output reg [7:0] fb_data ); reg [15:0] curr_x, curr_y; reg state; parameter ST_IDLE = 0, ST_DRAWING = 1; always @(posedge clk or posedge rst) begin if (rst) begin state <= ST_IDLE; fb_we <= 1'b0; done <= 1'b0; end else begin case(state) ST_IDLE: if (start) begin curr_x <= x; curr_y <= y; state <= ST_DRAWING; done <= 1'b0; end ST_DRAWING: begin fb_we <= 1'b1; fb_addr <= curr_y * 640 + curr_x; // 计算地址 fb_data <= color; // 更新坐标 if (curr_x == x + w - 1) begin curr_x <= x; if (curr_y == y + h - 1) begin state <= ST_IDLE; done <= 1'b1; fb_we <= 1'b0; end else begin curr_y <= curr_y + 1; end end else begin curr_x <= curr_x + 1; end end endcase end end endmodule

   重要优化：上述简单状态机每个时钟周期只处理一个像素，绘制大矩形会很慢。实际可以设计为流水线或增加处理带宽（如一次计算一行像素的地址范围）。
3. 集成与测试：将矩形绘制模块连接到指令解析器。当解析到CMD_DRAW_RECT时，启动该模块。运行上位机程序，观察屏幕是否出现指定位置和颜色的矩形。

4.4 步骤四：实现更复杂的图形——直线与三角形

在矩形绘制成功后，可以挑战更复杂的图元。

1. 直线绘制（Bresenham算法）：
   • 算法核心是避免浮点运算，用整数误差项决定下一个像素点。
   • 需要处理所有八分圆（不同斜率）的情况。硬件实现时，状态机需要根据斜率的正负、绝对值大小来选择合适的步进方向。
2. 三角形填充（扫描线算法）：
   • 步骤1：顶点排序。按Y坐标对三个顶点进行排序，确定top, middle, bottom。
   • 步骤2：计算边方程。为每条边计算dx, dy以及用于判断像素是否在三角形内的边函数。
   • 步骤3：扫描线循环。从y_top到y_bottom，对每条扫描线，计算与两条活动边的交点x_left和x_right。
   • 步骤4：水平填充。从x_left到x_right填充像素。
   • 硬件实现挑战：需要计算斜率（涉及除法）、维护活动边表（AET）。为了简化，可以预先用软件计算好三角形的所有像素坐标，然后通过指令流发送给GPU，GPU只做填充操作。但这失去了硬件加速的意义。一个折中方案是使用固定点小数来表示斜率和交点，避免浮点除法。

5. 开发过程中的“血泪史”与常见问题排查

自制GPU的过程绝非一帆风顺，以下是笔者踩过的一些典型“坑”及其解决方案。

5.1 时序与同步问题

5.2 功能与算法问题

5.3 调试技巧心得

1. 仿真优先：在综合和上板之前，务必用iverilog进行充分的功能仿真。编写全面的testbench，覆盖各种指令和边界情况。
2. 善用ILA：Vivado的ILA是硬件调试的神器。可以将关键内部信号（状态机状态、计数器、地址、数据）添加到ILA核中，上板后实时抓取波形，与仿真结果对比。
3. 增量开发：不要试图一次性实现所有功能。遵循“VGA显示 -> 静态图案 -> 串口控制 -> 画点 -> 画矩形 -> 画线 -> 画三角形”的路径，每步都确保稳定。
4. 视觉化调试：除了看波形，直接看屏幕输出是最直观的。可以设计一些简单的诊断图案，比如用不同颜色绘制屏幕四边和中心十字线，快速定位坐标系统是否正确。

6. 优化、扩展与工程实践建议

当基本功能跑通后，可以从以下几个方面进行优化和扩展，使其更接近一个实用的图形加速器。

6.1 性能优化

1. 流水线化：将绘图流水线的各个阶段（取指、解码、顶点处理、光栅化、片段着色）拆分开，让它们可以同时处理不同图元的不同阶段，大幅提高吞吐量。
2. 增加处理带宽：让光栅化器一次输出一个2x2或4x4的像素块（Fragment Quad），而不是单个像素。片段着色器也相应地进行并行处理。
3. 指令集优化：定义更高效的指令编码，支持批量绘制（如DrawTriangleStrip）、设置渲染状态（颜色、混合模式）等，减少CPU-GPU之间的通信开销。
4. 使用块RAM（BRAM）的特性：FPGA的BRAM通常支持宽位读写。可以将颜色深度从8位提高到16位（RGB565），或者利用双端口特性实现更复杂的缓存机制。

6.2 功能扩展

1. 几何变换：在顶点处理阶段加入一个简单的变换矩阵乘法单元，实现2D图形的平移、旋转和缩放。
2. 纹理映射：增加一个纹理内存（另一块BRAM）和纹理坐标插值单元。片段着色器根据插值后的纹理坐标，从纹理内存中取出颜色，代替固定颜色。
3. 简单的3D渲染：将顶点坐标扩展到3维（x,y,z），实现正交投影或极简的透视投影。虽然仍然是2D光栅化，但可以绘制具有深度信息的线框模型。
4. 接入软核CPU：将UART指令接口替换为AXI4-Lite或Wishbone总线接口，让FPGA内的软核CPU（如MicroBlaze）能够像访问内存一样直接向GPU发送指令，构建一个真正的片上系统（SoC）。

6.3 工程化与代码管理建议

1. 参数化设计：使用Verilog的parameter和localparam来定义屏幕分辨率、颜色深度、内存大小等，使得设计易于移植到不同的FPGA平台。
2. 清晰的模块接口：为每个模块编写详细的注释，说明其功能、输入输出信号的含义和时序。使用一致的命名规范（如_i表示输入，_o表示输出）。
3. 版本控制：使用Git管理代码，特别是当设计变得复杂时。为每个主要功能（如VGA显示、画线、画三角）创建独立的分支进行开发。
4. 自动化测试：除了上板测试，建立一套基于仿真的自动化测试套件，对每个绘图模块进行回归测试，确保修改不会破坏原有功能。
5. 文档记录：维护一个项目日志，记录每次遇到的问题、解决方案和设计决策。这不仅是给自己的备忘，也是未来分享和复盘的重要资料。

历时半年的“硬件狂奔”至此告一段落。从点亮第一个像素，到画出流畅的线条和填充的三角形，每一步都充满了挑战与突破。这个自制的GPU虽然性能微不足道，功能也极其简陋，但它像一扇窗，让我得以窥见现代图形处理器庞大帝国的一角。通过这个项目，我不仅学会了Verilog和FPGA开发流程，更重要的是，对图形渲染的底层原理、软硬件协同的思维方式有了刻骨铭心的理解。如果你也对硬件、对图形学充满好奇，不妨也尝试踏上这条从零开始的创造之路。最初的几步或许艰难，但当你亲手绘制的图形在屏幕上亮起时，那种成就感是无与伦比的。项目所有的源代码、设计文档和测试程序都已开源，希望能成为你探索之旅的一块垫脚石。