rik/jlibxinput
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import from http://drts.cvs.sourceforge.net/viewvc/drts/projects/jxinput/ tarball

Browse Source
This commit is contained in:
Rik Veenboer
2014-10-18 17:43:25 +01:00
commit f45b3ebaf8
97 changed files with 7544 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

95
java/de/hardcode/jxinput/j3d/DeviceConfiguration.java Normal file
View File

@@ -0,0 +1,95 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 23. Februar 2002, 14:05
//**********************************************************************************************
package de.hardcode.jxinput.j3d;
import de.hardcode.jxinput.Axis;
/**
* Connects JXInput with J3DInputDevice.
*
* @author Herkules
*/
public class DeviceConfiguration
{
public final static int AXIS_X = 0;
public final static int AXIS_Y = 1;
public final static int AXIS_Z = 2;
private final static class axisvalue
{
private final Axis mAxis;
private final IsActiveCondition mIsActive;
private final IsActiveCondition mIsIncremental;
private final double mScale;
private final double mOffset;
private double mValue;
axisvalue( Axis axis, IsActiveCondition active, IsActiveCondition incremental, double offset, double scale )
{
mAxis = axis;
mIsActive = active;
mIsIncremental = incremental;
mValue = mOffset = offset;
mScale = scale;
}
double value()
{
if ( mIsActive.isActive() )
{
double newval = mAxis.getValue() * mScale;
if ( mIsIncremental.isActive() )
mValue += newval;
else
mValue = newval + mOffset;
}
return mValue;
}
}
DeviceConfiguration.axisvalue [] mAxisTrans = new DeviceConfiguration.axisvalue[ 3 ];
DeviceConfiguration.axisvalue [] mAxisRot = new DeviceConfiguration.axisvalue[ 3 ];
/**
* Creates a new instance of DeviceConfiguration.
*/
public DeviceConfiguration()
{
}
double getTranslational( int axisid )
{
DeviceConfiguration.axisvalue val = mAxisTrans[ axisid ];
return null == val ? 0.0 : val.value();
}
double getRotational( int axisid )
{
DeviceConfiguration.axisvalue val = mAxisRot[ axisid ];
return null == val ? 0.0 : val.value();
}
public void setTranslational( int axisid, Axis axis, IsActiveCondition active, IsActiveCondition incremental, double offset, double scale )
{
if ( axisid < 0 || axisid > AXIS_Z )
throw new IllegalArgumentException();
mAxisTrans[ axisid ] = new DeviceConfiguration.axisvalue( axis, active, incremental, offset, scale );
}
public void setRotational( int axisid, Axis axis, IsActiveCondition active, IsActiveCondition incremental, double offset, double scale )
{
if ( axisid < 0 || axisid > AXIS_Z )
throw new IllegalArgumentException();
mAxisRot[ axisid ] = new DeviceConfiguration.axisvalue( axis, active, incremental, offset, scale );
}
}

25
java/de/hardcode/jxinput/j3d/IsActiveCondition.java Normal file
View File

@@ -0,0 +1,25 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 25. Februar 2002, 22:41
//**********************************************************************************************
package de.hardcode.jxinput.j3d;
/**
*
* @author Herkules
*/
public interface IsActiveCondition
{
public final static IsActiveCondition ALWAYS = IsAlwaysActiveCondition.ALWAYS;
public final static IsActiveCondition NEVER = IsAlwaysActiveCondition.NEVER;
/**
* Tell wether a certain thing is active.
*/
boolean isActive();
}

39
java/de/hardcode/jxinput/j3d/IsActiveOnButtonCondition.java Normal file
View File

@@ -0,0 +1,39 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 25. Februar 2002, 22:43
//**********************************************************************************************
package de.hardcode.jxinput.j3d;
import de.hardcode.jxinput.Button;
/**
*
* @author Herkules
*/
public class IsActiveOnButtonCondition implements IsActiveCondition
{
private final boolean mActiveState;
private final Button mButton;
/**
* Creates a new instance of IsAlwayActiveCondition.
*/
public IsActiveOnButtonCondition( Button button, boolean activestate )
{
mActiveState = activestate;
mButton = button;
}
/**
* Tell wether a certain thing is active.
*/
public boolean isActive()
{
return mButton.getState() == mActiveState;
}
}

