Example #1
0
 public Translate(float startTick, float endTick, string actorName, Vector3?possibleOrigin, Vector3Nullable destination) :
     base(startTick, endTick)
 {
     this.actorName      = actorName;
     this.possibleOrigin = possibleOrigin;
     this.destination    = destination;
 }
Example #2
0
 private static void enqueueRotateActions(IStoryAction <UintT> storyAction, CM.DomainAction domainAction,
                                          CM.Animation effectingAnimation, FireBoltActionList aaq,
                                          string parentActionId, bool implicitActorInstantiation)
 {
     foreach (CM.RotateAction ra in domainAction.RotateActions)
     {
         float   startTick     = 0;
         float   endTick       = 0;
         string  actorName     = null;
         float?  targetDegrees = null;
         Vector2?targetPoint   = null;
         foreach (CM.DomainActionParameter domainActionParameter in domainAction.Params)
         {
             if (domainActionParameter.Name == ra.ActorNameParamName)
             {
                 if (!getActionParameterValue(storyAction, domainActionParameter, out actorName) ||
                     (implicitActorInstantiation && !actorWillBeInstantiated(actorName)))
                 {
                     break;
                 }
             }
             else if (domainActionParameter.Name == ra.DestinationParamName)
             {
                 IActionProperty targetOrientation;
                 if (storyAction.TryGetProperty(domainActionParameter.Name, out targetOrientation))
                 {
                     if (targetOrientation.Value.Value is float)
                     {
                         targetDegrees = (float)targetOrientation.Value.Value;
                         if (targetOrientation.Range.Name == "x+degrees")
                         {
                             targetDegrees = targetDegrees.Value.convertSourceEngineToUnityRotation();
                         }
                     }
                     else if (targetOrientation.Value.Value is Coordinate2D)
                     {
                         targetPoint = new Vector2((float)((Coordinate2D)targetOrientation.Value.Value).X,
                                                   (float)((Coordinate2D)targetOrientation.Value.Value).Y);
                     }
                 }
                 else
                 {
                     Debug.LogError("orientation not set for stepId[" + storyAction.Name + "]");
                 }
             }
         }
         startTick = getStartTick(storyAction, ra, effectingAnimation);
         endTick   = getEndTick(storyAction, ra, effectingAnimation, startTick);
         var targetRotation = new Vector3Nullable(null, targetDegrees, null);
         if (Rotate.ValidForConstruction(actorName, targetRotation, targetPoint))
         {
             aaq.Add(new Rotate(startTick, endTick, actorName, targetRotation, targetPoint)
             {
                 ParentActionId = parentActionId
             });
         }
     }
 }
Example #3
0
 public static bool ValidForConstruction(string actorName, Vector3Nullable targetRotation, Vector2?targetPoint)
 {
     if (string.IsNullOrEmpty(actorName))
     {
         return(false);
     }
     if ((targetRotation.X.HasValue || targetRotation.Y.HasValue || targetRotation.Z.HasValue) && //can't define an angle and a point
         targetPoint.HasValue)
     {
         return(false);
     }
     return(true);
 }
Example #4
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="startTick"></param>
        /// <param name="endTick"></param>
        /// <param name="actorName"></param>
        /// <param name="targetRotation"></param>
        /// <param name="targetPoint">x,z</param>
        public Rotate(float startTick, float endTick, string actorName, Vector3Nullable targetRotation, Vector2?targetPoint) :
            base(startTick, endTick)
        {
            this.actorName = actorName;

            //TODO this smells.  but generality in all dimensions will take too long to figure out
            //if the targetPoint is specified, prefer to use it over a bare rotation value
            if (targetPoint.HasValue)
            {
                this.targetOrientation = new Vector3Nullable(null, Mathf.Atan2(targetPoint.Value.x, targetPoint.Value.y) * Mathf.Rad2Deg, null);
            }
            else
            {
                this.targetOrientation = targetRotation;
            }
        }
