Initial commit: com.sky.sentis.yolox Unity package

YOLOX object detection for the Unity Inference Engine (Sentis), FP16.
Includes Runtime sources and model weights (Models~/, git-lfs).

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.sentis filter=lfs diff=lfs merge=lfs -text

CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## [0.1.0] - 2026-06-22
+### Added
+- Initial package: `Yolox` Unity Inference Engine (Sentis) inference wrapper and FP16 model weights under `Models~`.

CHANGELOG.md.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: b98fa00cb2a2a4058b809040d3a969af
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

LICENSE.md

@@ -0,0 +1,18 @@
+# sentis-yolox License
+
+This package's wrapper code is licensed under the Apache License 2.0.
+The bundled model weights are derived from Megvii-BaseDetection/YOLOX (https://github.com/Megvii-BaseDetection/YOLOX) and are also Apache-2.0 licensed.
+
+Copyright 2026 Sky Kim
+Copyright the upstream authors of Megvii-BaseDetection/YOLOX (https://github.com/Megvii-BaseDetection/YOLOX)
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+these files except in compliance with the License. You may obtain a copy of the
+License at:
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.

LICENSE.md.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 5fad480053daa4611a1551b821c9f0f0
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Models~/yolox_fp16.sentis

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:81b2a88891591fd85431fca32fbbf2337cb667fcfc157c27698be27b0f467920
+size 1958976

README.md

@@ -1,3 +1,48 @@
 ---
 license: apache-2.0
+library_name: unity-sentis
+tags:
+  - unity
+  - sentis
+  - on-device
+  - object-detection
+  - yolox
 ---
+
+# sentis-yolox
+
+YOLOX object detection converted to **Unity Inference Engine (Sentis)** FP16.
+
+## Files
+
+```
+yolox_fp16.sentis
+YoloxDetector.cs    # self-contained Unity Sentis inference (COCO labels)
+```
+
+## Model I/O
+
+- **Input:** RGB NCHW `[1, 3, S, S]` in `[0, 1]` (read `S` from the model; the `[0,1]→[0,255]` scale is
+  baked into the export). YOLOX is typically trained BGR, so a R↔B swizzle is usually needed.
+- **Output:** one tensor `[1, N, 5+C]` (or `[1, 5+C, N]`) where each candidate is
+  `[cx, cy, w, h, objectness, class_0..class_{C-1}]`, scores already sigmoid-activated and boxes in
+  input-pixel coordinates (export with the grid/stride decode baked in). NMS runs on the C# side.
+
+## Inference
+
+A complete self-contained implementation lives in [`YoloxDetector.cs`](YoloxDetector.cs) (texture →
+tensor with optional R↔B swizzle, layout auto-detection, scoring, class-wise NMS, GPU warmup, 80 COCO
+labels inlined). Minimal usage:
+
+```csharp
+var detector = new YoloxDetector(BackendType.GPUCompute);
+detector.Load(modelRoot);                                  // folder holding yolox_fp16.sentis
+List<YoloxDetector.Detection> dets = await detector.DetectAsync(frameTexture); // boxes in input-pixel space
+```
+
+> Do not substitute Ultralytics weights (`yolo*`), which are **AGPL-3.0**. This repo ships YOLOX only.
+
+## License & attribution
+
+Apache-2.0. Converted from [Megvii-BaseDetection/YOLOX](https://github.com/Megvii-BaseDetection/YOLOX)
+(Apache-2.0).

README.md.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 4e2f69251dd1d4c95b2795cdf0ceae9e
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 8320957a855574432a15403a11cc61de
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/Sky.Sentis.Yolox.asmdef

@@ -0,0 +1,16 @@
+{
+    "name": "Sky.Sentis.Yolox",
+    "rootNamespace": "SentisModels",
+    "references": [
+        "Unity.InferenceEngine"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

Runtime/Sky.Sentis.Yolox.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: ec42095011d644f7a8bdca66283613de
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/YoloxDetector.cs

@@ -0,0 +1,312 @@
+// YOLOX object detector (COCO). Self-contained Unity Sentis inference.
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using Unity.InferenceEngine;
+using UnityEngine;
+
+namespace SentisModels
+{
+public sealed class YoloxDetector : IDisposable
+{
+    const int DefaultInputSize = 640;
+    const int NumCoords = 4;
+    const float NmsIouThreshold = 0.45f;
+    const string DefaultModelFile = "yolox_fp16.sentis";
+
+    static readonly string[] s_CocoLabels =
+    {
+        "person", "bicycle", "car", "motorcycle", "airplane", "bus", "train", "truck", "boat", "traffic light",
+        "fire hydrant", "stop sign", "parking meter", "bench", "bird", "cat", "dog", "horse", "sheep", "cow",
+        "elephant", "bear", "zebra", "giraffe", "backpack", "umbrella", "handbag", "tie", "suitcase", "frisbee",
+        "skis", "snowboard", "sports ball", "kite", "baseball bat", "baseball glove", "skateboard", "surfboard", "tennis racket", "bottle",
+        "wine glass", "cup", "fork", "knife", "spoon", "bowl", "banana", "apple", "sandwich", "orange",
+        "broccoli", "carrot", "hot dog", "pizza", "donut", "cake", "chair", "couch", "potted plant", "bed",
+        "dining table", "toilet", "tv", "laptop", "mouse", "remote", "keyboard", "cell phone", "microwave", "oven",
+        "toaster", "sink", "refrigerator", "book", "clock", "vase", "scissors", "teddy bear", "hair drier", "toothbrush"
+    };
+
+    readonly BackendType m_BackendType;
+    readonly float m_ConfidenceThreshold;
+    readonly bool m_LogOutputShapeOnce;
+    readonly bool m_WarmupOnLoad;
+    // Swap R<->B before inference. YOLOX is typically trained on BGR while Sentis ToTensor produces RGB.
+    readonly bool m_SwapRedBlue;
+
+    string[] Labels => s_CocoLabels;
+
+    Worker m_Worker;
+    // Model input resolution (square), read from the loaded model; falls back to DefaultInputSize.
+    int m_InputSize = DefaultInputSize;
+    bool m_LoggedShape;
+    // Worker is not re-entrant; serializes concurrent callers.
+    readonly SemaphoreSlim m_InferLock = new SemaphoreSlim(1, 1);
+
+    public struct Detection
+    {
+        public int ClassId;
+        public string ClassName;
+        public float Confidence;
+        public Rect BoxXyxy;
+    }
+
+    public bool IsReady => m_Worker != null;
+
+    public YoloxDetector(
+        BackendType backendType = BackendType.GPUCompute,
+        float confidenceThreshold = 0.25f,
+        bool swapRedBlue = true,
+        bool warmupOnLoad = true,
+        bool logOutputShapeOnce = true)
+    {
+        m_BackendType = backendType;
+        m_ConfidenceThreshold = confidenceThreshold;
+        m_SwapRedBlue = swapRedBlue;
+        m_WarmupOnLoad = warmupOnLoad;
+        m_LogOutputShapeOnce = logOutputShapeOnce;
+    }
+
+    // modelRoot: absolute path to the folder holding yolox_fp16.sentis.
+    public void Load(string modelRoot, string modelFile = DefaultModelFile)
+    {
+        DisposeResources();
+        Model model;
+        try
+        {
+            model = ModelLoader.Load(Path.Combine(modelRoot, modelFile));
+        }
+        catch (Exception exception)
+        {
+            Debug.LogException(exception);
+            return;
+        }
+
+        m_InputSize = ResolveInputSize(model, DefaultInputSize);
+        m_Worker = new Worker(model, m_BackendType);
+
+        if (m_WarmupOnLoad)
+            WarmupAsync();
+    }
+
+    // YOLO inputs are square NCHW (1, 3, S, S); read S from the model so 320- and 640-input
+    // exports both work. Falls back when the input dim is dynamic/unknown.
+    static int ResolveInputSize(Model model, int fallback)
+    {
+        if (model.inputs.Count == 0)
+            return fallback;
+        var dynamicShape = model.inputs[0].shape;
+        if (!dynamicShape.IsStatic())
+            return fallback;
+        var shape = dynamicShape.ToTensorShape();
+        return shape.rank >= 4 ? Mathf.Max(1, shape[shape.rank - 1]) : fallback;
+    }
+
+    // One throwaway inference on a blank frame so the GPUCompute kernels compile before the first
+    // real detection, which would otherwise stall while every shader is built.
+    async void WarmupAsync()
+    {
+        if (m_Worker == null)
+            return;
+
+        await m_InferLock.WaitAsync();
+        try
+        {
+            using var input = new Tensor<float>(new TensorShape(1, 3, m_InputSize, m_InputSize));
+            m_Worker.Schedule(input);
+
+            var out0 = m_Worker.PeekOutput(0) as Tensor<float>;
+            if (out0 != null)
+                (await out0.ReadbackAndCloneAsync()).Dispose();
+        }
+        catch (Exception exception)
+        {
+            Debug.LogException(exception);
+        }
+        finally
+        {
+            m_InferLock.Release();
+        }
+    }
+
+    public async Task<List<Detection>> DetectAsync(Texture frame)
+    {
+        if (m_Worker == null || frame == null)
+            return new List<Detection>();
+
+        // No ConfigureAwait(false): must resume on Unity main thread for Schedule + readback.
+        await m_InferLock.WaitAsync();
+        try
+        {
+            using var input = new Tensor<float>(new TensorShape(1, 3, m_InputSize, m_InputSize));
+            // Sentis ToTensor produces RGB; YOLOX is typically BGR. m_SwapRedBlue toggles R<->B (the
+            // [0,1]->[0,255] scale YOLOX expects is baked into the model).
+            var transform = m_SwapRedBlue
+                ? new TextureTransform().SetChannelSwizzle(2, 1, 0, 3)
+                : new TextureTransform();
+            TextureConverter.ToTensor(frame, input, transform);
+            m_Worker.Schedule(input);
+
+            var out0 = m_Worker.PeekOutput(0) as Tensor<float>;
+            if (out0 == null)
+            {
+                if (!m_LoggedShape)
+                {
+                    Debug.LogWarning("[Vision] YOLOX model produced no float output 0.");
+                    m_LoggedShape = true;
+                }
+                return new List<Detection>();
+            }
+
+            using var c0 = await out0.ReadbackAndCloneAsync();
+
+            if (m_LogOutputShapeOnce && !m_LoggedShape)
+            {
+                Debug.Log("[Vision] YOLOX output: out0=" + c0.shape);
+                m_LoggedShape = true;
+            }
+
+            return Decode(c0);
+        }
+        finally
+        {
+            m_InferLock.Release();
+        }
+    }
+
+    // YOLOX output: a single tensor [1, N, 5+C] or [1, 5+C, N], where each of the N candidates is
+    // [cx, cy, w, h, objectness, class_0 .. class_{C-1}]. Scores are already sigmoid-activated and
+    // box coords are in input-pixel space (export YOLOX with the grid/stride decode baked in, i.e.
+    // decode_in_inference). Input is RGB NCHW in [0,1] (Sentis ToTensor default) — bake any /255 or
+    // mean/std normalization into the exported model.
+    List<Detection> Decode(Tensor<float> t)
+    {
+        var labels = Labels;
+        var feat = NumCoords + 1 + labels.Length; // cx,cy,w,h + objectness + classes
+
+        if (!TryResolveLayout(t, feat, out var featAxis, out var candAxis))
+        {
+            if (!m_LoggedShape)
+            {
+                Debug.LogWarning("[Vision] Could not resolve YOLOX output layout (expected a dim == " +
+                    feat + " for " + labels.Length + " classes): " + t.shape);
+                m_LoggedShape = true;
+            }
+            return new List<Detection>();
+        }
+
+        var candidates = t.shape[candAxis];
+        var featMajor = featAxis < candAxis; // [1, F, N] flattens feature-major
+        float At(int f, int i) => featMajor ? t[f * candidates + i] : t[i * feat + f];
+
+        var dets = new List<Detection>();
+        for (var i = 0; i < candidates; i++)
+        {
+            var obj = At(4, i);
+
+            var bestClass = 0;
+            var bestCls = float.NegativeInfinity;
+            for (var c = 0; c < labels.Length; c++)
+            {
+                var v = At(5 + c, i);
+                if (v > bestCls) { bestCls = v; bestClass = c; }
+            }
+
+            var score = obj * bestCls;
+            if (score < m_ConfidenceThreshold)
+                continue;
+
+            float cx = At(0, i), cy = At(1, i), w = At(2, i), h = At(3, i);
+            var x1 = Mathf.Clamp(cx - w * 0.5f, 0f, m_InputSize);
+            var y1 = Mathf.Clamp(cy - h * 0.5f, 0f, m_InputSize);
+            var x2 = Mathf.Clamp(cx + w * 0.5f, 0f, m_InputSize);
+            var y2 = Mathf.Clamp(cy + h * 0.5f, 0f, m_InputSize);
+            if (x2 - x1 < 1f || y2 - y1 < 1f)
+                continue;
+
+            dets.Add(new Detection
+            {
+                ClassId = bestClass,
+                ClassName = labels[bestClass],
+                Confidence = score,
+                BoxXyxy = new Rect(x1, y1, x2 - x1, y2 - y1),
+            });
+        }
+
+        return NonMaxSuppression(dets, NmsIouThreshold);
+    }
+
+    static bool TryResolveLayout(Tensor<float> t, int targetDim, out int valueAxis, out int candidateAxis)
+    {
+        valueAxis = -1;
+        candidateAxis = -1;
+        var shape = t.shape;
+        if (shape.rank < 2)
+            return false;
+
+        for (var ax = 0; ax < shape.rank; ax++)
+        {
+            if (shape[ax] == targetDim) { valueAxis = ax; break; }
+        }
+        if (valueAxis < 0)
+            return false;
+
+        var maxDim = -1;
+        for (var ax = 0; ax < shape.rank; ax++)
+        {
+            if (ax == valueAxis) continue;
+            var d = shape[ax];
+            if (d <= 1) continue;
+            if (d > maxDim) { maxDim = d; candidateAxis = ax; }
+        }
+        if (candidateAxis < 0)
+        {
+            for (var ax = 0; ax < shape.rank; ax++)
+                if (ax != valueAxis) { candidateAxis = ax; break; }
+        }
+        return candidateAxis >= 0;
+    }
+
+    static List<Detection> NonMaxSuppression(List<Detection> dets, float iouThreshold)
+    {
+        dets.Sort((x, y) => y.Confidence.CompareTo(x.Confidence));
+        var kept = new List<Detection>();
+        var removed = new bool[dets.Count];
+        for (var i = 0; i < dets.Count; i++)
+        {
+            if (removed[i]) continue;
+            kept.Add(dets[i]);
+            for (var j = i + 1; j < dets.Count; j++)
+            {
+                if (removed[j]) continue;
+                if (dets[i].ClassId == dets[j].ClassId && Iou(dets[i].BoxXyxy, dets[j].BoxXyxy) > iouThreshold)
+                    removed[j] = true;
+            }
+        }
+        return kept;
+    }
+
+    static float Iou(Rect a, Rect b)
+    {
+        var x1 = Mathf.Max(a.xMin, b.xMin);
+        var y1 = Mathf.Max(a.yMin, b.yMin);
+        var x2 = Mathf.Min(a.xMax, b.xMax);
+        var y2 = Mathf.Min(a.yMax, b.yMax);
+        var inter = Mathf.Max(0f, x2 - x1) * Mathf.Max(0f, y2 - y1);
+        var union = a.width * a.height + b.width * b.height - inter;
+        return union <= 0f ? 0f : inter / union;
+    }
+
+    public void Dispose()
+    {
+        DisposeResources();
+    }
+
+    void DisposeResources()
+    {
+        m_Worker?.Dispose();
+        m_Worker = null;
+    }
+}
+}

Runtime/YoloxDetector.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 2f82e46a779df4c52aa88078c23815fd

package.json

@@ -0,0 +1,22 @@
+{
+  "name": "com.sky.sentis.yolox",
+  "version": "0.1.0",
+  "displayName": "Sentis YOLOX Detector",
+  "description": "YOLOX object detection for the Unity Inference Engine (Sentis), FP16 (80 COCO classes).",
+  "unity": "6000.4",
+  "license": "Apache-2.0",
+  "documentationUrl": "https://github.com/skykim/OnDeviceAgent",
+  "author": {
+    "name": "Sky Kim"
+  },
+  "keywords": [
+    "unity",
+    "sentis",
+    "inference-engine",
+    "on-device",
+    "ai"
+  ],
+  "dependencies": {
+    "com.unity.ai.inference": "2.6.1"
+  }
+}

package.json.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 34dfed7a132ee42c881b051b66826faf
+PackageManifestImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: