Games103的作业3：跳动的房子（有限元）

最新推荐文章于 2024-04-21 09:36:06 发布
最新推荐文章于 2024-04-21 09:36:06 发布
阅读量517 收藏 1
点赞数 2
分类专栏： Games103 文章标签： 学习 几何学 CG
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RobinWitch/article/details/127269098
版权

mark一下写的，果然，老师说得简单和代码量少对于我等人来说，不是一个维度的。

自己经验少，以为基本单元都是三角形的，这回第一次来了个四面体的，有点蒙圈，但处理过程中也还是把四面体拆成顶点和三角形来处理。确切的说，以往是以为mesh只是个三维空间中闭合的二维面，里面啥都没，就是个空心皮套一样。这回的mesh感觉里面也有三角形。虽说没看过（因为自己不会看模型里面…也有点懒不想找方法比如上色啥的）

这里有个稍微迷惑人的地方，就是初始的名为house的平面，其实它啥用都没…不要以为是神奇的代码把平面折叠成房子，你把FVM脚本附着在啥物体上其实都行。

在课程PPT里，一直是按着二维处理的，这里我们要变成三维，本质上大差不差。

下面记录代码：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
using System.IO;

public class FVM : MonoBehaviour
{
	float dt 			= 0.003f;
    float mass 			= 1;
	float stiffness_0	= 20000.0f; //lamda
    float stiffness_1 	= 5000.0f;  //miu
    float damp			= 0.999f;

	int[] 		Tet;        
	int tet_number;			//The number of tetrahedra

	Vector3[] 	Force;
	Vector3[] 	V;
	Vector3[] 	X;
	int number;				//The number of vertices

	Matrix4x4[] inv_Dm;

	//For Laplacian smoothing.
	Vector3[]   V_sum;
	int[]		V_num;

	SVD svd = new SVD();

