unity条件编译

㈠ Unity3D开发中热更新为什么不能使用C#的思考

阅读了网上一些文章，其实使用C#进行热更新是可以的，将需要更新的代码打包成程序集，然后利用反射即可，但是也提到在IOS平台是不行的，至于为什么不行，就不再说了，然后就是推荐Lua作为热更新方案，但是，为啥Lua就行？C#就不行？
因为C#是编译型语言，Lua是解释型语言？
好多人都说Lua能热更新，是因为它是解释型语言，不用编译，在运行时能动态解释Lua代码并运行。这种方法实际上不准确，从某些角度来说是错的。Lua确实是解释性脚本语言，但是不是因为是解释型才能进行热更新。即使使用C++这种编译语言，也能进行热更新，将动态链接库进行更新就是，然后动态加载动态链接库获取更新的函数地址即可。
而且，还有一点，C#并不能说是一种编译型语言，C#代码会被编译成IL，IL解释成机器码的过程可以在运行之前进行也能在运行时进行。如果在运行时进行解释，那么和Lua不就一样了吗，为啥C#不能进行热更新呢？
JIT对IL进行解释执行的原理
首先说一下，JIT对IL如何在运行时进行解释并执行的，大致过程为：将IL解释为所在平台的机器码，开辟一段内存空间，要求这段内存空间可读、可写、可执行，然后把解释出的机器码放入，修改CPU中的指令指针寄存器中的地址，让CPU执行之前解释出来的机器码。
注意这段内存的条件，最重要的一条是必须是可执行的，一般的内存申请我们只是存放数据，但是这里的内存权限要是有可执行权限
IOS限制了什么？
IOS不允许获取具有可执行权限的内存空间，这就直接要求JIT要以full AOT模式，这种模式会在生成之前把IL直接翻译成机器码而不是在运行期间，进行了这种操作C#从某种角度来说和C++一样，成为了编译型语言，失去了运行时解释的功能。
Lua的解释执行怎么就行呢？
如果Lua的解释执行原理和C#相同，肯定也不能在IOS平台上运行时解释执行。Lua是使用C编写的脚本语言，它在运行时读入Lua编写的代码，在解释Lua字节码（Lua自己的指令）时不是翻译为机器码，而是使用C代码进行解释，不用开辟特殊的内存空间，也不会有新代码在执行，执行的是Lua的虚拟机，用C写出来的虚拟机，这和C#的机制是完全不同的，因为Lua是基于C的脚本语言。
总结
说白了，就是由于Lua这种脚本语言的特性，基于已经存在的某种语言的一种新的语言，这也是脚本语言和C#、C++这类语言的本质区别。当然，Lua虚拟机不仅可以使用C写，也可以用C#写。使用热更新也不一定非要用Lua，Python同样可以，只不过Lua短小精悍，本身代码长度就不是很大，可以从GitHub上看到。

㈡ 手机游戏是用什么开发的

手机游戏一般是用Unity、COCOS、java、C语言开发的，但也要看具体情况，有的手机游戏也可能是用HTML5开发的。

flash、java游戏俗称小游戏，基本上都是一些休闲类的、傻呆萌的情节和操作，这类游戏开发相对比较简单，会javascript、flash cs、java就可以进行开发了。

开发游戏我们经常听到的是游戏引擎，一个游戏引擎决定一个游戏最基本的东西操作和效果，那么一般的游戏开发架构从底到顶一般是Direct X游戏引擎。

Direct X可是大名鼎鼎相当于所有显卡的一个统一接口，为游戏提供一个利用硬件渲染的编程模型，但Direct X接口为了追求高性能功能非常简单基本的绘图功能，不利于游戏的高效开发。

此时就需要根据游戏特点对其进行适当的取舍和封装，实现一组更高抽象的游戏开发接口和框架，可以理解成游戏引擎中的图形引擎。这部分的开发一般使用的语言是C、C++和少量的汇编语言。

