Unity-chan Stage

Homebrew Engine, C++, DirectX 11

Individual Work

Particle System

Data-driven Parameters

The particle system can read parameters from XML files. It also introduces Timeline for lifetime evaluating parameters.

                            
<Effect name="ribbon">
  <Emitter name="ribbon" type="ribbon">
    <Location module="box">
      <Mins>0.0,0.0,0.0</Mins>
      <Maxs>0.0,0.0,0.0</Maxs>
    </Location>
    <Velocity module="line">
      <MaxVelocity>0.0,0.0,0.0</MaxVelocity>
      <MinVelocity>0.0,0.0,0.0</MinVelocity>
    </Velocity>
    <LifeTime>1</LifeTime>

    <!-- Time before emitter stops spawning particles -->
    <SpawnTime>5</SpawnTime>

    <!-- Initial burst spawning -->
    <Burst>0</Burst>

    <!-- Particles spawned per second -->
    <Spawn>60</Spawn>

    <ConstantAcceleration>0.0,0.0,0.0</ConstantAcceleration>
    <ColorByLife>
      <KeyFrame fraction="0" value="0,209,237,255"/>
      <KeyFrame fraction="1" value="0,209,237,0"/>
    </ColorByLife>
    <SizeByLife>
      <KeyFrame fraction="0" value="0"/>
      <KeyFrame fraction="0.1" value="0.1"/>
      <KeyFrame fraction="1" value="0"/>
    </SizeByLife>
    <Prewarm>false</Prewarm>
    <Material>Data/Material/Ribbon.xml</Material>
  </Emitter>
</Effect>

                            
                        

Ribbon Particles

                            



bool ParticleEmitter::GetRibbonVertices(std::vector<Vertex3>& vertices, const Vector3& cameraPosition) const
{
    if (m_particles.empty())
        return false;
    vertices.reserve((uint)(m_particles.size() * 12));

    Vertex3 prevTop;
    Vertex3 prevBottom;
    Vector3 prevPos;

    for (size_t particleIndex = 0; particleIndex < m_particles.size(); particleIndex++)
    {

        if (particleIndex == 0)
        {
            Particle* prev = m_particles[0];
            prevPos = prev->m_status.m_position;
            Rgba prevColor = m_definition->GetColorByTime(m_definition->m_lifeTime);
            prevTop = Vertex3(prevPos, prevColor);
            prevBottom = Vertex3(prevPos, prevColor);
            continue;
        }

        Particle* current = m_particles[particleIndex];
        Vector3 currentPos = current->m_status.m_position;

        //create basis
        Vector3 toCamera = cameraPosition - currentPos;
        Vector3 toPrev = prevPos - currentPos;
        Vector3 planeVertical = CrossProduct(toCamera, toPrev);
        planeVertical.Normalize();

        float currentSize = m_definition->GetSizeByTime(current->m_lifeSpam);
        Rgba currentColor = m_definition->GetColorByTime(current->m_lifeSpam);

        //new pair of control points
        Vertex3 currentTop(currentPos + planeVertical*currentSize*0.5f, currentColor, Vector2(1.f, 0.f));
        Vertex3 currentBottom(currentPos - planeVertical*currentSize*0.5f, currentColor, Vector2(1.f, 1.f));

        //triangulate
        vertices.emplace_back(prevBottom);
        vertices.emplace_back(currentBottom);
        vertices.emplace_back(currentTop);
        vertices.emplace_back(prevBottom);
        vertices.emplace_back(currentTop);
        vertices.emplace_back(prevTop);

        vertices.emplace_back(prevBottom);
        vertices.emplace_back(currentTop);
        vertices.emplace_back(currentBottom);
        vertices.emplace_back(prevBottom);
        vertices.emplace_back(prevTop);
        vertices.emplace_back(currentTop);

        currentTop.texCoords = Vector2(0.f, 0.f);
        currentBottom.texCoords = Vector2(0.f, 1.f);

        prevPos = currentPos;
        prevTop = currentTop;
        prevBottom = currentBottom;
    }
    return true;
}

                            
                        

Spectrum Dancing Floor

                            

struct vertex_in_t
{
    float3 position : POSITION;
    float2 uv : UV;
    float4 color : COLOR;
    float3 normal : NORMAL;
    float3 tangent : TANGENT;
    uint4 boneIndices : BONE_INDICES;
    float4 boneWeights : BONE_WEIGHTS;
};

struct vertex_to_fragment_t
{
    float4 position : SV_Position;
    float2 uv : UV;
    float4 color : COLOR;
    float3 normal : NORMAL;
    float3 tangent : TANGENT;

    float3 world_position : WORLD_POSITION;
};

cbuffer model_position_cb : register(b10)
{
    float3 MODEL_POSITION;
    float padding;
};

cbuffer matrix_cb : register(b0)
{
    float4x4 MODEL;
    float4x4 VIEW;
    float4x4 PROJECTION;

    float4 EYE_POSITION;
};

    StructuredBuffer<float4x4> tSkinMatrices : register(t3);
    StructuredBuffer<float> tMusicSpectrum : register(t10);

