Ejemplo n.º 1
0
        public Entity CreateBlock(BlockType type, int2 position)
        {
            float  scale  = config.blockScale;
            Entity entity = CreateBaseEntity(VisualOrigin + new float3(position.x, 0, position.y) * scale);

            EntityManager.AddComponentData(entity, new NonUniformScale()
            {
                Value = new float3(scale, GroupSize.x * 2, scale)
            });
            EntityManager.AddComponentData(entity, new Block()
            {
                Type = type
            });
            EntityManager.AddComponentData(entity, new BlockPoint()
            {
                Value = position
            });
            EntityManager.AddComponentData(entity, new Depth()
            {
                Value = 0
            });
            RenderMeshUtility.AddComponents(entity, EntityManager, MeshDescriptions[(int)type]);

            return(entity);
        }
Ejemplo n.º 2
0
    // RenderMeshUtility.AddComponents code example as actual code to make sure it compiles.
    void CodeExample()
    {
        var world         = World.DefaultGameObjectInjectionWorld;
        var entityManager = world.EntityManager;

        var desc = new RenderMeshDescription(
            Mesh,
            Material);

        // RenderMeshUtility can be used to easily create Hybrid Renderer
        // compatible entities, but it can only be called from the main thread.
        var entity = entityManager.CreateEntity();

        RenderMeshUtility.AddComponents(
            entity,
            entityManager,
            desc);
        entityManager.AddComponentData(entity, new ExampleComponent());

        // If multiple similar entities are to be created, 'entity' can now
        // be instantiated using Instantiate(), and its component values changed
        // afterwards.
        // This can also be done in Burst jobs using EntityCommandBuffer.ParallelWriter.
        var secondEntity = entityManager.Instantiate(entity);

        entityManager.SetComponentData(secondEntity, new Translation {
            Value = new float3(1, 2, 3)
        });
    }
Ejemplo n.º 3
0
        public Entity CreateWorker(WorkerConfig workerConfig, int2 position)
        {
            float3 worldPos = blockGroupSystem.VisualOrigin + new float3(position.x, 0, position.y);

            Entity block = blockGroupSystem.GetBlock(position);

            Entity entity = CreateBaseEntity(worldPos);

            Color color = workerConfig.Color;

            EntityManager.AddComponentData(entity, new Worker()
            {
                Ability        = workerConfig.ability,
                CurrentBlock   = block,
                Frequency      = workerConfig.frequency,
                SizeLossPerHit = workerConfig.sizeLossPerHit,
                Radius         = workerConfig.radius,
                MaxBounces     = workerConfig.maxBounces,
                MarkDuration   = workerConfig.markDuration,
                Timer          = 0.75f,
                Color          = new float4(color.r, color.g, color.b, color.a)
            });

            EntityManager.AddComponentData(entity, new DestinationPoint()
            {
                Value = position, PreviousPoint = position
            });
            EntityManager.AddComponentData(entity, new VerticalLimit()
            {
                FlightHeight = Random.CreateFromIndex((uint)Time.ElapsedTime).NextInt(5, 8)
            });
            EntityManager.AddComponentData(entity, new NonUniformScale()
            {
                Value = workerConfig.size
            });
            EntityManager.AddComponentData(entity, new DrillPower()
            {
                Amount = workerConfig.power, Frequency = workerConfig.frequency
            });
            EntityManager.AddComponentData(entity, new WorkerAnimations()
            {
                Bounce = bounceCurve, Move = moveCurve
            });
            RenderMeshUtility.AddComponents(entity, EntityManager, cachedMeshDescriptions[workerConfig]);
            EntityManager.SetComponentData(entity, new Translation()
            {
                Value = blockGroupSystem.ToWorldPoint(position, 0)
            });
            return(entity);
        }
Ejemplo n.º 4
0
 public void AddPrimitiveInstanced(
     uint nodeIndex,
     string meshName,
     Mesh mesh,
     int[] materialIndices,
     uint instanceCount,
     NativeArray <Vector3>?positions,
     NativeArray <Quaternion>?rotations,
     NativeArray <Vector3>?scales,
     int primitiveNumeration = 0
     )
 {
     if ((settings.mask & ComponentType.Mesh) == 0)
     {
         return;
     }
     foreach (var materialIndex in materialIndices)
     {
         var material = gltf.GetMaterial(materialIndex) ?? gltf.GetDefaultMaterial();
         material.enableInstancing = true;
         var renderMeshDescription = new RenderMeshDescription(mesh, material, subMeshIndex: materialIndex);
         var prototype             = entityManager.CreateEntity(nodeArcheType);
         RenderMeshUtility.AddComponents(prototype, entityManager, renderMeshDescription);
         if (scales.HasValue)
         {
             entityManager.AddComponent <NonUniformScale>(prototype);
         }
         for (var i = 0; i < instanceCount; i++)
         {
             var instance = i > 0 ? entityManager.Instantiate(prototype) : prototype;
             entityManager.SetComponentData(instance, new Translation {
                 Value = positions?[i] ?? Vector3.zero
             });
             entityManager.SetComponentData(instance, new Rotation {
                 Value = rotations?[i] ?? Quaternion.identity
             });
             entityManager.SetComponentData(instance, new Parent {
                 Value = nodes[nodeIndex]
             });
             if (scales.HasValue)
             {
                 entityManager.SetComponentData(instance, new NonUniformScale()
                 {
                     Value = scales.Value[i]
                 });
             }
         }
     }
 }
