1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
// This file is part of the 64k demo project.
// It implements Hybrid3D (simplified v2 port).
// TODO: Full Renderer3D integration with texture manager, noise assets
#include "util/fatal_error.h"
#include "effects/hybrid3_d_effect.h"
#include "gpu/gpu.h"
#include <cmath>
Hybrid3D::Hybrid3D(const GpuContext& ctx,
const std::vector<std::string>& inputs,
const std::vector<std::string>& outputs)
: Effect(ctx, inputs, outputs), depth_node_(outputs[0] + "_depth"),
dummy_texture_(nullptr), dummy_texture_view_(nullptr) {
// Headless mode: skip GPU resource creation (compiled out in STRIP_ALL)
HEADLESS_RETURN_IF_NULL(ctx_.device);
// Initialize renderer (format is always RGBA8Unorm for v2)
renderer_.init(ctx_.device, ctx_.queue, WGPUTextureFormat_RGBA8Unorm);
// Create 1×1 white dummy texture for noise/sky (Renderer3D requires these)
WGPUTextureDescriptor tex_desc = {};
tex_desc.size = {1, 1, 1};
tex_desc.format = WGPUTextureFormat_RGBA8Unorm;
tex_desc.usage = WGPUTextureUsage_TextureBinding | WGPUTextureUsage_CopyDst;
tex_desc.dimension = WGPUTextureDimension_2D;
tex_desc.mipLevelCount = 1;
tex_desc.sampleCount = 1;
dummy_texture_ = wgpuDeviceCreateTexture(ctx_.device, &tex_desc);
dummy_texture_view_ = wgpuTextureCreateView(dummy_texture_, nullptr);
// Write white pixel
uint32_t white_pixel = 0xFFFFFFFF;
#if defined(DEMO_CROSS_COMPILE_WIN32)
WGPUImageCopyTexture dst = {
.texture = dummy_texture_,
.mipLevel = 0,
.origin = {0, 0, 0}
};
WGPUTextureDataLayout data_layout = {
.bytesPerRow = 4,
.rowsPerImage = 1
};
#else
WGPUTexelCopyTextureInfo dst = {
.texture = dummy_texture_,
.mipLevel = 0,
.origin = {0, 0, 0}
};
WGPUTexelCopyBufferLayout data_layout = {
.bytesPerRow = 4,
.rowsPerImage = 1
};
#endif
WGPUExtent3D size = {1, 1, 1};
wgpuQueueWriteTexture(ctx_.queue, &dst, &white_pixel, 4, &data_layout, &size);
renderer_.set_noise_texture(dummy_texture_view_);
renderer_.set_sky_texture(dummy_texture_view_);
initialized_ = true;
// Setup simple scene (1 center cube + 8 surrounding objects)
scene_.clear();
Object3D center(ObjectType::BOX);
center.position = vec3(0, 0, 0);
center.color = vec4(1, 0, 0, 1);
scene_.add_object(center);
for (int i = 0; i < 8; ++i) {
ObjectType type = (i % 3 == 1) ? ObjectType::TORUS :
(i % 3 == 2) ? ObjectType::BOX : ObjectType::SPHERE;
Object3D obj(type);
float angle = (i / 8.0f) * 6.28318f;
obj.position = vec3(std::cos(angle) * 4.0f, 0, std::sin(angle) * 4.0f);
obj.scale = vec3(0.7f, 0.7f, 0.7f);
if (type == ObjectType::SPHERE)
obj.color = vec4(0, 1, 0, 1);
else if (type == ObjectType::TORUS)
obj.color = vec4(0, 0.5f, 1, 1);
else
obj.color = vec4(1, 1, 0, 1);
scene_.add_object(obj);
}
}
Hybrid3D::~Hybrid3D() {
if (dummy_texture_view_)
wgpuTextureViewRelease(dummy_texture_view_);
if (dummy_texture_)
wgpuTextureRelease(dummy_texture_);
renderer_.shutdown();
}
void Hybrid3D::declare_nodes(NodeRegistry& registry) {
// Declare depth buffer node
registry.declare_node(depth_node_, NodeType::DEPTH24, -1, -1);
}
void Hybrid3D::render(WGPUCommandEncoder encoder,
const UniformsSequenceParams& params,
NodeRegistry& nodes) {
// Update camera (orbiting)
float angle = params.time * 0.3f;
vec3 cam_pos = vec3(std::cos(angle) * 10.0f, 5.0f, std::sin(angle) * 10.0f);
camera_.position = cam_pos;
camera_.target = vec3(0, 0, 0);
camera_.aspect_ratio = params.aspect_ratio;
// Get output views
WGPUTextureView color_view = nodes.get_view(output_nodes_[0]);
WGPUTextureView depth_view = nodes.get_view(depth_node_);
// Render 3D scene using sequence encoder
WGPURenderPassColorAttachment color_attachment = {};
#if !defined(DEMO_CROSS_COMPILE_WIN32)
color_attachment.depthSlice = WGPU_DEPTH_SLICE_UNDEFINED;
#endif
color_attachment.view = color_view;
color_attachment.loadOp = WGPULoadOp_Clear;
color_attachment.storeOp = WGPUStoreOp_Store;
color_attachment.clearValue = {0.05f, 0.05f, 0.05f, 1.0f};
WGPURenderPassDepthStencilAttachment depth_attachment = {};
depth_attachment.view = depth_view;
depth_attachment.depthLoadOp = WGPULoadOp_Clear;
depth_attachment.depthStoreOp = WGPUStoreOp_Store;
depth_attachment.depthClearValue = 1.0f;
WGPURenderPassDescriptor pass_desc = {};
pass_desc.colorAttachmentCount = 1;
pass_desc.colorAttachments = &color_attachment;
pass_desc.depthStencilAttachment = &depth_attachment;
WGPURenderPassEncoder pass = wgpuCommandEncoderBeginRenderPass(encoder, &pass_desc);
renderer_.draw(pass, scene_, camera_, params.time);
wgpuRenderPassEncoderEnd(pass);
wgpuRenderPassEncoderRelease(pass);
}
|
