updated ebiten version from 2.7.9 to 2.9.9

2026-06-15 19:06:55 +02:00
parent 21edbc41c4
commit db1b625069
405 changed files with 31913 additions and 12595 deletions
@@ -14,28 +14,58 @@

 //go:build playstation5

-// The actual implementation will be provided by -overlay.
+// The actual implementation will be provided by github.com/hajimehoshi/uwagaki.

 #include "graphics_playstation5.h"

-extern "C" ebitengine_Error ebitengine_InitializeGraphics(void) {
+extern "C" ebitengine_Error ebitengine_InitializeGraphics(void) { return {}; }
+
+extern "C" ebitengine_Error ebitengine_NewImage(int *image, int width,
+                                                int height) {
  return {};
 }

-extern "C" ebitengine_Error ebitengine_NewImage(int* image, int width, int height) {
+extern "C" void ebitengine_ReadPixels(int image, uint8_t *pixels,
+                                      ebitengine_Region region) {}
+
+extern "C" ebitengine_Error ebitengine_FlushReadPixels(int image) { return {}; }
+
+extern "C" void ebitengine_WritePixels(int image, const uint8_t *pixels,
+                                       ebitengine_Region region) {}
+
+extern "C" ebitengine_Error ebitengine_FlushWritePixels(int image) {
  return {};
 }

-extern "C" ebitengine_Error ebitengine_NewScreenFramebufferImage(int* image, int width, int height) {
+extern "C" ebitengine_Error
+ebitengine_NewScreenFramebufferImage(int *image, int width, int height) {
  return {};
 }

-extern "C" void ebitengine_DisposeImage(int id) {
-}
+extern "C" void ebitengine_DisposeImage(int id) {}

-extern "C" ebitengine_Error ebitengine_NewShader(int* shader, const char* source) {
+extern "C" void ebitengine_Begin() {}
+
+extern "C" void ebitengine_End(int present) {}
+
+extern "C" void ebitengine_SetVertices(const float *vertices, int vertex_count,
+                                       const uint32_t *indices,
+                                       int index_count) {}
+
+extern "C" ebitengine_Error
+ebitengine_DrawTriangles(int dst, const int *srcs, int src_count, int shader,
+                         const ebitengine_DstRegion *dst_regions,
+                         int dst_region_count, int index_offset,
+                         ebitengine_Blend blend, const uint32_t *uniforms,
+                         int uniform_count, int fill_rule) {
  return {};
 }

-extern "C" void ebitengine_DisposeShader(int id) {
+extern "C" ebitengine_Error ebitengine_NewShader(
+    int *shader, const char *vertex_header, int vertex_header_size,
+    const char *vertex_text, int vertex_text_size, const char *pixel_header,
+    int pixel_header_size, const char *pixel_text, int pixel_text_size) {
+  return {};
 }
+
+extern "C" void ebitengine_DisposeShader(int id) {}
@@ -17,16 +17,24 @@
 package playstation5

 // #include "graphics_playstation5.h"
+// #include <stdlib.h>
 import "C"

 import (
 	"fmt"
+	"runtime"
+	"unsafe"

 	"github.com/hajimehoshi/ebiten/v2/internal/graphics"
 	"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
 	"github.com/hajimehoshi/ebiten/v2/internal/shaderir"
 )

+//export ebitengine_ProjectionMatrixUniformDwordIndex
+func ebitengine_ProjectionMatrixUniformDwordIndex() C.int {
+	return C.int(graphics.ProjectionMatrixUniformDwordIndex)
+}
+
 type playstation5Error struct {
 	name    string
 	code    int
@@ -60,10 +68,16 @@ func (g *Graphics) Initialize() error {
 }

 func (g *Graphics) Begin() error {
+	C.ebitengine_Begin()
 	return nil
 }

 func (g *Graphics) End(present bool) error {
+	var cPresent C.int
+	if present {
+		cPresent = 1
+	}
+	C.ebitengine_End(cPresent)
 	return nil
 }

@@ -71,11 +85,16 @@ func (g *Graphics) SetTransparent(transparent bool) {
 }

 func (g *Graphics) SetVertices(vertices []float32, indices []uint32) error {
+	defer runtime.KeepAlive(vertices)
+	defer runtime.KeepAlive(indices)
+	C.ebitengine_SetVertices((*C.float)(unsafe.SliceData(vertices)), C.int(len(vertices)), (*C.uint32_t)(unsafe.SliceData(indices)), C.int(len(indices)))
 	return nil
 }

 func (g *Graphics) NewImage(width, height int) (graphicsdriver.Image, error) {
 	var id C.int
+	width = graphics.InternalImageSize(width)
+	height = graphics.InternalImageSize(height)
 	if err := C.ebitengine_NewImage(&id, C.int(width), C.int(height)); !C.ebitengine_IsErrorNil(&err) {
 		return nil, newPlaystation5Error("(*playstation5.Graphics).NewImage", err)
 	}
@@ -98,7 +117,7 @@ func (g *Graphics) SetVsyncEnabled(enabled bool) {
 }

 func (g *Graphics) NeedsClearingScreen() bool {
-	return false
+	return true
 }

 func (g *Graphics) MaxImageSize() int {
@@ -106,9 +125,15 @@ func (g *Graphics) MaxImageSize() int {
 }

 func (g *Graphics) NewShader(program *shaderir.Program) (graphicsdriver.Shader, error) {
+	s := precompiledShaders[program.SourceHash]
+	defer runtime.KeepAlive(s)
+
 	var id C.int
-	// TODO: Give a source code.
-	if err := C.ebitengine_NewShader(&id, nil); !C.ebitengine_IsErrorNil(&err) {
+	if err := C.ebitengine_NewShader(&id,
+		(*C.char)(unsafe.Pointer(unsafe.SliceData(s.vertexHeader))), C.int(len(s.vertexHeader)),
+		(*C.char)(unsafe.Pointer(unsafe.SliceData(s.vertexText))), C.int(len(s.vertexText)),
+		(*C.char)(unsafe.Pointer(unsafe.SliceData(s.pixelHeader))), C.int(len(s.pixelHeader)),
+		(*C.char)(unsafe.Pointer(unsafe.SliceData(s.pixelText))), C.int(len(s.pixelText))); !C.ebitengine_IsErrorNil(&err) {
 		return nil, newPlaystation5Error("(*playstation5.Graphics).NewShader", err)
 	}
 	return &Shader{
@@ -116,7 +141,43 @@ func (g *Graphics) NewShader(program *shaderir.Program) (graphicsdriver.Shader,
 	}, nil
 }

-func (g *Graphics) DrawTriangles(dst graphicsdriver.ImageID, srcs [graphics.ShaderImageCount]graphicsdriver.ImageID, shader graphicsdriver.ShaderID, dstRegions []graphicsdriver.DstRegion, indexOffset int, blend graphicsdriver.Blend, uniforms []uint32, fillRule graphicsdriver.FillRule) error {
+func (g *Graphics) DrawTriangles(dst graphicsdriver.ImageID, srcs [graphics.ShaderSrcImageCount]graphicsdriver.ImageID, shader graphicsdriver.ShaderID, dstRegions []graphicsdriver.DstRegion, indexOffset int, blend graphicsdriver.Blend, uniforms []uint32, fillRule graphicsdriver.FillRule) error {
+	cSrcs := make([]C.int, len(srcs))
+	for i, src := range srcs {
+		cSrcs[i] = C.int(src)
+	}
+	defer runtime.KeepAlive(cSrcs)
+
+	cDstRegions := make([]C.ebitengine_DstRegion, len(dstRegions))
+	defer runtime.KeepAlive(cDstRegions)
+	for i, r := range dstRegions {
+		cDstRegions[i] = C.ebitengine_DstRegion{
+			min_x:       C.int(r.Region.Min.X),
+			min_y:       C.int(r.Region.Min.Y),
+			max_x:       C.int(r.Region.Max.X),
+			max_y:       C.int(r.Region.Max.Y),
+			index_count: C.int(r.IndexCount),
+		}
+	}
+
+	cBlend := C.ebitengine_Blend{
+		factor_src_rgb:   C.uint8_t(blend.BlendFactorSourceRGB),
+		factor_src_alpha: C.uint8_t(blend.BlendFactorSourceAlpha),
+		factor_dst_rgb:   C.uint8_t(blend.BlendFactorDestinationRGB),
+		factor_dst_alpha: C.uint8_t(blend.BlendFactorDestinationAlpha),
+		operation_rgb:    C.uint8_t(blend.BlendOperationRGB),
+		operation_alpha:  C.uint8_t(blend.BlendOperationAlpha),
+	}
+
+	cUniforms := make([]C.uint32_t, len(uniforms))
+	defer runtime.KeepAlive(cUniforms)
+	for i, u := range uniforms {
+		cUniforms[i] = C.uint32_t(u)
+	}
+
+	if err := C.ebitengine_DrawTriangles(C.int(dst), unsafe.SliceData(cSrcs), C.int(len(cSrcs)), C.int(shader), unsafe.SliceData(cDstRegions), C.int(len(cDstRegions)), C.int(indexOffset), cBlend, unsafe.SliceData(cUniforms), C.int(len(cUniforms)), C.int(fillRule)); !C.ebitengine_IsErrorNil(&err) {
+		return newPlaystation5Error("(*playstation5.Graphics).DrawTriangles", err)
+	}
 	return nil
 }

@@ -133,12 +194,34 @@ func (i *Image) Dispose() {
 }

 func (i *Image) ReadPixels(args []graphicsdriver.PixelsArgs) error {
-	// TODO: Implement this
+	for _, a := range args {
+		region := C.ebitengine_Region{
+			min_x: C.int(a.Region.Min.X),
+			min_y: C.int(a.Region.Min.Y),
+			max_x: C.int(a.Region.Max.X),
+			max_y: C.int(a.Region.Max.Y),
+		}
+		C.ebitengine_ReadPixels(C.int(i.id), (*C.uint8_t)(unsafe.Pointer(unsafe.SliceData(a.Pixels))), region)
+	}
+	if err := C.ebitengine_FlushReadPixels(C.int(i.id)); !C.ebitengine_IsErrorNil(&err) {
+		return newPlaystation5Error("(*playstation5.Image).ReadPixels", err)
+	}
 	return nil
 }

 func (i *Image) WritePixels(args []graphicsdriver.PixelsArgs) error {
-	// TODO: Implement this
+	for _, a := range args {
+		region := C.ebitengine_Region{
+			min_x: C.int(a.Region.Min.X),
+			min_y: C.int(a.Region.Min.Y),
+			max_x: C.int(a.Region.Max.X),
+			max_y: C.int(a.Region.Max.Y),
+		}
+		C.ebitengine_WritePixels(C.int(i.id), (*C.uint8_t)(unsafe.Pointer(unsafe.SliceData(a.Pixels))), region)
+	}
+	if err := C.ebitengine_FlushWritePixels(C.int(i.id)); !C.ebitengine_IsErrorNil(&err) {
+		return newPlaystation5Error("(*playstation5.Image).WritePixels", err)
+	}
 	return nil
 }

@@ -19,26 +19,100 @@

 #include <stdbool.h>
 #include <stddef.h>
+#include <stdint.h>

 #ifdef __cplusplus
 extern "C" {
 #endif

+int ebitengine_ProjectionMatrixUniformDwordIndex();
+
 typedef struct ebitengine_Error {
-  const char* message;
-  int         code;
+  const char *message;
+  int code;
 } ebitengine_Error;

-static bool ebitengine_IsErrorNil(ebitengine_Error* err) {
+static bool ebitengine_IsErrorNil(ebitengine_Error *err) {
  return err->message == NULL && err->code == 0;
 }

+typedef struct ebitengine_Region {
+  int min_x;
+  int min_y;
+  int max_x;
+  int max_y;
+} ebitengine_Region;
+
+typedef struct ebitengine_DstRegion {
+  int min_x;
+  int min_y;
+  int max_x;
+  int max_y;
+  int index_count;
+} ebitengine_DstRegion;
+
+// kBlendFactor* and kBlendOperation* must be synced with
+// internal/graphicsdriver/blend.go.
+
+enum {
+  kBlendFactorZero = 0,
+  kBlendFactorOne = 1,
+  kBlendFactorSourceColor = 2,
+  kBlendFactorOneMinusSourceColor = 3,
+  kBlendFactorSourceAlpha = 4,
+  kBlendFactorOneMinusSourceAlpha = 5,
+  kBlendFactorDestinationColor = 6,
+  kBlendFactorOneMinusDestinationColor = 7,
+  kBlendFactorDestinationAlpha = 8,
+  kBlendFactorOneMinusDestinationAlpha = 9,
+  kBlendFactorSourceAlphaSaturated = 10,
+};
+
+enum {
+  kBlendOperationAdd = 0,
+  kBlendOperationSubtract = 1,
+  kBlendOperationReverseSubtract = 2,
+  kBlendOperationMin = 3,
+  kBlendOperationMax = 4,
+};
+
+typedef struct ebitengine_Blend {
+  uint8_t factor_src_rgb;
+  uint8_t factor_src_alpha;
+  uint8_t factor_dst_rgb;
+  uint8_t factor_dst_alpha;
+  uint8_t operation_rgb;
+  uint8_t operation_alpha;
+} ebitengine_Blend;
+
 ebitengine_Error ebitengine_InitializeGraphics(void);
-ebitengine_Error ebitengine_NewImage(int* image, int width, int height);
-ebitengine_Error ebitengine_NewScreenFramebufferImage(int* image, int width, int height);
+ebitengine_Error ebitengine_NewImage(int *image, int width, int height);
+ebitengine_Error ebitengine_NewScreenFramebufferImage(int *image, int width,
+                                                      int height);
+void ebitengine_ReadPixels(int image, uint8_t *pixels,
+                           ebitengine_Region region);
+ebitengine_Error ebitengine_FlushReadPixels(int image);
+void ebitengine_WritePixels(int image, const uint8_t *pixels,
+                            ebitengine_Region region);
+ebitengine_Error ebitengine_FlushWritePixels(int image);
 void ebitengine_DisposeImage(int id);

-ebitengine_Error ebitengine_NewShader(int* shader, const char* source);
+void ebitengine_Begin();
+void ebitengine_End(int present);
+void ebitengine_SetVertices(const float *vertices, int vertex_count,
+                            const uint32_t *indices, int index_count);
+
+ebitengine_Error
+ebitengine_DrawTriangles(int dst, const int *srcs, int src_count, int shader,
+                         const ebitengine_DstRegion *dst_regions,
+                         int dst_region_count, int indexOffset,
+                         ebitengine_Blend blend, const uint32_t *uniforms,
+                         int uniform_count, int fill_rule);
+
+ebitengine_Error ebitengine_NewShader(
+    int *shader, const char *vertex_header, int vertex_header_size,
+    const char *vertex_text, int vertex_text_size, const char *pixel_header,
+    int pixel_header_size, const char *pixel_text, int pixel_text_size);
 void ebitengine_DisposeShader(int id);

 #ifdef __cplusplus
@@ -0,0 +1,34 @@
+// Copyright 2024 The Ebitengine Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//go:build playstation5
+
+package playstation5
+
+import (
+	"github.com/hajimehoshi/ebiten/v2/internal/shaderir"
+)
+
+var (
+	// precompiledShaders is a map to store precompiled shaders.
+	// precompiledShaders is initialized by a separate tool.
+	precompiledShaders map[shaderir.SourceHash]*shaderSource
+)
+
+type shaderSource struct {
+	vertexHeader []byte
+	vertexText   []byte
+	pixelHeader  []byte
+	pixelText    []byte
+}