先是是3D编程中通用的数量见 这即使是终点组成的网格数据 称之为mesh,什么人说开3D便只好用DirectX OpenGL了

先是是3D编程中通用的数量表现 这就是极组成的网格数据 称之为mesh,
3只点吗同一组  组成的三角形面片数据。五个点顺时针的趋向那么 箭头方向也他表面
另一样冲吧外表面 ,在绘制的当儿 内表面不可见。
图片 1

顾了 绕着任意轴进行盘

 1         //平面是否面向摄像机的判别
 2         public bool angelCalc( Point3dF A,Point3dF B,Point3dF C)
 3         {
 4             //https://zhidao.baidu.com/question/810216091258785532.html
 5             //AB、AC所在平面的法向量即AB×AC=(a,b,c),其中:
 6             //a=(y2-y1)(z3-z1)-(z2-z1)(y3-y1)
 7             //b=(z2-z1)(x3-x1)-(z3-z1)(x2-x1)
 8             //c=(x2-x1)(y3-y1)-(x3-x1)(y2-y1)
 9             
10             //先得出点 对应的向量
11             //Point3dF AB = new Point3dF(B.x - A.x, B.y - A.y, B.z - A.z);
12 
13             //首先求出法向量
14             double a = ((B.y - A.y)*(C.z - A.z) - (B.z - A.z)*(C.y - A.y));
15             double b = (B.z - A.z) * (C.x - A.x) - (C.z - A.z) * (B.x - A.x);
16             double c = (B.x - A.x) * (C.y - A.y) - (C.x - A.x) * (B.y - A.y);
17             Point3dF bb = new Point3dF(a, b, c);
18             //套公式 第二册 下b 39  通过两向量的cos函数 继而通过反余弦得出角度
19             var angelPlan =Math.Acos(
20                 (A.x * bb.x + A.y * bb.y + A.z * bb.z) / (
21                Math.Sqrt(Math.Pow(A.x, 2) + Math.Pow(A.y, 2) + Math.Pow(A.z, 2)) *
22                Math.Sqrt(Math.Pow(bb.x, 2) + Math.Pow(bb.y, 2) + Math.Pow(bb.z, 2))
23                )
24                );
25 
26             if (angelPlan > (Math.PI / 2))//法向量与镜头的夹角大于90度 代表三角面片面向摄像机 则可见
27                 return true;
28             else//否则不可见
29                 return false;
30         }

眼前的都是发生来挖的人家的,这个效应相对是上下一心挑出的。起始那一个无是少零星内的线条绘制啥的且不得不算是
点绘制 
,我们现设开展面绘制。首先你如解的凡自的顶三角面片数据已于有了,
3d坐标点打在半透明纸张上 的x,y 也曾经得出了。 调用gdi的fillpath按ABC
的逐条并起来 就可以绘制一个三角形面片 是不是坏简短。不过先别慌
还有个别独问题需处理,一个就是是可晤面判别。 就是零星个三角形面片 的职务
决定了 在透视投影的时光何人在头里谁在继, 还有面相交的情景呢 ?
是免是充足复杂?其实从不用管,虽然要管 只要您以z缓冲算法 也非是不行复杂
zbuffer 。就是当哀告出屏幕x y过后拿与xy的点z越接近视点的居前方
这样虽然达成目标了。那里我们先 不管这么些zbuffer算法 
下次起空余了大家再一次来描写。这里大家使用另外一种方法
通过辨认正向面与后朝着面来达到目标。后边我们无是说了吗 :

 1         public class Marsh
 2         {
 3             public List<Point3dF> points;
 4             public Marsh()
 5             {
 6                 points = new List<Point3dF>();
 7 
 8                 //0
 9                 Point3dF pointA = new Point3dF(30, 30, -160);
10                 //1
11                 Point3dF pointB = new Point3dF(-30, 30, -160);
12                 //2
13                 Point3dF pointC = new Point3dF(-30, -30, -160);
14                 //3
15                 Point3dF pointD = new Point3dF(30, -30, -160);
16                 //4
17                 Point3dF pointE = new Point3dF(30, 30, -100);
18                 //5
19                 Point3dF pointF = new Point3dF(-30, 30, -100);
20                 //6
21                 Point3dF pointG = new Point3dF(-30, -30, -100);
22                 //7
23                 Point3dF pointH = new Point3dF(30, -30, -100);
24 
25                 points.Add(pointA);
26                 points.Add(pointB);
27                 points.Add(pointC);
28                 points.Add(pointD);
29 
30                 points.Add(pointE);
31                 points.Add(pointF);
32                 points.Add(pointG);
33                 points.Add(pointH);
34 
35                 
36 
37                 path1 = new List<int>() { 
38                     4, 6,7,
39                     4,5,6,
40                     5 ,2 ,6,
41                     5, 1, 2,
42                     1 ,3 ,2,
43                     1, 0 ,3,
44                     0 ,7 ,3,
45                     0 ,4, 7
46                     ,
47                     4, 1, 5,
48                     4 ,0 ,1,
49                     6, 2 ,7,
50                     2, 3, 7
51                 };
52 
53                 faceColors = new List<Brush>();
54                 Random rdm = new Random();
55 
56                 for (int i = 0; i < 6; i++)
57                 {
58                     Brush b= new SolidBrush(Color.FromArgb(rdm.Next(0, 255), rdm.Next(0, 255), rdm.Next(0, 255)));
59                     //Brush b = new SolidBrush(Color.FromArgb(266 / 6 * i, 266 / 6 * i, 266 / 6 * i));
60                     faceColors.Add(b);
61                     faceColors.Add(b);
62                 }
63                 
64             }
65             public List<Brush> faceColors;
66             public List<int> path1;
67 
68         }

吓就是这么 先举行3d空间的触发转,
再拓展平面坐标映射绘制 用线连起来。是无是不怕暴发接触3D立体之旗帜了。哇哈哈哈哈

小心了 绕着任意轴进行盘

图片 2

至于透视投影 和终端绘制

