USARBot.MultiView

/* MultiView robot for multirobot support on
 * single client simulation.
 * by Marco Zaratti - marco.zaratti@gmail.com
*/
class MultiView extends Pawn config(USARBot);

// This structure defines all the data necessary to maintain a single view.
struct ViewInfo
{
    var bool assigned;      // TRUE if the view is already assigned to some robot.
    var vector location;    // Current robot camera location.
    var rotator rotation;   // Current robot camera rotation.
    var int FOV;            // Current robot camera FOV.
    var bool isStereo;      // Set by UpdateView() to enable stereo view.
    var vector stereoSpacing;   // if isStereo than this defines the spacing between the eyes/2, in uu.
};

// This strucure maintains the layout of the viewports.
struct ViewLayout
{
    var int Num;    // Max number of viewports.
    var int divX;   // Viewport X subdivision (max views in a raw).
    var int divY;   // Viewport Y subdivision (max views in a column).
    var int deltaX;    // Used to compute Xres in DrawHUD() function.
    var int deltaY;    // Used to compute Yres in DrawHUD() function.
    var int moduleFactor;  // Number of views in a row + 1 (used with the % operator)
    var int Xres;  // Width of the viewport
    var int Yres;  // Height of the viewport
};

// Camera
var RobotCamera     myCamera;   //Accessed by ViewTestPlayerController to locate view coords
var int             CameraZoom; //Accessed by ViewTestPlayerController to locate view FOV

//Viewports configuration
var ViewLayout      Viewports;
var config int      WideMode;   // 0 = automatic viewport subdivision, n = fixed number of columns.
var config int      CameraNum;  //Valid values: 0..inf (0 disables MultiView)
var config int      CameraXres; //Camera X resolution
var config int      CameraYres; //Camera Y resolution
var float           Aspect;     //Aspect ratio (CameraXres/CameraYres)
var config bool     IsCameraLocked; //Accessed by ViewTestPlayerController to lock the MultiView camera.
var array<ViewInfo> RobotView;

// Variables used to replicate view assignment on client side.
var int delView, assView, lastAssView, lastDelView;
const NULL_VIEW = 1000; //Assigned to the replicated variables when not used. Necessary for replication.

//#########################################################
//                    MULTIVIEW CODE
//#########################################################


replication
{
    reliable if(Role == ROLE_Authority)
        assView, delView;
}

// Creates own camera and generates subview matrix.
// Standard mode (X & Y = divisions, N = num od cameras):
// N: 1 2 3 4 5 6 7 8 9 10 ...
// X: 1 2 2 2 3 3 3 3 3  4 ...
// Y: 1 1 2 2 2 2 3 3 3  3 ...
// Wide mode (i.e. with 4 columns):
// N: 1 2 3 4 5 6 7 8 9 10 ...
// X: 1 2 3 4 4 4 4 4 4  4 ...
// Y: 1 1 1 1 2 2 2 2 3  3 ...
simulated event PostNetBeginPlay()
{
    local SquadAI S;
    local bool divYupdate;    //defaults to false

    Super.PostNetBeginPlay();
    if (Role == ROLE_Authority) {
        S = spawn(class'SquadAI');
        S.SetLeader(Controller);
        S.AddBot(Bot(Controller));
    }

    // Mount camera
    myCamera = spawn(class'USARBot.RobotCamera', self,, Location, Rotation);
    myCamera.init("MultiView",self,Location,Rotation,none,'None');
    CameraZoom = myCamera.CameraFov;

    //Assigns a name to the controller
    if(PlayerReplicationInfo != none)
        PlayerReplicationInfo.PlayerName = "MultiView";

    //Configure Viewports
    Viewports.Num = Max(CameraNum,0);
    //Builds dynamically a viewport subdivision
    Viewports.divX = 1;
    Viewports.divY = 1;

    if(WideMode == 0)   //Auto subdivision
    {
        while(Viewports.divX * Viewports.divY < Viewports.Num)
        {
            if(divYupdate) Viewports.divY++;
                else Viewports.divX++;
            divYupdate = !divYupdate;
        }
    }
    else        //fixed columns subdivision
    {
        if(Viewports.Num <= WideMode)
        {
            Viewports.divX = Viewports.Num;
        }
        else
        {
            Viewports.divX = WideMode;
            Viewports.divY = Viewports.Num / WideMode;
        }
    }

    Viewports.moduleFactor = Viewports.divX;
    Aspect = float(CameraXres) / CameraYres;
    RobotView.Insert(0,Viewports.Num);

    assView = NULL_VIEW;
    delView = NULL_VIEW;
}

simulated event Destroyed()
{
    if (myCamera!=None) myCamera.Destroy();
    Super.Destroyed();
}
/*
simulated event SetInitialState()
{
    Super.SetInitialState();
    Enable('Tick');
}
*/
simulated function Tick(float Delta)
{
    Super.Tick(Delta);

    if (Role < ROLE_Authority)
    {
        if (assView!=lastAssView)
        {
            if(assView == NULL_VIEW)
                lastAssView = NULL_VIEW;
            else
            {
                RobotView[assView].assigned = True;
                RobotView[assView].isStereo = False;
            lastAssView = assView;
        }
        }
        if (delView!=lastDelView)
        {
            if(delView == NULL_VIEW)
                lastDelView = NULL_VIEW;
            else
            {
                DeleteView(delView);
            lastDelView = delView;
        }
    }
    }
    return;
}

