gosu 0.13.3 → 0.14.0.pre2

data/src/GosuGLView.cpp

@@ -1,7 +1,9 @@
 #include <Gosu/Platform.hpp>
 #if defined(GOSU_IS_IPHONE)
 
-#import "GosuGLView.h"
+#import "GosuGLView.hpp"
+#import <Gosu/Input.hpp>
+#import <Gosu/TextInput.hpp>
 
 #import <OpenGLES/EAGL.h>
 #import <OpenGLES/EAGLDrawable.h>
@@ -9,6 +11,7 @@
 #import <OpenGLES/ES1/glext.h>
 #import <QuartzCore/QuartzCore.h>
 
+
 static EAGLContext __weak* globalContext;
 
 namespace Gosu
@@ -28,7 +31,7 @@ namespace Gosu
 @implementation GosuGLView
 {
     EAGLContext* _context;
-    
+
     GLint _backingWidth;
     GLint _backingHeight;
 
@@ -36,41 +39,22 @@ namespace Gosu
     GLuint _viewFramebuffer;
 }
 
-+ (Class)layerClass
-{
-    return [CAEAGLLayer class];
-}
-
-- (id)initWithFrame:(CGRect)frame
-{
-    if ((self = [super initWithFrame:frame])) {
-        [self initializeGosuGLView];
-    }
-    
-    return self;
-}
-
-- (id)initWithCoder:(NSCoder*)aDecoder
+- (instancetype)initWithFrame:(CGRect)frame
 {
-    if ((self = [super initWithCoder:aDecoder])) {
-        [self initializeGosuGLView];
+    if (self = [super initWithFrame:frame]) {
+        CAEAGLLayer* layer = (CAEAGLLayer*)self.layer;
+        layer.opaque = YES;
+        
+        globalContext = _context = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES1];
+        [EAGLContext setCurrentContext:_context];
+        
+        self.exclusiveTouch = YES;
+        self.multipleTouchEnabled = YES;
     }
     
     return self;
 }
 
-- (void)initializeGosuGLView
-{
-    CAEAGLLayer* layer = (CAEAGLLayer*)self.layer;
-    layer.opaque = YES;
-    
-    globalContext = _context = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES1];
-    [EAGLContext setCurrentContext:_context];
-    
-    self.exclusiveTouch = YES;
-    self.multipleTouchEnabled = YES;
-}
-
 - (void)dealloc
 {
     [EAGLContext setCurrentContext:nil];
@@ -93,6 +77,13 @@ namespace Gosu
     [_context presentRenderbuffer:GL_RENDERBUFFER_OES];
 }
 
+#pragma mark - UIView
+
++ (Class)layerClass
+{
+    return [CAEAGLLayer class];
+}
+
 - (void)layoutSubviews
 {
     [EAGLContext setCurrentContext:_context];
@@ -128,6 +119,43 @@ namespace Gosu
     _viewRenderbuffer = 0;
 }
 
+#pragma mark - NSResponder / UIKeyInput / UITextInputTraits
+
+- (BOOL)canBecomeFirstResponder
+{
+    return _input && _input->text_input();
+}
+
+- (BOOL)hasText
+{
+    return _input && _input->text_input() && !_input->text_input()->text().empty();
+}
+
+- (void)insertText:(NSString*)text
+{
+    if (_input && _input->text_input()) {
+        auto filtered_text = _input->text_input()->filter(text.UTF8String ?: "");
+        _input->text_input()->insert_text(filtered_text);
+    }
+}
+
+- (void)deleteBackward
+{
+    if (_input && _input->text_input()) {
+        _input->text_input()->delete_backward();
+    }
+}
+
+- (UITextAutocapitalizationType)autocapitalizationType
+{
+    return UITextAutocapitalizationTypeNone;
+}
+
+- (UITextAutocorrectionType)autocorrectionType
+{
+    return UITextAutocorrectionTypeNo;
+}
+
 @end
 
 #endif

data/src/GosuGLView.hpp

@@ -0,0 +1,14 @@
+#import <UIKit/UIKit.h>
+#import <Gosu/Fwd.hpp>
+
+@interface GosuGLView : UIView <UIKeyInput>
+
+- (instancetype)initWithFrame:(CGRect)frame NS_DESIGNATED_INITIALIZER;
+- (instancetype)initWithCoder:(NSCoder*)aDecoder NS_UNAVAILABLE;
+
+- (void)redrawGL:(void (^)())code;
+
+// This property must be set in order for TextInput handling to work.
+@property (nonatomic, assign) Gosu::Input* input;
+
+@end

