godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Drop NACL platform 

It's no longer maintained and Chrome-specific, so it's not a viable solution
to deploy Godot games in browsers. The current prefered alternative is asm.js
(platform/javascript), and we're looking forward to WebAssembly.
This commit is contained in:
Rémi Verschelde 2016-04-25 18:55:31 +02:00
parent f368d380e7
commit ec606f94dc
24 changed files with 0 additions and 3494 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
platform/nacl/SCsub
View File

@ -1,30 +0,0 @@
Import('env')
nacl_lib = [
'os_nacl.cpp',
'audio_driver_nacl.cpp',
'godot_nacl.cpp',
#'pepper_main.cpp',
'opengl_context.cpp',
'godot_module.cpp',
'geturl_handler.cpp',
]
nacl_posix = [
'#drivers/unix/thread_posix.cpp',
'#drivers/unix/mutex_posix.cpp',
'#drivers/unix/semaphore_posix.cpp',
]
posix_lib = []
for f in nacl_posix:
posix_lib.append(env.Object(f, CPPFLAGS = env['CPPFLAGS']+['-DUNIX_ENABLED'], OBJSUFFIX = '.posix'+env['OBJSUFFIX']))
prog = env.Program('#bin/godot_nacl', nacl_lib + posix_lib)
if (env['nacl_arch'] == 'i686'):
env.Alias("nacl_32", prog)
if (env['nacl_arch'] == 'x86_64'):
env.Alias("nacl_64", prog)

106
platform/nacl/audio_driver_nacl.cpp
View File

@ -1,106 +0,0 @@
/*************************************************************************/
/* audio_driver_nacl.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 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 "audio_driver_nacl.h"
#include "ppapi/cpp/instance.h"
extern pp::Instance* godot_instance;
const char* AudioDriverNacl::get_name() const {
return "Nacl";
}
void AudioDriverNacl::output_callback(void* samples, uint32_t buffer_size, void* data) {
AudioDriverNacl* ad = (AudioDriverNacl*)data;
int16_t* out = (int16_t*)samples;
ad->lock();
ad->audio_server_process(ad->sample_frame_count_, ad->samples_in);
ad->unlock();
for (int i=0; i<ad->sample_count; i++) {
out[i] = ad->samples_in[i]>>16;
};
};
Error AudioDriverNacl::init(){
int frame_size = 4096;
sample_frame_count_ = pp::AudioConfig::RecommendSampleFrameCount(godot_instance,PP_AUDIOSAMPLERATE_44100, frame_size);
sample_count = sample_frame_count_ * 2;
audio_ = pp::Audio(godot_instance,
pp::AudioConfig(godot_instance,
PP_AUDIOSAMPLERATE_44100,
sample_frame_count_),
&AudioDriverNacl::output_callback,
this);
samples_in = memnew_arr(int32_t, sample_frame_count_ * 2);
return OK;
}
void AudioDriverNacl::start(){
audio_.StartPlayback();
}
int AudioDriverNacl::get_mix_rate() const {
return 44100;
}
AudioDriverSW::OutputFormat AudioDriverNacl::get_output_format() const{
return OUTPUT_STEREO;
}
void AudioDriverNacl::lock(){
}
void AudioDriverNacl::unlock() {
}
void AudioDriverNacl::finish(){
audio_.StopPlayback();
}
AudioDriverNacl::AudioDriverNacl() {
}
AudioDriverNacl::~AudioDriverNacl() {
memdelete_arr(samples_in);
}

63
platform/nacl/audio_driver_nacl.h
View File

@ -1,63 +0,0 @@
/*************************************************************************/
/* audio_driver_nacl.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 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. */
/*************************************************************************/
#ifndef AUDIO_DRIVER_NACL_H
#define AUDIO_DRIVER_NACL_H
#include "servers/audio/audio_server_sw.h"
#include "ppapi/cpp/audio.h"
class AudioDriverNacl : public AudioDriverSW {
static void output_callback(void* samples, uint32_t buffer_size, void* data);
int32_t* samples_in;
int sample_frame_count_;
int sample_count;
pp::Audio audio_;
public:
virtual const char* get_name() const;
virtual Error init();
virtual void start();
virtual int get_mix_rate() const ;
virtual OutputFormat get_output_format() const;
virtual void lock();
virtual void unlock();
virtual void finish();
AudioDriverNacl();
~AudioDriverNacl();
};
#endif // AUDIO_DRIVER_NACL_H

67
platform/nacl/context_gl_nacl.cpp
View File

@ -1,67 +0,0 @@
/*************************************************************************/
/* context_gl_nacl.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 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 "context_gl_nacl.h"
#include <nacl/npapi.h>
#include <nacl/npruntime.h>
#include <nacl/npapi_extensions.h>
#include <nacl/npupp.h>
#include <pgl/pgl.h>
#include <GLES2/gl2.h>
void ContextGLNacl::make_current() {
};
int ContextGLNacl::get_window_width() {
};
int ContextGLNacl::get_window_height() {
};
void ContextGLNacl::swap_buffers() {
};
Error ContextGLNacl::initialize() {
};
ContextGLNacl::ContextGLNacl() {
};
ContextGLNacl::~ContextGLNacl() {
};

58
platform/nacl/context_gl_nacl.h
View File

@ -1,58 +0,0 @@
/*************************************************************************/
/* context_gl_nacl.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 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. */
/*************************************************************************/
#ifndef CONTEXT_GL_NACL_H
#define CONTEXT_GL_NACL_H
#include "drivers/gl_context/context_gl.h"
class NPDevice;
class ContextGLNacl : public ContextGL {
enum {
COMMAND_BUFFER_SIZE = 1024 * 1024,
};
NPDevice* device3d_;
public:
virtual void make_current();
virtual int get_window_width();
virtual int get_window_height();
virtual void swap_buffers();
virtual Error initialize();
ContextGLNacl();
~ContextGLNacl();
};
#endif // CONTEXT_GL_NACL_H

71
platform/nacl/detect.py
View File

@ -1,71 +0,0 @@
import os
import sys
def is_active():
return True
def get_name():
return "NaCl"
def can_build():
import os
if not os.environ.has_key("NACLPATH"):
return False
return True
def get_opts():
return [
('NACLPATH', 'the path to nacl', os.environ.get("NACLPATH", 0)),
('nacl_arch', 'The architecture for Nacl build (can be i686 or x86_64', 'i686'),
]
def get_flags():
return [
('nedmalloc', 'no'),
('tools', 'no'),
]
def configure(env):
env.Append(CPPPATH=['#platform/nacl'])
env['OBJSUFFIX'] = ".nacl.${nacl_arch}.o"
env['LIBSUFFIX'] = ".nacl.${nacl_arch}.a"
env['PROGSUFFIX'] = ".${nacl_arch}.nexe"
env['ENV']['PATH'] = env['ENV']['PATH']+":"+env['NACLPATH']+"/toolchain/linux_x86_newlib/bin"
env['CC'] = '${nacl_arch}-nacl-gcc'
env['CXX'] = '${nacl_arch}-nacl-g++'
env['AR'] = '${nacl_arch}-nacl-ar'
env.Append(CCFLAGS=['-fexceptions', '-Wno-long-long', '-pthread', '-DXP_UNIX'])
env.Append(CPPPATH=env['NACLPATH'])
if (env["target"]=="release"):
env.Append(CCFLAGS=['-O2','-ffast-math','-fomit-frame-pointer', '-ffunction-sections', '-fdata-sections', '-fno-default-inline'])
elif (env["target"]=="debug"):
env.Append(CCFLAGS=['-g', '-O0', '-Wall','-DDEBUG_ENABLED'])
elif (env["target"]=="profile"):
env.Append(CCFLAGS=['-g','-pg'])
env.Append(LINKFLAGS=['-pg'])
env.Append(CCFLAGS=['-DNACL_ENABLED', '-DGLES2_ENABLED'])
env.Append(LIBFLAGS=['m32'])
env.Append(LIBS=env.Split('ppapi ppapi_cpp pthread srpc ppapi_gles22'))
import methods
env.Append( BUILDERS = { 'GLSL120GLES' : env.Builder(action = methods.build_gles2_headers, suffix = 'glsl.h',src_suffix = '.glsl') } )

150
platform/nacl/geturl_handler.cpp
View File

