C++ (Cpp) ToolManager::getToolClassSection示例

示例#1

ViewpointFileNavigationToolFactory::ViewpointFileNavigationToolFactory(ToolManager& toolManager)
	:ToolFactory("ViewpointFileNavigationTool",toolManager),
	 viewpointFileName(""),
	 showGui(false),
	 showKeyframes(true),
	 pauseFileName("ViewpointFileNavigation.pauses"),
	 autostart(false)
	{
	/* Initialize tool layout: */
	layout.setNumButtons(1);
	
	/* Insert class into class hierarchy: */
	ToolFactory* toolFactory=toolManager.loadClass("NavigationTool");
	toolFactory->addChildClass(this);
	addParentClass(toolFactory);
	
	/* Load class settings: */
	Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
	viewpointFileName=cfs.retrieveString("./viewpointFileName",viewpointFileName);
	showGui=cfs.retrieveValue<bool>("./showGui",showGui);
	showKeyframes=cfs.retrieveValue<bool>("./showKeyframes",showKeyframes);
	pauseFileName=cfs.retrieveString("./pauseFileName",pauseFileName);
	autostart=cfs.retrieveValue<bool>("./autostart",autostart);
	
	/* Set tool class' factory pointer: */
	ViewpointFileNavigationTool::factory=this;
	}

示例#2

文件： SixDofWithScaleNavigationTool.cpp 项目： VisualIdeation/Vrui

SixDofWithScaleNavigationToolFactory::SixDofWithScaleNavigationToolFactory(ToolManager& toolManager)
	:ToolFactory("SixDofWithScaleNavigationTool",toolManager),
	 scaleDeviceDistance(getInchFactor()*Scalar(6)),
	 deviceScaleDirection(0,1,0),
	 scaleFactor(getInchFactor()*Scalar(12))
	{
	/* Initialize tool layout: */
	layout.setNumDevices(2);
	layout.setNumButtons(0,1);
	layout.setNumButtons(1,0);
	
	/* Insert class into class hierarchy: */
	ToolFactory* navigationToolFactory=toolManager.loadClass("NavigationTool");
	navigationToolFactory->addChildClass(this);
	addParentClass(navigationToolFactory);
	
	/* Load class settings: */
	Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
	scaleDeviceDistance=cfs.retrieveValue<Scalar>("./scaleDeviceDistance",scaleDeviceDistance);
	scaleDeviceDistance2=scaleDeviceDistance*scaleDeviceDistance;
	deviceScaleDirection=cfs.retrieveValue<Vector>("./deviceScaleDirection",deviceScaleDirection);
	scaleFactor=cfs.retrieveValue<Scalar>("./scaleFactor",scaleFactor);
	
	/* Set tool class' factory pointer: */
	SixDofWithScaleNavigationTool::factory=this;
	}

示例#3

文件： MouseDialogNavigationTool.cpp 项目： VisualIdeation/Vrui-2.2-003

MouseDialogNavigationToolFactory::MouseDialogNavigationToolFactory(ToolManager& toolManager)
	:ToolFactory("MouseDialogNavigationTool",toolManager),
	 rotatePlaneOffset(getInchFactor()*Scalar(3)),
	 rotateFactor(getInchFactor()*Scalar(3)),
	 screenDollyingDirection(0,-1,0),
	 screenScalingDirection(0,-1,0),
	 dollyFactor(Scalar(1)),
	 scaleFactor(getInchFactor()*Scalar(3)),
	 spinThreshold(getUiSize()*Scalar(2)),
	 interactWithWidgets(true)
	{
	/* Initialize tool layout: */
	layout.setNumButtons(1);
	
	/* Insert class into class hierarchy: */
	ToolFactory* navigationToolFactory=toolManager.loadClass("NavigationTool");
	navigationToolFactory->addChildClass(this);
	addParentClass(navigationToolFactory);
	
	/* Load class settings: */
	Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
	rotatePlaneOffset=cfs.retrieveValue<Scalar>("./rotatePlaneOffset",rotatePlaneOffset);
	rotateFactor=cfs.retrieveValue<Scalar>("./rotateFactor",rotateFactor);
	screenDollyingDirection=cfs.retrieveValue<Vector>("./screenDollyingDirection",screenDollyingDirection);
	screenScalingDirection=cfs.retrieveValue<Vector>("./screenScalingDirection",screenScalingDirection);
	dollyFactor=cfs.retrieveValue<Scalar>("./dollyFactor",dollyFactor);
	scaleFactor=cfs.retrieveValue<Scalar>("./scaleFactor",scaleFactor);
	spinThreshold=cfs.retrieveValue<Scalar>("./spinThreshold",spinThreshold);
	interactWithWidgets=cfs.retrieveValue<bool>("./interactWithWidgets",interactWithWidgets);
	
	/* Set tool class' factory pointer: */
	MouseDialogNavigationTool::factory=this;
	}

示例#4

文件： ComeHitherNavigationTool.cpp 项目： VisualIdeation/Vrui