data/src/GosuViewController.cpp

@@ -1,8 +1,8 @@
 #include <Gosu/Platform.hpp>
 #if defined(GOSU_IS_IPHONE)
 
-#import "GosuGLView.h"
-#import "GosuViewController.h"
+#import "GosuGLView.hpp"
+#import "GosuViewController.hpp"
 #import "GraphicsImpl.hpp"
 #import "AudioImpl.hpp"
 #import <Gosu/Gosu.hpp>
@@ -52,21 +52,11 @@ static void handle_audio_interruption(void* unused, UInt32 inInterruptionState)
     return YES;
 }
 
-- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation
-{
-    return UIInterfaceOrientationIsLandscape(interfaceOrientation);
-}
-
 - (NSUInteger)supportedInterfaceOrientations
 {
     return UIInterfaceOrientationMaskLandscape;
 }
 
-- (GosuGLView*)GLView
-{
-    return (GosuGLView*)self.view;
-}
-
 - (Gosu::Window&)gosuWindowReference
 {
     NSAssert(self.gosuWindow, @"gosuWindow needs to be set before showing GosuViewController");
@@ -80,6 +70,7 @@ static void handle_audio_interruption(void* unused, UInt32 inInterruptionState)
 {
     [super viewDidLoad];
     
+    // TODO - replace with AVAudioSession https://stackoverflow.com/q/19710046
     AudioSessionInitialize(nullptr, nullptr, handle_audio_interruption, nullptr);
     
     [[NSNotificationCenter defaultCenter] addObserver:self
@@ -151,15 +142,13 @@ static void handle_audio_interruption(void* unused, UInt32 inInterruptionState)
 
 - (void)setupTimerOrDisplayLink
 {
-    if (_timerOrDisplayLink) {
-        return;
-    }
+    if (_timerOrDisplayLink) return;
     
     NSInteger targetFPS = round(1000.0 / self.gosuWindowReference.update_interval());
     
     if (60 % targetFPS != 0) {
         NSTimeInterval interval = self.gosuWindowReference.update_interval() / 1000.0;
-        NSTimer* timer          = [NSTimer scheduledTimerWithTimeInterval:interval
+        NSTimer* timer = [NSTimer scheduledTimerWithTimeInterval:interval
                                                           target:self
                                                         selector:@selector(updateAndDraw:)
                                                         userInfo:nil
@@ -188,7 +177,7 @@ static void handle_audio_interruption(void* unused, UInt32 inInterruptionState)
     }
     
     if (window.needs_redraw()) {
-        [self.GLView redrawGL:^{
+        [(GosuGLView*)self.view redrawGL:^{
             window.graphics().frame([&window] {
                 window.draw();
                 Gosu::FPS::register_frame();
@@ -199,26 +188,37 @@ static void handle_audio_interruption(void* unused, UInt32 inInterruptionState)
     Gosu::Song::update();
 }
 
+#pragma mark - Input setup
+
+- (void)trackTextInput:(Gosu::Input&)input
+{
+    ((GosuGLView*)self.view).input = &input;
+}
+
 #pragma mark - Touch forwarding
 
 - (void)touchesBegan:(NSSet*)touches withEvent:(UIEvent*)event
 {
-    self.gosuWindowReference.input().feed_touch_event(0, (__bridge void*) touches);
+    auto& input = self.gosuWindowReference.input();
+    input.feed_touch_event(input.on_touch_began, (__bridge void*)touches);
 }
 
 - (void)touchesMoved:(NSSet*)touches withEvent:(UIEvent*)event
 {
-    self.gosuWindowReference.input().feed_touch_event(1, (__bridge void*) touches);
+    auto& input = self.gosuWindowReference.input();
+    input.feed_touch_event(input.on_touch_moved, (__bridge void*)touches);
 }
 
 - (void)touchesEnded:(NSSet*)touches withEvent:(UIEvent*)event
 {
-    self.gosuWindowReference.input().feed_touch_event(2, (__bridge void*) touches);
+    auto& input = self.gosuWindowReference.input();
+    input.feed_touch_event(input.on_touch_ended, (__bridge void*)touches);
 }
 
 - (void)touchesCancelled:(NSSet*)touches withEvent:(UIEvent*)event
 {
-    self.gosuWindowReference.input().feed_touch_event(3, (__bridge void*) touches);
+    auto& input = self.gosuWindowReference.input();
+    input.feed_touch_event(input.on_touch_cancelled, (__bridge void*)touches);
 }
 
 @end

data/src/{GosuViewController.h → GosuViewController.hpp}

@@ -1,12 +1,10 @@
 #import <UIKit/UIKit.h>
-
-
-@class GosuGLView;
+#import <Gosu/Fwd.hpp>
 
 
 @interface GosuViewController : UIViewController
 
-- (GosuGLView *)GLView;
+- (void)trackTextInput:(Gosu::Input&)input;
 
 @property (nonatomic, assign) void *gosuWindow;
 

data/src/Graphics.cpp

@@ -4,7 +4,7 @@
 #include "GraphicsImpl.hpp"
 #include "LargeImageData.hpp"
 #include "Macro.hpp"
-#include "TexChunk.hpp"
+#include "OffScreenTarget.hpp"
 #include "Texture.hpp"
 #include <Gosu/Bitmap.hpp>
 #include <Gosu/Image.hpp>
@@ -26,7 +26,6 @@ namespace Gosu
             if (current_graphics_pointer == nullptr) {
                 throw logic_error("Gosu::Graphics can only be drawn to while rendering");
             }
-            
             return *current_graphics_pointer;
         }
         
@@ -160,45 +159,44 @@ void Gosu::Graphics::frame(const function<void ()>& f)
     }
     else {
         // Create default draw-op queue.
-        queues.resize(1);
+        queues.emplace_back(QM_RENDER_TO_SCREEN);
     }
     
     queues.back().set_base_transform(pimpl->base_transform);
     
+    ensure_current_context();
     glClearColor(0, 0, 0, 1);
-    glClear(GL_COLOR_BUFFER_BIT);
-    
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
     current_graphics_pointer = this;
     
     f();
     
-    // If recording is in process, cancel it.
-    while (current_queue().recording()) {
-        queues.pop_back();
-    }
+    // Cancel all intermediate queues that have not been cleaned up.
+    while (queues.size() > 1) queues.pop_back();
     
     flush();
     
     if (pimpl->black_height || pimpl->black_width) {
         if (pimpl->black_height) {
             draw_quad(0, -pimpl->black_height, Color::BLACK,
-                     width(), -pimpl->black_height, Color::BLACK,
-                     0, 0, Color::BLACK,
-                     width(), 0, Color::BLACK, 0);
+                      width(), -pimpl->black_height, Color::BLACK,
+                      0, 0, Color::BLACK,
+                      width(), 0, Color::BLACK, 0);
             draw_quad(0, height(), Color::BLACK,
-                     width(), height(), Color::BLACK,
-                     0, height() + pimpl->black_height, Color::BLACK,
-                     width(), height() + pimpl->black_height, Color::BLACK, 0);
+                      width(), height(), Color::BLACK,
+                      0, height() + pimpl->black_height, Color::BLACK,
+                      width(), height() + pimpl->black_height, Color::BLACK, 0);
         }
         if (pimpl->black_width) {
             draw_quad(-pimpl->black_width, 0, Color::BLACK,
-                     0, 0, Color::BLACK,
-                     -pimpl->black_width, height(), Color::BLACK,
-                     0, height(), Color::BLACK, 0);
+                      0, 0, Color::BLACK,
+                      -pimpl->black_width, height(), Color::BLACK,
+                      0, height(), Color::BLACK, 0);
             draw_quad(width(), 0, Color::BLACK,
-                     width() + pimpl->black_width, 0, Color::BLACK,
-                     width(), height(), Color::BLACK,
-                     width() + pimpl->black_width, height(), Color::BLACK, 0);
+                      width() + pimpl->black_width, 0, Color::BLACK,
+                      width(), height(), Color::BLACK,
+                      width() + pimpl->black_width, height(), Color::BLACK, 0);
         }
         flush();
     }
@@ -219,13 +217,13 @@ void Gosu::Graphics::frame(const function<void ()>& f)
 
 void Gosu::Graphics::flush()
 {
-    current_queue().perform_draw_ops_andCode();
+    current_queue().perform_draw_ops_and_code();
     current_queue().clear_queue();
 }
 
 void Gosu::Graphics::gl(const function<void ()>& f)
 {
-    if (current_queue().recording()) {
+    if (current_queue().mode() == QM_RECORD_MACRO) {
         throw logic_error("Custom OpenGL is not allowed while creating a macro");
     }
     
@@ -267,17 +265,53 @@ void Gosu::Graphics::clip_to(double x, double y, double width, double height,
     current_queue().end_clipping();
 }
 
-unique_ptr<Gosu::ImageData> Gosu::Graphics::record(int width, int height,
-                                                   const function<void ()>& f)
+Gosu::Image Gosu::Graphics::render(int width, int height, const function<void ()>& f)
+{
+    ensure_current_context();
+    
+    // Prepare for rendering at the requested size, but save the previous matrix and viewport.
+    glMatrixMode(GL_PROJECTION);
+    glPushMatrix();
+    glLoadIdentity();
+    GLint prev_viewport[4];
+    glGetIntegerv(GL_VIEWPORT, prev_viewport);
+    glViewport(0, 0, width, height);
+    // Note the flipped vertical axis in the glOrtho call - this is so we don't have to vertically
+    // flip the texture afterwards.
+#ifdef GOSU_IS_OPENGLES
+    glOrthof(0, width, 0, height, -1, 1);
+#else
+    glOrtho(0, width, 0, height, -1, 1);
+#endif
+
+    // This is the actual render-to-texture step.
+    Image result = OffScreenTarget(width, height).render([&] {
+        glClearColor(0, 0, 0, 0);
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+        queues.emplace_back(QM_RENDER_TO_SCREEN);
+        f();
+        queues.back().perform_draw_ops_and_code();
+        queues.pop_back();
+        glFlush();
+    });
+    
+    // Restore previous matrix and glViewport.
+    glMatrixMode(GL_PROJECTION);
+    glPopMatrix();
+    glViewport(prev_viewport[0], prev_viewport[1], prev_viewport[2], prev_viewport[3]);
+    
+    return result;
+}
+
+Gosu::Image Gosu::Graphics::record(int width, int height, const function<void ()>& f)
 {
-    queues.resize(queues.size() + 1);
-    current_queue().set_recording();
+    queues.emplace_back(QM_RECORD_MACRO);
 
     f();
     
     unique_ptr<ImageData> result(new Macro(current_queue(), width, height));
     queues.pop_back();
-    return result;
+    return Image(move(result));
 }
 
 void Gosu::Graphics::transform(const Gosu::Transform& transform, const function<void ()>& f)
@@ -386,21 +420,21 @@ unique_ptr<Gosu::ImageData> Gosu::Graphics::create_image(const Bitmap& src,
             src_width == src_height &&
             (src_width & (src_width - 1)) == 0 &&
             src_width >= 64 && src_width <= max_size) {
-        shared_ptr<Texture> texture(new Texture(src_width, wants_retro));
+        shared_ptr<Texture> texture(new Texture(src_width, src_height, wants_retro));
         unique_ptr<ImageData> data;
         
         // Use the source bitmap directly if the source area completely covers
         // it.
         if (src_x == 0 && src_width == src.width() && src_y == 0 && src_height == src.height()) {
-            data = texture->try_alloc(texture, src, 0);
+            data = texture->try_alloc(src, 0);
         }
         else {
             Bitmap bmp(src_width, src_height);
             bmp.insert(src, 0, 0, src_x, src_y, src_width, src_height);
-            data = texture->try_alloc(texture, bmp, 0);
+            data = texture->try_alloc(bmp, 0);
         }
         
-        if (!data.get()) throw logic_error("Internal texture block allocation error");
+        if (!data) throw logic_error("Internal texture block allocation error");
         return data;
     }
     
@@ -417,22 +451,21 @@ unique_ptr<Gosu::ImageData> Gosu::Graphics::create_image(const Bitmap& src,
     apply_border_flags(bmp, src, src_x, src_y, src_width, src_height, flags);
 
     // Try to put the bitmap into one of the already allocated textures.
-    for (auto texture : textures) {
+    for (const auto& texture : textures) {
         if (texture->retro() != wants_retro) continue;
         
-        unique_ptr<ImageData> data;
-        data = texture->try_alloc(texture, bmp, 1);
-        if (data.get()) return data;
+        unique_ptr<ImageData> data = texture->try_alloc(bmp, 1);
+        if (data) return data;
     }
     
     // All textures are full: Create a new one.
     
     shared_ptr<Texture> texture;
-    texture.reset(new Texture(max_size, wants_retro));
+    texture.reset(new Texture(max_size, max_size, wants_retro));
     textures.push_back(texture);
     
     unique_ptr<ImageData> data;
-    data = texture->try_alloc(texture, bmp, 1);
+    data = texture->try_alloc(bmp, 1);
     if (!data.get()) throw logic_error("Internal texture block allocation error");
     return data;
 }