vertex_to_fragment_t VertexFunction(vertex_in_t vertex)
{

    vertex_to_fragment_t out_data = (vertex_to_fragment_t) 0;

    float4 model_position = float4(vertex.position, 1.0f);
    float4 world_position = mul(model_position, MODEL);

    float3 meshDistance = world_position.xyz - MODEL_POSITION;

    float2 distance = float2(meshDistance.x, meshDistance.z);
    float len = length(distance);
    float radius = 3.f;
    float outerRadius = 20.f;
    if (len < radius)
    {
        float fraction = 1 - len / radius;
        fraction = fraction * fraction;
        int index = int((float)1024 * fraction);
        float offset = tMusicSpectrum[index] * 2;
        offset = clamp(offset, 0.f, 2.f);
        world_position.y += offset;
    }

    float4 view_position = mul(world_position, VIEW);
    float4 clip_position = mul(view_position, PROJECTION);

    out_data.position = clip_position;
    out_data.uv = vertex.uv;
    out_data.color = vertex.color;
    out_data.normal = mul(float4(vertex.normal, 0.f), MODEL).xyz;
    out_data.tangent = mul(float4(vertex.tangent, 0.f), MODEL).xyz;
    out_data.world_position = float4(world_position.xyz, 1.0f);
    return out_data;

}

                            
                        

                            
template <typename DataType>
struct KeyFrame
{
    float m_time;
    DataType m_value;

    KeyFrame();
    KeyFrame(float time, const DataType& data);
};

//---------------------------------------------------------

class TimeEvent
{
    std::vector<KeyFrame<CallbackFunc>> m_keys;
    float m_prevTime;
    float m_currentTime;
    public:
    TimeEvent();
    void Reset();
    void Update(float deltaSeconds);
    void AddEvent(float time, CallbackFunc func);
};

void TimeEvent::Update(float deltaSeconds)
{
    m_currentTime += deltaSeconds;
    for (KeyFrame<CallbackFunc>& key : m_keys)
        if (m_prevTime <= key.m_time && key.m_time <= m_currentTime)
            key.m_value("");
    m_prevTime = m_currentTime;
}
                            
                        

Miner Survival

Homebrew Engine, C++, DirectX 11

Individual Work

Procedurally Generated World

                            

//Build Chunk with Perlin Noise
void Chunk::BuildChunk()
{
    const float scale = 100.f;
    const int numOfOctaves = 8;
    const float octavePersistence = 0.3f;
    const float octaveScale = 2.f;
    const float maxAmplitude = CHUNK_SIZE_Z * 0.25f;

    for (int x = 0; x < CHUNK_SIZE_X; x++)
    {
        for (int y = 0; y < CHUNK_SIZE_Y; y++)
        {
            float coordXInWorld = static_cast<float>(x + m_mapCoords.x * CHUNK_SIZE_X);
            float coordYInWorld = static_cast<float>(y + m_mapCoords.y * CHUNK_SIZE_Y);
            int deltaColumnHeight = static_cast<int>(
            	Compute2dPerlinNoise(
            		coordXInWorld, coordYInWorld, scale, numOfOctaves, octavePersistence, octaveScale)
            	* maxAmplitude);
            int columnHeight = SEA_LEVEL + deltaColumnHeight;

            for (int z = 0; z < CHUNK_SIZE_Z; z++)
            {
                int blockIndex = GetIndex(x, y, z);
                BlockType blockType;
                if (z < columnHeight - DIRT_HEIGHT)
                    blockType = BLOCK_STONE;
                else if (z < columnHeight)
                {
                    if (z <= SEA_LEVEL)
                        blockType = BLOCK_SAND;
                    else
                        blockType = BLOCK_DIRT;
                }
                else if (z == columnHeight)
                {
                    if (IsPercentChance(0.001f))
                        blockType = BLOCK_GLOW_STONE;
                    else if (columnHeight <= SEA_LEVEL)
                        blockType = BLOCK_SAND;
                    else
                        blockType = BLOCK_GRASS;
                }
                else
                {
                    if (z <= SEA_LEVEL)
                    {
                        if (IsPercentChance(0.001f))
                            blockType = BLOCK_LAVA;
                        else
                            blockType = BLOCK_SAND;//BLOCK_WATER;
                    }
                    else
                        blockType = BLOCK_AIR;
                }
                m_blocks[blockIndex].SetBlockType(blockType);
            }
        }
    }
}

                            
                        

Chunk Management

Due to the cost of chunk management (create/load/save a chunk) of blocks is huge, executing it multiple time in a frame will crash the frame rate.

The solution is to prioritize and run one of the operation at most one time per frame:

1. Deactivate farthest chunk when the number of active chunks reach max value
2. Activate the nearest chunk
3. Deacticate a chunk that is out of range

Zombie AI

                            

