2015年你必须学习的编程语言和前端框架
 
 各种前端开发库和前端框架在不断的更新，为了适应潮流的需要，你必须不断的学习新的东西。但是下面提到的编程语言和前端框架会在很长的时间内占据重要的位置，学习和掌握它们是值得的和必须的。从长远来看，它们是十分受欢迎的，被广大社区支持，并且提供很多的就业机会。
 
 
 
 JAVASCRIPT
 
 
 如果你正在从事前端web的开发工作，那么不论你使用什么后台语言，前台开发中javascript使你必须掌握的语言。你可以在浏览器中、在服务器上、在移动app中、甚至是在可编程硬件上使用JS。ECMAScript 6将会使语言更强大、更易于编写。更好的方法是学习Bower 和 npm，以及使用 jshint和 jscs等工具来编写代码和检查错误。
 
 　ANGULARJS
 
 
 AngularJS 是谷歌的一个javascript框架。它能够很容易的建立各种强大的WEB应用程序。你会发现在各种前端工作的招聘中，都提到需要你掌握AngularJS。但是你先不要急着完全掌握它，有消息透露，在新的2.0版本中，AngularJS将作出重大的改进和调整。你可以参考guide angularjs examples。
 
 REACT　
 
 
 React是一个新东西，它的理念是可重复使用的WEB组件。这个库是由Facebook开发的，因为是虚拟DOM，它的性能非常突出，它还能很容易的集成到其它项目中。它还有一个非常活跃的、可开发各种组件的社区的支持。在我们看来，React是很有潜力的，你应该在2015年掌握它。
 
 NODE.JS
 
 
 使用Node.js，你可以使用javascript开发网络服务器应用程序。它可以用于简单的网站后台框架如：Express， API endpoints， websocket服务，甚至是 torrent clients。NodeJS有一个活跃的社区支持其模块的编写。如果你是一个初学者，我们建议你从 NodeSchool 开始学习。
 
 NOSQL DATABASES
 
 
 不需要SQL数据库表的数据库在目前还未流行，但是我们相信它会在不久的将来成为热门。有两个值得我们考虑的选择： Mongodb和Redis。它们的起步比MySQL数据库更容易。但是不要简单的认为NoSQL数据库是一个简单的替代-在某些情况下，一个典型的关系型数据库将更使你的开发容易，即使这需要付出更多的工作量。
 
 LESS/SASS/STYLUS
 
 
 CSS有时是十分令人困扰的，大于1000行的CSS代码你要想修改它是非常困难的，为了解决这些问题，出现了 Less 、 Sass 和 Stylus 等带变量和宏、可编译的CSS预处理语言。它们将能帮你写出更好的CSS代码。你可以选择其中之一来学习。
 
 NEW FRAMEWORKS
 
 
 Meteor 是一种全新的WEB应用开发方式，它模糊了前端和后端之间的界限。它允许你编写实时(reall-time)应用程序，并且有一个专门的社区为其编写各种应用程序包。 Hood.ie 提供了一种全新的方法，它可以帮你处理后台程序，是你可以完全投入到前台的开发当中。
 
 NEW LANGUAGES
 
 
 对于程序语言爱好者来说， Golang 、 Rust 和 Elixir 无疑是他们的新大陆。这些语言被在特殊情况下使用，它们需要非常高的性能支持。你可以从现在开始学习一些关于它们的知识。
 
 A CLASSIC FULL STACK FRAMEWORK
 
 
 虽然单页应用日益普及，但是仍有很多的服务器端的Web应用程序的需求。 Ruby on Rails 、 Django 、Laravel 、 Play 、ASP.NET是当前最顶级的全栈式框架。但是任何MVC框架都需要你花费大量时间去研究它。
 
 THE OLD GUARD
 
 
 许多平台和语言仍然是当前流行的 - Java 、 .NET 、 Python 、 Ruby 。这些语言有大量社区的支持，它们各自都有优点和缺点。当你选择它们时，最主要是看它是否能完成你当前的工作需要。
 
 DON’T FORGET THESE
 
 
 PHP、 WordPress 和 jQuery 仍然是创建网站的一个有效方式。WordPress已经超越了一个博客平台的范畴，它现在是一个功能强大的CMS /框架开发一个广泛的Web应用程序。如果你是一个设计师，你应该考虑选择这些技术了。如果你觉得使用PHP作为你的后台程序，那么请了解正确使用php的方法。如果你已经准备好了，请参考一下Bootstrap-它能帮助你写出优秀的前端代码。

MFC，是微软的;boland的VCL，不过好像已经卖给别的公司了;还有trolltech公司的QT(卖给了nokia)，这个支持跨平台。 
VC和Delphi作为开发平台，很重要的一点就是提供了一个"无所不包"的应用框架：VC的MFC和Delphi的VCL。MFC是用C++写的，VCL是用Object Pascal写的。当然，我们都知道，C++的使用范围比Object Pascal广得多，移植性也好得多。这本来是优点，但很有意思的是，正因为如此，微软写MFC时必须考虑最大限度减少对语言本身的改动，而把功夫下在源代码级，以便能尽可能支持ANSI等标准，结果导致MFC的封装复杂而不直观。(尤其是它对消息的封装，下文还会提到)。太多的宏定义和含义模糊且自动生成、不得改动的注释使MFC乃至VC让很多新手望而生畏，不敢"下水"深入学习。而Object Pascal几乎是Inprise"专用"的，不必考虑"标准"问题，因此Inprise写VCL时就把全部精力放在了结构与性能上，结果语言与框架的磨合程度非常好。VCL框架的结构清晰，VCL代码的可读性非常好。许多人说Delphi比较容易上手，也是这个缘故。天下没有白吃的午餐。你要工业标准吗？你要可移植性吗(关于可移植性和兼容性，下文会详细比较)？那么请面对MFC的"天书"级代码吧。 

编译和连接：The Need For Speed 
不同的语言带来的另一个不同是，编译和连接的速度的不同，以及执行速度的不同。Delphi的编译和连接速度，毫不夸张地说，比VC快几十倍。即使把VC的Incremental Link选项打开，Delphi的编译和连接速度仍比VC快好几倍。并不是说微软的编译器不行，这是由C++的复杂性决定的。模板的处理、预处理和宏的展开都是很费时的。前文不是提到Object Pascal没有模板、预处理和宏吗？这本来是缺点，但带来的一个好处就是编译速度极快。至于编译完的二进制代码，在打开相同的优化选项的情况下，Delphi和VC执行速度并没有太大的差别。 
为了克服编译的速度问题，C++编译器一般需要增强的连接器和预处理机制。但是预处理机制仍然存在若干问题：1）程序调试的断点行可能和代码行不同；2）没有将最新的代码信息综合进去；3）容易产生错误的逻辑；4）因为读错文件头而很容易产生类似"Unexpected End of File"的错误。 
两个编译器有个共同点是都能识别无用的"死"代码，比如一个没有用的函数等等。编译后的程序将不包含这些多余的信息。Delphi在这方面作得更加出色。它可以让你在编辑器中可视化地提示出那行代码是"活"的、那行代码是"死"的。这样你就能整理出最精简的代码。Delphi在编译后将在左边显示一个小蓝点表示这行代码是"活"的。Visual C++做不到这点。 
Delphi编译后可执行文件至少有200K（如果不使用VCL，仅仅使用WinAPI，文件的大小将大大缩小）但是Visual C++编程使用MFC编译后的可执行文件通常只有几十K，主要是因为微软已经将系统运行库包含在Windows系统了（Borland公司曾经和微软协商这个接口，但是微软利用操作系统的优势不愿意公开）。同样道理，使用BDE开发的的数据库程序必须附带3-5M的额外系统文件，也是非常不协调的。 
非常有趣的是，Delphi能够使用由C++ Builder创建的的OBJ文件，但是使用上受很大的局限性。 
最后，Visual C++的编译和连接时的错误信息比Delphi要详细和具体的多。特别是使用ATL开发更加如此。 

