GAMES101-Assignment8

最新推荐文章于 2024-07-05 15:13:30 发布
最新推荐文章于 2024-07-05 15:13:30 发布
阅读量921 收藏 19
点赞数 20
分类专栏： # GAMES101-Lab 文章标签： Lab 图形渲染
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39876147/article/details/135777973
版权
本文详细介绍了如何在C++中使用Rope类构建物理模拟的绳子，涉及构造函数实现、显式/半隐式欧拉法、显式Verlet算法以及加入阻尼的仿真过程。文章还指导读者安装必要的依赖并提供参考代码片段。
摘要由CSDN通过智能技术生成

一、总览

1.1 连接绳子的约束

在rope.cpp 中, 实现Rope 类的构造函数。这个构造函数应该可以创建一个
新的绳子(Rope) 对象，该对象从start 开始，end 结束，包含num_nodes 个节点。也就是如下图所示：
在这里插入图片描述

每个结点都有质量，称为质点；质点之间的线段是一个弹簧。通过创建一系列的质点和弹簧，你就可以创建一个像弹簧一样运动的物体。
pinned_nodes 设置结点的索引。这些索引对应结点的固定属性(pinned attribute)应该设置为真（他们是静止的）。对于每一个结点，你应该构造一个Mass对象，并在Mass对象的构造函数里设置质量和固定属性。（请仔细阅读代码，确定传递给构造函数的参数）。你应该在连续的两个结点之间创建一个弹簧，设置弹簧两端的结点索引和弹簧系数k，请检查构造函数的签名以确定传入的参数。
运行./ropesim。你应该可以看到屏幕上画出绳子，但它不发生运动。

1.2 显式/半隐式欧拉法

胡克定律表示弹簧连接的两个质点之间的力和他们之间的距离成比例。也就是：
在这里插入图片描述

在Rope::simulateEuler 中, 首先实现胡克定律。遍历所有的弹簧，对弹簧两端的质点施加正确的弹簧力。保证力的方向是正确的！对每个质点，累加所有的弹簧力。
一旦计算出所有的弹簧力，对每个质点应用物理定律：
在这里插入图片描述

运行./ropesim。仿真应该就开始运行了，但是只有3 个结点，看起来不够多。在application.cpp 文件的最上方，你应该可以看到欧拉绳子Verlet绳子的定义。改变两个绳子结点个数（默认为3个），比如16或者更多。
运行./ropesim -s 32 来设置仿真中每帧不同的仿真步数。尝试设置较小的
值和较大的值（默认值为64）。

1.3 显式Verlet

Verlet 是另一种精确求解所有约束的方法。这种方法的优点是只处理仿真中
顶点的位置并且保证四阶精度。和欧拉法不同，Verlet 积分按如下的方式来更新下一步位置：
在这里插入图片描述

除此之外，我们可以仿真弹簧系数无限大的弹簧。不用再考虑弹簧力，而是用解约束的方法来更新质点位置：只要简单的移动每个质点的位置使得弹簧的长度保持原长。修正向量应该和两个质点之间的位移成比例，方向为一个质点指向另一质点。每个质点应该移动位移的一半。
只要对每个弹簧执行这样的操作，我们就可以得到稳定的仿真。为了使运动更加平滑，每一帧可能需要更多的仿真次数。

1.4 阻尼

向显示Verlet方法积分的胡克定律中加入阻尼。现实中的弹簧不会永远跳动，因为动能会因摩擦而减小。阻尼系数设置为0.00005, 加入阻尼之后质点位置更新如下：
在这里插入图片描述

应该修改的函数是:

  • rope.cpp 中的Rope::rope(…)
  • rope.cpp 中的void Rope::simulateEuler(…)
  • rope.cpp 中的void Rope::simulateVerlet(…)

二、安装依赖

$ sudo apt install libglu1-mesa-dev freeglut3-dev mesa-common-dev
$ sudo apt install xorg-dev

三、参考答案

3.1 rope.cpp中的Rope::rope(…)

