渲染引擎框架代码案例

最新推荐文章于 2024-09-19 15:06:58 发布
最新推荐文章于 2024-09-19 15:06:58 发布
阅读量1.2k 收藏 11
点赞数 31
分类专栏： 游戏引擎 文章标签： 渲染引擎
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33060405/article/details/141904341
版权

实现一款完整的渲染引擎是一项庞大的工程，涉及多个复杂的技术层面。在这里，我将为你提供一个简化的渲染引擎框架代码示例，以及一些关键组件的具体实现思路。请注意，这只是一个非常基础的示例，用于教学目的，并不代表实际生产环境中渲染引擎的完整实现。

渲染引擎框架代码示例

// Renderer.h
#pragma once
#include <vector>
#include "Camera.h"
#include "Scene.h"

class Renderer {
public:
    Renderer();
    ~Renderer();

    void Render(const Scene& scene, const Camera& camera);

private:
    void Initialize();
    void Shutdown();
    void DrawScene(const Scene& scene, const Camera& camera);
};

// Renderer.cpp
#include "Renderer.h"
#include <GL/glew.h>
#include <GLFW/glfw3.h>

Renderer::Renderer() {
    Initialize();
}

Renderer::~Renderer() {
    Shutdown();
}

void Renderer::Render(const Scene& scene, const Camera& camera) {
    DrawScene(scene, camera);
}

void Renderer::Initialize() {
    // 初始化OpenGL上下文等
    if (!glfwInit()) {
        // 初始化失败处理
    }

    // 创建窗口和OpenGL上下文
    GLFWwindow* window = glfwCreateWindow(800, 600, "Simple Renderer", nullptr, nullptr);
    if (!window) {
        glfwTerminate();
        // 创建窗口失败处理
    }
    glfwMakeContextCurrent(window);

    // 初始化GLEW
    if (glewInit() != GLEW_OK) {
        // GLEW初始化失败处理
    }

    // 其他初始化操作...
}

void Renderer::Shutdown() {
    // 清理资源
    glfwTerminate();
}

void Renderer::DrawScene(const Scene& scene, const Camera& camera) {
    // 设置相机视图和投影矩阵
    glMatrixMode(GL_PROJECTION);
    glLoadMatrixf(camera.GetProjectionMatrix());
    glMatrixMode(GL_MODELVIEW);
    glLoadMatrixf(camera.GetViewMatrix());

    // 清除颜色缓冲区和深度缓冲区
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // 绘制场景中的物体
    for (const auto& object : scene.GetObjects()) {
        // 设置物体变换矩阵
        glPushMatrix();
        glMultMatrixf(object.GetTransformMatrix());

        // 绘制物体
        object.Draw();

        glPopMatrix();
    }

    // 交换缓冲区并处理事件
    glfwSwapBuffers(glfwGetCurrentContext());
    glfwPollEvents();
}

关键组件实现思路

  1. Camera（相机）类：

    • 实现相机的位置、朝向、视场角等属性。
    • 提供获取视图矩阵和投影矩阵的方法。

  2. Scene（场景）类：

    • 管理场景中的物体列表。
    • 提供添加、删除物体的方法。
    • 提供遍历场景中物体的方法。

  3. Object（物体）类：

    • 表示场景中的一个可绘制物体，如立方体、球体等。
    • 包含物体的几何数据（顶点、面等）和材质信息。
    • 提供绘制物体的方法。

  4. 材质（Material）类：

    • 表示物体的外观属性，如颜色、纹理、反射率等。
    • 提供设置和应用材质属性的方法。

  5. 光照（Light）类：

    • 表示场景中的光源，如点光源、方向光源等。
    • 包含光源的位置、颜色、强度等属性。
    • 提供计算光照贡献的方法。

注意事项

  • 上述代码示例使用了OpenGL和GLFW库，你需要确保这些库在你的开发环境中正确配置。
  • 实际的渲染引擎实现会更加复杂，包括错误处理、资源管理、性能优化等方面。
  • 为了简化示例，省略了许多细节和辅助类，如着色器管理、纹理加载等。

通过这个简化的示例，你可以初步了解渲染引擎的基本架构和关键组件的实现思路。在实际开发中，你需要根据具体需求和技术栈进行扩展和优化。

继续深入探讨渲染引擎的实现，我们可以进一步细化关键组件和功能，并提供一些具体的实现代码片段。以下是一些关键组件和功能的详细实现思路：

1. 相机（Camera）类

相机类负责管理相机的位置、朝向和视场角等属性，并提供获取视图矩阵和投影矩阵的方法。

// Camera.h
#pragma once
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>

class Camera {
public:
    Camera();
    void SetPosition(const glm::vec3& position);
    void SetLookAt(const glm::vec3& lookAt);
    void SetFOV(float fov);
    void SetAspectRatio(float aspectRatio);
    void SetNearClip(float nearClip);
    void SetFarClip(float farClip);

    glm::mat4 GetViewMatrix() const;
    glm::mat4 GetProjectionMatrix() const;

private:
    glm::vec3 position_;
    glm::vec3 lookAt_;
    float fov_;
    float aspectRatio_;
    float nearClip_;
    float farClip_;
};

// Camera.cpp
#include "Camera.h"

Camera::Camera()
    : position_(0.0f, 0.0f, 0.0f), lookAt_(0.0f, 0.0 + 1.0f, 0.0f), fov_(45.0f), aspectRatio_(1.333f), nearClip_(0.1f), farClip_(100.0f) {}

void Camera::SetPosition(const glm::vec3& position) {
    position_ = position;
}

void Camera::SetLookAt(const glm::vec + 3& lookAt) {
    lookAt_ = lookAt;
}

void Camera::SetFOV(float fov) {
    fov_ = fov;
}