38
java/de/hardcode/jxinput/j3d/IsAlwaysActiveCondition.java Normal file
View File

@@ -0,0 +1,38 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 25. Februar 2002, 22:43
//**********************************************************************************************
package de.hardcode.jxinput.j3d;
/**
*
* @author Herkules
*/
final class IsAlwaysActiveCondition implements IsActiveCondition
{
private final boolean mIsActive;
public final static IsActiveCondition ALWAYS = new IsAlwaysActiveCondition( true );
public final static IsActiveCondition NEVER = new IsAlwaysActiveCondition( false );
/**
* Creates a new instance of IsAlwayActiveCondition.
*/
private IsAlwaysActiveCondition(boolean isactive)
{
mIsActive = isactive;
}
/**
* Tell wether a certain thing is active.
*/
public boolean isActive()
{
return mIsActive;
}
}

171
java/de/hardcode/jxinput/j3d/J3DInputDevice.java Normal file
View File

@@ -0,0 +1,171 @@
//**********************************************************************************************
// (C) Copyright 2002 by Dipl. Phys. Joerg Plewe, HARDCODE Development
// All rights reserved. Copying, modification,
// distribution or publication without the prior written
// consent of the author is prohibited.
//
// Created on 22. Februar 2002, 13:21
//**********************************************************************************************
package de.hardcode.jxinput.j3d;
import javax.media.j3d.InputDevice;
import javax.media.j3d.Sensor;
import javax.media.j3d.SensorRead;
import javax.vecmath.Vector3d;
import javax.media.j3d.Transform3D;
import de.hardcode.jxinput.JXInputManager;
/**
* Implementation of Java3D's InputDevice
*
* @author Herkules
*/
public class J3DInputDevice
implements InputDevice
{
private Vector3d mPosition = new Vector3d();
private Transform3D mNewTransform = new Transform3D();
private Transform3D mRotTransX = new Transform3D();
private Transform3D mRotTransY = new Transform3D();
private Transform3D mRotTransZ = new Transform3D();
private Vector3d mInitPos = new Vector3d( 0.0, 0.0, 0.0 );
private Sensor mSensor = new Sensor( this );
private SensorRead mSensorRead = new SensorRead();
private DeviceConfiguration mConfig;
/**
* Creates a new instance of J3DInputDevice.
*/
public J3DInputDevice( DeviceConfiguration config )
{
mConfig = config;
setNominalPositionAndOrientation();
}
public void close()
{
// Intentionally empty
}
/**
* Retrieve processing mode.
* For this device, it always is NON_BLOCKING.
*/
public int getProcessingMode()
{
return InputDevice.NON_BLOCKING;
}
/**
* Don't care for the index, I only support one sensor.
* And I deliver that.
*/
public Sensor getSensor( int param )
{
return mSensor;
}
/**
* Tell the world about the only one sensor I support.
*/
public int getSensorCount()
{
return 1;
}
/**
* Well - initialize!
* Nothing to do here.
*/
public boolean initialize()
{
return true;
}
/**
* The main update method.
*/
public void pollAndProcessInput()
{
JXInputManager.updateFeatures();
mSensorRead.setTime( JXInputManager.getLastUpdateTime() );
mRotTransX.rotX( mConfig.getRotational( DeviceConfiguration.AXIS_X ) );
mRotTransY.rotY( mConfig.getRotational( DeviceConfiguration.AXIS_Y ) );
mRotTransZ.rotZ( mConfig.getRotational( DeviceConfiguration.AXIS_Z ) );
mPosition.set(
mConfig.getTranslational( DeviceConfiguration.AXIS_X ),
mConfig.getTranslational( DeviceConfiguration.AXIS_Y ),
mConfig.getTranslational( DeviceConfiguration.AXIS_Z )
);
mNewTransform.set( mPosition );
mNewTransform.mul( mRotTransX );
mNewTransform.mul( mRotTransY );
mNewTransform.mul( mRotTransZ );
mSensorRead.set( mNewTransform );
mSensor.setNextSensorRead( mSensorRead );
}
/**
* Not called by current j3d implementation.
*/
public void processStreamInput()
{
// Intentionally empty
}
/**
* Reset state.
*/
public void setNominalPositionAndOrientation()
{
mSensorRead.setTime( JXInputManager.getLastUpdateTime() );
mRotTransX.rotX( 0.0 );
mRotTransY.rotY( 0.0 );
mRotTransZ.rotZ( 0.0 );
mPosition.set( mInitPos );
mNewTransform.set( mPosition );
mNewTransform.mul( mRotTransX );
mNewTransform.mul( mRotTransY );
mNewTransform.mul( mRotTransZ );
mSensorRead.set( mNewTransform );
mSensor.setNextSensorRead( mSensorRead );
}
/**
* Set the processing mode.
* Only NON_BLOCKING is allowed!
*/
public void setProcessingMode(int param)
{
if ( param != InputDevice.NON_BLOCKING )
throw new IllegalArgumentException("Processing mode must be NON_BLOCKING");
}
}

