Skip to content

Commit 5086a92

Browse files
simollsimoll
committed
[SER] HitObject accessors HLSL -> DXIL lowering
1 parent c5e0ec0 commit 5086a92

3 files changed

Lines changed: 455 additions & 19 deletions

File tree

‎lib/HLSL/HLOperationLower.cpp‎

Lines changed: 79 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -5953,19 +5953,31 @@ Value *TranslateNoArgVectorOperation(CallInst *CI, IntrinsicOp IOP,
59535953
return retVal;
59545954
}
59555955

5956+
template<typename ColElemTy>
5957+
static void GetMatrixIndices(Constant *&Rows, Constant *&Cols, bool Is3x4,
5958+
LLVMContext &Ctx) {
5959+
if (Is3x4) {
5960+
uint32_t RVals[] = {0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2};
5961+
Rows = ConstantDataVector::get(Ctx, RVals);
5962+
ColElemTy CVals[] = {0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3};
5963+
Cols = ConstantDataVector::get(Ctx, CVals);
5964+
return;
5965+
}
5966+
uint32_t RVals[] = {0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2};
5967+
Rows = ConstantDataVector::get(Ctx, RVals);
5968+
ColElemTy CVals[] = {0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3};
5969+
Cols = ConstantDataVector::get(Ctx, CVals);
5970+
}
5971+
59565972
Value *TranslateNoArgMatrix3x4Operation(
59575973
CallInst *CI, IntrinsicOp IOP, OP::OpCode opcode,
59585974
HLOperationLowerHelper &helper, HLObjectOperationLowerHelper *pObjHelper,
59595975
bool &Translated) {
59605976
hlsl::OP *hlslOP = &helper.hlslOP;
59615977
VectorType *Ty = cast<VectorType>(CI->getType());
5962-
uint32_t rVals[] = {0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2};
5963-
Constant *rows = ConstantDataVector::get(CI->getContext(), rVals);
5964-
uint8_t cVals[] = {0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3};
5965-
Constant *cols = ConstantDataVector::get(CI->getContext(), cVals);
5966-
Value *retVal =
5967-
TrivialDxilOperation(opcode, {nullptr, rows, cols}, Ty, CI, hlslOP);
5968-
return retVal;
5978+
Constant *Rows, *Cols;
5979+
GetMatrixIndices<uint8_t>(Rows, Cols, true, CI->getContext());
5980+
return TrivialDxilOperation(opcode, {nullptr, Rows, Cols}, Ty, CI, hlslOP);
59695981
}
59705982

