使用DragonBonesPro制作补间动画、龙骨动画 1.开场动画 2.小丑盒子 3.跑步的人 4.跳跳羊 5.猴子荡树 一.开场动画 1.导入素材 2.将素材拖入舞台内，并调整位置以及图层 3.多处设置关键帧，创建补间动画 4.最后运行 二.小丑盒子动画 1.导入素材 2.将素材拖入舞台，并调整层级 3.创建骨骼，调整场景树 4.添加关键帧，创建补间动画 5.最后运行 三.跑步的人 1.导入json文件 2. 创建手臂和腿的骨骼 3. 创建头部和身体的骨骼 4.所有骨骼建成效果 5.所有场景树 6.添加动作(run) 7.创建其他动作 8.不同状态运行结果 四.跳跳羊 1.导入json素材 2.给羊创建骨骼，调整层级，场景树如图 3.选择网格模式，对跳跳羊创建网格 4.添加边线 5.添加里面的各个点 6.添加关键帧，创建补间动画 7.最终运行图 五.猴子荡树 1.导入素材 2.创建网格以及骨骼，将网格绑定在骨骼上 3.设置关键帧，创建补间动画 4.最终运行

开发软件：DragonBonesPro 1、开场动画实例 2、小丑盒子实例 3、跑步的人实例 4、跳跳样实例 1、开场动画 步骤： 1、导入素材： 2、将素材拖入到舞台并调整位置 3、调整图层位置 4、设置关键帧，创建补间动画 5、成品图 2、小丑盒子实例 步骤： 1、导入素材 2、将素材拖入到舞台，调整层级 3、创建骨骼 4、创建补间动画 5、成果图 小丑头会左摇右晃，辫子会上下摆动，同时弹簧会有收缩 3、跑步的人实例 步骤： 1、导入.json文件 2、创建手臂和腿的骨骼，层级（手臂：innerarm_upper—innerarm lower-innerarm- hand 腿部：innerleg_upper—innerleg lower-innerleg- foot） 3、创建头部和身体的骨骼，层级（lowerbody- upperbody-head） 4、整理骨骼层级 5、制作补间动画 最低位姿态第0帧： 第二个最低位姿态第4帧： 最高位姿态第2帧： 对第一帧和第三帧进行微调，使动作更流畅 用同样的方法完成另一个半步。例如把第0帧的所有关键帧复制到第8帧 创建其他动作： 4、跳跳羊实例 步骤 1、导入.json文件到舞台 2、给跳跳羊创建骨骼，层级如下图 3、选择网格模式，对跳跳羊创建网格、添加顶点 4、制作补间动画 5.运行结果

当我们查看别人的shader,如果没有在代码里找到声明那多半是使用了UNITY内置的文件和变量。 一、包含文件 UNITY可以使用#include 来包含部分文件,文件后缀.cginc,类似C++头文件/java的包 例如 CGPROGRAM ... #include "UnityCG.cginc" ... ENDCG 通过这种方式可以引用UNITY已经封装好的函数/变量我们可以通过 http://unity3d.com/cn/get-unity/download/archive 下载(虽然网站没法访问) 常用的UNITY内置文件 UnityCG.cginc 包含了最常用的函数结构体和宏等 UnityShaderVariables.cginc 在编译UNITY SHADER时 会自动被包含进来 ,包含了很多全局变量 如 UNITY_MATRIX_MVP转换矩阵 Lighting.cginc 包含了各种光照模型,如果编写Surface Shader的话 会被自动包含进来 HLSLSupport.cginc 在编译UNITY SHADER时被自动包含进来,声明了很多用于跨平台编译的宏和定义 UnityStandardBRDF.cginc、UnityStandardCore.cginc 这些文件里面包含了用于基于物理的渲染 ----------------------------------------------------------- 其中UnityCG.cginc是最常用的组件 他里面提供了很多常用的定义和文件 常用结构体名 包含变量 appdata_base 顶点位置 顶点法线 第一组纹理坐标 appdata_tan 顶点位置 顶点法线 顶点切线 第一组纹理坐标 appdata_full 顶点位置 顶点法线 顶点切线 第四组(或者更多)纹理坐标 appdata_img v2f_img 顶点位置 第一组纹理坐标 裁剪空间中的位置 纹理坐标 UnityCG.cginc常用的函数 函数名 描述 float3 WordSpaceViewDir(float4 v) 输入一个模型空间的顶点位置,返回在世界空间中这个点到摄像机的方向 float3 ObjSpaceViewDir(flaot4 v) 输入一个模型空间的顶点位置,返回在模型空间中这个点到摄像机的方向 float3 WordSpaceLightDir(float4 v) 仅可用于前向渲染,输入一个模型空间的顶点,返回世界空间中该点到光源的光照方向,没有被归一化 flaot3 ObjSpaceLightDir(float4 v) 仅可用于前向渲染,输入一个模型空间的顶点,返回模型空间中该点到光源的光照方向,没有被归一化 float3 UnityObjToWorldNormal(flaot3 normal) 把法线方向从模型空间转换到世界空间 float3 UnityObjToWorldDir(int float3 dir) float3 UnityWorldToObjDir(int float3 dir) 把方向矢量从模型空间转换到世界空间中 把方向矢量从世界空间转换到模型空间中 二、内置变量 除了上述常用的函数和文件,unity还提供了很多常用的变量,如用于访问环境光、雾效、时间、光照等目的的变量,这些变量大都在UnityShaderVariables.cginc中 光照的变量还位于 Lighting.cginc 和AutoLight.cginc 三、Unity支持的语义 SV_POSITION/SV_Target/POSITION/COLOR0等等都是CG/HLSL提供的语义 可以在微软的DirectX的文档里找到说明(网址倒是能打开 ,就是没看懂) http://msdn.microsoft.com/en-us/library/windows/desktop/bb509674(v=vs8.5).aspx#VS 语义其实就是赋给shader的一个输入输出的字符串,这个字符串表达了参数的含义，这些语义可以让shader知道从哪里读取数据,并把数据输出到哪里 他们在CG/HLSL的shader流水线中是不可获取的,需要注意的是 Unity并没有支持所有的语义 通常情况下 这些输入输出的参数并不需要特别有意义,我们可以自行决定这些变量的用途.变量本身存储什么 shader并不关心 UNITY为了方便数据传输,对一些特殊的语义进行了特殊的含义规定,例如TEXCOORD0,在顶点着色器的入参结构体a2v的内部我们用它描述texcoord,UNITY会识别该语义并把第一组纹理坐标填充给texcoord,需要注意即使语义一样出现的位置不同,意义也可能不同,如TEXCOORD0出现在输出结构体内时,这个修饰的变量由我自己定义。 在DirectX10之后出现了一种新语义, 系统语义,SV开头 System Value Semantics 例如上面的SV_POSITION修饰pos,那么就表示pos包含了可以用于光栅化的变换后的顶点坐标，即齐次裁剪空间坐标,这些语义修饰的变量是不可随便赋值的,因为流水线需要靠他们去实现一些特殊的目的,例如渲染引擎会把SV_POSITION的坐标经过光栅化后显示在屏幕上,有的时候我们会看到同样的变量在不同的shader里用不同的语义修饰，例如一些shader会使用POSITION而不是SV_POSITION来修饰顶点的着色器输出,SV_POSITION 和POSITION在大多数平台上是等价的,但在某些平台上必须使用SV_POSITION来修饰输出,同样的情况还会在COLOR0和SV_Target上出现, 所以我们尽量使用SV开头的修饰符。 语义名称 描述 POSITION 模型空间中的顶点位置,通常是float4类型 NORMAL 顶点法线,通常是float3类型 TANGENT 顶点切线,通常是float4类型 TEXCOORDn COLOR 第n组纹理坐标,通常是float2和float4类型 顶点颜色,通常是float4或者fixed4 TEXCOORDn的n是由shader model决定的 ,在shader model2 的时候 n最大为4,在shader model 3的时候为8,在shader model 4的时候为16 通常情况下 一个模型的纹理坐标不超过2,即我们往往只使用TEXCOORD0/TEXCOORD1，在UNITY内置的appdata_full中,最多使用6个坐标纹理组 从顶点着色器传递到片元着色器的常用语义 语义 描述 SV_POSITION 裁剪空间里的顶点坐标,输出结构体必须包含这个修饰的变量,DirectX9里面是POSITION，但最好使用SV_POSITION COLOR0 通常用于输出的第一组颜色 但是不是必须的 COLOR1 TEXCOORD0~TEXCOORD7 通常用于输出的第二组颜色,但是不是必须的 通常用于输出纹理坐标,但是不是必须的 上面的语义 除了SV_POSITION之外,其他语义对变量没有明确的要求,也就是说我们可以存储任意值到语义描述的变量中,通常我们把一些自定义数据从顶点着色器传递到片元着色器,使用TEXCOORD0修饰。 片元着色器输出时使用的常用语义 SV_Target:输出值会存储到渲染目标Render Target中,等同于DirectX9中的COLOR语义,但最好使用SV_Target。 四、如何定义复杂的变量类型 上面提到的语义多半用来描述矢量或者标量类型的变量,例如fixed2 float float4 fixed4 下面的代码给出了一些使用语义来修饰不同变量的例子 struct v2f{ float4 pos:SV_POSITION; fixed3 color0:COLOR0; fixed4 color1:COLOR1; half value0:TEXCOORD0; float2 value1:TEXCOORD1; } 需要注意 一个语义可以使用的寄存器最多只能使用四个浮点值,因此如果我们想要定义矩阵类型,如float3*4,float4*4等变量就需要使用更多的空间,另一种方法就是把这些变量拆分成多个变量,如float4*4 可以拆分成4个float4,每个变量存储一行矩阵的元素。