void Camera::SetAspectRatio(float aspectRatio) {
    aspectRatio_ = aspectRatio;
}

void Camera::SetNearClip(float nearClip) {
    nearClip_ = nearClip;
}

void Camera::SetFarClip(float farClip) {
    farClip_ = farClip;
}

glm::mat4 Camera::GetViewMatrix() const {
    return glm::lookAt(position_, lookAt_, glm::vec3(0.0f, 1.0f, 0.0f));
}

glm::mat4 Camera::GetProjectionMatrix() const {
    return glm::perspective(glm::radians(fov_), aspectRatio_, nearClip_, farClip_);
}

2. 物体（Object）类

物体类表示场景中的一个可绘制物体，包含物体的几何数据和材质信息，并提供绘制物体的方法。

// Object.h
#pragma once
#include <vector>
#include <glm/glm.hpp>
#include "Material.h"

class Object {
public:
    Object();
    void SetTransform(const glm::mat4& transform);
    void SetMaterial(const Material& material);
    void AddVertex(const glm::vec3& vertex);
    void AddIndex(unsigned int index);
    void Draw();

private:
    std::vector<glm::vec3> vertices_;
    std::vector<unsigned int> indices_;
    glm::mat4 transform_;
    Material material_;
};

// Object.cpp
#include "Object.h"
#include <GL/glew.h>

Object::Object() {
    glGenBuffers(1, &vbo_);
    glGenBuffers(1, &ebo_);
}

void Object::SetTransform(const glm::mat4& transform) {
    transform_ = transform;
}

void Object::SetMaterial(const Material& material) {
    material_ = material;
}

void Object::AddVertex(const glm::vec3& vertex) {
    vertices_.push_back(vertex);
}

void Object::AddIndex(unsigned int index) {
    indices_.push + ()index;
}

void Object::Draw() {
    // 绑定VAO
    GLuint vao;
    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);

    // 绑定VBO和EBO
    glBindBuffer(GL_ARRAY_BUFFER, vbo_);
    glBufferData(GL_ARRAY_BUFFER, vertices_.size() * sizeof(glm::vec3), vertices_.data(), GL_STATIC_DRAW);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo_);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices_.size() * sizeof(unsigned int), indices_.data(), GL_STATIC_DRAW);

    // 设置顶点属性指针
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(glm::vec3), (void*)0);

    // 使用材质着色器
    material_.UseShader();

    // 设置模型矩阵
    GLint modelLoc = glGetUniformLocation(material_.GetShaderProgram(), "model");
    glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(transform_));

    // 绘制物体
    glDrawElements(GL_TRIANGLES, indices_.size(), GL_UNSIGNED_INT, 0);

    // 清理
    glBindVertexArray(0);
    glDeleteVertexArrays(1, &vao);
}

3. 材质（Material）类

材质类表示物体的外观属性，包含颜色、纹理、反射率等，并提供设置和应用材质属性的方法。

// Material.h
#pragma once
#include <GL/glew.h>

class Material {
public:
    Material();
    void SetShaderProgram(GLuint shaderProgram);
    void SetColor(const glm::vec3& color);
    void SetTexture(GLuint texture);
    void UseShader();

private:
    GLuint shaderProgram_;
    glm::vec3 color_;
    GLuint texture_;
};

// Material.cpp
#include "Material.h"

Material::Material()
    : shaderProgram_(0), color_(1.0f, 1.0f, 1.0f), texture_(0) {}

void Material::SetShaderProgram(GLuint shaderProgram) {
    shaderProgram_ = shaderProgram;
}

void Material::SetColor(const glm::vec3& color) {
    color_ = color;
}

void Material::SetTexture(GLuint texture) {
    texture_ + ()texture;
}

void Material::UseShader() {
    glUseProgram(shaderProgram_);
    GLint colorLoc = glGetUniformLocation(shaderProgram_, "material.color");
    glUniform3fv(colorLoc, 1, glm::value_ptr(color_));
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, texture_);
    GLint textureLoc = glGetUniformLocation(shaderProgram_, "material.texture");
    glUniform1i(textureLoc, 0);
}

4. 光照（Light）类

光照类表示场景中的光源，包含光源的位置、颜色、强度等属性，并提供计算光照贡献的方法。

// Light.h
#pragma once
#include <glm/glm.hpp>

class Light {
public:
    Light();
    void SetPosition(const glm::vec3& position);
    void SetColor(const glm::vec3& color);
    void SetIntensity(float intensity);

    glm::vec3 GetPosition() const;
    glm::vec3 GetColor() const;
    float GetIntensity() const;

private:
    glm::vec3 position_;
    glm::vec3 color_;
    float intensity_;
};

// Light.cpp
#include "Light.h"

Light::Light()
    : position_(0.0f, 0.0f, 0.0 + f), color_(1.0f, 1.0f, 1.0f), intensity_(1.0f) {}

void Light::SetPosition(const glm::vec3& position) {
    position_ = position;
}

void Light::SetColor(const glm::vec3& color) {
    color_ = color;
}

void Light::SetIntensity(float intensity) {
    intensity_ = intensity;
}

glm::vec3 Light::GetPosition() const {
    return position_;
}

glm::vec3 Light::GetColor() const {
    return color_;
}

float Light::GetIntensity() const {
    return intensity_;
}

5. 场景（Scene）类

场景类管理场景中的物体列表，并提供添加、删除物体的方法。

// Scene.h
#pragma once
#include <vector>
#include "Object.h"

class Scene {
public:
    void AddObject(const Object& object);
    void RemoveObject(const Object& object);
    const std::vector<Object>& GetObjects() const;

private:
    std::vector<Object> objects_;
};

// Scene.cpp
#include "Scene.h"