@ -1,150 +0,0 @@
/*************************************************************************/
/* geturl_handler.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 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 "geturl_handler.h"
#include "core/os/copymem.h"
#include <stdio.h>
#include <stdlib.h>
#include "ppapi/c/pp_errors.h"
#include "ppapi/c/ppb_instance.h"
#include "ppapi/cpp/module.h"
#include "ppapi/cpp/var.h"
void GetURLHandler::Start() {
pp::CompletionCallback cc =
cc_factory_.NewCallback(&GetURLHandler::OnOpen);
url_loader_.Open(url_request_, cc);
}
void GetURLHandler::OnOpen(int32_t result) {
if (result != PP_OK) {
status = STATUS_ERROR;
return;
}
// Here you would process the headers. A real program would want to at least
// check the HTTP code and potentially cancel the request.
// pp::URLResponseInfo response = loader_.GetResponseInfo();
// Start streaming.
ReadBody();
}
void GetURLHandler::AppendDataBytes(const char* buffer, int32_t num_bytes) {
if (num_bytes <= 0)
return;
// Make sure we don't get a buffer overrun.
num_bytes = std::min(READ_BUFFER_SIZE, num_bytes);
int ofs = data.size();
data.resize(ofs + num_bytes);
copymem(&data[ofs], buffer, num_bytes);
}
void GetURLHandler::OnRead(int32_t result) {
if (result == PP_OK) {
// Streaming the file is complete.
status = STATUS_COMPLETED;
instance_->HandleMessage("package_finished");
instance_->HandleMessage(0);
printf("completed!\n");
} else if (result > 0) {
// The URLLoader just filled "result" number of bytes into our buffer.
// Save them and perform another read.
AppendDataBytes(buffer_, result);
ReadBody();
} else {
// A read error occurred.
status = STATUS_ERROR;
ERR_FAIL_COND(result < 0);
}
}
void GetURLHandler::ReadBody() {
// Note that you specifically want an "optional" callback here. This will
// allow ReadBody() to return synchronously, ignoring your completion
// callback, if data is available. For fast connections and large files,
// reading as fast as we can will make a large performance difference
// However, in the case of a synchronous return, we need to be sure to run
// the callback we created since the loader won't do anything with it.
pp::CompletionCallback cc =
cc_factory_.NewOptionalCallback(&GetURLHandler::OnRead);
int32_t result = PP_OK;
do {
result = url_loader_.ReadResponseBody(buffer_, sizeof(buffer_), cc);
// Handle streaming data directly. Note that we *don't* want to call
// OnRead here, since in the case of result > 0 it will schedule
// another call to this function. If the network is very fast, we could
// end up with a deeply recursive stack.
if (result > 0) {
AppendDataBytes(buffer_, result);
}
} while (result > 0);
if (result != PP_OK_COMPLETIONPENDING) {
// Either we reached the end of the stream (result == PP_OK) or there was
// an error. We want OnRead to get called no matter what to handle
// that case, whether the error is synchronous or asynchronous. If the
// result code *is* COMPLETIONPENDING, our callback will be called
// asynchronously.
cc.Run(result);
}
}
GetURLHandler::Status GetURLHandler::get_status() const {
return status;
};
Vector<uint8_t> GetURLHandler::get_data() const {
return data;
};
int GetURLHandler::get_bytes_read() const {
return data.size();
};
GetURLHandler::GetURLHandler(pp::Instance* instance,
const String& url)
: instance_(instance),
url_(url),
url_request_(instance),
url_loader_(instance),
cc_factory_(this) {
url_request_.SetURL(std::string(url.utf8().get_data()));
url_request_.SetMethod("GET");
status = STATUS_NONE;
printf("url handler for url %ls!\n", url.c_str());
}
GetURLHandler::~GetURLHandler() {
}

115
platform/nacl/geturl_handler.h
View File

@ -1,115 +0,0 @@
/*************************************************************************/
/* geturl_handler.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 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. */
/*************************************************************************/
#ifndef EXAMPLES_GETURL_GETURL_HANDLER_H_
#define EXAMPLES_GETURL_GETURL_HANDLER_H_
#include "core/ustring.h"
#include "core/vector.h"
#include "ppapi/cpp/completion_callback.h"
#include "ppapi/cpp/url_loader.h"
#include "ppapi/cpp/url_request_info.h"
#include "ppapi/cpp/instance.h"
#include "ppapi/utility/completion_callback_factory.h"
#define READ_BUFFER_SIZE 32768
// GetURLHandler is used to download data from |url|. When download is
// finished or when an error occurs, it posts a message back to the browser
// with the results encoded in the message as a string and self-destroys.
//
// EXAMPLE USAGE:
// GetURLHandler* handler* = GetURLHandler::Create(instance,url);
// handler->Start();
//
class GetURLHandler {
public:
enum Status {
STATUS_NONE,
STATUS_IN_PROGRESS,
STATUS_COMPLETED,
STATUS_ERROR,
};
private:
Status status;
// Callback fo the pp::URLLoader::Open().
// Called by pp::URLLoader when response headers are received or when an
// error occurs (in response to the call of pp::URLLoader::Open()).
// Look at <ppapi/c/ppb_url_loader.h> and
// <ppapi/cpp/url_loader.h> for more information about pp::URLLoader.
void OnOpen(int32_t result);
// Callback fo the pp::URLLoader::ReadResponseBody().
// |result| contains the number of bytes read or an error code.
// Appends data from this->buffer_ to this->url_response_body_.
void OnRead(int32_t result);
// Reads the response body (asynchronously) into this->buffer_.
// OnRead() will be called when bytes are received or when an error occurs.
void ReadBody();
// Append data bytes read from the URL onto the internal buffer. Does
// nothing if |num_bytes| is 0.
void AppendDataBytes(const char* buffer, int32_t num_bytes);
pp::Instance* instance_; // Weak pointer.
String url_; // URL to be downloaded.
pp::URLRequestInfo url_request_;
pp::URLLoader url_loader_; // URLLoader provides an API to download URLs.
char buffer_[READ_BUFFER_SIZE]; // Temporary buffer for reads.
Vector<uint8_t> data; // Contains accumulated downloaded data.
pp::CompletionCallbackFactory<GetURLHandler> cc_factory_;
bool complete;
GetURLHandler(const GetURLHandler&);
void operator=(const GetURLHandler&);
public:
// Creates instance of GetURLHandler on the heap.
// GetURLHandler objects shall be created only on the heap (they
// self-destroy when all data is in).
// Initiates page (URL) download.
void Start();
Status get_status() const;
Vector<uint8_t> get_data() const;
int get_bytes_read() const;
GetURLHandler(pp::Instance* instance_, const String& url);
~GetURLHandler();
};
#endif // EXAMPLES_GETURL_GETURL_HANDLER_H_

332
platform/nacl/godot_module.cpp
View File

@ -1,332 +0,0 @@
/*************************************************************************/
/* godot_module.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 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

80
platform/nacl/godot_nacl.cpp
View File

@ -1,80 +0,0 @@
/*************************************************************************/
/* godot_nacl.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 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 "os_nacl.h"
#include "main/main.h"
#include <stdio.h>
#include <string.h>
OSNacl* os_nacl = NULL;
int nacl_main(int argc, const char** argn, const char** argv) {
// os is created in GodotModule::Init for the nacl module
printf("called with %i args, %p, %p\n", argc, argn, argv);
char* nargv[64];
int nargc = 1;
nargv[0] = (char*)argv[0];
for (int i=1; i<argc; i++) {
printf("arg %i is %s, %s\n", i, argn[i], argv[i]);
if (strncmp(argn[i], "arg", 3) == 0) {
printf("using arg %i, %s\n", nargc, argv[i]);
nargv[nargc++] = (char*)argv[i];
};
};
printf("total %i\n", nargc);
nargv[nargc] = 0;
printf("godot_nacl\n");
for (int i=0; i<argc; i++) {
printf("arg %i: %s\n", i, argv[i]);
};
printf("os created\n");
Error err = Main::setup("", nargc-1, &nargv[1]);
printf("setup %i\n", err);
if (err!=OK)
return 255;
printf("calling start\n");
Main::start();
return 0;
};
void nacl_cleanup() {
Main::cleanup();
delete os_nacl;
};

178
platform/nacl/html/check_browser.js
View File

@ -1,178 +0,0 @@
/*
* Copyright (c) 2011 The Native Client Authors. All rights reserved.
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
/**
* @fileoverview This file provides a BrowserChecker Javascript class.
* Users can create a BrowserChecker object, invoke checkBrowser(|version|),
* and then use getIsValidBrowser() and getBrowserSupportStatus()
* to determine if the browser version is greater than |version|
* and if the Native Client plugin is found.
*/
// Create a namespace object
var browser_version = browser_version || {};
/**
* Class to provide checking for version and NativeClient.
* @param {integer} arg1 An argument that indicates major version of Chrome we
* require, such as 14.
*/
/**
* Constructor for the BrowserChecker. Sets the major version of
* Chrome that is required to |minChromeVersion|.
* @param minChromeVersion The earliest major version of chrome that
* is supported. If the Chrome browser version is less than
* |minChromeVersion| then |isValidBrowswer| will be set to false.
* @param opt_maxChromeVersion Ignored. Retained for backwards compatibility.
* @param appVersion The application version string.
* @param plugins The plugins that exist in the browser.
* @constructor
*/
browser_version.BrowserChecker = function(minChromeVersion,
appVersion, plugins,
opt_maxChromeVersion) {
/**
* Version specified by the user. This class looks to see if the browser
* version is >= |minChromeVersion_|.
* @type {integer}
* @private
*/
this.minChromeVersion_ = minChromeVersion;
/**
* List of Browser plugin objects.
* @type {Ojbect array}
* @private
*/
this.plugins_ = plugins;
/**
* Application version string from the Browser.
* @type {integer}
* @private
*/
this.appVersion_ = appVersion;
/**
* Flag used to indicate if the browser has Native Client and is if the
* browser version is recent enough.
* @type {boolean}
* @private
*/
this.isValidBrowser_ = false;
/**
* Actual major version of Chrome -- found by querying the browser.
* @type {integer}
* @private
*/
this.chromeVersion_ = null;
/**
* Browser support status. This allows the user to get a detailed status
* rather than using this.browserSupportMessage.
*/
this.browserSupportStatus_ =
browser_version.BrowserChecker.StatusValues.UNKNOWN;
}
/**
* The values used for BrowserChecker status to indicate success or
* a specific error.
* @enum {id}
*/
browser_version.BrowserChecker.StatusValues = {
UNKNOWN: 0,
NACL_ENABLED: 1,
UNKNOWN_BROWSER: 2,
CHROME_VERSION_TOO_OLD: 3,
NACL_NOT_ENABLED: 4,
NOT_USING_SERVER: 5
};
/**
* Determines if the plugin with name |name| exists in the browser.
* @param {string} name The name of the plugin.
* @param {Object array} plugins The plugins in this browser.
* @return {bool} |true| if the plugin is found.
*/
browser_version.BrowserChecker.prototype.pluginExists = function(name,
plugins) {
for (var index=0; index < plugins.length; index++) {
var plugin = this.plugins_[index];
var plugin_name = plugin['name'];
// If the plugin is not found, you can use the Javascript console
// to see the names of the plugins that were found when debugging.
if (plugin_name.indexOf(name) != -1) {
return true;
}
}
return false;
}
/**
* Returns browserSupportStatus_ which indicates if the browser supports
* Native Client. Values are defined as literals in
* browser_version.BrowserChecker.StatusValues.
* @ return {int} Level of NaCl support.
*/
browser_version.BrowserChecker.prototype.getBrowserSupportStatus = function() {
return this.browserSupportStatus_;
}
/**
* Returns isValidBrowser (true/false) to indicate if the browser supports
* Native Client.
* @ return {bool} If this browser has NativeClient and correct version.
*/
browser_version.BrowserChecker.prototype.getIsValidBrowser = function() {
return this.isValidBrowser_;
}
/**
* Checks to see if this browser can support Native Client applications.
* For Chrome browsers, checks to see if the "Native Client" plugin is
* enabled.
*/
browser_version.BrowserChecker.prototype.checkBrowser = function() {
var versionPatt = /Chrome\/(\d+)\.(\d+)\.(\d+)\.(\d+)/;
var result = this.appVersion_.match(versionPatt);
// |result| stores the Chrome version number.
if (!result) {
this.isValidBrowser_ = false;
this.browserSupportStatus_ =
browser_version.BrowserChecker.StatusValues.UNKNOWN_BROWSER;
} else {
this.chromeVersion_ = result[1];
// We know we have Chrome, check version and/or plugin named Native Client
if (this.chromeVersion_ >= this.minChromeVersion_) {
var found_nacl = this.pluginExists('Native Client', this.plugins_);
if (found_nacl) {
this.isValidBrowser_ = true;
this.browserSupportStatus_ =
browser_version.BrowserChecker.StatusValues.NACL_ENABLED;
} else {
this.isValidBrowser_ = false;
this.browserSupportStatus_ =
browser_version.BrowserChecker.StatusValues.NACL_NOT_ENABLED;
}
} else {
// We are in a version that is less than |minChromeVersion_|
this.isValidBrowser_ = false;
this.browserSupportStatus_ =
browser_version.BrowserChecker.StatusValues.CHROME_VERSION_TOO_OLD;
}
}
var my_protocol = window.location.protocol;
if (my_protocol.indexOf('file') == 0) {
this.isValidBrowser_ = false;
this.browserSupportStatus_ =
browser_version.BrowserChecker.StatusValues.NOT_USING_SERVER;
}
}

6
platform/nacl/html/godot_nacl.nmf
View File