Ejemplo n.º 5
0
        public static void AddRenderMeshRenderer(EntityManager em, Entity e, Material mat = default)
        {
            mat = mat == default ? Resources.Load <Material>("Terminal8x8") : mat;
            em.AddComponents(e, _meshDataTypes);

            var mesh = new Mesh();

            mesh.MarkDynamic();
            RenderMeshUtility.AddComponents(e, em, new RenderMeshDescription
            {
                RenderMesh = new RenderMesh
                {
                    mesh     = mesh,
                    material = mat
                }
            });
        }
Ejemplo n.º 6
0
    void Start()
    {
        var world         = World.DefaultGameObjectInjectionWorld;
        var entityManager = world.EntityManager;

        EntityCommandBuffer ecb = new EntityCommandBuffer(Allocator.TempJob);

        // Create a RenderMeshDescription using the convenience constructor
        // with named parameters.
        var desc = new RenderMeshDescription(
            Mesh,
            Material,
            shadowCastingMode: ShadowCastingMode.Off,
            receiveShadows: false);

        // Create empty base entity
        var prototype = entityManager.CreateEntity();

        // Call AddComponents to populate base entity with the components required
        // by Hybrid Renderer
        RenderMeshUtility.AddComponents(
            prototype,
            entityManager,
            desc);
        entityManager.AddComponentData(prototype, new LocalToWorld());

        // Spawn most of the entities in a Burst job by cloning a pre-created prototype entity,
        // which can be either a Prefab or an entity created at run time like in this sample.
        // This is the fastest and most efficient way to create entities at run time.
        var spawnJob = new SpawnJob
        {
            Prototype   = prototype,
            Ecb         = ecb.AsParallelWriter(),
            EntityCount = EntityCount,
        };

        var spawnHandle = spawnJob.Schedule(EntityCount, 128);

        spawnHandle.Complete();

        ecb.Playback(entityManager);
        ecb.Dispose();
        entityManager.DestroyEntity(prototype);
    }
Ejemplo n.º 7
0
    private void SwapRenderMesh(Entity entity, bool isTorso, Mesh torsoMesh, Mesh mesh)
    {
        var origMeshData = EntityManager.GetSharedComponentData <RenderMesh>(entity);

        EntityManager.RemoveComponent <RenderMesh>(entity);

        var renderMeshDescription = new RenderMeshDescription(isTorso ? torsoMesh : mesh, DynamicMaterial, ShadowCastingMode.On);

        RenderMeshUtility.AddComponents(entity, EntityManager, renderMeshDescription);
        EntityManager.AddComponentData(entity, new LocalToWorld());

        if (!isTorso)
        {
            EntityManager.AddComponentData(entity, new NonUniformScale
            {
                Value = origMeshData.mesh.bounds.size,
            });
        }
    }
Ejemplo n.º 8
0
    // Start is called before the first frame update
    void Start()
    {
        var world         = World.DefaultGameObjectInjectionWorld;
        var entityManager = world.EntityManager;

        EntityCommandBuffer ecbJob        = new EntityCommandBuffer(Allocator.TempJob);
        EntityCommandBuffer ecbMainThread = new EntityCommandBuffer(Allocator.Temp);

        var desc = new RenderMeshDescription(
            Mesh,
            Material,
            shadowCastingMode: ShadowCastingMode.Off,
            receiveShadows: false);

        var prototype = entityManager.CreateEntity();

        RenderMeshUtility.AddComponents(
            prototype,
            entityManager,
            desc);
        entityManager.AddComponentData(prototype, new MaterialColor());

        // Spawn most of the entities in a Burst job by cloning a pre-created prototype entity,
        // which can be either a Prefab or an entity created at run time like in this sample.
        // This is the fastest and most efficient way to create entities at run time.
        var spawnJob = new SpawnJob
        {
            Prototype   = prototype,
            Ecb         = ecbJob.AsParallelWriter(),
            EntityCount = EntityCount,
            ObjectScale = ObjectScale,
            Radius      = Radius,
            Twists      = Twists,
        };

        int numJobEntities = EntityCount - MainThreadEntityCount;
        var spawnHandle    = spawnJob.Schedule(numJobEntities, 128);

        // Spawn a small portion in the main thread to test that the ECB API works.
        // This is NOT the recommended way, this simply tests that this API works.
        for (int i = 0; i < MainThreadEntityCount; ++i)
        {
            int index = i + numJobEntities;
            var e     = ecbMainThread.CreateEntity();
            RenderMeshUtility.AddComponents(
                e,
                ecbMainThread,
                desc);
            ecbMainThread.SetComponent(e, new LocalToWorld {
                Value = spawnJob.ComputeTransform(index)
            });
            // Use AddComponent because we didn't clone the prototype here
            ecbMainThread.AddComponent(e, new MaterialColor {
                Value = spawnJob.ComputeColor(index)
            });
        }

        spawnHandle.Complete();

        ecbJob.Playback(entityManager);
        ecbJob.Dispose();
        ecbMainThread.Playback(entityManager);
        entityManager.DestroyEntity(prototype);
    }
