godot/platform/nacl/godot_module.cpp
2014-02-09 22:10:30 -03:00

333 lines
9.8 KiB
C++

/*************************************************************************/
/* godot_module.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "opengl_context.h"
#include <cstdlib>
#include <cstring>
#include <string>
#include <vector>
#include "ppapi/cpp/instance.h"
#include "ppapi/cpp/module.h"
#include "ppapi/gles2/gl2ext_ppapi.h"
#include "ppapi/cpp/rect.h"
#include "ppapi/cpp/size.h"
#include "ppapi/cpp/var.h"
#include "geturl_handler.h"
#include "core/variant.h"
#include "os_nacl.h"
extern int nacl_main(int argc, const char** argn, const char** argv);
extern void nacl_cleanup();
static String pkg_url;
pp::Instance* godot_instance = NULL;
struct StateData {
int arg_count;
Array args;
String method;
};
extern OSNacl* os_nacl;
class GodotInstance : public pp::Instance {
enum State {
STATE_METHOD,
STATE_PARAM_COUNT,
STATE_PARAMS,
STATE_CALL,
};
State state;
StateData* sd;
SharedOpenGLContext opengl_context_;
int width;
int height;
#define MAX_ARGS 64
uint32_t init_argc;
char* init_argn[MAX_ARGS];
char* init_argv[MAX_ARGS];
bool package_loaded;
GetURLHandler* package_pending;
public:
explicit GodotInstance(PP_Instance instance) : pp::Instance(instance) {
printf("GodotInstance!\n");
state = STATE_METHOD;
RequestInputEvents(PP_INPUTEVENT_CLASS_MOUSE | PP_INPUTEVENT_CLASS_KEYBOARD | PP_INPUTEVENT_CLASS_WHEEL | PP_INPUTEVENT_CLASS_TOUCH);
sd = NULL;
package_pending = NULL;
package_loaded = false;
godot_instance = this;
}
virtual ~GodotInstance() {
nacl_cleanup();
}
/// Called by the browser to handle the postMessage() call in Javascript.
/// Detects which method is being called from the message contents, and
/// calls the appropriate function. Posts the result back to the browser
/// asynchronously.
/// @param[in] var_message The message posted by the browser. The possible
/// messages are 'fortyTwo' and 'reverseText:Hello World'. Note that
/// the 'reverseText' form contains the string to reverse following a ':'
/// separator.
virtual void HandleMessage(const pp::Var& var_message);
bool HandleInputEvent(const pp::InputEvent& event);
bool Init(uint32_t argc, const char* argn[], const char* argv[]) {
printf("******* init! %i, %p, %p\n", argc, argn, argv);
fflush(stdout);
if (opengl_context_ == NULL) {
opengl_context_.reset(new OpenGLContext(this));
};
opengl_context_->InvalidateContext(this);
opengl_context_->ResizeContext(pp::Size(0, 0));
int current = opengl_context_->MakeContextCurrent(this);
printf("current is %i\n", current);
os_nacl = new OSNacl;
pkg_url = "";
for (uint32_t i=0; i<argc; i++) {
if (strcmp(argn[i], "package") == 0) {
pkg_url = argv[i];
};
};
sd = memnew(StateData);
if (pkg_url == "") {
nacl_main(argc, argn, argv);
} else {
printf("starting package %ls\n", pkg_url.c_str());
init_argc = MIN(argc, MAX_ARGS-1);
for (uint32_t i=0; i<argc; i++) {
int nlen = strlen(argn[i]);
init_argn[i] = (char*)memalloc(nlen+1);
strcpy(init_argn[i], argn[i]);
init_argn[i+1] = NULL;
int len = strlen(argv[i]);
init_argv[i] = (char*)memalloc(len+1);
strcpy(init_argv[i], argv[i]);
init_argv[i+1] = NULL;
};
package_pending = memnew(GetURLHandler(this, pkg_url));
package_pending->Start();
};
return true;
};
// Called whenever the in-browser window changes size.
virtual void DidChangeView(const pp::Rect& position, const pp::Rect& clip) {
if (position.size().width() == width &&
position.size().height() == height)
return; // Size didn't change, no need to update anything.
if (opengl_context_ == NULL) {
opengl_context_.reset(new OpenGLContext(this));
};
opengl_context_->InvalidateContext(this);
opengl_context_->ResizeContext(position.size());
if (!opengl_context_->MakeContextCurrent(this))
return;
width = position.size().width();
height = position.size().height();
// init gl here?
OS::VideoMode vm;
vm.width = width;
vm.height = height;
vm.resizable = false;
vm.fullscreen = true;
OS::get_singleton()->set_video_mode(vm, 0);
DrawSelf();
};
// Called to draw the contents of the module's browser area.
void DrawSelf() {
if (opengl_context_ == NULL)
return;
opengl_context_->FlushContext();
};
};
static Variant to_variant(const pp::Var& p_var) {
if (p_var.is_undefined() || p_var.is_null())
return Variant();
if (p_var.is_bool())
return Variant(p_var.AsBool());
if (p_var.is_double())
return Variant(p_var.AsDouble());
if (p_var.is_int())
return Variant((int64_t)p_var.AsInt());
if (p_var.is_string())
return Variant(String::utf8(p_var.AsString().c_str()));
return Variant();
};
void GodotInstance::HandleMessage(const pp::Var& var_message) {
switch (state) {
case STATE_METHOD: {
ERR_FAIL_COND(!var_message.is_string());
sd->method = var_message.AsString().c_str();
state = STATE_PARAM_COUNT;
} break;
case STATE_PARAM_COUNT: {
ERR_FAIL_COND(!var_message.is_number());
sd->arg_count = var_message.AsInt();
state = sd->arg_count>0?STATE_PARAMS:STATE_CALL;
} break;
case STATE_PARAMS: {
Variant p = to_variant(var_message);
sd->args.push_back(p);
if (sd->args.size() >= sd->arg_count)
state = STATE_CALL;
} break;
default:
break;
};
if (state == STATE_CALL) {
// call
state = STATE_METHOD;
if (sd->method == "package_finished") {
GetURLHandler::Status status = package_pending->get_status();
printf("status is %i, %i, %i\n", status, GetURLHandler::STATUS_ERROR, GetURLHandler::STATUS_COMPLETED);
if (status == GetURLHandler::STATUS_ERROR) {
printf("Error fetching package!\n");
};
if (status == GetURLHandler::STATUS_COMPLETED) {
OSNacl* os = (OSNacl*)OS::get_singleton();
os->add_package(pkg_url, package_pending->get_data());
};
memdelete(package_pending);
package_pending = NULL;
package_loaded = true;
opengl_context_->MakeContextCurrent(this);
nacl_main(init_argc, (const char**)init_argn, (const char**)init_argv);
for (uint32_t i=0; i<init_argc; i++) {
memfree(init_argn[i]);
memfree(init_argv[i]);
};
};
if (sd->method == "get_package_status") {
if (package_loaded) {
// post "loaded"
PostMessage("loaded");
} else if (package_pending == NULL) {
// post "none"
PostMessage("none");
} else {
// post package_pending->get_bytes_read();
PostMessage(package_pending->get_bytes_read());
};
};
};
}
bool GodotInstance::HandleInputEvent(const pp::InputEvent& event) {
OSNacl* os = (OSNacl*)OS::get_singleton();
os->handle_event(event);
return true;
};
class GodotModule : public pp::Module {
public:
GodotModule() : pp::Module() {}
virtual ~GodotModule() {
glTerminatePPAPI();
}
/// Create and return a GodotInstance object.
/// @param[in] instance a handle to a plug-in instance.
/// @return a newly created GodotInstance.
/// @note The browser is responsible for calling @a delete when done.
virtual pp::Instance* CreateInstance(PP_Instance instance) {
printf("CreateInstance! %x\n", instance);
return new GodotInstance(instance);
}
/// Called by the browser when the module is first loaded and ready to run.
/// This is called once per module, not once per instance of the module on
/// the page.
virtual bool Init() {
printf("GodotModule::init!\n");
return glInitializePPAPI(get_browser_interface());
}
};
namespace pp {
/// Factory function called by the browser when the module is first loaded.
/// The browser keeps a singleton of this module. It calls the
/// CreateInstance() method on the object you return to make instances. There
/// is one instance per <embed> tag on the page. This is the main binding
/// point for your NaCl module with the browser.
/// @return new GodotModule.
/// @note The browser is responsible for deleting returned @a Module.
Module* CreateModule() {
printf("CreateModule!\n");
return new GodotModule();
}
} // namespace pp