Example #5
0
        public override bool Init()
        {
            if (initialized)
            {
                return(true);
            }
            Profiler.BeginSample("init shot frag");
            Extensions.RenderColliders();
            //don't throw null refs in the debug statement if framing isn't there.  it's not required
            string framingDescriptor = string.Empty;

            if (existsFraming())
            {
                framingDescriptor = framings[0].ToString();
            }

            Extensions.Log("init shot fragment start[{0}] end[{1}] anchor[{2}] height[{3}] lens[{4}] fStop[{5}] framing[{6}] direction[{7}] angle[{8}] focus[{9}] d:s[{10}:{11}]",
                           startTick, endTick, anchor, height, lensName, fStopName, framingDescriptor, direction, cameraAngle, focusTarget,
                           ElPresidente.Instance.CurrentDiscourseTime, ElPresidente.Instance.CurrentStoryTime);
            if (!findCamera())
            {
                return(false);
            }
            savePreviousCameraState();

            //ground parameters
            tempCameraPosition    = new Vector3Nullable(null, null, null);
            tempCameraOrientation = new Vector3Nullable(null, null, null);

            //anchor if specified
            Vector2 anchorPosition;

            if (calculateAnchor(anchor, out anchorPosition))
            {
                Extensions.Log("setting camera anchor[{0}]", anchorPosition);
                tempCameraPosition.X = anchorPosition.x;
                tempCameraPosition.Z = anchorPosition.y;
            }

            //subject position if something is framed

            GameObject framingTarget = null;

            if (existsFraming())
            {
                if (getActorByName(framings[0].FramingTarget, out framingTarget))
                {
                    targetLookAtPoint = findTargetLookAtPoint(framingTarget);
                }
                else
                {
                    Debug.LogError(string.Format("could not find actor [{0}]",
                                                 framings[0].FramingTarget).AppendTimestamps());
                }
            }

            //height
            if (existsFraming()) //default to even height with point of interest on framed target
            {
                tempCameraPosition.Y = targetLookAtPoint.y;
            }
            else if (height.HasValue)
            {
                tempCameraPosition.Y = height;
            }
            else
            {
                tempCameraPosition.Y = 1; //in the absence of all information just put the camera not at 0 height
            }

            //lens
            ushort tempLens;

            if (!string.IsNullOrEmpty(lensName) &&
                CameraActionFactory.lenses.TryGetValue(lensName, out tempLens))
            {
                tempLensIndex = tempLens;
            }

            //F Stop
            ushort tempFStop;

            if (!string.IsNullOrEmpty(fStopName) &&
                CameraActionFactory.fStops.TryGetValue(fStopName, out tempFStop))
            {
                tempFStopIndex = tempFStop;
            }

            //framing
            if (existsFraming() && framingTarget)
            {
                Bounds targetBounds = framingTarget.GetComponent <BoxCollider>().bounds;
                targetBounds.BuildDebugBox(5, Color.cyan);

                Extensions.Log("framing target[{0}] bounds[{1},{2}]", framingTarget.name,
                               targetBounds.min.y, targetBounds.max.y);

                FramingParameters framingParameters = FramingParameters.FramingTable[framings[0].FramingType];

                //default our aperture to one appropriate to the framing if it's not set
                if (!tempFStopIndex.HasValue &&
                    CameraActionFactory.fStops.TryGetValue(framingParameters.DefaultFStop, out tempFStop))
                {
                    tempFStopIndex = tempFStop;
                }

                if (tempLensIndex.HasValue && tempCameraPosition.X.HasValue && tempCameraPosition.Z.HasValue)
                {
                    //case is here for completeness.  rotation needs to be done for all combinations of lens and anchor specification, so it goes after all the conditionals
                }
                else if (!tempLensIndex.HasValue && tempCameraPosition.X.HasValue && tempCameraPosition.Z.HasValue)//direction still doesn't matter since we can't move in the x,z plane
                {
                    //naively guessing and checking
                    Quaternion savedCameraRotation = cameraBody.NodalCamera.transform.rotation;
                    //point the camera at the thing
                    cameraBody.NodalCamera.transform.rotation = Quaternion.LookRotation(targetBounds.center - cameraBody.NodalCamera.transform.position);
                    float targetFov = 0;
                    //need to keep from stepping up and down over some boundary
                    bool incremented = false;
                    bool decremented = false;
                    while (!(incremented && decremented))  //if we haven't set a value and we haven't stepped both up and down.
                    {
                        //find where on the screen the extents are.  using viewport space so this will be in %. z is world units away from camera
                        Vector3 bMax = cameraBody.NodalCamera.WorldToViewportPoint(targetBounds.max);
                        Vector3 bMin = cameraBody.NodalCamera.WorldToViewportPoint(targetBounds.min);

                        float FovStepSize = 2.5f;//consider making step size a function of current size to increase granularity at low fov.  2.5 is big enough to jump 100-180 oddly

                        if (bMax.y - bMin.y > framingParameters.MaxPercent && bMax.y - bMin.y < framingParameters.MinPercent)
                        {
                            break;//we found our answer in cameraBody.NodalCamera.fov
                        }
                        else if (bMax.y - bMin.y < framingParameters.MinPercent)
                        {
                            cameraBody.NodalCamera.fieldOfView -= FovStepSize;
                            decremented = true;
                        }
                        else //(bMax.y - bMin.y >= fp.MaxPercent)
                        {
                            cameraBody.NodalCamera.fieldOfView += FovStepSize;
                            incremented = true;
                        }

                        //force matrix recalculations on the camera after adjusting fov
                        cameraBody.NodalCamera.ResetProjectionMatrix();
                        cameraBody.NodalCamera.ResetWorldToCameraMatrix();
                    }
                    //reset camera position...we should only be moving the rig
                    targetFov = cameraBody.NodalCamera.fieldOfView;
                    cameraBody.NodalCamera.transform.rotation = savedCameraRotation;
                    tempLensIndex = (ushort)ElPresidente.Instance.GetLensIndex(targetFov);
                }
                else if (tempLensIndex.HasValue &&                                           //direction matters here.
                         (!tempCameraPosition.X.HasValue || !tempCameraPosition.Z.HasValue)) //also assuming we get x,z in a pair.  if only one is provided, it is invalid and will be ignored
                {
                    //allow full exploration of circle about target since we can't move in or out and keep the same framing
                    if (!findCameraPositionByRadius(framingTarget, targetBounds, framingParameters, 1.0f))
                    {
                        Extensions.Log("failed to find satisfactory position for camera to frame [{0}] [{1}] with lens [{2}]. view will be obstructed",
                                       framings[0].FramingTarget, framings[0].FramingType.ToString(), ElPresidente.Instance.lensFovData[tempLensIndex.Value]._focalLength);
                    }
                }
                else //we are calculating everything by framing and direction.
                {
                    //x,z does not have value
                    //pick a typical lens for this type of shot
                    tempLensIndex = CameraActionFactory.lenses[framingParameters.DefaultFocalLength];
                    //see if we can find a camera location for this lens
                    //allow less than some % of a circle variance from ideal viewing.  if we don't find an answer, change the lens

                    bool   sign       = true;
                    short  iterations = 0;
                    ushort maxLensChangeIterations = 6;
                    while (!findCameraPositionByRadius(framingTarget, targetBounds, framingParameters, 0.35f))
                    {
                        iterations++;
                        if (iterations > maxLensChangeIterations)
                        {
                            Extensions.Log("exceeded max lens change iterations[{0}] solving framing[{1}] on target[{2}]",
                                           maxLensChangeIterations, framingParameters.Type, framingTarget);
                            break; //framing is just not working out.  we will return a shot that's not so good and get on with things
                        }
                        int offset = sign ? iterations : -iterations;
                        if (tempLensIndex + offset < 0)
                        {
                            //should never get here since the smallest we specify is 27mm and we will cap at +-3 lenses
                        }
                        else if (tempLensIndex + offset > CameraActionFactory.lenses.Values.Max <ushort>())
                        {
                            //explore on the other side of our start lens until we hit our max iterations
                            iterations++;
                            offset = sign ? -iterations : iterations;
                        }
                        tempLensIndex = (ushort)(tempLensIndex + offset);
                    }
                }

                tempCameraOrientation.Y = Quaternion.LookRotation(framingTarget.transform.position - tempCameraPosition.Merge(previousCameraPosition)).eulerAngles.y;
            }
            else if (pan.HasValue) //no framing, we can pay attention to a direct rotate command
            {
                tempCameraOrientation.Y = pan.Value.BindToSemiCircle();
            }

            //this destroys the ability to angle with respect to anything but the framing target if specified
            //this does not seem terribly harmful. subject is attached to angle mostly because we wanted to not have
            //to specify a framing (if we used an absolute anchor for camera positioning)
            tiltCameraAtSubject(cameraAngle, framingTarget);

            //focus has to go after all possible x,y,z settings to get the correct distance to subject
            Vector3 focusPosition;

            if (calculateFocusPosition(focusTarget, out focusPosition))
            {
                tempFocusDistance = Vector3.Distance(tempCameraPosition.Merge(previousCameraPosition), focusPosition);
            }
            else if (framingTarget != null)//we didn't specify what to focus on, but we framed something.  let's focus on that by default
            {
                tempFocusDistance = Vector3.Distance(tempCameraPosition.Merge(previousCameraPosition), targetLookAtPoint);
            }

            //sort out what wins where and assign to final camera properties
            //start with previous camera properties in case nothing fills them in
            newCameraPosition    = tempCameraPosition.Merge(previousCameraPosition);
            newCameraOrientation = Quaternion.Euler(tempCameraOrientation.Merge(previousCameraOrientation.eulerAngles));
            newLensIndex         = tempLensIndex.HasValue ? tempLensIndex.Value : previousLensIndex;
            newFStopIndex        = tempFStopIndex.HasValue ? tempFStopIndex.Value : previousFStopIndex;
            newfocusDistance     = tempFocusDistance.HasValue ? tempFocusDistance.Value : previousFocusDistance;

            Skip();

            initialized = true;
            Profiler.EndSample();
            return(initialized);
        }
