Return to cXformer.C CVS log

Up to [Development] / performer / src / lib / libpfui

Initial check-in based on OpenGL Performer 2.4 tree.
-flynnt

/*
 * Copyright 1993, 1994, 1995, Silicon Graphics, Inc.
 * ALL RIGHTS RESERVED
 *
 * UNPUBLISHED -- Rights reserved under the copyright laws of the United
 * States.   Use of a copyright notice is precautionary only and does not
 * imply publication or disclosure.
 *
 * U.S. GOVERNMENT RESTRICTED RIGHTS LEGEND:
 * Use, duplication or disclosure by the Government is subject to restrictions
 * as set forth in FAR 52.227.19(c)(2) or subparagraph (c)(1)(ii) of the Rights
 * in Technical Data and Computer Software clause at DFARS 252.227-7013 and/or
 * in similar or successor clauses in the FAR, or the DOD or NASA FAR
 * Supplement.  Contractor/manufacturer is Silicon Graphics, Inc.,
 * 2011 N. Shoreline Blvd. Mountain View, CA 94039-7311.
 *
 * THE CONTENT OF THIS WORK CONTAINS CONFIDENTIAL AND PROPRIETARY
 * INFORMATION OF SILICON GRAPHICS, INC. ANY DUPLICATION, MODIFICATION,
 * DISTRIBUTION, OR DISCLOSURE IN ANY FORM, IN WHOLE, OR IN PART, IS STRICTLY
 * PROHIBITED WITHOUT THE PRIOR EXPRESS WRITTEN PERMISSION OF SILICON
 * GRAPHICS, INC.
 */


/*
 * cXformer.C
 * --------------
 * $Revision: 1.1 $
 * $Date: 2000/11/21 21:39:35 $
 */

#include <math.h>
#include <X11/X.h>

#include <Performer/pf.h>
#include <Performer/pr/pfLinMath.h>
#include <Performer/pr/pfGeoMath.h>

#define _PFI_XFORMER_C_
#include <Performer/pfui.h>
#include "pfiXformer.h"


pfType*
pfiGetXformerClassType(void)
{
    return pfiXformer::getClassType();    
}

pfiXformer *
pfiNewXformer(void *arena)
{
    return new(arena) pfiXformer;
}

void 
pfiXformerModel(pfiXformer* xf, int _index, pfiInputXform* _model)
{
     if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiXformerModel -- null pfiXformer*");
	return;
    }
    xf->setModel(_index, _model);
}

void 
pfiSelectXformerModel(pfiXformer *xf, int _which)
{ 
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiSelectXformerModel -- null pfiXformer*");
	return;
    }
    xf->selectModel(_which);
}

pfiInputXform*  
pfiGetXformerCurModel(pfiXformer *xf)
{ 
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiGetXformerCurModel -- null pfiXformer*");
	return NULL;
    }
    return xf->getCurModel();
}

int
pfiGetXformerCurModelIndex(pfiXformer *xf)
{ 
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiGetXformerCurModelIndex -- null pfiXformer*");
	return -1;
    }
    return xf->getCurModelIndex();
}

void 
pfiRemoveXformerModel(pfiXformer* xf, pfiInputXform* _model)
{
     if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiRemoveXformerModel -- null pfiXformer*");
	return;
    }
    xf->removeModel(_model);
}

void 
pfiRemoveXformerModelIndex(pfiXformer* xf, int _index)
{
     if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiRemoveXformerModelIndex -- null pfiXformer*");
	return;
    }
    xf->removeModelIndex(_index);
}

void
pfiStopXformer(pfiXformer *xf)
{
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiStopXformer -- null pfiXformer*");
	return;
    }
    xf->stop();
}

void
pfiResetXformer(pfiXformer *xf)
{
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiResetXformer -- null pfiXformer*");
	return;
    }
    xf->reset();
}

void
pfiResetXformerPosition(pfiXformer *xf)
{
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiResetXformerPosition -- null pfiXformer*");
	return;
    }
    xf->resetPosition();
}

void
pfiCenterXformer(pfiXformer *xf)
{
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiCenterXformer -- null pfiXformer*");
	return;
    }
    xf->center();
}


