package vendor:nanovg/gl

Source

Blend :: struct {
	src_RGB:   u32,
	dst_RGB:   u32,
	src_alpha: u32,
	dst_alpha: u32,
}

Call :: struct {
	type:           CallType,
	image:          int,
	pathOffset:     int,
	pathCount:      int,
	triangleOffset: int,
	triangleCount:  int,
	uniformOffset:  int,
	blendFunc:      Blend,
}

CallType :: enum int {
	NONE, 
	FILL, 
	CONVEX_FILL, 
	STROKE, 
	TRIANGLES, 
}

Color :: [4]f32

Context :: struct {
	shader:          Shader,
	textures:        [dynamic]Texture,
	view:            [2]f32,
	textureId:       int,
	vertBuf:         u32,
	vertArr:         u32,
	// GL3
	fragBuf:         u32,
	// USE_UNIFORMBUFFER
	fragSize:        int,
	flags:           bit_set[CreateFlag],
	frag_binding:    u32,
	// Per frame buffers
	calls:           [dynamic]Call,
	paths:           [dynamic]Path,
	verts:           [dynamic][4]f32,
	uniforms:        [dynamic]u8,
	// cached state used for state filter
	boundTexture:    u32,
	stencilMask:     u32,
	stencilFunc:     u32,
	stencilFuncRef:  i32,
	stencilFuncMask: u32,
	blendFunc:       Blend,
	dummyTex:        int,
}

CreateFlag :: enum int {
	// Flag indicating if geometry based anti-aliasing is used (may not be needed when using MSAA).
	ANTI_ALIAS, 
	// Flag indicating if strokes should be drawn using stencil buffer. The rendering will be a little
	// slower, but path overlaps (i.e. self-intersecting or sharp turns) will be drawn just once.
	STENCIL_STROKES, 
	// additional debug checks
	DEBUG, 
}

CreateFlags :: bit_set[CreateFlag]

FragUniforms :: struct #packed {
	scissorMat:   [12]f32,
	// matrices are actually 3 vec4s
	paintMat:     [12]f32,
	innerColor:   [4]f32,
	outerColor:   [4]f32,
	scissorExt:   [2]f32,
	scissorScale: [2]f32,
	extent:       [2]f32,
	radius:       f32,
	feather:      f32,
	strokeMult:   f32,
	strokeThr:    f32,
	texType:      i32,
	type:         ShaderType,
}

ImageFlags :: bit_set[nanovg.ImageFlag]

Paint :: nanovg.Paint

Path :: struct {
	fillOffset:   int,
	fillCount:    int,
	strokeOffset: int,
	strokeCount:  int,
}

ScissorT :: nanovg.ScissorT

Shader :: struct {
	prog: u32,
	frag: u32,
	vert: u32,
	loc:  [UniformLoc]i32,
}

ShaderType :: enum i32 {
	FILL_GRAD, 
	FILL_IMG, 
	SIMPLE, 
	IMG, 
}

Texture :: struct {
	id:     int,
	tex:    u32,
	width:  int,
	height: int,
	type:   nanovg.Texture,
	flags:  bit_set[nanovg.ImageFlag],
}

TextureType :: nanovg.Texture

UniformLoc :: enum int {
	VIEW_SIZE, 
	TEX, 
	FRAG, 
}

Vertex :: [4]f32

framebuffer :: struct {
	ctx:     ^nanovg.Context,
	fbo:     u32,
	rbo:     u32,
	texture: u32,
	image:   int,
}

BLEND_FACTOR_TABLE: [nanovg.BlendFactor]u32 : [nvg.BlendFactor]u32{.ZERO = gl.ZERO, .ONE = gl.ONE, .SRC_COLOR = gl.SRC_COLOR, .ONE_MINUS_SRC_COLOR = gl.ONE_MINUS_SRC_COLOR, .DST_COLOR = gl.DST_COLOR, .ONE_MINUS_DST_COLOR = gl.ONE_MINUS_DST_COLOR, .SRC_ALPHA = gl.SRC_ALPHA, .ONE_MINUS_SRC_ALPHA = gl.ONE_MINUS_SRC_ALPHA, .DST_ALPHA = gl.DST_ALPHA, .ONE_MINUS_DST_ALPHA = gl.ONE_MINUS_DST_ALPHA, .SRC_ALPHA_SATURATE = gl.SRC_ALPHA_SATURATE}

DEFAULT_FBO :: 100_000

DEFAULT_IMPLEMENTATION_STRING :: #config(NANOVG_GL_IMPL, "GL3")

GL2 :: false

GL2_IMPLEMENTATION :: DEFAULT_IMPLEMENTATION_STRING == "GL2"

GL3 :: true

GL3_IMPLEMENTATION :: DEFAULT_IMPLEMENTATION_STRING == "GL3"

GLES2 :: false

GLES2_IMPLEMENTATION :: DEFAULT_IMPLEMENTATION_STRING == "GLES2"

GLES3 :: false

GLES3_IMPLEMENTATION :: DEFAULT_IMPLEMENTATION_STRING == "GLES3"

GL_IMPLEMENTATION :: true

GL_UNIFORMARRAY_SIZE :: 11

GL_USE_UNIFORMBUFFER :: true

USE_STATE_FILTER :: #config(USE_STATE_FILTER, true)

defaultFBO: i32 = …

frag_shader: []u8 = …

vert_shader: []u8 = …

BindFramebuffer :: proc(fb: ^framebuffer) {…}

Create :: proc(flags: bit_set[CreateFlag]) -> ^nanovg.Context {…}

CreateFramebuffer :: proc(ctx: ^nanovg.Context, w, h: int, imageFlags: bit_set[nanovg.ImageFlag]) -> (fb: framebuffer) {…}

CreateImageFromHandle :: proc(ctx: ^nanovg.Context, textureId: u32, w, h: int, imageFlags: bit_set[nanovg.ImageFlag]) -> int {…}

DeleteFramebuffer :: proc(fb: ^framebuffer) {…}

Destroy :: proc(ctx: ^nanovg.Context) {…}

ImageHandle :: proc(ctx: ^nanovg.Context, textureId: int) -> u32 {…}