光照这游戏意儿如故 用到三角面片的法向量 ,三角面片正对着光 则表面亮度最高
,垂直则成为黑暗。参照面绘制的规律就是足以做出来
我这边就每个面各用把五颜六色的水彩算了吧 懒得整了。

 

 1         //得到旋转矩阵
 2         double[,] RotateArbitraryLine(Point3dF v1, Point3dF v2, double theta)
 3         {
 4             
 5             double a = v1.x;
 6             double b = v1.y;
 7             double c = v1.z;
 8             Point3dF p = new Point3dF(v2.x - v1.x, v2.y - v1.y, v2.z - v1.z);
 9             //v2归一化
10             double x_p2 = p.x / Math.Sqrt(Math.Pow(p.x, 2) + Math.Pow(p.y, 2));
11             double y_p2 = p.y / Math.Sqrt(Math.Pow(p.x, 2) + Math.Pow(p.y, 2));
12 
13             if (double.IsNaN(x_p2))
14                 x_p2 = 0;
15             if (double.IsNaN(y_p2))
16                 y_p2 = 0;
17 
18             double u = x_p2;
19             double v = y_p2;
20             double w = 0d;// -130d;// 0d;
21 
22             double uu = u * u;
23             double uv = u * v;
24             double uw = u * w;
25             double vv = v * v;
26             double vw = v * w;
27             double ww = w * w;
28             double au = a * u;
29             double av = a * v;
30             double aw = a * w;
31             double bu = b * u;
32             double bv = b * v;
33             double bw = b * w;
34             double cu = c * u;
35             double cv = c * v;
36             double cw = c * w;
37 
38             double costheta = Math.Cos(theta);
39             double sintheta = Math.Sin(theta) ;
40             double[,] pOut = new double[4, 4];
41             pOut[0,0] = uu + (vv + ww) * costheta;
42             pOut[1,0] = uv * (1 - costheta) + w * sintheta;
43             pOut[2,0] = uw * (1 - costheta) - v * sintheta;
44             pOut[3,0] = 0;
45                   
46             pOut[0,1] = uv * (1 - costheta) - w * sintheta;
47             pOut[1,1] = vv + (uu + ww) * costheta;
48             pOut[2,1] = vw * (1 - costheta) + u * sintheta;
49             pOut[3,1] = 0;
50                   
51             pOut[0,2] = uw * (1 - costheta) + v * sintheta;
52             pOut[1,2] = vw * (1 - costheta) - u * sintheta;
53             pOut[2,2] = ww + (uu + vv) * costheta;
54             pOut[3,2] = 0;
55                   
56             pOut[0,3] = (a * (vv + ww) - u * (bv + cw)) * (1 - costheta) + (bw - cv) * sintheta;
57             pOut[1,3] = (b * (uu + ww) - v * (au + cw)) * (1 - costheta) + (cu - aw) * sintheta;
58             pOut[2,3] = (c * (uu + vv) - w * (au + bv)) * (1 - costheta) + (av - bu) * sintheta;
59             pOut[3,3] = 1;
60 
61             return pOut;
62         }

好这我们也以此模式来定义数据 ,我们定义之事物是一个 核心地方在(
0,0,-130)处之立方体。我们的观察点在(0, 0, 0)处 正对正在立方体观看。
由于咱们记念叫立方体一个面对之水彩相同,所以是个别独也平组定义之
,当然三角形也是以同等的
两单呢同样组 组成一个正好方形面。因此对体表面空间点的讲述数据就是抓好了。
哼 ,定义数据的代码:

图片 3 
咱俩因此测算每个三角面片的法向量, 然后我们发出一个视点到三角面片的朝量
,通过测算两奔量的点积  图片 4下一场通过反余弦函数就足以得出两朝着量之夹角
。 假如夹角大于90渡过表示三角面片正奔面朝着视点,
假诺小于90度过表示正为面背对了视点, 则不针对这些三角面片举办渲染。如此一来
你细心想想 大家的立方体至始至终不相会有一个冲把此外一个给遮的状况。
哼了规律讲至此 好下 按照原理撸代码:

最为开端自无绘制面只是绘制的顶点线框而现已 。然后自己怀想做的是转 
让他改动起来,总共八独点连成线就是立方体了,哪怕是low逼的线条
只要改变起来是未是就起立方体的则了。  哇哈哈哈哈。最先河我思量的坏简短啊
立体之转动也未曾啥不得了底啊 ,比如饶y轴转动 我将他当成平面的匪纵得矣么
y不变x和z变。 绕x轴旋转 同理。 我本也勾勒了面的点举行盘的总计。
为了顺应图形学上之专业措施 最终自己要么接纳二维矩阵旋转的道: 

 

 

  

 

现行自己眷恋做的凡举办一个跟球效果 。鼠标按下拖动的时吃物体
像烤肉串样绕在雷同根本轴转动。 网上跟球都是转相机
我们这里直接旋转物体坐标。绕在任意轴旋转啊绕着任意轴旋转的矩阵 说实话
3D旋转矩阵这几个我搞不清楚 ,我看不明了推导过程 然而我会看公式 哇哈哈哈哈。 
https://www.cnblogs.com/graphics/archive/2012/08/10/2627458.html 
此外的博文里贴出的旋矩阵也是这么 直接将他的代码抄下来之  ,c++的
我抄成c#的 没啥难的 我就越好把c++代码了。可想而知大家若做的便是
得出一个二维数组作为矩阵回传
让具有坐标遵照这矩阵展开演算。注意起些许独基本概念:  两独点相减 a-b 
得发底是 b到a 的向量 (0,0) -(1,1)  =(-1,-1)  ,然后是向量归一化:
什么给归一化, 就是 把向量的趋势无换 长度变至单位长度
,也即使是1。问于量归一化怎么打  。好
,比如一个二维向量,统计原理就是通过距离总括公式图片 5查获距离。这多少个离与1之比率等于 现x与归一化后x的比值:图片 6求归一化后y的价同理。当然那些都是基础的没什么特别说之。
请旋转矩阵的函数:

再有本人之录像机镜头是一定的 ,其实还有很多办事需举办  。
希望各位大大继续到。看下效果 是免是有模有样:上个gif图:
图片 7
君得将平面面向录像机判别函数再次来到的值反为一下看望啊效益,是免是盼内壁的那一端了 是不是万分神奇哇哈哈哈哈
凡的君莫看错就如此几百执为主部分尽管实现了  差不多都是数学知识
,其他的都是补充砖加瓦的从,原理都当霎时了。 好了
未来更拘留DirectX 啊OpenGL啊 图形学
变换矩阵啊这些的 别被惊吓住了 没那么难之。
按说的说话那一个文化总体来说蛮难的 然而究竟仍旧仿照过高中的向量 
两望量垂直时点积等于零 那个之类的  , 靠在摸着石头过河
把那些半懂不懂的知识 拼凑起来 加上各类度娘 和查看资料 来实现
没想到依旧成了。 意外意外  ,当然学习是倘使依自己的 
你想一向度娘给您下个你要的功能 这是免可能的。

 

 