void
pfiXformerAutoInput(pfiXformer *xf, pfChannel *_chan, pfuMouse *_mouse, 
    pfuEventStream *_events)
{
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiXformerAutoInput -- null pfiXformer*");
	return;
    }

    xf->setAutoInput(_chan, _mouse, _events);
}

void
pfiGetXformerAutoInput(pfiXformer *xf, pfChannel **_chan, pfuMouse **_mouse, 
    pfuEventStream **_events)
{
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiXformerAutoInput -- null pfiXformer*");
	return;
    }

    xf->getAutoInput(_chan, _mouse, _events);
}

void
pfiXformerMat(pfiXformer *xf, pfMatrix& _mat)
{
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiXformerMat -- null pfiXformer*");
	return;
    }
    xf->setMat(_mat);
}


void
pfiGetXformerMat(pfiXformer *xf, pfMatrix& _mat)
{
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiGetXformerMat -- null pfiXformer*");
	return;
    }

    xf->getMat(_mat);
}

void
pfiXformerModelMat(pfiXformer *xf, pfMatrix& _mat)
{
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiXformerModelMat -- null pfiXformer*");
	return;
    }
    xf->setModelMat(_mat);
}


void
pfiGetXformerModelMat(pfiXformer *xf, pfMatrix& _mat)
{
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiGetXformerModelMat -- null pfiXformer*");
	return;
    }

    xf->getModelMat(_mat);
}


void
pfiXformerCoord(pfiXformer *xf, pfCoord *_coord)
{
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiXformerCoord -- null pfiXformer*");
	return;
    }
    xf->setCoord(_coord);
}


void
pfiGetXformerCoord(pfiXformer *xf, pfCoord *_coord)
{
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiGetXformerCoord -- null pfiXformer*");
	return;
    }
    xf->getCoord(_coord); 
}

void
pfiXformerResetCoord(pfiXformer *xf, pfCoord *_resetCoord)
{
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiXformerCoord -- null pfiXformer*");
	return;
    }
    xf->setResetCoord(_resetCoord);
}


void
pfiGetXformerResetCoord(pfiXformer *xf, pfCoord *_resetCoord)
{
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiGetXformerCoord -- null pfiXformer*");
	return;
    }
    xf->getResetCoord(_resetCoord); 
}

void
pfiXformerNode(pfiXformer *xf, pfNode *_node)
{
   if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiXformerNode -- null pfiXformer*");
	return;
    } 
    xf->setNode(_node);
}

pfNode *
pfiGetXformerNode(pfiXformer *xf)
{
   if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiGetXformerNode -- null pfiXformer*");
	return NULL;
    } 
    return xf->getNode();
}

void
pfiXformerAutoPosition(pfiXformer *xf, pfChannel *_chan, pfDCS *_dcs)
{
   if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiXformerAutoPosition -- null pfiXformer*");
	return;
    } 
    xf->setAutoPosition(_chan, _dcs);
}

void
pfiGetXformerAutoPosition(pfiXformer *xf, pfChannel **_chan, pfDCS **_dcs)
{
   if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiGetXformerAutoPosition -- null pfiXformer*");
	return;
    } 
    xf->getAutoPosition(_chan, _dcs);
}


void
pfiXformerLimits(pfiXformer *xf, float _maxSpeed, float _angularVel, 
    float _accel, pfBox *_dbLimits)
{
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiXformerLimits -- null pfiXformer*");
	return;
    }
    xf->setMotionLimits(_maxSpeed, _angularVel, _accel);
    xf->setDBLimits(_dbLimits);
}

void
pfiGetXformerLimits(pfiXformer *xf, float *_maxSpeed, float *_angularVel, 
    float *_accel, pfBox *_dbLimits)
{
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiGetXformerLimits -- null pfiXformer*");
	return;
    }
    xf->getMotionLimits(_maxSpeed, _angularVel, _accel);
    xf->getDBLimits(_dbLimits);
}

void
pfiXformerCollision(pfiXformer *xf, int _mode, float _val, pfNode *_node)
{
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiXformerCollision -- null pfiXformer*");
	return;
    }
    xf->setCollision(_mode, _val, _node);
}

