Globals Module

import Globals

import Globals

resources {
  camera: cbuffer<Globals::CameraUniforms>
  material: cbuffer<Globals::BWEMaterial>
}

float4 worldPos = resources.camera.viewMatrix * float4(attributes.position, 1.0);
output.position = resources.camera.projectionMatrix * worldPos;

float3 albedo = resources.material.albedo.rgb;
float alpha = resources.material.albedo.a * (1.0 - resources.material.transparency);
output.color = float4(albedo, alpha);

import Globals

Globals::MeshDescriptor desc = resources.meshes[resources.meshIndex];
bool hasNormals = Globals::hasAttribute(desc, Globals::VertexAttribute::Normal);
bool hasColor = Globals::hasAttribute(desc, Globals::VertexAttribute::Color);

float3 normal = hasNormals ? normalize(input.normal) : float3(0.0, 1.0, 0.0);
float3 vertexColor = hasColor ? input.color.rgb : float3(1.0);

float lit = max(dot(normal, normalize(resources.lightDir)), 0.0);
output.color = float4(vertexColor * (0.2 + lit * 0.8), 1.0);

struct CameraUniforms {
    mat4 viewMatrix;
    mat4 projectionMatrix;
    float4 cameraPosition;
};

struct MeshDescriptor {
    VertexAttribute attributeFlags;
    uint _padding[3];
    uint numVertices;
    uint numIndices;
    uint indexOffset;
    uint positionOffset;
    uint normalOffset;
    uint texCoordOffset;
    uint colorOffset;
    uint tangentOffset;
    uint bitangentOffset;
    uint boneIndicesOffset;
    uint boneWeightsOffset;
};

struct AttributeOffsetInfo {
    uint baseOffset;
    uint stride;
    uint elementCount;
    uint present;
};

struct DrawMetadata {
    uint _pipelineState[2];
    uint sectionId;
    uint transformIndex;
    uint materialIndex;
    uint _padding;
};

struct BWEMaterial {
    float4 albedo;
    float roughness;
    float metallic;
    float specular;
    float ambientOcclusion;
    float3 emissiveColor;
    float emissiveIntensity;
    float transparency;
    float refractionIndex;
    float anisotropy;
    float subsurfaceScattering;
    float2 albedoTextureTiling;
    float2 albedoTextureOffset;
    float padding[2];
};

struct LightSourcesSoA {
    float3 positions[MAX_LIGHTS];
    float3 directions[MAX_LIGHTS];
    float3 colors[MAX_LIGHTS];
    float intensities[MAX_LIGHTS];
    float constantAttenuations[MAX_LIGHTS];
    float linearAttenuations[MAX_LIGHTS];
    float quadraticAttenuations[MAX_LIGHTS];
    float innerCutoffs[MAX_LIGHTS];
    float outerCutoffs[MAX_LIGHTS];
    float lengths[MAX_LIGHTS];
    float radii[MAX_LIGHTS];
    int types[MAX_LIGHTS];
    int version;
};

struct CascadeData {
    mat4 viewProjMatrix;
    float splitDistance;
    float padding[3];
};

struct ShadowData {
    CascadeData cascades[MAX_CASCADES];
    float4 lightDirection;
    uint numCascades;
    uint shadowMapSize;
    float cascadeSplitLambda;
    float shadowBias;
    float shadowSlopeBias;
    float shadowFilterRadius;
    float padding[2];
};

enum LightType : int {
    Point = 0,
    Directional = 1,
    Line = 2,
    Spot = 3,
    Probe = 4,
    Area = 5
}

enum VertexAttribute : uint {
    Position    = 0b00000001,
    Normal      = 0b00000010,
    TexCoord    = 0b00000100,
    Color       = 0b00001000,
    Tangent     = 0b00010000,
    Bitangent   = 0b00100000,
    BoneIndices = 0b01000000,
    BoneWeights = 0b10000000,
    
    // Check if a specific attribute is present
    eval has :: (self, VertexAttribute flag) -> bool {
        return (self & flag) != 0;
    }
    
    // Count how many attributes are set
    eval count :: (self) -> int {
        int c = 0;
        eval if (self & Position) { c++; }
        eval if (self & Normal) { c++; }
        eval if (self & TexCoord) { c++; }
        eval if (self & Color) { c++; }
        eval if (self & Tangent) { c++; }
        eval if (self & Bitangent) { c++; }
        eval if (self & BoneIndices) { c++; }
        eval if (self & BoneWeights) { c++; }
        return c;
    }
    
    // Check if skinning data is available
    eval hasSkinning :: (self) -> bool {
        return (self & BoneIndices) != 0 && (self & BoneWeights) != 0;
    }
    
    // Check if tangent space is complete
    eval hasTangentSpace :: (self) -> bool {
        return (self & Normal) != 0 && (self & Tangent) != 0 && (self & Bitangent) != 0;
    }
}