expmtlControl.h

Go to the documentation of this file.

/**********************************************************************
 *<
    FILE: expmtlControl.h

    DESCRIPTION: Classes to extend materials and shaders. These class
                 provide control over whether the exposure control
                 is to process the shaded values of the material,
                 and whether the material should use the exposure
                 control to convert self-illumination, reflection and
                 refraction from RGB to scaled physical values.

    CREATED BY: Cleve Ard

    HISTORY:

 *> Copyright (c) 2000, All Rights Reserved.
 **********************************************************************/
#pragma once

#include "ifnpub.h"
#include "imtl.h"

// =====================================================================
// Implementation classes
#define EXPOSURE_MATERIAL_CONTROL Interface_ID(0x153b0cbc, 0x5d6b0879)

//==============================================================================
// class ExposureMaterialControl

class ExposureMaterialControl : public FPMixinInterface {
public:
    enum {
        kGetNoExposureControl = 0,
        kSetNoExposureControl = 1,
        kGetInvertSelfIllum = 2,
        kSetInvertSelfIllum = 3,
        kGetInvertReflect = 4,
        kSetInvertReflect = 5,
        kGetInvertRefract = 6,
        kSetInvertRefract = 7
    };

    ExposureMaterialControl() :
        mNoExposure(false),
        mInvertSelfIllum(false),
        mInvertReflect(false),
        mInvertRefract(false) {}

    BEGIN_FUNCTION_MAP 
        PROP_FNS(kGetNoExposureControl, GetNoExposure,
            kSetNoExposureControl, SetNoExposure, TYPE_BOOL);
        PROP_FNS(kGetInvertSelfIllum, GetInvertSelfIllum,
            kSetInvertSelfIllum, SetInvertSelfIllum, TYPE_BOOL);
        PROP_FNS(kGetInvertReflect, GetInvertReflect,
            kSetInvertReflect, SetInvertReflect, TYPE_BOOL);
        PROP_FNS(kGetInvertRefract, GetInvertRefract,
            kSetInvertRefract, SetInvertRefract, TYPE_BOOL);
    END_FUNCTION_MAP 

    BOOL GetNoExposure() const { return mNoExposure; }

    virtual void SetNoExposure(BOOL on) { mNoExposure = on != 0; }

    BOOL GetInvertSelfIllum() const { return mInvertSelfIllum; }

    virtual void SetInvertSelfIllum(BOOL on) { mInvertSelfIllum = on != 0; }

    BOOL GetInvertReflect() const { return mInvertReflect; }

    virtual void SetInvertReflect(BOOL on) { mInvertReflect = on != 0; }

    BOOL GetInvertRefract() const { return mInvertRefract; }

    virtual void SetInvertRefract(BOOL on) { mInvertRefract = on != 0; }

    ULONG isNoExposure() const { return mNoExposure ? MTLREQ_NOEXPOSURE : 0; }
    bool isInvertSelfIllum() const { return !mNoExposure & mInvertSelfIllum; }
    bool isInvertReflect() const { return !mNoExposure & mInvertReflect; }
    bool isInvertRefract() const { return !mNoExposure & mInvertRefract; }

    IOResult Save(ISave* isave);
    
    IOResult Load(ILoad* iload);

protected:
    enum {
        DATA_CHUNK = 0x322
    };

    IOResult write(ISave* isave, bool& b);
    IOResult read(ILoad* iload, bool& b);

    bool                mNoExposure;
    bool                mInvertSelfIllum;
    bool                mInvertReflect;
    bool                mInvertRefract;
};

inline IOResult ExposureMaterialControl::Save(ISave* isave)
{
    isave->BeginChunk(DATA_CHUNK);
    IOResult res;
    if ((res = write(isave, mNoExposure)) == IO_OK
            && (res = write(isave, mInvertSelfIllum)) == IO_OK
            && (res = write(isave, mInvertReflect)) == IO_OK)
        res = write(isave, mInvertRefract);
    isave->EndChunk();
    return res;
}

inline IOResult ExposureMaterialControl::Load(ILoad* iload)
{
    IOResult res;
    USHORT id;
    while (IO_OK==(res=iload->OpenChunk())) {
        switch(id = iload->CurChunkID())  {
        case DATA_CHUNK:
            if ((res = read(iload, mNoExposure)) == IO_OK
                    && (res = read(iload, mInvertSelfIllum)) == IO_OK
                    && (res = read(iload, mInvertReflect)) == IO_OK)
                res = read(iload, mInvertRefract);
            break;
        }

        iload->CloseChunk();
        if (res!=IO_OK) 
            return res;
    }
    return IO_OK;
}

inline IOResult ExposureMaterialControl::write(ISave* isave, bool& b)
{
    DWORD n;
    IOResult res = isave->Write(&b, sizeof(b), &n);
    if (res != IO_OK)
        return res;
    return n == sizeof(b) ? IO_OK : IO_ERROR;
}

inline IOResult ExposureMaterialControl::read(ILoad* iload, bool& b)
{
    DWORD n;
    IOResult res = iload->Read(&b, sizeof(b), &n);
    if (res != IO_OK)
        return res;
    return n == sizeof(b) ? IO_OK : IO_ERROR;
}


inline ExposureMaterialControl* GetExposureMaterialControl(InterfaceServer* mtl)
{
    return static_cast<ExposureMaterialControl*>(
        mtl->GetInterface(EXPOSURE_MATERIAL_CONTROL));
}

//==========================================================================================

class ExposureMaterialControlDesc : public FPInterfaceDesc {
public:
    ExposureMaterialControlDesc(
        ClassDesc& cd,
        int         idsDescrString,
        int         idsNoExposureString,
        int         idsInvertSelfIllumString,
        int         idsInvertReflectString,
        int         idsInvertRefractString
    ) :
        FPInterfaceDesc(EXPOSURE_MATERIAL_CONTROL, _M("ExposureMaterialControl"),
                idsDescrString, &cd, FP_MIXIN,
            properties,
                ExposureMaterialControl::kGetNoExposureControl,
                    ExposureMaterialControl::kSetNoExposureControl, _M("noExposureControl"),
                    idsNoExposureString, TYPE_BOOL,
                ExposureMaterialControl::kGetInvertSelfIllum,
                    ExposureMaterialControl::kSetInvertSelfIllum, _M("exposureControlInvertSelfIllum"),
                    idsInvertSelfIllumString, TYPE_BOOL,
                ExposureMaterialControl::kGetInvertReflect,
                    ExposureMaterialControl::kSetInvertReflect, _M("exposureControlInvertReflection"),
                    idsInvertReflectString, TYPE_BOOL,
                ExposureMaterialControl::kGetInvertRefract,
                    ExposureMaterialControl::kSetInvertRefract, _M("exposureControlInvertRefraction"),
                    idsInvertRefractString, TYPE_BOOL,
            end) {}
}; 

template<class T, class B> class ExposureMaterialControlImp : public B
{
public:
    // Visual Studio has problem with using B::GetInterface
    // This workaround is to define GetInterface(ULONG id)
    // rather than using B::GetInterface. 
    void* GetInterface(ULONG id) { return B::GetInterface(id); }

    BaseInterface* GetInterface(Interface_ID id) {
        if (id == EXPOSURE_MATERIAL_CONTROL)
            return static_cast<ExposureMaterialControl*>(this);
        return B::GetInterface(id);
    }

    FPInterfaceDesc* GetDesc() { return &T::msExpMtlControlDesc; }

private:
};

template<class B> class AddExposureMaterialControl : public B, public ExposureMaterialControl
{
public:
    using B::GetInterface;
};