ComeHitherNavigationToolFactory::ComeHitherNavigationToolFactory(ToolManager& toolManager)
	:ToolFactory("ComeHitherNavigationTool",toolManager),
	 linearSnapThreshold(getDisplaySize()*Scalar(0.5)),
	 angularSnapThreshold(Scalar(45)),
	 maxLinearVelocity(getDisplaySize()*Scalar(1.5)),
	 maxAngularVelocity(Scalar(90.0))
	{
	/* Initialize tool layout: */
	layout.setNumDevices(1);
	layout.setNumButtons(0,1);
	
	/* Insert class into class hierarchy: */
	ToolFactory* navigationToolFactory=toolManager.loadClass("NavigationTool");
	navigationToolFactory->addChildClass(this);
	addParentClass(navigationToolFactory);
	
	/* Load class settings: */
	Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
	linearSnapThreshold=cfs.retrieveValue<Scalar>("./linearSnapThreshold",linearSnapThreshold);
	angularSnapThreshold=Math::rad(cfs.retrieveValue<Scalar>("./angularSnapThreshold",angularSnapThreshold));
	maxLinearVelocity=cfs.retrieveValue<Scalar>("./maxLinearVelocity",maxLinearVelocity);
	maxAngularVelocity=Math::rad(cfs.retrieveValue<Scalar>("./maxAngularVelocity",maxAngularVelocity));
	
	/* Set tool class' factory pointer: */
	ComeHitherNavigationTool::factory=this;
	}

示例#5

文件： ValuatorFlyNavigationTool.cpp 项目： jrevote/3DA-Vrui

ValuatorFlyNavigationToolFactory::ValuatorFlyNavigationToolFactory(ToolManager& toolManager)
    :ToolFactory("ValuatorFlyNavigationTool",toolManager),
     valuatorThreshold(0),
     flyDirection(Vector(0,1,0)),
     flyFactor(getDisplaySize()*Scalar(0.5))
{
    /* Initialize tool layout: */
    layout.setNumDevices(1);
    layout.setNumValuators(0,1);

    /* Insert class into class hierarchy: */
    ToolFactory* navigationToolFactory=toolManager.loadClass("NavigationTool");
    navigationToolFactory->addChildClass(this);
    addParentClass(navigationToolFactory);

    /* Load class settings: */
    Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
    valuatorThreshold=cfs.retrieveValue<Scalar>("./valuatorThreshold",valuatorThreshold);
    flyDirection=cfs.retrieveValue<Vector>("./flyDirection",flyDirection);
    flyDirection.normalize();
    flyFactor=cfs.retrieveValue<Scalar>("./flyFactor",flyFactor);

    /* Set tool class' factory pointer: */
    ValuatorFlyNavigationTool::factory=this;
}

示例#6

文件： ValuatorTurnNavigationTool.cpp 项目： Doc-Ok/OpticalTracking

ValuatorTurnNavigationToolFactory::ValuatorTurnNavigationToolFactory(ToolManager& toolManager)
	:ToolFactory("ValuatorTurnNavigationTool",toolManager),
	 valuatorThreshold(0.25),
	 flyDirection(Vector(0,1,0)),
	 flyFactor(getDisplaySize()*Scalar(0.5)),
	 rotationAxis0(Vector(0,0,1)),
	 rotationAxis1(Vector(1,0,0)),
	 rotationCenter(Point::origin),
	 rotationFactor(Scalar(90))
	{
	/* Initialize tool layout: */
	layout.setNumButtons(1);
	layout.setNumValuators(2);
	
	/* Insert class into class hierarchy: */
	ToolFactory* navigationToolFactory=toolManager.loadClass("NavigationTool");
	navigationToolFactory->addChildClass(this);
	addParentClass(navigationToolFactory);
	
	/* Load class settings: */
	Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
	valuatorThreshold=cfs.retrieveValue<Scalar>("./valuatorThreshold",valuatorThreshold);
	flyDirection=cfs.retrieveValue<Vector>("./flyDirection",flyDirection);
	flyDirection.normalize();
	flyFactor=cfs.retrieveValue<Scalar>("./flyFactor",flyFactor);
	rotationAxis0=cfs.retrieveValue<Vector>("./rotationAxis0",rotationAxis0);
	rotationAxis0.normalize();
	rotationAxis1=cfs.retrieveValue<Vector>("./rotationAxis1",rotationAxis1);
	rotationAxis1.normalize();
	rotationCenter=cfs.retrieveValue<Point>("./rotationCenter",rotationCenter);
	rotationFactor=Math::rad(cfs.retrieveValue<Scalar>("./rotationFactor",rotationFactor));
	
	/* Set tool class' factory pointer: */
	ValuatorTurnNavigationTool::factory=this;
	}

示例#7

文件： ButtonInputDeviceTool.cpp 项目： Doc-Ok/OpticalTracking

ButtonInputDeviceToolFactory::ButtonInputDeviceToolFactory(ToolManager& toolManager)
	:ToolFactory("ButtonInputDeviceTool",toolManager)
	{
	/* Initialize tool layout: */
	layout.setNumButtons(8,true);
	layout.setNumValuators(0,true);
	
	/* Load class settings: */
	Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
	
	/* Insert class into class hierarchy: */
	ToolFactory* inputDeviceToolFactory=toolManager.loadClass("InputDeviceTool");
	inputDeviceToolFactory->addChildClass(this);
	addParentClass(inputDeviceToolFactory);
	
	/* Initialize translation and rotation vectors: */
	Scalar translateFactor=cfs.retrieveValue<Scalar>("./translateFactor",Scalar(4)*getInchFactor());
	Scalar rotateFactor=Math::rad(cfs.retrieveValue<Scalar>("./rotateFactor",Scalar(60)));
	for(int i=0;i<6;++i)
		translations[i]=Vector::zero;
	for(int i=0;i<3;++i)
		{
		translations[2*i+0][i]=-translateFactor;
		translations[2*i+1][i]=translateFactor;
		}
	rotations[0]=Vector(0,0,-rotateFactor);
	rotations[1]=Vector(0,0,rotateFactor);
	rotations[2]=Vector(0,-rotateFactor,0);
	rotations[3]=Vector(0,rotateFactor,0);
	rotations[4]=Vector(rotateFactor,0,0);
	rotations[5]=Vector(-rotateFactor,0,0);
	
	/* Set tool class' factory pointer: */
	ButtonInputDeviceTool::factory=this;
	}