图片 8

 

 

 1         public void paint()
 2         {
 3             Graphics gph = Graphics.FromHwnd(this.Handle);
 4             gph.Clear(Color.Lavender);
 5             //进行到屏幕坐标的映射(x y z)
 6             //p~ =(-n x/z       -n y/z      -n)
 7             PointF screenLastPoint= PointF.Empty;
 8             for (int i = 0; i < msh.path1.Count / 3; i++)
 9             {
10                 //if (i >= 4)
11                 //    return;
12                 PointF screenPointA = new PointF((float)((-nearPlan) * (msh.points[msh.path1[i * 3]].x / msh.points[msh.path1[i * 3]].z)) , (float)((-nearPlan) * (msh.points[msh.path1[i * 3]].y / msh.points[msh.path1[i * 3]].z))  );
13                 PointF screenPointB = new PointF((float)((-nearPlan) * (msh.points[msh.path1[i * 3 + 1]].x / msh.points[msh.path1[i * 3 + 1]].z)) , (float)((-nearPlan) * (msh.points[msh.path1[i * 3 + 1]].y / msh.points[msh.path1[i * 3 + 1]].z))  );
14                 PointF screenPointC = new PointF((float)((-nearPlan) * (msh.points[msh.path1[i * 3 + 2]].x / msh.points[msh.path1[i * 3 + 2]].z))  , (float)((-nearPlan) * (msh.points[msh.path1[i * 3 + 2]].y / msh.points[msh.path1[i * 3 + 2]].z))  );
15 
16                 screenPointA.Y = -screenPointA.Y;
17                 screenPointB.Y = -screenPointB.Y;
18                 screenPointC.Y = -screenPointC.Y;
19 
20                 screenPointA.Y=screenPointA.Y+offsety;
21                 screenPointB.Y= screenPointB.Y+offsety;
22                 screenPointC.Y = screenPointC.Y + offsety;
23 
24                 screenPointA.X = screenPointA.X + offsetx;
25                 screenPointB.X = screenPointB.X + offsetx;
26                 screenPointC.X = screenPointC.X + offsetx;
27 
28                 System.Drawing.Drawing2D.GraphicsPath ph = new System.Drawing.Drawing2D.GraphicsPath(
29                     new PointF[] { screenPointA, screenPointB, screenPointC },
30                     new byte[] { 1, 1, 1 },
31                     System.Drawing.Drawing2D.FillMode.Winding);
32 
33 
34                 //---求法向量及夹角 如果为true 则渲染面//计算当前管线三角面片的法向量 是否朝着镜头 ,最终决定是否可见
35                 if (angelCalc(msh.points[msh.path1[i * 3]], msh.points[msh.path1[i * 3+1]], msh.points[msh.path1[i * 3+2]]) == true)
36                     gph.FillPath(msh.faceColors[i], ph);
37             }
38 
39             //绘制边框
40             gph.DrawLine(Pens.Red, new PointF(offsetx - 36, offsety - 36), new PointF(offsetx + 36, offsety - 36));
41             gph.DrawLine(Pens.Red,  new PointF(offsetx + 36, offsety - 36),new PointF(offsetx + 36, offsety + 36));
42             gph.DrawLine(Pens.Red, new PointF(offsetx + 36, offsety +36), new PointF(offsetx - 36, offsety + 36));
43             gph.DrawLine(Pens.Red, new PointF(offsetx - 36, offsety + 36), new PointF(offsetx - 36, offsety - 36));
44 
45             ////绘制网格线
46             //screenLastPoint = PointF.Empty;
47             //for (int i = 0; i < msh.path1.Count / 3; i++)
48             //{
49             //    //if (i >= 4)
50             //    //    return;
51             //    PointF screenPointA = new PointF((float)((-nearPlan) * (msh.points[msh.path1[i * 3]].x / msh.points[msh.path1[i * 3]].z)), (float)((-nearPlan) * (msh.points[msh.path1[i * 3]].y / msh.points[msh.path1[i * 3]].z)));
52             //    PointF screenPointB = new PointF((float)((-nearPlan) * (msh.points[msh.path1[i * 3 + 1]].x / msh.points[msh.path1[i * 3 + 1]].z)), (float)((-nearPlan) * (msh.points[msh.path1[i * 3 + 1]].y / msh.points[msh.path1[i * 3 + 1]].z)));
53             //    PointF screenPointC = new PointF((float)((-nearPlan) * (msh.points[msh.path1[i * 3 + 2]].x / msh.points[msh.path1[i * 3 + 2]].z)), (float)((-nearPlan) * (msh.points[msh.path1[i * 3 + 2]].y / msh.points[msh.path1[i * 3 + 2]].z)));
54 
55             //    screenPointA.Y = -screenPointA.Y;
56             //    screenPointB.Y = -screenPointB.Y;
57             //    screenPointC.Y = -screenPointC.Y;
58 
59             //    screenPointA.Y = screenPointA.Y + offsety;
60             //    screenPointB.Y = screenPointB.Y + offsety;
61             //    screenPointC.Y = screenPointC.Y + offsety;
62 
63             //    screenPointA.X = screenPointA.X + offsetx;
64             //    screenPointB.X = screenPointB.X + offsetx;
65             //    screenPointC.X = screenPointC.X + offsetx;
66 
67             //    gph.DrawLine(Pens.Red, screenPointA, screenPointB);
68             //    gph.DrawLine(Pens.Red, screenPointB, screenPointC);
69             //    gph.DrawLine(Pens.Red, screenPointC, screenPointA);
70 
71             //}
72 
73         }

图片 9

其他的

 

至于光照

图片 10

 

函数写好了 矩阵也会查获了,还发只问题:函数的那几单参数
,旋转的度数也好搞 按下之时节记录一个点 拖动的时节总结和他的去
距离作为度数 拖动50像素 旋转50渡过。
旋转的那么到底儿轴你怎么得出来,起首接触好 立方体的主导是0 0 -130 
。按下的时记录了按下开接触 鼠标的移动就曾是一个向量了
所以大家仅仅待对之向量 绕z轴举办90过旋转 ,z也设成-130
就跟主题点同样并了 就是内需的烤肉串儿的旋轴了。 好 原理讲得了了
,代码走由:

