Remove glad, fix windows build, finally a good base
This commit is contained in:
parent
126a18b66b
commit
9945fa5b40
26
build.zig
26
build.zig
@ -15,19 +15,11 @@ pub fn build(b: *std.Build) void {
|
||||
// set a preferred release mode, allowing the user to decide how to optimize.
|
||||
const optimize = b.standardOptimizeOption(.{});
|
||||
|
||||
// const sdl_dep = b.dependency("SDL", .{
|
||||
// .target = target,
|
||||
// .optimize = .ReleaseSafe,
|
||||
// });
|
||||
// const sdl2 = sdl_dep.artifact("SDL2");
|
||||
|
||||
const glad = b.addSharedLibrary(.{
|
||||
.name = "glad",
|
||||
const sdl_dep = b.dependency("SDL", .{
|
||||
.target = target,
|
||||
.optimize = optimize,
|
||||
.optimize = .ReleaseSafe,
|
||||
});
|
||||
glad.addCSourceFile(.{ .file = .{ .path = "src/glad.c" } });
|
||||
glad.addIncludePath(.{ .path = "include" });
|
||||
const sdl2 = sdl_dep.artifact("SDL2");
|
||||
|
||||
const lib = b.addSharedLibrary(.{
|
||||
.name = "learnopengl",
|
||||
@ -36,11 +28,7 @@ pub fn build(b: *std.Build) void {
|
||||
.optimize = optimize,
|
||||
});
|
||||
|
||||
lib.linkSystemLibrary("SDL2");
|
||||
lib.addSystemIncludePath(.{ .path = "/opt/homebrew/opt/sdl2/include/" });
|
||||
lib.addLibraryPath(.{ .path = "/opt/homebrew/opt/sdl2/lib" });
|
||||
lib.linkLibrary(glad);
|
||||
lib.addIncludePath(.{ .path = "include" });
|
||||
lib.linkLibrary(sdl2);
|
||||
|
||||
const installLib = b.addInstallArtifact(lib, .{
|
||||
.dest_dir = .{ .override = .bin },
|
||||
@ -56,11 +44,7 @@ pub fn build(b: *std.Build) void {
|
||||
.optimize = optimize,
|
||||
});
|
||||
|
||||
exe.linkSystemLibrary("SDL2");
|
||||
exe.addSystemIncludePath(.{ .path = "/opt/homebrew/opt/sdl2/include/" });
|
||||
exe.addLibraryPath(.{ .path = "/opt/homebrew/opt/sdl2/lib" });
|
||||
exe.linkLibrary(glad);
|
||||
exe.addIncludePath(.{ .path = "include" });
|
||||
exe.linkLibrary(sdl2);
|
||||
|
||||
// This declares intent for the executable to be installed into the
|
||||
// standard location when the user invokes the "install" step (the default
|
||||
|
||||
@ -16,8 +16,8 @@
|
||||
// internet connectivity.
|
||||
.dependencies = .{
|
||||
.SDL = .{
|
||||
.url = "https://github.com/sergeypdev/SDL/tarball/0d062f21742b2914a0258df718931f80a952be1a",
|
||||
.hash = "122009e9c57dcbc6cd92be92c61eba913468ecfebd6c166011f6065a3ffbdc75f45f",
|
||||
.url = "https://github.com/sergeypdev/SDL/tarball/b23c0ba880c53e5e98c57d2d5470c8d551a520b3",
|
||||
.hash = "122080136ee910b4bec7be16e6c69cf1e7fc4f69d14f4d7d2dd1bba3c3fe30e489a3",
|
||||
},
|
||||
},
|
||||
.paths = .{
|
||||
|
||||
@ -1,311 +0,0 @@
|
||||
#ifndef __khrplatform_h_
|
||||
#define __khrplatform_h_
|
||||
|
||||
/*
|
||||
** Copyright (c) 2008-2018 The Khronos Group Inc.
|
||||
**
|
||||
** Permission is hereby granted, free of charge, to any person obtaining a
|
||||
** copy of this software and/or associated documentation files (the
|
||||
** "Materials"), to deal in the Materials without restriction, including
|
||||
** without limitation the rights to use, copy, modify, merge, publish,
|
||||
** distribute, sublicense, and/or sell copies of the Materials, and to
|
||||
** permit persons to whom the Materials are furnished to do so, subject to
|
||||
** the following conditions:
|
||||
**
|
||||
** The above copyright notice and this permission notice shall be included
|
||||
** in all copies or substantial portions of the Materials.
|
||||
**
|
||||
** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
||||
** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
|
||||
*/
|
||||
|
||||
/* Khronos platform-specific types and definitions.
|
||||
*
|
||||
* The master copy of khrplatform.h is maintained in the Khronos EGL
|
||||
* Registry repository at https://github.com/KhronosGroup/EGL-Registry
|
||||
* The last semantic modification to khrplatform.h was at commit ID:
|
||||
* 67a3e0864c2d75ea5287b9f3d2eb74a745936692
|
||||
*
|
||||
* Adopters may modify this file to suit their platform. Adopters are
|
||||
* encouraged to submit platform specific modifications to the Khronos
|
||||
* group so that they can be included in future versions of this file.
|
||||
* Please submit changes by filing pull requests or issues on
|
||||
* the EGL Registry repository linked above.
|
||||
*
|
||||
*
|
||||
* See the Implementer's Guidelines for information about where this file
|
||||
* should be located on your system and for more details of its use:
|
||||
* http://www.khronos.org/registry/implementers_guide.pdf
|
||||
*
|
||||
* This file should be included as
|
||||
* #include <KHR/khrplatform.h>
|
||||
* by Khronos client API header files that use its types and defines.
|
||||
*
|
||||
* The types in khrplatform.h should only be used to define API-specific types.
|
||||
*
|
||||
* Types defined in khrplatform.h:
|
||||
* khronos_int8_t signed 8 bit
|
||||
* khronos_uint8_t unsigned 8 bit
|
||||
* khronos_int16_t signed 16 bit
|
||||
* khronos_uint16_t unsigned 16 bit
|
||||
* khronos_int32_t signed 32 bit
|
||||
* khronos_uint32_t unsigned 32 bit
|
||||
* khronos_int64_t signed 64 bit
|
||||
* khronos_uint64_t unsigned 64 bit
|
||||
* khronos_intptr_t signed same number of bits as a pointer
|
||||
* khronos_uintptr_t unsigned same number of bits as a pointer
|
||||
* khronos_ssize_t signed size
|
||||
* khronos_usize_t unsigned size
|
||||
* khronos_float_t signed 32 bit floating point
|
||||
* khronos_time_ns_t unsigned 64 bit time in nanoseconds
|
||||
* khronos_utime_nanoseconds_t unsigned time interval or absolute time in
|
||||
* nanoseconds
|
||||
* khronos_stime_nanoseconds_t signed time interval in nanoseconds
|
||||
* khronos_boolean_enum_t enumerated boolean type. This should
|
||||
* only be used as a base type when a client API's boolean type is
|
||||
* an enum. Client APIs which use an integer or other type for
|
||||
* booleans cannot use this as the base type for their boolean.
|
||||
*
|
||||
* Tokens defined in khrplatform.h:
|
||||
*
|
||||
* KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values.
|
||||
*
|
||||
* KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0.
|
||||
* KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0.
|
||||
*
|
||||
* Calling convention macros defined in this file:
|
||||
* KHRONOS_APICALL
|
||||
* KHRONOS_APIENTRY
|
||||
* KHRONOS_APIATTRIBUTES
|
||||
*
|
||||
* These may be used in function prototypes as:
|
||||
*
|
||||
* KHRONOS_APICALL void KHRONOS_APIENTRY funcname(
|
||||
* int arg1,
|
||||
* int arg2) KHRONOS_APIATTRIBUTES;
|
||||
*/
|
||||
|
||||
#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC)
|
||||
# define KHRONOS_STATIC 1
|
||||
#endif
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
* Definition of KHRONOS_APICALL
|
||||
*-------------------------------------------------------------------------
|
||||
* This precedes the return type of the function in the function prototype.
|
||||
*/
|
||||
#if defined(KHRONOS_STATIC)
|
||||
/* If the preprocessor constant KHRONOS_STATIC is defined, make the
|
||||
* header compatible with static linking. */
|
||||
# define KHRONOS_APICALL
|
||||
#elif defined(_WIN32)
|
||||
# define KHRONOS_APICALL __declspec(dllimport)
|
||||
#elif defined (__SYMBIAN32__)
|
||||
# define KHRONOS_APICALL IMPORT_C
|
||||
#elif defined(__ANDROID__)
|
||||
# define KHRONOS_APICALL __attribute__((visibility("default")))
|
||||
#else
|
||||
# define KHRONOS_APICALL
|
||||
#endif
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
* Definition of KHRONOS_APIENTRY
|
||||
*-------------------------------------------------------------------------
|
||||
* This follows the return type of the function and precedes the function
|
||||
* name in the function prototype.
|
||||
*/
|
||||
#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__)
|
||||
/* Win32 but not WinCE */
|
||||
# define KHRONOS_APIENTRY __stdcall
|
||||
#else
|
||||
# define KHRONOS_APIENTRY
|
||||
#endif
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
* Definition of KHRONOS_APIATTRIBUTES
|
||||
*-------------------------------------------------------------------------
|
||||
* This follows the closing parenthesis of the function prototype arguments.
|
||||
*/
|
||||
#if defined (__ARMCC_2__)
|
||||
#define KHRONOS_APIATTRIBUTES __softfp
|
||||
#else
|
||||
#define KHRONOS_APIATTRIBUTES
|
||||
#endif
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
* basic type definitions
|
||||
*-----------------------------------------------------------------------*/
|
||||
#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__)
|
||||
|
||||
|
||||
/*
|
||||
* Using <stdint.h>
|
||||
*/
|
||||
#include <stdint.h>
|
||||
typedef int32_t khronos_int32_t;
|
||||
typedef uint32_t khronos_uint32_t;
|
||||
typedef int64_t khronos_int64_t;
|
||||
typedef uint64_t khronos_uint64_t;
|
||||
#define KHRONOS_SUPPORT_INT64 1
|
||||
#define KHRONOS_SUPPORT_FLOAT 1
|
||||
/*
|
||||
* To support platform where unsigned long cannot be used interchangeably with
|
||||
* inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t.
|
||||
* Ideally, we could just use (u)intptr_t everywhere, but this could result in
|
||||
* ABI breakage if khronos_uintptr_t is changed from unsigned long to
|
||||
* unsigned long long or similar (this results in different C++ name mangling).
|
||||
* To avoid changes for existing platforms, we restrict usage of intptr_t to
|
||||
* platforms where the size of a pointer is larger than the size of long.
|
||||
*/
|
||||
#if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__)
|
||||
#if __SIZEOF_POINTER__ > __SIZEOF_LONG__
|
||||
#define KHRONOS_USE_INTPTR_T
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#elif defined(__VMS ) || defined(__sgi)
|
||||
|
||||
/*
|
||||
* Using <inttypes.h>
|
||||
*/
|
||||
#include <inttypes.h>
|
||||
typedef int32_t khronos_int32_t;
|
||||
typedef uint32_t khronos_uint32_t;
|
||||
typedef int64_t khronos_int64_t;
|
||||
typedef uint64_t khronos_uint64_t;
|
||||
#define KHRONOS_SUPPORT_INT64 1
|
||||
#define KHRONOS_SUPPORT_FLOAT 1
|
||||
|
||||
#elif defined(_WIN32) && !defined(__SCITECH_SNAP__)
|
||||
|
||||
/*
|
||||
* Win32
|
||||
*/
|
||||
typedef __int32 khronos_int32_t;
|
||||
typedef unsigned __int32 khronos_uint32_t;
|
||||
typedef __int64 khronos_int64_t;
|
||||
typedef unsigned __int64 khronos_uint64_t;
|
||||
#define KHRONOS_SUPPORT_INT64 1
|
||||
#define KHRONOS_SUPPORT_FLOAT 1
|
||||
|
||||
#elif defined(__sun__) || defined(__digital__)
|
||||
|
||||
/*
|
||||
* Sun or Digital
|
||||
*/
|
||||
typedef int khronos_int32_t;
|
||||
typedef unsigned int khronos_uint32_t;
|
||||
#if defined(__arch64__) || defined(_LP64)
|
||||
typedef long int khronos_int64_t;
|
||||
typedef unsigned long int khronos_uint64_t;
|
||||
#else
|
||||
typedef long long int khronos_int64_t;
|
||||
typedef unsigned long long int khronos_uint64_t;
|
||||
#endif /* __arch64__ */
|
||||
#define KHRONOS_SUPPORT_INT64 1
|
||||
#define KHRONOS_SUPPORT_FLOAT 1
|
||||
|
||||
#elif 0
|
||||
|
||||
/*
|
||||
* Hypothetical platform with no float or int64 support
|
||||
*/
|
||||
typedef int khronos_int32_t;
|
||||
typedef unsigned int khronos_uint32_t;
|
||||
#define KHRONOS_SUPPORT_INT64 0
|
||||
#define KHRONOS_SUPPORT_FLOAT 0
|
||||
|
||||
#else
|
||||
|
||||
/*
|
||||
* Generic fallback
|
||||
*/
|
||||
#include <stdint.h>
|
||||
typedef int32_t khronos_int32_t;
|
||||
typedef uint32_t khronos_uint32_t;
|
||||
typedef int64_t khronos_int64_t;
|
||||
typedef uint64_t khronos_uint64_t;
|
||||
#define KHRONOS_SUPPORT_INT64 1
|
||||
#define KHRONOS_SUPPORT_FLOAT 1
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
* Types that are (so far) the same on all platforms
|
||||
*/
|
||||
typedef signed char khronos_int8_t;
|
||||
typedef unsigned char khronos_uint8_t;
|
||||
typedef signed short int khronos_int16_t;
|
||||
typedef unsigned short int khronos_uint16_t;
|
||||
|
||||
/*
|
||||
* Types that differ between LLP64 and LP64 architectures - in LLP64,
|
||||
* pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
|
||||
* to be the only LLP64 architecture in current use.
|
||||
*/
|
||||
#ifdef KHRONOS_USE_INTPTR_T
|
||||
typedef intptr_t khronos_intptr_t;
|
||||
typedef uintptr_t khronos_uintptr_t;
|
||||
#elif defined(_WIN64)
|
||||
typedef signed long long int khronos_intptr_t;
|
||||
typedef unsigned long long int khronos_uintptr_t;
|
||||
#else
|
||||
typedef signed long int khronos_intptr_t;
|
||||
typedef unsigned long int khronos_uintptr_t;
|
||||
#endif
|
||||
|
||||
#if defined(_WIN64)
|
||||
typedef signed long long int khronos_ssize_t;
|
||||
typedef unsigned long long int khronos_usize_t;
|
||||
#else
|
||||
typedef signed long int khronos_ssize_t;
|
||||
typedef unsigned long int khronos_usize_t;
|
||||
#endif
|
||||
|
||||
#if KHRONOS_SUPPORT_FLOAT
|
||||
/*
|
||||
* Float type
|
||||
*/
|
||||
typedef float khronos_float_t;
|
||||
#endif
|
||||
|
||||
#if KHRONOS_SUPPORT_INT64
|
||||
/* Time types
|
||||
*
|
||||
* These types can be used to represent a time interval in nanoseconds or
|
||||
* an absolute Unadjusted System Time. Unadjusted System Time is the number
|
||||
* of nanoseconds since some arbitrary system event (e.g. since the last
|
||||
* time the system booted). The Unadjusted System Time is an unsigned
|
||||
* 64 bit value that wraps back to 0 every 584 years. Time intervals
|
||||
* may be either signed or unsigned.
|
||||
*/
|
||||
typedef khronos_uint64_t khronos_utime_nanoseconds_t;
|
||||
typedef khronos_int64_t khronos_stime_nanoseconds_t;
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Dummy value used to pad enum types to 32 bits.
|
||||
*/
|
||||
#ifndef KHRONOS_MAX_ENUM
|
||||
#define KHRONOS_MAX_ENUM 0x7FFFFFFF
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Enumerated boolean type
|
||||
*
|
||||
* Values other than zero should be considered to be true. Therefore
|
||||
* comparisons should not be made against KHRONOS_TRUE.
|
||||
*/
|
||||
typedef enum {
|
||||
KHRONOS_FALSE = 0,
|
||||
KHRONOS_TRUE = 1,
|
||||
KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM
|
||||
} khronos_boolean_enum_t;
|
||||
|
||||
#endif /* __khrplatform_h_ */
|
||||
2652
include/glad/glad.h
2652
include/glad/glad.h
File diff suppressed because it is too large
Load Diff
@ -1,4 +1,3 @@
|
||||
pub usingnamespace @cImport({
|
||||
@cInclude("glad/glad.h");
|
||||
@cInclude("SDL2/SDL.h");
|
||||
});
|
||||
|
||||
88
src/game.zig
88
src/game.zig
@ -1,5 +1,6 @@
|
||||
const std = @import("std");
|
||||
const c = @import("c.zig");
|
||||
const gl = @import("gl.zig");
|
||||
|
||||
const DEFAULT_WIDTH = 800;
|
||||
const DEFAULT_HEIGHT = 600;
|
||||
@ -15,9 +16,9 @@ pub const InitMemory = struct {
|
||||
pub const GameMemory = struct {
|
||||
global_allocator: std.mem.Allocator,
|
||||
counter: i32 = 0,
|
||||
triangle_vao: c.GLuint = 0,
|
||||
triangle_vbo: c.GLuint = 0,
|
||||
shader_program: c.GLuint = 0,
|
||||
triangle_vao: gl.GLuint = 0,
|
||||
triangle_vbo: gl.GLuint = 0,
|
||||
shader_program: gl.GLuint = 0,
|
||||
};
|
||||
|
||||
var g_init_exists = false;
|
||||
@ -29,7 +30,7 @@ fn game_init_window_err(global_allocator: std.mem.Allocator) !void {
|
||||
|
||||
try sdl_try(c.SDL_GL_SetAttribute(c.SDL_GL_DOUBLEBUFFER, 1));
|
||||
try sdl_try(c.SDL_GL_SetAttribute(c.SDL_GL_CONTEXT_MAJOR_VERSION, 4));
|
||||
try sdl_try(c.SDL_GL_SetAttribute(c.SDL_GL_CONTEXT_MINOR_VERSION, 1));
|
||||
try sdl_try(c.SDL_GL_SetAttribute(c.SDL_GL_CONTEXT_MINOR_VERSION, 5));
|
||||
try sdl_try(c.SDL_GL_SetAttribute(c.SDL_GL_CONTEXT_PROFILE_MASK, c.SDL_GL_CONTEXT_PROFILE_CORE));
|
||||
|
||||
const maybe_window = c.SDL_CreateWindow(
|
||||
@ -48,13 +49,20 @@ fn game_init_window_err(global_allocator: std.mem.Allocator) !void {
|
||||
|
||||
const context = c.SDL_GL_CreateContext(window);
|
||||
|
||||
if (c.gladLoadGLLoader(c.SDL_GL_GetProcAddress) == 0) {
|
||||
return error.GladInitError;
|
||||
}
|
||||
try gl.load(null, struct {
|
||||
fn getProcAddress(ctx: @TypeOf(null), proc: [:0]const u8) ?gl.FunctionPointer {
|
||||
_ = ctx;
|
||||
return @ptrCast(c.SDL_GL_GetProcAddress(proc));
|
||||
}
|
||||
}.getProcAddress);
|
||||
|
||||
c.glViewport(0, 0, DEFAULT_WIDTH, DEFAULT_HEIGHT);
|
||||
gl.viewport(0, 0, DEFAULT_WIDTH, DEFAULT_HEIGHT);
|
||||
|
||||
std.log.debug("OpenGL Version: {}.{}", .{ c.GLVersion.major, c.GLVersion.minor });
|
||||
var majorVer: gl.GLint = 0;
|
||||
var minorVer: gl.GLint = 0;
|
||||
gl.getIntegerv(gl.MAJOR_VERSION, &majorVer);
|
||||
gl.getIntegerv(gl.MINOR_VERSION, &minorVer);
|
||||
std.log.debug("OpenGL Version: {}.{}", .{ majorVer, minorVer });
|
||||
|
||||
g_init = try global_allocator.create(InitMemory);
|
||||
g_init_exists = true;
|
||||
@ -82,52 +90,52 @@ export fn game_init(global_allocator: *std.mem.Allocator) void {
|
||||
.global_allocator = global_allocator.*,
|
||||
};
|
||||
|
||||
c.glGenBuffers(1, &g_mem.triangle_vbo);
|
||||
c.glGenVertexArrays(1, &g_mem.triangle_vao);
|
||||
gl.genBuffers(1, &g_mem.triangle_vbo);
|
||||
gl.genVertexArrays(1, &g_mem.triangle_vao);
|
||||
|
||||
c.glBindVertexArray(g_mem.triangle_vao);
|
||||
gl.bindVertexArray(g_mem.triangle_vao);
|
||||
|
||||
c.glBindBuffer(c.GL_ARRAY_BUFFER, g_mem.triangle_vbo);
|
||||
c.glBufferData(c.GL_ARRAY_BUFFER, @sizeOf(@TypeOf(vertices)), &vertices, c.GL_STATIC_DRAW);
|
||||
c.glVertexAttribPointer(0, 3, c.GL_FLOAT, c.GL_FALSE, @sizeOf(f32) * 3, @ptrFromInt(0));
|
||||
c.glEnableVertexAttribArray(0);
|
||||
gl.bindBuffer(gl.ARRAY_BUFFER, g_mem.triangle_vbo);
|
||||
gl.bufferData(gl.ARRAY_BUFFER, @sizeOf(@TypeOf(vertices)), &vertices, gl.STATIC_DRAW);
|
||||
gl.vertexAttribPointer(0, 3, gl.FLOAT, gl.FALSE, @sizeOf(f32) * 3, @ptrFromInt(0));
|
||||
gl.enableVertexAttribArray(0);
|
||||
|
||||
const vertex_shader = c.glCreateShader(c.GL_VERTEX_SHADER);
|
||||
defer c.glDeleteShader(vertex_shader);
|
||||
const vertex_shader = gl.createShader(gl.VERTEX_SHADER);
|
||||
defer gl.deleteShader(vertex_shader);
|
||||
|
||||
c.glShaderSource(vertex_shader, 1, &[_][*c]const u8{vertex_shader_code}, null);
|
||||
c.glCompileShader(vertex_shader);
|
||||
gl.shaderSource(vertex_shader, 1, &[_][*c]const u8{vertex_shader_code}, null);
|
||||
gl.compileShader(vertex_shader);
|
||||
var success: c_int = 0;
|
||||
c.glGetShaderiv(vertex_shader, c.GL_COMPILE_STATUS, &success);
|
||||
gl.getShaderiv(vertex_shader, gl.COMPILE_STATUS, &success);
|
||||
if (success == 0) {
|
||||
var info_log: [512:0]u8 = undefined;
|
||||
c.glGetShaderInfoLog(vertex_shader, info_log.len, null, &info_log);
|
||||
gl.getShaderInfoLog(vertex_shader, info_log.len, null, &info_log);
|
||||
std.log.err("ERROR::SHADER::VERTEX::COMPILATION_FAILED\n{s}\n", .{@as([:0]const u8, &info_log)});
|
||||
}
|
||||
|
||||
const fragment_shader = c.glCreateShader(c.GL_FRAGMENT_SHADER);
|
||||
defer c.glDeleteShader(fragment_shader);
|
||||
const fragment_shader = gl.createShader(gl.FRAGMENT_SHADER);
|
||||
defer gl.deleteShader(fragment_shader);
|
||||
|
||||
c.glShaderSource(fragment_shader, 1, &[_][*c]const u8{fragment_shader_code}, null);
|
||||
c.glCompileShader(fragment_shader);
|
||||
gl.shaderSource(fragment_shader, 1, &[_][*c]const u8{fragment_shader_code}, null);
|
||||
gl.compileShader(fragment_shader);
|
||||
success = 0;
|
||||
c.glGetShaderiv(fragment_shader, c.GL_COMPILE_STATUS, &success);
|
||||
gl.getShaderiv(fragment_shader, gl.COMPILE_STATUS, &success);
|
||||
if (success == 0) {
|
||||
var info_log: [512:0]u8 = undefined;
|
||||
c.glGetShaderInfoLog(fragment_shader, info_log.len, null, &info_log);
|
||||
gl.getShaderInfoLog(fragment_shader, info_log.len, null, &info_log);
|
||||
std.log.err("ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n{s}\n", .{@as([:0]const u8, &info_log)});
|
||||
}
|
||||
|
||||
g_mem.shader_program = c.glCreateProgram();
|
||||
c.glAttachShader(g_mem.shader_program, vertex_shader);
|
||||
c.glAttachShader(g_mem.shader_program, fragment_shader);
|
||||
c.glLinkProgram(g_mem.shader_program);
|
||||
g_mem.shader_program = gl.createProgram();
|
||||
gl.attachShader(g_mem.shader_program, vertex_shader);
|
||||
gl.attachShader(g_mem.shader_program, fragment_shader);
|
||||
gl.linkProgram(g_mem.shader_program);
|
||||
|
||||
success = 0;
|
||||
c.glGetProgramiv(g_mem.shader_program, c.GL_LINK_STATUS, &success);
|
||||
gl.getProgramiv(g_mem.shader_program, gl.LINK_STATUS, &success);
|
||||
if (success == 0) {
|
||||
var info_log: [512:0]u8 = undefined;
|
||||
c.glGetProgramInfoLog(g_mem.shader_program, info_log.len, null, &info_log);
|
||||
gl.getProgramInfoLog(g_mem.shader_program, info_log.len, null, &info_log);
|
||||
std.log.err("ERROR::SHADER::PROGRAM::LINK_FAILED\n{s}\n", .{@as([:0]const u8, &info_log)});
|
||||
}
|
||||
}
|
||||
@ -159,7 +167,7 @@ export fn game_update() bool {
|
||||
g_init.width = event.window.data1;
|
||||
g_init.height = event.window.data2;
|
||||
|
||||
c.glViewport(0, 0, g_init.width, g_init.height);
|
||||
gl.viewport(0, 0, g_init.width, g_init.height);
|
||||
},
|
||||
else => {},
|
||||
}
|
||||
@ -168,12 +176,12 @@ export fn game_update() bool {
|
||||
}
|
||||
g_mem.counter += 1;
|
||||
|
||||
c.glClearColor(0.0, 0.0, 0.0, 1.0);
|
||||
c.glClear(c.GL_COLOR_BUFFER_BIT);
|
||||
gl.clearColor(0.0, 0.0, 0.0, 1.0);
|
||||
gl.clear(gl.COLOR_BUFFER_BIT);
|
||||
|
||||
c.glUseProgram(g_mem.shader_program);
|
||||
c.glBindVertexArray(g_mem.triangle_vao);
|
||||
c.glDrawArrays(c.GL_TRIANGLES, 0, 3);
|
||||
gl.useProgram(g_mem.shader_program);
|
||||
gl.bindVertexArray(g_mem.triangle_vao);
|
||||
gl.drawArrays(gl.TRIANGLES, 0, 3);
|
||||
|
||||
c.SDL_GL_SwapWindow(g_init.window);
|
||||
c.SDL_Delay(1);
|
||||
|
||||
9275
src/gl.zig
Normal file
9275
src/gl.zig
Normal file
File diff suppressed because it is too large
Load Diff
1421
src/glad.c
1421
src/glad.c
File diff suppressed because it is too large
Load Diff
Loading…
x
Reference in New Issue
Block a user