实现1.1 连接绳子的约束

    Rope::Rope(Vector2D start, Vector2D end, int num_nodes, float node_mass, float k, vector<int> pinned_nodes)
    {
        // TODO (Part 1): Create a rope starting at `start`, ending at `end`, and containing `num_nodes` nodes.
        for(int i = 0; i < num_nodes; i++){// 创建质点
            Vector2D pos = start + (end - start) * (double(i) / double(num_nodes));
            masses.push_back(new Mass(pos, node_mass, false));
        }
        for(int i = 0; i < num_nodes - 1; i++){// 创建弹簧
            springs.push_back(new Spring(masses[i], masses[i + 1], k));
        }
//        Comment-in this part when you implement the constructor
       for (auto &i : pinned_nodes) {
           masses[i]->pinned = true;
       }
    }

3.2 rope.cpp 中的void Rope::simulateEuler(…)

实现1.2 显式/半隐式欧拉法

  • 胡克定律
    在这里插入图片描述
    for (auto &s : springs)
    {
        // TODO (Part 2): Use Hooke's law to calculate the force on a node
        auto len = (s->m1->position - s->m2->position).norm();
        s->m1->forces += -s->k * (s->m1->position - s->m2->position) / len * (len - s->rest_length);
        s->m2->forces += -s->k * (s->m2->position - s->m1->position) / len * (len - s->rest_length);
    }
  • 显式/隐式欧拉法
    在这里插入图片描述
    if (!m->pinned)
    {
        // TODO (Part 2): Add the force due to gravity, then compute the new velocity and position
        // 显式欧拉法：下一个时刻位置用当前速度计算
        auto a = m->forces / m->mass + gravity;
        m->position += m->velocity * delta_t;//根据当前速度更新位置
        m->velocity += a * delta_t;//更新下一时刻速度
        
        // 隐式欧拉法：下一个时刻位置用下一时刻速度计算
        // auto a = m->forces / m->mass + gravity;
        // m->velocity += a * delta_t;//更新速度
        // m->position += m->velocity * delta_t;//根据下一时刻速度更新位置 

        // TODO (Part 2): Add global damping
    }
  • 完整代码
    void Rope::simulateEuler(float delta_t, Vector2D gravity)
    {
        for (auto &s : springs)
        {
            // TODO (Part 2): Use Hooke's law to calculate the force on a node
            auto len = (s->m1->position - s->m2->position).norm();
            s->m1->forces += -s->k * (s->m1->position - s->m2->position) / len * (len - s->rest_length);
            s->m2->forces += -s->k * (s->m2->position - s->m1->position) / len * (len - s->rest_length);
        }

        for (auto &m : masses)
        {
            if (!m->pinned)
            {
                // TODO (Part 2): Add the force due to gravity, then compute the new velocity and position
                // 显式欧拉法：下一个时刻位置用当前速度计算
                auto a = m->forces / m->mass + gravity;
                m->position += m->velocity * delta_t;//根据当前速度更新位置
                m->velocity += a * delta_t;//更新下一时刻速度
                
                // 隐式欧拉法：下一个时刻位置用下一时刻速度计算
                // auto a = m->forces / m->mass + gravity;
                // m->velocity += a * delta_t;//更新速度
                // m->position += m->velocity * delta_t;//根据下一时刻速度更新位置 

                // TODO (Part 2): Add global damping
            }

            // Reset all forces on each mass
            m->forces = Vector2D(0, 0);
        }
    }

3.3 rope.cpp 中的void Rope::simulateVerlet(…)

实现1.3 显式Verlet

  • 显式Verlet
    在这里插入图片描述
    void Rope::simulateVerlet(float delta_t, Vector2D gravity)
    {
        for (auto &s : springs)
        {
            // TODO (Part 3): Simulate one timestep of the rope using explicit Verlet （solving constraints)
            auto len = (s->m1->position - s->m2->position).norm();
            s->m1->forces += -s->k * (s->m1->position - s->m2->position) / len * (len - s->rest_length);
            s->m2->forces += -s->k * (s->m2->position - s->m1->position) / len * (len - s->rest_length);
        }

        for (auto &m : masses)
        {
            if (!m->pinned)
            {
                Vector2D temp_position = m->position;
                // TODO (Part 3.1): Set the new position of the rope mass
                auto a = m->forces / m->mass + gravity;
                m->position = temp_position + (temp_position - m->last_position) + a * delta_t * delta_t;
                m->last_position = temp_position;

                // TODO (Part 4): Add global Verlet damping
            }
            m->forces = Vector2D(0, 0);
        }
    }

