cpuSmoothNormalContext.h

Go to the documentation of this file.

//
//   Copyright 2013 Pixar
//
//   Licensed under the Apache License, Version 2.0 (the "Apache License")
//   with the following modification; you may not use this file except in
//   compliance with the Apache License and the following modification to it:
//   Section 6. Trademarks. is deleted and replaced with:
//
//   6. Trademarks. This License does not grant permission to use the trade
//      names, trademarks, service marks, or product names of the Licensor
//      and its affiliates, except as required to comply with Section 4(c) of
//      the License and to reproduce the content of the NOTICE file.
//
//   You may obtain a copy of the Apache License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the Apache License with the above modification is
//   distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
//   KIND, either express or implied. See the Apache License for the specific
//   language governing permissions and limitations under the Apache License.
//

#ifndef OSD_CPU_SMOOTHNORMAL_CONTEXT_H
#define OSD_CPU_SMOOTHNORMAL_CONTEXT_H

#include "../version.h"

#include "../osd/nonCopyable.h"
#include "../osd/vertexDescriptor.h"
#include "../osd/vertex.h"

#include "../far/patchTables.h"

namespace OpenSubdiv {
namespace OPENSUBDIV_VERSION {

namespace Osd {

class CpuSmoothNormalContext :  private NonCopyable<CpuSmoothNormalContext> {

public:

    static CpuSmoothNormalContext * Create(
        Far::PatchTables const *patchTables, bool resetMemory=false);

    template<class VERTEX_BUFFER>
    void Bind(VERTEX_BUFFER * in, int iOfs,
              VERTEX_BUFFER * out, int oOfs) {

        assert( ((iOfs+3)<=in->GetNumElements()) and
            ((oOfs+3)<=out->GetNumElements()) and
            out->GetNumVertices()>=in->GetNumVertices());

        _iBuffer = in ? in->BindCpuBuffer() : 0;
        _oBuffer = out ? out->BindCpuBuffer() : 0;

        _iDesc = VertexBufferDescriptor( iOfs, 3, in->GetNumElements() );
        _oDesc = VertexBufferDescriptor( oOfs, 3, out->GetNumElements() );

        _numVertices = out->GetNumVertices();
    }

    void Unbind() {

        _iBuffer = _oBuffer = 0;
        _iDesc.Reset();
        _oDesc.Reset();
        _numVertices = 0;
    }

    const Far::PatchTables::PatchArrayVector & GetPatchArrayVector() const {
        return _patchArrays;
    }

    const std::vector<unsigned int> & GetControlVertices() const {
        return _patches;
    }

    float const * GetCurrentInputVertexBuffer() const {
        return _iBuffer;
    }

    float * GetCurrentOutputVertexBuffer() {
        return _oBuffer;
    }

    VertexBufferDescriptor const & GetInputVertexDescriptor() const {
        return _iDesc;
    }

    VertexBufferDescriptor const & GetOutputVertexDescriptor() const {
        return _oDesc;
    }

    int GetNumVertices() const {
        return _numVertices;
    }

    bool GetResetMemory() const {
        return _resetMemory;
    }

    void SetResetMemory(bool resetMemory) {
        _resetMemory = resetMemory;
    }

protected:
    // Constructor
    explicit CpuSmoothNormalContext(
        Far::PatchTables const *patchTables, bool resetMemory);

private:

    // Topology data for a mesh
    Far::PatchTables::PatchArrayVector     _patchArrays;    // patch descriptor for each patch in the mesh
    Far::PatchTables::PTable               _patches;        // patch control vertices

    VertexBufferDescriptor _iDesc,
                              _oDesc;

    int _numVertices;

    float * _iBuffer,
          * _oBuffer;

    bool _resetMemory;  // set to true if the output buffer needs to be reset to 0
};


}  // end namespace Osd

}  // end namespace OPENSUBDIV_VERSION
using namespace OPENSUBDIV_VERSION;

}  // end namespace OpenSubdiv

#endif  // OSD_CPU_SMOOTHNORMAL_CONTEXT_H