ai_shader_util.h

Go to the documentation of this file.

// Copyright 2025 Autodesk, Inc.  All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
 
#pragma once
#include "ai_bbox.h"
#include "ai_color.h"
#include "ai_vector.h"
#include "ai_api.h"
#include "ai_shaderglobals.h"
 
// forward declaration
struct AtSampler;
struct AtNode;
 
#define AI_WORLD_TO_OBJECT  1 
#define AI_OBJECT_TO_WORLD  2 
/* \}*/
 
#define AI_WIREFRAME_TRIANGLES            0   
#define AI_WIREFRAME_POLYGONS             1   
#define AI_WIREFRAME_PATCHES              2   
/* \}*/
 
AI_API AI_DEVICE AI_GPU_FORCE_INLINE AtRGB      AiOcclusion(const AtVector& N, const AtVector& Ng, AtShaderGlobals* sg, float mint, float maxt, float spread, float falloff, const AtSampler* sampler, AtVector* Nbent);
AI_API AI_DEVICE AI_GPU_FORCE_INLINE AtRGB      AiSelfOcclusion(const AtVector& N, const AtVector& Ng, AtShaderGlobals* sg, float mint, float maxt, float spread, float falloff, const AtSampler* sampler, AtVector* Nbent);
AI_API                               AtRGB      AiDirectDiffuse(const AtVector& N, AtShaderGlobals* sg);
AI_API                               AtRGB      AiIndirectDiffuse(const AtVector& N, AtShaderGlobals* sg, const AtRGB& weight);
/* \} */
 
AI_API AI_DEVICE AtVector   AiReflect(const AtVector& I, const AtVector& N);
AI_API           AtVectorDv AiReflectWithDerivs(const AtVectorDv& I, const AtVectorDv& N);
AI_API AI_DEVICE AtVector   AiReflectSafe(const AtVector& I, const AtVector& N, const AtVector& Ng);
AI_API AI_DEVICE bool       AiRefract(const AtVector& I, const AtVector& N, AtVector& T, float n1, float n2);
AI_API           bool       AiRefractWithDerivs(const AtVectorDv& I, const AtVectorDv& N, AtVectorDv& T, float n1, float n2);
 
AI_API AI_DEVICE AI_CONST float AiSchlickFresnel(const AtVector& N, const AtVector& Rd, float Krn);
AI_API AI_CONST AtRGB      AiSchlickFresnelRGB(const AtVector& N, const AtVector& Rd, const AtRGB& Krn);
AI_API AI_CONST AtRGB      AiConductorFresnel(const AtVector& N, const AtVector& Rd, const AtRGB& n, const AtRGB& k);
AI_API AI_CONST float      AiDielectricFresnel(const AtVector& N, const AtVector& Rd, float eta);
AI_API AI_DEVICE void      AiArtisticToConductorFresnel(const AtRGB& reflectivity, const AtRGB& edgetint, AtRGB& n, AtRGB& k);
 
AI_API AI_DEVICE void      AiFaceForward(AtVector& N, const AtVector& I);
/* \}*/
 
#ifdef AI_CPU_COMPILER
typedef float (*AtFloatBumpEvaluator)(AtShaderGlobals* sg, void* data);
#endif // AI_CPU_COMPILER
/* \}*/
 