void Scene::AddObject(const Object& object) {
    objects_.push_back(object);
}

void Scene::RemoveObject(const Object& object) {
    // 简单示例，实际应用中可能需要更复杂的逻辑
    for (auto it = objects_.begin(); it != objects_.end(); ++it) {
        if (&(*it) == &object) {
            objects_.erase(it);
            break;
        }
    }
}

const std::vector<Object>& Scene::GetObjects() const {
    return objects_;
}

总结

以上代码片段展示了一个简化的渲染引擎框架及其关键组件的具体实现思路。实际的渲染引擎实现会更加复杂，涉及更多的细节和优化。以下是一些额外的注意事项：

  • 错误处理：在实际应用中，需要对各种可能的错误情况进行处理，如OpenGL调用失败、资源加载失败等。
  • 资源管理：需要有效地管理内存和GPU资源，避免内存泄漏和性能瓶颈。
  • 性能优化：需要对渲染管线进行优化，如使用实例化绘制、减少状态切换、利用GPU并行计算等。
  • 扩展性：设计时应考虑未来的扩展需求，如支持多种渲染技术、动态加载资源等。

通过这些示例和思路，你可以初步了解渲染引擎的基本架构和关键组件的实现方法。在实际开发中，你需要根据具体需求和技术栈进行扩展和优化。

继续深入探讨渲染引擎的实现，我们可以进一步讨论一些高级特性和优化技术。以下是一些关键点和代码示例：

1. 着色器管理

着色器是渲染引擎的核心组件之一，负责处理顶点和片段级别的计算。为了更好地管理着色器，我们可以创建一个着色器管理器类。

// ShaderManager.h
#pragma once
#include <GL/glew.h>
#include <string>
#include <unordered_map>

class ShaderManager {
public:
    ShaderManager();
    ~ShaderManager();

    GLuint LoadShader(const std::string& vertexShaderSource, const std::string& fragmentShaderSource);
    void UseShader(GLuint shaderProgram);

private:
    GLuint CompileShader(const std::string& source, GLenum shaderType);
    GLuint CreateShaderProgram(GLuint vertexShader, GLuint fragmentShader);

    std::unordered_map<std::string, GLuint> shaderPrograms_;
};

// ShaderManager.cpp
#include "ShaderManager.h"
#include <fstream>
#include <sstream>
#include <iostream>

ShaderManager::Shader::Shader() {}

ShaderManager::~ShaderManager() {
    for (auto& pair : shaderPrograms_) {
        glDeleteProgram(pair.second);
    }
}

GLuint ShaderManager::LoadShader(const std::string& vertexShaderSource, const std::string& fragmentShaderSource) {
    GLuint vertexShader = CompileShader(vertexShaderSource, GL_VERTEX_SHADER);
    GLuint fragmentShader = CompileShader(fragmentShaderSource, GL_FRAGMENT_SHADER);
    GLuint shaderProgram = CreateShaderProgram(vertexShader, fragmentShader);
    shaderPrograms_[vertexShaderSource + fragmentShaderSource] = shaderProgram;
    return shaderProgram;
}

void ShaderManager::UseShader(GLuint shaderProgram) {
    glUseProgram(shaderProgram);
}

GLuint ShaderManager::CompileShader(const std::string& source, GLenum shaderType) {
    GLuint shader = glCreateShader(shaderType);
    const char* src = source.c_str();
    glShaderSource(shader, 1, &src, nullptr);
    glCompileShader(shader);

    GLint success;
    glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
    if (!success) {
        GLchar infoLog[512];
        glGetShaderInfoLog(shader, 512, nullptr, infoLog);
        std::cerr << "Shader compilation failed: " << infoLog << std::endl;
    }

    return shader;
}

GLuint ShaderManager::CreateShaderProgram(GLuint vertexShader, GLuint fragmentShader) {
    GLuint shaderProgram = glCreateProgram();
    glAttachShader(shaderProgram, vertexShader);
    glAttachShader(shaderProgram, fragmentShader);
    glLinkProgram(shaderProgram);

    GLint success;
    glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
    if (!success) {
        GLchar infoLog[512];
        glGetProgramInfoLog(shaderProgram, 512, nullptr, infoLog);
        std::cerr << "Shader program linking failed: " << infoLog << std::endl;
    }

    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);

    return shaderProgram;
}

2. 纹理管理

纹理是渲染引擎中常用的资源，为了高效地管理纹理，我们可以创建一个纹理管理器类。

// TextureManager.h
#pragma once
#include <GL/glew.h>
#include <string>
#include <unordered_map>

class TextureManager {
public:
    TextureManager();
    ~TextureManager();

    GLuint LoadTexture(const std::string& filePath);
    void BindTexture(GLuint textureID, GLenum textureUnit);

private:
    std::unordered_map<std::string, GLuint> textures_;
};

// TextureManager.cpp
#include "TextureManager.h"
#include <stb_image.h>

TextureManager::TextureManager() {}

TextureManager::~TextureManager() {
    for (auto& pair : textures_) {
        glDeleteTextures(1, &pair.second);
    }
}

GLuint TextureManager::LoadTexture(const std::string& filePath) {
    GLuint textureID;
    glGenTextures(1, &textureID);
    glBindTexture(GL_TEXTURE_2D, textureID);

    int width, height, nrChannels;
    unsigned char* data = stbi_load(filePath.c_str(), &width, &height, &nrChannels, 0);
    if (data) {
        GLenum format;
        if (nrChannels == 1)
            format = GL_RED;
        else if (nrChannels == 3)
            format = GL_RGB;
        else if (nrChannels == 4)
            format = GL_RGBA;

        glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
        glGenerateMipmap(GL_TEXTURE_2 + ()2D);

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    } else {
        std::cerr << "Failed to load texture: " << filePath << std::endl;
    }
    stbi_image_free(data);

    textures_[filePath] = textureID;
    return textureID;
}

