tinywebserver buffer模块 缓冲区

已于 2024-05-24 11:35:32 修改
阅读量379 收藏 6
点赞数 4
分类专栏： tinywebserver 文章标签： c++ 服务器
于 2024-05-24 11:34:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/endangered_ds/article/details/139169455
版权

项目源网站 tinywebserver。这个模块是缓冲区模块，相比于TCP UDP的循环队列，这个缓冲区的操作牺牲了一部分存储空间的重复利用，更加的直白易懂。

代码

头文件

/*
 * @Author       : mark
 * @Date         : 2020-06-26
 * @copyleft Apache 2.0
 */ 

#ifndef BUFFER_H
#define BUFFER_H
#include <cstring>   //perror
#include <iostream>
#include <unistd.h>  // write
#include <sys/uio.h> //readv
#include <vector> //readv
#include <atomic>
#include <assert.h>
class Buffer {
public:
    Buffer(int initBuffSize = 1024);
    ~Buffer() = default;

    size_t WritableBytes() const;       
    size_t ReadableBytes() const ;
    size_t PrependableBytes() const;

    const char* Peek() const;
    void EnsureWriteable(size_t len);
    void HasWritten(size_t len);

    void Retrieve(size_t len);
    void RetrieveUntil(const char* end);

    void RetrieveAll() ;
    std::string RetrieveAllToStr();

    const char* BeginWriteConst() const;
    char* BeginWrite();

    void Append(const std::string& str);
    void Append(const char* str, size_t len);
    void Append(const void* data, size_t len);
    void Append(const Buffer& buff);

    ssize_t ReadFd(int fd, int* Errno);
    ssize_t WriteFd(int fd, int* Errno);

private:
    char* BeginPtr_();
    const char* BeginPtr_() const;
    void MakeSpace_(size_t len);

    // buffer_start         readPos_         writePos_         buffer_end
    // |----------------------|-------------------|-------------------|
    // |                      |       数据        |                   |
    std::vector<char> buffer_;
    std::atomic<std::size_t> readPos_;  //读指针的位置 [readPos_, writePos_) 这一块是可读的正确的数据
    std::atomic<std::size_t> writePos_; //写指针的位置 [writePos_, buffer_end) 这一块是空闲区域
};

#endif //BUFFER_H

源文件

/*
 * @Author       : mark
 * @Date         : 2020-06-26
 * @copyleft Apache 2.0
 */
#include "buffer.h"

Buffer::Buffer(int initBuffSize) : buffer_(initBuffSize), readPos_(0), writePos_(0) {}

size_t Buffer::ReadableBytes() const
{
    // 可以读的大小
    return writePos_ - readPos_;
}
size_t Buffer::WritableBytes() const
{
    // 可以写的大小
    return buffer_.size() - writePos_;
}

size_t Buffer::PrependableBytes() const
{
    return readPos_;
}

const char *Buffer::Peek() const
{
    return BeginPtr_() + readPos_;
}

void Buffer::Retrieve(size_t len)
{
    //取回数据readPos_到readPos_+len-1的数据
    assert(len <= ReadableBytes());
    readPos_ += len;
}

void Buffer::RetrieveUntil(const char *end)
{
    //取回数据readPos_到end之间的数据
    assert(Peek() <= end);
    Retrieve(end - Peek());
}

void Buffer::RetrieveAll()
{
    //清空buffer_
    bzero(&buffer_[0], buffer_.size()); // 把buffer_里的数据全部设为0
    readPos_ = 0;
    writePos_ = 0;
}

std::string Buffer::RetrieveAllToStr()
{
    //将缓冲区所有的数据都转换成str
    std::string str(Peek(), ReadableBytes());
    RetrieveAll();
    return str;
}

const char *Buffer::BeginWriteConst() const
{
    return BeginPtr_() + writePos_;
}

char *Buffer::BeginWrite()
{
    return BeginPtr_() + writePos_;
}

void Buffer::HasWritten(size_t len)
{
    writePos_ += len;
}

void Buffer::Append(const std::string &str)
{
    Append(str.data(), str.length());
}

void Buffer::Append(const void *data, size_t len)
{
    assert(data);
    Append(static_cast<const char *>(data), len);
}

