288 lines
7.2 KiB
Text
288 lines
7.2 KiB
Text
#include <MetalKit/MetalKit.h>
|
|
#include <gfx_metal.hpp>
|
|
#include <GameController/GameController.h>
|
|
|
|
#import <UIKit/UIKit.h>
|
|
|
|
#include <engine.hpp>
|
|
|
|
#include <@APP_INCLUDE@>
|
|
|
|
@APP_CLASS@* app = nullptr;
|
|
|
|
int maxFPS = 60;
|
|
|
|
std::array<bool, 8> inputKeys;
|
|
|
|
float rightX = 0.0f, rightY = 0.0f;
|
|
float leftX = 0.0f, leftY = 0.0f;
|
|
|
|
@interface GameView : UIView
|
|
@end
|
|
|
|
@implementation GameView
|
|
|
|
+ (Class) layerClass {
|
|
return [CAMetalLayer class];
|
|
}
|
|
|
|
- (void)draw {
|
|
engine->update(1.0f / (float)maxFPS);
|
|
engine->begin_frame(1.0f / (float)maxFPS);
|
|
engine->render(0);
|
|
}
|
|
|
|
- (void) controllerConnected {
|
|
GCController* controller = [GCController controllers][0];
|
|
[[controller extendedGamepad] setValueChangedHandler:^(GCExtendedGamepad * _Nonnull gamepad, GCControllerElement * _Nonnull element) {
|
|
const auto& handle_element = [element](int index, GCControllerElement* e) {
|
|
if(element == e)
|
|
inputKeys[index] = [(GCControllerButtonInput*)e value] == 1.0f;
|
|
};
|
|
|
|
handle_element(0, [[controller extendedGamepad] buttonA]);
|
|
handle_element(1, [[controller extendedGamepad] buttonB]);
|
|
handle_element(2, [[controller extendedGamepad] buttonX]);
|
|
handle_element(3, [[controller extendedGamepad] buttonY]);
|
|
|
|
if(element == [[controller extendedGamepad] dpad]) {
|
|
inputKeys[4] = [[[[controller extendedGamepad] dpad] up] value] == 1.0f;
|
|
inputKeys[5] = [[[[controller extendedGamepad] dpad] down] value] == 1.0f;
|
|
inputKeys[6] = [[[[controller extendedGamepad] dpad] left] value] == 1.0f;
|
|
inputKeys[7] = [[[[controller extendedGamepad] dpad] right] value] == 1.0f;
|
|
}
|
|
|
|
if(element == [[controller extendedGamepad] leftThumbstick]) {
|
|
leftX = [[[[controller extendedGamepad] leftThumbstick] xAxis] value];
|
|
leftY = [[[[controller extendedGamepad] leftThumbstick] yAxis] value];
|
|
}
|
|
|
|
if(element == [[controller extendedGamepad] rightThumbstick]) {
|
|
rightX = [[[[controller extendedGamepad] rightThumbstick] xAxis] value];
|
|
rightY = [[[[controller extendedGamepad] rightThumbstick] yAxis] value];
|
|
}
|
|
}];
|
|
}
|
|
|
|
@end
|
|
|
|
@interface GameViewController : UIViewController
|
|
|
|
@end
|
|
|
|
float mouse_x = 0.0f, mouse_y = 0.0f;
|
|
bool mouse_down = false;
|
|
|
|
@interface GameViewController ()
|
|
{
|
|
GameView* view;
|
|
}
|
|
@end
|
|
|
|
@implementation GameViewController
|
|
|
|
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
|
|
UITouch* touch = [touches anyObject];
|
|
CGPoint touchPoint = [touch locationInView: self.view];
|
|
|
|
mouse_x = touchPoint.x;
|
|
mouse_y = touchPoint.y;
|
|
|
|
mouse_down = true;
|
|
engine->process_mouse_down(0, {static_cast<int32_t>(touchPoint.x), static_cast<int32_t>(touchPoint.y)});
|
|
}
|
|
|
|
- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
|
|
UITouch* touch = [touches anyObject];
|
|
CGPoint touchPoint = [touch locationInView: self.view];
|
|
|
|
mouse_x = touchPoint.x;
|
|
mouse_y = touchPoint.y;
|
|
|
|
mouse_down = false;
|
|
}
|
|
|
|
- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
|
|
UITouch* touch = [touches anyObject];
|
|
CGPoint touchPoint = [touch locationInView: self.view];
|
|
|
|
mouse_x = touchPoint.x;
|
|
mouse_y = touchPoint.y;
|
|
}
|
|
|
|
int width, height;
|
|
int drawable_width, drawable_height;
|
|
|
|
- (void)viewDidLoad {
|
|
[super viewDidLoad];
|
|
view = (GameView*)self.view;
|
|
view.userInteractionEnabled = true;
|
|
|
|
CADisplayLink* displayLink = [CADisplayLink displayLinkWithTarget:view selector:@selector(draw)];
|
|
[displayLink addToRunLoop:NSRunLoop.mainRunLoop forMode:NSDefaultRunLoopMode];
|
|
|
|
width = [view frame].size.width;
|
|
height = [view frame].size.height;
|
|
|
|
drawable_width = [view frame].size.width * [view contentScaleFactor];
|
|
drawable_height = [view frame].size.height * [view contentScaleFactor];
|
|
|
|
engine = new prism::Engine(0, nullptr);
|
|
|
|
app = new @APP_CLASS@();
|
|
engine->set_app(app);
|
|
|
|
GFXCreateInfo createInfo = {};
|
|
createInfo.api_validation_enabled = true;
|
|
|
|
GFXMetal* gfx = new GFXMetal();
|
|
gfx->initialize(createInfo);
|
|
engine->set_gfx(gfx);
|
|
|
|
app_main(engine);
|
|
|
|
engine->add_window((void*)CFBridgingRetain([view layer]), 0, {static_cast<uint32_t>(width), static_cast<uint32_t>(height)});
|
|
|
|
app->initialize_render();
|
|
|
|
NSNotificationCenter* nc = [NSNotificationCenter defaultCenter];
|
|
[nc addObserver:view
|
|
selector:@selector(controllerConnected)
|
|
name:GCControllerDidConnectNotification
|
|
object:nil];
|
|
}
|
|
|
|
- (void)didReceiveMemoryWarning {
|
|
[super didReceiveMemoryWarning];
|
|
// Dispose of any resources that can be recreated.
|
|
}
|
|
|
|
-(bool)prefersStatusBarHidden {
|
|
return YES;
|
|
}
|
|
|
|
@end
|
|
|
|
void platform::capture_mouse(const bool capture) {
|
|
|
|
}
|
|
|
|
Offset platform::get_cursor_position() {
|
|
return {static_cast<int32_t>(mouse_x), static_cast<int32_t>(mouse_y)};
|
|
}
|
|
|
|
std::tuple<float, float> platform::get_right_stick_position() {
|
|
return {rightX, rightY};
|
|
}
|
|
|
|
std::tuple<float, float> platform::get_left_stick_position() {
|
|
return {leftX, leftY};
|
|
}
|
|
|
|
bool platform::get_key_down(InputButton key) {
|
|
if(key == InputButton::ButtonA)
|
|
return inputKeys[0];
|
|
|
|
if(key == InputButton::ButtonB)
|
|
return inputKeys[1];
|
|
|
|
if(key == InputButton::ButtonX)
|
|
return inputKeys[2];
|
|
|
|
if(key == InputButton::ButtonY)
|
|
return inputKeys[3];
|
|
|
|
if(key == InputButton::DPadUp)
|
|
return inputKeys[4];
|
|
|
|
if(key == InputButton::DPadDown)
|
|
return inputKeys[5];
|
|
|
|
if(key == InputButton::DPadLeft)
|
|
return inputKeys[6];
|
|
|
|
if(key == InputButton::DPadRight)
|
|
return inputKeys[7];
|
|
|
|
return false;
|
|
}
|
|
|
|
int platform::open_window(const std::string_view title, const Rectangle rect, const WindowFlags flags) {
|
|
return 0;
|
|
}
|
|
|
|
void platform::set_window_title(const int index, const std::string_view title) {
|
|
|
|
}
|
|
|
|
bool platform::is_window_focused(const int index) {
|
|
|
|
}
|
|
|
|
void platform::set_window_focused(const int index) {
|
|
|
|
}
|
|
|
|
Extent platform::get_window_size(const int index) {
|
|
return {static_cast<uint32_t>(width), static_cast<uint32_t>(height)};
|
|
}
|
|
|
|
Extent platform::get_window_drawable_size(const int index) {
|
|
return {static_cast<uint32_t>(drawable_width), static_cast<uint32_t>(drawable_height)};
|
|
}
|
|
|
|
Offset platform::get_window_position(const int index) {
|
|
|
|
}
|
|
|
|
void platform::set_window_size(const int index, const Extent extent) {
|
|
|
|
}
|
|
|
|
void platform::set_window_position(const int index, const Offset offset) {
|
|
|
|
}
|
|
|
|
void platform::close_window(const int index) {
|
|
|
|
}
|
|
|
|
char* platform::translate_keycode(const unsigned int keycode) {
|
|
return nullptr;
|
|
}
|
|
|
|
int platform::get_keycode(const InputButton button) {
|
|
|
|
}
|
|
|
|
Rectangle platform::get_monitor_resolution() {
|
|
|
|
}
|
|
|
|
Rectangle platform::get_monitor_work_area() {
|
|
|
|
}
|
|
|
|
Offset platform::get_screen_cursor_position() {
|
|
|
|
}
|
|
|
|
float platform::get_window_dpi(const int index) {
|
|
return 2.0f;
|
|
}
|
|
|
|
bool platform::get_mouse_button_down(const int index) {
|
|
return mouse_down;
|
|
}
|
|
|
|
float platform::get_monitor_dpi() {
|
|
return 2.0f;
|
|
}
|
|
|
|
std::tuple<float, float> platform::get_wheel_delta() {
|
|
|
|
}
|
|
|
|
const char* platform::get_name() {
|
|
return "iOS";
|
|
}
|