应用框架：MFC？有KFC流行吗？ 
应用程序框架(Application Frame)，有时也称为对象框架。Visual C++采用的框架是MFC。MFC不仅仅是人们通常理解的一个类库(同样，Delphi的VCL也不仅仅是一个控件库，尽管它的名字叫"可视控件库")。你如果选择了MFC，也就选择了一种程序结构，一种编程风格。MFC早在Windows 3.x的时代就出现了，那时的Visual C++还是16位的。经过这些年的不断补充和完善，MFC已经十分成熟。但由于原型出现得比较早，MFC相比于VCL落后了一个时代。尽管微软对MFC的更新没有停止，我也经常读到"只要Windows不过时，MFC就不会过时"之类观点的文章，但就象Inprise(原Borland)的OWL框架的淡出一样，MFC的淡出也是早晚的事。其实MFC是和OWL同一个时代的产物。OWL已经不在了，MFC怎能不"居安思危"呢？如果MFC青春永驻，微软的开发人员也不会"私自"开发出基于ATL的WTL呀。当然，WTL的地位不能和MFC比，它并不是微软官方支持的框架，封装的功能也相当有限。但至少也反衬出了MFC存在的不足。 
我们以为，最能体现一个应用程序框架的先进性的是它的委托模型，即对Windows消息的封装机制。对Windows API的封装就不用说了吧。大同小异，也没什么技术含量。如果高兴，你也可以自己写一个类库来封装。但对Windows消息驱动机制的封装就不是那么容易的了。最自然的封装方式是采用虚成员函数。如果要响应某个消息就重载相应的虚函数。但出乎我的意料，MFC采用的是"古老"的宏定义方法。用宏定义方法的好处是省去了虚函数VTable的系统开销(由于Windows的消息种类很多，开销不算太小)。不过带来的缺点就是映射不太直观。对于MFC，则是"太不直观"了。它的消息映射代码虽然是可见的，但"劝君莫碰"。好在VC的ClassWizard可以自动生成消息映射代码，使用起来还算方便。但和VCL的委托模型相比，MFC的映射方法就显得太落后了。而Delphi的Object Pascal因为没有"标准负担"，语言引入了组件、事件处理、属性等新特性。由于功夫做在编译器级，生成的源代码就显得十分简洁。似乎VC是"让框架迁就语言"，而Delphi是"让语言迁就框架"。 
我想举一个对字符串操作的封装的例子来说明MFC和VCL的优缺点。在MFC中，CStringList类有加入、获取、删除等功能，但VCL的TStringList类除了上述功能还有排序、从逗号分隔的字串读入、流输入输出等功能。但同样的字符串替换功能，VCL的StringReplace要比MFC的CString::Replace慢2－3倍。总的来说，VCL的封装比MFC更为高层，更为抽象，但不可避免地带来的问题是某些部分执行效率比MFC略低。这就象低级语言(如汇编)的执行效率比高级语言(如Basic)高，但编程效率较低。鱼和熊掌不可兼得嘛。 
VCL比之MFC的另一优点是对异常处理的支持，而一大缺点是对多线程支持差。VCL的大部分都不是针对多线程优化的。虽说VCL提供了简化多线程操作的类，但只是工作者线程(worker threads)使用起来比较简单。如果线程要和界面打交道的话事情就变得麻烦了，因为除了应用程序的主线程，任何线程不能访问任何可视的VCL部件。你不得不使用Synchronize方法等待主线程处理它的消息，然后在主线程中访问VCL部件。而MFC就没有这样的限制。 

稳定性与完善程度：VC是老大哥 
VC要比Delphi稳定和完善。VC的发展历史比Delphi长，微软的总体实力比Inprise强。VC的框架MFC经历了那么多年的发展和完善，功能非常全面，而且十分稳定，bug很少。其中你可能遇到的bug也更少。而且有第三方的专门工具帮助你避开这些bug。如此规模的一个类库，能做到这一点不容易。不要小看了这一点，很多专业程序员就是为这个选择VC的。因为尽管VCL比MFC的抽象程度高，封装较为高层，但由此带来的开发效率的提高对高手来说毕竟是有限的。而如果你遇到一个怪问题，调试了半天，发现不是你的代码有错，而是VCL的bug，你作何感想？虽说遇到这类问题的可能性很小，但对VCL的形象的影响可不小。Delphi的IDE太占资源，启动速度太慢，和某些显卡驱动程序冲突，VCL中有bug，调试器不够健壮，对不稳定的第三方控件没有防护措施 …… 问题多多，在这方面Delphi不如VC。希望Inprise能更上一层楼。顺便说一下，我们在网上看到有些人极言Delphi的不稳定，说几分钟出现20多次非法操作。Delphi的确不如Visual C++稳定，但也不至于如此呀。我估计是那位朋友的Delphi装了某些有问题的第三方控件，导致了Delphi的频频出错。不妨卸下那些控件试试？ 

可移植性：立足现实，放眼未来 
Inprise正在开发Delphi的Linux版本，代号为Kylix。也许通过Kylix，用VCL构架编写的Windows程序向Linux移植成为可能。但这只是可能。因为在目前Inprise的兼容性工作做得并不好。低版本的Delphi不能使用高版本的VCL组件，而高版本的Delphi竟然不能使用低版本的VCL组件。真是岂有此理，我们很少看见软件有不向下二进制兼容的。如果Windows 98不能运行95的程序，Windows 95不能运行3.x的程序，Win 3.x不能运行DOS程序，你还会用Windows吗？如果Windows 95的程序必须经过重新编译才能在98下运行，98会卖得那么好吗？"同门兄弟"C++Builder和Delphi也不能互相使用对方的组件，甚至同一套VCL库的文件名也不一样。所以一个组件有for D1/D2/D3/D4/D5/C1/C3/C4/C5这些不同版本是常有的事，而且随着Delphi和C++Builder版本的升级可能还会增加。希望Inprise能先解决同门兄弟的兼容性问题。而微软的VC就没有这类问题。MFC1.0的程序也可以毫无障碍地在VC6.0下编译通过。 