void Buffer::Append(const char *str, size_t len)
{
    // 把数据[str, str+len)放到buffer_里
    assert(str);
    EnsureWriteable(len);
    std::copy(str, str + len, BeginWrite());
    HasWritten(len);
}

void Buffer::Append(const Buffer &buff)
{
    Append(buff.Peek(), buff.ReadableBytes());
}

void Buffer::EnsureWriteable(size_t len)
{
    // 确保buffer_里有足够的空间，有的话就返回，没有的话就扩大buffer_
    if (WritableBytes() < len)
    {
        MakeSpace_(len);
    }
    assert(WritableBytes() >= len);
}

ssize_t Buffer::ReadFd(int fd, int *saveErrno)
{
    // 把数据从fd读入buffer
    char buff[65535];
    struct iovec iov[2];
    const size_t writable = WritableBytes();

    iov[0].iov_base = BeginPtr_() + writePos_;
    iov[0].iov_len = writable;
    iov[1].iov_base = buff;
    iov[1].iov_len = sizeof(buff);

    const ssize_t len = readv(fd, iov, 2); // 分散读，先把数据放到buffer_里，溢出了之后放到buff里
    if (len < 0)
    {
        *saveErrno = errno;
    }
    else if (static_cast<size_t>(len) <= writable)
    {
        writePos_ += len;
    }
    else
    {
        writePos_ = buffer_.size();
        Append(buff, len - writable);
    }
    return len;
}

ssize_t Buffer::WriteFd(int fd, int *saveErrno)
{
    //将buffer_里的数据写到fd
    size_t readSize = ReadableBytes();
    ssize_t len = write(fd, Peek(), readSize);
    if (len < 0)
    {
        *saveErrno = errno;
        return len;
    }
    readPos_ += len;
    return len;
}

char *Buffer::BeginPtr_()
{
    return &*buffer_.begin();
}

const char *Buffer::BeginPtr_() const
{
    return &*buffer_.begin();
}

void Buffer::MakeSpace_(size_t len)
{
    if (WritableBytes() + PrependableBytes() < len)
    {
        // 如果buffer不够用了，就扩大buffer
        // buffer_begin           readPos_           writePos_     buffer_end  -->
        // buffer_begin           readPos_           writePos_                       buffer_end+len
        buffer_.resize(writePos_ + len + 1);
    }
    else
    {
        // 够用，把数据搬移到buffer_begin
        //  buffer_begin           readPos_           writePos_     buffer_end  -->
        //  readPos_           writePos_                            buffer_end

        size_t readable = ReadableBytes();
        std::copy(BeginPtr_() + readPos_, BeginPtr_() + writePos_, BeginPtr_());
        readPos_ = 0;
        writePos_ = readPos_ + readable;
        assert(readable == ReadableBytes());
    }
}

缓冲区定义，读，写

缓冲区的定义

    // buffer_start         readPos_         writePos_         buffer_end
    // |----------------------|-------------------|-------------------|
    // |                      |       数据        |                   |
    std::vector<char> buffer_;
    std::atomic<std::size_t> readPos_;  //读指针的位置 [readPos_, writePos_) 这一块是可读的正确的数据
    std::atomic<std::size_t> writePos_; //写指针的位置 [writePos_, buffer_end) 这一块是空闲区域

用vector buffer_相当于就是一串存储一个字节的数据，就是缓冲区。
readPos_ 和 writePos_之间的，就是有效的数据。

从fd里读数据到缓冲区

读数据就是把writePos_向后移动，直到移动到末尾，不够就扩容

ssize_t Buffer::ReadFd(int fd, int *saveErrno)
{
    // 把数据从fd读入buffer
    char buff[65535];
    struct iovec iov[2];
    const size_t writable = WritableBytes();

    iov[0].iov_base = BeginPtr_() + writePos_;
    iov[0].iov_len = writable;
    iov[1].iov_base = buff;
    iov[1].iov_len = sizeof(buff);

    const ssize_t len = readv(fd, iov, 2); // 分散读，先把数据放到buffer_里，溢出了之后放到buff里
    if (len < 0)
    {
        *saveErrno = errno;
    }
    else if (static_cast<size_t>(len) <= writable)
    {
        writePos_ += len;
    }
    else
    {
        writePos_ = buffer_.size();
        Append(buff, len - writable);
    }
    return len;
}