㈢ unity shader里 dot(lightCoord, lightCoord).rr

#ifdef USING_DIRECTIONAL_LIGHT
fixed atten = 1.0;
#else
float3 lightCoord = mul(_LightMatrix0, float4(i.worldPos, 1)).xyz;
fixed atten = tex2D(_LightTexture0, dot(lightCoord, lightCoord).rr).UNITY_ATTEN_CHANNEL;
#endif

• _LightMatrix0：这个变量在书的P184页表格和官方文档中均有说明，它在内置的AutoLight.cginc文件中的特定宏下被定义，可以用于把点从世界空间变换到该光源的局部空间下。因此，上面代码第一句“mul(_LightMatrix0, float4(i.worldPos, 1)).xyz”就是把顶点坐标变换到光源空间下的坐标，这点在书中也有解释。

• _LightTexture0：和_LightMatrix0类似的，也是在内置的AutoLight.cginc文件中的特定宏下被定义，紧跟_LightMatrix0的定义。它是一张包含了光源衰减信息的衰减纹理，我们可以用第一句代码得到的坐标进一步处理得到衰减纹理的采样坐标。由于Unity没有官方解释_LightMatrix0具体的数值范围含义，我们可以推测得到（推测方法可以是利用假彩色一节的方法来把这个变量当成颜色输出）_LightMatrix0得到的坐标模范围会是[0, 1]，即与光源重合处是(0, 0, 0), 在光源范围的边界处模值为1。而 dot(lightCoord, lightCoord).rr一句，首先是由点积得到光源的距离平方，这是一个标量，我们对这个变量进行.rr操作相当于构建了一个二维矢量，这个二维矢量每个分量的值都是这个标量值，由此得到一个二维采样坐标。这个操作是shader中常见的swizzling操作，Cg的官网上也有说明。我们随后使用这个二维坐标对光照衰减纹理_LightTexture0进行采样，得到衰减值。关于_LightTexture0后面会系统讲。

• 这段代码不够规范：书上有说这一节的代码不能直接用到项目里，仅仅是用来阐述原理，但如果你想用这段代码直接发布项目的话，是需要修改的，因为当时写的时候不够规范。原因是这段代码的keyword判断条件有问题，导致_LightTexture0或_LightMatrix0可能并没有被定义。我们可以将原来的代码替换成下面的代码（新的代码也已经push到了github上）：

  #ifdef USING_DIRECTIONAL_LIGHT
  fixed atten = 1.0;
  #else
  #if defined (POINT)
  // 把点坐标转换到点光源的坐标空间中，_LightMatrix0由引擎代码计算后传递到shader中，这里包含了对点光源范围的计算，具体可参考Unity引擎源码。经过_LightMatrix0变换后，在点光源中心处lightCoord为(0, 0, 0)，在点光源的范围边缘处lightCoord模为1
  float3 lightCoord = mul(_LightMatrix0, float4(i.worldPos, 1)).xyz;
  // 使用点到光源中心距离的平方dot(lightCoord, lightCoord)构成二维采样坐标，对衰减纹理_LightTexture0采样。_LightTexture0纹理具体长什么样可以看后面的内容
  // UNITY_ATTEN_CHANNEL是衰减值所在的纹理通道，可以在内置的HLSLSupport.cginc文件中查看。一般PC和主机平台的话UNITY_ATTEN_CHANNEL是r通道，移动平台的话是a通道
  fixed atten = tex2D(_LightTexture0, dot(lightCoord, lightCoord).rr).UNITY_ATTEN_CHANNEL;
  #elif defined (SPOT)
  // 把点坐标转换到聚光灯的坐标空间中，_LightMatrix0由引擎代码计算后传递到shader中，这里面包含了对聚光灯的范围、角度的计算，具体可参考Unity引擎源码。经过_LightMatrix0变换后，在聚光灯光源中心处或聚光灯范围外的lightCoord为(0, 0, 0)，在点光源的范围边缘处lightCoord模为1
  float4 lightCoord = mul(_LightMatrix0, float4(i.worldPos, 1));
  // 与点光源不同，由于聚光灯有更多的角度等要求，因此为了得到衰减值，除了需要对衰减纹理采样外，还需要对聚光灯的范围、张角和方向进行判断
  // 此时衰减纹理存储到了_LightTextureB0中，这张纹理和点光源中的_LightTexture0是等价的
  // 聚光灯的_LightTexture0存储的不再是基于距离的衰减纹理，而是一张基于张角范围的衰减纹理
  fixed atten = (lightCoord.z > 0) * tex2D(_LightTexture0, lightCoord.xy / lightCoord.w + 0.5).w * tex2D(_LightTextureB0, dot(lightCoord, lightCoord).rr).UNITY_ATTEN_CHANNEL;
  #else
  fixed atten = 1.0;
  #endif
  #endif
  

  上面更加精确地判断了keyword条件，保证只在正确的时候执行访问衰减纹理的代码。_LightTexture0和_LightMatrix0只在某些条件下会被定义，例如在开启了POINT、SPOT、POINT_COOKIE、DIRECTIONAL_COOKIE等，具体我们可以在AutoLight.cginc里面找到。但因为原来的代码里没有进行严格判断，在发布的时候由于Unity会严格编译Unity Shader根据不同的keyword生成对应的shader program，此时它就会发现我们的错误了。

