Diary2.txt

【2017-12-24】【1】Android开发概念回顾
1.JDK
http://www.oracle.com/technetwork/cn/java/javase/downloads/jdk8-downloads-2133151-zhs.html
JDK是 Java 语言的软件开发工具包 主要用于移动设备 嵌入式设备上的java应用程序 
JDK是整个java开发的核心 它包含了JAVA的运行环境(JVM+Java系统类库)和JAVA工具

2.ADT
Android Developer Tools
安卓开发工具 Google研发的一个插件
集成在eclipse中，为安卓开发提供专属开发环境
简单的说ADT就是Android在Eclipse上的开发工具
在Eclipse和SDK之间起到了一个桥梁的作用

3.NDK
https://www.cnblogs.com/crowsong/p/6737780.html
Native Development Kit 
Android NDK是一个让开发人员在Android应用中嵌入使用本地代码编写的组件的工具集
提供了一系列的工具，帮助开发者快速开发C(或C++)的动态库 并能自动将so和java应用一起打包成apk

4.ANT
Apache的一个项目管理工具
是一个可将软件编译 测试 部署等步骤联系在一起加以自动化的工具
大多用于Java环境中的软件开发

5.LLDB
https://segmentfault.com/a/1190000005738395
LLDB是一个高效的c/c++的调试器 是与LLVM编译器一起使用

【2017-12-24】【2】Android Studio技巧
1.Alt + Enter 自动补全缺少的库

【2018-01-12】gflags 查越界访问
http://blog.csdn.net/zcc1414/article/details/38396411
1.下载WinDbg工具
2.用管理员权限运行cmd
3.使用命令
gflags /p /enable KAPP.exe /full [/unaligned]
跟踪进程(/unaligned Win10用不了)
gflags /p /disable KAPP.exe
撤销跟踪
原理是: 当有堆分配的时候 在分配的内存的后面放上几个守护字节(Guard Bytes)

【2018-01-17】C++ Map初始化技巧
typedef std::map<int, int> MapType;
typedef MapType::value_type ValueType;
// 定义ValueType数组
ValueType values[] = 
{
	std::map<int, int>::value_type(1, 1),
	std::map<int, int>::value_type(2, 2),
	std::map<int, int>::value_type(3, 3)
};
// 用ValueType数组初始化对应的Map
MapType myMap(values, values + sizeof(values) / sizeof(ValueType));

【2018-01-23】【1】C#学习
1.c#内置三种引用类型 object、dynamic 和 string
2.当一个值类型转换为对象类型时 则被称为装箱
另一方面 当一个对象类型转换为值类型时则被称为 拆箱
3.System.Object(可以用object关键字)是C#所有通用数据类型的终极基类 包括所有自定义的class和struct
4.dynamic是动态数据类型关键字 类型检查是在运行时发生的
5.C# string 字符串的前面可以加 @(称作"逐字字符串")将转义字符（\）当作普通字符对待
6.在类型后面加上?表示该类型是可空类型(Nullable)[string是Nullable]
7.Null 合并运算符(??)
double? num1 = null;
double? num2 = 3.14157;
double num3;
num3 = num1 ?? 5.34;
Console.WriteLine("num3 的值： {0}", num3);
num3 = num2 ?? 5.34;
Console.WriteLine("num3 的值： {0}", num3);

num3 的值： 5.34
num3 的值： 3.14157

【2018-01-23】【2】C#数组
1.数组是引用类型
2.数组声明: 类型[]
3.创建数组：new 类型[数组大小]
4.示例:
int[] array；
array = new int[10];

【2018-01-23】【3】C#结构
1.若自定义构造函数不能没有参数
2.构造函数需要初始化所有成员
3.当使用 new 操作符创建一个结构对象时 会调用适当的构造函数来创建结构
与类不同 结构可以不使用 new 操作符即可被实例化
struct HelloStruct
{
	public HelloStruct(string _name)
	{
		name = _name;
		Console.WriteLine("HelloStruct Call");
	}
	public string name;
}

HelloStruct hs;
HelloStruct hs2 = new HelloStruct("hi");
4.结构不支持继承

【2018-01-23】【4】C#枚举
1.访问枚举成员必须带有枚举类型名称(与C++不同)
enum MyEnum
{
	E0,
	E1,
	E2
}
int x = (int)MyEnum.E0;
2.不允许在函数内部定义枚举