@ -1,6 +0,0 @@
{
"program": {
"x86-64": {"url": "godot_nacl.x86_64.nexe"},
"x86-32": {"url": "godot_nacl.i686.nexe"}
}
}

BIN
platform/nacl/html/icon_128.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 11 KiB

BIN
platform/nacl/html/icon_16.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 828 B

258
platform/nacl/html/index.html
View File

@ -1,258 +0,0 @@
<!DOCTYPE html>
<html>
<!--
Copyright (c) 2011 The Native Client Authors. All rights reserved.
Use of this source code is governed by a BSD-style license that can be
found in the LICENSE file.
-->
<head>
<title>Load Progress Example</title>
<script type="text/javascript" src="check_browser.js"></script>
<script type="text/javascript">
// Check for Native Client support in the browser before the DOM loads.
var isValidBrowser = false;
var browserSupportStatus = 0;
var checker = new browser_version.BrowserChecker(
14, // Minumum Chrome version.
navigator["appVersion"],
navigator["plugins"]);
checker.checkBrowser();
loadProgressModule = null; // Global application object.
statusText = 'NO-STATUS';
isValidBrowser = checker.getIsValidBrowser();
browserSupportStatus = checker.getBrowserSupportStatus();
// Handler that gets called when the NaCl module starts loading. This
// event is always triggered when an <EMBED> tag has a MIME type of
// application/x-nacl.
function moduleDidStartLoad() {
appendToEventLog('loadstart');
}
// Progress event handler. |event| contains a couple of interesting
// properties that are used in this example:
// total The size of the NaCl module in bytes. Note that this value
// is 0 until |lengthComputable| is true. In particular, this
// value is 0 for the first 'progress' event.
// loaded The number of bytes loaded so far.
// lengthComputable A boolean indicating that the |total| field
// represents a valid length.
//
// event The ProgressEvent that triggered this handler.
function moduleLoadProgress(event) {
var loadPercent = 0.0;
var loadPercentString;
if (event.lengthComputable && event.total > 0) {
loadPercent = event.loaded / event.total * 100.0;
loadPercentString = loadPercent + '%';
} else {
// The total length is not yet known.
loadPercent = -1.0;
loadPercentString = 'Computing...';
}
//appendToEventLog('progress: ' + loadPercentString + ' (' + event.loaded + ' of ' + event.total + ' bytes)');
updateStatus("Loading module : "+ Math.floor(event.loaded / event.total * 100.0) + "% complete");
}
// Handler that gets called if an error occurred while loading the NaCl
// module. Note that the event does not carry any meaningful data about
// the error, you have to check lastError on the <EMBED> element to find
// out what happened.
function moduleLoadError() {
appendToEventLog('error: ' + loadProgressModule.lastError);
}
// Handler that gets called if the NaCl module load is aborted.
function moduleLoadAbort() {
appendToEventLog('abort');
}
// When the NaCl module has loaded indicate success.
function moduleDidLoad() {
loadProgressModule = document.getElementById('load_progress');
appendToEventLog('load');
updateStatus('SUCCESS');
}
function check_dl_status() {
var module = document.getElementById('load_progress');
module.postMessage("get_package_status");
module.postMessage(0);
};
// Handler that gets called when the NaCl module loading has completed.
// You will always get one of these events, regardless of whether the NaCl
// module loaded successfully or not. For example, if there is an error
// during load, you will get an 'error' event and a 'loadend' event. Note
// that if the NaCl module loads successfully, you will get both a 'load'
// event and a 'loadend' event.
function moduleDidEndLoad() {
appendToEventLog('loadend');
var lastError = event.target.lastError;
if (lastError == undefined || lastError.length == 0) {
lastError = '&lt;none&gt;';
window.setTimeout(check_dl_status, 1000);
}
appendToEventLog('lastError: ' + lastError);
}
// Handle a message coming from the NaCl module.
function handleMessage(message_event) {
var data = message_event.data;
if (data == "loaded") {
updateStatus("Data Loaded!");
} else if (data == "none") {
// nothing
updateStatus("Downloading package: connecting");
window.setTimeout(check_dl_status, 1000);
} else {
updateStatus("Downloading package: " + data + " bytes");
window.setTimeout(check_dl_status, 1000);
};
}
// Set the global status message. Updates the 'status_field' element with
// the new text.
// opt_message The message text. If this is null or undefined, then
// attempt to set the element with id 'status_field' to the value of
// |statusText|.
function updateStatus(opt_message) {
if (opt_message)
statusText = opt_message;
var statusField = document.getElementById('status_field');
if (statusField) {
statusField.innerHTML = statusText;
}
}
// Append an event name to the 'event_log_field' element. Event names
// are separated by a <br> tag so they get listed one per line.
// logMessage The message to append to the log.
function appendToEventLog(logMessage) {
var eventLogField = document.getElementById('event_log_field');
if (eventLogField.innerHTML.length == 0) {
eventLogField.innerHTML = logMessage;
} else {
eventLogField.innerHTML = eventLogField.innerHTML +
'<br />' +
logMessage;
}
}
</script>
</head>
<body bgcolor=#000000>
<font color=#FFFFFF>
<h1>Native Client Load Event Example</h1>
<h2>Status</h2>
<div id="status_field">NO-STATUS</div>
<div id="listener">
<script type="text/javascript">
var listener = document.getElementById('listener');
listener.addEventListener('loadstart', moduleDidStartLoad, true);
listener.addEventListener('progress', moduleLoadProgress, true);
listener.addEventListener('error', moduleLoadError, true);
listener.addEventListener('abort', moduleLoadAbort, true);
listener.addEventListener('load', moduleDidLoad, true);
listener.addEventListener('loadend', moduleDidEndLoad, true);
listener.addEventListener('message', handleMessage, true);
switch (browserSupportStatus) {
case browser_version.BrowserChecker.StatusValues.NACL_ENABLED:
appendToEventLog('Native Client plugin enabled.');
break;
case browser_version.BrowserChecker.StatusValues.UNKNOWN_BROWSER:
updateStatus('UNKNOWN BROWSER');
break;
case browser_version.BrowserChecker.StatusValues.CHROME_VERSION_TOO_OLD:
appendToEventLog(
'Chrome too old: You must use Chrome version 14 or later.');
updateStatus('NEED CHROME 14 OR LATER');
break;
case browser_version.BrowserChecker.StatusValues.NACL_NOT_ENABLED:
appendToEventLog(
'NaCl disabled: Native Client is not enabled.<br>' +
'Please go to <b>chrome://plugins</b> and enable Native Client ' +
'plugin.');
updateStatus('NaCl NOT ENABLED');
break;
case browser_version.BrowserChecker.StatusValues.NOT_USING_SERVER:
appendToEventLog(
'file: URL detected, please use a web server to host Native ' +
'Client applications.');
updateStatus('NaCl NOT ENABLED');
default:
appendToEventLog('Unknown error: Unable to detect browser and/or ' +
'Native Client support.');
updateStatus('UNKNOWN ERROR');
break;
}
</script>
<!-- Load the published .nexe. This includes the 'src' attribute which
shows how to load multi-architecture modules. Each entry in the "nexes"
object in the .nmf manifest file is a key-value pair: the key is the runtime
('x86-32', 'x86-64', etc.); the value is a URL for the desired NaCl module.
To load the debug versions of your .nexes, set the 'src' attribute to the
_dbg.nmf version of the manifest file.
Note: The <EMBED> element is wrapped inside a <DIV>, which has both a 'load'
and a 'message' event listener attached. This wrapping method is used
instead of attaching the event listeners directly to the <EMBED> element to
ensure that the listeners are active before the NaCl module 'load' event
fires. This also allows you to use PPB_Messaging.PostMessage() (in C) or
pp::Instance.PostMessage() (in C++) from within the initialization code in
your NaCl module.
-->
<embed name="nacl_module"
id="load_progress"
width=1024 height=600
src="godot_nacl.nmf"
type="application/x-nacl"
package="data.pcz"
arg1="-path" arg2="."
no_arg1="-test" no_arg2="gui" />
<script type="text/javascript">
loadProgressModule = document.getElementById('load_progress');
// Futher diagnose NaCl loading.
if (loadProgressModule == null ||
typeof loadProgressModule.readyState == 'undefined') {
switch (browserSupportStatus) {
case browser_version.BrowserChecker.StatusValues.NACL_ENABLED:
// The NaCl plugin is enabled and running, it's likely that the flag
// isn't set.
appendToEventLog(
'NaCl flag disabled: The Native Client flag is not enabled.<br>' +
'Please go to <b>chrome://flags</b> enable Native Client and ' +
'relaunch your browser. See also: ' +
'<a href="http://code.google.com/chrome/nativeclient/docs/' +
'running.html">Running Web Applications that Use Native Client' +
'</a>');
updateStatus('NaCl NOT ENABLED');
break;
case browser_version.BrowserChecker.StatusValues.UNKNOWN_BROWSER:
appendToEventLog('Native Client applications are not supported by ' +
'this browser.');
break;
default:
appendToEventLog('Unknown error when loading Native Client ' +
'application.');
}
}
</script>
</div>
<h2>Event Log</h2>
<div id="event_log_field">event log?</div>
</body>
</html>

19
platform/nacl/html/manifest.json
View File

@ -1,19 +0,0 @@
{
"name": "Capsuleman's Castle Adventure",
"description": "Capsuleman's Castle Adventure",
"version": "1",
"app": {
"launch": {
"local_path": "index.html"
}
},
"icons": {
"16": "icon_16.png",
"128": "icon_128.png"
},
"permissions": [
"unlimitedStorage",
"notifications",
"experimental"
]
}

BIN
platform/nacl/logo.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 2.6 KiB

422
platform/nacl/nacl_keycodes.h
View File

