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
|
// Miscellaneous functions
// Copyright (C) 2021 Nguyễn Gia Phong
//
// This file is part of Black Shades.
//
// Black Shades is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published
// by the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Black Shades is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Black Shades. If not, see <https://www.gnu.org/licenses/>.
usingnamespace @cImport({
@cInclude("AL/al.h");
@cInclude("GL/gl.h");
@cInclude("GL/glu.h");
@cInclude("lodepng.h");
});
const al = @import("zeal");
const allocator = std.heap.c_allocator;
const cwd = std.fs.cwd;
const data_dir = @import("build_options").data_dir ++ [_]u8{ sep };
const free = std.c.free;
const join = std.fs.path.joinZ;
const maxInt = std.math.maxInt;
const sep = std.fs.path.sep;
const span = std.mem.span;
const std = @import("std");
/// Load audio file into an OpenAL buffer and return it.
pub fn loadSound(filename: [*:0]const u8) callconv(.C) u32 {
const path = join(allocator, &.{ data_dir ++ "sounds", span(filename) })
catch unreachable;
defer allocator.free(path);
const audio = al.Audio.read(allocator, span(path)) catch unreachable;
defer audio.free();
const buffer = al.Buffer.init(audio) catch unreachable;
return buffer.reference;
}
fn check(errorString: fn (c_uint) callconv(.C) [*c]const u8,
status: anytype) void {
if (status != 0)
@panic(span(errorString(@intCast(c_uint, status))));
}
/// Load PNG file into an OpenGL buffer and return it.
pub fn loadTexture(filename: [*:0]const u8) callconv(.C) GLuint {
var dir = cwd().openDir(data_dir ++ "textures", .{}) catch unreachable;
defer dir.close();
// Don't judge me, take care of me!
var file = dir.readFileAlloc(allocator, span(filename), maxInt(usize))
catch unreachable;
defer allocator.free(file);
var data: [*c]u8 = undefined;
var w: c_uint = undefined;
var h: c_uint = undefined;
check(lodepng_error_text,
lodepng_decode32(&data, &w, &h, file.ptr, file.len));
defer free(data);
var texture: GLuint = undefined;
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
defer glBindTexture(GL_TEXTURE_2D, 0);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
const width = @intCast(GLint, w);
const height = @intCast(GLint, h);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glTexImage2D(GL_TEXTURE_2D, 0, 4, width, height,
0, GL_RGBA, GL_UNSIGNED_BYTE, data);
check(gluErrorString, gluBuild2DMipmaps(GL_TEXTURE_2D, 4, width, height,
GL_RGBA, GL_UNSIGNED_BYTE, data));
return texture;
}
/// Move sound source to given position and play it.
pub fn playSound(source: u32, x: f32, y: f32, z: f32) callconv(.C) void {
const src = al.Source{ .reference = source };
_ = alGetError(); // TODO: remove when completely migrate to zeal
src.setPosition(.{ x / 32, y / 32, z / 32 }) catch unreachable;
src.play() catch unreachable;
}
|