集成界面：宏观与微观 
就大处说，VC的集成界面是不如Delphi的。Delphi仅仅一个Object Inspector就可以将VC的一堆Wizards比下去，何况它还有Code Explorer、ToDo List等。但从小处，又可以看出Delphi的不成熟。比如"自动完成"功能的智能化程度和提示详细程度不如VC，响应速度也没有VC快。 
Visual C++所带的MSDN是一部"开发者的百科全书"，信息庞大，查询方便，这方面比Delphi更专业。很多帮助项都有源程序示范。 
Delphi的OpenTools是完全面向第三方的开放系统，开发者可以修改很多Borland公司自身的功能，从IDE的可扩充性上说Delphi更好。 

调试：细微之处见真功 
Visual C++和Delphi的调试功能都非常强大，同时都具有单步可视化调试、断点跟踪、运行时改变变量、鼠标指向可以得到变量值等等功能。对DLL的输入输出也能方便的管理，能够进行源码级别的调试。 
相对而言，Visual C++能够更加方便地看到变量的变化情况，这包括对结构可以展开成数据树，从而了解每一个变量的值，每一步调试，变化了的变量会加红，从而使调试更加方便。另外，Visual C++的块内存察看比Delphi也要方便。 
当然，Delphi也有很多体贴的细微之处，比如在线程调试的时候，Delphi能够很方便地察看线程的变化，Visual C++却必须要弹出一个模式对话框。 

数据库开发：Delphi一枝独秀 
数据库支持是Delphi的强项。这主要体现在Delphi与BDE的无缝集成，以及Delphi提供的那一大堆现成的数据库操作控件。这是VC望尘莫及的。目前Delphi支持BDE、ADO、InterBase三种数据库访问方式。所有的方式都能拖拉到应用程序中实现可视化操作。正是因为Delphi对数据库类的包装，使得用户操作数据库不像在Visual C++中必须从开始到最后都要干预。明显地提高了开发速度。 
Delphi中使用WebBroker控件还能很方便地构造出基于数据库的Web页面，通过HTML管理Web数据库。 Visual C++访问数据主要通过ADO和OLEDB，很多ActiveX控件也能添加数据库功能。但是没有像Paradox这样的桌面数据库，Access相对功能太弱了。也许SQL Server是不错的选择。 

COM：新技术的力量 
COM是组件对象模型的缩写。它是OLE和ActiveX技术的基础，COM定义了一组API和一个二进制标准，让不同的编程语言、不同平台的彼此独立的对象相互进行通讯。 
COM是Microsoft制订的行业标准。但Delphi也为COM提供了强大的语言支持。支持接口、variant、宽字符串功能。这些对COM的封装确实比C++更方便。比如在C++（没有类框架）进行COM编程时，变体定义为oaidl.h文件中的VARIANT结构。要处理变体，必须手工调整oleaut32.dll中VariantXXXX() API函数对其进行初始化和管理，如VariantInit()、VariantCopy()、VariantClear()等等。 
Visual C++实现COM编程有一种特殊的方法就是使用ATL。ATL使用Visual C++特有的多重继承来实现COM接口。虽然不见得实现COM服务和控制更容易，但是ATL和最新COM技术的接口，基于模板的构造都比Delphi强。ATL更有利于建立小巧、快捷的COM组件程序。 
按目前通用的观点，Visual C++应用到COM服务程序更有优势，Delphi应用到COM组件程序更合适。 

昨天，今天，明天 
技术的进步在很多时候是此消彼长的。当初Borland的Turbo C和Borland C++几乎是C/C++程序员唯一的选择。微软的Quick C(现在还有人知道这个产品吗？)和Microsoft C/C++从来也没有成为过主流。但Borland C++又流行了多少年呢？不久就被新崛起的Microsoft Visual C/C++压下去了。于是Inprise(原Borland)拣起了当年Turbo Pascal和Borland Pascal的辉煌(事实上Borland的成名作就是第一个Pascal编译器)，全力推出了Delphi。Delphi当初推出时被称为VB杀手，但VB现在仍然活得挺好。毕竟微软是靠Basic起家的嘛，VB不是那么容易被打败的。Inprise想了想不和VB争了，使用Delphi的IDE和VCL配上C++语言，推出了C++Builder，又向Visual C++的市场发起了夹攻。C++Builder似乎是个不错的折衷选择了？再仔细想想！C++Builder的优点Delphi都有，但Delphi的优点C++Builder未必有。比如C++Builder的编译速度比VC还慢，哪能和Delphi比？而且因为VCL是Object Pascal写的，C++语言和VCL磨合得并不好。C++Builder的bug比Delphi还多，甚至Sample代码中还有错。VCL的部分功能不能使用，要靠嵌入pascal代码访问。C++Builder可用的第三方控件远没有Delphi多。 
唉，真是金无足赤。Microsoft和Inprise，谁会笑在最后呢？ 