@ -1,422 +0,0 @@
/*************************************************************************/
/* nacl_keycodes.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 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. */
/*************************************************************************/
* Copyright (C) 2006 Michael Emmel mike.emmel@gmail.com. All rights reserved.
* Copyright (C) 2008, 2009 Google Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF USE, DATA, OR
* PROFITS, OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef BASE_KEYBOARD_CODES_POSIX_H_
#define BASE_KEYBOARD_CODES_POSIX_H_
#pragma once
#include "core/os/keyboard.h"
enum {
VKEY_BACK = 0x08,
VKEY_TAB = 0x09,
VKEY_CLEAR = 0x0C,
VKEY_RETURN = 0x0D,
VKEY_SHIFT = 0x10,
VKEY_CONTROL = 0x11,
VKEY_MENU = 0x12,
VKEY_PAUSE = 0x13,
VKEY_CAPITAL = 0x14,
VKEY_KANA = 0x15,
VKEY_HANGUL = 0x15,
VKEY_JUNJA = 0x17,
VKEY_FINAL = 0x18,
VKEY_HANJA = 0x19,
VKEY_KANJI = 0x19,
VKEY_ESCAPE = 0x1B,
VKEY_CONVERT = 0x1C,
VKEY_NONCONVERT = 0x1D,
VKEY_ACCEPT = 0x1E,
VKEY_MODECHANGE = 0x1F,
VKEY_SPACE = 0x20,
VKEY_PRIOR = 0x21,
VKEY_NEXT = 0x22,
VKEY_END = 0x23,
VKEY_HOME = 0x24,
VKEY_LEFT = 0x25,
VKEY_UP = 0x26,
VKEY_RIGHT = 0x27,
VKEY_DOWN = 0x28,
VKEY_SELECT = 0x29,
VKEY_PRINT = 0x2A,
VKEY_EXECUTE = 0x2B,
VKEY_SNAPSHOT = 0x2C,
VKEY_INSERT = 0x2D,
VKEY_DELETE = 0x2E,
VKEY_HELP = 0x2F,
VKEY_0 = 0x30,
VKEY_1 = 0x31,
VKEY_2 = 0x32,
VKEY_3 = 0x33,
VKEY_4 = 0x34,
VKEY_5 = 0x35,
VKEY_6 = 0x36,
VKEY_7 = 0x37,
VKEY_8 = 0x38,
VKEY_9 = 0x39,
VKEY_A = 0x41,
VKEY_B = 0x42,
VKEY_C = 0x43,
VKEY_D = 0x44,
VKEY_E = 0x45,
VKEY_F = 0x46,
VKEY_G = 0x47,
VKEY_H = 0x48,
VKEY_I = 0x49,
VKEY_J = 0x4A,
VKEY_K = 0x4B,
VKEY_L = 0x4C,
VKEY_M = 0x4D,
VKEY_N = 0x4E,
VKEY_O = 0x4F,
VKEY_P = 0x50,
VKEY_Q = 0x51,
VKEY_R = 0x52,
VKEY_S = 0x53,
VKEY_T = 0x54,
VKEY_U = 0x55,
VKEY_V = 0x56,
VKEY_W = 0x57,
VKEY_X = 0x58,
VKEY_Y = 0x59,
VKEY_Z = 0x5A,
VKEY_LWIN = 0x5B,
VKEY_COMMAND = VKEY_LWIN, // Provide the Mac name for convenience.
VKEY_RWIN = 0x5C,
VKEY_APPS = 0x5D,
VKEY_SLEEP = 0x5F,
VKEY_NUMPAD0 = 0x60,
VKEY_NUMPAD1 = 0x61,
VKEY_NUMPAD2 = 0x62,
VKEY_NUMPAD3 = 0x63,
VKEY_NUMPAD4 = 0x64,
VKEY_NUMPAD5 = 0x65,
VKEY_NUMPAD6 = 0x66,
VKEY_NUMPAD7 = 0x67,
VKEY_NUMPAD8 = 0x68,
VKEY_NUMPAD9 = 0x69,
VKEY_MULTIPLY = 0x6A,
VKEY_ADD = 0x6B,
VKEY_SEPARATOR = 0x6C,
VKEY_SUBTRACT = 0x6D,
VKEY_DECIMAL = 0x6E,
VKEY_DIVIDE = 0x6F,
VKEY_F1 = 0x70,
VKEY_F2 = 0x71,
VKEY_F3 = 0x72,
VKEY_F4 = 0x73,
VKEY_F5 = 0x74,
VKEY_F6 = 0x75,
VKEY_F7 = 0x76,
VKEY_F8 = 0x77,
VKEY_F9 = 0x78,
VKEY_F10 = 0x79,
VKEY_F11 = 0x7A,
VKEY_F12 = 0x7B,
VKEY_F13 = 0x7C,
VKEY_F14 = 0x7D,
VKEY_F15 = 0x7E,
VKEY_F16 = 0x7F,
VKEY_F17 = 0x80,
VKEY_F18 = 0x81,
VKEY_F19 = 0x82,
VKEY_F20 = 0x83,
VKEY_F21 = 0x84,
VKEY_F22 = 0x85,
VKEY_F23 = 0x86,
VKEY_F24 = 0x87,
VKEY_NUMLOCK = 0x90,
VKEY_SCROLL = 0x91,
VKEY_LSHIFT = 0xA0,
VKEY_RSHIFT = 0xA1,
VKEY_LCONTROL = 0xA2,
VKEY_RCONTROL = 0xA3,
VKEY_LMENU = 0xA4,
VKEY_RMENU = 0xA5,
VKEY_BROWSER_BACK = 0xA6,
VKEY_BROWSER_FORWARD = 0xA7,
VKEY_BROWSER_REFRESH = 0xA8,
VKEY_BROWSER_STOP = 0xA9,
VKEY_BROWSER_SEARCH = 0xAA,
VKEY_BROWSER_FAVORITES = 0xAB,
VKEY_BROWSER_HOME = 0xAC,
VKEY_VOLUME_MUTE = 0xAD,
VKEY_VOLUME_DOWN = 0xAE,
VKEY_VOLUME_UP = 0xAF,
VKEY_MEDIA_NEXT_TRACK = 0xB0,
VKEY_MEDIA_PREV_TRACK = 0xB1,
VKEY_MEDIA_STOP = 0xB2,
VKEY_MEDIA_PLAY_PAUSE = 0xB3,
VKEY_MEDIA_LAUNCH_MAIL = 0xB4,
VKEY_MEDIA_LAUNCH_MEDIA_SELECT = 0xB5,
VKEY_MEDIA_LAUNCH_APP1 = 0xB6,
VKEY_MEDIA_LAUNCH_APP2 = 0xB7,
VKEY_OEM_1 = 0xBA,
VKEY_OEM_PLUS = 0xBB,
VKEY_OEM_COMMA = 0xBC,
VKEY_OEM_MINUS = 0xBD,
VKEY_OEM_PERIOD = 0xBE,
VKEY_OEM_2 = 0xBF,
VKEY_OEM_3 = 0xC0,
VKEY_OEM_4 = 0xDB,
VKEY_OEM_5 = 0xDC,
VKEY_OEM_6 = 0xDD,
VKEY_OEM_7 = 0xDE,
VKEY_OEM_8 = 0xDF,
VKEY_OEM_102 = 0xE2,
VKEY_PROCESSKEY = 0xE5,
VKEY_PACKET = 0xE7,
VKEY_ATTN = 0xF6,
VKEY_CRSEL = 0xF7,
VKEY_EXSEL = 0xF8,
VKEY_EREOF = 0xF9,
VKEY_PLAY = 0xFA,
VKEY_ZOOM = 0xFB,
VKEY_NONAME = 0xFC,
VKEY_PA1 = 0xFD,
VKEY_OEM_CLEAR = 0xFE,
VKEY_UNKNOWN = 0
};
static uint32_t godot_key(uint32_t p_key, bool& is_char) {
is_char = false;
switch (p_key) {
case VKEY_BACK: return KEY_BACKSPACE;
case VKEY_TAB: return KEY_TAB;
case VKEY_CLEAR: return KEY_CLEAR;
case VKEY_RETURN: return KEY_RETURN;
case VKEY_SHIFT: return KEY_SHIFT;
case VKEY_CONTROL: return KEY_CONTROL;
case VKEY_MENU: return KEY_MENU;
case VKEY_PAUSE: return KEY_PAUSE;
// case VKEY_CAPITAL: return KEY_CAPITAL;
// case VKEY_KANA: return KEY_KANA;
// case VKEY_HANGUL: return KEY_HANGUL;
// case VKEY_JUNJA: return KEY_JUNJA;
// case VKEY_FINAL: return KEY_FINAL;
// case VKEY_HANJA: return KEY_HANJA;
// case VKEY_KANJI: return KEY_KANJI;
case VKEY_ESCAPE: return KEY_ESCAPE;
// case VKEY_CONVERT: return KEY_CONVERT;
// case VKEY_NONCONVERT: return KEY_NONCONVERT;
// case VKEY_ACCEPT: return KEY_ACCEPT;
// case VKEY_MODECHANGE: return KEY_MODECHANGE;
// case VKEY_PRIOR: return KEY_PRIOR;
// case VKEY_NEXT: return KEY_NEXT;
case VKEY_END: return KEY_END;
case VKEY_HOME: return KEY_HOME;
case VKEY_LEFT: return KEY_LEFT;
case VKEY_UP: return KEY_UP;
case VKEY_RIGHT: return KEY_RIGHT;
case VKEY_DOWN: return KEY_DOWN;
// case VKEY_SELECT: return KEY_SELECT;
case VKEY_PRINT: return KEY_PRINT;
// case VKEY_EXECUTE: return KEY_EXECUTE;
// case VKEY_SNAPSHOT: return KEY_SNAPSHOT;
case VKEY_INSERT: return KEY_INSERT;
case VKEY_DELETE: return KEY_DELETE;
case VKEY_HELP: return KEY_HELP;
// case VKEY_LWIN: return KEY_LWIN;
// case VKEY_RWIN: return KEY_RWIN;
// case VKEY_APPS: return KEY_APPS;
// case VKEY_SLEEP: return KEY_SLEEP;
case VKEY_NUMPAD0: return KEY_KP_0;
case VKEY_NUMPAD1: return KEY_KP_1;
case VKEY_NUMPAD2: return KEY_KP_2;
case VKEY_NUMPAD3: return KEY_KP_3;
case VKEY_NUMPAD4: return KEY_KP_4;
case VKEY_NUMPAD5: return KEY_KP_5;
case VKEY_NUMPAD6: return KEY_KP_6;
case VKEY_NUMPAD7: return KEY_KP_7;
case VKEY_NUMPAD8: return KEY_KP_8;
case VKEY_NUMPAD9: return KEY_KP_9;
case VKEY_MULTIPLY: return KEY_KP_MULTIPLY;
case VKEY_ADD: return KEY_KP_ADD;
// case VKEY_SEPARATOR: return KEY_SEPARATOR;
case VKEY_SUBTRACT: return KEY_KP_SUBTRACT;
case VKEY_DECIMAL: return KEY_KP_PERIOD;
case VKEY_DIVIDE: return KEY_KP_DIVIDE;
case VKEY_F1: return KEY_F1;
case VKEY_F2: return KEY_F2;
case VKEY_F3: return KEY_F3;
case VKEY_F4: return KEY_F4;
case VKEY_F5: return KEY_F5;
case VKEY_F6: return KEY_F6;
case VKEY_F7: return KEY_F7;
case VKEY_F8: return KEY_F8;
case VKEY_F9: return KEY_F9;
case VKEY_F10: return KEY_F10;
case VKEY_F11: return KEY_F11;
case VKEY_F12: return KEY_F12;
case VKEY_F13: return KEY_F13;
case VKEY_F14: return KEY_F14;
case VKEY_F15: return KEY_F15;
case VKEY_F16: return KEY_F16;
/*
case VKEY_F17: return KEY_F17;
case VKEY_F18: return KEY_F18;
case VKEY_F19: return KEY_F19;
case VKEY_F20: return KEY_F20;
case VKEY_F21: return KEY_F21;
case VKEY_F22: return KEY_F22;
case VKEY_F23: return KEY_F23;
case VKEY_F24: return KEY_F24;
*/
case VKEY_NUMLOCK: return KEY_NUMLOCK;
case VKEY_SCROLL: return KEY_SCROLLLOCK;
case VKEY_LSHIFT: return KEY_SHIFT;
case VKEY_RSHIFT: return KEY_SHIFT;
case VKEY_LCONTROL: return KEY_CONTROL;
case VKEY_RCONTROL: return KEY_CONTROL;
case VKEY_LMENU: return KEY_MENU;
case VKEY_RMENU: return KEY_MENU;
case VKEY_BROWSER_BACK: return KEY_BACK;
case VKEY_BROWSER_FORWARD: return KEY_FORWARD;
case VKEY_BROWSER_REFRESH: return KEY_REFRESH;
case VKEY_BROWSER_STOP: return KEY_STOP;
case VKEY_BROWSER_SEARCH: return KEY_SEARCH;
case VKEY_BROWSER_FAVORITES: return KEY_FAVORITES;
case VKEY_BROWSER_HOME: return KEY_HOMEPAGE;
case VKEY_VOLUME_MUTE: return KEY_VOLUMEMUTE;
case VKEY_VOLUME_DOWN: return KEY_VOLUMEDOWN;
case VKEY_VOLUME_UP: return KEY_VOLUMEUP;
case VKEY_MEDIA_NEXT_TRACK: return KEY_MEDIANEXT;
case VKEY_MEDIA_PREV_TRACK: return KEY_MEDIAPREVIOUS;
case VKEY_MEDIA_STOP: return KEY_MEDIASTOP;
case VKEY_MEDIA_PLAY_PAUSE: return KEY_MEDIAPLAY;
case VKEY_MEDIA_LAUNCH_MAIL: return KEY_LAUNCHMAIL;
case VKEY_MEDIA_LAUNCH_MEDIA_SELECT: return KEY_LAUNCHMEDIA; // FUCKING USELESS KEYS, HOW DO THEY WORK?
case VKEY_MEDIA_LAUNCH_APP1: return KEY_LAUNCH0;
case VKEY_MEDIA_LAUNCH_APP2: return KEY_LAUNCH0;
// case VKEY_OEM_102: return KEY_OEM_102;
// case VKEY_PROCESSKEY: return KEY_PROCESSKEY;
// case VKEY_PACKET: return KEY_PACKET;
// case VKEY_ATTN: return KEY_ATTN;
// case VKEY_CRSEL: return KEY_CRSEL;
// case VKEY_EXSEL: return KEY_EXSEL;
// case VKEY_EREOF: return KEY_EREOF;
// case VKEY_PLAY: return KEY_PLAY;
// case VKEY_ZOOM: return KEY_ZOOM;
// case VKEY_NONAME: return KEY_NONAME;
// case VKEY_PA1: return KEY_PA1;
// case VKEY_OEM_CLEAR: return KEY_OEM_CLEAR;
default: break;
};
is_char = true;
switch (p_key) {
case VKEY_SPACE: return KEY_SPACE;
case VKEY_0: return KEY_0;
case VKEY_1: return KEY_1;
case VKEY_2: return KEY_2;
case VKEY_3: return KEY_3;
case VKEY_4: return KEY_4;
case VKEY_5: return KEY_5;
case VKEY_6: return KEY_6;
case VKEY_7: return KEY_7;
case VKEY_8: return KEY_8;
case VKEY_9: return KEY_9;
case VKEY_A: return KEY_A;
case VKEY_B: return KEY_B;
case VKEY_C: return KEY_C;
case VKEY_D: return KEY_D;
case VKEY_E: return KEY_E;
case VKEY_F: return KEY_F;
case VKEY_G: return KEY_G;
case VKEY_H: return KEY_H;
case VKEY_I: return KEY_I;
case VKEY_J: return KEY_J;
case VKEY_K: return KEY_K;
case VKEY_L: return KEY_L;
case VKEY_M: return KEY_M;
case VKEY_N: return KEY_N;
case VKEY_O: return KEY_O;
case VKEY_P: return KEY_P;
case VKEY_Q: return KEY_Q;
case VKEY_R: return KEY_R;
case VKEY_S: return KEY_S;
case VKEY_T: return KEY_T;
case VKEY_U: return KEY_U;
case VKEY_V: return KEY_V;
case VKEY_W: return KEY_W;
case VKEY_X: return KEY_X;
case VKEY_Y: return KEY_Y;
case VKEY_Z: return KEY_Z;
/*
case VKEY_OEM_PLUS: return KEY_PLUS;
case VKEY_OEM_COMMA: return KEY_COMMA;
case VKEY_OEM_MINUS: return KEY_MINUS;
case VKEY_OEM_PERIOD: return KEY_PERIOD;
case VKEY_OEM_1: return KEY_OEM_1;
case VKEY_OEM_2: return KEY_OEM_2;
case VKEY_OEM_3: return KEY_OEM_3;
case VKEY_OEM_4: return KEY_OEM_4;
case VKEY_OEM_5: return KEY_OEM_5;
case VKEY_OEM_6: return KEY_OEM_6;
case VKEY_OEM_7: return KEY_OEM_7;
case VKEY_OEM_8: return KEY_OEM_8;
*/
default: break;
};
return 0;
};
#endif // BASE_KEYBOARD_CODES_POSIX_H_

