maybe

main.go

@@ -12,114 +12,85 @@ import (
 //go:embed glsl-optimizer.wasm
 var glslOptimizer []byte
 
-var engine *wasmtime.Engine
-var store *wasmtime.Store
-var module *wasmtime.Module
-var instance *wasmtime.Instance
-var optimizeGLSL *wasmtime.Func
-var memory *wasmtime.Memory
-
 func tryOptimize(src string, vertex bool) (string, error) {
-	for {
-		data := memory.UnsafeData(store)
-		ptr := len(data) - len(src) - 1
-		copy(data[ptr:], src)
-		data[ptr+len(src)] = 0
-
-		var ty int32
-		if vertex {
-			ty = 1
-		}
-
-		res, err := optimizeGLSL.Call(store, int32(ptr), int32(3), ty)
-		if err != nil {
-			return "", err
-		}
-		var out strings.Builder
-		i := res.(int32)
-		if i == 0 {
-			return "", errors.New("something went wrong")
-		}
-		for {
-			if data[i] == 0 {
-				break
-			}
-			out.WriteByte(data[i])
-			i++
-		}
-
-		if out.Len() > 10 {
-			return out.String(), nil
-		}
-
-		// hack: add a newline character and try again
-		src += "\n"
+	engine := wasmtime.NewEngine()
+	store := wasmtime.NewStore(engine)
+	module, err := wasmtime.NewModule(engine, glslOptimizer)
+	if err != nil {
+		return "", err
 	}
-}
-
-func Optimize(input, output string) error {
-	if engine == nil {
-		engine = wasmtime.NewEngine()
+	instance, err := wasmtime.NewInstance(store, module, []wasmtime.AsExtern{
+		wasmtime.WrapFunc(store, func(int32, int32, int32, int32) int32 { // fd_write
+			return 0
+		}),
+		wasmtime.WrapFunc(store, func(int32, int32, int32, int32) int32 { // fd_read
+			return 0
+		}),
+		wasmtime.WrapFunc(store, func(int32, int64, int32, int32) int32 { // fd_seek
+			return 0
+		}),
+		wasmtime.WrapFunc(store, func(int32) int32 { // fd_close
+			return 0
+		}),
+		wasmtime.WrapFunc(store, func(int32) { // proc_exit
+			return
+		}),
+	})
+	if err != nil {
+		return "", err
 	}
-	if store == nil {
-		store = wasmtime.NewStore(engine)
+	initialize := instance.GetExport(store, "_initialize")
+	if initialize == nil {
+		return "", errors.New("can't find _initialize func")
+	}
+	_, err = initialize.Func().Call(store)
+	if err != nil {
+		return "", err
 	}
 
-	if module == nil {
-		var err error
-		module, err = wasmtime.NewModule(engine, glslOptimizer)
-		if err != nil {
-			return err
-		}
+	opt := instance.GetExport(store, "optimize_glsl")
+	if opt == nil {
+		return "", errors.New("can't find optimize_glsl func")
 	}
+	optimizeGLSL := opt.Func()
 
-	if instance == nil {
-		var err error
-		instance, err = wasmtime.NewInstance(store, module, []wasmtime.AsExtern{
-			wasmtime.WrapFunc(store, func(int32, int32, int32, int32) int32 { // fd_write
-				return 0
-			}),
-			wasmtime.WrapFunc(store, func(int32, int32, int32, int32) int32 { // fd_read
-				return 0
-			}),
-			wasmtime.WrapFunc(store, func(int32, int64, int32, int32) int32 { // fd_seek
-				return 0
-			}),
-			wasmtime.WrapFunc(store, func(int32) int32 { // fd_close
-				return 0
-			}),
-			wasmtime.WrapFunc(store, func(int32) { // proc_exit
-				return
-			}),
-		})
-		if err != nil {
-			return err
-		}
-		initialize := instance.GetExport(store, "_initialize")
-		if initialize == nil {
-			return errors.New("can't find _initialize func")
-		}
-		_, err = initialize.Func().Call(store)
-		if err != nil {
-			return err
-		}
+	mem := instance.GetExport(store, "memory")
+	if mem == nil {
+		return "", errors.New("can't find memory func")
 	}
+	memory := mem.Memory()
 
-	if optimizeGLSL == nil {
-		opt := instance.GetExport(store, "optimize_glsl")
-		if opt == nil {
-			return errors.New("can't find optimize_glsl func")
-		}
-		optimizeGLSL = opt.Func()
+	data := memory.UnsafeData(store)
+	ptr := len(data) - len(src) - 1
+	copy(data[ptr:], src)
+	data[ptr+len(src)] = 0
+
+	var ty int32
+	if vertex {
+		ty = 1
 	}
-	if memory == nil {
-		mem := instance.GetExport(store, "memory")
-		if mem == nil {
-			return errors.New("can't find memory func")
+
+	res, err := optimizeGLSL.Call(store, int32(ptr), int32(3), ty)
+	if err != nil {
+		return "", err
+	}
+	var out strings.Builder
+	i := res.(int32)
+	if i == 0 {
+		return "", errors.New("something went wrong")
+	}
+	for {
+		if data[i] == 0 {
+			break
 		}
-		memory = mem.Memory()
+		out.WriteByte(data[i])
+		i++
 	}
 
+	return out.String(), nil
+}
+
+func Optimize(input, output string) error {
 	src, err := os.ReadFile(input)
 	if err != nil {
 		return err