示例#8

文件： JediTool.cpp 项目： KeckCAVES/Vrui

JediToolFactory::JediToolFactory(ToolManager& toolManager)
	:ToolFactory("JediTool",toolManager),
	 lightsaberLength(Scalar(48)*getInchFactor()),
	 lightsaberWidth(Scalar(6)*getInchFactor()),
	 baseOffset(Scalar(3)*getInchFactor()),
	 lightsaberImageFileName(std::string(VRUI_INTERNAL_CONFIG_SHAREDIR)+"/Textures/Lightsaber.png")
	{
	/* Initialize tool layout: */
	layout.setNumButtons(1);
	
	/* Insert class into class hierarchy: */
	ToolFactory* toolFactory=toolManager.loadClass("PointingTool");
	toolFactory->addChildClass(this);
	addParentClass(toolFactory);
	
	/* Load class settings: */
	Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
	lightsaberLength=cfs.retrieveValue<Scalar>("./lightsaberLength",lightsaberLength);
	lightsaberWidth=cfs.retrieveValue<Scalar>("./lightsaberWidth",lightsaberWidth);
	baseOffset=cfs.retrieveValue<Scalar>("./baseOffset",baseOffset);
	lightsaberImageFileName=cfs.retrieveString("./lightsaberImageFileName",lightsaberImageFileName);
	
	/* Set tool class' factory pointer: */
	JediTool::factory=this;
	}

示例#9

文件： MouseNavigationTool.cpp 项目： jrevote/3DA-Vrui

MouseNavigationToolFactory::MouseNavigationToolFactory(ToolManager& toolManager)
    :ToolFactory("MouseNavigationTool",toolManager),
     rotatePlaneOffset(getInchFactor()*Scalar(12)),
     rotateFactor(getInchFactor()*Scalar(12)),
     invertDolly(false),
     screenDollyingDirection(0,1,0),
     screenScalingDirection(0,1,0),
     dollyFactor(getInchFactor()*Scalar(12)),
     scaleFactor(getInchFactor()*Scalar(12)),
     wheelDollyFactor(getInchFactor()*Scalar(-12)),
     wheelScaleFactor(Scalar(0.5)),
     spinThreshold(Scalar(0)),
     showScreenCenter(false),
     interactWithWidgets(true),
     showMouseCursor(false),
     mouseCursorSize(Scalar(0.5),Scalar(0.5),Scalar(0.0)),
     mouseCursorHotspot(Scalar(0.0),Scalar(1.0),Scalar(0.0)),
     mouseCursorImageFileName(DEFAULTMOUSECURSORIMAGEFILENAME),
     mouseCursorNominalSize(24)
{
    /* Initialize tool layout: */
    layout.setNumDevices(1);
    layout.setNumButtons(0,3);
    layout.setNumValuators(0,1);

    /* Insert class into class hierarchy: */
    ToolFactory* navigationToolFactory=toolManager.loadClass("NavigationTool");
    navigationToolFactory->addChildClass(this);
    addParentClass(navigationToolFactory);

    /* Load class settings: */
    Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
    rotatePlaneOffset=cfs.retrieveValue<Scalar>("./rotatePlaneOffset",rotatePlaneOffset);
    rotateFactor=cfs.retrieveValue<Scalar>("./rotateFactor",rotateFactor);
    invertDolly=cfs.retrieveValue<bool>("./invertDolly",invertDolly);
    screenDollyingDirection=cfs.retrieveValue<Vector>("./screenDollyingDirection",screenDollyingDirection);
    screenScalingDirection=cfs.retrieveValue<Vector>("./screenScalingDirection",screenScalingDirection);
    dollyFactor=cfs.retrieveValue<Scalar>("./dollyFactor",dollyFactor);
    scaleFactor=cfs.retrieveValue<Scalar>("./scaleFactor",scaleFactor);
    wheelDollyFactor=cfs.retrieveValue<Scalar>("./wheelDollyFactor",wheelDollyFactor);
    wheelScaleFactor=cfs.retrieveValue<Scalar>("./wheelScaleFactor",wheelScaleFactor);
    spinThreshold=cfs.retrieveValue<Scalar>("./spinThreshold",spinThreshold);
    showScreenCenter=cfs.retrieveValue<bool>("./showScreenCenter",showScreenCenter);
    interactWithWidgets=cfs.retrieveValue<bool>("./interactWithWidgets",interactWithWidgets);
    showMouseCursor=cfs.retrieveValue<bool>("./showMouseCursor",showMouseCursor);
    mouseCursorSize=cfs.retrieveValue<Size>("./mouseCursorSize",mouseCursorSize);
    mouseCursorHotspot=cfs.retrieveValue<Vector>("./mouseCursorHotspot",mouseCursorHotspot);
    mouseCursorImageFileName=cfs.retrieveString("./mouseCursorImageFileName",mouseCursorImageFileName);
    mouseCursorNominalSize=cfs.retrieveValue<unsigned int>("./mouseCursorNominalSize",mouseCursorNominalSize);

    /* Set tool class' factory pointer: */
    MouseNavigationTool::factory=this;
}