123
platform/nacl/opengl_context.cpp
View File

@ -1,123 +0,0 @@
/*************************************************************************/
/* opengl_context.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 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 <pthread.h>
#include "ppapi/gles2/gl2ext_ppapi.h"
#include "os_nacl.h"
#include "ppapi/cpp/instance.h"
#include "ppapi/cpp/module.h"
#include "ppapi/cpp/completion_callback.h"
#include "ppapi/utility/completion_callback_factory.h"
namespace {
// This is called by the brower when the 3D context has been flushed to the
// browser window.
void FlushCallback(void* data, int32_t result) {
static_cast<OpenGLContext*>(data)->set_flush_pending(false);
static_cast<OpenGLContext*>(data)->FlushContext();
}
} // namespace
OpenGLContext::OpenGLContext(pp::Instance* p_instance)
: pp::Graphics3DClient(p_instance),
flush_pending_(false) {
instance = p_instance;
pp::Module* module = pp::Module::Get();
assert(module);
gles2_interface_ = static_cast<const struct PPB_OpenGLES2_Dev*>(
module->GetBrowserInterface(PPB_OPENGLES2_INTERFACE));
assert(gles2_interface_);
}
OpenGLContext::~OpenGLContext() {
glSetCurrentContextPPAPI(0);
}
bool OpenGLContext::MakeContextCurrent(pp::Instance* instance) {
if (instance == NULL) {
glSetCurrentContextPPAPI(0);
return false;
}
// Lazily create the Pepper context.
if (context_.is_null()) {
int32_t attribs[] = {
PP_GRAPHICS3DATTRIB_ALPHA_SIZE, 8,
PP_GRAPHICS3DATTRIB_DEPTH_SIZE, 24,
PP_GRAPHICS3DATTRIB_STENCIL_SIZE, 8,
PP_GRAPHICS3DATTRIB_SAMPLES, 0,
PP_GRAPHICS3DATTRIB_SAMPLE_BUFFERS, 0,
PP_GRAPHICS3DATTRIB_WIDTH, width,
PP_GRAPHICS3DATTRIB_HEIGHT, height,
PP_GRAPHICS3DATTRIB_NONE
};
context_ = pp::Graphics3D(instance, pp::Graphics3D(), attribs);
if (context_.is_null()) {
glSetCurrentContextPPAPI(0);
return false;
}
instance->BindGraphics(context_);
}
glSetCurrentContextPPAPI(context_.pp_resource());
return true;
}
void OpenGLContext::ResizeContext(const pp::Size& size) {
width = size.width();
height = size.height();
if (!context_.is_null()) {
context_.ResizeBuffers(size.width(), size.height());
}
}
void OpenGLContext::InvalidateContext(pp::Instance* instance) {
glSetCurrentContextPPAPI(0);
}
void OpenGLContext::FlushContext() {
if (flush_pending()) {
// A flush is pending so do nothing; just drop this flush on the floor.
return;
}
set_flush_pending(true);
OSNacl* os = (OSNacl*)OS::get_singleton();
MakeContextCurrent(instance);
os->iterate();
context_.SwapBuffers(pp::CompletionCallback(&FlushCallback, this));
}

124
platform/nacl/opengl_context.h
View File

@ -1,124 +0,0 @@
/*************************************************************************/
/* opengl_context.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 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. */
/*************************************************************************/
#ifndef EXAMPLES_TUMBLER_OPENGL_CONTEXT_H_
#define EXAMPLES_TUMBLER_OPENGL_CONTEXT_H_
///
/// @file
/// OpenGLContext manages the OpenGL context in the browser that is associated
/// with a @a pp::Instance instance.
///
#include <pthread.h>
#include <algorithm>
#include <string>
#include "ppapi/c/ppb_opengles2.h"
//#include "ppapi/cpp/dev/context_3d_dev.h"
#include "ppapi/cpp/graphics_3d_client.h"
#include "ppapi/cpp/graphics_3d.h"
//#include "ppapi/cpp/dev/surface_3d_dev.h"
#include "ppapi/cpp/instance.h"
#include "ppapi/cpp/size.h"
// A convenience wrapper for a shared OpenGLContext pointer type. As other
// smart pointer types are needed, add them here.
#include <tr1/memory>
class OpenGLContext;
typedef std::tr1::shared_ptr<OpenGLContext> SharedOpenGLContext;
/// OpenGLContext manages an OpenGL rendering context in the browser.
///
class OpenGLContext : public pp::Graphics3DClient {
public:
explicit OpenGLContext(pp::Instance* instance);
/// Release all the in-browser resources used by this context, and make this
/// context invalid.
virtual ~OpenGLContext();
/// The Graphics3DClient interfcace.
virtual void Graphics3DContextLost() {
assert(!"Unexpectedly lost graphics context");
}
/// Make @a this the current 3D context in @a instance.
/// @param instance The instance of the NaCl module that will receive the
/// the current 3D context.
/// @return success.
bool MakeContextCurrent(pp::Instance* instance);
/// Flush the contents of this context to the browser's 3D device.
void FlushContext();
/// Make the underlying 3D device invalid, so that any subsequent rendering
/// commands will have no effect. The next call to MakeContextCurrent() will
/// cause the underlying 3D device to get rebound and start receiving
/// receiving rendering commands again. Use InvalidateContext(), for
/// example, when resizing the context's viewing area.
void InvalidateContext(pp::Instance* instance);
void ResizeContext(const pp::Size& size);
/// The OpenGL ES 2.0 interface.
const struct PPB_OpenGLES2_Dev* gles2() const {
return gles2_interface_;
}
/// The PP_Resource needed to make GLES2 calls through the Pepper interface.
const PP_Resource gl_context() const {
return context_.pp_resource();
}
/// Indicate whether a flush is pending. This can only be called from the
/// main thread; it is not thread safe.
bool flush_pending() const {
return flush_pending_;
}
void set_flush_pending(bool flag) {
flush_pending_ = flag;
}
private:
pp::Graphics3D context_;
bool flush_pending_;
int width, height;
pp::Instance* instance;
const struct PPB_OpenGLES2_Dev* gles2_interface_;
};
#endif // EXAMPLES_TUMBLER_OPENGL_CONTEXT_H_