3.4 增加阻尼

  • rope.cpp 中的void Rope::simulateVerlet(…)
    向显示Verlet方法积分的胡克定律中加入阻尼。现实中的弹簧不会永远跳动，因为动能会因摩擦而减小。阻尼系数设置为0.00005, 加入阻尼之后质点位置更新如下：
    在这里插入图片描述
    void Rope::simulateVerlet(float delta_t, Vector2D gravity)
    {
        for (auto &s : springs)
        {
            // TODO (Part 3): Simulate one timestep of the rope using explicit Verlet （solving constraints)
            auto len = (s->m1->position - s->m2->position).norm();
            s->m1->forces += -s->k * (s->m1->position - s->m2->position) / len * (len - s->rest_length);
            s->m2->forces += -s->k * (s->m2->position - s->m1->position) / len * (len - s->rest_length);
        }

        for (auto &m : masses)
        {
            if (!m->pinned)
            {
                Vector2D temp_position = m->position;
                // TODO (Part 3.1): Set the new position of the rope mass
                auto a = m->forces / m->mass + gravity;
                //m->position = temp_position + (temp_position - m->last_position) + a * delta_t * delta_t;
                //m->last_position = temp_position;

                // TODO (Part 4): Add global Verlet damping
                double damping_factor = 0.00005;
                m->position = temp_position + (1 - damping_factor) * (temp_position - m->last_position) + a * delta_t * delta_t;
                m->last_position = temp_position;
            }
            m->forces = Vector2D(0, 0);
        }
    }
  • rope.cpp 中的void Rope::simulateEuler(…)
    向欧拉方法中加入阻尼，直接使用−kdv作为阻尼，而不是相对速度
    void Rope::simulateEuler(float delta_t, Vector2D gravity)
    {
        for (auto &s : springs)
        {
            // TODO (Part 2): Use Hooke's law to calculate the force on a node
            auto len = (s->m1->position - s->m2->position).norm();
            s->m1->forces += -s->k * (s->m1->position - s->m2->position) / len * (len - s->rest_length);
            s->m2->forces += -s->k * (s->m2->position - s->m1->position) / len * (len - s->rest_length);
        }

        for (auto &m : masses)
        {
            if (!m->pinned)
            {
                // TODO (Part 2): Add the force due to gravity, then compute the new velocity and position
                // 显式欧拉法：下一个时刻位置用当前速度计算
                // auto a = m->forces / m->mass + gravity;
                // m->position += m->velocity * delta_t;//根据当前速度更新位置
                // m->velocity += a * delta_t;//更新下一时刻速度
                
                // 隐式欧拉法：下一个时刻位置用下一时刻速度计算
                // auto a = m->forces / m->mass + gravity;
                // m->velocity += a * delta_t;//更新速度
                // m->position += m->velocity * delta_t;//根据下一时刻速度更新位置 

                // TODO (Part 2): Add global damping
                float kd = 0.005;
                auto a = m->forces / m->mass + gravity - kd * m->velocity / m->mass;
                m->velocity += a * delta_t; 
                m->position += m->velocity * delta_t; //隐式欧拉法
            }

            // Reset all forces on each mass
            m->forces = Vector2D(0, 0);
        }
    }

四、编译

$ mkdir build
$ cd build
$ cmake ..
$ make

通过查看rope.cpp中的Rope::rope(…)的引用，可以定位到application.cpp文件，

// Create two ropes 
// 通过修改构造函数的第三个参数指定质点个数(默认三个质点，这里改成了10个)
ropeEuler = new Rope(Vector2D(0, 200), Vector2D(-400, 200), 10, config.mass,
                    config.ks, {0});