鱼和熊掌：艰难的选择 
选择一个开发工具依赖于很多不同的因素，每个人都能因为某种语言的某个缺陷而放弃学习或使用这种语言。任何程序员都希望自己喜欢的工具能达到理想的境界，通过上面不完善的比较，我想大家都有自己的看法。我们认为影响大家选择开发语言的因素主要包括： 
1） 哪门语言更容易入门？ 
学习一种语言需要投入大量的时间和精力。开发程序的开发成本是值得考虑的现实。一个熟练的Delphi程序员和一个熟练的VC程序员工作效率是一样的。但是，成为熟练的程序员必须很快掌握一门语言的技巧。不幸的是，目前熟练的Visual C++程序员是十里挑一。相对而言，Delphi更适合初学者。 
2） 哪门语言有更多可继承的代码？ 
语言代码的可重用性是加快开发效率明显方面，从早期的过程、函数到现在的组件技术都是朝这个目标在奋斗。这两种语言对代码重用的理解是不一样的，Delphi主要通过VCL控件来实现代码重用，Visual C++实现起来就比较复杂。 
3） 语言自身的本性。 
就技术(主要指应用框架)来说，Delphi目前领先于Visual C++。但稳定性和健壮性的不足又让我对Inprise"想说爱你不容易"。而VC尽管发展到今日已十分完善，但MFC框架已是明日黄花了。如果不使用MFC，目前又没有合适的替代品。根据你的需要和实际情况做选择吧。实际上Visual C++和Delphi也不是简单竞争关系。它们在许多领域并不重叠，甚至是互补的。到底怎样取舍，要根据你的项目特性决定。如果你开发系统底层的东西，需要极好的兼容性和稳定性，选Visual C++吧。你可以只调用Windows的各种API，不用MFC。如果你写传统的Windows桌面应用程序，Visual C++的MFC框架是"正统"的选择；如果界面部分占这个应用程序代码比例较大的话，或者Delphi中有相关功能的控件的话，Delphi是事半功倍的选择。如果你为企业开发数据库、信息管理系统等高层应用("高层"是相对于"低层/底层"而言的，不是说技术高级或低级)，而且有比较紧的期限限制，选Delphi比较好。如果你熟悉的语言是Object Pascal，又不打算学复杂的C++，那么Delphi几乎是唯一的选择。传统的观点是：Delphi适合编写Internet/Intranet、表格制图、数据库操作、高级用户界面等等。Visual C++适合编写设备驱动、COM服务程序、科学计算、控制台（console）程序、WinCE的应用和一些小的工具等等。应用范围的不同要求好的程序员同时精通这两门语言。 
4） 语言的前景和可扩充性。 
Delphi是Inprise的旗舰产品之一，前景应当还是比较乐观的，而且Inprise已经在向Linux进军了，而微软还迟迟没有动作。遗憾的是，Inprise公司Delphi的创始人已经跳槽到微软去主持Visual J++和C#项目了。但愿对Inprise冲击不会太大。 
微软的Visual C++的前景又怎样呢？Visual Studio 7.0就要推出了。这一版本将加强网络开发的特性。看来微软虽然被判解体，开发实力可是一点没打折扣。 
另外，虽说MFC已稍显落后，但不是说它不值得学。事实上，不学MFC就等于没学VC。利用MFC框架开发程序仍然是目前开发桌面应用的主流模式，而且还会保持相当长的时间。微软公司CEO史蒂夫·巴尔默(Steve Ballmer)曾说，.NET流行还得等2－3年。那么，MFC至少还有2－3年的生命空间。在技术日新月异的IT界，2－3年实在是很长一段时间了。好好把握吧。即使你不使用MFC框架，花点时间看一下MFC的封装机制对你熟悉C++的OOP机制和Windows底层功能也是很有好处的。而VCL的源代码是Object Pascal的，对C/C++程序员就没有这个"额外"的作用了。
 
 Qt工具包是一个C++类库，并且是使用“一次编写，随处编译”的方式用于构建多平台图形用户界面程序的一套工具。Qt使程序员通过使用一个单一源程序来构建应用程序。该应用程序可以运行在Windows 95到XP、Mac OS X、Linux、Solaris、HP-UX和其它很多使用X11的Unix版本上。还有一个Qt的版本可以用于嵌入式Linux，它和桌面版本具有相同的应用程序编程接口.Qt是一个多平台的C++图形用户界面应用程序框架。它提供给应用程序开发者建立艺术级的图形用户界面所需的所用功能。Qt是完全面向对象的很容易扩展，并且允许真正地组件编程.从1996年早些时候，Qt进入商业领域，它已经成为全世界范围内数千种成功的应用程序的基础。Qt也是流行的Linux桌面环境KDE 的基础，KDE是所有主要的Linux发行版的一个标准组件。

中国最大的IT技术社区CSDN联合美国权威IT技术媒体CMP集团，共同为中国百万开发者带来的国内最权威的顶级软件技术大会----“2007 软件开发2.0技术大会”（SD2C）正在九华山庄火热进行当中。11月29日上午9点，在主会场中2.0大会顺利开幕。





有10年开发经验的老牌Delphi铁杆Fans，熟悉多种主流的编程语言和开发工具，已经在Borland工作了一年多的范路，在演讲中提到未来web开发趋势时，用有一个幽默的比喻：裸奔编程越来越少见，框架应用越来越普遍。



他指出几年前，开发一个软件时，一切都是从头开始：需要一个控件就编写控件；需要一个协议就写一个协议……现在，这种情况已经不存在了，我们有了框架！





     下面是他指出的几点主要变化： 

• 裸奔编程越来越少见，编程越来越依赖于各种框架

• 框架经过不断的发展，功能日趋完善。在不断提高的硬件性能的基础上，效率也基本上可以被人接受

• 框架的发展方向是越来越专业化

• 完全重新规划设计编写的程序越来越少

• 多种硬件、操作系统、数据库环境相结合的系统越来越多

• 分工更加明确





 

  原文出处： 
 Max Christ and Warren Moore   译文出处：
 migrant   欢迎分享原创到
 伯乐头条
 
 Metal 框架支持 GPU 加速高级 3D 图像渲染，以及数据并行计算工作。Metal 提供了先进合理的 API，它不仅为图形的组织、处理和呈现，也为计算命令以及为这些命令相关的数据和资源的管理，提供了细粒度和底层的控制。Metal 的主要目的是最小化 GPU 工作时 CPU 所要的消耗。– Metal Programming Guide
 
 Metal 是针对 iPhone 和 iPad 中 GPU 编程的高度优化的框架。其名字来源是因为 Metal 是 iOS 平台中最底层的图形框架 (意指 “最接近硬件”)。
 
 该框架被设计用来实现两个目标: 3D 图形渲染和并行计算。这两者有很多共同点。它们都在数量庞大的数据上并行运行特殊的代码，并可以在 GPU. 上执行。
 
 什么人应该使用 Metal?
 
 在谈论 API 和语言本身之前，我们应该讨论一下什么样的开发者能从 Metal 中受益。正如上面提过的，Metal 提供两个功能: 图形渲染和并行计算。
 
 对于寻找游戏引擎的开发者来说，Metal 不是最佳选择。苹果官方的的 Scene Kit (3D) 和 Sprite Kit (2D) 是更好的选择。这些 API 提供了包括物理模拟在内的更高级别的游戏引擎。另外还有功能更全面的 3D 引擎，例如 Epic 的 Unreal Engine 或 Unity，二者都是跨平台的。使用这些引擎，你无需直接使用 Metal 的 API，就可以从 Metal 中获益。
 
 编写基于底层图形 API 的渲染引擎时，除了 Metal 以外的其他选择还有 OpenGL 和 OpenGL ES。OpenGL 不仅支持包括 OSX，Windows，Linux 和 Android 在内的几乎所有平台，还有大量的教程，书籍和最佳实践指南等资料。目前，Metal 的资源非常有限，并且仅限于搭载了 64 位处理器的 iPhone 和 iPad。但另外一方面，因为 OpenGL 的限制，其性能与 Metal 相比并不占优势，毕竟后者是专门用来解决这些问题的。
 
 如果想要一个 iOS 上高性能的并行计算库，答案非常简单。Metal 是唯一的选择。OpenCL 在 iOS 上是私有框架，而 Core Image (使用了 OpenCL) 对这样的任务来说既不够强大又不够灵活。
 
 使用 Metal 的好处
 
 Metal 的最大好处就是与 OpenGL ES 相比显著降低了消耗。在 OpenGL 中无论创建缓冲区还是纹理，OpenGL 都会复制一份以防止 GPU 在使用它们的时候被意外访问。出于安全的原因复制类似纹理和缓冲区这样的大的资源是非常耗时的操作。而 Metal 并不复制资源。开发者需要负责在 CPU 和 GPU 之间同步访问。幸运的是，苹果提供了另一个很棒的 API 使资源同步访问更加容易，那就是Grand Central Dispatch。虽然使用 Metal 时仍然有些这方面的问题需要注意，但是一个在渲染时加载和卸载资源的先进的引擎，在避免额外的复制后能够获得更多的好处。
 
 Metal 的另外一个好处是其预估 GPU 状态来避免多余的验证和编译。通常在 OpenGL 中，你需要依次设置 GPU 的状态，在每个绘制指令 (draw call) 之前需要验证新的状态。最坏的情况是 OpenGL 需要再次重新编译着色器 (shader) 以反映新的状态。当然，这种评估是必要的，但 Metal 选择了另一种方法。在渲染引擎初始化过程中，一组状态被烘焙 (bake) 至预估渲染的 路径 (pass) 中。多个不同资源可以共同使用该渲染路径对象，但其它的状态是恒定的。Metal 中一个渲染路径无需更进一步的验证，使 API 的消耗降到最低，从而大大增加每帧的绘制指令的数量。
 
 Metal API
 
 虽然这个平台上许多 API 都暴露为具体的类，但 Metal 提供的大多是协议。因为 Metal 对象的具体类型取决于 Metal 运行在哪个设备上。这更鼓励了面向接口而不是面向实现编程。然而，这同时也意味着，如果不使用 Objective-C 运行时的广泛而危险的操作，就不能子类化 Metal 的类或者为其增加扩展，
 
 Metal 为了速度而在安全性上做了必要的妥协。对于错误，苹果的其它框架显得更加安全和健壮，而 Metal 则完全相反。在某些时候，你会收到指向内部缓冲区的裸指针，你必须小心的同步访问它。OpenGL 中发生错误时，结果通常是黑屏；然而在 Metal 中，结果可能是完全随机的效果，例如闪屏和偶尔的崩溃。之所以有这些陷阱，是因为 Metal 框架是对 GPU 的非常轻量级抽象。
 
 一个有趣的方面是苹果并没有为 Metal 实现可以在 iOS 模拟器上使用的软件渲染。使用 Metal 框架的时候应用必须运行在真实设备上。
 
 基础 Metal 程序
 
 在这部分中，我们会介绍写出第一个 Metal 程序所必要的部分。这个简单的程序绘制了一个正方形的旋转。你可以在 GitHub 中下载这篇文章的示例代码。
 
 虽然不能涵盖每一个细节，但我们尽量涉及至少所有的移动部分。你可以阅读源代码和参阅线上资源来深入理解。
 
 使用 UIKit 创建设备和界面
 
 在 Metal 中，设备是 GPU 的抽象。它被用来创建很多其它类型的对象，例如缓冲区，纹理和函数库。使用MTLCreateSystemDefaultDevice 函数来获取默认设备:
 
 
 
 
   
  
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   Objective-C
  
 
 
 
 
 
  
 
 

  

      

       

        1
       
      

      

       

        id
        &
        lt
        ;
        MTLDevice
        &
        gt
        ;
         
        device
         
        =
         
        MTLCreateSystemDefaultDevice
        (
        )
        ;
       
      
 