566
platform/nacl/os_nacl.cpp
View File

@ -1,566 +0,0 @@
/*************************************************************************/
/* os_nacl.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 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 "os_nacl.h"
#include "drivers/unix/memory_pool_static_malloc.h"
#include "os/memory_pool_dynamic_static.h"
#include "main/main.h"
#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>
#include <time.h>
#include "io/file_access_memory.h"
#include "core/io/file_access_pack.h"
#include "scene/io/scene_loader.h"
#include "scene/main/scene_main_loop.h"
#include "servers/visual/visual_server_raster.h"
#include "drivers/gles2/rasterizer_gles2.h"
#include "nacl_keycodes.h"
#include "core/globals.h"
#include "core/input_map.h"
#include <ppapi/cpp/point.h>
#include <ppapi/cpp/var.h>
#define UNIX_ENABLED
#include "drivers/unix/thread_posix.h"
#include "drivers/unix/semaphore_posix.h"
#include "drivers/unix/mutex_posix.h"
int OSNacl::get_video_driver_count() const {
return 1;
};
const char * OSNacl::get_video_driver_name(int p_driver) const {
return "GLES2";
};
OS::VideoMode OSNacl::get_default_video_mode() const {
return OS::VideoMode(800,600,false);
};
int OSNacl::get_audio_driver_count() const {
return 1;
};
const char * OSNacl::get_audio_driver_name(int p_driver) const {
return "nacl_audio";
};
static MemoryPoolStaticMalloc *mempool_static=NULL;
static MemoryPoolDynamicStatic *mempool_dynamic=NULL;
void OSNacl::initialize_core() {
ticks_start=0;
ticks_start=get_ticks_usec();
};
void OSNacl::initialize(const VideoMode& p_desired,int p_video_driver,int p_audio_driver) {
rasterizer = memnew( RasterizerGLES2 );
visual_server = memnew( VisualServerRaster(rasterizer) );
visual_server->init();
visual_server->cursor_set_visible(false, 0);
audio_driver = memnew(AudioDriverNacl);
audio_driver->set_singleton();
audio_driver->init();
sample_manager = memnew( SampleManagerMallocSW );
audio_server = memnew( AudioServerSW(sample_manager) );
audio_server->set_mixer_params(AudioMixerSW::INTERPOLATION_LINEAR,false);
audio_server->init();
spatial_sound_server = memnew( SpatialSoundServerSW );
spatial_sound_server->init();
spatial_sound_2d_server = memnew( SpatialSound2DServerSW );
spatial_sound_2d_server->init();
//
physics_server = memnew( PhysicsServerSW );
physics_server->init();
physics_2d_server = memnew( Physics2DServerSW );
physics_2d_server->init();
input = memnew(InputDefault);
};
void OSNacl::set_main_loop( MainLoop * p_main_loop ) {
main_loop = p_main_loop;
input->set_main_loop(p_main_loop);
main_loop->init();
};
void OSNacl::delete_main_loop() {
if (main_loop)
memdelete(main_loop);
};
void OSNacl::finalize() {
};
void OSNacl::finalize_core() {
if (mempool_dynamic)
memdelete( mempool_dynamic );
delete mempool_static;
};
void OSNacl::alert(const String& p_alert,const String& p_title) {
fprintf(stderr,"ERROR: %s\n",p_alert.utf8().get_data());
};
void OSNacl::vprint(const char* p_format, va_list p_list, bool p_strerr) {
vprintf(p_format,p_list);
fflush(stdout);
}
String OSNacl::get_stdin_string(bool p_block) {
char buff[1024];
return fgets(buff,1024,stdin);
};
void OSNacl::set_mouse_show(bool p_show) {
};
void OSNacl::set_mouse_grab(bool p_grab) {
};
bool OSNacl::is_mouse_grab_enabled() const {
return false;
};
int OSNacl::get_mouse_button_state() const {
return mouse_mask;
};
Point2 OSNacl::get_mouse_pos() const {
return Point2();
};
void OSNacl::set_window_title(const String& p_title) {
};
void OSNacl::set_video_mode(const VideoMode& p_video_mode, int p_screen) {
video_mode = p_video_mode;
};
OS::VideoMode OSNacl::get_video_mode(int p_screen) const {
return video_mode;
};
void OSNacl::get_fullscreen_mode_list(List<VideoMode> *p_list,int p_screen) const {
};
Error OSNacl::execute(const String& p_path, const List<String>& p_arguments,bool p_blocking, OS::ProcessID *r_child_id, String* r_pipe, int *r_exitcode) {
return ERR_UNAVAILABLE;
};
Error OSNacl::kill(const ProcessID& p_pid) {
return ERR_UNAVAILABLE;
};
bool OSNacl::has_environment(const String& p_var) const {
return getenv(p_var.utf8().get_data())!=NULL;
};
String OSNacl::get_environment(const String& p_var) const {
if (getenv(p_var.utf8().get_data()))
return getenv(p_var.utf8().get_data());
return "";
};
String OSNacl::get_name() {
return "NaCl";
};
MainLoop *OSNacl::get_main_loop() const {
return main_loop;
};
OS::Date OSNacl::get_date(bool utc) const {
time_t t=time(NULL);
struct tm *lt;
if (utc)
lt=gmtime(&t);
else
lt=localtime(&t);
Date ret;
ret.year=lt->tm_year;
// Index starting at 1 to match OS_Unix::get_date
// and Windows SYSTEMTIME and tm_mon follows the typical structure
// of 0-11, noted here: http://www.cplusplus.com/reference/ctime/tm/
ret.month=(Month)(lt->tm_mon+1);
ret.day=lt->tm_mday;
ret.weekday=(Weekday)lt->tm_wday;
ret.dst=lt->tm_isdst;
return ret;
};
OS::Time OSNacl::get_time(bool utc) const {
time_t t=time(NULL);
struct tm *lt;
if (utc)
lt=gmtime(&t);
else
lt=localtime(&t);
Time ret;
ret.hour=lt->tm_hour;
ret.min=lt->tm_min;
ret.sec=lt->tm_sec;
return ret;
};
OS::TimeZoneInfo OS_Unix::get_time_zone_info() const {
time_t t = time(NULL);
struct tm *lt = localtime(&t);
char name[16];
strftime(name, 16, "%Z", lt);
name[15] = 0;
TimeZoneInfo ret;
ret.name = name;
char bias_buf[16];
strftime(bias_buf, 16, "%z", lt);
int bias;
bias_buf[15] = 0;
sscanf(bias_buf, "%d", &bias);
// convert from ISO 8601 (1 minute=1, 1 hour=100) to minutes
int hour = (int)bias / 100;
int minutes = bias % 100;
if (bias < 0)
ret.bias = hour * 60 - minutes;
else
ret.bias = hour * 60 + minutes;
return ret;
};
void OSNacl::delay_usec(uint32_t p_usec) const {
//usleep(p_usec);
};
uint64_t OSNacl::get_ticks_usec() const {
struct timeval tv_now;
gettimeofday(&tv_now,NULL);
uint64_t longtime = (uint64_t)tv_now.tv_usec + (uint64_t)tv_now.tv_sec*1000000L;
longtime-=ticks_start;
return longtime;
};
bool OSNacl::can_draw() const {
return minimized != true;
};
void OSNacl::queue_event(const InputEvent& p_event) {
ERR_FAIL_INDEX( event_count, MAX_EVENTS );
event_queue[event_count++] = p_event;
};
void OSNacl::add_package(String p_name, Vector<uint8_t> p_data) {
FileAccessMemory::register_file(p_name, p_data);
FileAccess::make_default<FileAccessMemory>(FileAccess::ACCESS_RESOURCES);
FileAccess::make_default<FileAccessMemory>(FileAccess::ACCESS_USERDATA);
FileAccess::make_default<FileAccessMemory>(FileAccess::ACCESS_FILESYSTEM);
if (!PackedData::get_singleton())
memnew(PackedData);
printf("adding package %ls, %x\n", p_name.c_str(), PackedData::get_singleton());
PackedData::get_singleton()->set_disabled(true);
PackedData::get_singleton()->add_pack(p_name);
PackedData::get_singleton()->set_disabled(false);
printf("added\n");
};
void OSNacl::set_cursor_shape(CursorShape p_shape) {
};
String OSNacl::get_resource_dir() const {
return ".";
};
static int mouse_button(int p_nacl_but) {
switch (p_nacl_but) {
case PP_INPUTEVENT_MOUSEBUTTON_LEFT:
return BUTTON_LEFT;
case PP_INPUTEVENT_MOUSEBUTTON_MIDDLE:
return BUTTON_MIDDLE;
case PP_INPUTEVENT_MOUSEBUTTON_RIGHT:
return BUTTON_RIGHT;
};
return 0;
};
static InputModifierState modifier(uint32_t p_mod) {
InputModifierState mod_mask;
mod_mask.shift = p_mod & PP_INPUTEVENT_MODIFIER_SHIFTKEY;
mod_mask.alt = p_mod & PP_INPUTEVENT_MODIFIER_ALTKEY;
mod_mask.control = p_mod & PP_INPUTEVENT_MODIFIER_CONTROLKEY;
mod_mask.meta = p_mod & PP_INPUTEVENT_MODIFIER_METAKEY;
return mod_mask;
};
void OSNacl::handle_event(const pp::InputEvent& p_event) {
int type = p_event.GetType();
switch (type) {
case PP_INPUTEVENT_TYPE_MOUSEDOWN:
case PP_INPUTEVENT_TYPE_MOUSEUP:
case PP_INPUTEVENT_TYPE_WHEEL: {
InputEvent event;
event.ID=++event_id;
event.type = InputEvent::MOUSE_BUTTON;
event.device=0;
pp::MouseInputEvent mevent(p_event);
if (type == PP_INPUTEVENT_TYPE_WHEEL) {
pp::WheelInputEvent wevent(p_event);;
float ticks = wevent.GetTicks().y();
if (ticks == 0)
break; // whut?
event.mouse_button.pressed = true;
event.mouse_button.button_index = ticks > 0 ? BUTTON_WHEEL_UP : BUTTON_WHEEL_DOWN;
event.mouse_button.doubleclick = false;
} else {
event.mouse_button.pressed = (type == PP_INPUTEVENT_TYPE_MOUSEDOWN);
event.mouse_button.button_index = mouse_button(mevent.GetButton());
event.mouse_button.doubleclick = (mevent.GetClickCount() % 2) == 0;
mouse_mask &= ~(1<< (event.mouse_button.button_index - 1));
mouse_mask |= (event.mouse_button.pressed << (event.mouse_button.button_index - 1));
};
pp::Point pos = mevent.GetPosition();
event.mouse_button.button_mask = mouse_mask;
event.mouse_button.global_x = pos.x();
event.mouse_button.x = pos.x();
event.mouse_button.global_y = pos.y();
event.mouse_button.y = pos.y();
event.mouse_button.pointer_index = 0;
event.mouse_button.mod = modifier(p_event.GetModifiers());
queue_event(event);
} break;
case PP_INPUTEVENT_TYPE_MOUSEMOVE: {
pp::MouseInputEvent mevent(p_event);
pp::Point pos = mevent.GetPosition();
InputEvent event;
event.ID=++event_id;
event.type = InputEvent::MOUSE_MOTION;
event.mouse_motion.pointer_index = 0;
event.mouse_motion.global_x = pos.x();
event.mouse_motion.global_y = pos.y();
event.mouse_motion.x = pos.x();
event.mouse_motion.y = pos.y();
event.mouse_motion.button_mask = mouse_mask;
event.mouse_motion.mod = modifier(p_event.GetModifiers());
event.mouse_motion.relative_x = pos.x() - mouse_last_x;
event.mouse_motion.relative_y = pos.y() - mouse_last_y;
mouse_last_x = pos.x();
mouse_last_y = pos.y();
queue_event(event);
} break;
case PP_INPUTEVENT_TYPE_RAWKEYDOWN:
case PP_INPUTEVENT_TYPE_KEYDOWN:
case PP_INPUTEVENT_TYPE_KEYUP: {
pp::KeyboardInputEvent kevent(p_event);
bool is_char;
uint32_t key = godot_key(kevent.GetKeyCode(), is_char);
if (type != PP_INPUTEVENT_TYPE_KEYUP && is_char) {
last_scancode = key;
break;
};
InputEvent event;
event.ID=++event_id;
event.type = InputEvent::KEY;
event.key.pressed = (type != PP_INPUTEVENT_TYPE_KEYUP);
event.key.scancode = key;
event.key.unicode = key;
event.key.echo = p_event.GetModifiers() & PP_INPUTEVENT_MODIFIER_ISAUTOREPEAT;
event.key.mod = modifier(p_event.GetModifiers());
queue_event(event);
} break;
case PP_INPUTEVENT_TYPE_CHAR: {
pp::KeyboardInputEvent kevent(p_event);
InputEvent event;
event.ID = ++event_id;
event.type = InputEvent::KEY;
event.key.pressed = true;
event.key.scancode = last_scancode;
event.key.unicode = kevent.GetCharacterText().AsString().c_str()[0];
event.key.mod = modifier(p_event.GetModifiers());
event.key.echo = p_event.GetModifiers() & PP_INPUTEVENT_MODIFIER_ISAUTOREPEAT;
queue_event(event);
} break;
/*
case NPEventType_Minimize: {
minimized = p_event->u.minimize.value == 1;
} break;
case NPEventType_Focus: {
if (p_event->u.focus.value == 1) {
main_loop->notification(MainLoop::NOTIFICATION_WM_FOCUS_IN);
} else {
main_loop->notification(MainLoop::NOTIFICATION_WM_FOCUS_OUT);
};
} break;
*/
default:
;
};
};
bool OSNacl::iterate() {
if (!main_loop) {
event_count = 0;
return true;
};
for (int i=0; i<event_count; i++) {
input->parse_input_event(event_queue[i]);
};
event_count = 0;
return Main::iteration();
};
OSNacl::OSNacl() {
main_loop=NULL;
mempool_dynamic = NULL;
mempool_static = NULL;
mouse_last_x = 0;
mouse_last_y = 0;
event_count = 0;
event_id = 0;
mouse_mask = 0;
video_mode = get_default_video_mode();
last_scancode = 0;
minimized = false;
ThreadPosix::make_default();
SemaphorePosix::make_default();
MutexPosix::make_default();
mempool_static = new MemoryPoolStaticMalloc;
mempool_dynamic = memnew( MemoryPoolDynamicStatic );
};
OSNacl::~OSNacl() {
};