影响服务器租用的因素有什么 ？ 什么是好的 服务器租用 商呢 ？ 其实对于企业来说性能稳定便是最好的要求 ， 但是在选择服务商的时候也需要进行对比 ， 因为不同的判断不同的考量会选择不同的服务商 ， 影响服务器租用的因素有很多 ， 那么应该注意什么呢 ？ 宽带和防御 比如说 ，BGP 多线线路机房 ，6M 宽半的服务器 ， 价格就要比 10M 兆宽带的价格便宜一些 。 宽带与防御因素 ， 其实也是某些不良运营商做动手比较容易切入的地方 ， 所以如果你真的遇到服务器租用价格比较低的运营商的话 ， 那么很可能是商家在这个方面缩减了成本 。 所以一定不要盲目选择这种价格较低的合作伙伴 。 地域因素 也就是说即便是同一运营商 ， 如果机房服务器是在不同的地域 ， 那么所产生的价格也是不一样的 。 所以说 ， 企业在选择服务器租用合作商的时候 ， 一定要考虑一下地域因素 。 尽量选择机房离得近 ， 公司比较近 ， 同时租用价格还比较低这样的合作商 。 是配置因素 这里所说的配置元素 ， 主要包括服务器机房线路 ， 服务器处理器以及内存等等要素 ， 可以说配置越高的话 ， 服务器租用的价格也就越贵 ， 这一点大家应该都心知肚明 。 总的来说 ， 影响企业服务器租用价格的主要因素就是以上三个要素了 。 一般来讲 ， 在选择服务器租用运营商的时候 ， 企业工作人员要切记 ， 运营商要有相关行业资格证 ， 这样才能选出真正适合自己需求的高品质运营商 。

