Controller.cs

Go to the documentation of this file.

using UnityEngine;
using System.Collections;

public class Controller : MonoBehaviour {

    GameObject _genericModel;
    GameObject _snakeImageplane;

    ControlPoints _controlPoints;
    Snake _snake;

    void Start () {
        _genericModel = GameObject.Find("Head_mesh");

        _controlPoints = _genericModel.GetComponent<ControlPoints> ();

        _snake = gameObject.GetComponent<Snake> ();
    }

    bool finished = false;
    
    void Update () {}

    public void findFaceContours(Vector2 leftEyeCenter, Vector2 rightEyeCenter, Vector2 mouthCenter){

        RunLEyeDeformation (leftEyeCenter);
        RunREyeDeformation (rightEyeCenter);
        RunMouthDeformation (mouthCenter);
    }
    public void findEyebrows(Vector2 leftEyeBrowCenter, Vector2 rightEyeBrowCenter){

        RunLEyeBrowDeformation (leftEyeBrowCenter);
        RunREyeBrowDeformation (rightEyeBrowCenter);
    }

    public void resetSnake(){
        _snake.enabled = false;
        _controlPoints.enabled = false;
        _snake.enabled = true;
        _controlPoints.enabled = true;
    }

    public void RunContourDeformation () {
        _snake.enabled = true;
        _controlPoints.enabled = true;

        _snake.SetControlPoints (_controlPoints.ContourFCP);

        Vector3[] offsets = RunExpandingSnake (_controlPoints.ContourFCP);

        _controlPoints.DeformContour (offsets);
    }


    Vector3 eyeScale =  new Vector3(1.5f, 2.3f, 1f);
    Vector3 eyeBrowsScale =  new Vector3(1.5f, 2f, 1f);

    public void RunLEyeDeformation (Vector2 center) {
        _snake.enabled = true;
        _controlPoints.enabled = true;

        _snake.SetControlPoints(transformContour(_controlPoints.LEyeFCP, eyeScale, center));
        Vector3[] offsets = RunContractingSnake (_controlPoints.LEyeFCP);
        
        _controlPoints.DeformLEye (offsets);
    }

    public void RunREyeDeformation (Vector2 center) {
        
        _snake.enabled = true;
        _controlPoints.enabled = true;

        _snake.SetControlPoints(transformContour(_controlPoints.REyeFCP, eyeScale, center));
        
        Vector3[] offsets = RunContractingSnake (_controlPoints.REyeFCP);
        
        _controlPoints.DeformREye (offsets);
    }

    public void RunLEyeBrowDeformation (Vector2 center) {
        _snake.enabled = true;
        _controlPoints.enabled = true;
        
        _snake.SetControlPoints (transformContour(_controlPoints.LEyebrowCP, eyeBrowsScale, center));
        Vector3[] offsets = RunContractingSnake (_controlPoints.LEyebrowCP);
        
        _controlPoints.DeformLEyeBrow (offsets);
        //_controlPoints.ApplyDeformation();
    }

    public void RunREyeBrowDeformation (Vector2 center) {
        _snake.enabled = true;
        _controlPoints.enabled = true;
        
        _snake.SetControlPoints(transformContour(_controlPoints.REyebrowCP, eyeBrowsScale, center));
        Vector3[] offsets = RunContractingSnake (_controlPoints.REyebrowCP);
        
        _controlPoints.DeformREyeBrow (offsets);
    }

    public void RunMouthDeformation (Vector2 center) {
        
        _snake.enabled = true;
        _controlPoints.enabled = true;

        _snake.SetControlPoints (transformContour(_controlPoints.MouthFCP, new Vector3(0.5f, 0.5f, 1f), center));
        
        Vector3[] offsets = RunExpandingSnake (_controlPoints.MouthFCP);
        
        _controlPoints.DeformMouth (offsets);
    }

    bool drawSteps = true;
    Vector3[] RunExpandingSnake(Vector3[] startpoints) {

        _snake.InitSnake(true);
        _snake.UpdateSnake(150, drawSteps);

        Vector3[] startExpWPoints = startpoints;
        Vector3 meshPos = new Vector3 (1f, 0f, 0f);

        for (int i = 0; i < startExpWPoints.Length; i++ ) {
            startExpWPoints[i] -= meshPos;
            startExpWPoints[i].z = -2.0f;
        }

        //startExpWPoints = transformContour (_snake.GetStartWorldPoints (), new Vector3(1f/scale.x, 1f/scale.y, 1f/scale.z), center);


        Vector3[] expWPoints = _snake.GetSnakeWorldPoints ();
        Vector3[] expOffsets = _controlPoints.CalculateOffset (startExpWPoints, expWPoints);

        return expOffsets;
    }

    Vector3[] RunContractingSnake(Vector3[] startpoints){
        _snake.InitSnake();
        _snake.UpdateSnake(200, drawSteps);

        Vector3[] startContWPoints = startpoints;
        Vector3 meshPos = new Vector3 (1f, 0f, 0f);
        
        for (int i = 0; i < startContWPoints.Length; i++ ) {
            startContWPoints[i] -= meshPos;
            startContWPoints[i].z = -2.0f;
        }

        //startContWPoints = transformContour (_snake.GetStartWorldPoints (), new Vector3(1f/scale.x, 1f/scale.y, 1f/scale.z), center);

        Vector3[] contWPoints = _snake.GetSnakeWorldPoints ();
        Vector3[] contOffsets = _controlPoints.CalculateOffset (startContWPoints, contWPoints);

        return contOffsets;
    }

    Vector3[] transformContour(Vector3[] points, Vector3 scaleFactor, Vector2 newCenter){

        float xMin = float.MaxValue;
        float xMax = 0;
        float yMin = float.MaxValue;
        float yMax = 0;
        float zMin = float.MaxValue;
        float zMax = 0;


        foreach (Vector3 p in points) {
            if(p.x<xMin)
                xMin = p.x;
            if(p.x>xMax)
                xMax = p.x;
            if(p.y<yMin)
                yMin = p.y;
            if(p.y>yMax)
                yMax = p.y;
            if(p.z<zMin)
                zMin = p.z;
            if(p.z>zMax)
                zMax = p.z;
        }

        Vector3 center = new Vector3 ((xMin + xMax) / 2, (yMin + yMax) / 2, (zMin + zMax) / 2);

        Vector3 newCenter3 = new Vector3 (newCenter.x + 1f, newCenter.y, center.z);
        
        for (int i=0; i<points.Length; i++) 
            points[i] = newCenter3 - Vector3.Scale((center - points[i]), scaleFactor);


        return points;
    }
    
    public void ApplyDeformation() {
        _controlPoints.ApplyDeformation();
    }
}