'in_app_store.mm',

'icloud.mm',

'ios.mm',

]

env_ios = env.Clone()

/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */

/*************************************************************************/

#import "gl_view.h"

#import "view_controller.h"

#import <UIKit/UIKit.h>

#import <CoreMotion/CoreMotion.h>

//@property (strong, nonatomic) UIWindow *window;

ViewController *view_controller;

bool is_focus_out;

#include "core/project_settings.h"

#include "drivers/coreaudio/audio_driver_coreaudio.h"

#import "gl_view.h"

#include "main/main.h"

#include "os_iphone.h"

OS::VideoMode _get_video_mode() {

int backingWidth;

int backingHeight;

glGetRenderbufferParameterivOES(GL_RENDERBUFFER_OES,

GL_RENDERBUFFER_WIDTH_OES, &backingWidth);

glGetRenderbufferParameterivOES(GL_RENDERBUFFER_OES,

GL_RENDERBUFFER_HEIGHT_OES, &backingHeight);

OS::VideoMode vm;

vm.fullscreen = true;

};

static int frame_count = 0;

{

switch (frame_count) {

return FALSE;

};

// WARNING: We must *always* create the GLView after we have constructed the

// OS with iphone_main. This allows the GLView to access project settings so

// it can properly initialize the OpenGL context

view_controller = [[ViewController alloc] init];

view_controller.view = glView;

_set_keep_screen_on(bool(GLOBAL_DEF("display/window/energy_saving/keep_screen_on", true)) ? YES : NO);

glView.useCADisplayLink =

printf("cadisaplylink: %d", glView.useCADisplayLink);

glView.animationInterval = 1.0 / kRenderingFrequency;

[glView startAnimation];

// Show the window

[window makeKeyAndVisible];

return [

('IPHONEPATH', 'Path to iPhone toolchain', '/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain'),

('IPHONESDK', 'Path to the iPhone SDK', ''),

BoolVariable('game_center', 'Support for game center', True),

BoolVariable('store_kit', 'Support for in-app store', True),

BoolVariable('icloud', 'Support for iCloud', True),

'-framework', 'Foundation',

'-framework', 'GameController',

'-framework', 'MediaPlayer',

'-framework', 'QuartzCore',

'-framework', 'Security',

'-framework', 'SystemConfiguration',

env.Append(CPPDEFINES=['ICLOUD_ENABLED'])

env.Prepend(CPPPATH=['$IPHONESDK/usr/include',

'$IPHONESDK/System/Library/Frameworks/AudioUnit.framework/Headers',

])

env['ENV']['CODESIGN_ALLOCATE'] = '/Developer/Platforms/iPhoneOS.platform/Developer/usr/bin/codesign_allocate'

env.Prepend(CPPPATH=['#platform/iphone'])

/*************************************************************************/

#include "export.h"

#include "core/io/marshalls.h"

#include "core/io/resource_saver.h"

#include "core/io/zip_io.h"

#include "editor/editor_export.h"

#include "editor/editor_node.h"

#include "editor/editor_settings.h"

#include "platform/iphone/logo.gen.h"

#include "string.h"

typedef Error (*FileHandler)(String p_file, void *p_userdata);

static Error _walk_dir_recursive(DirAccess *p_da, FileHandler p_handler, void *p_userdata);

static Error _codesign(String p_file, void *p_userdata);

struct IOSConfigData {

String pkg_name;

public:

virtual String get_name() const { return "iOS"; }

virtual String get_os_name() const { return "iOS"; }

virtual List<String> get_binary_extensions(const Ref<EditorExportPreset> &p_preset) const {

List<String> list;

String driver = ProjectSettings::get_singleton()->get("rendering/quality/driver/driver_name");

if (driver == "GLES2") {

r_features->push_back("etc");

r_features->push_back("etc2");

}

Vector<String> architectures = _get_preset_architectures(p_preset);

struct LoadingScreenInfo {

const char *preset_key;

const char *export_name;

};

static const LoadingScreenInfo loading_screen_infos[] = {

};

void EditorExportPlatformIOS::get_export_options(List<ExportOption> *r_options) {

r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "orientation/landscape_right"), true));

r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "orientation/portrait_upside_down"), true));

