Page MenuHomeWildfire Games
Differential D1989 Diff 9951 source/simulation2/scripting/EngineScriptConversions.cpp

Changeset View

Standalone View

View Options

source/simulation2/scripting/EngineScriptConversions.cpp

Show All 22 Lines
#include "maths/Fixed.h" #include "maths/Fixed.h"
#include "maths/FixedVector2D.h" #include "maths/FixedVector2D.h"
#include "maths/FixedVector3D.h" #include "maths/FixedVector3D.h"
#include "ps/CLogger.h" #include "ps/CLogger.h"
#include "ps/Shapes.h" #include "ps/Shapes.h"
#include "ps/utf16string.h" #include "ps/utf16string.h"
#include "simulation2/helpers/CinemaPath.h" #include "simulation2/helpers/CinemaPath.h"
#include "simulation2/helpers/Grid.h" #include "simulation2/helpers/Grid.h"
#include "simulation2/components/ICmpVisual.h"
#include "simulation2/system/IComponent.h" #include "simulation2/system/IComponent.h"
#include "simulation2/system/ParamNode.h" #include "simulation2/system/ParamNode.h"
#define FAIL(msg) STMT(JS_ReportError(cx, msg); return false) #define FAIL(msg) STMT(JS_ReportError(cx, msg); return false)
#define FAIL_VOID(msg) STMT(JS_ReportError(cx, msg); return) #define FAIL_VOID(msg) STMT(JS_ReportError(cx, msg); return)
template<> void ScriptInterface::ToJSVal<IComponent*>(JSContext* cx, JS::MutableHandleValue ret, IComponent* const& val) template<> void ScriptInterface::ToJSVal<IComponent*>(JSContext* cx, JS::MutableHandleValue ret, IComponent* const& val)
{ {
▲ Show 20 Lines • Show All 295 Lines • ▼ Show 20 Linestemplate<> bool ScriptInterface::FromJSVal<CCinemaPath>(JSContext* cx, JS::HandleValue v, CCinemaPath& out)
if (!FromJSProperty(cx, v, "style", pathData.m_Style)) if (!FromJSProperty(cx, v, "style", pathData.m_Style))
pathData.m_Style = L"default"; pathData.m_Style = L"default";
out = CCinemaPath(pathData, positionSpline, targetSpline); out = CCinemaPath(pathData, positionSpline, targetSpline);
return true; return true;
} }
template<> void ScriptInterface::ToJSVal<JsProp>(JSContext* cx, JS::MutableHandleValue ret, const JsProp& val)
{
JSAutoRequest rq(cx);
JS::RootedObject obj(cx, JS_NewPlainObject(cx));
JS::RootedValue name(cx);
JS::RootedValue position(cx);
ToJSVal(cx, &name, val.m_Name);
ToJSVal(cx, &position, val.m_Position);
ScriptInterface::CreateObject(
cx,
elexisUnsubmitted
Done
Inline Actions

ScriptInterface::CreateObject

elexis: ScriptInterface::CreateObject
ret,
"name", name,
"position", position);
}
template<> void ScriptInterface::ToJSVal<std::vector<JsProp>>(JSContext* cx, JS::MutableHandleValue ret, const std::vector<JsProp>& val)
StanAuthorUnsubmitted
Done
Inline Actions

There is probably a way to make it generic for every type of std::vector but I haven't found it.

Stan: There is probably a way to make it generic for every type of std::vector but I haven't found it.
elexisUnsubmitted
Done
Inline Actions

Take a look at the line after the code you insert here.

elexis: Take a look at the line after the code you insert here.
{
elexisUnsubmitted
Not Done
Inline Actions

I dont assume that you envision to allow JS to change prop points. If so, specifying this method is wrong.

05:17 < Stan`> elexis actuay I can't because of the macro usage.

One can.

elexis: I dont assume that you envision to allow JS to change prop points. If so, specifying this…
StanAuthorUnsubmitted
Done
Inline Actions

So how does one prevent that when the function is explicitely called by a macro you asked me to use ?

Stan: So how does one prevent that when the function is explicitely called by a macro you asked me to…
elexisUnsubmitted
Not Done
Inline Actions

You are permitted to find a solution that meets the objective of the macro without implementing a function that is not used and depending on design of the patch must or must not exist.

elexis: You are permitted to find a solution that meets the objective of the macro without implementing…
StanAuthorUnsubmitted
Done
Inline Actions

That makes no sense to me, as I would've done it had I know how to :) but thanks I guess.

Stan: That makes no sense to me, as I would've done it had I know how to :) but thanks I guess.
elexisUnsubmitted
Not Done
Inline Actions

This is an example of how to define only one of the two functions without having to reimplement the vector<->JS array conversion:

class IComponent;
template<> void ScriptInterface::ToJSVal<std::vector<IComponent*> >(JSContext* cx, JS::MutableHandleValue ret, const std::vector<IComponent*>& val)
{
	ToJSVal_vector(cx, ret, val);
}

template<> bool ScriptInterface::FromJSVal<std::vector<Entity> >(JSContext* cx, JS::HandleValue v, std::vector<Entity>& out)
{
	return FromJSVal_vector(cx, v, out);
}
elexis: This is an example of how to define only one of the two functions without having to reimplement…
JSAutoRequest rq(cx);
JS::RootedObject objArr(cx, JS_NewArrayObject(cx, val.size()));
for (size_t i = 0; i < val.size(); ++i)
{
JS::RootedValue element(cx);
ToJSVal(cx, &element, val[i]);
elexisUnsubmitted
Not Done
Inline Actions

FromJSVal means that we create a new JS object without properties and then try to read the name and position property of that empty object?

elexis: FromJSVal means that we create a new JS object without properties and then try to read the name…
StanAuthorUnsubmitted
Done
Inline Actions

I guess not just copied the code above, as I said, I didn't need that function until I started using the macro.

Stan: I guess not just copied the code above, as I said, I didn't need that function until I started…
JS_SetElement(cx, objArr, i, element);
}
elexisUnsubmitted
Done
Inline Actions

(Otherwise had said ScriptInterface::CreateArray)

elexis: (Otherwise had said ScriptInterface::CreateArray)
StanAuthorUnsubmitted
Done
Inline Actions

What are the advantages / disadvantages ?

Stan: What are the advantages / disadvantages ?
StanAuthorUnsubmitted
Done
Inline Actions

Nevermind. Got it ^^'

Stan: Nevermind. Got it ^^'
ret.setObject(*objArr);
}
// define vectors // define vectors
JSVAL_VECTOR(CFixedVector2D) JSVAL_VECTOR(CFixedVector2D)
JSVAL_VECTOR(JsProp)
#undef FAIL #undef FAIL
#undef FAIL_VOID #undef FAIL_VOID
Wildfire Games · Phabricator