Context.h

// ======================================================================== //
// Copyright 2019-2021 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 "DeviceContext.h"
#include "ObjectRegistry.h"
#include "Buffer.h"
#include "Texture.h"
#include "Group.h"
#include "RayGen.h"
#include "LaunchParams.h"
#include "MissProg.h"
 
namespace owl {
 
  struct Context : public Object {
 
    typedef std::shared_ptr<Context> SP;
 
    inline static bool logging()
    {
#ifdef NDEBUG
      return false;
#else
      return true;
#endif
    }
 
    virtual std::string toString() const override { return "owl::Context"; }
 
    Context(int32_t *requestedDeviceIDs,
            int      numRequestedDevices);
 
    virtual ~Context();
 
    size_t deviceCount() const { return getDevices().size(); }
    const std::vector<DeviceContext::SP> &getDevices() const { return devices; }
    DeviceContext::SP getDevice(int ID) const
    { assert(ID >= 0 && ID < (int)devices.size()); return devices[ID]; }
 
    void buildHitGroupRecordsOn(const DeviceContext::SP &device);
    void buildRayGenRecordsOn(const DeviceContext::SP &device);
    void buildMissProgRecordsOn(const DeviceContext::SP &device);
 
    void setRayTypeCount(size_t rayTypeCount);
 
    void setBoundLaunchParamValues(const std::vector<OWLBoundValueDecl> &boundValues);
    
    void enableMotionBlur();
    
    void enableCurves();
    
    void enableSpheres();
 
    void disablePerGeometrySBTRecords();
    
    void setMaxInstancingDepth(int32_t maxInstanceDepth);
 
    /* Set number of attributes for passing data from custom Intersection programs
       to ClosestHit programs.  Default 2.  Has no effect once programs are built.*/
    void setNumAttributeValues(size_t numAttributeValues);
 
    /* Set number of payload values for passing data between programs. Default 2.  
    Has no effect once programs are built.*/
    void setNumPayloadValues(size_t numPayloadValues);
 
    // ------------------------------------------------------------------
    // internal mechanichs/plumbling that do the actual work
    // ------------------------------------------------------------------
    
    void buildSBT(OWLBuildSBTFlags flags);
    void buildPipeline();
    void buildPrograms(bool debug = false);
    void destroyPrograms();
    void buildModules(bool debug = false);
    void destroyModules();
 
 
    // ------------------------------------------------------------------
    // factory methods to create objects within this context
    // ------------------------------------------------------------------
 
    Texture::SP
    texture2DCreate(OWLTexelFormat texelFormat,
                    OWLTextureFilterMode filterMode,
                    OWLTextureAddressMode addressMode,
                    OWLTextureColorSpace colorSpace,
                    const vec2i size,
                    uint32_t linePitchInBytes,
                    const void *texels);
 
    GeomGroup::SP
    trianglesGeomGroupCreate(size_t numChildren, unsigned int buildFlags);
    
    GeomGroup::SP
    curvesGeomGroupCreate(size_t numChildren, unsigned int buildFlags);
    
    GeomGroup::SP
    userGeomGroupCreate(size_t numChildren, unsigned int buildFlags);
    
    GeomGroup::SP
    sphereGeomGroupCreate(size_t numChildren, unsigned int buildFlags);
 
    Buffer::SP
    deviceBufferCreate(OWLDataType type,
                       size_t count,
                       const void *init);
 
    Buffer::SP
    hostPinnedBufferCreate(OWLDataType type,
                           size_t count);
    
    Buffer::SP
    managedMemoryBufferCreate(OWLDataType type,
                              size_t count,
                              const void *init);
 
    Buffer::SP
    graphicsBufferCreate(OWLDataType type,
                         size_t count,
                         cudaGraphicsResource_t resource);
 
    
    RayGenType::SP
    createRayGenType(Module::SP module,
                     const std::string &progName,
                     size_t varStructSize,
                     const std::vector<OWLVarDecl> &varDecls);
 
    RayGen::SP
    createRayGen(const std::shared_ptr<RayGenType> &type);
    
    LaunchParamsType::SP
    createLaunchParamsType(size_t varStructSize,
                           const std::vector<OWLVarDecl> &varDecls);
    
    LaunchParams::SP
    createLaunchParams(const std::shared_ptr<LaunchParamsType> &type);
    
    MissProgType::SP
    createMissProgType(Module::SP module,
                       const std::string &progName,
                       size_t varStructSize,
                       const std::vector<OWLVarDecl> &varDecls);
 
    MissProg::SP
    createMissProg(const std::shared_ptr<MissProgType> &type);
 
    void setMissProg(int rayTypeToSet, MissProg::SP missProgToUse);
    
    GeomType::SP
    createGeomType(OWLGeomKind kind,
                   size_t varStructSize,
                   const std::vector<OWLVarDecl> &varDecls);
    
    Module::SP
    createModule(const std::string &ptxCode);
 
    Module::SP
    createModule(const std::vector<uint8_t> &IR);
 
    // ------------------------------------------------------------------
    // member variables
    // ------------------------------------------------------------------
 
    ObjectRegistryT<Buffer>       buffers;
    ObjectRegistryT<Texture>      textures;
    ObjectRegistryT<Group>        groups;
    ObjectRegistryT<RayGenType>   rayGenTypes;
    ObjectRegistryT<RayGen>       rayGens;
    ObjectRegistryT<MissProgType> missProgTypes;
    ObjectRegistryT<MissProg>     missProgs;
    ObjectRegistryT<GeomType>     geomTypes;
    ObjectRegistryT<Geom>         geoms;
    ObjectRegistryT<Module>       modules;
    ObjectRegistryT<LaunchParamsType> launchParamTypes;
    ObjectRegistryT<LaunchParams>     launchParams;
    RangeAllocator sbtRangeAllocator;
 
    std::vector<MissProg::SP> missProgPerRayType;
 
    int maxInstancingDepth = 1;
 
    bool perGeometrySBTRecordsDisabled = false;
 
    int numRayTypes { 1 };
 
#if OPTIX_VERSION >= 70200
    std::vector<OptixModuleCompileBoundValueEntry> boundLaunchParamValues;
#endif
    
    bool motionBlurEnabled = false;
 
    bool curvesEnabled = false;
 
    bool spheresEnabled = false;
 
    /* Number of attributes for writing data between Intersection and ClosestHit */
    int numAttributeValues = 2;
 
    /* Number of payload values to request for passing data between RT programs */
    int numPayloadValues = 2;
 
    LaunchParams::SP dummyLaunchParams;
 
  private:
    void enablePeerAccess();
    std::vector<DeviceContext::SP> devices;
  };
 
} // ::owl