///////////////////////////////////////////////////////////
//                 MultiView Functions                   //
///////////////////////////////////////////////////////////

// Assign a camera. Returns -1 if there are no more free cameras.
simulated function int RegisterView()
{
    local int i;

    //Assigns a view slot
    for(i = 0; i < Viewports.Num; i++)
        if(RobotView[i].assigned == False)
        {
            RobotView[i].assigned = True;
            RobotView[i].isStereo = False;
            assView = i;
            delView = NULL_VIEW;
            return i;
        }
    //Reports an error value if there are no more available views
    return -1;
}

//Frees a camera resource
simulated function DeleteView(int ViewNum)
{

    //Updates ViewRoster
    if((ViewNum >= 0) && (ViewNum < Viewports.Num))
    {
        RobotView[ViewNum].assigned = False;
        delView = viewNum;
        assView = NULL_VIEW;
    }
}

// Called by KRobot to update camera location and rotation.
// Every spawned robot that has registered successfully a view will call
// this function to update its camera coordinates. All these coordinates
// are then used in the DrawHud() function to draw each view.
simulated function UpdateView(int ViewNum, vector Location, rotator Rotation, int cameraFOV, optional bool stereo, optional vector spacing)
{
    if(ViewNum >=0 && ViewNum < Viewports.Num)
        if(RobotView[ViewNum].assigned)
        {
            RobotView[ViewNum].location = Location;
            RobotView[ViewNum].rotation = Rotation;
            RobotView[ViewNum].FOV = cameraFOV;
            RobotView[ViewNum].isStereo = stereo;
            RobotView[ViewNum].stereoSpacing = spacing;
        }
}

// Here we actually draw every view.
simulated function DrawHud(Canvas C)
{
    local int n;
    local int posX, posY;
    local float actualAspect;
    local int halfSizeY;
    local vector stereoRotated;

    if(Viewports.Num == 0) return;

    //Done at every frame to allow resizing of UT client window
    Viewports.deltaX = C.SizeX / Viewports.divX;
    Viewports.deltaY = C.SizeY / Viewports.divY;
    Viewports.Xres= Clamp(CameraXres,10,Viewports.deltaX);
    Viewports.Yres= Clamp(CameraYres,10,Viewports.deltaY);
    actualAspect = float(Viewports.Xres) / Viewports.Yres;
    //Corrects aspect ratio: mantains aspect ratio choosen with CameraXres and CameraYres
    //If X is shrink (by Clamp function) then shrink also Y
    //If Y is shrink (by Clamp function) then shrink also X
    if(actualAspect > Aspect)
       Viewports.Xres = Viewports.Yres * Aspect;
    else
       Viewports.Yres = Viewports.Xres / Aspect;

    C.Reset();              //Resets Canvas state variables
    C.Clear(false,true);    //Clears Z buffer only

    for(n = 0; n < Viewports.Num; n++)
    {
        if(RobotView[n].Assigned)
        {
            posX = Viewports.Xres * (n % Viewports.moduleFactor);
            posY = Viewports.Yres * (n / Viewports.moduleFactor);
            if(RobotView[n].isStereo)
            {
                halfSizeY = Viewports.Yres/2.0;
                stereoRotated =  RobotView[n].stereoSpacing >> RobotView[n].rotation;
                C.DrawPortal(posX, posY, Viewports.Xres, halfSizeY, myCamera,
                    RobotView[n].Location - stereoRotated, RobotView[n].Rotation, RobotView[n].FOV);
                C.DrawPortal(posX, posY + halfSizeY, Viewports.Xres, halfSizeY, myCamera,
                    RobotView[n].Location + stereoRotated, RobotView[n].Rotation, RobotView[n].FOV);
            }
            else
            {
                C.DrawPortal(posX, posY, Viewports.Xres, Viewports.Yres, myCamera,
                    RobotView[n].Location, RobotView[n].Rotation, RobotView[n].FOV);
            }
        }
    }
/*  //for debugging:
    C.SetDrawColor(255,255,255);
    C.DrawText("divX :"$Viewports.divX,true);
    C.DrawText("divY :"$Viewports.divY,true);
    C.DrawText("resX :"$Viewports.Xres,true);
    C.DrawText("resY :"$Viewports.Yres,true);
    C.DrawText("Aspect :"$Aspect,true);
    C.DrawText("moduleF :"$Viewports.moduleFactor,true);
    C.DrawText("View Num :"$Viewports.Num,true);
    C.DrawText("posX :"$posX,true);
    C.DrawText("posY :"$posY,true);
    C.DrawText("n :"$n,true);
*/
}

defaultproperties
{
    CameraNum=0    // 0 = no multiview
    WideMode=0     // 0 = automatic viewport subdivision
                   // n = fixed number of columns
    CameraXres=208
    CameraYres=160
    IsCameraLocked=False

    DrawType=DT_StaticMesh
    StaticMesh=StaticMesh'USARSim_Objects_Meshes.MultiView.Eye'
    ControllerClass=Class'USARBot.ViewBot'

    bNoDelete=false
    bStatic=false
    bStasis=false
    bCollideActors=false
    bAlwaysRelevant=true
    bSimulateGravity=False
    bSpecialHUD=True
    bNoTeamBeacon=True
    bCanUse=False
    bGameRelevant=True
    bCanTeleport=False
    bBlockActors=False
}