这里他比较高明的地方在于，用了readv这个函数，先把数据读到缓冲区，缓冲区溢出了之后，扩容，再把溢出来的数据添加到缓冲区里。避免了开始的时候要对fd里的数据大小进行判断。

  • Append
void Buffer::Append(const std::string &str)
{
    Append(str.data(), str.length());
}

void Buffer::Append(const void *data, size_t len)
{
    assert(data);
    Append(static_cast<const char *>(data), len);
}

void Buffer::Append(const char *str, size_t len)
{
    // 把数据[str, str+len)放到buffer_里
    assert(str);
    EnsureWriteable(len);
    std::copy(str, str + len, BeginWrite());
    HasWritten(len);
}

void Buffer::Append(const Buffer &buff)
{
    Append(buff.Peek(), buff.ReadableBytes());
}

这几个Append都是一个，把const char *str里读取len的数据到缓冲区

把缓冲区的数据写到fd里

  • WriteFd
ssize_t Buffer::WriteFd(int fd, int *saveErrno)
{
    //将buffer_里的数据写到fd
    size_t readSize = ReadableBytes();
    ssize_t len = write(fd, Peek(), readSize);
    if (len < 0)
    {
        *saveErrno = errno;
        return len;
    }
    readPos_ += len;
    return len;
}

这没啥好说的，就是把数据写到fd里

  • Retrive
void Buffer::Retrieve(size_t len)
{
    //取回数据readPos_到readPos_+len-1的数据
    assert(len <= ReadableBytes());
    readPos_ += len;
}

void Buffer::RetrieveUntil(const char *end)
{
    //取回数据readPos_到end之间的数据
    assert(Peek() <= end);
    Retrieve(end - Peek());
}

void Buffer::RetrieveAll()
{
    //清空buffer_
    bzero(&buffer_[0], buffer_.size()); // 把buffer_里的数据全部设为0
    readPos_ = 0;
    writePos_ = 0;
}

这三个Retrive函数，就是把已经写入的数据，撤回来，将其标记为无效数据，就是把readPos_向后移size个字节。

扩容函数

这个MakeSpace_函数只在Append 的时候调用

void Buffer::MakeSpace_(size_t len)
{
    if (WritableBytes() + PrependableBytes() < len)
    {
        // 如果buffer不够用了，就扩大buffer
        // buffer_begin           readPos_           writePos_     buffer_end  -->
        // buffer_begin           readPos_           writePos_                       buffer_end+len
        buffer_.resize(writePos_ + len + 1);
    }
    else
    {
        // 够用，把数据搬移到buffer_begin
        //  buffer_begin           readPos_           writePos_     buffer_end  -->
        //  readPos_           writePos_                            buffer_end

        size_t readable = ReadableBytes();
        std::copy(BeginPtr_() + readPos_, BeginPtr_() + writePos_, BeginPtr_());
        readPos_ = 0;
        writePos_ = readPos_ + readable;
        assert(readable == ReadableBytes());
    }
}
  • 缓冲区的数据够用，writePos_后面的空间够了
  • 缓冲区的数据够用，writePos_后面的空间不够 --> 将readPos_ 到writePos_的数据移动到缓冲区的头部
  • 缓冲区的数据不够用，建一个新的vector，将writePos_到writePos_数据复制过去，然后扩容
    这就是比较高明的地方，循环队列每次添加的时候都要判断当前指针是不是到了末尾，就很麻烦，这种简单的方法减少了判断。

测试代码

gtest

#include <gtest/gtest.h>
#include <string>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "buffer.h"

namespace WebServerTest
{
    using namespace std;
    // 匿名空间，避免命名冲突
    class BufferTest : public testing::Test
    {
    protected:
        void SetUp() override
        {
            buffer_.RetrieveAll(); // 清空缓冲区
            file_data_ = "file write test";
        }

        Buffer buffer_;
        string file_data_;
    };

    TEST_F(BufferTest, InintState)
    {
        // 初始状态下的测试
        EXPECT_EQ(buffer_.ReadableBytes(), 0);    // 初始状态下，缓冲区为空
        EXPECT_EQ(buffer_.WritableBytes(), 1024); // 初始状态下，可写字节数为1024
        EXPECT_EQ(buffer_.PrependableBytes(), 0); // 初始状态下，头部预留字节数为0

        EXPECT_EQ(buffer_.BeginWrite(), buffer_.Peek()); // 初始状态下，开始写指针与Peek指针相同
    };