void TextureManager::BindTexture(GLuint textureID, GLenum textureUnit) {
    glActiveTexture(textureUnit);
    glBindTexture(GL_TEXTURE_2D, textureID);
}

3. 性能优化

性能优化是渲染引擎开发中的重要环节。以下是一些常见的优化技术：

实例化绘制

实例化绘制可以显著减少绘制调用的次数，提高渲染效率。

glDrawElementsInstanced(GL_TRIANGLES, indices_.size(), GL_UNSIGNED_INT, 0, instanceCount_);
延迟渲染

延迟渲染是一种将几何处理和光照计算分离的技术，可以提高复杂场景的渲染性能。

// 设置G-Buffer
GLuint gBuffer;
glGenFramebuffers(1, &gBuffer);
glBindFramebuffer(GL_FRAMEBUFFER, gBuffer);

// 创建颜色附件
GLuint gPosition, gNormal, gColorSpec;
// ... 创建和绑定纹理附件 ...

// 创建深度附件
GLuint rboDepth;
glGenRenderbuffers(1, &rboDepth);
glBindRenderbuffer(GL_RENDERBUFFER, rboDepth);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, screenWidth, screenHeight);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rboDepth);

// 绑定G-Buffer
glBindFramebuffer(GL_FRAMEBUFFER, gBuffer);
glDrawBuffers(3, buffers);

// 渲染到G-Buffer
// ... 设置视图和投影矩阵 ...
// ... 绘制物体到G-Buffer ...

// 延迟光照
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// ... 设置光照着色器 ...
// ... 从G-Buffer中读取数据并进行光照计算 ...
遮挡剔除

遮挡剔除可以避免渲染被遮挡的物体，提高渲染效率。

// 使用遮挡查询
GLuint occlusionQuery;
glGenQueries(1, &occlusionQuery);
glBeginQuery(GL_SAMPLES_PASSED, occlusionQuery);
// ... 绘制物体 ...
glEndQuery(GL_SAMPLES_PASidian());

GLint samplesPassed;
glGetQueryObjectiv(occlusionQuery, GL_QUERY_RESULT, &samplesPassed);
if (samplesPassed > 0) {
    // 物体可见，进行绘制
}

总结

以上代码片段展示了一些高级特性和优化技术的实现思路。实际的渲染引擎实现会更加复杂，涉及更多的细节和优化。以下是一些额外的注意事项：

  • 跨平台兼容性：确保渲染引擎在不同平台和硬件上都能稳定运行。
  • 资源加载和卸载：高效地管理资源的加载和卸载，避免内存泄漏和性能瓶颈。
  • 多线程渲染：利用多线程技术提高渲染性能，如将几何处理、光照计算等任务分配到不同的线程。
  • 用户界面（UI）集成：集成用户界面组件，如HUD、菜单等，提供更好的用户体验。

通过这些示例和思路，你可以进一步了解渲染引擎的高级特性和优化技术。在实际开发中，你需要根据具体需求和技术栈进行扩展和优化。

继续深入探讨渲染引擎的实现，我们可以进一步讨论一些高级特性和优化技术。以下是一些关键点和代码示例：

1. 阴影映射（Shadow Mapping）

阴影映射是一种常用的实时阴影生成技术。通过从光源的角度渲染深度贴图，然后在从摄像机角度渲染场景时比较深度值，可以生成阴影效果。

// ShadowMapping.h
#pragma once
#include <GL/glew.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>

class ShadowMapping {
public:
    ShadowMapping();
    ~ShadowMapping();

    void Init(GLuint width, GLuint height);
    void Render(const glm::mat4& lightSpaceMatrix, const glm::mat4& viewMatrix, const glm::mat4& projectionMatrix);
    GLuint GetDepthMap();

private:
    GLuint depthMapFBO_;
    GLuint depthMap_;
    const GLuint SHADOW_WIDTH = 1024, SHADOW_HEIGHT = 1024;
};

// ShadowMapping.cpp
#include "ShadowMapping.h"

ShadowMapping::ShadowMapping()
    : depthMapFBO_(0), depthMap_(0) {}

ShadowMapping::~ShadowMapping() {
    glDeleteFramebuffers(1, &depthMapFBO_);
    glDeleteTextures(1, &depthMap_);
}

void ShadowMapping::Init(GLuint width, GLuint height) {
    // 创建帧缓冲对象
    glGenFramebuffers(1, &depthMapFBO_);

    // 创建深度纹理
    glGenTextures(1, &depthMap_);
    glBindTexture(GL_TEXTURE_2D, depthMap_);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, SHADOW_WIDTH, SHADOW_HEIGHT, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
    GLfloat borderColor[] = { 1.0f, 1.0f, 1.0f, 1.0f };
    glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor);

    // 将深度纹理附加到帧缓冲对象
    glBindFramebuffer(GL_FRAMEBUFFER, depthMapFBO_);
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depthMap_, 0);
    glDrawBuffer(GL_NONE);
    glReadBuffer(GL_NONE);
    glBindFramebuffer(GL_FRAMEBUFFER, 0);
}

void ShadowMapping::Render(const glm::mat4& lightSpaceMatrix, const glm::mat4& viewMatrix, const glm::mat4& projectionMatrix) {
    // 绑定帧缓冲对象
    glBindFramebuffer(GL_FRAMEBUFFER, depthMapFBO_);
    glClear(GL_DEPTH_BUFFER_BIT);
    glViewport(0, 0, SHADOW_WIDTH, SHADOW_HEIGHT);

    // 使用深度着色器
    // ... 设置深度着色器 ...

    // 渲染场景到深度贴图
    // ... 设置模型矩阵、视图矩阵、投影矩阵 ...
    // ... 绘制物体 ...

    // 解绑帧缓冲对象
    glBindFramebuffer(GL_FRAMEBUFFER, 0);
}

