导出数据转spine

2026-09-07 21:29:15 +08:00
parent d258d4f435
commit 3a7c0b4092
65 changed files with 6000 additions and 0 deletions
@@ -0,0 +1,305 @@
+#include "RuntimeApi.h"
+
+#include <spine/Animation.h>
+#include <spine/AnimationState.h>
+#include <spine/AnimationStateData.h>
+#include <spine/Atlas.h>
+#include <spine/ClippingAttachment.h>
+#include <spine/Extension.h>
+#include <spine/MeshAttachment.h>
+#include <spine/RegionAttachment.h>
+#include <spine/Skeleton.h>
+#include <spine/SkeletonBinary.h>
+#include <spine/SkeletonClipping.h>
+#include <spine/SkeletonData.h>
+#include <spine/SkeletonJson.h>
+#include <spine/Skin.h>
+#include <spine/Slot.h>
+#include <spine/SlotData.h>
+#include <spine/TextureLoader.h>
+
+#include <algorithm>
+#include <cctype>
+#include <cstddef>
+#include <memory>
+#include <string>
+#include <vector>
+
+#ifndef DTS_SPINE_LINE
+#error DTS_SPINE_LINE must be defined before including LegacyRuntimeAdapter.inl
+#endif
+
+namespace {
+struct TextureRecord { std::string path; };
+class MetadataTextureLoader final : public spine::TextureLoader {
+public:
+    void load(spine::AtlasPage& page, const spine::String& path) override {
+#if defined(DTS_SPINE_41)
+        page.texture = new TextureRecord{path.buffer()};
+#else
+        page.setRendererObject(new TextureRecord{path.buffer()});
+#endif
+    }
+    void unload(void* texture) override { delete static_cast<TextureRecord*>(texture); }
+};
+struct RenderBatch {
+    std::vector<DtsRenderVertex> vertices;
+    std::vector<std::uint16_t> indices;
+    std::string texturePath;
+    std::uint32_t blendMode = 0;
+};
+struct RuntimeContext {
+    MetadataTextureLoader textureLoader;
+    std::unique_ptr<spine::Atlas> atlas;
+    std::unique_ptr<spine::SkeletonData> skeletonData;
+    std::unique_ptr<spine::Skeleton> skeleton;
+    std::unique_ptr<spine::AnimationStateData> animationStateData;
+    std::unique_ptr<spine::AnimationState> animationState;
+    spine::SkeletonClipping clipper;
+    std::vector<std::string> animationNames;
+    std::vector<float> animationDurations;
+    std::vector<std::string> skinNames;
+    std::vector<RenderBatch> renderBatches;
+    std::string error;
+};
+RuntimeContext* context(DtsRuntimeHandle handle) { return static_cast<RuntimeContext*>(handle); }
+std::string lowercaseExtension(const std::string& path) {
+    const auto dot = path.find_last_of('.');
+    auto extension = dot == std::string::npos ? std::string{} : path.substr(dot);
+    std::transform(extension.begin(), extension.end(), extension.begin(),
+        [](unsigned char value) { return static_cast<char>(std::tolower(value)); });
+    return extension;
+}
+void collectMetadata(RuntimeContext& value) {
+    value.animationNames.clear();
+    value.animationDurations.clear();
+    auto& animations = value.skeletonData->getAnimations();
+    for (std::size_t index = 0; index < animations.size(); ++index) {
+        value.animationNames.emplace_back(animations[index]->getName().buffer());
+        value.animationDurations.push_back(animations[index]->getDuration());
+    }
+    value.skinNames.clear();
+    auto& skins = value.skeletonData->getSkins();
+    for (std::size_t index = 0; index < skins.size(); ++index)
+        value.skinNames.emplace_back(skins[index]->getName().buffer());
+}
+spine::AtlasRegion* regionFor(spine::RegionAttachment& attachment) {
+#if defined(DTS_SPINE_41)
+    return static_cast<spine::AtlasRegion*>(attachment.getRegion());
+#else
+    return static_cast<spine::AtlasRegion*>(attachment.getRendererObject());
+#endif
+}
+spine::AtlasRegion* regionFor(spine::MeshAttachment& attachment) {
+#if defined(DTS_SPINE_41)
+    return static_cast<spine::AtlasRegion*>(attachment.getRegion());
+#else
+    return static_cast<spine::AtlasRegion*>(attachment.getRendererObject());
+#endif
+}
+std::uint32_t packedColor(spine::Skeleton& skeleton, spine::Slot& slot,
+    spine::Color& attachment) {
+    const auto component = [](float value) {
+        return static_cast<std::uint32_t>(std::clamp(value, 0.0F, 1.0F) * 255.0F);
+    };
+    const auto& skeletonColor = skeleton.getColor();
+    const auto& slotColor = slot.getColor();
+    const auto red = component(skeletonColor.r * slotColor.r * attachment.r);
+    const auto green = component(skeletonColor.g * slotColor.g * attachment.g);
+    const auto blue = component(skeletonColor.b * slotColor.b * attachment.b);
+    const auto alpha = component(skeletonColor.a * slotColor.a * attachment.a);
+    return (alpha << 24) | (red << 16) | (green << 8) | blue;
+}
+void appendBatch(RuntimeContext& value, spine::Slot& slot, spine::Color& color,
+    spine::AtlasRegion* region, spine::Vector<float>& positions,
+    spine::Vector<float>& uvs, spine::Vector<unsigned short>& indices) {
+    if (!region || !region->page) return;
+#if defined(DTS_SPINE_41)
+    auto* texture = static_cast<TextureRecord*>(region->page->texture);
+#else
+    auto* texture = static_cast<TextureRecord*>(region->page->getRendererObject());
+#endif
+    if (!texture) return;
+    auto* sourcePositions = &positions;
+    auto* sourceUvs = &uvs;
+    auto* sourceIndices = &indices;
+    if (value.clipper.isClipping()) {
+        value.clipper.clipTriangles(positions, indices, uvs, 2);
+        sourcePositions = &value.clipper.getClippedVertices();
+        sourceUvs = &value.clipper.getClippedUVs();
+        sourceIndices = &value.clipper.getClippedTriangles();
+    }
+    RenderBatch batch;
+    const auto vertexCount = sourcePositions->size() / 2;
+    batch.vertices.reserve(vertexCount);
+    const auto packed = packedColor(*value.skeleton, slot, color);
+    for (std::size_t index = 0; index < vertexCount; ++index)
+        batch.vertices.push_back({(*sourcePositions)[index * 2], -(*sourcePositions)[index * 2 + 1],
+            (*sourceUvs)[index * 2], (*sourceUvs)[index * 2 + 1], packed});
+    batch.indices.assign(sourceIndices->buffer(), sourceIndices->buffer() + sourceIndices->size());
+    batch.texturePath = texture->path;
+    batch.blendMode = static_cast<std::uint32_t>(slot.getData().getBlendMode());
+    value.renderBatches.push_back(std::move(batch));
+}
+void collectDrawCommands(RuntimeContext& value) {
+    value.renderBatches.clear();
+    spine::Vector<float> positions;
+    spine::Vector<unsigned short> quadIndices;
+    quadIndices.add(0); quadIndices.add(1); quadIndices.add(2);
+    quadIndices.add(2); quadIndices.add(3); quadIndices.add(0);
+    auto& drawOrder = value.skeleton->getDrawOrder();
+    for (std::size_t index = 0; index < drawOrder.size(); ++index) {
+        auto& slot = *drawOrder[index];
+        auto* attachment = slot.getAttachment();
+        if (!attachment) {
+            value.clipper.clipEnd(slot);
+            continue;
+        }
+        if (attachment->getRTTI().isExactly(spine::RegionAttachment::rtti)) {
+            auto& region = *static_cast<spine::RegionAttachment*>(attachment);
+            positions.setSize(8, 0);
+#if defined(DTS_SPINE_41)
+            region.computeWorldVertices(slot, positions, 0, 2);
+#else
+            region.computeWorldVertices(slot.getBone(), positions, 0, 2);
+#endif
+            appendBatch(value, slot, region.getColor(), regionFor(region),
+                positions, region.getUVs(), quadIndices);
+        } else if (attachment->getRTTI().isExactly(spine::MeshAttachment::rtti)) {
+            auto& mesh = *static_cast<spine::MeshAttachment*>(attachment);
+            positions.setSize(mesh.getWorldVerticesLength(), 0);
+            mesh.computeWorldVertices(slot, 0, mesh.getWorldVerticesLength(),
+                positions.buffer(), 0, 2);
+            appendBatch(value, slot, mesh.getColor(), regionFor(mesh),
+                positions, mesh.getUVs(), mesh.getTriangles());
+        } else if (attachment->getRTTI().isExactly(spine::ClippingAttachment::rtti)) {
+            value.clipper.clipStart(slot, static_cast<spine::ClippingAttachment*>(attachment));
+        }
+        value.clipper.clipEnd(slot);
+    }
+    value.clipper.clipEnd();
+}
+} // namespace
+
+namespace spine {
+SpineExtension* getDefaultExtension() { return new DefaultSpineExtension(); }
+} // namespace spine
+
+extern "C" {
+uint32_t dtsRuntimeGetApiVersion() { return DTS_RUNTIME_API_VERSION; }
+int32_t dtsRuntimeGetInfo(DtsRuntimeInfo* info) {
+    if (!info || info->structSize < sizeof(DtsRuntimeInfo)) return -1;
+    info->apiVersion = DTS_RUNTIME_API_VERSION;
+    info->spineVersionLine = DTS_SPINE_LINE;
+    info->adapterBuild = "preview-1";
+    info->capabilities = DTS_RUNTIME_CAP_SKELETON_METADATA | DTS_RUNTIME_CAP_DRAW_COMMANDS;
+    return 0;
+}
+DtsRuntimeHandle dtsRuntimeCreate() { return new RuntimeContext; }
+void dtsRuntimeDestroy(DtsRuntimeHandle handle) { delete context(handle); }
+int32_t dtsRuntimeLoad(DtsRuntimeHandle handle, const DtsLoadRequest* request) {
+    auto* value = context(handle);
+    if (!value || !request || request->structSize < sizeof(DtsLoadRequest)
+        || !request->skeletonPathUtf8 || !request->atlasPathUtf8) return -1;
+    value->error.clear();
+    value->renderBatches.clear();
+    value->animationState.reset();
+    value->animationStateData.reset();
+    value->skeleton.reset();
+    value->skeletonData.reset();
+    value->atlas.reset();
+    value->atlas = std::make_unique<spine::Atlas>(request->atlasPathUtf8, &value->textureLoader, true);
+    const float scale = request->scale > 0 ? request->scale : 1.0F;
+    if (lowercaseExtension(request->skeletonPathUtf8) == ".json") {
+        spine::SkeletonJson loader(value->atlas.get());
+        loader.setScale(scale);
+        value->skeletonData.reset(loader.readSkeletonDataFile(request->skeletonPathUtf8));
+        if (!value->skeletonData) value->error = loader.getError().buffer();
+    } else {
+        spine::SkeletonBinary loader(value->atlas.get());
+        loader.setScale(scale);
+        value->skeletonData.reset(loader.readSkeletonDataFile(request->skeletonPathUtf8));
+        if (!value->skeletonData) value->error = loader.getError().buffer();
+    }
+    if (!value->skeletonData) {
+        if (value->error.empty()) value->error = "Spine Runtime could not load skeleton data.";
+        return -2;
+    }
+    collectMetadata(*value);
+    value->skeleton = std::make_unique<spine::Skeleton>(value->skeletonData.get());
+    value->animationStateData = std::make_unique<spine::AnimationStateData>(value->skeletonData.get());
+    value->animationState = std::make_unique<spine::AnimationState>(value->animationStateData.get());
+    if (!value->animationNames.empty())
+        value->animationState->setAnimation(0, value->animationNames.front().c_str(), true);
+    value->animationState->apply(*value->skeleton);
+    value->skeleton->updateWorldTransform();
+    collectDrawCommands(*value);
+    return 0;
+}
+int32_t dtsRuntimeGetSkeletonInfo(DtsRuntimeHandle handle, DtsSkeletonInfo* info) {
+    auto* value = context(handle);
+    if (!value || !value->skeletonData || !info || info->structSize < sizeof(DtsSkeletonInfo)) return -1;
+    auto* data = value->skeletonData.get();
+    info->boneCount = static_cast<uint32_t>(data->getBones().size());
+    info->slotCount = static_cast<uint32_t>(data->getSlots().size());
+    info->skinCount = static_cast<uint32_t>(value->skinNames.size());
+    info->animationCount = static_cast<uint32_t>(value->animationNames.size());
+    info->eventCount = static_cast<uint32_t>(data->getEvents().size());
+    info->constraintCount = static_cast<uint32_t>(data->getIkConstraints().size()
+        + data->getTransformConstraints().size() + data->getPathConstraints().size());
+    return 0;
+}
+const char* dtsRuntimeGetAnimationName(DtsRuntimeHandle handle, uint32_t index) {
+    auto* value = context(handle);
+    return value && index < value->animationNames.size() ? value->animationNames[index].c_str() : nullptr;
+}
+float dtsRuntimeGetAnimationDuration(DtsRuntimeHandle handle, uint32_t index) {
+    auto* value = context(handle);
+    return value && index < value->animationDurations.size() ? value->animationDurations[index] : 0.0F;
+}
+const char* dtsRuntimeGetSkinName(DtsRuntimeHandle handle, uint32_t index) {
+    auto* value = context(handle);
+    return value && index < value->skinNames.size() ? value->skinNames[index].c_str() : nullptr;
+}
+const char* dtsRuntimeGetLastError(DtsRuntimeHandle handle) {
+    auto* value = context(handle);
+    return value ? value->error.c_str() : "Invalid runtime handle.";
+}
+int32_t dtsRuntimeSetAnimation(DtsRuntimeHandle handle, const char* name, int32_t loop) {
+    auto* value = context(handle);
+    if (!value || !value->animationState || !name) return -1;
+    if (!value->skeletonData->findAnimation(name)) {
+        value->error = "Animation was not found.";
+        return -2;
+    }
+    value->skeleton->setToSetupPose();
+    value->animationState->setAnimation(0, name, loop != 0);
+    return 0;
+}
+int32_t dtsRuntimeUpdate(DtsRuntimeHandle handle, float seconds) {
+    auto* value = context(handle);
+    if (!value || !value->animationState || !value->skeleton) return -1;
+    value->animationState->update(std::max(0.0F, seconds));
+    value->animationState->apply(*value->skeleton);
+    value->skeleton->updateWorldTransform();
+    collectDrawCommands(*value);
+    return 0;
+}
+uint32_t dtsRuntimeGetDrawCommandCount(DtsRuntimeHandle handle) {
+    auto* value = context(handle);
+    return value ? static_cast<uint32_t>(value->renderBatches.size()) : 0;
+}
+int32_t dtsRuntimeGetDrawCommand(DtsRuntimeHandle handle, uint32_t index, DtsDrawCommand* command) {
+    auto* value = context(handle);
+    if (!value || index >= value->renderBatches.size() || !command
+        || command->structSize < sizeof(DtsDrawCommand)) return -1;
+    const auto& batch = value->renderBatches[index];
+    command->vertices = batch.vertices.data();
+    command->vertexCount = static_cast<uint32_t>(batch.vertices.size());
+    command->indices = batch.indices.data();
+    command->indexCount = static_cast<uint32_t>(batch.indices.size());
+    command->texturePathUtf8 = batch.texturePath.c_str();
+    command->blendMode = batch.blendMode;
+    return 0;
+}
+} // extern "C"