UserGeom.h

// ======================================================================== //
// Copyright 2019-2020 Ingo Wald                                            //
//                                                                          //
// 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.                                           //
// ======================================================================== //
 
#pragma once
 
#include "Geometry.h"
 
namespace owl {
 
  struct UserGeomType : public GeomType {
    typedef std::shared_ptr<UserGeomType> SP;
 
    struct DeviceData : public GeomType::DeviceData {
      typedef std::shared_ptr<DeviceData> SP;
 
      DeviceData(const DeviceContext::SP &device);
 
      void fillPGDesc(OptixProgramGroupDesc &pgDesc,
                      GeomType *gt,
                      int rayType) override;
 
      CUfunction boundsFuncKernel = 0;
 
      CUfunction motionBoundsFuncKernel = 0;
    };
 
    UserGeomType(Context *const context,
                 size_t varStructSize,
                 const std::vector<OWLVarDecl> &varDecls);
 
    void setIntersectProg(int rayType,
                          Module::SP module,
                          const std::string &progName);
    
    void setBoundsProg(Module::SP module,
                       const std::string &progName);
 
    void setMotionBoundsProg(Module::SP module,
                       const std::string &progName);
 
    void buildBoundsProg();
 
    void buildMotionBoundsProg();
 
    std::string toString() const override;
 
    virtual std::shared_ptr<Geom> createGeom() override;
 
    inline DeviceData &getDD(const DeviceContext::SP &device) const;
    
    RegisteredObject::DeviceData::SP createOn(const DeviceContext::SP &device) override;
 
    ProgramDesc boundsProg;
 
    ProgramDesc motionBoundsProg;
    
    std::vector<ProgramDesc> intersectProg;
  };
 
 
  struct UserGeom : public Geom {
    typedef std::shared_ptr<UserGeom> SP;
 
    struct DeviceData : public Geom::DeviceData {
      DeviceData(const DeviceContext::SP &device)
        : Geom::DeviceData(device)
      {};
 
      DeviceMemory internalBufferForBoundsProgram;
 
      DeviceMemory internalBufferForBoundsProgramKey1;
      DeviceMemory internalBufferForBoundsProgramKey2;
 
      DeviceMemory tempMem;
 
      /* if this is true, then the above buffers come from the user, and should not be 
        malloced/freed on tree rebuilds */
      bool useExternalBoundsBuffer = false;
    };
 
    UserGeom(Context *const context,
             GeomType::SP geometryType);
 
    RegisteredObject::DeviceData::SP createOn(const DeviceContext::SP &device) override;
 
    inline DeviceData &getDD(const DeviceContext::SP &device);
                        
    UserGeomType::DeviceData &getTypeDD(const DeviceContext::SP &device) const;
 
    std::string toString() const override;
 
    void setPrimCount(size_t count);
 
    void setBoundsBuffer(Buffer::SP buffer);
    
    void setMotionBoundsBuffers(Buffer::SP buffer1, Buffer::SP buffer2);
 
    void executeBoundsProgOnPrimitives(const DeviceContext::SP &device);
 
    void executeMotionBoundsProgOnPrimitives(const DeviceContext::SP &device);
 
    size_t primCount = 0;
  };
 
 
  // ------------------------------------------------------------------
  // implementation section
  // ------------------------------------------------------------------
  
  inline UserGeomType::DeviceData &
  UserGeomType::getDD(const DeviceContext::SP &device) const
  {
    assert(device && device->ID >= 0 && device->ID < (int)deviceData.size());
    return deviceData[device->ID]->as<UserGeomType::DeviceData>();
  }
 
  inline UserGeom::DeviceData &
  UserGeom::getDD(const DeviceContext::SP &device)
  {
    assert(device && device->ID >= 0 && device->ID < (int)deviceData.size());
    return deviceData[device->ID]->as<UserGeom::DeviceData>();
  }
 
  inline UserGeomType::DeviceData &
  UserGeom::getTypeDD(const DeviceContext::SP &device) const
  {
    return (UserGeomType::DeviceData &)type->getDD(device);
  }
} // ::owl