nightshade 0.13.3

A cross-platform data-oriented game engine.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use crate::ecs::world::World;
use crate::mcp::McpResponse;

pub(crate) fn mcp_set_position(
    world: &mut World,
    request: crate::mcp::SetPositionRequest,
) -> Result<McpResponse, McpResponse> {
    let entity = super::resolve_entity(world, &request.name)?;

    let Some(transform) = world.core.get_local_transform_mut(entity) else {
        return Err(McpResponse::Error(format!(
            "Entity '{}' has no transform",
            request.name
        )));
    };

    transform.translation = nalgebra_glm::Vec3::new(
        request.position[0],
        request.position[1],
        request.position[2],
    );
    crate::ecs::transform::systems::mark_local_transform_dirty(world, entity);
    Ok(McpResponse::Success(format!(
        "Set position of '{}' to {:?}",
        request.name, request.position
    )))
}

pub(crate) fn mcp_set_rotation(
    world: &mut World,
    request: crate::mcp::SetRotationRequest,
) -> Result<McpResponse, McpResponse> {
    let entity = super::resolve_entity(world, &request.name)?;

    let Some(transform) = world.core.get_local_transform_mut(entity) else {
        return Err(McpResponse::Error(format!(
            "Entity '{}' has no transform",
            request.name
        )));
    };

    let qx = nalgebra_glm::quat_angle_axis(request.rotation[0], &nalgebra_glm::Vec3::x());
    let qy = nalgebra_glm::quat_angle_axis(request.rotation[1], &nalgebra_glm::Vec3::y());
    let qz = nalgebra_glm::quat_angle_axis(request.rotation[2], &nalgebra_glm::Vec3::z());
    transform.rotation = nalgebra_glm::quat_normalize(&(qz * qy * qx));
    crate::ecs::transform::systems::mark_local_transform_dirty(world, entity);
    Ok(McpResponse::Success(format!(
        "Set rotation of '{}' to {:?}",
        request.name, request.rotation
    )))
}

pub(crate) fn mcp_set_scale(
    world: &mut World,
    request: crate::mcp::SetScaleRequest,
) -> Result<McpResponse, McpResponse> {
    let entity = super::resolve_entity(world, &request.name)?;

    let Some(transform) = world.core.get_local_transform_mut(entity) else {
        return Err(McpResponse::Error(format!(
            "Entity '{}' has no transform",
            request.name
        )));
    };

    transform.scale = nalgebra_glm::Vec3::new(request.scale[0], request.scale[1], request.scale[2]);
    crate::ecs::transform::systems::mark_local_transform_dirty(world, entity);
    Ok(McpResponse::Success(format!(
        "Set scale of '{}' to {:?}",
        request.name, request.scale
    )))
}

pub(crate) fn mcp_set_parent(
    world: &mut World,
    request: crate::mcp::SetParentRequest,
) -> Result<McpResponse, McpResponse> {
    use crate::ecs::transform::components::Parent;

    let entity = super::resolve_entity(world, &request.name)?;

    let parent_entity = if let Some(ref pname) = request.parent {
        if pname.is_empty() {
            None
        } else {
            let Some(&parent) = world.resources.entity_names.get(pname) else {
                return Err(McpResponse::Error(format!(
                    "Parent entity '{}' not found",
                    pname
                )));
            };
            Some(parent)
        }
    } else {
        None
    };

    world.core.set_parent(entity, Parent(parent_entity));
    crate::ecs::transform::commands::mark_local_transform_dirty(world, entity);

    match request.parent {
        Some(ref pname) if !pname.is_empty() => Ok(McpResponse::Success(format!(
            "Set parent of '{}' to '{}'",
            request.name, pname
        ))),
        _ => Ok(McpResponse::Success(format!(
            "Unparented '{}'",
            request.name
        ))),
    }
}