示例#10

文件： SixAxisSurfaceNavigationTool.cpp 项目： VisualIdeation/Vrui-2.2-003

SixAxisSurfaceNavigationToolFactory::SixAxisSurfaceNavigationToolFactory(ToolManager& toolManager)
	:ToolFactory("SixAxisSurfaceNavigationTool",toolManager),
	 canRoll(true),
	 bankTurns(false),levelSpeed(5),
	 canFly(true),
	 probeSize(getDisplaySize()),
	 maxClimb(getDisplaySize()),
	 fixAzimuth(false),
	 drawHud(true),hudColor(0.0f,1.0f,0.0f),hudRadius(float(getFrontplaneDist()*1.25f)),hudFontSize(float(getUiSize())*1.5f)
	{
	/* Initialize tool layout: */
	layout.setNumValuators(6);
	
	/* Load class settings: */
	Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
	Vector trans;
	for(int i=0;i<3;++i)
		trans[i]=getDisplaySize();
	trans=cfs.retrieveValue<Vector>("./translateFactors",trans);
	for(int i=0;i<3;++i)
		translateFactors[i]=trans[i];
	Vector rot=cfs.retrieveValue<Vector>("./rotateFactors",Vector(180,180,180));
	for(int i=0;i<3;++i)
		rotateFactors[i]=Math::rad(rot[i]);
	canRoll=cfs.retrieveValue<bool>("./canRoll",canRoll);
	bankTurns=cfs.retrieveValue<bool>("./bankTurns",bankTurns);
	levelSpeed=cfs.retrieveValue<Scalar>("./levelSpeed",levelSpeed);
	if(levelSpeed<Scalar(0))
		levelSpeed=Scalar(0);
	canFly=cfs.retrieveValue<bool>("./canFly",canFly);
	probeSize=cfs.retrieveValue<Scalar>("./probeSize",probeSize);
	maxClimb=cfs.retrieveValue<Scalar>("./maxClimb",maxClimb);
	fixAzimuth=cfs.retrieveValue<bool>("./fixAzimuth",fixAzimuth);
	drawHud=cfs.retrieveValue<bool>("./drawHud",drawHud);
	hudColor=cfs.retrieveValue<Color>("./hudColor",hudColor);
	hudRadius=cfs.retrieveValue<float>("./hudRadius",hudRadius);
	hudFontSize=cfs.retrieveValue<float>("./hudFontSize",hudFontSize);
	
	/* Insert class into class hierarchy: */
	ToolFactory* navigationToolFactory=toolManager.loadClass("SurfaceNavigationTool");
	navigationToolFactory->addChildClass(this);
	addParentClass(navigationToolFactory);
	
	/* Set tool class' factory pointer: */
	SixAxisSurfaceNavigationTool::factory=this;
	}

示例#11

文件： MultiDeviceNavigationTool.cpp 项目： KeckCAVES/Vrui

MultiDeviceNavigationToolFactory::MultiDeviceNavigationToolFactory(ToolManager& toolManager)
	:ToolFactory("MultiDeviceNavigationTool",toolManager)
	{
	/* Initialize tool layout: */
	layout.setNumButtons(1,true);
	
	/* Insert class into class hierarchy: */
	ToolFactory* navigationToolFactory=toolManager.loadClass("NavigationTool");
	navigationToolFactory->addChildClass(this);
	addParentClass(navigationToolFactory);
	
	/* Load class settings: */
	Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
	configuration.read(cfs);
	
	/* Set tool class' factory pointer: */
	MultiDeviceNavigationTool::factory=this;
	}

示例#12

文件： SixAxisTransformTool.cpp 项目： soimy/OpticalTracking

SixAxisTransformToolFactory::SixAxisTransformToolFactory(ToolManager& toolManager)
    :ToolFactory("SixAxisTransformTool",toolManager)
{
    /* Initialize tool layout: */
    layout.setNumButtons(1,true);
    layout.setNumValuators(6,true);

    /* Insert class into class hierarchy: */
    ToolFactory* transformToolFactory=toolManager.loadClass("TransformTool");
    transformToolFactory->addChildClass(this);
    addParentClass(transformToolFactory);

    /* Load class settings: */
    config.load(toolManager.getToolClassSection(getClassName()));

    /* Set tool class' factory pointer: */
    SixAxisTransformTool::factory=this;
}

示例#13

文件： SixAxisNavigationTool.cpp 项目： Doc-Ok/OpticalTracking

SixAxisNavigationToolFactory::SixAxisNavigationToolFactory(ToolManager& toolManager)
	:ToolFactory("SixAxisNavigationTool",toolManager)
	{
	/* Initialize tool layout: */
	layout.setNumValuators(7);
	
	/* Insert class into class hierarchy: */
	ToolFactory* navigationToolFactory=toolManager.loadClass("NavigationTool");
	navigationToolFactory->addChildClass(this);
	addParentClass(navigationToolFactory);
	
	/* Load class settings: */
	Misc::ConfigurationFileSection cfs(toolManager.getToolClassSection(getClassName()));
	config.load(cfs);
	
	/* Set tool class' factory pointer: */
	SixAxisNavigationTool::factory=this;
	}

