HUSD_MirrorRootLayer.h

Go to the documentation of this file.

/*
 * Copyright 2019 Side Effects Software Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

#ifndef __HUSD_MirrorRootLayer_h__
#define __HUSD_MirrorRootLayer_h__

#include "HUSD_API.h"
#include <UT/UT_FloatArray.h>
#include <UT/UT_Matrix4.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_UniquePtr.h>
#include <UT/UT_ValArray.h>
#include <pxr/pxr.h>

class UT_JSONWriter;

PXR_NAMESPACE_OPEN_SCOPE

class XUSD_MirrorRootLayerData;

PXR_NAMESPACE_CLOSE_SCOPE

class HUSD_DataHandle;
class HUSD_TimeCode;

// This class contains content that should be copied to the root layer of a
// mirrored HUSD_Datahandle. This is separate from teh HUSD_Overrides session
// layers, because those can be enabled or disabled by user preference. The
// data in this layer must always exist, and is makes sense to allow it to be
// overridden by the data in the HUSD_Overrides, so we put it into the root
// layer of the mirrored stage.
//
// For now this root layer holds the USD camera primitive used when free
// tumbling in the viewport. This camera can either be a default camera or
// a reference to an existing camera, with modifications to the transforms.
class HUSD_API HUSD_MirrorRootLayer
{
public:
     HUSD_MirrorRootLayer(const UT_StringRef &freecamsavepath = UT_StringRef());
    ~HUSD_MirrorRootLayer();

    void                         clear();
    PXR_NS::XUSD_MirrorRootLayerData &data() const;

    class CameraParms
    {
    public:
        UT_DMatrix4              myXform;
        fpreal                   myFocalLength = 50.0;
        fpreal                   myHAperture = 41.4214;
        fpreal                   myHApertureOffset = 0.0;
        fpreal                   myVAperture = 41.4214;
        fpreal                   myVApertureOffset = 0.0;
        fpreal                   myNearClip = 0.1;
        fpreal                   myFarClip = 10000.0;
        bool                     myIsOrtho = false;
        bool                     mySetCamParms = true;
        bool                     myDoCamEffects = true;
        bool                     mySetCropParms = false;
        bool                     myPreserveDepthOfField = false;

        // We only need to add time sampled transforms if we
        // are looking through a camera with a render region.
        // Eventually it would be good for this to go away if the
        // render region gets implemented as a data window instead
        // of using the free camera.
        UT_Array<UT_DMatrix4>    myXformSamples;
        UT_FloatArray            myXformSampleTimes;

        void            dump() const;
        void            dump(UT_JSONWriter &w) const;
    };

    // Configure a USD camera primitive for use in the viewport.
    void                 createViewportCamera(
                                const HUSD_DataHandle &datahandle,
                                const UT_StringRef &refcamera,
                                const CameraParms &camparms,
                                const HUSD_TimeCode &timecode);

private:
    UT_UniquePtr<PXR_NS::XUSD_MirrorRootLayerData>   myData;
    bool                                             myViewportCameraCreated;
};

extern HUSD_API size_t
format(char *buf, size_t sz, const HUSD_MirrorRootLayer::CameraParms &p);

#endif