osg::Matrixd CameraController::calcMatrixBasedOnAxis( const Vec3d& origin, const Vec3d& axisY, const Vec3d& axisZ )
{
Matrixd matTrans;
matTrans.makeTranslate(origin);
Vec3d oldY = Vec3d(0, 1, 0);
Vec3d oldZ = Vec3d(0, 0, 1);
Vec3d newY = axisY;
Vec3d newZ = axisZ;
newY.normalize();
newZ.normalize();
Matrixd mat1;
mat1.makeRotate(oldZ, newZ);
oldY = oldY * mat1;
Matrixd mat2;
mat2.makeRotate(oldY, newY);
Matrixd matFinal = mat1 * mat2 * matTrans;
return matFinal;
}
/***************************************************************
* Function: applyEditorInfo()
***************************************************************/
void CAVEGroupEditGeodeWireframe::applyEditorInfo(CAVEGeodeShape::EditorInfo **infoPtr)
{
/* reset root offset only when the shape is moved */
if ((*infoPtr)->getTypeMasking() == CAVEGeodeShape::EditorInfo::MOVE)
{
/* apply translations on 'mAccRootMat' */
const Vec3 offset = (*infoPtr)->getMoveOffset();
Matrixd transMat;
transMat.makeTranslate(offset);
mAccRootMat = mAccRootMat * transMat;
}
else if ((*infoPtr)->getTypeMasking() == CAVEGeodeShape::EditorInfo::ROTATE)
{
/* apply rotations on 'mAccRootMat' */
const float angle = (*infoPtr)->getRotateAngle();
const Vec3 axis = (*infoPtr)->getRotateAxis();
Matrixf rotateMat;
rotateMat.makeRotate(angle, axis);
mAccRootMat = mAccRootMat * rotateMat;
}
else if ((*infoPtr)->getTypeMasking() == CAVEGeodeShape::EditorInfo::SCALE)
{
const Vec3f scaleVect = (*infoPtr)->getScaleVect();
const Vec3f scaleCenter = (*infoPtr)->getScaleCenter();
Matrixd scalingMat, transMat, revTransMat;
scalingMat.makeScale(scaleVect);
transMat.makeTranslate(scaleCenter);
revTransMat.makeTranslate(-scaleCenter);
mAccRootMat = mAccRootMat * scalingMat;
}
}
void CameraController::testSetCameraAtMatrix(const Matrixd& atToWorldMatrix, double distFromEyeToAt,
Vec3d& resEye, Vec3d& resAt, Vec3d& resBase)
{
_testAtToWorldMatrix = atToWorldMatrix;
Vec3d v1 = Vec3d(0, 0, distFromEyeToAt);
Vec3d v2 = Vec3d(0, 0, 0);
v1 = v1 * atToWorldMatrix;
v2 = v2 * atToWorldMatrix;
Matrixd trans;
trans.makeTranslate(v1-v2);
_testEyeToWorldMatrix = _testAtToWorldMatrix * trans;
Matrixd upMatrix = _testEyeToWorldMatrix;
upMatrix.setTrans(Vec3d(0, 0, 0));
_testEye = v1;
_testAt = v2;
_testUp = _initUp * upMatrix;
_testBase = _currBase;
updateBaseToWorldMatrix();
}
void Camera::pushMatrix(const osg::Matrixd &mat)
{
const Matrixd m = mat * qMatrix.back();
glLoadMatrixd(m.ptr());
CHECK_GL();
qMatrix.push_back(m);
}
void MyServerThread::sendMatrix(Matrixd transNode)
{
float matrix1[16];
Vec3 objTrans = transNode.getTrans();
Quat objQuad = transNode.getRotate();
//cout << " Orientation " << objQuad.x() << "," << objQuad.y() << "," << objQuad.z() << "," << objQuad.w() << endl; // orientation
//cout << " Postion " << objTrans.x() << "," << objTrans.y() << "," << objTrans.z() << endl; // position
/*for (int i=0; i<4; ++i){
for (int j=0; j<4; ++j)
{
cout << transNode(i,j) << " " ; // position
}
cout << endl;
} */
cout << endl;
for (int i=0; i<4; ++i)
for (int j=0; j<4; ++j)
matrix[i*4+j] = transNode(i,j);
for(int i=0; i<16; i++)
{
cout <<"matrix:" << i << " " << matrix1[i] << endl;
}
//memcpy(buf,matrix1,sizeof(float)*16);
//sendMSG();
}
void CameraController::updateEyeAndAtToWorldMatrix()
{
_testEyeToWorldMatrix = calcMatrixBasedOnAxis(_testEye, _testUp, _testEye - _testAt);
Matrixd mat;
mat.makeTranslate(_testAt - _testEye);
_testAtToWorldMatrix = _testEyeToWorldMatrix * mat;
}
void CAVEGeodeIconToolkitManipulate::setMatrixTrans(MatrixTransform *matTrans)
{
Matrixd offsetMat;
offsetMat.makeTranslate(Vec3(mScalingDir.x() * mBoundingVect.x(),
mScalingDir.y() * mBoundingVect.y(),
mScalingDir.z() * mBoundingVect.z()));
matTrans->setMatrix(offsetMat);
}
void SceneGraphManipulator::setInteractionMode(int mode, Vec3f center, float imageZoom)
{
if (_trackerMode == -1) _trackerMode = 0; // if ProjectionType is UNKNOWN treat it as VISION
else _trackerMode = mode;
Matrixd viewMat = getMatrix();
float C = 1.5;
_panRating = C * (viewMat.preMult(center)).length() / imageZoom; //(viewMat.preMult(center)).length() is the distance between the eye and the center of the viewed scene
}
Vec3d CameraController::switchCoordinateSystem_point( const Vec3d& point, const Matrixd& from, const Matrixd& to )
{
Matrixd mat;
mat.invert(to);
Vec3d v = point * from * mat;
return v;
}
virtual void calcVertex64(Vector3Dd* vtx) {
Matrixd matrix;
matrix.translate(m_origin);
matrix.rotate(m_direction, Vector3Dd(0.0f,0.0f,1.0f));
matrix.scale(m_scale);
for (size_t n = 0; n < VertexCount; ++n) {
vtx[n] = matrix.mult(ts::gobj::Building3D::buildingVertex[n]);
}
}
/** Set the position of the manipulator using a 4x4 matrix.*/
void FirstPersonManipulator::setByMatrix( const Matrixd& matrix )
{
// set variables
_eye = matrix.getTrans();
_rotation = matrix.getRotate();
// fix current rotation
if( getVerticalAxisFixed() )
fixVerticalAxis( _eye, _rotation, true );
}
Vec3d CameraController::calcUp(const Vec3d& oldSight, const Vec3d& newSight, const Vec3d& oldUp)
{
Vec3d v1 = oldSight, v2 = newSight;
v1.normalize();
v2.normalize();
Matrixd mat;
mat.makeRotate(v1, v2);
Vec3d newUp = oldUp * mat;
return newUp;
}
/***************************************************************
* Function: setEquatorPos()
***************************************************************/
void DSVirtualEarth::setEquatorPos(const float &t)
{
/* get virtual time based on longi/lati/date */
float vtime = (mLongi + 180.f) / 15.f + 12 + (mDate - gDateOffset) * 24 + mTimeOffset;
vtime = vtime - (int)(vtime / 24.f) * 24.f;
mTimeOffset += (t - vtime);
Matrixd rotMat;
rotMat.makeRotate(mTimeOffset / 12.f * M_PI, Vec3(0, 0, 1));
mEquatorTrans->setMatrix(rotMat);
}
/***************************************************************
* Function: updateUnitGridSizeInfo()
***************************************************************/
void CAVEGroupReferenceAxis::updateUnitGridSizeInfo(const string &infoStr)
{
if (mTextEnabledFlag)
{
mGridInfoText->setText("Unit size = " + infoStr);
mGridInfoText->setPosition(Vec3(0, -gCharSize, -gCharSize));
/* align the text to viewer's front direction */
Matrixd rotMat;
rotMat.makeRotate(Vec3(0, 1, 0), gPointerDir);
mGridInfoTextTrans->setMatrix(Matrixd(rotMat));
}
}
Vec3d CameraController::switchCoordinateSystem_vector( const Vec3d& vec, const Matrixd& from, const Matrixd& to )
{
Matrixd mat;
mat.invert(to);
Vec3d begin = Vec3d(0, 0, 0);
Vec3d end = vec;
Vec3d begin2 = begin * from * mat;
Vec3d end2 = end * from * mat;
Vec3d v = end2 - begin2;
return v;
}
/// hum. read the doc, then come back here. then try to figure.
void
dxfInsert::drawScene(scene* sc)
{
// INSERTs can be nested. So pull the current matrix
// and push it back after we fill our context
// This is a snapshot in time. I will rewrite all this to be cleaner,
// but for now, it seems working fine
// (with the files I have, the results are equal to Voloview,
// and better than Deep Exploration and Lightwave).
// sanity check (useful when no block remains after all unsupported entities have been filtered out)
if (!_block)
return;
Matrixd back = sc->backMatrix();
Matrixd m;
m.makeIdentity();
sc->pushMatrix(m, true);
Vec3d trans = _block->getPosition();
sc->blockOffset(-trans);
if (_rotation) {
sc->pushMatrix(Matrixd::rotate(osg::DegreesToRadians(_rotation), 0,0,1));
}
sc->pushMatrix(Matrixd::scale(_scale.x(), _scale.y(), _scale.z()));
sc->pushMatrix(Matrixd::translate(_point.x(), _point.y(), _point.z()));
getOCSMatrix(_ocs, m);
sc->pushMatrix(m);
sc->pushMatrix(back);
EntityList& l = _block->getEntityList();
for (EntityList::iterator itr = l.begin(); itr != l.end(); ++itr) {
dxfBasicEntity* e = (*itr)->getEntity();
if (e) {
e->drawScene(sc);
}
}
sc->popMatrix(); // ocs
sc->popMatrix(); // translate
sc->popMatrix(); // scale
if (_rotation) {
sc->popMatrix(); // rotate
}
sc->popMatrix(); // identity
sc->popMatrix(); // back
sc->blockOffset(Vec3d(0,0,0));
}
void CAVEGeodeIconToolkitRotate::setMatrixTrans(osg::MatrixTransform *matTrans)
{
Matrixd rotMat;
if (mAxisAlignment == X_AXIS)
{
rotMat = Matrixd(Quat(M_PI * 0.5, Vec3(0, 1, 0)));
}
else if (mAxisAlignment == Y_AXIS)
{
rotMat = Matrixd(Quat(M_PI * 0.5, Vec3(1, 0, 0)));
}
else rotMat.makeIdentity();
matTrans->setMatrix(rotMat);
}
void CAVEGeodeIconToolkitMove::setMatrixTrans(MatrixTransform *matTrans)
{
Matrixd rotMat;
if (mFaceOrient == FRONT_BACK)
{
rotMat = Matrixd(Quat(M_PI * 0.5, Vec3(1, 0, 0)));
}
else if (mFaceOrient == LEFT_RIGHT)
{
rotMat = Matrixd(Quat(M_PI * 0.5, Vec3(0, 1, 0)));
}
else rotMat.makeIdentity();
matTrans->setMatrix(rotMat);
}
void SceneGraphManipulator::setByMatrix(const Matrixd& matrix)
{
osg::Vec3d eye, center, up;
matrix.getLookAt(eye, center, up);
setHomePosition(eye, center, up);
home(0.0);
}
//Constructor
DSVirtualEarth::DSVirtualEarth(): mState(SET_NULL), mLongi(-117.17f), mLati(32.75f), mTime(8.f), mDate(0.551f),
mTimeOffset(0.0f), mTimeLapseSpeed(0.0f)
{
mEclipticTrans = new MatrixTransform();
mTiltAxisTrans = new MatrixTransform();
mEquatorTrans = new MatrixTransform();
mEclipticSwitch = new Switch;
mEquatorSwitch = new Switch;
addChild(mEclipticTrans);
mEclipticTrans->addChild(mEclipticSwitch);
mEclipticTrans->addChild(mTiltAxisTrans);
mTiltAxisTrans->addChild(mEquatorTrans);
mEquatorTrans->addChild(mEquatorSwitch);
Matrixd tiltaxisMat;
float angle = 23.5f / 180.0f * M_PI;
tiltaxisMat.makeRotate(Vec3(0, 0, 1), Vec3(sin(angle), 0, cos(angle)));
mTiltAxisTrans->setMatrix(tiltaxisMat);
/* Level 1: Seasons map and Ecliptic ruler */
Switch *thisPtr = dynamic_cast <Switch*> (this);
CAVEAnimationModeler::ANIMLoadVirtualEarthReferenceLevel(&thisPtr, &mSeasonsMapGeode);
/* Level 2: Wired sphere, Meridian ruler, earth axis, equator ruler*/
CAVEAnimationModeler::ANIMLoadVirtualEarthEclipticLevel(&mEclipticSwitch);
/* Level 3: Wired sphere, fwd & bwd animation, pin indicator, fixed pin trans */
CAVEAnimationModeler::ANIMLoadVirtualEarthEquatorLevel(&mEquatorSwitch, &mEarthGeode,
&mPATransFwd, &mPATransBwd, &mFixedPinIndicatorTrans, &mFixedPinTrans);
/* set initial geographical info/ time / date */
setFixedPinPos(mLongi, mLati);
setEclipticPos(mDate);
setEquatorPos(mTime);
setPinIndicatorPos(mLongi);
setAllChildrenOff();
/* transform matrix that flip shader world plain to vertical earth model */
mUnitspaceMat = Matrixd::inverse(Matrixd( 0, 0, -1, 0, -1, 0, 0, 0,
0, 1, 0, 0, 0, 0, 0, 1));
/* create instance of intersector */
mDSIntersector = new DSIntersector();
mTrackballController = new TrackballController();
mVirtualScenicHandler = NULL;
}
void SceneGraphManipulator::computeNodeCenterAndRotation(Vec3d& nodeCenter, Quat& nodeRotation) const
{
Matrixd localToWorld;
computeNodeLocalToWorld(localToWorld);
if (validateNodePath())
nodeCenter = Vec3d(_trackNodePath.back()->getBound().center())*localToWorld;
else
nodeCenter = Vec3d(0.0f,0.0f,0.0f)*localToWorld;
// scale the matrix to get rid of any scales before we extract the rotation.
double sx = 1.0/sqrt(localToWorld(0,0)*localToWorld(0,0) + localToWorld(1,0)*localToWorld(1,0) + localToWorld(2,0)*localToWorld(2,0));
double sy = 1.0/sqrt(localToWorld(0,1)*localToWorld(0,1) + localToWorld(1,1)*localToWorld(1,1) + localToWorld(2,1)*localToWorld(2,1));
double sz = 1.0/sqrt(localToWorld(0,2)*localToWorld(0,2) + localToWorld(1,2)*localToWorld(1,2) + localToWorld(2,2)*localToWorld(2,2));
localToWorld = localToWorld*Matrixd::scale(sx,sy,sz);
nodeRotation = localToWorld.getRotate();
}
/***************************************************************
* Function: updateVSParameters()
***************************************************************/
void DSVirtualEarth::updateVSParameters(const Vec3 &viewDir, const Vec3 &viewPos)
{
if (!mVirtualScenicHandler) return;
/* compute sun direction in world space: apply transforms resulted by viewer's orientation change,
guarantee that from the viewer's position, the virtual earth is always half illuminated. */
Matrixd baserotMat;
baserotMat.makeRotate(Vec3(0, 1, 0), gDesignStateFrontVect);
Vec3 sunDirWorld = (CAVEAnimationModeler::ANIMVirtualEarthLightDir()) * baserotMat;
StateSet *stateset = mEarthGeode->getStateSet();
if (stateset)
{
Uniform *lightposUniform = stateset->getOrCreateUniform("LightPos", Uniform::FLOAT_VEC4);
lightposUniform->set(Vec4(sunDirWorld, 0.0));
}
/* compute matrix combination that transforms a vector from shader space into world space */
Matrixd latiMat;
latiMat.makeRotate(mLati / 180.f * M_PI, Vec3(0, 1, 0));
Matrixd equatorMat;
equatorMat.makeRotate((mTimeOffset / 12.f + mLongi / 180.f) * M_PI, Vec3(0, 0, 1));
Matrixd tiltaxisMat = mTiltAxisTrans->getMatrix();
Matrixd eclipticMat = mEclipticTrans->getMatrix();
Matrixd transMat = mUnitspaceMat * latiMat * equatorMat * tiltaxisMat * eclipticMat * baserotMat;
/* updata environment rendering by passing parameters to VirtualScenicHandler */
mVirtualScenicHandler->updateVSParameters(transMat, sunDirWorld, viewDir, viewPos);
}
/***************************************************************
* Constructor: CalibrationController()
***************************************************************/
CalibrationController::CalibrationController(Group *rootGroup, const string &datadir): mCaliFlag(false), mPlaybackFlag(false),
mLeftRange(M_PI / 9), mRightRange(M_PI / 9), mUpwardRange(M_PI / 9), mDownwardRange(M_PI / 9),
mMinDepthRange(0.5), mMaxDepthRange(5), mHorFreq(1), mVerFreq(1), mDepFreq(1),
mFieldRight(Vec3(1, 0, 0)), mFieldFront(Vec3(0, 1, 0)), mFieldUp(Vec3(0, 0, 1)), mFieldPos(Vec3(0, 0, 0))
{
mTimer = 0.0;
mViewerAlignmentTrans = new MatrixTransform();
rootGroup->addChild(mViewerAlignmentTrans);
/* apply downwards offset towards nose's position */
mNoseOffsetTrans = new MatrixTransform();
mViewerAlignmentTrans->addChild(mNoseOffsetTrans);
Matrixd noseoffsetMat;
noseoffsetMat.makeTranslate(Vec3(0, 0, gNoseOffset));
mNoseOffsetTrans->setMatrix(noseoffsetMat);
BallHandler::setDataDir(datadir);
mCaliBallHandler = new CaliBallHandler(mNoseOffsetTrans);
mPlaybackBallHandler = new PlaybackBallHandler(mNoseOffsetTrans);
mCaliFieldHandler = new CaliFieldHandler(mNoseOffsetTrans);
mDataDir = datadir;
}
void ArbitraryRotate(Vec3d U, Vec3d V, Vec3d W,
double degreeX, double degreeY,
Vec3d& point, Vec3d aim) {
double cx = cos(Deg2Rad(degreeX));
double sx = sin(Deg2Rad(degreeX));
double cy = cos(Deg2Rad(degreeY));
double sy = sin(Deg2Rad(degreeY));
Matrixd trans = { {1, 0, 0, -aim[0]},
{0, 1, 0, -aim[1]},
{0, 0, 1, -aim[2]},
{0, 0, 0, 1}};
Matrixd mat = { {U[0], U[1], U[2], 0},
{V[0], V[1], V[2], 0},
{W[0], W[1], W[2], 0},
{0, 0, 0, 1}};
Matrixd rot(4, 4);
Matrixd pos = {{point[0]}, {point[1]}, {point[2]}, {1}};
pos = trans * pos;
pos = mat*pos;
rot = {{1, 0, 0, 0},
{0, cx, sx, 0},
{0, -sx, cx, 0},
{0, 0, 0, 1}};
pos = rot*pos;
rot = {{ cy, 0, sy, 0},
{0, 1, 0, 0},
{-sy, 0, cy, 0},
{0, 0, 0, 1}};
pos = rot * pos;
pos = mat.inv()*pos;
pos = trans.inv()*pos;
point = {pos.get(0, 0), pos.get(1, 0), pos.get(2, 0)};
}
/***************************************************************
* Function: recordPathEntry()
*
* Write current scale and xform matrix to file with time stamp
*
***************************************************************/
void PathRecordManager::recordPathEntry(const double &scale, const Matrixd &xMat)
{
if (!mFilePtr) return;
fwrite(&mTimer,sizeof(double),1,mFilePtr);
double scaled = scale;
fwrite(&scaled,sizeof(double),1,mFilePtr);
fwrite(xMat.ptr(),16*sizeof(double),1,mFilePtr);
/*fprintf(mFilePtr, "%f %f ", mTimer, scale);
fprintf(mFilePtr, "%f %f %f %f ", xMat(0, 0), xMat(0, 1), xMat(0, 2), xMat(0, 3));
fprintf(mFilePtr, "%f %f %f %f ", xMat(1, 0), xMat(1, 1), xMat(1, 2), xMat(1, 3));
fprintf(mFilePtr, "%f %f %f %f ", xMat(2, 0), xMat(2, 1), xMat(2, 2), xMat(2, 3));
fprintf(mFilePtr, "%f %f %f %f ", xMat(3, 0), xMat(3, 1), xMat(3, 2), xMat(3, 3));
fprintf(mFilePtr, "\n");*/
}
int main(int argc, char const* argv[]) {
info(coda::version());
info("testing matrix");
Matrixd A(4, 4);
A.fill(0.1);
A.print("A:");
A.randu();
A.print("A:");
info("testing matrix operations");
A += 2;
A.print("A+=2");
Matrixd B;
B = A;
B.print("B=A");
info("testing cwise_exp");
Matrixd C;
C = A + B;
C.print("C=A+B");
C = A % B;
C.print("C=A%B");
info("testing cwise_op");
C = A + 2;
C.print("C=A+2");
info("testing vector");
Vector<double> x(4);
x.basis(2);
x.at(0) = 10;
x[1] = -10.0001;
x.print("x:");
x.randu();
x.print("x:");
info("testing operations");
info("x+=2");
x += 2;
x.print("x+=2");
Vector<double> y;
y = x;
y.print("y=x");
y += x;
y.print("y=+x");
info("testing cwiseop");
y = x + 2;
y.print("y=x+2");
y = abs(x);
y.print("y=abs(x)");
y = ramp(x);
y.print("y=ramp(x)");
info("testing cwiseop");
Vector<double> z;
x.print("x=");
y.print("y=");
z = x + y;
z.print("z=x+y");
z = x - y;
z.print("z=x-y");
z = 2.0 * x * (y - 1.0);
z.print("z=2*x*(y-1)");
z = 2.0 * (A + B) * x - C * y;
z.print("2.0*(A+B)*x-C*y");
z[0] = -100;
info("norm1(z) : %f", norm1(z));
info("norm2(z) : %f", norm2(z));
info("norm_max(z) : %f", norm_max(z));
y = A * x;
for (uint i = 0; i < y.nelem; ++i) {
y[i] += 1e-4 * randu<double>();
}
z = A * x;
y.print("y :");
z.print("Ax:");
std::cout << "norm(Ax-y) = " << norm2(A * x - y) << std::endl;
coda::warning("This is a warning");
coda::error("This is an error");
return 0;
}
/***************************************************************
* Function: updateGridUnits()
***************************************************************/
void CAVEGroupEditGeodeWireframe::updateGridUnits(const float &gridUnitLegnth,
const float &gridUnitAngle, const float &gridUnitScale)
{
/* update 'Move' matrix transform wireframes */
unsigned int numMoveChildren = mMoveSwitch->getNumChildren();
if (numMoveChildren > 1)
{
Vec3 gridOffsetVect = Vec3(0, 0, 0);
if (mMoveSVect.x() > 0) gridOffsetVect = Vec3(gridUnitLegnth, 0, 0);
else if (mMoveSVect.x() < 0) gridOffsetVect = Vec3(-gridUnitLegnth, 0, 0);
else if (mMoveSVect.y() > 0) gridOffsetVect = Vec3(0, gridUnitLegnth, 0);
else if (mMoveSVect.y() < 0) gridOffsetVect = Vec3(0, -gridUnitLegnth, 0);
else if (mMoveSVect.z() > 0) gridOffsetVect = Vec3(0, 0, gridUnitLegnth);
else if (mMoveSVect.z() < 0) gridOffsetVect = Vec3(0, 0, -gridUnitLegnth);
for (int i = 0; i < numMoveChildren; i++)
{
Matrixd transMat;
transMat.makeTranslate(gridOffsetVect * i);
mMoveMatTransVector[i]->setMatrix(mBoundBoxScaleMat * mAccRootMat * transMat);
}
return;
}
/* update 'Rotate' matrix transform wireframes */
unsigned int numRotateChildren = mRotateSwitch->getNumChildren();
if (numRotateChildren > 1)
{
Vec3 gridRotationAxis = Vec3(0, 0, 1);
if (mRotateSVect.x() > 0) gridRotationAxis = Vec3(1, 0, 0);
else if (mRotateSVect.x() < 0) gridRotationAxis = Vec3(-1, 0, 0);
else if (mRotateSVect.y() > 0) gridRotationAxis = Vec3(0, 1, 0);
else if (mRotateSVect.y() < 0) gridRotationAxis = Vec3(0, -1, 0);
else if (mRotateSVect.z() > 0) gridRotationAxis = Vec3(0, 0, 1);
else if (mRotateSVect.z() < 0) gridRotationAxis = Vec3(0, 0, -1);
for (int i = 0; i < numRotateChildren; i++)
{
Matrixd rotMat;
rotMat.makeRotate(gridUnitAngle * i, gridRotationAxis);
mRotateMatTransVector[i]->setMatrix(mBoundSphereScaleMat * rotMat);
}
return;
}
/* update 'Scale' matrix transform wireframes */
unsigned int numScaleChildren = mManipulateSwitch->getNumChildren();
if (numScaleChildren > 1)
{
/* rewrite scaling vector */
mScaleUnitVect.x() = mScaleUnitVect.x() > 0 ? 1:0;
mScaleUnitVect.y() = mScaleUnitVect.y() > 0 ? 1:0;
mScaleUnitVect.z() = mScaleUnitVect.z() > 0 ? 1:0;
mScaleUnitVect *= gridUnitScale;
for (int i = 0; i < numScaleChildren; i++)
{
/* generate scaling vector with non-negative values */
Vec3 scaleVect = Vec3(1, 1, 1);
if (mScaleNumSegs > 0) scaleVect += mScaleUnitVect * i;
else scaleVect -= mScaleUnitVect * i;
scaleVect.x() = scaleVect.x() > 0 ? scaleVect.x() : 0;
scaleVect.y() = scaleVect.y() > 0 ? scaleVect.y() : 0;
scaleVect.z() = scaleVect.z() > 0 ? scaleVect.z() : 0;
Matrixd scaleMat;
scaleMat.makeScale(scaleVect);
mManipulateMatTransVector[i]->setMatrix(mBoundBoxScaleMat * mAccRootMat * scaleMat);
}
return;
}
}
/***************************************************************
* Function: applyScaling()
*
* 'gridUnitScaleVect' is guranteed to be non-negative vector
*
***************************************************************/
void CAVEGroupEditGeodeWireframe::applyScaling( const short &nOffsetSegs, const Vec3 &gridUnitScaleVect,
const std::string &gridUnitScaleInfo)
{
mManipulateSwitch->setAllChildrenOn();
/* scale to other direction: clear all children of 'mManipulateSwitch' except child[0], rebuild offset tree */
if (mScaleNumSegs * nOffsetSegs <= 0)
{
unsigned int numChildren = mManipulateSwitch->getNumChildren();
if (numChildren > 1)
{
mManipulateSwitch->removeChildren(1, numChildren - 1);
MatrixTransVector::iterator itrMatTrans = mManipulateMatTransVector.begin();
mManipulateMatTransVector.erase(itrMatTrans + 1, itrMatTrans + numChildren);
}
mScaleNumSegs = 0;
}
/* decide unit offset vector and start/end index of children under 'mManipulateSwitch' */
short idxStart = 0, idxEnd = 0;
if (nOffsetSegs != 0)
{
idxStart = mScaleNumSegs;
idxEnd = nOffsetSegs;
}
idxStart = idxStart > 0 ? idxStart: -idxStart;
idxEnd = idxEnd > 0 ? idxEnd : -idxEnd;
/* update the first wireframe with global translation and rotation */
if (idxStart == 0) mManipulateMatTransVector[0]->setMatrix(mBoundBoxScaleMat * mAccRootMat);
/* create or remove a sequence of extra children under 'mMoveSwitch' */
if (idxStart < idxEnd)
{
for (short i = idxStart + 1; i <= idxEnd; i++)
{
/* generate scaling vector with non-negative values */
Vec3 scaleVect = Vec3(1, 1, 1);
if (nOffsetSegs > 0) scaleVect += gridUnitScaleVect * i;
else scaleVect -= gridUnitScaleVect * i;
scaleVect.x() = scaleVect.x() > 0 ? scaleVect.x() : 0;
scaleVect.y() = scaleVect.y() > 0 ? scaleVect.y() : 0;
scaleVect.z() = scaleVect.z() > 0 ? scaleVect.z() : 0;
Matrixd scaleMat;
scaleMat.makeScale(scaleVect);
MatrixTransform *scaleTrans = new MatrixTransform;
CAVEGeodeEditWireframeManipulate *manipulateGeode = new CAVEGeodeEditWireframeManipulate;
mManipulateSwitch->addChild(scaleTrans);
mManipulateMatTransVector.push_back(scaleTrans);
scaleTrans->addChild(manipulateGeode);
scaleTrans->setMatrix(mBoundBoxScaleMat * mAccRootMat * scaleMat);
}
}
else if (idxStart > idxEnd)
{
mManipulateSwitch->removeChildren(idxEnd + 1, idxStart - idxEnd);
MatrixTransVector::iterator itrMatTrans = mManipulateMatTransVector.begin();
itrMatTrans += idxEnd + 1;
mManipulateMatTransVector.erase(itrMatTrans, itrMatTrans + (idxStart - idxEnd));
}
mScaleNumSegs = nOffsetSegs;
mScaleUnitVect = gridUnitScaleVect;
if (!mPrimaryFlag) return;
/* update info text if 'this' wireframe is primary */
mEditInfoTextSwitch->setAllChildrenOn();
float scaleUnit = gridUnitScaleVect.x() > 0 ? gridUnitScaleVect.x() : gridUnitScaleVect.y();
scaleUnit = scaleUnit > 0 ? scaleUnit : gridUnitScaleVect.z();
char info[128];
float scaleval = scaleUnit * nOffsetSegs + 1.0f;
scaleval = scaleval > 0 ? scaleval:0;
sprintf(info, "Scale = %3.2f \nSnapping = ", scaleval);
mEditInfoText->setText(info + gridUnitScaleInfo);
}
/***************************************************************
* Function: applyRotation()
*
* 'axisSVect': rotational snapping values around each axis,
* for instance, Vec3(2, 0, 0) means rotation around X-axis by
* two times of 'gridUnitAngle'
* only one component of 'axisIntVect' is supposed to be non-zero
*
***************************************************************/
void CAVEGroupEditGeodeWireframe::applyRotation(const osg::Vec3s &axisSVect, const float &gridUnitAngle,
const string &gridUnitAngleInfo)
{
if (!mPrimaryFlag) return;
mRotateSwitch->setAllChildrenOn();
/* rotate in other direction: clear all children of 'mRotateSwitch' except child[0], rebuild offset tree */
if ((mRotateSVect.x() * axisSVect.x() + mRotateSVect.y() * axisSVect.y() + mRotateSVect.z() * axisSVect.z()) <= 0)
{
unsigned int numChildren = mRotateSwitch->getNumChildren();
if (numChildren > 1)
{
mRotateSwitch->removeChildren(1, numChildren - 1);
MatrixTransVector::iterator itrMatTrans = mRotateMatTransVector.begin();
mRotateMatTransVector.erase(itrMatTrans + 1, itrMatTrans + numChildren);
}
mRotateSVect = Vec3s(0, 0, 0);
}
/* decide unit rotation quat and start/end index of children under 'mRotateSwitch' */
Vec3 gridRotationAxis;
short idxStart = 0, idxEnd = 0;
if (axisSVect.x() != 0)
{
idxStart = mRotateSVect.x();
idxEnd = axisSVect.x();
if (axisSVect.x() > 0) gridRotationAxis = Vec3(1, 0, 0);
else gridRotationAxis = Vec3(-1, 0, 0);
}
else if (axisSVect.y() != 0)
{
idxStart = mRotateSVect.y();
idxEnd = axisSVect.y();
if (axisSVect.y() > 0) gridRotationAxis = Vec3(0, 1, 0);
else gridRotationAxis = Vec3(0, -1, 0);
}
else if (axisSVect.z() != 0)
{
idxStart = mRotateSVect.z();
idxEnd = axisSVect.z();
if (axisSVect.z() > 0) gridRotationAxis = Vec3(0, 0, 1);
else gridRotationAxis = Vec3(0, 0, -1);
}
idxStart = idxStart > 0 ? idxStart: -idxStart;
idxEnd = idxEnd > 0 ? idxEnd : -idxEnd;
/* create or remove a sequence of extra children under 'mRotateSwitch' */
if (idxStart < idxEnd)
{
for (short i = idxStart + 1; i <= idxEnd; i++)
{
Matrixd rotMat;
rotMat.makeRotate(gridUnitAngle * i, gridRotationAxis);
MatrixTransform *rotateTrans = new MatrixTransform;
CAVEGeodeEditWireframeRotate *rotateGeode = new CAVEGeodeEditWireframeRotate;
mRotateSwitch->addChild(rotateTrans);
mRotateMatTransVector.push_back(rotateTrans);
rotateTrans->addChild(rotateGeode);
rotateTrans->setMatrix(mBoundSphereScaleMat * rotMat);
}
}
else if (idxStart > idxEnd)
{
mRotateSwitch->removeChildren(idxEnd + 1, idxStart - idxEnd);
MatrixTransVector::iterator itrMatTrans = mRotateMatTransVector.begin();
itrMatTrans += idxEnd + 1;
mRotateMatTransVector.erase(itrMatTrans, itrMatTrans + (idxStart - idxEnd));
}
mRotateSVect = axisSVect;
/* update info text if 'this' wireframe is primary */
mEditInfoTextSwitch->setAllChildrenOn();
char info[128];
const float gridUnitAngleDegree = gridUnitAngle * 180 / M_PI;
sprintf(info, "Angle = %3.2f\nSnapping = ", gridUnitAngleDegree * idxEnd);
mEditInfoText->setText(info + gridUnitAngleInfo);
}
/***************************************************************
* Function: applyTranslation()
*
* 'gridSVect': number of snapping segments along each direction
* 'gridUnitLegnth': actual length represented by each segment,
* only one component of 'gridSVect' is supposed to be non-zero
*
***************************************************************/
void CAVEGroupEditGeodeWireframe::applyTranslation(const osg::Vec3s &gridSVect, const float &gridUnitLegnth,
const string &gridUnitLegnthInfo)
{
mMoveSwitch->setAllChildrenOn();
/* move to other direction: clear all children of 'mMoveSwitch' except child[0], rebuild offset tree */
if ((mMoveSVect.x() * gridSVect.x() + mMoveSVect.y() * gridSVect.y() + mMoveSVect.z() * gridSVect.z()) <= 0)
{
unsigned int numChildren = mMoveSwitch->getNumChildren();
if (numChildren > 1)
{
mMoveSwitch->removeChildren(1, numChildren - 1);
MatrixTransVector::iterator itrMatTrans = mMoveMatTransVector.begin();
mMoveMatTransVector.erase(itrMatTrans + 1, itrMatTrans + numChildren);
}
mMoveSVect = Vec3s(0, 0, 0);
}
/* decide unit offset vector and start/end index of children under 'mMoveSwitch' */
Vec3 gridOffsetVect;
short idxStart = 0, idxEnd = 0;
if (gridSVect.x() != 0)
{
idxStart = mMoveSVect.x();
idxEnd = gridSVect.x();
if (gridSVect.x() > 0) gridOffsetVect = Vec3(gridUnitLegnth, 0, 0);
else gridOffsetVect = Vec3(-gridUnitLegnth, 0, 0);
}
else if (gridSVect.y() != 0)
{
idxStart = mMoveSVect.y();
idxEnd = gridSVect.y();
if (gridSVect.y() > 0) gridOffsetVect = Vec3(0, gridUnitLegnth, 0);
else gridOffsetVect = Vec3(0, -gridUnitLegnth, 0);
}
else if (gridSVect.z() != 0)
{
idxStart = mMoveSVect.z();
idxEnd = gridSVect.z();
if (gridSVect.z() > 0) gridOffsetVect = Vec3(0, 0, gridUnitLegnth);
else gridOffsetVect = Vec3(0, 0, -gridUnitLegnth);
}
idxStart = idxStart > 0 ? idxStart: -idxStart;
idxEnd = idxEnd > 0 ? idxEnd : -idxEnd;
/* update the first wireframe with global translation and rotation */
if (idxStart == 0) mMoveMatTransVector[0]->setMatrix(mBoundBoxScaleMat * mAccRootMat);
/* create or remove a sequence of extra children under 'mMoveSwitch' */
if (idxStart < idxEnd)
{
for (short i = idxStart + 1; i <= idxEnd; i++)
{
Matrixd transMat;
transMat.makeTranslate(gridOffsetVect * i);
MatrixTransform *moveTrans = new MatrixTransform;
CAVEGeodeEditWireframeMove *moveGeode = new CAVEGeodeEditWireframeMove;
mMoveSwitch->addChild(moveTrans);
mMoveMatTransVector.push_back(moveTrans);
moveTrans->addChild(moveGeode);
moveTrans->setMatrix(mBoundBoxScaleMat * mAccRootMat * transMat);
}
}
else if (idxStart > idxEnd)
{
mMoveSwitch->removeChildren(idxEnd + 1, idxStart - idxEnd);
MatrixTransVector::iterator itrMatTrans = mMoveMatTransVector.begin();
itrMatTrans += idxEnd + 1;
mMoveMatTransVector.erase(itrMatTrans, itrMatTrans + (idxStart - idxEnd));
}
mMoveSVect = gridSVect;
if (!mPrimaryFlag) return;
/* update info text if 'this' wireframe is primary */
mEditInfoTextSwitch->setAllChildrenOn();
char info[128];
sprintf(info, "Offset = %3.2f m\nSnapping = ", gridUnitLegnth * idxEnd);
mEditInfoText->setText(info + gridUnitLegnthInfo);
}