虽然假诺始所述 视点在(0,0,0) 处看于 位于(0,0,-130) 的立方体 
,假诺有一绑架录像机 
,那么上图虽是外的由半空看下的俯视图。设p为(x,z)  p’为(x’
,z’) 。则x’=-N(x/z)  y’=-N(y/z)。为了方便
我们的数码定义也是跟示意图上大多的。于是我们依葫芦画瓢
把具备的点绘制出来 包装成一个paint函数。
用留意的是平面坐标系 跟屏幕坐标中的转换 ,其实不为难
你任何计量以数学公式 数学函数 还是一如既往该咋算咋算。
 完成后我们平面坐标系的0,0  对诺屏幕坐标的0,0   。
图片 11图片 12
看到没 x轴0左边也是负数 不用无  就单纯是y的标记不等同
变成-y就可了。然后要是于他出示在窗口中  还要举行偏移 就是x加偏移,
y加偏移  就这么虽到位啦 。  哈哈哈哈哈。 

 注意了 面绘制

 1         //得到旋转矩阵
 2         double[,] RotateArbitraryLine(Point3dF v1, Point3dF v2, double theta)
 3         {
 4             
 5             double a = v1.x;
 6             double b = v1.y;
 7             double c = v1.z;
 8             Point3dF p = new Point3dF(v2.x - v1.x, v2.y - v1.y, v2.z - v1.z);
 9             //v2归一化
10             double x_p2 = p.x / Math.Sqrt(Math.Pow(p.x, 2) + Math.Pow(p.y, 2));
11             double y_p2 = p.y / Math.Sqrt(Math.Pow(p.x, 2) + Math.Pow(p.y, 2));
12 
13             if (double.IsNaN(x_p2))
14                 x_p2 = 0;
15             if (double.IsNaN(y_p2))
16                 y_p2 = 0;
17 
18             double u = x_p2;
19             double v = y_p2;
20             double w = 0d;// -130d;// 0d;
21 
22             double uu = u * u;
23             double uv = u * v;
24             double uw = u * w;
25             double vv = v * v;
26             double vw = v * w;
27             double ww = w * w;
28             double au = a * u;
29             double av = a * v;
30             double aw = a * w;
31             double bu = b * u;
32             double bv = b * v;
33             double bw = b * w;
34             double cu = c * u;
35             double cv = c * v;
36             double cw = c * w;
37 
38             double costheta = Math.Cos(theta);
39             double sintheta = Math.Sin(theta) ;
40             double[,] pOut = new double[4, 4];
41             pOut[0,0] = uu + (vv + ww) * costheta;
42             pOut[1,0] = uv * (1 - costheta) + w * sintheta;
43             pOut[2,0] = uw * (1 - costheta) - v * sintheta;
44             pOut[3,0] = 0;
45                   
46             pOut[0,1] = uv * (1 - costheta) - w * sintheta;
47             pOut[1,1] = vv + (uu + ww) * costheta;
48             pOut[2,1] = vw * (1 - costheta) + u * sintheta;
49             pOut[3,1] = 0;
50                   
51             pOut[0,2] = uw * (1 - costheta) + v * sintheta;
52             pOut[1,2] = vw * (1 - costheta) - u * sintheta;
53             pOut[2,2] = ww + (uu + vv) * costheta;
54             pOut[3,2] = 0;
55                   
56             pOut[0,3] = (a * (vv + ww) - u * (bv + cw)) * (1 - costheta) + (bw - cv) * sintheta;
57             pOut[1,3] = (b * (uu + ww) - v * (au + cw)) * (1 - costheta) + (cu - aw) * sintheta;
58             pOut[2,3] = (c * (uu + vv) - w * (au + bv)) * (1 - costheta) + (av - bu) * sintheta;
59             pOut[3,3] = 1;
60 
61             return pOut;
62         }

图片 13

起先之饶舌

尽起始自从没绘制面只是绘制的顶点线框而就 。然后自己思做的是转 
让他改变起来,总共六个点并成线便是立方体了,哪怕是low逼的线条
只要反起来是匪是就是出立方体的样子了。  哇哈哈哈哈。最先河自思的很粗略啊
立体的旋转也并未啥不得了之啊 ,比如饶y轴转动 我将他真是平面的免就得矣么
y不变x和z变。 绕x轴旋转 同理。 我原也描绘过面的接触进展盘的计。
为了顺应图形学上的正统方法 最后自己或利用二维矩阵旋转的法子: 

前方的都是出头挖的人家的,这多少个力量相对是自己挑出的。起头这些管是有限星星以内的线绘制啥的且不得不算
点绘制 
,我们现在假如举办面绘制。首先你假若了然的是本身之顶点三角面片数据已经为起了,
3d坐标点打在半透明纸张上 的x,y 也都得出了。 调用gdi的fillpath按ABC
的一一并起来 就会绘制一个三角形面片 是免是那多少个简短。不过先别慌
还有少数个问题需处理,一个即是可会师判别。 就是少数只三角面片 的岗位
决定了 在透视投影的时段什么人在前头什么人在晚, 还有面相交的图景呢 ?
是免是挺复杂?其实根本无须管,尽管要管 只要你用z缓冲算法 也未是老复杂
zbuffer 。就是在请来屏幕x y过后拿与xy的点z越走近视点的在前方
这样即使达到目标了。这里我们先 不管这么些zbuffer算法 
下次出空暇了我们还来形容。这里我们以此外一种植办法
通过辨认正向面与继为面来达到目的。前边大家无是说了吗 :

再有本人的油画机镜头是稳的 ,其实还有许多行事索要进行  。
希望各位大大继续系数。看下效果 是未是有模有样:上个gif图:
图片 14
您得管平面面向视频机判别函数重返的值反为一下探访啊效用,是匪是看出内壁的那一端了 是无是颇神奇哇哈哈哈哈
举凡的你没看错就这么几百推行为主组成部分就落实了  差不多都是数学知识
,其他的依然加砖加瓦的行,原理都当当时了。 好了
未来重新看DirectX 啊OpenGL啊 图形学
变换矩阵啊那一个的 别被胁迫住了 没那么难以之。
按理的语句这个知识总体来说蛮难的 不过总依然仿过高中的向量 
两向量垂直时点积等于零 这一个之类的  , 靠在摸着石头过河
把这多少个半懂不懂的知识 拼凑起来 加上各样度娘 和查资料 来实现
没想到居然成功了。 意外意外  ,当然学习是假诺依赖自己的 
你想直接度娘给您下个你只要之机能 这是匪容许的。

 