11
java/de/hardcode/jxinput/j3d/package.html Normal file
View File

@@ -0,0 +1,11 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<HTML>
<HEAD>
<TITLE></TITLE>
</HEAD>
<BODY>
Connecting JXInput to Java3D by implementing the interface
javax.media.j3d.InputDevice.
</BODY>
</HTML>

205
java/de/hardcode/jxinput/j3d/test/HelloUniverse.java Normal file
View File

@@ -0,0 +1,205 @@
/*
* @(#)HelloUniverse.java 1.15 02/02/07 14:48:36
*
* Copyright (c) 1996-2002 Sun Microsystems, Inc. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistribution in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* Neither the name of Sun Microsystems, Inc. or the names of
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* This software is provided "AS IS," without a warranty of any
* kind. ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND
* WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY
* EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
* DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN
* OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR
* FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
* PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
* LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE SOFTWARE,
* EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
*
* You acknowledge that Software is not designed,licensed or intended
* for use in the design, construction, operation or maintenance of
* any nuclear facility.
*/
package de.hardcode.jxinput.j3d.test;
import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
import com.sun.j3d.utils.applet.MainFrame;
import com.sun.j3d.utils.geometry.ColorCube;
import com.sun.j3d.utils.universe.*;
import javax.media.j3d.*;
import javax.vecmath.*;
import de.hardcode.jxinput.j3d.DeviceConfiguration;
import de.hardcode.jxinput.Axis;
import de.hardcode.jxinput.JXInputManager;
import de.hardcode.jxinput.j3d.IsActiveCondition;
import de.hardcode.jxinput.j3d.J3DInputDevice;
import de.hardcode.jxinput.j3d.IsActiveOnButtonCondition;
public class HelloUniverse extends Applet
{
private SimpleUniverse u = null;
TransformGroup objTrans;
public BranchGroup createSceneGraph()
{
BranchGroup objRoot = new BranchGroup();
objTrans = new TransformGroup();
objTrans.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
objRoot.addChild(objTrans);
objTrans.addChild(new ColorCube(0.4));
// Transform3D yAxis = new Transform3D();
// Alpha rotationAlpha = new Alpha(-1, Alpha.INCREASING_ENABLE,
// 0, 0,
// 4000, 0, 0,
// 0, 0, 0);
// RotationInterpolator rotator = new RotationInterpolator(rotationAlpha, objTrans, yAxis,
// 0.0f, (float) Math.PI*2.0f);
// BoundingSphere bounds = new BoundingSphere(new Point3d(0.0,0.0,0.0), 100.0);
// rotator.setSchedulingBounds(bounds);
// objTrans.addChild(rotator);
return objRoot;
}
public HelloUniverse()
{
}
public void init()
{
// These are the string arguments given to the VirtualInputDevice
// constructor. These are settable parameters. Look in the
// VirtualInputDevice constructor for a complete list.
String[] args = new String[10];
args[0] = "printvalues";
args[1] = "true";
args[2] = "yscreeninitloc";
args[3] = "50";
args[4] = null;
// now create the HelloUniverse Canvas
setLayout(new BorderLayout());
GraphicsConfiguration config = SimpleUniverse.getPreferredConfiguration();
Canvas3D c = new Canvas3D(config);
add("Center", c);
// Create a simple scene and attach it to the virtual universe
BranchGroup scene = createSceneGraph();
u = new SimpleUniverse(c);
//
// Use the inputdevice
//
InputDevice device = createInputDevice();
// Register the VirtualInputDevice with Java 3D
u.getViewer().getPhysicalEnvironment().addInputDevice( device );
// TransformGroup viewTrans = u.getViewingPlatform().getViewPlatformTransform();
// Put the behavoir to teh object
SensorBehavior s = new SensorBehavior( objTrans, device.getSensor(0) );
s.setSchedulingBounds( new BoundingSphere( new Point3d(0.0,0.0,0.0), Float.MAX_VALUE ) );
objTrans.addChild( s );
u.getViewingPlatform().setNominalViewingTransform();
u.addBranchGraph(scene);
}
public void destroy()
{
u.removeAllLocales();
}
/**
* Setup an input device.
*/
private InputDevice createInputDevice()
{
IsActiveCondition button1down = new IsActiveOnButtonCondition(JXInputManager.getJXInputDevice( 0 ).getButton( 0 ), true );
IsActiveCondition button1up = new IsActiveOnButtonCondition(JXInputManager.getJXInputDevice( 0 ).getButton( 0 ), false );
Axis xaxis = JXInputManager.getJXInputDevice( 0 ).getAxis( Axis.ID_X );
Axis yaxis = JXInputManager.getJXInputDevice( 0 ).getAxis( Axis.ID_Y );
DeviceConfiguration cnf = new DeviceConfiguration();
//
// Setup the configuration to use joysticks x/y for rotation is not button is pressed
// and for translation if button1 is pressed.
//
cnf.setRotational(
DeviceConfiguration.AXIS_Y,
xaxis,
button1up,
IsActiveCondition.NEVER,
0.0, Math.PI
);
cnf.setRotational(
DeviceConfiguration.AXIS_X,
yaxis,
button1up,
IsActiveCondition.NEVER,
0.0, Math.PI
);
cnf.setTranslational(
DeviceConfiguration.AXIS_Z,
yaxis,
button1down,
IsActiveCondition.NEVER,
-5.0, 4.0
);
cnf.setTranslational(
DeviceConfiguration.AXIS_X,
xaxis,
button1down,
IsActiveCondition.NEVER,
0.0, 4.0
);
// We have the config, create the device...
J3DInputDevice d = new J3DInputDevice( cnf );
// The InputDevice must be initialized before registering it
// with the PhysicalEnvironment object.
d.initialize();
return d;
}
public static void main(String[] args)
{
new MainFrame(new HelloUniverse(), 350, 350);
}
}