AI_API AI_DEVICE bool    AiShaderGlobalsGetTriangle(const AtShaderGlobals* sg, int key, AtVector p[3]);
AI_API         bool      AiShaderGlobalsGetVertexNormals(const AtShaderGlobals* sg, int key, AtVector n[3]);
AI_API         bool      AiShaderGlobalsGetVertexUVs(const AtShaderGlobals* sg, const AtString uvset, AtVector2 uv[3]);
AI_API AI_DEVICE uint32_t  AiShaderGlobalsGetPolygon(const AtShaderGlobals* sg, int key, AtVector* p);
AI_API AI_DEVICE uint32_t  AiShaderGlobalsGetUniformID(const AtShaderGlobals* sg);
AI_API AI_DEVICE void      AiShaderGlobalsGetPositionAtTime(const AtShaderGlobals* sg, float time, AtVector& P, AtVector* N, AtVector* Ng, AtVector* Ns);
AI_API AI_DEVICE AI_PURE AtVector2 AiShaderGlobalsGetPixelMotionVector(const AtShaderGlobals* sg, float time0, float time1);
AI_API AI_PURE AtBBox    AiShaderGlobalsGetBBoxLocal(const AtShaderGlobals* sg);
AI_API AI_PURE AtBBox    AiShaderGlobalsGetBBoxWorld(const AtShaderGlobals* sg);
AI_API         AtNode*   AiShaderGlobalsGetShader(const AtShaderGlobals* sg);
AI_API AI_DEVICE int32_t   AiShaderGlobalsGetSelectedOutput(const AtShaderGlobals* sg);
AI_API AI_DEVICE AI_PURE AtVector  AiShaderGlobalsTransformNormal(const AtShaderGlobals* sg, AtVector N, int space);
AI_API AI_DEVICE AI_PURE AtVector  AiShaderGlobalsTransformPoint(const AtShaderGlobals* sg, AtVector P, int space);
AI_API AI_DEVICE AI_PURE AtVector  AiShaderGlobalsTransformVector(const AtShaderGlobals* sg, AtVector V, int space);
AI_API         void      AiShaderGlobalsSetTraceSet(AtShaderGlobals* sg, const AtString set, bool inclusive);
AI_API         void      AiShaderGlobalsUnsetTraceSet(AtShaderGlobals* sg);
AI_API         void*     AiShaderGlobalsQuickAlloc(const AtShaderGlobals* sg, uint32_t size);
#ifdef AI_CPU_COMPILER
AI_API AI_PURE AtVector  AiShaderGlobalsEvaluateBump(AtShaderGlobals* sg, AtFloatBumpEvaluator bump_func, void* data);
#endif // AI_CPU_COMPILER
AI_API AI_DEVICE AtRGB   AiShaderGlobalsStochasticOpacity(AtShaderGlobals *sg, const AtRGB& opacity);
AI_API AI_DEVICE AI_PURE float AiShaderGlobalsArea(const AtShaderGlobals* sg);
AI_API AI_DEVICE AI_PURE float AiShaderGlobalsEdgeLength(const AtShaderGlobals* sg);
AI_API AI_DEVICE AI_PURE float     AiWireframe(const AtShaderGlobals* sg, float line_width, bool raster_space, int edge_type);
AI_API AI_PURE bool      AiShaderGlobalsIsObjectMatte(const AtShaderGlobals *sg);
AI_API AI_PURE bool      AiShaderGlobalsIsObjectOpaque(const AtShaderGlobals *sg);
 
AI_DEVICE inline AtVector AiFaceViewer(const AtShaderGlobals* sg)
{
   return (AiV3Dot(sg->Ng, sg->Rd) > 0.0f) ? -sg->N : sg->N;
}
 
/* \}*/
 
AI_API AI_PURE float AiCameraGetShutterStart();
AI_API AI_PURE float AiCameraGetShutterEnd();
AI_API AI_DEVICE void  AiCameraToWorldMatrix(const AtNode* node, float time, AtMatrix& out);
AI_API AI_DEVICE void  AiWorldToCameraMatrix(const AtNode* node, float time, AtMatrix& out);
AI_API AI_DEVICE void  AiWorldToScreenMatrix(const AtNode* node, float time, AtMatrix& out);
/* \}*/
 
AI_API void AiMappingMirroredBall(const AtVector& dir, float& u, float& v);
AI_API void AiMappingAngularMap  (const AtVector& dir, float& u, float& v);
AI_API void AiMappingLatLong     (const AtVector& dir, float& u, float& v);
/* \}*/
 
AI_API AI_DEVICE void AiMappingMirroredBallDerivs(const AtVector &dir, const AtVector &dDdx, const AtVector &dDdy, float &u, float &v, float &dudx, float &dudy, float &dvdx, float &dvdy);
AI_API AI_DEVICE void AiMappingAngularMapDerivs  (const AtVector &dir, const AtVector &dDdx, const AtVector &dDdy, float &u, float &v, float &dudx, float &dudy, float &dvdx, float &dvdy);
AI_API AI_DEVICE void AiMappingLatLongDerivs     (const AtVector &dir, const AtVector &dDdx, const AtVector &dDdy, float &u, float &v, float &dudx, float &dudy, float &dvdx, float &dvdy);
 
/* \}*/
 
AI_API AI_DEVICE int AiPointCloudSearch(const AtShaderGlobals* sg, AtString name,
                                        const AtVector& P, float radius, int max_points,
                                        bool sort, size_t* out_indices,
                                        float* out_distances_squared);
 
#define AiPointCloudGetBool(name, indices, count, attr, out_values)                      \
   AiPointCloudGetBoolFunc(sg, name, indices, count, attr, out_values)
#define AiPointCloudGetByte(name, indices, count, attr, out_values)                      \
   AiPointCloudGetByteFunc(sg, name, indices, count, attr, out_values)