注意 device 并不是一个详细具体的类，正如前面提到的，它是遵循 MTLDevice 协议的类。
下面的代码展示了如何创建一个 Metal layer 并将它作为 sublayer 添加到一个 UIView 的 layer:

 

  
  

   

    

   
   

    

   
   

    

   
   

    

   
   Objective-C
  
 
 

  
 
 
 
 
  
 
      
 
       

         1
       
 
       

         2
       
 
       

         3
       
 
       

         4
       
 
       

         5
       
 
      
 
 
      
 
       
 
        CAMetalLayer
         
        *metalLayer
         
        =
         
        [
        CAMetalLayer
         
        layer
        ]
        ;
          
       
 
       
 
        metalLayer
        .
        device
         
        =
         
        device
        ;
          
       
 
       
 
        metalLayer
        .
        pixelFormat
         
        =
         
        MTLPixelFormatBGRA8Unorm
        ;
          
       
 
       
 
        metalLayer
        .
        frame
         
        =
         
        view
        .
        bounds
        ;
          
       
 
       
 
        [
        view
        .
        layer
         addSublayer
        :self
        .
        metalLayer
        ]
        ;
       
 
      
 
 
 
 
 
 CAMetalLayer 是 CALayer 的子类，它可以展示 Metal 帧缓冲区的内容。我们必须告诉 layer 该使用哪个 Metal 设备 (我们刚创建的那个)，并通知它所预期的像素格式。我们选择 8-bit-per-channel BGRA 格式，即每个像素由蓝，绿，红和透明组成，值从 0-255。
 
 库和函数
 
 你的 Metal 程序的很多功能会被用顶点和片段函数的方式书写，也就是我们所说的着色器。Metal 着色器用 Metal 着色器语言编写，我们将在下面详细讨论。Metal 的优点之一就是着色器函数在你的应用构建到中间语言时进行编译，这可以节省很多应用启动时所需的时间。
 
 一个 Metal 库是一组函数的集合。你的所有写在工程内的着色器函数都将被编译到默认库中，这个库可以通过设备获得:
 
 
 
 
   
  
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   Objective-C
  
 
 
 
 
 
  
 
 

  

      

       

        1
       
      

      

       

        id
        &
        lt
        ;
        MTLLibrary
        &
        gt
        ;
         
        library
         
        =
         
        [
        device 
        newDefaultLibrary
        ]
       
      
 

接下来构建渲染管道状态的时候将使用这个库。
命令队列
命令通过与 Metal 设备相关联的命令队列提交给 Metal 设备。命令队列以线程安全的方式接收命令并顺序执行。创建一个命令队列:

 

  
  

   

    

   
   

    

   
   

    

   
   

    

   
   Objective-C
  
 
 

  
 
 
 
 
  
 
      
 
       

         1
       
 
      
 
 
      
 
       
 
        id
        &
        lt
        ;
        MTLCommandQueue
        &
        gt
        ;
         
        commandQueue
         
        =
         
        [
        device 
        newCommandQueue
        ]
        ;
       
 
      
 
 
 
 
 
 
 
 构建管道
 
 当我们在 Metal 编程中提到管道，指的是顶点数据在渲染时经历的变化。顶点着色器和片段着色器是管道中两个可编程的节点，但还有其它一定会发生的事件 (剪切，栅格化和视图变化) 不在我们的直接控制之下。管道特性中的后者的类组成了固定功能管道。
 
 在 Metal 中创建一个管道，我们需要指定对于每个顶点和每个像素分别想要执行哪个顶点和片段函数 (译者注: 片段着色器又被称为像素着色器)。我们还需要将帧缓冲区的像素格式告诉管道。在本例中，该格式必须与 Metal layer 的格式匹配，因为我们想在屏幕上绘制。
 
 从库中通过名字来获取函数:
 
 
 
 
   
  
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   Objective-C
  
 
 
 
 
 
  
 
 

  

      

       

        1
       
       

        2
       
      

      

       

        id
        &
        lt
        ;
        MTLFunction
        &
        gt
        ;
         
        vertexProgram
         
        =
         
        [
        library
         newFunctionWithName
        :
        @
        &
        quot
        ;
        vertex_function
        &
        quot
        ;
        ]
        ;
          
       
       

        id
        &
        lt
        ;
        MTLFunction
        &
        gt
        ;
         
        fragmentProgram
         
        =
         
        [
        library
         newFunctionWithName
        :
        @
        &
        quot
        ;
        fragment_function
        &
        quot
        ;
        ]
        ;
       
      
 