    // Start is called before the first frame update
    void Start()
    {
    	// FILO IO: Read the house model from files.
    	// The model is from Jonathan Schewchuk's Stellar lib.
    	{
    		string fileContent = File.ReadAllText("Assets/house2.ele");
    		string[] Strings = fileContent.Split(new char[]{' ', '\t', '\r', '\n'}, StringSplitOptions.RemoveEmptyEntries);
    		
    		tet_number=int.Parse(Strings[0]);
        	Tet = new int[tet_number*4];

    		for(int tet=0; tet<tet_number; tet++)
    		{
				Tet[tet*4+0]=int.Parse(Strings[tet*5+4])-1;
				Tet[tet*4+1]=int.Parse(Strings[tet*5+5])-1;
				Tet[tet*4+2]=int.Parse(Strings[tet*5+6])-1;
				Tet[tet*4+3]=int.Parse(Strings[tet*5+7])-1;
			}
    	}
    	{
			string fileContent = File.ReadAllText("Assets/house2.node");
    		string[] Strings = fileContent.Split(new char[]{' ', '\t', '\r', '\n'}, StringSplitOptions.RemoveEmptyEntries);
    		number = int.Parse(Strings[0]);
    		X = new Vector3[number];
       		for(int i=0; i<number; i++)
       		{
       			X[i].x=float.Parse(Strings[i*5+5])*0.4f;
       			X[i].y=float.Parse(Strings[i*5+6])*0.4f;
       			X[i].z=float.Parse(Strings[i*5+7])*0.4f;
       		}
    		//Centralize the model.
	    	Vector3 center=Vector3.zero;
	    	for(int i=0; i<number; i++)		center+=X[i];
	    	center=center/number;
	    	for(int i=0; i<number; i++)
	    	{
	    		X[i]-=center;
	    		float temp=X[i].y;
	    		X[i].y=X[i].z;
	    		X[i].z=temp;
	    	}
		}
        /*
        tet_number=1;
        Tet = new int[tet_number*4];
        Tet[0]=0;
        Tet[1]=1;
        Tet[2]=2;
        Tet[3]=3;

        number=4;
        X = new Vector3[number];
        V = new Vector3[number];
        Force = new Vector3[number];
        X[0]= new Vector3(0, 0, 0);
        X[1]= new Vector3(1, 0, 0);
        X[2]= new Vector3(0, 1, 0);
        X[3]= new Vector3(0, 0, 1);
        */


        //Create triangle mesh.
       	Vector3[] vertices = new Vector3[tet_number*12];
        int vertex_number=0;
        for(int tet=0; tet<tet_number; tet++)
        {
        	vertices[vertex_number++]=X[Tet[tet*4+0]];
        	vertices[vertex_number++]=X[Tet[tet*4+2]];
        	vertices[vertex_number++]=X[Tet[tet*4+1]];

        	vertices[vertex_number++]=X[Tet[tet*4+0]];
        	vertices[vertex_number++]=X[Tet[tet*4+3]];
        	vertices[vertex_number++]=X[Tet[tet*4+2]];

        	vertices[vertex_number++]=X[Tet[tet*4+0]];
        	vertices[vertex_number++]=X[Tet[tet*4+1]];
        	vertices[vertex_number++]=X[Tet[tet*4+3]];

        	vertices[vertex_number++]=X[Tet[tet*4+1]];
        	vertices[vertex_number++]=X[Tet[tet*4+2]];
        	vertices[vertex_number++]=X[Tet[tet*4+3]];
        }

        int[] triangles = new int[tet_number*12];
        for(int t=0; t<tet_number*4; t++)
        {
        	triangles[t*3+0]=t*3+0;
        	triangles[t*3+1]=t*3+1;
        	triangles[t*3+2]=t*3+2;
        }
        Mesh mesh = GetComponent<MeshFilter> ().mesh;
		mesh.vertices  = vertices;
		mesh.triangles = triangles;
		mesh.RecalculateNormals ();


		V 	  = new Vector3[number];
        Force = new Vector3[number];
        V_sum = new Vector3[number];
        V_num = new int[number];

        //TODO: Need to allocate and assign inv_Dm
        inv_Dm = new Matrix4x4[tet_number]; //初始的位置矩阵
        for (int tet = 0; tet < tet_number; tet++)
            inv_Dm[tet] = Build_Edge_Matrix(tet).inverse;
    }

    Matrix4x4 Build_Edge_Matrix(int tet)
    {
    	Matrix4x4 ret=Matrix4x4.zero;
        //TODO: Need to build edge matrix here.

        ret[0, 0] = X[Tet[tet * 4 + 1]].x - X[Tet[tet * 4 + 0]].x;
        ret[1, 0] = X[Tet[tet * 4 + 1]].y - X[Tet[tet * 4 + 0]].y;
        ret[2, 0] = X[Tet[tet * 4 + 1]].z - X[Tet[tet * 4 + 0]].z;
        ret[3, 0] = 0;

        ret[0, 1] = X[Tet[tet * 4 + 2]].x - X[Tet[tet * 4 + 0]].x;
        ret[1, 1] = X[Tet[tet * 4 + 2]].y - X[Tet[tet * 4 + 0]].y;
        ret[2, 1] = X[Tet[tet * 4 + 2]].z - X[Tet[tet * 4 + 0]].z;
        ret[3, 1] = 0;

        ret[0, 2] = X[Tet[tet * 4 + 3]].x - X[Tet[tet * 4 + 0]].x;
        ret[1, 2] = X[Tet[tet * 4 + 3]].y - X[Tet[tet * 4 + 0]].y;
        ret[2, 2] = X[Tet[tet * 4 + 3]].z - X[Tet[tet * 4 + 0]].z;
        ret[3, 2] = 0;

        ret[0, 3] = 0;
        ret[1, 3] = 0;
        ret[2, 3] = 0;
        ret[3, 3] = 1;
        return ret;
    }