㈣ 如何用unity3d编写javascript

Unity中的JS,也称UnityScript,和基于浏览器的JS有比较大的区别，因为UnityScript是基于Mono的.net 的IL语言规范，CLR运行环境(Mono虚拟机)上设计的语言。
0.基本概念：
Unity3d中的脚本可以与游戏对象链接，变量数值的修改以及实时预览脚本修改后的游戏效果，节省了很多脚本调整和调试的时间，提高了开发效率。
简单的项目和Unity中的大量例子和脚本资源包都是用JS。商业项目基本都用C#,因为C#和C/C++交互方便，丰富的数据结构和面向对象的架构利于大型程序的编写,很多强大的第三方插件是用C#开发的，方便工作流程。
编译过程：
UnityScript运行环境使用Mono 的.NET Framework。实际上，UnityScript是用Boo实现的，Boo是运行在Mono虚拟机上的一种语言，并且编译成本机代码。JavasScript很多典型的运行环境如String和Math库由Mono提供。你也就知道了为什么UnityScript中方法名要大写了，因为要与Mono中相同。
Unity中的脚本和传统的解释型(JIT解释)语言不同，都是需要经过编译的，因此速度都一样快。
这三种语言的代码最后都会被编译执行，而且脚本可以互相访问。
库的调用：
Unity的脚本基于Mono的.net平台上运行，脚本都可以使用.net库，为xml,数据库，正则表达式提供了良好的解决方案。
Unity中js想调用mono的.net库，直接import即可。
import System;
import System.IO;
否则，你带指定完整的命名空间来调用函数，如System.IO.File.Open()，而不是File.Open()。
1.基本类型和语句：
1)数据类型：
数值类型：char,byte,sbyte;short, ushort, int, uint, long, ulong; float,double; decimal.
布尔值：boolean
字符串：String，[index]符号
字符串[0]是字符串取下标为0的字符。
var s: String = "Whatever_it_may_be";
s =s.Replace("_"[0], " "[0]); // replace all the underscoreswith spaces
2)变量声明：
变量必须先声明[必须](编译缘故，且声明类型有利于减少太多常量，避免内存泄露发生)，可以定义类型[可选]：
var playerName:String;
函数的参数也要声明类型：
function Test( playerName:String, baseInfo:Object )
{
}
如果声明时候定义或赋值了类型，那么不能再改变类型，除非声明时候不定义类型。
var a= "test";
a =5;// 报错
var a;
a ="test";
a =5;//正确
变量前面可以加public,protected, private来修饰；不写默认是public的，public的变量可以在Inspector视图中查看和编辑。
3)数组：
内建自定义数组(快功能简单）：
var values : int[] = {1,2,3};
转换到Array数组(需要对数组处理），var arr = new Array(values);
Array对象数组（慢动态增长排序合并功能）：
var arr = new Array(); arr.Push("good");
转换到内建数组（需要比较高的性能时候)，var bArray : int[] = arr.ToBuiltin(int);
4)链表和泛型：
UnityScript可以使用泛型，所以当用到动态大小的数组时，最好用List来替代Array。基本上就没有什么理由要用到Array了，List更快并且功能更多。如果你需要混合类型的数组，你可以用Object List。UnityScript中泛型的语法与C#中接近，除了要加一个额外的“.”符号在“<>”之前。如C#中的"varmyList = new List<int>();"在UnityScript中对应的写法为："var myList = new List.<int>();"。
5)运算符和表达式:
和C一样。
6)语句：
每行必须写分号; 比C多了for in 用于遍历对象元素，for(var i:int = 0; i < 10; i++)。
switch可以使用String变量。
2.函数
声明规则：
function函数名(参数1:参数类型, 参数2:参数类型...):返回值类型
{
}
unityScript中的函数可以视为Function类型对象，可以像变量一样进行赋值比较等操作。
不能写匿名函数。
Math需要用Mathf。
3.类(DOM js中没有类)：
在Unity里，一个js文件就是一个类，unity引擎会为js文件自动生成一个类。
对于UnityScript脚本，Unity编译该文件时会自动的为脚本添加一个与脚本文件名相同的类，并自动地继承于MonoBehaviour。但对于C#或Boo,则需要在脚本中显式的写出类名和继承关系。要创建不继承自MonoBehaviour的类，用C#语言，或者从外部添加js脚本资源(就可以自己直接new对象出来了)。
//SayHello.js
#pragma strict // 严格类型检测,尽早生成错误,禁用动态类型,强制用静态类型(强类型)
function sayHello()
{
}
等价于C#中：
#pragma strict
public class SayHello extends MonoBehaviour
{
function sayHello()
{
}
}
但是，你可以在同一个文件中声明多个类，尤其是当你需要使用一些辅助工具类时非常有用，一般这种辅助类没有继承自MonoBehaviour。
如
class ButtonState {
var currentState : int;
var offset : Vector2;
}
如果你在一个文件中声明了MonoBehaviour的子类，但类名与文件名不匹配的话，即使是大小写不一致，你也会碰到麻烦。
一定要理解，当你在js文件中编写行为脚本是，你实际上在编写一个类：
a) 类及其对象：文件名就是类名，如果文件名是foo.js，你就可以在其他地方以var x = new foo()的格式进行调用；
b)类的方法和预定义方法：有一些特定的方法是实现系统预先定义的一些事件处理器，如Start、FixedUpdate等。任何事件中，声明的一个函数就是这个文件所代表的类的一个方法。
c) 类的属性：文件中在函数定义之外编写的代码都在该类的范围之内执行，声明的变量也是该类的成员变量。类中的静态函数、变量本质上是类的方法与属性。
实例：
/*whenyou drag the behavior onto a gameobject, these values will be visible andeditable
*/
public name : String;
/*otherscripts which have a reference to this object (e.g. if they're attached to thesame object) can see public functions
*/
publicage : int;
/*privatemembers are NOT visible to other scripts, even if they have a reference to thisobject
*/
private favoriteColor : Color;
/*youcan assign a value to bestFriend by dragging a gameObject with an attached of the foo behavior to this property. This will give you access to bestFriend'spublic methods and members
*/
public bestFriend : foo;
/*this function will be called every frame by Unity, so it's actually an eventhandler
*/
function Update(){
/*transform is a property inherited from thegameObject the behavior is attached to*/
var t = transform;
}
function Bar(){
// this is just a function, if you don't callit yourself, it will never do anything
}
4.继承
Unity里需要extends关键字：
class MyHello extends Hello
{
}
DOM js中用prototype里的bind()方法。
Unityjs里面还提供了虚拟函数。
类的继承也是不同的。在JavaScript和C#中，方法是隐型并且不可重载，除非方法声明中添加虚拟关键字。不同的是C#只重载那些包含重载关键字override的方法。而JavaScript不需要关键词，只要重载类方法就可以覆盖，其它的都可继承得到。
//Foo.js
var foo = "hello, world";
function doEet () {
// does nothing, intended to be overridden
}
将会生成：
//Foo.js
import UnityEngine;
classFoo extends MonoBehaviour {
public var foo = "hello, world";
public function doEet () {
// does nothing, intended to be overridden
}
}
子类写法：
//PrintingFoo.js
class PrintingFoo extends Foo {
function doEet() {
print( foo );
}
}
创建虚函数：
classFoo
{
virtual function DoSomething ()
{
Debug.Log("from baseclass");
}
}
//SubFoo.js
class SubFoo extends Foo
{
virtual function DoSomething()
{
Debug.Log("from subclass");
}
}
//Elsewhere
varfoo : Foo = new SubFoo();
foo.DoSomething();//printsfrom sub class
如果你要调用父类的方法，用关键字super。示例如下：
class SubFoo extends Foo
{
virtual function DoSomething()
{
super.DoSomething();// 不是虚函数，应该不需要super修饰就可以直接调用。
Debug.Log("from sub class");
}
}
//Elsewhere
varfoo : Foo = new SubFoo();
foo.DoSomething();//prints"from base class" and "from sub class"
类间通信：Use-a方式（关联关系）比继承耦合度底得多，易于修改维护
/*Foo.js */
varbar : Bar;
function Start(){
bar = gameObject.GetComponent(Bar);
}
function doEet(){
// do my own thing
if( bar ){
bar.doEet();
}
}
/*Bar.js */
function doEet(){
// do something special
}
5.对象
Unity中不一定可以用new 创建对象(普通类可以，特殊类不行，各种脚本都一样)。特殊类：用编辑器工程视图右键或者组件Create js 或者C#的类都是继承自MonoBehaviour类，对这种类型的类不能new出来一个对象，原因是Unity会为这种类自动创建对象，并调用被重载的方法。
使得用Unity非常有趣的一件事是，它的类采用了非常自由的mixin策略。通常你可以非常快速简单的查到你所需要的类。最通用的一个例子是Transform类，对于你正在处理的一个对象，所有被附加到该对象的相关联的类，都可以简单快速的获取它的属性和方法。
比如，典型的动作就是你会访问名叫"transform"的变量，它代表与该对象关联的Transform类的实例。如果你需要相关的位置坐标，就访问transform.position(一个 Vector3对象);如果你需要它的GameObject，就访问transform.gameObject；如果你需要它的渲染器，就访问transform.renderer。等等。一般如果你一个对象的主要属性，你就可以快速获取该对象所有其他的属性。
6.js和C#单向通信，不能双向通信，因为编译问题
js访问C#脚本组件：
//createa variable to access the C# script
private var csScript : CSharp1;
function Awake()
{
//Get the CSharp Script
csScript =this.GetComponent("CSharp1");//Don't forget to place the 'CSharp1'file inside the 'Standard Assets' folder
}
//rendertext and other GUI elements to the screen
function OnGUI()
{
//render the CSharp1 'message' variable
GUI.Label(new Rect(10,30,500,20),csScript.message);
}
C#访问js脚本组件：
using UnityEngine;
using System.Collections;
public class CSharp2 : MonoBehaviour
{
//create a variable to access the JavaScriptscript
private JS1 jsScript;
void Awake()
{
//Get the JavaScript component
jsScript = this.GetComponent<JS1>();//Don'tforget to place the 'JS1' file inside the 'Standard Assets' folder
}
//render text and other GUI elements to thescreen
void OnGUI()
{
//render the JS1 'message' variable
GUI.Label(newRect(10,10,300,20),jsScript.message);
}
}
7.使用第三方库：
第三方.NET库如XML-RPC可以以新建资源Asset的方式引入。
8.调试
可以用print函数，Log()函数或者Debug.Log(),想设置断点，用Debug.Break()函数。
print() 函数将会生成消息，并输出到状态栏及控制台中，但仅限MonoBehavioour类范围内。
更好的办法是使用Debug.Log("insert messagehere");，该方法到处都可使用。还可用Debug.LogWarning 和 Debug.LogError生成警告和错误消息。
Debug.Break(); 可以将游戏暂停在一个精确的点。当一种特定的情条件发生时，如果你想检查对象的状态的时候，这个特性非常有用。
开发环境运行项目时，编辑界面也是完全实时更新的，你可以查看对象实例的内部状态。

