ebiten/cmd/ebitenmobile/_files/EbitenViewController.m
Hajime Hoshi a3ff5f283b cmd/ebitenmobile: bug fix: accessing a view property caused deadlock on iOS
This change delays the initialization of the view until viewDidLoad is
called AND mobile.SetGame is called.

Closes #2768
2023-09-21 19:18:01 +09:00

396 lines
9.0 KiB
Objective-C

// Copyright 2022 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.
#import <TargetConditionals.h>
#import <stdint.h>
#import <UIKit/UIKit.h>
#import <GLKit/GLKit.h>
#import "Ebitenmobileview.objc.h"
@interface {{.PrefixUpper}}EbitenViewController : UIViewController<EbitenmobileviewRenderRequester, EbitenmobileviewSetGameNotifier>
@end
@implementation {{.PrefixUpper}}EbitenViewController {
UIView* metalView_;
GLKView* glkView_;
bool started_;
bool active_;
bool error_;
CADisplayLink* displayLink_;
bool explicitRendering_;
NSThread* renderThread_;
bool viewDidLoad_;
bool gameSet_;
}
- (id)initWithNibName:(NSString *)nibNameOrNil
bundle:(NSBundle *)nibBundleOrNil {
self = [super initWithNibName:nibNameOrNil
bundle:nibBundleOrNil];
if (self) {
EbitenmobileviewSetSetGameNotifier(self);
}
return self;
}
- (id)initWithCoder:(NSCoder *)coder {
// Though initWithCoder might not be a designated initializer, this should be overwritten.
// https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/Archiving/Articles/codingobjects.html
self = [super initWithCoder:coder];
if (self) {
EbitenmobileviewSetSetGameNotifier(self);
}
return self;
}
- (UIView*)metalView {
if (!metalView_) {
metalView_ = [[UIView alloc] init];
metalView_.multipleTouchEnabled = YES;
}
return metalView_;
}
- (GLKView*)glkView {
if (!glkView_) {
glkView_ = [[GLKView alloc] init];
glkView_.multipleTouchEnabled = YES;
}
return glkView_;
}
- (void)viewDidLoad {
[super viewDidLoad];
viewDidLoad_ = true;
if (viewDidLoad_ && gameSet_) {
[self initView];
}
}
- (void)initView {
// initView must be called only when viewDidLoad_, and gameSet_ are true i.e. mobile.SetGame is called.
// Or, EbitenmobileviewIsGL causes a dead lock (#2768).
// A game is requried to determine a graphics driver, and EbitenmobileviewIsGL cannot return a value without a game.
NSAssert(viewDidLoad_ && gameSet_, @"viewDidLoad must be called and a game must be set at initView");
if (!started_) {
@synchronized(self) {
active_ = true;
}
started_ = true;
}
NSError* err = nil;
BOOL isGL = NO;
EbitenmobileviewIsGL(&isGL, &err);
if (err != nil) {
[self onErrorOnGameUpdate:err];
@synchronized(self) {
error_ = true;
}
return;
}
if (isGL) {
self.glkView.delegate = (id<GLKViewDelegate>)(self);
[self.view addSubview: self.glkView];
} else {
[self.view addSubview: self.metalView];
EbitenmobileviewSetUIView((uintptr_t)(self.metalView), &err);
if (err != nil) {
[self onErrorOnGameUpdate:err];
@synchronized(self) {
error_ = true;
}
return;
}
}
renderThread_ = [[NSThread alloc] initWithTarget:self
selector:@selector(initRenderer)
object:nil];
[renderThread_ start];
}
- (void)initRenderer {
NSError* err = nil;
BOOL isGL = NO;
EbitenmobileviewIsGL(&isGL, &err);
if (err != nil) {
[self performSelectorOnMainThread:@selector(onErrorOnGameUpdate:)
withObject:err
waitUntilDone:NO];
@synchronized(self) {
error_ = true;
}
return;
}
if (isGL) {
EAGLContext *context = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES3];
[self glkView].context = context;
[EAGLContext setCurrentContext:context];
}
displayLink_ = [CADisplayLink displayLinkWithTarget:self selector:@selector(drawFrame)];
[displayLink_ addToRunLoop:[NSRunLoop currentRunLoop] forMode:NSDefaultRunLoopMode];
EbitenmobileviewSetRenderRequester(self);
// Run the loop. This will never return.
[[NSRunLoop currentRunLoop] run];
}
- (void)viewWillLayoutSubviews {
if (!started_) {
return;
}
NSError* err = nil;
BOOL isGL = NO;
EbitenmobileviewIsGL(&isGL, &err);
if (err != nil) {
[self onErrorOnGameUpdate:err];
@synchronized(self) {
error_ = true;
}
return;
}
CGRect viewRect = [[self view] frame];
if (isGL) {
[[self glkView] setFrame:viewRect];
} else {
[[self metalView] setFrame:viewRect];
}
}
- (void)viewDidLayoutSubviews {
[super viewDidLayoutSubviews];
if (!started_) {
return;
}
CGRect viewRect = [[self view] frame];
EbitenmobileviewLayout(viewRect.size.width, viewRect.size.height);
}
- (void)didReceiveMemoryWarning {
[super didReceiveMemoryWarning];
// Dispose of any resources that can be recreated.
// TODO: Notify this to Go world?
}
- (void)drawFrame{
@synchronized(self) {
if (!active_) {
return;
}
}
NSError* err = nil;
BOOL isGL = NO;
EbitenmobileviewIsGL(&isGL, &err);
if (err != nil) {
[self performSelectorOnMainThread:@selector(onErrorOnGameUpdate:)
withObject:err
waitUntilDone:NO];
@synchronized(self) {
error_ = true;
}
return;
}
if (isGL) {
dispatch_async(dispatch_get_main_queue(), ^{
[[self glkView] setNeedsDisplay];
});
} else {
[self updateEbiten];
}
@synchronized(self) {
if (explicitRendering_) {
[displayLink_ setPaused:YES];
}
}
}
- (void)glkView:(GLKView*)view drawInRect:(CGRect)rect {
[self updateEbiten];
}
- (void)updateEbiten {
@synchronized(self) {
if (error_) {
return;
}
}
NSError* err = nil;
EbitenmobileviewUpdate(&err);
if (err != nil) {
[self performSelectorOnMainThread:@selector(onErrorOnGameUpdate:)
withObject:err
waitUntilDone:NO];
@synchronized(self) {
error_ = true;
}
}
}
- (void)onErrorOnGameUpdate:(NSError*)err {
NSLog(@"Error: %@", err);
}
- (void)updateTouches:(NSSet*)touches {
if (!started_) {
return;
}
NSError* err = nil;
BOOL isGL = NO;
EbitenmobileviewIsGL(&isGL, &err);
if (err != nil) {
[self onErrorOnGameUpdate:err];
@synchronized(self) {
error_ = true;
}
return;
}
for (UITouch* touch in touches) {
if (isGL) {
if (touch.view != [self glkView]) {
continue;
}
} else {
if (touch.view != [self metalView]) {
continue;
}
}
CGPoint location = [touch locationInView:touch.view];
EbitenmobileviewUpdateTouchesOnIOS(touch.phase, (uintptr_t)touch, location.x, location.y);
}
}
- (void)touchesBegan:(NSSet*)touches withEvent:(UIEvent*)event {
[self updateTouches:touches];
}
- (void)touchesMoved:(NSSet*)touches withEvent:(UIEvent*)event {
[self updateTouches:touches];
}
- (void)touchesEnded:(NSSet*)touches withEvent:(UIEvent*)event {
[self updateTouches:touches];
}
- (void)touchesCancelled:(NSSet*)touches withEvent:(UIEvent*)event {
[self updateTouches:touches];
}
- (void)updatePresses:(NSSet<UIPress *> *)presses {
if (!started_) {
return;
}
if (@available(iOS 13.4, *)) {
// Note: before iOS 13.4, this just can return UIPressType, which is
// insufficient for games.
for (UIPress *press in presses) {
UIKey *key = press.key;
if (key == nil) {
continue;
}
EbitenmobileviewUpdatePressesOnIOS(press.phase, key.keyCode, key.characters);
}
}
}
- (void)pressesBegan:(NSSet<UIPress *> *)presses withEvent:(UIPressesEvent *)event {
[self updatePresses:presses];
}
- (void)pressesEnded:(NSSet<UIPress *> *)presses withEvent:(UIPressesEvent *)event {
[self updatePresses:presses];
}
- (void)suspendGame {
if (!started_) {
return;
}
@synchronized(self) {
active_ = false;
}
NSError* err = nil;
EbitenmobileviewSuspend(&err);
if (err != nil) {
[self onErrorOnGameUpdate:err];
}
}
- (void)resumeGame {
if (!started_) {
return;
}
@synchronized(self) {
active_ = true;
}
NSError* err = nil;
EbitenmobileviewResume(&err);
if (err != nil) {
[self onErrorOnGameUpdate:err];
}
}
- (void)setExplicitRenderingMode:(BOOL)explicitRendering {
@synchronized(self) {
explicitRendering_ = explicitRendering;
if (explicitRendering_) {
[displayLink_ setPaused:YES];
}
}
}
- (void)requestRenderIfNeeded {
@synchronized(self) {
if (explicitRendering_) {
// Resume the callback temporarily.
// This is paused again soon in drawFrame.
[displayLink_ setPaused:NO];
}
}
}
- (void)notifySetGame {
dispatch_async(dispatch_get_main_queue(), ^{
gameSet_ = true;
if (viewDidLoad_ && gameSet_) {
[self initView];
}
});
}
@end