Yaminabe

public class  XXXXX : MonoBehaviour
{

     private MaterialPropertyBlock _PropertyBlock; 
     private int _ColorPropertyId ;

void Start()
{

               _PropertyBlock    = new MaterialPropertyBlock();
               _ColorPropertyId = Shader.PropertyToID("_Color");

}

void Update() 
{

               _PropertyBlock.Clear(); 
               _PropertyBlock.AddColor(_ColorPropertyId, Color.white);    
               Graphics.DrawMesh( Mesh, Position , Rotation, Material, 0, MainCamera, 0,_PropertyBlock);

  }

}

using System.Collections.Generic;
using UnityEngine;
using Assets;

public class DrawMeshManager : MonoBehaviour
{
   
    public Mesh ObjMesh;
    public Material Material1;
   
    public Camera MainCamera;
    public Transform Player;
    public float ForceDrawWithinDistance = 50.0f;
   
    public int Maxval = 100;
    public float  Scaler = 2.0f;   
   
    private List Objs = new List();
   
    private MaterialPropertyBlock _PropertyBlock;
    private int _ColorPropertyId ;
   
   
    private void Start()
    {
       
        MainCamera = Camera.main;                
        float Offset=(Maxval*Scaler/2.0f)-Maxval*Scaler;
        int ObjectType = 0;
       
        for(var x=0 ; x        {                
            ObjectType = x%2;          
            for(var y=0 ; y            {                   
                for(var z=0 ; z                {    
                                                                
                    ObjData newObj = new ObjData( ObjectType,
                                            new Vector3((float)x*Scaler+Offset,(float)y*Scaler+Offset,(float)z*Scaler+Offset),
                                            Quaternion.Euler(0, 0 ,0));

                    Objs.Add(newObj);                                       
        
                }
           }
           
        }
       
        _PropertyBlock = new MaterialPropertyBlock();
        _ColorPropertyId = Shader.PropertyToID("_Color");       
        
    }

   
    private void Update()
    {
       

        Vector3 playerPosition = Player.position;
        var FrustumPlanes = GeometryUtility.CalculateFrustumPlanes(MainCamera);

        
        float _timer = Time.timeSinceLevelLoad;               
        var ObjBounds = ObjMesh.bounds;
       
        foreach (var Obj in Objs)
        {
                        
        //    int ObjType   = Obj.ObjType; // メッシュオブジェクトを複数定義する場合に使用する
            
                ObjBounds.center = Obj.WorldPosition;

       
            float distance = Vector3.Distance(Obj.WorldPosition, playerPosition);

       
            if (distance < ForceDrawWithinDistance || GeometryUtility.TestPlanesAABB(FrustumPlanes, ObjBounds))
            {
                   
                float ofst = Mathf.Sin((Obj.WorldPosition.y + _timer)/4.0f)*1.5f;
                                
                _PropertyBlock.Clear();
                _PropertyBlock.AddColor(_ColorPropertyId, Obj.Color);   
                Graphics.DrawMesh(ObjMesh, Obj.WorldPosition + new Vector3(ofst,0,ofst) , Obj.Rotation, Material1, 0, MainCamera, 0,_PropertyBlock);
                                          
                    
            }
        }
    }
}

using System;
using UnityEngine;

namespace Assets
{
    public class ObjData
    {
        private  int _ObjType;
        private  Vector3 _WorldPosition;
        private  Quaternion _Rotation;
        private  Color _Color;
       

        public ObjData(int ObjType, Vector3 worldPosition, Quaternion rotation)
        {
            _ObjType = ObjType;
            _WorldPosition = worldPosition;
            _Rotation = rotation;
           
            if (ObjType == 0)
            {
               
                _Color = Color.white;
               
            }
            else
            {

               _Color = new Color(1.0f,0.2f,0.05f);
               
            }      
            
        }

        public Vector3 WorldPosition
        {
            get { return _WorldPosition; }
        }
        public Quaternion Rotation
        {
            get { return _Rotation; }
        }
        public int ObjType
        {
            get { return _ObjType; }
        }       
        public Color Color
        {
            get { return _Color; }
        }
       
    }
}

float3 tangent;

float3 c1 = cross(Normal, float3(0.0, 0.0, 1.0));
float3 c2 = cross(Normal, float3(0.0, 1.0, 0.0));

if (length(c1)>length(c2))
{
    tangent = c1;
}
else
{
    tangent = c2;
}

tangent = normalize(tangent);

particle[i].force.x+=random(-0.1,0.1);

particle[i].force.y+=random(-0.1,0.1);

particle[i].force.x+=perlin(particle[i].x*scale, particle[i].y*scale,1.352+time);

particle[i].force.y+=perlin(particle[i].x*scale, particle[i].y*scale,12.814+time);

using UnityEngine;
using System.Collections;

public class ParticleBufferAccess_Curl : MonoBehaviour {
       
public Vector3 Amount = new Vector3(1.0f,1.0f,1.0f);
const int bufferSize =  1000;
   
private ParticleSystem.Particle[] particles = new ParticleSystem.Particle[bufferSize];
private float[] dx =new float[bufferSize];
private float[] dy =new float[bufferSize];
private float[] dz =new float[bufferSize];
   
private Perlin noise;
   
public float  scale = 0.1f;
public float  speed = 0.05f;
      
void  Start ()
{
   
        noise = new Perlin ();
             
}    
       
void LateUpdate() {

int length = particleSystem.GetParticles(particles);
int i = 0;
       

while (i < length) {

    float  scalex = Time.time  * speed + 0.1365143f;
    float  scaley = Time.time  * speed +   1.21688f;   
    float  scalez = Time.time  * speed +    2.5564f;   
       
    dx[i] = noise.Noise(particles[i].position.x*scale, particles[i].position.y*scale, particles[i].position.z*scalex);
    dy[i] = noise.Noise(particles[i].position.x*scale, particles[i].position.y*scale, particles[i].position.z*scaley);
    dz[i] = noise.Noise(particles[i].position.x*scale, particles[i].position.y*scale, particles[i].position.z*scalez);

    particles[i].position += new Vector3(dx[i]*Amount.x, dy[i]*Amount.y, dz[i]*Amount.z) ;           
    i++;   
       
}
       
particleSystem.SetParticles(particles, length);

}       
}

    float  scalex = Time.time  * speed + 0.1365143f; 
    float  scaley = Time.time  * speed +     1.21688f;   
    float  scalez = Time.time  * speed +       2.5564f;   
       
    dx[i] = noise.Noise(particles[i].position.x*scale, particles[i].position.y*scale, particles[i].position.z*scalex);
    dy[i] = noise.Noise(particles[i].position.x*scale, particles[i].position.y*scale,particles[i].position.z* scaley); 
    dz[i] = noise.Noise(particles[i].position.x*scale, particles[i].position.y*scale, particles[i].position.z*scalez);

    particles[i].position += new Vector3(dx[i]*Amount.x, dy[i]*Amount.y, dz[i]*Amount.z) ;   

static var triggered=0;

function OnTriggerEnter  (other : Collider) {
triggered=1;
}

function OnTriggerExit (other : Collider) {
triggered=0;
}

using UnityEngine;
using System.Collections;

public class Example : MonoBehaviour {
    void ExplosionDamage(Vector3 center, float radius) {
        Collider[] hitColliders = Physics.OverlapSphere(center, radius);
        int i = 0;
        while (i < hitColliders.Length) {
            hitColliders[i].SendMessage("AddDamage");
            i++;
        }
    }
}

float3 RGBToHSL(float3 color)
{
    float3 hsl; // init to 0 to avoid warnings ? (and reverse if + remove first part)
   
    float fmin = min(min(color.r, color.g), color.b);    //Min. value of RGB
    float fmax = max(max(color.r, color.g), color.b);    //Max. value of RGB
    float delta = fmax - fmin;             //Delta RGB value

    hsl.z = (fmax + fmin) / 2.0; // Luminance

    if (delta == 0.0)        //This is a gray, no chroma...
    {
        hsl.x = 0.0;    // Hue
        hsl.y = 0.0;    // Saturation
    }
    else                                    //Chromatic data...
    {
        if (hsl.z < 0.5)
            hsl.y = delta / (fmax + fmin); // Saturation
        else
            hsl.y = delta / (2.0 - fmax - fmin); // Saturation
       
        float deltaR = (((fmax - color.r) / 6.0) + (delta / 2.0)) / delta;
        float deltaG = (((fmax - color.g) / 6.0) + (delta / 2.0)) / delta;
        float deltaB = (((fmax - color.b) / 6.0) + (delta / 2.0)) / delta;

        if (color.r == fmax )
            hsl.x = deltaB - deltaG; // Hue
        else if (color.g == fmax)
            hsl.x = (1.0 / 3.0) + deltaR - deltaB; // Hue
        else if (color.b == fmax)
            hsl.x = (2.0 / 3.0) + deltaG - deltaR; // Hue

        if (hsl.x < 0.0)
            hsl.x += 1.0; // Hue
        else if (hsl.x > 1.0)
            hsl.x -= 1.0; // Hue
    }

    return hsl;
}

float HueToRGB(float f1, float f2, float hue)
{
    if (hue < 0.0)
        hue += 1.0;
    else if (hue > 1.0)
        hue -= 1.0;
    float res;
    if ((6.0 * hue) < 1.0)
        res = f1 + (f2 - f1) * 6.0 * hue;
    else if ((2.0 * hue) < 1.0)
        res = f2;
    else if ((3.0 * hue) < 2.0)
        res = f1 + (f2 - f1) * ((2.0 / 3.0) - hue) * 6.0;
    else
        res = f1;
    return res;
}

float3 HSLToRGB(float3 hsl)
{
    float3 rgb;
   
    if (hsl.y == 0.0)
        rgb = float3(hsl.z, hsl.z, hsl.z); // Luminance
    else
    {
        float f2;
       
        if (hsl.z < 0.5)
            f2 = hsl.z * (1.0 + hsl.y);
        else
            f2 = (hsl.z + hsl.y) - (hsl.y * hsl.z);
           
        float f1 = 2.0 * hsl.z - f2;
       
        rgb.r = HueToRGB(f1, f2, hsl.x + (1.0/3.0));
        rgb.g = HueToRGB(f1, f2, hsl.x);
        rgb.b= HueToRGB(f1, f2, hsl.x - (1.0/3.0));
    }
   
    return rgb;
}

#define Blend(base, blend, funcf)         float3(funcf(base.r, blend.r), funcf(base.g, blend.g), funcf(base.b, blend.b))

#define BlendNormal(base, blend)         (base)
#define BlendLighten                BlendLightenf
#define BlendDarken                BlendDarkenf
#define BlendMultiply(base, blend)         (base * blend)
#define BlendAverage(base, blend)         ((base + blend) / 2.0)
#define BlendAdd(base, blend)         min(base + blend, float3(1.0, 1.0, 1.0))
#define BlendSubstract(base, blend)     max(base + blend - float3(1.0, 1.0, 1.0), float3(0.0, 0.0, 0.0))
#define BlendDifference(base, blend)     abs(base - blend)
#define BlendNegation(base, blend)     (float3(1.0, 1.0, 1.0) - abs(float3(1.0, 1.0, 1.0) - base - blend))
#define BlendExclusion(base, blend)     (base + blend - 2.0 * base * blend)
#define BlendScreen(base, blend)         Blend(base, blend, BlendScreenf)
#define BlendOverlay(base, blend)         Blend(base, blend, BlendOverlayf)
#define BlendSoftLight(base, blend)     Blend(base, blend, BlendSoftLightf)
#define BlendHardLight(base, blend)     BlendOverlay(blend, base)
#define BlendColorDodge(base, blend)     Blend(base, blend, BlendColorDodgef)
#define BlendColorBurn(base, blend)     Blend(base, blend, BlendColorBurnf)
#define BlendLinearDodge            BlendAdd
#define BlendLinearBurn            BlendSubstract

#define BlendLinearLight(base, blend)     Blend(base, blend, BlendLinearLightf)

#define BlendVividLight(base, blend)     Blend(base, blend, BlendVividLightf)
#define BlendPinLight(base, blend)         Blend(base, blend, BlendPinLightf)
#define BlendHardMix(base, blend)         Blend(base, blend, BlendHardMixf)
#define BlendReflect(base, blend)         Blend(base, blend, BlendReflectf)
#define BlendGlow(base, blend)         BlendReflect(blend, base)
#define BlendPhoenix(base, blend)         (min(base, blend) - max(base, blend) + float3(1.0, 1.0, 1.0))
#define BlendOpacity(base, blend, F, O)     (F(base, blend) * O + blend * (1.0 - O))