public override void Init(GPUSkinning gpuSkinning)
{
base.Init(gpuSkinning);
shaderPropId_HierarchyToObjectMat = Shader.PropertyToID("_HierarchyToObjectMat");
shaderPorpId_HierarchyToObjectMats = Shader.PropertyToID("_HierarchyToObjectMats");
shaderPropId_JointLocalMatrix = Shader.PropertyToID("_JointLocalMatrix");
localMatrix = Matrix4x4.TRS(position, Quaternion.Euler(eulerAngle), scale);
mesh = weaponPrefab.GetComponent <MeshFilter>().sharedMesh;
material = new Material(weaponPrefab.GetComponent <MeshRenderer>().sharedMaterial);
#if UNITY_5_5 || UNITY_5_6 || UNITY_5_7 || UNITY_5_8 || UNITY_5_9 || UNITY_6 || UNITY_2017 || UNITY_2018 // etc.
isBuiltInDrawMeshInstancedSupported = true;
#else
isBuiltInDrawMeshInstancedSupported = false;
#endif
if (isBuiltInDrawMeshInstancedSupported)
{
material.EnableKeyword("BUILT_IN_DRAW_MESH_INSTANCED_ON");
material.DisableKeyword("BUILT_IN_DRAW_MESH_INSTANCED_OFF");
}
else
{
material.EnableKeyword("BUILT_IN_DRAW_MESH_INSTANCED_OFF");
material.DisableKeyword("BUILT_IN_DRAW_MESH_INSTANCED_ON");
}
}
public override void Init(GPUSkinning gpuSkinning)
{
base.Init(gpuSkinning);
newLodMesh = new Mesh();
newLodMesh.vertices = lodMesh.vertices;
newLodMesh.uv = lodMesh.uv;
newLodMesh.triangles = lodMesh.triangles;
newLodMesh.tangents = GPUSkinningUtil.ExtractBoneWeights(lodMesh);
additionalVertexStreames = new GPUSkinning_AdditionalVertexStreames(newLodMesh);
// Bounding Sphere
lodBoundingSpheres = new BoundingSphere[gpuSkinning.model.spawnObjects.Length];
for (int i = 0; i < lodBoundingSpheres.Length; ++i)
{
lodBoundingSpheres[i] = new BoundingSphere(gpuSkinning.model.spawnObjects[i].transform.position, 1f);
}
// Culling Group
lodCullingGroup = new CullingGroup();
lodCullingGroup.targetCamera = Camera.main;
lodCullingGroup.SetBoundingSpheres(lodBoundingSpheres);
lodCullingGroup.SetBoundingSphereCount(lodBoundingSpheres.Length);
lodCullingGroup.SetBoundingDistances(new float[] { 10, 15, 25, 40 });
lodCullingGroup.SetDistanceReferencePoint(Camera.main.transform);
lodCullingGroup.onStateChanged = OnLodCullingGroupOnStateChangedHandler;
newLodMesh.UploadMeshData(true);
}
public override void Init(GPUSkinning gpuSkinning)
{
base.Init(gpuSkinning);
shaderPropID_TerrainTex = Shader.PropertyToID("_TerrainTex");
shaderPropID_TerrainSize = Shader.PropertyToID("_TerrainSize");
shaderPropID_TerrainPos = Shader.PropertyToID("_TerrainPos");
if (terrain != null)
{
terrainData = terrain.terrainData;
terrainSize = terrainData.size;
}
if (terrain == null)
{
gpuSkinning.model.newMtrl.EnableKeyword("TERRAIN_HEIGHT_OFF");
gpuSkinning.model.newMtrl.DisableKeyword("TERRAIN_HEIGHT_ON");
}
else
{
gpuSkinning.model.newMtrl.EnableKeyword("TERRAIN_HEIGHT_ON");
gpuSkinning.model.newMtrl.DisableKeyword("TERRAIN_HEIGHT_OFF");
}
}
public override void Init(GPUSkinning gpuSkinning)
{
base.Init(gpuSkinning);
shaderPropID_Matrices = Shader.PropertyToID("_Matrices");
matricesUniformBlock = new Matrix4x4[gpuSkinning.GetComponentInChildren <SkinnedMeshRenderer>().bones.Length];
}
void Start()
{
SetupParticles();
if (m_GPUSkinning)
{
gpuSkinning = gameObject.AddComponent <GPUSkinning>();
gpuSkinning.root = m_Root;
}
}
public static void ExtractBoneAnimMatrix(GPUSkinning gpuSkinning, GPUSkinning_BoneAnimation boneAnimation, System.Action <Matrix4x4, Matrix4x4> boneAnimMatrixCB, System.Action <int> frameCB)
{
for (int frameIndex = 0; frameIndex < boneAnimation.frames.Length; ++frameIndex)
{
float second = (float)(frameIndex) / (float)boneAnimation.fps;
gpuSkinning.matrixArray.UpdateBoneAnimationMatrix(null, second);
int numBones = gpuSkinning.model.bones.Length;
for (int i = 0; i < numBones; ++i)
{
boneAnimMatrixCB(gpuSkinning.model.bones[i].animationMatrix, gpuSkinning.model.bones[i].hierarchyMatrix);
}
frameCB(frameIndex);
}
}
public override void Init(GPUSkinning gpuSkinning)
{
base.Init(gpuSkinning);
shaderPropID_mpb_time = Shader.PropertyToID("_mpb_time");
if (CheckGPUInstancingIsSupported())
{
gpuSkinning.model.newMtrl.shader.maximumLOD = 200;
gpuSkinning.joint.material.shader.maximumLOD = 200;
SetGPUInstancingMaterialPropertyBlock();
}
else
{
gpuSkinning.model.newMtrl.shader.maximumLOD = 100;
gpuSkinning.joint.material.shader.maximumLOD = 100;
ClearGPUInstancingMaterialPropertyBlock();
}
}
public override void Init(GPUSkinning gpuSkinning)
{
base.Init(gpuSkinning);
if (IsMatricesTextureSupported())
{
shaderPropID_MatricesTex = Shader.PropertyToID("_MatricesTex");
shaderPropID_MatricesTexSize = Shader.PropertyToID("_MatricesTexSize");
shaderPropID_AnimLength = Shader.PropertyToID("_AnimLength");
shaderPropID_AnimFPS = Shader.PropertyToID("_AnimFPS");
shaderPropID_NumPixelsPerFrame = Shader.PropertyToID("_NumPixelsPerFrame");
matricesTex = new Texture2D(matricesTexWidth, matricesTexHeight, TextureFormat.RGBAHalf, false);
matricesTex.name = "_MatricesTex";
matricesTex.filterMode = FilterMode.Point;
additionalVertexStreames = new GPUSkinning_AdditionalVertexStreames(gpuSkinning.model.newMesh);
BakeAnimationsToTexture();
}
}
public virtual void Init(GPUSkinning gpuSkinning)
{
this.gpuSkinning = gpuSkinning;
}
public virtual void Destroy()
{
gpuSkinning = null;
}
public override void Init(GPUSkinning gpuSkinning)
{
base.Init(gpuSkinning);
if (!SystemInfo.supportsComputeShaders)
{
return;
}
shaderPropID_Time = Shader.PropertyToID("_GameTime");
// Material
Shader shader = Shader.Find("Unlit/ProceduralModel");
if (!shader.isSupported)
{
return;
}
proceduralModelMaterial = new Material(shader);
proceduralModelMaterial.mainTexture = gpuSkinning.model.newMtrl.mainTexture;
// Vertices
int[] indices = gpuSkinning.model.newMesh.triangles;
Vector3[] vertices = gpuSkinning.model.newMesh.vertices;
Vector4[] tangents = gpuSkinning.model.newMesh.tangents;
Vector2[] uv = gpuSkinning.model.newMesh.uv;
verticesComputeBuffer = new ComputeBuffer(indices.Length, GPUSkinning_ComputeShader_Vertex.size);
var data = new GPUSkinning_ComputeShader_Vertex[indices.Length];
for (int i = 0; i < indices.Length; ++i)
{
var item = new GPUSkinning_ComputeShader_Vertex();
item.vertex = vertices[indices[i]];
item.tangents = tangents[indices[i]];
item.uv = uv[indices[i]];
data[i] = item;
}
verticesComputeBuffer.SetData(data);
numVertices_computeBuffer = data.Length;
// Global Data
var globalData = new GPUSkinning_CompueteShader_GlobalData();
globalData.fps = gpuSkinning.model.boneAnimations[0].fps;
globalData.animLength = gpuSkinning.model.boneAnimations[0].length;
// Bone Animation Matrices
List <GPUSkinning_ComputeShader_Matrix> cbMatricesList = new List <GPUSkinning_ComputeShader_Matrix>();
int matIndex = 0;
GPUSkinningUtil.ExtractBoneAnimMatrix(
gpuSkinning,
gpuSkinning.model.boneAnimations[0],
(animMat, hierarchyMat) =>
{
var matData = new GPUSkinning_ComputeShader_Matrix();
matData.mat = animMat;
cbMatricesList.Add(matData);
++matIndex;
},
(frameIndex) =>
{
if (frameIndex == 0)
{
globalData.oneFrameMatricesStride = matIndex;
}
}
);
matricesComputeBuffer = new ComputeBuffer(cbMatricesList.Count, GPUSkinning_ComputeShader_Matrix.size);
matricesComputeBuffer.SetData(cbMatricesList.ToArray());
// Global Data
globalDataComputeBuffer = new ComputeBuffer(1, GPUSkinning_CompueteShader_GlobalData.size);
globalDataComputeBuffer.SetData(new GPUSkinning_CompueteShader_GlobalData[] { globalData });
// Procedural Model Data
var modelData = new GPUSkinning_ComputeShader_Model[numProceduralInstances];
int numProceduralModelsPerRow = (int)Mathf.Sqrt(numProceduralInstances);
for (int i = 0; i < numProceduralInstances; ++i)
{
var aModelData = new GPUSkinning_ComputeShader_Model();
int row = i / numProceduralModelsPerRow;
int col = i - row * numProceduralModelsPerRow;
aModelData.pos = new Vector3(-row * proceduralModelGap, -1, -col * proceduralModelGap);
aModelData.time = Random.Range(0.0f, 10.0f);
modelData[i] = aModelData;
}
modelDataComputeBuffer = new ComputeBuffer(numProceduralInstances, GPUSkinning_ComputeShader_Model.size);
modelDataComputeBuffer.SetData(modelData);
// Draw Procedural Model
GPUSkinning_Camera.instance.onPostRender += Draw;
}
public override void Init(GPUSkinning gpuSkinning)
{
base.Init(gpuSkinning);
shaderPropID_Time = Shader.PropertyToID("_GameTime");
smr = gpuSkinning.GetComponentInChildren <SkinnedMeshRenderer>();
mesh = smr.sharedMesh;
// Init Bones
int numBones = smr.bones.Length;
bones = new GPUSkinning_Bone[numBones];
for (int i = 0; i < numBones; ++i)
{
GPUSkinning_Bone bone = new GPUSkinning_Bone();
bones[i] = bone;
bone.transform = smr.bones[i];
bone.name = bone.transform.gameObject.name;
bone.bindpose = mesh.bindposes[i] /*smr to bone*/;
}
// Construct Hierarchy
for (int i = 0; i < numBones; ++i)
{
if (bones[i].transform == smr.rootBone)
{
rootBoneIndex = i;
break;
}
}
System.Action <GPUSkinning_Bone> CollectChildren = null;
CollectChildren = (currentBone) =>
{
List <GPUSkinning_Bone> children = new List <GPUSkinning_Bone>();
for (int j = 0; j < currentBone.transform.childCount; ++j)
{
Transform childTransform = currentBone.transform.GetChild(j);
GPUSkinning_Bone childBone = GetBoneByTransform(childTransform);
if (childBone != null)
{
childBone.parent = currentBone;
children.Add(childBone);
CollectChildren(childBone);
}
}
currentBone.children = children.ToArray();
};
CollectChildren(bones[rootBoneIndex]);
// New MeshFilter MeshRenderer
mf = gpuSkinning.gameObject.AddComponent <MeshFilter>();
mr = gpuSkinning.gameObject.AddComponent <MeshRenderer>();
newMtrl = new Material(Shader.Find("Unlit/GPUSkinning"));
newMtrl.CopyPropertiesFromMaterial(smr.sharedMaterial);
mr.sharedMaterial = newMtrl;
// New Mesh
newMesh = new Mesh();
newMesh.vertices = mesh.vertices;
newMesh.tangents = GPUSkinningUtil.ExtractBoneWeights(mesh);
newMesh.uv = mesh.uv;
newMesh.triangles = mesh.triangles;
mf.sharedMesh = newMesh;
#if UNITY_EDITOR
// Extract bone animation data
int boneAnimationsCount = 0;
boneAnimations = new GPUSkinning_BoneAnimation[gpuSkinning.GetComponent <Animator>().runtimeAnimatorController.animationClips.Length];
foreach (AnimationClip animClip in gpuSkinning.GetComponent <Animator>().runtimeAnimatorController.animationClips)
{
GPUSkinning_BoneAnimation boneAnimation = ScriptableObject.CreateInstance <GPUSkinning_BoneAnimation>();
boneAnimation.fps = 60;
boneAnimation.animName = animClip.name;
boneAnimation.frames = new GPUSkinning_BoneAnimationFrame[(int)(animClip.length * boneAnimation.fps)];
boneAnimation.length = animClip.length;
boneAnimations[boneAnimationsCount++] = boneAnimation;
for (int frameIndex = 0; frameIndex < boneAnimation.frames.Length; ++frameIndex)
{
GPUSkinning_BoneAnimationFrame frame = new GPUSkinning_BoneAnimationFrame();
boneAnimation.frames[frameIndex] = frame;
float second = (float)(frameIndex) / (float)boneAnimation.fps;
List <GPUSkinning_Bone> bones2 = new List <GPUSkinning_Bone>();
List <Matrix4x4> matrices = new List <Matrix4x4>();
List <string> bonesHierarchyNames = null; if (boneAnimation.bonesHierarchyNames == null)
{
bonesHierarchyNames = new List <string>();
}
EditorCurveBinding[] curvesBinding = AnimationUtility.GetCurveBindings(animClip);
foreach (var curveBinding in curvesBinding)
{
GPUSkinning_Bone bone = GetBoneByHierarchyName(curveBinding.path);
if (bones2.Contains(bone))
{
continue;
}
bones2.Add(bone);
if (bonesHierarchyNames != null)
{
bonesHierarchyNames.Add(GetBoneHierarchyName(bone));
}
AnimationCurve curveRX = AnimationUtility.GetEditorCurve(animClip, curveBinding.path, curveBinding.type, "m_LocalRotation.x");
AnimationCurve curveRY = AnimationUtility.GetEditorCurve(animClip, curveBinding.path, curveBinding.type, "m_LocalRotation.y");
AnimationCurve curveRZ = AnimationUtility.GetEditorCurve(animClip, curveBinding.path, curveBinding.type, "m_LocalRotation.z");
AnimationCurve curveRW = AnimationUtility.GetEditorCurve(animClip, curveBinding.path, curveBinding.type, "m_LocalRotation.w");
AnimationCurve curvePX = AnimationUtility.GetEditorCurve(animClip, curveBinding.path, curveBinding.type, "m_LocalPosition.x");
AnimationCurve curvePY = AnimationUtility.GetEditorCurve(animClip, curveBinding.path, curveBinding.type, "m_LocalPosition.y");
AnimationCurve curvePZ = AnimationUtility.GetEditorCurve(animClip, curveBinding.path, curveBinding.type, "m_LocalPosition.z");
float curveRX_v = curveRX.Evaluate(second);
float curveRY_v = curveRY.Evaluate(second);
float curveRZ_v = curveRZ.Evaluate(second);
float curveRW_v = curveRW.Evaluate(second);
float curvePX_v = curvePX.Evaluate(second);
float curvePY_v = curvePY.Evaluate(second);
float curvePZ_v = curvePZ.Evaluate(second);
Vector3 translation = new Vector3(curvePX_v, curvePY_v, curvePZ_v);
Quaternion rotation = new Quaternion(curveRX_v, curveRY_v, curveRZ_v, curveRW_v);
NormalizeQuaternion(ref rotation);
matrices.Add(
Matrix4x4.TRS(translation, rotation, Vector3.one)
);
}
frame.bones = bones2.ToArray();
frame.matrices = matrices.ToArray();
if (boneAnimation.bonesHierarchyNames == null)
{
boneAnimation.bonesHierarchyNames = bonesHierarchyNames.ToArray();
}
}
}
// Save as ScriptableObject
AssetDatabase.CreateAsset(boneAnimations[0], "Assets/GPUSkinning/Resources/anim0.asset");
AssetDatabase.Refresh();
#else
// Read from ScriptableObject directly
boneAnimations = new GPUSkinning_BoneAnimation[] { Resources.Load("anim0") as GPUSkinning_BoneAnimation };
foreach (var boneAnimation in boneAnimations)
{
foreach (var frame in boneAnimation.frames)
{
int numBones2 = boneAnimation.bonesHierarchyNames.Length;
frame.bones = new GPUSkinning_Bone[numBones2];
for (int i = 0; i < numBones2; ++i)
{
frame.bones[i] = GetBoneByHierarchyName(boneAnimation.bonesHierarchyNames[i]);
}
}
}
#endif
// Spawn many models
if (spawnPoints != null)
{
List <GPUSkinning_SpawnObject> list = new List <GPUSkinning_SpawnObject>();
for (int i = 0; i < spawnPoints.Length; ++i)
{
for (int j = 0; j < spawnPoints[i].childCount; ++j)
{
GPUSkinning_SpawnObject spawnObject = new GPUSkinning_SpawnObject();
list.Add(spawnObject);
spawnObject.transform = spawnPoints[i].GetChild(j);
spawnObject.mf = spawnObject.transform.gameObject.AddComponent <MeshFilter>();
spawnObject.mr = spawnObject.transform.gameObject.AddComponent <MeshRenderer>();
spawnObject.mr.sharedMaterial = newMtrl;
spawnObject.mf.sharedMesh = newMesh;
}
}
spawnObjects = list.ToArray();
}
}
public override void Init(GPUSkinning gpuSkinning)
{
base.Init(gpuSkinning);
SetPlayMode0();
}