示例#14

文件： WalkNavigationTool.cpp 项目： VisualIdeation/Vrui

WalkNavigationToolFactory::WalkNavigationToolFactory(ToolManager& toolManager)
	:ToolFactory("WalkNavigationTool",toolManager),
	 floorPlane(getFloorPlane()),
	 centerOnActivation(false),
	 centerPoint(getDisplayCenter()),
	 moveSpeed(getDisplaySize()),
	 innerRadius(getDisplaySize()*Scalar(0.5)),outerRadius(getDisplaySize()*Scalar(0.75)),
	 centerViewDirection(getForwardDirection()),
	 rotateSpeed(Math::rad(Scalar(120))),
	 innerAngle(Math::rad(Scalar(30))),outerAngle(Math::rad(Scalar(120))),
	 drawMovementCircles(true),
	 movementCircleColor(0.0f,1.0f,0.0f)
	{
	/* Initialize tool layout: */
	layout.setNumDevices(1);
	layout.setNumButtons(0,1);
	
	/* Insert class into class hierarchy: */
	ToolFactory* navigationToolFactory=toolManager.loadClass("NavigationTool");
	navigationToolFactory->addChildClass(this);
	addParentClass(navigationToolFactory);
	
	/* Load class settings: */
	Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
	floorPlane=cfs.retrieveValue<Plane>("./floorPlane",floorPlane);
	floorPlane.normalize();
	centerOnActivation=cfs.retrieveValue<bool>("./centerOnActivation",centerOnActivation);
	centerPoint=cfs.retrieveValue<Point>("./centerPoint",centerPoint);
	centerPoint=floorPlane.project(centerPoint);
	moveSpeed=cfs.retrieveValue<Scalar>("./moveSpeed",moveSpeed);
	innerRadius=cfs.retrieveValue<Scalar>("./innerRadius",innerRadius);
	outerRadius=cfs.retrieveValue<Scalar>("./outerRadius",outerRadius);
	centerViewDirection=cfs.retrieveValue<Vector>("./centerViewDirection",centerViewDirection);
	centerViewDirection=floorPlane.project(centerViewDirection);
	centerViewDirection.normalize();
	rotateSpeed=Math::rad(cfs.retrieveValue<Scalar>("./rotateSpeed",Math::deg(rotateSpeed)));
	innerAngle=Math::rad(cfs.retrieveValue<Scalar>("./innerAngle",Math::deg(innerAngle)));
	outerAngle=Math::rad(cfs.retrieveValue<Scalar>("./outerAngle",Math::deg(outerAngle)));
	drawMovementCircles=cfs.retrieveValue<bool>("./drawMovementCircles",drawMovementCircles);
	movementCircleColor=cfs.retrieveValue<Color>("./movementCircleColor",movementCircleColor);
	
	/* Set tool class' factory pointer: */
	WalkNavigationTool::factory=this;
	}

示例#15

文件： RayScreenMenuTool.cpp 项目： Doc-Ok/OpticalTracking

RayScreenMenuToolFactory::RayScreenMenuToolFactory(ToolManager& toolManager)
	:ToolFactory("RayScreenMenuTool",toolManager),
	 interactWithWidgets(false)
	{
	/* Initialize tool layout: */
	layout.setNumButtons(1);
	
	/* Insert class into class hierarchy: */
	ToolFactory* menuToolFactory=toolManager.loadClass("MenuTool");
	menuToolFactory->addChildClass(this);
	addParentClass(menuToolFactory);
	
	/* Load class settings: */
	Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
	interactWithWidgets=cfs.retrieveValue<bool>("./interactWithWidgets",interactWithWidgets);
	
	/* Set tool class' factory pointer: */
	RayScreenMenuTool::factory=this;
	}

示例#16

文件： PlaneSnapInputDeviceTool.cpp 项目： VisualIdeation/Vrui-2.3-001

PlaneSnapInputDeviceToolFactory::PlaneSnapInputDeviceToolFactory(ToolManager& toolManager)
	:ToolFactory("PlaneSnapInputDeviceTool",toolManager),
	 markerSize(getUiSize())
	{
	/* Initialize tool layout: */
	layout.setNumButtons(1);
	
	/* Insert class into class hierarchy: */
	ToolFactory* inputDeviceToolFactory=toolManager.loadClass("InputDeviceTool");
	inputDeviceToolFactory->addChildClass(this);
	addParentClass(inputDeviceToolFactory);
	
	/* Load class settings: */
	Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
	markerSize=cfs.retrieveValue<Scalar>("./markerSize",markerSize);
	
	/* Set tool class' factory pointer: */
	PlaneSnapInputDeviceTool::factory=this;
	}

示例#17

文件： TrackballNavigationTool.cpp 项目： VisualIdeation/Vrui-2.2-003

TrackballNavigationToolFactory::TrackballNavigationToolFactory(ToolManager& toolManager)
	:ToolFactory("TrackballNavigationTool",toolManager),
	 rotateFactor(1)
	{
	/* Initialize tool layout: */
	layout.setNumButtons(1);
	
	/* Insert class into class hierarchy: */
	ToolFactory* navigationToolFactory=toolManager.loadClass("NavigationTool");
	navigationToolFactory->addChildClass(this);
	addParentClass(navigationToolFactory);
	
	/* Load class settings: */
	Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
	rotateFactor=cfs.retrieveValue<Scalar>("./rotateFactor",rotateFactor);
	
	/* Set tool class' factory pointer: */
	TrackballNavigationTool::factory=this;
	}

