---

Avars.cc

Go to the documentation of this file.

/*
    File:           Avars.cc

    Function:       See header file

    Author(s):      Andrew Willmott

    Copyright:      (c) 1995-2000, Andrew Willmott

    Notes:          'Avar' is defined in Scene.cc

*/

#include "gcl/Avars.h"
#include "cl/CLConfig.h"

Void ReadAvar(Avar &a, istream &s);


// --- Transformation avars ---------------------------------------------------

scAvarTransform::scAvarTransform(const Avar &avar, Vector vector) : 
    scTransform(),
    avar(avar),
    listSlot(-1),
    vector(vector)
{
    Recalc();
};

Bool scAvarTransform::HasAvar(Avar &setAvar, Int slot)
{
    setAvar = avar;
    listSlot = slot;

    return(true);
}

#ifdef UNFINISHED
Bool scAvarTransform::HasAvar(Avar &setAvar, Int slot)
{
    setAvar = avar;
    listSlot = slot;

    return(true);
}
#endif

Void scAvarTransform::AddToContext(SLContext *context)
{
    AvarList    *avarList;
    GCLReal     newValue;
    
    if (avarList = SC_GET(AvarList))
    {
        newValue = (*avarList)[listSlot].value;
    
        if (newValue != avar.value)
        {
            avar.value = newValue;
            Recalc();
        }
    }
    
    scTransform::AddToContext(context);
}

Void scAvarShift::Recalc()
{
    (Transform &) SELF = Shift(vector * avar.value);
}

Void scAvarShift::Print(ostream &s) const
{
    s << "avar shift " << avar << " " << vector;
}

Void ReadAvar(Avar &a, istream &s)
{
    String *str = new String;
    Vector v;
    
    str->ReadWord(s);
    a.name = str->Ref();
    s >> v;
    a.lowerBound = v[0];
    a.value = v[1];
    a.upperBound = v[2];
}

Void scAvarShift::Parse(istream &s)
{
    ReadAvar(avar, s);
    s >> vector; 
    Recalc();
}

Void scAvarRotation::Recalc()
{
    (scTransform &) SELF = Rotation(vector, avar.value * vl_pi);
}

Void scAvarRotation::Print(ostream &s) const
{
    s << "avar rotate " << avar << " " << vector;
}

Void scAvarRotation::Parse(istream &s)
{
    ReadAvar(avar, s);
    s >> vector; 
    Recalc();
}

Void scAvarScale::Recalc()
{
    Vector scale(vector);
    Int i;
    
    for (i = 0; i < 3; i++)
        if (scale[i] == 0)
            scale[i] = 1;
        else
            scale[i] *= avar.value;
    
    (Transform &) SELF = Scale(scale);
}

Void scAvarScale::Print(ostream &s) const
{
    s << "avar scale " << avar << " " << vector;
}

Void scAvarScale::Parse(istream &s)
{
    ReadAvar(avar, s);
    s >> vector; 
    Recalc();
}

scAvarScalef::scAvarScalef(const Avar &avar) :
    scTransform(),
    avar(avar),
    listSlot(-1)
{
}

Void scAvarScalef::Recalc()
{
    (Transform &) SELF = Scalef(avar.value);
}

Bool scAvarScalef::HasAvar(Avar &setAvar, Int slot)
{
    setAvar = avar;

    listSlot = slot;

    return(true);
}

Void scAvarScalef::AddToContext(SLContext *context)
{
    AvarList    *avarList;
    
    if (avarList = SC_GET(AvarList))
        avar.value = (*avarList)[listSlot].value;
    
    Recalc();
    
    scTransform::AddToContext(context);
}

Void scAvarScalef::Print(ostream &s) const
{
    s << "avar scalef " << avar;
}

Void scAvarScalef::Parse(istream &s)
{
    ReadAvar(avar, s);
    Recalc();
}


// --- Colour avar ------------------------------------------------------------