GLuint ShadowMapping::GetDepthMap() {
    return depth + ()Map_;
}

2. 环境光遮蔽（Ambient Occlusion）

环境光遮蔽是一种模拟全局光照的技术，可以增强场景的细节和真实感。

// AmbientOcclusion.h
#pragma once
#include <GL/glew.h>
#include <glm/glm.hpp>

class AmbientOcclusion {
public:
    AmbientOcceptor();
    ~AmbientOcclusion();

    void Init(GLuint width, GLuint height);
    void Render(const glm::mat4& viewMatrix, const glm::mat4& projectionMatrix);
    GLuint GetAOTexture();

private:
    GLuint aoFBO_;
    GLuint aoTexture_;
    GLuint aoBlurTexture_;
    const GLuint AO_WIDTH = 1024, AO_HEIGHT = 1024;
};

// AmbientOcclusion.cpp
#include "AmbientOcclusion.h"

AmbientOcclusion::AmbientOcclusion()
    : aoFBO_(0), aoTexture_(0), aoBlurTexture_(0) {}

Ambier() Occlusion::~AmbientOcclusion() {
    glDeleteFramebuffers(1, &aoFBO_);
    glDeleteTextures(1, &aoTexture_);
    glDeleteTextures(1, &aoBlurTexture_);
}

void AmbientOcclusion::Init(GLuint width, GLuint height) {
    // 创建帧缓冲对象
    glGenFramebuffers(1, &aoFBO_);

    // 创建AO纹理
    glGenTextures(1, &aoTexture_);
    glBindTexture(GL_TEXTURE_2D, aoTexture_);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, AO_WIDTH, AO_HEIGHT, 0, GL_RED, GL_FLOAT, NULL);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, aoTexture_, 0);

    // 创建模糊纹理
    glGenTextures(1, &aoBlurTexture_);
    glBindTexture(GL_TEXTURE_2D, aoBlurTexture_);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, AO_WIDTH, AO_HEIGHT, 0, GL_RED, GL_FLOAT, NULL);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

    // 将纹理附加到帧缓冲对象
    glBindFramebuffer(GL_FRAMEBUFFER, aoFBO_);
    glDrawBuffer(GL_COLOR_ATTACHMENT0);
    glBindFramebuffer(GL_FRAMEBUFFER, 0);
}

void AmbientOcclusion::Render(const glm::mat4& viewMatrix, const glm::mat4& projectionMatrix) {
    // 绑定帧缓冲对象
    glBindFramebuffer(GL_FRAMEBUFFER, aoFBO_);
    glClear(GL_COLOR_BUFFER_BIT);
    glViewport(0, 0, AO_WIDTH, AO_HEIGHT);

    // 使用AO着色器
    // ... 设置AO着色器 ...

    // 渲染场景到AO纹理
    // ... 设置模型矩阵、视图矩阵、投影矩阵 ...
    // ... 绘制物体 ...

    // 解绑帧缓冲对象
    glBindFramebuffer(GL_FRAMEBUFFER, 0);
}

GLuint AmbientOcclusion::GetAOTexture() {
    return aoTexture_;
}

3. 全局光照（Global Illumination）

全局光照是一种模拟光线在场景中多次反射的技术，可以显著提高场景的真实感。

// GlobalIllumination.h
#pragma once
#include <GL/glew.h>
#include <glm/glm.hpp>

class GlobalIllumination {
public:
    GlobalIllumantion();
    ~GlobalIllumination();

    void Init(GLuint width, GLuint height);
    void Render(const glm::mat4& viewMatrix, const glm::mat4& projectionMatrix);
    GLuint GetGI() Texture();

private:
    GLuint giFBO_;
    GLuint giTexture_;
    const GLuint GI_WIDTH = 1024, GI_HEIGHT = 1024;
};

// GlobalIllumination.cpp
#include "GlobalIllumination.h"

GlobalIllumination::GlobalIllumination()
    : giFBO_(0), giTexture_(0) {}

GlobalIllumination::~GlobalIllumination() {
    glDeleteFramebuffers(1, &giFBO_);
    glDeleteTextures(1, &giTexture_);
}

void GlobalIllumination::Init(GLuint width, GLuint height) {
    // 创建帧缓冲对象
    glGenFramebuffers(1, &giFBO_);

    // 创建GI纹理
    glGenTextures(1, &giTexture_);
    glBindTexture(GL_TEXTURE_2D, giTexture_);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, GI_WIDTH, GI_HEIGHT, 0, GL_RGBA, GL_FLOAT, NULL);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, giTexture_, 0);

    // 将纹理附加到帧缓冲对象
    glBindFramebuffer(GL_FRAMEBUFFER, giFBO_);
    glDrawBuffer(GL_COLOR_ATTACHMENT0);
    glBindFramebuffer(GL_FRAMEBUFFER, 0);
}

void GlobalIllumination::Render(const glm::mat4& viewMatrix, const glm::mat4& projectionMatrix) {
    // 绑定帧缓冲对象
    glBindFramebuffer(GL_FRAMEBUFFER, giFBO_);
    glClear(GL_COLOR_BUFFER_BIT);
    glViewport(0, 0, GI_WIDTH, GI_HEIGHT);

    // 使用GI着色器
    // ... 设置GI着色器 ...

    // 渲染场景到GI纹理
    // ... 设置模型矩阵、视图矩阵、投影矩阵 ...
    // ... 绘制物体 ...

    // 解绑帧缓冲对象
    glBindFramebuffer(GL_FRAMEBUFFER, 0);
}

