SDL圆周程序跨0/360度边界的角度最短旋转方向计算问题

这是一个简单的SDL程序，实现单个像素/点实体绕圆心做圆周旋转，之后沿对应朝向移动的效果。

当前无法正确计算两个角度值之间的最短旋转距离，尤其当角度跨越360度/0度边界时，计算结果不符合预期。

实现可兼容跨360度边界场景的计算逻辑，准确判断从起始角度到目标角度的最短旋转路径为顺时针（Clockwise）还是逆时针（Counter Clockwise）。

程序运行展示 #

待实现逻辑参考场景 #

主逻辑 #

void draw ( )
{
    /* - - - - - - - - - - - - - - - - - Init - - - - - - - - - - - - - - - - - */
    
    SDL_Event sdl_event;

    WALKER walker;
    
    walker = { POINT { WINDOW_WIDTH / 2, WINDOW_HEIGHT / 2 } };    // Entity in center

    /* - - - - - - - - - - - - - - - - - Init - - - - - - - - - - - - - - - - - */
    
    int degree = 0;
    
    walker.rotation.set ( degree, generate_random ( 0, 360 ) );
    
    while ( run_loop )     // Display Animation
    {
        set_render_draw_colors ( );
        
        SDL_RenderDrawPoint ( renderer, walker.origin.x, walker.origin.y );     // Draw: entity dot

        POINT point = walker.rotate ( degree );     // Create: pivot point & rotate per degree

        SDL_RenderDrawLine ( renderer, walker.origin.x, walker.origin.y, point.x, point.y );     // Draw: sightline with acquired orientation

        SDL_RenderPresent ( renderer );

        degree++;

        degree = ( degree > 359 ) ? 0 : degree;

        if ( degree == walker.rotation.destination )
            walker.rotation.set( walker.rotation.destination, generate_random ( 0, 360 ) );
        
        while ( SDL_PollEvent ( &sdl_event )  )
        {
            if ( sdl_event.type == SDL_QUIT )
                run_loop = false;
            else
                break;
        }
    }
}

Walker结构体 #

struct WALKER
{
    POINT origin     = { 0, 0 };
    POINT point      = { 0, 0 };

    ROTATION rotation;
    
    int point_length = 35;
    
    time_t time_seed;
    
    // Constructors ......................................................... //
    
    WALKER ( POINT origin, POINT point )
    {
        this->origin = origin;
        this->point  = point;
    }
    
    // Constructors (Generic) ... //
    
    WALKER ( )  { };

    ~WALKER ( ) { };

    // Functions ............................................................ //

    double convertToRadian ( int degree )
    {
        return ( degree * PI / 180 );
    }

    int convertToDegree ( float radian )
    {
        return ( radian * 180 ) / PI;
    }
    
    POINT rotate ( int degree )
    {
        POINT point    = { this->origin.x + this->point_length, this->origin.y };
        
        double radians = convertToRadian ( degree );
        
        double sine    = sin ( radians );
        double cosine  = cos ( radians );

        point.x       -= this->origin.x;     // translate point back to origin
        point.y       -= this->origin.y;

        double x_new  = point.x * cosine - point.y * sine;     // rotate point
        double y_new  = point.x * sine   - point.y * cosine;
        
        point.x       = x_new + this->origin.x;     // translate point back
        point.y       = y_new + this->origin.y;
        
        return point;
    }
};

问题根因 #

现有代码固定每帧对角度执行+1操作，始终沿顺时针方向旋转，未做跨0/360度边界的最短路径判断，遇到大角度差跨边界场景时会绕行长路径。

核心计算规则 #

要兼容跨边界的最短旋转方向判断，只需将两个角度的差值规整到[-180, 180)区间即可：

• 先计算顺时针方向总差值：diff = (目标角度 - 当前角度 + 360) % 360，结果范围为0~359
• 若diff > 180：逆时针旋转路径更短，每帧角度-1
• 若diff ≤ 180：顺时针旋转路径更短，每帧角度+1

代码修改 #

1. 补全缺失的ROTATION结构体，新增方向判断方法：

struct ROTATION
{
    int current;
    int destination;

    void set(int start, int target)
    {
        current = start;
        destination = target;
    }

    int get_step()
    {
        int diff = (destination - current + 360) % 360;
        return diff > 180 ? -1 : 1;
    }
};

2. 修改主循环内的角度更新逻辑，替换原有固定degree++和边界判断的代码：

// 替换原有的 degree++ 和 degree = ( degree > 359 ) ? 0 : degree; 两行
int step = walker.rotation.get_step();
degree = (degree + step + 360) % 360;

修改后所有参考场景均可正确判断方向：

• 0°→45°：顺时针，符合预期
• 313°→225°：逆时针，符合预期
• 350°→10°：顺时针，符合预期

内容的提问来源于stack exchange，提问作者Justin Byrne