scAvarColour::scAvarColour(const Avar &avar, Colour colour) : 
    scColour(),
    avar(avar), 
    listSlot(-1),
    colour(colour)
{
}

Void scAvarColour::Recalc()
{
    (Colour &) SELF = colour * avar.value;
}

Bool scAvarColour::HasAvar(Avar &setAvar, Int slot)
{
    setAvar = avar;

    listSlot = slot;

    return(true);
}

Void scAvarColour::AddToContext(SLContext *context)
{
    AvarList    *avarList;
    
    if (avarList = SC_GET(AvarList))
        avar.value = (*avarList)[listSlot].value;
    
    Recalc();
    
    scColour::AddToContext(context);
}

Void scAvarColour::Print(ostream &s) const
{
    s << "avar colour " << avar << " " << colour;
}

Void scAvarColour::Parse(istream &s)
{
    ReadAvar(avar, s);
    s >> colour; 
    Recalc();
}


// --- Emittance avar ---------------------------------------------------------


scAvarEmittance::scAvarEmittance(const Avar &avar, Colour colour) :
    scEmittance(),
    avar(avar),
    listSlot(-1),
    colour(colour)
{
}

Void scAvarEmittance::Recalc()
{
    (Colour &) SELF = colour * avar.value;
}

Bool scAvarEmittance::HasAvar(Avar &setAvar, Int slot)
{
    setAvar = avar;

    listSlot = slot;

    return(true);
}

Void scAvarEmittance::AddToContext(SLContext *context)
{
    AvarList    *avarList;
    
    if (avarList = SC_GET(AvarList))
        avar.value = (*avarList)[listSlot].value;
    
    Recalc();
    
    scEmittance::AddToContext(context);
}

Void scAvarEmittance::Print(ostream &s) const
{
    s << "avar emittance " << avar << " " << colour;
}

Void scAvarEmittance::Parse(istream &s)
{
    ReadAvar(avar, s);
    s >> colour; 
    Recalc();
}


// --- Emittance avar ---------------------------------------------------------


scAvarSwitch::scAvarSwitch(const Avar &avar) : 
    scAttribute(aObjHide),
    avar(avar),
    listSlot(-1)
{
}

Bool scAvarSwitch::HasAvar(Avar &setAvar, Int slot)
{
    setAvar = avar;

    listSlot = slot;

    return(true);
}

Void scAvarSwitch::AddToContext(SLContext *context)
{
    AvarList    *avarList;
    
    if (avarList = SC_GET(AvarList))
        avar.value = (*avarList)[listSlot].value;
    
    if (avar.value < 0.5)
        scAttribute::AddToContext(context);
}

Void scAvarSwitch::Print(ostream &s) const
{
    s << "avar switch " << avar;
}

Void scAvarSwitch::Parse(istream &s)
{
    ReadAvar(avar, s);
}


// --- scAvarList --------------------------------------------

Void scAvarList::Print(ostream &s) const
{
// XXX
//  s << "avarList " << (AvarList &) SELF;
}

Bool scAvarList::SetAvar(StrConst name, GCLReal value)
{
    Int i;
    
    for (i = 0; i < NumItems(); i++)
        if (Item(i).name == name)
        {
            Item(i).value = value;
            return(true);
        }
    return(false);
}

#ifdef UNFINISHED
Int scAvarList::AddAvar(StrConst name, Int numElts)
{
    
}
#endif


// --- Action to build avar list ----------------------------------------------


Void CreateAvarList::Start()
{
    scSceneAction::Start();
    delete avarList;
    avarList = new scAvarList;
}

Void CreateAvarList::Attribute(scAttribute *sa)
{
    scSceneAction::Attribute(sa);
    if (sa->HasAvar(newAvar, avarList->NumItems()))
        avarList->Append(newAvar);
}

#ifdef CL_TMPL_INST
template class Array<Avar>;
#endif

---