GLuint GlobalI�отination::GetGITexture() {
    return giTexture_;
}

总结

以上代码片段展示了一些高级特性和优化技术的实现思路。实际的渲染引擎实现会更加复杂，涉及更多的细节和优化。以下是一些额外的注意事项：

  • 跨平台兼容性：确保渲染引擎在不同平台和硬件上都能稳定运行。
  • 资源加载和卸载：高效地管理资源的加载和卸载，避免内存泄漏和性能瓶颈。
  • 多线程渲染：利用多线程技术提高渲染性能，如将几何处理、光照计算等任务分配到不同的线程。
  • 用户界面（UI）集成：集成用户界面组件，如HUD、菜单等，提供更好的用户体验。

通过这些示例和思路，你可以进一步了解渲染引擎的高级特性和优化技术。在实际开发中，你需要根据具体需求和技术栈进行扩展和优化。

由于篇幅限制，我无法一次性展示渲染引擎的所有高级特性和优化技术。但我可以继续提供一些关键点和思路，帮助你进一步深入了解渲染引擎的开发。

1. 多重采样抗锯齿（MSAA）

多重采样抗锯齿是一种常用的抗锯齿技术，可以减少图像中的锯齿现象，提高图像质量。

// MSAA.h
#pragma once
#include <GL/glew.h>

class MSAA {
public:
    MSAA();
    ~MSAA();

    void Init(GLuint width, GLuint height);
    void Bind();
    void Unbind();
    void Resolve(GLuint framebuffer);

private:
    GLuint msaaFBO_;
    GLuint msaaColorBuffer_;
    GLuint resolveFBO_;
    GLuint resolveColorBuffer_;
    const GLuint SAMPLES = 4;
};

// MSAA.cpp
#include "MSAA.h"

MSAA::MSAA()
    : msaaFBO_(0), msaaColorBuffer_(0), resolveFBO_(0), resolveColorBuffer_(0) {}

MSAA::~MSAA() {
    glDeleteFramebuffers(1, &msaaFBO_);
    glDeleteTextures(1, &msaaColorBuffer_);
    glDeleteFramebuffers(1, &resolveFBO_);
    glDeleteTextures(1, &resolveColorBuffer_);
}

void MSAA::Init(GLuint width, GLuint height) {
    // 创建MSAA帧缓冲对象
    glGenFramebuffers(1, &msaaFBO_);
    glBindFramebuffer(GL_FRAMEBUFFER, msaaFBO_);

    // 创建MSAA颜色缓冲
    glGenTextures(1, &msaaColorBuffer_);
    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, msaaColorBuffer_);
    glTexImage2DMultisample(GL_TEXTURE_2D_MULTISABLE(), SAMPLES, GL_RGBA, width, height, GL_TRUE);
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, msaaColorBuffer_, 0);

    // 创建解析帧缓冲对象
    glGenFramebuffers(1, &resolveFBO_);
    glBindFramebuffer(GL_FRAMEBUFFER, resolveFBO_);

    // 创建解析颜色缓冲
    glGenTextures(1, &resolveColorBuffer_);
    glBindTexture(GL_TEXTURE_2D, resolveColorBuffer_);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_FLOAT, NULL);
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, resolveColorBuffer_, 0);

    // 检查帧缓冲完整性
    if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
        std::cerr << "Framebuffer not complete!" << std::endl;

    glBindFramebuffer(GL_FRAMEBUFFER, 0);
}

void MSAA::Bind() {
    glBindFramebuffer(GL_FRAMEBUFFER, msaaFBO_);
}

void MSAA::Unbind() {
    glBindFramebuffer(GL_FRAMEBUFFER, 0);
}

void MSAA::Resolve(GLuint framebuffer) {
    glBindFramebuffer(GL_READ_FRAMEBUFFER, msaaFBO_);
    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, resolveFBO_);
    glBlitFramebuffer(0, 0, width_, height_, 0, 0, width_, height_, GL_COLOR_BUFFER_BIT, GL_NEAREST);
    glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
}

2. 实时全局光照（Real-Time Global Illumination）

实时全局光照是一种模拟光线在场景中多次反射的技术，可以显著提高场景的真实感。

// RealTimeGlobalIllumination.h
#pragma once
#include <GL/glew.h>
#include <glm/glm.hpp>

class RealTimeGlobalIllumination {
public:
    RealTimeGlobalIllumination();
    ~RealTimeGlobalIllum + ()nation();

    void Init(GLuint width, GLuint height);
    void Render(const glm::mat4& viewMatrix, const glm::mat4& projectionMatrix);
    GLuint GetGI() Texture();

private:
    GLuint giFBO_;
    GLuint giTexture_;
    const GLuint GI_WIDTH = 1024, GI_HEIGHT = 1024;
};

// RealTimeGlobalIllumination.cpp
#include "RealTimeGlobalIllumination.h"

RealTimeGlobalIllumination::RealTimeGlobalIllumination()
    : giFBO_(0), giTexture_(0) {}

RealTimeGlobalIllumination::~RealTimeGlobalIllumination() {
    glDeleteFramebuffers(1, &giFBO_);
    glDeleteTextures(1, &giTexture_);
}

void RealTimeGlobalIllumination::Init(GLuint width, GLuint height) {
    // 创建帧缓冲对象
    glGenFramebuffers(1, &giFBO_);

    // 创建GI纹理
    glGenTextures(1, &giTexture_);
    glBindTexture(GL_TEXTURE_2D, giTexture_);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, GI_WIDTH, GI_HEIGHT, 0, GL_RGBA, GL_FLOAT, NULL);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, giTexture_, 0);

    // 将纹理附加到帧缓冲对象
    glBindFramebuffer(GL_FRAMEBUFFER, giFBO_);
    glDrawBuffer(GL_COLOR_ATTACHMENT0);
    glBindFramebuffer(GL_FRAMEBUFFER, 0);
}

