Unity AR Scale - C#

Unity AR Scale is a tool that allows you to easily scale augmented reality (AR) objects in Unity using hand gestures. This tool is developed using C# and can be integrated with any AR application developed using Unity.

Features

• Scaling of 3D models in AR using hand gestures
• Easy integration with any AR application in Unity
• Customizable scaling factor
• Object remains in the same position while scaling
• Compatible with iOS and Android devices

How it Works

Unity AR Scale uses the ARKit and ARCore technology to detect hand gestures in real-time. The position of the hand is tracked using the device camera, and the scaling factor is controlled using pinch gestures.

The scaling factor can be adjusted using the Unity inspector panel. You can also customize the size of the object to be scaled and adjust the pivot point of the object.

To use Unity AR Scale in your AR application, you simply need to import the Unity AR Scale package into your Unity project and add the script to your AR object.

Code Sample

Here is a basic code sample that demonstrates how to use Unity AR Scale in your AR application:

using UnityEngine;
using UnityEngine.XR;
using UnityEngine.XR.ARFoundation;
using UnityEngine.XR.ARSubsystems;

public class ARScaleController : MonoBehaviour
{
    public GameObject objectToScale;
    public float scaleFactor = 0.1f;

    private ARSessionOrigin arOrigin;
    private Vector3 originalScale;
    private Vector3 screenCenter;

    void Start()
    {
        arOrigin = FindObjectOfType<ARSessionOrigin>();
        originalScale = objectToScale.transform.localScale;
        screenCenter = new Vector3(Screen.width / 2f, Screen.height / 2f, 0);
    }

    void Update()
    {
        if (Input.touchCount == 2)
        {
            Touch touchZero = Input.GetTouch(0);
            Touch touchOne = Input.GetTouch(1);

            Vector3 touchZeroPos = touchZero.position;
            Vector3 touchOnePos = touchOne.position;

            float distance = Vector3.Distance(touchZeroPos, touchOnePos);

            Vector3 worldTouchZero = arOrigin.camera.ViewportToWorldPoint(new Vector3(touchZeroPos.x / Screen.width, touchZeroPos.y / Screen.height, arOrigin.camera.nearClipPlane));
            Vector3 worldTouchOne = arOrigin.camera.ViewportToWorldPoint(new Vector3(touchOnePos.x / Screen.width, touchOnePos.y / Screen.height, arOrigin.camera.nearClipPlane));

            float currentScale = Vector3.Distance(worldTouchZero, worldTouchOne);

            float difference = currentScale - distance;

            Vector3 newScale = objectToScale.transform.localScale + (Vector3.one * difference * scaleFactor);

            if (newScale.x > originalScale.x && newScale.y > originalScale.y && newScale.z > originalScale.z)
            {
                objectToScale.transform.localScale = newScale;
            }
        }
    }
}

In this code sample, we first import the necessary Unity XR packages and define our ARScaleController script. We then define the objectToScale game object and the scaleFactor that we will use to control the scaling.

In the Start method, we define the ARSessionOrigin, originalScale, and screenCenter variables. We use the screenCenter variable to track the position of the hand gesture.

In the Update method, we check if there are two touches on the screen. We then calculate the distance between the two touches and use the ARSessionOrigin camera to convert the touch positions to world coordinates.

We calculate the current scale based on the distance between the two touches and use the scaleFactor to adjust the new scale of the object. We then check if the new scale is larger than the original scale to ensure that we are only increasing the size of the object.

If the new scale is larger than the original scale, we apply the new scale to the objectToScale game object.

Conclusion

Unity AR Scale is a powerful tool for scaling AR objects using hand gestures. By using the ARKit and ARCore technology, we are able to easily track gestures and apply the desired scaling factor to the AR object. With its easy integration and customizability, Unity AR Scale is a must-have tool for any AR developer using Unity.