随风逐叶

unity中判断iphone设备型号的方法

作者: rontian
时间: 2018-03-26
分类: Unity3D
评论

> 转载来源:<a href="http://www.unitycn.cn/?p=342" target="_blank">http://www.unitycn.cn/?p=342</a>

### SystemInfo 详解
```
Rendering.CopyTextureSupport copyTextureSupport：（只读）支持多种复制纹理功能的情况。
string  deviceModel：（只读）设备的模型或模式。
string  deviceName：（只读）用户定义的设备名称。
DeviceType  deviceType：（只读）返回程序运行所在的设备类型（PC电脑、掌上型等）。
string  deviceUniqueIdentifier：（只读）设备的唯一标识符。每一台设备都有唯一的标识符。
int   graphicsDeviceID：（只读）显卡的唯一标识符ID。
string  graphicsDeviceName：（只读）显卡的名称。
Rending.GraphicsDeviceType  graphicsDeviceType：（只读）显卡的类型。
string   graphicsDeviceVendor：（只读）显卡的供应商。
int   graphicsDeviceVendorID：（只读）显卡供应商的唯一识别码ID。
string   graphicsDeviceVersion：（只读）显卡的类型和版本。
int   graphicsMemorySize：（只读）显存大小。
bool  graphicsMultiThreaded：（只读）是否支持多线程渲染？
int   graphicsShaderLevel：（只读）显卡着色器的级别。
int   maxTextureSize：（只读）支持的最大纹理大小。
NPOTSupport  npotSupport：（只读）GPU支持的NPOT纹理。
string  operatingSystem：（只读）操作系统的版本名称。
int   processorCount：（只读）当前处理器的数量。
int   processorFrequency：（只读）处理器的频率。
string  processorType：（只读）处理器的名称。
int   supportedRenderTargetCount：（只读）支持渲染多少目标纹理。
bool  supports2DArrayTextures：（只读）是否支持2D数组纹理。
bool  supports3DTextures：（只读）是否支持3D（体积）纹理。
bool  supportsAccelerometer：（只读）是否支持获取加速度计。
bool  supportsAudio：（只读）是否支持获取用于回放的音频设备。
bool  supportsComputeShaders：（只读）是否支持计算着色器。
bool  supportsGyroscope：是否支持获取陀螺仪。
bool  supportsImageEffects：（只读）是否支持图形特效。
bool  supportsInstancing：（只读）是否支持实例化GPU的Draw Call。
bool  supportsLocationService：是否支持定位功能。
bool  supportsMotionVectors：是否支持运动向量。
bool  supportsRawShadowDepthSampling：（只读）是否支持阴影深度。
bool  supportsRenderTextures：（只读）是否支持渲染纹理。
bool  supportsRenderToCubemap：（只读）是否支持立方体纹理。
bool  supportsShadows：（只读）是否支持内置阴影。
bool  supportsSparseTextures：（只读）是否支持稀疏纹理。
bool  supportsStencil：（只读）是否支持模版缓存。
bool  supportsVibration：是否支持用户触摸震动反馈。
int   systemMemorySize：（只读）系统内存大小。
string   unsupportedIdentifier：不支持运行在当前设备的SystemInfo属性值。
```

KVM VPS Ubuntu16 使用Docker安装shadowsocks

作者: rontian
时间: 2018-01-25
分类: Others
评论

Unity模型变灰Shader

作者: rontian
时间: 2017-12-22
分类: Unity3D
评论

