mirror of
https://github.com/PixarAnimationStudios/OpenSubdiv
synced 2024-12-12 12:00:11 +00:00
181 lines
5.5 KiB
C++
181 lines
5.5 KiB
C++
//
|
|
// 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.
|
|
//
|
|
|
|
#pragma once
|
|
#ifndef OPENSUBDIV3_OSD_CPU_SMOOTHNORMAL_CONTEXT_H
|
|
#define OPENSUBDIV3_OSD_CPU_SMOOTHNORMAL_CONTEXT_H
|
|
|
|
#include "../version.h"
|
|
|
|
#include "../osd/nonCopyable.h"
|
|
#include "../osd/vertexDescriptor.h"
|
|
#include "../far/types.h"
|
|
|
|
#include <vector>
|
|
|
|
namespace OpenSubdiv {
|
|
namespace OPENSUBDIV_VERSION {
|
|
|
|
namespace Far {
|
|
class TopologyRefiner;
|
|
}
|
|
|
|
namespace Osd {
|
|
|
|
class CpuSmoothNormalContext : private NonCopyable<CpuSmoothNormalContext> {
|
|
|
|
public:
|
|
|
|
/// Creates an CpuComputeContext instance
|
|
///
|
|
/// @param refiner The uniformly refined Far::TopologyRefiner
|
|
///
|
|
/// @param level Refinement level used to generate normals
|
|
///
|
|
/// @param resetMemory Set to true if the target vertex buffer needs its
|
|
/// memory reset before accumulating the averaged normals.
|
|
/// If the SmoothNormal Controller runs after a Computer
|
|
/// Controller, then the vertex buffer will already have
|
|
/// been reset and this step can be skipped to save time.
|
|
///
|
|
static CpuSmoothNormalContext * Create(
|
|
Far::TopologyRefiner const & refiner, int level, bool resetMemory=false);
|
|
|
|
/// Binds a vertex and a varying data buffers to the context. Binding ensures
|
|
/// that data buffers are properly inter-operated between Contexts and
|
|
/// Controllers operating across multiple devices.
|
|
///
|
|
/// @param in a buffer containing input vertex-interpolated primvar data
|
|
///
|
|
/// @param iOfs offset to the buffer element describing the vertex position
|
|
///
|
|
/// @param out a buffer where the smooth normals will be output
|
|
///
|
|
/// @param oOfs offset to the buffer element describing the normal position
|
|
///
|
|
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();
|
|
}
|
|
|
|
/// Unbinds any previously bound vertex and varying data buffers.
|
|
void Unbind() {
|
|
|
|
_iBuffer = _oBuffer = 0;
|
|
_iDesc.Reset();
|
|
_oDesc.Reset();
|
|
_numVertices = 0;
|
|
}
|
|
|
|
Far::Index const * GetFaceVertices() const {
|
|
return &_faceVerts[0];
|
|
}
|
|
|
|
|
|
int GetNumFaces() const {
|
|
return (int)_faceVerts.size()/4;
|
|
}
|
|
|
|
/// Returns the number of vertices in output vertex buffer
|
|
int GetNumVertices() const {
|
|
return _numVertices;
|
|
}
|
|
|
|
|
|
/// Returns a pointer to the data of the input buffer
|
|
float const * GetCurrentInputVertexBuffer() const {
|
|
return _iBuffer;
|
|
}
|
|
|
|
/// Returns a pointer to the data of the output buffer
|
|
float * GetCurrentOutputVertexBuffer() {
|
|
return _oBuffer;
|
|
}
|
|
|
|
/// Returns an VertexDescriptor for the input vertex data
|
|
VertexBufferDescriptor const & GetInputVertexDescriptor() const {
|
|
return _iDesc;
|
|
}
|
|
|
|
/// Returns an VertexDescriptor for the buffer where the normals data
|
|
/// will be stored
|
|
VertexBufferDescriptor const & GetOutputVertexDescriptor() const {
|
|
return _oDesc;
|
|
}
|
|
|
|
/// Returns whether the controller needs to reset the vertex buffer before
|
|
/// accumulating smooth normals
|
|
bool GetResetMemory() const {
|
|
return _resetMemory;
|
|
}
|
|
|
|
/// Set to true if the controller needs to reset the vertex buffer before
|
|
/// accumulating smooth normals
|
|
void SetResetMemory(bool resetMemory) {
|
|
_resetMemory = resetMemory;
|
|
}
|
|
|
|
protected:
|
|
// Constructor
|
|
explicit CpuSmoothNormalContext(Far::TopologyRefiner const & refiner,
|
|
int level, bool resetMemory);
|
|
|
|
private:
|
|
|
|
// Topology data for a mesh
|
|
std::vector<Far::Index> _faceVerts; // 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 // OPENSUBDIV3_OSD_CPU_SMOOTHNORMAL_CONTEXT_H
|