极端数据显现

 1         public void RotationTest2()
 2         {
 3 
 4             //二维空间旋转矩阵为 : x是角度
 5             //cos(x)  -sin(x)   (1-cos(x))tx+ty*sin(x))  x
 6             //Sin(x) cos(x)     (1-cos(x))ty-tx*sin(x)) y
 7 
 8             //2pi 等于360度
 9             //绕y轴旋转
10             //double xita = ((Math.PI * 2d) / 360d) * 2d;
11             double xita = ((Math.PI * 2d) / 360d) * anglex;
12             double cosx = Math.Cos(xita);
13             double sinx = Math.Sin(xita);
14 
15             double xitay = ((Math.PI * 2d) / 360) * angley;
16             double cosy = Math.Cos(xitay);
17             double siny = Math.Sin(xitay);
18 
19             for (int i = 0; i < msh.points.Count; i++)
20             {
21                 //Point3dF tmpPoint = new Point3dF(msh.points[i].x, msh.points[i].y, msh.points[i].z);
22                 Point3dF tmpPoint = new Point3dF(mshSource.points[i].x, mshSource.points[i].y, mshSource.points[i].z);
23                 msh.points[i].x =
24                     tmpPoint.x * cosx + ((-sinx) * tmpPoint.z) +
25                 (((1d - cosx) * 0d) + ((-130d) * sinx));
26 
27                 msh.points[i].z =
28                     tmpPoint.x * sinx + (cosx * tmpPoint.z) +
29                     (((1d - cosx) * (-130d)) - ((0d) * sinx));
30 
31                 msh.points[i].y = tmpPoint.y;
32 
33                 //---------------------------------
34                 tmpPoint = new Point3dF(msh.points[i].x, msh.points[i].y, msh.points[i].z);
35 
36                 msh.points[i].y = tmpPoint.y * cosy + ((-siny) * tmpPoint.z) +
37                 (((1d - cosy) * 0d) + ((-130d) * siny));
38 
39                 msh.points[i].z = tmpPoint.y * siny + (cosy * tmpPoint.z) +
40                     (((1d - cosy) * (-130d)) - ((0d) * siny));
41             }
42 
43         }

图片 15

图片 16
咱通过测算每个三角面片的法向量, 然后我们出一个视点到三角面片的往量
,通过测算两奔量的点积 
图片 17接下来经过反余弦函数就可汲取两通向量之夹角
。 假如夹角大于90过表示三角面片正往面朝着视点,
假如小于90渡过表示刚刚奔面背对了视点, 则免对准之三角面片实行渲染。如此一来
你精心想想 大家的立方体至始至终不会面在一个面把其他一个面遮的状。
哼了规律讲至此 好下 依据原理撸代码:

图片 18

近日本人眷恋做的是召开一个跟球效果 。鼠标按下拖动的时刻吃物体
像烤肉串样绕在平等绝望轴转动。 网上跟球都是转相机
大家这里直接旋转物体坐标。绕在任意轴旋转啊绕着任意轴旋转的矩阵 说实话
3D旋转矩阵这一个自家弄不知晓 ,我看不了解推导过程 可是我会看公式 哇哈哈哈哈。
https://www.cnblogs.com/graphics/archive/2012/08/10/2627458.html
另外的博文里贴出来的团团转矩阵也是这样 直接把他的代码抄下来之  ,c++的
我抄成c#的 没啥难之 我就越好把c++代码了。总之我们只要做的就是
得出一个二维数组作为矩阵回传
让有坐标遵照这一个矩阵展开演算。注意有点儿只基本概念:  两独点相减 a-b 
得发的是 b到a 的朝量 (0,0) -(1,1)  =(-1,-1)  ,然后是向量归一化:
什么给归一化, 就是 把向量的主旋律无变换 长度变至单位长度
,也固然是1。问于量归一化怎么来  。好
,比如一个二维向量,总结原理就是经过距离总括公式图片 19得出距离。这多少个离与1底比率等于 现x与归一化后x的比率:图片 20求归一化后y的值同理。当然那多少个都是基础的没什么特别说之。
请旋转矩阵的函数:

图片 21

说是3D发动机确实暴发硌过于博眼球了,其实就是贯彻了一个看透投影,当然为无是那么粗略的。
此篇稿子是彻头彻尾让多少白看的 高手请不喷 。也称为小为带您图学入门基础 。
哇哈哈哈哈 一游说及做一个3D画面的东东 一说总是顶DirectX  OpenGL 那个实物儿
我们这么些菜鸟总是 想到哇擦擦 哇C++的   哇
计算机图形学好难。这游戏意儿难度好慌。其实即便那么回事儿 ,DirectX OpenGL
只是工具 而已, 只要将原理为了解了
你看我为此low逼的GDI照样吃你绘制一个3D物体 可以这样说固然无须GDI
其他任何可以划线 画点的东西
,我在安卓平台上如故被你兑现之效果。不要局限为工具
什么人说开3D便只好用DirectX OpenGL了 ,哪个人说做3D不得不用C++了  。

发端的饶舌

函数写好了 矩阵也会查获了,还来只问题:函数的这么些参数
,旋转的度数也好搞 按下之时段记录一个点 拖动的时段总计和他的离开
距离作为度数 拖动50诸如素 旋转50渡过。
旋转之那么根本儿轴你怎么得出去,起始接触好 立方体的为主是0 0 -130 
。按下的当儿记录了本下开接触 鼠标的位移就都是一个向量了
所以大家只是待对斯向量 绕z轴举办90度旋转 ,z也设成-130
就与中央点同样并了 就是索要的烤肉串儿的旋转轴了。 好 原理讲得了了
,代码走由:

吓那我们为以此方法来定义数据 ,我们定义之事物是一个 主题地方于(
0,0,-130)处的立方体。我们的观察点在(0, 0, 0)处 正对正在立方体观看。
由于我们想念叫立方体一个迎之颜色一样,所以是有限独为同一组定义之
,当然三角形也是因同等的
两单吗同组 组成一个刚刚方形面。由此对体表面空间点的讲述数据就是搞好了。
好 ,定义数据的代码:

自己数学底子差 在描写这一个事例往日参考了成千上万前辈的
图形学理论基础。最假设看破投影 和3D旋转矩阵绕任意轴旋转
。甚至未曾全弄懂 于是自己不怕抄自代码开为了。
不得不说立即戏意儿真的非凡有趣。
先是是看破投影:http://blog.csdn.net/popy007/article/details/1797121
作者说的良详细 其实我偏偏盼一半 ,后边矩阵推导这个最为难矣 没有继续为生啃
。视线是一个分流的计从一个沾出去
(其实说到底发现并非管什么视椎体不视椎体的)。
假诺视点前边来同一张半晶莹剔透底纸张
视线上的点是怎打到纸张上之?关于这么些题目  你一旦粗暴点确实挺简短
就是三角形 初中的学问。
图片 22