【2018-01-24】【1】C#多态
1.C#类中定义抽象函数时其所在类也必须定义成抽象类
abstract class Base
{
	public abstract void Print();
}

2.C#类中定义与基类相同函数(在基类声明为虚函数)
必须加关键字override(重写)或者new(覆盖)

class Base
{
	public virtual void Print()
	{
		Console.WriteLine("Base");
	}
}

class Derived : Base
{
	public new void Print()
	{
		Console.WriteLine("Derived");
	}
}

// 若Print函数关键字为new则输出结果为Base
// 若将Print函数关键字改为override则输出结果为Derived
Derived derived = new Derived();
Base mybase = derived;
mybase.Print();

【2018-01-24】【2】C#接口
1.接口定义
interface Base
{
	// 不能加 virtual 或者 public 关键字
	void Print();
}
2.实现接口
class Derived : Base
{
	public void Print()
	{
		Console.WriteLine("Impl");
	}
}
3.接口可以继承接口
interface Base
{
	void Print();
}

interface Base2 : Base
{
	void Print2();
}

class Derived : Base2
{
	public void Print()
	{
		Console.WriteLine("Impl");
	}

	public void Print2()
	{
		Console.WriteLine("Impl2");
	}
}

【2018-02-07】【1】C#调用C++ DLL
1.C#里调用的 C++ DLL 必须开启 公共语言运行时支持(/clr)
2.在C#引用里添加对应的 C++ DLL
3.加上以下代码

using System.Runtime.InteropServices;   //必须添加，不然DllImport报错
class CPPDLL
{
	//[DllImport("CPPLibrary.dll", CharSet = CharSet.Auto)] //引入dll，并设置字符集
	[DllImport("CPPLibrary.dll")] //可以替代上一句代码
	public static extern void CPPTell();// 对用于 CPPLibrary.dll 里的 extern "C" _declspec(dllexport) void CPPTell()原型
}

然后代码里调用CPPDLL里的函数即可实现调用对应C++ DLL函数了

【2018-02-07】【2】C#调用委托
C#中的委托(Delegate)类似于 C 或 C++ 中函数的指针
声明委托:
public delegate void MyDelegate();
使用:
class FuncClass
{
	static public void FuncA()
	{
		Console.WriteLine("FuncA");
	}

	static public void FuncB()
	{
		Console.WriteLine("FuncB");
	}
}

MyDelegate deleA = new MyDelegate(FuncClass.FuncA);
MyDelegate deleB = new MyDelegate(FuncClass.FuncB);
MyDelegate deleC = null;

deleA();// FuncClass.FuncA
deleB();// FuncClass.FuncB

deleC = deleA;
deleC += deleB;

deleC();// 先调用FuncClass.FuncA然后调用FuncClass.FuncB

【2018-02-08】【1】C#事件
事件在类中声明且生成且通过使用同一个类或其他类中的委托与事件处理程序关联
声明委托:
public delegate void MyDelegate();
class FuncClass
{
	static public void FuncA()
	{
		Console.WriteLine("FuncA");
	}

	static public void FuncB()
	{
		Console.WriteLine("FuncB");
	}
	// 声明事件
	public event MyDelegate deleGate;

	public void Call()
	{
		if (deleGate != null)
		{
			deleGate();
		}
		else
		{
			Console.WriteLine("Nothing");
		}
	}
}

FuncClass funcClass = new FuncClass();
// Nothing
funcClass.Call();

funcClass.deleGate += new MyDelegate(FuncClass.FuncA);
// FuncA
funcClass.Call();

funcClass.deleGate += new MyDelegate(FuncClass.FuncB);
// FuncA FuncB
funcClass.Call();

funcClass.deleGate -= new MyDelegate(FuncClass.FuncB);
// FuncA
funcClass.Call();

funcClass.deleGate -= new MyDelegate(FuncClass.FuncA);
// Nothing
funcClass.Call();

【2018-02-08】【2】C#泛型
泛型类:
class SwapClass<T>
{
	static public void Do(ref T a, ref T b)
	{
		T temp = a;
		a = b;
		b = temp;
	}
}
泛型函数:
public static void Swap<T>(ref T a, ref T b)
{
	SwapClass<T>.Do(ref a, ref b);
}
调用:
int a = 1, b = 2;
Swap(ref a, ref b);