接下来创建一个设置了函数和像素格式的管道描述器:

 

  
  

   

    

   
   

    

   
   

    

   
   

    

   
   

    

   
   Objective-C
  
 
 

  
 
 
 
 
  
 
      
 
       

         1
       
 
       

         2
       
 
       

         3
       
 
       

         4
       
 
      
 
 
      
 
       
 
        MTLRenderPipelineDescriptor
         
        *pipelineStateDescriptor
         
        =
         
        [
        [
        MTLRenderPipelineDescriptor
         
        alloc
        ]
         init
        ]
        ;
          
       
 
       
 
        [
        pipelineStateDescriptor
         setVertexFunction
        :vertexProgram
        ]
        ;
       
 
       
 
        [
        pipelineStateDescriptor
         setFragmentFunction
        :fragmentProgram
        ]
        ;
       
 
       
 
        pipelineStateDescriptor
        .
        colorAttachments
        [
        0
        ]
        .
        pixelFormat
         
        =
         
        MTLPixelFormatBGRA8Unorm
        ;
       
 
      
 
 
 
 
 
 最后，我们从描述器中创建管道状态。这会根据程序运行的硬件环境，从中间代码中编译着色器函数为优化后的代码。
 
 
 
 
   
  
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   Objective-C
  
 
 
 
 
 
  
 
 

  

      

       

        1
       
      

      

       

        id
        &
        lt
        ;
        MTLRenderPipelineState
        &
        gt
        ;
         
        pipelineState
         
        =
         
        [
        device
         newRenderPipelineStateWithDescriptor
        :pipelineStateDescriptor
         error
        :nil
        ]
        ;
       
      
 


读取数据到缓冲区
现在已经有了一个构建好的管道，我们需要用数据填充它。在示例工程中，我们绘制了一个简单的几何图形: 一个旋转的正方形。正方形由两个共享一条边的直角三角形组成:

 

  
  

   

    

   
   

    

   
   

    

   
   

    

   
   Objective-C
  
 
 

  
 
 
 
 
  
 
      
 
       

         1
       
 
       

         2
       
 
       

         3
       
 
       

         4
       
 
       

         5
       
 
       

         6
       
 
       

         7
       
 
       

         8
       
 
       

         9
       
 
       

         10
       
 
      
 
 
      
 
       
 
        static
         
        float
         
        quadVertexData
        [
        ]
         
        =
          
       
 
       
 
        {
       
 
       
 
             
        0.5
        ,
         
        -
        0.5
        ,
         
        0.0
        ,
         
        1.0
        ,
             
        1.0
        ,
         
        0.0
        ,
         
        0.0
        ,
         
        1.0
        ,
       
 
       
 
            
        -
        0.5
        ,
         
        -
        0.5
        ,
         
        0.0
        ,
         
        1.0
        ,
             
        0.0
        ,
         
        1.0
        ,
         
        0.0
        ,
         
        1.0
        ,
       
 
       
 
            
        -
        0.5
        ,
          
        0.5
        ,
         
        0.0
        ,
         
        1.0
        ,
             
        0.0
        ,
         
        0.0
        ,
         
        1.0
        ,
         
        1.0
        ,
       
 
       

          
       
 
       
 
             
        0.5
        ,
          
        0.5
        ,
         
        0.0
        ,
         
        1.0
        ,
             
        1.0
        ,
         
        1.0
        ,
         
        0.0
        ,
         
        1.0
        ,
       
 
       
 
             
        0.5
        ,
         
        -
        0.5
        ,
         
        0.0
        ,
         
        1.0
        ,
             
        1.0
        ,
         
        0.0
        ,
         
        0.0
        ,
         
        1.0
        ,
       
 
       
 
            
        -
        0.5
        ,
          
        0.5
        ,
         
        0.0
        ,
         
        1.0
        ,
             
        0.0
        ,
         
        0.0
        ,
         
        1.0
        ,
         
        1.0
        ,
       
 
       
 
        }
        ;
       
 
      
 
 
 
 
 
 每一行的前四个数字代表了每一个顶点的 x，y，z 和 w 元素。后四个数字代表每个顶点的红色，绿色，蓝色和透明值元素。
 
 你可能会奇怪为什么需要四个数字来描述 3D 空间中的一个位置。第四个顶点位置元素，w，是一个数学上的便利，使我们能以一种统一的方式描述 3D 转换 (旋转，平移，缩放)。这个细节在本文的示例代码并没有体现。
 
 为了使用 Metal 绘制顶点数据，我们需要将它放入缓冲区。缓冲区是被 CPU 和 GPU 共享的简单的无结构的内存块:
 
 
 
 
   
  
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   Objective-C
  
 
 
 
 
 
  
 
 

  

      

       

        1
       
       

        2
       
       

        3
       
      

      

       

        vertexBuffer
         
        =
         
        [
        device
         newBufferWithBytes
        :quadVertexData
          
       
       

                                               length
        :sizeof
        (
        quadVertexData
        )
       
       

                                              options
        :MTLResourceOptionCPUCacheModeDefault
        ]
        ;
       
      
 

我们将使用另一个缓冲区来存储用来旋转正方形的旋转矩阵。与预先提供数据不同，这里只是通过创建规定长度的缓冲区来创建一个空间。

 

  
  

   

    

   
   

    

   
   

    

   
   

    

   
   

    

   
   Objective-C
  
 
 

  
 
 
 
 
  
 
      
 
       

         1
       
 
       

         2
       
 
      
 
 
      
 
       
 
        uniformBuffer
         
        =
         
        [
        device
         newBufferWithLength
        :sizeof
        (
        Uniforms
        )
          
       
 
       
 
                                                options
        :MTLResourceOptionCPUCacheModeDefault
        ]
        ;
       
 
      
 
 
 
 
 
 
 
 动画
 
 为了在屏幕上旋转正方形，我们需要把转换顶点作为顶点着色器的一部分。这需要更新每一帧的统一缓冲区。我们运用三角学知识，从当前旋转角度生成一个旋转矩阵，将它复制到统一缓冲区。
 
 Uniforms 结构体只有一个成员，该成员是一个保存了旋转矩阵的 4×4 的矩阵。矩阵类型 matrix_float4x4 来自于苹果的 SIMD 库，该库是一个类型的集合，它们可以从 数据并行操作 中获益:
 
 
 
 
   
  
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   Objective-C
  
 
 
 
 
 
  
 
 

  

      

       

        1
       
       

        2
       
       

        3
       
       

        4
       
      

      

       

        typedef
         
        struct
          
       
       

        {
       
       

            
        matrix_float4x4 
        rotation_matrix
        ;
       
       

        }
         
        Uniforms
        ;
       
      
 