图片 23

 

其他的

 注意了 面绘制

 1         public class Marsh
 2         {
 3             public List<Point3dF> points;
 4             public Marsh()
 5             {
 6                 points = new List<Point3dF>();
 7 
 8                 //0
 9                 Point3dF pointA = new Point3dF(30, 30, -160);
10                 //1
11                 Point3dF pointB = new Point3dF(-30, 30, -160);
12                 //2
13                 Point3dF pointC = new Point3dF(-30, -30, -160);
14                 //3
15                 Point3dF pointD = new Point3dF(30, -30, -160);
16                 //4
17                 Point3dF pointE = new Point3dF(30, 30, -100);
18                 //5
19                 Point3dF pointF = new Point3dF(-30, 30, -100);
20                 //6
21                 Point3dF pointG = new Point3dF(-30, -30, -100);
22                 //7
23                 Point3dF pointH = new Point3dF(30, -30, -100);
24 
25                 points.Add(pointA);
26                 points.Add(pointB);
27                 points.Add(pointC);
28                 points.Add(pointD);
29 
30                 points.Add(pointE);
31                 points.Add(pointF);
32                 points.Add(pointG);
33                 points.Add(pointH);
34 
35                 
36 
37                 path1 = new List<int>() { 
38                     4, 6,7,
39                     4,5,6,
40                     5 ,2 ,6,
41                     5, 1, 2,
42                     1 ,3 ,2,
43                     1, 0 ,3,
44                     0 ,7 ,3,
45                     0 ,4, 7
46                     ,
47                     4, 1, 5,
48                     4 ,0 ,1,
49                     6, 2 ,7,
50                     2, 3, 7
51                 };
52 
53                 faceColors = new List<Brush>();
54                 Random rdm = new Random();
55 
56                 for (int i = 0; i < 6; i++)
57                 {
58                     Brush b= new SolidBrush(Color.FromArgb(rdm.Next(0, 255), rdm.Next(0, 255), rdm.Next(0, 255)));
59                     //Brush b = new SolidBrush(Color.FromArgb(266 / 6 * i, 266 / 6 * i, 266 / 6 * i));
60                     faceColors.Add(b);
61                     faceColors.Add(b);
62                 }
63                 
64             }
65             public List<Brush> faceColors;
66             public List<int> path1;
67 
68         }

光照这戏意儿仍旧 用到三角面片的法向量 ,三角面片正对正在光 则表面亮度最高
,垂直则变为黑暗。参照面绘制的规律就是可做出来
我这边就每个面各用几五颜六色的水彩算了吧 懒得整了。

自我数学底子差 在描写这例子此前参考了森前辈的
图形学理论基础。最要害是看破投影 和3D旋转矩阵绕任意轴旋转
。甚至不曾全弄懂 于是自己就抄起代码开为了。
不得不说就游戏意儿真的至极有趣。
首先是看破投影:http://blog.csdn.net/popy007/article/details/1797121
作者称的杀详细 其实我特盼一半 ,前面矩阵推导那一个极端碍事矣 没有继续为生啃
。视线是一个分流的法子自一个点出去
(其实说到底发现并非管什么视椎体不视椎体的)。
假如视点后边来同一摆放半晶莹剔透底纸
视线上的点是怎从到纸张上之?关于这题目  你若粗暴点确实怪粗略
就是三角形 初中的学识。 
图片 24

 1         private void Form1_MouseMove(object sender, MouseEventArgs e)
 2         {
 3             //必须要得出旋转的轴才行
 4             if (pressed)
 5             {
 6 
 7                 //中心点 0,0,-130
 8                 //通过拖动远近决定旋转角度,垂直向量 得到旋转轴
 9 
10                 //得出鼠标拖动向量 
11 
12                 Point3dF dragJuli = new Point3dF((e.Location.X - startPoint.X),( e.Location.Y - startPoint.Y),-130d);
13                 //还要旋转90度才是真正的旋转轴
14                 //cos(x)  -sin(x)
15                 //Sin(x) cos(x)  
16                 double cos90=0d;
17                 double sin90=1d;
18                 var x = dragJuli.x * 0d + dragJuli.y * 1d;
19                 var y = dragJuli.x * 1d + dragJuli.y * 0d;
20 
21                 Point3dF dragJuli2 = new Point3dF(x, y, dragJuli.z);
22 
23                 //Point3dF dragJuli90=
24                 //x1 x2+y1 y2=0
25                 //double x2=(-dragJuli.y)/(dragJuli.x);
26                 //垂直的旋转轴向量
27                 //Point3dF roll = new Point3dF(x2, 1, -130);
28 
29                 //拖动距离 拖动距离等于角度
30                 angelourua= Math.Sqrt(Math.Pow((e.Location.X - startPoint.X), 2) + Math.Pow((e.Location.Y - startPoint.Y), 2));
31                 angelourua = angelourua % 360;
32                 angelourua = ((Math.PI * 2d) / 360d) * angelourua;
33 
34                 double[,] roatMatarix= RotateArbitraryLine(new Point3dF(0, 0, -130d), dragJuli2,angelourua);
35 
36                 RotationTest(roatMatarix);
37                 paint();
38 
39             }
40         }