r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "required_icons/iphone_120x120", PROPERTY_HINT_FILE, "*.png"), "")); // Home screen on iPhone/iPod Touch with retina display

r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "required_icons/ipad_76x76", PROPERTY_HINT_FILE, "*.png"), "")); // Home screen on iPad

r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "required_icons/app_store_1024x1024", PROPERTY_HINT_FILE, "*.png"), "")); // App Store

r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "optional_icons/spotlight_40x40", PROPERTY_HINT_FILE, "*.png"), "")); // Spotlight

r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "optional_icons/spotlight_80x80", PROPERTY_HINT_FILE, "*.png"), "")); // Spotlight on devices with retina display

for (uint64_t i = 0; i < sizeof(loading_screen_infos) / sizeof(loading_screen_infos[0]); ++i) {

r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, loading_screen_infos[i].preset_key, PROPERTY_HINT_FILE, "*.png"), ""));

}

}

String EditorExportPlatformIOS::_get_additional_plist_content() {

String result;

for (int i = 0; i < export_plugins.size(); ++i) {

result += export_plugins[i]->get_ios_plist_content();

}

String EditorExportPlatformIOS::_get_linker_flags() {

String result;

for (int i = 0; i < export_plugins.size(); ++i) {

String flags = export_plugins[i]->get_ios_linker_flags();

}

String EditorExportPlatformIOS::_get_cpp_code() {

String result;

for (int i = 0; i < export_plugins.size(); ++i) {

result += export_plugins[i]->get_ios_cpp_code();

return result;

}

struct IconInfo {

const char *preset_key;

const char *idiom;

{ "required_icons/iphone_120x120", "iphone", "Icon-120.png", "120", "2x", "60x60", true },

{ "required_icons/iphone_120x120", "iphone", "Icon-120.png", "120", "3x", "40x40", true },

{ "optional_icons/iphone_180x180", "iphone", "Icon-180.png", "180", "3x", "60x60", false },

for (uint64_t i = 0; i < (sizeof(icon_infos) / sizeof(icon_infos[0])); ++i) {

IconInfo info = icon_infos[i];

String icon_path = p_preset->get(info.preset_key);

if (icon_path.length() == 0) {

return ERR_UNCONFIGURED;

}

}

sizes += String(info.actual_size_side) + "\n";

if (i > 0) {

LoadingScreenInfo info = loading_screen_infos[i];

String loading_screen_file = p_preset->get(info.preset_key);

if (loading_screen_file.size() > 0) {

if (err) {

memdelete(da);

String err_str = String("Failed to export loading screen (") + info.preset_key + ") from path '" + loading_screen_file + "'.";

ERR_PRINT(err_str.utf8().get_data());

return err;

}

}

}

memdelete(da);

};

void EditorExportPlatformIOS::_add_assets_to_project(const Ref<EditorExportPreset> &p_preset, Vector<uint8_t> &p_project_data, const Vector<IOSExportAsset> &p_additional_assets) {

Vector<String> frameworks;

for (int i = 0; i < export_plugins.size(); ++i) {

Vector<String> plugin_frameworks = export_plugins[i]->get_ios_frameworks();

}

Error EditorExportPlatformIOS::_export_additional_assets(const String &p_out_dir, const Vector<SharedObject> &p_libraries, Vector<IOSExportAsset> &r_exported_assets) {

for (int i = 0; i < export_plugins.size(); i++) {

Vector<String> frameworks = export_plugins[i]->get_ios_frameworks();

Error err = _export_additional_assets(p_out_dir, frameworks, true, r_exported_assets);

print_line("Creating " + dir_name);

Error dir_err = tmp_app_path->make_dir_recursive(dir_name);

if (dir_err) {

unzClose(src_pkg_zip);

memdelete(tmp_app_path);

return ERR_CANT_CREATE;

/* write the file */

FileAccess *f = FileAccess::open(file, FileAccess::WRITE);

if (!f) {

unzClose(src_pkg_zip);

memdelete(tmp_app_path);

return ERR_CANT_CREATE;

unzClose(src_pkg_zip);

if (!found_library) {

memdelete(tmp_app_path);

return ERR_FILE_NOT_FOUND;

}

String project_file_name = dest_dir + binary_name + ".xcodeproj/project.pbxproj";

FileAccess *f = FileAccess::open(project_file_name, FileAccess::WRITE);

if (!f) {

return ERR_CANT_CREATE;

};

f->store_buffer(project_file_data.ptr(), project_file_data.size());

ret["type"] = "achievement_descriptions";

if (error == nil) {

ret["result"] = "ok";

Array hidden;

Array replayable;

ret["type"] = "achievements";

if (error == nil) {

ret["result"] = "ok";

for (int i = 0; i < [achievements count]; i++) {

@end

*/

int gl_view_base_fb;

static String keyboard_text;

static GLView *_instance = NULL;

kEAGLColorFormatRGBA8,

kEAGLDrawablePropertyColorFormat,

nil];

// Create GL ES 2 context

context = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES2];

NSLog(@"Setting up an OpenGL ES 2.0 context.");

if (!context) {

const char *str = [(NSString *)object UTF8String];

return String::utf8(str != NULL ? str : "");

} else if ([object isKindOfClass:[NSData class]]) {

NSData *data = (NSData *)object;

if ([data length] > 0) {

ret.resize([data length]);

{

}

}

return ret;

[result addObject:value];

}

return result;

return result;

}

WARN_PRINT(String("Could not add unsupported type to iCloud: '" + Variant::get_type_name(v.get_type()) + "'").utf8().get_data());

Dictionary ret;

ret["type"] = "key_value_changed";

//Array result_values;

Dictionary keyValues;

String reason = "";

Dictionary ret;

ret["type"] = "product_info";

ret["result"] = "ok";

for (NSUInteger i = 0; i < [products count]; i++) {

ret["localized_prices"] = localized_prices;

ret["currency_codes"] = currency_codes;

for (NSString *ipid in response.invalidProductIdentifiers) {

Dictionary params = p_params;

ERR_FAIL_COND_V(!params.has("product_ids"), ERR_INVALID_PARAMETER);

printf("************ request product info! %i\n", pids.size());

NSMutableArray *array = [[[NSMutableArray alloc] initWithCapacity:pids.size()] autorelease];

#include "os_iphone.h"

#include "drivers/gles2/rasterizer_gles2.h"

#include "servers/visual/visual_server_raster.h"

#include "servers/visual/visual_server_wrap_mt.h"

const char *OSIPhone::get_video_driver_name(int p_driver) const {

switch (p_driver) {

case VIDEO_DRIVER_GLES2:

return "GLES2";

}

void OSIPhone::initialize_core() {

OS_Unix::initialize_core();

set_data_dir(data_dir);

};

return video_driver_index;

}

Error OSIPhone::initialize(const VideoMode &p_desired, int p_video_driver, int p_audio_driver) {

bool gl_initialization_error = false;

}

if (gl_initialization_error) {

OS::get_singleton()->alert("Your device does not support any of the supported OpenGL versions.",

return ERR_UNAVAILABLE;

}

visual_server = memnew(VisualServerRaster);

// FIXME: Reimplement threaded rendering

if (get_render_thread_mode() != RENDER_THREAD_UNSAFE) {

visual_server = memnew(VisualServerWrapMT(visual_server, false));

}

visual_server->init();

//visual_server->cursor_set_visible(false, 0);

// reset this to what it should be, it will have been set to 0 after visual_server->init() is called

AudioDriverManager::initialize(p_audio_driver);

ev.instance();

ev->set_echo(false);

ev->set_pressed(p_pressed);

ev->set_unicode(p_key);

queue_event(ev);

};

};

int OSIPhone::set_base_framebuffer(int p_fb) {

// gl_view_base_fb has not been updated yet

return 0;

};

#include "servers/visual/rasterizer.h"

#include "servers/visual_server.h"

class OSIPhone : public OS_Unix {

private:

MainLoop *main_loop;

VideoMode video_mode;

virtual int get_video_driver_count() const;

#include <alloca.h>

#define GLES2_INCLUDE_H <ES2/gl.h>

#define PLATFORM_REFCOUNT

/*************************************************************************/

/*************************************************************************/

/* This file is part of: */

/* GODOT ENGINE */

/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */

/*************************************************************************/

public:

};

/*************************************************************************/

/*************************************************************************/

/* This file is part of: */

/* GODOT ENGINE */

/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */

/*************************************************************************/

}

}

}

}