Add New Sensor

/*
 * Copyright (c) 2026 LG Electronics Inc.
 *
 * SPDX-License-Identifier: MIT
 */

using UnityEngine;
using messages = cloisim.msgs;

namespace SensorDevices
{
	public partial class MyNewSensor : Device
	{
		private messages.MyMessage _msg;

		// Per-axis noise holders (if applicable)
		private Noise _noiseX;

		protected override void OnAwake()
		{
			Mode = ModeType.TX_THREAD;
			DeviceName = name;
		}

		protected override void OnStart()
		{
			// Cache initial transforms, register with managers
		}

		protected override void OnReset()
		{
			// Restore initial state
		}

		protected override void InitializeMessages()
		{
			_msg = new messages.MyMessage();
			_msg.Stamp = new messages.Time();
			// Allocate all nested sub-messages explicitly
		}

		protected override void SetupMessages()
		{
			_msg.EntityName = DeviceName;
		}

		// For timer-polled TX_THREAD: override GenerateMessage
		protected override void GenerateMessage()
		{
			// Populate message fields from current state
			_msg.Stamp.Set(GetNextSyntheticTime());
			PushDeviceMessage<messages.MyMessage>(_msg);
		}

		// For event-driven TX_THREAD: call EnqueueMessage() from
		// async callbacks instead, and let default GenerateMessage drain the queue

		private void FixedUpdate()
		{
			// Physics-based sensing here (IMU, force/torque)
			// Apply noise: _noiseX.Apply<float>(ref value, Time.fixedDeltaTime);
		}
	}
}

public void SetupNoise(in SDFormat.Noise noise)
{
	_noiseX = new Noise(noise);
}

// Or per-axis:
public void SetupNoises(in SDFormat.XxxSensor sensor)
{
	if (sensor.XNoise != null)
		_noiseX = new Noise(sensor.XNoise);
}

_noiseX.Apply<float>(ref value, Time.fixedDeltaTime);  // single value
_noise.Apply<double>(dataArray);                         // array (parallelized)

public static Device AddMyNewSensor(this GameObject targetObject, in SDFormat.MyNewSensorType element)
{
	var newSensorObject = new GameObject();
	targetObject.AttachSensor(newSensorObject);

	var sensor = newSensorObject.AddComponent<SensorDevices.MyNewSensor>();
	sensor.DeviceName = newSensorObject.GetFrameName();

	// Configure sensor-specific parameters from SDF element
	// sensor.SomeParameter = element.SomeField;

	// Setup noise if applicable
	if (element.Noise != null)
		sensor.SetupNoise(element.Noise);

	return sensor;
}

case "my_new_sensor":
	var myData = sensor.GetMyNewSensorData();  // or sensor.MyNewSensorData
	device = targetObject.AddMyNewSensor(myData);
	break;

/*
 * Copyright (c) 2026 LG Electronics Inc.
 *
 * SPDX-License-Identifier: MIT
 */

using System.Collections;
using UnityEngine;

public class MyNewSensorPlugin : CLOiSimPlugin
{
	private SensorDevices.MyNewSensor _sensor;

	protected override void OnAwake()
	{
		_type = ICLOiSimPlugin.Type.SENSOR;  // or a new specific type
		_sensor = gameObject.GetComponent<SensorDevices.MyNewSensor>();
	}

	protected override IEnumerator OnStart()
	{
		if (RegisterServiceDevice(out var portService, "Info"))
		{
			AddThread(portService, ServiceThread);
		}

		if (RegisterTxDevice(out var portTx, "Data"))
		{
			AddThread(portTx, SenderThread, _sensor);
		}

		yield return null;
	}

	protected override void HandleCustomRequestMessage(
		in string requestType, in Any requestValue, ref DeviceMessage response)
	{
		switch (requestType)
		{
			case "request_transform":
				var devicePose = _sensor.GetPose();
				var deviceName = _sensor.DeviceName;
				SetTransformInfoResponse(ref response, deviceName, devicePose, _parentLinkName);
				break;
			default:
				break;
		}
	}
}