Example #6
0
 /// <summary>
 /// applies the specified values in this Vector3Nullable, newValues, over those in overridden.
 /// for all unspecified values in newValues, overridden controls.
 /// </summary>
 /// <param name="newValues"></param>
 /// <param name="overridden"></param>
 /// <returns></returns>
 public static Vector3 Merge(this Vector3Nullable newValues, Vector3 overridden)
 {
     return(new Vector3(newValues.X.HasValue ? newValues.X.Value : overridden.x,
                        newValues.Y.HasValue ? newValues.Y.Value : overridden.y,
                        newValues.Z.HasValue ? newValues.Z.Value : overridden.z));
 }
Example #7
0
 private static void enqueuetranslateActions(IStoryAction <UintT> storyAction, CM.DomainAction domainAction,
                                             CM.Animation effectingAnimation, FireBoltActionList aaq,
                                             string parentActionId, bool implicitActorInstantiation)
 {
     foreach (CM.TranslateAction ta in domainAction.TranslateActions)
     {
         float           startTick   = 0;
         float           endTick     = 0;
         string          actorName   = null;
         Vector3Nullable destination = new Vector3Nullable(null, null, null);
         Vector3         origin      = Vector3.zero;
         foreach (CM.DomainActionParameter domainActionParameter in domainAction.Params)
         {
             if (domainActionParameter.Name == ta.OriginParamName)
             {
                 IActionProperty coord;
                 if (storyAction.TryGetProperty(domainActionParameter.Name, out coord))
                 {
                     if (coord.Value.Value is Coordinate2D)
                     {
                         origin = ((Coordinate2D)coord.Value.Value).ToVector3(cm.DomainDistancePerEngineDistanceX, cm.DomainDistancePerEngineDistanceY, cm.DomainDistancePerEngineDistanceZ);
                     }
                     else if (coord.Value.Value is Coordinate3D)
                     {
                         origin = ((Coordinate3D)coord.Value.Value).ToVector3(cm.DomainDistancePerEngineDistanceX, cm.DomainDistancePerEngineDistanceY, cm.DomainDistancePerEngineDistanceZ);
                     }
                 }
                 else
                 {
                     Debug.LogError("origin not set for stepId[" + storyAction.Name + "]");
                 }
             }
             else if (domainActionParameter.Name == ta.DestinationParamName)
             {
                 IActionProperty coord;
                 if (storyAction.TryGetProperty(domainActionParameter.Name, out coord))
                 {
                     if (coord.Value.Value is Coordinate2D)
                     {
                         destination = ((Coordinate2D)coord.Value.Value).ToVector3Nullable(cm.DomainDistancePerEngineDistanceX, cm.DomainDistancePerEngineDistanceY, cm.DomainDistancePerEngineDistanceZ);
                     }
                     else if (coord.Value.Value is Coordinate3D)
                     {
                         destination = ((Coordinate3D)coord.Value.Value).ToVector3Nullable(cm.DomainDistancePerEngineDistanceX, cm.DomainDistancePerEngineDistanceY, cm.DomainDistancePerEngineDistanceZ);
                     }
                 }
                 else
                 {
                     Debug.LogError("destination not set for stepId[" + storyAction.Name + "]");
                 }
             }
             else if (domainActionParameter.Name == ta.ActorNameParamName)
             {
                 if (!getActionParameterValue(storyAction, domainActionParameter, out actorName) ||
                     (implicitActorInstantiation && !actorWillBeInstantiated(actorName)))
                 {
                     break;
                 }
             }
         }
         startTick = getStartTick(storyAction, ta, effectingAnimation);
         endTick   = getEndTick(storyAction, ta, effectingAnimation, startTick);
         if (Translate.ValidForConstruction(actorName))
         {
             aaq.Add(new Translate(startTick, endTick, actorName, origin, destination)
             {
                 ParentActionId = parentActionId
             });
         }
     }
 }