【2018-02-08】【3】C#反射
// http://www.codeisbug.com/Ask/11/1041
// https://www.cnblogs.com/Stephenchao/p/4481995.html
C#反射类似C++的RTTI 可以在程序执行期间判定对象类型
在C#中有三个支持RTTI的关键字：is as typeof

通过is运算符 能够判断对象类型是否为特定类型
通过as运算符 在运行期间执行类型转换 并且能够使得类型转换失败不抛异常 而返回一个null值

通常通过typeof运算符使用反射
简单使用方法:
/*
System.Reflection命名空间包含的几个类 允许你反射(解析)这些元数据表的代码 
System.Type类包装了类型
因此是整个反射子系统的核心 这个类中包含了很多属性和方法
使用这些属性和方法可以在运行时得到类型的信息
*/
System.Type myType = typeof(MyProgram);
foreach (System.Reflection.MemberInfo mi in myType.GetMembers())
{
	Console.WriteLine("{0}/{1}", mi.MemberType, mi.Name);
}

【2018-02-08】【4】C#属性
// http://blog.csdn.net/zt15732625878/article/details/50696590
属性(Property) 是类(class) 结构(structure) 和接口(interface)的命名(named)成员

struct HelloStruct
{
	public HelloStruct(string _name)
	{
		name = _name;
		//Console.WriteLine("HelloStruct Call");
	}

	string name;

	// 属性 外部通过 Name 访问和修改name成员
	public string Name
	{
		get
		{
			return name;
		}
		set
		{
			name = value + "__SET";
		}
	}
	// 属性特殊用法
	// 使用默认的get set方法 相当于 public int Val;
	public int Val { get; set; }
}

HelloStruct hello = new HelloStruct("Hello");
hello.Name = "Test";
// Test__SET
Console.WriteLine(hello.Name);

【2018-02-09】C#关键字
1.sealed关键字
	1.1.当对一个类应用 sealed 修饰符时 此修饰符会阻止其他类从该类继承
	1.2.sealed修饰方法或属性 防止它们重写特定的虚方法或虚属性
2.var关键字
	从 Visual C# 3.0 开始 在方法范围内声明的变量可以具有隐式"类型"var
类似于C++的auto

【2018-02-19】C# yield
C# yield 用于迭代器代码中指示它所在的方法是迭代器块
yield 关键字与 return 关键字结合使用 向枚举器对象提供值 这是一个返回值
yield 关键字也可与 break 结合使用 表示迭代结束
例子:
using System.Collections;
class MyProgram
{
	public IEnumerator GetEnumerator()
	{
		string[] value = { "ONE", "TWO", "THREE" };
		int x = 0;
		foreach(string str in value)
		{
			if (x >= 2)
				yield break;
			yield return str;
			++x;
		}
	}
}

MyProgram prog = new MyProgram();
foreach (string str in prog)
{
	Console.WriteLine(str);
}

输出:
ONE TWO

【2018-02-22】【1】C# 静态类
// http://blog.csdn.net/y13156556538/article/details/51232815
static class MeumScript
静态类不能实例化
不能使用 new 关键字创建静态类类型的变量

【2018-02-22】【2】Unity 新建菜单栏
在Editor下新建脚本
由于使用UnityEditor 如果不在Editor目录下新建会导致设备打包失败
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;

static class MeumScript
{
	[MenuItem("File/Build Bundles/Generate Instance Data")]
	public static void GenerateInstanceData()
	{

	}
}

【2018-02-28】Unity AssetBundle
Unity可以在Inspector为资源指定AssetBundle
然后添加类似代码
[MenuItem("File/Build Bundles/Build AssetBundles")]
static void BuildAllAssetBundles()
{
	string assetBundleDirectory = "Assets/AssetBundles";
	if(!System.IO.Directory.Exists(assetBundleDirectory))
	{
		System.IO.Directory.CreateDirectory(assetBundleDirectory);
	}
	BuildPipeline.BuildAssetBundles(assetBundleDirectory, BuildAssetBundleOptions.None, BuildTarget.StandaloneWindows);
}
导出Bundle