70
java/de/hardcode/jxinput/j3d/test/SensorBehavior.java Normal file
View File

@@ -0,0 +1,70 @@
package de.hardcode.jxinput.j3d.test;
/*
* @(#)SensorBehavior.java 1.8 02/02/07 14:48:34
*
* Copyright (c) 1996-2002 Sun Microsystems, Inc. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistribution in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* Neither the name of Sun Microsystems, Inc. or the names of
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* This software is provided "AS IS," without a warranty of any
* kind. ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND
* WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY
* EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
* DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN
* OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR
* FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
* PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
* LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE SOFTWARE,
* EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
*
* You acknowledge that Software is not designed,licensed or intended
* for use in the design, construction, operation or maintenance of
* any nuclear facility.
*/
import javax.media.j3d.*;
import java.util.*;
public class SensorBehavior extends Behavior
{
private WakeupOnElapsedFrames conditions = new WakeupOnElapsedFrames(0);
private TransformGroup transformGroup;
private Sensor sensor;
private Transform3D transform = new Transform3D();
public SensorBehavior( TransformGroup tg, Sensor sensor )
{
transformGroup = tg;
this.sensor = sensor;
}
public void initialize()
{
wakeupOn( conditions );
}
public void processStimulus( Enumeration criteria )
{
sensor.getRead( transform );
transformGroup.setTransform( transform );
wakeupOn( conditions );
}
}