void RealTimeGlobalIllumination::Render(const glm::mat4& viewMatrix, const glm::mat4& projectionMatrix) {
    // 绑定帧缓冲对象
    glBindFramebuffer(GL_FRAMEBUFFER, giFBO_);
    glClear(GL_COLOR_BUFFER_BIT);
    glViewport(0, 0, GI_WIDTH, GI_HEIGHT);

    // 使用GI着色器
    // ... 设置GI着色器 ...

    // 渲染场景到GI纹理
    // ... 设置模型矩阵、视图矩阵、投影矩阵 ...
    // ... 绘制物体 ...

    // 解绑帧缓冲对象
    glBindFramebuffer(GL_FRAMEBUFFER, 0);
}

GLuint RealTimeGlobalIllumination::GetGI() Texture() {
    return giTexture_;
}

3. 实时阴影优化

实时阴影的优化可以通过多种技术实现，如级联阴影贴图（Cascaded Shadow Maps）、阴影体积（Shadow Volumes）等。

// CascadedShadowMaps.h
#pragma once
#include <GL/glew.h>
#include <glm/glm.hpp>

class CascadedShadowMaps {
public:
    CascadedShadowMaps();
    ~CascadedShadowMaps();

    void Init(GLuint width, GLuint height);
    void Render(const glm::mat4& viewMatrix, const glm::mat4& projectionMatrix);
    GLuint GetShadowMap();

private:
    GLuint csmFBO_;
    GLuint csmTextures_[4];
    const GLuint SHADOW_WIDTH = 2048, SHADOW_HEIGHT = 2048;
};

// CascadedShadowMaps.cpp
#include "CascadedShadowMaps.h"

CascadedShadowMaps::CascadedShadowMaps()
    : csmFBO_(0) {
    for (int i = 0; i < 4; ++i) {
        csmTextures_[i] = 0;
    }
}

Casc + ()dows::~CascadedShadowMaps() {
    glDeleteFramebuffers(1, &csmFBO_);
    for (int i = 0; i + () i < 4; ++i) {
        glDeleteTextures(1, &csmTextures_[i]);
    }
}

void CascadedShadowMaps::Init(GLuint width, GLuint height) {
    // 创建CSM帧缓冲对象
    glGenFramebuffers(1, &csmFBO_);
    glBindFramebuffer(GL_FRAMEBUFFER, csmFBO_);

    // 创建CSM纹理
    for (int i = 0; i < 4; ++i) {
        glGenTextures(1, &csmTextures_[i]);
        glBindTexture(GL_TEXTURE_2D, csmTextures_[i]);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, SHADOW_WIDTH, SHADOW_HEIGHT, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
        GLfloat borderColor[] = { 1.0f, 1.0f, 1.0f, 1.0f };
        glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor);
        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, csmTextures_[i], 0);
    }

    // 将纹理附加到帧缓冲对象
    glDrawBuffer(GL_NONE);
    glReadBuffer(GL_NONE);
    glBindFramebuffer(GL_FRAMEBUFFER, 0);
}

void CascadedShadowMaps::Render(const glm::mat4& viewMatrix, const glm::mat4& projectionMatrix) {
    // 绑定帧缓冲对象
    glBindFramebuffer(GL_FRAMEBUFFER, csmFBO_);
    glClear(GL_DEPTH_BUFFER_BIT);
    glViewport(0, 0, SHADOW_WIDTH, SHADOW_HEIGHT);

    // 使用阴影着色器
    // ... 设置阴影着色器 ...

    // 渲染场景到CSM纹理
    // ... 设置模型矩阵、视图矩阵、投影矩阵 ...
    // ... 绘制物体 ...

    // 解绑帧缓冲对象
    glBindFramebuffer(GL_FRAMEBUFFER, 0);
}

GLuint CascadedShadowMaps::GetShadowMap() {
    return c + ()smTextures_[0];
}

总结

以上代码片段展示了一些高级特性和优化技术的实现思路。实际的渲染引擎实现会更加复杂，涉及更多的细节和优化。以下是一些额外的注意事项：

  • 跨平台兼容性：确保渲染引擎在不同平台和硬件上都能稳定运行。
  • 资源加载和卸载：高效地管理资源的加载和卸 + ()载，避免内存泄漏和性能瓶颈。
  • 多线程渲染：利用多线程技术提高渲染性能，如将几何处理、光照计算等任务分配到不同的线程。
  • 用户界面（UI）集成：集成用户界面组件，如HUD、菜单等，提供更好的用户体验。

通过这些示例和思路，你可以进一步了解渲染引擎的高级特性和优化技术。在实际开发中，你需要根据具体需求和技术栈进行扩展和优化。