#define AiPointCloudGetInt(name, indices, count, attr, out_values)                       \
   AiPointCloudGetIntFunc(sg, name, indices, count, attr, out_values)
#define AiPointCloudGetUInt(name, indices, count, attr, out_values)                      \
   AiPointCloudGetUIntFunc(sg, name, indices, count, attr, out_values)
#define AiPointCloudGetFlt(name, indices, count, attr, out_values)                       \
   AiPointCloudGetFltFunc(sg, name, indices, count, attr, out_values)
#define AiPointCloudGetRGB(name, indices, count, attr, out_values)                       \
   AiPointCloudGetRGBFunc(sg, name, indices, count, attr, out_values)
#define AiPointCloudGetRGBA(name, indices, count, attr, out_values)                      \
   AiPointCloudGetRGBAFunc(sg, name, indices, count, attr, out_values)
#define AiPointCloudGetVec(name, indices, count, attr, out_values)                       \
   AiPointCloudGetVecFunc(sg, name, indices, count, attr, out_values)
#define AiPointCloudGetVec2(name, indices, count, attr, out_values)                      \
   AiPointCloudGetVec2Func(sg, name, indices, count, attr, out_values)
#define AiPointCloudGetStr(name, indices, count, attr, out_values)                       \
   AiPointCloudGetStrFunc(sg, name, indices, count, attr, out_values)
#define AiPointCloudGetPtr(name, indices, count, attr, out_values)                       \
   AiPointCloudGetPtrFunc(sg, name, indices, count, attr, out_values)
#define AiPointCloudGetNode(name, indices, count, attr, out_values)                      \
   AiPointCloudGetNodeFunc(sg, name, indices, count, attr, out_values)
#define AiPointCloudGetArray(name, indices, count, attr, out_values)                     \
   AiPointCloudGetArrayFunc(sg, name, indices, count, attr, out_values)
#define AiPointCloudGetMatrix(name, indices, count, attr, out_values)                    \
   AiPointCloudGetMatrixFunc(sg, name, indices, count, attr, out_values)
/*\}*/
 
AI_API AI_DEVICE bool AiPointCloudGetBoolFunc(const AtShaderGlobals*, AtString,
                                              const size_t*, int, AtString, bool*);
AI_API AI_DEVICE bool AiPointCloudGetByteFunc(const AtShaderGlobals*, AtString,
                                              const size_t*, int, AtString, uint8_t*);
AI_API AI_DEVICE bool AiPointCloudGetIntFunc(const AtShaderGlobals*, AtString,
                                             const size_t*, int, AtString, int*);
AI_API AI_DEVICE bool AiPointCloudGetUIntFunc(const AtShaderGlobals*, AtString,
                                              const size_t*, int, AtString, unsigned int*);
AI_API AI_DEVICE bool AiPointCloudGetFltFunc(const AtShaderGlobals*, AtString,
                                             const size_t*, int, AtString, float*);
AI_API AI_DEVICE bool AiPointCloudGetRGBFunc(const AtShaderGlobals*, AtString,
                                             const size_t*, int, AtString, AtRGB*);
AI_API AI_DEVICE bool AiPointCloudGetRGBAFunc(const AtShaderGlobals*, AtString,
                                              const size_t*, int, AtString, AtRGBA*);
AI_API AI_DEVICE bool AiPointCloudGetVecFunc(const AtShaderGlobals*, AtString,
                                             const size_t*, int, AtString, AtVector*);
AI_API AI_DEVICE bool AiPointCloudGetVec2Func(const AtShaderGlobals*, AtString,
                                              const size_t*, int, AtString, AtVector2*);
AI_API AI_DEVICE bool AiPointCloudGetStrFunc(const AtShaderGlobals*, AtString,
                                             const size_t*, int, AtString, AtString*);
AI_API AI_DEVICE bool AiPointCloudGetPtrFunc(const AtShaderGlobals*, AtString,
                                             const size_t*, int, AtString, void**);
AI_API AI_DEVICE bool AiPointCloudGetNodeFunc(const AtShaderGlobals*, AtString,
                                              const size_t*, int, AtString, AtNode**);
AI_API AI_DEVICE bool AiPointCloudGetArrayFunc(const AtShaderGlobals*, AtString,
                                               const size_t*, int, AtString, AtArray**);
AI_API AI_DEVICE bool AiPointCloudGetMatrixFunc(const AtShaderGlobals*, AtString,
                                                const size_t*, int, AtString, AtMatrix*);
 
/*\}*/