Callbacks

#include <UnigineEngine.h>
#include <UnigineInterpreter.h>
#include <UnigineInterface.h>

#include "AppSystemLogic.h"
#include "AppWorldLogic.h"
#include "AppEditorLogic.h"


using namespace Unigine;

/*
	World function
*/
const Variable &runWorldFunction(const Variable &name,const Variable &v) {
	
	Log::warning("runWorldFunction(%s,%s) is called\n",name.getTypeName().get(),v.getTypeName().get());
	
	Engine *engine = Engine::get();
	return engine->runWorldFunction(name,v);
}

/*
*/
#ifdef _WIN32
	int wmain(int argc,wchar_t *argv[]) {
#else
	int main(int argc,char *argv[]) {
#endif

	// export the runWorldFunction() function defined above
	Unigine::Interpreter::addExternFunction("runWorldFunction", MakeExternFunction(&runWorldFunction));
	
	AppSystemLogic system_logic;
	AppWorldLogic world_logic;
	AppEditorLogic editor_logic;
	
	Unigine::EnginePtr engine(UNIGINE_VERSION,argc,argv);
	
	engine->main(&system_logic,&world_logic,&editor_logic);
	
	return 0;
}

#include "AppWorldLogic.h"
#include "UnigineEditor.h"
#include "UnigineGame.h"

#include <UnigineInterpreter.h>


using namespace Unigine;
/*
 */
AppWorldLogic::AppWorldLogic() {
	
}

AppWorldLogic::~AppWorldLogic() {
	
}

/*
 */
int AppWorldLogic::init() {
	return 1;
}

int AppWorldLogic::shutdown() {
	return 1;
}

int AppWorldLogic::destroy() {
	return 1;
}

/*
 */
int AppWorldLogic::update() {
	/*
		Callbacks usage example
	*/

	// call the counter() function of the script
	Variable ret = Engine::get()->runWorldFunction(Variable("counter"));
	// print a message depending on the value returned by the counter() script function:
	// print the current value of the counter
	if (ret.getInt() != -1) Log::message("counter is: %d\n", ret.getInt());
	// print the world name
	if (ret.getInt() == 3) Log::message("\nworld name is: \"%s\"\n", Engine::get()->runWorldFunction(Variable("engine.world.getName")).getString());

	return 1;
}

int AppWorldLogic::render() {
	return 1;
}

int AppWorldLogic::flush() {
	return 1;
}

/*
 */
int AppWorldLogic::save(const Unigine::StreamPtr &stream) {
	UNIGINE_UNUSED(stream);
	return 1;
}

int AppWorldLogic::restore(const Unigine::StreamPtr &stream) {
	UNIGINE_UNUSED(stream);
	return 1;
}

// unigine_project.usc

/*
*/
int callback(int value) {
	
	log.warning("callback(%s) is called\n",typeinfo(value));
	
	return value;
}

/*
*/
void counter() {
	
	for(int i = 0; i < 4; i++) {
		log.warning("counter(): called\n");
		yield i;
	}
	
	return -1;
}

/*
*/
int init() {
	
	log.message("\n");
	
	// run the callback() script function via the API runWorldFunction() function
	log.message("result is: %s\n\n",typeinfo(runWorldFunction("callback",10)));
	log.message("result is: %s\n\n",typeinfo(runWorldFunction("callback",vec3(1,2,3))));
	log.message("result is: %s\n\n",typeinfo(runWorldFunction("callback","a string")));
	
	/////////////////////////////////
	
	// show a console
	engine.console.setActivity(1);
	
	return 1;
}

runWorldFunction(string,int): called
callback(int: 10): called
result is: int: 10

runWorldFunction(string,vec3): called
callback(vec3: 1 2 3): called
result is: vec3: 1 2 3

runWorldFunction(string,string): called
callback(string: "a string") is called
result is: string: "a string"

counter(): called
counter is: 0
counter(): called
counter is: 1
counter(): called
counter is: 2
counter(): called
counter is: 3

world name is: "unigine_project/unigine_project"