示例#18

文件： RayInputDeviceTool.cpp 项目： jrevote/3DA-Vrui

RayInputDeviceToolFactory::RayInputDeviceToolFactory(ToolManager& toolManager)
	:ToolFactory("RayInputDeviceTool",toolManager),
	 rotateFactor(getInchFactor()*Scalar(3))
	{
	/* Initialize tool layout: */
	layout.setNumDevices(1);
	layout.setNumButtons(0,1);
	
	/* Insert class into class hierarchy: */
	ToolFactory* inputDeviceToolFactory=toolManager.loadClass("InputDeviceTool");
	inputDeviceToolFactory->addChildClass(this);
	addParentClass(inputDeviceToolFactory);
	
	/* Load class settings: */
	Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
	rotateFactor=cfs.retrieveValue<Scalar>("./rotateFactor",rotateFactor);
	
	/* Set tool class' factory pointer: */
	RayInputDeviceTool::factory=this;
	}

示例#19

文件： RevolverTool.cpp 项目： chebee7i/Vrui

RevolverToolFactory::RevolverToolFactory(ToolManager& toolManager)
	:ToolFactory("RevolverTool",toolManager),
	 numChambers(6)
	{
	/* Insert class into class hierarchy: */
	TransformToolFactory* transformToolFactory=dynamic_cast<TransformToolFactory*>(toolManager.loadClass("TransformTool"));
	transformToolFactory->addChildClass(this);
	addParentClass(transformToolFactory);
	
	/* Load class settings: */
	Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
	numChambers=cfs.retrieveValue<int>("./numChambers",numChambers);
	
	/* Initialize tool layout: */
	layout.setNumButtons(1,true);
	layout.setNumValuators(0,true);
	
	/* Set tool class' factory pointer: */
	RevolverTool::factory=this;
	}

示例#20

文件： WaldoTool.cpp 项目： Doc-Ok/OpticalTracking

WaldoToolFactory::WaldoToolFactory(ToolManager& toolManager)
	:ToolFactory("WaldoTool",toolManager),
	 linearScale(0.25),angularScale(0.25)
	{
	/* Insert class into class hierarchy: */
	TransformToolFactory* transformToolFactory=dynamic_cast<TransformToolFactory*>(toolManager.loadClass("TransformTool"));
	transformToolFactory->addChildClass(this);
	addParentClass(transformToolFactory);
	
	/* Load class settings: */
	Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
	linearScale=cfs.retrieveValue<Scalar>("./linearScale",linearScale);
	angularScale=cfs.retrieveValue<Scalar>("./angularScale",angularScale);
	
	/* Initialize tool layout: */
	layout.setNumButtons(0,true);
	layout.setNumValuators(0,true);
	
	/* Set tool class' factory pointer: */
	WaldoTool::factory=this;
	}

示例#21

文件： DaisyWheelTool.cpp 项目： VisualIdeation/Vrui

DaisyWheelToolFactory::DaisyWheelToolFactory(ToolManager& toolManager)
	:ToolFactory("DaisyWheelTool",toolManager),
	 innerRadius(getUiSize()*Scalar(8)),outerRadius(getUiSize()*Scalar(24))
	{
	/* Initialize tool layout: */
	layout.setNumDevices(1);
	layout.setNumButtons(0,1);
	
	/* Insert class into class hierarchy: */
	ToolFactory* toolFactory=toolManager.loadClass("UserInterfaceTool");
	toolFactory->addChildClass(this);
	addParentClass(toolFactory);
	
	/* Load class settings: */
	Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
	innerRadius=cfs.retrieveValue<Scalar>("./innerRadius",innerRadius);
	outerRadius=cfs.retrieveValue<Scalar>("./outerRadius",outerRadius);
	
	/* Set tool class' factory pointer: */
	DaisyWheelTool::factory=this;
	}

示例#22

文件： ClutchTool.cpp 项目： VisualIdeation/Vrui

ClutchToolFactory::ClutchToolFactory(ToolManager& toolManager)
	:ToolFactory("ClutchTool",toolManager),
	 clutchButtonToggleFlag(false)
	{
	/* Insert class into class hierarchy: */
	TransformToolFactory* transformToolFactory=dynamic_cast<TransformToolFactory*>(toolManager.loadClass("TransformTool"));
	transformToolFactory->addChildClass(this);
	addParentClass(transformToolFactory);
	
	/* Load class settings: */
	Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
	clutchButtonToggleFlag=cfs.retrieveValue<bool>("./clutchButtonToggleFlag",clutchButtonToggleFlag);
	
	/* Initialize tool layout: */
	layout.setNumDevices(1);
	layout.setNumButtons(0,transformToolFactory->getNumButtons()+1);
	layout.setNumValuators(0,transformToolFactory->getNumValuators());
	
	/* Set tool class' factory pointer: */
	ClutchTool::factory=this;
	}

示例#23

文件： OffsetTool.cpp 项目： jrevote/3DA-Vrui