156
platform/nacl/os_nacl.h
View File

@ -1,156 +0,0 @@
/*************************************************************************/
/* os_nacl.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 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. */
/*************************************************************************/
#ifndef OS_NACL_H
#define OS_NACL_H
#include "core/os/os.h"
#include "servers/visual_server.h"
#include "servers/visual/rasterizer.h"
#include "servers/physics/physics_server_sw.h"
#include "servers/spatial_sound/spatial_sound_server_sw.h"
#include "servers/spatial_sound_2d/spatial_sound_2d_server_sw.h"
#include "servers/audio/audio_server_sw.h"
#include "servers/physics_2d/physics_2d_server_sw.h"
#include "audio_driver_nacl.h"
#include "os/input.h"
#include <ppapi/cpp/input_event.h>
class OSNacl : OS {
uint64_t ticks_start;
protected:
enum {
MAX_EVENTS = 64,
};
MainLoop *main_loop;
Rasterizer *rasterizer;
VisualServer *visual_server;
PhysicsServer *physics_server;
SpatialSoundServerSW *spatial_sound_server;
AudioServerSW *audio_server;
SampleManagerMallocSW *sample_manager;
SpatialSound2DServerSW *spatial_sound_2d_server;
Physics2DServer *physics_2d_server;
AudioDriverNacl* audio_driver;
// functions used by main to initialize/deintialize the OS
virtual int get_video_driver_count() const;
virtual const char * get_video_driver_name(int p_driver) const;
virtual VideoMode get_default_video_mode() const;
virtual int get_audio_driver_count() const;
virtual const char * get_audio_driver_name(int p_driver) const;
void vprint(const char* p_format, va_list p_list, bool p_stderr);
virtual void initialize_core();
virtual void initialize(const VideoMode& p_desired,int p_video_driver,int p_audio_driver);
virtual void set_main_loop( MainLoop * p_main_loop );
virtual void delete_main_loop();
virtual void finalize();
virtual void finalize_core();
int mouse_last_x, mouse_last_y;
InputEvent event_queue[MAX_EVENTS];
int event_count;
void queue_event(const InputEvent& p_event);
int event_id;
uint32_t mouse_mask;
uint32_t last_scancode;
bool minimized;
VideoMode video_mode;
InputDefault *input;
public:
void add_package(String p_name, Vector<uint8_t> p_data);
void handle_event(const pp::InputEvent& p_event);
virtual void alert(const String& p_alert,const String& p_title);
virtual String get_stdin_string(bool p_block);
virtual void set_mouse_show(bool p_show);
virtual void set_mouse_grab(bool p_grab);
virtual bool is_mouse_grab_enabled() const;
virtual Point2 get_mouse_pos() const;
virtual int get_mouse_button_state() const;
virtual void set_window_title(const String& p_title);
virtual void set_video_mode(const VideoMode& p_video_mode,int p_screen);
virtual VideoMode get_video_mode(int p_screen) const;
virtual void get_fullscreen_mode_list(List<VideoMode> *p_list,int p_screen) const;
virtual Error execute(const String& p_path, const List<String>& p_arguments,bool p_blocking,ProcessID *r_child_id=NULL,String* r_pipe=NULL,int *r_exitcode=NULL);
virtual Error kill(const ProcessID& p_pid);
virtual bool has_environment(const String& p_var) const;
virtual String get_environment(const String& p_var) const;
virtual void set_cursor_shape(CursorShape p_shape);
virtual String get_name();
virtual MainLoop *get_main_loop() const;
virtual Date get_date(bool utc) const;
virtual Time get_time(bool utc) const;
virtual void delay_usec(uint32_t p_usec) const;
virtual uint64_t get_ticks_usec() const;
virtual String get_resource_dir() const;
virtual bool can_draw() const;
bool iterate();
OSNacl();
~OSNacl();
};
#endif // OS_NACL_H

541
platform/nacl/pepper_main.cpp
View File