void Zombie::Update(float deltaSeconds)
{

	if (m_hp <= 0.f)
	{
		m_rotationDegrees.z += TURN_SPEED * deltaSeconds;
		TurnToward(m_rotationDegrees.x, 90.f, TURN_SPEED * deltaSeconds);
		Entity::Update(deltaSeconds);
		return;
	}

	float horizontalAcc = HORIZONTAL_ACC;
	m_jumpCoolDown -= deltaSeconds;

	if (!m_isLanded)
		horizontalAcc *= 0.1f;

	Vector3 planeDelta = g_theGame->m_map->m_player->m_position - m_position;
	planeDelta.z = 0.f;

	m_velocity += planeDelta.GetNormalize() * horizontalAcc * deltaSeconds;

	Vector2 velocityProjectionInXYPlane(m_velocity);
	TurnToward(m_rotationDegrees.z, velocityProjectionInXYPlane.CalcHeadingDegrees(), TURN_SPEED * deltaSeconds);

	//dig blocks to pass if the wall is 2 or more blocks high
	if (m_isLanded)
	{
		float velDegree = velocityProjectionInXYPlane.CalcHeadingDegrees();

		BlockInfo facingBottomBlock;
		if (-135.f < velDegree && velDegree <= -45.f) //south
		{
			facingBottomBlock = g_theGame->m_map->GetBlockInfoAtWorldPos(m_position).GetSouth();
		}
		else if (-45.f < velDegree && velDegree <= 45.f) // east
		{
			facingBottomBlock = g_theGame->m_map->GetBlockInfoAtWorldPos(m_position).GetEast();
		}
		else if (45.f < velDegree && velDegree <= 135.f) // north
		{
			facingBottomBlock = g_theGame->m_map->GetBlockInfoAtWorldPos(m_position).GetNorth();
		}
		else // west
		{
			facingBottomBlock = g_theGame->m_map->GetBlockInfoAtWorldPos(m_position).GetWest();
		}

		BlockInfo facingTopBlock = facingBottomBlock.GetTop();
		BlockInfo facingTopTopBlock = facingTopBlock.GetTop();
		BlockInfo topTopBlock = g_theGame->m_map->GetBlockInfoAtWorldPos(m_position).GetTop().GetTop();
		if (/*facingBottomBlock.IsSolid() &&*/ (facingTopBlock.IsSolid()||facingTopTopBlock.IsSolid()))
		{
			g_theGame->m_map->DigBlock(facingTopBlock);
			g_theGame->m_map->DigBlock(facingTopTopBlock);
			g_theGame->m_map->DigBlock(topTopBlock);
			m_jumpCoolDown = JUMP_COOL_DOWN;
		}
		if (topTopBlock.IsSolid())
		{
			g_theGame->m_map->DigBlock(topTopBlock);
			m_jumpCoolDown = JUMP_COOL_DOWN;
		}
	}

	if (m_isLanded && m_jumpCoolDown <= 0.f)
	{
		m_velocity += Vector3(0.f, 0.f, JUMP_ACC_ONE_SHOT);
		m_jumpCoolDown = JUMP_COOL_DOWN;
	}

	m_light = g_theGame->m_map->GetBlockInfoAtWorldPos(m_position).GetLight();

	Entity::Update(deltaSeconds);
}

                            
                        

Self-made Assets

I created models of enemies/player/projectile and the BGM.

State Management

In this game, the play has multiple abilities to use, and one of them is Inflation. When the player uses Inflation, its mesh "inflates" then turn into a round, fat balloon mesh. The inflated player becomes no longer a character but a physics actor. The player can use Inflation again to "deflate" and switch back to normal state.

To switch between pawn actor and physics actor, it needs to follow the process below:

Inflation

1. Change character mesh
2. Remove animation instance. (A physics actor doesn't animate)
3. Change relative transform since the two mesh may have a different center point or initial rotation.
4. Set the new mesh to simulate physics. (this will detach the mesh component from its root, so it needs to re-attach to the root when switching back)
5. Disable collision of root collider. (since the mesh is detached and not moving with the root collider anymore, leaving it on the ground would create a "ghost collision")
6. Enable collision of character mesh. Now the mesh component handles collision itself. (physics simulated mesh also need collision on to move)
7. Do collision settings. (allow overlap events, collision channels or whatever)
8. "Copy" velocity from character movement velocity to physics linear velocity to prevent a sudden stop when switching state.
9. Deactivate character movement component.

Deflation

1. Move the root to mesh position (and apply offset to fit well)
2. Activate character movement component.
3. "Copy" velocity from physics linear velocity.
4. Enable collision of the root collider.
5. Do collision settings.
6. Reattach mesh to the root collider.
7. Restore relative transform.
8. Set animation instance.
9. Change character mesh

Physics-based Animation

To give an image of a funny and floppy balloon, I use Physics-Based Animation to blend animation with physics simulation.

The amount of physics blending become larger when the character is in the air.

The same mechanism also applies to children when the player uses Air Burst to blow them into the air.

Visual Effects

Weapon Recoil and Recovery Mechanism

Particle Effects

I was responsible for prototyping particle effects for weapon and abilities.

I focused on the motion and found out vector field did add a lot of dynamics to effects.