void
pfiEnableXformerCollision(pfiXformer *xf)
{
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiEnableXformerCollision -- null pfiXformer*");
	return;
    }
    xf->enableCollision();
}

void
pfiDisableXformerCollision(pfiXformer *xf)
{
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiDisableXformerCollision -- null pfiXformer*");
	return;
    }
    xf->disableCollision();
}

int
pfiGetXformerCollisionEnable(pfiXformer *xf)
{
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiGetXformerCollisionEnable -- null pfiXformer*");
	return -1;
    }
    return xf->getCollisionEnable();
}


int
pfiGetXformerCollisionStatus(pfiXformer *xf)
{
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiGetXformerCollisionStatus -- null pfiXformer*");
	return -1;
    }
    return xf->getCollisionStatus();
}


void
pfiUpdateXformer(pfiXformer *xf)
{
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiUpdateXformer -- null pfiXformer*");
	return;
    }
    xf->update();
}

int
pfiCollideXformer(pfiXformer *xf)
{
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiCollideXformer -- null pfiXformer*");
	return NULL;
    }
    return xf->collide();
}


/* TDF Xformer Routines */


pfType*
pfiGetTDFXformerClassType(void)
{
    return pfiTDFXformer::getClassType();    
}

pfiTDFXformer *
pfiNewTDFXformer(void *arena)
{
    return new(arena) pfiTDFXformer;
}

pfiXformer *
pfiCreateTDFXformer(pfiInputXformTrackball *_tb,
				pfiInputXformDrive *_drive,
				pfiInputXformFly *_fly,
		                pfiInputXformSpheric *_spheric, void *arena)
{ 
    return new(arena) pfiTDFXformer(_tb, _drive, _fly, _spheric);
}

void
pfiTDFXformerFastClickTime(pfiTDFXformer *xf, float _clickTime)
{
   if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiXformerHeight -- null pfiXformer*");
	return;
    } 
    xf->setFastClickTime(_clickTime);
}

float
pfiGetTDFXformerFastClickTime(pfiTDFXformer *xf)
{
   if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiGetTDFXformerFastClickTime -- null pfiXformer*");
	return -1;
    } 
    return xf->getFastClickTime();
}

void 
pfiTDFXformerTrackball(pfiTDFXformer *xf, pfiInputXformTrackball *_tb)
{ 
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiXformerTrackball -- null pfiXformer*");
	return;
    }
    xf->setTrackball(_tb);
}

pfiInputXformTrackball  *
pfiGetTDFXformerTrackball(pfiTDFXformer *xf)
{ 
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiGetXformerTrackball -- null pfiXformer*");
	return NULL;
    }
    return xf->getTrackball();
}

void 
pfiTDFXformerDrive(pfiTDFXformer *xf, pfiInputXformDrive *_tb)
{ 
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiXformerTrackball -- null pfiXformer*");
	return;
    }
    xf->setDrive(_tb);
}

pfiInputXformDrive *
pfiGetTDFXformerDrive(pfiTDFXformer *xf)
{ 
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiGetXformerTrackball -- null pfiXformer*");
	return NULL;
    }
    return xf->getDrive();
}

void pfiTDFXformerFly(pfiTDFXformer *xf, pfiInputXformFly *_fly)
{ 
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiXformerFly -- null pfiXformer*");
	return;
    }
    xf->setFly(_fly);
}

pfiInputXformFly * 
pfiGetTDFXformerFly(pfiTDFXformer *xf)
{ 
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE, 
	    "pfiGetXformerFly -- null pfiXformer*");
	return NULL;
    }
    return xf->getFly();
}

void pfiTDFXformerSpheric(pfiTDFXformer *xf, pfiInputXformSpheric *_spheric)
{
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE,
	    "pfiXformerSpheric -- null pfiXformer*");
	return;
    }
    xf->setSpheric(_spheric);
}

pfiInputXformSpheric *
pfiGetTDFXformerSpheric(pfiTDFXformer *xf)
{
    if (xf == NULL)
    {
	pfNotify(PFNFY_WARN, PFNFY_USAGE,
	    "pfiGetXformerSpheric -- null pfiXformer*");
	return NULL;
    }
    return xf->getSpheric();
}