// http://blog.csdn.net/ethuangfen/article/details/53762182
Bundle里的资源可能会存在相互依赖关系 Unity不会根据依赖自动加载Bundle
导出Bundle时的主Bundle 可以通过读取里面 类型为AssetBundleManifest 名为"AssetBundleManifest"的资产
查询Bundle依赖关系 通过代码手动把依赖的Bundle先加载进来 这样根据Bundle实例化对象时资源才能被成功加载

static String CubeBundleName = "cube";
static String SphereBundleName = "sphere";

[MenuItem("File/Build Bundles/Load AssetBundles")]
static void Load()
{
	AssetBundle assetBundleManifest = AssetBundle.LoadFromFile(Application.dataPath + "/AssetBundles/AssetBundles");
	if (assetBundleManifest != null)
	{
		// 读取出主Bundle的manifest
		AssetBundleManifest manifest = (AssetBundleManifest)assetBundleManifest.LoadAsset("AssetBundleManifest");
		if (manifest)
		{
			AssetBundle bundle = AssetBundle.LoadFromFile(Application.dataPath + "/AssetBundles/" + CubeBundleName);
			if (bundle)
			{
				string[] depends = manifest.GetAllDependencies(CubeBundleName);
				AssetBundle[] dependsAssetbundle = new AssetBundle[depends.Length];
				for (int index = 0; index < depends.Length; index++)
				{
					// 读取依赖Bundle
					dependsAssetbundle[index] = AssetBundle.LoadFromFile(Application.dataPath + "/AssetBundles/" + depends[index]);
				}
				GameObject obj = bundle.LoadAsset(CubeBundleName) as GameObject;
				if (obj != null)
				{
					// 实例化GameObject
					GameObject.Instantiate(obj);
				}
				bundle.Unload(false);
				for (int index = 0; index < depends.Length; index++)
				{
					if (dependsAssetbundle[index])
						dependsAssetbundle[index].Unload(false);
				}
			}
		}
		// Bundle不需要使用时要Unload
		assetBundleManifest.Unload(false);
	}
}

AssetBundle.LoadFromFile加载一个Bundle后会全局持有这个Bundle 要通过Bundle对象的Unload方法卸载
否则再次调用AssetBundle.LoadFromFile加载同一个Bundle会失败

【2018-03-01】Unity角度裁剪技巧
首先给所有GameObject加上一个大小很笑的碰撞体
然后通过相机碰撞体与场景碰撞体的相交 判断出相交碰撞体对应的场景物体
然后再进行角度裁剪判断
public class AngleFilterTest : MonoBehaviour
{

	private float m_fLastCheckTime;
	public float fIntervalTime = 0.2f;
	public int nCheckPosDist = 50;
	public int nCheckBoxRange = 100;
	public float fCheckAngle = 0f;

	// Use this for initialization
	void Start ()
	{
	}

	// Update is called once per frame
	void Update ()
	{
		float fNowTime = Time.time;
		if (fNowTime - m_fLastCheckTime > 0.0f)
		{
			SceneFilterProcess();
		}
	}

	void SceneFilterProcess()
	{
		Transform cameraTrans = this.transform;

		Vector3 vecCheckCenterPos = cameraTrans.position + cameraTrans.forward.normalized * nCheckPosDist;
		float fCheckRadian = (fCheckAngle / 2) * Mathf.Deg2Rad;

		Collider[] colliders = Physics.OverlapBox(vecCheckCenterPos, new Vector3(nCheckBoxRange, nCheckBoxRange, nCheckBoxRange));

		BoxCollider boxCollider = null;
		for (uint i = 0; i < colliders.Length; ++i)
		{
			boxCollider = colliders[i] as BoxCollider;
			if (boxCollider != null)
			{
				CalcBoxAngleFoliter(boxCollider, cameraTrans.position, fCheckRadian);
			}
		}

		m_fLastCheckTime = Time.time;
	}

	void CalcBoxAngleFoliter(BoxCollider boxCollider, Vector3 cameraPos, float fCheckRadian)
	{
        GameObject gameObj = boxCollider.gameObject;
        Renderer renderer = gameObj.GetComponent<Renderer>();
        if (renderer != null)
        {
            float fDist = Vector3.Distance(cameraPos, renderer.bounds.center);
            float fRadian = Mathf.Atan(renderer.bounds.extents.x * 0.5f / fDist);

            if (fRadian < fCheckRadian)
                renderer.enabled = false;
            else
                renderer.enabled = true;
        }
	}
}