606 lines
14 KiB
Markdown
606 lines
14 KiB
Markdown
### 文件：include/are/platform/window.h
|
||
```cpp
|
||
/**
|
||
* @file window.h
|
||
* @brief Window management using GLFW
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_PLATFORM_WINDOW_H
|
||
#define ARE_INCLUDE_PLATFORM_WINDOW_H
|
||
|
||
#include <are/core/config.h>
|
||
#include <are/core/types.h>
|
||
#include <string>
|
||
|
||
// Forward declare GLFW types to avoid including GLFW in header
|
||
struct GLFWwindow;
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @class Window
|
||
* @brief GLFW window wrapper
|
||
*
|
||
* Manages window creation, input handling, and OpenGL context.
|
||
*/
|
||
class Window {
|
||
public:
|
||
/**
|
||
* @brief Constructor
|
||
* @param config Window configuration
|
||
*/
|
||
explicit Window(const WindowConfig& config);
|
||
|
||
/**
|
||
* @brief Destructor
|
||
*/
|
||
~Window();
|
||
|
||
// Window control
|
||
bool should_close() const;
|
||
void set_should_close(bool should_close);
|
||
void swap_buffers();
|
||
void poll_events();
|
||
|
||
// Window properties
|
||
int get_width() const;
|
||
int get_height() const;
|
||
Real get_aspect_ratio() const;
|
||
const std::string& get_title() const;
|
||
|
||
void set_title(const std::string& title);
|
||
void set_size(int width, int height);
|
||
|
||
// Framebuffer size (may differ from window size on high-DPI displays)
|
||
void get_framebuffer_size(int& width, int& height) const;
|
||
|
||
// VSync control
|
||
void set_vsync(bool enabled);
|
||
bool get_vsync() const;
|
||
|
||
// Input queries (basic support)
|
||
bool is_key_pressed(int key) const;
|
||
bool is_mouse_button_pressed(int button) const;
|
||
void get_cursor_pos(double& x, double& y) const;
|
||
|
||
// Internal
|
||
GLFWwindow* get_native_window() const { return window_; }
|
||
|
||
private:
|
||
void initialize_glfw();
|
||
void create_window();
|
||
void setup_callbacks();
|
||
|
||
static void framebuffer_size_callback(GLFWwindow* window, int width, int height);
|
||
static void error_callback(int error, const char* description);
|
||
|
||
GLFWwindow* window_; ///< GLFW window handle
|
||
WindowConfig config_; ///< Window configuration
|
||
bool vsync_enabled_; ///< VSync state
|
||
|
||
static int instance_count_; ///< Number of Window instances
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_PLATFORM_WINDOW_H
|
||
```
|
||
|
||
### 文件：include/are/platform/gl_context.h
|
||
```cpp
|
||
/**
|
||
* @file gl_context.h
|
||
* @brief OpenGL context management
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_PLATFORM_GL_CONTEXT_H
|
||
#define ARE_INCLUDE_PLATFORM_GL_CONTEXT_H
|
||
|
||
#include <are/core/types.h>
|
||
#include <string>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @class GLContext
|
||
* @brief OpenGL context initialization and management
|
||
*
|
||
* Handles GLAD initialization and provides OpenGL utility functions.
|
||
*/
|
||
class GLContext {
|
||
public:
|
||
/**
|
||
* @brief Initialize OpenGL context (load function pointers)
|
||
* @return true if initialization succeeded
|
||
*/
|
||
static bool initialize();
|
||
|
||
/**
|
||
* @brief Check if context is initialized
|
||
* @return true if initialized
|
||
*/
|
||
static bool is_initialized();
|
||
|
||
/**
|
||
* @brief Get OpenGL version string
|
||
* @return Version string
|
||
*/
|
||
static std::string get_version();
|
||
|
||
/**
|
||
* @brief Get OpenGL renderer string
|
||
* @return Renderer string
|
||
*/
|
||
static std::string get_renderer();
|
||
|
||
/**
|
||
* @brief Get OpenGL vendor string
|
||
* @return Vendor string
|
||
*/
|
||
static std::string get_vendor();
|
||
|
||
/**
|
||
* @brief Check if OpenGL extension is supported
|
||
* @param extension Extension name
|
||
* @return true if supported
|
||
*/
|
||
static bool is_extension_supported(const std::string& extension);
|
||
|
||
/**
|
||
* @brief Print OpenGL information to console
|
||
*/
|
||
static void print_info();
|
||
|
||
/**
|
||
* @brief Check for OpenGL errors
|
||
* @param file Source file
|
||
* @param line Line number
|
||
* @return true if error occurred
|
||
*/
|
||
static bool check_error(const char* file, int line);
|
||
|
||
/**
|
||
* @brief Clear all OpenGL errors
|
||
*/
|
||
static void clear_errors();
|
||
|
||
private:
|
||
static bool initialized_; ///< Initialization flag
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
// OpenGL error checking macro
|
||
#ifdef ARE_ENABLE_DEBUG_VIS
|
||
#define ARE_GL_CHECK() are::GLContext::check_error(__FILE__, __LINE__)
|
||
#else
|
||
#define ARE_GL_CHECK() ((void)0)
|
||
#endif
|
||
|
||
#endif // ARE_INCLUDE_PLATFORM_GL_CONTEXT_H
|
||
```
|
||
|
||
### 文件：include/are/utils/file_utils.h
|
||
```cpp
|
||
/**
|
||
* @file file_utils.h
|
||
* @brief File system utilities
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_UTILS_FILE_UTILS_H
|
||
#define ARE_INCLUDE_UTILS_FILE_UTILS_H
|
||
|
||
#include <string>
|
||
#include <vector>
|
||
#include <cstdint>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @brief Read entire file into string
|
||
* @param filepath File path
|
||
* @return File contents (empty if failed)
|
||
*/
|
||
std::string read_file_to_string(const std::string& filepath);
|
||
|
||
/**
|
||
* @brief Read entire file into byte array
|
||
* @param filepath File path
|
||
* @return File contents (empty if failed)
|
||
*/
|
||
std::vector<uint8_t> read_file_to_bytes(const std::string& filepath);
|
||
|
||
/**
|
||
* @brief Write string to file
|
||
* @param filepath File path
|
||
* @param content Content to write
|
||
* @return true if write succeeded
|
||
*/
|
||
bool write_string_to_file(const std::string& filepath, const std::string& content);
|
||
|
||
/**
|
||
* @brief Write bytes to file
|
||
* @param filepath File path
|
||
* @param data Data pointer
|
||
* @param size Data size in bytes
|
||
* @return true if write succeeded
|
||
*/
|
||
bool write_bytes_to_file(const std::string& filepath, const void* data, size_t size);
|
||
|
||
/**
|
||
* @brief Check if file exists
|
||
* @param filepath File path
|
||
* @return true if file exists
|
||
*/
|
||
bool file_exists(const std::string& filepath);
|
||
|
||
/**
|
||
* @brief Check if path is directory
|
||
* @param path Directory path
|
||
* @return true if directory exists
|
||
*/
|
||
bool is_directory(const std::string& path);
|
||
|
||
/**
|
||
* @brief Create directory (including parent directories)
|
||
* @param path Directory path
|
||
* @return true if creation succeeded
|
||
*/
|
||
bool create_directory(const std::string& path);
|
||
|
||
/**
|
||
* @brief Get file extension
|
||
* @param filepath File path
|
||
* @return Extension (lowercase, without dot)
|
||
*/
|
||
std::string get_file_extension(const std::string& filepath);
|
||
|
||
/**
|
||
* @brief Get filename from path
|
||
* @param filepath File path
|
||
* @return Filename (without directory)
|
||
*/
|
||
std::string get_filename(const std::string& filepath);
|
||
|
||
/**
|
||
* @brief Get directory from path
|
||
* @param filepath File path
|
||
* @return Directory path
|
||
*/
|
||
std::string get_directory(const std::string& filepath);
|
||
|
||
/**
|
||
* @brief Join path components
|
||
* @param parts Path components
|
||
* @return Joined path
|
||
*/
|
||
std::string join_path(const std::vector<std::string>& parts);
|
||
|
||
/**
|
||
* @brief Normalize path (resolve .. and .)
|
||
* @param path Path to normalize
|
||
* @return Normalized path
|
||
*/
|
||
std::string normalize_path(const std::string& path);
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_UTILS_FILE_UTILS_H
|
||
```
|
||
|
||
这是你所要求的三个头文件，如果还需要更多头文件的代码，请随时向我提出。同时，平台层着三个函数的代码我也已经实现，你只需要专心考虑渲染管线即可。此外，渲染管线的头文件我也实现了，你只需要负责实现渲染管线的shader以及代码实现即可。
|
||
### 文件：include/are/rasterizer/shader_program.h
|
||
```cpp
|
||
/**
|
||
* @file shader_program.h
|
||
* @brief OpenGL shader program wrapper
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_RASTERIZER_SHADER_PROGRAM_H
|
||
#define ARE_INCLUDE_RASTERIZER_SHADER_PROGRAM_H
|
||
|
||
#include <are/core/types.h>
|
||
#include <string>
|
||
#include <unordered_map>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @enum ShaderType
|
||
* @brief Shader stage types
|
||
*/
|
||
enum class ShaderType {
|
||
ARE_SHADER_VERTEX,
|
||
ARE_SHADER_FRAGMENT,
|
||
ARE_SHADER_COMPUTE
|
||
};
|
||
|
||
/**
|
||
* @class ShaderProgram
|
||
* @brief OpenGL shader program management
|
||
*/
|
||
class ShaderProgram {
|
||
public:
|
||
/**
|
||
* @brief Constructor
|
||
*/
|
||
ShaderProgram();
|
||
|
||
/**
|
||
* @brief Destructor
|
||
*/
|
||
~ShaderProgram();
|
||
|
||
/**
|
||
* @brief Load and compile shader from file
|
||
* @param type Shader type
|
||
* @param filepath Shader file path
|
||
* @return true if compilation succeeded
|
||
*/
|
||
bool load_shader(ShaderType type, const std::string& filepath);
|
||
|
||
/**
|
||
* @brief Compile shader from source string
|
||
* @param type Shader type
|
||
* @param source Shader source code
|
||
* @return true if compilation succeeded
|
||
*/
|
||
bool compile_shader(ShaderType type, const std::string& source);
|
||
|
||
/**
|
||
* @brief Link shader program
|
||
* @return true if linking succeeded
|
||
*/
|
||
bool link();
|
||
|
||
/**
|
||
* @brief Use this shader program
|
||
*/
|
||
void use() const;
|
||
|
||
/**
|
||
* @brief Check if program is valid
|
||
* @return true if valid
|
||
*/
|
||
bool is_valid() const { return program_ != 0 && linked_; }
|
||
|
||
/**
|
||
* @brief Get OpenGL program ID
|
||
* @return Program ID
|
||
*/
|
||
uint32_t get_program() const { return program_; }
|
||
|
||
// Uniform setters
|
||
void set_uniform(const std::string& name, int value);
|
||
void set_uniform(const std::string& name, float value);
|
||
void set_uniform(const std::string& name, const Vec2& value);
|
||
void set_uniform(const std::string& name, const Vec3& value);
|
||
void set_uniform(const std::string& name, const Vec4& value);
|
||
void set_uniform(const std::string& name, const Mat3& value);
|
||
void set_uniform(const std::string& name, const Mat4& value);
|
||
|
||
/**
|
||
* @brief Get uniform location (cached)
|
||
* @param name Uniform name
|
||
* @return Uniform location (-1 if not found)
|
||
*/
|
||
int get_uniform_location(const std::string& name);
|
||
|
||
private:
|
||
bool check_compile_errors(uint32_t shader, ShaderType type);
|
||
bool check_link_errors();
|
||
|
||
uint32_t program_; ///< OpenGL program ID
|
||
uint32_t vertex_shader_; ///< Vertex shader ID
|
||
uint32_t fragment_shader_; ///< Fragment shader ID
|
||
uint32_t compute_shader_; ///< Compute shader ID
|
||
|
||
bool linked_; ///< Link status
|
||
std::unordered_map<std::string, int> uniform_cache_; ///< Uniform location cache
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_RASTERIZER_SHADER_PROGRAM_H
|
||
```
|
||
|
||
### 文件：include/are/rasterizer/gbuffer.h
|
||
```cpp
|
||
/**
|
||
* @file gbuffer.h
|
||
* @brief G-Buffer management for deferred rendering
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_RASTERIZER_GBUFFER_H
|
||
#define ARE_INCLUDE_RASTERIZER_GBUFFER_H
|
||
|
||
#include <are/core/types.h>
|
||
#include <cstdint>
|
||
|
||
namespace are {
|
||
|
||
/**
|
||
* @class GBuffer
|
||
* @brief G-Buffer for deferred rendering
|
||
*
|
||
* Contains multiple render targets for position, normal, albedo, etc.
|
||
*/
|
||
class GBuffer {
|
||
public:
|
||
/**
|
||
* @brief Constructor
|
||
* @param width Buffer width
|
||
* @param height Buffer height
|
||
*/
|
||
GBuffer(int width, int height);
|
||
|
||
/**
|
||
* @brief Destructor
|
||
*/
|
||
~GBuffer();
|
||
|
||
/**
|
||
* @brief Resize G-Buffer
|
||
* @param width New width
|
||
* @param height New height
|
||
*/
|
||
void resize(int width, int height);
|
||
|
||
/**
|
||
* @brief Bind G-Buffer for rendering
|
||
*/
|
||
void bind();
|
||
|
||
/**
|
||
* @brief Unbind G-Buffer
|
||
*/
|
||
void unbind();
|
||
|
||
/**
|
||
* @brief Clear all buffers
|
||
*/
|
||
void clear();
|
||
|
||
/**
|
||
* @brief Bind texture for reading
|
||
* @param index Texture index (0=position, 1=normal, 2=albedo, etc.)
|
||
* @param texture_unit Texture unit to bind to
|
||
*/
|
||
void bind_texture(int index, int texture_unit);
|
||
|
||
// Texture getters
|
||
uint32_t get_position_texture() const { return position_texture_; }
|
||
uint32_t get_normal_texture() const { return normal_texture_; }
|
||
uint32_t get_albedo_texture() const { return albedo_texture_; }
|
||
uint32_t get_material_texture() const { return material_texture_; }
|
||
uint32_t get_depth_texture() const { return depth_texture_; }
|
||
|
||
// Dimensions
|
||
int get_width() const { return width_; }
|
||
int get_height() const { return height_; }
|
||
|
||
/**
|
||
* @brief Read pixel data from G-Buffer
|
||
* @param index Buffer index
|
||
* @param data Output data pointer
|
||
*/
|
||
void read_pixels(int index, void* data);
|
||
|
||
private:
|
||
void create_textures();
|
||
void delete_textures();
|
||
void create_framebuffer();
|
||
|
||
uint32_t fbo_; ///< Framebuffer object
|
||
uint32_t rbo_depth_; ///< Depth renderbuffer
|
||
|
||
// G-Buffer textures
|
||
uint32_t position_texture_; ///< World position (RGB16F)
|
||
uint32_t normal_texture_; ///< World normal (RGB16F)
|
||
uint32_t albedo_texture_; ///< Albedo + Metallic (RGBA8)
|
||
uint32_t material_texture_; ///< Roughness + AO (RG8)
|
||
uint32_t depth_texture_; ///< Depth (R32F)
|
||
|
||
int width_; ///< Buffer width
|
||
int height_; ///< Buffer height
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_RASTERIZER_GBUFFER_H
|
||
```
|
||
|
||
### 文件：include/are/rasterizer/rasterizer.h
|
||
```cpp
|
||
/**
|
||
* @file rasterizer.h
|
||
* @brief Rasterization pipeline for G-Buffer generation
|
||
*/
|
||
|
||
#ifndef ARE_INCLUDE_RASTERIZER_RASTERIZER_H
|
||
#define ARE_INCLUDE_RASTERIZER_RASTERIZER_H
|
||
|
||
#include <are/core/types.h>
|
||
#include <are/core/config.h>
|
||
#include <memory>
|
||
|
||
namespace are {
|
||
|
||
// Forward declarations
|
||
class GBuffer;
|
||
class ShaderProgram;
|
||
class SceneManager;
|
||
class Camera;
|
||
class Mesh;
|
||
|
||
/**
|
||
* @class Rasterizer
|
||
* @brief OpenGL rasterization pipeline
|
||
*
|
||
* Renders scene geometry to G-Buffer using traditional rasterization.
|
||
*/
|
||
class Rasterizer {
|
||
public:
|
||
/**
|
||
* @brief Constructor
|
||
* @param width Framebuffer width
|
||
* @param height Framebuffer height
|
||
*/
|
||
Rasterizer(int width, int height);
|
||
|
||
/**
|
||
* @brief Destructor
|
||
*/
|
||
~Rasterizer();
|
||
|
||
/**
|
||
* @brief Resize framebuffer
|
||
* @param width New width
|
||
* @param height New height
|
||
*/
|
||
void resize(int width, int height);
|
||
|
||
/**
|
||
* @brief Render scene to G-Buffer
|
||
* @param scene Scene manager
|
||
* @param camera Camera
|
||
*/
|
||
void render_gbuffer(const SceneManager& scene, const Camera& camera);
|
||
|
||
/**
|
||
* @brief Get G-Buffer
|
||
* @return G-Buffer reference
|
||
*/
|
||
GBuffer& get_gbuffer();
|
||
const GBuffer& get_gbuffer() const;
|
||
|
||
/**
|
||
* @brief Upload mesh data to GPU
|
||
* @param mesh Mesh to upload
|
||
*/
|
||
void upload_mesh(Mesh& mesh);
|
||
|
||
/**
|
||
* @brief Delete mesh GPU resources
|
||
* @param mesh Mesh to delete
|
||
*/
|
||
void delete_mesh(Mesh& mesh);
|
||
|
||
private:
|
||
void initialize_shaders(const std::string& shader_dir);
|
||
void setup_mesh_buffers(Mesh& mesh);
|
||
|
||
std::unique_ptr<GBuffer> gbuffer_; ///< G-Buffer
|
||
std::unique_ptr<ShaderProgram> gbuffer_shader_; ///< G-Buffer shader
|
||
|
||
int width_; ///< Framebuffer width
|
||
int height_; ///< Framebuffer height
|
||
};
|
||
|
||
} // namespace are
|
||
|
||
#endif // ARE_INCLUDE_RASTERIZER_RASTERIZER_H
|
||
```
|
||
|
||
如果没有还需要我给出的内容的话，你就可以开始实现了。
|