参考<>第五章 一、如何获取其他模型数据 在001里介绍了通过POSITION获取顶点位置坐标,如果想的到更多的模型数据,比如我们想要得到模型上每个顶点的纹理坐标和法线方向 PS:我们可以通过纹理坐标来访问纹理 法线坐标一般用来计算光照 因此我们需要给顶点着色器定义一个新的参数·这个参数将不是一个简单的数据类型 而是一个结构体 Shader "Customer/SimpleShader003"{ SubShader{ Pass{ CGPROGRAM #pragma vertex vert #pragma fragment frag struct a2v{ float4 vertex: POSITION; float3 normal:NORMAL; float4 texcoord:TEXCOORD0; }; float4 vert(a2v v): SV_POSITION{ return mul(UNITY_MATRIX_MVP,v.vertex); } fixed4 frag(): SV_Target{ return fixed4(1.0,1.0,1.0,1.0); } ENDCG } } } 在上面的代码中 声明的结构体a2v 他包含了顶点着色器需要的模型数据 在a2v的定义中,我们用到了更多的UNITY支持的语义,如 NORMAL 和TEXCOORD0,当他们作为顶点着色器的输入时都是有特定含义的 因为UNITY会根据这些语义来填充这个结构体,对于顶点着色器的输出,UNITY 支持的语义有POSITION,TANGENT,NORMAL,TEXCOORD0,TEXCOORD1,TEXCOORD2 TEXCOORD3,COLOR等。 为了使用一个自定义的结构体,我们必须使用如下格式 struct name{ Type Name:Semantic； Type Name:Semantic； ...... }； a表示应用 v表示顶点着色器 a2v的意义就是从应用阶段传递到顶点着色器中 那么填充到POSITION,TANGENT,NORMAL的语义里的数据酒究竟是从哪里来的呢？ 在UNITY中,它们是由使用该材质的MeshRender组件提供的。 在每帧调用DRAW CALL的时候,MeshRender组件会把他负责渲染的模型的数据发送给UNITY SHADER， 我们知道,一个模型通常包含了一组三角面片。(我们不知道啊QAQ) 每个三角面片由三个顶点构成,而每个顶点又包含了一些数据,例如顶点位置、发现坐标、顶点颜色等等 通过上面的方法,我们就可以在顶点着色器中访问顶点的这些模型数据。 二、顶点、片元着色器之间如何相互通信 我们在实际开发的过程中,往往希望从顶点着色器输出一些数据,例如把模型的法线纹理坐标等传递给片元着色器 这就涉及到了顶点着色器和片元着色器之间的通信 为此我们需要新建一个结构体.修改后代码如下 Shader "Customer/SimpleShader004"{ SubShader{ Pass{ CGPROGRAM #pragma vertex vert #pragma fragment frag struct a2v{ float4 vertex:POSITION; float3 normal:NORMAL; float4 texcoord:TEXCOORD0; }; //使用一个结构体来定义顶点着色器的输出 struct v2f{ float4 pos :SV_POSITION; fixed3 color:COLOR0; }; v2f vert(a2v v):SV_POSITION{ v2f o; o.pos = mul(UNITY_MATRIX_MVP,v.vertex); o.color = v.normal*0.5 + fixed3(0.5,0.5,0.5); return o; } fixed4 frag(v2f i):SV_Target{ return fixed4(i.color,1.0); } ENDCG } } } 在上面的代码中,我们声明了一个新的结构体v2f v2f中也需要指定每个变量的语义,在本例中我们定义了SV_POSITION和COLOR0，顶点着色器的输出结构中,必须包含SV_POSITION,否则无法获取 裁剪空间的顶点坐标,COLOR0则由用户自己定义,一般是用来存颜色,例如逐顶点的漫反射颜色等,类似语义还有COLOR1 至此我们完成了从顶点着色器往片元着色器传递数据,顶点着色器是逐顶点的,片元着色器是逐片元的,因此片元着色器的输入实际是把顶点着色器的输出进行插值的结果 二、如何使用属性 unityshader和材质密不可分,shader提供了一些可以设置的参数来调试材质的效果,这些参数需要写在properties语义块里面 比如我们现在有一个新的需求,需要在面板上显示一个颜色拾取器,为此需要修改上面的代码 Shader "Customer/SimpleShader004"{ Properties{ //声明一个color类型的属性 _Color("Color Tint",Color) = (1.0,1.0,1.0,1.0) } SubShader{ Pass{ CGPROGRAM #pragma vertex vert #pragma fragment frag fixed4 _Color; struct a2v{ float4 vertex:POSITION; float3 normal:NORMAL; float4 texcoord:TEXCOORD0; }; struct v2f{ float4 pos:SV_POSITION; float3 color:COLOR0; }; v2f vert(a2v v) :SV_POSITION{ v2f o; o.pos = mul(UNITY_MATRIX_MVP,v.vertex); o.color = v.color*0.5+fixed3(0.5,0.5,0.5); return o; } fixed4 frag(v2f i):SV_Target{ fixed3 = i.color; c *=_Color.rgb; return fixed4(c,1.0); } ENDCG } } } 在上面的语句里我们定义了一个color,(1.0,1.0,1.0,1.0)代表的是白色 为了在CG代码里面访问他,我们还需要提前自己定义一个新变量 ，该变量名必须和属性里的变量名一致 ShaderLab中变量和CG类型中变量对应的关系如下所示 有时 CG变量前会有一个 uniform 关键字 uniform fixed4 _Color; 该关键字在CG里是用来修饰变量,仅仅提供该变量初始值的是如何指定和存储的相关信息,UNITY SHADER里该关键字可以省略。

今天正式开始学习shader, 准确的说是学习如何编写顶点/片元着色器 一、顶点/片元着色器的基本结构 shader包含subshader、shader、property、fallback等语句块 　PS:每个UnityShader文件可以包含多个SubShader语义块，但至少要有一个。 当Unity需要加载这个UnityShader时， Unity会扫描所有的SubShader语义块， 然后选择一个能够在目标平台上运行的SubShader。 如果都不支持的话，Unity 就会使用FallBack语义指定的UnityShader。 同样子着色器中的Pass也是可以有很多个， 当执行子着色器内的渲染方案时，所有的Pass会被依次执行 Shader "MyShader"{ Properties{//属性} SubShader{//针对显卡A的SubShader Pass{ //设置渲染状态和标签 //开始CG代码片段 CGPROGRAM //该代码片段编译指令,例如 #pragma vertex vert #pragma fragment frag //CG代码 ENDCG //其他设置 } //其他需要的Pass ｝ SubShader{//针对显卡B的SubShader} //上面的subshader全都失败之后用于回调的unity shader Fallback "VertexLit" } 其中最重要的是Pass语义块,绝大部分代码都是在Pass里实现的 EXAMPLE: Shader "Customer/SimpleShader"{ SubShader{ Pass{ CGPROGRAM #pragma vertex vert #pragma fragment frag float4 vert(float4 v :POSITION) :SV_POSITION{ return mul(UNITY_MATRIX_MVP,v) } fixed4 frag() : SV_Target{ return fixed4(1.0,1.0,1.0,1.0) } ENDCG } } } 上面的代码里没有用到Properties语义 Properties语义并不是必须的 可以不声明任何材质属性 subshader里没有进行标签设置,所以将使用默认的渲染和标签设置 在SubShader语义块中,我们定义了一个Pass， 这个pass里也没有设置任何自定义的渲染和标签 接着就是CGPROGRAM和ENDGC所包围的CG代码片段 #pragma vertex vert #pragma fragment frag 这两个指令将告诉UNITY哪个函数包含了顶点着色器的代码 哪个包含了片元着色器的代码 float4介绍 参考 https://www.cnblogs.com/jiahuafu/p/6136871.html GPU是以四维向量为基本单位来计算的。4个浮点数所组成的float4向量是GPU内置的最基本类型。使用GPU对两个float4向量进行计算，与CPU对两个整数或两个浮点数进行计算一样简单，都是只需要一个指令就可以完成。 HLSH的基本数据类型定义了float、int和bool等非向量类型，但是它们实际上都会被Complier转换成float4的向量， 只要把float4向量的其中3个数值忽略，就可以把float4类型作为标量使用 。 使用贴图坐标时，只需要二维向量，HLSL定义了float2类型作为二维向量使用。 Shader经常会用到矩阵，HLSL有一个内置类型float4x4,它可以用来表示一个4*4矩阵。float4x4并不是GPU的内置类型，float4x4实际上是由4个float4所组成的数组。其他的还有float3x3、float2x2，分表代表3*3矩阵、2*2矩阵。 Shader也可以声明数组，4*4矩阵实际上就是一个float4 m[4]的数组。注意，Shader中的所有的变量都使用寄存器，没有其他内存空间可以使用，所以越大的数组会占用越多的寄存器，甚至会超出寄存器的数量限制。 在使用float4向量中的个别数值时，可以用xyzw或rgba，都可以用来表示四维向量中的数值。但不能把它们混用，例如不能用xyba，把它视为颜色时就用rgba，否则就是用xyzw，不能把这二者混合使用。 rgba : 前三个值（红绿蓝）的范围为0到255之间的整数或者0%到100%之间的百分数。这些值描述了红绿蓝三原色在预期色彩中的量。 第四个值，alpha值，制订了色彩的透明度/不透明度，它的范围为0.0到1.0之间，0.5为半透明。 rgba(255,255,255,0)则表示完全透明的白色； rgba(0,0,0,1)则表示完全不透明的黑色； rgba(0,0,0,0)则表示完全不透明的白色,也即是无色； 二、顶点着色器结构 具体看一下vert函数的定义 float4 vert(float4 v: POSITION):SV_POSITION{ return mul(UNITY_MATRIX_MVP,v); } 这个就是本例所使用的顶点着色器的代码,他是逐顶点执行的。mul(UNITY_MATRIX_MVP,v)的意思是把顶点坐标从模型空间转换为裁剪空间 vert函数输入的v包含顶点的位置 这个是通过POSITION语义指定的 他的返回值是一个float4类型的变量 POSITION/SV_POSITION都是CG/HLSL里的语义,不可省略 这些语义将要告诉系统用户需要哪些输入值以及用户输出的是什么 。 简单地说POSITION语意用于顶点着色器，用来指定这些个位置坐标值，是在变换前的顶点的object space坐标。SV_POSITION语意则用于像素着色器，用来标识经过顶点着色器变换之后的顶点坐标 本例中POSITION 将告诉UNITY 把模型的顶点坐标填充到输入参数v中 SV_POSITION将告诉UNITY顶点着色器输出的是裁剪空间中的顶点坐标 三、片元着色器结构 现在看一下frag函数 fixed4 frag() ：SV_Target{ return fixed4(1.0,1.0,1.0,1.0); } 上面的代码输出的上一个fixed4类型的变量,并且使用了SV_Target语义进行限定,SV_Target也是一个系统语义,它告诉渲染器,把用户输出的颜色存储到一个渲染目标里,这里将输出到默认的帧缓存中,片元着色器返回的fixed4类型的变量,片元着色器输出的颜色在[0,1]中,其中(0，0，0)是黑色,(1,1,1)是白色. PS:FIXED类型数据 参考 https://www.cnblogs.com/jiahuafu/p/6237859.html 在处理图形运算，特别是3D图形生成运算时，往往要定义一个Fixed数据类型，我称它为定点数，定点数其时就是一个整形数据类型，他的作用就是把所有数 进行转换，从而得到相应类型的整型表达，然后使用定点数进行整行运算，取到最终值并将其转换回实际的基本数据类型。因此它是通过避免大量的浮点运算来加快 图形处理的一个方式。 Fixed类型说了一堆，究竟来做什么的？ 比如上例中，Y轴每次都要偏移0.4，而这个数是个浮点，严重影响了运算速度。比如，我们后台有一个数，用来计量Y轴本次的坐标，就叫做变量YY吧。X每 次都加1，也就是XX++，Y每次加0.4，也就是YY+=0.4。为了提高速度，我们将YY升级到Fixed类型，YY每次加Fixed的0.4，也就 是0.4*65536=26214，然后再四舍五入到整数类型，即YY+=26214，Y=(YY+32768)>>16。这样，就得到了每 次的整数Y，并且都是整数的加减和位运算，速度非常快。 SV_Target介绍 参考 https://zhuanlan.zhihu.com/p/113237579 SV_Target SV_POSITION 这两个都是 语义绑定 （semantics binding）。什么是语义绑定呢？语义绑定可以理解为关键字，我们都知道图形渲染是按照一步一步地进行的，又叫做渲染管线。那么为什么是要一步一步地进行呢？因为GPU的架构与CPU非常不同，cpu更像是人的大脑，可以同时思考不同的问题，而GPU则相当于计算机，通过有特定的输入，通过计算得到最终的输出。GPU没有像CPU一样的堆栈来存取变量与值，所以通过语义绑定将一个计算好的值放在一个物理存储位置，再用的话就利用语义绑定去特定物理位置取出，这也是GPU不能像CPU一样工作的原因之一吧。 SV_前缀的变量代表system value的意思，在DX10+的语义绑定中被使用代表特殊的意义，SV_POSITION在用法上和POSITION是一样的，区别是 SV_POSTION一旦被作为vertex函数的输出语义，那么这个最终的顶点位置就被固定了，不得改变。 四、效果 把写好的shader文件赋值给material文件,然后新建一个3DObject 修改mesh render里面的material为我们自己创建的 效果如下 可以尝试修改shader,参考 https://zhuanlan.zhihu.com/p/85594617 Shader "Custom/SimpleShader02" { SubShader { Pass { Blend SrcAlpha OneMinusSrcAlpha CGPROGRAM #pragma vertex vert #pragma fragment frag #include "UnityCG.cginc" struct appdata { float4 vertex : POSITION; float2 uv : TEXCOORD0; }; struct v2f { float4 vertex : SV_POSITION; float2 uv : TEXCOORD1; }; v2f vert(appdata v) { v2f o; o.vertex = UnityObjectToClipPos(v.vertex); o.uv = v.uv; return o; } float4 frag(v2f i) : SV_Target { return float4(i.uv.r, i.uv.g,0,1); } ENDCG } } 先在两个结构体里面加入一些东西 struct appdata { float4 vertex : POSITION; float2 uv : TEXCOORD0; }; struct v2f { float4 vertex : SV_POSITION; float2 uv : TEXCOORD1; }; 在vertex shader做的事情:将拿到的uv直接通过v2f传给frag函数 v2f vert(appdata v) { v2f o; o.vertex = mul(UNITY_MATRIX_MVP, v.vertex); o.uv = v.uv return o; } 接下来把uv的值填入颜色的返回值中，得到下图 float4 frag(v2f i) : SV_Target { float4 color = float4(i.uv.r, i.uv.g, 0, 1); return color; } PS：TEXCOORD0 TEXCOORD1里的uv是什么？ 纹理坐标，也就是俗称的UV，是顶点数据的一部分。 在建模软件比如3D Max中，建模时有个过程俗称展开UV，其实就是指定模型每个顶点的UV。因为纹理可以有不止一张，所以UV也可以有不止一组。 建模软件导出的模型数据自然也包含顶点的UV数据，在引擎中渲染模型之前，创建顶点缓冲时，包含了UV信息的顶点数组被复制到顶点缓冲里用于接下来的渲染。 在渲染过程中，vs阶段的输入就是(当前)顶点数据，包括各组UV。当然你可以选择性使用，比如说你只需要一组UV，就可以只选择绑定一个TEXCOORD0 texcoord0和texcoord1分别表示两层UV，有时候我们模型上的贴图需要多个图片一起贴在一处，那么贴两层就会有两层UV。 参考<>第五章 参考 https://zhuanlan.zhihu.com/p/113237579 SV_Target介绍 参考 https://zhuanlan.zhihu.com/p/85594617 shader简单着色编写 参考 https://docs.unity3d.com/Manual/SL-VertexProgramInputs.html 官方实例及API介绍 参考 https://www.zhihu.com/question/353273260/answer/876813032 TEXCOORD0 的uv是什么 参考 https://www.cnblogs.com/leeplogs/p/7339097.html TEXCOORD0 参考 https://www.cnblogs.com/jiahuafu/p/6237859.html FIXED类型的数据

什么是服务器日志 ？ 服务器日志要怎么看 ？ 什么是服务器日志 虽然现在很多站长懂得做搜索排名知识 ， 但是懂得 SEO， 并不代表就懂得服务器日志了 ， 那么服务器日志是什么呢 ？ 其实 ， 服务器日志 (server log) 是一个或多个由服务器自动创建和维护的日志文件 ， 其中包含其所执行活动的列表 。 简而言之 ， 服务器日记就是记录网站被访问的全过程 ， 通过服务器日志 ， 站长就可以知道什么时间到什么时间有哪些人来过 ， 并且还知道什么搜索引擎来过 ， 有没有收录你的网页 ， 从你的网站工作的第一天你的日记就有了 。 假如你想做好 SEO， 那么你就要好好的了解下服务器日志了 ， 因为它可以让你更了解搜索引擎爬虫 。 服务器日志怎么看 1、 开始 —— 管理工具 —— 事件查看器 —— 系统或者控制面板 —— 管理工具 —— 事件查看器 —— 系统 。 2、 在远程客户端 ， 运行 IE 浏览器 ， 在地址栏中输入 “https://Win2003 服务器 IP 地址 :8098”， 如 “https://192.168.1.1:8098”。 在弹出的登录对话框中输入管理员的用户名和密码 ， 点击 “ 确定 ” 按钮即可登录 Web 访问接口管理界面 。 接着在 “ 欢迎使用 ” 界面中点击 “ 维护 ” 链接 ， 切换到 “ 维护 ” 管理页面 ， 然后点击 “ 日志 ” 链接进入 。 到日志管理页面后 ， 在日志管理页面中 ， 管理员可以查看 、 下载或清除 windows 2003 服务器日志 。 选择系统日志可进行查看 ， 并且在日志管理页面中可列出 windows 2003 服务器的所有日志分类 ， 如应用程序日志 、 安全日志 、 系统日志 、Web 管理日志等 。

一般来讲，配音分为广义和狭义之分。广义的配音就是指的是音乐、动效、音响、 游戏配音等等的处理。而狭义的配音则指专门为对白、独白、内心独白、解说和旁白等语言的后期配制而进行的一系列创作活动。 　　影视配音和动画配音都是配音艺术，但是，这两种配音类型的创作依据却是不一样的。接下来，我们就一起了解一下影视配音和动画配音创作依据有哪些不同。 影视配音，简单来说就是替前面的演员说话，由配音员为已经完成了的电视剧中的某一人物录制台词，通过后期配音的方法准确、生动的塑造出人物形象。影视剧配音以演员的形象为依据，需要对作品有深刻的感悟和体验，是一种再创造的过程。 　　动画配音是配音演员以文字形象和动画设计师绘出的画面形象，也就是视觉形象为依据，通过自身对作品的深刻理解，运用自己的声音展现动画人物造型的个性，把握语言节奏的艺术创造，而不是再创造。但是，动画配音是一种假定的艺术，不受人物形象的限制，不需要模仿生活，所以，动画配音是不会受到任何物质现实的制约。 　　影视剧配音和动画配音的创作依据是不同的，影视剧配音员需要把握表演者的风格，具有很强的约束性，而动画配音员则没有那么多制约。

「Creator星球游戏开发社区公众号」有2年半了，一直以游戏开发技术内容为主，对于游戏开发如何挣钱还是一个小孩子。 晓衡在不断的探索中成长，计划将游戏开发、运营、挣钱的整个完整流程揉碎，掰开了一点点学习，并与大家分享其中心得！下图是晓衡粗解的小游戏开发运营挣钱模型。 长期以来，个人开发者们主要是停留在立项、开发阶段，其中开发又涉及程序、美术、策划以及测试。 大多数个人开发者，游戏一旦上线效果不好，很可能快速放弃，又开始了一个新的项目，反复轮回，徘徊在放弃的边缘！ 最近，有过两款开发经验的开发者跟晓衡沟通，除了微店源码服务外，能否帮忙对接流量服务，满足前期游戏调优和后期游戏运营需要。 游戏调优是个怎么样的阶段呢？不要小看这个，他是链接游戏开发与运营的重要环节！ 调优的内容大概包括： 游戏性能调优 分享裂变调优 用户留存调优 广告收益调优 当我们完成一款游戏的核心主体功能时，就可以发布上线，这时游戏可以被玩家接触到，想当于我们的种子用户，我们需要获得玩家的反馈，对游戏进行从技术到留存，再到广收益等调整。 但是在微信平台上有一个非常残酷的问题：“没有自然流量”！！！很多开发者连最初的1000个用户都需要较长的时间和巨大的精力才能达成。 由于样本量太低，并不能指导开发者对游戏的调整，从而导致很多具有潜力的游戏沦为数字垃圾安静的躺在开发者的电脑里。 经过晓衡的不懈努力终于对接到一家以儿童机器人（类似智能音箱）运营为主的流量资源，有意向寻找合适流量的小游戏主可进行流量合作。欢迎加我微信： z6346289 ，关注我的微信公众号： Creator游戏开发社区 ，晓衡在线等你！ 完整原文： https://mp.weixin.qq.com/s/4GpsEidOEcYzf4AHAI6P8A

如何传一个固定的Vec3数组: osg::Uniform *uniform3 = new osg::Uniform(osg::Uniform::Type::FLOAT_VEC3, "arr3", 8); uniform3->setElement(0, osg::Vec3(1, 0, 0)); uniform3->setElement(1, osg::Vec3(1, 0, 1)); uniform3->setElement(2, osg::Vec3(1, 1, 0)); 与一般的写法不同, Element的数目是固定的

常用于摄像机追随玩家 实现平滑跟踪 void Update () { if (player != null) { float x = Mathf.Lerp (this.transform.position.x , player.position.x , 0.2f); float y = Mathf.Lerp (this.transform.position.y , player.position.y , 0.2f); this.transform.position = new Vector3 (x , y , this.transform.position.z); } }

我国不同的地方有不同的地方语言，俗称“方言”，近些年来，方言配音在游戏中被广泛应用。不同的方言有其独特之处，不同的方言有不同的发音，声调也有不同。对于声调的方言有什么差异？下面 游戏方言配音小编就给大家说说吧！ 　　现代汉语方言大致分为七大方言区，根据各方言的声调状况，可把它们归并为两大类。 1、北方方言，各地北方话的系统比较一致。大多数地区的声调数目是四个，没有入声调； 2、南方方言，声调数目较多，许多方言都有六七个声调，大多数南方方言都有入声调。 就全国来说，声调差异很大，虽然大部分地区有阴阳上去四类，但表现的调值是不同的。 调类上看，有三类的，也有十类的。而调值的把握不是件很难的事，如果能认清自己方言中的声调，再和普通话的声调做对比。 得出他们之间的对应规律，就会取得事半功倍的效果。 举例说明： 比如阴平在你的方言里是多少，和普通话有什么区别？普通话中“天”这个阴平是高平调，而天津人发“天”时也是阴平，但调值是低平调，找到规律后就好改了。 方言是我国的语言多样性的特色，我们来自不同的地区，不同地区的人会说不同的地方语言，这是中国方言的一大特色。由于方言的声调具有差异。只有了解这些声调知识，才能让方言配音游刃有余。

使用scala的开发的软件 spark , apache flink , kafka 等 scala 与java 区别例子 Scala vs Java HelloWorld public class HelloWorld { public static void main(String[] args) { System.out.println("Hello World..."); } } Scala每行代码并不强求使用;结束，但是Java是必须的 object HelloWorld { def main(args : Array[String]) { println("Hello World...") } } sacla 语法 数字类型转换 判断是否属于某个数字类型 val vs var val：值 final val 值名称:类型 = xxx var：变量 var 值名称:类型 = xxx Scala基本数据类型 Byte/Char Short/Int/Long/Float/Double Boolean lazy scala 函数 函数/方法的定义 def 方法名(参数名:参数类型): 返回值类型 = { // 括号内的叫做方法体 // 方法体内的最后一行为返回值，不需要使用return } 默认参数： 在函数定义时，允许指定参数的默认值 $SPARK_HOME/conf/spark-defaults.conf 可变参数： JDK5+ : 可变参数 循环表达式 to Range until 定义与使用 命名参数 调用参数可以顺序不一样 可变参数 即参数可以有任意多个 /** * 可变参数 ，可以有多个 类似 java 的 ... * @param numbers */ def sum(numbers:Int*): Unit ={ 表达式 if else 等 循环表达式 def loop(): Unit ={ var num1 = 1 to 10 var num2 = 1.to(10) // 与 1 to 10 写法一样的 for (elem <- num1) { println(elem) } for( i <- 1 to 10 if i%2 == 0){ println(i) } val courses=Array("语文","数学") for (elem <- courses) { } courses.foreach(f => println(f)) courses.foreach(f => { println(f) } ) } 面向对象 占位符 _ 下划线，即 使用默认值，不赋值 类的定义与使用 package org.train.scala.c4 object SimpleApp { def main(args: Array[String]): Unit = { val person=new People(); person.name="ss" println(person.name+ person.age) person.eat() person.printInfo() } } class People{ //变量，自动生成 get /set 方法 var name="" var nick : String =_ //不可变常量，没有 get/set val age:Int = 10 def eat(): String={ name +"eat ..." } //只能在class 内可以访问，类外不可以 private [this] val gender="male" // [this] 可去掉： private val gender="male" def printInfo(): Unit ={ println(gender) } } 构造器 package com.imooc.scala.course04 object ConstructorApp { def main(args: Array[String]): Unit = { // val person = new Person("zhangsan", 30) // println(person.name + " : " + person.age + " : " + person.school) // // // val person2 = new Person("PK", 18, "M") // println(person2.name + " : " // + person2.age + " : " // + person2.school + " :" // + person2.gender // ) val student = new Student("PK", 18, "Math") println(student.name + " : " + student.major) println(student) } } // 主构造器 class Person(val name:String, val age:Int) { println("Person Constructor enter....") val school = "ustc" var gender:String = _ // 附属构造器 def this(name:String, age:Int, gender:String) { this(name, age) // 附属构造器的第一行代码必须要调用主构造器或者其他附属构造器 this.gender = gender } println("Person Constructor leave....") } class Student(name:String, age:Int, var major:String) extends Person(name, age) { println("Person Student enter....") //重写 override val school = "peking" override def toString: String = "Person: override def toString :" + school println("Person Student leave....") } 抽象类 abstract package org.train.scala.c4 object AbstractApp { def main(args: Array[String]): Unit = { new Stude2().speak; } } /** * 只有定义，没有实现 */ abstract class Person2{ //抽象方法 def speak //抽象的属性 val name:String } class Stude2 extends Person2{ override def speak: Unit = { println("sk") } override val name: String = _ } 伴生类和伴生对象 /** * 伴生类和伴生对象 * 如果有一个class，还有一个与class同名的object * 那么就称这个object是class的伴生对象，class是object的伴生类 */ //伴生类 （相对 object ApplyTest ） class ApplyTest{ } //伴生对象 （相对class ApplyTest 来说的 ） object ApplyTest{ } apply 方法 package com.imooc.scala.course04 object ApplyApp { def main(args: Array[String]): Unit = { // for(i <- 1 to 10) { // ApplyTest.incr // } // // println(ApplyTest.count) // 10 说明object本身就是一个单例对象 val b = ApplyTest() // ==> Object.apply println("~~~~~~~~~~~") val c = new ApplyTest() println(c) c() // 类名() ==> Object.apply // 对象() ==> Class.apply } } /** * 伴生类和伴生对象 * 如果有一个class，还有一个与class同名的object * 那么就称这个object是class的伴生对象，class是object的伴生类 */ class ApplyTest{ def apply() = { println("class ApplyTest apply....") } } object ApplyTest{ println("Object ApplyTest enter....") var count = 0 def incr = { count = count + 1 } // 最佳实践：在Object的apply方法中去new Class def apply():ApplyTest = { println("Object ApplyTest apply....") // 在object中的apply中new class new ApplyTest } println("Object ApplyTest leave....") } case class // 通常用在模式匹配 object CaseClassApp { def main(args: Array[String]): Unit = { println(Dog("wangcai").name) } } // case class不用new case class Dog(name:String) case class Dog2(name: String) trait 接口 Java/Scala OO 封装：属性、方法封装到类中 Person: private int id, String name, Date birthday..... getter/setter eat、sleep.... 继承：父类和子类之间的关系 User extends Person exam..... 多态：***** 父类引用指向子类对象 精髓所在 开发框架的基石 Person person = new Person(); User user = new User(); Person person = new User(); Trait xxx extends ATrait with BTrait class SparkConf(loadDefaults: Boolean) extends Cloneable with Logging with Serializable ... .... 集合 数组 package com.imooc.scala.course05 object ArrayApp extends App{ // val a = new Array[String](5) // a.length // a(1) = "hello" // // val b = Array("hadoop", "spark", "storm") // // val c = Array(2,3,4,5,6,7,8,9) // c.sum // c.min // c.max // // c.mkString(",") // 可变数组 val c = scala.collection.mutable.ArrayBuffer[Int]() c += 1 c += 2 c += (3,4,5) c ++= Array(6,7,8) c.insert(0,0) c.remove(1) c.remove(0,3) c.trimEnd(2) // for(i <- 0 until c.length) { // println(c(i)) // } // for(ele <- c) { // println(ele) // } for(i <- (0 until c.length).reverse) { println(c(i)) } // println(c.toArray.mkString) } List nil 就是 一个空的集合的意思 package com.imooc.scala.course05 object ListApp extends App{ // val l = List(1,2,3,4,5) // // // val l5 = scala.collection.mutable.ListBuffer[Int]()//可变list // l5 += 2 // l5 += (3,4,5) // l5 ++= List(6,7,8,9) // // // l5 -= 2 // l5 -= 3 // l5 -= (1, 4) // l5 --= List(5,6,7,8) // // println(l5) // // // l5.isEmpty // l5.head // l5.tail def sum(nums:Int*):Int = { if(nums.length == 0) { 0 } else { nums.head + sum(nums.tail:_*) // _* 类型自动转换 } } // val set = scala.collection.mutable.Set[Int]() // set += 1 // set += (1,1) println(sum()) println(sum(1,2,3,4)) } head 就是 第一个， 而 tail 就是 除了 第一个数据的 之后的所有数据 set 无序，不可重复的 list ,用法与 list 类似 // val set = scala.collection.mutable.Set[Int]() //可变set // set += 1 // set += (1,1) map package com.imooc.scala.course05 import scala.collection.mutable object MapApp extends App{ val a = Map("PK" -> 18, "zhangsan" -> 30) val b = Map("PK" -> 18, "zhangsan" -> 30) // val c = mutable.HashMap[String,Int]() // b.getOrElse("PK", 9) // for((key,value) <- b) { // println(key + " : " + value ) // } // for(key <- b.keySet) { // println(key + " : " + b.getOrElse(key, 9)) // } // for(value <- b.values) { // println(value) // } for((key,_) <- b) { println(key + " : " + b.getOrElse(key, 9) ) } } Option , Some, None object OptionApp extends App { val m = Map(1 -> 2) // println(m(1)) // println(m(2)) // println(m.get(1).get) println(m.getOrElse(2, "None")) } /** * case object None extends Option[Nothing] { def isEmpty = true def get = throw new NoSuchElementException("None.get") } final case class Some[+A](x: A) extends Option[A] { def isEmpty = false def get = x } */ Option 是一个抽象类 ， 实现类是 Some ,None Some 代表存在， None 代表空 Tuple // 元组：(.......) object TupleApp extends App{ val a = (1,2,3,4,5) for(i <- 0 until(a.productArity)) { println(a.productElement(i)) } //下标从 1 开始，不是 0 val hostPort = ("localhost",8080) hostPort._1 hostPort._2 } 模式匹配 即 match case 类似 java 的 switch case 用法，但是比JAVA的强大很多 模式匹配 Java： 对一个值进行条件判断，返回针对不同的条件进行不同的处理 变量 match { case value1 => 代码1 case value2 => 代码2 ..... case _ => 代码N } 基本模式匹配 def grade(grade : String): Unit = { grade match{ case "A" => println("99。。。") case "B" => println("89。。。") case _ => println("00。。。") } } 条件匹配 def grade(grade : String): Unit = { grade match{ case "A" => println("99。。。") case "B" => println("89。。。") //条件匹配， 双重过滤 case _ if(grade=="C") => println("cc。。。") case _ => println("00。。。") } } Array 模式匹配 def greeting(array:Array[String]): Unit = { array match { case Array("zhangsan") => println("Hi:zhangsan") //数组必须是 zhangsan case Array(x,y) => println("Hi:" + x + " , " + y) // 数组可以有任意的2个 case Array("zhangsan", _*) => println("Hi:zhangsan and other friends...")//多个内容， case _ => println("Hi: everybody...") } } List 模式匹配 def greeting(list:List[String]): Unit = { list match { case "zhangsan"::Nil => println("Hi:zhangsan") //只有 zhangsan case x::y::Nil => println("Hi:" + x + " , " + y) //只有2个 任意元素 case "zhangsan"::tail => println("Hi: zhangsan and other friends...") // 多个 case _ => println("Hi:everybody....") } } 类型匹配 def matchType(obj:Any): Unit = { obj match { case x:Int => println("Int") case x:String => println("String") case m:Map[_,_] => m.foreach(println) // map , key value 任意 case _ => println("other type") } } 异常处理 //IO val file = "test.txt" try{ // open file // use file val i = 10/0 println(i) } catch { case e:ArithmeticException => println("除数不能为0..") case e:Exception => println(e.getMessage) } finally { // 释放资源，一定能执行: close file } case class 模式匹配 def caseclassMatch(person:Person): Unit = { person match { case CTO(name,floor) => println("CTO name is: " + name + " , floor is: " + floor) case Employee(name,floor) => println("Employee name is: " + name + " , floor is: " + floor) case _ => println("other") } } class Person case class CTO(name:String, floor:String) extends Person case class Employee(name:String, floor:String) extends Person case class Other(name:String) extends Person caseclassMatch(CTO("PK", "22")) caseclassMatch(Employee("zhangsan", "2")) caseclassMatch(Other("other")) Some None 模式匹配 val grades = Map("PK"->"A", "zhangsan"-> "C") def getGrade(name:String): Unit = { val grade = grades.get(name) grade match { case Some(grade) => println(name + ": your grade is :" + grade) case None => println("Sorry....") } } 高级函数 字符串高级操作 object StringApp extends App { val s = "Hello:" val name = "PK" // println(s + name) println(s"Hello:$name") val team = "AC Milan" // 插值 println(s"Hello:$name, Welcome to $team") val b = """ |这是一个多行字符串 |hello |world |PK """.stripMargin println(b) } 查值，就是 s + “ xx $属性名 ” ， 必须是 s 开头的， 属性名 必须带上 $ 匿名函数 匿名参数传递给 对应函数 匿名函数传递给 add 函数 ， 或者 匿名函数传递给变量都是可以的 currying 函数 // 将原来接收两个参数的一个函数，转换成2个 def sum(a:Int, b:Int) = a+b println(sum(2,3)) // 改成 currying 函数 def sum2(a:Int)(b:Int) = a + b println(sum2(2)(3)) 即将参数给 拆开 高阶函数 package com.imooc.scala.course07 /** * 匿名函数： 函数是可以命名的，也可以不命名 * (参数名：参数类型...) => 函数体 */ object FunctionApp extends App { // def sayHello(name:String): Unit = { // println("Hi: " + name) // } // // sayHello("PK") // // 将原来接收两个参数的一个函数，转换成2个 // def sum(a:Int, b:Int) = a+b // println(sum(2,3)) // // def sum2(a:Int)(b:Int) = a + b // println(sum2(2)(3)) val l = List(1, 2, 3, 4, 5, 6, 7, 8) //map: 逐个去操作集合中的每个元素 // l.map((x: Int) => x + 1) // l.map((x) => x * 2) // l.map(x => x * 2) // l.map(_ * 2).foreach(println) // l.map(_ * 2).filter(_ > 8).foreach(println) // 1+2 3+3 6+4 10+5 // l.reduce(_+_) // 即 求和 sum l.reduceLeft(_-_) l.reduceRight(_-_) l.fold(0)(_-_) println( l.fold(100)(_ + _)) // 从 100 开始 以此 求和 val f = List(List(1,2),List(3,4),List(5,6)) f.flatten // // 压扁 合成一个 List // flatMap f.map(_.map(_*2)) //每个元素 乘以2 f.flatMap(_.map(_*2)) // 并合成一个 List, 每个元素 乘以2 , val txt = scala.io.Source.fromFile("/Users/rocky/imooc/hello.txt").mkString // println(txt) val txts = List(txt) // 如何使用scala来完成wordcount统计 // 链式编程：Hibernate、Spark txts.flatMap(_.split(",")).map(x => (x,1)) //... .foreach(println) } 偏函数 /** * 偏函数：被包在花括号内没有match的一组case语句 */ object PartitalFunctionApp extends App { val names = Array("Akiho Yoshizawa", "YuiHatano", "Aoi Sola") val name = names(Random.nextInt(names.length)) name match { case "Akiho Yoshizawa" => println("吉老师...") case "YuiHatano" => println("波老师....") case _ => println("真不知道你们在说什么....") } // A 输入参数类型 B 输出参数类型 // A 输入参数类型 第一个参数, B 输出参数类型 第二个参数, def sayChinese:PartialFunction[String,String] = { case "Akiho Yoshizawa" => "吉老师..." case "YuiHatano" => "波老师...." case _ => "真不知道你们在说什么...." } println(sayChinese("Akiho Yoshizawa")) } 隐式转换 即类似 java 的 动态代理 AOP 需求：为一个已存在的类添加一个新的方法 Java：动态代理 Scala：隐式转换 双刃剑 Spark/Hive/MR.... 调优 import java.io.File //import ImplicitAspect._ object ImplicitApp { // 定义隐式转换函数即可 // implicit def man2superman(man:Man):Superman = new Superman(man.name) // val man = new Man("PK") // man.fly() // implicit def file2RichFile(file: File): RichFile = new RichFile(file) // val file = new File("/Users/rocky/imooc/hello.txt") // val txt = file.read() // println(txt) } //class Man(val name: String) { // def eat(): Unit = { // println(s"man[ $name ] eat ..... ") // } //} // //class Superman(val name: String) { // def fly(): Unit = { // println(s"superman[ $name ] fly ..... ") // } //} class RichFile(val file: File) { def read() = { scala.io.Source.fromFile(file.getPath).mkString } } 隐式参数 object ImplicatParam extends App { def testParam(implicit name:String): Unit ={ println(name) } // testParam("aa") // implicit val name2 ="bb" // testParam// 不会报错，默认使用 name2 // implicit val s1="s1" // implicit val s2="s2" // testParam // 多个 会报错，不知道用 s1 还是 s2 } 隐式类 object ImplicitClassApp extends App { implicit class Calcuotor(x:Int){ def add(a:Int) = a+x } println(1.add(3)) // 可以使用调用 Calcuotor 方法 } scala 操作外部数据 读取文件及网络数据 import scala.io.Source object FileApp { def main(args: Array[String]): Unit = { val file = Source.fromFile("/Users/rocky/imooc/hello.txt")(scala.io.Codec.ISO8859) def readLine(): Unit ={ for(line <- file.getLines()){ println(line) } } //readLine() def readChar(): Unit ={ for(ele <- file) { println(ele) } } // readChar() def readNet(): Unit ={ val file = Source.fromURL("http://www.baidu.com") for(line <- file.getLines()){ println(line) } } readNet() } } 读取mysql package org.train.scala.c9 import java.sql.{Connection, DriverManager} object MySQLApp { def main(args: Array[String]): Unit = { val url = "jdbc:mysql://localhost:3306/mysql" val username = "root" val password = "123456" var connection:Connection = null try{ // make the connection classOf[com.mysql.jdbc.Driver] connection = DriverManager.getConnection(url, username, password) // create the statement, and run the select query val statement = connection.createStatement() val resultSet = statement.executeQuery("select host,user from user") while(resultSet.next()){ val host = resultSet.getString("host") val user = resultSet.getString("user") println(s"$host, $user") } } catch { case e:Exception => e.printStackTrace() } finally { // free if(connection == null) { connection.close() } } } } 与java 写法一样的 操作xml

FIX4.2 Test

package org.train.scala.c9 import java.io.{FileInputStream, InputStreamReader} import scala.xml.XML object XMLApp { def main(args: Array[String]): Unit = { // loadXML() // readXMLAttr() updateXML() } def updateXML(): Unit ={ val xml = XML.load(this.getClass.getClassLoader.getResource("books.xml")) // println(xml) val bookMap = scala.collection.mutable.HashMap[String,String]() (xml \ "book").map(x => { val id = (x \ "@id").toString() val name = (x \ "name").text.toString bookMap(id) = name }) // for((key,value) <- bookMap) { // println(s"$key : $value") // } val newXml = {bookMap.map(updateXmlFile)} // println(newXml) XML.save("newBooks.xml", newXml) } def updateXmlFile(ele:(String,String)) = { val (id, oldName) = ele {oldName + " Programming"} } def readXMLAttr(): Unit = { val xml = XML.load(this.getClass.getClassLoader.getResource("pk.xml")) // println(xml) // header/field // val headerField = xml \ "header" \ "field" // println(headerField) // all field // val fields = xml \\ "field" // for (field <- fields) { // println(field) // } // header/field/name // val fieldAttributes = (xml \ "header" \ "field").map(_ \ "@name") // val fieldAttributes = (xml \ "header" \ "field" \\ "@name") // for (fieldAttribute <- fieldAttributes) { // println(fieldAttribute) // } //name="Logon" message // val filters = (xml \\ "message") // .filter(_.attribute("name").exists(_.text.equals("Logon"))) // val filters = (xml \\ "message") // .filter(x => ((x \ "@name").text).equals("Logon")) // for (filter <- filters) { // println(filter) // } // header/field content (xml \ "header" \ "field") .map(x => (x \ "@name", x.text, x \ "@required")) .foreach(println) } def loadXML(): Unit = { // val xml = XML.load(this.getClass.getClassLoader.getResource("test.xml")) // println(xml) // val xml = XML.load(new FileInputStream("/Users/rocky/source/scala-train/src/main/resources/test.xml")) // println(xml) val xml = XML.load( new InputStreamReader( new FileInputStream("/Users/rocky/source/scala-train/src/main/resources/test.xml") ) ) println(xml) } } scala 结合spring boot 参考 https://gitee.com/odilil/boot-scala?_from=gitee_search bean 注入 还可以： @Autowired val metaTableRepository : MetaTableRepository = null // 不能使用 _ 下划线 占位符来标识

特别要注意第二窗体对应的view的fxml文件路径写法（view和controller都放在各自的包下）： @FXML protected void show2Action() throws IOException { Stage stage = new Stage(); stage.setTitle("第二个窗体实验"); AnchorPane pane = FXMLLoader.load(getClass().getResource("../javafxcontroller2.fxml"));//要注意fxml文件的类路径写法(与本JavaFXController.java的相对关系） Scene scene = new Scene(pane,300,400); stage.setScene(scene); stage.initModality(Modality.APPLICATION_MODAL);//模式窗体 stage.setOnCloseRequest(new EventHandler() { @Override public void handle(WindowEvent event) { System.out.println("window close event"); if(i++<2){ event.consume(); // i=0; } else i=0; } }); stage.show(); // stage.showAndWait(); //等待stage关闭之后才能继续运行 System.out.println("stage.showAndWait"); // stage.show(); }

1.触发条件： MinorGC：当Eden去满了就会触发。 FullGC： 1.调用System.gc()后，建议FullGC，但不一定会执行； 2.老年代空间满了； 3.方法区满了； 4.调用MinorGC后进入老年代的平均大小大于老年代可用内存；

一、ThreadLocal简介 　　多线程访问同一个共享变量的时候容易出现并发问题，特别是多个线程对一个变量进行写入的时候，为了保证线程安全，一般使用者在访问共享变量的时候需要进行额外的同步措施才能保证线程安全性。ThreadLocal是除了加锁这种同步方式之外的一种保证一种规避多线程访问出现线程不安全的方法，当我们在创建一个变量后，如果每个线程对其进行访问的时候访问的都是线程自己的变量这样就不会存在线程不安全问题。 　　ThreadLocal是JDK包提供的，它提供线程本地变量，如果创建一乐ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的一个副本，在实际多线程操作的时候，操作的是自己本地内存中的变量，从而规避了线程安全问题，如下图所示 二、ThreadLocal简单使用 　　下面的例子中，开启两个线程，在每个线程内部设置了本地变量的值，然后调用print方法打印当前本地变量的值。如果在打印之后调用本地变量的remove方法会删除本地内存中的变量，代码如下所示 1 package test; 2 3 public class ThreadLocalTest { 4 5 static ThreadLocal localVar = new ThreadLocal<> (); 6 7 static void print(String str) { 8 // 打印当前线程中本地内存中本地变量的值 9 System.out.println(str + " :" + localVar.get()); 10 // 清除本地内存中的本地变量 11 localVar.remove(); 12 } 13 14 public static void main(String[] args) { 15 Thread t1 = new Thread( new Runnable() { 16 @Override 17 public void run() { 18 // 设置线程1中本地变量的值 19 localVar.set("localVar1" ); 20 // 调用打印方法 21 print("thread1" ); 22 // 打印本地变量 23 System.out.println("after remove : " + localVar.get()); 24 } 25 }); 26 27 Thread t2 = new Thread( new Runnable() { 28 @Override 29 public void run() { 30 // 设置线程1中本地变量的值 31 localVar.set("localVar2" ); 32 // 调用打印方法 33 print("thread2" ); 34 // 打印本地变量 35 System.out.println("after remove : " + localVar.get()); 36 } 37 }); 38 39 t1.start(); 40 t2.start(); 41 } 42 } 下面是运行后的结果： 三、ThreadLocal的实现原理 　　下面是ThreadLocal的类图结构，从图中可知：Thread类中有两个变量threadLocals和inheritableThreadLocals，二者都是ThreadLocal内部类ThreadLocalMap类型的变量，我们通过查看内部内ThreadLocalMap可以发现实际上它类似于一个HashMap。在默认情况下，每个线程中的这两个变量都为null ，只有当线程第一次调用ThreadLocal的set或者get方法的时候才会创建他们（后面我们会查看这两个方法的源码）。除此之外，和我所想的不同的是，每个线程的本地变量不是存放在ThreadLocal实例中，而是放在调用线程的ThreadLocals变量里面（前面也说过，该变量是Thread类的变量）。也就是说，ThreadLocal类型的本地变量是存放在具体的线程空间上，其本身相当于一个装载本地变量的工具壳，通过set方法将value添加到调用线程的threadLocals中，当调用线程调用get方法时候能够从它的threadLocals中取出变量。如果调用线程一直不终止，那么这个本地变量将会一直存放在他的threadLocals中，所以不使用本地变量的时候需要调用remove方法将threadLocals中删除不用的本地变量。下面我们通过查看ThreadLocal的set、get以及remove方法来查看ThreadLocal具体实怎样工作的 　　1、set方法源码 1 public void set(T value) { 2 //(1) 获取当前线程（调用者线程） 3 Thread t = Thread.currentThread(); 4 //(2) 以当前线程作为key值，去查找对应的线程变量，找到对应的map 5 ThreadLocalMap map = getMap(t); 6 //(3) 如果map不为null，就直接添加本地变量，key为当前线程，值为添加的本地变量值 7 if (map != null ) 8 map.set( this , value); 9 //(4) 如果map为null，说明首次添加，需要首先创建出对应的map 10 else 11 createMap(t, value); 12 } 　　在上面的代码中，(2)处调用getMap方法获得当前线程对应的threadLocals(参照上面的图示和文字说明)，该方法代码如下 ThreadLocalMap getMap(Thread t) { return t.threadLocals; // 获取线程自己的变量threadLocals，并绑定到当前调用线程的成员变量threadLocals上 } 　　如果调用getMap方法返回值不为null，就直接将value值设置到threadLocals中（key为当前线程引用，值为本地变量）；如果getMap方法返回null说明是第一次调用set方法（前面说到过，threadLocals默认值为null，只有调用set方法的时候才会创建map），这个时候就需要调用createMap方法创建threadLocals，该方法如下所示 1 void createMap(Thread t, T firstValue) { 2 t.threadLocals = new ThreadLocalMap( this , firstValue); 3 } 　　createMap方法不仅创建了threadLocals，同时也将要添加的本地变量值添加到了threadLocals中。 　　2、get方法源码 　　在get方法的实现中，首先获取当前调用者线程，如果当前线程的threadLocals不为null，就直接返回当前线程绑定的本地变量值，否则执行setInitialValue方法初始化threadLocals变量。在setInitialValue方法中，类似于set方法的实现，都是判断当前线程的threadLocals变量是否为null，是则添加本地变量（这个时候由于是初始化，所以添加的值为null），否则创建threadLocals变量，同样添加的值为null。 1 public T get() { 2 // (1)获取当前线程 3 Thread t = Thread.currentThread(); 4 // (2)获取当前线程的threadLocals变量 5 ThreadLocalMap map = getMap(t); 6 // (3)如果threadLocals变量不为null，就可以在map中查找到本地变量的值 7 if (map != null ) { 8 ThreadLocalMap.Entry e = map.getEntry( this ); 9 if (e != null ) { 10 @SuppressWarnings("unchecked" ) 11 T result = (T)e.value; 12 return result; 13 } 14 } 15 // (4)执行到此处，threadLocals为null，调用该更改初始化当前线程的threadLocals变量 16 return setInitialValue(); 17 } 18 19 private T setInitialValue() { 20 // protected T initialValue() {return null;} 21 T value = initialValue(); 22 // 获取当前线程 23 Thread t = Thread.currentThread(); 24 // 以当前线程作为key值，去查找对应的线程变量，找到对应的map 25 ThreadLocalMap map = getMap(t); 26 // 如果map不为null，就直接添加本地变量，key为当前线程，值为添加的本地变量值 27 if (map != null ) 28 map.set( this , value); 29 // 如果map为null，说明首次添加，需要首先创建出对应的map 30 else 31 createMap(t, value); 32 return value; 33 } 　　3、remove方法的实现 　　remove方法判断该当前线程对应的threadLocals变量是否为null，不为null就直接删除当前线程中指定的threadLocals变量 1 public void remove() { 2 // 获取当前线程绑定的threadLocals 3 ThreadLocalMap m = getMap(Thread.currentThread()); 4 // 如果map不为null，就移除当前线程中指定ThreadLocal实例的本地变量 5 if (m != null ) 6 m.remove( this ); 7 } 　　4、如下图所示：每个线程内部有一个名为threadLocals的成员变量，该变量的类型为ThreadLocal.ThreadLocalMap类型（类似于一个HashMap），其中的key为当前定义的ThreadLocal变量的this引用，value为我们使用set方法设置的值。每个线程的本地变量存放在自己的本地内存变量threadLocals中，如果当前线程一直不消亡，那么这些本地变量就会一直存在（所以可能会导致内存溢出），因此使用完毕需要将其remove掉。 四、ThreadLocal不支持继承性 　　同一个ThreadLocal变量在父线程中被设置值后，在子线程中是获取不到的。（threadLocals中为当前调用线程对应的本地变量，所以二者自然是不能共享的） 1 package test; 2 3 public class ThreadLocalTest2 { 4 5 // (1)创建ThreadLocal变量 6 public static ThreadLocal threadLocal = new ThreadLocal<> (); 7 8 public static void main(String[] args) { 9 // 在main线程中添加main线程的本地变量 10 threadLocal.set("mainVal" ); 11 // 新创建一个子线程 12 Thread thread = new Thread( new Runnable() { 13 @Override 14 public void run() { 15 System.out.println("子线程中的本地变量值:"+ threadLocal.get()); 16 } 17 }); 18 thread.start(); 19 // 输出main线程中的本地变量值 20 System.out.println("mainx线程中的本地变量值:"+ threadLocal.get()); 21 } 22 } 五、InheritableThreadLocal类 　　在上面说到的ThreadLocal类是不能提供子线程访问父线程的本地变量的，而InheritableThreadLocal类则可以做到这个功能，下面是该类的源码 1 public class InheritableThreadLocal extends ThreadLocal { 2 3 protected T childValue(T parentValue) { 4 return parentValue; 5 } 6 7 ThreadLocalMap getMap(Thread t) { 8 return t.inheritableThreadLocals; 9 } 10 11 void createMap(Thread t, T firstValue) { 12 t.inheritableThreadLocals = new ThreadLocalMap( this , firstValue); 13 } 14 } 　　从上面代码可以看出，InheritableThreadLocal类继承了ThreadLocal类，并重写了childValue、getMap、createMap三个方法。其中createMap方法在被调用（当前线程调用set方法时得到的map为null的时候需要调用该方法）的时候，创建的是inheritableThreadLocal而不是threadLocals。同理，getMap方法在当前调用者线程调用get方法的时候返回的也不是threadLocals而是inheritableThreadLocal。 　　下面我们看看重写的childValue方法在什么时候执行，怎样让子线程访问父线程的本地变量值。我们首先从Thread类开始说起 1 private void init(ThreadGroup g, Runnable target, String name, 2 long stackSize) { 3 init(g, target, name, stackSize, null , true ); 4 } 5 private void init(ThreadGroup g, Runnable target, String name, 6 long stackSize, AccessControlContext acc, 7 boolean inheritThreadLocals) { 8 // 判断名字的合法性 9 if (name == null ) { 10 throw new NullPointerException("name cannot be null" ); 11 } 12 13 this .name = name; 14 // (1)获取当前线程(父线程) 15 Thread parent = currentThread(); 16 // 安全校验 17 SecurityManager security = System.getSecurityManager(); 18 if (g == null ) { // g:当前线程组 19 if (security != null ) { 20 g = security.getThreadGroup(); 21 } 22 if (g == null ) { 23 g = parent.getThreadGroup(); 24 } 25 } 26 g.checkAccess(); 27 if (security != null ) { 28 if (isCCLOverridden(getClass())) { 29 security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION); 30 } 31 } 32 33 g.addUnstarted(); 34 35 this .group = g; // 设置为当前线程组 36 this .daemon = parent.isDaemon(); // 守护线程与否(同父线程) 37 this .priority = parent.getPriority(); // 优先级同父线程 38 if (security == null || isCCLOverridden(parent.getClass())) 39 this .contextClassLoader = parent.getContextClassLoader(); 40 else 41 this .contextClassLoader = parent.contextClassLoader; 42 this .inheritedAccessControlContext = 43 acc != null ? acc : AccessController.getContext(); 44 this .target = target; 45 setPriority(priority); 46 //(2) 如果父线程的inheritableThreadLocal不为null 47 if (inheritThreadLocals && parent.inheritableThreadLocals != null ) 48 //（3） 设置子线程中的inheritableThreadLocals为父线程的inheritableThreadLocals 49 this .inheritableThreadLocals = 50 ThreadLocal.createInheritedMap(parent.inheritableThreadLocals); 51 this .stackSize = stackSize; 52 53 tid = nextThreadID(); 54 } 　　在init方法中，首先(1)处获取了当前线程(父线程)，然后（2）处判断当前父线程的inheritableThreadLocals是否为null，然后调用createInheritedMap将父线程的inheritableThreadLocals作为构造函数参数创建了一个新的ThreadLocalMap变量，然后赋值给子线程。下面是createInheritedMap方法和ThreadLocalMap的构造方法 1 static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) { 2 return new ThreadLocalMap(parentMap); 3 } 4 5 private ThreadLocalMap(ThreadLocalMap parentMap) { 6 Entry[] parentTable = parentMap.table; 7 int len = parentTable.length; 8 setThreshold(len); 9 table = new Entry[len]; 10 11 for ( int j = 0; j < len; j++ ) { 12 Entry e = parentTable[j]; 13 if (e != null ) { 14 @SuppressWarnings("unchecked" ) 15 ThreadLocal