㈤ 我想学习编程，但是不知道该怎么开始。

我建议最好是从基础入手，而不是一开始就进行可视化编程。虽然如今国内绝大多数pc都是使用的windows，但是毕竟这知识这个世界的冰山一角。扎实的基础自然会更有用处。编程其实重要的是程序思维，然后是算法和数据结构。这些都是超出语言的，就是说不管是学c学java学delphi还是别的什么，这一部分都是一致的。因此培养这部分的知识可以说是一本万利的事情。初学肯定是通过语言熟悉思想熟悉算法和数据结构，到一定的时候就是纯粹的思想和算法数据结构的学习，便已经脱离程序语言了。经历过这些阶段，换一种语言不过是重新了解一下描述的方式，就像你了解了中文思维，山东话和四川话的差别就不会太大；了解了拉丁语的思维，整个语系的语言都不过是简简单单的记忆工作，应用就好。入门的语言，理论上是怎么方便学哪个，看那个顺眼学哪个。当然这里面还是有不同的推荐的。一般来说我比较推荐pascal、c/c++、java。并不是因为这三个东西很通用很有前途，而是它们实在是严整而有规则（c/c++还显得稍微的宽松了一点），而严谨的语法要求和明确的概念区分是有利于编程思维的形成和算法数据结构的学习的。同样的因为这个理由我不推荐vb，而并不是因为它功能不强大（事实上vb在windows环境中是相当牛的语言）另外一个建议是，如果学c，不要一开始就用vc。ms提供的很多东西很方便，有很多很简单的实现方法，但是它们不标准。vc与ansi
c标准是有很大的差距的。首先一个不遵循标准的c/c++程序是不通用的，换个编译器说不定就不被承认了。所以我非常推崇gcc，理由之一是它完全符合
ansi
c标准，无论它的c还是c++编译器都很严整，功能上一点也不缺乏（有人说gcc不能做图形界面的程序，这一点完全错误，到处都有的qt库和gtk库都能做出很好的界面），另外一个理由便是它免费，毕竟稍微大一点的软件企业就不会屈从与微软的编译器和平台，而一个免费的c编译器无疑可以创造更多的利益；就算要转vc，标准的c程序也是几乎不要作任何改动的。当然，这一切的前提是，你真的很想很好的学编程，做一个这方面的精英。如果只不过是兴趣，或者只是想拿一个ms的工程师认证然后在国内企业找份诸如设计vf、vb程序之类的工作，那完全可以忽略我上面的话，去找个认证培训班，认认真真听听课，好好完成练习，从vb或者vc入手，考好认证是很不会太难的。毕竟现在很多很好的大学里都从来不缺乏计算机的课程，不会缺少算法或者编译原理的课程，不会没有计算机科学的研究院，而那里面出来的人一般都具备了很好的基础知识，会更加容易成为前面所说的精英。