就是说3D发动机确实暴发硌过于博眼球了,其实即便是落实了一个看透投影,当然为无是那么简单的。
此篇稿子是彻头彻尾让多少白看的 高手请不喷 。也叫小为带您图学入门基础 。
哇哈哈哈哈 一游说交做一个3D画面的东东 一说总是顶DirectX  OpenGL 这个东西儿
我们这个菜鸟总是 想到哇擦擦 哇C++的   哇
统计机图形学好难。这游戏意儿难度好死。其实就是那么回事儿 ,DirectX OpenGL
只是工具 而已, 只要拿原理为了然了
你看自己于是low逼的GDI照样吃您绘制一个3D物体 可以这么说不怕无须GDI
其他任何可以划线 画点的东西
,我在安卓平台上还是被你实现之效果。不要局限为工具
谁说开3D即使不得不用DirectX OpenGL了 ,什么人说做3D只能用C++了  。

 

 1         //平面是否面向摄像机的判别
 2         public bool angelCalc( Point3dF A,Point3dF B,Point3dF C)
 3         {
 4             //https://zhidao.baidu.com/question/810216091258785532.html
 5             //AB、AC所在平面的法向量即AB×AC=(a,b,c),其中:
 6             //a=(y2-y1)(z3-z1)-(z2-z1)(y3-y1)
 7             //b=(z2-z1)(x3-x1)-(z3-z1)(x2-x1)
 8             //c=(x2-x1)(y3-y1)-(x3-x1)(y2-y1)
 9             
10             //先得出点 对应的向量
11             //Point3dF AB = new Point3dF(B.x - A.x, B.y - A.y, B.z - A.z);
12 
13             //首先求出法向量
14             double a = ((B.y - A.y)*(C.z - A.z) - (B.z - A.z)*(C.y - A.y));
15             double b = (B.z - A.z) * (C.x - A.x) - (C.z - A.z) * (B.x - A.x);
16             double c = (B.x - A.x) * (C.y - A.y) - (C.x - A.x) * (B.y - A.y);
17             Point3dF bb = new Point3dF(a, b, c);
18             //套公式 第二册 下b 39  通过两向量的cos函数 继而通过反余弦得出角度
19             var angelPlan =Math.Acos(
20                 (A.x * bb.x + A.y * bb.y + A.z * bb.z) / (
21                Math.Sqrt(Math.Pow(A.x, 2) + Math.Pow(A.y, 2) + Math.Pow(A.z, 2)) *
22                Math.Sqrt(Math.Pow(bb.x, 2) + Math.Pow(bb.y, 2) + Math.Pow(bb.z, 2))
23                )
24                );
25 
26             if (angelPlan > (Math.PI / 2))//法向量与镜头的夹角大于90度 代表三角面片面向摄像机 则可见
27                 return true;
28             else//否则不可见
29                 return false;
30         }

纠缠在以标轴举办盘  

 1         private void Form1_MouseMove(object sender, MouseEventArgs e)
 2         {
 3             //必须要得出旋转的轴才行
 4             if (pressed)
 5             {
 6 
 7                 //中心点 0,0,-130
 8                 //通过拖动远近决定旋转角度,垂直向量 得到旋转轴
 9 
10                 //得出鼠标拖动向量 
11 
12                 Point3dF dragJuli = new Point3dF((e.Location.X - startPoint.X),( e.Location.Y - startPoint.Y),-130d);
13                 //还要旋转90度才是真正的旋转轴
14                 //cos(x)  -sin(x)
15                 //Sin(x) cos(x)  
16                 double cos90=0d;
17                 double sin90=1d;
18                 var x = dragJuli.x * 0d + dragJuli.y * 1d;
19                 var y = dragJuli.x * 1d + dragJuli.y * 0d;
20 
21                 Point3dF dragJuli2 = new Point3dF(x, y, dragJuli.z);
22 
23                 //Point3dF dragJuli90=
24                 //x1 x2+y1 y2=0
25                 //double x2=(-dragJuli.y)/(dragJuli.x);
26                 //垂直的旋转轴向量
27                 //Point3dF roll = new Point3dF(x2, 1, -130);
28 
29                 //拖动距离 拖动距离等于角度
30                 angelourua= Math.Sqrt(Math.Pow((e.Location.X - startPoint.X), 2) + Math.Pow((e.Location.Y - startPoint.Y), 2));
31                 angelourua = angelourua % 360;
32                 angelourua = ((Math.PI * 2d) / 360d) * angelourua;
33 
34                 double[,] roatMatarix= RotateArbitraryLine(new Point3dF(0, 0, -130d), dragJuli2,angelourua);
35 
36                 RotationTest(roatMatarix);
37                 paint();
38 
39             }
40         }

终点数据见

 

吓就是这么 先举办3d空间的触发转,
再拓展平面坐标映射绘制 用线连起来。是勿是就是暴发接触3D立体之楷模了。哇哈哈哈哈

 1         public void RotationTest2()
 2         {
 3 
 4             //二维空间旋转矩阵为 : x是角度
 5             //cos(x)  -sin(x)   (1-cos(x))tx+ty*sin(x))  x
 6             //Sin(x) cos(x)     (1-cos(x))ty-tx*sin(x)) y
 7 
 8             //2pi 等于360度
 9             //绕y轴旋转
10             //double xita = ((Math.PI * 2d) / 360d) * 2d;
11             double xita = ((Math.PI * 2d) / 360d) * anglex;
12             double cosx = Math.Cos(xita);
13             double sinx = Math.Sin(xita);
14 
15             double xitay = ((Math.PI * 2d) / 360) * angley;
16             double cosy = Math.Cos(xitay);
17             double siny = Math.Sin(xitay);
18 
19             for (int i = 0; i < msh.points.Count; i++)
20             {
21                 //Point3dF tmpPoint = new Point3dF(msh.points[i].x, msh.points[i].y, msh.points[i].z);
22                 Point3dF tmpPoint = new Point3dF(mshSource.points[i].x, mshSource.points[i].y, mshSource.points[i].z);
23                 msh.points[i].x =
24                     tmpPoint.x * cosx + ((-sinx) * tmpPoint.z) +
25                 (((1d - cosx) * 0d) + ((-130d) * sinx));
26 
27                 msh.points[i].z =
28                     tmpPoint.x * sinx + (cosx * tmpPoint.z) +
29                     (((1d - cosx) * (-130d)) - ((0d) * sinx));
30 
31                 msh.points[i].y = tmpPoint.y;
32 
33                 //---------------------------------
34                 tmpPoint = new Point3dF(msh.points[i].x, msh.points[i].y, msh.points[i].z);
35 
36                 msh.points[i].y = tmpPoint.y * cosy + ((-siny) * tmpPoint.z) +
37                 (((1d - cosy) * 0d) + ((-130d) * siny));
38 
39                 msh.points[i].z = tmpPoint.y * siny + (cosy * tmpPoint.z) +
40                     (((1d - cosy) * (-130d)) - ((0d) * siny));
41             }
42 
43         }

  

图片 25

 

关于透视投影 和终点绘制

 

 

纠缠在为标轴举行盘  

关于光照