ropeVerlet = new Rope(Vector2D(0, 200), Vector2D(-400, 200), 10, config.mass,
                    config.ks, {0});

附件

作业7压缩包

Luqwera
关注
  • 20
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
GAMES101-ASSIGNMENT8（作业8）
dx1313113的博客
09-18 541
你应该在连续的两个结点之间创建一个弹簧，设置弹簧两端的结点索引和弹簧系数 k，请检查构造函数的签名以确定传入的参数。不用再考虑弹簧力，而是用解约束的方法来更新质点位置：只要简单的移动每个质点的位置使得弹簧的长度保持原长。在application.cpp 文件的最上方，你应该可以看到欧拉绳子和 Verlet 绳子的定义。遍历所有的弹簧，对弹簧两端的质点施加正确的弹簧力。通过创建一系列的质点和弹簧，你就可以创建一个像弹簧一样运动的物体。胡克定律表示弹簧连接的两个质点之间的力和他们之间的距离成比例。
GAMES101:作业7
qq_41765657的博客
12-15 5295
做出来图片有横条的原因在这里：这个数字不能过于接近0。 由于本人电脑虚拟机不太稳定，日常闪退，因此我渲染了474秒，取SPP=30，结果如下： 可以看到，不到七分钟的渲染结果还是非常不错的 并且注意检查 t_enter = t_exit 的时候的判断是否正确。 这句提示其实非常关键！老师上课的时候经常提到，图形学很少关心相等的时候的条件，但是这里确实会影响到输出的结果。假如 t_enter = t_exit 时返回的是false，那么作业6并不会出任何问题，但作业7中会导致只能渲染出左侧的盒子和墙体。因此，
GAMES101-Assignment3
一个搬运知识的笨小孩
02-11 734
简要实现shading
GAMES101-Assignment1
一个搬运知识的笨小孩
01-15 461
MVP变换的简要实现
GAMES101-Computer-Graphics-Assignment
03-29
开始学习时间：2021-03-21
games50-assignment-2020-x-1
04-27
【标题】"games50-assignment-2020-x-1" 是一个与游戏开发相关的项目或课程作业，可能是2020年某个阶段的游戏设计课程中的第X部分。这个项目的重点可能在于使用Lua语言进行编程，因此，我们可以深入探讨Lua在游戏...
GAMES101-作业0-8框架+大作业参考资料.rar
07-02
【标题】"GAMES101-作业0-8框架+大作业参考资料.rar" 提供的是一个关于游戏编程的学习资源，特别关注了图形学和C++编程语言的应用。这个压缩包可能包含了完成从作业0到8一系列课程项目所需的框架代码、指导文档、...
Assignment1_games101作业1_games101作业7_C++_games101作业_
10-03
在本作业中，我们关注的是GAMES101课程中的第一份作业，它涉及到了图形学中的一个重要概念——投影矩阵。GAMES101通常是一门计算机图形学的基础课程，涵盖了游戏开发和3D图形渲染的基本原理。在这个作业中，学生被...
Wagr-Assignment:回购以容纳Wagr给的带回家作业
03-29
wagr-assignment作者：史蒂文·安德鲁斯此存储库包含Wagr提供的带回家作业。 随着功能的进步，将会有更多信息。快取该项目缓存由Games API检索到的游戏信息，以允许用户查看离线或连接不良的即将到来的游戏。
图形渲染基础-Unity渲染管线介绍
Hanson的博客
07-05 970
Unity渲染管线介绍
数据分析的核心技能和方法
07-19
数据分析的核心技能和方法
毕业设计javajsp人寿保险销售网站(ssh)-qkrp源码含文档工具包
07-19
毕业设计javajsp人寿保险销售网站(ssh)-qkrp源码含文档工具包 后台是ssh框架，页面是jsp，数据库mysql，jdk1.8，开发工具用ecplise、myecplise、sts、idea都可以 平湖人寿保险公司保险销售网站分为用户和管理员两个部分 前台部分（用户界面）： 1、资讯浏览功能： （1）新闻资讯浏览 （2）新闻资讯查询 （3）公司简介 （4）通知公告 2、用户登录注册功能： （1）注册 （2）登录 3、用户管理功能 （1）个人信息管理 （2）订单管理 4、保险购买功能： （1）保险产品浏览 （2）保险产品查询 （3）保险产品购买 后台管理（管理员界面） 1、管理员登录功能： 管理员在管理员登录界面输入用户名和密码，即可登录管理员的界面。 2、资讯管理功能： （1）新闻资讯管理 （2）公司简介管理 （3）通知公告管理 3、保险产品管理： （1）保险产品信息管理 （2）保险产品查询 4、会员管理： （1）会员删除 （2）会员级别管理 5、统计管理： （1）保险产品销售量统计 （2）有效会员数量统计 包含：源码、数据库脚本、论文、环境工具包、相同框架项目的安装教程
毕业设计javajsp公共课考试系统(ssh)-qlkrp源码工具包
07-19
毕业设计javajsp公共课考试系统(ssh)-qlkrp源码工具包 后台是ssh框架，页面是jsp，数据库mysql，jdk1.8，开发工具用ecplise、myecplise、sts、idea都可以 题库 试卷信息管理 阅卷 统计功能 包含：源码、数据库脚本、环境工具包、相同框架项目的安装教程（在说明文档中）
揭秘黑箱：YOLO预测结果的可解释性探究
07-19
YOLO（You Only Look Once）是一种流行的实时对象检测系统，最初由 Joseph Redmon 等人在 2015 年提出。它的核心思想是将对象检测任务视为一个回归问题，直接从图像像素到边界框坐标和类别概率的映射。YOLO 以其快速和高效而闻名，特别适合需要实时处理的应用场景。 以下是 YOLO 的一些关键特点： 1. **单次检测**：YOLO 模型在单次前向传播中同时预测多个对象的边界框和类别概率，不需要多次扫描图像。 2. **速度快**：YOLO 非常快速，能够在视频帧率下进行实时检测，适合移动设备和嵌入式系统。 3. **端到端训练**：YOLO 模型可以从原始图像直接训练到最终的检测结果，无需复杂的后处理步骤。 4. **易于集成**：YOLO 模型结构简单，易于与其他视觉任务（如图像分割、关键点检测等）结合使用。 5. **多尺度预测**：YOLO 可以通过多尺度预测来检测不同大小的对象，提高了检测的准确性。 YOLO 已经发展出多个版本，包括 YOLOv1、YOLOv2（也称为 YOLO9000）、YOLOv3、YOLOv4 和 YOLOv5 等。
吃鸡pubg适用于罗技GHUB的鼠标宏
07-19
安装步骤如下！ 导入lua宏到GHUB的步骤如下： 1. 打开GHUB，选择你的罗技鼠标。 2. 转到“宏”选项卡，创建一个新的宏。 3. 在宏编辑器中，点击“导入”，选择"pubg1.lua"文件。 4. 宏会自动加载lua文件中的所有操作，你可以调整它们的顺序或延迟时间，以适应自己的游戏风格。 5. 将这个宏绑定到鼠标上的任意按键，就可以在游戏中使用了
基于海洋捕食者优化算法MPA-VMD实现信号去噪目标函数为包络信息熵 包络熵 排列熵 样本熵最小附matlab代码.rar
07-19
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
工业控制系统安全测评指导书（二级）
最新发布
07-20
工业控制系统安全测评指导书（二级）
基于springboot+jsp的毕业生信息管理系统数据库表
07-19
设计一个毕业生信息管理系统，可实现管理员、辅导员、学生用户进行登录的系统，去除掉一些不必要的功能并添加一些新的功能使得页面更加简洁，用户可简单直接地进行操作该系统，并且更好地使用该系统，从而对毕业生的信息进行更好的管理。
Atomicity (continued) - Assignment
05-18
In programming, an assignment is an operation that sets a value to a variable or a memory location. The atomicity of an assignment refers to the property that the assignment operation is indivisible ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值