Ejemplo n.º 9
0
        public virtual void AddPrimitive(
            uint nodeIndex,
            string meshName,
            Mesh mesh,
            int[] materialIndices,
            uint[] joints              = null,
            uint?rootJoint             = null,
            float[] morphTargetWeights = null,
            int primitiveNumeration    = 0
            )
        {
            if ((settings.mask & ComponentType.Mesh) == 0)
            {
                return;
            }
            Entity node;

            if (primitiveNumeration == 0)
            {
                // Use Node GameObject for first Primitive
                node = nodes[nodeIndex];
            }
            else
            {
                node = entityManager.CreateEntity(nodeArcheType);
                entityManager.SetComponentData(node, new Translation {
                    Value = new float3(0, 0, 0)
                });
                entityManager.SetComponentData(node, new Rotation {
                    Value = quaternion.identity
                });
                entityManager.SetComponentData(node, new Parent {
                    Value = nodes[nodeIndex]
                });
            }

            var hasMorphTargets = mesh.blendShapeCount > 0;

            for (var index = 0; index < materialIndices.Length; index++)
            {
                var material = gltf.GetMaterial(materialIndices[index]) ?? gltf.GetDefaultMaterial();

                RenderMeshUtility.AddComponents(node, entityManager, new RenderMeshDescription(mesh, material, layer: settings.layer, subMeshIndex: index));
                if (joints != null || hasMorphTargets)
                {
                    if (joints != null)
                    {
                        var bones = new Entity[joints.Length];
                        for (var j = 0; j < bones.Length; j++)
                        {
                            var jointIndex = joints[j];
                            bones[j] = nodes[jointIndex];
                        }
                        // TODO: Store bone entities array somewhere (pendant to SkinnedMeshRenderer.bones)
                    }
                    if (morphTargetWeights != null)
                    {
                        for (var i = 0; i < morphTargetWeights.Length; i++)
                        {
                            var weight = morphTargetWeights[i];
                            // TODO set blend shape weight in proper component (pendant to SkinnedMeshRenderer.SetBlendShapeWeight(i, weight); )
                        }
                    }
                }
            }
        }
        protected override void OnUpdate()
        {
            if (hitSource == null)
            {
                hitSource = GameObject.Find("HitAudioSource").GetComponent <AudioSource>();
            }

            EntityCommandBuffer buffer = commandBufferSystem.CreateCommandBuffer();

            quaternion rot = rotation;

            if (query.CalculateEntityCount() == 0)
            {
                return;
            }

            NativeArray <Entity>      result    = query.ToEntityArray(Allocator.Temp);
            NativeArray <Translation> positions = query.ToComponentDataArray <Translation>(Allocator.Temp);
            NativeArray <Depth>       dents     = query.ToComponentDataArray <Depth>(Allocator.Temp);
            NativeArray <Mark>        marks     = query.ToComponentDataArray <Mark>(Allocator.Temp);

            for (int i = 0; i < result.Length; i++)
            {
                Mark   mark   = marks[i];
                Entity entity = result[i];

                float4 c = marks[i].Color;

                Color  color  = new Color(c.x, c.y, c.z, c.w);
                Entity effect = buffer.CreateEntity();
                float3 pos    = positions[i].Value;
                pos.y = -dents[i].Value + 0.01f;
                buffer.AddComponent(effect, new Translation()
                {
                    Value = pos
                });
                buffer.AddComponent(effect, new LocalToWorld());
                buffer.AddComponent(effect, new Rotation()
                {
                    Value = rot
                });
                buffer.AddComponent(effect, new Effect()
                {
                    Timer = 0, Duration = mark.Duration, Size = 1f, Block = mark.Block
                });
                buffer.AddComponent(effect, new Scale()
                {
                    Value = 1
                });
                buffer.AddComponent(effect, new BlockColor()
                {
                    Value = new float4(color.r, color.g, color.b, color.a * mark.Power)
                });
                buffer.AddComponent(effect, new BlockGlow()
                {
                    Value = new float4(color.r, color.g, color.b, color.a * mark.Power)
                });


                RenderMeshUtility.AddComponents(effect, buffer, effectMesh);

                buffer.SetComponent(entity, mark);
                buffer.RemoveComponent <Mark>(entity);

                if (Time.ElapsedTime - lastSoundPlayTime > 0.05f)
                {
                    lastSoundPlayTime = (float)Time.ElapsedTime;
                    AudioClip sound = drillConfig.hitSounds[math.clamp((int)(dents[i].Value * drillConfig.hitSounds.Length), 0, drillConfig.hitSounds.Length - 1)];
                    hitSource.PlayOneShot(sound);
                }
            }

            positions.Dispose();
            dents.Dispose();
            result.Dispose();
            marks.Dispose();
        }