率先是3D编程中通用的数目表现 那即便是极组成的网格数据 称之为mesh,
3个点吗同组  组成的三角形面片数据。多只点顺时针的取向那么 箭头方向也他表面
另一样面吧外表面 ,在绘制的时 内表面不可见。
图片 26

 1         public void paint()
 2         {
 3             Graphics gph = Graphics.FromHwnd(this.Handle);
 4             gph.Clear(Color.Lavender);
 5             //进行到屏幕坐标的映射(x y z)
 6             //p~ =(-n x/z       -n y/z      -n)
 7             PointF screenLastPoint= PointF.Empty;
 8             for (int i = 0; i < msh.path1.Count / 3; i++)
 9             {
10                 //if (i >= 4)
11                 //    return;
12                 PointF screenPointA = new PointF((float)((-nearPlan) * (msh.points[msh.path1[i * 3]].x / msh.points[msh.path1[i * 3]].z)) , (float)((-nearPlan) * (msh.points[msh.path1[i * 3]].y / msh.points[msh.path1[i * 3]].z))  );
13                 PointF screenPointB = new PointF((float)((-nearPlan) * (msh.points[msh.path1[i * 3 + 1]].x / msh.points[msh.path1[i * 3 + 1]].z)) , (float)((-nearPlan) * (msh.points[msh.path1[i * 3 + 1]].y / msh.points[msh.path1[i * 3 + 1]].z))  );
14                 PointF screenPointC = new PointF((float)((-nearPlan) * (msh.points[msh.path1[i * 3 + 2]].x / msh.points[msh.path1[i * 3 + 2]].z))  , (float)((-nearPlan) * (msh.points[msh.path1[i * 3 + 2]].y / msh.points[msh.path1[i * 3 + 2]].z))  );
15 
16                 screenPointA.Y = -screenPointA.Y;
17                 screenPointB.Y = -screenPointB.Y;
18                 screenPointC.Y = -screenPointC.Y;
19 
20                 screenPointA.Y=screenPointA.Y+offsety;
21                 screenPointB.Y= screenPointB.Y+offsety;
22                 screenPointC.Y = screenPointC.Y + offsety;
23 
24                 screenPointA.X = screenPointA.X + offsetx;
25                 screenPointB.X = screenPointB.X + offsetx;
26                 screenPointC.X = screenPointC.X + offsetx;
27 
28                 System.Drawing.Drawing2D.GraphicsPath ph = new System.Drawing.Drawing2D.GraphicsPath(
29                     new PointF[] { screenPointA, screenPointB, screenPointC },
30                     new byte[] { 1, 1, 1 },
31                     System.Drawing.Drawing2D.FillMode.Winding);
32 
33 
34                 //---求法向量及夹角 如果为true 则渲染面//计算当前管线三角面片的法向量 是否朝着镜头 ,最终决定是否可见
35                 if (angelCalc(msh.points[msh.path1[i * 3]], msh.points[msh.path1[i * 3+1]], msh.points[msh.path1[i * 3+2]]) == true)
36                     gph.FillPath(msh.faceColors[i], ph);
37             }
38 
39             //绘制边框
40             gph.DrawLine(Pens.Red, new PointF(offsetx - 36, offsety - 36), new PointF(offsetx + 36, offsety - 36));
41             gph.DrawLine(Pens.Red,  new PointF(offsetx + 36, offsety - 36),new PointF(offsetx + 36, offsety + 36));
42             gph.DrawLine(Pens.Red, new PointF(offsetx + 36, offsety +36), new PointF(offsetx - 36, offsety + 36));
43             gph.DrawLine(Pens.Red, new PointF(offsetx - 36, offsety + 36), new PointF(offsetx - 36, offsety - 36));
44 
45             ////绘制网格线
46             //screenLastPoint = PointF.Empty;
47             //for (int i = 0; i < msh.path1.Count / 3; i++)
48             //{
49             //    //if (i >= 4)
50             //    //    return;
51             //    PointF screenPointA = new PointF((float)((-nearPlan) * (msh.points[msh.path1[i * 3]].x / msh.points[msh.path1[i * 3]].z)), (float)((-nearPlan) * (msh.points[msh.path1[i * 3]].y / msh.points[msh.path1[i * 3]].z)));
52             //    PointF screenPointB = new PointF((float)((-nearPlan) * (msh.points[msh.path1[i * 3 + 1]].x / msh.points[msh.path1[i * 3 + 1]].z)), (float)((-nearPlan) * (msh.points[msh.path1[i * 3 + 1]].y / msh.points[msh.path1[i * 3 + 1]].z)));
53             //    PointF screenPointC = new PointF((float)((-nearPlan) * (msh.points[msh.path1[i * 3 + 2]].x / msh.points[msh.path1[i * 3 + 2]].z)), (float)((-nearPlan) * (msh.points[msh.path1[i * 3 + 2]].y / msh.points[msh.path1[i * 3 + 2]].z)));
54 
55             //    screenPointA.Y = -screenPointA.Y;
56             //    screenPointB.Y = -screenPointB.Y;
57             //    screenPointC.Y = -screenPointC.Y;
58 
59             //    screenPointA.Y = screenPointA.Y + offsety;
60             //    screenPointB.Y = screenPointB.Y + offsety;
61             //    screenPointC.Y = screenPointC.Y + offsety;
62 
63             //    screenPointA.X = screenPointA.X + offsetx;
64             //    screenPointB.X = screenPointB.X + offsetx;
65             //    screenPointC.X = screenPointC.X + offsetx;
66 
67             //    gph.DrawLine(Pens.Red, screenPointA, screenPointB);
68             //    gph.DrawLine(Pens.Red, screenPointB, screenPointC);
69             //    gph.DrawLine(Pens.Red, screenPointC, screenPointA);
70 
71             //}
72 
73         }

便如始所述 视点在(0,0,0) 处看于 位于(0,0,-130) 的立方体 
,如果有一绑架视频机 
,那么上图虽是外的自空间看下的俯视图。设p为(x,z)  p’为(x’
,z’) 。则x’=-N(x/z)  y’=-N(y/z)。为了方便
大家的数额定义为是跟示意图上多的。于是我们依葫芦画瓢
把持有的点绘制出来 包装成一个paint函数。
亟待小心的凡平面坐标系 跟屏幕坐标中的易 ,其实不麻烦
你别计量以数学公式 数学函数 依旧一样该咋算咋算。
 完成后大家平面坐标系的0,0  对许屏幕坐标的0,0   。
图片 27图片 28
看来没 x轴0左边也是负数 不用无  就然则是y的标志不同等
变成-y就可以了。然后假诺给他亮在窗口中  还要开展偏移 就是x加偏移,
y加偏移  就这样尽管形成啦 。  哈哈哈哈哈。 

 

图片 29

图片 30

相关文章