    void Smooth_V()
    {
        for (int i = 0; i < number; i++)
        {
            V_sum[i] = new Vector3(0, 0, 0);
            V_num[i] = 0;
        }

        for (int tet = 0; tet < tet_number; tet++)
        {
            Vector3 sum = V[Tet[tet * 4 + 0]] + V[Tet[tet * 4 + 1]] + V[Tet[tet * 4 + 2]] + V[Tet[tet * 4 + 3]];
            V_sum[Tet[tet * 4 + 0]] += sum;
            V_sum[Tet[tet * 4 + 1]] += sum;
            V_sum[Tet[tet * 4 + 2]] += sum;
            V_sum[Tet[tet * 4 + 3]] += sum;
            V_num[Tet[tet * 4 + 0]] += 4;
            V_num[Tet[tet * 4 + 1]] += 4;
            V_num[Tet[tet * 4 + 2]] += 4;
            V_num[Tet[tet * 4 + 3]] += 4;
        }

        for (int i = 0; i < number; i++)
        {
            V[i] = 0.9f * V[i] + 0.1f * V_sum[i] / V_num[i];
        }
    }


    void _Update()
    {
    	// Jump up.
		if(Input.GetKeyDown(KeyCode.Space))
    	{
    		for(int i=0; i<number; i++)
    			V[i].y+=0.2f;
    	}

    	for(int i=0 ;i<number; i++)
    	{
            //TODO: Add gravity to Force.
            Force[i] = new Vector3(0,- 9.8f * mass, 0);
    	}

    	for(int tet=0; tet<tet_number; tet++)
    	{
            //TODO: Deformation Gradient
            Matrix4x4 F = Build_Edge_Matrix(tet) * inv_Dm[tet];
            //TODO: Green Strain
            Matrix4x4 G = F.transpose * F;
            for (int i = 0; i < 4; i++)
                for (int j = 0; j < 4; j++)
                {
                    if (i == j)
                        G[i, j] = G[i, j] - 1;
                    G[i, j] = 0.5f * G[i, j];
                }
            //TODO: Second PK Stress
            Matrix4x4 S = Matrix4x4.zero;
            float traceG = G[0, 0] + G[1, 1] + G[2, 2];
            for(int i=0;i<4;i++)
                for(int j=0;j<4;j++)
                {
                    S[i, j] = 2 * stiffness_1 * G[i, j];
                    if (i == j)
                        S[i, j] += stiffness_0 * traceG;
                }
            //TODO: Elastic Force
            Matrix4x4 force = F * S * inv_Dm[tet].transpose;
            float volume = 1/(inv_Dm[tet].determinant * 6); //注意下这里体积公式 S=||A||/6  S=1/(6*||A^-1||)
            for (int i = 0; i < 4; i++)
                for (int j = 0; j < 4; j++)
                    force[i, j] = -1*volume * force[i, j];
            Force[Tet[tet * 4 + 1]].x += force[0, 0];
            Force[Tet[tet * 4 + 1]].y += force[1, 0];
            Force[Tet[tet * 4 + 1]].z += force[2, 0];
            Force[Tet[tet * 4 + 2]].x += force[0, 1];
            Force[Tet[tet * 4 + 2]].y += force[1, 1];
            Force[Tet[tet * 4 + 2]].z += force[2, 1];
            Force[Tet[tet * 4 + 3]].x += force[0, 2];
            Force[Tet[tet * 4 + 3]].y += force[1, 2];
            Force[Tet[tet * 4 + 3]].z += force[2, 2];

            Force[Tet[tet * 4 + 0]].x -= (force[0, 0] + force[0, 1] + force[0, 2]);
            Force[Tet[tet * 4 + 0]].y -= (force[1, 0] + force[1, 1] + force[1, 2]);
            Force[Tet[tet * 4 + 0]].z -= (force[2, 0] + force[2, 1] + force[2, 2]);
        }

        Smooth_V();



        for (int i=0; i<number; i++)
    	{
            //TODO: Update X and V here.
            V[i] = (V[i] + dt * Force[i] / mass) * damp;
            X[i] = X[i] + V[i] * dt;
    		//TODO: (Particle) collision with floor.
            if(X[i].y<-3f)   //这里仅对局部坐标进行相应判断，选取-3的原因是底部物体的世界坐标是-3
            {
                X[i].y = -3f;
                if (V[i].y < 0)
                    V[i].y = -V[i].y;
            }
    	}
    }