59715983
Value *TranslateNoArgTransposedMatrix3x4Operation(
@@ -5974,13 +5986,9 @@ Value *TranslateNoArgTransposedMatrix3x4Operation(
59745986
bool &Translated) {
59755987
hlsl::OP *hlslOP = &helper.hlslOP;
59765988
VectorType *Ty = cast<VectorType>(CI->getType());
5977-
uint32_t rVals[] = {0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2};
5978-
Constant *rows = ConstantDataVector::get(CI->getContext(), rVals);
5979-
uint8_t cVals[] = {0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3};
5980-
Constant *cols = ConstantDataVector::get(CI->getContext(), cVals);
5981-
Value *retVal =
5982-
TrivialDxilOperation(opcode, {nullptr, rows, cols}, Ty, CI, hlslOP);
5983-
return retVal;
5989+
Constant *Rows, *Cols;
5990+
GetMatrixIndices<uint8_t>(Rows, Cols, false, CI->getContext());
5991+
return TrivialDxilOperation(opcode, {nullptr, Rows, Cols}, Ty, CI, hlslOP);
59845992
}
59855993

59865994
/*
@@ -6331,37 +6339,89 @@ Value *TranslateHitObjectScalarGetter(CallInst *CI, IntrinsicOp IOP,
63316339
HLOperationLowerHelper &Helper,
63326340
HLObjectOperationLowerHelper *pObjHelper,
63336341
bool &Translated) {
6334-
return UndefValue::get(CI->getType()); // TODO: Merge SER DXIL patches
6342+
hlsl::OP *OP = &Helper.hlslOP;
6343+
Value *HitObjectPtr = CI->getArgOperand(1);
6344+
IRBuilder<> Builder(CI);
6345+
Value *HitObject = Builder.CreateLoad(HitObjectPtr);
6346+
return TrivialDxilOperation(OpCode, {nullptr, HitObject}, CI->getType(), CI,
6347+
OP);
63356348
}
63366349

63376350
Value *TranslateHitObjectVectorGetter(CallInst *CI, IntrinsicOp IOP,
63386351
OP::OpCode OpCode,
63396352
HLOperationLowerHelper &Helper,
63406353
HLObjectOperationLowerHelper *pObjHelper,
63416354
bool &Translated) {
6342-
return UndefValue::get(CI->getType()); // TODO: Merge SER DXIL patches
6355+
hlsl::OP *OP = &Helper.hlslOP;
6356+
Value *HitObjectPtr = CI->getArgOperand(1);
6357+
IRBuilder<> Builder(CI);
6358+
Value *HitObject = Builder.CreateLoad(HitObjectPtr);
6359+
VectorType *Ty = cast<VectorType>(CI->getType());
6360+
uint32_t Vals[] = {0, 1, 2, 3};
6361+
Constant *Src = ConstantDataVector::get(CI->getContext(), Vals);
6362+
return TrivialDxilOperation(OpCode, {nullptr, HitObject, Src}, Ty, CI, OP);
6363+
}
6364+
6365+
static bool IsHitObject3x4Getter(IntrinsicOp IOP) {
6366+
switch (IOP) {
6367+
default:
6368+
return false;
6369+
case IntrinsicOp::MOP_DxHitObject_GetObjectToWorld3x4:
6370+
case IntrinsicOp::MOP_DxHitObject_GetWorldToObject3x4:
6371+
return true;
6372+
}
63436373
}
63446374

63456375
Value *TranslateHitObjectMatrixGetter(CallInst *CI, IntrinsicOp IOP,
63466376
OP::OpCode OpCode,
63476377
HLOperationLowerHelper &Helper,
63486378
HLObjectOperationLowerHelper *pObjHelper,
63496379
bool &Translated) {
6350-
return UndefValue::get(CI->getType()); // TODO: Merge SER DXIL patches
6380+
hlsl::OP *OP = &Helper.hlslOP;
6381+
Value *HitObjectPtr = CI->getArgOperand(1);
6382+
IRBuilder<> Builder(CI);
6383+
Value *HitObject = Builder.CreateLoad(HitObjectPtr);
6384+
6385+
// Create 3x4 matrix indices
6386+
bool Is3x4 = IsHitObject3x4Getter(IOP);
6387+
Constant *Rows, *Cols;
6388+
GetMatrixIndices<uint32_t>(Rows, Cols, Is3x4, CI->getContext());
6389+
6390+
VectorType *Ty = cast<VectorType>(CI->getType());
6391+
return TrivialDxilOperation(OpCode, {nullptr, HitObject, Rows, Cols}, Ty, CI,
6392+
OP);
63516393
}
63526394

63536395
Value *TranslateHitObjectLoadLocalRootTableConstant(
63546396
CallInst *CI, IntrinsicOp IOP, OP::OpCode OpCode,
63556397
HLOperationLowerHelper &Helper, HLObjectOperationLowerHelper *pObjHelper,
63566398
bool &Translated) {
6357-
return UndefValue::get(CI->getType()); // TODO: Merge SER DXIL patches
6399+
hlsl::OP *OP = &Helper.hlslOP;
6400+
IRBuilder<> Builder(CI);
6401+
6402+
Value *HitObjectPtr = CI->getArgOperand(1);
6403+
Value *Offset = CI->getArgOperand(2);
6404+
6405+
Value *HitObject = Builder.CreateLoad(HitObjectPtr);
6406+
return TrivialDxilOperation(OpCode, {nullptr, HitObject, Offset},
6407+
Helper.voidTy, CI, OP);
63586408
}
63596409

63606410
Value *TranslateHitObjectSetShaderTableIndex(
63616411
CallInst *CI, IntrinsicOp IOP, OP::OpCode OpCode,
63626412
HLOperationLowerHelper &Helper, HLObjectOperationLowerHelper *pObjHelper,
63636413
bool &Translated) {
6364-
return UndefValue::get(CI->getType()); // TODO: Merge SER DXIL patches
6414+
hlsl::OP *OP = &Helper.hlslOP;
6415+
IRBuilder<> Builder(CI);
6416+
6417+
Value *HitObjectPtr = CI->getArgOperand(1);
6418+
Value *ShaderTableIndex = CI->getArgOperand(2);
6419+
6420+
Value *InHitObject = Builder.CreateLoad(HitObjectPtr);
6421+
Value *OutHitObject = TrivialDxilOperation(
6422+
OpCode, {nullptr, InHitObject, ShaderTableIndex}, Helper.voidTy, CI, OP);
6423+
Builder.CreateStore(OutHitObject, HitObjectPtr);
6424+
return nullptr;
63656425
}
63666426

63676427
} // namespace

‎tools/clang/test/CodeGenDXIL/hlsl/objects/HitObject/hitobject_accessors.hlsl‎

Lines changed: 113 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,113 @@
1+
// REQUIRES: dxil-1-9
2+
// RUN: %dxc -T lib_6_9 -E main %s | FileCheck %s --check-prefix DXIL
3+
4+
// DXIL: %dx.types.HitObject = type { i8* }
5+
6+
// DXIL: %[[NOP:[^ ]+]] = call %dx.types.HitObject @dx.op.hitObject_MakeNop(i32 266) ; HitObject_MakeNop()
7+
// DXIL: %[[HIT:[^ ]+]] = call %dx.types.HitObject @dx.op.hitObject_SetShaderTableIndex(i32 287, %dx.types.HitObject %[[NOP]], i32 1) ; HitObject_SetShaderTableIndex(hitObject,shaderTableIndex)
8+
// DXIL-DAG: %{{[^ ]+}} = call i1 @dx.op.hitObject_StateScalar.i1(i32 270, %dx.types.HitObject %[[HIT]]) ; HitObject_IsHit(hitObject)
9+
// DXIL-DAG: %{{[^ ]+}} = call i1 @dx.op.hitObject_StateScalar.i1(i32 269, %dx.types.HitObject %[[HIT]]) ; HitObject_IsMiss(hitObject)
10+
// DXIL-DAG: %{{[^ ]+}} = call i1 @dx.op.hitObject_StateScalar.i1(i32 271, %dx.types.HitObject %[[HIT]]) ; HitObject_IsNop(hitObject)
11+
// DXIL-DAG: %{{[^ ]+}} = call i32 @dx.op.hitObject_StateScalar.i32(i32 281, %dx.types.HitObject %[[HIT]]) ; HitObject_GeometryIndex(hitObject)
12+
// DXIL-DAG: %{{[^ ]+}} = call i32 @dx.op.hitObject_StateScalar.i32(i32 285, %dx.types.HitObject %[[HIT]]) ; HitObject_HitKind(hitObject)
13+
// DXIL-DAG: %{{[^ ]+}} = call i32 @dx.op.hitObject_StateScalar.i32(i32 282, %dx.types.HitObject %[[HIT]]) ; HitObject_InstanceIndex(hitObject)
14+
// DXIL-DAG: %{{[^ ]+}} = call i32 @dx.op.hitObject_StateScalar.i32(i32 283, %dx.types.HitObject %[[HIT]]) ; HitObject_InstanceID(hitObject)
15+
// DXIL-DAG: %{{[^ ]+}} = call i32 @dx.op.hitObject_StateScalar.i32(i32 284, %dx.types.HitObject %[[HIT]]) ; HitObject_PrimitiveIndex(hitObject)
16+
// DXIL-DAG: %{{[^ ]+}} = call i32 @dx.op.hitObject_StateScalar.i32(i32 286, %dx.types.HitObject %[[HIT]]) ; HitObject_ShaderTableIndex(hitObject)
17+
// DXIL-DAG: %{{[^ ]+}} = call i32 @dx.op.hitObject_LoadLocalRootTableConstant(i32 288, %dx.types.HitObject %[[HIT]], i32 42) ; HitObject_LoadLocalRootTableConstant(hitObject,offset)
18+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateVector.f32(i32 277, %dx.types.HitObject %[[HIT]], i32 0) ; HitObject_ObjectRayOrigin(hitObject,component)
19+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateVector.f32(i32 277, %dx.types.HitObject %[[HIT]], i32 1) ; HitObject_ObjectRayOrigin(hitObject,component)
20+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateVector.f32(i32 277, %dx.types.HitObject %[[HIT]], i32 2) ; HitObject_ObjectRayOrigin(hitObject,component)
21+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateVector.f32(i32 278, %dx.types.HitObject %[[HIT]], i32 0) ; HitObject_ObjectRayDirection(hitObject,component)
22+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateVector.f32(i32 278, %dx.types.HitObject %[[HIT]], i32 1) ; HitObject_ObjectRayDirection(hitObject,component)
23+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateVector.f32(i32 278, %dx.types.HitObject %[[HIT]], i32 2) ; HitObject_ObjectRayDirection(hitObject,component)
24+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateVector.f32(i32 275, %dx.types.HitObject %[[HIT]], i32 0) ; HitObject_WorldRayOrigin(hitObject,component)
25+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateVector.f32(i32 275, %dx.types.HitObject %[[HIT]], i32 1) ; HitObject_WorldRayOrigin(hitObject,component)
26+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateVector.f32(i32 275, %dx.types.HitObject %[[HIT]], i32 2) ; HitObject_WorldRayOrigin(hitObject,component)
27+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateVector.f32(i32 276, %dx.types.HitObject %[[HIT]], i32 0) ; HitObject_WorldRayDirection(hitObject,component)
28+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateVector.f32(i32 276, %dx.types.HitObject %[[HIT]], i32 1) ; HitObject_WorldRayDirection(hitObject,component)
29+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateVector.f32(i32 276, %dx.types.HitObject %[[HIT]], i32 2) ; HitObject_WorldRayDirection(hitObject,component)
30+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateMatrix.f32(i32 279, %dx.types.HitObject %[[HIT]], i32 0, i32 0) ; HitObject_ObjectToWorld3x4(hitObject,row,col)
31+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateMatrix.f32(i32 279, %dx.types.HitObject %[[HIT]], i32 0, i32 1) ; HitObject_ObjectToWorld3x4(hitObject,row,col)
32+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateMatrix.f32(i32 279, %dx.types.HitObject %[[HIT]], i32 0, i32 2) ; HitObject_ObjectToWorld3x4(hitObject,row,col)
33+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateMatrix.f32(i32 279, %dx.types.HitObject %[[HIT]], i32 0, i32 3) ; HitObject_ObjectToWorld3x4(hitObject,row,col)
34+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateMatrix.f32(i32 279, %dx.types.HitObject %[[HIT]], i32 1, i32 0) ; HitObject_ObjectToWorld3x4(hitObject,row,col)
35+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateMatrix.f32(i32 279, %dx.types.HitObject %[[HIT]], i32 1, i32 1) ; HitObject_ObjectToWorld3x4(hitObject,row,col)
36+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateMatrix.f32(i32 279, %dx.types.HitObject %[[HIT]], i32 1, i32 2) ; HitObject_ObjectToWorld3x4(hitObject,row,col)
37+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateMatrix.f32(i32 279, %dx.types.HitObject %[[HIT]], i32 1, i32 3) ; HitObject_ObjectToWorld3x4(hitObject,row,col)
38+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateMatrix.f32(i32 279, %dx.types.HitObject %[[HIT]], i32 2, i32 0) ; HitObject_ObjectToWorld3x4(hitObject,row,col)
39+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateMatrix.f32(i32 279, %dx.types.HitObject %[[HIT]], i32 2, i32 1) ; HitObject_ObjectToWorld3x4(hitObject,row,col)
40+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateMatrix.f32(i32 279, %dx.types.HitObject %[[HIT]], i32 2, i32 2) ; HitObject_ObjectToWorld3x4(hitObject,row,col)
41+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateMatrix.f32(i32 279, %dx.types.HitObject %[[HIT]], i32 2, i32 3) ; HitObject_ObjectToWorld3x4(hitObject,row,col)
42+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateMatrix.f32(i32 280, %dx.types.HitObject %[[HIT]], i32 0, i32 0) ; HitObject_WorldToObject3x4(hitObject,row,col)
43+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateMatrix.f32(i32 280, %dx.types.HitObject %[[HIT]], i32 0, i32 1) ; HitObject_WorldToObject3x4(hitObject,row,col)
44+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateMatrix.f32(i32 280, %dx.types.HitObject %[[HIT]], i32 0, i32 2) ; HitObject_WorldToObject3x4(hitObject,row,col)
45+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateMatrix.f32(i32 280, %dx.types.HitObject %[[HIT]], i32 0, i32 3) ; HitObject_WorldToObject3x4(hitObject,row,col)
46+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateMatrix.f32(i32 280, %dx.types.HitObject %[[HIT]], i32 1, i32 0) ; HitObject_WorldToObject3x4(hitObject,row,col)
47+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateMatrix.f32(i32 280, %dx.types.HitObject %[[HIT]], i32 1, i32 1) ; HitObject_WorldToObject3x4(hitObject,row,col)
48+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateMatrix.f32(i32 280, %dx.types.HitObject %[[HIT]], i32 1, i32 2) ; HitObject_WorldToObject3x4(hitObject,row,col)
49+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateMatrix.f32(i32 280, %dx.types.HitObject %[[HIT]], i32 1, i32 3) ; HitObject_WorldToObject3x4(hitObject,row,col)
50+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateMatrix.f32(i32 280, %dx.types.HitObject %[[HIT]], i32 2, i32 0) ; HitObject_WorldToObject3x4(hitObject,row,col)
51+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateMatrix.f32(i32 280, %dx.types.HitObject %[[HIT]], i32 2, i32 1) ; HitObject_WorldToObject3x4(hitObject,row,col)
52+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateMatrix.f32(i32 280, %dx.types.HitObject %[[HIT]], i32 2, i32 2) ; HitObject_WorldToObject3x4(hitObject,row,col)
53+
// DXIL-DAG: %{{[^ ]+}} = call float @dx.op.hitObject_StateMatrix.f32(i32 280, %dx.types.HitObject %[[HIT]], i32 2, i32 3) ; HitObject_WorldToObject3x4(hitObject,row,col)
54+
// DXIL: ret void
55+
56+
RWByteAddressBuffer outbuf;
57+
58+
template <int M, int N>
59+
float hashM(in matrix<float, M, N> mat) {
60+
float h = 0.f;
61+
for (int i = 0; i < M; ++i)
62+
for (int j = 0; j < N; ++j)
63+
h += mat[i][j];
64+
return h;
65+
}
66+
67+
[shader("raygeneration")]
68+
void main() {
69+
dx::HitObject hit;
70+
int isum = 0;
71+
float fsum = 0.0f;
72+
vector<float, 3> vsum = 0;
73+
74+
///// Setters
75+
hit.SetShaderTableIndex(1);
76+
77+
///// Getters
78+
79+
// i1 accessors
80+
isum += hit.IsHit();
81+
isum += hit.IsMiss();
82+
isum += hit.IsNop();
83+
84+
// i32 accessors
85+
isum += hit.GetGeometryIndex();
86+
isum += hit.GetHitKind();
87+
isum += hit.GetInstanceIndex();
88+
isum += hit.GetInstanceID();
89+
isum += hit.GetPrimitiveIndex();
90+
isum += hit.GetShaderTableIndex();
91+
isum += hit.LoadLocalRootTableConstant(42);
92+
93+
// float3 accessors
94+
vsum += hit.GetWorldRayOrigin();
95+
vsum += hit.GetWorldRayDirection();
96+
vsum += hit.GetObjectRayOrigin();
97+
vsum += hit.GetObjectRayDirection();
98+
fsum += vsum[0] + vsum[1] + vsum[2];
99+
100+
// matrix accessors
101+
fsum += hashM<3, 4>(hit.GetObjectToWorld3x4());
102+
fsum += hashM<4, 3>(hit.GetObjectToWorld4x3());
103+
fsum += hashM<3, 4>(hit.GetWorldToObject3x4());
104+
fsum += hashM<4, 3>(hit.GetWorldToObject4x3());
105+
106+
// f32 accessors
107+
isum += hit.GetRayFlags();
108+
fsum += hit.GetRayTMin();
109+
fsum += hit.GetRayTCurrent();
110+
111+
outbuf.Store(0, fsum);
112+
outbuf.Store(4, isum);
113+
}

0 commit comments

Comments
 (0)