chore(v2): vendor dependencies for offline/China builds

go mod vendor pins onnxruntime_go v1.12.1, Gio and the rest into v2/vendor so go run/build work without hitting proxy.golang.org (blocked/slow in China). Verified: CGO_ENABLED=1 go build -mod=vendor ./internal/spike and GOOS=windows go build -mod=vendor ./internal/ui both pass. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-07-23 16:35:01 +08:00
parent 97c1c4a974
commit f58728cddd
972 changed files with 597802 additions and 0 deletions
@@ -0,0 +1,129 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+package driver
+
+import (
+	"fmt"
+	"unsafe"
+
+	"gioui.org/internal/gl"
+)
+
+// See gpu/api.go for documentation for the API types.
+
+type API interface {
+	implementsAPI()
+}
+
+type RenderTarget interface {
+	ImplementsRenderTarget()
+}
+
+type OpenGLRenderTarget gl.Framebuffer
+
+type Direct3D11RenderTarget struct {
+	// RenderTarget is a *ID3D11RenderTargetView.
+	RenderTarget unsafe.Pointer
+}
+
+type MetalRenderTarget struct {
+	// Texture is a MTLTexture.
+	Texture uintptr
+}
+
+type VulkanRenderTarget struct {
+	// WaitSem is a VkSemaphore that must signaled before accessing Framebuffer.
+	WaitSem uint64
+	// SignalSem is a VkSemaphore that signal access to Framebuffer is complete.
+	SignalSem uint64
+	// Fence is a VkFence that is set when all commands to Framebuffer has completed.
+	Fence uint64
+	// Image is the VkImage to render into.
+	Image uint64
+	// Framebuffer is a VkFramebuffer for Image.
+	Framebuffer uint64
+}
+
+type OpenGL struct {
+	// ES forces the use of ANGLE OpenGL ES libraries on macOS. It is
+	// ignored on all other platforms.
+	ES bool
+	// Context contains the WebGL context for WebAssembly platforms. It is
+	// empty for all other platforms; an OpenGL context is assumed current when
+	// calling NewDevice.
+	Context gl.Context
+	// Shared instructs users of the context to restore the GL state after
+	// use.
+	Shared bool
+}
+
+type Direct3D11 struct {
+	// Device contains a *ID3D11Device.
+	Device unsafe.Pointer
+}
+
+type Metal struct {
+	// Device is an MTLDevice.
+	Device uintptr
+	// Queue is a MTLCommandQueue.
+	Queue uintptr
+	// PixelFormat is the MTLPixelFormat of the default framebuffer.
+	PixelFormat int
+}
+
+type Vulkan struct {
+	// PhysDevice is a VkPhysicalDevice.
+	PhysDevice unsafe.Pointer
+	// Device is a VkDevice.
+	Device unsafe.Pointer
+	// QueueFamily is the queue familily index of the queue.
+	QueueFamily int
+	// QueueIndex is the logical queue index of the queue.
+	QueueIndex int
+	// Format is a VkFormat that matches render targets.
+	Format int
+}
+
+// API specific device constructors.
+var (
+	NewOpenGLDevice     func(api OpenGL) (Device, error)
+	NewDirect3D11Device func(api Direct3D11) (Device, error)
+	NewMetalDevice      func(api Metal) (Device, error)
+	NewVulkanDevice     func(api Vulkan) (Device, error)
+)
+
+// NewDevice creates a new Device given the api.
+//
+// Note that the device does not assume ownership of the resources contained in
+// api; the caller must ensure the resources are valid until the device is
+// released.
+func NewDevice(api API) (Device, error) {
+	switch api := api.(type) {
+	case OpenGL:
+		if NewOpenGLDevice != nil {
+			return NewOpenGLDevice(api)
+		}
+	case Direct3D11:
+		if NewDirect3D11Device != nil {
+			return NewDirect3D11Device(api)
+		}
+	case Metal:
+		if NewMetalDevice != nil {
+			return NewMetalDevice(api)
+		}
+	case Vulkan:
+		if NewVulkanDevice != nil {
+			return NewVulkanDevice(api)
+		}
+	}
+	return nil, fmt.Errorf("driver: no driver available for the API %T", api)
+}
+
+func (OpenGL) implementsAPI()                          {}
+func (Direct3D11) implementsAPI()                      {}
+func (Metal) implementsAPI()                           {}
+func (Vulkan) implementsAPI()                          {}
+func (OpenGLRenderTarget) ImplementsRenderTarget()     {}
+func (Direct3D11RenderTarget) ImplementsRenderTarget() {}
+func (MetalRenderTarget) ImplementsRenderTarget()      {}
+func (VulkanRenderTarget) ImplementsRenderTarget()     {}
@@ -0,0 +1,240 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+package driver
+
+import (
+	"errors"
+	"image"
+	"time"
+
+	"gioui.org/internal/f32color"
+	"gioui.org/shader"
+)
+
+// Device represents the abstraction of underlying GPU
+// APIs such as OpenGL, Direct3D useful for rendering Gio
+// operations.
+type Device interface {
+	BeginFrame(target RenderTarget, clear bool, viewport image.Point) Texture
+	EndFrame()
+	Caps() Caps
+	NewTimer() Timer
+	// IsContinuousTime reports whether all timer measurements
+	// are valid at the point of call.
+	IsTimeContinuous() bool
+	NewTexture(format TextureFormat, width, height int, minFilter, magFilter TextureFilter, bindings BufferBinding) (Texture, error)
+	NewImmutableBuffer(typ BufferBinding, data []byte) (Buffer, error)
+	NewBuffer(typ BufferBinding, size int) (Buffer, error)
+	NewComputeProgram(shader shader.Sources) (Program, error)
+	NewVertexShader(src shader.Sources) (VertexShader, error)
+	NewFragmentShader(src shader.Sources) (FragmentShader, error)
+	NewPipeline(desc PipelineDesc) (Pipeline, error)
+
+	Viewport(x, y, width, height int)
+	DrawArrays(off, count int)
+	DrawElements(off, count int)
+
+	BeginRenderPass(t Texture, desc LoadDesc)
+	EndRenderPass()
+	PrepareTexture(t Texture)
+	BindProgram(p Program)
+	BindPipeline(p Pipeline)
+	BindTexture(unit int, t Texture)
+	BindVertexBuffer(b Buffer, offset int)
+	BindIndexBuffer(b Buffer)
+	BindImageTexture(unit int, texture Texture)
+	BindUniforms(buf Buffer)
+	BindStorageBuffer(binding int, buf Buffer)
+
+	BeginCompute()
+	EndCompute()
+	CopyTexture(dst Texture, dstOrigin image.Point, src Texture, srcRect image.Rectangle)
+	DispatchCompute(x, y, z int)
+
+	Release()
+}
+
+var ErrDeviceLost = errors.New("GPU device lost")
+
+type LoadDesc struct {
+	Action     LoadAction
+	ClearColor f32color.RGBA
+}
+
+type Pipeline interface {
+	Release()
+}
+
+type PipelineDesc struct {
+	VertexShader   VertexShader
+	FragmentShader FragmentShader
+	VertexLayout   VertexLayout
+	BlendDesc      BlendDesc
+	PixelFormat    TextureFormat
+	Topology       Topology
+}
+
+type VertexLayout struct {
+	Inputs []InputDesc
+	Stride int
+}
+
+// InputDesc describes a vertex attribute as laid out in a Buffer.
+type InputDesc struct {
+	Type shader.DataType
+	Size int
+
+	Offset int
+}
+
+type BlendDesc struct {
+	Enable               bool
+	SrcFactor, DstFactor BlendFactor
+}
+
+type BlendFactor uint8
+
+type Topology uint8
+
+type (
+	TextureFilter uint8
+	TextureFormat uint8
+)
+
+type BufferBinding uint8
+
+type LoadAction uint8
+
+type Features uint
+
+type Caps struct {
+	// BottomLeftOrigin is true if the driver has the origin in the lower left
+	// corner. The OpenGL driver returns true.
+	BottomLeftOrigin bool
+	Features         Features
+	MaxTextureSize   int
+}
+
+type VertexShader interface {
+	Release()
+}
+
+type FragmentShader interface {
+	Release()
+}
+
+type Program interface {
+	Release()
+}
+
+type Buffer interface {
+	Release()
+	Upload(data []byte)
+	Download(data []byte) error
+}
+
+type Timer interface {
+	Begin()
+	End()
+	Duration() (time.Duration, bool)
+	Release()
+}
+
+type Texture interface {
+	RenderTarget
+	Upload(offset, size image.Point, pixels []byte, stride int)
+	ReadPixels(src image.Rectangle, pixels []byte, stride int) error
+	Release()
+}
+
+const (
+	BufferBindingIndices BufferBinding = 1 << iota
+	BufferBindingVertices
+	BufferBindingUniforms
+	BufferBindingTexture
+	BufferBindingFramebuffer
+	BufferBindingShaderStorageRead
+	BufferBindingShaderStorageWrite
+)
+
+const (
+	TextureFormatSRGBA TextureFormat = iota
+	TextureFormatFloat
+	TextureFormatRGBA8
+	// TextureFormatOutput denotes the format used by the output framebuffer.
+	TextureFormatOutput
+)
+
+const (
+	FilterNearest TextureFilter = iota
+	FilterLinear
+	FilterLinearMipmapLinear
+)
+
+const (
+	FeatureTimers Features = 1 << iota
+	FeatureFloatRenderTargets
+	FeatureCompute
+	FeatureSRGB
+)
+
+const (
+	TopologyTriangleStrip Topology = iota
+	TopologyTriangles
+)
+
+const (
+	BlendFactorOne BlendFactor = iota
+	BlendFactorOneMinusSrcAlpha
+	BlendFactorZero
+	BlendFactorDstColor
+)
+
+const (
+	LoadActionKeep LoadAction = iota
+	LoadActionClear
+	LoadActionInvalidate
+)
+
+var ErrContentLost = errors.New("buffer content lost")
+
+func (f Features) Has(feats Features) bool {
+	return f&feats == feats
+}
+
+func DownloadImage(d Device, t Texture, img *image.RGBA) error {
+	r := img.Bounds()
+	if err := t.ReadPixels(r, img.Pix, img.Stride); err != nil {
+		return err
+	}
+	if d.Caps().BottomLeftOrigin {
+		// OpenGL origin is in the lower-left corner. Flip the image to
+		// match.
+		flipImageY(r.Dx()*4, r.Dy(), img.Pix)
+	}
+	return nil
+}
+
+func flipImageY(stride, height int, pixels []byte) {
+	// Flip image in y-direction. OpenGL's origin is in the lower
+	// left corner.
+	row := make([]uint8, stride)
+	for y := range height / 2 {
+		y1 := height - y - 1
+		dest := y1 * stride
+		src := y * stride
+		copy(row, pixels[dest:])
+		copy(pixels[dest:], pixels[src:src+len(row)])
+		copy(pixels[src:], row)
+	}
+}
+
+func UploadImage(t Texture, offset image.Point, img *image.RGBA) {
+	var pixels []byte
+	size := img.Bounds().Size()
+	min := img.Rect.Min
+	start := img.PixOffset(min.X, min.Y)
+	end := img.PixOffset(min.X+size.X, min.Y+size.Y-1)
+	pixels = img.Pix[start:end]
+	t.Upload(offset, size, pixels, img.Stride)
+}