OffsetToolFactory::OffsetToolFactory(ToolManager& toolManager)
	:ToolFactory("OffsetTool",toolManager),
	 offset(ONTransform::identity)
	{
	/* Insert class into class hierarchy: */
	TransformToolFactory* transformToolFactory=dynamic_cast<TransformToolFactory*>(toolManager.loadClass("TransformTool"));
	transformToolFactory->addChildClass(this);
	addParentClass(transformToolFactory);
	
	/* Load class settings: */
	Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
	offset=cfs.retrieveValue<ONTransform>("./offset",offset);
	
	/* Initialize tool layout: */
	layout.setNumDevices(1);
	layout.setNumButtons(0,transformToolFactory->getNumButtons());
	layout.setNumValuators(0,transformToolFactory->getNumValuators());
	
	/* Set tool class' factory pointer: */
	OffsetTool::factory=this;
	}

示例#24

SketchingToolFactory::SketchingToolFactory(ToolManager& toolManager)
	:ToolFactory("SketchingTool",toolManager),
	 detailSize(getUiSize()),
	 curveFileName("SketchingTool.curves")
	{
	/* Initialize tool layout: */
	layout.setNumButtons(1);
	
	/* Insert class into class hierarchy: */
	ToolFactory* toolFactory=toolManager.loadClass("UtilityTool");
	toolFactory->addChildClass(this);
	addParentClass(toolFactory);
	
	/* Load class settings: */
	Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
	detailSize=cfs.retrieveValue<Scalar>("./detailSize",detailSize);
	curveFileName=cfs.retrieveString("./curveFileName",curveFileName);
	
	/* Set tool class' factory pointer: */
	SketchingTool::factory=this;
	}

示例#25

文件： ClipPlaneTool.cpp 项目： VisualIdeation/Vrui

ClipPlaneToolFactory::ClipPlaneToolFactory(ToolManager& toolManager)
	:ToolFactory("ClipPlaneTool",toolManager),
	 normal(0,1,0)
	{
	/* Initialize tool layout: */
	layout.setNumDevices(1);
	layout.setNumButtons(0,1);
	
	/* Insert class into class hierarchy: */
	ToolFactory* toolFactory=toolManager.loadClass("PointingTool");
	toolFactory->addChildClass(this);
	addParentClass(toolFactory);
	
	/* Load class settings: */
	Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
	normal=cfs.retrieveValue<Vector>("./normal",normal);
	normal.normalize();
	
	/* Set tool class' factory pointer: */
	ClipPlaneTool::factory=this;
	}

示例#26

文件： FPSNavigationTool.cpp 项目： jrevote/3DA-Vrui

FPSNavigationToolFactory::FPSNavigationToolFactory(ToolManager& toolManager)
	:ToolFactory("FPSNavigationTool",toolManager),
	 rotateFactor(getInchFactor()*Scalar(12)),
	 moveSpeed(getInchFactor()*Scalar(500))
	{
	/* Initialize tool layout: */
	layout.setNumDevices(1);
	layout.setNumButtons(0,5);
	
	/* Insert class into class hierarchy: */
	ToolFactory* navigationToolFactory=toolManager.loadClass("NavigationTool");
	navigationToolFactory->addChildClass(this);
	addParentClass(navigationToolFactory);
	
	/* Load class settings: */
	Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
	rotateFactor=cfs.retrieveValue<Scalar>("./rotateFactor",rotateFactor);
	moveSpeed=cfs.retrieveValue<Scalar>("./moveSpeed",moveSpeed);
	
	/* Set tool class' factory pointer: */
	FPSNavigationTool::factory=this;
	}

示例#27

文件： ValuatorFlyTurnNavigationTool.cpp 项目： VisualIdeation/Vrui

ValuatorFlyTurnNavigationToolFactory::ValuatorFlyTurnNavigationToolFactory(ToolManager& toolManager)
	:ToolFactory("ValuatorFlyTurnNavigationTool",toolManager),
	 valuatorThreshold(Scalar(0.25)),
	 valuatorExponent(Scalar(1)),
	 superAccelerationFactor(Scalar(1.1)),
	 flyDirectionDeviceCoordinates(true),flyDirection(Vector(0,1,0)),
	 flyFactor(getDisplaySize()*Scalar(2)),
	 rotationAxisDeviceCoordinates(true),rotationAxis(Vector(0,0,1)),
	 rotationCenterDeviceCoordinates(true),rotationCenter(Point::origin),
	 rotationFactor(Scalar(90))
	{
	/* Initialize tool layout: */
	layout.setNumDevices(1);
	layout.setNumValuators(0,2);
	
	/* Insert class into class hierarchy: */
	ToolFactory* navigationToolFactory=toolManager.loadClass("NavigationTool");
	navigationToolFactory->addChildClass(this);
	addParentClass(navigationToolFactory);
	
	/* Load class settings: */
	Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
	valuatorThreshold=cfs.retrieveValue<Scalar>("./valuatorThreshold",valuatorThreshold);
	valuatorExponent=cfs.retrieveValue<Scalar>("./valuatorExponent",valuatorExponent);
	superAccelerationFactor=cfs.retrieveValue<Scalar>("./superAccelerationFactor",superAccelerationFactor);
	flyDirectionDeviceCoordinates=cfs.retrieveValue<bool>("./flyDirectionDeviceCoordinates",flyDirectionDeviceCoordinates);
	flyDirection=cfs.retrieveValue<Vector>("./flyDirection",flyDirection);
	flyDirection.normalize();
	flyFactor=cfs.retrieveValue<Scalar>("./flyFactor",flyFactor);
	rotationAxisDeviceCoordinates=cfs.retrieveValue<bool>("./rotationAxisDeviceCoordinates",rotationAxisDeviceCoordinates);
	rotationAxis=cfs.retrieveValue<Vector>("./rotationAxis",rotationAxis);
	rotationAxis.normalize();
	rotationCenterDeviceCoordinates=cfs.retrieveValue<bool>("./rotationCenterDeviceCoordinates",rotationCenterDeviceCoordinates);
	rotationCenter=cfs.retrieveValue<Point>("./rotationCenter",rotationCenter);
	rotationFactor=Math::rad(cfs.retrieveValue<Scalar>("./rotationFactor",rotationFactor));
	
	/* Set tool class' factory pointer: */
	ValuatorFlyTurnNavigationTool::factory=this;
	}

