From c0a5e0961d8c72cffaf22688b88deb2620a6404f Mon Sep 17 00:00:00 2001 From: aap Date: Sun, 7 Jan 2018 02:12:20 +0100 Subject: [PATCH] work on uvanims --- src/base.cpp | 16 ++++++ src/matfx.cpp | 112 +++++++++++++++++++++++++++++++++++- src/rwanim.h | 16 ++++++ src/rwbase.h | 1 + src/rwplugins.h | 21 ++++++- src/uvanim.cpp | 149 ++++++++++++++++++++++++++++++++++++++++++++++-- 6 files changed, 307 insertions(+), 8 deletions(-) diff --git a/src/base.cpp b/src/base.cpp index 745ac11..375911b 100755 --- a/src/base.cpp +++ b/src/base.cpp @@ -40,6 +40,22 @@ static Matrix identMat = { }; // lazy implementation +int +strcmp_ci(const char *s1, const char *s2) +{ + char c1, c2; + for(;;){ + c1 = tolower(*s1); + c2 = tolower(*s2); + if(c1 != c2) + return c1 - c2; + if(c1 == '\0') + return 0; + s1++; + s2++; + } +} + int strncmp_ci(const char *s1, const char *s2, int n) { diff --git a/src/matfx.cpp b/src/matfx.cpp index aa7a258..0035527 100755 --- a/src/matfx.cpp +++ b/src/matfx.cpp @@ -36,8 +36,9 @@ createAtomicMatFX(void *object, int32 offset, int32) static void* copyAtomicMatFX(void *dst, void *src, int32 offset, int32) { + // don't call seteffects, it will override the pipeline if(*PLUGINOFFSET(int32, src, offset)) - MatFX::enableEffects((Atomic*)dst); + *PLUGINOFFSET(int32, dst, offset) = 1; return dst; } @@ -170,6 +171,24 @@ MatFX::setBumpCoefficient(float32 coef) this->fx[i].bump.coefficient = coef; } +Texture* +MatFX::getBumpTexture(void) +{ + int32 i = this->getEffectIndex(BUMPMAP); + if(i >= 0) + return this->fx[i].bump.tex; + return nil; +} + +float32 +MatFX::getBumpCoefficient(void) +{ + int32 i = this->getEffectIndex(BUMPMAP); + if(i >= 0) + return this->fx[i].bump.coefficient; + return 0.0f; +} + void MatFX::setEnvTexture(Texture *t) { @@ -194,6 +213,34 @@ MatFX::setEnvCoefficient(float32 coef) this->fx[i].env.coefficient = coef; } +Texture* +MatFX::getEnvTexture(void) +{ + int32 i = this->getEffectIndex(ENVMAP); + if(i >= 0) + return this->fx[i].env.tex; + return nil; +} + +Frame* +MatFX::getEnvFrame(void) +{ + int32 i = this->getEffectIndex(ENVMAP); + if(i >= 0) + return this->fx[i].env.frame; + return nil; +} + +float32 +MatFX::getEnvCoefficient(void) +{ + int32 i = this->getEffectIndex(ENVMAP); + if(i >= 0) + return this->fx[i].env.coefficient; + return 0.0f; +} + + void MatFX::setDualTexture(Texture *t) { @@ -218,6 +265,56 @@ MatFX::setDualDestBlend(int32 blend) this->fx[i].dual.dstBlend = blend; } +Texture* +MatFX::getDualTexture(void) +{ + int32 i = this->getEffectIndex(DUAL); + if(i >= 0) + return this->fx[i].dual.tex; + return nil; +} + +int32 +MatFX::getDualSrcBlend(void) +{ + int32 i = this->getEffectIndex(DUAL); + if(i >= 0) + return this->fx[i].dual.srcBlend; + return 0; +} + +int32 +MatFX::getDualDestBlend(void) +{ + int32 i = this->getEffectIndex(DUAL); + if(i >= 0) + return this->fx[i].dual.dstBlend; + return 0; +} + +void +MatFX::setUVTransformMatrices(Matrix *base, Matrix *dual) +{ + int32 i = this->getEffectIndex(UVTRANSFORM); + if(i >= 0){ + this->fx[i].uvtransform.baseTransform = base; + this->fx[i].uvtransform.dualTransform = dual; + } +} + +void +MatFX::getUVTransformMatrices(Matrix **base, Matrix **dual) +{ + int32 i = this->getEffectIndex(UVTRANSFORM); + if(i >= 0){ + if(base) *base = this->fx[i].uvtransform.baseTransform; + if(dual) *dual = this->fx[i].uvtransform.dualTransform; + return; + } + if(base) *base = nil; + if(dual) *dual = nil; +} + static void* createMaterialMatFX(void *object, int32 offset, int32) { @@ -437,6 +534,19 @@ MatFX::enableEffects(Atomic *atomic) atomic->pipeline = matFXGlobals.pipelines[rw::platform]; } +// This prevents setting the pipeline on clone +void +MatFX::disableEffects(Atomic *atomic) +{ + *PLUGINOFFSET(int32, atomic, matFXGlobals.atomicOffset) = 0; +} + +bool32 +MatFX::getEffects(Atomic *atomic) +{ + return *PLUGINOFFSET(int32, atomic, matFXGlobals.atomicOffset); +} + static void* matfxOpen(void *o, int32, int32) { diff --git a/src/rwanim.h b/src/rwanim.h index dad4be7..c24786b 100644 --- a/src/rwanim.h +++ b/src/rwanim.h @@ -105,6 +105,16 @@ struct AnimInterpolator // UV anim // +struct UVAnimParamData +{ + float32 theta; // rotation + float32 s0; // scale x + float32 s1; // scale y + float32 skew; // skew + float32 x; // x pos + float32 y; // y pos +}; + struct UVAnimKeyFrame { UVAnimKeyFrame *prev; @@ -162,9 +172,15 @@ struct UVAnimDictionary extern UVAnimDictionary *currentUVAnimDictionary; +// Material plugin struct UVAnim { + Matrix *uv[2]; AnimInterpolator *interp[8]; + + static bool32 exists(Material *mat); + static void addTime(Material *mat, float32 t); + static void applyUpdate(Material *mat); }; extern int32 uvAnimOffset; diff --git a/src/rwbase.h b/src/rwbase.h index c35c89a..2a1577e 100644 --- a/src/rwbase.h +++ b/src/rwbase.h @@ -579,6 +579,7 @@ extern int32 platform; extern bool32 streamAppendFrames; extern char *debugFile; +int strcmp_ci(const char *s1, const char *s2); int strncmp_ci(const char *s1, const char *s2, int n); // 0x04000000 3.1 diff --git a/src/rwplugins.h b/src/rwplugins.h index d0edf9f..86075e1 100755 --- a/src/rwplugins.h +++ b/src/rwplugins.h @@ -112,11 +112,10 @@ struct MatFX int32 dstBlend; }; struct UVtransform { - float *baseTransform; - float *dualTransform; + Matrix *baseTransform; + Matrix *dualTransform; }; struct { -// uint32 foo[32]; uint32 type; union { Bump bump; @@ -131,16 +130,32 @@ struct MatFX static uint32 getEffects(Material *m); static MatFX *get(Material *m); int32 getEffectIndex(uint32 type); + // Bump void setBumpTexture(Texture *t); void setBumpCoefficient(float32 coef); + Texture *getBumpTexture(void); + float32 getBumpCoefficient(void); + // Env void setEnvTexture(Texture *t); void setEnvFrame(Frame *f); void setEnvCoefficient(float32 coef); + Texture *getEnvTexture(void); + Frame *getEnvFrame(void); + float32 getEnvCoefficient(void); + // Dual void setDualTexture(Texture *t); void setDualSrcBlend(int32 blend); void setDualDestBlend(int32 blend); + Texture *getDualTexture(void); + int32 getDualSrcBlend(void); + int32 getDualDestBlend(void); + // UV transform + void setUVTransformMatrices(Matrix *base, Matrix *dual); + void getUVTransformMatrices(Matrix **base, Matrix **dual); static void enableEffects(Atomic *atomic); + static void disableEffects(Atomic *atomic); + static bool32 getEffects(Atomic *atomic); }; struct MatFXGlobals diff --git a/src/uvanim.cpp b/src/uvanim.cpp index fba042c..05e2fba 100644 --- a/src/uvanim.cpp +++ b/src/uvanim.cpp @@ -168,18 +168,103 @@ uvAnimStreamGetSize(Animation *anim) return 4 + 32 + 8*4 + anim->numFrames*(4 + 6*4 + 4); } +static void +uvAnimLinearApplyCB(void *result, void *frame) +{ + Matrix *m = (Matrix*)result; + UVAnimInterpFrame *f = (UVAnimInterpFrame*)frame; + m->right.x = f->uv[0]; + m->right.y = f->uv[1]; + m->right.z = 0.0f; + m->up.x = f->uv[2]; + m->up.y = f->uv[3]; + m->up.z = 0.0f; + m->at.x = 0.0f; + m->at.y = 0.0f; + m->at.z = 0.0f; + m->pos.x = f->uv[4]; + m->pos.y = f->uv[5]; + m->pos.z = 0.0f; + m->update(); +} + +static void +uvAnimLinearInterpCB(void *out, void *in1, void *in2, float32 t, void *custom) +{ + UVAnimInterpFrame *intf = (UVAnimInterpFrame*)out; + UVAnimKeyFrame *kf1 = (UVAnimKeyFrame*)in1; + UVAnimKeyFrame *kf2 = (UVAnimKeyFrame*)in2; + float32 f = (t - kf1->time) / (kf2->time - kf1->time); + intf->uv[0] = (kf2->uv[0] - kf1->uv[0])*f + kf1->uv[0]; + intf->uv[1] = (kf2->uv[1] - kf1->uv[1])*f + kf1->uv[1]; + intf->uv[2] = (kf2->uv[2] - kf1->uv[2])*f + kf1->uv[2]; + intf->uv[3] = (kf2->uv[3] - kf1->uv[3])*f + kf1->uv[3]; + intf->uv[4] = (kf2->uv[4] - kf1->uv[4])*f + kf1->uv[4]; + intf->uv[5] = (kf2->uv[5] - kf1->uv[5])*f + kf1->uv[5]; +} + +static void +uvAnimParamApplyCB(void *result, void *frame) +{ + Matrix *m = (Matrix*)result; + UVAnimInterpFrame *f = (UVAnimInterpFrame*)frame; + UVAnimParamData *p = (UVAnimParamData*)f->uv; + + m->right.x = p->s0; + m->right.y = p->skew; + m->right.z = 0.0f; + m->up.x = 0.0f; + m->up.y = p->s1; + m->up.z = 0.0f; + m->at.x = 0.0f; + m->at.y = 0.0f; + m->at.z = 0.0f; + m->pos.x = p->x; + m->pos.y = p->y; + m->pos.z = 0.0f; + m->update(); + static V3d xlat1 = { -0.5f, -0.5f, 0.0f }; + static V3d xlat2 = { 0.5f, 0.5f, 0.0f }; + static V3d axis = { 0.0f, 0.0f, 1.0f }; + m->translate(&xlat1, COMBINEPOSTCONCAT); + m->rotate(&axis, p->theta*180.0f/M_PI, COMBINEPOSTCONCAT); + m->translate(&xlat2, COMBINEPOSTCONCAT); +} + +static void +uvAnimParamInterpCB(void *out, void *in1, void *in2, float32 t, void *custom) +{ + UVAnimInterpFrame *intf = (UVAnimInterpFrame*)out; + UVAnimKeyFrame *kf1 = (UVAnimKeyFrame*)in1; + UVAnimKeyFrame *kf2 = (UVAnimKeyFrame*)in2; + float32 f = (t - kf1->time) / (kf2->time - kf1->time); + + float32 a = kf2->uv[0] - kf1->uv[0]; + while(a < M_PI) a += 2*M_PI; + while(a > M_PI) a -= 2*M_PI; + intf->uv[0] = a*f + kf1->uv[0]; + intf->uv[1] = (kf2->uv[1] - kf1->uv[1])*f + kf1->uv[1]; + intf->uv[2] = (kf2->uv[2] - kf1->uv[2])*f + kf1->uv[2]; + intf->uv[3] = (kf2->uv[3] - kf1->uv[3])*f + kf1->uv[3]; + intf->uv[4] = (kf2->uv[4] - kf1->uv[4])*f + kf1->uv[4]; + intf->uv[5] = (kf2->uv[5] - kf1->uv[5])*f + kf1->uv[5]; +} + + static void registerUVAnimInterpolator(void) { + // TODO: implement this fully + // Linear AnimInterpolatorInfo *info = rwNewT(AnimInterpolatorInfo, 1, MEMDUR_GLOBAL | ID_UVANIMATION); info->id = 0x1C0; info->interpKeyFrameSize = sizeof(UVAnimInterpFrame); info->animKeyFrameSize = sizeof(UVAnimKeyFrame); info->customDataSize = sizeof(UVAnimCustomData); - info->applyCB = nil; + info->applyCB = uvAnimLinearApplyCB; info->blendCB = nil; - info->interpCB = nil; + info->interpCB = uvAnimLinearInterpCB; info->addCB = nil; info->mulRecipCB = nil; info->streamRead = uvAnimStreamRead; @@ -193,9 +278,9 @@ registerUVAnimInterpolator(void) info->interpKeyFrameSize = sizeof(UVAnimInterpFrame); info->animKeyFrameSize = sizeof(UVAnimKeyFrame); info->customDataSize = sizeof(UVAnimCustomData); - info->applyCB = nil; + info->applyCB = uvAnimParamApplyCB; info->blendCB = nil; - info->interpCB = nil; + info->interpCB = uvAnimParamInterpCB; info->addCB = nil; info->mulRecipCB = nil; info->streamRead = uvAnimStreamRead; @@ -303,6 +388,11 @@ readUVAnim(Stream *stream, int32, void *object, int32 offset, int32) } bit <<= 1; } + // TEMP + if(uvanim->uv[0] == nil) + uvanim->uv[0] = Matrix::create(); + if(uvanim->uv[1] == nil) + uvanim->uv[1] = Matrix::create(); return stream; } @@ -358,4 +448,55 @@ registerUVAnimPlugin(void) readUVAnim, writeUVAnim, getSizeUVAnim); } +bool32 +UVAnim::exists(Material *mat) +{ + int32 i; + UVAnim *uvanim = PLUGINOFFSET(UVAnim, mat, uvAnimOffset); + for(i = 0; i < 8; i++) + if(uvanim->interp[i]) + return 1; + return 0; +} + +void +UVAnim::addTime(Material *mat, float32 t) +{ + int32 i; + UVAnim *uvanim = PLUGINOFFSET(UVAnim, mat, uvAnimOffset); + for(i = 0; i < 8; i++) + if(uvanim->interp[i]) + uvanim->interp[i]->addTime(t); +} + +void +UVAnim::applyUpdate(Material *mat) +{ + int32 i, j; + int32 uv; + Matrix m; + UVAnim *uvanim = PLUGINOFFSET(UVAnim, mat, uvAnimOffset); + for(i = 0; i < 2; i++) + if(uvanim->uv[i]) + uvanim->uv[i]->setIdentity(); + m.setIdentity(); + + for(i = 0; i < 8; i++){ + AnimInterpolator *ip = uvanim->interp[i]; + if(ip == nil) + continue; + UVAnimCustomData *custom = UVAnimCustomData::get(ip->currentAnim); + for(j = 0; j < ip->numNodes; j++){ + InterpFrameHeader *f = ip->getInterpFrame(j); + uv = custom->nodeToUVChannel[j]; + if(uv < 2 && uvanim->uv[uv]){ + ip->applyCB(&m, f); + uvanim->uv[uv]->transform(&m, COMBINEPRECONCAT); + } + } + } + MatFX *mfx = MatFX::get(mat); + if(mfx) mfx->setUVTransformMatrices(uvanim->uv[0], uvanim->uv[1]); +} + }