public void SetData(PosAndDir data, DepthInfo[] infos, Transform infoParent, Material mat)
{
_data = data;
_depthBuffer = infos;
_infoParent = infoParent;
this.GetComponent <Renderer>().material = mat;
ObjectInfo ye = PictureHandle.Instance.GetYearInfo(data);
_mat = mat;
_mat.SetTexture("_TexArrOne", PictureHandle.Instance.TexArr);
_mat.SetInt("_Index", _data.picIndex);
_mat.renderQueue = 3000;
Texture2D tex = null;
foreach (Texture2D texture2D in yearTexs)
{
if (texture2D.name == ye.BelongsClass)
{
tex = texture2D;
break;
}
}
_mat.SetTexture("_Year", tex);
this.transform.rotation = Quaternion.Euler(0f, 0f, 0f);
}
/// <summary>
/// 跟另个数据进行排序
/// </summary>
public bool Sort(PosAndDir otherData)
{
if (this.position.z >= otherData.position.z)
{
return(false);
}
return(true);
}
//检测点击点在哪个面片里面
void CheckClickPoint()
{
_clickPointsBuff.picIndex = -1;//重置索引
if (ClickPoint.z >= 100000)
{
return;
}
//Vector4 pos = _data.position;
Vector4 velocity = _data.velocity;
//// if(velocity.x>0)return;//值允许第一层有点击行为
float alpha = _depthBuffer[(int)velocity.x].alpha;
if (alpha < 1)
{
return; // 在第一排的深度才可以点击，用透明度判断是否在第一排
}
////float2 leftDownP2, float2 leftUpP1, float2 rightDownP3, float2 rightUpP4, float2 p
////默认图片大小为长宽为1，一半就是0.5
//Vector2 leftDown = new Vector2(pos.x - 0.5f, pos.y - 0.5f);//+ float2(-0.5, -0.5));
//Vector2 leftUp = new Vector2(pos.x - 0.5f, pos.y + 0.5f);
//Vector2 rightDown = new Vector2(pos.x + 0.5f, pos.y - 0.5f);
//Vector2 rightUp = new Vector2(pos.x + 0.5f, pos.y + 0.5f);
//bool isContains = Common.ContainsQuadrangle(leftDown, leftUp, rightDown, rightUp, clickPoint);
//if (isContains)
//{
// // positionBuffer[id.x].position.w=2;
// _clickPointsBuff = _data;
// PictureHandle.Instance.GetYearInfo(_data, _infoParent);
// Debug.Log("Click index is " + _data.picIndex);
//}
if (Vector3.Distance(_cacheTransform.position, ClickPoint) <= 0.01f)
{
// positionBuffer[id.x].position.w=2;
_clickPointsBuff = _data;
PictureHandle.Instance.GetYearInfo(_data, _infoParent);
// Debug.Log("Click index is " + _data.picIndex);
}
ClickPoint = Vector3.one * 100000;
}
protected override void Dispatch(ComputeBuffer system)
{
MouseButtonDownAction();
base.Dispatch(system);
if (_clickPoint.z < 1000000)//相当于有点击事件才触发
{
PosAndDir[] datas = new PosAndDir[1];
_clickPointBuff.GetData(datas);
Debug.Log(datas[0].picIndex);
}
}
private void Sort(PosAndDir[] data)
{
for (int i = 0; i < data.Length - 1; i++)
{
for (int j = 0; j < data.Length - 1 - i; j++)
{
if (!data[j].Sort(data[j + 1]))
{
PosAndDir temp = data[j];
data[j] = data[j + 1];
data[j + 1] = temp;
}
}
}
}
public ObjectInfo GetYearInfo(PosAndDir pad)
{
if (pad.picIndex < 0)
{
return(null);
}
ObjectInfo ye = null;
foreach (ClassInfo yearsInfo in _classInfos)
{
foreach (var yearsEvent in yearsInfo.ObjectInfos)
{
foreach (int inde in yearsEvent.PictureIndes)
{
if (pad.picIndex == inde)
{
ye = yearsEvent;
break;
}
}
}
}
if (ye == null)
{
throw new UnityException("没有找到相应的年代事件");
}
return(ye);
//Debug.Log(ye.ToString());
}
protected override void Init()
{
base.Init();
MotionType = MotionType.Loop;
_screenPosLeftDown = Camera.main.ScreenToWorldPoint(new Vector3(0, 0, Z - Camera.main.transform.position.z));
_screenPosLeftUp = Camera.main.ScreenToWorldPoint(new Vector3(0, Height, Z - Camera.main.transform.position.z));
_screenPosRightDown = Camera.main.ScreenToWorldPoint(new Vector3(Width, 0, Z - Camera.main.transform.position.z));
_screenPosRightUp = Camera.main.ScreenToWorldPoint(new Vector3(Width, Height, Z - Camera.main.transform.position.z));
int HorizontalColumn = TextureInstanced.Instance.HorizontalColumn;
int InstanceCount = TextureInstanced.Instance.InstanceCount;
float SizeWidth = TextureInstanced.Instance.SizeWidth;
float SizeHeight = TextureInstanced.Instance.SizeHeight;
//拿到实际上得到的最大横数，因为 Mathf.ClosestPowerOfTwo(InstanceCount);已经约束为2的N次方
int maxRow = InstanceCount / HorizontalColumn;
float rectangleWidth = (HorizontalColumn) * 0.1f + (HorizontalColumn) * SizeWidth;
float rectangleHeight = maxRow * 0.1f + maxRow * SizeHeight;
PosAndDir[] datas = new PosAndDir[ComputeBuffer.count];
ComputeBuffer.GetData(datas);
int rows = 0;//横列个数 y轴改变
//使面片排列成阵列
for (int i = 0; i < InstanceCount; i++)
{
if (i != 0 && i % HorizontalColumn == 0)
{
rows++;
}
int column = i - rows * HorizontalColumn;//竖列个数 x轴概念
//0.1f，为两面片间的间隙参数
Vector3 pos = new Vector3(0.1f * column, 0.1f * rows) + new Vector3(SizeWidth * column + SizeWidth / 2, SizeHeight * rows + SizeHeight / 2f);
//+左下角基准点
Vector4 temp = new Vector4(pos.x, pos.y, pos.z, 1f) + new Vector4(_screenPosLeftDown.x, _screenPosLeftDown.y, _screenPosLeftDown.z, 0);
// datas[i].position = temp;
datas[i].originalPos = datas[i].position;//存储变换前的位置
datas[i].moveTarget = temp;
datas[i].moveDir = Vector3.zero;
// if (i == 0) colors[i] = Color.white;//Color.red;
//else colors[i] = Random.ColorHSV();
datas[i].indexRC = new Vector2(rows, column);
datas[i].uvOffset = new Vector4(1f, 1f, 0f, 0f);
datas[i].uv2Offset = new Vector4(1f, 1f, 0f, 0f);
datas[i].picIndex = i % TextureInstanced.Instance.TexArr.depth;
datas[i].bigIndex = i % TextureInstanced.Instance.TexArr.depth;
Vector4 posTemp = datas[i].position;
datas[i].position = new Vector4(posTemp.x, posTemp.y, posTemp.z, 1f);
if (i == 0)
{
_originalPosLeftDown = temp; //保存面片坐标点原点位置
}
if (i == HorizontalColumn - 1) //右下角的索引
{
//colors[i] = Color.white;//颜色标记
_originalPosRightDown = temp;
}
if (rows + 1 == maxRow && i % HorizontalColumn == 0)//左上角倒数第二排第一个索引
{
//colors[i] = Color.white;//颜色标记
_originalPosLeftUp = temp;
}
if (rows + 1 == maxRow && i % HorizontalColumn == HorizontalColumn - 1)//右上角倒数第二排最后一个索引
{
// colors[i] = Color.white;//颜色标记
_originalPosRightUp = temp;
}
}
ComputeBuffer.SetData(datas);
int stride = Marshal.SizeOf(typeof(PosAndDir));
//点击缓存
_clickPointBuff = new ComputeBuffer(1, stride);
PosAndDir[] clickPoint = { new PosAndDir(-1) };
_clickPointBuff.SetData(clickPoint);
ComputeShader.SetBuffer(dispatchID, "positionBuffer", ComputeBuffer);
ComputeShader.SetBuffer(dispatchID, "clickPointsBuff", _clickPointBuff);
ComputeShader.SetBuffer(InitID, "positionBuffer", ComputeBuffer);
ComputeShader.SetFloat("rectangleWidth", rectangleWidth);
ComputeShader.SetFloat("rectangleHeight", rectangleHeight);
ComputeShader.SetFloat("MoveSpeed", MoveSpeed);
TextureInstanced.Instance.ChangeInstanceMat(null);
TextureInstanced.Instance.CurMaterial.SetVector("_WHScale", new Vector4(1, 1, 1, 1));
}
/// <summary>
/// 根据图片索引拿到年代事件信息
/// </summary>
public void GetYearInfo(PosAndDir pad, Transform canvas)
{
if (pad.picIndex < 0)
{
return;
}
ObjectInfo ye = null;
foreach (ClassInfo yearsInfo in _classInfos)
{
foreach (var yearsEvent in yearsInfo.ObjectInfos)
{
foreach (int inde in yearsEvent.PictureIndes)
{
if (pad.picIndex == inde)
{
ye = yearsEvent;
break;
}
}
}
}
if (ye == null)
{
throw new UnityException("没有找到相应的年代事件");
}
GameObject temp = Instantiate(_info, canvas.transform);
Item item = temp.GetComponent <Item>();
item.LoadData(ye, TexArr);
Vector3 screenPos = Camera.main.WorldToScreenPoint(pad.position);
RectTransform rectTransform = item.GetComponent <RectTransform>();
// rectTransform.SetSiblingIndex(2);
rectTransform.DOScale(0.35f, 0.75f);
//rectTransform.DOLocalRotate(new Vector3(0f, 360, 0f), 1f, RotateMode.LocalAxisAdd).OnComplete((() =>
//{
// item.RotEnd();
//}));
rectTransform.anchoredPosition = screenPos;
if (screenPos.y >= 800)
{
screenPos.y = 800;
}
if (screenPos.y <= 250)
{
screenPos.y = 250;
}
if (screenPos.x >= 1700f)
{
screenPos.x = 1700f;
}
if (screenPos.x <= 200f)
{
screenPos.x = 200f;
}
rectTransform.DOAnchorPos(screenPos, 0.35f);
//Debug.Log(ye.ToString());
}
protected override void Dispatch(ComputeBuffer system)
{
// MouseButtonDownAction();
Vector3[] temp = new Vector3[_clickBuff.count];
//_clickBuff.GetData(temp);
//传输过去前，先重置数据
//
for (int i = 0; i < temp.Length; i++)
{
temp[i] = Vector3.one * 1000000;
}
int n = 0;
foreach (KeyValuePair <int, ClickData> keyValuePair in _touchIds)
{
Vector3 pos = keyValuePair.Value.Position;
//Debug.Log(pos);
// pos = Camera.main.ScreenToWorldPoint(new Vector3(pos.x, pos.y, 6));//6 深度是相机到物体的深度 是第一排物体的离相机的距离
temp[n] = pos;
n++;
}
LeftDownTip.position = temp[0];
_clickBuff.SetData(temp);
ComputeShader.SetBuffer(dispatchID, "clicks", _clickBuff);
//if (Input.GetMouseButtonDown(1))
//{
// ComputeShader.SetVector("rangeRot", new Vector4(_zeroIndexCount + 115, _zeroIndexCount + 130, _zeroIndexCount + 50, _zeroIndexCount + 157));
//}
//if (Input.GetMouseButtonUp(1))
//{
// ComputeShader.SetVector("rangeRot", new Vector4(-1, -1, -1, -1));
//}
Ray ray;
// Debug.Log(_clickPoint + " " + Input.mousePosition);
ray = Camera.main.ScreenPointToRay(_clickPoint);
Vector3 clickPos = Vector3.one * 100000;
RaycastHit hitInfo;
if (Physics.Raycast(ray, out hitInfo))
{
clickPos = hitInfo.transform.position;
}
if (_clickPoint.z < 0)
{
_clickPoint = Camera.main.ScreenToWorldPoint(new Vector3(_clickPoint.x, _clickPoint.y, 6));
}
else
{
_clickPoint = Vector3.one * 1000000;
}
//_depthPictureMove.Excute(temp);
ComputeShader.SetVector("clickPoint", _clickPoint);
ComputeShader.SetFloat("deltaTime", Time.deltaTime);
Matrix4x4 v = Camera.main.worldToCameraMatrix;
Matrix4x4 p = Camera.main.projectionMatrix;
ComputeShader.SetMatrix("v", v);
ComputeShader.SetMatrix("p", p);
ComputeShader.SetMatrix("ip", p.inverse);
ComputeShader.SetMatrix("iv", v.inverse);
//Camera.main.ResetTransparencySortSettings();
//Camera.main.transparencySortAxis = Vector3.right;
//Camera.main.transparencySortMode = TransparencySortMode.CustomAxis;
Dispatch(dispatchID, system);
if (_clickPoint.z < 1000000)//相当于有点击事件才触发
{
var countBuffer = new ComputeBuffer(1, sizeof(int), ComputeBufferType.IndirectArguments);
ComputeBuffer.CopyCount(_appendBuffer, countBuffer, 0);
//通过这个方法拿到第一个数据。
int [] counter = { 0 };
countBuffer.GetData(counter);
int count = counter[0];
Debug.Log("count: " + count);
var data = new PosAndDir[count];
_appendBuffer.GetData(data);
if (data.Length > 0)
{
Debug.Log("data length: " + data.Length + " 得到的图片index is" + data[0].bigIndex);
}
else
{
Debug.Log("data length: " + 0);
}
PosAndDir[] datas = new PosAndDir[1];
_clickPointBuff.GetData(datas);
int index = datas[0].bigIndex;
Debug.Log("得到的图片index is " + index);
PictureHandle.Instance.GetYearInfo(datas[0], Canvas.transform);
_clickPoint = Vector3.one * 1000000; //重置数据
_appendBuffer.SetCounterValue(0); //重置数据
}
}
protected override void Init()
{
base.Init();
_screenPosLeftDown = Camera.main.ScreenToWorldPoint(new Vector3(0, 0, Z - Camera.main.transform.position.z));
_screenPosLeftUp = Camera.main.ScreenToWorldPoint(new Vector3(0, Height, Z - Camera.main.transform.position.z));
_screenPosRightDown = Camera.main.ScreenToWorldPoint(new Vector3(Width, 0, Z - Camera.main.transform.position.z));
_screenPosRightUp = Camera.main.ScreenToWorldPoint(new Vector3(Width, Height, Z - Camera.main.transform.position.z));
int instanceCount = TextureInstanced.Instance.InstanceCount;
PosAndDir[] datas = new PosAndDir[ComputeBuffer.count];
ComputeBuffer.GetData(datas);
//根据种类个数生成盒子，先手动完成，盒子分配，有时间在完善=>开发出自动分配均匀大小的盒子填满窗口
//这里以生成8个盒子还展开
List <Rect> rects = new List <Rect>();
if (CategoryCount == 8)
{
//生成八个盒子，横列4个，竖列2个
float width = Width / 4f; //480
float height = Height / 2f; //540
//x,y 为倍数
Rect rect0 = new Rect(0f, 0f, width, height);
Rect rect1 = new Rect(1f, 0f, width, height);
Rect rect2 = new Rect(2f, 0f, width, height);
Rect rect3 = new Rect(3f, 0f, width, height);
Rect rect4 = new Rect(0f, 1f, width, height);
Rect rect5 = new Rect(1f, 1f, width, height);
Rect rect6 = new Rect(2f, 1f, width, height);
Rect rect7 = new Rect(3f, 1f, width, height);
rects.Add(rect0);
rects.Add(rect1);
rects.Add(rect2);
rects.Add(rect3);
rects.Add(rect4);
rects.Add(rect5);
rects.Add(rect6);
rects.Add(rect7);
}
//每个盒子分配得到的面片个数
int count = instanceCount / (int)CategoryCount;//8192
Vector2 scale = Vector2.zero;
for (int i = 0; i < rects.Count; i++)
{
Rect rect = rects[i];
float width = rect.width;
float height = rect.height;
float fitedge = (Mathf.Sqrt((width * height * 1f) / count)); //适合的边长，
int row = (int)(width / fitedge); //求得大概行横列的个数，即一横有多少个
int column = (int)(height / fitedge); //求得竖列大概的个数，即一竖有多少个
float smallWidth = width * 1f / row; //求得小矩形屏幕分辨率的宽
float smallHeight = height * 1f / column; //求得小矩形屏幕分辨率的高，
//求得小矩形的宽和高后，填满大矩形的个数跟每个盒子分配的面片个数不一致，
//我们以求得的宽高后的盒子为准，多余的面片我们舍去
//row*column 为实际上用到的quad个数
//小矩形的宽高转化为世界宽度和高度，注意Z轴
Vector3 origin = Camera.main.ScreenToWorldPoint(new Vector3(0f, 0f, Z - Camera.main.transform.position.z));
//世界位置小矩形的宽
Vector3 wpos = Camera.main.ScreenToWorldPoint(new Vector3(smallWidth, 0f, Z - Camera.main.transform.position.z));
//世界位置小矩形的高
Vector3 hpos = Camera.main.ScreenToWorldPoint(new Vector3(0f, smallHeight, Z - Camera.main.transform.position.z));
//得到小矩形在世界坐标中应得到的宽度
float wwidth = wpos.x - origin.x;
//得到小矩形哎世界坐标中得到的高度
float wheight = hpos.y - origin.y;
//世界位置大矩形的宽的位置
Vector3 widthBigpos = Camera.main.ScreenToWorldPoint(new Vector3(rect.width, 0f, Z - Camera.main.transform.position.z));
//世界位置大矩形的高的位置
Vector3 heightBigpos = Camera.main.ScreenToWorldPoint(new Vector3(0f, rect.height, Z - Camera.main.transform.position.z));
//得到大矩形在世界坐标中应得到的宽度
float wwidthBig = widthBigpos.x - origin.x;
//得到大矩形哎世界坐标中得到的高度
float wheightBig = heightBigpos.y - origin.y;
//因为quad边长为1，对quab进行缩放加工，quad的位置的Z轴位置一定要正确
// Quab.transform.localScale = new Vector3(wwidth, wheight, 1f);
scale = new Vector2(wwidth, wheight);//把面片缩放倍数弹出去
int actual = row * column;//实际有作用的粒子个数
//进一步加工uv y=>rows x=>horizontalColumn
//得到一个新的uvwz,
float u = 1f / row;
float v = 1f / column;
float delay = Random.Range(3, 8);
//把小矩形填充整个大矩形
int columnTempCount = 0;//横列个数 y轴概念
for (int j = 0; j < actual; j++)
{
int index = i * count + j;//buff数组中的索引位置
// Vector3 pos = Vector3.zero;
if (j != 0 && j % row == 0)
{
columnTempCount++;
}
int rowTempCount = j - columnTempCount * row;//竖列个数 x轴概念
Vector3 pos = new Vector3(origin.x, origin.y, 0) +
//这里的xy,存放的是倍数
new Vector3(wwidthBig * rect.position.x, wheightBig * rect.position.y, 0) +
new Vector3(wwidth * rowTempCount + wwidth / 2, wheight * columnTempCount + wheight / 2f, Z);
datas[index].moveTarget = pos;
datas[index].originalPos = Vector4.one;
// datas[index].position = Vector4.one;
datas[index].indexRC = new Vector2(rowTempCount, columnTempCount);
datas[index].picIndex = i;
datas[index].bigIndex = i; //分类编号
Vector4 otherData = new Vector4(); //切换图片索要缓存的数据
otherData.x = delay; //延迟播放的时间
otherData.y = 1f; //Random.Range(0.1f,1f);//切换图片的时间
otherData.z = 0f; //时间缓存
otherData.w = 0f; //插值值
datas[index].velocity = otherData;
datas[index].initialVelocity = Vector3.zero; //缓存器
float w = u * rowTempCount; //rowsCount
float z = v * columnTempCount; //columnCount
datas[index].uvOffset = new Vector4(u, v, w, z);
#region 设置第二套UV，写死规定每个小矩形在切分成九个小矩形，这里只设置UV切分
float row2 = row / 3f; //小小矩形的横轴个数
float column2 = column / 3f; //小小矩形竖轴个数
float u2 = 1f / row2;
float v2 = 1f / column2;
int indexrow = (int)(rowTempCount * 1f / row2) + 1; //小矩形里小小矩形的x轴个数
int indexColumn = (int)(columnTempCount * 1f / column2) + 1; //小矩形里小小矩形的y轴的个数
float w2 = ((rowTempCount % row2) * 1f / row2);
float z2 = ((columnTempCount % column2) * 1f / column2);
datas[index].uv2Offset = new Vector4(u2, v2, w2, z2);
datas[index].bigIndex = i + (indexColumn - 1) * 3 + indexrow;//分类编号*3是因为一横有三个
#endregion
}
int useless = count - actual;//剩下的没有用到的面片，
//全部缩小至0，位置也归零
for (int j = 0; j < useless; j++)
{
int index = actual + j;
datas[index].position = Vector4.zero;
//datas[index].moveTarget = Vector3.zero;
//datas[index].originalPos = Vector4.zero;
}
}
TextureInstanced.Instance.ChangeInstanceMat(null);
TextureInstanced.Instance.CurMaterial.SetVector("_WHScale", new Vector4(scale.x, scale.y, 1, 1));
ComputeBuffer.SetData(datas);
ComputeShader.SetBuffer(dispatchID, "positionBuffer", ComputeBuffer);
ComputeShader.SetBuffer(InitID, "positionBuffer", ComputeBuffer);
MoveSpeed = 50f;//更改更快的插值速度
ComputeShader.SetFloat("MoveSpeed", MoveSpeed);
}
protected override void Init()
{
base.Init();
MotionType = MotionType.MultiDepth;
// Camera.main.fieldOfView = 30f;
_touchIds = new Dictionary <int, ClickData>();
PosAndDir[] datas = new PosAndDir[ComputeBuffer.count];
ComputeBuffer.GetData(datas);
List <PosAndDir> temp = new List <PosAndDir>();
List <PosAndDir> allDataList = new List <PosAndDir>();
//这里注意，posAndDir属于结构体，值拷贝
for (int i = 0; i < datas.Length; i++)
{
PosAndDir data = datas[i];
if (i < Common.PictureCount * 3)
{
temp.Add(data);//编号一样的单独拿出来
}
else
{
data.position = Vector4.zero;//其他编号都隐藏
data.originalPos = Vector4.one;
allDataList.Add(data);
}
}
_zeroIndexCount = allDataList.Count;
PosAndDir[] newData = temp.ToArray();
int stride = Marshal.SizeOf(typeof(DepthInfo));
_depthBuffer = new ComputeBuffer(3, stride);
_depths = new DepthInfo[3];
//点击缓存
_clickPointBuff = new ComputeBuffer(1, Marshal.SizeOf(typeof(PosAndDir)));
PosAndDir[] clickPoint = { new PosAndDir(-1) };
_clickPointBuff.SetData(clickPoint);
int k = 0;
float z = 6;
float scaleY = 1;//y轴位置屏幕有内容的比率
//得到随机点的个数，第一层的随机点个数不允许低于40
//这个参数存在的意义是Common.Sample2D方法采样的时候会得不到正确的个数，有时候明显偏低，这个参数就是为了修正这个数据
//这个数据如果scaleY s 两个参数有变化，应该考虑第一层随机点个数的变化
int count = 40;
List <Vector2> randomPos = new List <Vector2>();
for (int j = 0; j < newData.Length; j++)
{
if (j % Common.PictureCount == 0)
{
//距离相机的深度值
float tempZ = k * z - 4;
k++;
_screenPosLeftDown = Camera.main.ScreenToWorldPoint(new Vector3(0, 0, tempZ - Camera.main.transform.position.z));
_screenPosLeftUp = Camera.main.ScreenToWorldPoint(new Vector3(0, Height, tempZ - Camera.main.transform.position.z));
_screenPosRightDown = Camera.main.ScreenToWorldPoint(new Vector3(Width, 0, tempZ - Camera.main.transform.position.z));
_screenPosRightUp = Camera.main.ScreenToWorldPoint(new Vector3(Width, Height, tempZ - Camera.main.transform.position.z));
float s = 1f; //不同层次的给定不同的缩放
float a = 1f; //不同层次的给定不同的透明度
if (k == 1)
{
s = 1f;
a = 1f;
scaleY = 0.55f;
}
else if (k == 2)
{
s = 1.2f;
a = 0.45f;
scaleY = 0.25f;
}
else if (k == 3)
{
s = 1.4f;
a = 0.25f;
scaleY = 0.18f;
}
else if (k == 4)
{
s = 1.6f;
a = 0.45f;
scaleY = 0.7f;
}
else if (k == 5)
{
s = 1.8f;
a = 0.25f;
scaleY = 0.6f;
}
while (true)
{
if (count >= randomPos.Count)//如果得到的个数比上一个还小，那是不正确的采样，必须重新采样
{
// Debug.Log("x:" + _screenPosRightDown.x + " \r\n x1:" + _screenPosLeftDown.x + " \r\n y:" + _screenPosLeftUp.y + "\r\n y1:" + _screenPosLeftDown.y + " \r\n scaleY:" + scaleY + " \r\n s:" + s);
randomPos = Common.Sample2D((_screenPosRightDown.x - _screenPosLeftDown.x) * 4, (_screenPosLeftUp.y - _screenPosLeftDown.y) * scaleY, s + 0.75f, 25);
}
else
{
count = randomPos.Count;
break;
}
}
Debug.Log("randomPos count is " + randomPos.Count + " 层级为=> " + (k - 1) + " tempZ is=>" + tempZ);
_depths[k - 1] = new DepthInfo(k - 1, tempZ, s, a);
}
float rangeZ = Random.Range(-0.5f, 0.5f);//在同一层次，再随机不同的深度位置，不至于重叠一起，显得错落有致
Vector4 posTemp = newData[j].position;
newData[j].position = new Vector4(posTemp.x, posTemp.y, posTemp.z, 1);
Vector2 randomPoint;
if (randomPos.Count > 0)
{
// Random.InitState(Random.Range(0, randomPos.Count));
int rangIndex = Random.Range(0, randomPos.Count);
randomPoint = randomPos[rangIndex];
randomPos.RemoveAt(rangIndex);
}
else//如果多出来，则放到看不到的地方
{
randomPoint = new Vector2(_screenPosLeftDown.x, Random.Range(1000f, 2000f));
}
// Vector2 randomPoint = randomPos[j % randomPos.Count];
//计算Y轴的位置(1 - scaleY)为空余的位置(1 - scaleY)/2f上下空余的位置，(1 - scaleY)/2f*(_screenPosLeftUp.y - _screenPosLeftDown.y)空余位置的距离
float heightTmep = (1 - scaleY) / 2f * (_screenPosLeftUp.y - _screenPosLeftDown.y);
randomPoint = new Vector2(randomPoint.x + _screenPosLeftDown.x, randomPoint.y + _screenPosLeftDown.y + heightTmep);
newData[j].moveTarget = new Vector3(randomPoint.x, randomPoint.y + Common.HeightTemp, rangeZ);
newData[j].uvOffset = new Vector4(1f, 1f, 0f, 0f);
newData[j].uv2Offset = new Vector4(1f, 1f, 0f, 0f);
int picIndex = 0;
Vector2 size = PictureHandle.Instance.GetLevelIndexSize(j, k - 1, out picIndex);//得到缩放尺寸
float xScale = size.x / 512f;
float yScale = size.y / 512f;
float proportion = size.x / size.y;
if (xScale >= 2 || yScale >= 2)
{
//如果超过2倍大小，则强制缩放到一倍大小以内，并以宽度为准，等比例减少
int a = (int)xScale;
xScale = xScale - (a) + 2f;
yScale = xScale / proportion;
}
newData[j].initialVelocity = new Vector3(xScale, yScale, 0f);//填充真实宽高
newData[j].picIndex = picIndex;
newData[j].bigIndex = picIndex;
//x存储层次的索引,y存储透明度, z存储，x轴右边的边界值，为正数 ,最后一个为随机深度
newData[j].velocity = new Vector4(k - 1, 1f, _screenPosRightDown.x * 4f, 0);
Vector4 otherData = new Vector4();
newData[j].originalPos = otherData;
}
TextureInstanced.Instance.ChangeInstanceMat(CurMaterial);
CurMaterial.enableInstancing = true;
TextureInstanced.Instance.CurMaterial.SetVector("_WHScale", new Vector4(1f, 1f, 1f, 1f));
allDataList.AddRange(newData);
ComputeBuffer.SetData(allDataList.ToArray());
_depthBuffer.SetData(_depths);
ComputeShader.SetBuffer(dispatchID, "depthBuffer", _depthBuffer);
ComputeShader.SetBuffer(dispatchID, "positionBuffer", ComputeBuffer);
ComputeShader.SetFloat("Width", Screen.width);
ComputeShader.SetFloat("Height", Screen.height);
Matrix4x4 camMatri = Camera.main.projectionMatrix;
ComputeShader.SetFloat("m32", camMatri.m32);
ComputeShader.SetFloat("m00", camMatri.m00);
ComputeShader.SetFloat("m11", camMatri.m11);
ComputeShader.SetVector("camPos", Camera.main.transform.position);
// ComputeShader.SetFloats(dispatchID, "positionBuffer", ComputeBuffer);
// _depthPictureMove = new MultiDepthPictureMove(newData,_depths,Canvas);
//ComputeShader.SetBuffer(InitID, "positionBuffer", ComputeBuffer);
//ComputeShader.SetBuffer(InitID, "depthBuffer", _depthBuffer);
TextureInstanced.Instance.CurMaterial.SetBuffer("positionBuffer", ComputeBuffer);
TextureInstanced.Instance.CurMaterial.SetTexture("_TexArr", TextureInstanced.Instance.TexArr);
MoveSpeed = 50f;//更改更快的插值速度
ComputeShader.SetFloat("MoveSpeed", MoveSpeed);
ComputeShader.SetFloat("dis", 800);
ComputeShader.SetBuffer(dispatchID, "clickPointsBuff", _clickPointBuff);
//触摸点最大为十个
List <Vector3> clicks = new List <Vector3>();
for (int i = 0; i < 10; i++)
{
clicks.Add(Vector3.one * 100000);
}
_clickBuff = new ComputeBuffer(10, 12);
_clickBuff.SetData(clicks.ToArray());
ComputeShader.SetBuffer(dispatchID, "clicks", _clickBuff);
InitDisPatch(InitID);
}
protected override void Dispatch(ComputeBuffer system)
{
// MouseButtonDownAction();
Vector3[] temp = new Vector3[_clickBuff.count];
//_clickBuff.GetData(temp);
//传输过去前，先重置数据
//
for (int i = 0; i < temp.Length; i++)
{
temp[i] = Vector3.one * 1000000;
}
int n = 0;
foreach (KeyValuePair <int, ClickData> keyValuePair in _touchIds)
{
Vector3 pos = keyValuePair.Value.Position;
//Debug.Log(pos);
// pos = Camera.main.ScreenToWorldPoint(new Vector3(pos.x, pos.y, 6));//6 深度是相机到物体的深度 是第一排物体的离相机的距离
temp[n] = pos;
n++;
}
LeftDownTip.position = temp[0];
_clickBuff.SetData(temp);
ComputeShader.SetBuffer(dispatchID, "clicks", _clickBuff);
//if (Input.GetMouseButtonDown(1))
//{
// ComputeShader.SetVector("rangeRot", new Vector4(_zeroIndexCount + 115, _zeroIndexCount + 130, _zeroIndexCount + 50, _zeroIndexCount + 157));
//}
//if (Input.GetMouseButtonUp(1))
//{
// ComputeShader.SetVector("rangeRot", new Vector4(-1, -1, -1, -1));
//}
Ray ray;
// Debug.Log(_clickPoint + " " + Input.mousePosition);
ray = Camera.main.ScreenPointToRay(_clickPoint);
Vector3 clickPos = Vector3.one * 100000;
RaycastHit hitInfo;
if (Physics.Raycast(ray, out hitInfo))
{
clickPos = hitInfo.transform.position;
}
if (_clickPoint.z < 0)
{
_clickPoint = Camera.main.ScreenToWorldPoint(new Vector3(_clickPoint.x, _clickPoint.y, 6));
}
else
{
_clickPoint = Vector3.one * 1000000;
}
//_depthPictureMove.Excute(temp);
ComputeShader.SetVector("clickPoint", _clickPoint);
ComputeShader.SetFloat("deltaTime", Time.deltaTime);
//Camera.main.ResetTransparencySortSettings();
//Camera.main.transparencySortAxis = Vector3.right;
//Camera.main.transparencySortMode = TransparencySortMode.CustomAxis;
Dispatch(dispatchID, system);
if (_clickPoint.z < 1000000)//相当于有点击事件才触发
{
PosAndDir[] datas = new PosAndDir[1];
_clickPointBuff.GetData(datas);
int index = datas[0].picIndex;
Vector3 temp1 = Camera.main.ScreenToWorldPoint(new Vector3(400, 500, 10));
// Debug.Log("click WorldToScreenPos is " + datas[0].moveDir + " aip实现是 " + temp1);
PictureHandle.Instance.GetYearInfo(datas[0], Canvas.transform);
_clickPoint = Vector3.one * 1000000;//重置数据
}
}
protected override void Init()
{
base.Init();
_clickPoint = Vector3.one * 1000000;//重置数据
// Camera.main.fieldOfView = 30f;
_touchIds = new Dictionary <int, ClickData>();
PosAndDir[] datas = new PosAndDir[ComputeBuffer.count];
ComputeBuffer.GetData(datas);
//点击缓存
_clickPointBuff = new ComputeBuffer(1, Marshal.SizeOf(typeof(PosAndDir)));
PosAndDir[] clickPoint = { new PosAndDir(-1) };
_clickPointBuff.SetData(clickPoint);
int stride = Marshal.SizeOf(typeof(PosAndDir));
Debug.Log("占位宽是 " + stride);
_appendBuffer = new ComputeBuffer(ComputeBuffer.count, stride, ComputeBufferType.Append);//定好这个容器的容量，大小为ComputeBuffer.count
_appendBuffer.SetCounterValue(0);
for (int i = 0; i < datas.Length; i++)
{
float r = Random.Range(25f, 100f);
if (r <= 60f)
{
r = Random.Range(35f, 100f); //让半径长度偏向球体外侧
}
Vector3 dir = Random.onUnitSphere * r;
Vector3 dis = SrcPos + dir;
datas[i].position = new Vector4(dis.x, dis.y, dis.z, 1);
datas[i].moveTarget = dis;
datas[i].moveDir = dir; //存储方向
Vector4 otherData = new Vector4();
otherData.w = r; //存储半径
int randomxyz = Random.Range(1, 8);
float speed = Random.Range(0.0005f, 0.001f);
//speed = 0.05f;
randomxyz = 5;
switch (randomxyz)
{
case 1:
otherData = new Vector4(1, 0, 0, speed);
break;
case 2:
otherData = new Vector4(1, 1, 0, speed);
break;
case 3:
otherData = new Vector4(1, 1, 1, speed);
break;
case 4:
otherData = new Vector4(0, 1, 1, speed);
break;
case 5:
otherData = new Vector4(0, 1, 0, speed);
break;
case 6:
otherData = new Vector4(0, 0, 1, speed);
break;
case 7:
otherData = new Vector4(1, 0, 1, speed);
break;
case 8:
otherData = new Vector4(1, 0, 0, speed);
break;
default:
break;
}
datas[i].originalPos = otherData;
Vector2 galaxy = TextureInstanced.Instance.GalaxyPosList[i];
float galaxyY = Random.Range(-10f, 10f);
Vector3 galaxyVector3 = new Vector3(galaxy.x, galaxyY, galaxy.y) * 10f;
//存储银河信息恒星的大概位置信息
datas[i].uvOffset = new Vector4(galaxyVector3.x, galaxyVector3.y, galaxyVector3.z, 0.1f);
datas[i].uv2Offset = new Vector4(0f, 0f, 0f, 0f);
int picIndex = 0;
int isRest = 0;
int level = -1;
Vector2 size = PictureHandle.Instance.GetIndexSizeOfNumber(i, out level, out isRest, out picIndex);//得到缩放尺寸
float xScale = size.x / 512f;
float yScale = size.y / 512f;
float proportion = size.x / size.y;
if (xScale >= 2 || yScale >= 2)
{
//如果超过2倍大小，则强制缩放到一倍大小以内，并以宽度为准，等比例减少
int a = (int)xScale;
xScale = xScale - (a) + 2f;
yScale = xScale / proportion;
}
datas[i].initialVelocity = new Vector3(xScale, yScale, 0f);//填充真实宽高
datas[i].picIndex = picIndex;
datas[i].bigIndex = picIndex;
//x存储的是类别的索引,y存储透明度, z存储，x轴右边的边界值，为正数 ,最后一个为是否是重复的index，表示的是数据里已经有图片index跟他是一样的了
int tempVal = level;
datas[i].velocity = new Vector4(tempVal, 1f, _screenPosRightDown.x, isRest);
datas[i].stateCode = -1;
}
TextureInstanced.Instance.ChangeInstanceMat(CurMaterial);
CurMaterial.enableInstancing = true;
TextureInstanced.Instance.CurMaterial.SetVector("_WHScale", new Vector4(1f, 1f, 1f, 1f));
ComputeBuffer.SetData(datas);
ComputeShader.SetBuffer(dispatchID, "positionBuffer", ComputeBuffer);
ComputeShader.SetBuffer(dispatchID, "clickPointsBuff", _clickPointBuff);
ComputeShader.SetBuffer(dispatchID, "AppendBuff", _appendBuffer);
ComputeShader.SetFloat("Width", Screen.width);
ComputeShader.SetFloat("Height", Screen.height);
Matrix4x4 camMatri = Camera.main.projectionMatrix;
ComputeShader.SetFloat("m32", camMatri.m32);
ComputeShader.SetFloat("m00", camMatri.m00);
ComputeShader.SetFloat("m11", camMatri.m11);
ComputeShader.SetVector("camPos", Camera.main.transform.position);
TextureInstanced.Instance.CurMaterial.SetBuffer("positionBuffer", ComputeBuffer);
TextureInstanced.Instance.CurMaterial.SetTexture("_TexArr", TextureInstanced.Instance.TexArr);
MoveSpeed = 50f;//更改更快的插值速度
ComputeShader.SetFloat("MoveSpeed", MoveSpeed);
ComputeShader.SetFloat("dis", 800);
ComputeShader.SetVector("srcPos", SrcPos);
ComputeShader.SetInt("selectClass", _selectClass);
ComputeShader.SetInt("hideClass", _hideClass);
if (_selectClassBuffer != null)
{
_selectClassBuffer.Release();
}
temps.Add(Vector4.one);
_selectClassBuffer = new ComputeBuffer(temps.Count, 16);
_selectClassBuffer.SetData(temps.ToArray());
ComputeShader.SetBuffer(dispatchID, "randomPosData", _selectClassBuffer);
InitDisPatch(InitID);
}
protected override void Dispatch(ComputeBuffer system)
{
if (_clickPoint.z > 0)
{
_clickPoint = Vector3.one * 1000000;
}
//_depthPictureMove.Excute(temp);
ComputeShader.SetVector("clickPoint", _clickPoint);
ComputeShader.SetFloat("deltaTime", Time.deltaTime);
ComputeShader.SetVector("srcPos", SrcPos);
Matrix4x4 v = Camera.main.worldToCameraMatrix;
Matrix4x4 p = Camera.main.projectionMatrix;
ComputeShader.SetMatrix("v", v);
ComputeShader.SetMatrix("p", p);
ComputeShader.SetMatrix("ip", p.inverse);
ComputeShader.SetMatrix("iv", v.inverse);
base.Dispatch(dispatchID, system);
if (_clickPoint.z < 1000000) //相当于有点击事件才触发
{
PosAndDir[] datas = { new PosAndDir(-1) };
_clickPointBuff.GetData(datas);
int index = datas[0].picIndex;
Debug.Log("得到的图片index is " + index);
var countBuffer = new ComputeBuffer(1, sizeof(int), ComputeBufferType.IndirectArguments);
ComputeBuffer.CopyCount(_appendBuffer, countBuffer, 0);
//通过这个方法拿到第一个数据。
int[] counter = { 0 };
countBuffer.GetData(counter);
int count = counter[0];
Debug.Log("count: " + count);
var data = new PosAndDir[count];
_appendBuffer.GetData(data);
if (data.Length > 0)
{
Debug.Log("data length: " + data.Length + " 得到的图片index is" + data[0].bigIndex);
}
else
{
Debug.Log("data length: " + 0);
}
Sort(data);
if (data.Length > 0)
{
// PosAndDir pad = data[0];
PictureHandle.Instance.GetYearInfo(data[0], Canvas.transform);
}
_clickPoint = Vector3.one * 1000000;//重置数据
_appendBuffer.SetCounterValue(0);
countBuffer.Dispose();
// _appendBuffer.Release();
}
}
void CreateBuffers()
{
if (InstanceCount < 1)
{
InstanceCount = 1;
}
if (_column < 100)
{
_column = 100;
}
InstanceCount = Mathf.ClosestPowerOfTwo(InstanceCount);
GalaxyPosList = Common.GetPos(PosTexture2D, 1.5f, InstanceCount, 10);
InstanceMesh.bounds = new Bounds(Vector3.zero, Vector3.one * 10000f);
// Positions & Colors
if (positionBuffer != null)
{
positionBuffer.Release();
}
if (colorBuffer != null)
{
colorBuffer.Release();
}
if (boundaryBuffer != null)
{
boundaryBuffer.Release();
}
int stride = Marshal.SizeOf(typeof(PosAndDir));
//Debug.Log("stride byte size is " + stride);
positionBuffer = new ComputeBuffer(InstanceCount, stride);//16
colorBuffer = new ComputeBuffer(InstanceCount, 16);
int boundbuff = Marshal.SizeOf(typeof(Vector4));
boundaryBuffer = new ComputeBuffer(4, boundbuff);
Vector4[] colors = new Vector4[InstanceCount];
PosAndDir[] posDirs = new PosAndDir[InstanceCount];
for (int i = 0; i < InstanceCount; i++)
{
posDirs[i].position = Vector4.one;
posDirs[i].picIndex = i % TexArr.depth;
}
colorBuffer.SetData(colors);
positionBuffer.SetData(posDirs);
CurMaterial.SetBuffer("positionBuffer", positionBuffer);
// CurMaterial.SetBuffer("colorBuffer", colorBuffer);
// indirect args
uint numIndices = (InstanceMesh != null) ? InstanceMesh.GetIndexCount(0) : 0;
args[0] = numIndices;
args[1] = (uint)InstanceCount;
argsBuffer.SetData(args);
}
/// <summary>
/// 改变状态，直接把大矩形填满整个屏幕，其他大矩形则透明掉
/// </summary>
public void ChangeState(int classNumber)
{
if (Type != MotionType.ClassiFicationMotion)
{
return;
}
PosAndDir[] datas = new PosAndDir[ComputeBuffer.count];
ComputeBuffer.GetData(datas);
List <PosAndDir> temp = new List <PosAndDir>();
List <PosAndDir> allDataList = new List <PosAndDir>();
//这里注意，posAndDir属于结构体，值拷贝
for (int i = datas.Length - 1; i >= 0; i--)
{
PosAndDir data = datas[i];
if (datas[i].bigIndex == classNumber)
{
temp.Add(data);//编号一样的单独拿出来
}
else
{
data.position = Vector4.zero;//其他编号都隐藏
allDataList.Add(data);
}
}
PosAndDir[] newData = temp.ToArray();
//根据分辨率展开图片 写死每个大矩形的宽高
int widthCount = Width / 96; //每个图片宽99像素
int heightCount = Height / 108; //每个图片高108素
List <Rect> rects = new List <Rect>();
int tempHeithtCount = 0;//y轴上的个数
for (int i = 0; i < widthCount * heightCount; i++)
{
if (i != 0 && i % widthCount == 0)
{
tempHeithtCount++;
}
int tempWidthCount = i - tempHeithtCount * widthCount;//轴上的个数
Rect rect = new Rect(tempWidthCount, tempHeithtCount, 96f, 108f);
rects.Add(rect);
}
//每个盒子分配得到的面片个数 会有概率盒子分配过剩，记得把过剩的处理
int count = newData.Length / rects.Count;
Vector2 scale = Vector2.zero;
for (int i = 0; i < rects.Count; i++)
{
#region 处理小矩形
Rect rect = rects[i];
float width = rect.width;
float height = rect.height;
float fitedge = (Mathf.Sqrt((width * height * 1f) / count)); //适合的边长，
int row = (int)(width / fitedge); //求得大概行横列的个数，即一横有多少个
int column = (int)(height / fitedge); //求得竖列大概的个数，即一竖有多少个
float smallWidth = width * 1f / row; //求得小矩形屏幕分辨率的宽
float smallHeight = height * 1f / column; //求得小矩形屏幕分辨率的高，
//求得小矩形的宽和高后，填满大矩形的个数跟每个盒子分配的面片个数不一致，
//我们以求得的宽高后的盒子为准，多余的面片我们舍去
//row*column 为实际上用到的quad个数
//小矩形的宽高转化为世界宽度和高度，注意Z轴
Vector3 origin = Camera.main.ScreenToWorldPoint(new Vector3(0f, 0f, Z - Camera.main.transform.position.z));
//世界位置小矩形的宽
Vector3 wpos = Camera.main.ScreenToWorldPoint(new Vector3(smallWidth, 0f, Z - Camera.main.transform.position.z));
//世界位置小矩形的高
Vector3 hpos = Camera.main.ScreenToWorldPoint(new Vector3(0f, smallHeight, Z - Camera.main.transform.position.z));
//得到小矩形在世界坐标中应得到的宽度
float wwidth = wpos.x - origin.x;
//得到小矩形哎世界坐标中得到的高度
float wheight = hpos.y - origin.y;
//世界位置大矩形的宽的位置
Vector3 widthBigpos = Camera.main.ScreenToWorldPoint(new Vector3(rect.width, 0f, Z - Camera.main.transform.position.z));
//世界位置大矩形的高的位置
Vector3 heightBigpos = Camera.main.ScreenToWorldPoint(new Vector3(0f, rect.height, Z - Camera.main.transform.position.z));
//得到大矩形在世界坐标中应得到的宽度
float wwidthBig = widthBigpos.x - origin.x;
//得到大矩形哎世界坐标中得到的高度
float wheightBig = heightBigpos.y - origin.y;
//因为quad边长为1，对quab进行缩放加工，quad的位置的Z轴位置一定要正确
// Quab.transform.localScale = new Vector3(wwidth, wheight, 1f);
scale = new Vector2(wwidth, wheight);//把面片缩放倍数弹出去
int actual = row * column;//实际有作用的粒子个数
//进一步加工uv y=>rows x=>horizontalColumn
//得到一个新的uvwz,
float u = 1f / row;
float v = 1f / column;
float delay = Random.Range(3, 8);
//把小矩形填充整个大矩形
int rowsCount = 0;//横列个数 y轴概念
for (int j = 0; j < count; j++)
{
int index = i * count + j;//buff数组中的索引位置
if (j >= actual)//多余的面片不应该显示
{
newData[index].position = Vector4.zero;
//newData[index].moveTarget = Vector3.zero;
//newData[index].originalPos = Vector4.zero;
continue;
}
// Vector3 pos = Vector3.zero;
if (j != 0 && j % row == 0)
{
rowsCount++;
}
int columnCount = j - rowsCount * row;//竖列个数 x轴概念
Vector3 pos = new Vector3(origin.x, origin.y, 0) +
//这里的xy,存放的是倍数
new Vector3(wwidthBig * rect.position.x, wheightBig * rect.position.y, 0) +
new Vector3(wwidth * columnCount + wwidth / 2, wheight * rowsCount + wheight / 2f, Z);
newData[index].moveTarget = pos;
newData[index].originalPos = Vector4.one;
newData[index].indexRC = new Vector2(columnCount, rowsCount);
newData[index].picIndex = i % TextureInstanced.Instance.TexArr.depth;
newData[index].bigIndex = i % TextureInstanced.Instance.TexArr.depth; //分类编号
Vector4 otherData = new Vector4(); //切换图片索要缓存的数据
otherData.x = delay; //延迟播放的时间
otherData.y = 1f; //Random.Range(0.1f,1f);//切换图片的时间
otherData.z = 0f; //时间缓存
otherData.w = 0f; //插值值
newData[index].velocity = otherData;
float w = u * columnCount;
float z = v * rowsCount;//rowsCount
newData[index].uvOffset = new Vector4(u, v, w, z);
newData[index].uv2Offset = new Vector4(u, v, w, z);
}
#endregion
}
//计算剩余的不用的面片隐藏掉
int surplusCount = newData.Length - count * rects.Count;
if (surplusCount > 0)
{
for (int i = newData.Length - 1; i >= newData.Length - surplusCount; i--)
{
newData[i].position = Vector4.zero;
}
}
TextureInstanced.Instance.CurMaterial.SetVector("_WHScale", new Vector4(scale.x, scale.y, 1, 1));
allDataList.AddRange(newData);
ComputeBuffer.SetData(allDataList.ToArray());
ComputeShader.SetBuffer(dispatchID, "positionBuffer", ComputeBuffer);
ComputeShader.SetBuffer(InitID, "positionBuffer", ComputeBuffer);
MoveSpeed = 50f;//更改更快的插值速度
ComputeShader.SetFloat("MoveSpeed", MoveSpeed);
InitDisPatch(InitID);
}
protected override void Init()
{
base.Init();
MotionType = MotionType.Cube;
PosAndDir[] datas = new PosAndDir[ComputeBuffer.count];
ComputeBuffer.GetData(datas);
var sideCount = Mathf.FloorToInt(Mathf.Pow(ComputeBuffer.count, 1f / 3f));
var count = sideCount * sideCount * sideCount;
var dsideCount = sideCount * sideCount;
var scale = 2.5f;
var offset = -Vector3.one * 0.5f;
// Debug.Log("init cubeInstance");
//使图片组成立方体
//顺便取出立方体靠近相机的那个面的四个角的坐标，拿出来，判断是否越出边界
for (int x = 0; x < sideCount; x++)
{
var xoffset = x * dsideCount;
for (int y = 0; y < sideCount; y++)
{
var yoffset = y * sideCount;
for (int z = 0; z < sideCount; z++)
{
var index = xoffset + yoffset + z;
Vector3 pos = new Vector3(x, y, z) * scale + new Vector3(-55f, -55f, -9f);
// var particle = new GPUParticle(Random.Range(0.5f, 1f), pos, Quaternion.identity, Vector3.one, Vector3.zero, Vector3.zero, Color.white);
datas[index].moveTarget = pos;
datas[index].moveDir = pos;//在这里的意义就是一个开关而已
datas[index].originalPos = pos;
datas[index].uvOffset = new Vector4(1f, 1f, 0f, 0f);
datas[index].uv2Offset = new Vector4(1f, 1f, 0f, 0f);
datas[index].picIndex = index % TextureInstanced.Instance.TexArr.depth;
datas[index].bigIndex = index % TextureInstanced.Instance.TexArr.depth;
Vector4 posTemp = datas[index].position;
datas[index].position = new Vector4(posTemp.x, posTemp.y, posTemp.z, 1f);
if (index == 0)
{
LeftDownTip.position = pos;
_originalPosLeftDown = pos;
}
if (index == sideCount * (sideCount) - sideCount)
{
LeftUpTip.position = pos;
_originalPosLeftUp = pos;
}
if (index == sideCount * sideCount * (sideCount - 1))
{
RightDownTip.position = pos;
_originalPosRightDown = pos;
}
if (index == sideCount * sideCount * (sideCount) - sideCount)
{
RightUpTip.position = pos;
_originalPosRightUp = pos;
}
}
}
}
ComputeBuffer.SetData(datas);
TextureInstanced.Instance.ChangeInstanceMat(null);
TextureInstanced.Instance.CurMaterial.SetVector("_WHScale", new Vector4(1, 1, 1, 1));
}