示例#28

文件： LaserpointerTool.cpp 项目： Doc-Ok/OpticalTracking

LaserpointerToolFactory::LaserpointerToolFactory(ToolManager& toolManager)
	:ToolFactory("LaserpointerTool",toolManager),
	 rayLength(getDisplaySize()*Scalar(5)),
	 rayLineWidth(3.0f),
	 rayColor(1.0f,0.0f,0.0f)
	{
	/* Initialize tool layout: */
	layout.setNumButtons(1);
	
	/* Insert class into class hierarchy: */
	ToolFactory* toolFactory=toolManager.loadClass("PointingTool");
	toolFactory->addChildClass(this);
	addParentClass(toolFactory);
	
	/* Load class settings: */
	Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
	rayLength=cfs.retrieveValue<Scalar>("./rayLength",rayLength);
	rayLineWidth=cfs.retrieveValue<float>("./rayLineWidth",rayLineWidth);
	rayColor=cfs.retrieveValue<Color>("./rayColor",rayColor);
	
	/* Set tool class' factory pointer: */
	LaserpointerTool::factory=this;
	}

示例#29

文件： FlashlightTool.cpp 项目： jrevote/3DA-Vrui

FlashlightToolFactory::FlashlightToolFactory(ToolManager& toolManager)
	:ToolFactory("FlashlightTool",toolManager)
	{
	/* Initialize tool layout: */
	layout.setNumDevices(1);
	layout.setNumButtons(0,1);
	
	/* Insert class into class hierarchy: */
	ToolFactory* toolFactory=toolManager.loadClass("UtilityTool");
	toolFactory->addChildClass(this);
	addParentClass(toolFactory);
	
	/* Load class settings: */
	Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
	GLLight::Color lightColor=cfs.retrieveValue<GLLight::Color>("./lightColor",GLLight::Color(1.0f,1.0f,1.0f));
	light.diffuse=lightColor;
	light.specular=lightColor;
	light.spotCutoff=cfs.retrieveValue<GLfloat>("./lightSpotCutoff",180.0f);
	light.spotExponent=cfs.retrieveValue<GLfloat>("./lightSpotExponent",0.0f);
	
	/* Set tool class' factory pointer: */
	FlashlightTool::factory=this;
	}

示例#30

文件： HelicopterNavigationTool.cpp 项目： jrevote/3DA-Vrui

HelicopterNavigationToolFactory::HelicopterNavigationToolFactory(ToolManager& toolManager)
    :ToolFactory("HelicopterNavigationTool",toolManager),
     g(getMeterFactor()*Scalar(9.81)),
     collectiveMin(Scalar(0)),collectiveMax(g*Scalar(1.5)),
     thrust(g*Scalar(5)),
     brake(g*Scalar(0.75))
{
    /* Initialize tool layout: */
    layout.setNumDevices(1);
    layout.setNumButtons(0,3);
    layout.setNumValuators(0,6);

    /* Load class settings: */
    Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
    Vector rot=cfs.retrieveValue<Vector>("./rotateFactors",Vector(-60,-60,60));
    for(int i=0; i<3; ++i)
        rotateFactors[i]=Math::rad(rot[i]);
    g=cfs.retrieveValue<Scalar>("./g",g);
    collectiveMin=cfs.retrieveValue<Scalar>("./collectiveMin",collectiveMin);
    collectiveMax=cfs.retrieveValue<Scalar>("./collectiveMax",collectiveMax);
    thrust=cfs.retrieveValue<Scalar>("./thrust",thrust);
    brake=cfs.retrieveValue<Scalar>("./brake",brake);
    Vector drag=cfs.retrieveValue<Vector>("./dragCoefficients",Vector(0.3,0.1,0.3));
    for(int i=0; i<3; ++i)
        dragCoefficients[i]=-Math::abs(drag[i]);
    Geometry::Vector<Scalar,2> view=cfs.retrieveValue<Geometry::Vector<Scalar,2> >("./viewAngleFactors",Geometry::Vector<Scalar,2>(35,-25));
    for(int i=0; i<2; ++i)
        viewAngleFactors[i]=Math::rad(view[i]);

    /* Insert class into class hierarchy: */
    ToolFactory* navigationToolFactory=toolManager.loadClass("NavigationTool");
    navigationToolFactory->addChildClass(this);
    addParentClass(navigationToolFactory);

    /* Set tool class' factory pointer: */
    HelicopterNavigationTool::factory=this;
}