    TEST_F(BufferTest, AppendData)
    {
        // 添加数据

        const char *str = "Hello, World!";
        buffer_.Append(str, strlen(str)); // 添加字符串

        EXPECT_EQ(buffer_.ReadableBytes(), strlen(str));        // 可读字节数等于添加的字符串长度
        EXPECT_EQ(buffer_.WritableBytes(), 1024 - strlen(str)); // 可写字节数等于1024减去添加的字符串长度
        EXPECT_EQ(buffer_.PrependableBytes(), 0);               // 头部预留字节数为0
        EXPECT_EQ(0, strcmp(buffer_.Peek(), str));              // Peek指针指向添加的字符串开头

        buffer_.Append("1234567890", 10); // 添加10个字符

        EXPECT_EQ(buffer_.ReadableBytes(), strlen(str) + 10);        // 可读字节数等于添加的字符串长度加10
        EXPECT_EQ(buffer_.WritableBytes(), 1024 - strlen(str) - 10); // 可写字节数等于1024减去添加的字符串长度减去10
        EXPECT_EQ(buffer_.PrependableBytes(), 0);                    // 头部预留字节数为0
    }
    TEST_F(BufferTest,AppendDataOverflow){
        // 添加数据溢出
        Buffer small_buffer(10);
        const char *str = "aaaa aaaa aaaa";
        small_buffer.Append(str, strlen(str));
        EXPECT_EQ(small_buffer.ReadableBytes(), strlen(str));
        EXPECT_EQ(small_buffer.WritableBytes(), 1);

        string res_str=small_buffer.RetrieveAllToStr();
        EXPECT_STREQ(res_str.c_str(),str);

        int fd = open("append_data_overflow.txt", O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);  // 创建一个名为 output.txt 的文件
        if (fd < 0) {
            cerr << "Failed to open file for writing.";
        }
        string new_data="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        int ret = write(fd,new_data.c_str(),new_data.size());
        if(ret<0){
            cerr<<"Failed to write data to file."<<endl;
        }
        close(fd);  // 关闭文件描述符

        int fd_read = open("append_data_overflow.txt", O_RDONLY);
        int Errno = 0;
        small_buffer.ReadFd(fd_read,&Errno);
        if(Errno!=0){
            cerr<<"Failed to read data from file."<<endl;
        }
        close(fd_read);  // 关闭文件描述符

        EXPECT_STREQ(new_data.c_str(),small_buffer.Peek());
    }

    TEST_F(BufferTest, Retrive)
    {

        // 回退数据
        string str = "Hello, World!1234567890";
        buffer_.Append(str);
        EXPECT_EQ(buffer_.RetrieveAllToStr(), str);
        // 数据等于 初始状态下的测试
        EXPECT_EQ(buffer_.ReadableBytes(), 0);
        EXPECT_EQ(buffer_.WritableBytes(), 1024);
        EXPECT_EQ(buffer_.PrependableBytes(), 0);

        EXPECT_EQ(buffer_.BeginWrite(), buffer_.Peek());

        buffer_.Append(str);
        buffer_.Retrieve(5); // 回退5个字节

        EXPECT_EQ(buffer_.ReadableBytes(), str.size() - 5);    // 可读字节数等于添加的字符串长度减去5
        EXPECT_EQ(buffer_.WritableBytes(), 1024 - str.size()); // 可写字节数等于1024减去添加的字符串长度加5
        EXPECT_EQ(buffer_.PrependableBytes(), 5);              // 头部预留字节数为5
        EXPECT_EQ(0, strcmp(buffer_.Peek(), str.c_str() + 5)); // Peek指针指向回退后的字符串开头
    }

    TEST_F(BufferTest, Append)
    {
        // 添加数据
        const char *str = "Hello, World!";
        buffer_.Append(str, strlen(str)); // 添加字符串
        EXPECT_STREQ(str, buffer_.Peek());
        buffer_.RetrieveAll();

        string str2 = "1234567890";
        buffer_.Append(str2);
        EXPECT_STREQ(str2.c_str(), buffer_.Peek());
        buffer_.RetrieveAll();

        void *ptr=(void *)str;
        buffer_.Append(ptr, strlen(str));
        EXPECT_STREQ(str, buffer_.Peek());
        buffer_.RetrieveAll();
    }