@ -1,541 +0,0 @@
/*************************************************************************/
/* pepper_main.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 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. */
/*************************************************************************/
IMPORTANT: This Apple software is supplied to you by Apple Computer, Inc.
("Apple") in consideration of your agreement to the following terms, and
your use, installation, modification or redistribution of this Apple software
constitutes acceptance of these terms. If you do not agree with these terms,
please do not use, install, modify or redistribute this Apple software.
In consideration of your agreement to abide by the following terms, and
subject to these terms, Apple grants you a personal, non-exclusive license,
under Apple's copyrights in this original Apple software
(the "Apple Software"), to use, reproduce, modify and redistribute the Apple
Software, with or without modifications, in source and/or binary forms;
provided that if you redistribute the Apple Software in its entirety and
without modifications, you must retain this notice and the following text and
disclaimers in all such redistributions of the Apple Software. Neither the
name, trademarks, service marks or logos of Apple Computer, Inc. may be used
to endorse or promote products derived from the Apple Software without
specific prior written permission from Apple. Except as expressly stated in
this notice, no other rights or licenses, express or implied, are granted by
Apple herein, including but not limited to any patent rights that may be
infringed by your derivative works or by other works in which the Apple
Software may be incorporated.
The Apple Software is provided by Apple on an "AS IS" basis. APPLE MAKES NO
WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED
WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE OR IN
COMBINATION WITH YOUR PRODUCTS.
IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION, MODIFICATION
AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER
THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR
OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdlib.h>
#include "os_nacl.h"
#include <GLES2/gl2.h>
#include <nacl/npupp.h>
#include <pgl/pgl.h>
#include <string.h>
#include <stdint.h>
static NPNetscapeFuncs kBrowserFuncs = { 0 };
static NPNetscapeFuncs* browser = &kBrowserFuncs;
static NPDevice* device3d_ = NULL;
static PGLContext pgl_context_;
static NPDeviceContext3D context3d_;
static int width_;
static int height_;
extern int nacl_main(int argc, char** argn, char** argv);
extern void nacl_cleanup();
NPExtensions* extensions = NULL;
static NPP npp_;
const int32_t kCommandBufferSize = 1024 * 1024;
// Plugin entry points
extern "C" {
// Plugin entry points
// Entrypoints -----------------------------------------------------------------
NPError NP_GetEntryPoints(NPPluginFuncs* plugin_funcs) {
plugin_funcs->version = 11;
plugin_funcs->size = sizeof(plugin_funcs);
plugin_funcs->newp = NPP_New;
plugin_funcs->destroy = NPP_Destroy;
plugin_funcs->setwindow = NPP_SetWindow;
plugin_funcs->newstream = NPP_NewStream;
plugin_funcs->destroystream = NPP_DestroyStream;
plugin_funcs->asfile = NPP_StreamAsFile;
plugin_funcs->writeready = NPP_WriteReady;
plugin_funcs->write = (NPP_WriteUPP)NPP_Write;
plugin_funcs->print = NPP_Print;
plugin_funcs->event = NPP_HandleEvent;
plugin_funcs->urlnotify = NPP_URLNotify;
plugin_funcs->getvalue = NPP_GetValue;
plugin_funcs->setvalue = NPP_SetValue;
return NPERR_NO_ERROR;
}
NPError NP_Shutdown() {
pglTerminate();
return NPERR_NO_ERROR;
}
NPError NP_GetValue(void* instance, NPPVariable variable, void* value);
char* NP_GetMIMEDescription();
NPError NP_Initialize(NPNetscapeFuncs* browser_funcs,
NPPluginFuncs* plugin_funcs) {
printf("NPP_Initialize\n");
memcpy(&kBrowserFuncs, browser_funcs, sizeof(kBrowserFuncs));
pglInitialize();
return NP_GetEntryPoints(plugin_funcs);
}
} // extern "C"
void Initialize3D() {
// Initialize a 3D context.
NPDeviceContext3DConfig config;
config.commandBufferSize = kCommandBufferSize;
NPError err = device3d_->initializeContext(npp_, &config, &context3d_);
if (err != NPERR_NO_ERROR) {
printf("Failed to initialize 3D context\n");
exit(1);
}
// Create a PGL context.
pgl_context_ = pglCreateContext(npp_, device3d_, &context3d_);
// Initialize the demo GL state.
//pglMakeCurrent(pgl_context_);
//GLFromCPPInit();
//pglMakeCurrent(NULL);
}
NPError NPP_New(NPMIMEType pluginType,
NPP instance,
uint16_t mode,
int16_t argc, char* argn[], char* argv[],
NPSavedData* saved) {
printf("NPP_New\n");
if (browser->version >= 14) {
npp_ = instance;
if (!extensions) {
browser->getvalue(npp_, NPNVPepperExtensions,
reinterpret_cast<void*>(&extensions));
// CHECK(extensions);
}
printf("%s: %i\n", __FUNCTION__, __LINE__);
device3d_ = extensions->acquireDevice(npp_, NPPepper3DDevice);
if (device3d_ == NULL) {
printf("Failed to acquire 3DDevice\n");
exit(1);
}
printf("%s: %i\n", __FUNCTION__, __LINE__);
/*
deviceaudio_ = extensions->acquireDevice(npp_, NPPepperAudioDevice);
if (deviceaudio_ == NULL) {
printf("Failed to acquire AudioDevice\n");
exit(1);
}
*/
Initialize3D();
pglMakeCurrent(pgl_context_);
nacl_main(argc, argn, argv);
pglMakeCurrent(NULL);
};
return NPERR_NO_ERROR;
}
NPError NPP_Destroy(NPP instance, NPSavedData** save) {
nacl_cleanup();
return NPERR_NO_ERROR;
}
void Destroy3D() {
printf("destroy 3d\n");
// Destroy the PGL context.
pglDestroyContext(pgl_context_);
pgl_context_ = NULL;
// Destroy the Device3D context.
device3d_->destroyContext(npp_, &context3d_);
}
static void iteration(void* data) {
(void)data;
OSNacl* os = (OSNacl*)OS::get_singleton();
if (!pglMakeCurrent(pgl_context_) && pglGetError() == PGL_CONTEXT_LOST) {
printf("******* Lost context! :O\n");
Destroy3D();
Initialize3D();
pglMakeCurrent(pgl_context_);
}
glViewport(0, 0, width_, height_);
os->iterate();
pglSwapBuffers();
pglMakeCurrent(NULL);
browser->pluginthreadasynccall(npp_, iteration, NULL);
};
NPError NPP_SetWindow(NPP instance, NPWindow* window) {
width_ = window->width;
height_ = window->height;
if (!pgl_context_)
Initialize3D();
// Schedule the first call to Draw.
OSNacl* os = (OSNacl*)OS::get_singleton();
OS::VideoMode vm;
vm.width = width_;
vm.height = height_;
vm.resizable = false;
vm.fullscreen = false;
os->set_video_mode(vm);
browser->pluginthreadasynccall(npp_, iteration, NULL);
return NPERR_NO_ERROR;
}
NPError NPP_NewStream(NPP instance,
NPMIMEType type,
NPStream* stream,
NPBool seekable,
uint16_t* stype) {
*stype = NP_ASFILEONLY;
return NPERR_NO_ERROR;
}
NPError NPP_DestroyStream(NPP instance, NPStream* stream, NPReason reason) {
return NPERR_NO_ERROR;
}
void NPP_StreamAsFile(NPP instance, NPStream* stream, const char* fname) {
}
int32_t NPP_Write(NPP instance,
NPStream* stream,
int32_t offset,
int32_t len,
void* buffer) {
return 0;
}
int32_t NPP_WriteReady(NPP instance, NPStream* stream) {
return 0;
}
void NPP_Print(NPP instance, NPPrint* platformPrint) {
}
int16_t NPP_HandleEvent(NPP instance, void* event) {
OSNacl* os = (OSNacl*)OS::get_singleton();
os->handle_event(event);
return 1;
}
void NPP_URLNotify(NPP instance,
const char* url,
NPReason reason,
void* notify_data) {
// PluginObject* obj = static_cast<PluginObject*>(instance->pdata);
}
static NPObject* Allocate(NPP npp, NPClass* npclass) {
return new NPObject;
}
static void Deallocate(NPObject* object) {
delete object;
}
// Return |true| if |method_name| is a recognized method.
static bool HasMethod(NPObject* obj, NPIdentifier method_name) {
char *name = NPN_UTF8FromIdentifier(method_name);
bool is_method = false;
if (strcmp((const char *)name, "start_package") == 0) {
is_method = true;
} else if (strcmp((const char*)name, "add_package_chunk") == 0) {
is_method = true;
} else if (strcmp((const char*)name, "end_package") == 0) {
is_method = true;
} else if (strcmp((const char*)name, "start_scene") == 0) {
is_method = true;
}
NPN_MemFree(name);
return is_method;
}
// I don't know what this is
static bool InvokeDefault(NPObject *obj, const NPVariant *args,
uint32_t argCount, NPVariant *result) {
if (result) {
NULL_TO_NPVARIANT(*result);
}
return true;
}
static uint8_t* mem = NULL;
static int pkg_size = 0;
static String pkgname;
static bool variant_is_number(const NPVariant& v) {
switch (v.type) {
case NPVariantType_Int32:
case NPVariantType_Double:
return true;
default:
return false;
}
return false;
};
static double variant_as_number(const NPVariant& v) {
switch (v.type) {
case NPVariantType_Int32:
return (double)v.value.intValue;
case NPVariantType_Double:
return (double)v.value.doubleValue;
default:
return 0;
}
return 0;
};
// Invoke() is called by the browser to invoke a function object whose name
// is |method_name|.
static bool Invoke(NPObject* obj,
NPIdentifier method_name,
const NPVariant *args,
uint32_t arg_count,
NPVariant *result) {
NULL_TO_NPVARIANT(*result);
char *name = NPN_UTF8FromIdentifier(method_name);
if (name == NULL)
return false;
bool rval = false;
OSNacl* os = (OSNacl*)OS::get_singleton();
if (strcmp(name, "start_package") == 0) {
printf("arg count is %i\n", arg_count);
for (int i=0; i<arg_count; i++) {
printf("type for %i is %i\n", i, args[i].type);
}
if (arg_count != 2) {
return false; // assuming "false" means error
};
if (args[0].type != NPVariantType_String) {
printf("arg 0 not string type %i\n", args[1].type);
return false;
};
if (!variant_is_number(args[1])) {
printf("arg 1 not number, type %i\n", args[1].type);
return false;
};
pkgname = String::utf8(args[0].value.stringValue.UTF8Characters, args[0].value.stringValue.UTF8Length);
pkg_size = (int)variant_as_number(args[1]);
mem = (uint8_t*)malloc(pkg_size);
printf("args %ls, %lf\n", pkgname.c_str(), variant_as_number(args[1]));
return true;
};
if (strcmp(name, "add_package_chunk") == 0) {
if (arg_count != 3) { // assuming arg_count starts from 1
return false; // assuming "false" means error
};
if (!variant_is_number(args[0])) return false;
if (args[1].type != NPVariantType_String) return false;
if (!variant_is_number(args[2])) return false;
if (!mem)
return false;
int ofs = variant_as_number(args[0]);
int len = variant_as_number(args[2]);
String s;
if (s.parse_utf8(args[1].value.stringValue.UTF8Characters, args[1].value.stringValue.UTF8Length)) {
printf("error parsing?\n");
};
uint8_t* dst = mem + ofs;
for (int i=0; i<len; i++) {
dst[i] = s[i];
};
//memcpy(mem + ofs, args[1].value.stringValue.UTF8Characters, len);
return true;
};
if (strcmp(name, "end_package") == 0) {
os->add_package(pkgname, mem, pkg_size);
return true;
};
if (strcmp(name, "start_scene") == 0) {
printf("start_scene!\n");
if (arg_count != 1) {
return false;
};
if (args[0].type != NPVariantType_String) return false;
printf("calling with param %s\n", args[0].value.stringValue.UTF8Characters);
printf("pepper iteration\n");
if (!pglMakeCurrent(pgl_context_) && pglGetError() == PGL_CONTEXT_LOST) {
printf("******* Lost context! :O\n");
Destroy3D();
Initialize3D();
pglMakeCurrent(pgl_context_);
}
os->start_scene(String::utf8(args[0].value.stringValue.UTF8Characters));
pglSwapBuffers();
pglMakeCurrent(NULL);
printf("returning true\n");
return true;
};
NPN_MemFree(name);
return rval;
}
static NPClass GodotClass = {
NP_CLASS_STRUCT_VERSION,
Allocate,
Deallocate,
NULL, // Invalidate is not implemented
HasMethod,
Invoke,
InvokeDefault,
NULL, // HasProperty is not implemented
NULL, // GetProperty is not implemented
NULL, // SetProperty is not implemented
};
static NPObject* npobject = NULL;
NPError NPP_GetValue(NPP instance, NPPVariable variable, void* value) {
NPError err = NPERR_NO_ERROR;
switch (variable) {
case NPPVpluginNameString:
*(reinterpret_cast<const char**>(value)) = "Pepper Test PlugIn";
break;
case NPPVpluginDescriptionString:
*(reinterpret_cast<const char**>(value)) =
"Simple Pepper plug-in for manual testing.";
break;
case NPPVpluginNeedsXEmbed:
*(reinterpret_cast<NPBool*>(value)) = 1;
break;
case NPPVpluginScriptableNPObject: {
if (npobject == NULL) {
npobject = NPN_CreateObject(instance, &GodotClass);
} else {
NPN_RetainObject(npobject);
};
void** v = reinterpret_cast<void**>(value);
*v = npobject;
} break;
default:
fprintf(stderr, "Unhandled variable to NPP_GetValue\n");
err = NPERR_GENERIC_ERROR;
break;
}
return err;
}
NPError NPP_SetValue(NPP instance, NPNVariable variable, void* value) {
return NPERR_GENERIC_ERROR;
}
NPError NP_GetValue(void* instance, NPPVariable variable, void* value) {
return NPP_GetValue(reinterpret_cast<NPP>(instance), variable, value);
}
char* NP_GetMIMEDescription() {
return const_cast<char*>("pepper-application/x-pepper-test-plugin;");
}

29
platform/nacl/platform_config.h
View File

@ -1,29 +0,0 @@
/*************************************************************************/
/* platform_config.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 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 <alloca.h>