void VisualEffect::moveBetween(const VC3 &position_, const VC3 &endPosition, const VC3 &rotation, float alpha, float scale)
{
if (visualObject == NULL)
return;
if (effectType->getType() == VisualEffectType::VISUALEFFECT_TYPE_RAY)
{
this->position = (position_ + endPosition) / 2;
VC3 diffVec = endPosition - position_;
float raylen = diffVec.GetLength();
VC3 scalevec(1*scale,1*scale,raylen);
visualObject->setScale(scalevec);
visualObject->setVisibilityFactor(alpha);
}
visualObject->setPosition(this->position);
visualObject->setRotation(rotation.x, rotation.y, rotation.z);
}
/*! \COININTERNAL
Called when user drags the mouse after picking the dragger.
*/
void
SoHandleBoxDragger::drag(void)
{
SbVec3f startPt = this->getLocalStartingPoint();
if (this->whatkind == WHATKIND_TRANSLATOR) {
this->planeProj->setViewVolume(this->getViewVolume());
this->planeProj->setWorkingSpace(this->getLocalToWorldMatrix());
SbVec3f projPt = this->planeProj->project(this->getNormalizedLocaterPosition());
const SoEvent *event = this->getEvent();
if (event->wasShiftDown() && this->constraintState == CONSTRAINT_OFF) {
this->constraintState = CONSTRAINT_WAIT;
this->setStartLocaterPosition(event->getPosition());
this->getLocalToWorldMatrix().multVecMatrix(projPt, this->worldRestartPt);
}
else if (!event->wasShiftDown() && this->constraintState != CONSTRAINT_OFF) {
this->constraintState = CONSTRAINT_OFF;
this->updateArrows();
}
SbVec3f motion, localrestartpt;
if (this->constraintState != CONSTRAINT_OFF) {
this->getWorldToLocalMatrix().multVecMatrix(this->worldRestartPt,
localrestartpt);
motion = localrestartpt - startPt;
}
else motion = projPt - startPt;
switch(this->constraintState) {
case CONSTRAINT_OFF:
break;
case CONSTRAINT_WAIT:
if (this->isAdequateConstraintMotion()) {
SbVec3f newmotion = projPt - localrestartpt;
int biggest = 0;
double bigval = fabs(newmotion[0]);
if (fabs(newmotion[1]) > bigval) {
biggest = 1;
bigval = fabs(newmotion[1]);
}
if (fabs(newmotion[2]) > bigval) {
biggest = 2;
}
motion[biggest] += newmotion[biggest];
this->constraintState = CONSTRAINT_X + biggest;
this->updateArrows();
}
else {
return;
}
break;
case CONSTRAINT_X:
motion[0] += projPt[0] - localrestartpt[0];
break;
case CONSTRAINT_Y:
motion[1] += projPt[1] - localrestartpt[1];
break;
case CONSTRAINT_Z:
motion[2] += projPt[2] - localrestartpt[2];
}
this->setMotionMatrix(this->appendTranslation(this->getStartMotionMatrix(), motion));
}
else {
this->lineProj->setViewVolume(this->getViewVolume());
this->lineProj->setWorkingSpace(this->getLocalToWorldMatrix());
SbVec3f projPt = this->lineProj->project(this->getNormalizedLocaterPosition());
SbVec3f center = this->getDraggerCenter();
if (this->getEvent()->wasCtrlDown()) {
center += this->ctrlOffset;
}
float orglen = (startPt-center).length();
float currlen = (projPt-center).length();
float scale = 0.0f;
if (orglen > 0.0f) scale = currlen / orglen;
if (scale > 0.0f && (startPt-center).dot(projPt-center) <= 0.0f) scale = 0.0f;
SbVec3f scalevec(scale, scale, scale);
if (this->whatkind == WHATKIND_EXTRUDER) {
if (this->whatnum <= 2) scalevec[0] = scalevec[2] = 1.0f;
else if (this->whatnum <= 4) scalevec[1] = scalevec[2] = 1.0f;
else scalevec[0] = scalevec[1] = 1.0f;
}
this->setMotionMatrix(this->appendScale(this->getStartMotionMatrix(),
scalevec,
center));
}
}
/* ------------------------------------------------------------------------------------ */
Procedural* Particles_Create(char *TextureName, geWorld *World, const char *InputParams)
{
Procedural *Proc;
int i;
char ParamWork[8192],*pstr;
geBitmap *ppBitmap;
Proc = GE_RAM_ALLOCATE_STRUCT(Procedural);
if(!Proc)
return (Procedural*)NULL;
memset(Proc, 0, sizeof(Procedural));
ppBitmap = geWorld_GetBitmapByName(World, TextureName);
/**** read Params *****/
// changed RF064 by QD
if(!strcmp(InputParams, "Params_Oil"))
{
strcpy(ParamWork, Params_Oil);
}
else if(!strcmp(InputParams, "Params_Jet"))
{
strcpy(ParamWork,Params_Jet);
}
else if(!strcmp(InputParams, "Params_Steam"))
{
strcpy(ParamWork,Params_Steam);
}
else if(!strcmp(InputParams, "Params_Explosion") || strlen(InputParams) < 20 )
{
strcpy(ParamWork,DefaultParams);
}
// end change RF064 by QD
else
{
strcpy(ParamWork,InputParams);
}
pstr = strtok(ParamWork,strbreakers);
Proc->NumParticles = getint(pstr);
Proc->NumSources = getint(pstr);
/**** make Bitmap *****/
if(!Particles_InitBitmap(ppBitmap))
goto fail;
Proc->Bitmap = ppBitmap;
Proc->SizeX = geBitmap_Width(Proc->Bitmap);
Proc->SizeY = geBitmap_Height(Proc->Bitmap);
geBitmap_GetInfo(Proc->Bitmap, &(Proc->BmInfo), (geBitmap_Info*)NULL);
Proc->SizeZ = min(Proc->SizeX, Proc->SizeY);
/**** make Particles *****/
Proc->Particles = (Particle*)geRam_AllocateClear(Proc->NumParticles * sizeof(Particle));
if(!(Proc->Particles))
goto fail;
for(i=0; i<Proc->NumParticles; i++)
{
Proc->Particles[i].shade = -1;
}
Proc->NumActiveParticles = 0;
/**** make Sources *****/
Proc->Sources = (ParticleSource*)geRam_AllocateClear(Proc->NumSources * sizeof(ParticleSource));
if(!(Proc->Sources))
goto fail;
/**** More Params *****/
// <> for stock schemes, take a few colors as parameters
if(matchstr(pstr, "oil"))
{
nextparam(pstr);
Proc->NumColors = Proc->NumShades = 16;
Proc->PixelRGBA = PixelRGBA_OilColor;
}
else if(matchstr(pstr, "fire"))
{
nextparam(pstr);
Proc->NumColors = 1;
Proc->NumShades = 256;
Proc->PixelRGBA = PixelRGBA_FireColor;
}
else if(matchstr(pstr, "opaquefire"))
{
nextparam(pstr);
Proc->NumColors = 1;
Proc->NumShades = 256;
Proc->PixelRGBA = PixelRGBA_OpaqueFireColor;
}
else if(matchstr(pstr, "steam"))
{
nextparam(pstr);
Proc->NumColors = 1;
Proc->NumShades = 256;
Proc->PixelRGBA = PixelRGBA_SteamColor;
}
else
{
Proc->NumColors = getint(pstr);
Proc->NumShades = getint(pstr);
Proc->PixelRGBA = PixelRGBA_OilColor;
// <>
// way to read in general spline of colors ?
}
if((Proc->NumColors * Proc->NumShades) < 256)
{
Proc->NumColors = min(Proc->NumColors, 256);
Proc->NumShades = 256 / Proc->NumColors;
}
Proc->NumSmoothes = getint(pstr);
Proc->SmoothRadius = getint(pstr);
if(matchstr(pstr, "bounce"))
{
Proc->Capper = Capper_Bounce;
Proc->SmoothWrap = GE_FALSE;
}
else if(matchstr(pstr,"wrap"))
{
Proc->Capper = Capper_Wrap;
Proc->SmoothWrap = GE_TRUE;
}
else if(matchstr(pstr,"hard"))
{
Proc->Capper = Capper_Hard;
Proc->SmoothWrap = GE_FALSE;
}
else
{
goto fail;
}
nextparam(pstr);
Proc->DoMagnetic = getbool(pstr);
if(Proc->DoMagnetic)
{
getvec(pstr, &(Proc->MagneticField));
}
Proc->DoAttractor = getbool(pstr);
if(Proc->DoAttractor)
{
Proc->AttractorStrength = getfloat(pstr); // negative for repulsive
Proc->AttractorIsAxis = getbool(pstr);
if(Proc->AttractorIsAxis)
{
getvec(pstr, &(Proc->AttractorAxis));
geVec3d_Normalize(&(Proc->AttractorAxis));
}
getvec(pstr, &(Proc->AttractorPos));
scalevec(&(Proc->AttractorPos));
}
/**** LUT's *****/
if(!Particles_InitPalette(Proc))
goto fail;
for(i=0; i<Proc->NumSources; i++)
{
ParticleSource *pSource;
Particle *pParticle;
pSource = Proc->Sources + i;
// base
pParticle = &(pSource->Base);
getvec(pstr, pParticle->p);
getvec(pstr, pParticle->v);
scalevec(pParticle->p);
scalevec(pParticle->v);
pParticle->DeathTime = getfloat(pstr);
pParticle->color = getint(pstr);
pParticle->shade = Proc->NumShades - 1;
pParticle->CurDeathTime = 0.0f;
// random
pParticle = &(pSource->Random);
getvec(pstr,pParticle->p);
getvec(pstr,pParticle->v);
scalevec(pParticle->p);
scalevec(pParticle->v);
absvec(pParticle->p);
absvec(pParticle->v);
pParticle->DeathTime = getfloat(pstr);
pParticle->color = getint(pstr);
pParticle->shade = getint(pstr);
pParticle->CurDeathTime = 0.0f;
pSource->RandomVMagnitude = geVec3d_Normalize((geVec3d*)(pParticle->v));
pSource->Delay = getfloat(pstr); // seconds
pSource->Base.Drag = getfloat(pstr);
pSource->CurTime = pSource->Delay;
}
return Proc;
fail:
Particles_Destroy(Proc);
return (Procedural*)NULL;
}