为了将旋转矩阵复制到统一缓冲区中，我们取得它的内容的指针并将矩阵 memcpy 进去:

 

  
  

   

    

   
   

    

   
   

    

   
   

    

   
   Objective-C
  
 
 

  
 
 
 
 
  
 
      
 
       

         1
       
 
       

         2
       
 
       

         3
       
 
       

         4
       
 
      
 
 
      
 
       
 
        Uniforms
         
        uniforms
        ;
          
       
 
       
 
        uniforms
        .
        rotation_matrix
         
        =
         
        rotation_matrix_2d
        (
        rotationAngle
        )
        ;
          
       
 
       
 
        void
         
        *bufferPointer
         
        =
         
        [
        uniformBuffer 
        contents
        ]
        ;
          
       
 
       
 
        memcpy
        (
        bufferPointer
        ,
         
        &
        amp
        ;
        uniforms
        ,
         
        sizeof
        (
        Uniforms
        )
        )
        ;
       
 
      
 
 
 
 
 
 
 
 准备绘制
 
 为了在 Metal layer 上绘制，首先我们需要从 layer 中获得一个 ‘drawable’ 对象。这个可绘制对象管理着一组适合渲染的纹理:
 
 
 
 
   
  
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   Objective-C
  
 
 
 
 
 
  
 
 

  

      

       

        1
       
      

      

       

        id
        &
        lt
        ;
        CAMetalDrawable
        &
        gt
        ;
         
        drawable
         
        =
         
        [
        metalLayer 
        nextDrawable
        ]
        ;
       
      
 

接下来我们创建一个渲染路径描述器，它描述了在渲染之前和完成之后 Metal 应该执行的不同动作。下面我们展示了一个渲染路径，它将首先把帧缓冲区清除为纯白色，然后执行绘制指令，最后将结果存储到帧缓冲区来展示:

 

  
  

   

    

   
   

    

   
   

    

   
   

    

   
   

    

   
   Objective-C
  
 
 

  
 
 
 
 
  
 
      
 
       

         1
       
 
       

         2
       
 
       

         3
       
 
       

         4
       
 
       

         5
       
 
      
 
 
      
 
       
 
        MTLRenderPassDescriptor
         
        *renderPassDescriptor
         
        =
         
        [
        MTLRenderPassDescriptor
         
        renderPassDescriptor
        ]
        ;
          
       
 
       
 
        renderPassDescriptor
        .
        colorAttachments
        [
        0
        ]
        .
        texture
         
        =
         
        drawable
        .
        texture
        ;
          
       
 
       
 
        renderPassDescriptor
        .
        colorAttachments
        [
        0
        ]
        .
        loadAction
         
        =
         
        MTLLoadActionClear
        ;
          
       
 
       
 
        renderPassDescriptor
        .
        colorAttachments
        [
        0
        ]
        .
        clearColor
         
        =
         
        MTLClearColorMake
        (
        1
        ,
         
        1
        ,
         
        1
        ,
         
        1
        )
        ;
          
       
 
       
 
        renderPassDescriptor
        .
        colorAttachments
        [
        0
        ]
        .
        storeAction
         
        =
         
        MTLStoreActionStore
        ;
       
 
      
 
 
 
 
 
 
 
 发布绘制指令
 
 要放入设备的命令队列的命令必须被编码到命令缓冲区里。命令缓冲区是一个或多个命令的集合，可以以一种 GPU 了解的紧凑的方式执行和编码。
 
 
 
 
   
  
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   Objective-C
  
 
 
 
 
 
  
 
 

  

      

       

        1
       
      

      

       

        id
        &
        lt
        ;
        MTLCommandBuffer
        &
        gt
        ;
         
        commandBuffer
         
        =
         
        [
        self
        .
        commandQueue 
        commandBuffer
        ]
        ;
       
      
 

为了真正编码渲染命令，我们还需要另一个知道如何将我们的绘制指令转换为 GPU 懂得的语言的对象。这个对象叫做命令编码器。我们将上面创建的渲染路径描述器作为参数传入，就可以向命令缓冲区请求一个编码器:

 

  
  

   

    

   
   

    

   
   

    

   
   

    

   
   

    

   
   Objective-C
  
 
 

  
 
 
 
 
  
 
      
 
       

         1
       
 
      
 
 
      
 
       
 
        id
        &
        lt
        ;
        MTLRenderCommandEncoder
        &
        gt
        ;
         
        renderEncoder
         
        =
         
        [
        commandBuffer
         renderCommandEncoderWithDescriptor
        :renderPassDescriptor
        ]
        ;
       
 
      
 
 
 
 
 
 在绘制指令之前，我们使用预编译的管道状态设置渲染命令编码器并建立缓冲区，该缓冲区将作为顶点着色器的参数:
 
 
 
 
   
  
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   Objective-C
  
 
 
 
 
 
  
 
 

  

      

       

        1
       
       

        2
       
       

        3
       
      

      

       

        [
        renderEncoder
         setRenderPipelineState
        :pipelineState
        ]
        ;
       
       

        [
        renderEncoder
         setVertexBuffer
        :vertexBuffer
         offset
        :
        0
         atIndex
        :
        0
        ]
        ;
       
       

        [
        renderEncoder
         setVertexBuffer
        :uniformBuffer
         offset
        :
        0
         atIndex
        :
        1
        ]
        ;
       
      
 

为了真正的绘制几何图形，我们告诉 Metal 要绘制的形状 (三角形) 和缓冲区中顶点的数量 (本例中 6 个):

 

  
  

   

    

   
   

    

   
   

    

   
   

    

   
   

    

   
   Objective-C
  
 
 

  
 
 
 
 
  
 
      
 
       

         1
       
 
      
 
 
      
 
       
 
        [
        renderEncoder
         drawPrimitives
        :MTLPrimitiveTypeTriangle
         vertexStart
        :
        0
         vertexCount
        :
        6
        ]
        ;
       
 
      
 
 
 
 
 
 最后，执行 endEncoding 通知编码器发布绘制指令完成。
 
 
 
 
   
  
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   Objective-C
  
 
 
 
 
 
  
 
 

  

      

       

        1
       
      

      

       

        [
        renderEncoder 
        endEncoding
        ]
        ;
       
      
 


展示帧缓冲区
现在我们的绘制指令已经被编码并准备就绪，我们需要通知命令缓冲区应该将结果在屏幕上显示出来。调用 presentDrawable，使用当前从 Metal layer 中获得的 drawable 对象作为参数:

 

  
  

   

    

   
   

    

   
   

    

   
   

    

   
   Objective-C
  
 
 

  
 
 
 
 
  
 
      
 
       

         1
       
 
      
 
 
      
 
       
 
        [
        commandBuffer
         presentDrawable
        :drawable
        ]
        ;
       
 
      
 
 
 
 
 
 执行 commit 告诉缓冲区已经准备好安排并执行:
 
 
 
 
   
  
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   Objective-C
  
 
 
 
 
 
  
 
 

  

      

       

        1
       
      

      

       

        [
        commandBuffer 
        commit
        ]
        ;
       
      
 