        // 测试 WriteFd 函数
    TEST_F(BufferTest, WriteFdTest) {
        int fd = open("write_fd_test.txt", O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);  // 创建一个名为 output.txt 的文件
        if (fd < 0) {
            cerr<< "Failed to open file for writing.";
        }

        buffer_.Append(file_data_);  // 添加字符串
        int Errno = 0;
        ssize_t ret = buffer_.WriteFd(fd, &Errno);
        EXPECT_EQ(Errno, 0);
        EXPECT_GE(ret, file_data_.size());  
        close(fd);  // 关闭文件描述符

        //测试文件的内容是否正确
        int fd2 = open("write_fd_test.txt", O_RDONLY);
        char buffer[1024];
        ret = read(fd2, buffer, 1024);
        buffer[ret] = '\0';
        EXPECT_STREQ(file_data_.c_str(), buffer);
        close(fd2);  // 关闭文件描述符
    }

    TEST_F(BufferTest, ReadData){
        // 读取数据
        int fd2 = open("write_fd_test.txt", O_RDONLY);
        int Errno = 0;
        buffer_.ReadFd(fd2,&Errno);
        
        close(fd2);  // 关闭文件描述符
        EXPECT_STREQ(file_data_.c_str(), buffer_.Peek());
    }

};
木建隶
关注
  • 4
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
nodejs基础之buffer缓冲区用法分析
10-17
主要介绍了nodejs基础之buffer缓冲区用法,结合实例形式分析了buffer缓冲区的概念、功能、创建、读写等相关操作技巧,需要的朋友可以参考下
详细了解JAVA NIO之Buffer（缓冲区）
08-18
主要介绍了JAVA NIO之Buffer（缓冲区）的相关资料，文中讲解非常细致，帮助大家更好的学习JAVA NIO，感兴趣的朋友可以了解下
TinyWebServer
weixin_45045804的博客
10-24 3236
tinywebserver
Web服务器---TinyWebServer代码详细讲解（http模块）
qq_38872537的博客
01-27 5313
TinyWebServer代码详细讲解（http模块）http模块设计思路http_conn.cppread业务函数集process_read函数parse_request_line函数总结 这里的参照的代码是https://github.com/qinguoyi/TinyWebServer 对于原代码的不足之处，我会在之后的文章中给出改进代码 在笔者fork的这版中，原代码作者对于代码作出了更细化的分类 细节问题可以参考《APUE》《Linux高性能服务器编程》或者我之前的博客 毋庸置疑，http模块
TinyWebServer1--HTTP代码部分
zhaojiazb的博客
05-08 205
良好的代码习惯就是在.h中构建出全部的功能框架，然后在.cpp中完成实现
从零开始实现C++ TinyWebServer（三）---- 补偏救弊调试分析，日志系统来帮忙
JehanRio's Private Blog
05-04 4876
一个合格的Web服务器当然少不了日志系统了。正如标题所言，日志系统在整个项目中能够帮助调试、错误定位、数据分析。我们想设计一个日志模块，他能顺利写日志但是又不要占用主线程时间去写，所以我们设计异步写日志的模块。从零开始实现C++ TinyWebServer 全过程记录。
从零开始实现C++ TinyWebServer（九）---- 项目知识点总结
JehanRio's Private Blog
05-09 9196
这一两天效率感觉挺低的，我发现这个项目还有挺多小问题的，很多代码的逻辑判断有点冗余。我去除了一些没必要的判断，东捣鼓一下西捣鼓一下，昨天进行压测的时候居然能达到8K并发量了，算是一个小进步了吧。哦对了，平时说的QPS就是最后的，这一点别和并发量搞混淆了。学了一下午的CMake，最终放弃了，我也不知道这是第几次放弃学CMake了，现在做项目的时候，makefile感觉还要比CMake用着简单点，嘶~
webserver学习心得
烽言烽语的博客
04-21 300
​ webserver是一个基于Linux系统的高性能服务器项目，该项目实现了对HTTP协议中GET和POST请求的解析，同时经过webbench压测，可以实现上万的QPS​ 此项目前前后后花费的时间大概有4个月，从最初的走马观花，到阅读源码，再到最后的手撕源码，几个月学习下来，让自己了解了实现一个项目的大致流程（期间还进行了单元测试），虽然这是一个开源的个人项目，但是其中涉及到Linux，计算机网络，数据库，设计模式等许多作为一个程序员必须掌握的基本内容，非常值得一学。
tinyWebServer 学习笔记——二、HTTP 连接处理
BeZer0的学习笔记
05-15 5494
从模型的角度来看，从状态机负责通用的操作处理，主状态机负责特定的操作处理，主状态机需要使用从状态机提供的数据，从状态机需要被主状态机调用，每个状态机又是一个有限状态机。有限状态机是一种抽象的理论模型，使用选择语句来实现。模型要求代码存在 n 个状态，使用当前状态。
Rec.自学路上的第一个小项目Tiny-Webserver的实现总结
m0_74932004的博客
05-06 870
*进行读写数据并调用httprequest 来解析数据以及httpresponse来生成响应*/public://初始化客户端的地址数据//从读缓冲区读数据//从写缓冲区写数据//关闭客户端的请求//接口，返回客户端的sockfd//接口，返回客户端的端口号//接口，返回客户端的IP//接口，返回客户端的sockaddr//流程函数，包含reques解析请求，response响应报文int The_WriteBytes() //获取响应报文的总大小。
WebServer 之 http连接处理（下）
IT OR 考公？
02-17 1605
请求报文 -- 解析 + 响应
huanchongqu.rar_gis_gis buffer_缓冲区
09-21
GIS缓冲区形成方法，查询分析功能(QueryEx)和创建缓冲区的功能（转）
php中的buffer缓冲区用法分析
10-16
主要介绍了php中的buffer缓冲区用法,结合实例形式分析了buffer缓冲区的概念、原理及php使用缓冲区相关存储、输出等操作技巧,需要的朋友可以参考下
C语言环行缓冲区 环形buffer
07-25
此文件是对于C语言编写环形缓冲区的编写，如何对于学习的指针使用，写一个自己的环形缓冲区，很哟意思，我得思路比较复杂，希望有好方法的多交流一下，我也学习一下
【C++提高编程-05】----C++之Deque容器实战
一伦明悦的博客
06-15 896
Deque（双端队列）是C++ STL中的一种序列容器
c++ 6.11
Johan1111的博客
06-11 278
(5)另外， RMB 类还包含一个静态整型成员变量 count，用于记录当前已创建的 RMB 对象的数量。每当创建一个新的 RMB 对象时，count 应该自增 1；(1)重载算术运算符 + 和 -，使得可以对两个 RMB 对象进行加法和减法运算，并返回一个新的 RMB 对象作为结果。(2)重载关系运算符 >，判断一个 RMB 对象是否大于另一个 RMB 对象，并返回 true 或 false。(3)重载前置减减运算符 --，使得每次调用时 RMB 对象的 yuan、jiao 和 fen 分别减 1。
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 1030
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C语言猜输赢游戏
最新发布
qq_69383179的博客
06-15 1413
这里有关于C语言猜输赢游戏的程序
Z-Buffer深度缓冲区介绍与应用
06-09
Z-Buffer深度缓冲区是一种用于实现三维图形渲染的算法，它可以在渲染过程中自动处理遮挡关系，提高图形渲染效率。 Z-Buffer深度缓冲区的原理是将场景中的每个像素都与一个深度值进行关联，深度值表示该像素在场景中的深度位置。在渲染过程中，Z-buffer算法会遍历每个像素，并比较当前像素的深度值与深度缓冲区中相应像素的深度值的大小关系，如果当前像素的深度值小于深度缓冲区中相应像素的深度值，则更新深度缓冲区中相应像素的深度值，并将当前像素的颜色值渲染到屏幕上。 Z-Buffer深度缓冲区的应用非常广泛，比如在游戏中可以用来实现场景的渲染和遮挡关系的处理；在虚拟现实、计算机辅助设计等领域也有广泛应用。此外，Z-Buffer深度缓冲区还可以与其他渲染技术结合使用，比如纹理映射、光照等技术，以实现更加逼真的三维图形渲染效果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值