shape.h

/********************************************************************
 * Copyright (C) 2015 Liangliang Nan <liangliang.nan@gmail.com>
 * https://3d.bk.tudelft.nl/liangliang/
 *
 * This file is part of Easy3D. If it is useful in your research/work,
 * I would be grateful if you show your appreciation by citing it:
 * ------------------------------------------------------------------
 *      Liangliang Nan.
 *      Easy3D: a lightweight, easy-to-use, and efficient C++ library
 *      for processing and rendering 3D data.
 *      Journal of Open Source Software, 6(64), 3255, 2021.
 * ------------------------------------------------------------------
 *
 * Easy3D is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License Version 3
 * as published by the Free Software Foundation.
 *
 * Easy3D is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 ********************************************************************/
 
#ifndef EASY3D_RENDERER_SHAPE_H
#define EASY3D_RENDERER_SHAPE_H
 
#include <vector>
 
#include <easy3d/core/types.h>
 
 
namespace easy3d {
 
    class LinesDrawable;

    namespace shape {

        // @{

        void draw_quad_wire(const Rect &rect, const vec4 &color, int width, int height, float depth);

        void draw_quad_filled(const Rect &rect, const vec4 &color, int width, int height, float depth);

        void draw_quad_filled(const Rect &rect, unsigned int texture, int width, int height, float depth);

        void draw_full_screen_quad(unsigned int texture, float depth);

        void draw_depth_texture(const Rect &rect, unsigned int texture, int width, int height, float depth);

        void draw_quad(unsigned int position_attrib, unsigned int texcoord_attrib, int x, int y, int w, int h, int vpw,
                       int vph, float depth);

        void draw_full_screen_quad(unsigned int position_attrib, unsigned int texcoord_attrib, float depth);

        void draw_polygon_wire(const Polygon2 &polygon, const vec4 &color, int width, int height, float depth);

        void draw_polygon_filled(const Polygon2 &polygon, const vec4 &color, int width, int height, float depth);

        void draw_sphere_big_circles(LinesDrawable *drawable, const mat4 &mvp, const mat4 &m, bool axes = true);

        void draw_box_wire(LinesDrawable *drawable, const mat4 &mvp, const mat4 &m, bool abstracted = false);
        // @}
 
 

        // @{

        void create_grid(int x_steps, int y_steps, std::vector<vec3> &points, float depth = 0.0f, float scale = 0.5f);

        void create_circle(int slices, std::vector<vec3> &points, std::vector<unsigned int> &indices);

        void create_box(std::vector<vec3> &points, std::vector<vec3> &colors, bool abstracted = false);
 

        void create_sphere(
                const vec3 &center, double radius, int slices, int stacks, const vec3 &color,
                std::vector<vec3> &points, std::vector<vec3> &normals, std::vector<vec3> &colors
        );

        void create_checker_sphere(
                const vec3 &center, double radius, int slices, int stacks, int checker_size,
                const vec3 &color1, const vec3 &color2,
                std::vector<vec3> &points, std::vector<vec3> &normals, std::vector<vec3> &colors
        );

        void create_cylinder(
                double radius, int slices, const vec3 &s, const vec3 &t, const vec3 &color,
                std::vector<vec3> &points, std::vector<vec3> &normals, std::vector<vec3> &colors
        );

        void create_cone(
                double radius, int slices, const vec3 &s, const vec3 &t, const vec3 &color,
                std::vector<vec3> &points, std::vector<vec3> &normals, std::vector<vec3> &colors
        );

        void create_torus(double major_radius, double minor_radius, int major_slices, int minor_slices,
                          std::vector<vec3> &points, std::vector<vec3> &normals
        );

        void create_camera(std::vector<vec3> &points, float width, float fov, float hw_ratio = 0.6f);

        void create_camera(std::vector<vec3> &points, std::vector<unsigned int> &indices, float width, float fov,
                           float hw_ratio = 0.6f);
        // @}
 
 
        // create an image plane (useful for rendering images in 3D using camera extrinsic parameters)
//        void create_image_plane(const easy3d::mat3 &R, const easy3d::vec3 &t) {
//            if (!image_plane_) {
//                image_plane_ = new TrianglesDrawable("image_plane");
//                image_plane_->set_visible(show_images_);
//                image_plane_->update_texcoord_buffer({vec2(0, 0), vec2(1, 0), vec2(1, 1), vec2(0, 1)});
//                image_plane_->update_index_buffer({0, 2, 1, 0, 3, 2});
//                add_drawable(image_plane_);
//
//                if (!texture_1_)
//                    texture_1_ = Texture::create(resource::directory() + "/data/image_1.png");
//
//                if (texture_1_) {
//                    image_plane_->set_texture(texture_1_);
//                    image_plane_->set_use_texture(true);
//                }
//            }
//
//            if (!view_frustum_) {
//                view_frustum_ = new LinesDrawable("view_frustum");
//                view_frustum_->set_visible(show_images_);
//                add_drawable(view_frustum_);
//            }
//
//            const float fov = camera()->fieldOfView();
//            const float hw_ratio = static_cast<float>(height()) / width();
//            const float halfWidth = camera()->sceneRadius() * 2;  // large enough to put the image plane behind the object
//            const float halfHeight = halfWidth * hw_ratio;
//            const float dist = halfHeight / std::tan(fov * 0.5);
//
//            // coordinates in camera frame
//            const vec3 c(0.0f, 0.0f, 0.0f);  // camera center
//            std::vector<vec3> corners = {
//                    vec3(-halfWidth, -halfHeight, -dist),
//                    vec3(halfWidth, -halfHeight, -dist),
//                    vec3(halfWidth, halfHeight, -dist),
//                    vec3(-halfWidth, halfHeight, -dist)
//            };
//
//            Box3 box = current_model()->bounding_box();
//            // convert to world coordinate system
//            for (auto &p : corners) {
//                p = camera()->worldCoordinatesOf(p);
//                box.grow(p);
//            }
//            box.grow(camera()->position());
//            camera()->setSceneBoundingBox(box);
//
//            image_plane_->update_vertex_buffer(corners);
//
//            corners.push_back(camera()->position());
//            view_frustum_->update_vertex_buffer(corners);
//            view_frustum_->update_index_buffer({0, 4, 1, 4, 2, 4, 3, 4});
//        }
 
    }
 
}
 
#endif  // EASY3D_RENDERER_SHAPE_H