Open source Star Ruler 2 source code!
This commit is contained in:
Lucas de Vries
@@ -0,0 +1,284 @@
|
||||
#pragma once
|
||||
#include "scripts/manager.h"
|
||||
#include "script_bind.h"
|
||||
#include "vec3.h"
|
||||
#include "vec2.h"
|
||||
#include "quaternion.h"
|
||||
#include <string>
|
||||
#include <stdint.h>
|
||||
#include <vector>
|
||||
#include <functional>
|
||||
|
||||
#ifndef MAX_GENERIC_ARGUMENTS
|
||||
#define MAX_GENERIC_ARGUMENTS 16
|
||||
#endif
|
||||
|
||||
class Object;
|
||||
class Empire;
|
||||
class Design;
|
||||
struct Player;
|
||||
struct ScriptObjectType;
|
||||
|
||||
namespace net {
|
||||
struct Message;
|
||||
};
|
||||
|
||||
namespace scene {
|
||||
class Node;
|
||||
};
|
||||
|
||||
namespace scripts {
|
||||
|
||||
struct ArgumentDesc;
|
||||
struct GenericValue;
|
||||
|
||||
typedef std::function<void(net::Message&,ArgumentDesc&,GenericValue&)> customRW;
|
||||
typedef std::function<asIScriptObject*(ArgumentDesc&,asIScriptObject*)> customHandle;
|
||||
|
||||
struct GenericValue {
|
||||
union {
|
||||
int integer;
|
||||
unsigned uint;
|
||||
float sfloat;
|
||||
double dfloat;
|
||||
bool boolean;
|
||||
int64_t longint;
|
||||
std::string* str;
|
||||
|
||||
Object* obj;
|
||||
Empire* emp;
|
||||
scene::Node* node;
|
||||
Design* design;
|
||||
Player* player;
|
||||
asIScriptObject* script;
|
||||
net::Message* msg;
|
||||
vec3d* v3;
|
||||
vec2i* v2;
|
||||
quaterniond* quat;
|
||||
void* ptr;
|
||||
};
|
||||
bool managed;
|
||||
volatile bool asyncReturned;
|
||||
|
||||
template<class T>
|
||||
T& get() {
|
||||
return *(T*)this;
|
||||
}
|
||||
|
||||
GenericValue() :
|
||||
ptr(nullptr), managed(false), asyncReturned(false) {}
|
||||
};
|
||||
|
||||
void trivialCopy(GenericValue& to, GenericValue& from);
|
||||
|
||||
struct GenericType {
|
||||
std::string name;
|
||||
bool wouldConst;
|
||||
|
||||
std::function<void(GenericValue&,unsigned,asIScriptGeneric*)> get;
|
||||
std::function<void(GenericValue&,GenericValue&)> copy;
|
||||
std::function<void(GenericValue&,asIScriptGeneric*)> ret;
|
||||
std::function<void(Call&,GenericValue&)> call;
|
||||
std::function<void(Call&,ArgumentDesc&,GenericValue&,customHandle custom)> push;
|
||||
std::function<void(net::Message&,ArgumentDesc&,GenericValue&,customRW custom)> write;
|
||||
std::function<bool(net::Message&,ArgumentDesc&,GenericValue&,customRW custom)> read;
|
||||
std::function<void(GenericValue&)> destruct;
|
||||
|
||||
GenericType() : wouldConst(false) {}
|
||||
|
||||
template<class T>
|
||||
GenericType* setup(std::string Name, decltype(get) Get, decltype(ret) Ret, decltype(copy) Copy = trivialCopy,
|
||||
decltype(call) Cl = nullptr, decltype(push) Push = nullptr,
|
||||
decltype(write) Write = nullptr, decltype(read) Read = nullptr,
|
||||
decltype(destruct) Destruct = nullptr, bool WouldConst = false) {
|
||||
name = Name;
|
||||
get = Get;
|
||||
ret = Ret;
|
||||
copy = Copy;
|
||||
|
||||
if(Cl == nullptr) {
|
||||
call = [](Call& cl, GenericValue& val) {
|
||||
cl.call(val.get<T>());
|
||||
};
|
||||
}
|
||||
else {
|
||||
call = Cl;
|
||||
}
|
||||
|
||||
if(Push == nullptr) {
|
||||
push = [](Call& cl, ArgumentDesc& desc, GenericValue& val, customHandle custom) {
|
||||
cl.push(val.get<T>());
|
||||
};
|
||||
}
|
||||
else {
|
||||
push = Push;
|
||||
}
|
||||
|
||||
if(Write == nullptr) {
|
||||
write = [](net::Message& msg, ArgumentDesc& desc, GenericValue& val, customRW custom) {
|
||||
msg << val.get<T>();
|
||||
};
|
||||
}
|
||||
else {
|
||||
write = Write;
|
||||
}
|
||||
|
||||
if(Read == nullptr) {
|
||||
read = [](net::Message& msg, ArgumentDesc& desc, GenericValue& val, customRW custom) -> bool {
|
||||
msg >> val.get<T>();
|
||||
return true;
|
||||
};
|
||||
}
|
||||
else {
|
||||
read = Read;
|
||||
}
|
||||
|
||||
destruct = Destruct;
|
||||
wouldConst = WouldConst;
|
||||
return this;
|
||||
}
|
||||
};
|
||||
|
||||
extern GenericType* GT_uint;
|
||||
extern GenericType* GT_Custom_Handle;
|
||||
extern GenericType* GT_Player_Ref;
|
||||
extern GenericType* GT_Object_Ref;
|
||||
extern GenericType* GT_Empire_Ref;
|
||||
extern GenericType* GT_Node_Ref;
|
||||
|
||||
const std::string& getTypeString(GenericType* type);
|
||||
GenericType* getStringType(const std::string& type);
|
||||
|
||||
struct ArgumentDesc {
|
||||
GenericType* type;
|
||||
std::string argName;
|
||||
std::string defaultValue;
|
||||
std::string customName;
|
||||
void* customType;
|
||||
void* customRead;
|
||||
void* customWrite;
|
||||
bool isConst;
|
||||
|
||||
ArgumentDesc()
|
||||
: type(nullptr), customType(nullptr), customRead(nullptr), customWrite(nullptr), isConst(false) {
|
||||
}
|
||||
|
||||
ArgumentDesc(GenericType* Type)
|
||||
: type(Type), customType(nullptr), customRead(nullptr), customWrite(nullptr), isConst(false) {
|
||||
}
|
||||
|
||||
ArgumentDesc(GenericType* Type, bool IsConst)
|
||||
: type(Type), customType(nullptr), customRead(nullptr), customWrite(nullptr), isConst(IsConst) {
|
||||
}
|
||||
|
||||
ArgumentDesc(std::string CustomName, bool IsConst)
|
||||
: type(GT_Custom_Handle), customName(CustomName), customType(nullptr), customRead(nullptr),
|
||||
customWrite(nullptr), isConst(IsConst) {
|
||||
}
|
||||
|
||||
void operator=(const ArgumentDesc& other) {
|
||||
type = other.type;
|
||||
defaultValue = other.defaultValue;
|
||||
argName = other.argName;
|
||||
customName = other.customName;
|
||||
customType = other.customType;
|
||||
customRead = other.customRead;
|
||||
customWrite = other.customWrite;
|
||||
isConst = other.isConst;
|
||||
}
|
||||
|
||||
void operator=(GenericType* Type) {
|
||||
type = Type;
|
||||
}
|
||||
|
||||
operator GenericType*() {
|
||||
return type;
|
||||
}
|
||||
|
||||
std::string toString() {
|
||||
if(!type)
|
||||
return "void";
|
||||
|
||||
std::string out;
|
||||
if(isConst)
|
||||
out += "const ";
|
||||
|
||||
if(type == GT_Custom_Handle)
|
||||
out += customName+"@";
|
||||
else
|
||||
out += getTypeString(type);
|
||||
|
||||
return out;
|
||||
}
|
||||
};
|
||||
|
||||
//Generic calls follow descriptors that state
|
||||
//which arguments they have and what their return value is
|
||||
class GenericCallDesc {
|
||||
public:
|
||||
std::string name;
|
||||
ArgumentDesc returnType;
|
||||
ArgumentDesc arguments[MAX_GENERIC_ARGUMENTS];
|
||||
bool returnsArray;
|
||||
bool constFunction;
|
||||
unsigned argCount;
|
||||
|
||||
GenericCallDesc();
|
||||
GenericCallDesc(std::string declaration, bool hasReturnType = true, bool customRefs = false);
|
||||
|
||||
void parse(std::string declaration, bool hasReturnType = true, bool customRefs = false);
|
||||
|
||||
void append(GenericType* argument);
|
||||
void append(GenericCallDesc& desc);
|
||||
void append(std::vector<std::string>& arguments, bool customRefs = false);
|
||||
void prepend(ArgumentDesc argument);
|
||||
|
||||
GenericValue call(Call& cl);
|
||||
|
||||
std::string declaration(bool addReturnType = true, bool forceConst = false, unsigned start = 0);
|
||||
};
|
||||
|
||||
//Call data holds the values of all the arguments for easy passing around
|
||||
class GenericCallData {
|
||||
public:
|
||||
GenericCallDesc& desc;
|
||||
GenericValue values[MAX_GENERIC_ARGUMENTS];
|
||||
void* object;
|
||||
|
||||
GenericCallData(GenericCallDesc& desc);
|
||||
GenericCallData(GenericCallData& data);
|
||||
~GenericCallData();
|
||||
|
||||
//Generic call data can be sent over the network,
|
||||
//the function descriptor should be sent manually though,
|
||||
//depending on what system is sending it.
|
||||
void write(net::Message& msg, unsigned startAt = 0, customRW custom = nullptr);
|
||||
bool read(net::Message& msg, unsigned startAt = 0, customRW custom = nullptr);
|
||||
|
||||
//Read all the arguments from an angelscript generic
|
||||
//call, and stash them here
|
||||
GenericCallData(GenericCallDesc& desc, asIScriptGeneric* gen);
|
||||
|
||||
//Push all the arguments onto a script call to angelscript
|
||||
void pushTo(Call& call, int startAt = 0, customHandle custom = nullptr);
|
||||
GenericValue call(Call& cl);
|
||||
};
|
||||
|
||||
//Retrieve the function matching the call desc from this manager
|
||||
asIScriptFunction* getFunction(Manager* manager, const char* module, GenericCallDesc& desc, bool forceConst = false);
|
||||
|
||||
//Bind a generically specified function to a callback,
|
||||
//the callback receives the argument data and the bind id
|
||||
//returned by the call to bindGeneric so it can identify which
|
||||
//generic call was received
|
||||
typedef GenericValue (*GenericHandler)(void* arg, GenericCallData& data);
|
||||
int bindGeneric(GenericCallDesc& desc, GenericHandler handler, void* arg = nullptr, bool acceptConst = false);
|
||||
int bindGeneric(ClassBind& cls, GenericCallDesc& desc, GenericHandler handler, void* arg = nullptr, bool forceConst = false);
|
||||
int bindGeneric(ClassBind& cls, const std::string& decl, GenericCallDesc& desc, GenericHandler handler, void* arg = 0);
|
||||
void clearGenericBinds();
|
||||
|
||||
void initGenericTypes();
|
||||
|
||||
void bindGenericObjectType(ScriptObjectType* type, std::string name);
|
||||
|
||||
};
|
||||
Reference in New Issue
Block a user