    // Update is called once per frame
    void Update()
    {
    	for(int l=0; l<10; l++)
    		 _Update();

    	// Dump the vertex array for rendering.
    	Vector3[] vertices = new Vector3[tet_number*12];
        int vertex_number=0;
        for(int tet=0; tet<tet_number; tet++)
        {
        	vertices[vertex_number++]=X[Tet[tet*4+0]];
        	vertices[vertex_number++]=X[Tet[tet*4+2]];
        	vertices[vertex_number++]=X[Tet[tet*4+1]];
        	vertices[vertex_number++]=X[Tet[tet*4+0]];
        	vertices[vertex_number++]=X[Tet[tet*4+3]];
        	vertices[vertex_number++]=X[Tet[tet*4+2]];
        	vertices[vertex_number++]=X[Tet[tet*4+0]];
        	vertices[vertex_number++]=X[Tet[tet*4+1]];
        	vertices[vertex_number++]=X[Tet[tet*4+3]];
        	vertices[vertex_number++]=X[Tet[tet*4+1]];
        	vertices[vertex_number++]=X[Tet[tet*4+2]];
        	vertices[vertex_number++]=X[Tet[tet*4+3]];
        }
        Mesh mesh = GetComponent<MeshFilter> ().mesh;
		mesh.vertices  = vertices;
		mesh.RecalculateNormals ();
    }
}
RobinWitch
关注
专栏目录
[计算机动画]Games103-作业1-刚体动画
博客
08-11 1968
games103-lab1-作业
GAMES101:作业3
qq_41765657的博客
12-05 8218
GAMES101:作业3 照旧把这段代码粘贴过来： Eigen::Matrix4f get_projection_matrix(float eye_fov, float aspect_ratio, float zNear, float zFar) { float n = zNear; float f = zFar; Eigen::Matrix4f projection = Eigen::Matrix4f::Identity(); float t = -tan((eye_fov
games103——作业3
hhhcbw的博客，欢迎各位来访
05-16 1213
实验三主要使用FEM和hyperelastic模型完成弹性体的模拟完整项目已上传至github
GAMES103
averagePerson的博客
07-08 358
作为一个小白，不怎么会编程，也不怎么会数学。原理都是数学公式，看不懂，只能看看别人写的，凑凑热闹了……刚体模拟（GAMES103作业1）_哔哩哔哩_bilibili布料模拟（GAMES103作业2）_哔哩哔哩_bilibili 柔性体模拟 有限元 hyper elastics（GAMES103作业3）_哔哩哔哩_bilibili流体模拟 shallow wave（GAMES103作业4）_哔哩哔哩_bilibili......
games103,作业1（逻辑梳理）
Elsa的迷弟
03-03 1969
作业框架已知条件 兔子模型的顶点集 每个墙体的上的点P及法线N； 兔子初始速度（角速度w&线速度v） 全局速度衰减系数(linear_decay，angular_decay)，全局弹性系数（restitution），全局摩擦系数（friction） 步时（dt） 重力加速度（gravity） 惯性张量（I_ref） bool launched = false; float dt = 0.015f; Vector3 v = new Vector3(0, 0, 0); // v
games103——作业1
hhhcbw的博客，欢迎各位来访
04-13 1216
实验一主要实现简单的刚体动画模拟(一只兔子)，包括 impulse 的碰撞检测与响应，以及 Shape Matching方法。完整项目已上传至。
Assignment1_games101作业1_games101作业7_C++_games101作业_
10-03
在本作业中，我们关注的是GAMES101课程中的第一份作业，它涉及到了图形学中的一个重要概念——投影矩阵。GAMES101通常是一门计算机图形学的基础课程，涵盖了游戏开发和3D图形渲染的基本原理。在这个作业中，学生被...
GAMES101-现代计算机图形学学习笔记（作业03）
06-28
处实现与作业 2 类似的插值算法，实现法向量、颜色、纹理颜色的插值。 2. 修改函数 get_projection_matrix() in main.cpp: 将你自己在之前的实验中 实现的投影矩阵填到此处，此时你可以运行 ./Rasterizer output.png...
Games101-作业一: 旋转与投影
兔头咸鱼的博客
11-26 986
填写一个旋转矩阵和一个透视投影矩阵, 完成模型变换和投影变换的部分.
GAMES103-作业1-刚体模拟(个人解读)
qq_35975367的博客
04-20 624
有Rigid_Bunny和Rigid_Bunny_by_Shape_Matching两个脚本文件步骤：1.受重力因素更新速度2.受外力因素更新速度3.计算Inertia惯性张量(公式见上图)4.计算碰撞(代码中用的Collision Impulse)，调用Collision函数5.更新v和w(角速度)6.通过动态调整阈值（punish_threshold）来控制速度和角速度的增长速度，以保持运动的稳定性7.更新位置和方向if (!if(!
GAMES103-基于物理的计算机动画入门（1~4，lab1）
weixin_47652005的博客
12-20 1157
前言 本人的GAMES103笔记，以下分节根据知识点来分。同时包含了个人的一点补充。 1. Introduction 课程主页：http://games-cn.org/games103/ B站链接：https://www.bilibili.com/video/BV12Q4y1S73g?from=search&seid=2084315763141666934&spm_id_from=333.337.0.0 课程作业：http://games103.games-cn.org/ 课程安排： 理想
Games103的作业2：布 meets 球！
RobinWitch的博客
10-11 390
用的是隐式解决的方法，怎么说好呢，就是莫名奇妙的速度慢，重力加速度我都改成98了都好慢，但是能仿真成功，能动就算成功！
GAMES101作业3及课程总结
Xuuuuuuuuuuu的博客
04-22 1547
在做这个作业之前，看到弹幕说这次作业难度相对于前面几次上升很多，真正做了之后确实有那么点感受，但是实际上当厘清渲染管线之后，其实挺简单的，其实我觉得本次作业最难的地方就是看懂框架源码，知道它在干什么，理解核心代码的功能，通过这个过程去掌握渲染管线，明白这个之后，将问题拆解，其实这次作业也就不那么难了== 目录课程总结与理解（着色）框架梳理main函数draw函数rasterize_triangle函数任务一：实现插值算法任务二：填入投影矩阵get_projection_matrix函数法向量着色结果任务三：
探索GAMES103：构建交互式游戏的技术实践与创新
最新发布
gitblog_00040的博客
04-21 368
探索GAMES103：构建交互式游戏的技术实践与创新 项目地址:https://gitcode.com/games-webinar/GAMES103 GAMES103 是一个开源项目，旨在教授如何使用现代Web技术开发互动式游戏。这个项目不仅仅是一个教程，更是一个完整的框架，适合初学者和经验丰富的开发者们探索、学习和实践。 技术栈分析 GAMES103的核心技术包括： HTML5 Canvas:...
GAMES103（三）Cloth
Fyantu的博客
10-09 351
因此我们需要设定一种数据结构来寻找内部重复的边，使用一种三元列表的结构来存储边，前两个元素存储顶点索引，第三个元素存储边所在的三角形索引，这样对边结构一排序，重复的边就会相邻，从而可以找出相邻的三角形和不重复的边。PBD方法广泛用于现在的游戏中，由于它每次对内存的访问只有一个更新后的顶点坐标，所以可以提高模型的训练速度，事实上，目前对于矩阵的计算并不是影响计算速度的瓶颈，真实的速度瓶颈还是在内存访问上。所以我们也可以推断在拉伸的时候，我们整个系统比较稳定，因为一定是正定的，但压缩的时候就有可能导致。
【GAMES103学习笔记】线性系统（Linear System）及其解法（Linear Sovler）
不能自拔
07-10 2776
线性系统及其解法
基于动量计算的刚体碰撞模拟【Games103-物理模拟】
cycler_725的博客
11-17 877
Games103的lab1的学习笔记和代码实现 课程链接：GAMES103-基于物理的计算机动画入门_哔哩哔哩_bilibili 课程主页：GAMES103：基于物理的计算机动画入门 – 计算机图形学与混合现实在线平台 理论基础 点乘与叉乘 动量与角动量 四元数及计算 速度与角速度 坐标空间转换 2. 算法实现 2.1 算法思路 本质上刚体发生变化的就是位置（向量）和旋转（四元数）。 碰撞过程导致了受力变化，从而影响物体速度，进而更新物体的位置坐标和旋转。本算法是当前帧如果发生.
GAMES103-基于物理的计算机动画入门 笔记
qq_35975367的博客
04-15 182
Lecture 02 Math Background: Vector, Matrix and Tensor Calculus
Games 103 作业二
异次元的归来
10-28 238
难度相对于作业一来说要简单一些，在文档中基本把步骤都写清楚了。这里的f就是重力和弹簧间的弹力。然后我们按照文档的步骤一步一步地来。注意0号顶点和20号顶点是不参与更新的，它们相当于就是定死了位置。作业中是固定的32次迭代次数，这里的break判断就可以省略掉；然后我们再看下PBD的实现。迭代完别忘记更新下V，这里要使用+=，因为一开始算。如果你觉得我的文章有帮助，欢迎关注我的微信公众号。第二步就是计算梯度。这里的梯度就是PPT里的。作业文档中给了近似求解的方法，我们就不用算。
作业 3: pipeline and shading games101, 2020 年春季
09-04
pipeline and shading是计算机图形学中的两个重要概念。在Games101课程中，我们学习了这两个概念以及它们在游戏开发中的应用。 首先，管线（pipeline）是指图形渲染过程中的一系列阶段。这些阶段依次执行，以将3D模型转换为最终的2D图像。管线的主要阶段包括顶点处理、光栅化和片元处理。在顶点处理阶段，模型的顶点坐标被转换为屏幕空间坐标，并进行光照计算等操作。在光栅化阶段，模型的三角形被转化为像素，在屏幕上显示。在片元处理阶段，对每个像素执行颜色计算，以确定最终的像素颜色。 其次，着色（shading）是指确定模型表面每个像素的颜色和光照效果。常见的着色模型包括平面着色、高洛德着色和菲格斯特随机着色等。平面着色是最简单的一种，忽略了光照效果，给每个像素分配一个固定的颜色。高洛德着色则考虑了光照的方向和强度，使得模型表面看起来更加真实。菲格斯特随机着色则引入了随机过程，给模型表面增加纹理和细节。 在游戏开发中，管线和着色技术被广泛应用。通过管线的处理，可以实现更高的渲染效率和图像质量。而着色技术可以使游戏中的模型更加真实，增加玩家的沉浸感。此外，我们还可以通过改变管线和着色的参数来实现特殊的效果，如阴影、光线投射和折射等。 总的来说，pipeline and shading是计算机图形学中的重要概念。在Games101课程中，我们深入学习了这两个概念以及它们在游戏开发中的应用。通过理解和掌握管线和着色技术，我们可以实现更加高效和逼真的游戏图形效果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值