就这么多！
Metal 着色语言
虽然 Metal 和 Swift 是在 WWDC keynote 上被一同发表的，但着色语言是基于 C++11 的，有一些有限制的特性和增加的关键字。
Metal 着色语言实践
为了在着色器里使用顶点数据，我们定义了一个对应 Objective-C 中顶点数据的结构体：

 

  
  

   

    

   
   

    

   
   

    

   
   

    

   
   Objective-C
  
 
 

  
 
 
 
 
  
 
      
 
       

         1
       
 
       

         2
       
 
       

         3
       
 
       

         4
       
 
       

         5
       
 
      
 
 
      
 
       
 
        typedef
         
        struct
          
       
 
       
 
        {
       
 
       
 
            
        float4 
        position
        ;
       
 
       
 
            
        float4 
        color
        ;
       
 
       
 
        }
         
        VertexIn
        ;
       
 
      
 
 
 
 
 
 我们还需要一个类似的结构体来描述从顶点着色器传入片段着色器的顶点类型。然而，在本例中，我们必须区分 (通过使用[[position]] 属性) 哪一个结构体成员应该被看做是顶点位置:
 
 
 
 
   
  
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   Objective-C
  
 
 
 
 
 
  
 
 

  

      

       

        1
       
       

        2
       
       

        3
       
       

        4
       
      

      

       

        typedef
         
        struct
         
        {
          
       
       

         
        float4 
        position
         
        [
        [
        position
        ]
        ]
        ;
       
       

         
        float4 
        color
        ;
       
       

        }
         
        VertexOut
        ;
       
      
 

顶点函数在顶点数据中每个顶点被执行一次。它接收顶点列表的一个指针，和一个包含旋转矩阵的统一数据的引用。第三个参数是一个索引，用来告诉函数当前操作的是哪个顶点。
注意顶点函数的参数后面紧跟着标明它们用途的属性。在缓冲区参数中，参数中的索引对应着我们在渲染命令编码器中设置缓冲区时指定的索引。Metal 就是这样来区分哪个参数对应哪个缓冲区。
在顶点函数中，我们用顶点的位置乘以旋转矩阵。我们构建矩阵的方式决定了效果是围绕中心旋转正方形。接着我们将这个转换过的位置传入输出顶点。顶点颜色则从输入参数中直接复制。

 

  
  

   

    

   
   

    

   
   

    

   
   

    

   
   

    

   
   Objective-C
  
 
 

  
 
 
 
 
  
 
      
 
       

         1
       
 
       

         2
       
 
       

         3
       
 
       

         4
       
 
       

         5
       
 
       

         6
       
 
       

         7
       
 
       

         8
       
 
       

         9
       
 
      
 
 
      
 
       
 
        vertex 
        VertexOut
         
        vertex_function
        (
        device 
        VertexIn
         
        *vertices
         
        [
        [
        buffer
        (
        0
        )
        ]
        ]
        ,
          
       
 
       
 
                                             
        constant 
        Uniforms
         
        &
        amp
        ;
        uniforms
         
        [
        [
        buffer
        (
        1
        )
        ]
        ]
        ,
       
 
       
 
                                             
        uint 
        vid
         
        [
        [
        vertex_id
        ]
        ]
        )
       
 
       
 
        {
       
 
       
 
            
        VertexOut
         
        out
        ;
       
 
       
 
            
        out
        .
        position
         
        =
         
        uniforms
        .
        rotation_matrix 
        *
         
        vertices
        [
        vid
        ]
        .
        position
        ;
       
 
       
 
            
        out
        .
        color
         
        =
         
        vertices
        [
        vid
        ]
        .
        color
        ;
       
 
       
 
            
        return
         
        out
        ;
       
 
       
 
        }
       
 
      
 
 
 
 
 
 片段函数每个像素就会被执行一次。Metal 在 rasterization 过程中会通过在每个顶点中指定的位置和颜色参数中添加来生成参数。在这个简单的片段函数中，我们只是简单的返回了 Metal 添加的颜色。这会成为屏幕像素的颜色:
 
 
 
 
   
  
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   
 
    
 
    
 
   
 
   Objective-C
  
 
 
 
 
 
  
 
 
 
 
  
 
      
 
       

         1
       
 
       

         2
       
 
       

         3
       
 
       

         4
       
 
      
 
 
      
 
       
 
        fragment 
        float4 
        fragment_function
        (
        VertexOut
         
        in
         
        [
        [
        stage_in
        ]
        ]
        )
          
       
 
       
 
        {
       
 
       
 
            
        return
         
        in
        .
        color
        ;
       
 
       
 
        }
       
 
      
 
 
 
 
 
 
 
 为什么不干脆扩展 OPENGL?
 
 苹果是 OpenGL 架构审查委员会的成员，并且历史上也在 iOS 上提供过它们自己的 GL 扩展。但从内部改变 OpenGL 看起来是个困难的任务，因为它有着不同的设计目标。实际上，它必须有广泛的硬件兼容性以运行在很多不同的设备上。虽然 OpenGL 还在持续发展，但速度缓慢。
 
 而 Metal 则本来就是只为了苹果的平台而创建的。即使基于协议的 API 最初看起来不太常见，但和其它框架配合的很好。Metal 是用 Objective-C 编写的，基于 Foundation，使用 GCD 在 CPU 和 GPU 之间保持同步。它是更先进的 GPU 管道的抽象，而 OpenGL 想达到这些的话只能完全重写。
 
 Mac 上的 Metal?
 
 OS X 上支持 Metal 也是迟早的事。API 本身并不局限于 iPhone 和 iPad 使用的 ARM 架构的处理器。Metal 的大多数优点都可以移植到先进的 GPU 上。另外，iPhone 和 iPad 的 CPU 和 GPU 是共享内存的，无需复制就可以交换数据。这一代的 Mac 电脑并未提供共享内存，但这只是时间问题。或许，API 会被调整为支持使用了专门内存的架构，或者 Metal 只会运行在下一代的 Mac 电脑上。
 
 总结
 
 本文中我们尝试给出公正并有所帮助的关于 Metal 框架的介绍。
 
 当然，大多数的游戏开发者并不会直接使用 Metal。然而，顶层的游戏引擎已经从中获益，并且开发者无需直接使用 API 就可以从最新的技术中得到好处。另外，对于那些想要发挥硬件全部性能的开发者来说，Metal 或许可以让他们在游戏中创建出与众不同而华丽的效果，或者进行更快的并行计算，从而得到竞争优势。
 
 资源
 
Metal Programming Guide
Metal Shading Language Guide
Metal by Example