shuiyu1123
a51854455b
- android/ 167个模块 (app/content/os/view/widget/graphics/media/hardware/net/telephony/provider等) - java/ 35个模块 (lang/io/util/net/nio/security/crypto/sql/beans/rmi/awt等) - javax/ 4个模块 (net/crypto/security/sql) - org/ 5个模块 (json/w3c_dom/xml_sax/xml_pull/apache_http) - dalvik/ 1个模块 (system) - ~3053个类/接口，方法签名完全对齐Android SDK - 桌面跨平台运行 (Windows/macOS/Linux) - 修复所有导入错误和Python关键字冲突
699 lines
22 KiB
Python
699 lines
22 KiB
Python
"""
|
|
Android Graphics Surface 组件 — SurfaceTexture, SurfaceHolder, SurfaceView, GLSurfaceView
|
|
方法签名完全对齐 Android SDK (android.graphics.surface 包 和 android.view.Surface)
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import time
|
|
from typing import Any, Callable, Dict, List, Optional, Set, Tuple
|
|
|
|
from .._core import Stub, AndroidOnlyError
|
|
from ..java.lang import RuntimeException
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# SurfaceTexture
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class SurfaceTexture(Stub):
|
|
"""SurfaceTexture — 表面纹理"""
|
|
|
|
# 纹理目标常量
|
|
TEXTURE_TARGET_2D = 3553
|
|
TEXTURE_TARGET_EXTERNAL = 36197
|
|
|
|
# Transform 矩阵常量
|
|
TRANSFORM_MATRIX_SIZE = 16
|
|
|
|
def __init__(self, tex_name: int = 0, allow_high_performance: bool = True):
|
|
super().__init__()
|
|
self._tex_name = tex_name
|
|
self._tex_target: int = SurfaceTexture.TEXTURE_TARGET_EXTERNAL
|
|
self._timestamp: int = 0
|
|
self._frame_available_listener: Optional[Callable] = None
|
|
self._frame_available_listener_handler: Any = None
|
|
self._default_buffer_size: Tuple[int, int] = (0, 0)
|
|
self._is_abandoned: bool = False
|
|
self._is_released: bool = False
|
|
self._transform_matrix: List[float] = [
|
|
1.0, 0.0, 0.0, 0.0,
|
|
0.0, 1.0, 0.0, 0.0,
|
|
0.0, 0.0, 1.0, 0.0,
|
|
0.0, 0.0, 0.0, 1.0,
|
|
]
|
|
self._buffer_count: int = 0
|
|
self._frame_count: int = 0
|
|
self._width: int = 0
|
|
self._height: int = 0
|
|
|
|
def getTexName(self) -> int:
|
|
return self._tex_name
|
|
|
|
def getTimestamp(self) -> int:
|
|
"""获取时间戳 (纳秒)"""
|
|
return self._timestamp
|
|
|
|
def updateTexImage(self):
|
|
"""更新纹理图像"""
|
|
self._timestamp = int(time.time() * 1000000000)
|
|
self._frame_count += 1
|
|
|
|
def getTransformMatrix(self, matrix: Optional[List[float]] = None) -> List[float]:
|
|
"""获取变换矩阵"""
|
|
if matrix is not None and len(matrix) >= 16:
|
|
for i in range(16):
|
|
matrix[i] = self._transform_matrix[i]
|
|
return list(self._transform_matrix)
|
|
|
|
def setDefaultBufferSize(self, width: int, height: int):
|
|
"""设置默认缓冲区大小"""
|
|
self._default_buffer_size = (width, height)
|
|
self._width = width
|
|
self._height = height
|
|
|
|
def getDefaultBufferSize(self) -> Tuple[int, int]:
|
|
return self._default_buffer_size
|
|
|
|
def setOnFrameAvailableListener(self, listener: Optional[Callable],
|
|
handler: Any = None):
|
|
"""设置帧可用监听器"""
|
|
self._frame_available_listener = listener
|
|
self._frame_available_listener_handler = handler
|
|
if listener:
|
|
listener(self)
|
|
|
|
def getOnFrameAvailableListener(self) -> Optional[Callable]:
|
|
return self._frame_available_listener
|
|
|
|
def detachFromGLContext(self):
|
|
"""从 GL 上下文分离"""
|
|
pass
|
|
|
|
def attachToGLContext(self, tex_name: int):
|
|
"""附加到 GL 上下文"""
|
|
self._tex_name = tex_name
|
|
|
|
def release(self):
|
|
"""释放表面纹理"""
|
|
self._is_released = True
|
|
self._frame_available_listener = None
|
|
|
|
def releaseTexImage(self):
|
|
"""释放纹理图像"""
|
|
pass
|
|
|
|
def abandon(self):
|
|
"""废弃表面纹理"""
|
|
self._is_abandoned = True
|
|
self._frame_available_listener = None
|
|
|
|
def isReleased(self) -> bool:
|
|
return self._is_released
|
|
|
|
def isAbandoned(self) -> bool:
|
|
return self._is_abandoned
|
|
|
|
def getWidth(self) -> int:
|
|
return self._width
|
|
|
|
def getHeight(self) -> int:
|
|
return self._height
|
|
|
|
def getFrameCount(self) -> int:
|
|
return self._frame_count
|
|
|
|
def getBufferCount(self) -> int:
|
|
return self._buffer_count
|
|
|
|
def toString(self) -> str:
|
|
return f"SurfaceTexture(tex={self._tex_name}, {self._width}x{self._height})"
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# SurfaceHolder
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class SurfaceHolder(Stub):
|
|
"""SurfaceHolder — 表面持有者"""
|
|
|
|
SURFACE_TYPE_NORMAL = 0
|
|
SURFACE_TYPE_HARDWARE = 1
|
|
SURFACE_TYPE_GPU = 2
|
|
SURFACE_TYPE_PUSH_BUFFERS = 3
|
|
|
|
# 表面变更类型
|
|
CHANGE_TYPE_NONE = 0
|
|
CHANGE_TYPE_SIZE_CHANGED = 1
|
|
CHANGE_TYPE_FORMAT_CHANGED = 2
|
|
CHANGE_TYPE_SURFACE_CREATED = 3
|
|
CHANGE_TYPE_SURFACE_DESTROYED = 4
|
|
CHANGE_TYPE_SURFACE_REDRAW = 5
|
|
|
|
class Callback(Stub):
|
|
"""SurfaceHolder.Callback — 表面回调"""
|
|
|
|
def surfaceCreated(self, holder: SurfaceHolder):
|
|
pass
|
|
|
|
def surfaceChanged(self, holder: SurfaceHolder, format: int,
|
|
width: int, height: int):
|
|
pass
|
|
|
|
def surfaceDestroyed(self, holder: SurfaceHolder):
|
|
pass
|
|
|
|
def surfaceRedrawNeeded(self, holder: SurfaceHolder):
|
|
pass
|
|
|
|
class Callback2(Callback):
|
|
"""SurfaceHolder.Callback2 — 表面回调 (扩展)"""
|
|
|
|
def surfaceRedrawNeeded(self, holder: SurfaceHolder):
|
|
pass
|
|
|
|
def __init__(self, surface: Any = None):
|
|
super().__init__()
|
|
self._surface = surface
|
|
self._is_creating: bool = False
|
|
self._type: int = SurfaceHolder.SURFACE_TYPE_NORMAL
|
|
self._width: int = 0
|
|
self._height: int = 0
|
|
self._format: int = 0
|
|
self._callbacks: List[SurfaceHolder.Callback] = []
|
|
self._callback2: Optional[SurfaceHolder.Callback2] = None
|
|
self._fixed_size: Tuple[int, int] = (-1, -1)
|
|
self._keep_screen_on: bool = False
|
|
|
|
def getSurface(self) -> Any:
|
|
return self._surface
|
|
|
|
def setSurface(self, surface: Any):
|
|
self._surface = surface
|
|
|
|
def addCallback(self, callback: Callback):
|
|
if callback not in self._callbacks:
|
|
self._callbacks.append(callback)
|
|
|
|
def removeCallback(self, callback: Callback):
|
|
self._callbacks = [c for c in self._callbacks if c is not callback]
|
|
|
|
def getCallbacks(self) -> List[Callback]:
|
|
return list(self._callbacks)
|
|
|
|
def setType(self, type_: int):
|
|
self._type = type_
|
|
|
|
def getType(self) -> int:
|
|
return self._type
|
|
|
|
def setFixedSize(self, width: int, height: int):
|
|
self._fixed_size = (width, height)
|
|
self._width = width
|
|
self._height = height
|
|
|
|
def getFixedSize(self) -> Tuple[int, int]:
|
|
return self._fixed_size
|
|
|
|
def setSizeFromLayout(self):
|
|
"""从布局获取大小"""
|
|
pass
|
|
|
|
def isCreating(self) -> bool:
|
|
return self._is_creating
|
|
|
|
def setCreating(self, creating: bool):
|
|
self._is_creating = creating
|
|
if creating:
|
|
for cb in self._callbacks:
|
|
cb.surfaceCreated(self)
|
|
|
|
def setFormat(self, format: int):
|
|
self._format = format
|
|
|
|
def getFormat(self) -> int:
|
|
return self._format
|
|
|
|
def getWidth(self) -> int:
|
|
return self._width
|
|
|
|
def getHeight(self) -> int:
|
|
return self._height
|
|
|
|
def setKeepScreenOn(self, keep_on: bool):
|
|
self._keep_screen_on = keep_on
|
|
|
|
def isKeepScreenOn(self) -> bool:
|
|
return self._keep_screen_on
|
|
|
|
def lockCanvas(self) -> Any:
|
|
"""锁定画布"""
|
|
return None
|
|
|
|
def lockCanvas(Rect: Any) -> Any:
|
|
"""锁定画布指定区域"""
|
|
return None
|
|
|
|
def unlockCanvasAndPost(self, canvas: Any):
|
|
"""解锁画布并提交"""
|
|
pass
|
|
|
|
def notifySurfaceCreated(self):
|
|
for cb in self._callbacks:
|
|
cb.surfaceCreated(self)
|
|
|
|
def notifySurfaceChanged(self, format: int, width: int, height: int):
|
|
for cb in self._callbacks:
|
|
cb.surfaceChanged(self, format, width, height)
|
|
|
|
def notifySurfaceDestroyed(self):
|
|
for cb in self._callbacks:
|
|
cb.surfaceDestroyed(self)
|
|
|
|
def toString(self) -> str:
|
|
return f"SurfaceHolder({self._width}x{self._height}, type={self._type})"
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# SurfaceView
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class SurfaceView(Stub):
|
|
"""SurfaceView — 表面视图"""
|
|
|
|
def __init__(self, context: Any = None):
|
|
super().__init__()
|
|
self._context = context
|
|
self._holder: Optional[SurfaceHolder] = SurfaceHolder()
|
|
self._is_visible: bool = False
|
|
self._is_created: bool = False
|
|
self._width: int = 0
|
|
self._height: int = 0
|
|
self._format: int = 0
|
|
self._z_order: int = 0
|
|
self._is_securable: bool = False
|
|
self._transparent_region: Optional[Any] = None
|
|
self._surface_frame: Optional[Any] = None
|
|
self._window_token: Any = None
|
|
|
|
def getHolder(self) -> SurfaceHolder:
|
|
return self._holder
|
|
|
|
def setZOrderOnTop(self, on_top: bool):
|
|
"""设置 Z 轴顺序在顶层"""
|
|
self._z_order = 1 if on_top else 0
|
|
|
|
def setZOrderMediaOverlay(self, is_media_overlay: bool):
|
|
"""设置媒体覆盖 Z 轴顺序"""
|
|
self._z_order = 2 if is_media_overlay else 0
|
|
|
|
def setVisibility(self, visible: bool):
|
|
self._is_visible = visible
|
|
|
|
def isVisible(self) -> bool:
|
|
return self._is_visible
|
|
|
|
def getWidth(self) -> int:
|
|
return self._width
|
|
|
|
def getHeight(self) -> int:
|
|
return self._height
|
|
|
|
def setSecure(self, secure: bool):
|
|
self._is_securable = secure
|
|
|
|
def isSecure(self) -> bool:
|
|
return self._is_securable
|
|
|
|
def getContext(self) -> Any:
|
|
return self._context
|
|
|
|
def getWindowToken(self) -> Any:
|
|
return self._window_token
|
|
|
|
def setWindowToken(self, token: Any):
|
|
self._window_token = token
|
|
|
|
def onWindowVisibilityChanged(self, visibility: int):
|
|
"""窗口可见性变化回调"""
|
|
pass
|
|
|
|
def onMeasure(self, width_measure_spec: int, height_measure_spec: int):
|
|
"""测量回调"""
|
|
pass
|
|
|
|
def onLayout(self, changed: bool, left: int, top: int,
|
|
right: int, bottom: int):
|
|
"""布局回调"""
|
|
self._width = right - left
|
|
self._height = bottom - top
|
|
if self._holder:
|
|
self._holder.notifySurfaceChanged(self._format,
|
|
self._width, self._height)
|
|
|
|
def draw(self, canvas: Any):
|
|
"""绘制"""
|
|
pass
|
|
|
|
def toString(self) -> str:
|
|
return f"SurfaceView({self._width}x{self._height}, visible={self._is_visible})"
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# GLSurfaceView
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class GLSurfaceView(SurfaceView):
|
|
"""GLSurfaceView — OpenGL ES 表面视图"""
|
|
|
|
RENDERMODE_CONTINUOUSLY = 1
|
|
RENDERMODE_WHEN_DIRTY = 0
|
|
|
|
DEBUG_CHECK_GL_ERROR = 1
|
|
DEBUG_LOG_GL_CALLS = 2
|
|
|
|
class Renderer(Stub):
|
|
"""GLSurfaceView.Renderer — OpenGL 渲染器"""
|
|
|
|
def onSurfaceCreated(self, gl: Any, config: Any):
|
|
pass
|
|
|
|
def onSurfaceChanged(self, gl: Any, width: int, height: int):
|
|
pass
|
|
|
|
def onDrawFrame(self, gl: Any):
|
|
pass
|
|
|
|
def __init__(self, context: Any = None):
|
|
super().__init__(context)
|
|
self._renderer: Optional[GLSurfaceView.Renderer] = None
|
|
self._render_mode: int = GLSurfaceView.RENDERMODE_CONTINUOUSLY
|
|
self._egl_context_client_version: int = 2
|
|
self._preserve_egl_context_on_pause: bool = False
|
|
self._debug_flags: int = 0
|
|
self._is_running: bool = False
|
|
self._is_paused: bool = False
|
|
self._frame_count: int = 0
|
|
self._request_render: bool = False
|
|
|
|
def setRenderer(self, renderer: Renderer):
|
|
"""设置渲染器"""
|
|
self._renderer = renderer
|
|
|
|
def getRenderer(self) -> Optional[Renderer]:
|
|
return self._renderer
|
|
|
|
def setRenderMode(self, mode: int):
|
|
"""设置渲染模式"""
|
|
self._render_mode = mode
|
|
|
|
def getRenderMode(self) -> int:
|
|
return self._render_mode
|
|
|
|
def requestRender(self):
|
|
"""请求渲染"""
|
|
self._request_render = True
|
|
if self._render_mode == GLSurfaceView.RENDERMODE_WHEN_DIRTY:
|
|
self._frame_count += 1
|
|
|
|
def queueEvent(self, r: Callable):
|
|
"""队列事件"""
|
|
r()
|
|
|
|
def onPause(self):
|
|
"""暂停"""
|
|
self._is_paused = True
|
|
self._is_running = False
|
|
|
|
def onResume(self):
|
|
"""恢复"""
|
|
self._is_paused = False
|
|
self._is_running = True
|
|
|
|
def setPreserveEGLContextOnPause(self, preserve: bool):
|
|
self._preserve_egl_context_on_pause = preserve
|
|
|
|
def getPreserveEGLContextOnPause(self) -> bool:
|
|
return self._preserve_egl_context_on_pause
|
|
|
|
def setEGLContextClientVersion(self, version: int):
|
|
self._egl_context_client_version = version
|
|
|
|
def getEGLContextClientVersion(self) -> int:
|
|
return self._egl_context_client_version
|
|
|
|
def setDebugFlags(self, flags: int):
|
|
self._debug_flags = flags
|
|
|
|
def getDebugFlags(self) -> int:
|
|
return self._debug_flags
|
|
|
|
def isRunning(self) -> bool:
|
|
return self._is_running
|
|
|
|
def isPaused(self) -> bool:
|
|
return self._is_paused
|
|
|
|
def getFrameCount(self) -> int:
|
|
return self._frame_count
|
|
|
|
def onSurfaceCreated(self, gl: Any, config: Any):
|
|
if self._renderer:
|
|
self._renderer.onSurfaceCreated(gl, config)
|
|
|
|
def onSurfaceChanged(self, gl: Any, width: int, height: int):
|
|
if self._renderer:
|
|
self._renderer.onSurfaceChanged(gl, width, height)
|
|
|
|
def onDrawFrame(self, gl: Any):
|
|
if self._renderer:
|
|
self._renderer.onDrawFrame(gl)
|
|
|
|
def destroyDrawingCache(self):
|
|
pass
|
|
|
|
def toString(self) -> str:
|
|
return f"GLSurfaceView(renderMode={self._render_mode}, running={self._is_running})"
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# Surface (helper)
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class Surface(Stub):
|
|
"""Surface — 表面 (android.view.Surface)"""
|
|
|
|
ROTATION_0 = 0
|
|
ROTATION_90 = 1
|
|
ROTATION_180 = 2
|
|
ROTATION_270 = 3
|
|
|
|
SCALING_MODE_FREEZE = 0
|
|
SCALING_MODE_SCALE_TO_WINDOW = 1
|
|
SCALING_MODE_SCALE_CROP = 2
|
|
SCALING_MODE_NO_SCALE_CROP = 3
|
|
|
|
def __init__(self, surface_texture: Optional[SurfaceTexture] = None):
|
|
super().__init__()
|
|
self._surface_texture = surface_texture
|
|
self._is_valid: bool = True
|
|
self._is_released: bool = False
|
|
self._width: int = 0
|
|
self._height: int = 0
|
|
self._format: int = 0
|
|
self._name: str = ""
|
|
|
|
def isValid(self) -> bool:
|
|
return self._is_valid and not self._is_released
|
|
|
|
def isReleased(self) -> bool:
|
|
return self._is_released
|
|
|
|
def release(self):
|
|
self._is_released = True
|
|
|
|
def getSurfaceTexture(self) -> Optional[SurfaceTexture]:
|
|
return self._surface_texture
|
|
|
|
def setSurfaceTexture(self, st: SurfaceTexture):
|
|
self._surface_texture = st
|
|
|
|
def getWidth(self) -> int:
|
|
return self._width
|
|
|
|
def getHeight(self) -> int:
|
|
return self._height
|
|
|
|
def setWidth(self, width: int):
|
|
self._width = width
|
|
|
|
def setHeight(self, height: int):
|
|
self._height = height
|
|
|
|
def getFormat(self) -> int:
|
|
return self._format
|
|
|
|
def setName(self, name: str):
|
|
self._name = name
|
|
|
|
def getName(self) -> str:
|
|
return self._name
|
|
|
|
def lockCanvas(self, in_out_dirty_rect: Any = None) -> Any:
|
|
"""锁定画布"""
|
|
if self._is_released:
|
|
return None
|
|
return None
|
|
|
|
def unlockCanvasAndPost(self, canvas: Any):
|
|
"""解锁画布并提交"""
|
|
pass
|
|
|
|
def toString(self) -> str:
|
|
return f"Surface(name={self._name}, valid={self._is_valid}, released={self._is_released})"
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# SurfaceControl (helper)
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class SurfaceControl(Stub):
|
|
"""SurfaceControl — 表面控制"""
|
|
|
|
BUFFER_TRANSFORM_IDENTITY = 0
|
|
BUFFER_TRANSFORM_MIRROR_HORIZONTAL = 1
|
|
BUFFER_TRANSFORM_MIRROR_VERTICAL = 2
|
|
BUFFER_TRANSFORM_ROTATE_90 = 4
|
|
BUFFER_TRANSFORM_ROTATE_180 = 3
|
|
BUFFER_TRANSFORM_ROTATE_270 = 7
|
|
|
|
def __init__(self, surface: Optional[Surface] = None):
|
|
super().__init__()
|
|
self._surface = surface
|
|
self._alpha: float = 1.0
|
|
self._layer: int = 0
|
|
self._z_order: int = 0
|
|
self._is_visible: bool = True
|
|
self._transform: int = SurfaceControl.BUFFER_TRANSFORM_IDENTITY
|
|
self._crop: Tuple[int, int, int, int] = (0, 0, 0, 0)
|
|
|
|
def getSurface(self) -> Optional[Surface]:
|
|
return self._surface
|
|
|
|
def setSurface(self, surface: Surface):
|
|
self._surface = surface
|
|
|
|
def setAlpha(self, alpha: float):
|
|
self._alpha = max(0.0, min(1.0, alpha))
|
|
|
|
def getAlpha(self) -> float:
|
|
return self._alpha
|
|
|
|
def setLayer(self, layer: int):
|
|
self._layer = layer
|
|
|
|
def getLayer(self) -> int:
|
|
return self._layer
|
|
|
|
def setVisibility(self, visible: bool):
|
|
self._is_visible = visible
|
|
|
|
def isVisible(self) -> bool:
|
|
return self._is_visible
|
|
|
|
def setTransform(self, transform: int):
|
|
self._transform = transform
|
|
|
|
def getTransform(self) -> int:
|
|
return self._transform
|
|
|
|
def setCrop(self, left: int, top: int, right: int, bottom: int):
|
|
self._crop = (left, top, right, bottom)
|
|
|
|
def getCrop(self) -> Tuple[int, int, int, int]:
|
|
return self._crop
|
|
|
|
def release(self):
|
|
if self._surface:
|
|
self._surface.release()
|
|
|
|
def toString(self) -> str:
|
|
return f"SurfaceControl(layer={self._layer}, alpha={self._alpha})"
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# SurfaceUtils
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class SurfaceUtils(Stub):
|
|
"""SurfaceUtils — 表面工具类"""
|
|
|
|
@staticmethod
|
|
def createSurfaceFromTexture(texture: SurfaceTexture) -> Surface:
|
|
return Surface(texture)
|
|
|
|
@staticmethod
|
|
def createSurfaceTexture(tex_name: int = 0) -> SurfaceTexture:
|
|
return SurfaceTexture(tex_name)
|
|
|
|
@staticmethod
|
|
def createGLSurfaceView(context: Any) -> GLSurfaceView:
|
|
return GLSurfaceView(context)
|
|
|
|
@staticmethod
|
|
def createSurfaceView(context: Any) -> SurfaceView:
|
|
return SurfaceView(context)
|
|
|
|
@staticmethod
|
|
def createSurfaceHolder(surface: Any) -> SurfaceHolder:
|
|
return SurfaceHolder(surface)
|
|
|
|
@staticmethod
|
|
def isSurfaceValid(surface: Surface) -> bool:
|
|
return surface is not None and surface.isValid()
|
|
|
|
@staticmethod
|
|
def releaseSurface(surface: Surface):
|
|
if surface:
|
|
surface.release()
|
|
|
|
@staticmethod
|
|
def releaseSurfaceTexture(texture: SurfaceTexture):
|
|
if texture:
|
|
texture.release()
|
|
|
|
@staticmethod
|
|
def getDefaultRenderer(context: Any) -> GLSurfaceView.Renderer:
|
|
class DefaultRenderer(GLSurfaceView.Renderer):
|
|
def onSurfaceCreated(self, gl, config):
|
|
pass
|
|
def onSurfaceChanged(self, gl, width, height):
|
|
pass
|
|
def onDrawFrame(self, gl):
|
|
pass
|
|
return DefaultRenderer()
|
|
|
|
@staticmethod
|
|
def createSimpleRenderer() -> GLSurfaceView.Renderer:
|
|
class SimpleRenderer(GLSurfaceView.Renderer):
|
|
def __init__(self):
|
|
super().__init__()
|
|
self._background_color: Tuple[float, float, float, float] = (0.0, 0.0, 0.0, 1.0)
|
|
|
|
def onSurfaceCreated(self, gl, config):
|
|
pass
|
|
|
|
def onSurfaceChanged(self, gl, width, height):
|
|
pass
|
|
|
|
def onDrawFrame(self, gl):
|
|
pass
|
|
|
|
def setBackgroundColor(self, r: float, g: float, b: float, a: float):
|
|
self._background_color = (r, g, b, a)
|
|
|
|
return SimpleRenderer()
|
|
|
|
@staticmethod
|
|
def getSurfaceRotationDegrees(rotation: int) -> int:
|
|
return rotation * 90 |