mirror of
https://github.com/TwilitRealm/dusklight
synced 2026-08-10 18:46:45 -04:00
Reorganize library code into libs/ (#3119)
* Reorganize files into libs/{dolphin,JSystem,PowerPC_EABI_Support,revolution,TRK_MINNOW_DOLPHIN}
* Update configure.py and project.py for new libs structure
* Refactor `#include <dolphin/x.h>` -> `<x.h>`
* Remove `__REVOLUTION_SDK__` forwards from dolphin
* Fix dolphin/ references in revolution
* Wrap `#include <dolphin.h>` in `!__REVOLUTION_SDK__`
* Always build TRK against dolphin headers
* Resolve revolution SDK header resolution issues
This commit is contained in:
Luke Street
@@ -0,0 +1,5 @@
|
||||
#include "JSystem/JSystem.h" // IWYU pragma: keep
|
||||
|
||||
#include "JSystem/JStudio/JStudio/ctb.h"
|
||||
|
||||
const u32 JStudio::ctb::data::ga4cSignature = 'CTB\0';
|
||||
@@ -0,0 +1,140 @@
|
||||
#include "JSystem/JSystem.h" // IWYU pragma: keep
|
||||
|
||||
#include "JSystem/JStudio/JStudio/ctb.h"
|
||||
#include <iterator>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
|
||||
JStudio::ctb::TObject::~TObject() {}
|
||||
|
||||
JStudio::ctb::TObject_TxyzRy::TObject_TxyzRy(JStudio::ctb::data::TParse_TBlock const& param_0)
|
||||
: TObject(param_0.get_ID(), param_0.get_IDSize(), param_0.getContent()) {}
|
||||
|
||||
int JStudio::ctb::TObject_TxyzRy::getScheme() const {
|
||||
return 1;
|
||||
}
|
||||
|
||||
JStudio::ctb::TControl::TControl() : pFactory_(NULL) {}
|
||||
|
||||
JStudio::ctb::TControl::~TControl() {
|
||||
JGADGET_ASSERTWARN(94, ocObject_.empty());
|
||||
}
|
||||
|
||||
void JStudio::ctb::TControl::appendObject(JStudio::ctb::TObject* p) {
|
||||
JUT_ASSERT(106, p!=NULL)
|
||||
ocObject_.Push_back(p);
|
||||
}
|
||||
|
||||
void JStudio::ctb::TControl::removeObject(JStudio::ctb::TObject* p) {
|
||||
JUT_ASSERT(113, p!=NULL)
|
||||
ocObject_.Erase(p);
|
||||
}
|
||||
|
||||
void JStudio::ctb::TControl::destroyObject(JStudio::ctb::TObject* param_0) {
|
||||
removeObject(param_0);
|
||||
TFactory *pFactory = getFactory();
|
||||
JUT_ASSERT(129, pFactory!=NULL);
|
||||
pFactory->destroy(param_0);
|
||||
}
|
||||
|
||||
void JStudio::ctb::TControl::destroyObject_all() {
|
||||
while (!ocObject_.empty()) {
|
||||
destroyObject(&ocObject_.back());
|
||||
}
|
||||
}
|
||||
|
||||
// NONMATCHING - TPRObject_ID_equal issues
|
||||
JStudio::ctb::TObject* JStudio::ctb::TControl::getObject(void const* param_0, u32 param_1) {
|
||||
JGadget::TLinkList<TObject, -12>::iterator begin = ocObject_.begin();
|
||||
JGadget::TLinkList<TObject, -12>::iterator end = ocObject_.end();
|
||||
JGadget::TLinkList<TObject, -12>::iterator local_50 = std::find_if(begin, end, object::TPRObject_ID_equal(param_0, param_1));
|
||||
if ((local_50 != end) != false) {
|
||||
return &*local_50;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
JStudio::ctb::TObject* JStudio::ctb::TControl::getObject_index(u32 param_0) {
|
||||
if (param_0 >= ocObject_.size()) {
|
||||
return 0;
|
||||
}
|
||||
JGadget::TLinkList<TObject, -12>::iterator aiStack_14 = ocObject_.begin();
|
||||
std::advance(aiStack_14, param_0);
|
||||
return &*aiStack_14;
|
||||
}
|
||||
|
||||
JStudio::ctb::TFactory::~TFactory() {}
|
||||
|
||||
JStudio::ctb::TObject* JStudio::ctb::TFactory::create(JStudio::ctb::data::TParse_TBlock const& param_0) {
|
||||
switch(param_0.get_scheme()) {
|
||||
case 1:
|
||||
return new TObject_TxyzRy(param_0);
|
||||
default:
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio::ctb::TFactory::destroy(JStudio::ctb::TObject* param_0) {
|
||||
delete param_0;
|
||||
}
|
||||
|
||||
// NONMATCHING TParse_header_block vtable location
|
||||
JStudio::ctb::TParse::TParse(JStudio::ctb::TControl* param_0) : pControl_(param_0) {}
|
||||
|
||||
JStudio::ctb::TParse::~TParse() {}
|
||||
|
||||
bool JStudio::ctb::TParse::parseHeader_next(void const** ppData_inout, u32* puBlock_out, u32 param_3) {
|
||||
JUT_ASSERT(221, ppData_inout!=NULL);
|
||||
JUT_ASSERT(222, puBlock_out!=NULL);
|
||||
void const* pData = *ppData_inout;
|
||||
JUT_ASSERT(224, pData!=NULL);
|
||||
data::TParse_THeader aTStack_478(pData);
|
||||
*ppData_inout = aTStack_478.getContent();
|
||||
*puBlock_out = aTStack_478.get_blockNumber();
|
||||
if (memcmp(aTStack_478.get_signature(), &JStudio::ctb::data::ga4cSignature, sizeof(JStudio::ctb::data::ga4cSignature)) != 0) {
|
||||
return false;
|
||||
}
|
||||
if (aTStack_478.get_byteOrder() != 0xfeff) {
|
||||
return false;
|
||||
}
|
||||
u16 version = aTStack_478.get_version();
|
||||
if (version < 1) {
|
||||
return false;
|
||||
}
|
||||
return version <= 1;
|
||||
}
|
||||
|
||||
bool JStudio::ctb::TParse::parseBlock_next(void const** ppData_inout, u32* puData_out, u32 param_3) {
|
||||
JUT_ASSERT(260, ppData_inout!=NULL);
|
||||
JUT_ASSERT(261, puData_out!=NULL);
|
||||
void const* pData = *ppData_inout;
|
||||
JUT_ASSERT(263, pData!=NULL);
|
||||
data::TParse_TBlock aTStack_260(pData);
|
||||
*ppData_inout = aTStack_260.getNext();
|
||||
*puData_out = aTStack_260.get_size();
|
||||
JStudio::ctb::TControl* pControl = getControl();
|
||||
JUT_ASSERT(269, pControl!=NULL);
|
||||
if ((param_3 & 0x10) != 0) {
|
||||
if (pControl->getObject(aTStack_260.get_ID(), aTStack_260.get_IDSize()) != NULL) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
if ((param_3 & 0x20) != 0) {
|
||||
return true;
|
||||
}
|
||||
JStudio::ctb::TFactory* pFactory = pControl->getFactory();
|
||||
if (pFactory == NULL) {
|
||||
return false;
|
||||
}
|
||||
|
||||
JStudio::ctb::TObject* pTVar6 = pFactory->create(aTStack_260);
|
||||
if (pTVar6 == NULL) {
|
||||
if ((param_3 & 0x40) == 0) {
|
||||
return false;
|
||||
} else {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
pControl->appendObject(pTVar6);
|
||||
return true;
|
||||
}
|
||||
@@ -0,0 +1,904 @@
|
||||
#include "JSystem/JSystem.h" // IWYU pragma: keep
|
||||
|
||||
#include "JSystem/JStudio/JStudio/functionvalue.h"
|
||||
#include "JSystem/JGadget/search.h"
|
||||
#include "JSystem/JUtility/JUTException.h"
|
||||
#include "JSystem/JUtility/JUTAssert.h"
|
||||
#include "JSystem/JGadget/linklist.h"
|
||||
#include <cmath>
|
||||
#include <cstdlib>
|
||||
#include <limits>
|
||||
|
||||
namespace JStudio {
|
||||
|
||||
namespace {
|
||||
|
||||
const ExtrapolateParameter gapfnExtrapolateParameter_[4] = {
|
||||
functionvalue::extrapolateParameter_raw,
|
||||
functionvalue::extrapolateParameter_repeat,
|
||||
functionvalue::extrapolateParameter_turn,
|
||||
functionvalue::extrapolateParameter_clamp,
|
||||
};
|
||||
|
||||
} // namespace
|
||||
|
||||
ExtrapolateParameter TFunctionValue::toFunction_outside(int idx) {
|
||||
ExtrapolateParameter fallback = NULL;
|
||||
ExtrapolateParameter result;
|
||||
|
||||
result = JGadget::toValueFromIndex<ExtrapolateParameter>(idx, gapfnExtrapolateParameter_, 4,
|
||||
fallback);
|
||||
|
||||
if (result == NULL) {
|
||||
JUTWarn w;
|
||||
w << "unknown outside : " << idx;
|
||||
|
||||
return gapfnExtrapolateParameter_[0];
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
TFunctionValue::TFunctionValue() {}
|
||||
TFunctionValue::~TFunctionValue() {}
|
||||
|
||||
void TFunctionValueAttribute_refer::refer_initialize() {
|
||||
clear();
|
||||
}
|
||||
|
||||
static f64 dummy_literal1() {
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
namespace functionvalue {
|
||||
|
||||
f64 interpolateValue_hermite(f64 c0, f64 c1, f64 x, f64 c2, f64 x2, f64 c3, f64 x3) {
|
||||
f64 a;
|
||||
f64 b;
|
||||
f64 c;
|
||||
f64 d;
|
||||
|
||||
a = c0 - c1;
|
||||
b = a * (1.0 / (x2 - c1)); // (a - b) * 1.0 / (c - d)
|
||||
c = b - 1.0; // 1.0
|
||||
d = (3.0 + -2.0 * b) * (b * b); // 3.0 - 2.0 * b
|
||||
f64 cab = (c * a * b);
|
||||
f64 coeffx3 = cab * x3;
|
||||
f64 cca = (c * c * a);
|
||||
f64 coeffc2 = cca * c2;
|
||||
return ((1.0 - d) * x + (d * c3)) + coeffc2 + coeffx3;
|
||||
}
|
||||
|
||||
|
||||
f64 interpolateValue_BSpline_uniform(f64 interpolationFactor, f64 point2, f64 point3, f64 point4, f64 point5) {
|
||||
f64 inverseInterpolationFactor = (1.0 - interpolationFactor);
|
||||
f64 inverseInterpolationFactorSquared = inverseInterpolationFactor * inverseInterpolationFactor;
|
||||
f64 inverseInterpolationFactorCubed = inverseInterpolationFactorSquared * inverseInterpolationFactor;
|
||||
|
||||
f64 interpolationFactorSquared = interpolationFactor * interpolationFactor;
|
||||
f64 interpolationFactorCubed = interpolationFactorSquared * interpolationFactor;
|
||||
|
||||
f64 coefficient1 = inverseInterpolationFactorCubed;
|
||||
|
||||
f64 blendFactorForPoint3 = (1.0 / 2.0) * interpolationFactorCubed - interpolationFactorSquared + (2.0 / 3.0);
|
||||
|
||||
f64 blendFactorForPoint4 =
|
||||
(1.0 / 2.0) * (interpolationFactor + interpolationFactorSquared - interpolationFactorCubed) + (1.0 / 6.0);
|
||||
|
||||
f64 coefficient2 = interpolationFactorCubed;
|
||||
|
||||
return ((coefficient1 * point2) + (coefficient2 * point5)) * (1.0 / 6.0) + (blendFactorForPoint3 * point3) +
|
||||
(blendFactorForPoint4 * point4);
|
||||
}
|
||||
|
||||
f64 interpolateValue_BSpline_nonuniform(f64 interpolationFactor, const f64* controlPoints, const f64* knotVector) {
|
||||
f64 knot0 = knotVector[0];
|
||||
f64 knot1 = knotVector[1];
|
||||
f64 knot2 = knotVector[2];
|
||||
f64 knot3 = knotVector[3];
|
||||
f64 knot4 = knotVector[4];
|
||||
f64 knot5 = knotVector[5];
|
||||
f64 diff0 = interpolationFactor - knot0;
|
||||
f64 diff1 = interpolationFactor - knot1;
|
||||
f64 diff2 = interpolationFactor - knot2;
|
||||
f64 diff3 = knot3 - interpolationFactor;
|
||||
f64 diff4 = knot4 - interpolationFactor;
|
||||
f64 diff5 = knot5 - interpolationFactor;
|
||||
f64 inverseDeltaKnot32 = 1 / (knot3 - knot2);
|
||||
f64 blendFactor3 = (diff3 * inverseDeltaKnot32) / (knot3 - knot1);
|
||||
f64 blendFactor2 = (diff2 * inverseDeltaKnot32) / (knot4 - knot2);
|
||||
f64 blendFactor1 = (diff3 * blendFactor3) / (knot3 - knot0);
|
||||
f64 blendFactor4 = ((diff1 * blendFactor3) + (diff4 * blendFactor2)) / (knot4 - knot1);
|
||||
f64 blendFactor5 = (diff2 * blendFactor2) / (knot5 - knot2);
|
||||
f64 term1 = diff3 * blendFactor1;
|
||||
f64 term2 = (diff0 * blendFactor1) + (diff4 * blendFactor4);
|
||||
f64 term3 = (diff1 * blendFactor4) + (diff5 * blendFactor5);
|
||||
f64 term4 = diff2 * blendFactor5;
|
||||
|
||||
return (term1 * controlPoints[0]) + (term2 * controlPoints[1]) + (term3 * controlPoints[2]) + (term4 * controlPoints[3]);
|
||||
}
|
||||
|
||||
inline f64 interpolateValue_linear(f64 a1, f64 a2, f64 a3, f64 a4, f64 a5) {
|
||||
return a3 + ((a5 - a3) * (a1 - a2)) / (a4 - a2);
|
||||
}
|
||||
|
||||
inline f64 interpolateValue_linear_1(f64 a1, f64 a2, f64 a3, f64 a4) {
|
||||
return a3 + (a4 - a3) * (a1 - a2);
|
||||
}
|
||||
|
||||
inline f64 interpolateValue_plateau(f64 a1, f64 a2, f64 a3, f64 a4, f64 a5) {
|
||||
return interpolateValue_hermite(a1, a2, a3, 0.0, a4, a5, 0.0);
|
||||
}
|
||||
|
||||
f64 extrapolateParameter_turn(f64 param_0, f64 param_1) {
|
||||
f64 dVar2 = 2.0 * param_1;
|
||||
f64 dVar1 = extrapolateParameter_repeat(param_0, dVar2);
|
||||
if (dVar1 >= param_1) {
|
||||
dVar1 = dVar2 - dVar1;
|
||||
}
|
||||
return dVar1;
|
||||
}
|
||||
|
||||
} // namespace functionvalue
|
||||
|
||||
void TFunctionValueAttribute_range::range_initialize() {
|
||||
fBegin_ = NAN;
|
||||
fEnd_ = fBegin_;
|
||||
fDifference_ = fBegin_;
|
||||
|
||||
range_setProgress(TFunctionValue::PROG_INIT);
|
||||
range_setAdjust(TFunctionValue::ADJ_INIT);
|
||||
range_setOutside(TFunctionValue::OUT_INIT);
|
||||
}
|
||||
|
||||
void TFunctionValueAttribute_range::range_prepare() {
|
||||
TFunctionValue::TEProgress progress = range_getProgress();
|
||||
|
||||
switch (progress) {
|
||||
default:
|
||||
JUTWarn w;
|
||||
w << "unknown progress : " << progress;
|
||||
case 0:
|
||||
_20 = 0.0;
|
||||
_28 = 1.0;
|
||||
break;
|
||||
case 1:
|
||||
_20 = 0.0;
|
||||
_28 = -1.0;
|
||||
break;
|
||||
case 2:
|
||||
_20 = fBegin_;
|
||||
_28 = -1.0;
|
||||
break;
|
||||
case 3:
|
||||
_20 = fEnd_;
|
||||
_28 = -1.0;
|
||||
break;
|
||||
case 4:
|
||||
_20 = 0.5 * (fBegin_ + fEnd_);
|
||||
_28 = -1.0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void TFunctionValueAttribute_range::range_set(f64 begin, f64 end) {
|
||||
fBegin_ = begin;
|
||||
fEnd_ = end;
|
||||
fDifference_ = end - begin;
|
||||
|
||||
JUT_ASSERT(458, fDifference_>=TValue(0));
|
||||
}
|
||||
|
||||
f64 TFunctionValueAttribute_range::range_getParameter(f64 arg1, f64 arg2, f64 arg3) const {
|
||||
f64 progress = range_getParameter_progress(arg1);
|
||||
TFunctionValue::TEAdjust adjust = range_getAdjust();
|
||||
|
||||
f64 result;
|
||||
|
||||
switch (adjust) {
|
||||
default:
|
||||
JUTWarn w;
|
||||
w << "unknown adjust : " << adjust;
|
||||
case 0:
|
||||
result = range_getParameter_outside(progress);
|
||||
break;
|
||||
case 1:
|
||||
result = range_getParameter_outside(progress + fBegin_);
|
||||
break;
|
||||
case 2:
|
||||
result = range_getParameter_outside(progress + fEnd_);
|
||||
break;
|
||||
case 3:
|
||||
result = range_getParameter_outside(progress + 0.5 * (fBegin_ + fEnd_));
|
||||
break;
|
||||
case 4:
|
||||
f64 temp = range_getParameter_outside(progress);
|
||||
result = arg2 + ((temp - fBegin_) * (arg3 - arg2)) / fDifference_;
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
TFunctionValueAttribute_range::TFunctionValueAttribute_range()
|
||||
: fBegin_(NAN), fEnd_(fBegin_), fDifference_(fBegin_),
|
||||
mProgress(TFunctionValue::PROG_INIT), mAdjust(TFunctionValue::ADJ_INIT), _20(fBegin_),
|
||||
_28(fBegin_), mBegin(TFunctionValue::OUT_INIT), mEnd(TFunctionValue::OUT_INIT) {}
|
||||
|
||||
TFunctionValue_composite::TFunctionValue_composite() : pfn_(NULL), data((void*)NULL) {
|
||||
}
|
||||
|
||||
u32 TFunctionValue_composite::getType() const {
|
||||
return 1;
|
||||
}
|
||||
|
||||
TFunctionValueAttributeSet TFunctionValue_composite::getAttributeSet() {
|
||||
return TFunctionValueAttributeSet(this, NULL, NULL);
|
||||
}
|
||||
|
||||
void TFunctionValue_composite::initialize() {
|
||||
refer_initialize();
|
||||
pfn_ = NULL;
|
||||
data = TData((void*)NULL);
|
||||
}
|
||||
|
||||
void TFunctionValue_composite::prepare() {
|
||||
/* empty function */
|
||||
}
|
||||
|
||||
f64 TFunctionValue_composite::getValue(f64 arg1) {
|
||||
const TFunctionValueAttribute_refer* container = refer_getContainer();
|
||||
ASSERT(!refer_isReferring(this));
|
||||
ASSERT(pfn_ != NULL);
|
||||
|
||||
return pfn_(arg1, container, data_getData());
|
||||
}
|
||||
|
||||
f64 TFunctionValue_composite::composite_raw(TVector_pointer<TFunctionValue*> const& param_1,
|
||||
TData const& param_2, f64 param_3) {
|
||||
u32 index = param_2.get_unsignedInteger();
|
||||
if (index >= param_1.size()) {
|
||||
return 0.0;
|
||||
}
|
||||
TFunctionValue** p = (TFunctionValue**)param_1.begin();
|
||||
std::advance(p, index);
|
||||
JUT_ASSERT(0x247, p!=NULL);
|
||||
TFunctionValue* piVar4 = *p;
|
||||
return piVar4->getValue(param_3);
|
||||
}
|
||||
|
||||
|
||||
f64 TFunctionValue_composite::composite_index(TVector_pointer<TFunctionValue*> const& param_1,
|
||||
TData const& param_2, f64 param_3) {
|
||||
s32 size = param_1.size();
|
||||
if (size <= 1) {
|
||||
return 0.0;
|
||||
}
|
||||
TFunctionValue** local_148 = (TFunctionValue**)param_1.begin();
|
||||
TFunctionValue* pFront = *local_148;
|
||||
JUT_ASSERT(599, pFront!=NULL);
|
||||
TValue fData = pFront->getValue(param_3);
|
||||
s32 index = floor(fData);
|
||||
u32 uVar2 = param_2.get_outside();
|
||||
switch (uVar2) {
|
||||
case 0:
|
||||
case 3:
|
||||
default:
|
||||
if (index < 0) {
|
||||
index = 0;
|
||||
} else if (index >= size - 1) {
|
||||
index = size - 2;
|
||||
}
|
||||
break;
|
||||
case 1: {
|
||||
#ifdef __MWERKS__
|
||||
div_t dt = div(index, size - 1);
|
||||
#else
|
||||
div_t dt = div((int)index, (int)size - 1);
|
||||
#endif
|
||||
index = dt.rem;
|
||||
if (index < 0) {
|
||||
index = size + index;
|
||||
index--;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 2:
|
||||
if (size - 1 == 1) {
|
||||
index = 0;
|
||||
} else {
|
||||
u32 uVar3 = (u32)(size - 2) * 2;
|
||||
#ifdef __MWERKS__
|
||||
div_t dt2 = div(index, uVar3);
|
||||
#else
|
||||
div_t dt2 = div((int)index, (int)uVar3);
|
||||
#endif
|
||||
index = dt2.rem;
|
||||
if (index < 0) {
|
||||
index += uVar3;
|
||||
}
|
||||
if (index >= size - 1) {
|
||||
index = uVar3 - index;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
#ifdef __MWERKS__
|
||||
std::advance_pointer(local_148, index + 1);
|
||||
#else
|
||||
std::advance(local_148, index + 1);
|
||||
#endif
|
||||
pFront = *local_148;
|
||||
return pFront->getValue(param_3);
|
||||
}
|
||||
|
||||
|
||||
// TODO: remove when TContainerEnumerator_const is generic enough
|
||||
template <typename T>
|
||||
struct TContainerEnumerator_const_TVector : public JGadget::TEnumerator<const T*> {
|
||||
inline TContainerEnumerator_const_TVector(JGadget::TVector_pointer<T> const& param_1)
|
||||
: JGadget::TEnumerator<const T*>(param_1.begin(), param_1.end()) {}
|
||||
};
|
||||
|
||||
f64
|
||||
TFunctionValue_composite::composite_parameter(TVector_pointer<TFunctionValue*> const& param_1,
|
||||
TData const& param_2, f64 param_3) {
|
||||
f64 dVar4 = param_3 - param_2.get_value();
|
||||
TContainerEnumerator_const_TVector<TFunctionValue*> aTStack_18(param_1);
|
||||
while (aTStack_18) {
|
||||
TFunctionValue* const* ppiVar3 = *aTStack_18;
|
||||
TFunctionValue* piVar3 = *ppiVar3;
|
||||
dVar4 = piVar3->getValue(dVar4);
|
||||
}
|
||||
return dVar4;
|
||||
}
|
||||
|
||||
f64 TFunctionValue_composite::composite_add(TVector_pointer<TFunctionValue*> const& param_1,
|
||||
TData const& param_2, f64 param_3) {
|
||||
f64 dVar4 = param_2.get_value();
|
||||
TContainerEnumerator_const_TVector<TFunctionValue*> aTStack_18(param_1);
|
||||
while (aTStack_18) {
|
||||
TFunctionValue* const* p = *aTStack_18;
|
||||
JUT_ASSERT(0x2a1, p!=NULL);
|
||||
TFunctionValue* piVar3 = *p;
|
||||
dVar4 += piVar3->getValue(param_3);
|
||||
}
|
||||
return dVar4;
|
||||
}
|
||||
|
||||
f64 TFunctionValue_composite::composite_subtract(TVector_pointer<TFunctionValue*> const& param_1,
|
||||
TData const& param_2, f64 param_3) {
|
||||
u32 size = param_1.size();
|
||||
if (size == 0) {
|
||||
return 0.0;
|
||||
}
|
||||
TContainerEnumerator_const_TVector<TFunctionValue*> aTStack_18(param_1);
|
||||
TFunctionValue* const* local_148 = *aTStack_18;
|
||||
TFunctionValue* pFront = *local_148;
|
||||
JUT_ASSERT(688, pFront!=NULL);
|
||||
f64 dVar4 = pFront->getValue(param_3);
|
||||
while (aTStack_18) {
|
||||
TFunctionValue* const* p = *aTStack_18;
|
||||
JUT_ASSERT(0x2b5, p!=NULL);
|
||||
TFunctionValue* piVar3 = *p;
|
||||
dVar4 -= piVar3->getValue(param_3);
|
||||
}
|
||||
dVar4 -= param_2.f32data;
|
||||
return dVar4;
|
||||
}
|
||||
|
||||
|
||||
f64 TFunctionValue_composite::composite_multiply(TVector_pointer<TFunctionValue*> const& param_1,
|
||||
TData const& param_2, f64 param_3) {
|
||||
f64 dVar4 = param_2.get_value();
|
||||
TContainerEnumerator_const_TVector<TFunctionValue*> aTStack_18(param_1);
|
||||
while (aTStack_18) {
|
||||
TFunctionValue* const* p = *aTStack_18;
|
||||
JUT_ASSERT(0x2c5, p!=NULL);
|
||||
TFunctionValue* piVar3 = *p;
|
||||
dVar4 *= piVar3->getValue(param_3);
|
||||
}
|
||||
return dVar4;
|
||||
}
|
||||
|
||||
f64 TFunctionValue_composite::composite_divide(TVector_pointer<TFunctionValue*> const& param_1,
|
||||
TData const& param_2, f64 param_3) {
|
||||
u32 size = param_1.size();
|
||||
if (size == 0) {
|
||||
return 0.0;
|
||||
}
|
||||
TContainerEnumerator_const_TVector<TFunctionValue*> aTStack_18(param_1);
|
||||
TFunctionValue* const* local_148 = *aTStack_18;
|
||||
TFunctionValue* pFront = *local_148;
|
||||
JUT_ASSERT(724, pFront!=NULL);
|
||||
TValue fData = pFront->getValue(param_3);
|
||||
while (aTStack_18) {
|
||||
TFunctionValue* const* p = *aTStack_18;
|
||||
JUT_ASSERT(0x2d9, p!=NULL);
|
||||
TFunctionValue* piVar3 = *p;
|
||||
fData /= piVar3->getValue(param_3);
|
||||
JGADGET_ASSERTWARN(0x2db, fData!=TValue(0));
|
||||
}
|
||||
#if DEBUG
|
||||
TValue v = param_2.get_value();
|
||||
JGADGET_ASSERTWARN(0x2df, fData!=TValue(0));
|
||||
#endif
|
||||
fData /= param_2.f32data;
|
||||
return fData;
|
||||
}
|
||||
|
||||
#if PLATFORM_WII || PLATFORM_SHIELD
|
||||
#define NUMERIC_LIMIT double
|
||||
#else
|
||||
#define NUMERIC_LIMIT float
|
||||
#endif
|
||||
|
||||
TFunctionValue_constant::TFunctionValue_constant() : fValue_(std::numeric_limits<NUMERIC_LIMIT>::signaling_NaN()) {}
|
||||
|
||||
u32 TFunctionValue_constant::getType() const {
|
||||
return 2;
|
||||
}
|
||||
|
||||
TFunctionValueAttributeSet TFunctionValue_constant::getAttributeSet() {
|
||||
return TFunctionValueAttributeSet(NULL, NULL, NULL);
|
||||
}
|
||||
|
||||
void TFunctionValue_constant::initialize() {
|
||||
fValue_ = NAN;
|
||||
}
|
||||
|
||||
void TFunctionValue_constant::prepare() {
|
||||
/* empty function */
|
||||
}
|
||||
|
||||
f64 TFunctionValue_constant::getValue(f64 arg1) {
|
||||
return fValue_;
|
||||
}
|
||||
|
||||
TFunctionValue_transition::TFunctionValue_transition() : _48(NAN), _50(_48) {}
|
||||
|
||||
u32 TFunctionValue_transition::getType() const {
|
||||
return 3;
|
||||
}
|
||||
|
||||
TFunctionValueAttributeSet TFunctionValue_transition::getAttributeSet() {
|
||||
return TFunctionValueAttributeSet(NULL, this, this);
|
||||
}
|
||||
|
||||
void TFunctionValue_transition::initialize() {
|
||||
range_initialize();
|
||||
interpolate_initialize();
|
||||
|
||||
_48 = NAN;
|
||||
_50 = _48;
|
||||
}
|
||||
|
||||
void TFunctionValue_transition::prepare() {
|
||||
range_prepare();
|
||||
interpolate_prepare();
|
||||
}
|
||||
|
||||
f64 TFunctionValue_transition::getValue(f64 param_1) {
|
||||
f64 progress = range_getParameter_progress(param_1);
|
||||
f64 dVar3 = range_getParameter_outside(progress);
|
||||
switch (range_getAdjust()) {
|
||||
default:
|
||||
if (dVar3 < range_getBegin()) {
|
||||
return _48;
|
||||
}
|
||||
return _50;
|
||||
case TFunctionValue::ADJ_UNK2:
|
||||
if (dVar3 < range_getEnd()) {
|
||||
return _48;
|
||||
}
|
||||
return _50;
|
||||
case TFunctionValue::ADJ_UNK3:
|
||||
ADJ_UNK3_label:
|
||||
if (dVar3 < 0.5 * (range_getBegin() + range_getEnd())) {
|
||||
return _48;
|
||||
}
|
||||
return _50;
|
||||
case TFunctionValue::ADJ_UNK4:
|
||||
if (dVar3 < range_getBegin()) {
|
||||
return _48;
|
||||
}
|
||||
if (dVar3 >= range_getEnd()) {
|
||||
return _50;
|
||||
}
|
||||
switch (interpolate_get()) {
|
||||
case 0:
|
||||
goto ADJ_UNK3_label;
|
||||
case 1:
|
||||
case 3:
|
||||
return _48 + ((dVar3 - range_getBegin()) * data_getDifference()) / range_getDifference();
|
||||
case 2:
|
||||
return functionvalue::interpolateValue_plateau(dVar3, range_getBegin(), _48, range_getEnd(), _50);
|
||||
default:
|
||||
goto ADJ_UNK3_label;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TFunctionValue_list::TFunctionValue_list() : _44(NULL), uData_(0), _50(NAN), pfnUpdate_(NULL) {}
|
||||
|
||||
u32 TFunctionValue_list::getType() const {
|
||||
return 4;
|
||||
}
|
||||
|
||||
TFunctionValueAttributeSet TFunctionValue_list::getAttributeSet() {
|
||||
return TFunctionValueAttributeSet(NULL, this, this);
|
||||
}
|
||||
|
||||
void TFunctionValue_list::initialize() {
|
||||
range_initialize();
|
||||
interpolate_initialize();
|
||||
|
||||
_44 = NULL;
|
||||
uData_ = 0;
|
||||
_50 = NAN;
|
||||
pfnUpdate_ = NULL;
|
||||
}
|
||||
|
||||
void TFunctionValue_list::prepare() {
|
||||
range_prepare();
|
||||
interpolate_prepare();
|
||||
|
||||
u32 interp = interpolate_get();
|
||||
|
||||
switch (interp) {
|
||||
default:
|
||||
JUTWarn w;
|
||||
w << "unknown interpolation : " << interp;
|
||||
case 0:
|
||||
pfnUpdate_ = update_INTERPOLATE_NONE_;
|
||||
break;
|
||||
case 1:
|
||||
pfnUpdate_ = update_INTERPOLATE_LINEAR_;
|
||||
break;
|
||||
case 2:
|
||||
pfnUpdate_ = update_INTERPOLATE_PLATEAU_;
|
||||
break;
|
||||
case 3:
|
||||
pfnUpdate_ = update_INTERPOLATE_BSPLINE_dataMore3_;
|
||||
if (uData_ == 2)
|
||||
pfnUpdate_ = update_INTERPOLATE_LINEAR_;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
f64 TFunctionValue_list::getValue(f64 param_1) {
|
||||
f64 dVar9 = range_getParameter_progress(param_1);
|
||||
u32 iVar7 = uData_ - 1;
|
||||
TFunctionValue::TEAdjust iVar5 = range_getAdjust();
|
||||
f64 dVar12 = iVar7;
|
||||
TIndexData_ local_178;
|
||||
f64 parOutside;
|
||||
switch (iVar5) {
|
||||
case 0:
|
||||
default:
|
||||
parOutside = range_getParameter_outside(dVar9);
|
||||
local_178._0 = parOutside / _50;
|
||||
break;
|
||||
case 1:
|
||||
parOutside = range_getParameter_outside(dVar9 + range_getBegin());
|
||||
local_178._0 = parOutside / _50;
|
||||
break;
|
||||
case 2:
|
||||
parOutside = range_getParameter_outside(dVar9 + range_getEnd());
|
||||
local_178._0 = parOutside / _50;
|
||||
break;
|
||||
case 3:
|
||||
parOutside = range_getParameter_outside(dVar9 + 0.5 * (range_getBegin() + range_getEnd()));
|
||||
local_178._0 = parOutside / _50;
|
||||
break;
|
||||
case 4:
|
||||
parOutside = range_getParameter_outside(dVar9);
|
||||
local_178._0 = (dVar12 * (parOutside - range_getBegin())) / range_getDifference();
|
||||
break;
|
||||
}
|
||||
|
||||
if (local_178._0 < 0.0) {
|
||||
return _44[0];
|
||||
}
|
||||
if (local_178._0 >= dVar12) {
|
||||
return _44[iVar7];
|
||||
}
|
||||
local_178._8 = floor(local_178._0);
|
||||
local_178._10 = local_178._8;
|
||||
JUT_ASSERT(1063, pfnUpdate_!=NULL);
|
||||
return pfnUpdate_(*this, local_178);
|
||||
}
|
||||
|
||||
|
||||
f64 TFunctionValue_list::update_INTERPOLATE_NONE_(const TFunctionValue_list& rThis,
|
||||
const TIndexData_& data) {
|
||||
return rThis._44[data._10];
|
||||
}
|
||||
|
||||
f64 TFunctionValue_list::update_INTERPOLATE_LINEAR_(const TFunctionValue_list& rThis,
|
||||
const TIndexData_& data) {
|
||||
return functionvalue::interpolateValue_linear_1(data._0, data._8, rThis._44[data._10],
|
||||
rThis._44[data._10 + 1]);
|
||||
}
|
||||
|
||||
f64 TFunctionValue_list::update_INTERPOLATE_PLATEAU_(const TFunctionValue_list& rThis,
|
||||
const TIndexData_& data) {
|
||||
const f32* arr = rThis._44;
|
||||
|
||||
return functionvalue::interpolateValue_plateau(data._0, data._8, arr[data._10],
|
||||
1.0 + data._8, arr[data._10 + 1]);
|
||||
}
|
||||
|
||||
|
||||
f64 TFunctionValue_list::update_INTERPOLATE_BSPLINE_dataMore3_(
|
||||
TFunctionValue_list const& rThis, TFunctionValue_list::TIndexData_ const& param_2) {
|
||||
f64 dVar11 = rThis._44[param_2._10];
|
||||
f64 dVar10 = rThis._44[param_2._10 + 1];
|
||||
f64 dVar9;
|
||||
f64 dVar8;
|
||||
if (param_2._10 == 0) {
|
||||
JUT_ASSERT(1119, rThis.uData_>=3);
|
||||
dVar9 = 2.0 * dVar11 - dVar10;
|
||||
dVar8 = rThis._44[param_2._10 + 2];
|
||||
} else {
|
||||
if (param_2._10 == rThis.uData_ - 2) {
|
||||
JUT_ASSERT(1125, rThis.uData_>=3);
|
||||
dVar9 = rThis._44[param_2._10 - 1];
|
||||
dVar8 = 2.0 * dVar10 - dVar11;
|
||||
} else {
|
||||
JUT_ASSERT(1131, rThis.uData_>=3);
|
||||
dVar9 = rThis._44[param_2._10 - 1];
|
||||
dVar8 = rThis._44[param_2._10 + 2];
|
||||
}
|
||||
}
|
||||
return functionvalue::interpolateValue_BSpline_uniform(param_2._0 - param_2._8, dVar9, dVar11, dVar10, dVar8);
|
||||
}
|
||||
|
||||
|
||||
TFunctionValue_list_parameter::TFunctionValue_list_parameter()
|
||||
: pfData_(NULL), uData_(0), dat1(*this, NULL), dat2(dat1), dat3(dat1), pfnUpdate_(NULL) {}
|
||||
|
||||
u32 TFunctionValue_list_parameter::getType() const {
|
||||
return 5;
|
||||
}
|
||||
|
||||
TFunctionValueAttributeSet TFunctionValue_list_parameter::getAttributeSet() {
|
||||
return TFunctionValueAttributeSet(NULL, this, this);
|
||||
}
|
||||
|
||||
void TFunctionValue_list_parameter::data_set(const f32* pf, u32 u) {
|
||||
JUT_ASSERT(1277, (pf != NULL) || (u == 0));
|
||||
|
||||
pfData_ = pf;
|
||||
uData_ = u;
|
||||
|
||||
dat1.set(pfData_);
|
||||
dat2.set(&pfData_[uData_ * 2]);
|
||||
dat3 = dat1;
|
||||
#if DEBUG
|
||||
pfnUpdate_ = NULL;
|
||||
#endif
|
||||
}
|
||||
|
||||
void TFunctionValue_list_parameter::initialize() {
|
||||
range_initialize();
|
||||
interpolate_initialize();
|
||||
|
||||
pfData_ = NULL;
|
||||
uData_ = 0;
|
||||
|
||||
TIterator_data_ iter(*this, NULL);
|
||||
|
||||
dat1 = iter;
|
||||
dat2 = dat1;
|
||||
dat3 = dat1;
|
||||
pfnUpdate_ = NULL;
|
||||
}
|
||||
|
||||
void TFunctionValue_list_parameter::prepare() {
|
||||
range_prepare();
|
||||
interpolate_prepare();
|
||||
|
||||
u32 interp = interpolate_get();
|
||||
switch (interp) {
|
||||
default:
|
||||
JUTWarn w;
|
||||
w << "unknown interpolation : " << interp;
|
||||
case 0:
|
||||
pfnUpdate_ = update_INTERPOLATE_NONE_;
|
||||
break;
|
||||
case 1:
|
||||
pfnUpdate_ = update_INTERPOLATE_LINEAR_;
|
||||
break;
|
||||
case 2:
|
||||
pfnUpdate_ = update_INTERPOLATE_PLATEAU_;
|
||||
break;
|
||||
case 3:
|
||||
pfnUpdate_ = update_INTERPOLATE_BSPLINE_dataMore3_;
|
||||
if (uData_ != 2)
|
||||
return;
|
||||
pfnUpdate_ = update_INTERPOLATE_LINEAR_;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
f64 TFunctionValue_list_parameter::getValue(f64 param_0) {
|
||||
param_0 = range_getParameter(param_0, data_getValue_front(), data_getValue_back());
|
||||
JUT_ASSERT(1395, pfData_!=NULL)
|
||||
|
||||
dat3 = JGadget::findUpperBound_binary_current(dat1, dat2, dat3, param_0);
|
||||
if (dat3 == dat1) {
|
||||
return dat3.get()[1];
|
||||
}
|
||||
if (dat3 == dat2) {
|
||||
--dat3;
|
||||
return dat3.get()[1];
|
||||
}
|
||||
|
||||
const f32* pf = dat3.get();
|
||||
JUT_ASSERT(1411, (pfData_<=pf-suData_size)&&(pf<pfData_+suData_size*uData_));
|
||||
JUT_ASSERT(1412, pfnUpdate_!=NULL);
|
||||
return pfnUpdate_(*this, param_0);
|
||||
}
|
||||
|
||||
f64 TFunctionValue_list_parameter::update_INTERPOLATE_NONE_(
|
||||
const TFunctionValue_list_parameter& rThis, f64 d) {
|
||||
return rThis.dat3.get()[-1];
|
||||
}
|
||||
|
||||
f64 TFunctionValue_list_parameter::update_INTERPOLATE_LINEAR_(
|
||||
const TFunctionValue_list_parameter& rThis, f64 d) {
|
||||
const f32* a = rThis.dat3.get();
|
||||
return functionvalue::interpolateValue_linear(d, a[-2], a[-1], a[0], a[1]);
|
||||
}
|
||||
|
||||
f64 TFunctionValue_list_parameter::update_INTERPOLATE_PLATEAU_(
|
||||
const TFunctionValue_list_parameter& rThis, f64 d) {
|
||||
const f32* a = rThis.dat3.get();
|
||||
return functionvalue::interpolateValue_plateau(d, a[-2], a[-1], a[0], a[1]);
|
||||
}
|
||||
|
||||
|
||||
f64 TFunctionValue_list_parameter::update_INTERPOLATE_BSPLINE_dataMore3_(
|
||||
TFunctionValue_list_parameter const& rThis, f64 param_2) {
|
||||
JUT_ASSERT(1457, rThis.uData_>=3)
|
||||
const f32* pfVar2 = rThis.dat3.get();
|
||||
f64 local_68[4];
|
||||
f64 local_48[6];
|
||||
local_68[1] = pfVar2[-1];
|
||||
local_68[2] = pfVar2[1];
|
||||
local_48[2] = pfVar2[-2];
|
||||
local_48[3] = pfVar2[0];
|
||||
s32 iVar5 = ((intptr_t)pfVar2 - (intptr_t)rThis.dat1.get()) / 4;
|
||||
s32 iVar3 = ((intptr_t)rThis.dat2.get() - (intptr_t)pfVar2) / 4;
|
||||
switch(iVar5) {
|
||||
case 2:
|
||||
local_68[0] = 2.0 * local_68[1] - local_68[2];
|
||||
local_68[3] = pfVar2[3];
|
||||
local_48[4] = pfVar2[2];
|
||||
local_48[1] = 2.0 * local_48[2] - local_48[3];
|
||||
local_48[0] = 2.0 * local_48[2] - local_48[4];
|
||||
switch (iVar3) {
|
||||
case 2:
|
||||
JUT_ASSERT(1481, false);
|
||||
case 4:
|
||||
local_48[5] = 2.0 * local_48[4] - local_48[3];
|
||||
break;
|
||||
default:
|
||||
local_48[5] = pfVar2[4];
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case 4:
|
||||
local_68[0] = pfVar2[-3];
|
||||
local_48[1] = pfVar2[-4];
|
||||
local_48[0] = 2.0 * local_48[1] - local_48[2];
|
||||
switch (iVar3)
|
||||
{
|
||||
case 2:
|
||||
local_68[3] = 2.0 * local_68[2] - local_68[1];
|
||||
local_48[4] = 2.0 * local_48[3] - local_48[2];
|
||||
local_48[5] = 2.0 * local_48[3] - local_48[1];
|
||||
break;
|
||||
case 4:
|
||||
local_68[3] = pfVar2[3];
|
||||
local_48[4] = pfVar2[2];
|
||||
local_48[5] = 2.0 * local_48[4] - local_48[3];
|
||||
break;
|
||||
default:
|
||||
local_68[3] = pfVar2[3];
|
||||
local_48[4] = pfVar2[2];
|
||||
local_48[5] = pfVar2[4];
|
||||
}
|
||||
break;
|
||||
default:
|
||||
local_68[0] = pfVar2[-3];
|
||||
local_48[1] = pfVar2[-4];
|
||||
local_48[0] = pfVar2[-6];
|
||||
switch (iVar3) {
|
||||
case 2:
|
||||
local_68[3] = 2.0 * local_68[2] - local_68[1];
|
||||
local_48[4] = 2.0 * local_48[3] - local_48[2];
|
||||
local_48[5] = 2.0 * local_48[3] - local_48[1];
|
||||
break;
|
||||
case 4:
|
||||
local_68[3] = pfVar2[3];
|
||||
local_48[4] = pfVar2[2];
|
||||
local_48[5] = 2.0 * local_48[4] - local_48[3];
|
||||
break;
|
||||
default:
|
||||
local_68[3] = pfVar2[3];
|
||||
local_48[4] = pfVar2[2];
|
||||
local_48[5] = pfVar2[4];
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
return functionvalue::interpolateValue_BSpline_nonuniform(param_2, local_68, local_48);
|
||||
}
|
||||
|
||||
|
||||
TFunctionValue_hermite::TFunctionValue_hermite()
|
||||
: pfData_(NULL), u_(0), uSize_(0), dat1(*this, NULL), dat2(dat1), dat3(dat1) {}
|
||||
|
||||
u32 JStudio::TFunctionValue_hermite::getType() const {
|
||||
return 6;
|
||||
}
|
||||
|
||||
TFunctionValueAttributeSet TFunctionValue_hermite::getAttributeSet() {
|
||||
return TFunctionValueAttributeSet(NULL, this, NULL);
|
||||
}
|
||||
|
||||
void TFunctionValue_hermite::data_set(const f32* pf, u32 u, u32 uSize) {
|
||||
JUT_ASSERT(1676, (pf != NULL) || (u == 0));
|
||||
JUT_ASSERT(1677, (uSize == 3) || (uSize == 4));
|
||||
|
||||
pfData_ = pf;
|
||||
u_ = u;
|
||||
uSize_ = uSize;
|
||||
|
||||
dat1.set(pfData_, uSize_);
|
||||
dat2.set(&pfData_[u_ * uSize_], uSize_);
|
||||
dat3 = dat1;
|
||||
}
|
||||
|
||||
void TFunctionValue_hermite::initialize() {
|
||||
range_initialize();
|
||||
|
||||
pfData_ = NULL;
|
||||
u_ = 0;
|
||||
uSize_ = 0;
|
||||
|
||||
dat1 = TIterator_data_(*this, NULL);
|
||||
dat2 = dat1;
|
||||
dat3 = dat1;
|
||||
}
|
||||
|
||||
void TFunctionValue_hermite::prepare() {
|
||||
range_prepare();
|
||||
}
|
||||
|
||||
f64 TFunctionValue_hermite::getValue(f64 param_0) {
|
||||
param_0 = range_getParameter(param_0, data_getValue_front(), data_getValue_back());
|
||||
JUT_ASSERT(1716, pfData_!=NULL)
|
||||
|
||||
dat3 = JGadget::findUpperBound_binary_current(dat1, dat2, dat3, param_0);
|
||||
|
||||
if (dat3 == dat1) {
|
||||
return dat3.get()[1];
|
||||
}
|
||||
if (dat3 == dat2) {
|
||||
--dat3;
|
||||
return dat3.get()[1];
|
||||
}
|
||||
|
||||
const f32* pfVar5 = dat3.get();
|
||||
const f32* pfVar7 = pfVar5 - uSize_;
|
||||
return functionvalue::interpolateValue_hermite(
|
||||
param_0, pfVar7[0], pfVar7[1],
|
||||
pfVar7[uSize_ - 1], pfVar5[0],
|
||||
pfVar5[1], pfVar5[2]);
|
||||
}
|
||||
|
||||
} // namespace JStudio
|
||||
@@ -0,0 +1,18 @@
|
||||
#include "JSystem/JSystem.h" // IWYU pragma: keep
|
||||
|
||||
#include "JSystem/JStudio/JStudio/fvb-data-parse.h"
|
||||
|
||||
void JStudio::fvb::data::TParse_TParagraph::getData(TParse_TParagraph::TData* pData) const
|
||||
{
|
||||
JUT_ASSERT(24, pData!=NULL);
|
||||
const void *ptr = getRaw();
|
||||
ptr = JGadget::binary::parseVariableUInt_16_32_following(ptr, (u32*)pData, (u32*)&pData->u32Type, NULL);
|
||||
u32 t = (u32)pData->u32Size;
|
||||
if (!t) {
|
||||
pData->pContent = NULL;
|
||||
pData->next = (const u16*)ptr;
|
||||
} else {
|
||||
pData->pContent = (const u16*)ptr;
|
||||
pData->next = (u8*)ptr + JGadget::binary::align_roundUp(t, 4);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
#include "JSystem/JSystem.h" // IWYU pragma: keep
|
||||
|
||||
#include "JSystem/JStudio/JStudio/fvb-data.h"
|
||||
|
||||
const char JStudio::fvb::data::ga4cSignature[4] = "FVB";
|
||||
@@ -0,0 +1,460 @@
|
||||
#include "JSystem/JSystem.h" // IWYU pragma: keep
|
||||
|
||||
#include "JSystem/JStudio/JStudio/fvb.h"
|
||||
#include "JSystem/JUtility/JUTException.h"
|
||||
#include <cstring>
|
||||
|
||||
namespace JStudio {
|
||||
namespace fvb {
|
||||
|
||||
TObject::~TObject() {
|
||||
JGADGET_ASSERTWARN(26, pfv_!=NULL);
|
||||
}
|
||||
|
||||
void TObject::prepare(data::TParse_TBlock const& rBlock, TControl* pControl) {
|
||||
JUT_ASSERT(35, pfv_!=NULL);
|
||||
JUT_ASSERT(36, pControl!=NULL);
|
||||
TFunctionValueAttributeSet set = pfv_->getAttributeSet();
|
||||
const void* pNext = (const void*)rBlock.getNext();
|
||||
const void* pData = (const void*)rBlock.getContent();
|
||||
while (pData < pNext) {
|
||||
data::TParse_TParagraph para(pData);
|
||||
data::TParse_TParagraph::TData dat;
|
||||
para.getData(&dat);
|
||||
u32 u32Type = dat.u32Type;
|
||||
u32 u32Size = dat.u32Size;
|
||||
const void* pContent = dat.pContent;
|
||||
switch (u32Type) {
|
||||
case 0:
|
||||
goto end;
|
||||
case 1:
|
||||
prepare_data_(dat, pControl);
|
||||
break;
|
||||
case 0x10: {
|
||||
JGADGET_ASSERTWARN(61, u32Size>=4);
|
||||
JUT_ASSERT(62, pContent!=NULL);
|
||||
TFunctionValueAttribute_refer* pfvaRefer = set.refer_get();
|
||||
JGADGET_ASSERTWARN(64, pfvaRefer!=NULL);
|
||||
if (pfvaRefer == NULL) {
|
||||
JGADGET_WARNMSG(67, "invalid paragraph");
|
||||
break;
|
||||
}
|
||||
JGadget::TVector_pointer<TFunctionValue*>& rCnt = pfvaRefer->refer_referContainer();
|
||||
u8* content = (u8*)pContent;
|
||||
u32 i = *(u32*)content;
|
||||
u8* ptr = content + 4;
|
||||
for (; i != 0; i--) {
|
||||
u32 size = *(u32*)ptr;
|
||||
TObject* pObject = pControl->getObject(ptr + 4, size);
|
||||
if (pObject != NULL) {
|
||||
TFunctionValue* const rfv = pObject->referFunctionValue();
|
||||
TFunctionValue* const* pRfv = &rfv;
|
||||
rCnt.push_back(*pRfv);
|
||||
} else {
|
||||
JGADGET_WARNMSG(85, "object not found by ID");
|
||||
}
|
||||
ptr += align_roundUp(size, 4) + 4;
|
||||
}
|
||||
} break;
|
||||
case 0x11: {
|
||||
JGADGET_ASSERTWARN(93, u32Size>=4);
|
||||
JUT_ASSERT(94, pContent!=NULL);
|
||||
TFunctionValueAttribute_refer* pfvaRefer = set.refer_get();
|
||||
JGADGET_ASSERTWARN(96, pfvaRefer!=NULL);
|
||||
if (pfvaRefer == NULL) {
|
||||
JGADGET_WARNMSG(99, "invalid paragraph");
|
||||
break;
|
||||
}
|
||||
|
||||
JGadget::TVector_pointer<TFunctionValue*>& rCnt = pfvaRefer->refer_referContainer();
|
||||
u8* ptr = (u8*)pContent;
|
||||
u32 i = *(u32*)ptr;
|
||||
for (; ptr += 4, i != 0; i--) {
|
||||
u32 index = *(u32*)ptr;
|
||||
TObject* pObject = pControl->getObject_index(index);
|
||||
if (pObject != NULL) {
|
||||
TFunctionValue* const rfv = pObject->referFunctionValue();
|
||||
TFunctionValue* const* pRfv = &rfv;
|
||||
rCnt.push_back(*pRfv);
|
||||
} else {
|
||||
JGADGET_WARNMSG(114, "object not found by index : " << index);
|
||||
}
|
||||
}
|
||||
} break;
|
||||
case 0x12: {
|
||||
JGADGET_ASSERTWARN(121, u32Size==8);
|
||||
JUT_ASSERT(122, pContent!=NULL);
|
||||
TFunctionValueAttribute_range* pfvaRange = set.range_get();
|
||||
JGADGET_ASSERTWARN(124, pfvaRange!=NULL);
|
||||
if (pfvaRange == NULL) {
|
||||
JGADGET_WARNMSG(127, "invalid paragraph");
|
||||
break;
|
||||
}
|
||||
f32* arr = (f32*)pContent;
|
||||
pfvaRange->range_set(arr[0], arr[1]);
|
||||
} break;
|
||||
case 0x13: {
|
||||
JGADGET_ASSERTWARN(138, u32Size==4);
|
||||
JUT_ASSERT(139, pContent!=NULL);
|
||||
TFunctionValueAttribute_range* pfvaRange = set.range_get();
|
||||
JGADGET_ASSERTWARN(141, pfvaRange!=NULL);
|
||||
if (pfvaRange == NULL) {
|
||||
JGADGET_WARNMSG(144, "invalid paragraph");
|
||||
break;
|
||||
}
|
||||
|
||||
TFunctionValue::TEProgress prog = *(TFunctionValue::TEProgress*)pContent;
|
||||
pfvaRange->range_setProgress(prog);
|
||||
} break;
|
||||
case 0x14: {
|
||||
JGADGET_ASSERTWARN(156, u32Size==4);
|
||||
JUT_ASSERT(157, pContent!=NULL);
|
||||
TFunctionValueAttribute_range* pfvaRange = set.range_get();
|
||||
JGADGET_ASSERTWARN(159, pfvaRange!=NULL);
|
||||
if (pfvaRange == NULL) {
|
||||
JGADGET_WARNMSG(162, "invalid paragraph");
|
||||
break;
|
||||
}
|
||||
|
||||
TFunctionValue::TEAdjust adjust = *(TFunctionValue::TEAdjust*)pContent;
|
||||
pfvaRange->range_setAdjust(adjust);
|
||||
} break;
|
||||
case 0x15: {
|
||||
JGADGET_ASSERTWARN(174, u32Size==4);
|
||||
JUT_ASSERT(175, pContent!=NULL);
|
||||
TFunctionValueAttribute_range* pfvaRange = set.range_get();
|
||||
JGADGET_ASSERTWARN(177, pfvaRange!=NULL);
|
||||
if (pfvaRange == NULL) {
|
||||
JGADGET_WARNMSG(180, "invalid paragraph");
|
||||
break;
|
||||
}
|
||||
|
||||
u16* out = (u16*)pContent;
|
||||
pfvaRange->range_setOutside((TFunctionValue::TEOutside)out[0],
|
||||
(TFunctionValue::TEOutside)out[1]);
|
||||
} break;
|
||||
case 0x16: {
|
||||
JGADGET_ASSERTWARN(193, u32Size==4);
|
||||
JUT_ASSERT(194, pContent!=NULL);
|
||||
TFunctionValueAttribute_interpolate* pfvaInterpolate = set.interpolate_get();
|
||||
JGADGET_ASSERTWARN(197, pfvaInterpolate!=NULL);
|
||||
if (pfvaInterpolate == NULL) {
|
||||
JGADGET_WARNMSG(200, "invalid paragraph");
|
||||
break;
|
||||
}
|
||||
|
||||
TFunctionValue::TEInterpolate interp = *(TFunctionValue::TEInterpolate*)pContent;
|
||||
pfvaInterpolate->interpolate_set(interp);
|
||||
} break;
|
||||
default:
|
||||
JGADGET_WARNMSG(211, "unknown paragraph : " << u32Type);
|
||||
}
|
||||
pData = dat.next;
|
||||
JUT_ASSERT(214, pData!=NULL);
|
||||
}
|
||||
end:
|
||||
JGADGET_ASSERTWARN(216, pData==pNext);
|
||||
pfv_->prepare();
|
||||
}
|
||||
|
||||
namespace {
|
||||
|
||||
TFunctionValue_composite::TData getCompositeData_raw_(const void* arg1) {
|
||||
return TFunctionValue_composite::TData(*(const void**)arg1);
|
||||
}
|
||||
|
||||
TFunctionValue_composite::TData getCompositeData_index_(const void* arg1) {
|
||||
return TFunctionValue_composite::TData(*(u32*)arg1);
|
||||
}
|
||||
|
||||
TFunctionValue_composite::TData getCompositeData_parameter_(const void* arg1) {
|
||||
return TFunctionValue_composite::TData(*(f32*)arg1);
|
||||
}
|
||||
|
||||
TFunctionValue_composite::TData getCompositeData_add_(const void* arg1) {
|
||||
return TFunctionValue_composite::TData(*(f32*)arg1);
|
||||
}
|
||||
|
||||
TFunctionValue_composite::TData getCompositeData_subtract_(const void* arg1) {
|
||||
return TFunctionValue_composite::TData(*(f32*)arg1);
|
||||
}
|
||||
|
||||
TFunctionValue_composite::TData getCompositeData_multiply_(const void* arg1) {
|
||||
return TFunctionValue_composite::TData(*(f32*)arg1);
|
||||
}
|
||||
|
||||
TFunctionValue_composite::TData getCompositeData_divide_(const void* arg1) {
|
||||
return TFunctionValue_composite::TData(*(f32*)arg1);
|
||||
}
|
||||
|
||||
const data::CompositeOperation saCompositeOperation_[8] = {
|
||||
{NULL, NULL},
|
||||
{&TFunctionValue_composite::composite_raw, &getCompositeData_raw_},
|
||||
{&TFunctionValue_composite::composite_index, &getCompositeData_index_},
|
||||
{&TFunctionValue_composite::composite_parameter, &getCompositeData_parameter_},
|
||||
{&TFunctionValue_composite::composite_add, &getCompositeData_add_},
|
||||
{&TFunctionValue_composite::composite_subtract, &getCompositeData_subtract_},
|
||||
{&TFunctionValue_composite::composite_multiply, &getCompositeData_multiply_},
|
||||
{&TFunctionValue_composite::composite_divide, &getCompositeData_divide_},
|
||||
};
|
||||
|
||||
static const data::CompositeOperation* getCompositeOperation_(data::TEComposite comp) {
|
||||
return &saCompositeOperation_[comp];
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
TObject_composite::TObject_composite(const data::TParse_TBlock& block) : TObject(block, &fnValue) {}
|
||||
|
||||
void TObject_composite::prepare_data_(const data::TParse_TParagraph::TData& rData,
|
||||
TControl* control) {
|
||||
JUT_ASSERT(306, rData.u32Type==data::PARAGRAPH_DATA);
|
||||
u32 u32Size = rData.u32Size;
|
||||
struct unknown {
|
||||
data::TEComposite composite_type;
|
||||
u32 data;
|
||||
};
|
||||
|
||||
const unknown* pContent = static_cast<const unknown*>(rData.pContent);
|
||||
JGADGET_ASSERTWARN(310, u32Size== 8);
|
||||
JUT_ASSERT(311, pContent!=NULL);
|
||||
|
||||
data::TEComposite type = pContent->composite_type;
|
||||
const data::CompositeOperation* op = getCompositeOperation_(type);
|
||||
data::CompositeDataFunc pfn = op->getCompositeData;
|
||||
JUT_ASSERT(316, pfn!=NULL);
|
||||
fnValue.data_set(op->composite, pfn(&pContent->data));
|
||||
}
|
||||
|
||||
TObject_constant::TObject_constant(data::TParse_TBlock const& param_0)
|
||||
: TObject(param_0, &fnValue) {}
|
||||
|
||||
void TObject_constant::prepare_data_(const data::TParse_TParagraph::TData& rData,
|
||||
TControl* control) {
|
||||
JUT_ASSERT(337, rData.u32Type==data::PARAGRAPH_DATA);
|
||||
|
||||
u32 u32Size = rData.u32Size;
|
||||
const f32* pContent = static_cast<const f32*>(rData.pContent);
|
||||
JGADGET_ASSERTWARN(341, u32Size==4);
|
||||
JUT_ASSERT(342, pContent!=NULL);
|
||||
f32 val = pContent[0];
|
||||
fnValue.data_set(val);
|
||||
}
|
||||
|
||||
TObject_transition::TObject_transition(data::TParse_TBlock const& param_0)
|
||||
: TObject(param_0, &fnValue) {}
|
||||
|
||||
void TObject_transition::prepare_data_(const data::TParse_TParagraph::TData& rData,
|
||||
TControl* control) {
|
||||
ASSERT(rData.u32Type == data::PARAGRAPH_DATA);
|
||||
|
||||
u32 u32Size = rData.u32Size;
|
||||
JGADGET_ASSERTWARN(0, u32Size == 8);
|
||||
|
||||
const f32* pContent = static_cast<const f32*>(rData.pContent);
|
||||
ASSERT(pContent != NULL);
|
||||
|
||||
fnValue.data_set(pContent[0], pContent[1]);
|
||||
}
|
||||
|
||||
TObject_list::TObject_list(data::TParse_TBlock const& param_0) : TObject(param_0, &fnValue) {}
|
||||
|
||||
void TObject_list::prepare_data_(const data::TParse_TParagraph::TData& rData, TControl* control) {
|
||||
ASSERT(rData.u32Type == data::PARAGRAPH_DATA);
|
||||
|
||||
u32 u32Size = rData.u32Size;
|
||||
JGADGET_ASSERTWARN(0, u32Size >= 8);
|
||||
|
||||
const ListData* pContent = static_cast<const ListData*>(rData.pContent);
|
||||
ASSERT(pContent != NULL);
|
||||
|
||||
fnValue.data_setInterval(pContent->_0);
|
||||
fnValue.data_set(pContent->_8, pContent->_4);
|
||||
}
|
||||
|
||||
TObject_list_parameter::TObject_list_parameter(data::TParse_TBlock const& param_0)
|
||||
: TObject(param_0, &fnValue) {}
|
||||
|
||||
void TObject_list_parameter::prepare_data_(const data::TParse_TParagraph::TData& rData,
|
||||
TControl* control) {
|
||||
ASSERT(rData.u32Type == data::PARAGRAPH_DATA);
|
||||
|
||||
u32 u32Size = rData.u32Size;
|
||||
JGADGET_ASSERTWARN(0, u32Size >= 8);
|
||||
|
||||
const ListData* pContent = static_cast<const ListData*>(rData.pContent);
|
||||
ASSERT(pContent != NULL);
|
||||
|
||||
fnValue.data_set(pContent->_4, pContent->_0);
|
||||
}
|
||||
|
||||
TObject_hermite::TObject_hermite(data::TParse_TBlock const& param_0) : TObject(param_0, &fnValue) {}
|
||||
|
||||
void TObject_hermite::prepare_data_(const data::TParse_TParagraph::TData& rData,
|
||||
TControl* control) {
|
||||
ASSERT(rData.u32Type == data::PARAGRAPH_DATA);
|
||||
|
||||
u32 u32Size = rData.u32Size;
|
||||
JGADGET_ASSERTWARN(0, u32Size >= 8);
|
||||
|
||||
const ListData* pContent = static_cast<const ListData*>(rData.pContent);
|
||||
ASSERT(pContent != NULL);
|
||||
|
||||
fnValue.data_set(pContent->_4, pContent->_0 & 0xFFFFFFF, pContent->_0 >> 0x1C);
|
||||
}
|
||||
|
||||
TControl::TControl() : pFactory(NULL) {}
|
||||
|
||||
TControl::~TControl() {
|
||||
JGADGET_ASSERTWARN(0, ocObject_.empty());
|
||||
}
|
||||
|
||||
void TControl::appendObject(TObject* object) {
|
||||
ocObject_.Push_back(object);
|
||||
}
|
||||
|
||||
void TControl::removeObject(TObject* object) {
|
||||
ocObject_.Erase(object);
|
||||
}
|
||||
|
||||
void TControl::destroyObject(TObject* object) {
|
||||
removeObject(object);
|
||||
getFactory()->destroy(object);
|
||||
}
|
||||
|
||||
void TControl::destroyObject_all() {
|
||||
while (!ocObject_.empty()) {
|
||||
destroyObject(&ocObject_.back());
|
||||
}
|
||||
}
|
||||
|
||||
TObject* TControl::getObject(void const* id, u32 idSize) {
|
||||
typedef JGadget::TLinkList<TObject, -12>::iterator iterator;
|
||||
iterator begin = ocObject_.begin();
|
||||
iterator end = ocObject_.end();
|
||||
iterator it = std::find_if(begin, end, object::TPRObject_ID_equal(id, idSize));
|
||||
return it != end ? &*it : NULL;
|
||||
}
|
||||
|
||||
TObject* TControl::getObject_index(u32 index) {
|
||||
if (index >= ocObject_.size()) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
JGadget::TLinkList<TObject, -12>::iterator it = ocObject_.begin();
|
||||
std::advance(it, index);
|
||||
return &*it;
|
||||
}
|
||||
|
||||
TFactory::~TFactory() {}
|
||||
|
||||
TObject* TFactory::create(data::TParse_TBlock const& rBlock) {
|
||||
switch (rBlock.get_type()) {
|
||||
case 1:
|
||||
return new TObject_composite(rBlock);
|
||||
case 2:
|
||||
return new TObject_constant(rBlock);
|
||||
case 3:
|
||||
return new TObject_transition(rBlock);
|
||||
case 4:
|
||||
return new TObject_list(rBlock);
|
||||
case 5:
|
||||
return new TObject_list_parameter(rBlock);
|
||||
case 6:
|
||||
return new TObject_hermite(rBlock);
|
||||
default:
|
||||
JUTWarn w;
|
||||
w << "unknown type : ";
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
void TFactory::destroy(TObject* pObject) {
|
||||
delete pObject;
|
||||
}
|
||||
|
||||
TParse::TParse(TControl* pControl) : pControl_(pControl) {
|
||||
ASSERT(pControl_ != NULL);
|
||||
}
|
||||
|
||||
TParse::~TParse() {}
|
||||
|
||||
bool TParse::parseHeader_next(void const** ppData_inout, u32* puBlock_out, u32 flags) {
|
||||
ASSERT(ppData_inout != NULL);
|
||||
ASSERT(puBlock_out != NULL);
|
||||
|
||||
const void* pData = *ppData_inout;
|
||||
ASSERT(pData != NULL);
|
||||
|
||||
const data::TParse_THeader header(pData);
|
||||
*ppData_inout = header.getContent();
|
||||
*puBlock_out = header.get_blockNumber();
|
||||
|
||||
if (memcmp(header.get_signature(), &data::ga4cSignature, 4) != 0) {
|
||||
JUTWarn w;
|
||||
w << "unknown signature";
|
||||
return false;
|
||||
}
|
||||
|
||||
if (header.get_byteOrder() != 0xFEFF) {
|
||||
JUTWarn w;
|
||||
w << "illegal byte-order";
|
||||
return false;
|
||||
}
|
||||
u16 version = header.get_version();
|
||||
if (version < 2) {
|
||||
JUTWarn w;
|
||||
w << "obselete version : " << (s32)0;
|
||||
return false;
|
||||
} else if (version > 0x100) {
|
||||
JUTWarn w;
|
||||
w << "unknown version : " << version;
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool TParse::parseBlock_next(void const** ppData_inout, u32* puData_out, u32 flags) {
|
||||
ASSERT(ppData_inout != NULL);
|
||||
ASSERT(puData_out != NULL);
|
||||
|
||||
const void* pData = *ppData_inout;
|
||||
ASSERT(pData != NULL);
|
||||
data::TParse_TBlock blk(pData);
|
||||
*ppData_inout = blk.getNext();
|
||||
*puData_out = blk.get_size();
|
||||
|
||||
TControl* pControl = getControl();
|
||||
ASSERT(pControl != NULL);
|
||||
|
||||
if (flags & 0x10) {
|
||||
if (pControl->getObject(blk.get_ID(), blk.get_IDSize()) != NULL)
|
||||
return 1;
|
||||
}
|
||||
if (flags & 0x20) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
TFactory* pFactory = pControl->getFactory();
|
||||
if (pFactory == NULL) {
|
||||
JUTWarn w;
|
||||
w << "factory not specified";
|
||||
return 0;
|
||||
}
|
||||
|
||||
TObject* pObject = pFactory->create(blk);
|
||||
if (pObject == NULL) {
|
||||
JUTWarn w;
|
||||
w << "can't create function-value";
|
||||
if (flags & 0x40) {
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
pObject->prepare(blk, pControl);
|
||||
pControl->appendObject(pObject);
|
||||
return 1;
|
||||
}
|
||||
|
||||
} // namespace fvb
|
||||
} // namespace JStudio
|
||||
@@ -0,0 +1,194 @@
|
||||
//
|
||||
// jstudio-control
|
||||
//
|
||||
|
||||
#include "JSystem/JSystem.h" // IWYU pragma: keep
|
||||
|
||||
#include "JSystem/JStudio/JStudio/jstudio-control.h"
|
||||
#include "JSystem/JStudio/JStudio/jstudio-math.h"
|
||||
#include "JSystem/JStudio/JStudio/jstudio-data.h"
|
||||
#include <cstring>
|
||||
|
||||
JStudio::TControl::TControl() {
|
||||
mTransformOnSet = false;
|
||||
mTransformOnGet = false;
|
||||
Vec aVStack_20 = {0.0f,0.0f,0.0f};
|
||||
transform_setOrigin_TxyzRy(aVStack_20, 0.0f);
|
||||
}
|
||||
|
||||
JStudio::TControl::~TControl() {}
|
||||
|
||||
void JStudio::TControl::setFactory(JStudio::TFactory* factory) {
|
||||
fvb::TFactory* fvbFactory = NULL;
|
||||
ctb::TFactory* ctbFactory = NULL;
|
||||
if (factory != NULL) {
|
||||
fvbFactory = &factory->fvb_Factory;
|
||||
ctbFactory = &factory->ctb_Factory;
|
||||
}
|
||||
stb::TControl::setFactory(factory);
|
||||
fvb_Control.setFactory(fvbFactory);
|
||||
ctb_Control.setFactory(ctbFactory);
|
||||
}
|
||||
|
||||
int JStudio::TControl::transformOnSet_setOrigin_TxyzRy(Vec const& param_0, f32 param_1) {
|
||||
field_0x8c = param_0;
|
||||
mTransformOnSet_RotationY = param_1;
|
||||
JStudio::math::getTransformation_RyT(mTransformOnSet_Matrix, param_0, param_1);
|
||||
return 1;
|
||||
}
|
||||
|
||||
int JStudio::TControl::transformOnGet_setOrigin_TxyzRy(Vec const& param_0, f32 param_1) {
|
||||
field_0x98 = param_0;
|
||||
mTransformOnGet_RotationY = param_1;
|
||||
Mtx afStack_48;
|
||||
MTXTrans(afStack_48, -param_0.x, -param_0.y, -param_0.z);
|
||||
math::rotate_y(mTransformOnGet_Matrix, afStack_48, -param_1);
|
||||
return 1;
|
||||
}
|
||||
|
||||
int JStudio::TControl::transform_setOrigin_ctb(JStudio::ctb::TObject const& param_0) {
|
||||
switch (param_0.getScheme()) {
|
||||
case 1: {
|
||||
const f32* pfVar4 = (const f32*)param_0.getData();
|
||||
Vec local_144 = {0.0f, 0.0f, 0.0f};
|
||||
local_144.x = pfVar4[0];
|
||||
local_144.y = pfVar4[1];
|
||||
local_144.z = pfVar4[2];
|
||||
transform_setOrigin_TxyzRy(local_144, pfVar4[3]);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
bool JStudio::TControl::transform_setOrigin_ctb_index(u32 index) {
|
||||
ctb::TObject* object = ctb_getObject_index(index);
|
||||
if (object == NULL) {
|
||||
return false;
|
||||
}
|
||||
transform_setOrigin_ctb(*object);
|
||||
return true;
|
||||
}
|
||||
|
||||
JStudio::TCreateObject::~TCreateObject() {}
|
||||
|
||||
JStudio::TFactory::~TFactory() {}
|
||||
|
||||
void JStudio::TFactory::appendCreateObject(JStudio::TCreateObject* param_0) {
|
||||
mList.Push_back(param_0);
|
||||
}
|
||||
|
||||
|
||||
JStudio::TObject* JStudio::TFactory::create(JStudio::stb::data::TParse_TBlock_object const& rParse) {
|
||||
JGadget::TContainerEnumerator<JGadget::TLinkList<TCreateObject, -4> > aTStack_368(mList);
|
||||
while(aTStack_368) {
|
||||
TCreateObject& piVar1 = *aTStack_368;
|
||||
JStudio::TObject* obj;
|
||||
if (piVar1.create(&obj, rParse)) {
|
||||
return obj;
|
||||
}
|
||||
}
|
||||
#if DEBUG
|
||||
u32 type = rParse.get_type();
|
||||
char a5c[8];
|
||||
stb::data::toString_block(a5c, type);
|
||||
const char* szID = (const char*)rParse.get_ID();
|
||||
JGADGET_ASSERTWARN(0x108, rParse.get_IDSize()>0);
|
||||
JGADGET_ASSERTWARN(0x109, szID[rParse.get_IDSize()-1]=='\\0');
|
||||
JGADGET_WARNMSG3(0x10c, "ID not found\n demo object : ", szID, "\n type : ", a5c);
|
||||
#endif
|
||||
return NULL;
|
||||
}
|
||||
|
||||
JStudio::TParse::TParse(JStudio::TControl* param_0) : stb::TParse(param_0) {
|
||||
}
|
||||
|
||||
JStudio::TParse::~TParse() {}
|
||||
|
||||
bool JStudio::TParse::parseHeader(JStudio::stb::data::TParse_THeader const& param_0,
|
||||
u32 param_1) {
|
||||
const JStudio::stb::data::THeader::Target& target = param_0.get_target();
|
||||
if (memcmp(target.name, JStudio::data::ga8cSignature, sizeof(JStudio::data::ga8cSignature)) != 0) {
|
||||
return false;
|
||||
}
|
||||
if (target.target_version < 2) {
|
||||
return false;
|
||||
}
|
||||
if (target.target_version > 6) {
|
||||
return false;
|
||||
}
|
||||
JStudio::TControl* pControl = getControl();
|
||||
JUT_ASSERT(322, pControl!=NULL);
|
||||
if ((param_1 & 0x100) == 0) {
|
||||
Vec local_468 = {0.0f, 0.0f, 0.0f};
|
||||
pControl->transform_setOrigin_TxyzRy(local_468, 0.0f);
|
||||
pControl->transform_enable(false);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool JStudio::TParse::parseBlock_block(JStudio::stb::data::TParse_TBlock const& param_0,
|
||||
u32 param_1) {
|
||||
switch(param_0.get_type()) {
|
||||
case 'JFVB':
|
||||
return parseBlock_block_fvb_(param_0, param_1);
|
||||
case 'JCTB':
|
||||
return parseBlock_block_ctb_(param_0, param_1);
|
||||
default:
|
||||
return stb::TParse::parseBlock_block(param_0, param_1);
|
||||
}
|
||||
}
|
||||
|
||||
bool JStudio::TParse::parseBlock_block_fvb_(JStudio::stb::data::TParse_TBlock const& param_0,
|
||||
u32 param_1) {
|
||||
TControl* pControl = getControl();
|
||||
JUT_ASSERT(361, pControl!=NULL);
|
||||
const void* pContent = param_0.getContent();
|
||||
JUT_ASSERT(363, pContent!=NULL);
|
||||
u32 uVar4 = param_1 & 0xf;
|
||||
if ((param_1 & 0x10) != 0) {
|
||||
uVar4 |= 0x10;
|
||||
}
|
||||
if ((param_1 & 0x20) != 0) {
|
||||
uVar4 |= 0x20;
|
||||
}
|
||||
if ((param_1 & 0x40) != 0) {
|
||||
uVar4 |= 0x40;
|
||||
}
|
||||
fvb::TParse aTStack_30(&pControl->fvb_Control);
|
||||
if (!aTStack_30.parse(pContent, uVar4)) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool JStudio::TParse::parseBlock_block_ctb_(JStudio::stb::data::TParse_TBlock const& param_0,
|
||||
u32 param_1) {
|
||||
TControl* pControl = getControl();
|
||||
JUT_ASSERT(386, pControl!=NULL);
|
||||
const void* pContent = param_0.getContent();
|
||||
JUT_ASSERT(388, pContent!=NULL);
|
||||
u32 uVar4 = param_1 & 0xf;
|
||||
if ((param_1 & 0x10) != 0) {
|
||||
uVar4 |= 0x10;
|
||||
}
|
||||
if ((param_1 & 0x20) != 0) {
|
||||
uVar4 |= 0x20;
|
||||
}
|
||||
if ((param_1 & 0x40) != 0) {
|
||||
uVar4 |= 0x40;
|
||||
}
|
||||
ctb::TParse aTStack_30(&pControl->ctb_Control);
|
||||
if (!aTStack_30.parse(pContent, uVar4)) {
|
||||
return false;
|
||||
}
|
||||
if ((param_1 & 0x200) == 0) {
|
||||
if (pControl->transform_setOrigin_ctb_index(0) == 0) {
|
||||
return 0;
|
||||
}
|
||||
pControl->transform_enable(true);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
#include "JSystem/JSystem.h" // IWYU pragma: keep
|
||||
|
||||
#include "JSystem/JStudio/JStudio/jstudio-data.h"
|
||||
|
||||
const char JStudio::data::ga8cSignature[8] = "jstudio";
|
||||
@@ -0,0 +1,69 @@
|
||||
#include "JSystem/JSystem.h" // IWYU pragma: keep
|
||||
|
||||
#include "JSystem/JStudio/JStudio/jstudio-math.h"
|
||||
#include "JSystem/JGeometry.h"
|
||||
#include "JSystem/TPosition3.h"
|
||||
#include <cmath>
|
||||
|
||||
void JStudio::math::getRotation_xyz(MtxP param_1, f32 x, f32 y, f32 z) {
|
||||
f32 cosx = cosf(DEG_TO_RAD(x));
|
||||
f32 sinx = sinf(DEG_TO_RAD(x));
|
||||
f32 cosy = cosf(DEG_TO_RAD(y));
|
||||
f32 siny = sinf(DEG_TO_RAD(y));
|
||||
f32 cosz = cosf(DEG_TO_RAD(z));
|
||||
f32 sinz = sinf(DEG_TO_RAD(z));
|
||||
f32 cosxcosz = cosx * cosz;
|
||||
f32 cosxsinz = cosx * sinz;
|
||||
f32 sinxcosz = sinx * cosz;
|
||||
f32 sinxsinz = sinx * sinz;
|
||||
|
||||
param_1[0][0] = cosy * cosz;
|
||||
param_1[1][0] = cosy * sinz;
|
||||
param_1[2][0] = -siny;
|
||||
param_1[2][1] = sinx * cosy;
|
||||
param_1[2][2] = cosx * cosy;
|
||||
param_1[0][1] = ((sinxcosz * siny) - cosxsinz);
|
||||
param_1[0][2] = (sinxsinz + (cosxcosz * siny));
|
||||
param_1[1][1] = (cosxcosz + (sinxsinz * siny));
|
||||
param_1[1][2] = (((cosxsinz) * siny) - sinxcosz);
|
||||
param_1[0][3] = 0.0f;
|
||||
param_1[1][3] = 0.0f;
|
||||
param_1[2][3] = 0.0f;
|
||||
}
|
||||
|
||||
void JStudio::math::getTransformation_SRxyzT(MtxP param_1, Vec const& param_2, Vec const& param_3,
|
||||
Vec const& param_4) {
|
||||
Mtx afStack_40;
|
||||
MTXScale(afStack_40, param_2.x, param_2.y, param_2.z);
|
||||
Mtx amStack_70;
|
||||
rotate_xyz(afStack_40, amStack_70, param_3);
|
||||
MTXTransApply(amStack_70, param_1, param_4.x, param_4.y, param_4.z);
|
||||
}
|
||||
|
||||
void JStudio::math::getFromTransformation_SRxyzT(Vec* param_1, Vec* param_2, Vec* param_3,
|
||||
CMtxP param_4) {
|
||||
getFromTransformation_S(param_1, param_4);
|
||||
getFromTransformation_T(param_3, param_4);
|
||||
JGeometry::TRotation3<JGeometry::SMatrix33C<double> > aTStack_88;
|
||||
JGeometry::TVec3<double> local_a0;
|
||||
double dVar9 = 0.0;
|
||||
double dVar8 = 0.0;
|
||||
double dVar7 = 0.0;
|
||||
if (0.0f != param_1->x) {
|
||||
dVar9 = 1.0 / param_1->x;
|
||||
}
|
||||
if (0.0f != param_1->y) {
|
||||
dVar8 = 1.0 / param_1->y;
|
||||
}
|
||||
if (0.0f != param_1->z) {
|
||||
dVar7 = 1.0 / param_1->z;
|
||||
}
|
||||
aTStack_88.set(param_4[0][0] * dVar9, param_4[0][1] * dVar8, param_4[0][2] * dVar7,
|
||||
param_4[1][0] * dVar9, param_4[1][1] * dVar8, param_4[1][2] * dVar7,
|
||||
param_4[2][0] * dVar9, param_4[2][1] * dVar8, param_4[2][2] * dVar7);
|
||||
aTStack_88.getEulerXYZ(&local_a0);
|
||||
local_a0 *= 180.0 / m_PI_D;
|
||||
param_2->x = local_a0.x;
|
||||
param_2->y = local_a0.y;
|
||||
param_2->z = local_a0.z;
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,55 @@
|
||||
//
|
||||
// object-id
|
||||
//
|
||||
|
||||
#include "JSystem/JSystem.h" // IWYU pragma: keep
|
||||
|
||||
#include "JSystem/JStudio/JStudio/object-id.h"
|
||||
#include "JSystem/JUtility/JUTAssert.h"
|
||||
|
||||
bool JStudio::object::TIDData::isEqual(JStudio::object::TIDData const& a,
|
||||
JStudio::object::TIDData const& b) {
|
||||
u32 aSize = a.getIDSize();
|
||||
u32 bSize = b.getIDSize();
|
||||
if (aSize != bSize) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const u8* aStr32 = a.getID();
|
||||
const u8* bStr32 = b.getID();
|
||||
if (aStr32 == bStr32) {
|
||||
// they point to the same id
|
||||
return true;
|
||||
}
|
||||
|
||||
u32 u = aSize;
|
||||
for (; u >= 4; u -= 4, aStr32 += 4, bStr32 += 4) {
|
||||
if (*(u32*)aStr32 != *(u32*)bStr32) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
const u8* aStrBytes = aStr32;
|
||||
const u8* bStrBytes = bStr32;
|
||||
JUT_ASSERT(46, u<4);
|
||||
switch (u) {
|
||||
case 3:
|
||||
if (*aStrBytes != *bStrBytes) {
|
||||
return false;
|
||||
}
|
||||
aStrBytes++;
|
||||
bStrBytes++;
|
||||
case 2:
|
||||
if (*aStrBytes != *bStrBytes) {
|
||||
return false;
|
||||
}
|
||||
aStrBytes++;
|
||||
bStrBytes++;
|
||||
case 1:
|
||||
if (*aStrBytes != *bStrBytes) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
@@ -0,0 +1,84 @@
|
||||
#include "JSystem/JSystem.h" // IWYU pragma: keep
|
||||
|
||||
#include "JSystem/JStudio/JStudio/stb-data-parse.h"
|
||||
#include "JSystem/JUtility/JUTAssert.h"
|
||||
#include <os.h>
|
||||
#include <stdint.h>
|
||||
|
||||
namespace JStudio {
|
||||
namespace stb {
|
||||
namespace data {
|
||||
|
||||
void TParse_TSequence::getData(TData* pData) const {
|
||||
JUT_ASSERT(50, pData!=NULL);
|
||||
|
||||
pData->content = NULL;
|
||||
pData->next = NULL;
|
||||
u32 head = get_head();
|
||||
u8 type = head >> 24;
|
||||
u32 param = head & 0xffffff;
|
||||
pData->type = type & 0xff;
|
||||
pData->param = param;
|
||||
|
||||
if (type == 0)
|
||||
return;
|
||||
|
||||
const void* next = (const void*)((intptr_t)getRaw() + 4);
|
||||
if (type <= 0x7f) {
|
||||
pData->next = next;
|
||||
} else {
|
||||
pData->content = next;
|
||||
pData->next = (const void*)((intptr_t)next + param);
|
||||
}
|
||||
}
|
||||
|
||||
void TParse_TParagraph::getData(TData* pData) const {
|
||||
JUT_ASSERT(80, pData!=NULL);
|
||||
|
||||
const void* data = getRaw();
|
||||
u32 result;
|
||||
data = parseVariableUInt_16_32_following(data, &result, &pData->type, NULL);
|
||||
pData->param = result;
|
||||
if (result == 0) {
|
||||
pData->content = NULL;
|
||||
pData->next = data;
|
||||
} else {
|
||||
pData->content = data;
|
||||
pData->next = (const void*)((intptr_t)data + align_roundUp(result, 4));
|
||||
}
|
||||
}
|
||||
|
||||
void TParse_TParagraph_data::getData(TParse_TParagraph_data::TData* pData) const {
|
||||
JUT_ASSERT(104, pData!=NULL);
|
||||
pData->entrySize = 0;
|
||||
pData->entryCount = 0;
|
||||
pData->content = NULL;
|
||||
pData->next = NULL;
|
||||
u8* temp = (u8*)getRaw();
|
||||
u8* filedata = temp;
|
||||
if (filedata == NULL)
|
||||
return;
|
||||
u8 r29 = *filedata;
|
||||
pData->status = r29 & ~0x8;
|
||||
if (!r29)
|
||||
return;
|
||||
filedata++;
|
||||
u32 r28 = 1;
|
||||
if (r29 & 8) {
|
||||
r28 = *filedata;
|
||||
filedata++;
|
||||
}
|
||||
pData->entryCount = r28;
|
||||
pData->content = filedata;
|
||||
|
||||
u8 r27 = r29 & 7;
|
||||
if (r27 == 0)
|
||||
return;
|
||||
u32 dataSize = (gauDataSize_TEParagraph_data)[r27];
|
||||
pData->entrySize = dataSize;
|
||||
pData->next = filedata + (dataSize * r28);
|
||||
}
|
||||
|
||||
} // namespace data
|
||||
} // namespace stb
|
||||
} // namespace JStudio
|
||||
@@ -0,0 +1,6 @@
|
||||
#include "JSystem/JSystem.h" // IWYU pragma: keep
|
||||
|
||||
#include "JSystem/JStudio/JStudio/stb-data.h"
|
||||
|
||||
const s32 JStudio::stb::data::gauDataSize_TEParagraph_data[8] = {0x0, 0x1, 0x2, 0x4, 0x8, 0x10, 0x20, 0x40};
|
||||
const u32 JStudio::stb::data::ga4cSignature = 'STB\0';
|
||||
@@ -0,0 +1,487 @@
|
||||
#include "JSystem/JSystem.h" // IWYU pragma: keep
|
||||
|
||||
#include "JSystem/JStudio/JStudio/stb.h"
|
||||
#include "JSystem/JStudio/JStudio/jstudio-object.h"
|
||||
#include "JSystem/JUtility/JUTException.h"
|
||||
#include <algorithm>
|
||||
#include <cstring>
|
||||
|
||||
namespace JStudio {
|
||||
namespace stb {
|
||||
|
||||
// unchecked, in debug dol
|
||||
const char* TObject::toString_status(int status) {
|
||||
const char* result;
|
||||
|
||||
switch (status) {
|
||||
default:
|
||||
result = "(undefined)";
|
||||
break;
|
||||
case 0:
|
||||
result = "still";
|
||||
break;
|
||||
case 1:
|
||||
result = "end";
|
||||
break;
|
||||
case 2:
|
||||
result = "wait";
|
||||
break;
|
||||
case 4:
|
||||
result = "suspend";
|
||||
break;
|
||||
case 8:
|
||||
result = "inactive";
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
TObject::TObject(u32 arg1, const void* id, u32 id_size)
|
||||
: TObject_ID(id, id_size), pControl(NULL), signature(arg1), mFlag(0), bSequence_(0), _20(0),
|
||||
pSequence(NULL), pSequence_next(NULL), u32Wait_(0), mStatus(STATUS_STILL) {}
|
||||
|
||||
TObject::TObject(const data::TParse_TBlock_object& object)
|
||||
: TObject_ID(object.get_ID(), object.get_IDSize()), pControl(NULL),
|
||||
signature(object.get_type()), mFlag(object.get_flag()), bSequence_(0), _20(0), pSequence(0),
|
||||
pSequence_next(object.getContent()), u32Wait_(0), mStatus(STATUS_STILL) {}
|
||||
|
||||
TObject::~TObject() {
|
||||
JGADGET_ASSERTWARN(0, getControl() == NULL);
|
||||
}
|
||||
|
||||
void TObject::setFlag_operation(u8 op, int val) {
|
||||
switch (op) {
|
||||
default:
|
||||
JUTWarn w;
|
||||
w << "unknown flag-operation : " << op;
|
||||
break;
|
||||
case 1:
|
||||
mFlag |= val;
|
||||
break;
|
||||
case 2:
|
||||
mFlag &= val;
|
||||
break;
|
||||
case 3:
|
||||
mFlag ^= val;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
#if !PLATFORM_SHIELD || DEBUG
|
||||
void TObject::reset(const void* arg1) {
|
||||
bSequence_ = 0;
|
||||
mStatus = STATUS_STILL;
|
||||
pSequence_next = arg1;
|
||||
u32Wait_ = 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if DEBUG
|
||||
void TObject::reset() {
|
||||
reset(NULL);
|
||||
}
|
||||
#endif
|
||||
|
||||
bool TObject::forward(u32 arg1) {
|
||||
bool temp = false;
|
||||
|
||||
while (true) {
|
||||
if (mFlag & 0x8000) {
|
||||
switch (getStatus()) {
|
||||
case STATUS_STILL:
|
||||
case STATUS_END:
|
||||
break;
|
||||
case STATUS_WAIT:
|
||||
case STATUS_SUSPEND:
|
||||
setStatus_(STATUS_INACTIVE);
|
||||
if (bSequence_) {
|
||||
on_end();
|
||||
}
|
||||
break;
|
||||
case STATUS_INACTIVE:
|
||||
break;
|
||||
default:
|
||||
ASSERT(false);
|
||||
break;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
if (getStatus() == STATUS_INACTIVE) {
|
||||
ASSERT(bSequence_);
|
||||
on_begin();
|
||||
setStatus_(STATUS_WAIT);
|
||||
}
|
||||
ASSERT(getStatus() != STATUS_INACTIVE);
|
||||
|
||||
TControl* control = getControl();
|
||||
if ((control != NULL && control->isSuspended()) || isSuspended()) {
|
||||
if (bSequence_) {
|
||||
ASSERT((getStatus() == STATUS_WAIT) || (getStatus() == STATUS_SUSPEND));
|
||||
setStatus_(STATUS_SUSPEND);
|
||||
on_wait(arg1);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
while (true) {
|
||||
void* nextseq = (void*)getSequence_next();
|
||||
setSequence_(nextseq);
|
||||
|
||||
if (nextseq == NULL) {
|
||||
if (bSequence_) {
|
||||
ASSERT(getStatus() != STATUS_STILL);
|
||||
if (!temp) {
|
||||
on_wait(0);
|
||||
}
|
||||
bSequence_ = false;
|
||||
setStatus_(STATUS_END);
|
||||
on_end();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!bSequence_) {
|
||||
ASSERT(getStatus() == STATUS_STILL);
|
||||
bSequence_ = true;
|
||||
on_begin();
|
||||
}
|
||||
setStatus_(STATUS_WAIT);
|
||||
if (u32Wait_ == 0) {
|
||||
process_sequence_();
|
||||
if (u32Wait_ == 0) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
ASSERT(u32Wait_ > 0);
|
||||
|
||||
temp = true;
|
||||
if (arg1 >= u32Wait_) {
|
||||
u32 wait = u32Wait_;
|
||||
arg1 -= u32Wait_;
|
||||
u32Wait_ = 0;
|
||||
on_wait(wait);
|
||||
} else {
|
||||
u32Wait_ -= arg1;
|
||||
on_wait(arg1);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void TObject::do_begin() {
|
||||
/* empty function */
|
||||
}
|
||||
|
||||
void TObject::do_end() {
|
||||
/* empty function */
|
||||
}
|
||||
|
||||
void TObject::do_paragraph(u32 param_0, void const* param_1, u32 param_2) {
|
||||
/* empty function */
|
||||
}
|
||||
|
||||
void TObject::do_wait(u32 param_0) {
|
||||
/* empty function */
|
||||
}
|
||||
|
||||
void TObject::do_data(void const* param_0, u32 param_1, void const* param_2, u32 param_3) {
|
||||
/* empty function */
|
||||
}
|
||||
|
||||
void TObject::process_sequence_() {
|
||||
ASSERT(getWait() == 0);
|
||||
data::TParse_TSequence seq(getSequence());
|
||||
|
||||
data::TParse_TSequence::TData dat;
|
||||
|
||||
seq.getData(&dat);
|
||||
u8 type = dat.type;
|
||||
u32 u32Value = dat.param;
|
||||
const void* pContent = dat.content;
|
||||
const void* pNext = dat.next;
|
||||
setSequence_next(dat.next);
|
||||
|
||||
switch (type) {
|
||||
case 0:
|
||||
JGADGET_ASSERTWARN(0, u32Value == 0);
|
||||
JGADGET_ASSERTWARN(0, pContent == NULL);
|
||||
break;
|
||||
case 1:
|
||||
JGADGET_ASSERTWARN(0, pContent == NULL);
|
||||
setFlag_operation_(u32Value);
|
||||
break;
|
||||
case 2:
|
||||
JGADGET_ASSERTWARN(0, pContent == NULL);
|
||||
setWait(u32Value);
|
||||
break;
|
||||
case 3: {
|
||||
JGADGET_ASSERTWARN(0, pContent == NULL);
|
||||
s32 off = toInt32FromUInt24_(u32Value);
|
||||
void* nextseq = (void*)getSequence_offset(off);
|
||||
setSequence_next(nextseq);
|
||||
break;
|
||||
}
|
||||
case 4: {
|
||||
JGADGET_ASSERTWARN(0, pContent == NULL);
|
||||
u32 val = toInt32FromUInt24_(u32Value);
|
||||
suspend(val);
|
||||
break;
|
||||
}
|
||||
case 0x80: {
|
||||
ASSERT(pContent != NULL);
|
||||
void* p = (void*)pContent;
|
||||
data::TParse_TParagraph para(NULL);
|
||||
while (p < pNext) {
|
||||
para.setRaw(p);
|
||||
|
||||
data::TParse_TParagraph::TData para_dat;
|
||||
para.getData(¶_dat);
|
||||
if (para_dat.type <= 0xff) {
|
||||
process_paragraph_reserved_(para_dat.type, para_dat.content, para_dat.param);
|
||||
} else {
|
||||
on_paragraph(para_dat.type, para_dat.content, para_dat.param);
|
||||
}
|
||||
p = (void*)para_dat.next;
|
||||
ASSERT(p != NULL);
|
||||
}
|
||||
JGADGET_ASSERTWARN(0, p == pNext);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
JUTWarn w;
|
||||
w << "unknown sequence : " << dat.type;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void TObject::process_paragraph_reserved_(u32 arg1, const void* pContent, u32 uSize) {
|
||||
switch (arg1) {
|
||||
case 0x1:
|
||||
ASSERT(pContent != NULL);
|
||||
ASSERT(uSize == 4);
|
||||
setFlag_operation_(*(u32*)pContent);
|
||||
break;
|
||||
case 0x2:
|
||||
ASSERT(pContent != NULL);
|
||||
ASSERT(uSize == 4);
|
||||
setWait(*(u32*)pContent);
|
||||
break;
|
||||
case 0x3: {
|
||||
ASSERT(pContent != NULL);
|
||||
ASSERT(uSize == 4);
|
||||
const void* seq = getSequence_offset(*(s32*)pContent);
|
||||
setSequence_next(seq);
|
||||
break;
|
||||
}
|
||||
case 0x80:
|
||||
on_data(NULL, 0, pContent, uSize);
|
||||
break;
|
||||
case 0x81: {
|
||||
data::TParse_TParagraph_dataID dataID(pContent);
|
||||
const void* temp = dataID.getContent();
|
||||
on_data(dataID.get_ID(), dataID.get_IDSize(), temp,
|
||||
uSize - ((uintptr_t)temp - (uintptr_t)dataID.getRaw()));
|
||||
break;
|
||||
}
|
||||
case 0x82:
|
||||
ASSERT(pContent != NULL);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
TObject_control::TObject_control(const void* arg1, u32 arg2) : TObject(-1, arg1, arg2) {}
|
||||
|
||||
TControl::TControl() : _4(0), _8(0), pFactory(NULL), mObject_control(NULL, 0), _54(0) {
|
||||
resetStatus_();
|
||||
mObject_control.setControl_(this);
|
||||
}
|
||||
|
||||
// TObject_control::TObject_control() definition gets inlined here
|
||||
|
||||
TControl::~TControl() {
|
||||
mObject_control.setControl_(NULL);
|
||||
JGADGET_ASSERTWARN(0, ocObject_.empty());
|
||||
}
|
||||
|
||||
void TControl::appendObject(TObject* p) {
|
||||
p->setControl_(this);
|
||||
ocObject_.Push_back(p);
|
||||
}
|
||||
|
||||
void TControl::removeObject(TObject* p) {
|
||||
ASSERT(p != NULL);
|
||||
ASSERT(p->getControl() == this);
|
||||
p->setControl_(NULL);
|
||||
ocObject_.Erase(p);
|
||||
}
|
||||
|
||||
void TControl::destroyObject(TObject* p) {
|
||||
removeObject(p);
|
||||
ASSERT(pFactory != NULL);
|
||||
pFactory->destroy(p);
|
||||
}
|
||||
|
||||
void TControl::destroyObject_all() {
|
||||
while (!ocObject_.empty()) {
|
||||
destroyObject(&ocObject_.back());
|
||||
}
|
||||
}
|
||||
|
||||
// NONMATCHING - TPRObject_ID_equal copy issue
|
||||
TObject* TControl::getObject(void const* param_0, u32 param_1) {
|
||||
JGadget::TLinkList<TObject, -12>::iterator begin = ocObject_.begin();
|
||||
JGadget::TLinkList<TObject, -12>::iterator end = ocObject_.end();
|
||||
JGadget::TLinkList<TObject, -12>::iterator local_50 = std::find_if(begin, end, object::TPRObject_ID_equal(param_0, param_1));
|
||||
if ((local_50 != end) != false) {
|
||||
return &*local_50;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void TControl::reset() {
|
||||
resetStatus_();
|
||||
mObject_control.reset();
|
||||
JGadget::TContainerEnumerator<JGadget::TLinkList<JStudio::stb::TObject, -12> > aTStack_18(ocObject_);
|
||||
while (aTStack_18) {
|
||||
(*aTStack_18).reset();
|
||||
}
|
||||
}
|
||||
|
||||
bool TControl::forward(u32 param_0) {
|
||||
_54 = mObject_control.getSuspend();
|
||||
bool rv = mObject_control.forward(param_0);
|
||||
int uVar7 = 0xf;
|
||||
int uVar6 = 0;
|
||||
JGadget::TContainerEnumerator<JGadget::TLinkList<JStudio::stb::TObject, -12> > aTStack_38(ocObject_);
|
||||
while (aTStack_38) {
|
||||
JStudio::stb::TObject& this_00 = *aTStack_38;
|
||||
rv = this_00.forward(param_0) || rv;
|
||||
int uVar3 = this_00.getStatus();
|
||||
uVar7 &= uVar3;
|
||||
uVar6 |= uVar3;
|
||||
}
|
||||
setStatus_(uVar7 | (uVar6 << 0x10));
|
||||
return rv;
|
||||
}
|
||||
|
||||
TFactory::~TFactory() {}
|
||||
|
||||
JStudio::TObject* TFactory::create(data::TParse_TBlock_object const& param_0) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void TFactory::destroy(TObject* p) {
|
||||
delete p;
|
||||
}
|
||||
|
||||
TParse::TParse(TControl* pControl) : pControl(pControl) {}
|
||||
|
||||
TParse::~TParse() {}
|
||||
|
||||
bool TParse::parseHeader_next(const void** ppData_inout, u32* puBlock_out, u32 flags) {
|
||||
ASSERT(ppData_inout != NULL);
|
||||
ASSERT(puBlock_out != NULL);
|
||||
|
||||
const void* pData = *ppData_inout;
|
||||
ASSERT(pData != NULL);
|
||||
|
||||
const data::TParse_THeader header(pData);
|
||||
*ppData_inout = header.getContent();
|
||||
*puBlock_out = header.get_blockNumber();
|
||||
|
||||
if (memcmp(header.get_signature(), &data::ga4cSignature, 4) != 0) {
|
||||
JUTWarn w;
|
||||
w << "unknown signature";
|
||||
return false;
|
||||
}
|
||||
|
||||
if (header.get_byteOrder() != 0xFEFF) {
|
||||
JUTWarn w;
|
||||
w << "illegal byte-order";
|
||||
return false;
|
||||
}
|
||||
u16 version = header.get_version();
|
||||
if (version < 1) {
|
||||
JUTWarn w;
|
||||
w << "obselete version : " << (s32)0;
|
||||
return false;
|
||||
} else if (version > 3) {
|
||||
JUTWarn w;
|
||||
w << "unknown version : " << version;
|
||||
return false;
|
||||
}
|
||||
return parseHeader(header, flags);
|
||||
}
|
||||
|
||||
bool TParse::parseBlock_next(void const** ppData_inout, u32* puData_out, u32 flags) {
|
||||
ASSERT(ppData_inout != NULL);
|
||||
ASSERT(puData_out != NULL);
|
||||
|
||||
const void* pData = *ppData_inout;
|
||||
ASSERT(pData != NULL);
|
||||
|
||||
data::TParse_TBlock blk(pData);
|
||||
*ppData_inout = blk.getNext();
|
||||
*puData_out = blk.get_size();
|
||||
return parseBlock_block(blk, flags);
|
||||
}
|
||||
|
||||
bool TParse::parseHeader(data::TParse_THeader const& param_0, u32 flags) {
|
||||
return true;
|
||||
}
|
||||
|
||||
bool TParse::parseBlock_block(const data::TParse_TBlock& ppBlock, u32 flags) {
|
||||
return parseBlock_object(ppBlock.get(), flags);
|
||||
}
|
||||
|
||||
bool TParse::parseBlock_object(const data::TParse_TBlock_object& ppObject, u32 flags) {
|
||||
TControl* pControl = getControl();
|
||||
ASSERT(pControl != NULL);
|
||||
|
||||
if (ppObject.get_type() == data::BLOCK_NONE) {
|
||||
TObject_control& ref = pControl->referObject_control();
|
||||
ref.reset(ppObject.getContent());
|
||||
return true;
|
||||
}
|
||||
|
||||
if (flags & 0x10) {
|
||||
TObject* p = pControl->getObject(ppObject.get_ID(), ppObject.get_IDSize());
|
||||
if (p != NULL) {
|
||||
p->reset(ppObject.getContent());
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
if (flags & 0x20)
|
||||
return true;
|
||||
|
||||
TFactory* pFactory = pControl->getFactory();
|
||||
if (pFactory == NULL) {
|
||||
JUTWarn w;
|
||||
w << "factory not specified";
|
||||
return false;
|
||||
}
|
||||
|
||||
JStudio::TObject* p = pFactory->create(ppObject);
|
||||
if (p == NULL) {
|
||||
if (flags & 0x40)
|
||||
return true;
|
||||
|
||||
char a5c[8];
|
||||
char t[16];
|
||||
int type = ppObject.get_type();
|
||||
data::toString_block(a5c, type);
|
||||
|
||||
JUTWarn w;
|
||||
w << "can't create object : " << a5c;
|
||||
w << "(0x" << type << ")";
|
||||
return false;
|
||||
}
|
||||
pControl->appendObject(p);
|
||||
return true;
|
||||
}
|
||||
|
||||
} // namespace stb
|
||||
} // namespace JStudio
|
||||
@@ -0,0 +1,8 @@
|
||||
#include "JSystem/JSystem.h" // IWYU pragma: keep
|
||||
|
||||
#include "JSystem/JStudio/JStudio_JPreviewer/control.h"
|
||||
|
||||
|
||||
JStudioPreviewer::TControl::TControl() : JOREventCallbackListNode(0xc0000000,0xc00000ff,false) {
|
||||
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
//
|
||||
// control
|
||||
//
|
||||
|
||||
#include "JSystem/JSystem.h" // IWYU pragma: keep
|
||||
|
||||
#include "JSystem/JStudio/JStudio_JAudio2/control.h"
|
||||
#include "JSystem/JGadget/pointer.h"
|
||||
|
||||
JStudio_JAudio2::TCreateObject::~TCreateObject() {}
|
||||
|
||||
bool JStudio_JAudio2::TCreateObject::create(
|
||||
JStudio::TObject** ppObject, JStudio::stb::data::TParse_TBlock_object const& param_2) {
|
||||
JUT_ASSERT(40, ppObject!=NULL);
|
||||
CreateFunc func;
|
||||
switch (param_2.get_type()) {
|
||||
case 'JSND':
|
||||
func = createObject_JAI_SOUND_;
|
||||
break;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
*ppObject = func(param_2, this);
|
||||
return 1;
|
||||
}
|
||||
|
||||
JStudio::TObject* JStudio_JAudio2::TCreateObject::createObject_JAI_SOUND_(
|
||||
JStudio::stb::data::TParse_TBlock_object const& param_1,
|
||||
JStudio_JAudio2::TCreateObject* param_2) {
|
||||
JStudio_JAudio2::TAdaptor_sound* adaptor = new JStudio_JAudio2::TAdaptor_sound(param_2);
|
||||
if (adaptor == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
JGadget::TPointer_delete<JStudio_JAudio2::TAdaptor_sound> deleteGuard(adaptor);
|
||||
adaptor->set_bPermit_onExit_notEnd_(param_2->isPermit_onExit_notEnd());
|
||||
JStudio::TObject_sound* soundObj =
|
||||
JStudio::TCreateObject::createFromAdaptor<JStudio_JAudio2::TAdaptor_sound>(param_1,
|
||||
adaptor);
|
||||
if (soundObj == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
deleteGuard.set(NULL);
|
||||
return soundObj;
|
||||
}
|
||||
@@ -0,0 +1,327 @@
|
||||
//
|
||||
// object-sound
|
||||
//
|
||||
|
||||
#include "JSystem/JSystem.h" // IWYU pragma: keep
|
||||
|
||||
#include "JSystem/JStudio/JStudio_JAudio2/object-sound.h"
|
||||
#include "JSystem/JStudio/JStudio_JAudio2/control.h"
|
||||
#include "JSystem/JStudio/JStudio_JStage/control.h"
|
||||
|
||||
namespace JStudio_JAudio2 {
|
||||
namespace {
|
||||
|
||||
static void setValue_VOLUME_(JAISound *param_1, float param_2) {
|
||||
param_1->getAuxiliary().moveVolume(param_2, 0);
|
||||
}
|
||||
|
||||
static void setValue_PAN_(JAISound *param_1, float param_2) {
|
||||
param_1->getAuxiliary().movePan(param_2, 0);
|
||||
}
|
||||
|
||||
static void setValue_PITCH_(JAISound *param_1, float param_2) {
|
||||
param_1->getAuxiliary().movePitch(param_2, 0);
|
||||
}
|
||||
|
||||
static void setValue_TEMPO_(JAISound *param_1, float param_2) {
|
||||
JAITempoMgr* tempoMgr = param_1->getTempoMgr();
|
||||
if (tempoMgr != NULL) {
|
||||
tempoMgr->setTempo(param_2);
|
||||
}
|
||||
}
|
||||
|
||||
static void setValue_ECHO_(JAISound *param_1, float param_2) {
|
||||
param_1->getAuxiliary().moveFxMix(param_2, 0);
|
||||
}
|
||||
|
||||
}; // namespace
|
||||
}; // namespace JStudio_JAudio2
|
||||
|
||||
JStudio_JAudio2::TAdaptor_sound::TAdaptor_sound(JStudio_JAudio2::TCreateObject* param_1) :
|
||||
pCreateObject_(param_1) {
|
||||
field_0x11c = 0;
|
||||
field_0x11d = 0;
|
||||
field_0x11e = 0;
|
||||
field_0x11f = 0;
|
||||
field_0x120 = 0;
|
||||
field_0x124 = 0xffffffff;
|
||||
field_0x128 = 0;
|
||||
field_0x12c = NULL;
|
||||
field_0x13c = NULL;
|
||||
field_0x140 = 0xffffffff;
|
||||
field_0x144 = 0;
|
||||
JUT_ASSERT(112, pCreateObject_!=NULL);
|
||||
}
|
||||
|
||||
JStudio_JAudio2::TAdaptor_sound::~TAdaptor_sound() {
|
||||
if (opJAISoundHandle_) {
|
||||
if (field_0x11f == 0) {
|
||||
opJAISoundHandle_->stop();
|
||||
} else if (field_0x11c != 0) {
|
||||
opJAISoundHandle_.releaseSound();
|
||||
} else {
|
||||
opJAISoundHandle_->stop();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JAudio2::TAdaptor_sound::adaptor_do_prepare() {
|
||||
static JStudio::TAdaptor::TSetVariableValue_immediate aoData[4] = {
|
||||
TSetVariableValue_immediate(0, 0.0f),
|
||||
TSetVariableValue_immediate(1, 0.0f),
|
||||
TSetVariableValue_immediate(2, 0.0f),
|
||||
TSetVariableValue_immediate(-1, NAN),
|
||||
};
|
||||
adaptor_setVariableValue_immediate(aoData);
|
||||
for (TVVOSetValue_* pTVar1 = saoVVOSetValue_; pTVar1->field_0x04 != -1; pTVar1++) {
|
||||
adaptor_referVariableValue(pTVar1->field_0x04)->setOutput(pTVar1);
|
||||
}
|
||||
}
|
||||
|
||||
JStudio_JAudio2::TAdaptor_sound::TVVOSetValue_ JStudio_JAudio2::TAdaptor_sound::saoVVOSetValue_[6] = {
|
||||
JStudio_JAudio2::TAdaptor_sound::TVVOSetValue_(
|
||||
JStudio_JAudio2::TAdaptor_sound::UNK_7, setValue_VOLUME_
|
||||
),
|
||||
JStudio_JAudio2::TAdaptor_sound::TVVOSetValue_(
|
||||
JStudio_JAudio2::TAdaptor_sound::UNK_8, setValue_PAN_
|
||||
),
|
||||
JStudio_JAudio2::TAdaptor_sound::TVVOSetValue_(
|
||||
JStudio_JAudio2::TAdaptor_sound::UNK_9, setValue_PITCH_
|
||||
),
|
||||
JStudio_JAudio2::TAdaptor_sound::TVVOSetValue_(
|
||||
JStudio_JAudio2::TAdaptor_sound::UNK_10, setValue_TEMPO_
|
||||
),
|
||||
JStudio_JAudio2::TAdaptor_sound::TVVOSetValue_(
|
||||
JStudio_JAudio2::TAdaptor_sound::UNK_11, setValue_ECHO_
|
||||
),
|
||||
JStudio_JAudio2::TAdaptor_sound::TVVOSetValue_(
|
||||
JStudio_JAudio2::TAdaptor_sound::UNK_NONE, NULL
|
||||
),
|
||||
};
|
||||
|
||||
void JStudio_JAudio2::TAdaptor_sound::adaptor_do_end() {
|
||||
}
|
||||
|
||||
void JStudio_JAudio2::TAdaptor_sound::adaptor_do_update(u32 param_1) {
|
||||
const JStudio::TObject* pObject = adaptor_getObject();
|
||||
JUT_ASSERT(194, pObject!=NULL);
|
||||
const JStudio::TControl* pControl = pObject->getControl();
|
||||
JUT_ASSERT(196, pControl!=NULL);
|
||||
JStudio::TControl::TTransform_position VStack_148;
|
||||
JStudio::TControl::TTransform_position VStack_154;
|
||||
const JStudio::TControl::TTransform_position* pVVar2;
|
||||
adaptor_getVariableValue_Vec(&VStack_148,
|
||||
JStudio::TAdaptor_sound::sauVariableValue_3_POSITION_XYZ);
|
||||
if (field_0x144 == 0) {
|
||||
pVVar2 = pControl->transformOnSet_transform_ifEnabled(VStack_148, &VStack_154);
|
||||
} else {
|
||||
if (!JStudio_JStage::transform_toGlobalFromLocal(&VStack_154, VStack_148, field_0x13c, field_0x140)) {
|
||||
return;
|
||||
}
|
||||
pVVar2 = &VStack_154;
|
||||
}
|
||||
field_0x130 = *pVVar2;
|
||||
if (field_0x11d) {
|
||||
switch(field_0x120) {
|
||||
case 2: {
|
||||
JAISoundStarter* soundStarter = pCreateObject_->get_pJAISoundStarter_();
|
||||
soundStarter->startLevelSound(field_0x124, &opJAISoundHandle_, field_0x12c);
|
||||
break;
|
||||
}
|
||||
case 1:
|
||||
field_0x120 = 2;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (field_0x11e != 0 && field_0x124 != -1 && !opJAISoundHandle_) {
|
||||
prepareSound_();
|
||||
beginSound_fadeIn_();
|
||||
}
|
||||
if (field_0x12c != NULL && opJAISoundHandle_)
|
||||
{
|
||||
opJAISoundHandle_->setPos(*field_0x12c);
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JAudio2::TAdaptor_sound::adaptor_do_SOUND(JStudio::data::TEOperationData param_1,
|
||||
void const* pContent, u32 uSize) {
|
||||
switch(param_1) {
|
||||
case JStudio::data::UNK_0x19:
|
||||
JUT_ASSERT(283, pContent!=NULL);
|
||||
JUT_ASSERT(284, uSize==4);
|
||||
field_0x124 = *(u32*)pContent;
|
||||
prepareSound_();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JAudio2::TAdaptor_sound::adaptor_do_BEGIN(JStudio::data::TEOperationData param_1,
|
||||
void const* pContent, u32 uSize) {
|
||||
switch (param_1) {
|
||||
case JStudio::data::UNK_0x1:
|
||||
JUT_ASSERT(284, uSize == 0);
|
||||
beginSound_();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JAudio2::TAdaptor_sound::adaptor_do_BEGIN_FADE_IN(
|
||||
JStudio::data::TEOperationData param_1, void const* pContent, u32 uSize) {
|
||||
switch (param_1) {
|
||||
case JStudio::data::UNK_0x2:
|
||||
JUT_ASSERT(323, pContent!=NULL);
|
||||
JUT_ASSERT(324, uSize==4);
|
||||
beginSound_fadeIn_(*(f32*)pContent);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JAudio2::TAdaptor_sound::adaptor_do_END(JStudio::data::TEOperationData param_1,
|
||||
void const* pContent, u32 uSize) {
|
||||
switch (param_1) {
|
||||
case JStudio::data::UNK_0x1:
|
||||
JUT_ASSERT(345, uSize == 0);
|
||||
endSound_();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JAudio2::TAdaptor_sound::adaptor_do_END_FADE_OUT(
|
||||
JStudio::data::TEOperationData param_1, void const* pContent, u32 uSize) {
|
||||
switch (param_1) {
|
||||
case JStudio::data::UNK_0x2:
|
||||
JUT_ASSERT(364, pContent!=NULL);
|
||||
JUT_ASSERT(365, uSize==4);
|
||||
endSound_fadeOut_(*(f32*)pContent);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JAudio2::TAdaptor_sound::adaptor_do_PARENT(
|
||||
JStudio::data::TEOperationData param_1, void const* pContent, u32 uSize) {
|
||||
switch (param_1) {
|
||||
case JStudio::data::UNK_0x18:
|
||||
JUT_ASSERT(387, pContent!=NULL);
|
||||
JUT_ASSERT(388, uSize!=0);
|
||||
field_0x13c = NULL;
|
||||
JStage::TSystem* pJSGSystem = (JStage::TSystem*)pCreateObject_->get_pJSGSystem_();
|
||||
JUT_ASSERT(396, pJSGSystem != NULL);
|
||||
JStage::TObject* pJSGObject;
|
||||
if (!pJSGSystem->JSGFindObject(&pJSGObject, (const char*)pContent, JStage::OBJECT_UNDEFINED)) {
|
||||
JUT_ASSERT(405, pJSGObject != NULL);
|
||||
field_0x13c = pJSGObject;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JAudio2::TAdaptor_sound::adaptor_do_PARENT_NODE(JStudio::data::TEOperationData param_1,
|
||||
const void* pContent, u32 uSize) {
|
||||
switch (param_1) {
|
||||
case JStudio::data::UNK_0x18:
|
||||
if (field_0x13c != NULL) {
|
||||
JUT_ASSERT(431, pContent!=NULL);
|
||||
JUT_ASSERT(432, uSize==0);
|
||||
field_0x140 = field_0x13c->JSGFindNodeID((char*)pContent);
|
||||
if (field_0x140 == -1) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case JStudio::data::UNK_0x19:
|
||||
JUT_ASSERT(447, uSize==4);
|
||||
JUT_ASSERT(448, pContent!=NULL);
|
||||
field_0x140 = *(u32*)pContent;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JAudio2::TAdaptor_sound::adaptor_do_PARENT_ENABLE(
|
||||
JStudio::data::TEOperationData param_1, const void* pContent, u32 uSize) {
|
||||
if (param_1 == JStudio::data::UNK_0x2) {
|
||||
JUT_ASSERT(468, uSize == 4);
|
||||
JUT_ASSERT(469, pContent != NULL);
|
||||
field_0x144 = *(u32*)pContent ? 1 : 0;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JAudio2::TAdaptor_sound::adaptor_do_REPEAT(JStudio::data::TEOperationData param_1,
|
||||
const void* pContent, u32 uSize) {
|
||||
if (param_1 == JStudio::data::UNK_0x2) {
|
||||
JUT_ASSERT(490, uSize == 4);
|
||||
JUT_ASSERT(491, pContent != NULL);
|
||||
field_0x11e = *(u32*)pContent ? 1 : 0;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JAudio2::TAdaptor_sound::adaptor_do_CONTINUOUS(JStudio::data::TEOperationData param_1,
|
||||
const void* pContent, u32 uSize) {
|
||||
if (param_1 == JStudio::data::UNK_0x2) {
|
||||
JUT_ASSERT(512, uSize == 4);
|
||||
JUT_ASSERT(513, pContent != NULL);
|
||||
field_0x11d = *(u32*)pContent ? 1 : 0;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JAudio2::TAdaptor_sound::adaptor_do_LOCATED(JStudio::data::TEOperationData param_1,
|
||||
const void* pContent, u32 uSize) {
|
||||
if (param_1 == JStudio::data::UNK_0x2) {
|
||||
JUT_ASSERT(534, pContent != NULL);
|
||||
JUT_ASSERT(535, uSize == 4);
|
||||
u32 val = *(u32*)pContent;
|
||||
field_0x12c = NULL;
|
||||
if (val != 0) {
|
||||
field_0x12c = &field_0x130;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JAudio2::TAdaptor_sound::adaptor_do_ON_EXIT_NOT_END(
|
||||
JStudio::data::TEOperationData param_1, const void* pContent, u32 uSize) {
|
||||
if (param_1 == JStudio::data::UNK_0x2) {
|
||||
JUT_ASSERT(512, uSize == 4);
|
||||
JUT_ASSERT(513, pContent != NULL);
|
||||
field_0x11f = *(u32*)pContent ? 1 : 0;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JAudio2::TAdaptor_sound::TVVOSetValue_::operator()(f32 param_1,
|
||||
JStudio::TAdaptor* param_2) const {
|
||||
JUT_ASSERT(596, param_2 != NULL);
|
||||
if (((JStudio_JAudio2::TAdaptor_sound*)param_2)->opJAISoundHandle_) {
|
||||
JAISound* sound = ((JStudio_JAudio2::TAdaptor_sound*)param_2)->opJAISoundHandle_.sound_;
|
||||
field_0x08(sound, param_1);
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JAudio2::TAdaptor_sound::prepareSound_() {
|
||||
if (opJAISoundHandle_) {
|
||||
opJAISoundHandle_stop_();
|
||||
}
|
||||
JAISoundStarter* soundStarter = pCreateObject_->get_pJAISoundStarter_();
|
||||
if (field_0x11d == 0) {
|
||||
soundStarter->startSound(field_0x124, &opJAISoundHandle_, field_0x12c);
|
||||
} else {
|
||||
soundStarter->startLevelSound(field_0x124, &opJAISoundHandle_, field_0x12c);
|
||||
}
|
||||
if (opJAISoundHandle_) {
|
||||
opJAISoundHandle_->lockWhenPrepared();
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JAudio2::TAdaptor_sound::beginSound_fadeIn_() {
|
||||
if (opJAISoundHandle_) {
|
||||
opJAISoundHandle_->fadeIn(field_0x128);
|
||||
opJAISoundHandle_->unlockIfLocked();
|
||||
field_0x120 = 1;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JAudio2::TAdaptor_sound::endSound_fadeOut_(u32 u32FadeTime) {
|
||||
if (opJAISoundHandle_) {
|
||||
opJAISoundHandle_->stop(u32FadeTime);
|
||||
JUT_ASSERT(654, (u32FadeTime>0)||!opJAISoundHandle_);
|
||||
field_0x120 = 0;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
//
|
||||
// control
|
||||
//
|
||||
|
||||
#include "JSystem/JSystem.h" // IWYU pragma: keep
|
||||
|
||||
#include "JSystem/JStudio/JStudio_JParticle/control.h"
|
||||
#include "JSystem/JParticle/JPAEmitterManager.h"
|
||||
#include "JSystem/JGadget/pointer.h"
|
||||
|
||||
JStudio_JParticle::TCreateObject::~TCreateObject() {}
|
||||
|
||||
bool
|
||||
JStudio_JParticle::TCreateObject::create(JStudio::TObject** ppObject,
|
||||
JStudio::stb::data::TParse_TBlock_object const& param_2) {
|
||||
JUT_ASSERT(40, ppObject!=NULL);
|
||||
CreateFunc func;
|
||||
switch (param_2.get_type()) {
|
||||
case 'JPTC':
|
||||
func = createObject_JPA_PARTICLE_;
|
||||
break;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
*ppObject = func(param_2, this);
|
||||
return true;
|
||||
}
|
||||
|
||||
JPABaseEmitter* JStudio_JParticle::TCreateObject::emitter_create(u32 param_1) {
|
||||
JGeometry::TVec3<f32> local_08;
|
||||
Vec local_1c = {0.0f, 0.0f, 0.0f};
|
||||
local_08 = local_1c;
|
||||
return pJPAEmitterManager_->createSimpleEmitterID(
|
||||
local_08, param_1 & 0xffff, (param_1 >> 24) & 0xff, (param_1 >> 16) & 0xff, NULL, NULL);
|
||||
}
|
||||
|
||||
void JStudio_JParticle::TCreateObject::emitter_destroy(JPABaseEmitter* pEmitter) {
|
||||
pJPAEmitterManager_->forceDeleteEmitter(pEmitter);
|
||||
}
|
||||
|
||||
JStudio::TObject* JStudio_JParticle::TCreateObject::createObject_JPA_PARTICLE_(
|
||||
JStudio::stb::data::TParse_TBlock_object const& param_1,
|
||||
JStudio_JParticle::TCreateObject* param_2) {
|
||||
JStudio_JParticle::TAdaptor_particle* adaptor = new JStudio_JParticle::TAdaptor_particle(param_2);
|
||||
if (adaptor == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
JGadget::TPointer_delete<JStudio_JParticle::TAdaptor_particle> deleteGuard(adaptor);
|
||||
adaptor->set_bPermit_onExit_notEnd_(param_2->isPermit_onExit_notEnd());
|
||||
JStudio::TObject_particle* particle =
|
||||
JStudio::TCreateObject::createFromAdaptor<JStudio_JParticle::TAdaptor_particle>(param_1,
|
||||
adaptor);
|
||||
if (particle == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
deleteGuard.set(NULL);
|
||||
return particle;
|
||||
}
|
||||
@@ -0,0 +1,378 @@
|
||||
//
|
||||
// object-particle
|
||||
//
|
||||
|
||||
#include "JSystem/JSystem.h" // IWYU pragma: keep
|
||||
|
||||
#include "JSystem/JStudio/JStudio_JParticle/object-particle.h"
|
||||
#include "JSystem/JStudio/JStudio_JStage/control.h"
|
||||
|
||||
JStudio_JParticle::TAdaptor_particle::TAdaptor_particle(
|
||||
JStudio_JParticle::TCreateObject* param_1) :
|
||||
pCreateObject_(param_1),
|
||||
pJPAEmitter_(NULL),
|
||||
field_0x1a8(this) {
|
||||
field_0x1b4 = 0;
|
||||
field_0x1b5 = 0;
|
||||
field_0x1b6 = 0;
|
||||
field_0x1b7 = 0;
|
||||
field_0x1b8 = 0;
|
||||
field_0x1bc = -1;
|
||||
u32FadeTime_end = 0;
|
||||
field_0x1c4 = 0;
|
||||
field_0x1c8 = 0;
|
||||
field_0x1cc = 0;
|
||||
field_0x1d0 = NULL;
|
||||
field_0x1d4 = -1;
|
||||
field_0x1d8 = 0;
|
||||
JUT_ASSERT(90, pCreateObject_!=NULL);
|
||||
}
|
||||
|
||||
JStudio_JParticle::TAdaptor_particle::~TAdaptor_particle() {
|
||||
if (pJPAEmitter_ != NULL) {
|
||||
if (field_0x1b6 == 0) {
|
||||
pCreateObject_->emitter_destroy(pJPAEmitter_);
|
||||
} else if (field_0x1b4 != 0) {
|
||||
pJPAEmitter_->setEmitterCallBackPtr(field_0x1a8.getOld());
|
||||
pJPAEmitter_->quitImmortalEmitter();
|
||||
} else {
|
||||
pCreateObject_->emitter_destroy(pJPAEmitter_);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JParticle::TAdaptor_particle::adaptor_do_prepare() {
|
||||
static JStudio::TAdaptor::TSetVariableValue_immediate aoData[18] = {
|
||||
JStudio::TAdaptor::TSetVariableValue_immediate(0, 0.0f),
|
||||
JStudio::TAdaptor::TSetVariableValue_immediate(1, 0.0f),
|
||||
JStudio::TAdaptor::TSetVariableValue_immediate(2, 0.0f),
|
||||
JStudio::TAdaptor::TSetVariableValue_immediate(3, 0.0f),
|
||||
JStudio::TAdaptor::TSetVariableValue_immediate(4, 0.0f),
|
||||
JStudio::TAdaptor::TSetVariableValue_immediate(5, 0.0f),
|
||||
JStudio::TAdaptor::TSetVariableValue_immediate(6, 1.0f),
|
||||
JStudio::TAdaptor::TSetVariableValue_immediate(7, 1.0f),
|
||||
JStudio::TAdaptor::TSetVariableValue_immediate(8, 1.0f),
|
||||
JStudio::TAdaptor::TSetVariableValue_immediate(9, 255.0f),
|
||||
JStudio::TAdaptor::TSetVariableValue_immediate(10, 255.0f),
|
||||
JStudio::TAdaptor::TSetVariableValue_immediate(11, 255.0f),
|
||||
JStudio::TAdaptor::TSetVariableValue_immediate(12, 255.0f),
|
||||
JStudio::TAdaptor::TSetVariableValue_immediate(13, 255.0f),
|
||||
JStudio::TAdaptor::TSetVariableValue_immediate(14, 255.0f),
|
||||
JStudio::TAdaptor::TSetVariableValue_immediate(15, 255.0f),
|
||||
JStudio::TAdaptor::TSetVariableValue_immediate(16, 255.0f),
|
||||
JStudio::TAdaptor::TSetVariableValue_immediate(),
|
||||
};
|
||||
adaptor_setVariableValue_immediate(aoData);
|
||||
}
|
||||
|
||||
void JStudio_JParticle::TAdaptor_particle::adaptor_do_end() {
|
||||
}
|
||||
|
||||
void JStudio_JParticle::TAdaptor_particle::adaptor_do_update(u32 param_1) {
|
||||
const JStudio::TObject* pObject = adaptor_getObject();
|
||||
JUT_ASSERT(179, pObject != NULL);
|
||||
const JStudio::TControl* pControl = pObject->getControl();
|
||||
JUT_ASSERT(181, pControl != NULL);
|
||||
if (u32FadeTime_end != 0 && field_0x1c4 < u32FadeTime_end) {
|
||||
JUT_ASSERT(187, state_isFade_());
|
||||
JUT_ASSERT(188, pJPAEmitter_ != NULL);
|
||||
field_0x1c4 += param_1;
|
||||
if (field_0x1c4 >= u32FadeTime_end) {
|
||||
switch (field_0x1b8) {
|
||||
case 1:
|
||||
field_0x1b8 = 2;
|
||||
break;
|
||||
case 3:
|
||||
pCreateObject_->emitter_destroy(pJPAEmitter_);
|
||||
pJPAEmitter_ = NULL;
|
||||
field_0x1b8 = 0;
|
||||
break;
|
||||
}
|
||||
u32FadeTime_end = 0;
|
||||
field_0x1c4 = 0;
|
||||
}
|
||||
} else {
|
||||
JUT_ASSERT(210, !state_isFade_());
|
||||
}
|
||||
if (field_0x1b5 != 0 && field_0x1b7 != 0 && pJPAEmitter_ == NULL) {
|
||||
beginParticle_fadeIn_();
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JParticle::TAdaptor_particle::adaptor_do_PARTICLE(
|
||||
JStudio::data::TEOperationData param_1, const void* pContent, u32 uSize) {
|
||||
if (param_1 == JStudio::data::UNK_0x19) {
|
||||
JUT_ASSERT(232, uSize==4);
|
||||
JUT_ASSERT(233, pContent!=NULL);
|
||||
field_0x1bc = *(u32*)pContent;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JParticle::TAdaptor_particle::adaptor_do_BEGIN(JStudio::data::TEOperationData param_1,
|
||||
const void* pContent, u32 uSize) {
|
||||
switch (param_1) {
|
||||
case JStudio::data::UNK_0x1:
|
||||
JUT_ASSERT(253, uSize==0);
|
||||
beginParticle_();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JParticle::TAdaptor_particle::adaptor_do_BEGIN_FADE_IN(
|
||||
JStudio::data::TEOperationData param_1, const void* pContent, u32 uSize) {
|
||||
switch (param_1) {
|
||||
case JStudio::data::UNK_0x2:
|
||||
JUT_ASSERT(272, pContent!=NULL);
|
||||
JUT_ASSERT(273, uSize==4);
|
||||
beginParticle_fadeIn_(*(f32*)pContent);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JParticle::TAdaptor_particle::adaptor_do_END(JStudio::data::TEOperationData param_1,
|
||||
const void* pContent, u32 uSize) {
|
||||
if (param_1 == JStudio::data::UNK_0x1) {
|
||||
JUT_ASSERT(294, uSize==0);
|
||||
endParticle_();
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JParticle::TAdaptor_particle::adaptor_do_END_FADE_OUT(
|
||||
JStudio::data::TEOperationData param_1, const void* pContent, u32 uSize) {
|
||||
switch (param_1) {
|
||||
case JStudio::data::UNK_0x2:
|
||||
JUT_ASSERT(336, pContent!=NULL);
|
||||
JUT_ASSERT(337, uSize==4);
|
||||
endParticle_fadeOut_(*(f32*)pContent);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JParticle::TAdaptor_particle::adaptor_do_PARENT(
|
||||
JStudio::data::TEOperationData param_1, const void* pContent, u32 uSize) {
|
||||
switch (param_1) {
|
||||
case JStudio::data::UNK_0x18:
|
||||
JUT_ASSERT(313, pContent!=NULL);
|
||||
JUT_ASSERT(314, uSize==4);
|
||||
field_0x1d0 = NULL;
|
||||
const JStage::TSystem* pJSGSystem = pCreateObject_->get_pJSGSystem_();
|
||||
JUT_ASSERT(345, pJSGSystem!=NULL);
|
||||
JStage::TObject* pJSGObject;
|
||||
if (pJSGSystem->JSGFindObject(&pJSGObject, (const char*)pContent, JStage::OBJECT_UNDEFINED) == 0) {
|
||||
JUT_ASSERT(354, pJSGObject!=NULL);
|
||||
field_0x1d0 = pJSGObject;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JParticle::TAdaptor_particle::adaptor_do_PARENT_NODE(
|
||||
JStudio::data::TEOperationData param_1, const void* pContent, u32 uSize) {
|
||||
switch (param_1) {
|
||||
case JStudio::data::UNK_0x18:
|
||||
if (field_0x1d0 != NULL) {
|
||||
JUT_ASSERT(380, pContent!=NULL);
|
||||
JUT_ASSERT(381, uSize==4);
|
||||
field_0x1d4 = field_0x1d0->JSGFindNodeID((const char*)pContent);
|
||||
if (field_0x1d4 == -1) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case JStudio::data::UNK_0x19:
|
||||
JUT_ASSERT(397, uSize==4);
|
||||
JUT_ASSERT(396, pContent!=NULL);
|
||||
field_0x1d4 = *(u32*)pContent;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JParticle::TAdaptor_particle::adaptor_do_PARENT_ENABLE(JStudio::data::TEOperationData param_1,
|
||||
const void* pContent, u32 uSize) {
|
||||
if (param_1 == JStudio::data::UNK_0x2) {
|
||||
JUT_ASSERT(417, uSize==4);
|
||||
JUT_ASSERT(418, pContent!=NULL);
|
||||
field_0x1d8 = *(u32*)pContent ? 1 : 0;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JParticle::TAdaptor_particle::adaptor_do_PARENT_FUNCTION(JStudio::data::TEOperationData param_1,
|
||||
const void* pContent, u32 uSize) {
|
||||
if (param_1 == JStudio::data::UNK_0x2) {
|
||||
JUT_ASSERT(439, uSize==4);
|
||||
JUT_ASSERT(439, pContent!=NULL);
|
||||
field_0x1cc = *(u32*)pContent;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JParticle::TAdaptor_particle::adaptor_do_REPEAT(JStudio::data::TEOperationData param_1,
|
||||
const void* pContent, u32 uSize) {
|
||||
if (param_1 == JStudio::data::UNK_0x2) {
|
||||
JUT_ASSERT(460, uSize==4);
|
||||
JUT_ASSERT(461, pContent!=NULL);
|
||||
field_0x1b5 = *(u32*)pContent ? 1 : 0;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JParticle::TAdaptor_particle::adaptor_do_ON_EXIT_NOT_END(JStudio::data::TEOperationData param_1,
|
||||
const void* pContent, u32 uSize) {
|
||||
if (param_1 == JStudio::data::UNK_0x2) {
|
||||
JUT_ASSERT(460, uSize==4);
|
||||
JUT_ASSERT(461, pContent!=NULL);
|
||||
field_0x1b6 = *(u32*)pContent ? 1 : 0;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
JStudio_JParticle::TAdaptor_particle::TJPACallback_emitter_::execute(JPABaseEmitter* pJPAEmitter) {
|
||||
JUT_ASSERT(518, pJPAEmitter==pThis_->pJPAEmitter_);
|
||||
if (pJPAEmitter->isEnableDeleteEmitter()) {
|
||||
pThis_->pCreateObject_->emitter_destroy(pJPAEmitter);
|
||||
pThis_->pJPAEmitter_ = NULL;
|
||||
pThis_->field_0x1b8 = 0;
|
||||
pThis_->u32FadeTime_end = 0;
|
||||
pThis_->field_0x1c4 = 0;
|
||||
return;
|
||||
}
|
||||
const JStudio::TObject* pObject = pThis_->adaptor_getObject();
|
||||
JUT_ASSERT(534, pObject!=NULL);
|
||||
const JStudio::TControl* pControl = pObject->getControl();
|
||||
JUT_ASSERT(536, pControl!=NULL);
|
||||
TJPAEmitter_stopDrawParticle_ aTStack_21c(pJPAEmitter);
|
||||
JStudio::TControl::TTransform_translation_rotation_scaling VStack_19c;
|
||||
JStudio::TControl::TTransform_translation_rotation_scaling aTStack_1c0;
|
||||
pThis_->adaptor_getVariableValue_Vec(
|
||||
&VStack_19c.translation,
|
||||
sauVariableValue_3_TRANSLATION_XYZ);
|
||||
pThis_->adaptor_getVariableValue_Vec(
|
||||
&VStack_19c.rotation,
|
||||
sauVariableValue_3_ROTATION_XYZ);
|
||||
pThis_->adaptor_getVariableValue_Vec(
|
||||
&VStack_19c.scaling,
|
||||
sauVariableValue_3_SCALING_XYZ);
|
||||
if (pThis_->field_0x1d8 == 0) {
|
||||
const JStudio::TControl::TTransform_translation_rotation_scaling* pVVar9 = &VStack_19c;
|
||||
switch(pThis_->field_0x1cc) {
|
||||
case 0:
|
||||
pVVar9 = pControl->transformOnSet_transform_ifEnabled(VStack_19c, &aTStack_1c0);
|
||||
break;
|
||||
case 1:
|
||||
break;
|
||||
}
|
||||
pJPAEmitter->setGlobalTranslation(pVVar9->translation);
|
||||
int rotx = 65536.0 * (pVVar9->rotation.x / 360.0);
|
||||
int roty = 65536.0 * (pVVar9->rotation.y / 360.0);
|
||||
int rotz = 65536.0 * (pVVar9->rotation.z / 360.0);
|
||||
pJPAEmitter->setGlobalRotation(JGeometry::TVec3<s16>(rotx, roty, rotz));
|
||||
pJPAEmitter->setGlobalScale(pVVar9->scaling);
|
||||
} else {
|
||||
Mtx afStack_1f0;
|
||||
if (JStudio_JStage::transform_toGlobalFromLocal(afStack_1f0, VStack_19c, pThis_->field_0x1d0,
|
||||
pThis_->field_0x1d4) == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
pJPAEmitter->setGlobalSRTMatrix(afStack_1f0);
|
||||
}
|
||||
f64 alpha = 1.0;
|
||||
u32 u32FadeTime_end = pThis_->u32FadeTime_end;
|
||||
f64 dVar16 = u32FadeTime_end;
|
||||
f64 dVar15 = pThis_->field_0x1c4;
|
||||
switch(pThis_->field_0x1b8) {
|
||||
case 1:
|
||||
JUT_ASSERT(606, u32FadeTime_end>0);
|
||||
alpha = dVar15 / dVar16;
|
||||
break;
|
||||
case 3:
|
||||
JUT_ASSERT(611, u32FadeTime_end>0);
|
||||
alpha = (dVar16 - dVar15) / dVar16;
|
||||
}
|
||||
|
||||
u8 globalAlpha = 255;
|
||||
GXColor a_Stack_224;
|
||||
pThis_->adaptor_getVariableValue_GXColor(&a_Stack_224, sauVariableValue_4_COLOR_RGBA);
|
||||
alpha *= a_Stack_224.a;
|
||||
if (alpha < 255.0) {
|
||||
globalAlpha = alpha;
|
||||
}
|
||||
pJPAEmitter->setGlobalAlpha(globalAlpha);
|
||||
aTStack_21c.set(NULL);
|
||||
if (pOld != NULL) {
|
||||
pOld->execute(pJPAEmitter);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
JStudio_JParticle::TAdaptor_particle::TJPACallback_emitter_::executeAfter(JPABaseEmitter* pJPAEmitter) {
|
||||
if (pOld != NULL) {
|
||||
pOld->executeAfter(pJPAEmitter);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
JStudio_JParticle::TAdaptor_particle::TJPACallback_emitter_::draw(JPABaseEmitter* pJPAEmitter) {
|
||||
if (pOld != NULL) {
|
||||
pOld->draw(pJPAEmitter);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
JStudio_JParticle::TAdaptor_particle::TJPACallback_emitter_::drawAfter(JPABaseEmitter* pJPAEmitter) {
|
||||
if (pOld != NULL) {
|
||||
pOld->drawAfter(pJPAEmitter);
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JParticle::TAdaptor_particle::beginParticle_fadeIn_() {
|
||||
if (pJPAEmitter_ != NULL) {
|
||||
pCreateObject_->emitter_destroy(pJPAEmitter_);
|
||||
}
|
||||
JPABaseEmitter* pEmitter = pCreateObject_->emitter_create(field_0x1bc);
|
||||
pJPAEmitter_ = pEmitter;
|
||||
if (pEmitter != NULL) {
|
||||
field_0x1a8.setOld(pEmitter->getEmitterCallBackPtr());
|
||||
pEmitter->setEmitterCallBackPtr(&field_0x1a8);
|
||||
pEmitter->becomeImmortalEmitter();
|
||||
field_0x1b7 = 1;
|
||||
field_0x1b8 = 1;
|
||||
if (field_0x1c8 == 0) {
|
||||
field_0x1b8 = 2;
|
||||
}
|
||||
u32FadeTime_end = field_0x1c8;
|
||||
field_0x1c4 = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JParticle::TAdaptor_particle::endParticle_fadeOut_(u32 param_1) {
|
||||
if (pJPAEmitter_ == NULL) {
|
||||
return;
|
||||
}
|
||||
if (param_1 == 0) {
|
||||
pCreateObject_->emitter_destroy(pJPAEmitter_);
|
||||
pJPAEmitter_ = NULL;
|
||||
field_0x1b8 = 0;
|
||||
u32FadeTime_end = 0;
|
||||
field_0x1c4 = 0;
|
||||
return;
|
||||
}
|
||||
u8 eState_old = field_0x1b8 & 0xff;
|
||||
field_0x1b8 = 3;
|
||||
if (field_0x1c4 == 0) {
|
||||
u32FadeTime_end = param_1;
|
||||
return;
|
||||
}
|
||||
JUT_ASSERT(735, state_isFade_(eState_old));
|
||||
u32 u32Denominator = 0;
|
||||
|
||||
switch(eState_old) {
|
||||
case 1:
|
||||
u32Denominator = field_0x1c4;
|
||||
break;
|
||||
case 3:
|
||||
u32Denominator = u32FadeTime_end - field_0x1c4;
|
||||
break;
|
||||
}
|
||||
JUT_ASSERT(793, u32Denominator!=0);
|
||||
u32FadeTime_end = ((f64)param_1 * (f64)u32FadeTime_end) / u32Denominator;
|
||||
field_0x1c4 = u32FadeTime_end - param_1;
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
#include "JSystem/JSystem.h" // IWYU pragma: keep
|
||||
|
||||
#include "JSystem/JStudio/JStudio_JStage/control.h"
|
||||
#include "JSystem/JStage/JSGActor.h"
|
||||
#include "JSystem/JStage/JSGLight.h"
|
||||
#include "JSystem/JStage/JSGFog.h"
|
||||
#include "JSystem/JStage/JSGCamera.h"
|
||||
#include "JSystem/JStage/JSGAmbientLight.h"
|
||||
|
||||
JStudio_JStage::TCreateObject::~TCreateObject() {}
|
||||
|
||||
bool JStudio_JStage::TCreateObject::create(
|
||||
JStudio::TObject** ppObject, JStudio::stb::data::TParse_TBlock_object const& rParse) {
|
||||
JUT_ASSERT(83, ppObject!=NULL);
|
||||
*ppObject = NULL;
|
||||
ObjCreateFuncT pfnCreateObject;
|
||||
JStage::TEObject eObject;
|
||||
switch(rParse.get_type()) {
|
||||
case 'JACT':
|
||||
pfnCreateObject = createObject_JSG_<TAdaptor_actor, JStage::TActor>;
|
||||
eObject = JStage::OBJECT_ACTOR;
|
||||
break;
|
||||
case 'JCMR':
|
||||
pfnCreateObject = createObject_JSG_<TAdaptor_camera, JStage::TCamera>;
|
||||
eObject = JStage::OBJECT_CAMERA;
|
||||
break;
|
||||
case 'JABL':
|
||||
pfnCreateObject = createObject_JSG_<TAdaptor_ambientLight, JStage::TAmbientLight>;
|
||||
eObject = JStage::OBJECT_AMBIENT;
|
||||
break;
|
||||
case 'JLIT':
|
||||
pfnCreateObject = createObject_JSG_<TAdaptor_light, JStage::TLight>;
|
||||
eObject = JStage::OBJECT_LIGHT;
|
||||
break;
|
||||
case 'JFOG':
|
||||
pfnCreateObject = createObject_JSG_<TAdaptor_fog, JStage::TFog>;
|
||||
eObject = JStage::OBJECT_FOG;
|
||||
break;
|
||||
default:
|
||||
return NULL;
|
||||
}
|
||||
JUT_ASSERT(99, pfnCreateObject!=NULL);
|
||||
JUT_ASSERT(100, eObject!=JStage::OBJECT_UNDEFINED);
|
||||
JUT_ASSERT(109, pJSGSystem_!=NULL);
|
||||
JStage::TObject* pJSGObject;
|
||||
int pJVar2 = pJSGSystem_->JSGFindObject(&pJSGObject, (char const*)rParse.get_ID(), eObject);
|
||||
switch(pJVar2) {
|
||||
case 0:
|
||||
JUT_ASSERT(115, pJSGObject!=NULL);
|
||||
*ppObject = pfnCreateObject(rParse, pJSGObject, pJSGSystem_);
|
||||
return true;
|
||||
case 2:
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
@@ -0,0 +1,356 @@
|
||||
#include "JSystem/JSystem.h" // IWYU pragma: keep
|
||||
|
||||
#include "JSystem/JStudio/JStudio_JStage/object-actor.h"
|
||||
|
||||
JStudio_JStage::TAdaptor_actor::TAdaptor_actor(JStage::TSystem const* param_1,
|
||||
JStage::TActor* param_2) :
|
||||
TAdaptor_object_(this, param_1,param_2) {
|
||||
field_0x130 = 0;
|
||||
field_0x134 = 0;
|
||||
field_0x138 = 0;
|
||||
field_0x13c = NULL;
|
||||
field_0x140 = -1;
|
||||
field_0x144 = 0;
|
||||
field_0x148 = NULL;
|
||||
field_0x14c = -1;
|
||||
}
|
||||
|
||||
JStudio_JStage::TAdaptor_actor::~TAdaptor_actor() {
|
||||
adaptor_do_end();
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_actor::adaptor_do_prepare() {
|
||||
const TVVOutputObject* pOutput = saoVVOutput_;
|
||||
while (!pOutput->isEnd_()) {
|
||||
pOutput->adaptor_setOutput_(this);
|
||||
pOutput++;
|
||||
}
|
||||
|
||||
const TVVOutput_ANIMATION_FRAME_* pAnimOutput = saoVVOutput_ANIMATION_FRAME_;
|
||||
while (!pAnimOutput->isEnd_()) {
|
||||
pAnimOutput->adaptor_setOutput_(this);
|
||||
pAnimOutput++;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_actor::adaptor_do_begin() {
|
||||
adaptor_object_begin_();
|
||||
const JStage::TActor* pActor = get_pJSG_();
|
||||
#if DEBUG
|
||||
{ // This block is needed to match the stack in debug
|
||||
const JStudio::TObject* pObject = adaptor_getObject();
|
||||
JUT_ASSERT(72, pObject!=NULL);
|
||||
const JStudio::TControl* pControl = pObject->getControl();
|
||||
JUT_ASSERT(74, pControl!=NULL);
|
||||
getJSG_SRT_(pControl);
|
||||
}
|
||||
#else
|
||||
// Fakematch, load order is wrong in retail when using the inlines shown in debug
|
||||
getJSG_SRT_((const JStudio::TControl*)(adaptor_getObject()->pControl));
|
||||
#endif
|
||||
|
||||
const TVVOutputObject* pOutput = saoVVOutput_;
|
||||
while (!pOutput->isEnd_()) {
|
||||
pOutput->setVariableValue_(pActor, this);
|
||||
pOutput++;
|
||||
}
|
||||
|
||||
const TVVOutput_ANIMATION_FRAME_* pAnimOutput = saoVVOutput_ANIMATION_FRAME_;
|
||||
while (!pAnimOutput->isEnd_()) {
|
||||
pAnimOutput->setVariableValue_(pActor, this);
|
||||
pAnimOutput++;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_actor::adaptor_do_end() {
|
||||
adaptor_object_end_();
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_actor::adaptor_do_update(u32 param_1) {
|
||||
const JStudio::TObject* pObject = adaptor_getObject();
|
||||
JUT_ASSERT(104, pObject != NULL);
|
||||
const JStudio::TControl* pControl = pObject->getControl();
|
||||
JUT_ASSERT(106, pControl != NULL);
|
||||
setJSG_SRT_(pControl);
|
||||
pJSGObject_->JSGUpdate();
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_actor::adaptor_do_data(void const* param_1, u32 param_2,
|
||||
void const* param_3, u32 param_4) {
|
||||
adaptor_object_data_(param_1, param_2, param_3, param_4);
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_actor::adaptor_do_SHAPE(JStudio::data::TEOperationData operation,
|
||||
void const* param_2, u32 param_3) {
|
||||
setJSG_ID_(&JStage::TActor::JSGSetShape, operation, param_2, param_3);
|
||||
}
|
||||
|
||||
|
||||
void JStudio_JStage::TAdaptor_actor::adaptor_do_ANIMATION(JStudio::data::TEOperationData operation,
|
||||
void const* param_2, u32 param_3) {
|
||||
setJSG_ID_(&JStage::TActor::JSGSetAnimation, operation, param_2, param_3);
|
||||
}
|
||||
|
||||
|
||||
void JStudio_JStage::TAdaptor_actor::adaptor_do_ANIMATION_MODE(JStudio::data::TEOperationData operation,
|
||||
void const* pContent, u32 uSize) {
|
||||
switch (operation) {
|
||||
case JStudio::data::UNK_0x2:
|
||||
JUT_ASSERT(153, uSize==4);
|
||||
JUT_ASSERT(154, pContent!=NULL);
|
||||
field_0x130 = *(u32*)pContent;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_actor::adaptor_do_TEXTURE_ANIMATION(JStudio::data::TEOperationData operation,
|
||||
void const* param_2, u32 param_3) {
|
||||
setJSG_ID_(&JStage::TActor::JSGSetTextureAnimation, operation, param_2, param_3);
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_actor::adaptor_do_TEXTURE_ANIMATION_MODE(
|
||||
JStudio::data::TEOperationData operation, void const* pContent, u32 uSize) {
|
||||
switch (operation) {
|
||||
case JStudio::data::UNK_0x2:
|
||||
JUT_ASSERT(182, uSize==4);
|
||||
JUT_ASSERT(183, pContent!=NULL);
|
||||
field_0x134 = *(u32*)pContent;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_actor::adaptor_do_PARENT(
|
||||
JStudio::data::TEOperationData operation, void const* pContent, u32 uSize) {
|
||||
switch (operation) {
|
||||
case JStudio::data::UNK_0x18:
|
||||
JUT_ASSERT(203, pContent!=NULL);
|
||||
JUT_ASSERT(204, uSize!=0);
|
||||
field_0x13c = adaptor_object_findJSGObject_((const char*)pContent);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_actor::adaptor_do_PARENT_NODE(
|
||||
JStudio::data::TEOperationData operation, void const* pContent, u32 uSize) {
|
||||
switch (operation) {
|
||||
case JStudio::data::UNK_0x18:
|
||||
JUT_ASSERT(226, pContent!=NULL);
|
||||
JUT_ASSERT(227, uSize!=0);
|
||||
field_0x140 = adaptor_object_findJSGObjectNode_(field_0x13c, (const char*)pContent);
|
||||
break;
|
||||
case JStudio::data::UNK_0x19:
|
||||
JUT_ASSERT(237, uSize==4);
|
||||
JUT_ASSERT(238, pContent!=NULL);
|
||||
field_0x140 = *(u32*)pContent;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_actor::adaptor_do_PARENT_ENABLE(
|
||||
JStudio::data::TEOperationData operation, void const* pContent, u32 uSize) {
|
||||
switch (operation) {
|
||||
case JStudio::data::UNK_0x2:
|
||||
JUT_ASSERT(257, uSize==4);
|
||||
JUT_ASSERT(258, pContent!=NULL);
|
||||
bool v0 = (*(u32*)pContent != 0);
|
||||
if (field_0x144 != v0) {
|
||||
field_0x144 = v0;
|
||||
switch (field_0x138) {
|
||||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
JStage::TObject* object = NULL;
|
||||
u32 v1 = -1;
|
||||
if (v0 != 0) {
|
||||
object = field_0x13c;
|
||||
v1 = field_0x140;
|
||||
}
|
||||
pJSGObject_->JSGSetParent(object, v1);
|
||||
break;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_actor::adaptor_do_PARENT_FUNCTION(
|
||||
JStudio::data::TEOperationData operation, void const* pContent, u32 uSize) {
|
||||
switch (operation) {
|
||||
case JStudio::data::UNK_0x2:
|
||||
JUT_ASSERT(303, uSize==4);
|
||||
JUT_ASSERT(304, pContent!=NULL);
|
||||
field_0x138 = *(u32*)pContent;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_actor::adaptor_do_RELATION(
|
||||
JStudio::data::TEOperationData operation, void const* pContent, u32 uSize) {
|
||||
switch (operation) {
|
||||
case JStudio::data::UNK_0x18:
|
||||
JUT_ASSERT(324, pContent!=NULL);
|
||||
JUT_ASSERT(325, uSize!=0);
|
||||
field_0x148 = adaptor_object_findJSGObject_((const char*)pContent);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_actor::adaptor_do_RELATION_NODE(
|
||||
JStudio::data::TEOperationData operation, void const* pContent, u32 uSize) {
|
||||
switch (operation) {
|
||||
case JStudio::data::UNK_0x18:
|
||||
JUT_ASSERT(347, pContent!=NULL);
|
||||
JUT_ASSERT(348, uSize!=0);
|
||||
field_0x14c = adaptor_object_findJSGObjectNode_(field_0x13c, (const char*)pContent);
|
||||
break;
|
||||
case JStudio::data::UNK_0x19:
|
||||
JUT_ASSERT(358, uSize==4);
|
||||
JUT_ASSERT(359, pContent!=NULL);
|
||||
field_0x14c = *(u32*)pContent;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_actor::adaptor_do_RELATION_ENABLE(
|
||||
JStudio::data::TEOperationData operation, void const* pContent, u32 uSize) {
|
||||
switch (operation) {
|
||||
case JStudio::data::UNK_0x2:
|
||||
JUT_ASSERT(378, uSize==4);
|
||||
JUT_ASSERT(379, pContent!=NULL);
|
||||
pJSGObject_->JSGSetRelation(*(u32*)pContent, field_0x148, field_0x14c);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_actor::setJSG_ID_(void (JStage::TActor::*function)(u32),
|
||||
JStudio::data::TEOperationData operation,
|
||||
void const* pContent, u32 uSize) {
|
||||
switch (operation) {
|
||||
case JStudio::data::UNK_0x19:
|
||||
(((JStage::TActor*)pJSGObject_)->*function)(*(u32*)pContent);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_actor::setJSG_SRT_(JStudio::TControl const* pControl) {
|
||||
JStudio::TControl::TTransform_translation_rotation_scaling transform;
|
||||
JStudio::TControl::TTransform_translation_rotation_scaling multipliedTransform;
|
||||
adaptor_getVariableValue_Vec(&transform.translation, sauVariableValue_3_TRANSLATION_XYZ);
|
||||
adaptor_getVariableValue_Vec(&transform.rotation, sauVariableValue_3_ROTATION_XYZ);
|
||||
adaptor_getVariableValue_Vec(&transform.scaling, sauVariableValue_3_SCALING_XYZ);
|
||||
const JStudio::TControl::TTransform_translation_rotation_scaling* pTransform;
|
||||
if (field_0x144 == 0) {
|
||||
pTransform = pControl->transformOnSet_transform_ifEnabled(transform, &multipliedTransform);
|
||||
} else {
|
||||
pTransform = &transform;
|
||||
switch (field_0x138) {
|
||||
case 0: {
|
||||
Mtx mtx;
|
||||
bool check;
|
||||
if (!transform_toGlobalFromLocal(mtx, *pTransform, field_0x13c, field_0x140)) {
|
||||
check = false;
|
||||
} else {
|
||||
JStudio::math::getFromTransformation_SRxyzT(
|
||||
&multipliedTransform.scaling, &multipliedTransform.rotation,
|
||||
&multipliedTransform.translation, mtx);
|
||||
check = true;
|
||||
}
|
||||
|
||||
if (!check) {
|
||||
return;
|
||||
}
|
||||
pTransform = &multipliedTransform;
|
||||
break;
|
||||
}
|
||||
case 1:
|
||||
break;
|
||||
}
|
||||
}
|
||||
JStage::TActor* pActor = get_pJSG_();
|
||||
pActor->JSGSetTranslation(pTransform->translation);
|
||||
pActor->JSGSetRotation(pTransform->rotation);
|
||||
pActor->JSGSetScaling(pTransform->scaling);
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_actor::getJSG_SRT_(JStudio::TControl const* pControl) {
|
||||
JStudio::TControl::TTransform_translation_rotation_scaling transform;
|
||||
JStudio::TControl::TTransform_translation_rotation_scaling trs;
|
||||
Mtx mtx;
|
||||
JStage::TActor* pActor = get_pJSG_();
|
||||
pActor->JSGGetTranslation(&transform.translation);
|
||||
pActor->JSGGetRotation(&transform.rotation);
|
||||
pActor->JSGGetScaling(&transform.scaling);
|
||||
|
||||
JStudio::TControl::TTransform_translation_rotation_scaling* outTransform;
|
||||
if (!field_0x144) {
|
||||
outTransform = pControl->transformOnGet_transform_ifEnabled(&transform, &trs);
|
||||
} else {
|
||||
outTransform = &transform;
|
||||
switch (field_0x138) {
|
||||
case 1:
|
||||
break;
|
||||
case 0:
|
||||
bool check;
|
||||
if (!transform_toLocalFromGlobal(mtx, *outTransform, field_0x13c, field_0x140)) {
|
||||
check = false;
|
||||
} else {
|
||||
JStudio::math::getFromTransformation_SRxyzT(&trs.scaling, &trs.rotation,
|
||||
&trs.translation, mtx);
|
||||
check = true;
|
||||
}
|
||||
|
||||
if (!check) {
|
||||
return;
|
||||
}
|
||||
outTransform = &trs;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
adaptor_setVariableValue_Vec(sauVariableValue_3_TRANSLATION_XYZ,
|
||||
outTransform->translation);
|
||||
adaptor_setVariableValue_Vec(sauVariableValue_3_ROTATION_XYZ, outTransform->rotation);
|
||||
adaptor_setVariableValue_Vec(sauVariableValue_3_SCALING_XYZ, outTransform->scaling);
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_actor::TVVOutput_ANIMATION_FRAME_::operator()(
|
||||
f32 param_1, JStudio::TAdaptor* adaptor) const {
|
||||
JStage::TActor* actor = static_cast<TAdaptor_actor*>(adaptor)->get_pJSG_();
|
||||
// not sure what this bit is
|
||||
u32 idx = *(u32*)(((u32)adaptor - 1) + field_0x8);
|
||||
|
||||
u8 idx_lowBytes = idx;
|
||||
u8 idx_highBytes = idx >> 8;
|
||||
|
||||
f32 maxVal = (actor->*mMaxGetter)();
|
||||
switch (idx_highBytes) {
|
||||
case 1:
|
||||
param_1 = maxVal - param_1;
|
||||
break;
|
||||
case 0:
|
||||
break;
|
||||
}
|
||||
|
||||
if (maxVal > 0.0f) {
|
||||
param_1 = (f32)(*JStudio::TFunctionValue::toFunction_outside(idx_lowBytes))(param_1, maxVal);
|
||||
}
|
||||
(actor->*mSetter)(param_1);
|
||||
}
|
||||
|
||||
JStudio_JStage::TAdaptor_actor::TVVOutput_ANIMATION_FRAME_::~TVVOutput_ANIMATION_FRAME_() {
|
||||
}
|
||||
|
||||
namespace JStudio_JStage {
|
||||
|
||||
const TAdaptor_actor::TVVOutputObject TAdaptor_actor::saoVVOutput_[] = {
|
||||
TVVOutputObject(TAdaptor_actor::TEACTOR_1, &JStage::TActor::JSGSetAnimationTransition, &JStage::TActor::JSGGetAnimationTransition),
|
||||
TVVOutputObject()
|
||||
};
|
||||
|
||||
const TAdaptor_actor::TVVOutput_ANIMATION_FRAME_ TAdaptor_actor::saoVVOutput_ANIMATION_FRAME_[] = {
|
||||
TVVOutput_ANIMATION_FRAME_(0, 305, &JStage::TActor::JSGSetAnimationFrame, &JStage::TActor::JSGGetAnimationFrame, &JStage::TActor::JSGGetAnimationFrameMax),
|
||||
TVVOutput_ANIMATION_FRAME_(2, 309, &JStage::TActor::JSGSetTextureAnimationFrame, &JStage::TActor::JSGGetTextureAnimationFrame, &JStage::TActor::JSGGetTextureAnimationFrameMax),
|
||||
TVVOutput_ANIMATION_FRAME_()
|
||||
};
|
||||
|
||||
}; // namespace JStudio_JStage
|
||||
@@ -0,0 +1,42 @@
|
||||
//
|
||||
// object-ambientlight
|
||||
//
|
||||
|
||||
#include "JSystem/JSystem.h" // IWYU pragma: keep
|
||||
|
||||
#include "JSystem/JStudio/JStudio_JStage/object-ambientlight.h"
|
||||
|
||||
JStudio_JStage::TAdaptor_ambientLight::TAdaptor_ambientLight(JStage::TSystem const* param_1,
|
||||
JStage::TAmbientLight* param_2)
|
||||
: TAdaptor_object_(this, param_1, param_2) {}
|
||||
|
||||
JStudio_JStage::TAdaptor_ambientLight::~TAdaptor_ambientLight() {
|
||||
adaptor_do_end();
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_ambientLight::adaptor_do_prepare() {
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_ambientLight::adaptor_do_begin() {
|
||||
adaptor_object_begin_();
|
||||
JStage::TAmbientLight* light = get_pJSG_();
|
||||
GXColor color = light->JSGGetColor();
|
||||
adaptor_setVariableValue_GXColor(sauVariableValue_4_COLOR_RGBA, color);
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_ambientLight::adaptor_do_end() {
|
||||
adaptor_object_end_();
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_ambientLight::adaptor_do_update(u32 param_1) {
|
||||
JStage::TAmbientLight* lightObj = get_pJSG_();
|
||||
GXColor color;
|
||||
adaptor_getVariableValue_GXColor(&color, sauVariableValue_4_COLOR_RGBA);
|
||||
lightObj->JSGSetColor(color);
|
||||
pJSGObject_->JSGUpdate();
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_ambientLight::adaptor_do_data(void const* param_1, u32 param_2,
|
||||
void const* param_3, u32 param_4) {
|
||||
adaptor_object_data_(param_1, param_2, param_3, param_4);
|
||||
}
|
||||
@@ -0,0 +1,293 @@
|
||||
//
|
||||
// object-camera
|
||||
//
|
||||
|
||||
#include "JSystem/JSystem.h" // IWYU pragma: keep
|
||||
|
||||
#include "JSystem/JStudio/JStudio_JStage/object-camera.h"
|
||||
|
||||
JStudio_JStage::TAdaptor_camera::TAdaptor_camera(JStage::TSystem const* param_1,
|
||||
JStage::TCamera* param_2)
|
||||
: TAdaptor_object_(this, param_1, param_2) {
|
||||
field_0x108 = 0;
|
||||
field_0x10c = 0;
|
||||
field_0x110 = -1;
|
||||
field_0x114 = 0;
|
||||
field_0x118 = 0;
|
||||
field_0x11c = -1;
|
||||
field_0x120 = 0;
|
||||
}
|
||||
|
||||
JStudio_JStage::TAdaptor_camera::~TAdaptor_camera() {
|
||||
adaptor_do_end();
|
||||
}
|
||||
|
||||
JStudio_JStage::TAdaptor_camera::TVVOutput JStudio_JStage::TAdaptor_camera::saoVVOutput_[5] = {
|
||||
TVVOutput(JStudio_JStage::TAdaptor_camera::TECAMERA_7, &JStage::TCamera::JSGSetViewRoll,
|
||||
&JStage::TCamera::JSGGetViewRoll),
|
||||
TVVOutput(JStudio_JStage::TAdaptor_camera::TECAMERA_6, &JStage::TCamera::JSGSetProjectionFovy,
|
||||
&JStage::TCamera::JSGGetProjectionFovy),
|
||||
TVVOutput(JStudio_JStage::TAdaptor_camera::TECAMERA_8, &JStage::TCamera::JSGSetProjectionNear,
|
||||
&JStage::TCamera::JSGGetProjectionNear),
|
||||
TVVOutput(JStudio_JStage::TAdaptor_camera::TECAMERA_9, &JStage::TCamera::JSGSetProjectionFar,
|
||||
&JStage::TCamera::JSGGetProjectionFar),
|
||||
TVVOutput(),
|
||||
};
|
||||
|
||||
void JStudio_JStage::TAdaptor_camera::adaptor_do_prepare() {
|
||||
TVVOutput* pOutput = saoVVOutput_;
|
||||
while (!pOutput->isEnd_()) {
|
||||
pOutput->adaptor_setOutput_(this);
|
||||
pOutput++;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_camera::adaptor_do_begin() {
|
||||
adaptor_object_begin_();
|
||||
JStage::TCamera* pCamera = get_pJSG_();
|
||||
const JStudio::TObject* pObject = adaptor_getObject();
|
||||
JUT_ASSERT(70, pObject != NULL);
|
||||
const JStudio::TControl* pControl = pObject->getControl();
|
||||
JUT_ASSERT(72, pControl != NULL);
|
||||
getJSG_position_(pControl);
|
||||
getJSG_targetPosition_(pControl);
|
||||
TVVOutput* pOutput = saoVVOutput_;
|
||||
while (!pOutput->isEnd_()) {
|
||||
pOutput->setVariableValue_(pCamera, this);
|
||||
pOutput++;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_camera::adaptor_do_end() {
|
||||
adaptor_object_end_();
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_camera::adaptor_do_update(u32 param_1) {
|
||||
const JStudio::TObject* pObject = adaptor_getObject();
|
||||
JUT_ASSERT(98, pObject != NULL);
|
||||
const JStudio::TControl* pControl = pObject->getControl();
|
||||
JUT_ASSERT(100, pControl != NULL);
|
||||
setJSG_position_(pControl);
|
||||
setJSG_targetPosition_(pControl);
|
||||
pJSGObject_->JSGUpdate();
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_camera::adaptor_do_data(void const* param_1, u32 param_2,
|
||||
void const* param_3, u32 param_4) {
|
||||
adaptor_object_data_(param_1, param_2, param_3, param_4);
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_camera::adaptor_do_PARENT(JStudio::data::TEOperationData param_1,
|
||||
void const* pContent, u32 uSize) {
|
||||
switch(param_1) {
|
||||
case JStudio::data::UNK_0x18:
|
||||
JUT_ASSERT(132, pContent!=NULL);
|
||||
JUT_ASSERT(133, uSize!=0);
|
||||
field_0x10c = adaptor_object_findJSGObject_((char*)pContent);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_camera::adaptor_do_PARENT_NODE(JStudio::data::TEOperationData param_1,
|
||||
void const* pContent, u32 uSize) {
|
||||
switch (param_1) {
|
||||
case JStudio::data::UNK_0x18:
|
||||
JUT_ASSERT(155, pContent!=NULL);
|
||||
JUT_ASSERT(156, uSize!=0);
|
||||
field_0x110 = adaptor_object_findJSGObjectNode_(field_0x10c, (char*)pContent);
|
||||
break;
|
||||
case JStudio::data::UNK_0x19:
|
||||
JUT_ASSERT(166, uSize==4);
|
||||
JUT_ASSERT(167, pContent!=NULL);
|
||||
field_0x110 = *(int*)pContent;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
JStudio_JStage::TAdaptor_camera::adaptor_do_PARENT_ENABLE(JStudio::data::TEOperationData param_1,
|
||||
void const* pContent, u32 uSize) {
|
||||
switch (param_1) {
|
||||
case JStudio::data::UNK_0x2:
|
||||
JUT_ASSERT(185, uSize==4);
|
||||
JUT_ASSERT(186, pContent!=NULL);
|
||||
field_0x114 = *(u32*)pContent ? true : false;
|
||||
switch(field_0x108) {
|
||||
case 1: {
|
||||
JStage::TObject* parent = 0;
|
||||
int idx = -1;
|
||||
if (field_0x114 != 0) {
|
||||
parent = field_0x10c;
|
||||
idx = field_0x110;
|
||||
}
|
||||
pJSGObject_->JSGSetParent(parent, idx);
|
||||
break;
|
||||
}
|
||||
case 0:
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
JStudio_JStage::TAdaptor_camera::adaptor_do_PARENT_FUNCTION(JStudio::data::TEOperationData param_1,
|
||||
void const* pContent, u32 uSize) {
|
||||
switch(param_1) {
|
||||
case JStudio::data::UNK_0x2:
|
||||
JUT_ASSERT(226, uSize==4);
|
||||
JUT_ASSERT(227, pContent!=NULL);
|
||||
field_0x108 = *(int*)pContent;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_camera::adaptor_do_TARGET_PARENT(
|
||||
JStudio::data::TEOperationData param_1, void const* pContent, u32 uSize) {
|
||||
switch(param_1) {
|
||||
case JStudio::data::UNK_0x18:
|
||||
JUT_ASSERT(247, pContent!=NULL);
|
||||
JUT_ASSERT(248, uSize!=0);
|
||||
field_0x118 = adaptor_object_findJSGObject_((char*)pContent);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_camera::adaptor_do_TARGET_PARENT_NODE(
|
||||
JStudio::data::TEOperationData param_1, void const* pContent, u32 uSize) {
|
||||
switch (param_1) {
|
||||
case JStudio::data::UNK_0x18:
|
||||
JUT_ASSERT(270, pContent!=NULL);
|
||||
JUT_ASSERT(271, uSize!=0);
|
||||
field_0x11c = adaptor_object_findJSGObjectNode_(field_0x118, (char*)pContent);
|
||||
break;
|
||||
case JStudio::data::UNK_0x19:
|
||||
JUT_ASSERT(282, uSize==4);
|
||||
JUT_ASSERT(283, pContent!=NULL);
|
||||
field_0x11c = *(int*)pContent;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_camera::adaptor_do_TARGET_PARENT_ENABLE(
|
||||
JStudio::data::TEOperationData param_1, void const* pContent, u32 uSize) {
|
||||
switch(param_1) {
|
||||
case JStudio::data::UNK_0x2:
|
||||
JUT_ASSERT(301, uSize==4);
|
||||
JUT_ASSERT(302, pContent!=NULL);
|
||||
field_0x120 = *(int*)pContent ? 1 : 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_camera::setJSG_position_(JStudio::TControl const* param_1) {
|
||||
JStudio::TControl::TTransform_position VStack_138;
|
||||
JStudio::TControl::TTransform_position VStack_144;
|
||||
adaptor_getVariableValue_Vec(&VStack_138, sauVariableValue_3_POSITION_XYZ);
|
||||
const Vec* pViewPosition;
|
||||
if (field_0x114 == 0) {
|
||||
pViewPosition = param_1->transformOnSet_transform_ifEnabled(VStack_138, &VStack_144);
|
||||
} else {
|
||||
pViewPosition = &VStack_138;
|
||||
switch (field_0x108) {
|
||||
case 0: {
|
||||
int iVar1 =
|
||||
transform_toGlobalFromLocal(&VStack_144, VStack_138, field_0x10c, field_0x110);
|
||||
if (iVar1 == 0) {
|
||||
return;
|
||||
}
|
||||
pViewPosition = &VStack_144;
|
||||
break;
|
||||
}
|
||||
case 1:
|
||||
break;
|
||||
}
|
||||
}
|
||||
get_pJSG_()->JSGSetViewPosition(*pViewPosition);
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_camera::getJSG_position_(JStudio::TControl const* param_1) {
|
||||
Mtx mtx;
|
||||
JStudio::TControl::TTransform_position transform;
|
||||
JStudio::TControl::TTransform_position tempTransform;
|
||||
const JStudio::TControl::TTransform_position* outTransform;
|
||||
|
||||
get_pJSG_()->JSGGetViewPosition(&transform);
|
||||
|
||||
if (!field_0x114) {
|
||||
outTransform = param_1->transformOnGet_transform_ifEnabled(transform, &tempTransform);
|
||||
} else {
|
||||
outTransform = &transform;
|
||||
switch (field_0x108) {
|
||||
case 0:
|
||||
bool check;
|
||||
if (!transform_toLocalFromGlobal(mtx, *outTransform, field_0x10c, field_0x110)) {
|
||||
check = false;
|
||||
} else {
|
||||
tempTransform.x = mtx[0][3];
|
||||
tempTransform.y = mtx[1][3];
|
||||
tempTransform.z = mtx[2][3];
|
||||
check = true;
|
||||
}
|
||||
|
||||
if (!check) {
|
||||
return;
|
||||
}
|
||||
outTransform = &tempTransform;
|
||||
break;
|
||||
case 1:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
adaptor_setVariableValue_Vec(sauVariableValue_3_POSITION_XYZ, *outTransform);
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_camera::setJSG_targetPosition_(JStudio::TControl const* param_1) {
|
||||
JStudio::TControl::TTransform_position transform;
|
||||
JStudio::TControl::TTransform_position tempTransform;
|
||||
const JStudio::TControl::TTransform_position* outTransform;
|
||||
adaptor_getVariableValue_Vec(&transform, sauVariableValue_3_TARGET_POSITION_XYZ);
|
||||
if (field_0x120 == 0) {
|
||||
outTransform = param_1->transformOnSet_transform_ifEnabled(
|
||||
transform, &tempTransform);
|
||||
} else {
|
||||
if (transform_toGlobalFromLocal(&tempTransform, transform,
|
||||
field_0x118, field_0x11c) == 0) {
|
||||
return;
|
||||
}
|
||||
outTransform = &tempTransform;
|
||||
}
|
||||
get_pJSG_()->JSGSetViewTargetPosition(*outTransform);
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_camera::getJSG_targetPosition_(JStudio::TControl const* param_1) {
|
||||
Mtx mtx;
|
||||
JStudio::TControl::TTransform_position transform;
|
||||
JStudio::TControl::TTransform_position tempTransform;
|
||||
const JStudio::TControl::TTransform_position* outTransform;
|
||||
|
||||
get_pJSG_()->JSGGetViewTargetPosition(&transform);
|
||||
|
||||
if (!field_0x120) {
|
||||
outTransform = param_1->transformOnGet_transform_ifEnabled(transform, &tempTransform);
|
||||
} else {
|
||||
outTransform = &transform;
|
||||
bool check;
|
||||
if (!transform_toLocalFromGlobal(mtx, *outTransform, field_0x118, field_0x11c)) {
|
||||
check = false;
|
||||
} else {
|
||||
tempTransform.x = mtx[0][3];
|
||||
tempTransform.y = mtx[1][3];
|
||||
tempTransform.z = mtx[2][3];
|
||||
check = true;
|
||||
}
|
||||
|
||||
if (!check) {
|
||||
return;
|
||||
}
|
||||
outTransform = &tempTransform;
|
||||
}
|
||||
|
||||
adaptor_setVariableValue_Vec(sauVariableValue_3_TARGET_POSITION_XYZ, *outTransform);
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
//
|
||||
// object-fog
|
||||
//
|
||||
|
||||
#include "JSystem/JSystem.h" // IWYU pragma: keep
|
||||
|
||||
#include "JSystem/JStudio/JStudio_JStage/object-fog.h"
|
||||
|
||||
JStudio_JStage::TAdaptor_fog::TAdaptor_fog(JStage::TSystem const* param_0, JStage::TFog* param_1)
|
||||
: TAdaptor_object_(this, param_0, param_1) {}
|
||||
|
||||
JStudio_JStage::TAdaptor_fog::~TAdaptor_fog() {
|
||||
adaptor_do_end();
|
||||
}
|
||||
|
||||
JStudio_JStage::TVariableValueOutput_object_<JStudio_JStage::TAdaptor_fog, JStage::TFog> JStudio_JStage::TAdaptor_fog::saoVVOutput_[3] = {
|
||||
JStudio_JStage::TVariableValueOutput_object_<JStudio_JStage::TAdaptor_fog, JStage::TFog>(JStudio_JStage::TAdaptor_fog::TEFOG_4, &JStage::TFog::JSGSetStartZ, &JStage::TFog::JSGGetStartZ),
|
||||
JStudio_JStage::TVariableValueOutput_object_<JStudio_JStage::TAdaptor_fog, JStage::TFog>(JStudio_JStage::TAdaptor_fog::TEFOG_5, &JStage::TFog::JSGSetEndZ, &JStage::TFog::JSGGetEndZ),
|
||||
JStudio_JStage::TVariableValueOutput_object_<JStudio_JStage::TAdaptor_fog, JStage::TFog>(),
|
||||
};
|
||||
|
||||
void JStudio_JStage::TAdaptor_fog::adaptor_do_prepare() {
|
||||
TVariableValueOutput_object_<JStudio_JStage::TAdaptor_fog, JStage::TFog>* pOutput =
|
||||
saoVVOutput_;
|
||||
while (!pOutput->isEnd_()) {
|
||||
pOutput->adaptor_setOutput_(this);
|
||||
pOutput++;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_fog::adaptor_do_begin() {
|
||||
adaptor_object_begin_();
|
||||
JStage::TFog* pFog = get_pJSG_();
|
||||
adaptor_setVariableValue_GXColor(sauVariableValue_4_COLOR_RGBA, pFog->JSGGetColor());
|
||||
TVariableValueOutput_object_<JStudio_JStage::TAdaptor_fog, JStage::TFog>* pOutput =
|
||||
saoVVOutput_;
|
||||
while (!pOutput->isEnd_()) {
|
||||
pOutput->setVariableValue_(pFog, this);
|
||||
pOutput++;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_fog::adaptor_do_end() {
|
||||
adaptor_object_end_();
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_fog::adaptor_do_update(u32 param_1) {
|
||||
JStage::TFog* pFog = get_pJSG_();
|
||||
GXColor color;
|
||||
adaptor_getVariableValue_GXColor(&color, sauVariableValue_4_COLOR_RGBA);
|
||||
pFog->JSGSetColor(color);
|
||||
pJSGObject_->JSGUpdate();
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_fog::adaptor_do_data(void const* param_1, u32 param_2,
|
||||
void const* param_3, u32 param_4) {
|
||||
adaptor_object_data_(param_1, param_2, param_3, param_4);
|
||||
}
|
||||
@@ -0,0 +1,158 @@
|
||||
#include "JSystem/JSystem.h" // IWYU pragma: keep
|
||||
|
||||
#include "JSystem/JStudio/JStudio_JStage/object-light.h"
|
||||
|
||||
JStudio_JStage::TAdaptor_light::TAdaptor_light(JStage::TSystem const* param_1,
|
||||
JStage::TLight* param_2)
|
||||
: JStudio_JStage::TAdaptor_object_(this, param_1, param_2) {
|
||||
field_0x11c = 0;
|
||||
}
|
||||
|
||||
JStudio_JStage::TAdaptor_light::~TAdaptor_light() {
|
||||
adaptor_do_end();
|
||||
}
|
||||
|
||||
JStudio_JStage::TAdaptor_light::TVVOutput_direction_
|
||||
JStudio_JStage::TAdaptor_light::saoVVOutput_direction_[6] = {
|
||||
JStudio_JStage::TAdaptor_light::TVVOutput_direction_(
|
||||
JStudio_JStage::TAdaptor_light::TE_VALUE_10,
|
||||
JStudio_JStage::TAdaptor_light::DIRECTION_1),
|
||||
JStudio_JStage::TAdaptor_light::TVVOutput_direction_(
|
||||
JStudio_JStage::TAdaptor_light::TE_VALUE_11,
|
||||
JStudio_JStage::TAdaptor_light::DIRECTION_1),
|
||||
JStudio_JStage::TAdaptor_light::TVVOutput_direction_(
|
||||
JStudio_JStage::TAdaptor_light::TE_VALUE_7,
|
||||
JStudio_JStage::TAdaptor_light::DIRECTION_2),
|
||||
JStudio_JStage::TAdaptor_light::TVVOutput_direction_(
|
||||
JStudio_JStage::TAdaptor_light::TE_VALUE_8,
|
||||
JStudio_JStage::TAdaptor_light::DIRECTION_2),
|
||||
JStudio_JStage::TAdaptor_light::TVVOutput_direction_(
|
||||
JStudio_JStage::TAdaptor_light::TE_VALUE_9,
|
||||
JStudio_JStage::TAdaptor_light::DIRECTION_2),
|
||||
JStudio_JStage::TAdaptor_light::TVVOutput_direction_(),
|
||||
};
|
||||
|
||||
void JStudio_JStage::TAdaptor_light::adaptor_do_prepare() {
|
||||
TVVOutput_direction_* pOutput = saoVVOutput_direction_;
|
||||
while (!pOutput->isEnd_()) {
|
||||
pOutput->adaptor_setOutput_(this);
|
||||
pOutput++;
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_light::adaptor_do_begin() {
|
||||
{
|
||||
adaptor_object_begin_();
|
||||
JStage::TLight* pLightObj = get_pJSG_();
|
||||
const JStudio::TObject* pObject = adaptor_getObject();
|
||||
JUT_ASSERT(60, pObject!=NULL);
|
||||
const JStudio::TControl* pControl = pObject->getControl();
|
||||
JUT_ASSERT(62, pControl!=NULL);
|
||||
GXColor lightColor = pLightObj->JSGGetColor();
|
||||
adaptor_setVariableValue_GXColor(sauVariableValue_4_COLOR_RGBA, lightColor);
|
||||
JStudio::TControl::TTransform_position_direction lightObjTransform;
|
||||
JStudio::TControl::TTransform_position_direction aTStack_b8;
|
||||
pLightObj->JSGGetPosition(&lightObjTransform.position);
|
||||
pLightObj->JSGGetDirection(&lightObjTransform.direction);
|
||||
const JStudio::TControl::TTransform_position_direction* finalTransform =
|
||||
(const JStudio::TControl::TTransform_position_direction*)
|
||||
pControl->transformOnGet_transform_ifEnabled(lightObjTransform, &aTStack_b8);
|
||||
adaptor_setVariableValue_Vec(sauVariableValue_3_POSITION_XYZ, finalTransform->position);
|
||||
f32 dirx = finalTransform->direction.x;
|
||||
f32 diry = finalTransform->direction.y;
|
||||
f32 dirz = finalTransform->direction.z;
|
||||
f32 sqr = sqrtf(dirx * dirx + dirz * dirz);
|
||||
f32 dVar11 = atan2f(dirx, dirz);
|
||||
f32 dVar9 = atan2f(diry, sqr);
|
||||
adaptor_setVariableValue_immediate(10, MTXRadToDeg(dVar11));
|
||||
adaptor_setVariableValue_immediate(11, MTXRadToDeg(dVar9));
|
||||
Vec VStack_c4;
|
||||
VECAdd(&finalTransform->position, &finalTransform->direction, &VStack_c4);
|
||||
adaptor_setVariableValue_Vec(sauVariableValue_3_TARGET_POSITION_XYZ, VStack_c4);
|
||||
}
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_light::adaptor_do_end() {
|
||||
adaptor_object_end_();
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_light::adaptor_do_update(u32 param_1) {
|
||||
JStage::TLight* lightObj = get_pJSG_();
|
||||
const JStudio::TObject* pObject = adaptor_getObject();
|
||||
JUT_ASSERT(118, pObject!=NULL);
|
||||
const JStudio::TControl* pControl = pObject->getControl();
|
||||
JUT_ASSERT(120, pControl!=NULL);
|
||||
GXColor lightColor;
|
||||
adaptor_getVariableValue_GXColor(&lightColor, sauVariableValue_4_COLOR_RGBA);
|
||||
lightObj->JSGSetColor(lightColor);
|
||||
JStudio::TControl::TTransform_position_direction VStack_198;
|
||||
JStudio::TControl::TTransform_position_direction aTStack_1b0;
|
||||
adaptor_getVariableValue_Vec(&VStack_198.position, sauVariableValue_3_POSITION_XYZ);
|
||||
switch (field_0x11c) {
|
||||
case 1: {
|
||||
f32 dVar10 = adaptor_getVariableValue(10)->getValue();
|
||||
f32 dVar11 = adaptor_getVariableValue(11)->getValue();
|
||||
f32 temp = MTXDegToRad(dVar11);
|
||||
f32 dVar12 = cosf(temp);
|
||||
f32 sinVal = sinf(temp);
|
||||
f32 temp2 = MTXDegToRad(dVar10);
|
||||
VStack_198.direction.x = dVar12 * sinf(temp2);
|
||||
VStack_198.direction.y = sinVal;
|
||||
VStack_198.direction.z = dVar12 * cosf(temp2);
|
||||
break;
|
||||
}
|
||||
case 2:
|
||||
Vec VStack_1c0;
|
||||
adaptor_getVariableValue_Vec(&VStack_1c0, sauVariableValue_3_TARGET_POSITION_XYZ);
|
||||
VECSubtract(&VStack_1c0, &VStack_198.position, &VStack_198.direction);
|
||||
}
|
||||
const JStudio::TControl::TTransform_position_direction* pTrans =
|
||||
pControl->transformOnSet_transform_ifEnabled(VStack_198, &aTStack_1b0);
|
||||
lightObj->JSGSetPosition(pTrans->position);
|
||||
lightObj->JSGSetDirection(pTrans->direction);
|
||||
pJSGObject_->JSGUpdate();
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_light::adaptor_do_data(void const* param_1, u32 param_2,
|
||||
void const* param_3, u32 param_4) {
|
||||
adaptor_object_data_(param_1, param_2, param_3, param_4);
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_light::adaptor_do_FACULTY(JStudio::data::TEOperationData param_1,
|
||||
void const* pContent, u32 uSize) {
|
||||
switch (param_1) {
|
||||
case JStudio::data::UNK_0x2:
|
||||
JUT_ASSERT(198, uSize==4);
|
||||
JUT_ASSERT(199, pContent!=NULL);
|
||||
JStage::TELight lightType;
|
||||
switch (*(u32*)pContent) {
|
||||
case 0x301:
|
||||
lightType = JStage::TELIGHT_1;
|
||||
break;
|
||||
case 0x302:
|
||||
lightType = JStage::TELIGHT_2;
|
||||
break;
|
||||
case 0x303:
|
||||
lightType = JStage::TELIGHT_3;
|
||||
break;
|
||||
default:
|
||||
// TODO: find out how to lose the goto
|
||||
goto end;
|
||||
}
|
||||
get_pJSG_()->JSGSetLightType(lightType);
|
||||
break;
|
||||
}
|
||||
end:;
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_light::adaptor_do_ENABLE(JStudio::data::TEOperationData param_1,
|
||||
void const* param_2, u32 param_3) {
|
||||
adaptor_object_ENABLE_(param_1, param_2, param_3);
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_light::TVVOutput_direction_::operator()(
|
||||
f32 param_0, JStudio::TAdaptor* param_1) const {
|
||||
JStudio_JStage::TAdaptor_light* p = (JStudio_JStage::TAdaptor_light*)param_1;
|
||||
JUT_ASSERT(246, p!=NULL);
|
||||
p->field_0x11c = field_0x8;
|
||||
}
|
||||
@@ -0,0 +1,123 @@
|
||||
//
|
||||
// object
|
||||
//
|
||||
|
||||
#include "JSystem/JSystem.h" // IWYU pragma: keep
|
||||
|
||||
#include "JSystem/JStudio/JStudio_JStage/object.h"
|
||||
|
||||
bool JStudio_JStage::transform_toGlobalFromLocal(
|
||||
f32 (*param_1)[4], JStudio::TControl::TTransform_translation_rotation_scaling const& param_2,
|
||||
JStage::TObject const* param_3, u32 param_4) {
|
||||
if (param_3 == NULL) {
|
||||
return false;
|
||||
}
|
||||
Mtx nodeTransformMtx;
|
||||
if (!param_3->JSGGetNodeTransformation(param_4, nodeTransformMtx)) {
|
||||
return false;
|
||||
}
|
||||
Mtx amStack_70;
|
||||
JStudio::math::getTransformation_SRxyzT(amStack_70, param_2.scaling, param_2.rotation,
|
||||
param_2.translation);
|
||||
MTXConcat(nodeTransformMtx, amStack_70, param_1);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool JStudio_JStage::transform_toGlobalFromLocal(
|
||||
f32 (*param_1)[4], JStudio::TControl::TTransform_position const& param_2,
|
||||
JStage::TObject const* param_3, u32 param_4) {
|
||||
if (param_3 == NULL) {
|
||||
return false;
|
||||
}
|
||||
Mtx nodeTransformMtx;
|
||||
if (!param_3->JSGGetNodeTransformation(param_4, nodeTransformMtx)) {
|
||||
return false;
|
||||
}
|
||||
Mtx amStack_70;
|
||||
JStudio::math::getTransformation_T(amStack_70, ¶m_2);
|
||||
MTXConcat(nodeTransformMtx, amStack_70, param_1);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool JStudio_JStage::transform_toLocalFromGlobal(
|
||||
f32 (*param_1)[4], JStudio::TControl::TTransform_translation_rotation_scaling const& param_2,
|
||||
JStage::TObject const* param_3, u32 param_4) {
|
||||
if (param_3 == NULL) {
|
||||
return false;
|
||||
}
|
||||
Mtx nodeTransformMtx;
|
||||
if (!param_3->JSGGetNodeTransformation(param_4, nodeTransformMtx)) {
|
||||
return false;
|
||||
}
|
||||
Mtx afStack_70;
|
||||
JStudio::math::getTransformation_SRxyzT(afStack_70, param_2.scaling, param_2.rotation,
|
||||
param_2.translation);
|
||||
Mtx auStack_a0;
|
||||
MTXInverse(nodeTransformMtx, auStack_a0);
|
||||
MTXConcat(auStack_a0, afStack_70, param_1);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool JStudio_JStage::transform_toLocalFromGlobal(
|
||||
f32 (*param_1)[4], JStudio::TControl::TTransform_position const& param_2,
|
||||
JStage::TObject const* param_3, u32 param_4) {
|
||||
if (param_3 == NULL) {
|
||||
return false;
|
||||
}
|
||||
Mtx nodeTransformMtx;
|
||||
if (!param_3->JSGGetNodeTransformation(param_4, nodeTransformMtx)) {
|
||||
return false;
|
||||
}
|
||||
Mtx afStack_70;
|
||||
JStudio::math::getTransformation_T(afStack_70, ¶m_2);
|
||||
Mtx auStack_a0;
|
||||
MTXInverse(nodeTransformMtx, auStack_a0);
|
||||
MTXConcat(auStack_a0, afStack_70, param_1);
|
||||
return true;
|
||||
}
|
||||
|
||||
void JStudio_JStage::TAdaptor_object_::adaptor_object_data_(void const* param_1, u32 param_2,
|
||||
void const* param_3, u32 param_4) {
|
||||
int uVar3;
|
||||
if (param_2 == 0) {
|
||||
uVar3 = JStage::TActor::ID_NORMAL;
|
||||
} else {
|
||||
uVar3 = *(int*)param_1;
|
||||
}
|
||||
pJSGObject_->JSGSetData(uVar3, param_3, param_4);
|
||||
}
|
||||
|
||||
JStage::TObject*
|
||||
JStudio_JStage::TAdaptor_object_::adaptor_object_findJSGObject_(char const* param_1) {
|
||||
JStage::TObject* pJSGObject;
|
||||
if (pJSGSystem_->JSGFindObject(&pJSGObject, param_1, JStage::OBJECT_UNDEFINED) == 0) {
|
||||
JUT_ASSERT(122, pJSGObject != NULL);
|
||||
} else {
|
||||
return NULL;
|
||||
}
|
||||
return pJSGObject;
|
||||
}
|
||||
|
||||
s32 JStudio_JStage::TAdaptor_object_::adaptor_object_findJSGObjectNode_(
|
||||
JStage::TObject const* param_1, char const* param_2) {
|
||||
if (param_1 == NULL) {
|
||||
return -1;
|
||||
}
|
||||
return param_1->JSGFindNodeID(param_2);
|
||||
}
|
||||
|
||||
void
|
||||
JStudio_JStage::TAdaptor_object_::adaptor_object_ENABLE_(JStudio::data::TEOperationData param_1,
|
||||
void const* pContent, u32 uSize) {
|
||||
switch (param_1) {
|
||||
case JStudio::data::UNK_0x2:
|
||||
JUT_ASSERT(157, uSize==4);
|
||||
JUT_ASSERT(158, pContent!=NULL);
|
||||
if (*(u32*)pContent != 0) {
|
||||
pJSGObject_->JSGFEnableFlag(2);
|
||||
} else {
|
||||
pJSGObject_->JSGFDisableFlag(2);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user