Point2 projectPoint (Point3 &src, Matrix4 &viewMatrix, PointSolver2::Projector &projectionMatrix, Point3 &pointInCam)
{
	Point4 src4 (src.x(), src.y(), src.z(), 1);
	Point4 pcam = viewMatrix * src4;
	pointInCam = pcam.head(3);
	return projectionMatrix * pcam;
}
Esempio n. 2
0
void Hud::renderRadar(const float dt, sdlx::Surface &window, const std::vector<v3<int> > &specials, const std::vector<v3<int> > &flags, const sdlx::Rect &viewport) {
    if (!Map->loaded()) {
        _radar.free();
        _radar_bg.free();
        return;
    }

    if (_map_mode == MapNone || !_enable_radar)
        return;

    if (!_radar.isNull() && !_update_radar.tick(dt)) {
        const int x = window.get_width() - _radar.get_width(), y = _background->get_height();
        window.blit(_radar, x, y);
        return;
    }

    if (_radar_bg.isNull())
        generateRadarBG(viewport); //needed for destructable layers.

    v2<int> radar_size;

    if (_map_mode == MapSmall) {
        radar_size.x = math::min(window.get_width() / 8, _radar_bg.get_width());
        radar_size.y = math::min(window.get_height() / 8, _radar_bg.get_height());
    } else {
        radar_size.x = _radar_bg.get_width();
        radar_size.y = _radar_bg.get_height();
    }

    if (_radar.isNull()) {
        _radar.create_rgb(radar_size.x, radar_size.y, 32);
        _radar.display_format_alpha();
    }

    const int x = window.get_width() - _radar.get_width(), y = _background->get_height();
    v2<int> msize = Map->get_size();

    v2<int> radar_shift;
    if (_map_mode == MapSmall || Map->torus()) {
        radar_shift.x = viewport.x + viewport.w / 2 - msize.x / 2 - msize.x * (_radar.get_width() - _radar_bg.get_width()) / 2 / _radar_bg.get_width();
        radar_shift.y = viewport.y + viewport.h / 2 - msize.y / 2 - msize.y * (_radar.get_height() - _radar_bg.get_height()) / 2 / _radar_bg.get_height();
        Map->validate(radar_shift);
    }

    if (Map->torus()) {
        /* 2x2 split
        [12]
        [34]
        */
        v2<int> split = radar_shift;
        //LOG_DEBUG(("split: %d %d %d %d", split.x, split.y, viewport.x, viewport.y));
        split *= v2<int>(_radar_bg.get_width(), _radar_bg.get_height());
        split /= msize;
        //int split_x = (viewport.w - viewport.x) * _radar_bg.get_width() / msize.x, split_y = (viewport.h - viewport.y) * _radar_bg.get_width() / msize.x;

        _radar.fill(_radar.map_rgba(0,0,0,255));
        sdlx::Rect src1(split.x - _radar_bg.get_width(), split.y - _radar_bg.get_height(), _radar_bg.get_width(), _radar_bg.get_height());
        sdlx::Rect src2(split.x, split.y - _radar_bg.get_height(), _radar_bg.get_width(), _radar_bg.get_height());
        sdlx::Rect src3(split.x - _radar_bg.get_width(), split.y, _radar_bg.get_width(), _radar_bg.get_height());
        sdlx::Rect src4(split.x, split.y, _radar_bg.get_width(), _radar_bg.get_height());
        _radar.blit(_radar_bg, src1, 0, 0);
        _radar.blit(_radar_bg, src2, 0, 0);
        _radar.blit(_radar_bg, src3, 0, 0);
        _radar.blit(_radar_bg, src4, 0, 0);
    } else {
        if (radar_shift.x < 0)
            radar_shift.x = 0;
        if (radar_shift.y < 0)
            radar_shift.y = 0;
        v2<int> radar_map_size = radar_size * msize / v2<int>(_radar_bg.get_width(), _radar_bg.get_height());

        if (radar_shift.x + radar_map_size.x > msize.x)
            radar_shift.x = msize.x - radar_map_size.x;

        if (radar_shift.y + radar_map_size.y > msize.y)
            radar_shift.y = msize.y - radar_map_size.y;

        v2<int> shift = radar_shift * v2<int>(_radar_bg.get_width(), _radar_bg.get_height()) / msize;
        sdlx::Rect src(shift.x, shift.y, _radar.get_width(), _radar.get_height());
        _radar.blit(_radar_bg, src, 0, 0);
    }

    //LOG_DEBUG(("radar shift: %d %d", radar_shift.x, radar_shift.y));

    _radar.lock();

    size_t n = PlayerManager->get_slots_count();
    for(size_t i = 0; i < n; ++i) {
        PlayerSlot &slot = PlayerManager->get_slot(i);
        const Object *obj = slot.getObject();
        if (obj == NULL)
            continue;

        v2<int> pos;
        obj->get_center_position(pos);
        pos -= radar_shift;
        Map->validate(pos);

        _radar.put_pixel(pos.x * _radar_bg.get_width() / msize.x, pos.y * _radar_bg.get_height() / msize.y, index2color(_radar, i + 1, 255));
        _radar.put_pixel(pos.x * _radar_bg.get_width() / msize.x, pos.y * _radar_bg.get_height() / msize.y + 1, index2color(_radar, i + 1, 200));
        _radar.put_pixel(pos.x * _radar_bg.get_width() / msize.x, pos.y * _radar_bg.get_height() / msize.y - 1, index2color(_radar, i + 1, 200));
        _radar.put_pixel(pos.x * _radar_bg.get_width() / msize.x + 1, pos.y * _radar_bg.get_height() / msize.y, index2color(_radar, i + 1, 200));
        _radar.put_pixel(pos.x * _radar_bg.get_width() / msize.x - 1, pos.y * _radar_bg.get_height() / msize.y, index2color(_radar, i + 1, 200));
    }

    static bool blink;

    blink = !blink;
    if (blink) {
        //format me
        n = specials.size();
        for(size_t i = 0; i < n; ++i) {
            v3<int> pos = specials[i];
            {
                v2<int> p(pos.x, pos.y);
                p -= radar_shift;
                Map->validate(p);
                pos.x = p.x;
                pos.y = p.y;
            }

            Uint32 color[2];
            color[0] = index2color(_radar, i + 1, 255);
            color[1] = index2color(_radar, i + 1, 200);
            for(int b = 0; b < 2; ++b) {
                _radar.put_pixel(b + pos.x * _radar_bg.get_width() / msize.x, pos.y * _radar_bg.get_height() / msize.y, color[b]);
                for(int l = 1; l <= 2; ++l) {
                    _radar.put_pixel(b + pos.x * _radar_bg.get_width() / msize.x + l, pos.y * _radar_bg.get_height() / msize.y + l, color[b]);
                    _radar.put_pixel(b + pos.x * _radar_bg.get_width() / msize.x - l, pos.y * _radar_bg.get_height() / msize.y - l, color[b]);
                    _radar.put_pixel(b + pos.x * _radar_bg.get_width() / msize.x + l, pos.y * _radar_bg.get_height() / msize.y - l, color[b]);
                    _radar.put_pixel(b + pos.x * _radar_bg.get_width() / msize.x - l, pos.y * _radar_bg.get_height() / msize.y + l, color[b]);
                }
            }
        }


        n = flags.size();
        if (n > 2)
            n = 2;

        for(size_t i = 0; i < n; ++i) {
            v3<int> pos = flags[i];
            {
                v2<int> p(pos.x, pos.y);
                p -= radar_shift;
                Map->validate(p);
                pos.x = p.x;
                pos.y = p.y;
            }

            Uint32 color[2] = { _radar.map_rgb(255, 0, 0), _radar.map_rgb(0, 255, 0), };
            _radar.put_pixel(0 + pos.x * _radar_bg.get_width() / msize.x, 0 + pos.y * _radar_bg.get_height() / msize.y, color[i]);
            _radar.put_pixel(1 + pos.x * _radar_bg.get_width() / msize.x, 0 + pos.y * _radar_bg.get_height() / msize.y, color[i]);
            _radar.put_pixel(2 + pos.x * _radar_bg.get_width() / msize.x, 0 + pos.y * _radar_bg.get_height() / msize.y, color[i]);
            _radar.put_pixel(0 + pos.x * _radar_bg.get_width() / msize.x, 1 + pos.y * _radar_bg.get_height() / msize.y, color[i]);
            _radar.put_pixel(1 + pos.x * _radar_bg.get_width() / msize.x, 1 + pos.y * _radar_bg.get_height() / msize.y, color[i]);
            _radar.put_pixel(0 + pos.x * _radar_bg.get_width() / msize.x, 2 + pos.y * _radar_bg.get_height() / msize.y, color[i]);
            _radar.put_pixel(1 + pos.x * _radar_bg.get_width() / msize.x, 2 + pos.y * _radar_bg.get_height() / msize.y, color[i]);
            _radar.put_pixel(2 + pos.x * _radar_bg.get_width() / msize.x, 2 + pos.y * _radar_bg.get_height() / msize.y, color[i]);
            _radar.put_pixel(0 + pos.x * _radar_bg.get_width() / msize.x, 3 + pos.y * _radar_bg.get_height() / msize.y, color[i]);
        }

    } //blink

    _radar.unlock();

    window.blit(_radar, x, y);
}