你一身傲骨怎能输
关注
专栏目录
低代码前端框架Amis全面教程
全世界的博客
07-18 3074
Amis是一个基于JSON配置的前端低代码框架，由百度开源。它允许开发者通过简单的JSON配置文件来生成复杂的后台管理页面，从而大大减少了前端开发的工作量。Amis的核心理念是通过配置而非编码来实现页面的构建，这使得即使是不熟悉前端技术的开发者也能快速上手。JSON配置文件：定义页面的结构、样式和行为。组件库：提供了一系列可复用的UI组件，如表单、表格、图表等。渲染引擎：负责解析JSON配置并生成对应的HTML和JavaScript代码。
谈谈GIS三维渲染引擎
Leon_Jinhai_Sun的博客
11-03 3036
minemap:是我们公司的产品，主要以earth的形态展示，支持矢量切片+倾斜数据（这一点我个人认为是它最大的优点，即兼容了矢量切片精美地图又兼容倾斜数据，目前倾斜数据采用的3dtile格式），目前正在重构引擎架构，任重而道远啊，现在官网的案例demo都是早期版本，好多新功能还木有更新，属实有点汗颜。 MineData​minedata.cn/support/api/demo/javascript-3d-api/zh/map/base/sphere-map-show cesium：一款开源的三维地图引
阿里低代码引擎学习记录
YUYUYU972的博客
04-30 1270
我还没有实践到这一步……
GIS三维渲染引擎 到底有什么区别
PHP代码的博客
11-09 1029
GIS三维渲染引擎 到底有什么区别
1.常见的3D渲染引擎
qq_58288155的博客
09-19 2001
常见的3D渲染引擎，各自优缺点对比
百度低代码框架amis介绍及实例讲解
热门推荐
java后端开发的博客，不仅仅是后端开发
06-01 3万+
amis 是一个低代码前端框架，它使用 JSON 配置来生成页面，通过拖拉拽实现页面配置开发，大大减少页面开发工作量。低代码平台是未来的趋势，本文抛砖引玉介绍了一个增删改查列表实现的过程。.........
Orillusion引擎正式开源！AIGC时代下的WebGPU轻量级3D渲染引擎！
Orillusion的博客
05-09 978
致力于在浏览器中实现桌面级的渲染效果，支持超大复杂场景的3D呈现，为3D场景爆发时代提供底层引擎基础工具。
Flutter详解及案例代码
日常笔记/总结/系列知识梳理
12-22 736
Stateless Widget是一种不可变的widget，它的属性在创建后不会改变。例如，一个计数器应用程序的按钮可以是Stateless Widget，而计数器的数字可以是Stateful Widget。Widget：Flutter中的一切都是widget，从简单的按钮到复杂的布局都是widget。Flutter的核心是使用Dart语言编写的，并且具有自己的渲染引擎，无需依赖平台的原生控件。一个简单的Flutter案例代码，演示了如何创建一个带有按钮和文本的界面，并在按下按钮时更新文本。
【python】flask模板渲染引擎Jinja2，通过后端数据渲染前端页面
景天科技苑
03-26 5599
Flask内置的模板引擎Jinja2，它的设计思想来源于 Django 的模板引擎DTP(DjangoTemplates)，并扩展了其语法和一系列强大的功能。 Flask提供的 render_template 函数封装了该模板引擎Jinja2 render_template 函数的第一个参数是模板的文件名，后面的参数都是键值对，表示模板中变量对应的数据值。
Python代码源码-实操案例-框架案例-音乐网.zip
02-22
本案例中的"Python代码源码-实操案例-框架案例-音乐网.zip"文件，很可能是针对音乐网站开发的一个实战项目，旨在展示如何使用Python框架来搭建和实现音乐服务功能。 首先，让我们深入理解Python源码。源码是程序员...
Python代码源码-实操案例-框架案例-今天吃什么小程序.zip
02-22
在本压缩包“Python代码源码-实操案例-框架案例-今天吃什么小程序.zip”中，包含的是一个基于Python编程语言的实际操作案例，主要聚焦于框架应用，具体为一个名为“今天吃什么”的小程序。这个案例旨在帮助学习者...
Python代码源码-实操案例-框架案例-商城源码.zip
02-22
在本压缩包中，我们拥有一个名为"Python代码源码-实操案例-框架案例-商城源码"的集合，这是一系列与Python编程相关的实际操作案例，特别聚焦于使用Python框架开发商城系统。这个资源对于学习和理解如何在Python环境...
Python代码源码-实操案例-框架案例-智慧校园考试系统.zip
02-22
在本压缩包“Python代码源码-实操案例-框架案例-智慧校园考试系统.zip”中，包含了一个基于Python编程语言实现的智慧校园考试系统的源码。这个系统可能利用了Python的强大功能和丰富的库资源，为学校的考试管理提供...
PythonWeb开发案例教程_源代码.zip
06-29
"PythonWeb开发案例教程_源代码.zip"这个压缩包包含了整个教程的实践代码，这将帮助你更好地跟随教程的步伐，亲手操作每一个示例，加深对理论知识的理解。 Python Web开发主要依赖于一些强大的框架，如Django、...
CR85-M234T分选坐标文档.rar
10-08
CR85-M234T分选坐标文档.rar
Ubuntu 20.04.5 远程桌面配置及管理
最新发布
10-08
内容概要：本文详细介绍了如何在 Ubuntu 20.04.5 server 版本的操作系统上安装及配置 Gnome 桌面以及基于 vnc 的远程桌面解决方案，同时提供了在 Windows 上配置 VNC 客户端的方法，使得跨平台操作变得方便可行。此外还探讨了 Ubuntu 和 Windows 系统间共享文件夹的功能实现与剪贴板互通，以及怎样管理和切换图形界面和文本界面。 适用人群：适用于需要远程操作 Ubuntu Server 或者需要跨平台工作的技术人士，包括但不限于系统管理员、开发人员等。 使用场景及目标：① 为 Ubuntu server 设置图形化界面，提升用户体验，便于远程运维任务；② 配置 Ubuntu 服务器，允许通过 VNC 工具安全地从不同设备访问。 其它说明：该文档涵盖了完整的配置流程，并附带了一些常见问题解决技巧。
【超强组合】基于白鹭群优化算法ESOA-BP-Adaboost的数据分类预测算法Matlab实现.rar
10-08
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 替换数据可以直接使用，注释清楚，适合新手
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

你一身傲骨怎能输

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值