示例#1
0
        protected override void OnDestroy()
        {
            PowerLine     = null;
            Gear          = null;
            BeginActuator = null;
            EndActuator   = null;

            base.OnDestroy();
        }
示例#2
0
        protected override bool Initialize()
        {
            if (!agx.Runtime.instance().isModuleEnabled("AgX-DriveTrain"))
            {
                Debug.LogWarning("GearConstraint requires a valid license for the AGX Dynamics module: AgX-DriveTrain", this);
                return(false);
            }

            if (BeginActuatorConstraint?.GetInitialized <Constraint>() == null)
            {
                Debug.LogError("Invalid GearConstraint: Begin actuator constraint is invalid or null.", this);
                return(false);
            }
            if (EndActuatorConstraint?.GetInitialized <Constraint>() == null)
            {
                Debug.LogError("Invalid GearConstraint: End actuator constraint is invalid  or null.", this);
                return(false);
            }
            if (BeginActuatorConstraint == EndActuatorConstraint)
            {
                Debug.LogError("Invalid GearConstraint: Begin actuator constraint is the same instance as the end actuator constraint.", this);
                return(false);
            }
            if (!IsValidConstraintType(BeginActuatorConstraint.Type))
            {
                Debug.LogError($"Invalid GearConstraint: Begin actuator constraint type {BeginActuatorConstraint.Type} isn't supported.", this);
                return(false);
            }
            if (!IsValidConstraintType(EndActuatorConstraint.Type))
            {
                Debug.LogError($"Invalid GearConstraint: End actuator constraint type {EndActuatorConstraint.Type} isn't supported.", this);
                return(false);
            }

            // Rotational -> Rotational:
            //     Begin Actuator -> shaft -> Gear -> shaft -> End Actuator
            // Rotational -> Translational
            //     Begin Actuator -> shaft -> Gear -> shaft -> Converter (Rotational to Translational) -> End Actuator
            // Translational -> Translational
            //     Begin Actuator -> Converter -> shaft -> Gear -> shaft -> Converter -> End Actuator
            // Translational -> Rotational (Inverted)
            //     End Actuator -> shaft -> Gear -> shaft -> Converter -> Begin Actuator

            BeginActuator = CreateActuator(BeginActuatorConstraint);
            EndActuator   = CreateActuator(EndActuatorConstraint);

            IsInverted = BeginActuator.GetType() != EndActuator.GetType() &&
                         BeginActuator is agxPowerLine.TranslationalActuator &&
                         EndActuator is agxPowerLine.RotationalActuator;

            PowerLine = new agxPowerLine.PowerLine();
            Gear      = new agxDriveTrain.Gear(GearRatio);

            PowerLine.add(Gear);
            PowerLine.setName(name);

            var beginShaft = new agxDriveTrain.Shaft();
            var endShaft   = new agxDriveTrain.Shaft();

            Gear.connect(agxPowerLine.Side.INPUT, agxPowerLine.Side.OUTPUT, beginShaft);
            Gear.connect(agxPowerLine.Side.OUTPUT, agxPowerLine.Side.INPUT, endShaft);

            // Translational -> Rotational.
            if (IsInverted)
            {
                EndActuator.connect(endShaft);
                var converter = new agxPowerLine.RotationalTranslationalConnector();
                converter.connect((BeginActuator as agxPowerLine.TranslationalActuator).getInputRod());

                beginShaft.connect(converter);
            }
            // Rotational -> Translational.
            else if (BeginActuator is agxPowerLine.RotationalActuator &&
                     EndActuator is agxPowerLine.TranslationalActuator)
            {
                BeginActuator.connect(beginShaft);
                var converter = new agxPowerLine.RotationalTranslationalConnector();
                converter.connect((EndActuator as agxPowerLine.TranslationalActuator).getInputRod());

                endShaft.connect(converter);
            }
            // Translational -> Translational.
            else if (BeginActuator is agxPowerLine.TranslationalActuator &&
                     EndActuator is agxPowerLine.TranslationalActuator)
            {
                var beginConverter = new agxPowerLine.RotationalTranslationalConnector();
                var endConverter   = new agxPowerLine.RotationalTranslationalConnector();

                beginConverter.connect((BeginActuator as agxPowerLine.TranslationalActuator).getInputRod());
                endConverter.connect((EndActuator as agxPowerLine.TranslationalActuator).getInputRod());

                beginShaft.connect(beginConverter);
                endShaft.connect(endConverter);
            }
            // Rotational -> Rotational.
            else
            {
                BeginActuator.connect(beginShaft);
                EndActuator.connect(endShaft);
            }

            GetSimulation().add(PowerLine);

            return(true);
        }