update for zig 0.8.1
s-ol
1 year, 8 months ago
99 | 99 |
} else if (std.mem.eql(u8, key, "osc")) {
|
100 | 100 |
config.osc = try parseOSC(&parser, allocator);
|
101 | 101 |
} else {
|
102 | |
debug.warn("unknown key: '{}'\n", .{key});
|
|
102 |
debug.warn("unknown key: '{s}'\n", .{key});
|
103 | 103 |
try skipAny(&parser);
|
104 | 104 |
}
|
105 | 105 |
},
|
|
240 | 240 |
} else if (std.mem.eql(u8, key, "fullscreen")) {
|
241 | 241 |
output.*.fullscreen = try parseBool(parser);
|
242 | 242 |
} else {
|
243 | |
debug.warn("unknown key: '{}'\n", .{key});
|
|
243 |
debug.warn("unknown key: '{s}'\n", .{key});
|
244 | 244 |
try skipAny(parser);
|
245 | 245 |
}
|
246 | 246 |
},
|
|
302 | 302 |
param.*.type = try parseString(parser, allocator);
|
303 | 303 |
have_type = true;
|
304 | 304 |
} else {
|
305 | |
debug.warn("unknown key: '{}'\n", .{key});
|
|
305 |
debug.warn("unknown key: '{s}'\n", .{key});
|
306 | 306 |
try skipAny(parser);
|
307 | 307 |
}
|
308 | 308 |
},
|
|
363 | 363 |
} else if (std.mem.eql(u8, key, "port")) {
|
364 | 364 |
config.Manual.port = try parseInt(parser, u16);
|
365 | 365 |
} else {
|
366 | |
debug.warn("unknown key: '{}'\n", .{key});
|
|
366 |
debug.warn("unknown key: '{s}'\n", .{key});
|
367 | 367 |
try skipAny(parser);
|
368 | 368 |
}
|
369 | 369 |
},
|
5 | 5 |
fn verify_args(expected: u8, got: []const u8) !void {
|
6 | 6 |
for (got) |typ| {
|
7 | 7 |
if (typ != expected) {
|
8 | |
std.debug.warn("expected '{c}' but got '{c}' element (expected {})\n", .{expected, typ, got});
|
|
8 |
std.debug.warn("expected '{c}' but got '{c}' element (expected {s})\n", .{ expected, typ, got });
|
9 | 9 |
return error.typeMismatch;
|
10 | 10 |
}
|
11 | 11 |
}
|
|
182 | 182 |
}
|
183 | 183 |
|
184 | 184 |
self.set_uniform(path[1..], argv, argc, types) catch |err| {
|
185 | |
std.debug.warn("{} while processing {}\n", .{err, path});
|
|
185 |
std.debug.warn("{s} while processing {s}\n", .{ err, path });
|
186 | 186 |
};
|
187 | 187 |
return 0;
|
188 | 188 |
}
|
3 | 3 |
const panic = std.debug.panic;
|
4 | 4 |
const builtin = @import("builtin");
|
5 | 5 |
|
6 | |
pub const is_on = if (builtin.mode == builtin.Mode.ReleaseFast) c.GL_FALSE else c.GL_TRUE;
|
|
6 |
pub const is_on = if (builtin.mode == std.builtin.Mode.ReleaseFast) c.GL_FALSE else c.GL_TRUE;
|
7 | 7 |
|
8 | 8 |
fn glDebugMessage(
|
9 | 9 |
source: c.GLenum,
|
358 | 358 |
pub fn deinit(self: *UniformCache) void {
|
359 | 359 |
var it = self.uniforms.iterator();
|
360 | 360 |
while (it.next()) |entry| {
|
361 | |
self.allocator.free(entry.key);
|
|
361 |
self.allocator.free(entry.key_ptr.*);
|
362 | 362 |
}
|
363 | 363 |
|
364 | 364 |
self.uniforms.deinit();
|
|
380 | 380 |
var it = self.uniforms.iterator();
|
381 | 381 |
var i: usize = 0;
|
382 | 382 |
while (it.next()) |entry| {
|
383 | |
existing_names[i] = entry.key;
|
384 | |
existing_names_c[i] = entry.key.ptr;
|
|
383 |
existing_names[i] = entry.key_ptr.*;
|
|
384 |
existing_names_c[i] = entry.key_ptr.*.ptr;
|
385 | 385 |
i += 1;
|
386 | 386 |
}
|
387 | 387 |
}
|
|
396 | 396 |
for (existing_indices) |index, i| {
|
397 | 397 |
const name = existing_names[i];
|
398 | 398 |
if (index == c.GL_INVALID_INDEX) {
|
399 | |
if (self.uniforms.remove(name)) |removed| {
|
|
399 |
if (self.uniforms.fetchRemove(name)) |removed| {
|
400 | 400 |
self.allocator.free(removed.key);
|
401 | 401 |
}
|
402 | 402 |
} else {
|
|
414 | 414 |
|
415 | 415 |
var result = try self.uniforms.getOrPut(cloned_name);
|
416 | 416 |
if (!result.found_existing) {
|
417 | |
result.entry.value = CachedUniform.init(self.shader.*, name.ptr) catch {
|
|
417 |
result.value_ptr.* = CachedUniform.init(self.shader.*, name.ptr) catch {
|
418 | 418 |
_ = self.uniforms.remove(cloned_name);
|
419 | 419 |
self.allocator.free(cloned_name);
|
420 | 420 |
return null;
|
421 | 421 |
};
|
422 | 422 |
}
|
423 | 423 |
|
424 | |
return &result.entry.value;
|
|
424 |
return result.value_ptr;
|
425 | 425 |
}
|
426 | 426 |
};
|
427 | 427 |
|
11 | 11 |
var window: *c.GLFWwindow = undefined;
|
12 | 12 |
|
13 | 13 |
fn errorCallback(err: c_int, description: [*c]const u8) callconv(.C) void {
|
14 | |
panic("Error: {}\n", .{description});
|
|
14 |
panic("Error: {s}\n", .{description});
|
15 | 15 |
}
|
16 | 16 |
|
17 | 17 |
pub fn main() !void {
|
|
176 | 176 |
if (std.mem.eql(u8, pragma, "include")) {
|
177 | 177 |
var include_path = parts.next().?;
|
178 | 178 |
if (include_path[0] != '"' or include_path[include_path.len - 1] != '"') {
|
179 | |
std.debug.warn("Invalid #pragma directive '{}'\n", .{line});
|
|
179 |
std.debug.warn("Invalid #pragma directive '{s}'\n", .{line});
|
180 | 180 |
continue;
|
181 | 181 |
}
|
182 | 182 |
include_path = include_path[1 .. include_path.len - 1];
|
|
185 | 185 |
|
186 | 186 |
continue;
|
187 | 187 |
} else {
|
188 | |
std.debug.warn("Unknown #pragma directive '{}'\n", .{pragma});
|
|
188 |
std.debug.warn("Unknown #pragma directive '{s}'\n", .{pragma});
|
189 | 189 |
}
|
190 | 190 |
}
|
191 | 191 |
|
|
220 | 220 |
current.destroy();
|
221 | 221 |
current.* = new_program;
|
222 | 222 |
} else |err| {
|
223 | |
std.debug.warn("Error while reloading shader:{}\n", .{err});
|
224 | |
}
|
225 | |
}
|
|
223 |
std.debug.warn("Error while reloading shader: {s}\n", .{err});
|
|
224 |
}
|
|
225 |
}
|