#### 使用方法
```csharp
Renderer tryRenderer = gameObject.GetComponent<Renderer>();
if (value)
{
    tryRenderer.material.SetInt("_Desaturate", 1);
}
else
{
    tryRenderer.material.SetInt("_Desaturate", 0);
}
```
#### 代码
```
// Shader created with Shader Forge v1.38

Shader "Shader Forge/Model gray" {
    Properties {
        _Diffuse ("Diffuse", 2D) = "white" {}
        _Color ("Color", Color) = (0.5,0.5,0.5,1)
        [MaterialToggle] _Desaturate ("Desaturate", Float ) = 0
        [HideInInspector]_Cutoff ("Alpha cutoff", Range(0,1)) = 0.5
    }
    SubShader {
        Tags {
            "Queue"="AlphaTest"
            "RenderType"="TransparentCutout"
        }
        Pass {
            Name "FORWARD"
            Tags {
                "LightMode"="ForwardBase"
            }
            
            
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #define UNITY_PASS_FORWARDBASE
            #include "UnityCG.cginc"
            #include "AutoLight.cginc"
            #include "Lighting.cginc"
            #pragma multi_compile_fwdbase_fullshadows
            #pragma multi_compile_fog
            #pragma only_renderers d3d9 d3d11 glcore gles metal 
            #pragma target 3.0
            uniform sampler2D _Diffuse; uniform float4 _Diffuse_ST;
            uniform float4 _Color;
            uniform fixed _Desaturate;
            struct VertexInput {
                float4 vertex : POSITION;
                float3 normal : NORMAL;
                float2 texcoord0 : TEXCOORD0;
            };
            struct VertexOutput {
                float4 pos : SV_POSITION;
                float2 uv0 : TEXCOORD0;
                float4 posWorld : TEXCOORD1;
                float3 normalDir : TEXCOORD2;
                LIGHTING_COORDS(3,4)
                UNITY_FOG_COORDS(5)
            };
            VertexOutput vert (VertexInput v) {
                VertexOutput o = (VertexOutput)0;
                o.uv0 = v.texcoord0;
                o.normalDir = UnityObjectToWorldNormal(v.normal);
                o.posWorld = mul(unity_ObjectToWorld, v.vertex);
                float3 lightColor = _LightColor0.rgb;
                o.pos = UnityObjectToClipPos( v.vertex );
                UNITY_TRANSFER_FOG(o,o.pos);
                TRANSFER_VERTEX_TO_FRAGMENT(o)
                return o;
            }
            float4 frag(VertexOutput i) : COLOR {
                i.normalDir = normalize(i.normalDir);
                float3 normalDirection = i.normalDir;
                float4 _Diffuse_var = tex2D(_Diffuse,TRANSFORM_TEX(i.uv0, _Diffuse));
                clip(_Diffuse_var.a - 0.5);
                float3 lightDirection = normalize(_WorldSpaceLightPos0.xyz);
                float3 lightColor = _LightColor0.rgb;
////// Lighting:
                float attenuation = LIGHT_ATTENUATION(i);
////// Emissive:
                float3 node_544 = (lerp( _Diffuse_var.rgb, (float3(0.6,0.6,0.6)*lerp(_Diffuse_var.rgb,dot(_Diffuse_var.rgb,float3(0.3,0.59,0.11)),1.0)), _Desaturate )*_Color.rgb); // Diffuse Color
                float3 emissive = (node_544*_LightColor0.rgb*UNITY_LIGHTMODEL_AMBIENT.rgb);
                float node_7731 = 0.5;
                float node_5683 = ((max(0,dot(lightDirection,normalDirection))+node_7731)*node_7731);
                float3 finalColor = emissive + ((node_544*(node_5683*node_5683))*_LightColor0.rgb*attenuation);
                fixed4 finalRGBA = fixed4(finalColor,1);
                UNITY_APPLY_FOG(i.fogCoord, finalRGBA);
                return finalRGBA;
            }
            ENDCG
        }
        Pass {
            Name "FORWARD_DELTA"
            Tags {
                "LightMode"="ForwardAdd"
            }
            Blend One One
            
            
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #define UNITY_PASS_FORWARDADD
            #include "UnityCG.cginc"
            #include "AutoLight.cginc"
            #include "Lighting.cginc"
            #pragma multi_compile_fwdadd_fullshadows
            #pragma multi_compile_fog
            #pragma only_renderers d3d9 d3d11 glcore gles metal 
            #pragma target 3.0
            uniform sampler2D _Diffuse; uniform float4 _Diffuse_ST;
            uniform float4 _Color;
            uniform fixed _Desaturate;
            struct VertexInput {
                float4 vertex : POSITION;
                float3 normal : NORMAL;
                float2 texcoord0 : TEXCOORD0;
            };
            struct VertexOutput {
                float4 pos : SV_POSITION;
                float2 uv0 : TEXCOORD0;
                float4 posWorld : TEXCOORD1;
                float3 normalDir : TEXCOORD2;
                LIGHTING_COORDS(3,4)
                UNITY_FOG_COORDS(5)
            };
            VertexOutput vert (VertexInput v) {
                VertexOutput o = (VertexOutput)0;
                o.uv0 = v.texcoord0;
                o.normalDir = UnityObjectToWorldNormal(v.normal);
                o.posWorld = mul(unity_ObjectToWorld, v.vertex);
                float3 lightColor = _LightColor0.rgb;
                o.pos = UnityObjectToClipPos( v.vertex );
                UNITY_TRANSFER_FOG(o,o.pos);
                TRANSFER_VERTEX_TO_FRAGMENT(o)
                return o;
            }
            float4 frag(VertexOutput i) : COLOR {
                i.normalDir = normalize(i.normalDir);
                float3 normalDirection = i.normalDir;
                float4 _Diffuse_var = tex2D(_Diffuse,TRANSFORM_TEX(i.uv0, _Diffuse));
                clip(_Diffuse_var.a - 0.5);
                float3 lightDirection = normalize(lerp(_WorldSpaceLightPos0.xyz, _WorldSpaceLightPos0.xyz - i.posWorld.xyz,_WorldSpaceLightPos0.w));
                float3 lightColor = _LightColor0.rgb;
////// Lighting:
                float attenuation = LIGHT_ATTENUATION(i);
                float3 node_544 = (lerp( _Diffuse_var.rgb, (float3(0.6,0.6,0.6)*lerp(_Diffuse_var.rgb,dot(_Diffuse_var.rgb,float3(0.3,0.59,0.11)),1.0)), _Desaturate )*_Color.rgb); // Diffuse Color
                float node_7731 = 0.5;
                float node_5683 = ((max(0,dot(lightDirection,normalDirection))+node_7731)*node_7731);
                float3 finalColor = ((node_544*(node_5683*node_5683))*_LightColor0.rgb*attenuation);
                fixed4 finalRGBA = fixed4(finalColor * 1,0);
                UNITY_APPLY_FOG(i.fogCoord, finalRGBA);
                return finalRGBA;
            }
            ENDCG
        }
        Pass {
            Name "ShadowCaster"
            Tags {
                "LightMode"="ShadowCaster"
            }
            Offset 1, 1
            Cull Back
            
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #define UNITY_PASS_SHADOWCASTER
            #include "UnityCG.cginc"
            #include "Lighting.cginc"
            #pragma fragmentoption ARB_precision_hint_fastest
            #pragma multi_compile_shadowcaster
            #pragma multi_compile_fog
            #pragma only_renderers d3d9 d3d11 glcore gles metal 
            #pragma target 3.0
            uniform sampler2D _Diffuse; uniform float4 _Diffuse_ST;
            struct VertexInput {
                float4 vertex : POSITION;
                float2 texcoord0 : TEXCOORD0;
            };
            struct VertexOutput {
                V2F_SHADOW_CASTER;
                float2 uv0 : TEXCOORD1;
            };
            VertexOutput vert (VertexInput v) {
                VertexOutput o = (VertexOutput)0;
                o.uv0 = v.texcoord0;
                o.pos = UnityObjectToClipPos( v.vertex );
                TRANSFER_SHADOW_CASTER(o)
                return o;
            }
            float4 frag(VertexOutput i) : COLOR {
                float4 _Diffuse_var = tex2D(_Diffuse,TRANSFORM_TEX(i.uv0, _Diffuse));
                clip(_Diffuse_var.a - 0.5);
                SHADOW_CASTER_FRAGMENT(i)
            }
            ENDCG
        }
    }
    FallBack "Diffuse"
    CustomEditor "ShaderForgeMaterialInspector"
}

```