Geometry.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 "RegisteredObject.h"
#include "SBTObject.h"
#include "Module.h"
#include "Buffer.h"
 
namespace owl {
 
  struct Geom;
 
  struct ProgramDesc {
    Module::SP  module;
    std::string progName;
  };
 
  /* abstraction for any sort of geometry type - describes the
     programs to use, and structure of the SBT records, when building
     shader binding tables (SBTs) with geometries of this type. This
     will later get subclassed into triangle geometries, user/custom
     primtivie geometries, etc */
  struct GeomType : public SBTObjectType {
    typedef std::shared_ptr<GeomType> SP;
    
    struct DeviceData : public RegisteredObject::DeviceData {
      typedef std::shared_ptr<DeviceData> SP;
 
      DeviceData(const DeviceContext::SP &device);
 
      void buildHitGroupPrograms(GeomType *gt);
      
      virtual void fillPGDesc(OptixProgramGroupDesc &pgDesc,
                              GeomType *gt, int rayType);
      
      std::vector<OptixProgramGroup> hgPGs;
    };
 
    GeomType(Context *const context,
             size_t varStructSize,
             const std::vector<OWLVarDecl> &varDecls);
    
    std::string toString() const override;
 
    inline DeviceData &getDD(const DeviceContext::SP &device) const;
 
    RegisteredObject::DeviceData::SP createOn(const DeviceContext::SP &device) override;
    
    virtual std::shared_ptr<Geom> createGeom() = 0;
 
    void setAnyHitProgram(int rayType,
                          Module::SP module,
                          const std::string &progName);
    
    void setClosestHitProgram(int rayType,
                              Module::SP module,
                              const std::string &progName);
 
    std::vector<ProgramDesc> closestHit;
    
    std::vector<ProgramDesc> anyHit;
  };
 
  struct Geom : public SBTObject<GeomType> {
    typedef std::shared_ptr<Geom> SP;
 
    Geom(Context *const context, GeomType::SP geomType);
    
    std::string toString() const override;
 
    void writeSBTRecord(
                        uint8_t *const sbtRecord,
                        const DeviceContext::SP &device,
                        int rayTypeID);
 
    GeomType::SP geomType;
  };
  
  // ------------------------------------------------------------------
  // implementation section
  // ------------------------------------------------------------------
  
  inline GeomType::DeviceData &GeomType::getDD(const DeviceContext::SP &device) const
  {
    assert(device && device->ID >= 0 && device->ID < (int)deviceData.size());
    return deviceData[device->ID]->as<DeviceData>();
  }
  
} // ::owl