From 43cc7c97009450de86ea4a4ce9e36ec83adda78b Mon Sep 17 00:00:00 2001 From: MeltyPlayer Date: Fri, 21 Oct 2022 00:15:13 -0500 Subject: [PATCH 01/16] Pulled in the audio code from @ckosmic's fork, which is from the decomp project. --- ...eq_channel_layer_process_script_copt.inc.c | 500 +++ src/decomp/audio/data.c | 961 ++++++ src/decomp/audio/data.h | 154 + src/decomp/audio/effects.c | 545 ++++ src/decomp/audio/effects.h | 48 + src/decomp/audio/external.c | 2684 ++++++++++++++++ src/decomp/audio/external.h | 74 + src/decomp/audio/globals_start.c | 3 + src/decomp/audio/heap.c | 1747 ++++++++++ src/decomp/audio/heap.h | 144 + src/decomp/audio/internal.h | 886 +++++ src/decomp/audio/load.c | 1074 +++++++ src/decomp/audio/load.h | 114 + src/decomp/audio/load_dat.c | 11 + src/decomp/audio/load_dat.h | 11 + src/decomp/audio/load_sh.c | 1639 ++++++++++ src/decomp/audio/playback.c | 1472 +++++++++ src/decomp/audio/playback.h | 50 + src/decomp/audio/port_eu.c | 351 ++ src/decomp/audio/port_sh.c | 597 ++++ src/decomp/audio/seqplayer.c | 2853 +++++++++++++++++ src/decomp/audio/seqplayer.h | 18 + src/decomp/audio/shindou_debug_prints.c | 148 + src/decomp/audio/synthesis.c | 1544 +++++++++ src/decomp/audio/synthesis.h | 99 + src/decomp/audio/synthesis_sh.c | 914 ++++++ 26 files changed, 18641 insertions(+) create mode 100644 src/decomp/audio/copt/seq_channel_layer_process_script_copt.inc.c create mode 100644 src/decomp/audio/data.c create mode 100644 src/decomp/audio/data.h create mode 100644 src/decomp/audio/effects.c create mode 100644 src/decomp/audio/effects.h create mode 100644 src/decomp/audio/external.c create mode 100644 src/decomp/audio/external.h create mode 100644 src/decomp/audio/globals_start.c create mode 100644 src/decomp/audio/heap.c create mode 100644 src/decomp/audio/heap.h create mode 100644 src/decomp/audio/internal.h create mode 100644 src/decomp/audio/load.c create mode 100644 src/decomp/audio/load.h create mode 100644 src/decomp/audio/load_dat.c create mode 100644 src/decomp/audio/load_dat.h create mode 100644 src/decomp/audio/load_sh.c create mode 100644 src/decomp/audio/playback.c create mode 100644 src/decomp/audio/playback.h create mode 100644 src/decomp/audio/port_eu.c create mode 100644 src/decomp/audio/port_sh.c create mode 100644 src/decomp/audio/seqplayer.c create mode 100644 src/decomp/audio/seqplayer.h create mode 100644 src/decomp/audio/shindou_debug_prints.c create mode 100644 src/decomp/audio/synthesis.c create mode 100644 src/decomp/audio/synthesis.h create mode 100644 src/decomp/audio/synthesis_sh.c diff --git a/src/decomp/audio/copt/seq_channel_layer_process_script_copt.inc.c b/src/decomp/audio/copt/seq_channel_layer_process_script_copt.inc.c new file mode 100644 index 0000000..7b6b777 --- /dev/null +++ b/src/decomp/audio/copt/seq_channel_layer_process_script_copt.inc.c @@ -0,0 +1,500 @@ +//! Copt inlining for US/JP. Here be dragons +// This version is basically identical to EU + +#include +#include + +#include "../heap.h" +#include "../data.h" +#include "../load.h" +#include "../seqplayer.h" +#include "../external.h" +#include "../effects.h" + +#define PORTAMENTO_IS_SPECIAL(x) ((x).mode & 0x80) +#define PORTAMENTO_MODE(x) ((x).mode & ~0x80) +#define PORTAMENTO_MODE_1 1 +#define PORTAMENTO_MODE_2 2 +#define PORTAMENTO_MODE_3 3 +#define PORTAMENTO_MODE_4 4 +#define PORTAMENTO_MODE_5 5 + +#define COPT 0 +#if COPT +#define M64_READ_U8(state, dst) \ + dst = m64_read_u8(state); +#else +#define M64_READ_U8(state, dst) \ +{ \ + u8 * _ptr_pc; \ + u8 _pc; \ + _ptr_pc = (*state).pc; \ + ((*state).pc)++; \ + _pc = *_ptr_pc; \ + dst = _pc; \ +} +#endif + + +#if COPT +#define M64_READ_S16(state, dst) \ + dst = m64_read_s16(state); +#else +#define M64_READ_S16(state, dst) \ +{ \ + s16 _ret; \ + _ret = *(*state).pc << 8; \ + ((*state).pc)++; \ + _ret = *(*state).pc | _ret; \ + ((*state).pc)++; \ + dst = _ret; \ +} +#endif +#if COPT +#define M64_READ_COMPRESSED_U16(state, dst) \ + dst = m64_read_compressed_u16(state); +#else +#define M64_READ_COMPRESSED_U16(state, dst) \ +{ \ + u16 ret = *(state->pc++); \ + if (ret & 0x80) { \ + ret = (ret << 8) & 0x7f00; \ + ret = *(state->pc++) | ret; \ + } \ + dst = ret; \ +} +#endif + +#if COPT +#define GET_INSTRUMENT(seqChannel, instId, _instOut, _adsr, dst, l) \ + dst = get_instrument(seqChannel, instId, _instOut, _adsr); +#else +#define GET_INSTRUMENT(seqChannel, instId, _instOut, _adsr, dst, l) \ +{ \ +struct AdsrSettings *adsr = _adsr; \ +struct Instrument **instOut = _instOut;\ + u8 _instId = instId; \ + struct Instrument *inst; \ + UNUSED u32 pad; \ + /* copt inlines instId here */ \ + if (instId >= gCtlEntries[(*seqChannel).bankId].numInstruments) { \ + _instId = gCtlEntries[(*seqChannel).bankId].numInstruments; \ + if (_instId == 0) { \ + dst = 0; \ + goto ret ## l; \ + } \ + _instId--; \ + } \ + inst = gCtlEntries[(*seqChannel).bankId].instruments[_instId]; \ + if (inst == NULL) { \ + while (_instId != 0xff) { \ + inst = gCtlEntries[(*seqChannel).bankId].instruments[_instId]; \ + if (inst != NULL) { \ + goto gi ## l; \ + } \ + _instId--; \ + } \ + gi ## l:; \ + } \ + if (((uintptr_t) gBankLoadedPool.persistent.pool.start <= (uintptr_t) inst \ + && (uintptr_t) inst <= (uintptr_t)(gBankLoadedPool.persistent.pool.start \ + + gBankLoadedPool.persistent.pool.size)) \ + || ((uintptr_t) gBankLoadedPool.temporary.pool.start <= (uintptr_t) inst \ + && (uintptr_t) inst <= (uintptr_t)(gBankLoadedPool.temporary.pool.start \ + + gBankLoadedPool.temporary.pool.size))) { \ + (*adsr).envelope = (*inst).envelope; \ + (*adsr).releaseRate = (*inst).releaseRate; \ + *instOut = inst; \ + _instId++; \ + goto ret ## l; \ + } \ + gAudioErrorFlags = _instId + 0x20000; \ + *instOut = NULL; \ + ret ## l: ; \ +} +#endif + +void seq_channel_layer_process_script(struct SequenceChannelLayer *layer) { + struct SequencePlayer *seqPlayer; // sp5C, t4 + struct SequenceChannel *seqChannel; // sp58, t5 + struct M64ScriptState *state; + struct Portamento *portamento; + struct AudioBankSound *sound; + struct Instrument *instrument; + struct Drum *drum; + s32 temp_a0_5; + u8 sameSound; + u8 cmd; // a0 sp3E, EU s2 + u8 cmdSemitone; // sp3D, t0 + u16 sp3A; // t2, a0, a1 + f32 tuning; // f0 + s32 vel; // sp30, t3 + s32 usedSemitone; // a1 + f32 freqScale; // sp28, f0 + f32 sp24; + f32 temp_f12; + f32 temp_f2; + +//! Copt: manually inline these functions in the scope of this routine +#ifdef __sgi +#pragma inline routine(m64_read_u8) +#pragma inline routine(m64_read_compressed_u16) +#pragma inline routine(m64_read_s16) +#pragma inline routine(get_instrument) +#endif + + sameSound = TRUE; + if ((*layer).enabled == FALSE) { + return; + } + + if ((*layer).delay > 1) { + (*layer).delay--; + if (!layer->stopSomething && layer->delay <= layer->duration) { + seq_channel_layer_note_decay(layer); + layer->stopSomething = TRUE; + } + return; + } + + if (!layer->continuousNotes) { + seq_channel_layer_note_decay(layer); + } + + if (PORTAMENTO_MODE(layer->portamento) == PORTAMENTO_MODE_1 || + PORTAMENTO_MODE(layer->portamento) == PORTAMENTO_MODE_2) { + layer->portamento.mode = 0; + } + + seqChannel = (*layer).seqChannel; + seqPlayer = (*seqChannel).seqPlayer; + for (;;) { + state = &layer->scriptState; + //M64_READ_U8(state, cmd); + { + u8 *_ptr_pc; + _ptr_pc = (*state).pc++; + cmd = *_ptr_pc; + } + + if (cmd <= 0xc0) { + break; + } + + switch (cmd) { + case 0xff: // layer_end; function return or end of script + if (state->depth == 0) { + // N.B. this function call is *not* inlined even though it's + // within the same file, unlike in the rest of this function. + seq_channel_layer_disable(layer); + return; + } + state->depth--, state->pc = state->stack[state->depth]; + break; + + case 0xfc: // layer_call + M64_READ_S16(state, sp3A); + state->depth++, state->stack[state->depth - 1] = state->pc; + state->pc = seqPlayer->seqData + sp3A; + break; + + case 0xf8: // layer_loop; loop start, N iterations (or 256 if N = 0) + M64_READ_U8(state, state->remLoopIters[state->depth]); + state->depth++, state->stack[state->depth - 1] = state->pc; + break; + + case 0xf7: // layer_loopend + if (--state->remLoopIters[state->depth - 1] != 0) { + state->pc = state->stack[state->depth - 1]; + } else { + state->depth--; + } + break; + + case 0xfb: // layer_jump + M64_READ_S16(state, sp3A); + state->pc = seqPlayer->seqData + sp3A; + break; + + case 0xc1: // layer_setshortnotevelocity + case 0xca: // layer_setpan + temp_a0_5 = *(state->pc++); + if (cmd == 0xc1) { + layer->velocitySquare = (f32)(temp_a0_5 * temp_a0_5); + } else { + layer->pan = (f32) temp_a0_5 / US_FLOAT(128.0); + } + break; + + case 0xc2: // layer_transpose; set transposition in semitones + case 0xc9: // layer_setshortnoteduration + temp_a0_5 = *(state->pc++); + if (cmd == 0xc9) { + layer->noteDuration = temp_a0_5; + } else { + layer->transposition = temp_a0_5; + } + break; + + case 0xc4: // layer_somethingon + case 0xc5: // layer_somethingoff + //! copt needs a ternary: + //layer->continuousNotes = (cmd == 0xc4) ? TRUE : FALSE; + { + u8 setting; + if (cmd == 0xc4) { + setting = TRUE; + } else { + setting = FALSE; + } + layer->continuousNotes = setting; + seq_channel_layer_note_decay(layer); + } + break; + + case 0xc3: // layer_setshortnotedefaultplaypercentage + M64_READ_COMPRESSED_U16(state, sp3A); + layer->shortNoteDefaultPlayPercentage = sp3A; + break; + + case 0xc6: // layer_setinstr + M64_READ_U8(state, cmdSemitone); + + if (cmdSemitone < 127) { + GET_INSTRUMENT(seqChannel, cmdSemitone, &(*layer).instrument, &(*layer).adsr, cmdSemitone, 1); + } + break; + + case 0xc7: // layer_portamento + M64_READ_U8(state, (*layer).portamento.mode); + M64_READ_U8(state, cmdSemitone); + + cmdSemitone = cmdSemitone + (*seqChannel).transposition; + cmdSemitone += (*layer).transposition; + cmdSemitone += (*seqPlayer).transposition; + + if (cmdSemitone >= 0x80) { + cmdSemitone = 0; + } + layer->portamentoTargetNote = cmdSemitone; + + // If special, the next param is u8 instead of var + if (PORTAMENTO_IS_SPECIAL((*layer).portamento)) { + layer->portamentoTime = *((state)->pc++); + break; + } + + M64_READ_COMPRESSED_U16(state, sp3A); + layer->portamentoTime = sp3A; + break; + + case 0xc8: // layer_disableportamento + layer->portamento.mode = 0; + break; + + default: + switch (cmd & 0xf0) { + case 0xd0: // layer_setshortnotevelocityfromtable + sp3A = seqPlayer->shortNoteVelocityTable[cmd & 0xf]; + (*layer).velocitySquare = (f32)(sp3A * sp3A); + break; + case 0xe0: // layer_setshortnotedurationfromtable + (*layer).noteDuration = seqPlayer->shortNoteDurationTable[cmd & 0xf]; + break; + } + } + } + + if (cmd == 0xc0) { // layer_delay + M64_READ_COMPRESSED_U16(state, layer->delay); + layer->stopSomething = TRUE; + } else { + layer->stopSomething = FALSE; + + if (seqChannel->largeNotes == TRUE) { + switch (cmd & 0xc0) { + case 0x00: // layer_note0 (play percentage, velocity, duration) + M64_READ_COMPRESSED_U16(state, sp3A); + vel = *((*state).pc++); + layer->noteDuration = *((*state).pc++); + layer->playPercentage = sp3A; + goto l1090; + + case 0x40: // layer_note1 (play percentage, velocity) + M64_READ_COMPRESSED_U16(state, sp3A); + vel = *((*state).pc++); + layer->noteDuration = 0; + layer->playPercentage = sp3A; + goto l1090; + + case 0x80: // layer_note2 (velocity, duration; uses last play percentage) + sp3A = layer->playPercentage; + vel = *((*state).pc++); + layer->noteDuration = *((*state).pc++); + goto l1090; + } +l1090: + cmdSemitone = cmd - (cmd & 0xc0); + layer->velocitySquare = vel * vel; + } else { + switch (cmd & 0xc0) { + case 0x00: // play note, type 0 (play percentage) + M64_READ_COMPRESSED_U16(state, sp3A); + layer->playPercentage = sp3A; + goto l1138; + + case 0x40: // play note, type 1 (uses default play percentage) + sp3A = layer->shortNoteDefaultPlayPercentage; + goto l1138; + + case 0x80: // play note, type 2 (uses last play percentage) + sp3A = layer->playPercentage; + goto l1138; + } +l1138: + + cmdSemitone = cmd - (cmd & 0xc0); + } + + layer->delay = sp3A; + layer->duration = layer->noteDuration * sp3A / 256; + if ((seqPlayer->muted && (seqChannel->muteBehavior & MUTE_BEHAVIOR_STOP_NOTES) != 0) + || seqChannel->stopSomething2 + || !seqChannel->hasInstrument + ) { + layer->stopSomething = TRUE; + } else { + if (seqChannel->instOrWave == 0) { // drum + cmdSemitone += (*seqChannel).transposition + (*layer).transposition; + if (cmdSemitone >= gCtlEntries[seqChannel->bankId].numDrums) { + cmdSemitone = gCtlEntries[seqChannel->bankId].numDrums; + if (cmdSemitone == 0) { + // this goto looks a bit like a function return... + layer->stopSomething = TRUE; + goto skip; + } + + cmdSemitone--; + } + + drum = gCtlEntries[seqChannel->bankId].drums[cmdSemitone]; + if (drum == NULL) { + layer->stopSomething = TRUE; + } else { + layer->adsr.envelope = drum->envelope; + layer->adsr.releaseRate = drum->releaseRate; + layer->pan = FLOAT_CAST(drum->pan) / US_FLOAT(128.0); + layer->sound = &drum->sound; + layer->freqScale = layer->sound->tuning; + } + + skip:; + } else { // instrument + cmdSemitone += (*seqPlayer).transposition + (*seqChannel).transposition + (*layer).transposition; + if (cmdSemitone >= 0x80) { + layer->stopSomething = TRUE; + } else { + instrument = layer->instrument; + if (instrument == NULL) { + instrument = seqChannel->instrument; + } + + if (layer->portamento.mode != 0) { + //! copt needs a ternary: + //usedSemitone = (layer->portamentoTargetNote < cmdSemitone) ? cmdSemitone : layer->portamentoTargetNote; + if (layer->portamentoTargetNote < cmdSemitone) { + usedSemitone = cmdSemitone; + } else { + usedSemitone = layer->portamentoTargetNote; + } + + if (instrument != NULL) { + sound = (u8) usedSemitone < instrument->normalRangeLo ? &instrument->lowNotesSound + : (u8) usedSemitone <= instrument->normalRangeHi ? + &instrument->normalNotesSound : &instrument->highNotesSound; + + sameSound = (sound == (*layer).sound); + layer->sound = sound; + tuning = (*sound).tuning; + } else { + layer->sound = NULL; + tuning = 1.0f; + } + + temp_f2 = gNoteFrequencies[cmdSemitone] * tuning; + temp_f12 = gNoteFrequencies[layer->portamentoTargetNote] * tuning; + + portamento = &layer->portamento; + switch (PORTAMENTO_MODE(layer->portamento)) { + case PORTAMENTO_MODE_1: + case PORTAMENTO_MODE_3: + case PORTAMENTO_MODE_5: + sp24 = temp_f2; + freqScale = temp_f12; + goto l13cc; + + case PORTAMENTO_MODE_2: + case PORTAMENTO_MODE_4: + freqScale = temp_f2; + sp24 = temp_f12; + goto l13cc; + } +l13cc: + portamento->extent = sp24 / freqScale - US_FLOAT(1.0); + if (PORTAMENTO_IS_SPECIAL((*layer).portamento)) { + portamento->speed = US_FLOAT(32512.0) * FLOAT_CAST((*seqPlayer).tempo) + / ((f32)(*layer).delay * (f32) gTempoInternalToExternal + * FLOAT_CAST((*layer).portamentoTime)); + } else { + portamento->speed = US_FLOAT(127.0) / FLOAT_CAST((*layer).portamentoTime); + } + portamento->cur = 0.0f; + layer->freqScale = freqScale; + if (PORTAMENTO_MODE((*layer).portamento) == PORTAMENTO_MODE_5) { + layer->portamentoTargetNote = cmdSemitone; + } + } else if (instrument != NULL) { + sound = cmdSemitone < instrument->normalRangeLo ? + &instrument->lowNotesSound : cmdSemitone <= instrument->normalRangeHi ? + &instrument->normalNotesSound : &instrument->highNotesSound; + + sameSound = (sound == (*layer).sound); + layer->sound = sound; + layer->freqScale = gNoteFrequencies[cmdSemitone] * (*sound).tuning; + } else { + layer->sound = NULL; + layer->freqScale = gNoteFrequencies[cmdSemitone]; + } + } + } + layer->delayUnused = layer->delay; + } + } + + if (layer->stopSomething == TRUE) { + if (layer->note != NULL || layer->continuousNotes) { + seq_channel_layer_note_decay(layer); + } + return; + } + + cmdSemitone = FALSE; + if (!layer->continuousNotes) { + cmdSemitone = TRUE; + } else if (layer->note == NULL || layer->status == SOUND_LOAD_STATUS_NOT_LOADED) { + cmdSemitone = TRUE; + } else if (sameSound == FALSE) { + seq_channel_layer_note_decay(layer); + cmdSemitone = TRUE; + } else if (layer->sound == NULL) { + init_synthetic_wave(layer->note, layer); + } + + if (cmdSemitone != FALSE) { + (*layer).note = alloc_note(layer); + } + + if (layer->note != NULL && layer->note->parentLayer == layer) { + note_vibrato_init(layer->note); + } +} diff --git a/src/decomp/audio/data.c b/src/decomp/audio/data.c new file mode 100644 index 0000000..f8495bb --- /dev/null +++ b/src/decomp/audio/data.c @@ -0,0 +1,961 @@ +#include + +#include "data.h" +#include "effects.h" + +extern struct OSMesgQueue OSMesgQueue0; +extern struct OSMesgQueue OSMesgQueue1; +extern struct OSMesgQueue OSMesgQueue2; +extern struct OSMesgQueue OSMesgQueue3; + +#ifdef VERSION_EU +struct ReverbSettingsEU sReverbSettings[] = { + { 0x04, 0x0c, 0x2fff }, + { 0x04, 0x0a, 0x47ff }, + { 0x04, 0x10, 0x2fff }, + { 0x04, 0x0e, 0x3fff }, + { 0x04, 0x0c, 0x4fff }, + { 0x04, 0x0a, 0x37ff } +}; +struct AudioSessionSettingsEU gAudioSessionPresets[] = { + { 0x00007d00, 0x01, 0x10, 0x01, 0x00, &sReverbSettings[0], 0x7fff, 0x0000, 0x00003a40, 0x00006d00, + 0x00004400, 0x00002a00 }, + { 0x00007d00, 0x01, 0x10, 0x01, 0x00, &sReverbSettings[1], 0x7fff, 0x0000, 0x00003a40, 0x00006d00, + 0x00004400, 0x00002a00 }, + { 0x00007d00, 0x01, 0x10, 0x01, 0x00, &sReverbSettings[2], 0x7fff, 0x0000, 0x00003a40, 0x00006d00, + 0x00004400, 0x00002a00 }, + { 0x00007d00, 0x01, 0x10, 0x01, 0x00, &sReverbSettings[3], 0x7fff, 0x0000, 0x00003a40, 0x00006d00, + 0x00004400, 0x00002a00 }, + { 0x00007d00, 0x01, 0x10, 0x01, 0x00, &sReverbSettings[4], 0x7fff, 0x0000, 0x00003a40, 0x00006d00, + 0x00004400, 0x00002a00 }, + { 0x00007d00, 0x01, 0x10, 0x01, 0x00, &sReverbSettings[0], 0x7fff, 0x0000, 0x00004000, 0x00006e00, + 0x00003f00, 0x00002a00 }, + { 0x00007d00, 0x01, 0x10, 0x01, 0x00, &sReverbSettings[1], 0x7fff, 0x0000, 0x00004100, 0x00006e00, + 0x00004400, 0x00002a80 }, + { 0x00007d00, 0x01, 0x14, 0x01, 0x00, &sReverbSettings[5], 0x7fff, 0x0000, 0x00003500, 0x00006280, + 0x00004000, 0x00001b00 } +}; +#endif + +// Format: +// - frequency +// - max number of simultaneous notes +// - reverb downsample rate (makes the ring buffer be downsampled to save memory) +// - reverb window size (ring buffer size, length affects reverb delay) +// - reverb gain (0 = min reverb, 32767 = max reverb, 32769 to 65535 = louder and louder...) +// - volume +// - memory used for persistent sequences +// - memory used for persistent banks +// - memory used for temporary sequences +// - memory used for temporary banks +#if defined(VERSION_JP) || defined(VERSION_US) +struct AudioSessionSettings gAudioSessionPresets[18] = { +#ifdef VERSION_JP + { 32000, 16, 1, 0x0800, 0x2FFF, 0x7FFF, 0x3900, 0x6000, 0x4400, 0x2A00 }, + { 32000, 16, 1, 0x0A00, 0x47FF, 0x7FFF, 0x3900, 0x6000, 0x4400, 0x2A00 }, + { 32000, 16, 1, 0x1000, 0x2FFF, 0x7FFF, 0x3900, 0x6000, 0x4400, 0x2A00 }, + { 32000, 16, 1, 0x0E00, 0x3FFF, 0x7FFF, 0x3900, 0x6000, 0x4400, 0x2A00 }, + { 32000, 16, 1, 0x0C00, 0x4FFF, 0x7FFF, 0x3900, 0x6000, 0x4400, 0x2A00 }, + { 32000, 16, 1, 0x0800, 0x2FFF, 0x7FFF, 0x3E00, 0x6200, 0x3F00, 0x2A00 }, + { 32000, 16, 1, 0x0A00, 0x47FF, 0x7FFF, 0x3F00, 0x6200, 0x4400, 0x2A80 }, + { 32000, 20, 1, 0x0800, 0x37FF, 0x7FFF, 0x3300, 0x5500, 0x4000, 0x1B00 }, +#else + { 32000, 16, 1, 0x0C00, 0x2FFF, 0x7FFF, 0x3A00, 0x6D00, 0x4400, 0x2A00 }, + { 32000, 16, 1, 0x0A00, 0x47FF, 0x7FFF, 0x3A00, 0x6D00, 0x4400, 0x2A00 }, + { 32000, 16, 1, 0x1000, 0x2FFF, 0x7FFF, 0x3A00, 0x6D00, 0x4400, 0x2A00 }, + { 32000, 16, 1, 0x0E00, 0x3FFF, 0x7FFF, 0x3A00, 0x6D00, 0x4400, 0x2A00 }, + { 32000, 16, 1, 0x0C00, 0x4FFF, 0x7FFF, 0x3A00, 0x6D00, 0x4400, 0x2A00 }, + { 32000, 16, 1, 0x0C00, 0x2FFF, 0x7FFF, 0x4000, 0x6E00, 0x3F00, 0x2A00 }, + { 32000, 16, 1, 0x0A00, 0x47FF, 0x7FFF, 0x4100, 0x6E00, 0x4400, 0x2A80 }, + { 32000, 20, 1, 0x0800, 0x37FF, 0x7FFF, 0x34C0, 0x6280, 0x4000, 0x1B00 }, +#endif + { 27000, 16, 1, 0x0800, 0x2FFF, 0x7FFF, 0x2500, 0x5500, 0x7400, 0x2400 }, + { 27000, 16, 1, 0x0800, 0x3FFF, 0x7FFF, 0x2500, 0x5500, 0x7400, 0x2400 }, + { 27000, 16, 1, 0x1000, 0x2FFF, 0x7FFF, 0x2500, 0x5500, 0x7400, 0x2400 }, + { 27000, 16, 1, 0x1000, 0x3FFF, 0x7FFF, 0x2500, 0x5500, 0x7400, 0x2400 }, + { 27000, 16, 1, 0x0C00, 0x4FFF, 0x7FFF, 0x2500, 0x5500, 0x7400, 0x2400 }, + { 32000, 14, 1, 0x0800, 0x2FFF, 0x7FFF, 0x2500, 0x5500, 0x7400, 0x2400 }, + { 32000, 12, 1, 0x0800, 0x2FFF, 0x7FFF, 0x2500, 0x5500, 0x7400, 0x2400 }, + { 32000, 10, 1, 0x0800, 0x2FFF, 0x7FFF, 0x2500, 0x5500, 0x7400, 0x2400 }, + { 32000, 8, 1, 0x0800, 0x2FFF, 0x7FFF, 0x2500, 0x5500, 0x7400, 0x2400 }, + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } +}; +#endif +// gAudioCosineTable[k] = round((2**15 - 1) * cos(pi/2 * k / 127)). Unused. +#if defined(VERSION_JP) || defined(VERSION_US) +u16 gAudioCosineTable[128] = { + 0x7FFF, 32764, 32757, 32744, 32727, 32704, 32677, 32644, 32607, 32564, 32517, 32464, 32407, + 32344, 32277, 32205, 32127, 32045, 31958, 31866, 31770, 31668, 31561, 31450, 31334, 31213, + 31087, 30957, 30822, 30682, 30537, 30388, 30234, 30075, 29912, 29744, 29572, 29395, 29214, + 29028, 28838, 28643, 28444, 28241, 28033, 27821, 27605, 27385, 27160, 26931, 26698, 26461, + 26220, 25975, 25726, 25473, 25216, 24956, 24691, 24423, 24151, 23875, 23596, 23313, 23026, + 22736, 22442, 22145, 21845, 21541, 21234, 20924, 20610, 20294, 19974, 19651, 19325, 18997, + 18665, 18331, 17993, 17653, 17310, 16965, 16617, 16266, 15913, 15558, 15200, 14840, 14477, + 14113, 13746, 13377, 13006, 12633, 12258, 11881, 11503, 11122, 10740, 10357, 9971, 9584, + 9196, 8806, 8415, 8023, 7630, 7235, 6839, 6442, 6044, 5646, 5246, 4845, 4444, + 4042, 3640, 3237, 2833, 2429, 2025, 1620, 1216, 810, 405, 0, +}; +#endif + +// Transforms a pitch scale factor in -127..127 into a frequency scale factor +// between -1 and +1 octave. +// gPitchBendFrequencyScale[k] = 0.5 * 2^(k/127) +#ifndef VERSION_SH +#if defined(VERSION_EU) +f32 gPitchBendFrequencyScale[256] = { + 0.5f, +#else +f32 gPitchBendFrequencyScale[255] = { +#endif + 0.5f, 0.502736f, 0.505488f, 0.508254f, 0.511036f, 0.513833f, 0.516645f, 0.519472f, 0.522315f, + 0.525174f, 0.528048f, 0.530938f, 0.533843f, 0.536765f, 0.539702f, 0.542656f, 0.545626f, 0.548612f, + 0.551614f, 0.554633f, 0.557669f, 0.560721f, 0.563789f, 0.566875f, 0.569977f, 0.573097f, 0.576233f, + 0.579387f, 0.582558f, 0.585746f, 0.588951f, 0.592175f, 0.595415f, 0.598674f, 0.601950f, 0.605245f, + 0.608557f, 0.611888f, 0.615236f, 0.618603f, 0.621989f, 0.625393f, 0.628815f, 0.632257f, 0.635717f, + 0.639196f, 0.642694f, 0.646212f, 0.649748f, 0.653304f, 0.656880f, 0.660475f, 0.664089f, 0.667724f, + 0.671378f, 0.675052f, 0.678747f, 0.682461f, 0.686196f, 0.689952f, 0.693727f, 0.697524f, 0.701341f, + 0.705180f, 0.709039f, 0.712919f, 0.716821f, 0.720744f, 0.724689f, 0.728655f, 0.732642f, 0.736652f, + 0.740684f, 0.744737f, 0.748813f, 0.752911f, 0.757031f, 0.761175f, 0.765340f, 0.769529f, 0.773740f, + 0.777975f, 0.782232f, 0.786513f, 0.790818f, 0.795146f, 0.799497f, 0.803873f, 0.808272f, 0.812696f, + 0.817144f, 0.821616f, 0.826112f, 0.830633f, 0.835179f, 0.839750f, 0.844346f, 0.848966f, 0.853613f, + 0.858284f, 0.862982f, 0.867704f, 0.872453f, 0.877228f, 0.882029f, 0.886856f, 0.891709f, 0.896590f, + 0.901496f, 0.906430f, 0.911391f, 0.916379f, 0.921394f, 0.926436f, 0.931507f, 0.936604f, 0.941730f, + 0.946884f, 0.952066f, 0.957277f, 0.962516f, 0.967783f, 0.973080f, 0.978405f, 0.983760f, 0.989144f, + 0.994557f, 1.0f, 1.005473f, 1.010975f, 1.016508f, 1.022071f, 1.027665f, 1.033289f, 1.038944f, + 1.044630f, 1.050347f, 1.056095f, 1.061875f, 1.067687f, 1.073530f, 1.079405f, 1.085312f, 1.091252f, + 1.097224f, 1.103229f, 1.109267f, 1.115337f, 1.121441f, 1.127579f, 1.133750f, 1.139955f, 1.146193f, + 1.152466f, 1.158773f, 1.165115f, 1.171491f, 1.177903f, 1.184349f, 1.190831f, 1.197348f, 1.203901f, + 1.210489f, 1.217114f, 1.223775f, 1.230473f, 1.237207f, 1.243978f, 1.250786f, 1.257631f, 1.264514f, + 1.271434f, 1.278392f, 1.285389f, 1.292423f, 1.299497f, 1.306608f, 1.313759f, 1.320949f, 1.328178f, + 1.335447f, 1.342756f, 1.350104f, 1.357493f, 1.364922f, 1.372392f, 1.379903f, 1.387455f, 1.395048f, + 1.402683f, 1.410360f, 1.418078f, 1.425839f, 1.433642f, 1.441488f, 1.449377f, 1.457309f, 1.465285f, + 1.473304f, 1.481367f, 1.489474f, 1.497626f, 1.505822f, 1.514063f, 1.522349f, 1.530681f, 1.539058f, + 1.547481f, 1.555950f, 1.564465f, 1.573027f, 1.581636f, 1.590292f, 1.598995f, 1.607746f, 1.616545f, + 1.625392f, 1.634287f, 1.643231f, 1.652224f, 1.661266f, 1.670358f, 1.679500f, 1.688691f, 1.697933f, + 1.707225f, 1.716569f, 1.725963f, 1.735409f, 1.744906f, 1.754456f, 1.764058f, 1.773712f, 1.783419f, + 1.793179f, 1.802993f, 1.812860f, 1.822782f, 1.832757f, 1.842788f, 1.852873f, 1.863013f, 1.873209f, + 1.883461f, 1.893768f, 1.904132f, 1.914553f, 1.925031f, 1.935567f, 1.946159f, 1.956810f, 1.967520f, + 1.978287f, 1.989114f, 2.0f +}; + +// Frequencies for notes using the standard twelve-tone equal temperament scale. +// For indices 0..116, gNoteFrequencies[k] = 2^((k-39)/12). +// For indices 117..128, gNoteFrequencies[k] = 0.5 * 2^((k-39)/12). +// The 39 in the formula refers to piano key 40 (middle C, at 256 Hz) being +// the reference frequency, which is assigned value 1. +// clang-format off +f32 gNoteFrequencies[128] = { + 0.105112f, 0.111362f, 0.117984f, 0.125f, 0.132433f, 0.140308f, 0.148651f, 0.15749f, 0.166855f, 0.176777f, 0.187288f, 0.198425f, + 0.210224f, 0.222725f, 0.235969f, 0.25f, 0.264866f, 0.280616f, 0.297302f, 0.31498f, 0.33371f, 0.353553f, 0.374577f, 0.39685f, + 0.420448f, 0.445449f, 0.471937f, 0.5f, 0.529732f, 0.561231f, 0.594604f, 0.629961f, 0.66742f, 0.707107f, 0.749154f, 0.793701f, + 0.840897f, 0.890899f, 0.943875f, 1.0f, 1.059463f, 1.122462f, 1.189207f, 1.259921f, 1.33484f, 1.414214f, 1.498307f, 1.587401f, + 1.681793f, 1.781798f, 1.887749f, 2.0f, 2.118926f, 2.244924f, 2.378414f, 2.519842f, 2.66968f, 2.828428f, 2.996615f, 3.174803f, + 3.363586f, 3.563596f, 3.775498f, 4.0f, 4.237853f, 4.489849f, 4.756829f, 5.039685f, 5.33936f, 5.656855f, 5.993229f, 6.349606f, + 6.727173f, 7.127192f, 7.550996f, 8.0f, 8.475705f, 8.979697f, 9.513658f, 10.07937f, 10.67872f, 11.31371f, 11.986459f, 12.699211f, + 13.454346f, 14.254383f, 15.101993f, 16.0f, 16.95141f, 17.959394f, 19.027315f, 20.15874f, 21.35744f, 22.62742f, 23.972918f, 25.398422f, + 26.908691f, 28.508766f, 30.203985f, 32.0f, 33.90282f, 35.91879f, 38.05463f, 40.31748f, 42.71488f, 45.25484f, 47.945835f, 50.796844f, + 53.817383f, 57.017532f, 60.40797f, 64.0f, 67.80564f, 71.83758f, 76.10926f, 80.63496f, 85.42976f, 45.25484f, 47.945835f, 50.796844f, + 53.817383f, 57.017532f, 60.40797f, 64.0f, 67.80564f, 71.83758f, 76.10926f, 80.63496f +}; +// clang-format on + +// goes up by ~12 at each step for the first 4 values (starting from 0), then by ~6 +u8 gDefaultShortNoteVelocityTable[16] = { + 12, 25, 38, 51, 57, 64, 71, 76, 83, 89, 96, 102, 109, 115, 121, 127, +}; + +// goes down by 26 at each step for the first 4 values (starting from 255), then by ~12 +u8 gDefaultShortNoteDurationTable[16] = { + 229, 203, 177, 151, 139, 126, 113, 100, 87, 74, 61, 48, 36, 23, 10, 0, +}; + +#if defined(VERSION_JP) || defined(VERSION_US) +// gVibratoCurve[k] = k*8 +s8 gVibratoCurve[16] = { 0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120 }; +#endif + +struct AdsrEnvelope gDefaultEnvelope[] = { + { BSWAP16(4), BSWAP16(32000) }, // go from 0 to 32000 over the course of 16ms + { BSWAP16(1000), BSWAP16(32000) }, // stay there for 4.16 seconds + { BSWAP16(ADSR_HANG), 0 } // then continue staying there +}; +#endif + +#ifdef VERSION_EU +struct NoteSubEu gZeroNoteSub = { 0 }; +struct NoteSubEu gDefaultNoteSub = { 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, { NULL } }; +#endif + +#if defined(VERSION_EU) || defined(VERSION_SH) +s16 sSawtoothWaves[256] = { + 0, 1023, 2047, 3071, 4095, 5119, 6143, 7167, 8191, 9215, 10239, + 11263, 0x2FFF, 13311, 0x37FF, 15359, 0x3FFF, 17407, 0x47FF, 19455, 0x4FFF, 21503, + 22527, 23551, 24575, 25599, 26623, 27647, 28671, 29695, 30719, 31743, -0x7FFF, + -31743, -30719, -29695, -28671, -27647, -26623, -25599, -24575, -23551, -22527, -21503, + -0x4FFF, -19455, -0x47FF, -17407, -0x3FFF, -15359, -0x37FF, -13311, -0x2FFF, -11263, -10239, + -9215, -8191, -7167, -6143, -5119, -4095, -3071, -2047, -1023, + 0, 0x7FF, 0xFFF, 0x17FF, 0x1FFF, 0x27FF, 0x2FFF, 0x37FF, 0x3FFF, 0x47FF, 0x4FFF, + 0x57FF, 0x5FFF, 0x67FF, 0x6FFF, 0x77FF, 0x8001, 0x8801, 0x9001, 0x9801, 0xa001, 0xa801, + 0xb001, 0xb801, 0xc001, 0xc801, 0xd001, 0xd801, 0xe001, 0xe801, 0xf001, 0xf801, 0x0000, + 0x07ff, 0x0fff, 0x17ff, 0x1fff, 0x27ff, 0x2fff, 0x37ff, 0x3fff, 0x47ff, 0x4fff, 0x57ff, + 0x5fff, 0x67ff, 0x6fff, 0x77ff, 0x8001, 0x8801, 0x9001, 0x9801, 0xa001, 0xa801, 0xb001, + 0xb801, 0xc001, 0xc801, 0xd001, 0xd801, 0xe001, 0xe801, 0xf001, 0xf801, + 0x0000, 0x0fff, 0x1fff, 0x2fff, 0x3fff, 0x4fff, 0x5fff, 0x6fff, + 0x8001, 0x9001, 0xa001, 0xb001, 0xc001, 0xd001, 0xe001, 0xf001, + 0x0000, 0x0fff, 0x1fff, 0x2fff, 0x3fff, 0x4fff, 0x5fff, 0x6fff, + 0x8001, 0x9001, 0xa001, 0xb001, 0xc001, 0xd001, 0xe001, 0xf001, + 0x0000, 0x0fff, 0x1fff, 0x2fff, 0x3fff, 0x4fff, 0x5fff, 0x6fff, + 0x8001, 0x9001, 0xa001, 0xb001, 0xc001, 0xd001, 0xe001, 0xf001, + 0x0000, 0x0fff, 0x1fff, 0x2fff, 0x3fff, 0x4fff, 0x5fff, 0x6fff, + 0x8001, 0x9001, 0xa001, 0xb001, 0xc001, 0xd001, 0xe001, 0xf001, + 0x0000, 0x1fff, 0x3fff, 0x5fff, 0x8001, 0xa001, 0xc001, 0xe001, + 0x0000, 0x1fff, 0x3fff, 0x5fff, 0x8001, 0xa001, 0xc001, 0xe001, + 0x0000, 0x1fff, 0x3fff, 0x5fff, 0x8001, 0xa001, 0xc001, 0xe001, + 0x0000, 0x1fff, 0x3fff, 0x5fff, 0x8001, 0xa001, 0xc001, 0xe001, + 0x0000, 0x1fff, 0x3fff, 0x5fff, 0x8001, 0xa001, 0xc001, 0xe001, + 0x0000, 0x1fff, 0x3fff, 0x5fff, 0x8001, 0xa001, 0xc001, 0xe001, + 0x0000, 0x1fff, 0x3fff, 0x5fff, 0x8001, 0xa001, 0xc001, 0xe001, + 0x0000, 0x1fff, 0x3fff, 0x5fff, 0x8001, 0xa001, 0xc001, 0xe001 +}; +s16 sTriangleWaves[256] = { + 0x0000, 0x07ff, 0x0fff, 0x17ff, 0x1fff, 0x27ff, 0x2fff, 0x37ff, 0x3fff, 0x47ff, 0x4fff, 0x57ff, + 0x5fff, 0x67ff, 0x6fff, 0x77ff, 0x7fff, 0x77ff, 0x6fff, 0x67ff, 0x5fff, 0x57ff, 0x4fff, 0x47ff, + 0x3fff, 0x37ff, 0x2fff, 0x27ff, 0x1fff, 0x17ff, 0x0fff, 0x07ff, 0x0000, 0xf801, 0xf001, 0xe801, + 0xe001, 0xd801, 0xd001, 0xc801, 0xc001, 0xb801, 0xb001, 0xa801, 0xa001, 0x9801, 0x9001, 0x8801, + 0x8001, 0x8801, 0x9001, 0x9801, 0xa001, 0xa801, 0xb001, 0xb801, 0xc001, 0xc801, 0xd001, 0xd801, + 0xe001, 0xe801, 0xf001, 0xf801, 0x0000, 0x0fff, 0x1fff, 0x2fff, 0x3fff, 0x4fff, 0x5fff, 0x6fff, + 0x7fff, 0x6fff, 0x5fff, 0x4fff, 0x3fff, 0x2fff, 0x1fff, 0x0fff, 0x0000, 0xf001, 0xe001, 0xd001, + 0xc001, 0xb001, 0xa001, 0x9001, 0x8001, 0x9001, 0xa001, 0xb001, 0xc001, 0xd001, 0xe001, 0xf001, + 0x0000, 0x0fff, 0x1fff, 0x2fff, 0x3fff, 0x4fff, 0x5fff, 0x6fff, 0x7fff, 0x6fff, 0x5fff, 0x4fff, + 0x3fff, 0x2fff, 0x1fff, 0x0fff, 0x0000, 0xf001, 0xe001, 0xd001, 0xc001, 0xb001, 0xa001, 0x9001, + 0x8001, 0x9001, 0xa001, 0xb001, 0xc001, 0xd001, 0xe001, 0xf001, 0x0000, 0x1fff, 0x3fff, 0x5fff, + 0x7fff, 0x5fff, 0x3fff, 0x1fff, 0x0000, 0xe001, 0xc001, 0xa001, 0x8001, 0xa001, 0xc001, 0xe001, + 0x0000, 0x1fff, 0x3fff, 0x5fff, 0x7fff, 0x5fff, 0x3fff, 0x1fff, 0x0000, 0xe001, 0xc001, 0xa001, + 0x8001, 0xa001, 0xc001, 0xe001, 0x0000, 0x1fff, 0x3fff, 0x5fff, 0x7fff, 0x5fff, 0x3fff, 0x1fff, + 0x0000, 0xe001, 0xc001, 0xa001, 0x8001, 0xa001, 0xc001, 0xe001, 0x0000, 0x1fff, 0x3fff, 0x5fff, + 0x7fff, 0x5fff, 0x3fff, 0x1fff, 0x0000, 0xe001, 0xc001, 0xa001, 0x8001, 0xa001, 0xc001, 0xe001, + 0x0000, 0x3fff, 0x7fff, 0x3fff, 0x0000, 0xc001, 0x8001, 0xc001, 0x0000, 0x3fff, 0x7fff, 0x3fff, + 0x0000, 0xc001, 0x8001, 0xc001, 0x0000, 0x3fff, 0x7fff, 0x3fff, 0x0000, 0xc001, 0x8001, 0xc001, + 0x0000, 0x3fff, 0x7fff, 0x3fff, 0x0000, 0xc001, 0x8001, 0xc001, 0x0000, 0x3fff, 0x7fff, 0x3fff, + 0x0000, 0xc001, 0x8001, 0xc001, 0x0000, 0x3fff, 0x7fff, 0x3fff, 0x0000, 0xc001, 0x8001, 0xc001, + 0x0000, 0x3fff, 0x7fff, 0x3fff, 0x0000, 0xc001, 0x8001, 0xc001, 0x0000, 0x3fff, 0x7fff, 0x3fff, + 0x0000, 0xc001, 0x8001, 0xc001, +}; +s16 sSineWaves[256] = { + 0x0000, 0x0c8b, 0x18f8, 0x2527, 0x30fb, 0x3c56, 0x471c, 0x5133, 0x5a81, 0x62f1, 0x6a6c, 0x70e1, + 0x7640, 0x7a7c, 0x7d89, 0x7f61, 0x7fff, 0x7f61, 0x7d89, 0x7a7c, 0x7640, 0x70e1, 0x6a6c, 0x62f1, + 0x5a81, 0x5133, 0x471c, 0x3c56, 0x30fb, 0x2527, 0x18f8, 0x0c8b, 0x0000, 0xf375, 0xe708, 0xdad9, + 0xcf05, 0xc3aa, 0xb8e4, 0xaecd, 0xa57f, 0x9d0f, 0x9594, 0x8f1f, 0x89c0, 0x8584, 0x8277, 0x809f, + 0x8001, 0x809f, 0x8277, 0x8584, 0x89c0, 0x8f1f, 0x9594, 0x9d0f, 0xa57f, 0xaecd, 0xb8e4, 0xc3aa, + 0xcf05, 0xdad9, 0xe708, 0xf375, 0x0000, 0x18f8, 0x30fb, 0x471c, 0x5a81, 0x6a6c, 0x7640, 0x7d89, + 0x7fff, 0x7d89, 0x7640, 0x6a6c, 0x5a81, 0x471c, 0x30fb, 0x18f8, 0x0000, 0xe708, 0xcf05, 0xb8e4, + 0xa57f, 0x9594, 0x89c0, 0x8277, 0x8001, 0x8277, 0x89c0, 0x9594, 0xa57f, 0xb8e4, 0xcf05, 0xe708, + 0x0000, 0x18f8, 0x30fb, 0x471c, 0x5a81, 0x6a6c, 0x7640, 0x7d89, 0x7fff, 0x7d89, 0x7640, 0x6a6c, + 0x5a81, 0x471c, 0x30fb, 0x18f8, 0x0000, 0xe708, 0xcf05, 0xb8e4, 0xa57f, 0x9594, 0x89c0, 0x8277, + 0x8001, 0x8277, 0x89c0, 0x9594, 0xa57f, 0xb8e4, 0xcf05, 0xe708, 0x0000, 0x30fb, 0x5a81, 0x7640, + 0x7fff, 0x7640, 0x5a81, 0x30fb, 0x0000, 0xcf05, 0xa57f, 0x89c0, 0x8001, 0x89c0, 0xa57f, 0xcf05, + 0x0000, 0x30fb, 0x5a81, 0x7640, 0x7fff, 0x7640, 0x5a81, 0x30fb, 0x0000, 0xcf05, 0xa57f, 0x89c0, + 0x8001, 0x89c0, 0xa57f, 0xcf05, 0x0000, 0x30fb, 0x5a81, 0x7640, 0x7fff, 0x7640, 0x5a81, 0x30fb, + 0x0000, 0xcf05, 0xa57f, 0x89c0, 0x8001, 0x89c0, 0xa57f, 0xcf05, 0x0000, 0x30fb, 0x5a81, 0x7640, + 0x7fff, 0x7640, 0x5a81, 0x30fb, 0x0000, 0xcf05, 0xa57f, 0x89c0, 0x8001, 0x89c0, 0xa57f, 0xcf05, + 0x0000, 0x5a81, 0x7fff, 0x5a81, 0x0000, 0xa57f, 0x8001, 0xa57f, 0x0000, 0x5a81, 0x7fff, 0x5a81, + 0x0000, 0xa57f, 0x8001, 0xa57f, 0x0000, 0x5a81, 0x7fff, 0x5a81, 0x0000, 0xa57f, 0x8001, 0xa57f, + 0x0000, 0x5a81, 0x7fff, 0x5a81, 0x0000, 0xa57f, 0x8001, 0xa57f, 0x0000, 0x5a81, 0x7fff, 0x5a81, + 0x0000, 0xa57f, 0x8001, 0xa57f, 0x0000, 0x5a81, 0x7fff, 0x5a81, 0x0000, 0xa57f, 0x8001, 0xa57f, + 0x0000, 0x5a81, 0x7fff, 0x5a81, 0x0000, 0xa57f, 0x8001, 0xa57f, 0x0000, 0x5a81, 0x7fff, 0x5a81, + 0x0000, 0xa57f, 0x8001, 0xa57f, +}; +s16 sSquareWaves[256] = { + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, + 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, + 0x8001, 0x8001, 0x8001, 0x8001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7fff, 0x7fff, 0x7fff, 0x7fff, + 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x0000, 0x0000, 0x0000, 0x0000, + 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x0000, 0x0000, 0x0000, 0x0000, 0x8001, 0x8001, 0x8001, 0x8001, + 0x0000, 0x0000, 0x0000, 0x0000, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x0000, 0x0000, 0x0000, 0x0000, + 0x8001, 0x8001, 0x8001, 0x8001, 0x0000, 0x0000, 0x0000, 0x0000, 0x7fff, 0x7fff, 0x7fff, 0x7fff, + 0x0000, 0x0000, 0x0000, 0x0000, 0x8001, 0x8001, 0x8001, 0x8001, 0x0000, 0x0000, 0x0000, 0x0000, + 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x0000, 0x0000, 0x0000, 0x0000, 0x8001, 0x8001, 0x8001, 0x8001, + 0x0000, 0x0000, 0x7fff, 0x7fff, 0x0000, 0x0000, 0x8001, 0x8001, 0x0000, 0x0000, 0x7fff, 0x7fff, + 0x0000, 0x0000, 0x8001, 0x8001, 0x0000, 0x0000, 0x7fff, 0x7fff, 0x0000, 0x0000, 0x8001, 0x8001, + 0x0000, 0x0000, 0x7fff, 0x7fff, 0x0000, 0x0000, 0x8001, 0x8001, 0x0000, 0x0000, 0x7fff, 0x7fff, + 0x0000, 0x0000, 0x8001, 0x8001, 0x0000, 0x0000, 0x7fff, 0x7fff, 0x0000, 0x0000, 0x8001, 0x8001, + 0x0000, 0x0000, 0x7fff, 0x7fff, 0x0000, 0x0000, 0x8001, 0x8001, 0x0000, 0x0000, 0x7fff, 0x7fff, + 0x0000, 0x0000, 0x8001, 0x8001, +}; +s16 sEuUnknownWave6[256] = { + 0x0000, 0x9ba7, 0x9b41, 0x6c9b, 0x9450, 0xadda, 0x569e, 0x189a, 0x69bf, 0xb79d, 0x6fe9, 0x08ec, + 0x0d34, 0x1aea, 0xce76, 0xad86, 0x2710, 0xa038, 0x7e28, 0x2fd8, 0x3af8, 0x3bfa, 0xd10b, 0x84c7, + 0xcd7f, 0x18f4, 0xd4c8, 0x76f8, 0x8994, 0xaa11, 0x73fb, 0x6c01, 0x0000, 0x93ff, 0x8c05, 0x55ef, + 0x766c, 0x8907, 0x2b38, 0xe70d, 0x3281, 0x7b38, 0x2ef5, 0xc407, 0xc508, 0xd027, 0x81d8, 0x5fc9, + 0xd8f0, 0x5279, 0x318a, 0xe517, 0xf2cc, 0xf713, 0x9017, 0x4864, 0x9641, 0xe765, 0xa962, 0x5227, + 0x6bb0, 0x9364, 0x64bf, 0x645a, 0x0000, 0x9b41, 0x9450, 0x569e, 0x69bf, 0x6fe9, 0x0d34, 0xce76, + 0x2710, 0x7e28, 0x3af8, 0xd10b, 0xcd7f, 0xd4c8, 0x8994, 0x73fb, 0x0000, 0x8c05, 0x766c, 0x2b38, + 0x3281, 0x2ef5, 0xc508, 0x81d8, 0xd8f0, 0x318a, 0xf2cc, 0x9017, 0x9641, 0xa962, 0x6bb0, 0x64bf, + 0x0000, 0x9b41, 0x9450, 0x569e, 0x69bf, 0x6fe9, 0x0d34, 0xce76, 0x2710, 0x7e28, 0x3af8, 0xd10b, + 0xcd7f, 0xd4c8, 0x8994, 0x73fb, 0x0000, 0x8c05, 0x766c, 0x2b38, 0x3281, 0x2ef5, 0xc508, 0x81d8, + 0xd8f0, 0x318a, 0xf2cc, 0x9017, 0x9641, 0xa962, 0x6bb0, 0x64bf, 0x0000, 0x9450, 0x69bf, 0x0d34, + 0x2710, 0x3af8, 0xcd7f, 0x8994, 0x0000, 0x766c, 0x3281, 0xc508, 0xd8f0, 0xf2cc, 0x9641, 0x6bb0, + 0x0000, 0x9450, 0x69bf, 0x0d34, 0x2710, 0x3af8, 0xcd7f, 0x8994, 0x0000, 0x766c, 0x3281, 0xc508, + 0xd8f0, 0xf2cc, 0x9641, 0x6bb0, 0x0000, 0x9450, 0x69bf, 0x0d34, 0x2710, 0x3af8, 0xcd7f, 0x8994, + 0x0000, 0x766c, 0x3281, 0xc508, 0xd8f0, 0xf2cc, 0x9641, 0x6bb0, 0x0000, 0x9450, 0x69bf, 0x0d34, + 0x2710, 0x3af8, 0xcd7f, 0x8994, 0x0000, 0x766c, 0x3281, 0xc508, 0xd8f0, 0xf2cc, 0x9641, 0x6bb0, + 0x0000, 0x69bf, 0x2710, 0xcd7f, 0x0000, 0x3281, 0xd8f0, 0x9641, 0x0000, 0x69bf, 0x2710, 0xcd7f, + 0x0000, 0x3281, 0xd8f0, 0x9641, 0x0000, 0x69bf, 0x2710, 0xcd7f, 0x0000, 0x3281, 0xd8f0, 0x9641, + 0x0000, 0x69bf, 0x2710, 0xcd7f, 0x0000, 0x3281, 0xd8f0, 0x9641, 0x0000, 0x69bf, 0x2710, 0xcd7f, + 0x0000, 0x3281, 0xd8f0, 0x9641, 0x0000, 0x69bf, 0x2710, 0xcd7f, 0x0000, 0x3281, 0xd8f0, 0x9641, + 0x0000, 0x69bf, 0x2710, 0xcd7f, 0x0000, 0x3281, 0xd8f0, 0x9641, 0x0000, 0x69bf, 0x2710, 0xcd7f, + 0x0000, 0x3281, 0xd8f0, 0x9641, +}; +s16 gEuUnknownWave7[256] = { + 0x0000, 0x3fbc, 0x4eb4, 0x4f21, 0x6a49, 0x806f, 0x7250, 0x6a7b, 0x8d2e, 0xac0a, 0x98d6, 0x7832, + 0x7551, 0x71ca, 0x4eee, 0x3731, 0x4e20, 0x644d, 0x4a50, 0x23ba, 0x1b09, 0x119a, 0xe914, 0xccbe, + 0xe14e, 0xf8a3, 0xe47e, 0xc937, 0xd181, 0xde39, 0xcfc6, 0xcf94, 0x0000, 0x306c, 0x303a, 0x21c7, + 0x2e7f, 0x36c8, 0x1b82, 0x075e, 0x1eb2, 0x3341, 0x16ec, 0xee67, 0xe4f7, 0xdc45, 0xb5b0, 0x9bb4, + 0xb1e0, 0xc8ce, 0xb112, 0x8e37, 0x8aaf, 0x87cd, 0x672a, 0x53f7, 0x72d2, 0x9584, 0x8db0, 0x7f92, + 0x95b7, 0xb0de, 0xb14c, 0xc045, 0x0000, 0x4eb4, 0x6a49, 0x7250, 0x8d2e, 0x98d6, 0x7551, 0x4eee, + 0x4e20, 0x4a50, 0x1b09, 0xe914, 0xe14e, 0xe47e, 0xd181, 0xcfc6, 0x0000, 0x303a, 0x2e7f, 0x1b82, + 0x1eb2, 0x16ec, 0xe4f7, 0xb5b0, 0xb1e0, 0xb112, 0x8aaf, 0x672a, 0x72d2, 0x8db0, 0x95b7, 0xb14c, + 0x0000, 0x4eb4, 0x6a49, 0x7250, 0x8d2e, 0x98d6, 0x7551, 0x4eee, 0x4e20, 0x4a50, 0x1b09, 0xe914, + 0xe14e, 0xe47e, 0xd181, 0xcfc6, 0x0000, 0x303a, 0x2e7f, 0x1b82, 0x1eb2, 0x16ec, 0xe4f7, 0xb5b0, + 0xb1e0, 0xb112, 0x8aaf, 0x672a, 0x72d2, 0x8db0, 0x95b7, 0xb14c, 0x0000, 0x6a49, 0x8d2e, 0x7551, + 0x4e20, 0x1b09, 0xe14e, 0xd181, 0x0000, 0x2e7f, 0x1eb2, 0xe4f7, 0xb1e0, 0x8aaf, 0x72d2, 0x95b7, + 0x0000, 0x6a49, 0x8d2e, 0x7551, 0x4e20, 0x1b09, 0xe14e, 0xd181, 0x0000, 0x2e7f, 0x1eb2, 0xe4f7, + 0xb1e0, 0x8aaf, 0x72d2, 0x95b7, 0x0000, 0x6a49, 0x8d2e, 0x7551, 0x4e20, 0x1b09, 0xe14e, 0xd181, + 0x0000, 0x2e7f, 0x1eb2, 0xe4f7, 0xb1e0, 0x8aaf, 0x72d2, 0x95b7, 0x0000, 0x6a49, 0x8d2e, 0x7551, + 0x4e20, 0x1b09, 0xe14e, 0xd181, 0x0000, 0x2e7f, 0x1eb2, 0xe4f7, 0xb1e0, 0x8aaf, 0x72d2, 0x95b7, + 0x0000, 0x8d2e, 0x4e20, 0xe14e, 0x0000, 0x1eb2, 0xb1e0, 0x72d2, 0x0000, 0x8d2e, 0x4e20, 0xe14e, + 0x0000, 0x1eb2, 0xb1e0, 0x72d2, 0x0000, 0x8d2e, 0x4e20, 0xe14e, 0x0000, 0x1eb2, 0xb1e0, 0x72d2, + 0x0000, 0x8d2e, 0x4e20, 0xe14e, 0x0000, 0x1eb2, 0xb1e0, 0x72d2, 0x0000, 0x8d2e, 0x4e20, 0xe14e, + 0x0000, 0x1eb2, 0xb1e0, 0x72d2, 0x0000, 0x8d2e, 0x4e20, 0xe14e, 0x0000, 0x1eb2, 0xb1e0, 0x72d2, + 0x0000, 0x8d2e, 0x4e20, 0xe14e, 0x0000, 0x1eb2, 0xb1e0, 0x72d2, 0x0000, 0x8d2e, 0x4e20, 0xe14e, + 0x0000, 0x1eb2, 0xb1e0, 0x72d2, +}; +s16 *gWaveSamples[6] = { sSawtoothWaves, sTriangleWaves, sSineWaves, sSquareWaves, sEuUnknownWave6, gEuUnknownWave7 }; + +#else +// !VERSION_EU + +s16 sSineWave[0x40] = { + 0, 3211, 6392, 9511, 12539, 15446, 18204, 20787, 23169, 25329, 27244, + 28897, 30272, 31356, 32137, 32609, 0x7FFF, 32609, 32137, 31356, 30272, 28897, + 27244, 25329, 23169, 20787, 18204, 15446, 12539, 9511, 6392, 3211, 0, + -3211, -6392, -9511, -12539, -15446, -18204, -20787, -23169, -25329, -27244, -28897, + -30272, -31356, -32137, -32609, -0x7FFF, -32609, -32137, -31356, -30272, -28897, -27244, + -25329, -23169, -20787, -18204, -15446, -12539, -9511, -6392, -3211, +}; + +s16 sSquareWave[0x40] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, + 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, + -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, +}; +s16 sTriangleWave[0x40] = { + 0, 0x7FF, 0xFFF, 0x17FF, 0x1FFF, 0x27FF, 0x2FFF, 0x37FF, 0x3FFF, 0x47FF, 0x4FFF, + 0x57FF, 0x5FFF, 0x67FF, 0x6FFF, 0x77FF, 0x7FFF, 0x77FF, 0x6FFF, 0x67FF, 0x5FFF, 0x57FF, + 0x4FFF, 0x47FF, 0x3FFF, 0x37FF, 0x2FFF, 0x27FF, 0x1FFF, 0x17FF, 0xFFF, 0x7FF, 0, + -0x7FF, -0xFFF, -0x17FF, -0x1FFF, -10239, -0x2FFF, -0x37FF, -0x3FFF, -0x47FF, -0x4FFF, -22527, + -24575, -26623, -28671, -30719, -0x7FFF, -30719, -28671, -26623, -24575, -22527, -0x4FFF, + -0x47FF, -0x3FFF, -0x37FF, -0x2FFF, -0x27FF, -0x1FFF, -0x17FF, -0xFFF, -0x7FF, +}; + +s16 sSawtoothWave[0x40] = { + 0, 1023, 2047, 3071, 4095, 5119, 6143, 7167, 8191, 9215, 10239, + 11263, 0x2FFF, 13311, 0x37FF, 15359, 0x3FFF, 17407, 0x47FF, 19455, 0x4FFF, 21503, + 22527, 23551, 24575, 25599, 26623, 27647, 28671, 29695, 30719, 31743, -0x7FFF, + -31743, -30719, -29695, -28671, -27647, -26623, -25599, -24575, -23551, -22527, -21503, + -0x4FFF, -19455, -0x47FF, -17407, -0x3FFF, -15359, -0x37FF, -13311, -0x2FFF, -11263, -10239, + -9215, -8191, -7167, -6143, -5119, -4095, -3071, -2047, -1023, +}; +s16 *gWaveSamples[4] = { sSawtoothWave, sTriangleWave, sSineWave, sSquareWave }; +#endif + +#ifdef VERSION_SH +s32 unk_sh_data_0[2] = {0, 0}; +f32 gPitchBendFrequencyScale[256] = { + 0.5f, 0.5f, 0.502736f, 0.505488f, 0.508254f, 0.511036f, 0.513833f, 0.516645f, 0.519472f, + 0.522315f, 0.525174f, 0.528048f, 0.530938f, 0.533843f, 0.536765f, 0.539702f, 0.542656f, 0.545626f, + 0.548612f, 0.551614f, 0.554633f, 0.557669f, 0.560721f, 0.563789f, 0.566875f, 0.569977f, 0.573097f, + 0.576233f, 0.579387f, 0.582558f, 0.585746f, 0.588951f, 0.592175f, 0.595415f, 0.598674f, 0.601950f, + 0.605245f, 0.608557f, 0.611888f, 0.615236f, 0.618603f, 0.621989f, 0.625393f, 0.628815f, 0.632257f, + 0.635717f, 0.639196f, 0.642694f, 0.646212f, 0.649748f, 0.653304f, 0.656880f, 0.660475f, 0.664089f, + 0.667724f, 0.671378f, 0.675052f, 0.678747f, 0.682461f, 0.686196f, 0.689952f, 0.693727f, 0.697524f, + 0.701341f, 0.705180f, 0.709039f, 0.712919f, 0.716821f, 0.720744f, 0.724689f, 0.728655f, 0.732642f, + 0.736652f, 0.740684f, 0.744737f, 0.748813f, 0.752911f, 0.757031f, 0.761175f, 0.765340f, 0.769529f, + 0.773740f, 0.777975f, 0.782232f, 0.786513f, 0.790818f, 0.795146f, 0.799497f, 0.803873f, 0.808272f, + 0.812696f, 0.817144f, 0.821616f, 0.826112f, 0.830633f, 0.835179f, 0.839750f, 0.844346f, 0.848966f, + 0.853613f, 0.858284f, 0.862982f, 0.867704f, 0.872453f, 0.877228f, 0.882029f, 0.886856f, 0.891709f, + 0.896590f, 0.901496f, 0.906430f, 0.911391f, 0.916379f, 0.921394f, 0.926436f, 0.931507f, 0.936604f, + 0.941730f, 0.946884f, 0.952066f, 0.957277f, 0.962516f, 0.967783f, 0.973080f, 0.978405f, 0.983760f, + 0.989144f, 0.994557f, 1.0f, 1.005473f, 1.010975f, 1.016508f, 1.022071f, 1.027665f, 1.033289f, + 1.038944f, 1.044630f, 1.050347f, 1.056095f, 1.061875f, 1.067687f, 1.073530f, 1.079405f, 1.085312f, + 1.091252f, 1.097224f, 1.103229f, 1.109267f, 1.115337f, 1.121441f, 1.127579f, 1.133750f, 1.139955f, + 1.146193f, 1.152466f, 1.158773f, 1.165115f, 1.171491f, 1.177903f, 1.184349f, 1.190831f, 1.197348f, + 1.203901f, 1.210489f, 1.217114f, 1.223775f, 1.230473f, 1.237207f, 1.243978f, 1.250786f, 1.257631f, + 1.264514f, 1.271434f, 1.278392f, 1.285389f, 1.292423f, 1.299497f, 1.306608f, 1.313759f, 1.320949f, + 1.328178f, 1.335447f, 1.342756f, 1.350104f, 1.357493f, 1.364922f, 1.372392f, 1.379903f, 1.387455f, + 1.395048f, 1.402683f, 1.410360f, 1.418078f, 1.425839f, 1.433642f, 1.441488f, 1.449377f, 1.457309f, + 1.465285f, 1.473304f, 1.481367f, 1.489474f, 1.497626f, 1.505822f, 1.514063f, 1.522349f, 1.530681f, + 1.539058f, 1.547481f, 1.555950f, 1.564465f, 1.573027f, 1.581636f, 1.590292f, 1.598995f, 1.607746f, + 1.616545f, 1.625392f, 1.634287f, 1.643231f, 1.652224f, 1.661266f, 1.670358f, 1.679500f, 1.688691f, + 1.697933f, 1.707225f, 1.716569f, 1.725963f, 1.735409f, 1.744906f, 1.754456f, 1.764058f, 1.773712f, + 1.783419f, 1.793179f, 1.802993f, 1.812860f, 1.822782f, 1.832757f, 1.842788f, 1.852873f, 1.863013f, + 1.873209f, 1.883461f, 1.893768f, 1.904132f, 1.914553f, 1.925031f, 1.935567f, 1.946159f, 1.956810f, + 1.967520f, 1.978287f, 1.989114f, 2.0f +}; +#endif + +#ifdef VERSION_SH +f32 unk_sh_data_1[] = { + 0.890899f, 0.890899f, 0.89171f, 0.892521f, 0.893333f, 0.894146f, 0.89496f, 0.895774f, + 0.89659f, 0.897406f, 0.898222f, 0.89904f, 0.899858f, 0.900677f, 0.901496f, 0.902317f, + 0.903138f, 0.90396f, 0.904783f, 0.905606f, 0.90643f, 0.907255f, 0.908081f, 0.908907f, + 0.909734f, 0.910562f, 0.911391f, 0.91222f, 0.91305f, 0.913881f, 0.914713f, 0.915545f, + 0.916379f, 0.917213f, 0.918047f, 0.918883f, 0.919719f, 0.920556f, 0.921394f, 0.922232f, + 0.923072f, 0.923912f, 0.924752f, 0.925594f, 0.926436f, 0.927279f, 0.928123f, 0.928968f, + 0.929813f, 0.93066f, 0.931507f, 0.932354f, 0.933203f, 0.934052f, 0.934902f, 0.935753f, + 0.936604f, 0.937457f, 0.93831f, 0.939164f, 0.940019f, 0.940874f, 0.94173f, 0.942587f, + 0.943445f, 0.944304f, 0.945163f, 0.946023f, 0.946884f, 0.947746f, 0.948608f, 0.949472f, + 0.950336f, 0.951201f, 0.952066f, 0.952933f, 0.9538f, 0.954668f, 0.955537f, 0.956406f, + 0.957277f, 0.958148f, 0.95902f, 0.959893f, 0.960766f, 0.961641f, 0.962516f, 0.963392f, + 0.964268f, 0.965146f, 0.966024f, 0.966903f, 0.967783f, 0.968664f, 0.969546f, 0.970428f, + 0.971311f, 0.972195f, 0.97308f, 0.973965f, 0.974852f, 0.975739f, 0.976627f, 0.977516f, + 0.978405f, 0.979296f, 0.980187f, 0.981079f, 0.981972f, 0.982865f, 0.98376f, 0.984655f, + 0.985551f, 0.986448f, 0.987346f, 0.988244f, 0.989144f, 0.990044f, 0.990945f, 0.991847f, + 0.992749f, 0.993653f, 0.994557f, 0.995462f, 0.996368f, 0.997275f, 0.998182f, 0.999091f, + 1.0f, 1.00091f, 1.001821f, 1.002733f, 1.003645f, 1.004559f, 1.005473f, 1.006388f, + 1.007304f, 1.00822f, 1.009138f, 1.010056f, 1.010975f, 1.011896f, 1.012816f, 1.013738f, + 1.014661f, 1.015584f, 1.016508f, 1.017433f, 1.018359f, 1.019286f, 1.020214f, 1.021142f, + 1.022071f, 1.023002f, 1.023933f, 1.024864f, 1.025797f, 1.026731f, 1.027665f, 1.0286f, + 1.029536f, 1.030473f, 1.031411f, 1.03235f, 1.033289f, 1.03423f, 1.035171f, 1.036113f, + 1.037056f, 1.038f, 1.038944f, 1.03989f, 1.040836f, 1.041783f, 1.042731f, 1.04368f, + 1.04463f, 1.045581f, 1.046532f, 1.047485f, 1.048438f, 1.049392f, 1.050347f, 1.051303f, + 1.05226f, 1.053217f, 1.054176f, 1.055135f, 1.056095f, 1.057056f, 1.058018f, 1.058981f, + 1.059945f, 1.06091f, 1.061875f, 1.062842f, 1.063809f, 1.064777f, 1.065746f, 1.066716f, + 1.067687f, 1.068658f, 1.069631f, 1.070604f, 1.071578f, 1.072554f, 1.07353f, 1.074507f, + 1.075485f, 1.076463f, 1.077443f, 1.078424f, 1.079405f, 1.080387f, 1.08137f, 1.082355f, + 1.08334f, 1.084325f, 1.085312f, 1.0863f, 1.087289f, 1.088278f, 1.089268f, 1.09026f, + 1.091252f, 1.092245f, 1.093239f, 1.094234f, 1.09523f, 1.096226f, 1.097224f, 1.098223f, + 1.099222f, 1.100222f, 1.101224f, 1.102226f, 1.103229f, 1.104233f, 1.105238f, 1.106244f, + 1.10725f, 1.108258f, 1.109267f, 1.110276f, 1.111287f, 1.112298f, 1.11331f, 1.114323f, + 1.115337f, 1.116352f, 1.117368f, 1.118385f, 1.119403f, 1.120422f, 1.121441f, 1.122462f, +}; + +// Shindou moved these variables down here. :/ +// clang-format off +f32 gNoteFrequencies[128] = { + 0.105112f, 0.111362f, 0.117984f, 0.125f, 0.132433f, 0.140308f, 0.148651f, 0.15749f, 0.166855f, 0.176777f, 0.187288f, 0.198425f, + 0.210224f, 0.222725f, 0.235969f, 0.25f, 0.264866f, 0.280616f, 0.297302f, 0.31498f, 0.33371f, 0.353553f, 0.374577f, 0.39685f, + 0.420448f, 0.445449f, 0.471937f, 0.5f, 0.529732f, 0.561231f, 0.594604f, 0.629961f, 0.66742f, 0.707107f, 0.749154f, 0.793701f, + 0.840897f, 0.890899f, 0.943875f, 1.0f, 1.059463f, 1.122462f, 1.189207f, 1.259921f, 1.33484f, 1.414214f, 1.498307f, 1.587401f, + 1.681793f, 1.781798f, 1.887749f, 2.0f, 2.118926f, 2.244924f, 2.378414f, 2.519842f, 2.66968f, 2.828428f, 2.996615f, 3.174803f, + 3.363586f, 3.563596f, 3.775498f, 4.0f, 4.237853f, 4.489849f, 4.756829f, 5.039685f, 5.33936f, 5.656855f, 5.993229f, 6.349606f, + 6.727173f, 7.127192f, 7.550996f, 8.0f, 8.475705f, 8.979697f, 9.513658f, 10.07937f, 10.67872f, 11.31371f, 11.986459f, 12.699211f, + 13.454346f, 14.254383f, 15.101993f, 16.0f, 16.95141f, 17.959394f, 19.027315f, 20.15874f, 21.35744f, 22.62742f, 23.972918f, 25.398422f, + 26.908691f, 28.508766f, 30.203985f, 32.0f, 33.90282f, 35.91879f, 38.05463f, 40.31748f, 42.71488f, 45.25484f, 47.945835f, 50.796844f, + 53.817383f, 57.017532f, 60.40797f, 64.0f, 67.80564f, 71.83758f, 76.10926f, 80.63496f, 85.42976f, 45.25484f, 47.945835f, 50.796844f, + 53.817383f, 57.017532f, 60.40797f, 64.0f, 67.80564f, 71.83758f, 76.10926f, 80.63496f +}; +// clang-format on + +u8 gDefaultShortNoteVelocityTable[16] = { + 12, 25, 38, 51, 57, 64, 71, 76, 83, 89, 96, 102, 109, 115, 121, 127, +}; + +u8 gDefaultShortNoteDurationTable[16] = { + 229, 203, 177, 151, 139, 126, 113, 100, 87, 74, 61, 48, 36, 23, 10, 0, +}; + +struct AdsrEnvelope gDefaultEnvelope[] = { + { BSWAP16(4), BSWAP16(32000) }, // go from 0 to 32000 over the course of 16ms + { BSWAP16(1000), BSWAP16(32000) }, // stay there for 4.16 seconds + { BSWAP16(ADSR_HANG), 0 } // then continue staying there +}; + +u8 unk_sh_data2[4] = { 0, 0, 0, 0 }; + +struct NoteSubEu gZeroNoteSub = { 0 }; +struct NoteSubEu gDefaultNoteSub = { + 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, { NULL }, +#ifdef VERSION_SH + 0 +#endif +}; + +u16 gHeadsetPanQuantization[0x40] = { +0x3C, 0x3A, 0x38, 0x36, 0x34, 0x32, 0x30, 0x2E, +0x2C, 0x2A, 0x28, 0x26, 0x24, 0x22, 0x20, 0x1E, +0x1C, 0x1A, 0x18, 0x16, 0x14, 0x12, 0x10, 0x0E, +0x0C, 0x0A, 0x08, 0x06, 0x04, 0x02, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +}; +#endif + +#ifdef VERSION_EU +u8 euUnknownData_8030194c[4] = { 0x40, 0x20, 0x10, 0x08 }; +u16 gHeadsetPanQuantization[0x10] = { + 0x40, 0x40, 0x30, 0x30, 0x20, 0x20, 0x10, 0, 0, 0, +}; +#elif !defined(VERSION_SH) +u16 gHeadsetPanQuantization[10] = { 0x40, 0x30, 0x20, 0x10, 0, 0, 0, 0, 0, 0 }; +#endif + +#if defined(VERSION_EU) || defined(VERSION_SH) +s16 euUnknownData_80301950[64] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 500, 0, 0, 0, 0, 0, 0, 0, 500, 0, 0, 0, 0, 0, 0, 0, 500, 0, 0, 0, 0, 0, 0, 0, 500, 0, 0, 0, 0, +}; +#endif + +// Linearly interpolated between +// f(0/2 * 127) = 1 +// f(1/2 * 127) = 1/sqrt(2) +// f(2/2 * 127) = 0 +f32 gHeadsetPanVolume[128] = { + 1.0f, 0.995386f, 0.990772f, 0.986157f, 0.981543f, 0.976929f, 0.972315f, 0.967701f, 0.963087f, + 0.958472f, 0.953858f, 0.949244f, 0.94463f, 0.940016f, 0.935402f, 0.930787f, 0.926173f, 0.921559f, + 0.916945f, 0.912331f, 0.907717f, 0.903102f, 0.898488f, 0.893874f, 0.88926f, 0.884646f, 0.880031f, + 0.875417f, 0.870803f, 0.866189f, 0.861575f, 0.856961f, 0.852346f, 0.847732f, 0.843118f, 0.838504f, + 0.83389f, 0.829276f, 0.824661f, 0.820047f, 0.815433f, 0.810819f, 0.806205f, 0.801591f, 0.796976f, + 0.792362f, 0.787748f, 0.783134f, 0.77852f, 0.773906f, 0.769291f, 0.764677f, 0.760063f, 0.755449f, + 0.750835f, 0.74622f, 0.741606f, 0.736992f, 0.732378f, 0.727764f, 0.72315f, 0.718535f, 0.713921f, + 0.709307f, 0.70537f, 0.70211f, 0.69885f, 0.695591f, 0.692331f, 0.689071f, 0.685811f, 0.682551f, + 0.679291f, 0.676031f, 0.672772f, 0.669512f, 0.666252f, 0.662992f, 0.659732f, 0.656472f, 0.653213f, + 0.649953f, 0.646693f, 0.643433f, 0.640173f, 0.636913f, 0.633654f, 0.630394f, 0.627134f, 0.623874f, + 0.620614f, 0.617354f, 0.614094f, 0.610835f, 0.607575f, 0.604315f, 0.601055f, 0.597795f, 0.594535f, + 0.591276f, 0.588016f, 0.584756f, 0.581496f, 0.578236f, 0.574976f, 0.571717f, 0.568457f, 0.565197f, + 0.561937f, 0.558677f, 0.555417f, 0.552157f, 0.548898f, 0.545638f, 0.542378f, 0.539118f, 0.535858f, + 0.532598f, 0.529339f, 0.526079f, 0.522819f, 0.519559f, 0.516299f, 0.513039f, 0.50978f, 0.50652f, + 0.50326f, 0.5f +}; + +// Linearly interpolated between +// f(0/4 * 127) = 1/sqrt(2) +// f(1/4 * 127) = 1 +// f(2/4 * 127) = 1/sqrt(2) +// f(3/4 * 127) = 0 +// f(4/4 * 127) = 1/sqrt(8) +f32 gStereoPanVolume[128] = { + 0.707f, 0.716228f, 0.725457f, 0.734685f, 0.743913f, 0.753142f, 0.76237f, 0.771598f, 0.780827f, + 0.790055f, 0.799283f, 0.808512f, 0.81774f, 0.826968f, 0.836197f, 0.845425f, 0.854654f, 0.863882f, + 0.87311f, 0.882339f, 0.891567f, 0.900795f, 0.910024f, 0.919252f, 0.92848f, 0.937709f, 0.946937f, + 0.956165f, 0.965394f, 0.974622f, 0.98385f, 0.993079f, 0.997693f, 0.988465f, 0.979236f, 0.970008f, + 0.960779f, 0.951551f, 0.942323f, 0.933095f, 0.923866f, 0.914638f, 0.905409f, 0.896181f, 0.886953f, + 0.877724f, 0.868496f, 0.859268f, 0.850039f, 0.840811f, 0.831583f, 0.822354f, 0.813126f, 0.803898f, + 0.794669f, 0.785441f, 0.776213f, 0.766984f, 0.757756f, 0.748528f, 0.739299f, 0.730071f, 0.720843f, + 0.711614f, 0.695866f, 0.673598f, 0.651331f, 0.629063f, 0.606795f, 0.584528f, 0.56226f, 0.539992f, + 0.517724f, 0.495457f, 0.473189f, 0.450921f, 0.428654f, 0.406386f, 0.384118f, 0.36185f, 0.339583f, + 0.317315f, 0.295047f, 0.27278f, 0.250512f, 0.228244f, 0.205976f, 0.183709f, 0.161441f, 0.139173f, + 0.116905f, 0.094638f, 0.07237f, 0.050102f, 0.027835f, 0.005567f, 0.00835f, 0.019484f, 0.030618f, + 0.041752f, 0.052886f, 0.06402f, 0.075154f, 0.086287f, 0.097421f, 0.108555f, 0.119689f, 0.130823f, + 0.141957f, 0.153091f, 0.164224f, 0.175358f, 0.186492f, 0.197626f, 0.20876f, 0.219894f, 0.231028f, + 0.242161f, 0.253295f, 0.264429f, 0.275563f, 0.286697f, 0.297831f, 0.308965f, 0.320098f, 0.331232f, + 0.342366f, 0.3535f +}; + +// gDefaultVolume[k] = cos(pi/2 * k / 127) +f32 gDefaultPanVolume[128] = { + 1.0f, 0.999924f, 0.999694f, 0.999312f, 0.998776f, 0.998088f, 0.997248f, 0.996254f, 0.995109f, + 0.993811f, 0.992361f, 0.990759f, 0.989006f, 0.987101f, 0.985045f, 0.982839f, 0.980482f, 0.977976f, + 0.97532f, 0.972514f, 0.96956f, 0.966457f, 0.963207f, 0.959809f, 0.956265f, 0.952574f, 0.948737f, + 0.944755f, 0.940629f, 0.936359f, 0.931946f, 0.92739f, 0.922692f, 0.917853f, 0.912873f, 0.907754f, + 0.902497f, 0.897101f, 0.891567f, 0.885898f, 0.880093f, 0.874153f, 0.868079f, 0.861873f, 0.855535f, + 0.849066f, 0.842467f, 0.835739f, 0.828884f, 0.821901f, 0.814793f, 0.807561f, 0.800204f, 0.792725f, + 0.785125f, 0.777405f, 0.769566f, 0.76161f, 0.753536f, 0.745348f, 0.737045f, 0.72863f, 0.720103f, + 0.711466f, 0.70272f, 0.693867f, 0.684908f, 0.675843f, 0.666676f, 0.657406f, 0.648036f, 0.638567f, + 0.629f, 0.619337f, 0.609579f, 0.599728f, 0.589785f, 0.579752f, 0.56963f, 0.559421f, 0.549126f, + 0.538748f, 0.528287f, 0.517745f, 0.507124f, 0.496425f, 0.485651f, 0.474802f, 0.46388f, 0.452888f, + 0.441826f, 0.430697f, 0.419502f, 0.408243f, 0.396921f, 0.385538f, 0.374097f, 0.362598f, 0.351044f, + 0.339436f, 0.327776f, 0.316066f, 0.304308f, 0.292503f, 0.280653f, 0.268761f, 0.256827f, 0.244854f, + 0.232844f, 0.220798f, 0.208718f, 0.196606f, 0.184465f, 0.172295f, 0.160098f, 0.147877f, 0.135634f, + 0.12337f, 0.111087f, 0.098786f, 0.086471f, 0.074143f, 0.061803f, 0.049454f, 0.037097f, 0.024734f, + 0.012368f, 0.0f +}; + +#if defined(VERSION_JP) || defined(VERSION_US) +// gVolRampingLhs136[k] = 2^16 * max(1, (256*k)^(1/17) +f32 gVolRampingLhs136[128] = { + 65536.0f, 90811.555f, 94590.766f, 96873.96f, 98527.26f, 99829.06f, 100905.47f, + 101824.61f, 102627.57f, 103341.086f, 103983.55f, 104568.164f, 105104.75f, 105600.8f, + 106062.14f, 106493.46f, 106898.52f, 107280.414f, 107641.73f, 107984.62f, 108310.93f, + 108622.23f, 108919.875f, 109205.055f, 109478.8f, 109742.0f, 109995.48f, 110239.94f, + 110476.02f, 110704.305f, 110925.3f, 111139.45f, 111347.21f, 111548.945f, 111745.0f, + 111935.7f, 112121.35f, 112302.2f, 112478.51f, 112650.51f, 112818.4f, 112982.38f, + 113142.66f, 113299.37f, 113452.69f, 113602.766f, 113749.734f, 113893.73f, 114034.87f, + 114173.26f, 114309.02f, 114442.26f, 114573.055f, 114701.5f, 114827.69f, 114951.695f, + 115073.6f, 115193.47f, 115311.375f, 115427.39f, 115541.56f, 115653.96f, 115764.63f, + 115873.64f, 115981.04f, 116086.86f, 116191.164f, 116293.99f, 116395.38f, 116495.38f, + 116594.02f, 116691.34f, 116787.39f, 116882.19f, 116975.77f, 117068.17f, 117159.414f, + 117249.54f, 117338.57f, 117426.53f, 117513.45f, 117599.35f, 117684.266f, 117768.2f, + 117851.195f, 117933.266f, 118014.44f, 118094.72f, 118174.14f, 118252.71f, 118330.46f, + 118407.4f, 118483.55f, 118558.914f, 118633.53f, 118707.4f, 118780.54f, 118852.97f, + 118924.695f, 118995.74f, 119066.11f, 119135.82f, 119204.88f, 119273.31f, 119341.125f, + 119408.32f, 119474.92f, 119540.93f, 119606.36f, 119671.22f, 119735.52f, 119799.28f, + 119862.5f, 119925.195f, 119987.36f, 120049.02f, 120110.18f, 120170.84f, 120231.016f, + 120290.71f, 120349.945f, 120408.7f, 120467.016f, 120524.875f, 120582.3f, 120639.28f, + 120695.84f, 120751.984f +}; + +// gVolRampingRhs136[k] = 1 / max(1, (256*k)^(1/17)) +f32 gVolRampingRhs136[128] = { + 1.0f, 0.72167f, 0.692837f, 0.676508f, 0.665156f, 0.656482f, 0.649479f, 0.643616f, 0.638581f, + 0.634172f, 0.630254f, 0.62673f, 0.62353f, 0.620601f, 0.617902f, 0.615399f, 0.613067f, 0.610885f, + 0.608835f, 0.606901f, 0.605073f, 0.603339f, 0.60169f, 0.600119f, 0.598618f, 0.597183f, 0.595806f, + 0.594485f, 0.593215f, 0.591991f, 0.590812f, 0.589674f, 0.588573f, 0.587509f, 0.586478f, 0.585479f, + 0.58451f, 0.583568f, 0.582654f, 0.581764f, 0.580898f, 0.580055f, 0.579233f, 0.578432f, 0.57765f, + 0.576887f, 0.576142f, 0.575414f, 0.574701f, 0.574005f, 0.573323f, 0.572656f, 0.572002f, 0.571361f, + 0.570733f, 0.570118f, 0.569514f, 0.568921f, 0.568339f, 0.567768f, 0.567207f, 0.566656f, 0.566114f, + 0.565582f, 0.565058f, 0.564543f, 0.564036f, 0.563537f, 0.563046f, 0.562563f, 0.562087f, 0.561618f, + 0.561156f, 0.560701f, 0.560253f, 0.559811f, 0.559375f, 0.558945f, 0.558521f, 0.558102f, 0.557689f, + 0.557282f, 0.55688f, 0.556483f, 0.556091f, 0.555704f, 0.555322f, 0.554944f, 0.554571f, 0.554203f, + 0.553839f, 0.553479f, 0.553123f, 0.552772f, 0.552424f, 0.55208f, 0.55174f, 0.551404f, 0.551071f, + 0.550742f, 0.550417f, 0.550095f, 0.549776f, 0.549461f, 0.549148f, 0.548839f, 0.548534f, 0.548231f, + 0.547931f, 0.547634f, 0.54734f, 0.547048f, 0.54676f, 0.546474f, 0.546191f, 0.54591f, 0.545632f, + 0.545357f, 0.545084f, 0.544813f, 0.544545f, 0.54428f, 0.544016f, 0.543755f, 0.543496f, 0.543239f, + 0.542985f, 0.542732f +}; + +// gVolRampingLhs144[k] = 2^16 * max(1, (256*k)^(1/18)) +f32 gVolRampingLhs144[128] = { + 65536.0f, 89180.734f, 92681.9f, 94793.33f, 96320.52f, 97522.02f, 98514.84f, + 99362.14f, 100101.99f, 100759.16f, 101350.664f, 101888.74f, 102382.46f, 102838.75f, + 103263.016f, 103659.58f, 104031.914f, 104382.89f, 104714.88f, 105029.89f, 105329.61f, + 105615.5f, 105888.81f, 106150.63f, 106401.914f, 106643.49f, 106876.12f, 107100.44f, + 107317.05f, 107526.47f, 107729.17f, 107925.6f, 108116.125f, 108301.12f, 108480.88f, + 108655.72f, 108825.91f, 108991.68f, 109153.28f, 109310.914f, 109464.77f, 109615.04f, + 109761.88f, 109905.46f, 110045.92f, 110183.41f, 110318.02f, 110449.91f, 110579.17f, + 110705.914f, 110830.234f, 110952.234f, 111071.99f, 111189.59f, 111305.12f, 111418.64f, + 111530.23f, 111639.95f, 111747.875f, 111854.05f, 111958.54f, 112061.4f, 112162.67f, + 112262.42f, 112360.68f, 112457.51f, 112552.93f, 112647.0f, 112739.76f, 112831.23f, + 112921.46f, 113010.484f, 113098.33f, 113185.02f, 113270.61f, 113355.11f, 113438.555f, + 113520.97f, 113602.375f, 113682.805f, 113762.27f, 113840.81f, 113918.44f, 113995.18f, + 114071.055f, 114146.08f, 114220.266f, 114293.65f, 114366.24f, 114438.06f, 114509.12f, + 114579.44f, 114649.02f, 114717.91f, 114786.086f, 114853.586f, 114920.42f, 114986.6f, + 115052.14f, 115117.055f, 115181.34f, 115245.04f, 115308.13f, 115370.65f, 115432.59f, + 115493.98f, 115554.81f, 115615.11f, 115674.875f, 115734.12f, 115792.85f, 115851.08f, + 115908.82f, 115966.07f, 116022.85f, 116079.16f, 116135.01f, 116190.4f, 116245.35f, + 116299.87f, 116353.945f, 116407.6f, 116460.84f, 116513.67f, 116566.09f, 116618.125f, + 116669.76f, 116721.01f +}; + +// gVolRampingRhs144[k] = 1 / max(1, (256*k)^(1/18)) +f32 gVolRampingRhs144[128] = { + 1.0f, 0.734867f, 0.707107f, 0.691357f, 0.680395f, 0.672012f, 0.66524f, 0.659567f, 0.654692f, + 0.650422f, 0.646626f, 0.643211f, 0.64011f, 0.637269f, 0.634651f, 0.632223f, 0.629961f, 0.627842f, + 0.625852f, 0.623975f, 0.622199f, 0.620515f, 0.618913f, 0.617387f, 0.615929f, 0.614533f, 0.613196f, + 0.611912f, 0.610677f, 0.609487f, 0.60834f, 0.607233f, 0.606163f, 0.605128f, 0.604125f, 0.603153f, + 0.60221f, 0.601294f, 0.600403f, 0.599538f, 0.598695f, 0.597874f, 0.597074f, 0.596294f, 0.595533f, + 0.59479f, 0.594064f, 0.593355f, 0.592661f, 0.591983f, 0.591319f, 0.590669f, 0.590032f, 0.589408f, + 0.588796f, 0.588196f, 0.587608f, 0.58703f, 0.586463f, 0.585906f, 0.58536f, 0.584822f, 0.584294f, + 0.583775f, 0.583265f, 0.582762f, 0.582268f, 0.581782f, 0.581303f, 0.580832f, 0.580368f, 0.579911f, + 0.57946f, 0.579017f, 0.578579f, 0.578148f, 0.577722f, 0.577303f, 0.576889f, 0.576481f, 0.576078f, + 0.575681f, 0.575289f, 0.574902f, 0.574519f, 0.574142f, 0.573769f, 0.5734f, 0.573036f, 0.572677f, + 0.572321f, 0.57197f, 0.571623f, 0.57128f, 0.57094f, 0.570605f, 0.570273f, 0.569945f, 0.56962f, + 0.569299f, 0.568981f, 0.568667f, 0.568355f, 0.568047f, 0.567743f, 0.567441f, 0.567142f, 0.566846f, + 0.566553f, 0.566263f, 0.565976f, 0.565692f, 0.56541f, 0.565131f, 0.564854f, 0.56458f, 0.564309f, + 0.56404f, 0.563773f, 0.563509f, 0.563247f, 0.562987f, 0.56273f, 0.562475f, 0.562222f, 0.561971f, + 0.561722f, 0.561476f +}; + +// gVolRampingLhs128[k] = 2^16 * max(1, (256*k)^(1/16)) +f32 gVolRampingLhs128[128] = { + 65536.0f, 92681.9f, 96785.28f, 99269.31f, 101070.33f, 102489.78f, 103664.336f, + 104667.914f, 105545.09f, 106324.92f, 107027.39f, 107666.84f, 108253.95f, 108796.87f, + 109301.95f, 109774.29f, 110217.98f, 110636.39f, 111032.33f, 111408.164f, 111765.9f, + 112107.234f, 112433.66f, 112746.46f, 113046.766f, 113335.555f, 113613.72f, 113882.02f, + 114141.164f, 114391.77f, 114634.414f, 114869.58f, 115097.74f, 115319.31f, 115534.68f, + 115744.19f, 115948.16f, 116146.875f, 116340.625f, 116529.66f, 116714.195f, 116894.46f, + 117070.64f, 117242.945f, 117411.52f, 117576.55f, 117738.17f, 117896.54f, 118051.77f, + 118204.0f, 118353.35f, 118499.92f, 118643.83f, 118785.16f, 118924.01f, 119060.47f, + 119194.625f, 119326.555f, 119456.336f, 119584.03f, 119709.71f, 119833.445f, 119955.29f, + 120075.31f, 120193.555f, 120310.08f, 120424.94f, 120538.17f, 120649.836f, 120759.97f, + 120868.62f, 120975.82f, 121081.62f, 121186.05f, 121289.14f, 121390.94f, 121491.47f, + 121590.766f, 121688.87f, 121785.79f, 121881.57f, 121976.24f, 122069.82f, 122162.33f, + 122253.805f, 122344.266f, 122433.73f, 122522.23f, 122609.77f, 122696.4f, 122782.11f, + 122866.93f, 122950.89f, 123033.99f, 123116.26f, 123197.72f, 123278.37f, 123358.24f, + 123437.34f, 123515.69f, 123593.3f, 123670.19f, 123746.36f, 123821.84f, 123896.63f, + 123970.76f, 124044.23f, 124117.04f, 124189.23f, 124260.78f, 124331.73f, 124402.07f, + 124471.83f, 124540.99f, 124609.59f, 124677.63f, 124745.12f, 124812.055f, 124878.47f, + 124944.34f, 125009.71f, 125074.57f, 125138.92f, 125202.79f, 125266.164f, 125329.06f, + 125391.5f, 125453.47f +}; + +// gVolRampingRhs128[k] = 1 / max(1, (256*k)^(1/16)) +f32 gVolRampingRhs128[128] = { + 1.0f, 0.707107f, 0.677128f, 0.660184f, 0.64842f, 0.639439f, 0.632194f, 0.626133f, 0.620929f, + 0.616375f, 0.612329f, 0.608693f, 0.605391f, 0.60237f, 0.599587f, 0.597007f, 0.594604f, 0.592355f, + 0.590243f, 0.588251f, 0.586369f, 0.584583f, 0.582886f, 0.581269f, 0.579725f, 0.578247f, 0.576832f, + 0.575473f, 0.574166f, 0.572908f, 0.571696f, 0.570525f, 0.569394f, 0.5683f, 0.567241f, 0.566214f, + 0.565218f, 0.564251f, 0.563311f, 0.562398f, 0.561508f, 0.560642f, 0.559799f, 0.558976f, 0.558173f, + 0.55739f, 0.556625f, 0.555877f, 0.555146f, 0.554431f, 0.553732f, 0.553047f, 0.552376f, 0.551719f, + 0.551075f, 0.550443f, 0.549823f, 0.549216f, 0.548619f, 0.548033f, 0.547458f, 0.546892f, 0.546337f, + 0.545791f, 0.545254f, 0.544726f, 0.544206f, 0.543695f, 0.543192f, 0.542696f, 0.542209f, 0.541728f, + 0.541255f, 0.540788f, 0.540329f, 0.539876f, 0.539429f, 0.538988f, 0.538554f, 0.538125f, 0.537702f, + 0.537285f, 0.536873f, 0.536467f, 0.536065f, 0.535669f, 0.535277f, 0.534891f, 0.534509f, 0.534131f, + 0.533759f, 0.53339f, 0.533026f, 0.532666f, 0.53231f, 0.531958f, 0.53161f, 0.531266f, 0.530925f, + 0.530588f, 0.530255f, 0.529926f, 0.529599f, 0.529277f, 0.528957f, 0.528641f, 0.528328f, 0.528018f, + 0.527711f, 0.527407f, 0.527106f, 0.526808f, 0.526513f, 0.52622f, 0.525931f, 0.525644f, 0.525359f, + 0.525077f, 0.524798f, 0.524522f, 0.524247f, 0.523975f, 0.523706f, 0.523439f, 0.523174f, 0.522911f, + 0.522651f, 0.522393f +}; +#endif + +#ifdef VERSION_SH +u16 unk_sh_data_3[] = { + // 30 entries + // pattern: + // A B + // C D + // C B + // A E + 0x1000, 0x1000, + 0x1000, 0x1000, + 0x1000, 0x1000, + 0x1000, 0x1000, + + 0x0E6F, 0x1091, + 0x11EF, 0x1267, + 0x11EF, 0x1091, + 0x0E6F, 0x0BB8, + + 0x0C1D, 0x111D, + 0x1494, 0x15D2, + 0x1494, 0x111D, + 0x0C1D, 0x068E, + + 0x0838, 0x116E, + 0x18A6, 0x1B61, + 0x18A6, 0x116E, + 0x0838, 0x0001, + + 0x0227, 0x0F42, + 0x1B75, 0x206B, + 0x1B75, 0x0F42, + 0x0227, 0xFA2B, + + 0xFC28, 0x0AAE, + 0x1BE7, 0x2394, + 0x1BE7, 0x0AAE, + 0xFC28, 0xF874, + + 0xF809, 0x0582, + 0x1C36, 0x2788, + 0x1C36, 0x0582, + 0xF809, 0xFAEB, + + 0xF5F0, 0x0001, + 0x1E34, 0x2F71, + 0x1E34, 0x0001, + 0xF5F0, 0x0000, + + 0xF8AD, 0xFAF3, + 0x19ED, 0x2EB6, + 0x19ED, 0xFAF3, + 0xF8AD, 0x04AC, + + 0xFCC0, 0xF6FF, + 0x178B, 0x3207, + 0x178B, 0xF6FF, + 0xFCC0, 0x065F, + + 0x01A5, 0xF44E, + 0x1510, 0x36B4, + 0x1510, 0xF44E, + 0x01A5, 0x047B, + + 0x05C1, 0xF3CC, + 0x1145, 0x3988, + 0x1145, 0xF3CC, + 0x05C1, 0x0001, + + 0x07B9, 0xF517, + 0x0D20, 0x3C4C, + 0x0D20, 0xF517, + 0x07B9, 0xFBD4, + + 0x07C0, 0xF71C, + 0x09A1, 0x4528, + 0x09A1, 0xF71C, + 0x07C0, 0xF9B7, + + 0x058F, 0xFA43, + 0x05DC, 0x585F, + 0x05DC, 0xFA43, + 0x058F, 0xFAB3, +}; + +u16 unk_sh_data_4[] = { + 0xFA73, 0xFA42, + 0xFA27, 0x5866, + 0xFA27, 0xFA42, + 0xFA73, 0xFAB2, + + 0xF842, 0xF71B, + 0xF661, 0x452B, + 0xF661, 0xF71B, + 0xF842, 0xF9B5, + + 0xF848, 0xF516, + 0xF2E1, 0x3C4D, + 0xF2E1, 0xF516, + 0xF848, 0xFBD2, + + 0xFA3F, 0xF3CA, + 0xEEBD, 0x3989, + 0xEEBD, 0xF3CA, + 0xFA3F, 0xFFFF, + + 0xFE5B, 0xF44C, + 0xEAF2, 0x36B5, + 0xEAF2, 0xF44C, + 0xFE5B, 0x0479, + + 0x0340, 0xF6FD, + 0xE877, 0x3207, + 0xE877, 0xF6FD, + 0x0340, 0x065E, + + 0x0753, 0xFAF1, + 0xE615, 0x2EB5, + 0xE615, 0xFAF1, + 0x0753, 0x04AB, + + 0x0A12, 0xFFFF, + 0xE1CD, 0x2F71, + 0xE1CD, 0xFFFF, + 0x0A12, 0x0000, + + 0x07FA, 0x057F, + 0xE3CA, 0x2789, + 0xE3CA, 0x057F, + 0x07FA, 0xFAEA, + + 0x03DB, 0x0AAC, + 0xE41A, 0x2394, + 0xE41A, 0x0AAC, + 0x03DB, 0xF873, + + 0xFDDC, 0x0F41, + 0xE489, 0x206E, + 0xE489, 0x0F41, + 0xFDDC, 0xFA28, + + 0xF7CA, 0x116E, + 0xE758, 0x1B63, + 0xE758, 0x116E, + 0xF7CA, 0xFFFF, + + 0xF3E4, 0x111D, + 0xEB6A, 0x15D4, + 0xEB6A, 0x111D, + 0xF3E4, 0x068B, + + 0xF192, 0x1092, + 0xEE11, 0x1268, + 0xEE11, 0x1092, + 0xF192, 0x0BB6, + + 0xF05F, 0x1026, + 0xEF89, 0x1093, + 0xEF89, 0x1026, + 0xF05F, 0x0EEB, + + 0x0000, 0x0000, + 0x0000, 0x0000, + 0x7FFF, 0xD001, + 0x3FFF, 0xF001, + 0x5FFF, 0x9001, + 0x7FFF, 0x8001 +}; +#endif + +#ifndef VERSION_SH +s16 gTatumsPerBeat = TATUMS_PER_BEAT; +s8 gUnusedCount80333EE8 = UNUSED_COUNT_80333EE8; +s32 gAudioHeapSize = DOUBLE_SIZE_ON_64_BIT(AUDIO_HEAP_SIZE); +s32 gAudioInitPoolSize = DOUBLE_SIZE_ON_64_BIT(AUDIO_INIT_POOL_SIZE); +volatile s32 gAudioLoadLock = AUDIO_LOCK_UNINITIALIZED; +#endif + +#if defined(VERSION_EU) +u8 bufferDelete2[12] = { 0 }; +u8 D_EU_80302010 = 0; +u8 D_EU_80302014 = 0; + +struct OSMesgQueue *OSMesgQueues[4] = { &OSMesgQueue0, &OSMesgQueue1, &OSMesgQueue2, &OSMesgQueue3 }; +#elif defined(VERSION_JP) || defined(VERSION_US) +s8 sUnused8033EF8 = 24; +#endif + +// .bss + +volatile s32 gAudioFrameCount; + +#if defined(VERSION_EU) || defined(VERSION_SH) +s32 gCurrAudioFrameDmaCount; +#else +volatile s32 gCurrAudioFrameDmaCount; +#endif + +s32 gAudioTaskIndex; +s32 gCurrAiBufferIndex; + +u64 *gAudioCmdBuffers[2]; +u64 *gAudioCmd; + +struct SPTask *gAudioTask; +struct SPTask gAudioTasks[2]; + +#if defined(VERSION_EU) || defined(VERSION_SH) +f32 D_EU_802298D0; +s32 gRefreshRate; +#endif + +s16 *gAiBuffers[NUMAIBUFFERS]; +s16 gAiBufferLengths[NUMAIBUFFERS]; + +#if defined(VERSION_JP) || defined(VERSION_US) +u32 gUnused80226E58[0x10]; +u16 gUnused80226E98[0x10]; +#endif + +u32 gAudioRandom; + +#if defined(VERSION_EU) || defined(VERSION_SH) +s32 gAudioErrorFlags; +#endif + +#ifdef VERSION_SH +volatile u32 gAudioLoadLockSH; +struct EuAudioCmd sAudioCmd[0x100]; +u8 D_SH_80350F18; +u8 D_SH_80350F19; + +OSMesg D_SH_80350F1C[1]; +OSMesgQueue D_SH_80350F20; // address written to D_SH_80350F38 +OSMesgQueue *D_SH_80350F38; + +OSMesg D_SH_80350F40[4]; +OSMesgQueue D_SH_80350F50; // address written to D_SH_80350F68 +OSMesgQueue *D_SH_80350F68; + +OSMesg D_SH_80350F6C[1]; +OSMesgQueue D_SH_80350F70; // address written to D_SH_80350F88 +OSMesgQueue *D_SH_80350F88; + +OSMesg D_SH_80350F8C[1]; +OSMesgQueue D_SH_80350F90; // address written to D_SH_80350F90 +OSMesgQueue *D_SH_80350FA8; +#endif + +u64 gAudioGlobalsEndMarker; diff --git a/src/decomp/audio/data.h b/src/decomp/audio/data.h new file mode 100644 index 0000000..3deda31 --- /dev/null +++ b/src/decomp/audio/data.h @@ -0,0 +1,154 @@ +#ifndef AUDIO_DATA_H +#define AUDIO_DATA_H + +#include + +#include "internal.h" +#include + +#define AUDIO_LOCK_UNINITIALIZED 0 +#define AUDIO_LOCK_NOT_LOADING 0x76557364 +#define AUDIO_LOCK_LOADING 0x19710515 + +#define NUMAIBUFFERS 3 + +// constant .data +#if defined(VERSION_EU) || defined(VERSION_SH) +extern struct AudioSessionSettingsEU gAudioSessionPresets[]; +#else +extern struct AudioSessionSettings gAudioSessionPresets[18]; +#endif +extern u16 D_80332388[128]; // unused + +#if defined(VERSION_EU) || defined(VERSION_SH) +extern f32 gPitchBendFrequencyScale[256]; +#else +extern f32 gPitchBendFrequencyScale[255]; +#endif +extern f32 gNoteFrequencies[128]; + +extern u8 gDefaultShortNoteVelocityTable[16]; +extern u8 gDefaultShortNoteDurationTable[16]; +extern s8 gVibratoCurve[16]; +extern struct AdsrEnvelope gDefaultEnvelope[3]; + +#if defined(VERSION_EU) || defined(VERSION_SH) +extern s16 gEuUnknownWave7[256]; +extern s16 *gWaveSamples[6]; +#else +extern s16 *gWaveSamples[4]; +#endif + +#if defined(VERSION_EU) || defined(VERSION_SH) +extern u8 euUnknownData_8030194c[4]; +#ifdef VERSION_EU +extern u16 gHeadsetPanQuantization[0x10]; +#else +extern u16 gHeadsetPanQuantization[0x40]; +#endif +extern s16 euUnknownData_80301950[64]; +extern struct NoteSubEu gZeroNoteSub; +extern struct NoteSubEu gDefaultNoteSub; +#else +extern u16 gHeadsetPanQuantization[10]; +#endif +extern f32 gHeadsetPanVolume[128]; +extern f32 gStereoPanVolume[128]; +extern f32 gDefaultPanVolume[128]; + +extern f32 gVolRampingLhs136[128]; +extern f32 gVolRampingRhs136[128]; +extern f32 gVolRampingLhs144[128]; +extern f32 gVolRampingRhs144[128]; +extern f32 gVolRampingLhs128[128]; +extern f32 gVolRampingRhs128[128]; + +// non-constant .data +extern s16 gTatumsPerBeat; +extern s8 gUnusedCount80333EE8; +extern s32 gAudioHeapSize; // AUDIO_HEAP_SIZE +extern s32 gAudioInitPoolSize; // AUDIO_INIT_POOL_SIZE +extern volatile s32 gAudioLoadLock; + +// .bss +extern volatile s32 gAudioFrameCount; + +// number of DMAs performed during this frame +#if defined(VERSION_EU) || defined(VERSION_SH) +extern s32 gCurrAudioFrameDmaCount; +#else +extern volatile s32 gCurrAudioFrameDmaCount; +#endif + +extern s32 gAudioTaskIndex; +extern s32 gCurrAiBufferIndex; + +extern u64 *gAudioCmdBuffers[2]; +extern u64 *gAudioCmd; + +extern struct SPTask *gAudioTask; +extern struct SPTask gAudioTasks[2]; + +#if defined(VERSION_EU) || defined(VERSION_SH) +extern f32 D_EU_802298D0; +extern s32 gRefreshRate; +#endif + +extern s16 *gAiBuffers[NUMAIBUFFERS]; +extern s16 gAiBufferLengths[NUMAIBUFFERS]; +#if defined(VERSION_SH) +#define AIBUFFER_LEN 0xb00 +#elif defined(VERSION_EU) +#define AIBUFFER_LEN (0xa0 * 17) +#else +#define AIBUFFER_LEN (0xa0 * 16) +#endif + +extern u32 gUnused80226E58[0x10]; +extern u16 gUnused80226E98[0x10]; + +extern u32 gAudioRandom; + +#ifdef VERSION_SH +extern f32 unk_sh_data_1[]; + +extern volatile u32 gAudioLoadLockSH; + +extern u8 D_SH_80350F18; +extern u8 D_SH_80350F19; + +extern OSMesg D_SH_80350F1C[1]; +extern OSMesgQueue D_SH_80350F20; // address written to D_SH_80350F38 +extern OSMesgQueue *D_SH_80350F38; + +extern OSMesg D_SH_80350F40[4]; +extern OSMesgQueue D_SH_80350F50; // address written to D_SH_80350F68 +extern OSMesgQueue *D_SH_80350F68; + +extern OSMesg D_SH_80350F6C[1]; +extern OSMesgQueue D_SH_80350F70; // address written to D_SH_80350F88 +extern OSMesgQueue *D_SH_80350F88; + +extern OSMesg D_SH_80350F8C[1]; +extern OSMesgQueue D_SH_80350F90; // address written to D_SH_80350F90 +extern OSMesgQueue *D_SH_80350FA8; +#endif + +#if defined(VERSION_EU) || defined(VERSION_SH) +#define UNUSED_COUNT_80333EE8 24 +#define AUDIO_HEAP_SIZE 0x2c500 +#define AUDIO_INIT_POOL_SIZE 0x2c00 +#else +#define UNUSED_COUNT_80333EE8 16 +#define AUDIO_HEAP_SIZE 0x31150 +#define AUDIO_INIT_POOL_SIZE 0x2500 +#endif + +#ifdef VERSION_SH +extern u32 D_SH_80315EF0; +extern u16 D_SH_80315EF4; +extern u16 D_SH_80315EF8; +extern u16 D_SH_80315EFC; +#endif + +#endif // AUDIO_DATA_H diff --git a/src/decomp/audio/effects.c b/src/decomp/audio/effects.c new file mode 100644 index 0000000..76bb584 --- /dev/null +++ b/src/decomp/audio/effects.c @@ -0,0 +1,545 @@ +#include + +#include "effects.h" +#include "load.h" +#include "data.h" +#include "seqplayer.h" + +#ifdef VERSION_JP +#define US_FLOAT2(x) x##.0 +#else +#define US_FLOAT2(x) x +#endif + +f32 gTrackVolume = 1.0f; + +#if defined(VERSION_EU) || defined(VERSION_SH) +void sequence_channel_process_sound(struct SequenceChannel *seqChannel, s32 recalculateVolume) { + f32 channelVolume; + s32 i; + + if (seqChannel->changes.as_bitfields.volume || recalculateVolume) { + channelVolume = seqChannel->volume * seqChannel->volumeScale * seqChannel->seqPlayer->appliedFadeVolume; + if (seqChannel->seqPlayer->muted && (seqChannel->muteBehavior & MUTE_BEHAVIOR_SOFTEN) != 0) { + channelVolume = seqChannel->seqPlayer->muteVolumeScale * channelVolume; + } +#ifdef VERSION_SH + seqChannel->appliedVolume = channelVolume * channelVolume; +#else + seqChannel->appliedVolume = channelVolume; +#endif + } + + if (seqChannel->changes.as_bitfields.pan) { + seqChannel->pan = seqChannel->newPan * seqChannel->panChannelWeight; + } + + for (i = 0; i < 4; ++i) { + struct SequenceChannelLayer *layer = seqChannel->layers[i]; + if (layer != NULL && layer->enabled && layer->note != NULL) { + if (layer->notePropertiesNeedInit) { + layer->noteFreqScale = layer->freqScale * seqChannel->freqScale; + layer->noteVelocity = layer->velocitySquare * seqChannel->appliedVolume; + layer->notePan = (seqChannel->pan + layer->pan * (0x80 - seqChannel->panChannelWeight)) >> 7; + layer->notePropertiesNeedInit = FALSE; + } else { + if (seqChannel->changes.as_bitfields.freqScale) { + layer->noteFreqScale = layer->freqScale * seqChannel->freqScale; + } + if (seqChannel->changes.as_bitfields.volume || recalculateVolume) { + layer->noteVelocity = layer->velocitySquare * seqChannel->appliedVolume; + } + if (seqChannel->changes.as_bitfields.pan) { + layer->notePan = (seqChannel->pan + layer->pan * (0x80 - seqChannel->panChannelWeight)) >> 7; + } + } + } + } + seqChannel->changes.as_u8 = 0; +} +#else +static void sequence_channel_process_sound(struct SequenceChannel *seqChannel) { + f32 channelVolume; + f32 panLayerWeight; + f32 panFromChannel; + s32 i; + + channelVolume = seqChannel->volume * seqChannel->volumeScale * seqChannel->seqPlayer->fadeVolume; + if (seqChannel->seqPlayer->muted && (seqChannel->muteBehavior & MUTE_BEHAVIOR_SOFTEN) != 0) { + channelVolume *= seqChannel->seqPlayer->muteVolumeScale; + } + + panFromChannel = seqChannel->pan * seqChannel->panChannelWeight; + panLayerWeight = US_FLOAT(1.0) - seqChannel->panChannelWeight; + + for (i = 0; i < 4; i++) { + struct SequenceChannelLayer *layer = seqChannel->layers[i]; + if (layer != NULL && layer->enabled && layer->note != NULL) { + layer->noteFreqScale = layer->freqScale * seqChannel->freqScale; + layer->noteVelocity = layer->velocitySquare * (channelVolume * gTrackVolume); + layer->notePan = (layer->pan * panLayerWeight) + panFromChannel; + } + } +} +#endif + +void sequence_player_process_sound(struct SequencePlayer *seqPlayer) { + s32 i; + + if (seqPlayer->fadeRemainingFrames != 0) { + seqPlayer->fadeVolume += seqPlayer->fadeVelocity; +#if defined(VERSION_EU) || defined(VERSION_SH) + seqPlayer->recalculateVolume = TRUE; +#endif + + if (seqPlayer->fadeVolume > US_FLOAT2(1)) { + seqPlayer->fadeVolume = US_FLOAT2(1); + } + if (seqPlayer->fadeVolume < 0) { + seqPlayer->fadeVolume = 0; + } + + if (--seqPlayer->fadeRemainingFrames == 0) { +#if defined(VERSION_EU) || defined(VERSION_SH) + if (seqPlayer->state == 2) { + sequence_player_disable(seqPlayer); + return; + } +#else + switch (seqPlayer->state) { + case SEQUENCE_PLAYER_STATE_FADE_OUT: + sequence_player_disable(seqPlayer); + return; + + case SEQUENCE_PLAYER_STATE_2: + case SEQUENCE_PLAYER_STATE_3: + seqPlayer->state = SEQUENCE_PLAYER_STATE_0; + break; + + case SEQUENCE_PLAYER_STATE_4: + break; + } +#endif + } + } + +#if defined(VERSION_EU) || defined(VERSION_SH) + if (seqPlayer->recalculateVolume) { + seqPlayer->appliedFadeVolume = seqPlayer->fadeVolume * seqPlayer->fadeVolumeScale; + } +#endif + + // Process channels + for (i = 0; i < CHANNELS_MAX; i++) { + if (IS_SEQUENCE_CHANNEL_VALID(seqPlayer->channels[i]) == TRUE + && seqPlayer->channels[i]->enabled == TRUE) { +#if defined(VERSION_EU) || defined(VERSION_SH) + sequence_channel_process_sound(seqPlayer->channels[i], seqPlayer->recalculateVolume); +#else + sequence_channel_process_sound(seqPlayer->channels[i]); +#endif + } + } + +#if defined(VERSION_EU) || defined(VERSION_SH) + seqPlayer->recalculateVolume = FALSE; +#endif +} + +f32 get_portamento_freq_scale(struct Portamento *p) { + u32 v0; + f32 result; +#if defined(VERSION_JP) || defined(VERSION_US) + if (p->mode == 0) { + return 1.0f; + } +#endif + + p->cur += p->speed; + v0 = (u32) p->cur; + +#if defined(VERSION_EU) || defined(VERSION_SH) + if (v0 > 127) +#else + if (v0 >= 127) +#endif + { + v0 = 127; + } + +#if defined(VERSION_EU) || defined(VERSION_SH) + result = US_FLOAT(1.0) + p->extent * (gPitchBendFrequencyScale[v0 + 128] - US_FLOAT(1.0)); +#else + result = US_FLOAT(1.0) + p->extent * (gPitchBendFrequencyScale[v0 + 127] - US_FLOAT(1.0)); +#endif + return result; +} + +#if defined(VERSION_EU) || defined(VERSION_SH) +s16 get_vibrato_pitch_change(struct VibratoState *vib) { + s32 index; + vib->time += (s32) vib->rate; + index = (vib->time >> 10) & 0x3F; + return vib->curve[index] >> 8; +} +#else +s8 get_vibrato_pitch_change(struct VibratoState *vib) { + s32 index; + vib->time += vib->rate; + + index = (vib->time >> 10) & 0x3F; + + switch (index & 0x30) { + case 0x10: + index = 31 - index; + + case 0x00: + return vib->curve[index]; + + case 0x20: + index -= 0x20; + break; + + case 0x30: + index = 63 - index; + break; + } + + return -vib->curve[index]; +} +#endif + +f32 get_vibrato_freq_scale(struct VibratoState *vib) { + s32 pitchChange; + f32 extent; + f32 result; + + if (vib->delay != 0) { + vib->delay--; + return 1; + } + + if (vib->extentChangeTimer) { + if (vib->extentChangeTimer == 1) { + vib->extent = (s32) vib->seqChannel->vibratoExtentTarget; + } else { + vib->extent += + ((s32) vib->seqChannel->vibratoExtentTarget - vib->extent) / (s32) vib->extentChangeTimer; + } + + vib->extentChangeTimer--; + } else if (vib->seqChannel->vibratoExtentTarget != (s32) vib->extent) { + if ((vib->extentChangeTimer = vib->seqChannel->vibratoExtentChangeDelay) == 0) { + vib->extent = (s32) vib->seqChannel->vibratoExtentTarget; + } + } + + if (vib->rateChangeTimer) { + if (vib->rateChangeTimer == 1) { + vib->rate = (s32) vib->seqChannel->vibratoRateTarget; + } else { + vib->rate += ((s32) vib->seqChannel->vibratoRateTarget - vib->rate) / (s32) vib->rateChangeTimer; + } + + vib->rateChangeTimer--; + } else if (vib->seqChannel->vibratoRateTarget != (s32) vib->rate) { + if ((vib->rateChangeTimer = vib->seqChannel->vibratoRateChangeDelay) == 0) { + vib->rate = (s32) vib->seqChannel->vibratoRateTarget; + } + } + + if (vib->extent == 0) { + return 1.0f; + } + + pitchChange = get_vibrato_pitch_change(vib); + extent = (f32) vib->extent / US_FLOAT(4096.0); + +#if defined(VERSION_EU) || defined(VERSION_SH) + result = US_FLOAT(1.0) + extent * (gPitchBendFrequencyScale[pitchChange + 128] - US_FLOAT(1.0)); +#else + result = US_FLOAT(1.0) + extent * (gPitchBendFrequencyScale[pitchChange + 127] - US_FLOAT(1.0)); +#endif + return result; +} + +void note_vibrato_update(struct Note *note) { +#if defined(VERSION_EU) || defined(VERSION_SH) + if (note->portamento.mode != 0) { + note->portamentoFreqScale = get_portamento_freq_scale(¬e->portamento); + } + if (note->vibratoState.active && note->parentLayer != NO_LAYER) { + note->vibratoFreqScale = get_vibrato_freq_scale(¬e->vibratoState); + } +#else + if (note->vibratoState.active) { + note->portamentoFreqScale = get_portamento_freq_scale(¬e->portamento); + if (note->parentLayer != NO_LAYER) { + note->vibratoFreqScale = get_vibrato_freq_scale(¬e->vibratoState); + } + } +#endif +} + +void note_vibrato_init(struct Note *note) { + struct VibratoState *vib; + UNUSED struct SequenceChannel *seqChannel; +#if defined(VERSION_EU) || defined(VERSION_SH) + struct NotePlaybackState *seqPlayerState = (struct NotePlaybackState *) ¬e->priority; +#endif + + note->vibratoFreqScale = 1.0f; + note->portamentoFreqScale = 1.0f; + + vib = ¬e->vibratoState; + +#if defined(VERSION_JP) || defined(VERSION_US) + if (note->parentLayer->seqChannel->vibratoExtentStart == 0 + && note->parentLayer->seqChannel->vibratoExtentTarget == 0 + && note->parentLayer->portamento.mode == 0) { + vib->active = FALSE; + return; + } +#endif + + vib->active = TRUE; + vib->time = 0; + +#if defined(VERSION_EU) || defined(VERSION_SH) + vib->curve = gWaveSamples[2]; + vib->seqChannel = note->parentLayer->seqChannel; + if ((vib->extentChangeTimer = vib->seqChannel->vibratoExtentChangeDelay) == 0) { + vib->extent = FLOAT_CAST(vib->seqChannel->vibratoExtentTarget); + } else { + vib->extent = FLOAT_CAST(vib->seqChannel->vibratoExtentStart); + } + + if ((vib->rateChangeTimer = vib->seqChannel->vibratoRateChangeDelay) == 0) { + vib->rate = FLOAT_CAST(vib->seqChannel->vibratoRateTarget); + } else { + vib->rate = FLOAT_CAST(vib->seqChannel->vibratoRateStart); + } + vib->delay = vib->seqChannel->vibratoDelay; + + seqPlayerState->portamento = seqPlayerState->parentLayer->portamento; +#else + vib->curve = gVibratoCurve; + vib->seqChannel = note->parentLayer->seqChannel; + seqChannel = vib->seqChannel; + + if ((vib->extentChangeTimer = seqChannel->vibratoExtentChangeDelay) == 0) { + vib->extent = seqChannel->vibratoExtentTarget; + } else { + vib->extent = seqChannel->vibratoExtentStart; + } + + if ((vib->rateChangeTimer = seqChannel->vibratoRateChangeDelay) == 0) { + vib->rate = seqChannel->vibratoRateTarget; + } else { + vib->rate = seqChannel->vibratoRateStart; + } + vib->delay = seqChannel->vibratoDelay; + + note->portamento = note->parentLayer->portamento; +#endif +} + +void adsr_init(struct AdsrState *adsr, struct AdsrEnvelope *envelope, UNUSED s16 *volOut) { + adsr->action = 0; + adsr->state = ADSR_STATE_DISABLED; +#if defined(VERSION_EU) || defined(VERSION_SH) + adsr->delay = 0; + adsr->envelope = envelope; +#ifdef VERSION_SH + adsr->sustain = 0.0f; +#endif + adsr->current = 0.0f; +#else + adsr->initial = 0; + adsr->delay = 0; + adsr->velocity = 0; + adsr->envelope = envelope; + adsr->volOut = volOut; +#endif +} + +#if defined(VERSION_EU) || defined(VERSION_SH) +f32 adsr_update(struct AdsrState *adsr) { +#else +s32 adsr_update(struct AdsrState *adsr) { +#endif + u8 action = adsr->action; +#if defined(VERSION_EU) || defined(VERSION_SH) + u8 state = adsr->state; + switch (state) { +#else + switch (adsr->state) { +#endif + case ADSR_STATE_DISABLED: + return 0; + + case ADSR_STATE_INITIAL: { +#if defined(VERSION_JP) || defined(VERSION_US) + adsr->current = adsr->initial; + adsr->target = adsr->initial; +#endif + if (action & ADSR_ACTION_HANG) { + adsr->state = ADSR_STATE_HANG; + break; + } + // fallthrough + } + + case ADSR_STATE_START_LOOP: + adsr->envIndex = 0; +#if defined(VERSION_JP) || defined(VERSION_US) + adsr->currentHiRes = adsr->current << 0x10; +#endif + adsr->state = ADSR_STATE_LOOP; + // fallthrough + +#ifdef VERSION_SH + restart: +#endif + case ADSR_STATE_LOOP: + adsr->delay = BSWAP16(adsr->envelope[adsr->envIndex].delay); + switch (adsr->delay) { + case ADSR_DISABLE: + adsr->state = ADSR_STATE_DISABLED; + break; + case ADSR_HANG: + adsr->state = ADSR_STATE_HANG; + break; + case ADSR_GOTO: + adsr->envIndex = BSWAP16(adsr->envelope[adsr->envIndex].arg); +#ifdef VERSION_SH + goto restart; +#else + break; +#endif + case ADSR_RESTART: + adsr->state = ADSR_STATE_INITIAL; + break; + + default: +#if defined(VERSION_EU) || defined(VERSION_SH) + if (adsr->delay >= 4) { + adsr->delay = adsr->delay * gAudioBufferParameters.updatesPerFrame +#ifdef VERSION_SH + / gAudioBufferParameters.presetUnk4 +#endif + / 4; + } +#if defined(VERSION_SH) + if (adsr->delay == 0) { + adsr->delay = 1; + } + adsr->target = (f32) BSWAP16(adsr->envelope[adsr->envIndex].arg) / 32767.0f; +#elif defined(VERSION_EU) + adsr->target = (f32) BSWAP16(adsr->envelope[adsr->envIndex].arg) / 32767.0; +#endif + adsr->target = adsr->target * adsr->target; + adsr->velocity = (adsr->target - adsr->current) / adsr->delay; +#else + adsr->target = BSWAP16(adsr->envelope[adsr->envIndex].arg); + adsr->velocity = ((adsr->target - adsr->current) << 0x10) / adsr->delay; +#endif + adsr->state = ADSR_STATE_FADE; + adsr->envIndex++; + break; + } + if (adsr->state != ADSR_STATE_FADE) { + break; + } + // fallthrough + + case ADSR_STATE_FADE: +#if defined(VERSION_EU) || defined(VERSION_SH) + adsr->current += adsr->velocity; +#else + adsr->currentHiRes += adsr->velocity; + adsr->current = adsr->currentHiRes >> 0x10; +#endif + if (--adsr->delay <= 0) { + adsr->state = ADSR_STATE_LOOP; + } + // fallthrough + + case ADSR_STATE_HANG: + break; + + case ADSR_STATE_DECAY: + case ADSR_STATE_RELEASE: { + adsr->current -= adsr->fadeOutVel; +#if defined(VERSION_EU) || defined(VERSION_SH) + if (adsr->sustain != 0.0f && state == ADSR_STATE_DECAY) { +#else + if (adsr->sustain != 0 && adsr->state == ADSR_STATE_DECAY) { +#endif + if (adsr->current < adsr->sustain) { + adsr->current = adsr->sustain; +#if defined(VERSION_EU) || defined(VERSION_SH) + adsr->delay = 128; +#else + adsr->delay = adsr->sustain / 16; +#endif + adsr->state = ADSR_STATE_SUSTAIN; + } + break; + } + +#if defined(VERSION_SH) + if (adsr->current < 0.00001f) { + adsr->current = 0.0f; + adsr->state = ADSR_STATE_DISABLED; + } +#elif defined(VERSION_EU) + if (adsr->current < 0) { + adsr->current = 0.0f; + adsr->state = ADSR_STATE_DISABLED; + } +#else + if (adsr->current < 100) { + adsr->current = 0; + adsr->state = ADSR_STATE_DISABLED; + } +#endif + break; + } + + case ADSR_STATE_SUSTAIN: + adsr->delay -= 1; + if (adsr->delay == 0) { + adsr->state = ADSR_STATE_RELEASE; + } + break; + } + + if ((action & ADSR_ACTION_DECAY)) { + adsr->state = ADSR_STATE_DECAY; + adsr->action = action & ~ADSR_ACTION_DECAY; + } + + if ((action & ADSR_ACTION_RELEASE)) { + adsr->state = ADSR_STATE_RELEASE; +#if defined(VERSION_EU) || defined(VERSION_SH) + adsr->action = action & ~ADSR_ACTION_RELEASE; +#else + adsr->action = action & ~(ADSR_ACTION_RELEASE | ADSR_ACTION_DECAY); +#endif + } + +#if defined(VERSION_EU) || defined(VERSION_SH) + if (adsr->current < 0.0f) { + return 0.0f; + } + if (adsr->current > 1.0f) { + eu_stubbed_printf_1("Audio:Envp: overflow %f\n", adsr->current); + return 1.0f; + } + return adsr->current; +#else + *adsr->volOut = adsr->current; + return 0; +#endif +} diff --git a/src/decomp/audio/effects.h b/src/decomp/audio/effects.h new file mode 100644 index 0000000..56709e8 --- /dev/null +++ b/src/decomp/audio/effects.h @@ -0,0 +1,48 @@ +#ifndef AUDIO_EFFECTS_H +#define AUDIO_EFFECTS_H + +#include + +#include "internal.h" +#include + +#define ADSR_STATE_DISABLED 0 +#define ADSR_STATE_INITIAL 1 +#define ADSR_STATE_START_LOOP 2 +#define ADSR_STATE_LOOP 3 +#define ADSR_STATE_FADE 4 +#define ADSR_STATE_HANG 5 +#define ADSR_STATE_DECAY 6 +#define ADSR_STATE_RELEASE 7 +#define ADSR_STATE_SUSTAIN 8 + +#define ADSR_ACTION_RELEASE 0x10 +#define ADSR_ACTION_DECAY 0x20 +#define ADSR_ACTION_HANG 0x40 + +#define ADSR_DISABLE 0 +#define ADSR_HANG -1 +#define ADSR_GOTO -2 +#define ADSR_RESTART -3 + +// Envelopes are always stored as big endian, to match sequence files which are +// byte blobs and can embed envelopes. Hence this byteswapping macro. +#if IS_BIG_ENDIAN +#define BSWAP16(x) (x) +#else +#define BSWAP16(x) (((x) & 0xff) << 8 | (((x) >> 8) & 0xff)) +#endif + +extern f32 gTrackVolume; + +void sequence_player_process_sound(struct SequencePlayer *seqPlayer); +void note_vibrato_update(struct Note *note); +void note_vibrato_init(struct Note *note); +void adsr_init(struct AdsrState *adsr, struct AdsrEnvelope *envelope, s16 *volOut); +#if defined(VERSION_EU) || defined(VERSION_SH) +f32 adsr_update(struct AdsrState *adsr); +#else +s32 adsr_update(struct AdsrState *adsr); +#endif + +#endif // AUDIO_EFFECTS_H diff --git a/src/decomp/audio/external.c b/src/decomp/audio/external.c new file mode 100644 index 0000000..7e9edab --- /dev/null +++ b/src/decomp/audio/external.c @@ -0,0 +1,2684 @@ +#include +#include +#include "heap.h" +#include "load.h" +#include "data.h" +#include "seqplayer.h" +#include "external.h" +#include "playback.h" +#include "synthesis.h" +#include "../game/level_update.h" +#include "../game/camera.h" +#include + +#define SOUND_BANK_COUNT 10 +#define gCurrLevelNum 0 +#define gCurrAreaIndex 1 +#define gMarioCurrentRoom 0 +#define LEVEL_MAX 0 +#define SEQ_BASE_ID 0x7f + +#if defined(VERSION_EU) || defined(VERSION_SH) +#define EU_FLOAT(x) x##f +#else +#define EU_FLOAT(x) x +#endif +#include "../../debug_print.h" + +// N.B. sound banks are different from the audio banks referred to in other +// files. We should really fix our naming to be less ambiguous... +#define MAX_BACKGROUND_MUSIC_QUEUE_SIZE 6 +#define MAX_CHANNELS_PER_SOUND_BANK 1 + +#define SEQUENCE_NONE 0xFF + +#define SAMPLES_TO_OVERPRODUCE 0x10 +#define EXTRA_BUFFERED_AI_SAMPLES_TARGET 0x40 + +struct Sound { + s32 soundBits; + f32 *position; +}; // size = 0x8 + +struct ChannelVolumeScaleFade { + f32 velocity; + u8 target; + f32 current; + u16 remainingFrames; +}; // size = 0x10 + +struct SoundCharacteristics { + f32 *x; + f32 *y; + f32 *z; + f32 distance; + u32 priority; + u32 soundBits; // packed bits, same as first arg to play_sound + u8 soundStatus; + u8 freshness; + u8 prev; + u8 next; +}; // size = 0x1C + +// Also the number of frames a discrete sound can be in the WAITING state before being deleted +#define SOUND_MAX_FRESHNESS 10 + +struct SequenceQueueItem { + u8 seqId; + u8 priority; +}; // size = 0x2 + +// data +#if defined(VERSION_EU) || defined(VERSION_SH) +// moved to bss in data.c +s32 gAudioErrorFlags2 = 0; +#else +s32 gAudioErrorFlags = 0; +#endif +s32 sGameLoopTicked = 0; + +f32 gAudioVolume = 1.0f; +u8 gAudioReverb = 0.0f; + +// Dialog sounds +// The US difference is the sound for DIALOG_037 ("I win! You lose! Ha ha ha ha! +// You're no slouch, but I'm a better sledder! Better luck next time!"), spoken +// by Koopa instead of the penguin in JP. + +#define UKIKI 0 +#define TUXIE 1 +#define BOWS1 2 // Bowser Intro / Doors Laugh +#define KOOPA 3 +#define KBOMB 4 +#define BOO 5 +#define BOMB 6 +#define BOWS2 7 // Bowser Battle Laugh +#define GRUNT 8 +#define WIGLR 9 +#define YOSHI 10 +#define _ 0xFF + +#ifdef VERSION_JP +#define DIFF KOOPA +#else +#define DIFF TUXIE +#endif + +u8 sDialogSpeaker[] = { + // 0 1 2 3 4 5 6 7 8 9 + /* 0*/ _, BOMB, BOMB, BOMB, BOMB, KOOPA, KOOPA, KOOPA, _, KOOPA, + /* 1*/ _, _, _, _, _, _, _, KBOMB, _, _, + /* 2*/ _, BOWS1, BOWS1, BOWS1, BOWS1, BOWS1, BOWS1, BOWS1, BOWS1, BOWS1, + /* 3*/ _, _, _, _, _, _, _, DIFF, _, _, + /* 4*/ _, KOOPA, _, _, _, _, _, BOMB, _, _, + /* 5*/ _, _, _, _, _, TUXIE, TUXIE, TUXIE, TUXIE, TUXIE, + /* 6*/ _, _, _, _, _, _, _, BOWS2, _, _, + /* 7*/ _, _, _, _, _, _, _, _, _, UKIKI, + /* 8*/ UKIKI, _, _, _, _, BOO, _, _, _, _, + /* 9*/ BOWS2, _, BOWS2, BOWS2, _, _, _, _, BOO, BOO, + /*10*/ UKIKI, UKIKI, _, _, _, BOMB, BOMB, BOO, BOO, _, + /*11*/ _, _, _, _, GRUNT, GRUNT, KBOMB, GRUNT, GRUNT, _, + /*12*/ _, _, _, _, _, _, _, _, KBOMB, _, + /*13*/ _, _, TUXIE, _, _, _, _, _, _, _, + /*14*/ _, _, _, _, _, _, _, _, _, _, + /*15*/ WIGLR, WIGLR, WIGLR, _, _, _, _, _, _, _, + /*16*/ _, YOSHI, _, _, _, _, _, _, WIGLR, _ +}; +#undef _ + +s32 sDialogSpeakerVoice[] = { + SOUND_OBJ_UKIKI_CHATTER_LONG, + SOUND_OBJ_BIG_PENGUIN_YELL, + SOUND_OBJ_BOWSER_INTRO_LAUGH, + SOUND_OBJ_KOOPA_TALK, + SOUND_OBJ_KING_BOBOMB_TALK, + SOUND_OBJ_BOO_LAUGH_LONG, + SOUND_OBJ_BOBOMB_BUDDY_TALK, + SOUND_OBJ_BOWSER_LAUGH, + SOUND_OBJ2_BOSS_DIALOG_GRUNT, + SOUND_OBJ_WIGGLER_TALK, + SOUND_GENERAL_YOSHI_TALK, +#if defined(VERSION_JP) || defined(VERSION_US) + NO_SOUND, + NO_SOUND, + NO_SOUND, + NO_SOUND, +#endif +}; + +u8 sNumProcessedSoundRequests = 0; +u8 sSoundRequestCount = 0; + +// Music dynamic tables. A dynamic describes which volumes to apply to which +// channels of a sequence (I think?), and different parts of a level can have +// different dynamics. Each table below specifies first the sequence to apply +// the dynamics to, then a bunch of conditions for when each dynamic applies +// (e.g. "only if Mario's X position is between 100 and 300"), and finally a +// fallback dynamic. Due to the encoding of the tables, the conditions must +// come in the same order as the macros. +// TODO: dynamic isn't a great term for this, it means other things in music... + +#define MARIO_X_GE 0 +#define MARIO_Y_GE 1 +#define MARIO_Z_GE 2 +#define MARIO_X_LT 3 +#define MARIO_Y_LT 4 +#define MARIO_Z_LT 5 +#define MARIO_IS_IN_AREA 6 +#define MARIO_IS_IN_ROOM 7 + +#define DYN1(cond1, val1, res) (s16)(1 << (15 - cond1) | res), val1 +#define DYN2(cond1, val1, cond2, val2, res) \ + (s16)(1 << (15 - cond1) | 1 << (15 - cond2) | res), val1, val2 +#define DYN3(cond1, val1, cond2, val2, cond3, val3, res) \ + (s16)(1 << (15 - cond1) | 1 << (15 - cond2) | 1 << (15 - cond3) | res), val1, val2, val3 + +s16 sDynHmc[] = { + SEQ_LEVEL_UNDERGROUND, DYN2(MARIO_X_GE, 0, MARIO_Y_LT, -203, 4), + DYN2(MARIO_X_LT, 0, MARIO_Y_LT, -2400, 4), 3, +}; +s16 sDynUnk38[] = { + SEQ_LEVEL_UNDERGROUND, + DYN1(MARIO_IS_IN_AREA, 1, 3), + DYN1(MARIO_IS_IN_AREA, 2, 4), + DYN1(MARIO_IS_IN_AREA, 3, 7), + 0, +}; +s16 sDynNone[] = { SEQ_SOUND_PLAYER, 0 }; + +u8 sCurrentMusicDynamic = 0xff; +u8 sBackgroundMusicForDynamics = SEQUENCE_NONE; + +#define STUB_LEVEL(_0, _1, _2, _3, _4, _5, _6, leveldyn, _8) leveldyn, +#define DEFINE_LEVEL(_0, _1, _2, _3, _4, _5, _6, _7, _8, leveldyn, _10) leveldyn, +#define LEVEL_COUNT 1 +#define _ sDynNone +s16 *sLevelDynamics[LEVEL_COUNT] = { + _, // LEVEL_NONE +}; +#undef _ +#undef STUB_LEVEL +#undef DEFINE_LEVEL + +struct MusicDynamic { + /*0x0*/ s16 bits1; + /*0x2*/ u16 volScale1; + /*0x4*/ s16 dur1; + /*0x6*/ s16 bits2; + /*0x8*/ u16 volScale2; + /*0xA*/ s16 dur2; +}; // size = 0xC + +struct MusicDynamic sMusicDynamics[8] = { + { 0x0000, 127, 100, 0x0e43, 0, 100 }, // SEQ_LEVEL_WATER + { 0x0003, 127, 100, 0x0e40, 0, 100 }, // SEQ_LEVEL_WATER + { 0x0e43, 127, 200, 0x0000, 0, 200 }, // SEQ_LEVEL_WATER + { 0x02ff, 127, 100, 0x0100, 0, 100 }, // SEQ_LEVEL_UNDERGROUND + { 0x03f7, 127, 100, 0x0008, 0, 100 }, // SEQ_LEVEL_UNDERGROUND + { 0x0070, 127, 10, 0x0000, 0, 100 }, // SEQ_LEVEL_SPOOKY + { 0x0000, 127, 100, 0x0070, 0, 10 }, // SEQ_LEVEL_SPOOKY + { 0xffff, 127, 100, 0x0000, 0, 100 }, // any (unused) +}; + +#define STUB_LEVEL(_0, _1, _2, _3, echo1, echo2, echo3, _7, _8) { echo1, echo2, echo3 }, +#define DEFINE_LEVEL(_0, _1, _2, _3, _4, _5, echo1, echo2, echo3, _9, _10) { echo1, echo2, echo3 }, + +u8 sLevelAreaReverbs[LEVEL_COUNT][3] = { + { 0x00, 0x00, 0x00 }, // LEVEL_NONE +}; +#undef STUB_LEVEL +#undef DEFINE_LEVEL + +#define STUB_LEVEL(_0, _1, _2, volume, _4, _5, _6, _7, _8) volume, +#define DEFINE_LEVEL(_0, _1, _2, _3, _4, volume, _6, _7, _8, _9, _10) volume, + +u16 sLevelAcousticReaches[LEVEL_COUNT] = { + 20000, // LEVEL_NONE +}; + +#undef STUB_LEVEL +#undef DEFINE_LEVEL + +#define AUDIO_MAX_DISTANCE US_FLOAT(22000.0) + +#ifdef VERSION_JP +#define LOW_VOLUME_REVERB 48.0 +#else +#define LOW_VOLUME_REVERB 40.0f +#endif + +#ifdef VERSION_JP +#define VOLUME_RANGE_UNK1 0.8f +#define VOLUME_RANGE_UNK2 1.0f +#else +#define VOLUME_RANGE_UNK1 0.9f +#define VOLUME_RANGE_UNK2 0.8f +#endif + +// Default volume for background music sequences (playing on player 0). +u8 sBackgroundMusicDefaultVolume[] = { + 127, // SEQ_SOUND_PLAYER + 80, // SEQ_EVENT_CUTSCENE_COLLECT_STAR + 80, // SEQ_MENU_TITLE_SCREEN + 75, // SEQ_LEVEL_GRASS + 70, // SEQ_LEVEL_INSIDE_CASTLE + 75, // SEQ_LEVEL_WATER + 75, // SEQ_LEVEL_HOT + 75, // SEQ_LEVEL_BOSS_KOOPA + 70, // SEQ_LEVEL_SNOW + 65, // SEQ_LEVEL_SLIDE + 80, // SEQ_LEVEL_SPOOKY + 65, // SEQ_EVENT_PIRANHA_PLANT + 85, // SEQ_LEVEL_UNDERGROUND + 75, // SEQ_MENU_STAR_SELECT + 65, // SEQ_EVENT_POWERUP + 70, // SEQ_EVENT_METAL_CAP + 65, // SEQ_EVENT_KOOPA_MESSAGE + 70, // SEQ_LEVEL_KOOPA_ROAD + 70, // SEQ_EVENT_HIGH_SCORE + 65, // SEQ_EVENT_MERRY_GO_ROUND + 80, // SEQ_EVENT_RACE + 70, // SEQ_EVENT_CUTSCENE_STAR_SPAWN + 85, // SEQ_EVENT_BOSS + 75, // SEQ_EVENT_CUTSCENE_COLLECT_KEY + 75, // SEQ_EVENT_ENDLESS_STAIRS + 85, // SEQ_LEVEL_BOSS_KOOPA_FINAL + 70, // SEQ_EVENT_CUTSCENE_CREDITS + 80, // SEQ_EVENT_SOLVE_PUZZLE + 80, // SEQ_EVENT_TOAD_MESSAGE + 70, // SEQ_EVENT_PEACH_MESSAGE + 75, // SEQ_EVENT_CUTSCENE_INTRO + 80, // SEQ_EVENT_CUTSCENE_VICTORY + 70, // SEQ_EVENT_CUTSCENE_ENDING + 65, // SEQ_MENU_FILE_SELECT + 0, // SEQ_EVENT_CUTSCENE_LAKITU (not in JP) +}; + +STATIC_ASSERT(ARRAY_COUNT(sBackgroundMusicDefaultVolume) == SEQ_COUNT, + "change this array if you are adding sequences"); + +u8 sCurrentBackgroundMusicSeqId = SEQUENCE_NONE; +u8 sMusicDynamicDelay = 0; +u8 sSoundBankUsedListBack[SOUND_BANK_COUNT] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; +u8 sSoundBankFreeListFront[SOUND_BANK_COUNT] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }; +u8 sNumSoundsInBank[SOUND_BANK_COUNT] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; // only used for debugging +u8 sMaxChannelsForSoundBank[SOUND_BANK_COUNT] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }; + +// Banks 2 and 7 both grew from 0x30 sounds to 0x40 in size in US. +#ifdef VERSION_JP +#define BANK27_SIZE 0x30 +#else +#define BANK27_SIZE 0x40 +#endif +u8 sNumSoundsPerBank[SOUND_BANK_COUNT] = { + 0x70, 0x30, BANK27_SIZE, 0x80, 0x20, 0x80, 0x20, BANK27_SIZE, 0x80, 0x80, +}; +#undef BANK27_SIZE + +// sBackgroundMusicMaxTargetVolume and sBackgroundMusicTargetVolume use the 0x80 +// bit to indicate that they are set, and the rest of the bits for the actual value +#define TARGET_VOLUME_IS_PRESENT_FLAG 0x80 +#define TARGET_VOLUME_VALUE_MASK 0x7f +#define TARGET_VOLUME_UNSET 0x00 + +f32 gGlobalSoundSource[3] = { 0.0f, 0.0f, 0.0f }; +f32 sUnusedSoundArgs[3] = { 1.0f, 1.0f, 1.0f }; +u8 sSoundBankDisabled[16] = { 0 }; +u8 D_80332108 = 0; +u8 sHasStartedFadeOut = FALSE; +u16 sSoundBanksThatLowerBackgroundMusic = 0; +u8 sUnused80332114 = 0; // never read, set to 0 +u16 sUnused80332118 = 0; // never read, set to 0 +u8 sBackgroundMusicMaxTargetVolume = TARGET_VOLUME_UNSET; +u8 D_80332120 = 0; +u8 D_80332124 = 0; + +#if defined(VERSION_EU) || defined(VERSION_SH) +u8 D_EU_80300558 = 0; +#endif + +u8 sBackgroundMusicQueueSize = 0; + +#ifndef VERSION_JP +u8 sUnused8033323C = 0; // never read, set to 0 +#endif + + +// bss +#if defined(VERSION_JP) || defined(VERSION_US) +s16 *gCurrAiBuffer; +#endif +#ifdef VERSION_SH +s8 D_SH_80343CD0_pad[0x20]; +s32 D_SH_80343CF0; +s8 D_SH_80343CF8_pad[0x8]; +struct UnkStruct80343D00 D_SH_80343D00; +s8 D_SH_8034DC8_pad[0x8]; +OSPiHandle DriveRomHandle; // used in osDriveRomInit.c. Why here? +s8 D_SH_80343E48_pad[0x8]; +#endif + +struct Sound sSoundRequests[0x100]; +// Curiously, this has size 3, despite SEQUENCE_PLAYERS == 4 on EU +struct ChannelVolumeScaleFade D_80360928[3][CHANNELS_MAX]; +u8 sUsedChannelsForSoundBank[SOUND_BANK_COUNT]; +u8 sCurrentSound[SOUND_BANK_COUNT][MAX_CHANNELS_PER_SOUND_BANK]; // index into sSoundBanks + +/** + * For each sound bank, a pool containing the currently active sounds for that bank. + * The free and used slots in these pools are linked lists. The element sSoundBanks[bank][0] + * is used as a list header for the used list, and never holds an actual sound. See also + * sSoundBankUsedListBack and sSoundBankFreeListFront. + */ +struct SoundCharacteristics sSoundBanks[SOUND_BANK_COUNT][40]; + +u8 sSoundMovingSpeed[SOUND_BANK_COUNT]; +u8 sBackgroundMusicTargetVolume; +static u8 sLowerBackgroundMusicVolume; +struct SequenceQueueItem sBackgroundMusicQueue[MAX_BACKGROUND_MUSIC_QUEUE_SIZE]; + +#if defined(VERSION_EU) || defined(VERSION_SH) +s32 unk_sh_8034754C; +#endif + +#ifdef VERSION_EU +OSMesgQueue OSMesgQueue0; +OSMesgQueue OSMesgQueue1; +OSMesgQueue OSMesgQueue2; +OSMesgQueue OSMesgQueue3; +extern OSMesgQueue *OSMesgQueues[]; + +struct EuAudioCmd sAudioCmd[0x100]; + +OSMesg OSMesg0; +s32 pad1; // why is there 1 s32 here +OSMesg OSMesg1; +s32 pad2[2]; // it's not just that the struct is bigger than we think, because there are 2 here +OSMesg OSMesg2; // and none here. wth nintendo +OSMesg OSMesg3; +#else // VERSION_SH +extern OSMesgQueue *D_SH_80350F88; +extern OSMesgQueue *D_SH_80350FA8; +#endif + +#ifdef VERSION_JP +typedef u16 FadeT; +#else +typedef s32 FadeT; +#endif + +// some sort of main thread -> sound thread dispatchers +extern void func_802ad728(u32 bits, f32 arg); +extern void func_802ad74c(u32 bits, u32 arg); +extern void func_802ad770(u32 bits, s8 arg); + +static void update_background_music_after_sound(u8 bank, u8 soundIndex); +static void update_game_sound(void); +static void fade_channel_volume_scale(u8 player, u8 channelId, u8 targetScale, u16 fadeTimer); +void process_level_music_dynamics(void); +static u8 begin_background_music_fade(u16 fadeDuration); +void func_80320ED8(void); + +#ifndef VERSION_JP +void unused_8031E4F0(void) { + // This is a debug function which is almost entirely optimized away, + // except for loops, string literals, and a read of a volatile variable. + // The string literals have allowed it to be partially reconstructed. + s32 i; + + stubbed_printf("AUTOSEQ "); + stubbed_printf("%2x %2x <%5x : %5x / %5x>\n", gSeqLoadedPool.temporary.entries[0].id, + gSeqLoadedPool.temporary.entries[1].id, gSeqLoadedPool.temporary.entries[0].size, + gSeqLoadedPool.temporary.entries[1].size, gSeqLoadedPool.temporary.pool.size); + + stubbed_printf("AUTOBNK "); + stubbed_printf("%2x %3x <%5x : %5x / %5x>\n", gBankLoadedPool.temporary.entries[0].id, + gBankLoadedPool.temporary.entries[1].id, gBankLoadedPool.temporary.entries[0].size, + gBankLoadedPool.temporary.entries[1].size, gBankLoadedPool.temporary.pool.size); + + stubbed_printf("STAYSEQ "); + stubbed_printf("[%2x] <%5x / %5x>\n", gSeqLoadedPool.persistent.numEntries, + gSeqLoadedPool.persistent.pool.cur - gSeqLoadedPool.persistent.pool.start, + gSeqLoadedPool.persistent.pool.size); + for (i = 0; (u32) i < gSeqLoadedPool.persistent.numEntries; i++) { + stubbed_printf("%2x ", gSeqLoadedPool.persistent.entries[i].id); + } + stubbed_printf("\n"); + + stubbed_printf("STAYBNK "); + stubbed_printf("[%2x] <%5x / %5x>\n", gBankLoadedPool.persistent.numEntries, + gBankLoadedPool.persistent.pool.cur - gBankLoadedPool.persistent.pool.start, + gBankLoadedPool.persistent.pool.size); + for (i = 0; (u32) i < gBankLoadedPool.persistent.numEntries; i++) { + stubbed_printf("%2x ", gBankLoadedPool.persistent.entries[i].id); + } + stubbed_printf("\n\n"); + + stubbed_printf(" 0123456789ABCDEF0123456789ABCDEF01234567\n"); + stubbed_printf("--------------------------------------------\n"); + + // gSeqLoadStatus/gBankLoadStatus, 4 entries at a time? + stubbed_printf("SEQ "); + for (i = 0; i < 40; i++) { + stubbed_printf("%1x", 0); + } + stubbed_printf("\n"); + + stubbed_printf("BNK "); + for (i = 0; i < 40; i += 4) { + stubbed_printf("%1x", 0); + } + stubbed_printf("\n"); + + stubbed_printf("FIXHEAP "); + stubbed_printf("%4x / %4x\n", 0, 0); + stubbed_printf("DRVHEAP "); + stubbed_printf("%5x / %5x\n", 0, 0); + stubbed_printf("DMACACHE %4d Blocks\n", 0); + stubbed_printf("CHANNELS %2d / MAX %3d \n", 0, 0); + + stubbed_printf("TEMPOMAX %d\n", gTempoInternalToExternal / TEMPO_SCALE); + stubbed_printf("TEMPO G0 %d\n", gSequencePlayers[SEQ_PLAYER_LEVEL].tempo / TEMPO_SCALE); + stubbed_printf("TEMPO G1 %d\n", gSequencePlayers[SEQ_PLAYER_ENV].tempo / TEMPO_SCALE); + stubbed_printf("TEMPO G2 %d\n", gSequencePlayers[SEQ_PLAYER_SFX].tempo / TEMPO_SCALE); + stubbed_printf("DEBUGFLAG %8x\n", gAudioErrorFlags); +} + +void unused_8031E568(void) { + stubbed_printf("COUNT %8d\n", gAudioFrameCount); +} +#endif + +#if defined(VERSION_EU) || defined(VERSION_SH) +const char unusedErrorStr1[] = "Error : Queue is not empty ( %x ) \n"; +const char unusedErrorStr2[] = "specchg error\n"; +#endif + +/** + * Fade out a sequence player + * Called from threads: thread5_game_loop + */ +#if defined(VERSION_EU) || defined(VERSION_SH) +void audio_reset_session_eu(s32 presetId) { + OSMesg mesg; +#ifdef VERSION_SH + osRecvMesg(D_SH_80350FA8, &mesg, OS_MESG_NOBLOCK); + osSendMesg(D_SH_80350F88, (OSMesg) presetId, OS_MESG_NOBLOCK); + osRecvMesg(D_SH_80350FA8, &mesg, OS_MESG_BLOCK); + if ((s32) mesg != presetId) { + osRecvMesg(D_SH_80350FA8, &mesg, OS_MESG_BLOCK); + } + +#else + osRecvMesg(OSMesgQueues[3], &mesg, OS_MESG_NOBLOCK); + osSendMesg(OSMesgQueues[2], (OSMesg) presetId, OS_MESG_NOBLOCK); + osRecvMesg(OSMesgQueues[3], &mesg, OS_MESG_BLOCK); + if ((s32) mesg != presetId) { + osRecvMesg(OSMesgQueues[3], &mesg, OS_MESG_BLOCK); + } +#endif +} +#endif + +#if defined(VERSION_JP) || defined(VERSION_US) +/** + * Called from threads: thread3_main, thread5_game_loop + */ +static void seq_player_fade_to_zero_volume(s32 player, FadeT fadeDuration) { + struct SequencePlayer *seqPlayer = &gSequencePlayers[player]; + +#ifndef VERSION_JP + // fadeDuration is never 0 in practice + if (fadeDuration == 0) { + fadeDuration++; + } +#endif + + seqPlayer->fadeVelocity = -(seqPlayer->fadeVolume / fadeDuration); + seqPlayer->state = SEQUENCE_PLAYER_STATE_FADE_OUT; + seqPlayer->fadeRemainingFrames = fadeDuration; +} + +/** + * Called from threads: thread4_sound, thread5_game_loop + */ +static void func_8031D690(s32 player, FadeT fadeInTime) { + struct SequencePlayer *seqPlayer = &gSequencePlayers[player]; + + if (fadeInTime == 0 || seqPlayer->state == SEQUENCE_PLAYER_STATE_FADE_OUT) { + return; + } + + seqPlayer->state = SEQUENCE_PLAYER_STATE_2; + seqPlayer->fadeRemainingFrames = fadeInTime; + seqPlayer->fadeVolume = 0.0f; + seqPlayer->fadeVelocity = 0.0f; +} +#endif + +/** + * Called from threads: thread5_game_loop + */ +static void seq_player_fade_to_percentage_of_volume(s32 player, FadeT fadeDuration, u8 percentage) { + struct SequencePlayer *seqPlayer = &gSequencePlayers[player]; + f32 targetVolume; + +#if defined(VERSION_EU) || defined(VERSION_SH) + if (seqPlayer->state == 2) { + return; + } +#else + if (seqPlayer->state == SEQUENCE_PLAYER_STATE_FADE_OUT) { + return; + } +#endif + + targetVolume = (FLOAT_CAST(percentage) / EU_FLOAT(100.0)) * seqPlayer->fadeVolume; + seqPlayer->volume = seqPlayer->fadeVolume; + + seqPlayer->fadeRemainingFrames = 0; + if (fadeDuration == 0) { + seqPlayer->fadeVolume = targetVolume; + return; + } + seqPlayer->fadeVelocity = (targetVolume - seqPlayer->fadeVolume) / fadeDuration; +#if defined(VERSION_EU) || defined(VERSION_SH) + seqPlayer->state = 0; +#else + seqPlayer->state = SEQUENCE_PLAYER_STATE_4; +#endif + + seqPlayer->fadeRemainingFrames = fadeDuration; +} + +/** + * Called from threads: thread3_main, thread4_sound, thread5_game_loop + */ +static void seq_player_fade_to_normal_volume(s32 player, FadeT fadeDuration) { + struct SequencePlayer *seqPlayer = &gSequencePlayers[player]; + +#if defined(VERSION_EU) || defined(VERSION_SH) + if (seqPlayer->state == 2) { + return; + } +#else + if (seqPlayer->state == SEQUENCE_PLAYER_STATE_FADE_OUT) { + return; + } +#endif + + seqPlayer->fadeRemainingFrames = 0; + if (fadeDuration == 0) { + seqPlayer->fadeVolume = seqPlayer->volume; + return; + } + seqPlayer->fadeVelocity = (seqPlayer->volume - seqPlayer->fadeVolume) / fadeDuration; +#if defined(VERSION_EU) || defined(VERSION_SH) + seqPlayer->state = 0; +#else + seqPlayer->state = SEQUENCE_PLAYER_STATE_2; +#endif + + seqPlayer->fadeRemainingFrames = fadeDuration; +} + +/** + * Called from threads: thread3_main, thread4_sound, thread5_game_loop + */ +static void seq_player_fade_to_target_volume(s32 player, FadeT fadeDuration, u8 targetVolume) { + struct SequencePlayer *seqPlayer = &gSequencePlayers[player]; + +#if defined(VERSION_JP) || defined(VERSION_US) + if (seqPlayer->state == SEQUENCE_PLAYER_STATE_FADE_OUT) { + return; + } +#endif + + seqPlayer->fadeRemainingFrames = 0; + if (fadeDuration == 0) { + seqPlayer->fadeVolume = (FLOAT_CAST(targetVolume) / EU_FLOAT(127.0)); + return; + } + + seqPlayer->fadeVelocity = + (((f32)(FLOAT_CAST(targetVolume) / EU_FLOAT(127.0)) - seqPlayer->fadeVolume) + / (f32) fadeDuration); +#if defined(VERSION_EU) || defined(VERSION_SH) + seqPlayer->state = 0; +#else + seqPlayer->state = SEQUENCE_PLAYER_STATE_4; +#endif + + seqPlayer->fadeRemainingFrames = fadeDuration; +} + +#if defined(VERSION_EU) || defined(VERSION_SH) +#ifdef VERSION_EU +extern void func_802ad7a0(void); +#else +extern void func_sh_802F64C8(void); +#endif + +/** + * Called from threads: thread5_game_loop + */ +void maybe_tick_game_sound(void) { + if (sGameLoopTicked != 0) { + update_game_sound(); + sGameLoopTicked = 0; + } +#ifdef VERSION_EU + func_802ad7a0(); +#else + func_sh_802F64C8(); // moved in SH +#endif +} + +void func_eu_802e9bec(s32 player, s32 channel, s32 arg2) { + // EU verson of unused_803209D8 + // chan->stopSomething2 = arg2? + func_802ad770(0x08000000 | (player & 0xff) << 16 | (channel & 0xff) << 8, (s8) arg2); +} + +#else + +#ifdef TARGET_N64 +/** + * Called from threads: thread4_sound + */ +struct SPTask *create_next_audio_frame_task(void) { + u32 samplesRemainingInAI; + s32 writtenCmds; + s32 index; + OSTask_t *task; + s32 oldDmaCount; + s32 flags; + + gAudioFrameCount++; + if (gAudioLoadLock != AUDIO_LOCK_NOT_LOADING) { + stubbed_printf("DAC:Lost 1 Frame.\n"); + return NULL; + } + + gAudioTaskIndex ^= 1; + gCurrAiBufferIndex++; + gCurrAiBufferIndex %= NUMAIBUFFERS; + index = (gCurrAiBufferIndex - 2 + NUMAIBUFFERS) % NUMAIBUFFERS; + samplesRemainingInAI = osAiGetLength() / 4; + + // Audio is triple buffered; the audio interface reads from two buffers + // while the third is being written by the RSP. More precisely, the + // lifecycle is: + // - this function computes an audio command list + // - wait for vblank + // - the command list is sent to the RSP (we could have sent it to the + // RSP before the vblank, but that gives the RSP less time to finish) + // - wait for vblank + // - the RSP is now expected to be finished, and we can send its output + // on to the AI + // Here we thus send to the AI the sound that was generated two frames ago. + if (gAiBufferLengths[index] != 0) { + osAiSetNextBuffer(gAiBuffers[index], gAiBufferLengths[index] * 4); + } + + oldDmaCount = gCurrAudioFrameDmaCount; + // There has to be some sort of no-op if here, but it's not exactly clear + // how it should look... It's also very unclear why gCurrAudioFrameDmaQueue + // isn't read from here, despite gCurrAudioFrameDmaCount being reset. + if (oldDmaCount > AUDIO_FRAME_DMA_QUEUE_SIZE) { + stubbed_printf("DMA: Request queue over.( %d )\n", oldDmaCount); + } + gCurrAudioFrameDmaCount = 0; + + gAudioTask = &gAudioTasks[gAudioTaskIndex]; + gAudioCmd = gAudioCmdBuffers[gAudioTaskIndex]; + + index = gCurrAiBufferIndex; + gCurrAiBuffer = gAiBuffers[index]; + gAiBufferLengths[index] = + ((gSamplesPerFrameTarget - samplesRemainingInAI + EXTRA_BUFFERED_AI_SAMPLES_TARGET) & ~0xf) + + SAMPLES_TO_OVERPRODUCE; + if (gAiBufferLengths[index] < gMinAiBufferLength) { + gAiBufferLengths[index] = gMinAiBufferLength; + } + if (gAiBufferLengths[index] > gSamplesPerFrameTarget + SAMPLES_TO_OVERPRODUCE) { + gAiBufferLengths[index] = gSamplesPerFrameTarget + SAMPLES_TO_OVERPRODUCE; + } + + if (sGameLoopTicked != 0) { + update_game_sound(); + sGameLoopTicked = 0; + } + + // For the function to match we have to preserve some arbitrary variable + // across this function call. + flags = 0; + gAudioCmd = synthesis_execute(gAudioCmd, &writtenCmds, gCurrAiBuffer, gAiBufferLengths[index]); + gAudioRandom = ((gAudioRandom + gAudioFrameCount) * gAudioFrameCount); + + index = gAudioTaskIndex; + gAudioTask->msgqueue = NULL; + gAudioTask->msg = NULL; + + task = &gAudioTask->task.t; + task->type = M_AUDTASK; + task->flags = flags; + task->ucode_boot = rspF3DBootStart; + task->ucode_boot_size = (u8 *) rspF3DBootEnd - (u8 *) rspF3DBootStart; + task->ucode = rspAspMainStart; + task->ucode_size = 0x800; // (this size is ignored) + task->ucode_data = rspAspMainDataStart; + task->ucode_data_size = (rspAspMainDataEnd - rspAspMainDataStart) * sizeof(u64); + task->dram_stack = NULL; + task->dram_stack_size = 0; + task->output_buff = NULL; + task->output_buff_size = NULL; + task->data_ptr = gAudioCmdBuffers[index]; + task->data_size = writtenCmds * sizeof(u64); + +// The audio task never yields, so having a yield buffer is pointless. +// This wastefulness was fixed in US. +#ifdef VERSION_JP + task->yield_data_ptr = (u64 *) gAudioSPTaskYieldBuffer; + task->yield_data_size = OS_YIELD_AUDIO_SIZE; +#else + task->yield_data_ptr = NULL; + task->yield_data_size = 0; +#endif + + decrease_sample_dma_ttls(); + return gAudioTask; +} +#else +struct SPTask *create_next_audio_frame_task(void) { + return NULL; +} +void create_next_audio_buffer(s16 *samples, u32 num_samples) { + gAudioFrameCount++; + if (sGameLoopTicked != 0) { + update_game_sound(); + sGameLoopTicked = 0; + } + s32 writtenCmds; + synthesis_execute(gAudioCmdBuffers[0], &writtenCmds, samples, num_samples); + gAudioRandom = ((gAudioRandom + gAudioFrameCount) * gAudioFrameCount); + decrease_sample_dma_ttls(); +} +#endif +#endif + +/** + * Called from threads: thread5_game_loop + */ +void play_sound(s32 soundBits, f32 *pos) { + sSoundRequests[sSoundRequestCount].soundBits = soundBits; + sSoundRequests[sSoundRequestCount].position = pos; + sSoundRequestCount++; + //DEBUG_PRINT("play_sound(%d) request#%d; pos %f %f %f\n", soundBits,sSoundRequestCount,pos[0],pos[1],pos[2]); +} + +/** + * Called from threads: thread4_sound, thread5_game_loop (EU only) + */ +static void process_sound_request(u32 bits, f32 *pos) { + //DEBUG_PRINT("process_sound_request %d\n", bits); + u8 bank; + u8 soundIndex; + u8 counter = 0; + u8 soundId; + f32 dist; + const f32 one = 1.0f; + + bank = (bits & SOUNDARGS_MASK_BANK) >> SOUNDARGS_SHIFT_BANK; + soundId = (bits & SOUNDARGS_MASK_SOUNDID) >> SOUNDARGS_SHIFT_SOUNDID; + + if (soundId >= sNumSoundsPerBank[bank] || sSoundBankDisabled[bank]) { + //DEBUG_PRINT("process_sound_request: invalid soundId %d\n", soundId); + return; + } + + soundIndex = sSoundBanks[bank][0].next; + while (soundIndex != 0xff && soundIndex != 0) { + //DEBUG_PRINT("process_sound_request: soundIndex %d\n", soundIndex); + // If an existing sound from the same source exists in the bank, then we should either + // interrupt that sound and replace it with the new sound, or we should drop the new sound. + if (sSoundBanks[bank][soundIndex].x == pos) { + // If the existing sound has lower or equal priority, then we should replace it. + // Otherwise the new sound will be dropped. + if ((sSoundBanks[bank][soundIndex].soundBits & SOUNDARGS_MASK_PRIORITY) + <= (bits & SOUNDARGS_MASK_PRIORITY)) { + + // If the existing sound is discrete or is a different continuous sound, then + // interrupt it and play the new sound instead. + // Otherwise the new sound is continuous and equals the existing sound, so we just + // need to update the sound's freshness. + if ((sSoundBanks[bank][soundIndex].soundBits & SOUND_DISCRETE) != 0 + || (bits & SOUNDARGS_MASK_SOUNDID) + != (sSoundBanks[bank][soundIndex].soundBits & SOUNDARGS_MASK_SOUNDID)) { + update_background_music_after_sound(bank, soundIndex); + sSoundBanks[bank][soundIndex].soundBits = bits; + // In practice, the starting status is always WAITING + sSoundBanks[bank][soundIndex].soundStatus = bits & SOUNDARGS_MASK_STATUS; + } + + // Reset freshness: + // - For discrete sounds, this gives the sound SOUND_MAX_FRESHNESS frames to play + // before it gets deleted for being stale + // - For continuous sounds, this gives it another 2 frames before play_sound must + // be called again to keep it playing + sSoundBanks[bank][soundIndex].freshness = SOUND_MAX_FRESHNESS; + } + + // Prevent allocating a new node - if the existing sound had higher piority, then the + // new sound will be dropped + soundIndex = 0; + } else { + soundIndex = sSoundBanks[bank][soundIndex].next; + } + counter++; + } + + if (counter == 0) { + sSoundMovingSpeed[bank] = 32; + } + + // If free list has more than one element remaining + if (sSoundBanks[bank][sSoundBankFreeListFront[bank]].next != 0xff && soundIndex != 0) { + //DEBUG_PRINT("process_sound_request2: soundIndex %d\n", soundIndex); + // Allocate from free list + soundIndex = sSoundBankFreeListFront[bank]; + + dist = sqrtf(pos[0] * pos[0] + pos[1] * pos[1] + pos[2] * pos[2]) * one; + sSoundBanks[bank][soundIndex].x = &pos[0]; + sSoundBanks[bank][soundIndex].y = &pos[1]; + sSoundBanks[bank][soundIndex].z = &pos[2]; + sSoundBanks[bank][soundIndex].distance = dist; + sSoundBanks[bank][soundIndex].soundBits = bits; + // In practice, the starting status is always WAITING + sSoundBanks[bank][soundIndex].soundStatus = bits & SOUNDARGS_MASK_STATUS; + sSoundBanks[bank][soundIndex].freshness = SOUND_MAX_FRESHNESS; + + // Append to end of used list and pop from front of free list + sSoundBanks[bank][soundIndex].prev = sSoundBankUsedListBack[bank]; + sSoundBanks[bank][sSoundBankUsedListBack[bank]].next = sSoundBankFreeListFront[bank]; + sSoundBankUsedListBack[bank] = sSoundBankFreeListFront[bank]; + sSoundBankFreeListFront[bank] = sSoundBanks[bank][sSoundBankFreeListFront[bank]].next; + sSoundBanks[bank][sSoundBankFreeListFront[bank]].prev = 0xff; + sSoundBanks[bank][soundIndex].next = 0xff; + } +} + +/** + * Processes all sound requests + * + * Called from threads: thread4_sound, thread5_game_loop (EU only) + */ +static void process_all_sound_requests(void) { + struct Sound *sound; + + while (sSoundRequestCount != sNumProcessedSoundRequests) { + sound = &sSoundRequests[sNumProcessedSoundRequests]; + process_sound_request(sound->soundBits, sound->position); + sNumProcessedSoundRequests++; + //DEBUG_PRINT("processed sounds: %d\n", sNumProcessedSoundRequests); + } +} + +/** + * Called from threads: thread4_sound, thread5_game_loop (EU only) + */ +static void delete_sound_from_bank(u8 bank, u8 soundIndex) { + if (sSoundBankUsedListBack[bank] == soundIndex) { + // Remove from end of used list + sSoundBankUsedListBack[bank] = sSoundBanks[bank][soundIndex].prev; + } else { + // Set sound.next.prev to sound.prev + sSoundBanks[bank][sSoundBanks[bank][soundIndex].next].prev = sSoundBanks[bank][soundIndex].prev; + } + + // Set sound.prev.next to sound.next + sSoundBanks[bank][sSoundBanks[bank][soundIndex].prev].next = sSoundBanks[bank][soundIndex].next; + + // Push to front of free list + sSoundBanks[bank][soundIndex].next = sSoundBankFreeListFront[bank]; + sSoundBanks[bank][soundIndex].prev = 0xff; + sSoundBanks[bank][sSoundBankFreeListFront[bank]].prev = soundIndex; + sSoundBankFreeListFront[bank] = soundIndex; +} + +/** + * Called from threads: thread3_main, thread4_sound, thread5_game_loop + */ +static void update_background_music_after_sound(u8 bank, u8 soundIndex) { + if (sSoundBanks[bank][soundIndex].soundBits & SOUND_LOWER_BACKGROUND_MUSIC) { + sSoundBanksThatLowerBackgroundMusic &= (1 << bank) ^ 0xffff; + begin_background_music_fade(50); + } +} + +/** + * Called from threads: thread4_sound, thread5_game_loop (EU only) + */ +static void select_current_sounds(u8 bank) { + u32 isDiscreteAndStatus; + u8 latestSoundIndex; + u8 i; + u8 j; + u8 soundIndex; + u32 liveSoundPriorities[16] = { 0x10000000, 0x10000000, 0x10000000, 0x10000000, + 0x10000000, 0x10000000, 0x10000000, 0x10000000, + 0x10000000, 0x10000000, 0x10000000, 0x10000000, + 0x10000000, 0x10000000, 0x10000000, 0x10000000 }; + u8 liveSoundIndices[16] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; + u8 liveSoundStatuses[16] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; + u8 numSoundsInBank = 0; + u8 requestedPriority; + + // + // Delete stale sounds and prioritize remaining sounds into the liveSound arrays + // + soundIndex = sSoundBanks[bank][0].next; + while (soundIndex != 0xff) { + latestSoundIndex = soundIndex; + + // If a discrete sound goes 10 frames without being played (because it is too low + // priority), then mark it for deletion + if ((sSoundBanks[bank][soundIndex].soundBits & (SOUND_DISCRETE | SOUNDARGS_MASK_STATUS)) + == (SOUND_DISCRETE | SOUND_STATUS_WAITING)) { + if (sSoundBanks[bank][soundIndex].freshness-- == 0) { + sSoundBanks[bank][soundIndex].soundBits = NO_SOUND; + } + } + // If a continuous sound goes 2 frames without play_sound being called, then mark it for + // deletion + else if ((sSoundBanks[bank][soundIndex].soundBits & SOUND_DISCRETE) == 0) { + if (sSoundBanks[bank][soundIndex].freshness-- == SOUND_MAX_FRESHNESS - 2) { + update_background_music_after_sound(bank, soundIndex); + sSoundBanks[bank][soundIndex].soundBits = NO_SOUND; + } + } + + // If a sound was marked for deletion and hasn't started playing yet, delete it now + if (sSoundBanks[bank][soundIndex].soundBits == NO_SOUND + && sSoundBanks[bank][soundIndex].soundStatus == SOUND_STATUS_WAITING) { + // Since the current sound will be deleted, the next iteration should process + // sound.prev.next + latestSoundIndex = sSoundBanks[bank][soundIndex].prev; + sSoundBanks[bank][soundIndex].soundStatus = SOUND_STATUS_STOPPED; + delete_sound_from_bank(bank, soundIndex); + } + + // If the current sound was not just deleted, consider it as a candidate for the currently + // playing sound + if (sSoundBanks[bank][soundIndex].soundStatus != SOUND_STATUS_STOPPED + && soundIndex == latestSoundIndex) { + + // Recompute distance each frame since the sound's position may have changed + sSoundBanks[bank][soundIndex].distance = + sqrtf((*sSoundBanks[bank][soundIndex].x * *sSoundBanks[bank][soundIndex].x) + + (*sSoundBanks[bank][soundIndex].y * *sSoundBanks[bank][soundIndex].y) + + (*sSoundBanks[bank][soundIndex].z * *sSoundBanks[bank][soundIndex].z)) + * 1; + + requestedPriority = (sSoundBanks[bank][soundIndex].soundBits & SOUNDARGS_MASK_PRIORITY) + >> SOUNDARGS_SHIFT_PRIORITY; + + // Recompute priority, possibly based on the sound's source position relative to the + // camera. + // (Note that the sound's priority is the opposite of requestedPriority; lower is + // more important) + if (sSoundBanks[bank][soundIndex].soundBits & SOUND_NO_PRIORITY_LOSS) { + sSoundBanks[bank][soundIndex].priority = 0x4c * (0xff - requestedPriority); + } else if (*sSoundBanks[bank][soundIndex].z > 0.0f) { + sSoundBanks[bank][soundIndex].priority = + (u32) sSoundBanks[bank][soundIndex].distance + + (u32)(*sSoundBanks[bank][soundIndex].z / US_FLOAT(6.0)) + + 0x4c * (0xff - requestedPriority); + } else { + sSoundBanks[bank][soundIndex].priority = + (u32) sSoundBanks[bank][soundIndex].distance + 0x4c * (0xff - requestedPriority); + } + + // Insert the sound into the liveSound arrays, keeping the arrays sorted by priority. + // If more than sMaxChannelsForSoundBank[bank] sounds are live, then the + // sound with lowest priority will be removed from the arrays. + // In practice sMaxChannelsForSoundBank is always 1, so this code is overly general. + for (i = 0; i < sMaxChannelsForSoundBank[bank]; i++) { + // If the correct position is found + if (liveSoundPriorities[i] >= sSoundBanks[bank][soundIndex].priority) { + // Shift remaining sounds to the right + for (j = sMaxChannelsForSoundBank[bank] - 1; j > i; j--) { + liveSoundPriorities[j] = liveSoundPriorities[j - 1]; + liveSoundIndices[j] = liveSoundIndices[j - 1]; + liveSoundStatuses[j] = liveSoundStatuses[j - 1]; + } + // Insert the sound at index i + liveSoundPriorities[i] = sSoundBanks[bank][soundIndex].priority; + liveSoundIndices[i] = soundIndex; + liveSoundStatuses[i] = sSoundBanks[bank][soundIndex].soundStatus; // unused + // Break + i = sMaxChannelsForSoundBank[bank]; + } + } + + numSoundsInBank++; + } + + soundIndex = sSoundBanks[bank][latestSoundIndex].next; + } + + sNumSoundsInBank[bank] = numSoundsInBank; + sUsedChannelsForSoundBank[bank] = sMaxChannelsForSoundBank[bank]; + + // + // Remove any sounds from liveSoundIndices that are already playing. + // Stop any currently playing sounds that are not in liveSoundIndices. + // + for (i = 0; i < sUsedChannelsForSoundBank[bank]; i++) { + // Check if sCurrentSound[bank][i] is present in the liveSound arrays. + for (soundIndex = 0; soundIndex < sUsedChannelsForSoundBank[bank]; soundIndex++) { + if (liveSoundIndices[soundIndex] != 0xff + && sCurrentSound[bank][i] == liveSoundIndices[soundIndex]) { + // If found, remove it from liveSoundIndices + liveSoundIndices[soundIndex] = 0xff; + soundIndex = 0xfe; // Break. Afterward soundIndex will be 0xff + } + } + + // If it is not present in the liveSound arrays, then stop playing it + if (soundIndex != 0xff) { + if (sCurrentSound[bank][i] != 0xff) { + // If the sound was marked for deletion and is playing, delete it + if (sSoundBanks[bank][sCurrentSound[bank][i]].soundBits == NO_SOUND) { + if (sSoundBanks[bank][sCurrentSound[bank][i]].soundStatus == SOUND_STATUS_PLAYING) { + sSoundBanks[bank][sCurrentSound[bank][i]].soundStatus = SOUND_STATUS_STOPPED; + delete_sound_from_bank(bank, sCurrentSound[bank][i]); + } + } + + // If the sound is discrete and is playing, then delete it + isDiscreteAndStatus = sSoundBanks[bank][sCurrentSound[bank][i]].soundBits + & (SOUND_DISCRETE | SOUNDARGS_MASK_STATUS); + if (isDiscreteAndStatus >= (SOUND_DISCRETE | SOUND_STATUS_PLAYING) + && sSoundBanks[bank][sCurrentSound[bank][i]].soundStatus != SOUND_STATUS_STOPPED) { +//! @bug On JP, if a discrete sound that lowers the background music is +// interrupted in this way, it will keep the background music low afterward. +// There are only a few of these sounds, and it probably isn't possible to do +// it in practice without using a time stop glitch like triple star spawn. +#ifndef VERSION_JP + update_background_music_after_sound(bank, sCurrentSound[bank][i]); +#endif + + sSoundBanks[bank][sCurrentSound[bank][i]].soundBits = NO_SOUND; + sSoundBanks[bank][sCurrentSound[bank][i]].soundStatus = SOUND_STATUS_STOPPED; + delete_sound_from_bank(bank, sCurrentSound[bank][i]); + } + // If the sound is continuous and is playing, then stop playing it but don't delete + // it. (A continuous sound shouldn't be deleted until it stops being requested) + else { + if (isDiscreteAndStatus == SOUND_STATUS_PLAYING + && sSoundBanks[bank][sCurrentSound[bank][i]].soundStatus + != SOUND_STATUS_STOPPED) { + sSoundBanks[bank][sCurrentSound[bank][i]].soundStatus = SOUND_STATUS_WAITING; + } + } + } + sCurrentSound[bank][i] = 0xff; + } + } + + // + // Start playing the remaining sounds from liveSoundIndices. + // + for (soundIndex = 0; soundIndex < sUsedChannelsForSoundBank[bank]; soundIndex++) { + if (liveSoundIndices[soundIndex] != 0xff) { + for (i = 0; i < sUsedChannelsForSoundBank[bank]; i++) { + if (sCurrentSound[bank][i] == 0xff) { + sCurrentSound[bank][i] = liveSoundIndices[soundIndex]; + + // Set (soundBits & status) to WAITING (soundStatus will be updated + // shortly after in update_game_sound) + sSoundBanks[bank][liveSoundIndices[soundIndex]].soundBits = + (sSoundBanks[bank][liveSoundIndices[soundIndex]].soundBits + & ~SOUNDARGS_MASK_STATUS) + + SOUND_STATUS_WAITING; + + liveSoundIndices[i] = 0xff; // doesn't do anything + i = 0xfe; // break + } + } + } + } +} + +/** + * Given x and z coordinates, return the pan. This is a value nominally between + * 0 and 1 that represents the audio direction. + * + * Pan: + * 0.0 - fully left + * 0.5 - center pan + * 1.0 - fully right + * + * Called from threads: thread4_sound, thread5_game_loop (EU only) + */ +static f32 get_sound_pan(f32 x, f32 z) { + f32 absX; + f32 absZ; + f32 pan; + + absX = (x < 0 ? -x : x); + if (absX > AUDIO_MAX_DISTANCE) { + absX = AUDIO_MAX_DISTANCE; + } + + absZ = (z < 0 ? -z : z); + if (absZ > AUDIO_MAX_DISTANCE) { + absZ = AUDIO_MAX_DISTANCE; + } + + // There are 4 panning equations (12-hr clock used for angles) + // 1. (0,0) fully-centered pan + // 2. far right pan: between 1:30 and 4:30 + // 3. far left pan: between 7:30 and 10:30 + // 4. center pan: between 4:30 and 7:30 or between 10:30 and 1:30 + if (x == US_FLOAT(0.0) && z == US_FLOAT(0.0)) { + // x and z being 0 results in a center pan + pan = US_FLOAT(0.5); + } else if (x >= US_FLOAT(0.0) && absX >= absZ) { + // far right pan + pan = US_FLOAT(1.0) - (2 * AUDIO_MAX_DISTANCE - absX) / (US_FLOAT(3.0) * (2 * AUDIO_MAX_DISTANCE - absZ)); + } else if (x < 0 && absX > absZ) { + // far left pan + pan = (2 * AUDIO_MAX_DISTANCE - absX) / (US_FLOAT(3.0) * (2 * AUDIO_MAX_DISTANCE - absZ)); + } else { + // center pan + //! @bug (JP PU sound glitch) If |x|, |z| > AUDIO_MAX_DISTANCE, we'll + // end up in this case, and pan may be set to something outside of [0,1] + // since x is not clamped. On JP, this can lead to an out-of-bounds + // float read in note_set_vel_pan_reverb when x is highly negative, + // causing console crashes when that float is a nan or denormal. + pan = 0.5 + x / (US_FLOAT(6.0) * absZ); + } + + return pan; +} + +/** + * Called from threads: thread4_sound, thread5_game_loop (EU only) + */ +static f32 get_sound_volume(u8 bank, u8 soundIndex, f32 volumeRange) { + f32 maxSoundDistance; + f32 intensity; +#ifndef VERSION_JP + s32 div = bank < 3 ? 2 : 3; +#endif + + if (!(sSoundBanks[bank][soundIndex].soundBits & SOUND_NO_VOLUME_LOSS)) { +#ifdef VERSION_JP + // Intensity linearly lowers from 1 at the camera to 0 at maxSoundDistance + maxSoundDistance = sLevelAcousticReaches[gCurrLevelNum]; + if (maxSoundDistance < sSoundBanks[bank][soundIndex].distance) { + intensity = 0.0f; + } else { + intensity = 1.0 - sSoundBanks[bank][soundIndex].distance / maxSoundDistance; + } +#else + // Intensity linearly lowers from 1 at the camera to 1 - volumeRange at maxSoundDistance, + // then it goes from 1 - volumeRange at maxSoundDistance to 0 at AUDIO_MAX_DISTANCE + if (sSoundBanks[bank][soundIndex].distance > AUDIO_MAX_DISTANCE) { + intensity = 0.0f; + } else { + maxSoundDistance = sLevelAcousticReaches[gCurrLevelNum] / div; + if (maxSoundDistance < sSoundBanks[bank][soundIndex].distance) { + intensity = ((AUDIO_MAX_DISTANCE - sSoundBanks[bank][soundIndex].distance) + / (AUDIO_MAX_DISTANCE - maxSoundDistance)) + * (1.0f - volumeRange); + } else { + intensity = + 1.0f - sSoundBanks[bank][soundIndex].distance / maxSoundDistance * volumeRange; + } + } +#endif + + if (sSoundBanks[bank][soundIndex].soundBits & SOUND_VIBRATO) { +#ifdef VERSION_JP + //! @bug Intensity is 0 when the sound is far away. Due to the subtraction below, it is possible to end up with a negative intensity. + // When it is, objects with a volumeRange of 1 can still occasionally be lightly heard. + if (intensity != 0.0) +#else + if (intensity >= 0.08f) +#endif + { + intensity -= (f32)(gAudioRandom & 0xf) / US_FLOAT(192.0); + } + } + } else { + intensity = 1.0f; + } + + // Rise quadratically from 1 - volumeRange to 1 + return (volumeRange * intensity * intensity + 1.0f - volumeRange) * gAudioVolume; +} + +/** + * Called from threads: thread4_sound, thread5_game_loop (EU only) + */ +static f32 get_sound_freq_scale(u8 bank, u8 item) { + f32 amount; + + if (!(sSoundBanks[bank][item].soundBits & SOUND_CONSTANT_FREQUENCY)) { + amount = sSoundBanks[bank][item].distance / AUDIO_MAX_DISTANCE; + if (sSoundBanks[bank][item].soundBits & SOUND_VIBRATO) { + amount += (f32)(gAudioRandom & 0xff) / US_FLOAT(64.0); + } + } else { + amount = 0.0f; + } + + // Goes from 1 at the camera to 1 + 1/15 at AUDIO_MAX_DISTANCE (and continues rising + // farther than that) + return amount / US_FLOAT(15.0) + US_FLOAT(1.0); +} + +/** + * Called from threads: thread4_sound, thread5_game_loop (EU only) + */ +static u8 get_sound_reverb(UNUSED u8 bank, UNUSED u8 soundIndex, u8 channelIndex) { + u8 area; + u8 level; + u8 reverb; + +#ifndef VERSION_JP + // Disable level reverb if NO_ECHO is set + if (sSoundBanks[bank][soundIndex].soundBits & SOUND_NO_ECHO) { + level = 0; + area = 0; + } else { +#endif + level = (gCurrLevelNum > LEVEL_MAX ? LEVEL_MAX : gCurrLevelNum); + area = gCurrAreaIndex - 1; + if (area > 2) { + area = 2; + } +#ifndef VERSION_JP + } +#endif + + // reverb = reverb adjustment + level reverb + a volume-dependent value + // The volume-dependent value is 0 when volume is at maximum, and raises to + // LOW_VOLUME_REVERB when the volume is 0 + /*reverb = (u8)((u8) gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->soundScriptIO[5] + + sLevelAreaReverbs[level][area] + + (US_FLOAT(1.0) - gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->volume) + * LOW_VOLUME_REVERB);*/ + + reverb = gAudioReverb; + + if (reverb > 0x7f) { + reverb = 0x7f; + } + return reverb; +} + +static void noop_8031EEC8(void) { +} + +/** + * Called from the game loop thread to inform the audio thread that a new game + * frame has started. + * + * Called from threads: thread5_game_loop + */ +void audio_signal_game_loop_tick(void) { + sGameLoopTicked = 1; +#if defined(VERSION_EU) || defined(VERSION_SH) + maybe_tick_game_sound(); +#endif + noop_8031EEC8(); +} + +/** + * Called from threads: thread4_sound, thread5_game_loop (EU and SH only) + */ +static void update_game_sound(void) { + u8 soundStatus; + u8 i; + u8 soundId; + u8 bank; + u8 channelIndex = 0; + u8 soundIndex; +#if defined(VERSION_JP) || defined(VERSION_US) + f32 value; +#endif + + process_all_sound_requests(); + process_level_music_dynamics(); + + if (gSequencePlayers[SEQ_PLAYER_SFX].channels[0] == &gSequenceChannelNone) { + return; + } + + for (bank = 0; bank < SOUND_BANK_COUNT; bank++) { + select_current_sounds(bank); + + for (i = 0; i < MAX_CHANNELS_PER_SOUND_BANK; i++) { + soundIndex = sCurrentSound[bank][i]; + + if (soundIndex < 0xff + && sSoundBanks[bank][soundIndex].soundStatus != SOUND_STATUS_STOPPED) { + soundStatus = sSoundBanks[bank][soundIndex].soundBits & SOUNDARGS_MASK_STATUS; + soundId = (sSoundBanks[bank][soundIndex].soundBits >> SOUNDARGS_SHIFT_SOUNDID); + + sSoundBanks[bank][soundIndex].soundStatus = soundStatus; + + if (soundStatus == SOUND_STATUS_WAITING) { + if (sSoundBanks[bank][soundIndex].soundBits & SOUND_LOWER_BACKGROUND_MUSIC) { + sSoundBanksThatLowerBackgroundMusic |= 1 << bank; + begin_background_music_fade(50); + } + + // Set sound status to PLAYING + sSoundBanks[bank][soundIndex].soundBits++; + sSoundBanks[bank][soundIndex].soundStatus = SOUND_STATUS_PLAYING; + + // Begin playing the sound + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->soundScriptIO[4] = soundId; + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->soundScriptIO[0] = 1; + + switch (bank) { + case SOUND_BANK_MOVING: + if (!(sSoundBanks[bank][soundIndex].soundBits & SOUND_CONSTANT_FREQUENCY)) { + if (sSoundMovingSpeed[bank] > 8) { +#if defined(VERSION_EU) || defined(VERSION_SH) + func_802ad728( + 0x02020000 | ((channelIndex & 0xff) << 8), + get_sound_volume(bank, soundIndex, VOLUME_RANGE_UNK1)); +#else + value = get_sound_volume(bank, soundIndex, VOLUME_RANGE_UNK1); + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->volume = + value; +#endif + } else { +#if defined(VERSION_EU) || defined(VERSION_SH) + func_802ad728(0x02020000 | ((channelIndex & 0xff) << 8), + get_sound_volume(bank, soundIndex, VOLUME_RANGE_UNK1) + * ((sSoundMovingSpeed[bank] + 8.0f) / 16)); +#else + value = get_sound_volume(bank, soundIndex, VOLUME_RANGE_UNK1); + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->volume = + (sSoundMovingSpeed[bank] + 8.0f) / 16 * value; +#endif + } +#if defined(VERSION_EU) || defined(VERSION_SH) + func_802ad770(0x03020000 | ((channelIndex & 0xff) << 8), + get_sound_pan(*sSoundBanks[bank][soundIndex].x, + *sSoundBanks[bank][soundIndex].z)); +#else + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->pan = + get_sound_pan(*sSoundBanks[bank][soundIndex].x, + *sSoundBanks[bank][soundIndex].z); +#endif + + if ((sSoundBanks[bank][soundIndex].soundBits & SOUNDARGS_MASK_SOUNDID) + == (SOUND_MOVING_FLYING & SOUNDARGS_MASK_SOUNDID)) { +#if defined(VERSION_EU) || defined(VERSION_SH) + func_802ad728( + 0x04020000 | ((channelIndex & 0xff) << 8), + get_sound_freq_scale(bank, soundIndex) + + ((f32) sSoundMovingSpeed[bank] / US_FLOAT(80.0))); +#else + value = get_sound_freq_scale(bank, soundIndex); + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->freqScale = + ((f32) sSoundMovingSpeed[bank] / US_FLOAT(80.0)) + value; +#endif + } else { +#if defined(VERSION_EU) || defined(VERSION_SH) + func_802ad728( + 0x04020000 | ((channelIndex & 0xff) << 8), + get_sound_freq_scale(bank, soundIndex) + + ((f32) sSoundMovingSpeed[bank] / US_FLOAT(400.0))); +#else + value = get_sound_freq_scale(bank, soundIndex); + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->freqScale = + ((f32) sSoundMovingSpeed[bank] / US_FLOAT(400.0)) + value; +#endif + } +#if defined(VERSION_EU) || defined(VERSION_SH) + func_802ad770(0x05020000 | ((channelIndex & 0xff) << 8), + get_sound_reverb(bank, soundIndex, channelIndex)); +#else + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->reverbVol = + get_sound_reverb(bank, soundIndex, channelIndex); +#endif + + break; + } + // fallthrough + case SOUND_BANK_MENU: +#if defined(VERSION_EU) || defined(VERSION_SH) + func_802ad728(0x02020000 | ((channelIndex & 0xff) << 8), 1); + func_802ad770(0x03020000 | ((channelIndex & 0xff) << 8), 64); + func_802ad728(0x04020000 | ((channelIndex & 0xff) << 8), + get_sound_freq_scale(bank, soundIndex)); +#else + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->volume = 1.0f; + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->pan = 0.5f; + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->freqScale = 1.0f; +#endif + break; + case SOUND_BANK_ACTION: + case SOUND_BANK_VOICE: +#if defined(VERSION_EU) || defined(VERSION_SH) + func_802ad770(0x05020000 | ((channelIndex & 0xff) << 8), + get_sound_reverb(bank, soundIndex, channelIndex)); + func_802ad728(0x02020000 | ((channelIndex & 0xff) << 8), + get_sound_volume(bank, soundIndex, VOLUME_RANGE_UNK1)); + func_802ad770(0x03020000 | ((channelIndex & 0xff) << 8), + get_sound_pan(*sSoundBanks[bank][soundIndex].x, + *sSoundBanks[bank][soundIndex].z) + * 127.0f + + 0.5f); + func_802ad728(0x04020000 | ((channelIndex & 0xff) << 8), + get_sound_freq_scale(bank, soundIndex)); +#else + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->volume = + get_sound_volume(bank, soundIndex, VOLUME_RANGE_UNK1); + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->pan = + get_sound_pan(*sSoundBanks[bank][soundIndex].x, + *sSoundBanks[bank][soundIndex].z); + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->freqScale = + get_sound_freq_scale(bank, soundIndex); + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->reverbVol = + get_sound_reverb(bank, soundIndex, channelIndex); +#endif + break; + case SOUND_BANK_GENERAL: + case SOUND_BANK_ENV: + case SOUND_BANK_OBJ: + case SOUND_BANK_AIR: + case SOUND_BANK_GENERAL2: + case SOUND_BANK_OBJ2: +#if defined(VERSION_EU) || defined(VERSION_SH) + func_802ad770(0x05020000 | ((channelIndex & 0xff) << 8), + get_sound_reverb(bank, soundIndex, channelIndex)); + func_802ad728(0x02020000 | ((channelIndex & 0xff) << 8), + get_sound_volume(bank, soundIndex, VOLUME_RANGE_UNK2)); + func_802ad770(0x03020000 | ((channelIndex & 0xff) << 8), + get_sound_pan(*sSoundBanks[bank][soundIndex].x, + *sSoundBanks[bank][soundIndex].z) + * 127.0f + + 0.5f); + func_802ad728(0x04020000 | ((channelIndex & 0xff) << 8), + get_sound_freq_scale(bank, soundIndex)); +#else + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->reverbVol = + get_sound_reverb(bank, soundIndex, channelIndex); + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->volume = + get_sound_volume(bank, soundIndex, VOLUME_RANGE_UNK2); + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->pan = + get_sound_pan(*sSoundBanks[bank][soundIndex].x, + *sSoundBanks[bank][soundIndex].z); + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->freqScale = + get_sound_freq_scale(bank, soundIndex); +#endif + break; + } + } +#ifdef VERSION_JP + // If the sound was marked for deletion (bits set to NO_SOUND), then stop playing it + // and delete it + // @bug (JP double red coin sound) If the sound finished within the same frame as + // being marked for deletion, the signal to stop playing will be interpreted as a + // signal to *start* playing, as .main_loop_023589 in 00_sound_player does not check + // for soundScriptIO[0] being zero. This happens most commonly for red coin sounds + // whose sound spawners deactivate 30 frames after the sound starts to play, while + // the sound itself runs for 1.20 seconds. With enough lag these may coincide. + // Fixed on US by checking that layer0->finished is FALSE. + else if (soundStatus == SOUND_STATUS_STOPPED) { + update_background_music_after_sound(bank, soundIndex); + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->soundScriptIO[0] = 0; + delete_sound_from_bank(bank, soundIndex); + } +#else + else if (gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->layers[0] == NULL) { + update_background_music_after_sound(bank, soundIndex); + sSoundBanks[bank][soundIndex].soundStatus = SOUND_STATUS_STOPPED; + delete_sound_from_bank(bank, soundIndex); + } else if (soundStatus == SOUND_STATUS_STOPPED + && gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex] + ->layers[0]->finished == FALSE) { + update_background_music_after_sound(bank, soundIndex); + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->soundScriptIO[0] = 0; + delete_sound_from_bank(bank, soundIndex); + } +#endif + // If sound has finished playing, then delete it + // @bug (JP sound glitch) On JP, ...->layers[0] has not been checked for null, + // so this access can crash if an earlier layer allocation failed due to too + // many sounds playing at once. This crash is comparatively common; RTA + // speedrunners even have a setup for avoiding it within the SSL pyramid: + // https://www.youtube.com/watch?v=QetyTgbQxcw + else if (gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->layers[0]->enabled + == FALSE) { + update_background_music_after_sound(bank, soundIndex); + sSoundBanks[bank][soundIndex].soundStatus = SOUND_STATUS_STOPPED; + delete_sound_from_bank(bank, soundIndex); + } else { + // Exactly the same code as before. Unfortunately we can't + // make a macro out of this, because then everything ends up + // on the same line after preprocessing, and the compiler, + // somehow caring about line numbers, makes it not match (it + // computes function arguments in the wrong order). + switch (bank) { + case SOUND_BANK_MOVING: + if (!(sSoundBanks[bank][soundIndex].soundBits & SOUND_CONSTANT_FREQUENCY)) { + if (sSoundMovingSpeed[bank] > 8) { +#if defined(VERSION_EU) || defined(VERSION_SH) + func_802ad728( + 0x02020000 | ((channelIndex & 0xff) << 8), + get_sound_volume(bank, soundIndex, VOLUME_RANGE_UNK1)); +#else + value = get_sound_volume(bank, soundIndex, VOLUME_RANGE_UNK1); + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->volume = + value; +#endif + } else { +#if defined(VERSION_EU) || defined(VERSION_SH) + func_802ad728(0x02020000 | ((channelIndex & 0xff) << 8), + get_sound_volume(bank, soundIndex, VOLUME_RANGE_UNK1) + * ((sSoundMovingSpeed[bank] + 8.0f) / 16)); +#else + value = get_sound_volume(bank, soundIndex, VOLUME_RANGE_UNK1); + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->volume = + (sSoundMovingSpeed[bank] + 8.0f) / 16 * value; +#endif + } +#if defined(VERSION_EU) || defined(VERSION_SH) + func_802ad770(0x03020000 | ((channelIndex & 0xff) << 8), + get_sound_pan(*sSoundBanks[bank][soundIndex].x, + *sSoundBanks[bank][soundIndex].z)); +#else + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->pan = + get_sound_pan(*sSoundBanks[bank][soundIndex].x, + *sSoundBanks[bank][soundIndex].z); +#endif + + if ((sSoundBanks[bank][soundIndex].soundBits & SOUNDARGS_MASK_SOUNDID) + == (SOUND_MOVING_FLYING & SOUNDARGS_MASK_SOUNDID)) { +#if defined(VERSION_EU) || defined(VERSION_SH) + func_802ad728( + 0x04020000 | ((channelIndex & 0xff) << 8), + get_sound_freq_scale(bank, soundIndex) + + ((f32) sSoundMovingSpeed[bank] / US_FLOAT(80.0))); +#else + value = get_sound_freq_scale(bank, soundIndex); + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->freqScale = + ((f32) sSoundMovingSpeed[bank] / US_FLOAT(80.0)) + value; +#endif + } else { +#if defined(VERSION_EU) || defined(VERSION_SH) + func_802ad728( + 0x04020000 | ((channelIndex & 0xff) << 8), + get_sound_freq_scale(bank, soundIndex) + + ((f32) sSoundMovingSpeed[bank] / US_FLOAT(400.0))); +#else + value = get_sound_freq_scale(bank, soundIndex); + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->freqScale = + ((f32) sSoundMovingSpeed[bank] / US_FLOAT(400.0)) + value; +#endif + } +#if defined(VERSION_EU) || defined(VERSION_SH) + func_802ad770(0x05020000 | ((channelIndex & 0xff) << 8), + get_sound_reverb(bank, soundIndex, channelIndex)); +#else + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->reverbVol = + get_sound_reverb(bank, soundIndex, channelIndex); +#endif + + break; + } + // fallthrough + case SOUND_BANK_MENU: +#if defined(VERSION_EU) || defined(VERSION_SH) + func_802ad728(0x02020000 | ((channelIndex & 0xff) << 8), 1); + func_802ad770(0x03020000 | ((channelIndex & 0xff) << 8), 64); + func_802ad728(0x04020000 | ((channelIndex & 0xff) << 8), + get_sound_freq_scale(bank, soundIndex)); +#else + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->volume = 1.0f; + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->pan = 0.5f; + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->freqScale = 1.0f; +#endif + break; + case SOUND_BANK_ACTION: + case SOUND_BANK_VOICE: +#if defined(VERSION_EU) || defined(VERSION_SH) + func_802ad770(0x05020000 | ((channelIndex & 0xff) << 8), + get_sound_reverb(bank, soundIndex, channelIndex)); + func_802ad728(0x02020000 | ((channelIndex & 0xff) << 8), + get_sound_volume(bank, soundIndex, VOLUME_RANGE_UNK1)); + func_802ad770(0x03020000 | ((channelIndex & 0xff) << 8), + get_sound_pan(*sSoundBanks[bank][soundIndex].x, + *sSoundBanks[bank][soundIndex].z) + * 127.0f + + 0.5f); + func_802ad728(0x04020000 | ((channelIndex & 0xff) << 8), + get_sound_freq_scale(bank, soundIndex)); +#else + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->volume = + get_sound_volume(bank, soundIndex, VOLUME_RANGE_UNK1); + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->pan = + get_sound_pan(*sSoundBanks[bank][soundIndex].x, + *sSoundBanks[bank][soundIndex].z); + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->freqScale = + get_sound_freq_scale(bank, soundIndex); + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->reverbVol = + get_sound_reverb(bank, soundIndex, channelIndex); +#endif + break; + case SOUND_BANK_GENERAL: + case SOUND_BANK_ENV: + case SOUND_BANK_OBJ: + case SOUND_BANK_AIR: + case SOUND_BANK_GENERAL2: + case SOUND_BANK_OBJ2: +#if defined(VERSION_EU) || defined(VERSION_SH) + func_802ad770(0x05020000 | ((channelIndex & 0xff) << 8), + get_sound_reverb(bank, soundIndex, channelIndex)); + func_802ad728(0x02020000 | ((channelIndex & 0xff) << 8), + get_sound_volume(bank, soundIndex, VOLUME_RANGE_UNK2)); + func_802ad770(0x03020000 | ((channelIndex & 0xff) << 8), + get_sound_pan(*sSoundBanks[bank][soundIndex].x, + *sSoundBanks[bank][soundIndex].z) + * 127.0f + + 0.5f); + func_802ad728(0x04020000 | ((channelIndex & 0xff) << 8), + get_sound_freq_scale(bank, soundIndex)); +#else + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->reverbVol = + get_sound_reverb(bank, soundIndex, channelIndex); + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->volume = + get_sound_volume(bank, soundIndex, VOLUME_RANGE_UNK2); + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->pan = + get_sound_pan(*sSoundBanks[bank][soundIndex].x, + *sSoundBanks[bank][soundIndex].z); + gSequencePlayers[SEQ_PLAYER_SFX].channels[channelIndex]->freqScale = + get_sound_freq_scale(bank, soundIndex); +#endif + break; + } + } + } + + // Increment to the next channel that this bank owns + channelIndex++; + } + + // Increment to the first channel index of the next bank + // (In practice sUsedChannelsForSoundBank[i] = sMaxChannelsForSoundBank[i] = 1, so this + // doesn't do anything) + channelIndex += sMaxChannelsForSoundBank[bank] - sUsedChannelsForSoundBank[bank]; + } +} + +/** + * Called from threads: thread4_sound, thread5_game_loop + */ +void seq_player_play_sequence(u8 player, u8 seqId, u16 arg2) { + u8 targetVolume; + u8 i; + + if (player == SEQ_PLAYER_LEVEL) { + sCurrentBackgroundMusicSeqId = seqId & SEQ_BASE_ID; + sBackgroundMusicForDynamics = SEQUENCE_NONE; + sCurrentMusicDynamic = 0xff; + sMusicDynamicDelay = 2; + } + + for (i = 0; i < CHANNELS_MAX; i++) { + D_80360928[player][i].remainingFrames = 0; + } + +#if defined(VERSION_EU) || defined(VERSION_SH) + func_802ad770(0x46000000 | ((u8)(u32) player) << 16, seqId & SEQ_VARIATION); + func_802ad74c(0x82000000 | ((u8)(u32) player) << 16 | ((u8)(seqId & SEQ_BASE_ID)) << 8, arg2); + + if (player == SEQ_PLAYER_LEVEL) { + targetVolume = begin_background_music_fade(0); + if (targetVolume != 0xff) { + gSequencePlayers[SEQ_PLAYER_LEVEL].fadeVolumeScale = (f32) targetVolume / US_FLOAT(127.0); + } + } +#else + + gSequencePlayers[player].seqVariation = seqId & SEQ_VARIATION; + load_sequence(player, seqId & SEQ_BASE_ID, 0); + + if (player == SEQ_PLAYER_LEVEL) { + targetVolume = begin_background_music_fade(0); + if (targetVolume != 0xff) { + gSequencePlayers[SEQ_PLAYER_LEVEL].state = SEQUENCE_PLAYER_STATE_4; + gSequencePlayers[SEQ_PLAYER_LEVEL].fadeVolume = (f32) targetVolume / US_FLOAT(127.0); + } + } else { + func_8031D690(player, arg2); + } +#endif +} + +/** + * Called from threads: thread5_game_loop + */ +void seq_player_fade_out(u8 player, u16 fadeDuration) { +#if defined(VERSION_EU) || defined(VERSION_SH) +#ifdef VERSION_EU + u32 fd = fadeDuration; +#else + s32 fd = fadeDuration; // will also match if we change function signature func_802ad74c to use s32 as arg1 +#endif + if (!player) { + sCurrentBackgroundMusicSeqId = SEQUENCE_NONE; + } + func_802ad74c(0x83000000 | (player & 0xff) << 16, fd); +#else + if (player == SEQ_PLAYER_LEVEL) { + sCurrentBackgroundMusicSeqId = SEQUENCE_NONE; + } + seq_player_fade_to_zero_volume(player, fadeDuration); +#endif +} + +/** + * Called from threads: thread5_game_loop + */ +void fade_volume_scale(u8 player, u8 targetScale, u16 fadeDuration) { + u8 i; + for (i = 0; i < CHANNELS_MAX; i++) { + fade_channel_volume_scale(player, i, targetScale, fadeDuration); + } +} + +/** + * Called from threads: thread3_main, thread4_sound, thread5_game_loop + */ +static void fade_channel_volume_scale(u8 player, u8 channelIndex, u8 targetScale, u16 fadeDuration) { + struct ChannelVolumeScaleFade *temp; + + if (gSequencePlayers[player].channels[channelIndex] != &gSequenceChannelNone) { + temp = &D_80360928[player][channelIndex]; + temp->remainingFrames = fadeDuration; + temp->velocity = ((f32)(targetScale / US_FLOAT(127.0)) + - gSequencePlayers[player].channels[channelIndex]->volumeScale) + / fadeDuration; + temp->target = targetScale; + temp->current = gSequencePlayers[player].channels[channelIndex]->volumeScale; + } +} + +/** + * Called from threads: thread4_sound, thread5_game_loop (EU only) + */ +static void func_8031F96C(u8 player) { + u8 i; + + // Loop over channels + for (i = 0; i < CHANNELS_MAX; i++) { + if (gSequencePlayers[player].channels[i] != &gSequenceChannelNone + && D_80360928[player][i].remainingFrames != 0) { + D_80360928[player][i].current += D_80360928[player][i].velocity; +#if defined(VERSION_EU) || defined(VERSION_SH) + func_802ad728(0x01000000 | (player & 0xff) << 16 | (i & 0xff) << 8, + D_80360928[player][i].current); +#else + gSequencePlayers[player].channels[i]->volumeScale = D_80360928[player][i].current; +#endif + D_80360928[player][i].remainingFrames--; + if (D_80360928[player][i].remainingFrames == 0) { +#if defined(VERSION_EU) + func_802ad728(0x01000000 | (player & 0xff) << 16 | (i & 0xff) << 8, + FLOAT_CAST(D_80360928[player][i].target) / 127.0); +#elif defined(VERSION_SH) + func_802ad728(0x01000000 | (player & 0xff) << 16 | (i & 0xff) << 8, + FLOAT_CAST(D_80360928[player][i].target) / 127.0f); +#else + gSequencePlayers[player].channels[i]->volumeScale = + D_80360928[player][i].target / 127.0f; +#endif + } + } + } +} + +/** + * Called from threads: thread4_sound, thread5_game_loop (EU only) + */ +void process_level_music_dynamics(void) { + u32 conditionBits; + u16 tempBits; + UNUSED u16 pad; + u8 musicDynIndex; + u8 condIndex; + u8 i; + u8 j; + s16 conditionValues[8]; + u8 conditionTypes[8]; + s16 dur1; + s16 dur2; + u16 bit; + + func_8031F96C(0); + func_8031F96C(2); + func_80320ED8(); + if (sMusicDynamicDelay != 0) { + sMusicDynamicDelay--; + } else { + sBackgroundMusicForDynamics = sCurrentBackgroundMusicSeqId; + } + + if (sBackgroundMusicForDynamics != sLevelDynamics[gCurrLevelNum][0]) { + return; + } + + conditionBits = sLevelDynamics[gCurrLevelNum][1] & 0xff00; + musicDynIndex = (u8) sLevelDynamics[gCurrLevelNum][1] & 0xff; + i = 2; + while (conditionBits & 0xff00) { + j = 0; + condIndex = 0; + bit = 0x8000; + while (j < 8) { + if (conditionBits & bit) { + conditionValues[condIndex] = sLevelDynamics[gCurrLevelNum][i++]; + conditionTypes[condIndex] = j; + condIndex++; + } + + j++; + bit = bit >> 1; + } + + for (j = 0; j < condIndex; j++) { + switch (conditionTypes[j]) { + case MARIO_IS_IN_AREA: { + if (gCurrAreaIndex != conditionValues[j]) { + j = condIndex + 1; + } + break; + } + case MARIO_IS_IN_ROOM: { + if (gMarioCurrentRoom != conditionValues[j]) { + j = condIndex + 1; + } + break; + } + } + } + + if (j == condIndex) { + // The area matches. Break out of the loop. + tempBits = 0; + } else { + tempBits = sLevelDynamics[gCurrLevelNum][i] & 0xff00; + musicDynIndex = sLevelDynamics[gCurrLevelNum][i] & 0xff; + i++; + } + + conditionBits = tempBits; + } + + if (sCurrentMusicDynamic != musicDynIndex) { + tempBits = 1; + if (sCurrentMusicDynamic == 0xff) { + dur1 = 1; + dur2 = 1; + } else { + dur1 = sMusicDynamics[musicDynIndex].dur1; + dur2 = sMusicDynamics[musicDynIndex].dur2; + } + + for (i = 0; i < CHANNELS_MAX; i++) { + conditionBits = tempBits; + tempBits = 0; + if (sMusicDynamics[musicDynIndex].bits1 & conditionBits) { + fade_channel_volume_scale(SEQ_PLAYER_LEVEL, i, sMusicDynamics[musicDynIndex].volScale1, + dur1); + } + if (sMusicDynamics[musicDynIndex].bits2 & conditionBits) { + fade_channel_volume_scale(SEQ_PLAYER_LEVEL, i, sMusicDynamics[musicDynIndex].volScale2, + dur2); + } + tempBits = conditionBits << 1; + } + + sCurrentMusicDynamic = musicDynIndex; + } +} + +void unused_8031FED0(u8 player, u32 bits, s8 arg2) { + u8 i; + + if (arg2 < 0) { + arg2 = -arg2; + } + + for (i = 0; i < CHANNELS_MAX; i++) { + if (gSequencePlayers[player].channels[i] != &gSequenceChannelNone) { + if ((bits & 3) == 0) { + gSequencePlayers[player].channels[i]->volumeScale = 1.0f; + } else if ((bits & 1) != 0) { + gSequencePlayers[player].channels[i]->volumeScale = (f32) arg2 / US_FLOAT(127.0); + } else { + gSequencePlayers[player].channels[i]->volumeScale = + US_FLOAT(1.0) - (f32) arg2 / US_FLOAT(127.0); + } + } + bits >>= 2; + } +} + +/** + * Lower a sequence player's volume over fadeDuration frames. + * If player is SEQ_PLAYER_LEVEL (background music), the given percentage is ignored + * and a max target volume of 40 is used. + * + * Called from threads: thread5_game_loop + */ +void seq_player_lower_volume(u8 player, u16 fadeDuration, u8 percentage) { + if (player == SEQ_PLAYER_LEVEL) { + sLowerBackgroundMusicVolume = TRUE; + begin_background_music_fade(fadeDuration); + } else if (gSequencePlayers[player].enabled == TRUE) { + seq_player_fade_to_percentage_of_volume(player, fadeDuration, percentage); + } +} + +/** + * Remove the lowered volume constraint set by seq_player_lower_volume. + * If player is SEQ_PLAYER_LEVEL (background music), the music won't necessarily + * raise back to normal volume if other constraints have been set, e.g. + * sBackgroundMusicTargetVolume. + * + * Called from threads: thread5_game_loop + */ +void seq_player_unlower_volume(u8 player, u16 fadeDuration) { + sLowerBackgroundMusicVolume = FALSE; + if (player == SEQ_PLAYER_LEVEL) { + if (gSequencePlayers[player].state != SEQUENCE_PLAYER_STATE_FADE_OUT) { + begin_background_music_fade(fadeDuration); + } + } else { + if (gSequencePlayers[player].enabled == TRUE) { + seq_player_fade_to_normal_volume(player, fadeDuration); + } + } +} + +/** + * Begin a volume fade to adjust the background music to the correct volume. + * The target volume is determined by global variables like sBackgroundMusicTargetVolume + * and sLowerBackgroundMusicVolume. + * If none of the relevant global variables are set, then the default background music + * volume for the sequence is used. + * + * Called from threads: thread3_main, thread4_sound, thread5_game_loop + */ +static u8 begin_background_music_fade(u16 fadeDuration) { + u8 targetVolume = 0xff; + + if (sCurrentBackgroundMusicSeqId == SEQUENCE_NONE + || sCurrentBackgroundMusicSeqId == SEQ_EVENT_CUTSCENE_CREDITS) { + return 0xff; + } + + if (gSequencePlayers[SEQ_PLAYER_LEVEL].volume == 0.0f && fadeDuration) { + gSequencePlayers[SEQ_PLAYER_LEVEL].volume = gSequencePlayers[SEQ_PLAYER_LEVEL].fadeVolume; + } + + if (sBackgroundMusicTargetVolume != TARGET_VOLUME_UNSET) { + targetVolume = (sBackgroundMusicTargetVolume & TARGET_VOLUME_VALUE_MASK); + } + + if (sBackgroundMusicMaxTargetVolume != TARGET_VOLUME_UNSET) { + u8 maxTargetVolume = (sBackgroundMusicMaxTargetVolume & TARGET_VOLUME_VALUE_MASK); + if (targetVolume > maxTargetVolume) { + targetVolume = maxTargetVolume; + } + } + + if (sLowerBackgroundMusicVolume && targetVolume > 40) { + targetVolume = 40; + } + + if (sSoundBanksThatLowerBackgroundMusic != 0 && targetVolume > 20) { + targetVolume = 20; + } + + if (gSequencePlayers[SEQ_PLAYER_LEVEL].enabled == TRUE) { + if (targetVolume != 0xff) { + seq_player_fade_to_target_volume(SEQ_PLAYER_LEVEL, fadeDuration, targetVolume); + } else { +#if defined(VERSION_JP) || defined(VERSION_US) + gSequencePlayers[SEQ_PLAYER_LEVEL].volume = + sBackgroundMusicDefaultVolume[sCurrentBackgroundMusicSeqId] / 127.0f; +#endif + seq_player_fade_to_normal_volume(SEQ_PLAYER_LEVEL, fadeDuration); + } + } + + return targetVolume; +} + +/** + * Called from threads: thread5_game_loop + */ +void set_audio_muted(u8 muted) { + u8 i; + + for (i = 0; i < SEQUENCE_PLAYERS; i++) { +#if defined(VERSION_EU) || defined(VERSION_SH) + if (muted) + func_802ad74c(0xf1000000, 0); + else + func_802ad74c(0xf2000000, 0); +#else + gSequencePlayers[i].muted = muted; +#endif + } +} + +/** + * Called from threads: thread4_sound + */ +void sound_init(void) { + u8 i; + u8 j; + + for (i = 0; i < SOUND_BANK_COUNT; i++) { + // Set each sound in the bank to STOPPED + for (j = 0; j < 40; j++) { + sSoundBanks[i][j].soundStatus = SOUND_STATUS_STOPPED; + } + + // Remove current sounds + for (j = 0; j < MAX_CHANNELS_PER_SOUND_BANK; j++) { + sCurrentSound[i][j] = 0xff; + } + + sSoundBankUsedListBack[i] = 0; + sSoundBankFreeListFront[i] = 1; + sNumSoundsInBank[i] = 0; + } + + for (i = 0; i < SOUND_BANK_COUNT; i++) { + // Set used list to empty + sSoundBanks[i][0].prev = 0xff; + sSoundBanks[i][0].next = 0xff; + + // Set free list to contain every sound slot + for (j = 1; j < 40 - 1; j++) { + sSoundBanks[i][j].prev = j - 1; + sSoundBanks[i][j].next = j + 1; + } + sSoundBanks[i][j].prev = j - 1; + sSoundBanks[i][j].next = 0xff; + } + + for (j = 0; j < 3; j++) { + for (i = 0; i < CHANNELS_MAX; i++) { + D_80360928[j][i].remainingFrames = 0; + } + } + + for (i = 0; i < MAX_BACKGROUND_MUSIC_QUEUE_SIZE; i++) { + sBackgroundMusicQueue[i].priority = 0; + } + + sound_banks_enable(SEQ_PLAYER_SFX, SOUND_BANKS_ALL_BITS); + + sUnused80332118 = 0; + sBackgroundMusicTargetVolume = TARGET_VOLUME_UNSET; + sLowerBackgroundMusicVolume = FALSE; + sSoundBanksThatLowerBackgroundMusic = 0; + sUnused80332114 = 0; + sCurrentBackgroundMusicSeqId = 0xff; + gSoundMode = SOUND_MODE_STEREO; + sBackgroundMusicQueueSize = 0; + sBackgroundMusicMaxTargetVolume = TARGET_VOLUME_UNSET; + D_80332120 = 0; + D_80332124 = 0; + sNumProcessedSoundRequests = 0; + sSoundRequestCount = 0; +} + +// (unused) +void get_currently_playing_sound(u8 bank, u8 *numPlayingSounds, u8 *numSoundsInBank, u8 *soundId) { + u8 i; + u8 count = 0; + + for (i = 0; i < sMaxChannelsForSoundBank[bank]; i++) { + if (sCurrentSound[bank][i] != 0xff) { + count++; + } + } + *numPlayingSounds = count; + + *numSoundsInBank = sNumSoundsInBank[bank]; + + if (sCurrentSound[bank][0] != 0xff) { + *soundId = (u8)(sSoundBanks[bank][sCurrentSound[bank][0]].soundBits >> SOUNDARGS_SHIFT_SOUNDID); + } else { + *soundId = 0xff; + } +} + +/** + * Called from threads: thread5_game_loop + */ +void stop_sound(u32 soundBits, f32 *pos) { + u8 bank = (soundBits & SOUNDARGS_MASK_BANK) >> SOUNDARGS_SHIFT_BANK; + u8 soundIndex = sSoundBanks[bank][0].next; + + while (soundIndex != 0xff) { + // If sound has same id and source position pointer + if ((u16)(soundBits >> SOUNDARGS_SHIFT_SOUNDID) + == (u16)(sSoundBanks[bank][soundIndex].soundBits >> SOUNDARGS_SHIFT_SOUNDID) + && sSoundBanks[bank][soundIndex].x == pos) { + + // Mark sound for deletion + update_background_music_after_sound(bank, soundIndex); + sSoundBanks[bank][soundIndex].soundBits = NO_SOUND; + soundIndex = 0xff; // break + } else { + soundIndex = sSoundBanks[bank][soundIndex].next; + } + } +} + +/** + * Called from threads: thread5_game_loop + */ +void stop_sounds_from_source(f32 *pos) { + u8 bank; + u8 soundIndex; + + for (bank = 0; bank < SOUND_BANK_COUNT; bank++) { + soundIndex = sSoundBanks[bank][0].next; + while (soundIndex != 0xff) { + if (sSoundBanks[bank][soundIndex].x == pos) { + update_background_music_after_sound(bank, soundIndex); + sSoundBanks[bank][soundIndex].soundBits = NO_SOUND; + } + soundIndex = sSoundBanks[bank][soundIndex].next; + } + } +} + +/** + * Called from threads: thread3_main, thread5_game_loop + */ +static void stop_sounds_in_bank(u8 bank) { + u8 soundIndex = sSoundBanks[bank][0].next; + + while (soundIndex != 0xff) { + update_background_music_after_sound(bank, soundIndex); + sSoundBanks[bank][soundIndex].soundBits = NO_SOUND; + soundIndex = sSoundBanks[bank][soundIndex].next; + } +} + +/** + * Stops sounds in all of the sound banks that predominantly consist of continuous + * sounds. Misses some specific continuous sounds in other banks like bird chirping + * and the ticking sound after pressing a switch. + * + * Called from threads: thread3_main, thread5_game_loop + */ +void stop_sounds_in_continuous_banks(void) { + stop_sounds_in_bank(SOUND_BANK_MOVING); + stop_sounds_in_bank(SOUND_BANK_ENV); + stop_sounds_in_bank(SOUND_BANK_AIR); +} + +/** + * Called from threads: thread3_main, thread5_game_loop + */ +void sound_banks_disable(UNUSED u8 player, u16 bankMask) { + u8 i; + + for (i = 0; i < SOUND_BANK_COUNT; i++) { + if (bankMask & 1) { + sSoundBankDisabled[i] = TRUE; + } + bankMask = bankMask >> 1; + } +} + +/** + * Called from threads: thread5_game_loop + */ +static void disable_all_sequence_players(void) { + u8 i; + + for (i = 0; i < SEQUENCE_PLAYERS; i++) { + sequence_player_disable(&gSequencePlayers[i]); + } +} + +/** + * Called from threads: thread5_game_loop + */ +void sound_banks_enable(UNUSED u8 player, u16 bankMask) { + u8 i; + + for (i = 0; i < SOUND_BANK_COUNT; i++) { + if (bankMask & 1) { + sSoundBankDisabled[i] = FALSE; + } + bankMask = bankMask >> 1; + } +} + +u8 unused_803209D8(u8 player, u8 channelIndex, u8 arg2) { + u8 ret = 0; + if (gSequencePlayers[player].channels[channelIndex] != &gSequenceChannelNone) { + gSequencePlayers[player].channels[channelIndex]->stopSomething2 = arg2; + ret = arg2; + } + return ret; +} +void func_80320A4C(u8 bankIndex, u8 arg1) { + sSoundMovingSpeed[bankIndex] = arg1; +} + +/** + * Set the moving speed for a sound bank, which may affect the volume and pitch + * of the sound. + * + * Called from threads: thread5_game_loop + */ +void set_sound_moving_speed(u8 bank, u8 speed) { + sSoundMovingSpeed[bank] = speed; +} + +/** + * Called from threads: thread5_game_loop + */ +void play_music(u8 player, u16 seqArgs, u16 fadeTimer) { + u8 seqId = seqArgs & 0xff; + u8 priority = seqArgs >> 8; + u8 i; + u8 foundIndex = 0; + + // Except for the background music player, we don't support queued + // sequences. Just play them immediately, stopping any old sequence. + if (player != SEQ_PLAYER_LEVEL) { + seq_player_play_sequence(player, seqId, fadeTimer); + return; + } + + // Abort if the queue is already full. + if (sBackgroundMusicQueueSize == MAX_BACKGROUND_MUSIC_QUEUE_SIZE) { + return; + } + + // If already in the queue, abort, after first restarting the sequence if + // it is first, and handling disabled music somehow. + // (That handling probably ought to occur even when the queue is full...) + for (i = 0; i < sBackgroundMusicQueueSize; i++) { + if (sBackgroundMusicQueue[i].seqId == seqId) { + if (i == 0) { + seq_player_play_sequence(SEQ_PLAYER_LEVEL, seqId, fadeTimer); + } else if (!gSequencePlayers[SEQ_PLAYER_LEVEL].enabled) { + stop_background_music(sBackgroundMusicQueue[0].seqId); + } + return; + } + } + + // Find the next sequence slot by priority. + for (i = 0; i < sBackgroundMusicQueueSize; i++) { + if (sBackgroundMusicQueue[i].priority <= priority) { + foundIndex = i; + i = sBackgroundMusicQueueSize; // break + } + } + + // If the sequence ends up first in the queue, start it, and make space for + // one more entry in the queue. + if (foundIndex == 0) { + seq_player_play_sequence(SEQ_PLAYER_LEVEL, seqId, fadeTimer); + sBackgroundMusicQueueSize++; + } + + // Move all items up in queue, throwing away the last one if we didn't put + // the new sequence first. + for (i = sBackgroundMusicQueueSize - 1; i > foundIndex; i--) { + sBackgroundMusicQueue[i].priority = sBackgroundMusicQueue[i - 1].priority; + sBackgroundMusicQueue[i].seqId = sBackgroundMusicQueue[i - 1].seqId; + } + + // Insert item into queue. + sBackgroundMusicQueue[foundIndex].priority = priority; + sBackgroundMusicQueue[foundIndex].seqId = seqId; +} + +/** + * Called from threads: thread5_game_loop + */ +void stop_background_music(u16 seqId) { + u8 foundIndex; + u8 i; + + if (sBackgroundMusicQueueSize == 0) { + return; + } + + // If sequence is not found, remove an empty queue item (the next empty + // queue slot). + foundIndex = sBackgroundMusicQueueSize; + + // Search for the sequence. + for (i = 0; i < sBackgroundMusicQueueSize; i++) { + if (sBackgroundMusicQueue[i].seqId == (u8)(seqId & 0xff)) { + // Remove sequence from queue. If it was first, play the next one, + // or fade out the music. + sBackgroundMusicQueueSize--; + if (i == 0) { + if (sBackgroundMusicQueueSize != 0) { + seq_player_play_sequence(SEQ_PLAYER_LEVEL, sBackgroundMusicQueue[1].seqId, 0); + } else { + seq_player_fade_out(SEQ_PLAYER_LEVEL, 20); + } + } + foundIndex = i; + i = sBackgroundMusicQueueSize; // "break;" + } + } + + // Move later slots down. + for (i = foundIndex; i < sBackgroundMusicQueueSize; i++) { + sBackgroundMusicQueue[i].priority = sBackgroundMusicQueue[i + 1].priority; + sBackgroundMusicQueue[i].seqId = sBackgroundMusicQueue[i + 1].seqId; + } + + // @bug? If the sequence queue is full and we attempt to stop a sequence + // that isn't in the queue, this writes out of bounds. Can that happen? + sBackgroundMusicQueue[i].priority = 0; +} + +/** + * Called from threads: thread5_game_loop + */ +void fadeout_background_music(u16 seqId, u16 fadeOut) { + if (sBackgroundMusicQueueSize != 0 && sBackgroundMusicQueue[0].seqId == (u8)(seqId & 0xff)) { + seq_player_fade_out(SEQ_PLAYER_LEVEL, fadeOut); + } +} + +/** + * Called from threads: thread5_game_loop + */ +void drop_queued_background_music(void) { + if (sBackgroundMusicQueueSize != 0) { + sBackgroundMusicQueueSize = 1; + } +} + +/** + * Called from threads: thread5_game_loop + */ +u16 get_current_background_music(void) { + if (sBackgroundMusicQueueSize != 0) { + return (sBackgroundMusicQueue[0].priority << 8) + sBackgroundMusicQueue[0].seqId; + } + return -1; +} + +/** + * Called from threads: thread4_sound, thread5_game_loop (EU only) + */ +void func_80320ED8(void) { +#if defined(VERSION_EU) || defined(VERSION_SH) + if (D_EU_80300558 != 0) { + D_EU_80300558--; + } + + if (gSequencePlayers[SEQ_PLAYER_ENV].enabled + || sBackgroundMusicMaxTargetVolume == TARGET_VOLUME_UNSET || D_EU_80300558 != 0) { +#else + if (gSequencePlayers[SEQ_PLAYER_ENV].enabled + || sBackgroundMusicMaxTargetVolume == TARGET_VOLUME_UNSET) { +#endif + return; + } + + sBackgroundMusicMaxTargetVolume = TARGET_VOLUME_UNSET; + begin_background_music_fade(50); + + if (sBackgroundMusicTargetVolume != TARGET_VOLUME_UNSET + && (D_80332120 == SEQ_EVENT_MERRY_GO_ROUND || D_80332120 == SEQ_EVENT_PIRANHA_PLANT)) { + seq_player_play_sequence(SEQ_PLAYER_ENV, D_80332120, 1); + if (D_80332124 != 0xff) { + seq_player_fade_to_target_volume(SEQ_PLAYER_ENV, 1, D_80332124); + } + } +} + +/** + * Called from threads: thread5_game_loop + */ +void play_secondary_music(u8 seqId, u8 bgMusicVolume, u8 volume, u16 fadeTimer) { + UNUSED u32 dummy; + + sUnused80332118 = 0; + if (sCurrentBackgroundMusicSeqId == 0xff || sCurrentBackgroundMusicSeqId == SEQ_MENU_TITLE_SCREEN) { + return; + } + + if (sBackgroundMusicTargetVolume == TARGET_VOLUME_UNSET) { + sBackgroundMusicTargetVolume = bgMusicVolume + TARGET_VOLUME_IS_PRESENT_FLAG; + begin_background_music_fade(fadeTimer); + seq_player_play_sequence(SEQ_PLAYER_ENV, seqId, fadeTimer >> 1); + if (volume < 0x80) { + seq_player_fade_to_target_volume(SEQ_PLAYER_ENV, fadeTimer, volume); + } + D_80332124 = volume; + D_80332120 = seqId; + } else if (volume != 0xff) { + sBackgroundMusicTargetVolume = bgMusicVolume + TARGET_VOLUME_IS_PRESENT_FLAG; + begin_background_music_fade(fadeTimer); + seq_player_fade_to_target_volume(SEQ_PLAYER_ENV, fadeTimer, volume); + D_80332124 = volume; + } +} + +/** + * Called from threads: thread5_game_loop + */ +void func_80321080(u16 fadeTimer) { + if (sBackgroundMusicTargetVolume != TARGET_VOLUME_UNSET) { + sBackgroundMusicTargetVolume = TARGET_VOLUME_UNSET; + D_80332120 = 0; + D_80332124 = 0; + begin_background_music_fade(fadeTimer); + seq_player_fade_out(SEQ_PLAYER_ENV, fadeTimer); + } +} + +/** + * Called from threads: thread3_main, thread5_game_loop + */ +void func_803210D4(u16 fadeDuration) { + u8 i; + + if (sHasStartedFadeOut) { + return; + } + + if (gSequencePlayers[SEQ_PLAYER_LEVEL].enabled == TRUE) { +#if defined(VERSION_EU) || defined(VERSION_SH) + func_802ad74c(0x83000000, fadeDuration); +#else + seq_player_fade_to_zero_volume(SEQ_PLAYER_LEVEL, fadeDuration); +#endif + } + + if (gSequencePlayers[SEQ_PLAYER_ENV].enabled == TRUE) { +#if defined(VERSION_EU) || defined(VERSION_SH) + func_802ad74c(0x83010000, fadeDuration); +#else + seq_player_fade_to_zero_volume(SEQ_PLAYER_ENV, fadeDuration); +#endif + } + + for (i = 0; i < SOUND_BANK_COUNT; i++) { + if (i != SOUND_BANK_MENU) { + fade_channel_volume_scale(SEQ_PLAYER_SFX, i, 0, fadeDuration / 16); + } + } + + sHasStartedFadeOut = TRUE; +} + +/** + * Called from threads: thread5_game_loop + */ +void play_course_clear(void) { + seq_player_play_sequence(SEQ_PLAYER_ENV, SEQ_EVENT_CUTSCENE_COLLECT_STAR, 0); + sBackgroundMusicMaxTargetVolume = TARGET_VOLUME_IS_PRESENT_FLAG | 0; +#if defined(VERSION_EU) || defined(VERSION_SH) + D_EU_80300558 = 2; +#endif + begin_background_music_fade(50); +} + +/** + * Called from threads: thread5_game_loop + */ +void play_peachs_jingle(void) { + seq_player_play_sequence(SEQ_PLAYER_ENV, SEQ_EVENT_PEACH_MESSAGE, 0); + sBackgroundMusicMaxTargetVolume = TARGET_VOLUME_IS_PRESENT_FLAG | 0; +#if defined(VERSION_EU) || defined(VERSION_SH) + D_EU_80300558 = 2; +#endif + begin_background_music_fade(50); +} + +/** + * Plays the puzzle jingle. Plays the dadada dadada *dadada* jingle + * that usually plays when you solve a "puzzle", like chests, talking to + * yoshi, releasing chain chomp, opening the pyramid top, etc. + * + * Called from threads: thread5_game_loop + */ +void play_puzzle_jingle(void) { + seq_player_play_sequence(SEQ_PLAYER_ENV, SEQ_EVENT_SOLVE_PUZZLE, 0); + sBackgroundMusicMaxTargetVolume = TARGET_VOLUME_IS_PRESENT_FLAG | 20; +#if defined(VERSION_EU) || defined(VERSION_SH) + D_EU_80300558 = 2; +#endif + begin_background_music_fade(50); +} + +/** + * Called from threads: thread5_game_loop + */ +void play_star_fanfare(void) { + seq_player_play_sequence(SEQ_PLAYER_ENV, SEQ_EVENT_HIGH_SCORE, 0); + sBackgroundMusicMaxTargetVolume = TARGET_VOLUME_IS_PRESENT_FLAG | 20; +#if defined(VERSION_EU) || defined(VERSION_SH) + D_EU_80300558 = 2; +#endif + begin_background_music_fade(50); +} + +/** + * Called from threads: thread5_game_loop + */ +void play_power_star_jingle(u8 arg0) { + if (!arg0) { + sBackgroundMusicTargetVolume = 0; + } + seq_player_play_sequence(SEQ_PLAYER_ENV, SEQ_EVENT_CUTSCENE_STAR_SPAWN, 0); + sBackgroundMusicMaxTargetVolume = TARGET_VOLUME_IS_PRESENT_FLAG | 20; +#if defined(VERSION_EU) || defined(VERSION_SH) + D_EU_80300558 = 2; +#endif + begin_background_music_fade(50); +} + +/** + * Called from threads: thread5_game_loop + */ +void play_race_fanfare(void) { + seq_player_play_sequence(SEQ_PLAYER_ENV, SEQ_EVENT_RACE, 0); + sBackgroundMusicMaxTargetVolume = TARGET_VOLUME_IS_PRESENT_FLAG | 20; +#if defined(VERSION_EU) || defined(VERSION_SH) + D_EU_80300558 = 2; +#endif + begin_background_music_fade(50); +} + +/** + * Called from threads: thread5_game_loop + */ +void play_toads_jingle(void) { + seq_player_play_sequence(SEQ_PLAYER_ENV, SEQ_EVENT_TOAD_MESSAGE, 0); + sBackgroundMusicMaxTargetVolume = TARGET_VOLUME_IS_PRESENT_FLAG | 20; +#if defined(VERSION_EU) || defined(VERSION_SH) + D_EU_80300558 = 2; +#endif + begin_background_music_fade(50); +} + +/** + * Called from threads: thread5_game_loop + */ +void sound_reset(u8 presetId) { +#ifndef VERSION_JP + if (presetId >= 8) { + presetId = 0; + sUnused8033323C = 0; + } +#endif + sGameLoopTicked = 0; + disable_all_sequence_players(); + sound_init(); +#ifdef VERSION_SH + func_802ad74c(0xF2000000, 0); +#endif +#if defined(VERSION_JP) || defined(VERSION_US) + audio_reset_session(&gAudioSessionPresets[presetId]); +#else + audio_reset_session_eu(presetId); +#endif + osWritebackDCacheAll(); + if (presetId != 7) { + preload_sequence(SEQ_EVENT_SOLVE_PUZZLE, PRELOAD_BANKS | PRELOAD_SEQUENCE); + preload_sequence(SEQ_EVENT_PEACH_MESSAGE, PRELOAD_BANKS | PRELOAD_SEQUENCE); + preload_sequence(SEQ_EVENT_CUTSCENE_STAR_SPAWN, PRELOAD_BANKS | PRELOAD_SEQUENCE); + } + seq_player_play_sequence(SEQ_PLAYER_SFX, SEQ_SOUND_PLAYER, 0); + D_80332108 = (D_80332108 & 0xf0) + presetId; + gSoundMode = D_80332108 >> 4; + sHasStartedFadeOut = FALSE; +} + +/** + * Called from threads: thread5_game_loop + */ +void audio_set_sound_mode(u8 soundMode) { + D_80332108 = (D_80332108 & 0xf) + (soundMode << 4); + gSoundMode = soundMode; +} + +#if defined(VERSION_JP) || defined(VERSION_US) +void unused_80321460(UNUSED s32 arg0, UNUSED s32 arg1, UNUSED s32 arg2, UNUSED s32 arg3) { +} + +void unused_80321474(UNUSED s32 arg0) { +} +#endif diff --git a/src/decomp/audio/external.h b/src/decomp/audio/external.h new file mode 100644 index 0000000..10fd35a --- /dev/null +++ b/src/decomp/audio/external.h @@ -0,0 +1,74 @@ +#ifndef AUDIO_EXTERNAL_H +#define AUDIO_EXTERNAL_H + +#include + +#include + +// Sequence arguments, passed to seq_player_play_sequence. seqId may be bit-OR'ed with +// SEQ_VARIATION; this will load the same sequence, but set a variation +// bit which may be read by the sequence script. +#define SEQUENCE_ARGS(priority, seqId) ((priority << 8) | seqId) + +#define SOUND_MODE_STEREO 0 +#define SOUND_MODE_MONO 3 +#define SOUND_MODE_HEADSET 1 + +#define SEQ_PLAYER_LEVEL 0 // Level background music +#define SEQ_PLAYER_ENV 1 // Misc music like the puzzle jingle +#define SEQ_PLAYER_SFX 2 // Sound effects + +extern s32 gAudioErrorFlags; +extern f32 gGlobalSoundSource[3]; +extern u32 gAudioRandom; +extern f32 gAudioVolume; +extern u8 gAudioReverb; + +extern u8 gAudioSPTaskYieldBuffer[]; // ucode yield data ptr; only used in JP + +struct SPTask *create_next_audio_frame_task(void); +void create_next_audio_buffer(s16 *samples, u32 num_samples); +void play_sound(s32 soundBits, f32 *pos); +void audio_signal_game_loop_tick(void); +void seq_player_fade_out(u8 player, u16 fadeDuration); +void fade_volume_scale(u8 player, u8 targetScale, u16 fadeDuration); +void seq_player_lower_volume(u8 player, u16 fadeDuration, u8 percentage); +void seq_player_unlower_volume(u8 player, u16 fadeDuration); +void set_audio_muted(u8 muted); +void sound_init(void); +void get_currently_playing_sound(u8 bank, u8 *numPlayingSounds, u8 *numSoundsInBank, u8 *soundId); +void stop_sound(u32 soundBits, f32 *pos); +void stop_sounds_from_source(f32 *pos); +void stop_sounds_in_continuous_banks(void); +void sound_banks_disable(u8 player, u16 bankMask); +void sound_banks_enable(u8 player, u16 bankMask); +void func_80320A4C(u8 bankIndex, u8 arg1); +void set_sound_moving_speed(u8 bank, u8 speed); +void play_dialog_sound(u8 dialogID); +void play_music(u8 player, u16 seqArgs, u16 fadeTimer); +void stop_background_music(u16 seqId); +void fadeout_background_music(u16 arg0, u16 fadeOut); +void drop_queued_background_music(void); +u16 get_current_background_music(void); +void play_secondary_music(u8 seqId, u8 bgMusicVolume, u8 volume, u16 fadeTimer); +void func_80321080(u16 fadeTimer); +void func_803210D4(u16 fadeOutTime); +void play_course_clear(void); +void play_peachs_jingle(void); +void play_puzzle_jingle(void); +void play_star_fanfare(void); +void play_power_star_jingle(u8 arg0); +void play_race_fanfare(void); +void play_toads_jingle(void); +void sound_reset(u8 presetId); +void audio_set_sound_mode(u8 arg0); + +void audio_init(void); // in load.c +void seq_player_play_sequence(u8 player, u8 seqId, u16 arg2); + +#if defined(VERSION_EU) || defined(VERSION_SH) +struct SPTask *unused_80321460(); +struct SPTask *unused_80321460(void); +#endif + +#endif // AUDIO_EXTERNAL_H diff --git a/src/decomp/audio/globals_start.c b/src/decomp/audio/globals_start.c new file mode 100644 index 0000000..01498f2 --- /dev/null +++ b/src/decomp/audio/globals_start.c @@ -0,0 +1,3 @@ +#include + +u64 gAudioGlobalsStartMarker; diff --git a/src/decomp/audio/heap.c b/src/decomp/audio/heap.c new file mode 100644 index 0000000..27281d8 --- /dev/null +++ b/src/decomp/audio/heap.c @@ -0,0 +1,1747 @@ +#include + +#include "heap.h" +#include "data.h" +#include "load.h" +#include "synthesis.h" +#include "seqplayer.h" +#include "effects.h" + +#define ALIGN16(val) (((val) + 0xF) & ~0xF) + +#if defined(VERSION_EU) +ALIGNED16 u8 gAudioHeap[DOUBLE_SIZE_ON_64_BIT(0x31200) - 0x3800]; +#elif defined(VERSION_SH) +ALIGNED16 u8 gAudioHeap[DOUBLE_SIZE_ON_64_BIT(0x31200) - 0x4800]; +#else +ALIGNED16 u8 gAudioHeap[DOUBLE_SIZE_ON_64_BIT(0x31200)]; +#endif + +struct PoolSplit { + u32 wantSeq; + u32 wantBank; + u32 wantUnused; + u32 wantCustom; +}; // size = 0x10 + +struct PoolSplit2 { + u32 wantPersistent; + u32 wantTemporary; +}; // size = 0x8 + +#if defined(VERSION_JP) || defined(VERSION_US) +s16 gVolume; +s8 gReverbDownsampleRate; +u8 sReverbDownsampleRateLog; // never read +#endif + +struct SoundAllocPool gAudioSessionPool; +struct SoundAllocPool gAudioInitPool; +struct SoundAllocPool gNotesAndBuffersPool; +u8 sAudioHeapPad[0x20]; // probably two unused pools +struct SoundAllocPool gSeqAndBankPool; +struct SoundAllocPool gPersistentCommonPool; +struct SoundAllocPool gTemporaryCommonPool; + +struct SoundMultiPool gSeqLoadedPool; +struct SoundMultiPool gBankLoadedPool; +struct SoundMultiPool gUnusedLoadedPool; + +#ifdef VERSION_SH +struct Unk1Pool gUnkPool1; +struct UnkPool gUnkPool2; +struct UnkPool gUnkPool3; +#endif + +struct PoolSplit sSessionPoolSplit; +struct PoolSplit2 sSeqAndBankPoolSplit; +struct PoolSplit sPersistentCommonPoolSplit; +struct PoolSplit sTemporaryCommonPoolSplit; + +#ifdef VERSION_SH +u8 gUnkLoadStatus[0x40]; +#endif +u8 gBankLoadStatus[0x40]; +u8 gSeqLoadStatus[0x100]; + +#if defined(VERSION_EU) || defined(VERSION_SH) +volatile u8 gAudioResetStatus; +u8 gAudioResetPresetIdToLoad; +s32 gAudioResetFadeOutFramesLeft; +#endif + +u8 gAudioUnusedBuffer[0x1000]; + +extern s32 gMaxAudioCmds; + +#ifdef VERSION_SH +void *get_bank_or_seq_inner(s32 poolIdx, s32 arg1, s32 bankId); +struct UnkEntry *func_sh_802f1ec4(u32 size); +void func_sh_802f2158(struct UnkEntry *entry); +struct UnkEntry *unk_pool2_alloc(u32 size); +void func_sh_802F2320(struct UnkEntry *entry, struct AudioBankSample *sample); +void func_sh_802f23ec(void); + +void unk_pools_init(u32 size1, u32 size2); +#endif + +#if defined(VERSION_EU) +/** + * Assuming 'k' in [9, 24], + * Computes a newton's method step for f(x) = x^k - d + */ +f64 root_newton_step(f64 x, s32 k, f64 d) +{ + f64 deg2 = x * x; + f64 deg4 = deg2 * deg2; + f64 deg8 = deg4 * deg4; + s32 degree = k - 9; + f64 fx; + + f64 deriv = deg8; + if (degree & 1) { + deriv *= x; + } + if (degree & 2) { + deriv *= deg2; + } + if (degree & 4) { + deriv *= deg4; + } + if (degree & 8) { + deriv *= deg8; + } + fx = deriv * x - d; + deriv = k * deriv; + return x - fx / deriv; +} + +/** + * Assuming 'k' in [9, 24], + * Computes d ^ (1/k) + * + * @return the root, or 1.0 if d is 0 + */ +f64 kth_root(f64 d, s32 k) { + f64 root = 1.5; + f64 next; + f64 diff; + s32 i; + if (d == 0.0) { + root = 1.0; + } else { + for (i = 0; i < 64; i++) { + if (1) { + } + next = root_newton_step(root, k, d); + diff = next - root; + + if (diff < 0) { + diff = -diff; + } + + if (diff < 1e-07) { + root = next; + break; + } else { + root = next; + } + } + } + + return root; +} + +void build_vol_rampings_table(s32 UNUSED unused, s32 len) { + s32 i; + s32 step; + s32 d; + s32 k = len / 8; + + for (step = 0, i = 0; i < 0x400; step += 32, i++) { + d = step; + if (step == 0) { + d = 1; + } + + gLeftVolRampings[0][i] = kth_root( d, k - 1); + gRightVolRampings[0][i] = kth_root(1.0 / d, k - 1) * 65536.0; + gLeftVolRampings[1][i] = kth_root( d, k); + gRightVolRampings[1][i] = kth_root(1.0 / d, k) * 65536.0; + gLeftVolRampings[2][i] = kth_root( d, k + 1); + gRightVolRampings[2][i] = kth_root(1.0 / d, k + 1) * 65536.0; + } +} +#endif + +void reset_bank_and_seq_load_status(void) { + s32 i; + +#ifdef VERSION_SH + for (i = 0; i < 64; i++) { + if (gBankLoadStatus[i] != SOUND_LOAD_STATUS_5) { + gBankLoadStatus[i] = SOUND_LOAD_STATUS_NOT_LOADED; + } + } + + for (i = 0; i < 64; i++) { + if (gUnkLoadStatus[i] != SOUND_LOAD_STATUS_5) { + gUnkLoadStatus[i] = SOUND_LOAD_STATUS_NOT_LOADED; + } + } + + for (i = 0; i < 256; i++) { + if (gSeqLoadStatus[i] != SOUND_LOAD_STATUS_5) { + gSeqLoadStatus[i] = SOUND_LOAD_STATUS_NOT_LOADED; + } + } +#else + for (i = 0; i < 64; i++) { + gBankLoadStatus[i] = SOUND_LOAD_STATUS_NOT_LOADED; + } + + for (i = 0; i < 256; i++) { + gSeqLoadStatus[i] = SOUND_LOAD_STATUS_NOT_LOADED; + } +#endif +} + +void discard_bank(s32 bankId) { + s32 i; + + for (i = 0; i < gMaxSimultaneousNotes; i++) { + struct Note *note = &gNotes[i]; + +#if defined(VERSION_EU) + if (note->noteSubEu.bankId == bankId) { +#else + if (note->bankId == bankId) { +#endif + // (These prints are unclear. Arguments are picked semi-randomly.) + eu_stubbed_printf_1("Warning:Kill Note %x \n", i); +#ifdef VERSION_SH + if (note->unkSH34 == NOTE_PRIORITY_DISABLED && note->priority) { +#else + if (note->priority >= NOTE_PRIORITY_MIN) { +#endif + eu_stubbed_printf_3("Kill Voice %d (ID %d) %d\n", note->waveId, + bankId, note->priority); + eu_stubbed_printf_0("Warning: Running Sequence's data disappear!\n"); + note->parentLayer->enabled = FALSE; // is 0x48, should be 0x44 + note->parentLayer->finished = TRUE; + } + note_disable(note); + audio_list_remove(¬e->listItem); + audio_list_push_back(&gNoteFreeLists.disabled, ¬e->listItem); + } + } +} + +void discard_sequence(s32 seqId) { + s32 i; + + for (i = 0; i < SEQUENCE_PLAYERS; i++) { + if (gSequencePlayers[i].enabled && gSequencePlayers[i].seqId == seqId) { +#if defined(VERSION_EU) || defined(VERSION_SH) + sequence_player_disable(&gSequencePlayers[i]); +#else + sequence_player_disable(gSequencePlayers + i); +#endif + } + } +} + +void *soundAlloc(struct SoundAllocPool *pool, u32 size) { +#if defined(VERSION_EU) || defined(VERSION_SH) + u8 *start; + u8 *pos; + u32 alignedSize = ALIGN16(size); + + start = pool->cur; + if (start + alignedSize <= pool->start + pool->size) { + pool->cur += alignedSize; + for (pos = start; pos < pool->cur; pos++) { + *pos = 0; + } + } else { + eu_stubbed_printf_1("Heap OverFlow : Not Allocate %d!\n", size); + return NULL; + } +#ifdef VERSION_SH + pool->numAllocatedEntries++; +#endif + return start; +#else + u8 *start; + s32 last; + s32 i; + + if ((pool->cur + ALIGN16(size) <= pool->size + pool->start)) { + start = pool->cur; + pool->cur += ALIGN16(size); + last = pool->cur - start - 1; + for (i = 0; i <= last; i++) { + start[i] = 0; + } + } else { + return NULL; + } + return start; +#endif +} + +#ifdef VERSION_SH +void *sound_alloc_uninitialized(struct SoundAllocPool *pool, u32 size) { + u8 *start; + u32 alignedSize = ALIGN16(size); + + start = pool->cur; + if (start + alignedSize <= pool->start + pool->size) { + pool->cur += alignedSize; + } else { + return NULL; + } + + pool->numAllocatedEntries++; + return start; +} +#endif + +void sound_alloc_pool_init(struct SoundAllocPool *pool, void *memAddr, u32 size) { + pool->cur = pool->start = (u8 *) ALIGN16((uintptr_t) memAddr); +#ifdef VERSION_SH + pool->size = size - ((uintptr_t) memAddr & 0xf); +#else + pool->size = size; +#endif + pool->numAllocatedEntries = 0; +} + +void persistent_pool_clear(struct PersistentPool *persistent) { + persistent->pool.numAllocatedEntries = 0; + persistent->pool.cur = persistent->pool.start; + persistent->numEntries = 0; +} + +void temporary_pool_clear(struct TemporaryPool *temporary) { + temporary->pool.numAllocatedEntries = 0; + temporary->pool.cur = temporary->pool.start; + temporary->nextSide = 0; + temporary->entries[0].ptr = temporary->pool.start; +#if defined(VERSION_EU) || defined(VERSION_SH) + temporary->entries[1].ptr = temporary->pool.start + temporary->pool.size; +#else + temporary->entries[1].ptr = temporary->pool.size + temporary->pool.start; +#endif + temporary->entries[0].id = -1; // should be at 1e not 1c + temporary->entries[1].id = -1; +} + +void unused_803160F8(struct SoundAllocPool *pool) { + pool->numAllocatedEntries = 0; + pool->cur = pool->start; +} + +extern s32 D_SH_80315EE8; +void sound_init_main_pools(s32 sizeForAudioInitPool) { + sound_alloc_pool_init(&gAudioInitPool, gAudioHeap, sizeForAudioInitPool); + sound_alloc_pool_init(&gAudioSessionPool, gAudioHeap + sizeForAudioInitPool, gAudioHeapSize - sizeForAudioInitPool); +} + +#ifdef VERSION_SH +#define SOUND_ALLOC_FUNC sound_alloc_uninitialized +#else +#define SOUND_ALLOC_FUNC soundAlloc +#endif + +void session_pools_init(struct PoolSplit *a) { + gAudioSessionPool.cur = gAudioSessionPool.start; + sound_alloc_pool_init(&gNotesAndBuffersPool, SOUND_ALLOC_FUNC(&gAudioSessionPool, a->wantSeq), a->wantSeq); + sound_alloc_pool_init(&gSeqAndBankPool, SOUND_ALLOC_FUNC(&gAudioSessionPool, a->wantCustom), a->wantCustom); +} + +void seq_and_bank_pool_init(struct PoolSplit2 *a) { + gSeqAndBankPool.cur = gSeqAndBankPool.start; + sound_alloc_pool_init(&gPersistentCommonPool, SOUND_ALLOC_FUNC(&gSeqAndBankPool, a->wantPersistent), a->wantPersistent); + sound_alloc_pool_init(&gTemporaryCommonPool, SOUND_ALLOC_FUNC(&gSeqAndBankPool, a->wantTemporary), a->wantTemporary); +} + +void persistent_pools_init(struct PoolSplit *a) { + gPersistentCommonPool.cur = gPersistentCommonPool.start; + sound_alloc_pool_init(&gSeqLoadedPool.persistent.pool, SOUND_ALLOC_FUNC(&gPersistentCommonPool, a->wantSeq), a->wantSeq); + sound_alloc_pool_init(&gBankLoadedPool.persistent.pool, SOUND_ALLOC_FUNC(&gPersistentCommonPool, a->wantBank), a->wantBank); + sound_alloc_pool_init(&gUnusedLoadedPool.persistent.pool, SOUND_ALLOC_FUNC(&gPersistentCommonPool, a->wantUnused), + a->wantUnused); + persistent_pool_clear(&gSeqLoadedPool.persistent); + persistent_pool_clear(&gBankLoadedPool.persistent); + persistent_pool_clear(&gUnusedLoadedPool.persistent); +} + +void temporary_pools_init(struct PoolSplit *a) { + gTemporaryCommonPool.cur = gTemporaryCommonPool.start; + sound_alloc_pool_init(&gSeqLoadedPool.temporary.pool, SOUND_ALLOC_FUNC(&gTemporaryCommonPool, a->wantSeq), a->wantSeq); + sound_alloc_pool_init(&gBankLoadedPool.temporary.pool, SOUND_ALLOC_FUNC(&gTemporaryCommonPool, a->wantBank), a->wantBank); + sound_alloc_pool_init(&gUnusedLoadedPool.temporary.pool, SOUND_ALLOC_FUNC(&gTemporaryCommonPool, a->wantUnused), + a->wantUnused); + temporary_pool_clear(&gSeqLoadedPool.temporary); + temporary_pool_clear(&gBankLoadedPool.temporary); + temporary_pool_clear(&gUnusedLoadedPool.temporary); +} +#undef SOUND_ALLOC_FUNC + +#if defined(VERSION_JP) || defined(VERSION_US) +UNUSED static void unused_803163D4(void) { +} +#endif + +#ifdef VERSION_SH +void *alloc_bank_or_seq(s32 poolIdx, s32 size, s32 arg3, s32 id) { +#else +void *alloc_bank_or_seq(struct SoundMultiPool *arg0, s32 arg1, s32 size, s32 arg3, s32 id) { +#endif + // arg3 = 0, 1 or 2? + +#ifdef VERSION_SH + struct SoundMultiPool *arg0; +#define isSound poolIdx +#endif + struct TemporaryPool *tp; + struct SoundAllocPool *pool; + void *ret; +#if defined(VERSION_JP) || defined(VERSION_US) + u16 UNUSED _firstVal; + u16 UNUSED _secondVal; +#else + u16 firstVal; + u16 secondVal; +#endif + u32 nullID = -1; + UNUSED s32 i; + u8 *table; +#ifndef VERSION_SH + u8 isSound; +#endif +#if defined(VERSION_JP) || defined(VERSION_US) + u16 firstVal; + u16 secondVal; + u32 bothDiscardable; + u32 leftDiscardable, rightDiscardable; + u32 leftNotLoaded, rightNotLoaded; + u32 leftAvail, rightAvail; +#endif + +#ifdef VERSION_SH + switch (poolIdx) { + case 0: + arg0 = &gSeqLoadedPool; + table = gSeqLoadStatus; + break; + + case 1: + arg0 = &gBankLoadedPool; + table = gBankLoadStatus; + break; + + case 2: + arg0 = &gUnusedLoadedPool; + table = gUnkLoadStatus; + break; + } +#endif + + if (arg3 == 0) { + tp = &arg0->temporary; +#ifndef VERSION_SH + if (arg0 == &gSeqLoadedPool) { + table = gSeqLoadStatus; + isSound = FALSE; + } else if (arg0 == &gBankLoadedPool) { + table = gBankLoadStatus; + isSound = TRUE; + } +#endif + +#ifdef VERSION_SH + if (tp->entries[0].id == (s8)nullID) { + firstVal = SOUND_LOAD_STATUS_NOT_LOADED; + } else { + firstVal = table[tp->entries[0].id]; + } + if (tp->entries[1].id == (s8)nullID) { + secondVal = SOUND_LOAD_STATUS_NOT_LOADED; + } else { + secondVal = table[tp->entries[1].id]; + } +#else + firstVal = (tp->entries[0].id == (s8)nullID ? SOUND_LOAD_STATUS_NOT_LOADED : table[tp->entries[0].id]); + secondVal = (tp->entries[1].id == (s8)nullID ? SOUND_LOAD_STATUS_NOT_LOADED : table[tp->entries[1].id]); +#endif + +#if defined(VERSION_JP) || defined(VERSION_US) + leftNotLoaded = (firstVal == SOUND_LOAD_STATUS_NOT_LOADED); + leftDiscardable = (firstVal == SOUND_LOAD_STATUS_DISCARDABLE); + leftAvail = (firstVal != SOUND_LOAD_STATUS_IN_PROGRESS); + rightNotLoaded = (secondVal == SOUND_LOAD_STATUS_NOT_LOADED); + rightDiscardable = (secondVal == SOUND_LOAD_STATUS_DISCARDABLE); + rightAvail = (secondVal != SOUND_LOAD_STATUS_IN_PROGRESS); + bothDiscardable = (leftDiscardable && rightDiscardable); + + if (leftNotLoaded) { + tp->nextSide = 0; + } else if (rightNotLoaded) { + tp->nextSide = 1; + } else if (bothDiscardable) { + // Use the opposite side from last time. + } else if (firstVal == SOUND_LOAD_STATUS_DISCARDABLE) { // ??! (I blame copt) + tp->nextSide = 0; + } else if (rightDiscardable) { + tp->nextSide = 1; + } else if (leftAvail) { + tp->nextSide = 0; + } else if (rightAvail) { + tp->nextSide = 1; + } else { + // Both left and right sides are being loaded into. + return NULL; + } +#else +#ifdef VERSION_EU + if (0) { + // It's unclear where these string literals go. + eu_stubbed_printf_0("DataHeap Not Allocate \n"); + eu_stubbed_printf_1("StayHeap Not Allocate %d\n", 0); + eu_stubbed_printf_1("AutoHeap Not Allocate %d\n", 0); + } +#endif + +#ifdef VERSION_SH + if (poolIdx == 1) { + if (firstVal == SOUND_LOAD_STATUS_4) { + for (i = 0; i < gMaxSimultaneousNotes; i++) { + if (gNotes[i].bankId == tp->entries[0].id && gNotes[i].noteSubEu.enabled) { + break; + } + } + if (i == gMaxSimultaneousNotes) { + if (gBankLoadStatus[tp->entries[0].id] != SOUND_LOAD_STATUS_5) { + gBankLoadStatus[tp->entries[0].id] = SOUND_LOAD_STATUS_DISCARDABLE; + } + firstVal = SOUND_LOAD_STATUS_DISCARDABLE; + } + } + if (secondVal == SOUND_LOAD_STATUS_4) { + for (i = 0; i < gMaxSimultaneousNotes; i++) { + if (gNotes[i].bankId == tp->entries[1].id && gNotes[i].noteSubEu.enabled) { + break; + } + } + if (i == gMaxSimultaneousNotes) { + if (gBankLoadStatus[tp->entries[1].id] != SOUND_LOAD_STATUS_5) { + gBankLoadStatus[tp->entries[1].id] = SOUND_LOAD_STATUS_DISCARDABLE; + } + secondVal = SOUND_LOAD_STATUS_DISCARDABLE; + } + } + } +#endif + + if (firstVal == SOUND_LOAD_STATUS_NOT_LOADED) { + tp->nextSide = 0; + } else if (secondVal == SOUND_LOAD_STATUS_NOT_LOADED) { + tp->nextSide = 1; + } else { + eu_stubbed_printf_0("WARNING: NO FREE AUTOSEQ AREA.\n"); + if ((firstVal == SOUND_LOAD_STATUS_DISCARDABLE) && (secondVal == SOUND_LOAD_STATUS_DISCARDABLE)) { + // Use the opposite side from last time. + } else if (firstVal == SOUND_LOAD_STATUS_DISCARDABLE) { + tp->nextSide = 0; + } else if (secondVal == SOUND_LOAD_STATUS_DISCARDABLE) { + tp->nextSide = 1; + } else { +#ifdef VERSION_EU + eu_stubbed_printf_0("WARNING: NO STOP AUTO AREA.\n"); + eu_stubbed_printf_0(" AND TRY FORCE TO STOP SIDE \n"); + if (firstVal != SOUND_LOAD_STATUS_IN_PROGRESS) { + tp->nextSide = 0; + } else if (secondVal != SOUND_LOAD_STATUS_IN_PROGRESS) { + tp->nextSide = 1; + } else { + // Both left and right sides are being loaded into. + eu_stubbed_printf_0("TWO SIDES ARE LOADING... ALLOC CANCELED.\n"); + return NULL; + } +#else + if (poolIdx == 0) { + if (firstVal == SOUND_LOAD_STATUS_COMPLETE) { + for (i = 0; i < SEQUENCE_PLAYERS; i++) { + if (gSequencePlayers[i].enabled && gSequencePlayers[i].seqId == tp->entries[0].id) { + break; + } + } + if (i == SEQUENCE_PLAYERS) { + tp->nextSide = 0; + goto out; + } + } + if (secondVal == SOUND_LOAD_STATUS_COMPLETE) { + for (i = 0; i < SEQUENCE_PLAYERS; i++) { + if (gSequencePlayers[i].enabled && gSequencePlayers[i].seqId == tp->entries[1].id) { + break; + } + } + if (i == SEQUENCE_PLAYERS) { + tp->nextSide = 1; + goto out; + } + } + } else if (poolIdx == 1) { + if (firstVal == SOUND_LOAD_STATUS_COMPLETE) { + for (i = 0; i < gMaxSimultaneousNotes; i++) { + if (gNotes[i].bankId == tp->entries[0].id && gNotes[i].noteSubEu.enabled) { + break; + } + } + if (i == gMaxSimultaneousNotes) { + tp->nextSide = 0; + goto out; + } + } + if (secondVal == SOUND_LOAD_STATUS_COMPLETE) { + for (i = 0; i < gMaxSimultaneousNotes; i++) { + if (gNotes[i].bankId == tp->entries[1].id && gNotes[i].noteSubEu.enabled) { + break; + } + } + if (i == gMaxSimultaneousNotes) { + tp->nextSide = 1; + goto out; + } + } + } + if (tp->nextSide == 0) { + if (firstVal == SOUND_LOAD_STATUS_IN_PROGRESS) { + if (secondVal != SOUND_LOAD_STATUS_IN_PROGRESS) { + tp->nextSide = 1; + goto out; + } + } else { + goto out; + } + } else { + if (secondVal == SOUND_LOAD_STATUS_IN_PROGRESS) { + if (firstVal != SOUND_LOAD_STATUS_IN_PROGRESS) { + tp->nextSide = 0; + goto out; + } + } else { + goto out; + } + } + return NULL; + out:; +#endif + } + } +#endif + + pool = &arg0->temporary.pool; + if (tp->entries[tp->nextSide].id != (s8)nullID) { + table[tp->entries[tp->nextSide].id] = SOUND_LOAD_STATUS_NOT_LOADED; + if (isSound == TRUE) { + discard_bank(tp->entries[tp->nextSide].id); + } + } + + switch (tp->nextSide) { + case 0: + tp->entries[0].ptr = pool->start; + tp->entries[0].id = id; + tp->entries[0].size = size; + + pool->cur = pool->start + size; + +#ifdef VERSION_SH + if (tp->entries[1].id != (s32)nullID) +#endif + if (tp->entries[1].ptr < pool->cur) { + eu_stubbed_printf_0("WARNING: Before Area Overlaid After."); + + // Throw out the entry on the other side if it doesn't fit. + // (possible @bug: what if it's currently being loaded?) + table[tp->entries[1].id] = SOUND_LOAD_STATUS_NOT_LOADED; + + switch (isSound) { + case FALSE: + discard_sequence(tp->entries[1].id); + break; + case TRUE: + discard_bank(tp->entries[1].id); + break; + } + + tp->entries[1].id = (s32)nullID; +#if defined(VERSION_EU) || defined(VERSION_SH) + tp->entries[1].ptr = pool->start + pool->size; +#else + tp->entries[1].ptr = pool->size + pool->start; +#endif + } + + ret = tp->entries[0].ptr; + break; + + case 1: +#if defined(VERSION_SH) + tp->entries[1].ptr = (u8 *) ((uintptr_t) (pool->start + pool->size - size) & ~0x0f); +#elif defined(VERSION_EU) + tp->entries[1].ptr = pool->start + pool->size - size - 0x10; +#else + tp->entries[1].ptr = pool->size + pool->start - size - 0x10; +#endif + tp->entries[1].id = id; + tp->entries[1].size = size; + +#ifdef VERSION_SH + if (tp->entries[0].id != (s32)nullID) +#endif + if (tp->entries[1].ptr < pool->cur) { + eu_stubbed_printf_0("WARNING: After Area Overlaid Before."); + + table[tp->entries[0].id] = SOUND_LOAD_STATUS_NOT_LOADED; + + switch (isSound) { + case FALSE: + discard_sequence(tp->entries[0].id); + break; + case TRUE: + discard_bank(tp->entries[0].id); + break; + } + + tp->entries[0].id = (s32)nullID; + pool->cur = pool->start; + } + + ret = tp->entries[1].ptr; + break; + + default: + eu_stubbed_printf_1("MEMORY:SzHeapAlloc ERROR: sza->side %d\n", tp->nextSide); + return NULL; + } + + // Switch sides for next time in case both entries are + // SOUND_LOAD_STATUS_DISCARDABLE. + tp->nextSide ^= 1; + + return ret; + } + +#if defined(VERSION_EU) || defined(VERSION_SH) +#ifdef VERSION_SH + ret = sound_alloc_uninitialized(&arg0->persistent.pool, size); +#else + ret = soundAlloc(&arg0->persistent.pool, arg1 * size); +#endif + arg0->persistent.entries[arg0->persistent.numEntries].ptr = ret; + + if (ret == NULL) +#else + arg0->persistent.entries[arg0->persistent.numEntries].ptr = soundAlloc(&arg0->persistent.pool, arg1 * size); + + if (arg0->persistent.entries[arg0->persistent.numEntries].ptr == NULL) +#endif + { + switch (arg3) { + case 2: +#if defined(VERSION_EU) + eu_stubbed_printf_0("MEMORY:StayHeap OVERFLOW."); + return alloc_bank_or_seq(arg0, arg1, size, 0, id); +#elif defined(VERSION_SH) + return alloc_bank_or_seq(poolIdx, size, 0, id); +#else + // Prevent tail call optimization. + ret = alloc_bank_or_seq(arg0, arg1, size, 0, id); + return ret; +#endif + case 1: +#ifdef VERSION_SH + case 0: +#endif + eu_stubbed_printf_1("MEMORY:StayHeap OVERFLOW (REQ:%d)", arg1 * size); + return NULL; + } + } + + // TODO: why is this guaranteed to write <= 32 entries...? + // Because the buffer is small enough that more don't fit? + arg0->persistent.entries[arg0->persistent.numEntries].id = id; + arg0->persistent.entries[arg0->persistent.numEntries].size = size; +#if defined(VERSION_EU) || defined(VERSION_SH) + return arg0->persistent.entries[arg0->persistent.numEntries++].ptr; +#else + arg0->persistent.numEntries++; return arg0->persistent.entries[arg0->persistent.numEntries - 1].ptr; +#endif +#ifdef VERSION_SH +#undef isSound +#endif +} + +#ifdef VERSION_SH +void *get_bank_or_seq(s32 poolIdx, s32 arg1, s32 id) { + void *ret; + + ret = unk_pool1_lookup(poolIdx, id); + if (ret != NULL) { + return ret; + } + if (arg1 == 3) { + return NULL; + } + return get_bank_or_seq_inner(poolIdx, arg1, id); +} +void *get_bank_or_seq_inner(s32 poolIdx, s32 arg1, s32 bankId) { + u32 i; + struct SoundMultiPool* loadedPool; + struct TemporaryPool* temporary; + struct PersistentPool* persistent; + + switch (poolIdx) { + case 0: + loadedPool = &gSeqLoadedPool; + break; + case 1: + loadedPool = &gBankLoadedPool; + break; + case 2: + loadedPool = &gUnusedLoadedPool; + break; + } + + temporary = &loadedPool->temporary; + if (arg1 == 0) { + if (temporary->entries[0].id == bankId) { + temporary->nextSide = 1; + return temporary->entries[0].ptr; + } else if (temporary->entries[1].id == bankId) { + temporary->nextSide = 0; + return temporary->entries[1].ptr; + } else { + return NULL; + } + } + + persistent = &loadedPool->persistent; + for (i = 0; i < persistent->numEntries; i++) { + if (persistent->entries[i].id == bankId) { + return persistent->entries[i].ptr; + } + } + + if (arg1 == 2) { + return get_bank_or_seq(poolIdx, 0, bankId); + } + return NULL; +} +#endif +#ifndef VERSION_SH +void *get_bank_or_seq(struct SoundMultiPool *arg0, s32 arg1, s32 id) { + u32 i; + UNUSED void *ret; + struct TemporaryPool *temporary = &arg0->temporary; + + if (arg1 == 0) { + // Try not to overwrite sound that we have just accessed, by setting nextSide appropriately. + if (temporary->entries[0].id == id) { + temporary->nextSide = 1; + return temporary->entries[0].ptr; + } else if (temporary->entries[1].id == id) { + temporary->nextSide = 0; + return temporary->entries[1].ptr; + } + eu_stubbed_printf_1("Auto Heap Unhit for ID %d\n", id); + return NULL; + } else { + struct PersistentPool *persistent = &arg0->persistent; + for (i = 0; i < persistent->numEntries; i++) { + if (id == persistent->entries[i].id) { + eu_stubbed_printf_2("Cache hit %d at stay %d\n", id, i); + return persistent->entries[i].ptr; + } + } + + if (arg1 == 2) { +#if defined(VERSION_EU) || defined(VERSION_SH) + return get_bank_or_seq(arg0, 0, id); +#else + // Prevent tail call optimization by using a temporary. + // Either copt or -Wo,-notail. + ret = get_bank_or_seq(arg0, 0, id); + return ret; +#endif + } + return NULL; + } +} +#endif + +#if defined(VERSION_EU) || defined(VERSION_SH) +void func_eu_802e27e4_unused(f32 arg0, f32 arg1, u16 *arg2) { + s32 i; + f32 tmp[16]; + + tmp[0] = (f32) (arg1 * 262159.0f); + tmp[8] = (f32) (arg0 * 262159.0f); + tmp[1] = (f32) ((arg1 * arg0) * 262159.0f); + tmp[9] = (f32) (((arg0 * arg0) + arg1) * 262159.0f); + + for (i = 2; i < 8; i++) { + //! @bug they probably meant to store the value to tmp[i] and tmp[8 + i] + arg2[i] = arg1 * tmp[i - 2] + arg0 * tmp[i - 1]; + arg2[8 + i] = arg1 * tmp[6 + i] + arg0 * tmp[7 + i]; + } + + for (i = 0; i < 16; i++) { + arg2[i] = tmp[i]; + } + +#ifdef VERSION_EU + for (i = 0; i < 8; i++) { + eu_stubbed_printf_1("%d ", arg2[i]); + } + eu_stubbed_printf_0("\n"); + + for (i = 8; i < 16; i++) { + eu_stubbed_printf_1("%d ", arg2[i]); + } + eu_stubbed_printf_0("\n"); +#endif +} +#endif + +#ifdef VERSION_SH +void fill_zero_filter(s16 filter[]) { + s32 i; + for (i = 0; i < 8; i++) { + filter[i] = 0; + } +} + +extern s16 unk_sh_data_3[15 * 8]; +extern s16 unk_sh_data_4[15 * 8]; +void func_sh_802F0DE8(s16 filter[8], s32 arg1) { + s32 i; + s16 *ptr = &unk_sh_data_3[8 * (arg1 - 1)]; + for (i = 0; i < 8; i++) { + filter[i] = ptr[i]; + } +} + +void func_sh_802F0E40(s16 filter[8], s32 arg1) { // Unused + s32 i; + s16 *ptr = &unk_sh_data_4[8 * (arg1 - 1)]; + for (i = 0; i < 8; i++) { + filter[i] = ptr[i]; + } +} + +void fill_filter(s16 filter[8], s32 arg1, s32 arg2) { + s32 i; + s16 *ptr; + if (arg1 != 0) { + func_sh_802F0DE8(filter, arg1); + } else { + fill_zero_filter(filter); + } + if (arg2 != 0) { + ptr = &unk_sh_data_4[8 * (arg2 - 1)]; + for (i = 0; i < 8; i++) { + filter[i] += ptr[i]; + } + } +} +#endif + +void decrease_reverb_gain(void) { +#if defined(VERSION_EU) + s32 i; + for (i = 0; i < gNumSynthesisReverbs; i++) { + gSynthesisReverbs[i].reverbGain -= gSynthesisReverbs[i].reverbGain / 8; + } +#elif defined(VERSION_JP) || defined(VERSION_US) + gSynthesisReverb.reverbGain -= gSynthesisReverb.reverbGain / 4; +#else + s32 i, j; + s32 v0 = gAudioBufferParameters.presetUnk4 == 2 ? 2 : 1; + for (i = 0; i < gNumSynthesisReverbs; i++) { + for (j = 0; j < v0; j++) { + gSynthesisReverbs[i].reverbGain -= gSynthesisReverbs[i].reverbGain / 3; + } + } +#endif +} + +#if defined(VERSION_SH) +void clear_curr_ai_buffer(void) { + s32 currIndex = gCurrAiBufferIndex; + s32 i; + gAiBufferLengths[currIndex] = gAudioBufferParameters.minAiBufferLength; + for (i = 0; i < (s32) (AIBUFFER_LEN / sizeof(s16)); i++) { + gAiBuffers[currIndex][i] = 0; + } +} +#endif + + +#if defined(VERSION_EU) || defined(VERSION_SH) +s32 audio_shut_down_and_reset_step(void) { + s32 i; + s32 j; +#ifdef VERSION_SH + s32 num = gAudioBufferParameters.presetUnk4 == 2 ? 2 : 1; +#endif + + switch (gAudioResetStatus) { + case 5: + for (i = 0; i < SEQUENCE_PLAYERS; i++) { + sequence_player_disable(&gSequencePlayers[i]); + } +#ifdef VERSION_SH + gAudioResetFadeOutFramesLeft = 4 / num; +#else + gAudioResetFadeOutFramesLeft = 4; +#endif + gAudioResetStatus--; + break; + case 4: + if (gAudioResetFadeOutFramesLeft != 0) { + gAudioResetFadeOutFramesLeft--; + decrease_reverb_gain(); + } else { + for (i = 0; i < gMaxSimultaneousNotes; i++) { + if (gNotes[i].noteSubEu.enabled && gNotes[i].adsr.state != ADSR_STATE_DISABLED) { + gNotes[i].adsr.fadeOutVel = gAudioBufferParameters.updatesPerFrameInv; + gNotes[i].adsr.action |= ADSR_ACTION_RELEASE; + } + } +#ifdef VERSION_SH + gAudioResetFadeOutFramesLeft = 16 / num; +#else + gAudioResetFadeOutFramesLeft = 16; +#endif + gAudioResetStatus--; + } + break; + case 3: + if (gAudioResetFadeOutFramesLeft != 0) { + gAudioResetFadeOutFramesLeft--; +#ifdef VERSION_SH + if (1) { + } +#endif + decrease_reverb_gain(); + } else { + for (i = 0; i < NUMAIBUFFERS; i++) { + for (j = 0; j < (s32) (AIBUFFER_LEN / sizeof(s16)); j++) { + gAiBuffers[i][j] = 0; + } + } +#ifdef VERSION_SH + gAudioResetFadeOutFramesLeft = 4 / num; +#else + gAudioResetFadeOutFramesLeft = 4; +#endif + gAudioResetStatus--; + } + break; + case 2: +#ifdef VERSION_SH + clear_curr_ai_buffer(); +#endif + if (gAudioResetFadeOutFramesLeft != 0) { + gAudioResetFadeOutFramesLeft--; + } else { + gAudioResetStatus--; +#ifdef VERSION_SH + func_sh_802f23ec(); +#endif + } + break; + case 1: + audio_reset_session(); + gAudioResetStatus = 0; +#ifdef VERSION_SH + for (i = 0; i < NUMAIBUFFERS; i++) { + gAiBufferLengths[i] = gAudioBufferParameters.maxAiBufferLength; + for (j = 0; j < (s32) (AIBUFFER_LEN / sizeof(s16)); j++) { + gAiBuffers[i][j] = 0; + } + } +#endif + } +#ifdef VERSION_SH + if (gAudioResetFadeOutFramesLeft) { + } +#endif + if (gAudioResetStatus < 3) { + return 0; + } + return 1; +} +#else +/** + * Waits until a specified number of audio frames have been created + */ +void wait_for_audio_frames(UNUSED s32 frames) { + gAudioFrameCount = 0; +#ifdef TARGET_N64 + // Sound thread will update gAudioFrameCount + while (gAudioFrameCount < frames) { + // spin + } +#endif +} +#endif + +#if defined(VERSION_JP) || defined(VERSION_US) +void audio_reset_session(struct AudioSessionSettings *preset) { +#else +void audio_reset_session(void) { + struct AudioSessionSettingsEU *preset = &gAudioSessionPresets[gAudioResetPresetIdToLoad]; + struct ReverbSettingsEU *reverbSettings; +#endif + s16 *mem; +#if defined(VERSION_JP) || defined(VERSION_US) + s8 updatesPerFrame; + s32 reverbWindowSize; + s32 k; +#endif + s32 i; + s32 j; + s32 persistentMem; + s32 temporaryMem; + s32 totalMem; + s32 wantMisc; +#if defined(VERSION_JP) || defined(VERSION_US) + s32 frames; + s32 remainingDmas; +#else + struct SynthesisReverb *reverb; +#endif + eu_stubbed_printf_1("Heap Reconstruct Start %x\n", gAudioResetPresetIdToLoad); + +#if defined(VERSION_JP) || defined(VERSION_US) + if (gAudioLoadLock != AUDIO_LOCK_UNINITIALIZED) { + decrease_reverb_gain(); + for (i = 0; i < gMaxSimultaneousNotes; i++) { + if (gNotes[i].enabled && gNotes[i].adsr.state != ADSR_STATE_DISABLED) { + gNotes[i].adsr.fadeOutVel = 0x8000 / gAudioUpdatesPerFrame; + gNotes[i].adsr.action |= ADSR_ACTION_RELEASE; + } + } + + // Wait for all notes to stop playing + frames = 0; + for (;;) { + wait_for_audio_frames(1); + frames++; + if (frames > 4 * 60) { + // Break after 4 seconds + break; + } + + for (i = 0; i < gMaxSimultaneousNotes; i++) { + if (gNotes[i].enabled) + break; + } + + if (i == gMaxSimultaneousNotes) { + // All zero, break early + break; + } + } + + // Wait for the reverb to finish as well + decrease_reverb_gain(); + wait_for_audio_frames(3); + + // The audio interface is double buffered; thus, we have to take the + // load lock for 2 frames for the buffers to free up before we can + // repurpose memory. Make that 3 frames, just in case. + gAudioLoadLock = AUDIO_LOCK_LOADING; + wait_for_audio_frames(3); + + remainingDmas = gCurrAudioFrameDmaCount; + while (remainingDmas > 0) { + for (i = 0; i < gCurrAudioFrameDmaCount; i++) { + if (osRecvMesg(&gCurrAudioFrameDmaQueue, NULL, OS_MESG_NOBLOCK) == 0) + remainingDmas--; + } + } + gCurrAudioFrameDmaCount = 0; + + for (j = 0; j < NUMAIBUFFERS; j++) { + for (k = 0; k < (s32) (AIBUFFER_LEN / sizeof(s16)); k++) { + gAiBuffers[j][k] = 0; + } + } + } +#endif + + gSampleDmaNumListItems = 0; +#if defined(VERSION_EU) || defined(VERSION_SH) + gAudioBufferParameters.frequency = preset->frequency; + gAudioBufferParameters.aiFrequency = osAiSetFrequency(gAudioBufferParameters.frequency); + gAudioBufferParameters.samplesPerFrameTarget = ALIGN16(gAudioBufferParameters.frequency / gRefreshRate); + gAudioBufferParameters.minAiBufferLength = gAudioBufferParameters.samplesPerFrameTarget - 0x10; + gAudioBufferParameters.maxAiBufferLength = gAudioBufferParameters.samplesPerFrameTarget + 0x10; +#ifdef VERSION_SH + gAudioBufferParameters.updatesPerFrame = (gAudioBufferParameters.samplesPerFrameTarget + 0x10) / 192 + 1; + gAudioBufferParameters.samplesPerUpdate = (gAudioBufferParameters.samplesPerFrameTarget / gAudioBufferParameters.updatesPerFrame) & -8; +#else + gAudioBufferParameters.updatesPerFrame = (gAudioBufferParameters.samplesPerFrameTarget + 0x10) / 160 + 1; + gAudioBufferParameters.samplesPerUpdate = (gAudioBufferParameters.samplesPerFrameTarget / gAudioBufferParameters.updatesPerFrame) & 0xfff8; +#endif + gAudioBufferParameters.samplesPerUpdateMax = gAudioBufferParameters.samplesPerUpdate + 8; + gAudioBufferParameters.samplesPerUpdateMin = gAudioBufferParameters.samplesPerUpdate - 8; + gAudioBufferParameters.resampleRate = 32000.0f / FLOAT_CAST(gAudioBufferParameters.frequency); +#ifdef VERSION_SH + gAudioBufferParameters.unkUpdatesPerFrameScaled = (1.0f / 256.0f) / gAudioBufferParameters.updatesPerFrame; +#else + gAudioBufferParameters.unkUpdatesPerFrameScaled = (3.0f / 1280.0f) / gAudioBufferParameters.updatesPerFrame; +#endif + gAudioBufferParameters.updatesPerFrameInv = 1.0f / gAudioBufferParameters.updatesPerFrame; + + gMaxSimultaneousNotes = preset->maxSimultaneousNotes; + gVolume = preset->volume; + gTempoInternalToExternal = (u32) (gAudioBufferParameters.updatesPerFrame * 2880000.0f / gTatumsPerBeat / D_EU_802298D0); + + gAudioBufferParameters.presetUnk4 = preset->unk1; + gAudioBufferParameters.samplesPerFrameTarget *= gAudioBufferParameters.presetUnk4; + gAudioBufferParameters.maxAiBufferLength *= gAudioBufferParameters.presetUnk4; + gAudioBufferParameters.minAiBufferLength *= gAudioBufferParameters.presetUnk4; + gAudioBufferParameters.updatesPerFrame *= gAudioBufferParameters.presetUnk4; + +#ifdef VERSION_SH + if (gAudioBufferParameters.presetUnk4 >= 2) { + gAudioBufferParameters.maxAiBufferLength -= 0x10; + } + gMaxAudioCmds = gMaxSimultaneousNotes * 0x14 * gAudioBufferParameters.updatesPerFrame + preset->numReverbs * 0x20 + 0x1E0; +#else + gMaxAudioCmds = gMaxSimultaneousNotes * 0x10 * gAudioBufferParameters.updatesPerFrame + preset->numReverbs * 0x20 + 0x300; +#endif +#else + reverbWindowSize = preset->reverbWindowSize; + gAiFrequency = osAiSetFrequency(preset->frequency); + gMaxSimultaneousNotes = preset->maxSimultaneousNotes; + gSamplesPerFrameTarget = ALIGN16(gAiFrequency / 60); + gReverbDownsampleRate = preset->reverbDownsampleRate; + + switch (gReverbDownsampleRate) { + case 1: + sReverbDownsampleRateLog = 0; + break; + case 2: + sReverbDownsampleRateLog = 1; + break; + case 4: + sReverbDownsampleRateLog = 2; + break; + case 8: + sReverbDownsampleRateLog = 3; + break; + case 16: + sReverbDownsampleRateLog = 4; + break; + default: + sReverbDownsampleRateLog = 0; + } + + gReverbDownsampleRate = preset->reverbDownsampleRate; + gVolume = preset->volume; + gMinAiBufferLength = gSamplesPerFrameTarget - 0x10; + updatesPerFrame = gSamplesPerFrameTarget / 160 + 1; + gAudioUpdatesPerFrame = gSamplesPerFrameTarget / 160 + 1; + + // Compute conversion ratio from the internal unit tatums/tick to the + // external beats/minute (JP) or tatums/minute (US). In practice this is + // 300 on JP and 14360 on US. +#ifdef VERSION_JP + gTempoInternalToExternal = updatesPerFrame * 3600 / gTatumsPerBeat; +#else + gTempoInternalToExternal = (u32)(updatesPerFrame * 2880000.0f / gTatumsPerBeat / 16.713f); +#endif + gMaxAudioCmds = gMaxSimultaneousNotes * 20 * updatesPerFrame + 320; +#endif + +#if defined(VERSION_SH) + persistentMem = DOUBLE_SIZE_ON_64_BIT(preset->persistentSeqMem + preset->persistentBankMem + preset->unk18 + preset->unkMem28 + 0x10); + temporaryMem = DOUBLE_SIZE_ON_64_BIT(preset->temporarySeqMem + preset->temporaryBankMem + preset->unk24 + preset->unkMem2C + 0x10); +#elif defined(VERSION_EU) + persistentMem = DOUBLE_SIZE_ON_64_BIT(preset->persistentSeqMem + preset->persistentBankMem); + temporaryMem = DOUBLE_SIZE_ON_64_BIT(preset->temporarySeqMem + preset->temporaryBankMem); +#else + persistentMem = DOUBLE_SIZE_ON_64_BIT(preset->persistentBankMem + preset->persistentSeqMem); + temporaryMem = DOUBLE_SIZE_ON_64_BIT(preset->temporaryBankMem + preset->temporarySeqMem); +#endif + totalMem = persistentMem + temporaryMem; + wantMisc = gAudioSessionPool.size - totalMem - 0x100; + sSessionPoolSplit.wantSeq = wantMisc; + sSessionPoolSplit.wantCustom = totalMem; + session_pools_init(&sSessionPoolSplit); + sSeqAndBankPoolSplit.wantPersistent = persistentMem; + sSeqAndBankPoolSplit.wantTemporary = temporaryMem; + seq_and_bank_pool_init(&sSeqAndBankPoolSplit); + sPersistentCommonPoolSplit.wantSeq = DOUBLE_SIZE_ON_64_BIT(preset->persistentSeqMem); + sPersistentCommonPoolSplit.wantBank = DOUBLE_SIZE_ON_64_BIT(preset->persistentBankMem); +#ifdef VERSION_SH + sPersistentCommonPoolSplit.wantUnused = preset->unk18; +#else + sPersistentCommonPoolSplit.wantUnused = 0; +#endif + persistent_pools_init(&sPersistentCommonPoolSplit); + sTemporaryCommonPoolSplit.wantSeq = DOUBLE_SIZE_ON_64_BIT(preset->temporarySeqMem); + sTemporaryCommonPoolSplit.wantBank = DOUBLE_SIZE_ON_64_BIT(preset->temporaryBankMem); +#ifdef VERSION_SH + sTemporaryCommonPoolSplit.wantUnused = preset->unk24; +#else + sTemporaryCommonPoolSplit.wantUnused = 0; +#endif + temporary_pools_init(&sTemporaryCommonPoolSplit); +#ifdef VERSION_SH + unk_pools_init(preset->unkMem28, preset->unkMem2C); +#endif + reset_bank_and_seq_load_status(); + +#if defined(VERSION_JP) || defined(VERSION_US) + for (j = 0; j < 2; j++) { + gAudioCmdBuffers[j] = soundAlloc(&gNotesAndBuffersPool, gMaxAudioCmds * sizeof(u64)); + } +#endif + + gNotes = soundAlloc(&gNotesAndBuffersPool, gMaxSimultaneousNotes * sizeof(struct Note)); + note_init_all(); + init_note_free_list(); + +#if defined(VERSION_EU) || defined(VERSION_SH) + gNoteSubsEu = soundAlloc(&gNotesAndBuffersPool, (gAudioBufferParameters.updatesPerFrame * gMaxSimultaneousNotes) * sizeof(struct NoteSubEu)); + + for (j = 0; j != 2; j++) { + gAudioCmdBuffers[j] = soundAlloc(&gNotesAndBuffersPool, gMaxAudioCmds * sizeof(u64)); + } + + for (j = 0; j < 4; j++) { + gSynthesisReverbs[j].useReverb = 0; + } + gNumSynthesisReverbs = preset->numReverbs; + for (j = 0; j < gNumSynthesisReverbs; j++) { + reverb = &gSynthesisReverbs[j]; + reverbSettings = &preset->reverbSettings[j]; +#ifdef VERSION_SH + reverb->downsampleRate = reverbSettings->downsampleRate; + reverb->windowSize = reverbSettings->windowSize * 64; + reverb->windowSize /= reverb->downsampleRate; +#else + reverb->windowSize = reverbSettings->windowSize * 64; + reverb->downsampleRate = reverbSettings->downsampleRate; +#endif + reverb->reverbGain = reverbSettings->gain; +#ifdef VERSION_SH + reverb->panRight = reverbSettings->unk4; + reverb->panLeft = reverbSettings->unk6; + reverb->unk5 = reverbSettings->unk8; + reverb->unk08 = reverbSettings->unkA; +#endif + reverb->useReverb = 8; + reverb->ringBuffer.left = soundAlloc(&gNotesAndBuffersPool, reverb->windowSize * 2); + reverb->ringBuffer.right = soundAlloc(&gNotesAndBuffersPool, reverb->windowSize * 2); + reverb->nextRingBufferPos = 0; + reverb->unkC = 0; + reverb->curFrame = 0; + reverb->bufSizePerChannel = reverb->windowSize; + reverb->framesLeftToIgnore = 2; +#ifdef VERSION_SH + reverb->resampleFlags = A_INIT; +#endif + if (reverb->downsampleRate != 1) { +#ifndef VERSION_SH + reverb->resampleFlags = A_INIT; +#endif + reverb->resampleRate = 0x8000 / reverb->downsampleRate; + reverb->resampleStateLeft = soundAlloc(&gNotesAndBuffersPool, 16 * sizeof(s16)); + reverb->resampleStateRight = soundAlloc(&gNotesAndBuffersPool, 16 * sizeof(s16)); + reverb->unk24 = soundAlloc(&gNotesAndBuffersPool, 16 * sizeof(s16)); + reverb->unk28 = soundAlloc(&gNotesAndBuffersPool, 16 * sizeof(s16)); + for (i = 0; i < gAudioBufferParameters.updatesPerFrame; i++) { + mem = soundAlloc(&gNotesAndBuffersPool, DEFAULT_LEN_2CH); + reverb->items[0][i].toDownsampleLeft = mem; + reverb->items[0][i].toDownsampleRight = mem + DEFAULT_LEN_1CH / sizeof(s16); + mem = soundAlloc(&gNotesAndBuffersPool, DEFAULT_LEN_2CH); + reverb->items[1][i].toDownsampleLeft = mem; + reverb->items[1][i].toDownsampleRight = mem + DEFAULT_LEN_1CH / sizeof(s16); + } + } +#ifdef VERSION_SH + if (reverbSettings->unkC != 0) { + reverb->unk108 = sound_alloc_uninitialized(&gNotesAndBuffersPool, 16 * sizeof(s16)); + reverb->unk100 = sound_alloc_uninitialized(&gNotesAndBuffersPool, 8 * sizeof(s16)); + func_sh_802F0DE8(reverb->unk100, reverbSettings->unkC); + } else { + reverb->unk100 = NULL; + } + if (reverbSettings->unkE != 0) { + reverb->unk10C = sound_alloc_uninitialized(&gNotesAndBuffersPool, 16 * sizeof(s16)); + reverb->unk104 = sound_alloc_uninitialized(&gNotesAndBuffersPool, 8 * sizeof(s16)); + func_sh_802F0DE8(reverb->unk104, reverbSettings->unkE); + } else { + reverb->unk104 = NULL; + } +#endif + } + +#else + if (reverbWindowSize == 0) { + gSynthesisReverb.useReverb = 0; + } else { + gSynthesisReverb.useReverb = 8; + gSynthesisReverb.ringBuffer.left = soundAlloc(&gNotesAndBuffersPool, reverbWindowSize * 2); + gSynthesisReverb.ringBuffer.right = soundAlloc(&gNotesAndBuffersPool, reverbWindowSize * 2); + gSynthesisReverb.nextRingBufferPos = 0; + gSynthesisReverb.unkC = 0; + gSynthesisReverb.curFrame = 0; + gSynthesisReverb.bufSizePerChannel = reverbWindowSize; + gSynthesisReverb.reverbGain = preset->reverbGain; + gSynthesisReverb.framesLeftToIgnore = 2; + if (gReverbDownsampleRate != 1) { + gSynthesisReverb.resampleFlags = A_INIT; + gSynthesisReverb.resampleRate = 0x8000 / gReverbDownsampleRate; + gSynthesisReverb.resampleStateLeft = soundAlloc(&gNotesAndBuffersPool, 16 * sizeof(s16)); + gSynthesisReverb.resampleStateRight = soundAlloc(&gNotesAndBuffersPool, 16 * sizeof(s16)); + gSynthesisReverb.unk24 = soundAlloc(&gNotesAndBuffersPool, 16 * sizeof(s16)); + gSynthesisReverb.unk28 = soundAlloc(&gNotesAndBuffersPool, 16 * sizeof(s16)); + for (i = 0; i < gAudioUpdatesPerFrame; i++) { + mem = soundAlloc(&gNotesAndBuffersPool, DEFAULT_LEN_2CH); + gSynthesisReverb.items[0][i].toDownsampleLeft = mem; + gSynthesisReverb.items[0][i].toDownsampleRight = mem + DEFAULT_LEN_1CH / sizeof(s16); + mem = soundAlloc(&gNotesAndBuffersPool, DEFAULT_LEN_2CH); + gSynthesisReverb.items[1][i].toDownsampleLeft = mem; + gSynthesisReverb.items[1][i].toDownsampleRight = mem + DEFAULT_LEN_1CH / sizeof(s16); + } + } + } +#endif + + init_sample_dma_buffers(gMaxSimultaneousNotes); + +#if defined(VERSION_EU) + build_vol_rampings_table(0, gAudioBufferParameters.samplesPerUpdate); +#endif + +#ifdef VERSION_SH + D_SH_8034F68C = 0; + D_SH_803479B4 = 4096; +#endif + + osWritebackDCacheAll(); + +#if defined(VERSION_JP) || defined(VERSION_US) + if (gAudioLoadLock != AUDIO_LOCK_UNINITIALIZED) { + gAudioLoadLock = AUDIO_LOCK_NOT_LOADING; + } +#endif +} + +#ifdef VERSION_SH +void *unk_pool1_lookup(s32 poolIdx, s32 id) { + s32 i; + + for (i = 0; i < gUnkPool1.pool.numAllocatedEntries; i++) { + if (gUnkPool1.entries[i].poolIndex == poolIdx && gUnkPool1.entries[i].id == id) { + return gUnkPool1.entries[i].ptr; + } + } + return NULL; +} + +void *unk_pool1_alloc(s32 poolIndex, s32 arg1, u32 size) { + void *ret; + s32 pos; + + pos = gUnkPool1.pool.numAllocatedEntries; + ret = sound_alloc_uninitialized(&gUnkPool1.pool, size); + gUnkPool1.entries[pos].ptr = ret; + if (ret == NULL) { + return NULL; + } + gUnkPool1.entries[pos].poolIndex = poolIndex; + gUnkPool1.entries[pos].id = arg1; + gUnkPool1.entries[pos].size = size; + +#ifdef AVOID_UB + //! @bug UB: missing return. "ret" is in v0 at this point, but doing an + // explicit return uses an additional register. + return ret; +#endif +} + +u8 *func_sh_802f1d40(u32 size, s32 bank, u8 *arg2, s8 medium) { + struct UnkEntry *ret; + + ret = func_sh_802f1ec4(size); + if (ret != NULL) { + ret->bankId = bank; + ret->dstAddr = arg2; + ret->medium = medium; + return ret->srcAddr; + } + return NULL; +} +u8 *func_sh_802f1d90(u32 size, s32 bank, u8 *arg2, s8 medium) { + struct UnkEntry *ret; + + ret = unk_pool2_alloc(size); + if (ret != NULL) { + ret->bankId = bank; + ret->dstAddr = arg2; + ret->medium = medium; + return ret->srcAddr; + } + return NULL; +} +u8 *func_sh_802f1de0(u32 size, s32 bank, u8 *arg2, s8 medium) { // duplicated function? + struct UnkEntry *ret; + + ret = unk_pool2_alloc(size); + if (ret != NULL) { + ret->bankId = bank; + ret->dstAddr = arg2; + ret->medium = medium; + return ret->srcAddr; + } + return NULL; +} +void unk_pools_init(u32 size1, u32 size2) { + void *mem; + + mem = sound_alloc_uninitialized(&gPersistentCommonPool, size1); + if (mem == NULL) { + gUnkPool2.pool.size = 0; + } else { + sound_alloc_pool_init(&gUnkPool2.pool, mem, size1); + } + mem = sound_alloc_uninitialized(&gTemporaryCommonPool, size2); + + if (mem == NULL) { + gUnkPool3.pool.size = 0; + } else { + sound_alloc_pool_init(&gUnkPool3.pool, mem, size2); + } + + gUnkPool2.numEntries = 0; + gUnkPool3.numEntries = 0; +} + +struct UnkEntry *func_sh_802f1ec4(u32 size) { + u8 *temp_s2; + u8 *phi_s3; + u8 *memLocation; + u8 *cur; + + s32 i; + s32 chosenIndex; + + struct UnkStructSH8034EC88 *unkStruct; + struct UnkPool *pool = &gUnkPool3; + + u8 *itemStart; + u8 *itemEnd; + + phi_s3 = pool->pool.cur; + memLocation = sound_alloc_uninitialized(&pool->pool, size); + if (memLocation == NULL) { + cur = pool->pool.cur; + pool->pool.cur = pool->pool.start; + memLocation = sound_alloc_uninitialized(&pool->pool, size); + if (memLocation == NULL) { + pool->pool.cur = cur; + return NULL; + } + phi_s3 = pool->pool.start; + } + temp_s2 = pool->pool.cur; + + chosenIndex = -1; + for (i = 0; i < D_SH_8034F68C; i++) { + unkStruct = &D_SH_8034EC88[i]; + if (unkStruct->isFree == FALSE) { + itemStart = unkStruct->ramAddr; + itemEnd = unkStruct->ramAddr + unkStruct->sample->size - 1; + if (itemEnd < phi_s3 && itemStart < phi_s3) { + continue; + + } + if (itemEnd >= temp_s2 && itemStart >= temp_s2) { + continue; + + } + + unkStruct->isFree = TRUE; + } + } + + for (i = 0; i < pool->numEntries; i++) { + if (pool->entries[i].used == FALSE) { + continue; + } + itemStart = pool->entries[i].srcAddr; + itemEnd = itemStart + pool->entries[i].size - 1; + + if (itemEnd < phi_s3 && itemStart < phi_s3) { + continue; + } + + if (itemEnd >= temp_s2 && itemStart >= temp_s2) { + continue; + } + + func_sh_802f2158(&pool->entries[i]); + if (chosenIndex == -1) { + chosenIndex = i; + } + } + + if (chosenIndex == -1) { + chosenIndex = pool->numEntries++; + } + pool->entries[chosenIndex].used = TRUE; + pool->entries[chosenIndex].srcAddr = memLocation; + pool->entries[chosenIndex].size = size; + + return &pool->entries[chosenIndex]; +} + +void func_sh_802f2158(struct UnkEntry *entry) { + s32 idx; + s32 seqCount; + s32 bankId1; + s32 bankId2; + s32 instId; + s32 drumId; + struct Drum *drum; + struct Instrument *inst; + + seqCount = gAlCtlHeader->seqCount; + for (idx = 0; idx < seqCount; idx++) { + bankId1 = gCtlEntries[idx].bankId1; + bankId2 = gCtlEntries[idx].bankId2; + if ((bankId1 != 0xff && entry->bankId == bankId1) || (bankId2 != 0xff && entry->bankId == bankId2) || entry->bankId == 0) { + if (get_bank_or_seq(1, 2, idx) != NULL) { + if (IS_BANK_LOAD_COMPLETE(idx) != FALSE) { + for (instId = 0; instId < gCtlEntries[idx].numInstruments; instId++) { + inst = get_instrument_inner(idx, instId); + if (inst != NULL) { + if (inst->normalRangeLo != 0) { + func_sh_802F2320(entry, inst->lowNotesSound.sample); + } + if (inst->normalRangeHi != 127) { + func_sh_802F2320(entry, inst->highNotesSound.sample); + } + func_sh_802F2320(entry, inst->normalNotesSound.sample); + } + } + for (drumId = 0; drumId < gCtlEntries[idx].numDrums; drumId++) { + drum = get_drum(idx, drumId); + if (drum != NULL) { + func_sh_802F2320(entry, drum->sound.sample); + } + } + } + } + } + } +} + +void func_sh_802F2320(struct UnkEntry *entry, struct AudioBankSample *sample) { + if (sample != NULL && sample->sampleAddr == entry->srcAddr) { + sample->sampleAddr = entry->dstAddr; + sample->medium = entry->medium; + } +} + +struct UnkEntry *unk_pool2_alloc(u32 size) { + void *data; + struct UnkEntry *ret; + s32 *numEntries = &gUnkPool2.numEntries; + + data = sound_alloc_uninitialized(&gUnkPool2.pool, size); + if (data == NULL) { + return NULL; + } + ret = &gUnkPool2.entries[*numEntries]; + ret->used = TRUE; + ret->srcAddr = data; + ret->size = size; + (*numEntries)++; + return ret; +} + +void func_sh_802f23ec(void) { + s32 i; + s32 idx; + s32 seqCount; + s32 bankId1; + s32 bankId2; + s32 instId; + s32 drumId; + struct Drum *drum; + struct Instrument *inst; + UNUSED s32 pad; + struct UnkEntry *entry; //! @bug: not initialized but nevertheless used + + seqCount = gAlCtlHeader->seqCount; + for (idx = 0; idx < seqCount; idx++) { + bankId1 = gCtlEntries[idx].bankId1; + bankId2 = gCtlEntries[idx].bankId2; + if ((bankId1 != 0xffu && entry->bankId == bankId1) || (bankId2 != 0xff && entry->bankId == bankId2) || entry->bankId == 0) { + if (get_bank_or_seq(1, 3, idx) != NULL) { + if (IS_BANK_LOAD_COMPLETE(idx) != FALSE) { + for (i = 0; i < gUnkPool2.numEntries; i++) { + entry = &gUnkPool2.entries[i]; + for (instId = 0; instId < gCtlEntries[idx].numInstruments; instId++) { + inst = get_instrument_inner(idx, instId); + if (inst != NULL) { + if (inst->normalRangeLo != 0) { + func_sh_802F2320(entry, inst->lowNotesSound.sample); + } + if (inst->normalRangeHi != 127) { + func_sh_802F2320(entry, inst->highNotesSound.sample); + } + func_sh_802F2320(entry, inst->normalNotesSound.sample); + } + } + for (drumId = 0; drumId < gCtlEntries[idx].numDrums; drumId++) { + drum = get_drum(idx, drumId); + if (drum != NULL) { + func_sh_802F2320(entry, drum->sound.sample); + } + } + } + } + } + } + } +} +#endif + +#ifdef VERSION_EU +u8 audioString22[] = "SFrame Sample %d %d %d\n"; +u8 audioString23[] = "AHPBASE %x\n"; +u8 audioString24[] = "AHPCUR %x\n"; +u8 audioString25[] = "HeapTop %x\n"; +u8 audioString26[] = "SynoutRate %d / %d \n"; +u8 audioString27[] = "FXSIZE %d\n"; +u8 audioString28[] = "FXCOMP %d\n"; +u8 audioString29[] = "FXDOWN %d\n"; +u8 audioString30[] = "WaveCacheLen: %d\n"; +u8 audioString31[] = "SpecChange Finished\n"; +#endif diff --git a/src/decomp/audio/heap.h b/src/decomp/audio/heap.h new file mode 100644 index 0000000..4bc73bd --- /dev/null +++ b/src/decomp/audio/heap.h @@ -0,0 +1,144 @@ +#ifndef AUDIO_HEAP_H +#define AUDIO_HEAP_H + +#include + +#include "internal.h" + +#define SOUND_LOAD_STATUS_NOT_LOADED 0 +#define SOUND_LOAD_STATUS_IN_PROGRESS 1 +#define SOUND_LOAD_STATUS_COMPLETE 2 +#define SOUND_LOAD_STATUS_DISCARDABLE 3 +#define SOUND_LOAD_STATUS_4 4 +#define SOUND_LOAD_STATUS_5 5 + +#define IS_BANK_LOAD_COMPLETE(bankId) (gBankLoadStatus[bankId] >= SOUND_LOAD_STATUS_COMPLETE) +#define IS_SEQ_LOAD_COMPLETE(seqId) (gSeqLoadStatus[seqId] >= SOUND_LOAD_STATUS_COMPLETE) + +struct SoundAllocPool +{ + u8 *start; + u8 *cur; + u32 size; + s32 numAllocatedEntries; +}; // size = 0x10 + +struct SeqOrBankEntry { + u8 *ptr; + u32 size; +#ifdef VERSION_SH + s16 poolIndex; + s16 id; +#else + s32 id; // seqId or bankId +#endif +}; // size = 0xC + +struct PersistentPool +{ + /*0x00*/ u32 numEntries; + /*0x04*/ struct SoundAllocPool pool; + /*0x14*/ struct SeqOrBankEntry entries[32]; +}; // size = 0x194 + +struct TemporaryPool +{ + /*EU, SH*/ + /*0x00, 0x00*/ u32 nextSide; + /*0x04, */ struct SoundAllocPool pool; + /*0x04, pool.start */ + /*0x08, pool.cur */ + /*0x0C, 0x0C pool.size */ + /*0x10, 0x10 pool.numAllocatedEntries */ + /*0x14, */ struct SeqOrBankEntry entries[2]; + /*0x14, 0x14 entries[0].ptr */ + /*0x18, entries[0].size*/ + /*0x1C, 0x1E entries[0].id */ + /*0x20, 0x20 entries[1].ptr */ + /*0x24, entries[1].size*/ + /*0x28, 0x2A entries[1].id */ +}; // size = 0x2C + +struct SoundMultiPool +{ + /*0x000*/ struct PersistentPool persistent; + /*0x194*/ struct TemporaryPool temporary; + /* */ u32 pad2[4]; +}; // size = 0x1D0 + +struct Unk1Pool +{ + struct SoundAllocPool pool; + struct SeqOrBankEntry entries[32]; +}; + +struct UnkEntry +{ + s8 used; + s8 medium; + s8 bankId; + u32 pad; + u8 *srcAddr; + u8 *dstAddr; + u32 size; +}; + +struct UnkPool +{ + /*0x00*/ struct SoundAllocPool pool; + /*0x10*/ struct UnkEntry entries[64]; + /*0x510*/ s32 numEntries; + /*0x514*/ u32 unk514; +}; + +extern u8 gAudioHeap[]; +extern s16 gVolume; +extern s8 gReverbDownsampleRate; +extern struct SoundAllocPool gAudioInitPool; +extern struct SoundAllocPool gNotesAndBuffersPool; +extern struct SoundAllocPool gPersistentCommonPool; +extern struct SoundAllocPool gTemporaryCommonPool; +extern struct SoundMultiPool gSeqLoadedPool; +extern struct SoundMultiPool gBankLoadedPool; +#ifdef VERSION_SH +extern struct Unk1Pool gUnkPool1; +extern struct UnkPool gUnkPool2; +extern struct UnkPool gUnkPool3; +#endif +extern u8 gBankLoadStatus[64]; +extern u8 gSeqLoadStatus[256]; +extern volatile u8 gAudioResetStatus; +extern u8 gAudioResetPresetIdToLoad; + +#if defined(VERSION_EU) || defined(VERSION_SH) +extern volatile u8 gAudioResetStatus; +#endif + +void *soundAlloc(struct SoundAllocPool *pool, u32 size); +void *sound_alloc_uninitialized(struct SoundAllocPool *pool, u32 size); +void sound_init_main_pools(s32 sizeForAudioInitPool); +void sound_alloc_pool_init(struct SoundAllocPool *pool, void *memAddr, u32 size); +#ifdef VERSION_SH +void *alloc_bank_or_seq(s32 poolIdx, s32 size, s32 arg3, s32 id); +void *get_bank_or_seq(s32 poolIdx, s32 arg1, s32 id); +#else +void *alloc_bank_or_seq(struct SoundMultiPool *arg0, s32 arg1, s32 size, s32 arg3, s32 id); +void *get_bank_or_seq(struct SoundMultiPool *arg0, s32 arg1, s32 id); +#endif +#if defined(VERSION_EU) || defined(VERSION_SH) +s32 audio_shut_down_and_reset_step(void); +void audio_reset_session(void); +#else +void audio_reset_session(struct AudioSessionSettings *preset); +#endif +void discard_bank(s32 bankId); + +#ifdef VERSION_SH +void fill_filter(s16 filter[8], s32 arg1, s32 arg2); +u8 *func_sh_802f1d40(u32 size, s32 bank, u8 *arg2, s8 medium); +u8 *func_sh_802f1d90(u32 size, s32 bank, u8 *arg2, s8 medium); +void *unk_pool1_lookup(s32 poolIdx, s32 id); +void *unk_pool1_alloc(s32 poolIndex, s32 arg1, u32 size); +#endif + +#endif // AUDIO_HEAP_H diff --git a/src/decomp/audio/internal.h b/src/decomp/audio/internal.h new file mode 100644 index 0000000..a3fc8f5 --- /dev/null +++ b/src/decomp/audio/internal.h @@ -0,0 +1,886 @@ +#ifndef AUDIO_INTERNAL_H +#define AUDIO_INTERNAL_H + +#include + +#include + +#if defined(VERSION_EU) || defined(VERSION_SH) +#define SEQUENCE_PLAYERS 4 +#define SEQUENCE_CHANNELS 48 +#define SEQUENCE_LAYERS 64 +#else +#define SEQUENCE_PLAYERS 3 +#define SEQUENCE_CHANNELS 32 +#ifdef VERSION_JP +#define SEQUENCE_LAYERS 48 +#else +#define SEQUENCE_LAYERS 52 +#endif +#endif + +#define LAYERS_MAX 4 +#define CHANNELS_MAX 16 + +#define NO_LAYER ((struct SequenceChannelLayer *)(-1)) + +#define MUTE_BEHAVIOR_STOP_SCRIPT 0x80 // stop processing sequence/channel scripts +#define MUTE_BEHAVIOR_STOP_NOTES 0x40 // prevent further notes from playing +#define MUTE_BEHAVIOR_SOFTEN 0x20 // lower volume, by default to half + +#define SEQUENCE_PLAYER_STATE_0 0 +#define SEQUENCE_PLAYER_STATE_FADE_OUT 1 +#define SEQUENCE_PLAYER_STATE_2 2 +#define SEQUENCE_PLAYER_STATE_3 3 +#define SEQUENCE_PLAYER_STATE_4 4 + +#define NOTE_PRIORITY_DISABLED 0 +#define NOTE_PRIORITY_STOPPING 1 +#define NOTE_PRIORITY_MIN 2 +#define NOTE_PRIORITY_DEFAULT 3 + +#define TATUMS_PER_BEAT 48 + +// abi.h contains more details about the ADPCM and S8 codecs, "skip" skips codec processing +#define CODEC_ADPCM 0 +#define CODEC_S8 1 +#define CODEC_SKIP 2 + +#ifdef VERSION_JP +#define TEMPO_SCALE 1 +#else +#define TEMPO_SCALE TATUMS_PER_BEAT +#endif + +// TODO: US_FLOAT should probably be renamed to JP_DOUBLE since eu seems to use floats too +#ifdef VERSION_JP +#define US_FLOAT(x) x +#else +#define US_FLOAT(x) x ## f +#endif + +// Convert u8 or u16 to f32. On JP, this uses a u32->f32 conversion, +// resulting in more bloated codegen, while on US it goes through s32. +// Since u8 and u16 fit losslessly in both, behavior is the same. +#ifdef VERSION_JP +#define FLOAT_CAST(x) (f32) (x) +#else +#define FLOAT_CAST(x) (f32) (s32) (x) +#endif + +// No-op printf macro which leaves string literals in rodata in IDO. IDO +// doesn't support variadic macros, so instead we let the parameter list +// expand to a no-op comma expression. Another possibility is that it might +// have expanded to something with "if (0)". See also goddard/gd_main.h. +// On US/JP, -sopt optimizes away these except for external.c. +#ifdef __sgi +#define stubbed_printf +#else +#define stubbed_printf(...) +#endif + +#ifdef VERSION_EU +#define eu_stubbed_printf_0(msg) stubbed_printf(msg) +#define eu_stubbed_printf_1(msg, a) stubbed_printf(msg, a) +#define eu_stubbed_printf_2(msg, a, b) stubbed_printf(msg, a, b) +#define eu_stubbed_printf_3(msg, a, b, c) stubbed_printf(msg, a, b, c) +#else +#define eu_stubbed_printf_0(msg) +#define eu_stubbed_printf_1(msg, a) +#define eu_stubbed_printf_2(msg, a, b) +#define eu_stubbed_printf_3(msg, a, b, c) +#endif + +struct NotePool; + +struct AudioListItem +{ + // A node in a circularly linked list. Each node is either a head or an item: + // - Items can be either detached (prev = NULL), or attached to a list. + // 'value' points to something of interest. + // - List heads are always attached; if a list is empty, its head points + // to itself. 'count' contains the size of the list. + // If the list holds notes, 'pool' points back to the pool where it lives. + // Otherwise, that member is NULL. + struct AudioListItem *prev; + struct AudioListItem *next; + union { + void *value; // either Note* or SequenceChannelLayer* + s32 count; + } u; + struct NotePool *pool; +}; // size = 0x10 + +struct NotePool +{ + struct AudioListItem disabled; + struct AudioListItem decaying; + struct AudioListItem releasing; + struct AudioListItem active; +}; + +struct VibratoState { + /*0x00, 0x00*/ struct SequenceChannel *seqChannel; + /*0x04, 0x04*/ u32 time; +#if defined(VERSION_EU) || defined(VERSION_SH) + /* , 0x08*/ s16 *curve; + /* , 0x0C*/ f32 extent; + /* , 0x10*/ f32 rate; + /* , 0x14*/ u8 active; +#else + /*0x08, */ s8 *curve; + /*0x0C, */ u8 active; + /*0x0E, */ u16 rate; + /*0x10, */ u16 extent; +#endif + /*0x12, 0x16*/ u16 rateChangeTimer; + /*0x14, 0x18*/ u16 extentChangeTimer; + /*0x16, 0x1A*/ u16 delay; +}; // size = 0x18, 0x1C on EU + +// Pitch sliding by up to one octave in the positive direction. Negative +// direction is "supported" by setting extent to be negative. The code +// extrapolates exponentially in the wrong direction in that case, but that +// doesn't prevent seqplayer from doing it, AFAICT. +struct Portamento { + u8 mode; // bit 0x80 denotes something; the rest are an index 0-5 + f32 cur; + f32 speed; + f32 extent; +}; // size = 0x10 + +struct AdsrEnvelope { + s16 delay; + s16 arg; +}; // size = 0x4 + +struct AdpcmLoop +{ + u32 start; + u32 end; + u32 count; + u32 pad; + s16 state[16]; // only exists if count != 0. 8-byte aligned +}; + +struct AdpcmBook +{ + s32 order; + s32 npredictors; + s16 book[1]; // size 8 * order * npredictors. 8-byte aligned +}; + +struct AudioBankSample +{ +#ifdef VERSION_SH +#if !IS_BIG_ENDIAN + u32 size : 24; +#endif + /* 0x00 */ u32 codec : 4; + /* 0x00 */ u32 medium : 2; + /* 0x00 */ u32 bit1 : 1; + /* 0x00 */ u32 isPatched : 1; +#if IS_BIG_ENDIAN + /* 0x01 */ u32 size : 24; +#endif +#else + u8 unused; + u8 loaded; +#endif + u8 *sampleAddr; + struct AdpcmLoop *loop; + struct AdpcmBook *book; +#ifndef VERSION_SH + u32 sampleSize; // never read. either 0 or 1 mod 9, depending on padding +#endif +}; + +struct AudioBankSound +{ + struct AudioBankSample *sample; + f32 tuning; // frequency scale factor +}; // size = 0x8 + +struct Instrument +{ + /*0x00*/ u8 loaded; + /*0x01*/ u8 normalRangeLo; + /*0x02*/ u8 normalRangeHi; + /*0x03*/ u8 releaseRate; + /*0x04*/ struct AdsrEnvelope *envelope; + /*0x08*/ struct AudioBankSound lowNotesSound; + /*0x10*/ struct AudioBankSound normalNotesSound; + /*0x18*/ struct AudioBankSound highNotesSound; +}; // size = 0x20 + +struct Drum +{ + u8 releaseRate; + u8 pan; + u8 loaded; + struct AudioBankSound sound; + struct AdsrEnvelope *envelope; +}; + +struct AudioBank +{ + struct Drum **drums; + struct Instrument *instruments[1]; +}; // dynamic size + +struct CtlEntry +{ +#ifndef VERSION_SH + u8 unused; +#endif + u8 numInstruments; + u8 numDrums; +#ifdef VERSION_SH + u8 bankId1; + u8 bankId2; +#endif + struct Instrument **instruments; + struct Drum **drums; +}; // size = 0xC + +struct M64ScriptState { + u8 *pc; + u8 *stack[4]; + u8 remLoopIters[4]; + u8 depth; +}; // size = 0x1C + +// Also known as a Group, according to debug strings. +struct SequencePlayer +{ + /*US/JP, EU, SH */ +#if defined(VERSION_EU) || defined(VERSION_SH) + /*0x000, 0x000, 0x000*/ u8 enabled : 1; +#else + /*0x000, 0x000*/ volatile u8 enabled : 1; +#endif + /*0x000, 0x000*/ u8 finished : 1; // never read + /*0x000, 0x000*/ u8 muted : 1; + /*0x000, 0x000*/ u8 seqDmaInProgress : 1; + /*0x000, 0x000*/ u8 bankDmaInProgress : 1; +#if defined(VERSION_EU) || defined(VERSION_SH) + /* 0x000*/ u8 recalculateVolume : 1; +#endif +#ifdef VERSION_SH + /* 0x000*/ u8 unkSh: 1; +#endif +#if defined(VERSION_JP) || defined(VERSION_US) + /*0x001 */ s8 seqVariation; +#endif + /*0x002, 0x001, 0x001*/ u8 state; + /*0x003, 0x002*/ u8 noteAllocPolicy; + /*0x004, 0x003*/ u8 muteBehavior; + /*0x005, 0x004*/ u8 seqId; + /*0x006, 0x005*/ u8 defaultBank[1]; // must be an array to get a comparison + // to match; other u8's might also be part of that array + /*0x007, 0x006*/ u8 loadingBankId; +#if defined(VERSION_JP) || defined(VERSION_US) + /*0x008, ?????*/ u8 loadingBankNumInstruments; + /*0x009, ?????*/ u8 loadingBankNumDrums; +#endif +#if defined(VERSION_EU) || defined(VERSION_SH) + /* , 0x007, 0x007*/ s8 seqVariationEu[1]; +#endif + /*0x00A, 0x008*/ u16 tempo; // beats per minute in JP, tatums per minute in US/EU + /*0x00C, 0x00A*/ u16 tempoAcc; +#if defined(VERSION_JP) || defined(VERSION_US) + /*0x00E, 0x010*/ u16 fadeRemainingFrames; +#endif +#ifdef VERSION_SH + /* 0x00C*/ s16 tempoAdd; +#endif + /*0x010, 0x00C, 0x00E*/ s16 transposition; + /*0x012, 0x00E, 0x010*/ u16 delay; +#if defined(VERSION_EU) || defined(VERSION_SH) + /*0x00E, 0x010, 0x012*/ u16 fadeRemainingFrames; + /* , 0x012, 0x014*/ u16 fadeTimerUnkEu; +#endif + /*0x014, 0x014*/ u8 *seqData; // buffer of some sort + /*0x018, 0x018, 0x1C*/ f32 fadeVolume; // set to 1.0f + /*0x01C, 0x01C*/ f32 fadeVelocity; // set to 0.0f + /*0x020, 0x020, 0x024*/ f32 volume; // set to 0.0f + /*0x024, 0x024*/ f32 muteVolumeScale; // set to 0.5f +#if defined(VERSION_EU) || defined(VERSION_SH) + /* , 0x028, 0x02C*/ f32 fadeVolumeScale; + /* , 0x02C*/ f32 appliedFadeVolume; +#else + /* */ u8 pad2[4]; +#endif + /*0x02C, 0x030, 0x034*/ struct SequenceChannel *channels[CHANNELS_MAX]; + /*0x06C, 0x070*/ struct M64ScriptState scriptState; + /*0x088, 0x08C*/ u8 *shortNoteVelocityTable; + /*0x08C, 0x090*/ u8 *shortNoteDurationTable; + /*0x090, 0x094*/ struct NotePool notePool; + /*0x0D0, 0x0D4*/ OSMesgQueue seqDmaMesgQueue; + /*0x0E8, 0x0EC*/ OSMesg seqDmaMesg; + /*0x0EC, 0x0F0*/ OSIoMesg seqDmaIoMesg; + /*0x100, 0x108*/ OSMesgQueue bankDmaMesgQueue; + /*0x118, 0x120*/ OSMesg bankDmaMesg; + /*0x11C, 0x124*/ OSIoMesg bankDmaIoMesg; + /*0x130, 0x13C*/ u8 *bankDmaCurrMemAddr; +#if defined(VERSION_JP) || defined(VERSION_US) + /*0x134, ?????*/ struct AudioBank *loadingBank; +#endif + /*0x138, 0x140*/ uintptr_t bankDmaCurrDevAddr; + /*0x13C, 0x144*/ ssize_t bankDmaRemaining; +}; // size = 0x140, 0x148 on EU, 0x14C on SH + +struct AdsrSettings +{ + u8 releaseRate; +#if defined(VERSION_EU) || defined(VERSION_SH) + u8 sustain; +#else + u16 sustain; // sustain level, 2^16 = max +#endif + struct AdsrEnvelope *envelope; +}; // size = 0x8 + +struct AdsrState { + /*0x00, 0x00*/ u8 action; + /*0x01, 0x01*/ u8 state; +#if defined(VERSION_JP) || defined(VERSION_US) + /*0x02, */ s16 initial; // always 0 + /*0x04, */ s16 target; + /*0x06, */ s16 current; +#endif + /*0x08, 0x02*/ s16 envIndex; + /*0x0A, 0x04*/ s16 delay; +#if defined(VERSION_EU) || defined(VERSION_SH) + /* , 0x08*/ f32 sustain; + /* , 0x0C*/ f32 velocity; + /* , 0x10*/ f32 fadeOutVel; + /* , 0x14*/ f32 current; + /* , 0x18*/ f32 target; + s32 pad1C; +#else + /*0x0C, */ s16 sustain; + /*0x0E, */ s16 fadeOutVel; + /*0x10, */ s32 velocity; + /*0x14, */ s32 currentHiRes; + /*0x18, */ s16 *volOut; +#endif + /*0x1C, 0x20*/ struct AdsrEnvelope *envelope; +}; // size = 0x20, 0x24 in EU + +struct ReverbBitsData { + /* 0x00 */ u8 bit0 : 1; + /* 0x00 */ u8 bit1 : 1; + /* 0x00 */ u8 bit2 : 1; + /* 0x00 */ u8 usesHeadsetPanEffects : 1; + /* 0x00 */ u8 stereoHeadsetEffects : 2; + /* 0x00 */ u8 strongRight : 1; + /* 0x00 */ u8 strongLeft : 1; +}; + +union ReverbBits { + /* 0x00 */ struct ReverbBitsData s; + /* 0x00 */ u8 asByte; +}; +struct ReverbInfo { + u8 reverbVol; + u8 synthesisVolume; // UQ4.4, although 0 <= x < 1 is rounded up to 1 + u8 pan; + union ReverbBits reverbBits; + f32 freqScale; + f32 velocity; + s32 unused; + s16 *filter; +}; + +struct NoteAttributes +{ + u8 reverbVol; +#ifdef VERSION_SH + u8 synthesisVolume; // UQ4.4, although 0 <= x < 1 is rounded up to 1 +#endif +#if defined(VERSION_EU) || defined(VERSION_SH) + u8 pan; +#endif +#ifdef VERSION_SH + union ReverbBits reverbBits; +#endif + f32 freqScale; + f32 velocity; +#if defined(VERSION_JP) || defined(VERSION_US) + f32 pan; +#endif +#ifdef VERSION_SH + s16 *filter; +#endif +}; // size = 0x10 + +// Also known as a SubTrack, according to debug strings. +// Confusingly, a SubTrack is a container of Tracks. +struct SequenceChannel +{ + /* U/J, EU, SH */ + /*0x00, 0x00*/ u8 enabled : 1; + /*0x00, 0x00*/ u8 finished : 1; + /*0x00, 0x00*/ u8 stopScript : 1; + /*0x00, 0x00*/ u8 stopSomething2 : 1; // sets SequenceChannelLayer.stopSomething + /*0x00, 0x00*/ u8 hasInstrument : 1; + /*0x00, 0x00*/ u8 stereoHeadsetEffects : 1; + /*0x00, ????*/ u8 largeNotes : 1; // notes specify duration and velocity + /*0x00, ????*/ u8 unused : 1; // never read, set to 0 +#if defined(VERSION_EU) || defined(VERSION_SH) + /* , 0x01*/ union { + struct { + u8 freqScale : 1; + u8 volume : 1; + u8 pan : 1; + } as_bitfields; + u8 as_u8; + } changes; +#endif + /*0x01, 0x02*/ u8 noteAllocPolicy; + /*0x02, 0x03, 0x03*/ u8 muteBehavior; + /*0x03, 0x04, 0x04*/ u8 reverbVol; // until EU: Q1.7, after EU: UQ0.8 + /*0x04, ????*/ u8 notePriority; // 0-3 +#ifdef VERSION_SH + u8 unkSH06; // some priority +#endif + /*0x05, 0x06*/ u8 bankId; +#if defined(VERSION_EU) || defined(VERSION_SH) + /* , 0x07*/ u8 reverbIndex; + /* , 0x08, 0x09*/ u8 bookOffset; + /* , 0x09*/ u8 newPan; + /* , 0x0A*/ u8 panChannelWeight; // proportion of pan that comes from the channel (0..128) +#else + /*0x06, */ u8 updatesPerFrameUnused; +#endif +#ifdef VERSION_SH + /* 0x0C*/ u8 synthesisVolume; // UQ4.4, although 0 <= x < 1 is rounded up to 1 +#endif + /*0x08, 0x0C, 0x0E*/ u16 vibratoRateStart; // initially 0x800 + /*0x0A, 0x0E, 0x10*/ u16 vibratoExtentStart; + /*0x0C, 0x10, 0x12*/ u16 vibratoRateTarget; // initially 0x800 + /*0x0E, 0x12, 0x14*/ u16 vibratoExtentTarget; + /*0x10, 0x14, 0x16*/ u16 vibratoRateChangeDelay; + /*0x12, 0x16, 0x18*/ u16 vibratoExtentChangeDelay; + /*0x14, 0x18, 0x1A*/ u16 vibratoDelay; + /*0x16, 0x1A, 0x1C*/ u16 delay; + /*0x18, 0x1C, 0x1E*/ s16 instOrWave; // either 0 (none), instrument index + 1, or + // 0x80..0x83 for sawtooth/triangle/sine/square waves. + /*0x1A, 0x1E, 0x20*/ s16 transposition; + /*0x1C, 0x20, 0x24*/ f32 volumeScale; + /*0x20, 0x24, 0x28*/ f32 volume; +#if defined(VERSION_JP) || defined(VERSION_US) + /*0x24, */ f32 pan; + /*0x28, */ f32 panChannelWeight; // proportion of pan that comes from the channel (0..1) +#else + /* , 0x28*/ s32 pan; + /* , 0x2C*/ f32 appliedVolume; +#endif + /*0x2C, 0x30*/ f32 freqScale; + /*0x30, 0x34*/ u8 (*dynTable)[][2]; + /*0x34, ????*/ struct Note *noteUnused; // never read + /*0x38, ????*/ struct SequenceChannelLayer *layerUnused; // never read + /*0x3C, 0x40*/ struct Instrument *instrument; + /*0x40, 0x44*/ struct SequencePlayer *seqPlayer; + /*0x44, 0x48*/ struct SequenceChannelLayer *layers[LAYERS_MAX]; +#ifndef VERSION_SH + /*0x54, 0x58 */ s8 soundScriptIO[8]; // bridge between sound script and audio lib. For player 2, + // [0] contains enabled, [4] contains sound ID, [5] contains reverb adjustment +#endif + /*0x5C, 0x60*/ struct M64ScriptState scriptState; + /*0x78, 0x7C*/ struct AdsrSettings adsr; + /*0x80, 0x84*/ struct NotePool notePool; +#ifdef VERSION_SH + /* 0xC0*/ s8 soundScriptIO[8]; // bridge between sound script and audio lib. For player 2, + // [0] contains enabled, [4] contains sound ID, [5] contains reverb adjustment + /* 0xC8*/ u16 unkC8; + /* 0xCC*/ s16 *filter; +#endif +}; // size = 0xC0, 0xC4 in EU, 0xD0 in SH + +// Also known as a Track, according to debug strings. +struct SequenceChannelLayer +{ + /* U/J, EU, SH */ + /*0x00, 0x00*/ u8 enabled : 1; + /*0x00, 0x00*/ u8 finished : 1; + /*0x00, 0x00*/ u8 stopSomething : 1; // ? + /*0x00, 0x00*/ u8 continuousNotes : 1; // keep the same note for consecutive notes with the same sound +#if defined(VERSION_EU) || defined(VERSION_SH) + /* , 0x00*/ u8 unusedEu0b8 : 1; + /* , 0x00*/ u8 notePropertiesNeedInit : 1; + /* , 0x00*/ u8 ignoreDrumPan : 1; +#ifdef VERSION_SH + /* , , 0x01 */ union ReverbBits reverbBits; +#endif + /* , 0x01, 0x02*/ u8 instOrWave; +#endif + /*0x01, 0x02, 0x03*/ u8 status; // 0x03 in SH + /*0x02, 0x03*/ u8 noteDuration; // set to 0x80 + /*0x03, 0x04*/ u8 portamentoTargetNote; +#if defined(VERSION_EU) || defined(VERSION_SH) + /* , 0x05*/ u8 pan; // 0..128 + /* , 0x06, 0x07*/ u8 notePan; +#endif + /*0x04, 0x08*/ struct Portamento portamento; + /*0x14, 0x18*/ struct AdsrSettings adsr; + /*0x1C, 0x20*/ u16 portamentoTime; + /*0x1E, 0x22*/ s16 transposition; // #semitones added to play commands + // (m64 instruction encoding only allows referring to the limited range + // 0..0x3f; this makes 0x40..0x7f accessible as well) + /*0x20, 0x24, 0x24*/ f32 freqScale; +#ifdef VERSION_SH + /* 0x28*/ f32 freqScaleMultiplier; +#endif + /*0x24, 0x28, 0x2C*/ f32 velocitySquare; +#if defined(VERSION_JP) || defined(VERSION_US) + /*0x28, */ f32 pan; // 0..1 +#endif + /*0x2C, 0x2C, 0x30*/ f32 noteVelocity; +#if defined(VERSION_JP) || defined(VERSION_US) + /*0x30*/ f32 notePan; +#endif + /*0x34, 0x30, 0x34*/ f32 noteFreqScale; + /*0x38, 0x34*/ s16 shortNoteDefaultPlayPercentage; + /*0x3A, 0x36*/ s16 playPercentage; // it's not really a percentage... + /*0x3C, 0x38*/ s16 delay; + /*0x3E, 0x3A*/ s16 duration; + /*0x40, 0x3C*/ s16 delayUnused; // set to 'delay', never read + /*0x44, 0x40, 0x44*/ struct Note *note; + /*0x48, 0x44*/ struct Instrument *instrument; + /*0x4C, 0x48*/ struct AudioBankSound *sound; + /*0x50, 0x4C, 0x50*/ struct SequenceChannel *seqChannel; + /*0x54, 0x50*/ struct M64ScriptState scriptState; + /*0x70, 0x6C*/ struct AudioListItem listItem; +#if defined(VERSION_EU) + u8 pad2[4]; +#endif +}; // size = 0x80 + +#if defined(VERSION_EU) || defined(VERSION_SH) +struct NoteSynthesisState +{ + /*0x00*/ u8 restart; + /*0x01*/ u8 sampleDmaIndex; + /*0x02*/ u8 prevHeadsetPanRight; + /*0x03*/ u8 prevHeadsetPanLeft; +#ifdef VERSION_SH + /* 0x04*/ u8 reverbVol; + /* 0x05*/ u8 unk5; +#endif + /*0x04, 0x06*/ u16 samplePosFrac; + /*0x08*/ s32 samplePosInt; + /*0x0C*/ struct NoteSynthesisBuffers *synthesisBuffers; + /*0x10*/ s16 curVolLeft; // UQ0.16 (EU Q1.15) + /*0x12*/ s16 curVolRight; // UQ0.16 (EU Q1.15) +}; +struct NotePlaybackState +{ + /* U/J, EU, SH */ + /*0x04, 0x00, 0x00*/ u8 priority; + /* 0x01, 0x01*/ u8 waveId; + /* 0x02, 0x02*/ u8 sampleCountIndex; +#ifdef VERSION_SH + /* 0x03*/ u8 bankId; + /* 0x04*/ u8 unkSH34; +#endif + /*0x08, 0x04, 0x06*/ s16 adsrVolScale; + /*0x18, 0x08, 0x08*/ f32 portamentoFreqScale; + /*0x1C, 0x0C, 0x0C*/ f32 vibratoFreqScale; + /*0x28, 0x10, */ struct SequenceChannelLayer *prevParentLayer; + /*0x2C, 0x14, 0x14*/ struct SequenceChannelLayer *parentLayer; + /*0x30, 0x18, 0x18*/ struct SequenceChannelLayer *wantedParentLayer; + /* , 0x1C, 0x1C*/ struct NoteAttributes attributes; + /*0x54, 0x28, 0x2C*/ struct AdsrState adsr; + /*0x74, 0x4C, */ struct Portamento portamento; + /*0x84, 0x5C, */ struct VibratoState vibratoState; +}; +struct NoteSubEu +{ + /*0x00*/ volatile u8 enabled : 1; + /*0x00*/ u8 needsInit : 1; + /*0x00*/ u8 finished : 1; + /*0x00*/ u8 envMixerNeedsInit : 1; + /*0x00*/ u8 stereoStrongRight : 1; + /*0x00*/ u8 stereoStrongLeft : 1; + /*0x00*/ u8 stereoHeadsetEffects : 1; + /*0x00*/ u8 usesHeadsetPanEffects : 1; + /*0x01*/ u8 reverbIndex : 3; + /*0x01*/ u8 bookOffset : 3; + /*0x01*/ u8 isSyntheticWave : 1; + /*0x01*/ u8 hasTwoAdpcmParts : 1; +#ifdef VERSION_EU + /*0x02*/ u8 bankId; +#else + /*0x02*/ u8 synthesisVolume; // UQ4.4, although 0 <= x < 1 is rounded up to 1 +#endif + /*0x03*/ u8 headsetPanRight; + /*0x04*/ u8 headsetPanLeft; + /*0x05*/ u8 reverbVol; // UQ0.7 (EU Q1.7) + /*0x06*/ u16 targetVolLeft; // UQ0.12 (EU UQ0.10) + /*0x08*/ u16 targetVolRight; // UQ0.12 (EU UQ0.10) + /*0x0A*/ u16 resamplingRateFixedPoint; // stored as signed but loaded as u16 + /*0x0C*/ union { + s16 *samples; + struct AudioBankSound *audioBankSound; + } sound; +#ifdef VERSION_SH + /*0x10*/ s16 *filter; +#endif +}; +struct Note +{ + /* U/J, EU, SH */ + /*0xA4, 0x00, 0x00*/ struct AudioListItem listItem; + /* 0x10, 0x10*/ struct NoteSynthesisState synthesisState; + // The next members are actually part of a struct (NotePlaybackState), but + // that results in messy US/EU ifdefs. Instead we cast to a struct pointer + // when needed... This breaks alignment on non-N64 platforms, which we hack + // around by skipping the padding in that case. + // TODO: use macros or something instead. +#ifdef TARGET_N64 + u8 pad0[12]; +#endif + + /*0x04, 0x30, 0x30*/ u8 priority; + /* 0x31, 0x31*/ u8 waveId; + /* 0x32, 0x32*/ u8 sampleCountIndex; +#ifdef VERSION_SH + /* 0x33*/ u8 bankId; + /* 0x34*/ u8 unkSH34; +#endif + /*0x08, 0x34, 0x36*/ s16 adsrVolScale; + /*0x18, 0x38, */ f32 portamentoFreqScale; + /*0x1C, 0x3C, */ f32 vibratoFreqScale; + /*0x28, 0x40, */ struct SequenceChannelLayer *prevParentLayer; + /*0x2C, 0x44, 0x44*/ struct SequenceChannelLayer *parentLayer; + /*0x30, 0x48, 0x48*/ struct SequenceChannelLayer *wantedParentLayer; + /* , 0x4C, 0x4C*/ struct NoteAttributes attributes; + /*0x54, 0x58, 0x5C*/ struct AdsrState adsr; + /*0x74, 0x7C*/ struct Portamento portamento; + /*0x84, 0x8C*/ struct VibratoState vibratoState; + u8 pad3[8]; + /* , 0xB0, 0xB4*/ struct NoteSubEu noteSubEu; +}; // size = 0xC0, known to be 0xC8 on SH +#else +// volatile Note, needed in synthesis_process_notes +struct vNote +{ + /* U/J, EU */ + /*0x00*/ volatile u8 enabled : 1; + long long int force_structure_alignment; +}; // size = 0xC0 +struct Note +{ + /* U/J, EU */ + /*0x00*/ u8 enabled : 1; + /*0x00*/ u8 needsInit : 1; + /*0x00*/ u8 restart : 1; + /*0x00*/ u8 finished : 1; + /*0x00*/ u8 envMixerNeedsInit : 1; + /*0x00*/ u8 stereoStrongRight : 1; + /*0x00*/ u8 stereoStrongLeft : 1; + /*0x00*/ u8 stereoHeadsetEffects : 1; + /*0x01*/ u8 usesHeadsetPanEffects; + /*0x02*/ u8 unk2; + /*0x03*/ u8 sampleDmaIndex; + /*0x04, 0x30*/ u8 priority; + /*0x05*/ u8 sampleCount; // 0, 8, 16, 32 or 64 + /*0x06*/ u8 instOrWave; + /*0x07*/ u8 bankId; // in NoteSubEu on EU + /*0x08*/ s16 adsrVolScale; + /* */ u8 pad1[2]; + /*0x0C, 0xB3*/ u16 headsetPanRight; + /*0x0E, 0xB4*/ u16 headsetPanLeft; + /*0x10*/ u16 prevHeadsetPanRight; + /*0x12*/ u16 prevHeadsetPanLeft; + /*0x14*/ s32 samplePosInt; + /*0x18, 0x38*/ f32 portamentoFreqScale; + /*0x1C, 0x3C*/ f32 vibratoFreqScale; + /*0x20*/ u16 samplePosFrac; + /*0x24*/ struct AudioBankSound *sound; + /*0x28, 0x40*/ struct SequenceChannelLayer *prevParentLayer; + /*0x2C, 0x44*/ struct SequenceChannelLayer *parentLayer; + /*0x30, 0x48*/ struct SequenceChannelLayer *wantedParentLayer; + /*0x34*/ struct NoteSynthesisBuffers *synthesisBuffers; + /*0x38*/ f32 frequency; + /*0x3C*/ u16 targetVolLeft; // Q1.15, but will always be non-negative + /*0x3E*/ u16 targetVolRight; // Q1.15, but will always be non-negative + /*0x40*/ u8 reverbVol; // Q1.7 + /*0x41*/ u8 unused1; // never read, set to 0x3f + /*0x44*/ struct NoteAttributes attributes; + /*0x54, 0x58*/ struct AdsrState adsr; + /*0x74, 0x7C*/ struct Portamento portamento; + /*0x84, 0x8C*/ struct VibratoState vibratoState; + /*0x9C*/ s16 curVolLeft; // Q1.15, but will always be non-negative + /*0x9E*/ s16 curVolRight; // Q1.15, but will always be non-negative + /*0xA0*/ s16 reverbVolShifted; // Q1.15 + /*0xA2*/ s16 unused2; // never read, set to 0 + /*0xA4, 0x00*/ struct AudioListItem listItem; + /* */ u8 pad2[0xc]; +}; // size = 0xC0 +#endif + +struct NoteSynthesisBuffers +{ + s16 adpcmdecState[0x10]; + s16 finalResampleState[0x10]; +#ifdef VERSION_SH + s16 unk[0x10]; + s16 filterBuffer[0x20]; + s16 panSamplesBuffer[0x20]; +#else + s16 mixEnvelopeState[0x28]; + s16 panResampleState[0x10]; + s16 panSamplesBuffer[0x20]; + s16 dummyResampleState[0x10]; +#if defined(VERSION_JP) || defined(VERSION_US) + s16 samples[0x40]; +#endif +#endif +}; + +#ifdef VERSION_EU +struct ReverbSettingsEU +{ + u8 downsampleRate; + u8 windowSize; // To be multiplied by 64 + u16 gain; +}; +#else +struct ReverbSettingsEU +{ + u8 downsampleRate; // always 1 + u8 windowSize; // To be multiplied by 16 + u16 gain; + u16 unk4; // always zero + u16 unk6; // always zero + s8 unk8; // always -1 + u16 unkA; // always 0x3000 + s16 unkC; // always zero + s16 unkE; // always zero +}; +#endif + +struct AudioSessionSettingsEU +{ + /* 0x00 */ u32 frequency; + /* 0x04 */ u8 unk1; // always 1 + /* 0x05 */ u8 maxSimultaneousNotes; + /* 0x06 */ u8 numReverbs; // always 1 + /* 0x07 */ u8 unk2; // always 0 + /* 0x08 */ struct ReverbSettingsEU *reverbSettings; + /* 0x0C */ u16 volume; + /* 0x0E */ u16 unk3; // always 0 + /* 0x10 */ u32 persistentSeqMem; + /* 0x14 */ u32 persistentBankMem; +#ifdef VERSION_SH + /* 0x18 */ u32 unk18; // always 0 +#endif + /* 0x18, 0x1C */ u32 temporarySeqMem; + /* 0x1C, 0x20 */ u32 temporaryBankMem; +#ifdef VERSION_SH + /* 0x24 */ u32 unk24; // always 0 + /* 0x28 */ u32 unkMem28; // always 0 + /* 0x2C */ u32 unkMem2C; // always 0 +#endif +}; // 0x30 on shindou + +struct AudioSessionSettings +{ + /*0x00*/ u32 frequency; + /*0x04*/ u8 maxSimultaneousNotes; + /*0x05*/ u8 reverbDownsampleRate; // always 1 + /*0x06*/ u16 reverbWindowSize; + /*0x08*/ u16 reverbGain; + /*0x0A*/ u16 volume; + /*0x0C*/ u32 persistentSeqMem; + /*0x10*/ u32 persistentBankMem; + /*0x14*/ u32 temporarySeqMem; + /*0x18*/ u32 temporaryBankMem; +}; // size = 0x1C + +struct AudioBufferParametersEU { + /*0x00*/ s16 presetUnk4; // audio frames per vsync? + /*0x02*/ u16 frequency; + /*0x04*/ u16 aiFrequency; // ?16 + /*0x06*/ s16 samplesPerFrameTarget; + /*0x08*/ s16 maxAiBufferLength; + /*0x0A*/ s16 minAiBufferLength; + /*0x0C*/ s16 updatesPerFrame; + /*0x0E*/ s16 samplesPerUpdate; + /*0x10*/ s16 samplesPerUpdateMax; + /*0x12*/ s16 samplesPerUpdateMin; + /*0x14*/ f32 resampleRate; // contains 32000.0f / frequency + /*0x18*/ f32 updatesPerFrameInv; // 1.0f / updatesPerFrame + /*0x1C*/ f32 unkUpdatesPerFrameScaled; // 3.0f / (1280.0f * updatesPerFrame) +}; + +struct EuAudioCmd { + union { +#if IS_BIG_ENDIAN + struct { + u8 op; + u8 arg1; + u8 arg2; + u8 arg3; + } s; +#else + struct { + u8 arg3; + u8 arg2; + u8 arg1; + u8 op; + } s; +#endif + s32 first; + } u; + union { + s32 as_s32; + u32 as_u32; + f32 as_f32; +#if IS_BIG_ENDIAN + u8 as_u8; + s8 as_s8; +#else + struct { + u8 pad0[3]; + u8 as_u8; + }; + struct { + u8 pad1[3]; + s8 as_s8; + }; +#endif + } u2; +}; + +#ifdef VERSION_SH +struct PendingDmaSample { + u8 medium; + u8 bankId; + u8 idx; + uintptr_t devAddr; + void *vAddr; + u8 *resultSampleAddr; + s32 state; + s32 remaining; + s8 *io; + /*0x1C*/ struct AudioBankSample sample; + /*0x2C*/ OSMesgQueue queue; + /*0x44*/ OSMesg mesgs[1]; + /*0x48*/ OSIoMesg ioMesg; +}; + +struct UnkStruct80343D00 { + u32 someIndex; // array into one of the two slots below + struct PendingDmaSample arr[2]; +}; + +// in external.c +extern s32 D_SH_80343CF0; +extern struct UnkStruct80343D00 D_SH_80343D00; +#endif + +#endif // AUDIO_INTERNAL_H diff --git a/src/decomp/audio/load.c b/src/decomp/audio/load.c new file mode 100644 index 0000000..1aa3053 --- /dev/null +++ b/src/decomp/audio/load.c @@ -0,0 +1,1074 @@ +#ifndef VERSION_SH +#include + +#include "data.h" +#include "external.h" +#include "heap.h" +#include "load.h" +#include "seqplayer.h" +#include "load_dat.h" + +#define ALIGN16(val) (((val) + 0xF) & ~0xF) + +struct SharedDma { + /*0x0*/ u8 *buffer; // target, points to pre-allocated buffer + /*0x4*/ uintptr_t source; // device address + /*0x8*/ u16 sizeUnused; // set to bufSize, never read + /*0xA*/ u16 bufSize; // size of buffer + /*0xC*/ u8 unused2; // set to 0, never read + /*0xD*/ u8 reuseIndex; // position in sSampleDmaReuseQueue1/2, if ttl == 0 + /*0xE*/ u8 ttl; // duration after which the DMA can be discarded +}; // size = 0x10 + +// EU only +void port_eu_init(void); + +struct Note *gNotes; + +#if defined(VERSION_EU) +UNUSED static u8 pad[4]; +#endif + +struct SequencePlayer gSequencePlayers[SEQUENCE_PLAYERS]; +struct SequenceChannel gSequenceChannels[SEQUENCE_CHANNELS]; +struct SequenceChannelLayer gSequenceLayers[SEQUENCE_LAYERS]; + +struct SequenceChannel gSequenceChannelNone; +struct AudioListItem gLayerFreeList; +struct NotePool gNoteFreeLists; + +OSMesgQueue gCurrAudioFrameDmaQueue; +OSMesg gCurrAudioFrameDmaMesgBufs[AUDIO_FRAME_DMA_QUEUE_SIZE]; +OSIoMesg gCurrAudioFrameDmaIoMesgBufs[AUDIO_FRAME_DMA_QUEUE_SIZE]; + +OSMesgQueue gAudioDmaMesgQueue; +OSMesg gAudioDmaMesg; +OSIoMesg gAudioDmaIoMesg; + +struct SharedDma sSampleDmas[0x60]; +u32 gSampleDmaNumListItems; // sh: 0x803503D4 +u32 sSampleDmaListSize1; // sh: 0x803503D8 +u32 sUnused80226B40; // set to 0, never read, sh: 0x803503DC + +// Circular buffer of DMAs with ttl = 0. tail <= head, wrapping around mod 256. +u8 sSampleDmaReuseQueue1[256]; +u8 sSampleDmaReuseQueue2[256]; +u8 sSampleDmaReuseQueueTail1; +u8 sSampleDmaReuseQueueTail2; +u8 sSampleDmaReuseQueueHead1; // sh: 0x803505E2 +u8 sSampleDmaReuseQueueHead2; // sh: 0x803505E3 + +// bss correct up to here + +ALSeqFile *gSeqFileHeader; +ALSeqFile *gAlCtlHeader; +ALSeqFile *gAlTbl; +u8 *gAlBankSets; +u16 gSequenceCount; + +struct CtlEntry *gCtlEntries; // sh: 0x803505F8 + +#if defined(VERSION_EU) +u32 padEuBss1; +struct AudioBufferParametersEU gAudioBufferParameters; +#elif defined(VERSION_US) || defined(VERSION_JP) +s32 gAiFrequency; +#endif + +u32 sDmaBufSize; +s32 gMaxAudioCmds; +s32 gMaxSimultaneousNotes; + +#if defined(VERSION_EU) +s16 gTempoInternalToExternal; +#else +s32 gSamplesPerFrameTarget; +s32 gMinAiBufferLength; + +s16 gTempoInternalToExternal; + +s8 gAudioUpdatesPerFrame; +#endif + +s8 gSoundMode; + +#if defined(VERSION_EU) +s8 gAudioUpdatesPerFrame; +#endif + +extern u64 gAudioGlobalsStartMarker; +extern u64 gAudioGlobalsEndMarker; + +extern u8* gSoundDataADSR; // sound_data.ctl +extern u8* gSoundDataRaw; // sound_data.tbl +extern u8* gMusicData; // sequences.s +extern u8* gBankSetsData; // bank_sets.s + +ALSeqFile *get_audio_file_header(s32 arg0); + +/** + * Performs an immediate DMA copy + */ +void audio_dma_copy_immediate(uintptr_t devAddr, void *vAddr, size_t nbytes) { + eu_stubbed_printf_3("Romcopy %x -> %x ,size %x\n", devAddr, vAddr, nbytes); + osInvalDCache(vAddr, nbytes); + osPiStartDma(&gAudioDmaIoMesg, OS_MESG_PRI_HIGH, OS_READ, devAddr, vAddr, nbytes, + &gAudioDmaMesgQueue); + osRecvMesg(&gAudioDmaMesgQueue, NULL, OS_MESG_BLOCK); + eu_stubbed_printf_0("Romcopyend\n"); +} + +#ifdef VERSION_EU +u8 audioString34[] = "CAUTION:WAVE CACHE FULL %d"; +u8 audioString35[] = "BASE %x %x\n"; +u8 audioString36[] = "LOAD %x %x %x\n"; +u8 audioString37[] = "INSTTOP %x\n"; +u8 audioString38[] = "INSTMAP[0] %x\n"; +u8 audioString39[] = "already flags %d\n"; +u8 audioString40[] = "already flags %d\n"; +u8 audioString41[] = "ERR:SLOW BANK DMA BUSY\n"; +u8 audioString42[] = "ERR:SLOW DMA BUSY\n"; +u8 audioString43[] = "Check %d bank %d\n"; +u8 audioString44[] = "Cache Check\n"; +u8 audioString45[] = "NO BANK ERROR\n"; +u8 audioString46[] = "BANK %d LOADING START\n"; +u8 audioString47[] = "BANK %d LOAD MISS (NO MEMORY)!\n"; +u8 audioString48[] = "BANK %d ALREADY CACHED\n"; +u8 audioString49[] = "BANK LOAD MISS! FOR %d\n"; +#endif + +/** + * Performs an asynchronus (normal priority) DMA copy + */ +void audio_dma_copy_async(uintptr_t devAddr, void *vAddr, size_t nbytes, OSMesgQueue *queue, OSIoMesg *mesg) { + osInvalDCache(vAddr, nbytes); + osPiStartDma(mesg, OS_MESG_PRI_NORMAL, OS_READ, devAddr, vAddr, nbytes, queue); +} + +/** + * Performs a partial asynchronous (normal priority) DMA copy. This is limited + * to 0x1000 bytes transfer at once. + */ +void audio_dma_partial_copy_async(uintptr_t *devAddr, u8 **vAddr, ssize_t *remaining, OSMesgQueue *queue, OSIoMesg *mesg) { +#if defined(VERSION_EU) + ssize_t transfer = (*remaining >= 0x1000 ? 0x1000 : *remaining); +#else + ssize_t transfer = (*remaining < 0x1000 ? *remaining : 0x1000); +#endif + *remaining -= transfer; + osInvalDCache(*vAddr, transfer); + osPiStartDma(mesg, OS_MESG_PRI_NORMAL, OS_READ, *devAddr, *vAddr, transfer, queue); + *devAddr += transfer; + *vAddr += transfer; +} + +void decrease_sample_dma_ttls() { + u32 i; + + for (i = 0; i < sSampleDmaListSize1; i++) { +#if defined(VERSION_EU) + struct SharedDma *temp = &sSampleDmas[i]; +#else + struct SharedDma *temp = sSampleDmas + i; +#endif + if (temp->ttl != 0) { + temp->ttl--; + if (temp->ttl == 0) { + temp->reuseIndex = sSampleDmaReuseQueueHead1; + sSampleDmaReuseQueue1[sSampleDmaReuseQueueHead1++] = (u8) i; + } + } + } + + for (i = sSampleDmaListSize1; i < gSampleDmaNumListItems; i++) { +#if defined(VERSION_EU) + struct SharedDma *temp = &sSampleDmas[i]; +#else + struct SharedDma *temp = sSampleDmas + i; +#endif + if (temp->ttl != 0) { + temp->ttl--; + if (temp->ttl == 0) { + temp->reuseIndex = sSampleDmaReuseQueueHead2; + sSampleDmaReuseQueue2[sSampleDmaReuseQueueHead2++] = (u8) i; + } + } + } + + sUnused80226B40 = 0; +} + +void *dma_sample_data(uintptr_t devAddr, u32 size, s32 arg2, u8 *dmaIndexRef) { + s32 hasDma = FALSE; + struct SharedDma *dma; + uintptr_t dmaDevAddr; + u32 transfer; + u32 i; + u32 dmaIndex; + ssize_t bufferPos; + UNUSED u32 pad; + + if (arg2 != 0 || *dmaIndexRef >= sSampleDmaListSize1) { + for (i = sSampleDmaListSize1; i < gSampleDmaNumListItems; i++) { +#if defined(VERSION_EU) + dma = &sSampleDmas[i]; +#else + dma = sSampleDmas + i; +#endif + bufferPos = devAddr - dma->source; + if (0 <= bufferPos && (size_t) bufferPos <= dma->bufSize - size) { + // We already have a DMA request for this memory range. + if (dma->ttl == 0 && sSampleDmaReuseQueueTail2 != sSampleDmaReuseQueueHead2) { + // Move the DMA out of the reuse queue, by swapping it with the + // tail, and then incrementing the tail. + if (dma->reuseIndex != sSampleDmaReuseQueueTail2) { + sSampleDmaReuseQueue2[dma->reuseIndex] = + sSampleDmaReuseQueue2[sSampleDmaReuseQueueTail2]; + sSampleDmas[sSampleDmaReuseQueue2[sSampleDmaReuseQueueTail2]].reuseIndex = + dma->reuseIndex; + } + sSampleDmaReuseQueueTail2++; + } + dma->ttl = 60; + *dmaIndexRef = (u8) i; +#if defined(VERSION_EU) + return &dma->buffer[(devAddr - dma->source)]; +#else + return (devAddr - dma->source) + dma->buffer; +#endif + } + } + + if (sSampleDmaReuseQueueTail2 != sSampleDmaReuseQueueHead2 && arg2 != 0) { + // Allocate a DMA from reuse queue 2. This queue can be empty, since + // TTL 60 is pretty large. + dmaIndex = sSampleDmaReuseQueue2[sSampleDmaReuseQueueTail2]; + sSampleDmaReuseQueueTail2++; + dma = sSampleDmas + dmaIndex; + hasDma = TRUE; + } + } else { +#if defined(VERSION_EU) + dma = sSampleDmas; + dma += *dmaIndexRef; +#else + dma = sSampleDmas + *dmaIndexRef; +#endif + bufferPos = devAddr - dma->source; + if (0 <= bufferPos && (size_t) bufferPos <= dma->bufSize - size) { + // We already have DMA for this memory range. + if (dma->ttl == 0) { + // Move the DMA out of the reuse queue, by swapping it with the + // tail, and then incrementing the tail. + if (dma->reuseIndex != sSampleDmaReuseQueueTail1) { +#if defined(VERSION_EU) + if (1) { + } +#endif + sSampleDmaReuseQueue1[dma->reuseIndex] = + sSampleDmaReuseQueue1[sSampleDmaReuseQueueTail1]; + sSampleDmas[sSampleDmaReuseQueue1[sSampleDmaReuseQueueTail1]].reuseIndex = + dma->reuseIndex; + } + sSampleDmaReuseQueueTail1++; + } + dma->ttl = 2; +#if defined(VERSION_EU) + return dma->buffer + (devAddr - dma->source); +#else + return (devAddr - dma->source) + dma->buffer; +#endif + } + } + + if (!hasDma) { + // Allocate a DMA from reuse queue 1. This queue will hopefully never + // be empty, since TTL 2 is so small. + dmaIndex = sSampleDmaReuseQueue1[sSampleDmaReuseQueueTail1++]; + dma = sSampleDmas + dmaIndex; + hasDma = TRUE; + } + + transfer = dma->bufSize; + dmaDevAddr = devAddr & ~0xF; + dma->ttl = 2; + dma->source = dmaDevAddr; + dma->sizeUnused = transfer; +#ifdef VERSION_US + osInvalDCache(dma->buffer, transfer); +#endif +#if defined(VERSION_EU) + osPiStartDma(&gCurrAudioFrameDmaIoMesgBufs[gCurrAudioFrameDmaCount++], OS_MESG_PRI_NORMAL, + OS_READ, dmaDevAddr, dma->buffer, transfer, &gCurrAudioFrameDmaQueue); + *dmaIndexRef = dmaIndex; + return (devAddr - dmaDevAddr) + dma->buffer; +#else + gCurrAudioFrameDmaCount++; + osPiStartDma(&gCurrAudioFrameDmaIoMesgBufs[gCurrAudioFrameDmaCount - 1], OS_MESG_PRI_NORMAL, + OS_READ, dmaDevAddr, dma->buffer, transfer, &gCurrAudioFrameDmaQueue); + *dmaIndexRef = dmaIndex; + return dma->buffer + (devAddr - dmaDevAddr); +#endif +} + + +void init_sample_dma_buffers(UNUSED s32 arg0) { + s32 i; +#if defined(VERSION_EU) +#define j i +#else + s32 j; +#endif + +#if defined(VERSION_EU) + sDmaBufSize = 0x400; +#else + sDmaBufSize = 144 * 9; +#endif + +#if defined(VERSION_EU) + for (i = 0; i < gMaxSimultaneousNotes * 3 * gAudioBufferParameters.presetUnk4; i++) +#else + for (i = 0; i < gMaxSimultaneousNotes * 3; i++) +#endif + { + sSampleDmas[gSampleDmaNumListItems].buffer = soundAlloc(&gNotesAndBuffersPool, sDmaBufSize); + if (sSampleDmas[gSampleDmaNumListItems].buffer == NULL) { +#if defined(VERSION_EU) + break; +#else + goto out1; +#endif + } + sSampleDmas[gSampleDmaNumListItems].bufSize = sDmaBufSize; + sSampleDmas[gSampleDmaNumListItems].source = 0; + sSampleDmas[gSampleDmaNumListItems].sizeUnused = 0; + sSampleDmas[gSampleDmaNumListItems].unused2 = 0; + sSampleDmas[gSampleDmaNumListItems].ttl = 0; + gSampleDmaNumListItems++; + } +#if defined(VERSION_JP) || defined(VERSION_US) +out1: +#endif + + for (i = 0; (u32) i < gSampleDmaNumListItems; i++) { + sSampleDmaReuseQueue1[i] = (u8) i; + sSampleDmas[i].reuseIndex = (u8) i; + } + + for (j = gSampleDmaNumListItems; j < 0x100; j++) { + sSampleDmaReuseQueue1[j] = 0; + } + + sSampleDmaReuseQueueTail1 = 0; + sSampleDmaReuseQueueHead1 = (u8) gSampleDmaNumListItems; + sSampleDmaListSize1 = gSampleDmaNumListItems; + +#if defined(VERSION_EU) + sDmaBufSize = 0x200; +#else + sDmaBufSize = 160 * 9; +#endif + for (i = 0; i < gMaxSimultaneousNotes; i++) { + sSampleDmas[gSampleDmaNumListItems].buffer = soundAlloc(&gNotesAndBuffersPool, sDmaBufSize); + if (sSampleDmas[gSampleDmaNumListItems].buffer == NULL) { +#if defined(VERSION_EU) + break; +#else + goto out2; +#endif + } + sSampleDmas[gSampleDmaNumListItems].bufSize = sDmaBufSize; + sSampleDmas[gSampleDmaNumListItems].source = 0; + sSampleDmas[gSampleDmaNumListItems].sizeUnused = 0; + sSampleDmas[gSampleDmaNumListItems].unused2 = 0; + sSampleDmas[gSampleDmaNumListItems].ttl = 0; + gSampleDmaNumListItems++; + } +#if defined(VERSION_JP) || defined(VERSION_US) +out2: +#endif + + for (i = sSampleDmaListSize1; (u32) i < gSampleDmaNumListItems; i++) { + sSampleDmaReuseQueue2[i - sSampleDmaListSize1] = (u8) i; + sSampleDmas[i].reuseIndex = (u8)(i - sSampleDmaListSize1); + } + + // This probably meant to touch the range size1..size2 as well... but it + // doesn't matter, since these values are never read anyway. + for (j = gSampleDmaNumListItems; j < 0x100; j++) { + sSampleDmaReuseQueue2[j] = sSampleDmaListSize1; + } + + sSampleDmaReuseQueueTail2 = 0; + sSampleDmaReuseQueueHead2 = gSampleDmaNumListItems - sSampleDmaListSize1; +#if defined(VERSION_EU) +#undef j +#endif +} + +#if defined(VERSION_JP) || defined(VERSION_US) +// This function gets optimized out on US due to being static and never called +UNUSED static +#endif +void patch_sound(UNUSED struct AudioBankSound *sound, UNUSED u8 *memBase, UNUSED u8 *offsetBase) { + struct AudioBankSample *sample; + void *patched; + UNUSED u8 *mem; // unused on US + +#define PATCH(x, base) (patched = (void *)((uintptr_t) (x) + (uintptr_t) base)) + + if (sound->sample != NULL) { + sample = sound->sample = PATCH(sound->sample, memBase); + if (sample->loaded == 0) { + sample->sampleAddr = PATCH(sample->sampleAddr, offsetBase); + sample->loop = PATCH(sample->loop, memBase); + sample->book = PATCH(sample->book, memBase); + sample->loaded = 1; + } +#if defined(VERSION_EU) + else if (sample->loaded == 0x80) { + PATCH(sample->sampleAddr, offsetBase); + mem = soundAlloc(&gNotesAndBuffersPool, sample->sampleSize); + if (mem == NULL) { + sample->sampleAddr = patched; + sample->loaded = 1; + } else { + audio_dma_copy_immediate((uintptr_t) patched, mem, sample->sampleSize); + sample->loaded = 0x81; + sample->sampleAddr = mem; + } + sample->loop = PATCH(sample->loop, memBase); + sample->book = PATCH(sample->book, memBase); + } +#endif + } + +#undef PATCH +} + +#ifdef VERSION_EU +#define PATCH_SOUND patch_sound +#else +// copt inline of the above +#define PATCH_SOUND(_sound, mem, offset) \ +{ \ + struct AudioBankSound *sound = _sound; \ + struct AudioBankSample *sample; \ + void *patched; \ + if ((*sound).sample != (void *) 0) \ + { \ + patched = (void *)(((uintptr_t)(*sound).sample) + ((uintptr_t)((u8 *) mem))); \ + (*sound).sample = patched; \ + sample = (*sound).sample; \ + if ((*sample).loaded == 0) \ + { \ + patched = (void *)(((uintptr_t)(*sample).sampleAddr) + ((uintptr_t) offset)); \ + (*sample).sampleAddr = patched; \ + patched = (void *)(((uintptr_t)(*sample).loop) + ((uintptr_t)((u8 *) mem))); \ + (*sample).loop = patched; \ + patched = (void *)(((uintptr_t)(*sample).book) + ((uintptr_t)((u8 *) mem))); \ + (*sample).book = patched; \ + (*sample).loaded = 1; \ + } \ + } \ +} +#endif + +// on US/JP this inlines patch_sound, using some -sopt compiler flag +void patch_audio_bank(struct AudioBank *mem, u8 *offset, u32 numInstruments, u32 numDrums) { + struct Instrument *instrument; + struct Instrument **itInstrs; + struct Instrument **end; + struct AudioBank *temp; + u32 i; + void *patched; + struct Drum *drum; + struct Drum **drums; +#if defined(VERSION_EU) + u32 numDrums2; +#endif + +#define BASE_OFFSET_REAL(x, base) (void *)((uintptr_t) (x) + (uintptr_t) base) +#define PATCH(x, base) (patched = BASE_OFFSET_REAL(x, base)) +#define PATCH_MEM(x) x = PATCH(x, mem) + +#if defined(VERSION_JP) || defined(VERSION_US) +#define BASE_OFFSET(x, base) BASE_OFFSET_REAL(x, base) +#else +#define BASE_OFFSET(x, base) BASE_OFFSET_REAL(base, x) +#endif + + drums = mem->drums; +#if defined(VERSION_JP) || defined(VERSION_US) + if (drums != NULL && numDrums > 0) { + mem->drums = (void *)((uintptr_t) drums + (uintptr_t) mem); + if (numDrums > 0) //! unneeded when -sopt is enabled + for (i = 0; i < numDrums; i++) { +#else + numDrums2 = numDrums; + if (drums != NULL && numDrums2 > 0) { + mem->drums = PATCH(drums, mem); + for (i = 0; i < numDrums2; i++) { +#endif + patched = mem->drums[i]; + if (patched != NULL) { + drum = PATCH(patched, mem); + mem->drums[i] = drum; + if (drum->loaded == 0) { +#if defined(VERSION_JP) || defined(VERSION_US) + //! copt replaces drum with 'patched' for these two lines + PATCH_SOUND(&(*(struct Drum *)patched).sound, mem, offset); + patched = (*(struct Drum *)patched).envelope; +#else + patch_sound(&drum->sound, (u8 *) mem, offset); + patched = drum->envelope; +#endif + drum->envelope = BASE_OFFSET(mem, patched); + drum->loaded = 1; + } + + } + } + } + + //! Doesn't affect EU, but required for US/JP + temp = &*mem; +#if defined(VERSION_JP) || defined(VERSION_US) + if (numInstruments >= 1) +#endif + if (numInstruments > 0) { + //! Doesn't affect EU, but required for US/JP + struct Instrument **tempInst; + itInstrs = temp->instruments; + tempInst = temp->instruments; + end = numInstruments + tempInst; + +#if defined(VERSION_JP) || defined(VERSION_US) +l2: +#else + do { +#endif + if (*itInstrs != NULL) { + *itInstrs = BASE_OFFSET(*itInstrs, mem); + instrument = *itInstrs; + + if (instrument->loaded == 0) { + PATCH_SOUND(&instrument->lowNotesSound, (u8 *) mem, offset); + PATCH_SOUND(&instrument->normalNotesSound, (u8 *) mem, offset); + PATCH_SOUND(&instrument->highNotesSound, (u8 *) mem, offset); + patched = instrument->envelope; + instrument->envelope = BASE_OFFSET(mem, patched); + instrument->loaded = 1; + } + } + itInstrs++; +#if defined(VERSION_JP) || defined(VERSION_US) + //! goto generated by copt, required to match US/JP + if (end != itInstrs) { + goto l2; + } +#else + } while (end != itInstrs); +#endif + } +#undef PATCH_MEM +#undef PATCH +#undef BASE_OFFSET_REAL +#undef BASE_OFFSET +#undef PATCH_SOUND +} + +struct AudioBank *bank_load_immediate(s32 bankId, s32 arg1) { + UNUSED u32 pad1[4]; + u32 buf[4]; + u32 numInstruments, numDrums; + struct AudioBank *ret; + u8 *ctlData; + s32 alloc; + + // (This is broken if the length is 1 (mod 16), but that never happens -- + // it's always divisible by 4.) + alloc = gAlCtlHeader->seqArray[bankId].len + 0xf; + alloc = ALIGN16(alloc); + alloc -= 0x10; + ctlData = gAlCtlHeader->seqArray[bankId].offset; + ret = alloc_bank_or_seq(&gBankLoadedPool, 1, alloc, arg1, bankId); + if (ret == NULL) { + return NULL; + } + + audio_dma_copy_immediate((uintptr_t) ctlData, buf, 0x10); + numInstruments = buf[0]; + numDrums = buf[1]; + audio_dma_copy_immediate((uintptr_t)(ctlData + 0x10), ret, alloc); + patch_audio_bank(ret, gAlTbl->seqArray[bankId].offset, numInstruments, numDrums); + gCtlEntries[bankId].numInstruments = (u8) numInstruments; + gCtlEntries[bankId].numDrums = (u8) numDrums; + gCtlEntries[bankId].instruments = ret->instruments; + gCtlEntries[bankId].drums = ret->drums; + gBankLoadStatus[bankId] = SOUND_LOAD_STATUS_COMPLETE; + return ret; +} + +struct AudioBank *bank_load_async(s32 bankId, s32 arg1, struct SequencePlayer *seqPlayer) { + u32 numInstruments, numDrums; + UNUSED u32 pad1[2]; + u32 buf[4]; + UNUSED u32 pad2; + size_t alloc; + struct AudioBank *ret; + u8 *ctlData; + OSMesgQueue *mesgQueue; +#if defined(VERSION_EU) + UNUSED u32 pad3; +#endif + alloc = gAlCtlHeader->seqArray[bankId].len + 0xf; + alloc = ALIGN16(alloc); + alloc -= 0x10; + ctlData = gAlCtlHeader->seqArray[bankId].offset; + ret = alloc_bank_or_seq(&gBankLoadedPool, 1, alloc, arg1, bankId); + if (ret == NULL) { + return NULL; + } + + audio_dma_copy_immediate((uintptr_t) ctlData, buf, 0x10); + numInstruments = buf[0]; + numDrums = buf[1]; + seqPlayer->loadingBankId = (u8) bankId; +#if defined(VERSION_EU) + gCtlEntries[bankId].numInstruments = numInstruments; + gCtlEntries[bankId].numDrums = numDrums; + gCtlEntries[bankId].instruments = ret->instruments; + gCtlEntries[bankId].drums = 0; + seqPlayer->bankDmaCurrMemAddr = (u8 *) ret; + seqPlayer->bankDmaCurrDevAddr = (uintptr_t)(ctlData + 0x10); + seqPlayer->bankDmaRemaining = alloc; + if (1) { + } +#else + seqPlayer->loadingBankNumInstruments = numInstruments; + seqPlayer->loadingBankNumDrums = numDrums; + seqPlayer->bankDmaCurrMemAddr = (u8 *) ret; + seqPlayer->loadingBank = ret; + seqPlayer->bankDmaCurrDevAddr = (uintptr_t)(ctlData + 0x10); + seqPlayer->bankDmaRemaining = alloc; +#endif + mesgQueue = &seqPlayer->bankDmaMesgQueue; + osCreateMesgQueue(mesgQueue, &seqPlayer->bankDmaMesg, 1); +#if defined(VERSION_JP) || defined(VERSION_US) + seqPlayer->bankDmaMesg = NULL; +#endif + seqPlayer->bankDmaInProgress = TRUE; + audio_dma_partial_copy_async(&seqPlayer->bankDmaCurrDevAddr, &seqPlayer->bankDmaCurrMemAddr, + &seqPlayer->bankDmaRemaining, mesgQueue, &seqPlayer->bankDmaIoMesg); + gBankLoadStatus[bankId] = SOUND_LOAD_STATUS_IN_PROGRESS; + return ret; +} + +void *sequence_dma_immediate(s32 seqId, s32 arg1) { + s32 seqLength; + void *ptr; + u8 *seqData; + + seqLength = gSeqFileHeader->seqArray[seqId].len + 0xf; + seqLength = ALIGN16(seqLength); + seqData = gSeqFileHeader->seqArray[seqId].offset; + ptr = alloc_bank_or_seq(&gSeqLoadedPool, 1, seqLength, arg1, seqId); + if (ptr == NULL) { + return NULL; + } + + audio_dma_copy_immediate((uintptr_t) seqData, ptr, seqLength); + gSeqLoadStatus[seqId] = SOUND_LOAD_STATUS_COMPLETE; + return ptr; +} + +void *sequence_dma_async(s32 seqId, s32 arg1, struct SequencePlayer *seqPlayer) { + s32 seqLength; + void *ptr; + u8 *seqData; + OSMesgQueue *mesgQueue; + + eu_stubbed_printf_1("Seq %d Loading Start\n", seqId); + seqLength = gSeqFileHeader->seqArray[seqId].len + 0xf; + seqLength = ALIGN16(seqLength); + seqData = gSeqFileHeader->seqArray[seqId].offset; + ptr = alloc_bank_or_seq(&gSeqLoadedPool, 1, seqLength, arg1, seqId); + if (ptr == NULL) { + eu_stubbed_printf_0("Heap Overflow Error\n"); + return NULL; + } + + if (seqLength <= 0x40) { + // Immediately load short sequenece + audio_dma_copy_immediate((uintptr_t) seqData, ptr, seqLength); + if (1) { + } + gSeqLoadStatus[seqId] = SOUND_LOAD_STATUS_COMPLETE; + } else { + audio_dma_copy_immediate((uintptr_t) seqData, ptr, 0x40); + mesgQueue = &seqPlayer->seqDmaMesgQueue; + osCreateMesgQueue(mesgQueue, &seqPlayer->seqDmaMesg, 1); +#if defined(VERSION_JP) || defined(VERSION_US) + seqPlayer->seqDmaMesg = NULL; +#endif + seqPlayer->seqDmaInProgress = TRUE; + audio_dma_copy_async((uintptr_t)(seqData + 0x40), (u8 *) ptr + 0x40, seqLength - 0x40, mesgQueue, + &seqPlayer->seqDmaIoMesg); + gSeqLoadStatus[seqId] = SOUND_LOAD_STATUS_IN_PROGRESS; + } + return ptr; +} + +u8 get_missing_bank(u32 seqId, s32 *nonNullCount, s32 *nullCount) { + void *temp; + u32 bankId; + u16 offset; + u8 i; + u8 ret; + + *nullCount = 0; + *nonNullCount = 0; +#if defined(VERSION_EU) + offset = ((u16 *) gAlBankSets)[seqId]; + for (i = gAlBankSets[offset++], ret = 0; i != 0; i--) { + bankId = gAlBankSets[offset++]; +#else + offset = ((u16 *) gAlBankSets)[seqId] + 1; + for (i = gAlBankSets[offset - 1], ret = 0; i != 0; i--) { + offset++; + bankId = gAlBankSets[offset - 1]; +#endif + + if (IS_BANK_LOAD_COMPLETE(bankId) == TRUE) { +#if defined(VERSION_EU) + temp = get_bank_or_seq(&gBankLoadedPool, 2, bankId); +#else + temp = get_bank_or_seq(&gBankLoadedPool, 2, gAlBankSets[offset - 1]); +#endif + } else { + temp = NULL; + } + + if (temp == NULL) { + (*nullCount)++; + ret = bankId; + } else { + (*nonNullCount)++; + } + } + + return ret; +} + +struct AudioBank *load_banks_immediate(s32 seqId, u8 *outDefaultBank) { + void *ret; + u32 bankId; + u16 offset; + u8 i; + + offset = ((u16 *) gAlBankSets)[seqId]; +#ifdef VERSION_EU + for (i = gAlBankSets[offset++]; i != 0; i--) { + bankId = gAlBankSets[offset++]; +#else + offset++; + for (i = gAlBankSets[offset - 1]; i != 0; i--) { + offset++; + bankId = gAlBankSets[offset - 1]; +#endif + + if (IS_BANK_LOAD_COMPLETE(bankId) == TRUE) { +#ifdef VERSION_EU + ret = get_bank_or_seq(&gBankLoadedPool, 2, bankId); +#else + ret = get_bank_or_seq(&gBankLoadedPool, 2, gAlBankSets[offset - 1]); +#endif + } else { + ret = NULL; + } + + if (ret == NULL) { + ret = bank_load_immediate(bankId, 2); + } + } + *outDefaultBank = bankId; + return ret; +} + +void preload_sequence(u32 seqId, u8 preloadMask) { + void *sequenceData; + u8 temp; + + if (seqId >= gSequenceCount) { + return; + } + + gAudioLoadLock = AUDIO_LOCK_LOADING; + if (preloadMask & PRELOAD_BANKS) { + load_banks_immediate(seqId, &temp); + } + + if (preloadMask & PRELOAD_SEQUENCE) { + // @bug should be IS_SEQ_LOAD_COMPLETE + if (IS_BANK_LOAD_COMPLETE(seqId) == TRUE) { + eu_stubbed_printf_1("SEQ %d ALREADY CACHED\n", seqId); + sequenceData = get_bank_or_seq(&gSeqLoadedPool, 2, seqId); + } else { + sequenceData = NULL; + } + if (sequenceData == NULL && sequence_dma_immediate(seqId, 2) == NULL) { + gAudioLoadLock = AUDIO_LOCK_NOT_LOADING; + return; + } + } + + gAudioLoadLock = AUDIO_LOCK_NOT_LOADING; +} + +void load_sequence_internal(u32 player, u32 seqId, s32 loadAsync); + +void load_sequence(u32 player, u32 seqId, s32 loadAsync) { + if (!loadAsync) { + gAudioLoadLock = AUDIO_LOCK_LOADING; + } + load_sequence_internal(player, seqId, loadAsync); + if (!loadAsync) { + gAudioLoadLock = AUDIO_LOCK_NOT_LOADING; + } +} + +void load_sequence_internal(u32 player, u32 seqId, s32 loadAsync) { + void *sequenceData; + struct SequencePlayer *seqPlayer = &gSequencePlayers[player]; + UNUSED u32 padding[2]; + + if (seqId >= gSequenceCount) { + return; + } + + sequence_player_disable(seqPlayer); + if (loadAsync) { + s32 numMissingBanks = 0; + s32 dummy = 0; + s32 bankId = get_missing_bank(seqId, &dummy, &numMissingBanks); + if (numMissingBanks == 1) { + eu_stubbed_printf_0("Ok,one bank slow load Start \n"); + if (bank_load_async(bankId, 2, seqPlayer) == NULL) { + return; + } + // @bug This should set the last bank (i.e. the first in the JSON) + // as default, not the missing one. This code path never gets + // taken, though -- all sequence loading is synchronous. + seqPlayer->defaultBank[0] = bankId; + } else { + eu_stubbed_printf_1("Sorry,too many %d bank is none.fast load Start \n", numMissingBanks); + if (load_banks_immediate(seqId, &seqPlayer->defaultBank[0]) == NULL) { + return; + } + } + } else if (load_banks_immediate(seqId, &seqPlayer->defaultBank[0]) == NULL) { + return; + } + + eu_stubbed_printf_2("Seq %d:Default Load Id is %d\n", seqId, seqPlayer->defaultBank[0]); + eu_stubbed_printf_0("Seq Loading Start\n"); + + seqPlayer->seqId = seqId; + sequenceData = get_bank_or_seq(&gSeqLoadedPool, 2, seqId); + if (sequenceData == NULL) { + if (seqPlayer->seqDmaInProgress) { + eu_stubbed_printf_0("Error:Before Sequence-SlowDma remain.\n"); + eu_stubbed_printf_0(" Cancel Seq Start.\n"); + return; + } + if (loadAsync) { + sequenceData = sequence_dma_async(seqId, 2, seqPlayer); + } else { + sequenceData = sequence_dma_immediate(seqId, 2); + } + + if (sequenceData == NULL) { + return; + } + } + + eu_stubbed_printf_1("SEQ %d ALREADY CACHED\n", seqId); + init_sequence_player(player); + seqPlayer->scriptState.depth = 0; + seqPlayer->delay = 0; + seqPlayer->enabled = TRUE; + seqPlayer->seqData = sequenceData; + seqPlayer->scriptState.pc = sequenceData; +} + +// (void) must be omitted from parameters to fix stack with -framepointer +void audio_init() { +#if defined(VERSION_EU) + UNUSED s8 pad[16]; +#else + UNUSED s8 pad[32]; +#endif +#if defined(VERSION_JP) || defined(VERSION_US) + u8 buf[0x10]; +#endif + s32 i, j, UNUSED k; + UNUSED s32 lim1; // lim1 unused in EU +#if defined(VERSION_EU) + UNUSED u8 buf[0x10]; + s32 UNUSED lim2, lim3; +#else + s32 lim2, UNUSED lim3; +#endif + UNUSED u32 size; + UNUSED u64 *ptr64; + void *data; + UNUSED s32 pad2; + + gAudioLoadLock = AUDIO_LOCK_UNINITIALIZED; + +#if defined(VERSION_JP) || defined(VERSION_US) + lim1 = gUnusedCount80333EE8; + for (i = 0; i < lim1; i++) { + gUnused80226E58[i] = 0; + gUnused80226E98[i] = 0; + } + + lim2 = gAudioHeapSize; + for (i = 0; i <= lim2 / 8 - 1; i++) { + ((u64 *) gAudioHeap)[i] = 0; + } + +#ifdef TARGET_N64 + // It seems boot.s doesn't clear the .bss area for audio, so do it here. + i = 0; + lim3 = ((uintptr_t) &gAudioGlobalsEndMarker - (uintptr_t) &gAudioGlobalsStartMarker) / 8; + ptr64 = &gAudioGlobalsStartMarker - 1; + for (k = lim3; k >= 0; k--) { + i++; + ptr64[i] = 0; + } +#endif + +#else + for (i = 0; i < gAudioHeapSize / 8; i++) { + ((u64 *) gAudioHeap)[i] = 0; + } + +#ifdef TARGET_N64 + // It seems boot.s doesn't clear the .bss area for audio, so do it here. + lim3 = ((uintptr_t) &gAudioGlobalsEndMarker - (uintptr_t) &gAudioGlobalsStartMarker) / 8; + ptr64 = &gAudioGlobalsStartMarker; + for (k = lim3; k >= 0; k--) { + *ptr64++ = 0; + } +#endif + + D_EU_802298D0 = 20.03042f; + gRefreshRate = 50; + port_eu_init(); + if (k) { + } +#endif + +#ifdef TARGET_N64 + eu_stubbed_printf_3("Clear Workarea %x -%x size %x \n", + (uintptr_t) &gAudioGlobalsStartMarker, + (uintptr_t) &gAudioGlobalsEndMarker, + (uintptr_t) &gAudioGlobalsEndMarker - (uintptr_t) &gAudioGlobalsStartMarker + ); +#endif + + eu_stubbed_printf_1("AudioHeap is %x\n", gAudioHeapSize); + + for (i = 0; i < NUMAIBUFFERS; i++) { + gAiBufferLengths[i] = 0xa0; + } + + gAudioFrameCount = 0; + gAudioTaskIndex = 0; + gCurrAiBufferIndex = 0; + gSoundMode = 0; + gAudioTask = NULL; + gAudioTasks[0].task.t.data_size = 0; + gAudioTasks[1].task.t.data_size = 0; + osCreateMesgQueue(&gAudioDmaMesgQueue, &gAudioDmaMesg, 1); + osCreateMesgQueue(&gCurrAudioFrameDmaQueue, gCurrAudioFrameDmaMesgBufs, + ARRAY_COUNT(gCurrAudioFrameDmaMesgBufs)); + gCurrAudioFrameDmaCount = 0; + gSampleDmaNumListItems = 0; + + sound_init_main_pools(gAudioInitPoolSize); + + for (i = 0; i < NUMAIBUFFERS; i++) { + gAiBuffers[i] = soundAlloc(&gAudioInitPool, AIBUFFER_LEN); + + for (j = 0; j < (s32) (AIBUFFER_LEN / sizeof(s16)); j++) { + gAiBuffers[i][j] = 0; + } + } + +#if defined(VERSION_EU) + gAudioResetPresetIdToLoad = 0; + gAudioResetStatus = 1; + audio_shut_down_and_reset_step(); +#else + audio_reset_session(&gAudioSessionPresets[0]); +#endif + + // Not sure about these prints + eu_stubbed_printf_1("Heap reset.Synth Change %x \n", 0); + eu_stubbed_printf_3("Heap %x %x %x\n", 0, 0, 0); + eu_stubbed_printf_0("Main Heap Initialize.\n"); + + // Load headers for sounds and sequences + gSeqFileHeader = (ALSeqFile *) buf; + data = gMusicData; + audio_dma_copy_immediate((uintptr_t) data, gSeqFileHeader, 0x10); + gSequenceCount = gSeqFileHeader->seqCount; +#if defined(VERSION_EU) + size = gSequenceCount * sizeof(ALSeqData) + 4; + size = ALIGN16(size); +#else + size = ALIGN16(gSequenceCount * sizeof(ALSeqData) + 4); +#endif + gSeqFileHeader = soundAlloc(&gAudioInitPool, size); + audio_dma_copy_immediate((uintptr_t) data, gSeqFileHeader, size); + alSeqFileNew(gSeqFileHeader, data); + + // Load header for CTL (instrument metadata) + gAlCtlHeader = (ALSeqFile *) buf; + data = gSoundDataADSR; + audio_dma_copy_immediate((uintptr_t) data, gAlCtlHeader, 0x10); + size = gAlCtlHeader->seqCount * sizeof(ALSeqData) + 4; + size = ALIGN16(size); + gCtlEntries = soundAlloc(&gAudioInitPool, gAlCtlHeader->seqCount * sizeof(struct CtlEntry)); + gAlCtlHeader = soundAlloc(&gAudioInitPool, size); + audio_dma_copy_immediate((uintptr_t) data, gAlCtlHeader, size); + alSeqFileNew(gAlCtlHeader, data); + + // Load header for TBL (raw sound data) + gAlTbl = (ALSeqFile *) buf; + audio_dma_copy_immediate((uintptr_t) data, gAlTbl, 0x10); + size = gAlTbl->seqCount * sizeof(ALSeqData) + 4; + size = ALIGN16(size); + gAlTbl = soundAlloc(&gAudioInitPool, size); + audio_dma_copy_immediate((uintptr_t) gSoundDataRaw, gAlTbl, size); + alSeqFileNew(gAlTbl, gSoundDataRaw); + + // Load bank sets for each sequence + gAlBankSets = soundAlloc(&gAudioInitPool, 0x100); + audio_dma_copy_immediate((uintptr_t) gBankSetsData, gAlBankSets, 0x100); + + init_sequence_players(); + gAudioLoadLock = AUDIO_LOCK_NOT_LOADING; + // Should probably contain the sizes of the data banks, but those aren't + // easily accessible from here. + eu_stubbed_printf_0("---------- Init Completed. ------------\n"); + eu_stubbed_printf_1(" Syndrv :[%6d]\n", 0); // gSoundDataADSR + eu_stubbed_printf_1(" Seqdrv :[%6d]\n", 0); // gMusicData + eu_stubbed_printf_1(" audiodata :[%6d]\n", 0); // gSoundDataRaw + eu_stubbed_printf_0("---------------------------------------\n"); +} +#endif diff --git a/src/decomp/audio/load.h b/src/decomp/audio/load.h new file mode 100644 index 0000000..63379d2 --- /dev/null +++ b/src/decomp/audio/load.h @@ -0,0 +1,114 @@ +#ifndef AUDIO_LOAD_H +#define AUDIO_LOAD_H + +#include + +#include "internal.h" + +#define AUDIO_FRAME_DMA_QUEUE_SIZE 0x40 + +#define PRELOAD_BANKS 2 +#define PRELOAD_SEQUENCE 1 + +#define IS_SEQUENCE_CHANNEL_VALID(ptr) ((uintptr_t)(ptr) != (uintptr_t)&gSequenceChannelNone) + +extern struct Note *gNotes; + +// Music in SM64 is played using 3 players: +// gSequencePlayers[0] is level background music +// gSequencePlayers[1] is misc music, like the puzzle jingle +// gSequencePlayers[2] is sound +extern struct SequencePlayer gSequencePlayers[SEQUENCE_PLAYERS]; + +extern struct SequenceChannel gSequenceChannels[SEQUENCE_CHANNELS]; +extern struct SequenceChannelLayer gSequenceLayers[SEQUENCE_LAYERS]; + +extern struct SequenceChannel gSequenceChannelNone; + +extern struct AudioListItem gLayerFreeList; +extern struct NotePool gNoteFreeLists; + +extern OSMesgQueue gCurrAudioFrameDmaQueue; +extern u32 gSampleDmaNumListItems; +extern ALSeqFile *gAlCtlHeader; +extern ALSeqFile *gAlTbl; +extern ALSeqFile *gSeqFileHeader; +extern u8 *gAlBankSets; + +extern struct CtlEntry *gCtlEntries; +#if defined(VERSION_EU) || defined(VERSION_SH) +extern struct AudioBufferParametersEU gAudioBufferParameters; +#endif +extern s32 gAiFrequency; +#ifdef VERSION_SH +extern s16 gCurrAiBufferLength; +extern s32 D_SH_8034F68C; +#endif +extern s32 gMaxAudioCmds; + +extern s32 gMaxSimultaneousNotes; +extern s32 gSamplesPerFrameTarget; +extern s32 gMinAiBufferLength; +extern s16 gTempoInternalToExternal; +extern s8 gAudioUpdatesPerFrame; // = 4 +extern s8 gSoundMode; + +#ifdef VERSION_SH +extern OSMesgQueue gUnkQueue1; + +struct UnkStructSH8034EC88 { + u8 *endAndMediumIdentification; + struct AudioBankSample *sample; + u8 *ramAddr; + u32 encodedInfo; + s32 isFree; +}; + +struct PatchStruct { + s32 bankId1; + s32 bankId2; + void *baseAddr1; + void *baseAddr2; + s32 medium1; + s32 medium2; +}; + +extern struct UnkStructSH8034EC88 D_SH_8034EC88[0x80]; +#endif + +void audio_dma_partial_copy_async(uintptr_t *devAddr, u8 **vAddr, ssize_t *remaining, OSMesgQueue *queue, OSIoMesg *mesg); +void decrease_sample_dma_ttls(void); +#ifdef VERSION_SH +void *dma_sample_data(uintptr_t devAddr, u32 size, s32 arg2, u8 *dmaIndexRef, s32 medium); +#else +void *dma_sample_data(uintptr_t devAddr, u32 size, s32 arg2, u8 *dmaIndexRef); +#endif +void init_sample_dma_buffers(s32 arg0); +#if defined(VERSION_SH) +void patch_audio_bank(s32 bankId, struct AudioBank *mem, struct PatchStruct *patchInfo); +#else +void patch_audio_bank(struct AudioBank *mem, u8 *offset, u32 numInstruments, u32 numDrums); +#endif +#ifdef VERSION_SH +void preload_sequence(u32 seqId, s32 preloadMask); +#else +void preload_sequence(u32 seqId, u8 preloadMask); +#endif +void load_sequence(u32 player, u32 seqId, s32 loadAsync); + +#ifdef VERSION_SH +void func_sh_802f3158(s32 seqId, s32 arg1, s32 arg2, OSMesgQueue *retQueue); +u8 *func_sh_802f3220(u32 seqId, u32 *a1); +struct AudioBankSample *func_sh_802f4978(s32 bankId, s32 idx); +s32 func_sh_802f47c8(s32 bankId, u8 idx, s8 *io); +void *func_sh_802f3f08(s32 poolIdx, s32 arg1, s32 arg2, s32 arg3, OSMesgQueue *retQueue); +void func_sh_802f41e4(s32 audioResetStatus); +BAD_RETURN(s32) func_sh_802f3368(s32 bankId); +void *func_sh_802f3764(s32 arg0, s32 idx, s32 *arg2); +s32 func_sh_802f3024(s32 bankId, s32 instId, s32 arg2); +void func_sh_802f30f4(s32 arg0, s32 arg1, s32 arg2, OSMesgQueue *arg3); +void func_sh_802f3288(s32 idx); + +#endif + +#endif // AUDIO_LOAD_H diff --git a/src/decomp/audio/load_dat.c b/src/decomp/audio/load_dat.c new file mode 100644 index 0000000..8181b93 --- /dev/null +++ b/src/decomp/audio/load_dat.c @@ -0,0 +1,11 @@ +#include "load_dat.h" + +unsigned char* gSoundDataADSR; + +unsigned char* gSoundDataRaw; + +unsigned char* gMusicData; + +#ifndef VERSION_SH +unsigned char* gBankSetsData; +#endif \ No newline at end of file diff --git a/src/decomp/audio/load_dat.h b/src/decomp/audio/load_dat.h new file mode 100644 index 0000000..8d3adda --- /dev/null +++ b/src/decomp/audio/load_dat.h @@ -0,0 +1,11 @@ +#pragma once + +extern unsigned char* gSoundDataADSR; + +extern unsigned char* gSoundDataRaw; + +extern unsigned char* gMusicData; + +#ifndef VERSION_SH +extern unsigned char* gBankSetsData; +#endif \ No newline at end of file diff --git a/src/decomp/audio/load_sh.c b/src/decomp/audio/load_sh.c new file mode 100644 index 0000000..c57e722 --- /dev/null +++ b/src/decomp/audio/load_sh.c @@ -0,0 +1,1639 @@ +#ifdef VERSION_SH +#include + +#include "data.h" +#include "external.h" +#include "heap.h" +#include "load.h" +#include "seqplayer.h" + +#define ALIGN16(val) (((val) + 0xF) & ~0xF) + +struct SharedDma { + /*0x0*/ u8 *buffer; // target, points to pre-allocated buffer + /*0x4*/ uintptr_t source; // device address + /*0x8*/ u16 sizeUnused; // set to bufSize, never read + /*0xA*/ u16 bufSize; // size of buffer + /*0xC*/ u8 unused2; // set to 0, never read + /*0xD*/ u8 reuseIndex; // position in sSampleDmaReuseQueue1/2, if ttl == 0 + /*0xE*/ u8 ttl; // duration after which the DMA can be discarded +}; // size = 0x10 + +void port_eu_init(void); +void patch_sound(struct AudioBankSound *sound, struct AudioBank *memBase, struct PatchStruct *patchInfo); +void *func_802f3f08(s32 poolIdx, s32 idx, s32 numChunks, s32 arg3, OSMesgQueue *retQueue); + +struct Note *gNotes; + +UNUSED static u32 pad; + +struct SequencePlayer gSequencePlayers[SEQUENCE_PLAYERS]; +struct SequenceChannel gSequenceChannels[SEQUENCE_CHANNELS]; +struct SequenceChannelLayer gSequenceLayers[SEQUENCE_LAYERS]; + +struct SequenceChannel gSequenceChannelNone; +struct AudioListItem gLayerFreeList; +struct NotePool gNoteFreeLists; + +struct AudioBankSample *D_SH_8034EA88[0x80]; +struct UnkStructSH8034EC88 D_SH_8034EC88[0x80]; +s32 D_SH_8034F688; // index into D_SH_8034EA88 +s32 D_SH_8034F68C; // index or size for D_SH_8034EC88 + +struct PendingDmaAudioBank { + s8 inProgress; + s8 timer; + s8 medium; + struct AudioBank *audioBank; + uintptr_t devAddr; + void *vAddr; + u32 remaining; + u32 transferSize; + u32 encodedInfo; + OSMesgQueue *retQueue; + OSMesgQueue dmaRetQueue; + OSMesg mesgs[1]; + OSIoMesg ioMesg; +}; +struct PendingDmaAudioBank sPendingDmaAudioBanks[16]; + +OSMesgQueue gUnkQueue1; +OSMesg gUnkMesgBufs1[0x10]; +OSMesgQueue gUnkQueue2; +OSMesg gUnkMesgBufs2[0x10]; + +OSMesgQueue gCurrAudioFrameDmaQueue; +OSMesg gCurrAudioFrameDmaMesgBufs[AUDIO_FRAME_DMA_QUEUE_SIZE]; +OSIoMesg gCurrAudioFrameDmaIoMesgBufs[AUDIO_FRAME_DMA_QUEUE_SIZE]; + +OSMesgQueue gAudioDmaMesgQueue; +OSMesg gAudioDmaMesg; +OSIoMesg gAudioDmaIoMesg; + +struct SharedDma *sSampleDmas; +u32 gSampleDmaNumListItems; +u32 sSampleDmaListSize1; +u32 sUnused80226B40; // set to 0, never read + +// Circular buffer of DMAs with ttl = 0. tail <= head, wrapping around mod 256. +u8 sSampleDmaReuseQueue1[256]; +u8 sSampleDmaReuseQueue2[256]; +u8 sSampleDmaReuseQueueTail1; +u8 sSampleDmaReuseQueueTail2; +u8 sSampleDmaReuseQueueHead1; +u8 sSampleDmaReuseQueueHead2; + +ALSeqFile *gSeqFileHeader; +ALSeqFile *gAlCtlHeader; +ALSeqFile *gAlTbl; +u8 *gAlBankSets; +u16 gSequenceCount; + +struct CtlEntry *gCtlEntries; + +struct AudioBufferParametersEU gAudioBufferParameters; +u32 sDmaBufSize; +s32 gMaxAudioCmds; +s32 gMaxSimultaneousNotes; + +s16 gTempoInternalToExternal; + +s8 gSoundMode; + +s8 gAudioUpdatesPerFrame; + +extern u64 gAudioGlobalsStartMarker; +extern u64 gAudioGlobalsEndMarker; + +extern u8 gSoundDataADSR[]; // ctl +extern u8 gSoundDataRaw[]; // tbl +extern u8 gMusicData[]; // sequences + +ALSeqFile *get_audio_file_header(s32 arg0); + +void *func_sh_802f3688(s32 bankId); +void *get_bank_or_seq_wrapper(s32 arg0, s32 arg1); +void func_sh_802f3d78(uintptr_t devAddr, void *vAddr, size_t nbytes, s32 arg3); +void func_sh_802f3c38(uintptr_t devAddr, void *vAddr, size_t nbytes, s32 medium); +s32 func_sh_802f3dd0(OSIoMesg *m, s32 pri, s32 direction, uintptr_t devAddr, + void *dramAddr, s32 size, OSMesgQueue *retQueue, s32 medium, UNUSED const char *reason); +void func_sh_802f4a4c(s32 audioResetStatus); +void func_sh_802f4bd8(struct PendingDmaSample *arg0, s32 len); +void func_sh_802f4c5c(uintptr_t devAddr, void *vAddr, size_t nbytes, s32 arg3); +struct PendingDmaAudioBank *func_sh_802f4cb4(uintptr_t devAddr, void *vAddr, s32 size, + s32 medium, s32 numChunks, OSMesgQueue *retQueue, s32 encodedInfo); +void func_sh_802f4dcc(s32 audioResetStatus); +void func_sh_802f4e50(struct PendingDmaAudioBank *audioBank, s32 audioResetStatus); +void func_sh_802f50ec(struct PendingDmaAudioBank *arg0, size_t len); +void func_sh_802f517c(uintptr_t devAddr, void *vAddr, size_t nbytes, s32 arg3); +BAD_RETURN(s32) func_sh_802f5310(s32 bankId, struct AudioBank *mem, struct PatchStruct *patchInfo, s32 arg3); +s32 func_sh_802f573c(s32 audioResetStatus); +void *func_sh_802f3564(s32 seqId); +s32 func_sh_802f3ec4(s32 arg0, uintptr_t *arg1); +void func_sh_802f3ed4(UNUSED s32 arg0, UNUSED s32 arg1, UNUSED void *vAddr, UNUSED size_t nbytes); + +s32 canonicalize_index(s32 poolIdx, s32 idx); + +void decrease_sample_dma_ttls() { + u32 i; + + for (i = 0; i < sSampleDmaListSize1; i++) { + struct SharedDma *temp = &sSampleDmas[i]; + if (temp->ttl != 0) { + temp->ttl--; + if (temp->ttl == 0) { + temp->reuseIndex = sSampleDmaReuseQueueHead1; + sSampleDmaReuseQueue1[sSampleDmaReuseQueueHead1++] = (u8) i; + } + } + } + + for (i = sSampleDmaListSize1; i < gSampleDmaNumListItems; i++) { + struct SharedDma *temp = &sSampleDmas[i]; + if (temp->ttl != 0) { + temp->ttl--; + if (temp->ttl == 0) { + temp->reuseIndex = sSampleDmaReuseQueueHead2; + sSampleDmaReuseQueue2[sSampleDmaReuseQueueHead2++] = (u8) i; + } + } + } + + sUnused80226B40 = 0; +} + +extern char shindouDebugPrint62[]; // "SUPERDMA" +void *dma_sample_data(uintptr_t devAddr, u32 size, s32 arg2, u8 *dmaIndexRef, s32 medium) { + UNUSED s32 sp60; + struct SharedDma *dma; + s32 hasDma = FALSE; + uintptr_t dmaDevAddr; + UNUSED u32 pad; + u32 dmaIndex; + u32 transfer; + ssize_t bufferPos; + u32 i; + + if (arg2 != 0 || *dmaIndexRef >= sSampleDmaListSize1) { + for (i = sSampleDmaListSize1; i < gSampleDmaNumListItems; i++) { + dma = &sSampleDmas[i]; + bufferPos = devAddr - dma->source; + if (0 <= bufferPos && (size_t) bufferPos <= dma->bufSize - size) { + // We already have a DMA request for this memory range. + if (dma->ttl == 0 && sSampleDmaReuseQueueTail2 != sSampleDmaReuseQueueHead2) { + // Move the DMA out of the reuse queue, by swapping it with the + // tail, and then incrementing the tail. + if (dma->reuseIndex != sSampleDmaReuseQueueTail2) { + sSampleDmaReuseQueue2[dma->reuseIndex] = + sSampleDmaReuseQueue2[sSampleDmaReuseQueueTail2]; + sSampleDmas[sSampleDmaReuseQueue2[sSampleDmaReuseQueueTail2]].reuseIndex = + dma->reuseIndex; + } + sSampleDmaReuseQueueTail2++; + } + dma->ttl = 60; + *dmaIndexRef = (u8) i; + return &dma->buffer[(devAddr - dma->source)]; + } + } + + if (sSampleDmaReuseQueueTail2 != sSampleDmaReuseQueueHead2 && arg2 != 0) { + // Allocate a DMA from reuse queue 2. This queue can be empty, since + // TTL 60 is pretty large. + dmaIndex = sSampleDmaReuseQueue2[sSampleDmaReuseQueueTail2]; + sSampleDmaReuseQueueTail2++; + dma = sSampleDmas + dmaIndex; + hasDma = TRUE; + } + } else { + dma = sSampleDmas + *dmaIndexRef; + bufferPos = devAddr - dma->source; + if (0 <= bufferPos && (size_t) bufferPos <= dma->bufSize - size) { + // We already have DMA for this memory range. + if (dma->ttl == 0) { + // Move the DMA out of the reuse queue, by swapping it with the + // tail, and then incrementing the tail. + if (dma->reuseIndex != sSampleDmaReuseQueueTail1) { + sSampleDmaReuseQueue1[dma->reuseIndex] = + sSampleDmaReuseQueue1[sSampleDmaReuseQueueTail1]; + sSampleDmas[sSampleDmaReuseQueue1[sSampleDmaReuseQueueTail1]].reuseIndex = + dma->reuseIndex; + } + sSampleDmaReuseQueueTail1++; + } + dma->ttl = 2; + return dma->buffer + (devAddr - dma->source); + } + } + + if (!hasDma) { + if (1) {} + // Allocate a DMA from reuse queue 1. This queue will hopefully never + // be empty, since TTL 2 is so small. + dmaIndex = sSampleDmaReuseQueue1[sSampleDmaReuseQueueTail1++]; + dma = sSampleDmas + dmaIndex; + hasDma = TRUE; + } + + transfer = dma->bufSize; + dmaDevAddr = devAddr & ~0xF; + dma->ttl = 2; + dma->source = dmaDevAddr; + dma->sizeUnused = transfer; + func_sh_802f3dd0(&gCurrAudioFrameDmaIoMesgBufs[gCurrAudioFrameDmaCount++], OS_MESG_PRI_NORMAL, OS_READ, + dmaDevAddr, dma->buffer, transfer, &gCurrAudioFrameDmaQueue, medium, shindouDebugPrint62); + *dmaIndexRef = dmaIndex; + return (devAddr - dmaDevAddr) + dma->buffer; +} + +void init_sample_dma_buffers(UNUSED s32 arg0) { + s32 i; + + sDmaBufSize = 0x2D0; + sSampleDmas = sound_alloc_uninitialized(&gNotesAndBuffersPool, + gMaxSimultaneousNotes * 4 * sizeof(struct SharedDma) * gAudioBufferParameters.presetUnk4); + + for (i = 0; i < gMaxSimultaneousNotes * 3 * gAudioBufferParameters.presetUnk4; i++) + { + if ((sSampleDmas[gSampleDmaNumListItems].buffer = sound_alloc_uninitialized(&gNotesAndBuffersPool, sDmaBufSize)) == NULL) { + break; + } + sSampleDmas[gSampleDmaNumListItems].bufSize = sDmaBufSize; + sSampleDmas[gSampleDmaNumListItems].source = 0; + sSampleDmas[gSampleDmaNumListItems].sizeUnused = 0; + sSampleDmas[gSampleDmaNumListItems].unused2 = 0; + sSampleDmas[gSampleDmaNumListItems].ttl = 0; + gSampleDmaNumListItems++; + } + + for (i = 0; (u32) i < gSampleDmaNumListItems; i++) { + sSampleDmaReuseQueue1[i] = (u8) i; + sSampleDmas[i].reuseIndex = (u8) i; + } + + for (i = gSampleDmaNumListItems; i < 0x100; i++) { + sSampleDmaReuseQueue1[i] = 0; + } + + sSampleDmaReuseQueueTail1 = 0; + sSampleDmaReuseQueueHead1 = (u8) gSampleDmaNumListItems; + sSampleDmaListSize1 = gSampleDmaNumListItems; + + sDmaBufSize = 0x2D0; + for (i = 0; i < gMaxSimultaneousNotes; i++) { + if ((sSampleDmas[gSampleDmaNumListItems].buffer = sound_alloc_uninitialized(&gNotesAndBuffersPool, sDmaBufSize)) == NULL) { + break; + } + sSampleDmas[gSampleDmaNumListItems].bufSize = sDmaBufSize; + sSampleDmas[gSampleDmaNumListItems].source = 0; + sSampleDmas[gSampleDmaNumListItems].sizeUnused = 0; + sSampleDmas[gSampleDmaNumListItems].unused2 = 0; + sSampleDmas[gSampleDmaNumListItems].ttl = 0; + gSampleDmaNumListItems++; + } + + for (i = sSampleDmaListSize1; (u32) i < gSampleDmaNumListItems; i++) { + sSampleDmaReuseQueue2[i - sSampleDmaListSize1] = (u8) i; + sSampleDmas[i].reuseIndex = (u8)(i - sSampleDmaListSize1); + } + + // This probably meant to touch the range size1..size2 as well... but it + // doesn't matter, since these values are never read anyway. + for (i = gSampleDmaNumListItems; i < 0x100; i++) { + sSampleDmaReuseQueue2[i] = sSampleDmaListSize1; + } + + sSampleDmaReuseQueueTail2 = 0; + sSampleDmaReuseQueueHead2 = gSampleDmaNumListItems - sSampleDmaListSize1; +} + +void patch_seq_file(ALSeqFile *seqFile, u8 *data, u16 arg2) { + s32 i; + + seqFile->unk2 = arg2; + seqFile->data = data; + for (i = 0; i < seqFile->seqCount; i++) { + if (seqFile->seqArray[i].len != 0 && seqFile->seqArray[i].medium == 2) { + seqFile->seqArray[i].offset += (uintptr_t)data; + } + } +} + +struct AudioBank *load_banks_immediate(s32 seqId, s32 *outDefaultBank) { + u8 bank; + s32 offset; + s32 i; + void *ret; + + offset = ((u16 *)gAlBankSets)[canonicalize_index(0, seqId)]; + bank = 0xFF; + for (i = gAlBankSets[offset++]; i > 0; i--) { + bank = gAlBankSets[offset++]; + ret = func_sh_802f3688(bank); + } + *outDefaultBank = bank; + return ret; +} + +void preload_sequence(u32 seqId, s32 preloadMask) { + UNUSED s32 pad; + s32 temp; + + seqId = canonicalize_index(0, seqId); + if (preloadMask & PRELOAD_BANKS) { + load_banks_immediate(seqId, &temp); + } + if (preloadMask & PRELOAD_SEQUENCE) { + func_sh_802f3564(seqId); + } +} + +s32 func_sh_802f2f38(struct AudioBankSample *sample, s32 bankId) { + u8 *sp24; + + if (sample->isPatched == TRUE && sample->medium != 0) { + sp24 = func_sh_802f1d90(sample->size, bankId, sample->sampleAddr, sample->medium); + if (sp24 == NULL) { + return -1; + } + if (sample->medium == 1) { + func_sh_802f3d78((uintptr_t) sample->sampleAddr, sp24, sample->size, gAlTbl->unk2); + } else { + func_sh_802f3c38((uintptr_t) sample->sampleAddr, sp24, sample->size, sample->medium); + } + sample->medium = 0; + sample->sampleAddr = sp24; + } +#ifdef AVOID_UB + return 0; +#endif +} + +s32 func_sh_802f3024(s32 bankId, s32 instId, s32 arg2) { + struct Instrument *instr; + struct Drum *drum; + + if (instId < 0x7F) { + instr = get_instrument_inner(bankId, instId); + if (instr == NULL) { + return -1; + } + if (instr->normalRangeLo != 0) { + func_sh_802f2f38(instr->lowNotesSound.sample, bankId); + } + func_sh_802f2f38(instr->normalNotesSound.sample, bankId); + if (instr->normalRangeHi != 0x7F) { + func_sh_802f2f38(instr->highNotesSound.sample, bankId); + } + //! @bug missing return + } else if (instId == 0x7F) { + drum = get_drum(bankId, arg2); + if (drum == NULL) { + return -1; + } + func_sh_802f2f38(drum->sound.sample, bankId); + return 0; + } +#ifdef AVOID_UB + return 0; +#endif +} + +void func_sh_802f30f4(s32 arg0, s32 arg1, s32 arg2, OSMesgQueue *arg3) { + if (func_802f3f08(2, canonicalize_index(2, arg0), arg1, arg2, arg3) == 0) { + osSendMesg(arg3, 0, 0); + } +} + +void func_sh_802f3158(s32 seqId, s32 numChunks, s32 arg2, OSMesgQueue *retQueue) { + s32 val; + s32 v; + + val = ((u16 *) gAlBankSets)[canonicalize_index(0, seqId)]; + v = gAlBankSets[val++]; + + while (v > 0) { + func_802f3f08(1, canonicalize_index(1, gAlBankSets[val++]), numChunks, arg2, retQueue); + v--; + } +} + +u8 *func_sh_802f3220(u32 seqId, u32 *a1) { + s32 val; + + val = ((u16 *) gAlBankSets)[canonicalize_index(0, seqId)]; + *a1 = gAlBankSets[val++]; + if (*a1 == 0) { + return NULL; + } + return &gAlBankSets[val]; +} + +void func_sh_802f3288(s32 idx) { + s32 bankId; + s32 s2; + + idx = ((u16*)gAlBankSets)[canonicalize_index(0, idx)]; + s2 = gAlBankSets[idx++]; + while (s2 > 0) { + s2--; + bankId = canonicalize_index(1, gAlBankSets[idx++]); + + if (unk_pool1_lookup(1, bankId) == NULL) { + func_sh_802f3368(bankId); + if (gBankLoadStatus[bankId] != SOUND_LOAD_STATUS_5) { + gBankLoadStatus[bankId] = SOUND_LOAD_STATUS_NOT_LOADED; + } + + continue; + } + + } +} + +BAD_RETURN(s32) func_sh_802f3368(s32 bankId) { + struct SoundMultiPool *pool = &gBankLoadedPool; + struct TemporaryPool *temporary = &pool->temporary; + struct PersistentPool *persistent; + u32 i; + + if (temporary->entries[0].id == bankId) { + temporary->entries[0].id = -1; + } else if (temporary->entries[1].id == bankId) { + temporary->entries[1].id = -1; + } + + persistent = &pool->persistent; + for (i = 0; i < persistent->numEntries; i++) { + if (persistent->entries[i].id == bankId) { + persistent->entries[i].id = -1; + } + + } + + discard_bank(bankId); +} + + +void load_sequence_internal(s32 player, s32 seqId, s32 loadAsync); +void load_sequence(u32 player, u32 seqId, s32 loadAsync) { + load_sequence_internal(player, seqId, loadAsync); +} + +void load_sequence_internal(s32 player, s32 seqId, UNUSED s32 loadAsync) { + struct SequencePlayer *seqPlayer; + u8 *sequenceData; + u32 s0; + s32 count; + u8 bank; + s32 i; + + seqPlayer = &gSequencePlayers[player]; + + seqId = canonicalize_index(0, seqId); + sequence_player_disable(seqPlayer); + + s0 = ((u16 *) gAlBankSets)[seqId]; + count = gAlBankSets[s0++]; + bank = 0xff; + + while (count > 0) { + bank = gAlBankSets[s0++]; + func_sh_802f3688(bank); + count--; + } + + sequenceData = func_sh_802f3564(seqId); + init_sequence_player(player); + seqPlayer->seqId = seqId; + seqPlayer->defaultBank[0] = bank; + seqPlayer->enabled = 1; + seqPlayer->seqData = sequenceData; + seqPlayer->scriptState.pc = sequenceData; + seqPlayer->scriptState.depth = 0; + seqPlayer->delay = 0; + seqPlayer->finished = 0; + + for (i = 0; i < 0x10; i++) { + } +} + +void *func_sh_802f3564(s32 seqId) { + s32 seqId2 = canonicalize_index(0, seqId); + s32 temp; + return func_sh_802f3764(0, seqId2, &temp); +} + +extern u8 gUnkLoadStatus[0x40]; + +void *func_sh_802f3598(s32 idx, s32 *medium) { + void *ret; + ALSeqFile *f; + s32 temp; + s32 sp28; + + f = get_audio_file_header(2); + idx = canonicalize_index(2, idx); + ret = get_bank_or_seq_wrapper(2, idx); + if (ret != NULL) { + if (gUnkLoadStatus[idx] != SOUND_LOAD_STATUS_5) { + gUnkLoadStatus[idx] = SOUND_LOAD_STATUS_COMPLETE; + } + + *medium = 0; + return ret; + } + + temp = f->seqArray[idx].magic; + if (temp == 4) { + *medium = f->seqArray[idx].medium; + return f->seqArray[idx].offset; + } else { + ret = func_sh_802f3764(2, idx, &sp28); + if (ret != 0) { + *medium = 0; + return ret; + } + + *medium = f->seqArray[idx].medium; + } + return f->seqArray[idx].offset; + +} + +void *func_sh_802f3688(s32 bankId) { + void *ret; + s32 bankId1; + s32 bankId2; + s32 sp38; + struct PatchStruct patchInfo; + + bankId = canonicalize_index(1, bankId); + bankId1 = gCtlEntries[bankId].bankId1; + bankId2 = gCtlEntries[bankId].bankId2; + + patchInfo.bankId1 = bankId1; + patchInfo.bankId2 = bankId2; + + if (patchInfo.bankId1 != 0xFF) { + patchInfo.baseAddr1 = func_sh_802f3598(patchInfo.bankId1, &patchInfo.medium1); + } else { + patchInfo.baseAddr1 = NULL; + } + + if (bankId2 != 0xFF) { + patchInfo.baseAddr2 = func_sh_802f3598(bankId2, &patchInfo.medium2); + } else { + patchInfo.baseAddr2 = NULL; + } + + if ((ret = func_sh_802f3764(1, bankId, &sp38)) == NULL) { + return NULL; + } + + if (sp38 == 1) { + func_sh_802f5310(bankId, ret, &patchInfo, 0); + } + + return ret; +} + +void *func_sh_802f3764(s32 poolIdx, s32 idx, s32 *arg2) { + s32 size; + ALSeqFile *f; + void *vAddr; + s32 medium; + UNUSED u32 pad2; + u8 *devAddr; + s8 loadStatus; + s32 sp18; + + vAddr = get_bank_or_seq_wrapper(poolIdx, idx); + if (vAddr != NULL) { + *arg2 = 0; + loadStatus = SOUND_LOAD_STATUS_COMPLETE; + } else { + f = get_audio_file_header(poolIdx); + size = f->seqArray[idx].len; + size = ALIGN16(size); + medium = f->seqArray[idx].medium; + sp18 = f->seqArray[idx].magic; + devAddr = f->seqArray[idx].offset; + + + switch (sp18) + { + case 0: + vAddr = unk_pool1_alloc(poolIdx, idx, size); + if (vAddr == NULL) { + return vAddr; + } + break; + case 1: + vAddr = alloc_bank_or_seq(poolIdx, size, 1, idx); + if (vAddr == NULL) { + return vAddr; + } + break; + case 2: + vAddr = alloc_bank_or_seq(poolIdx, size, 0, idx); + if (vAddr == NULL) { + return vAddr; + } + break; + + case 3: + case 4: + vAddr = alloc_bank_or_seq(poolIdx, size, 2, idx); + if (vAddr == NULL) { + return vAddr; + } + break; + } + + *arg2 = 1; + if (medium == 1) { + func_sh_802f3d78((uintptr_t) devAddr, vAddr, size, f->unk2); + } else { + func_sh_802f3c38((uintptr_t) devAddr, vAddr, size, medium); + } + + switch (sp18) { + case 0: + loadStatus = SOUND_LOAD_STATUS_5; + break; + + default: + loadStatus = SOUND_LOAD_STATUS_COMPLETE; + break; + } + } + + switch (poolIdx) { + case 0: + if (gSeqLoadStatus[idx] != SOUND_LOAD_STATUS_5) { + gSeqLoadStatus[idx] = loadStatus; + } + break; + + case 1: + if (gBankLoadStatus[idx] != SOUND_LOAD_STATUS_5) { + gBankLoadStatus[idx] = loadStatus; + } + break; + + case 2: + if (gUnkLoadStatus[idx] != SOUND_LOAD_STATUS_5) { + gUnkLoadStatus[idx] = loadStatus; + } + break; + } + + return vAddr; +} + +s32 canonicalize_index(s32 poolIdx, s32 idx) { + ALSeqFile *f; + + f = get_audio_file_header(poolIdx); + if (f->seqArray[idx].len == 0) { + idx = (s32) (uintptr_t) f->seqArray[idx].offset; + } + return idx; +} + +void *get_bank_or_seq_wrapper(s32 poolIdx, s32 id) { + void *ret; + + ret = unk_pool1_lookup(poolIdx, id); + if (ret != NULL) { + return ret; + } + ret = get_bank_or_seq(poolIdx, 2, id); + if (ret != 0) { + return ret; + } + return NULL; +} + +ALSeqFile *get_audio_file_header(s32 poolIdx) { + ALSeqFile *ret; + switch (poolIdx) { + default: + ret = NULL; + break; + case 0: + ret = gSeqFileHeader; + break; + case 1: + ret = gAlCtlHeader; + break; + case 2: + ret = gAlTbl; + break; + } + return ret; +} + +void patch_audio_bank(s32 bankId, struct AudioBank *mem, struct PatchStruct *patchInfo) { + struct Instrument *instrument; + void **itInstrs; + struct Instrument **end; + s32 i; + void *patched; + struct Drum *drum; + s32 numDrums; + s32 numInstruments; + +#define BASE_OFFSET(x, base) (void *)((uintptr_t) (x) + (uintptr_t) base) +#define PATCH(x, base) (patched = BASE_OFFSET(x, base)) +#define PATCH_MEM(x) x = PATCH(x, mem) + + numDrums = gCtlEntries[bankId].numDrums; + numInstruments = gCtlEntries[bankId].numInstruments; + itInstrs = (void **) mem->drums; + if (mem->drums) { + } + if (itInstrs != NULL && numDrums != 0) { + if (1) { + mem->drums = PATCH(itInstrs, mem); + } + for (i = 0; i < numDrums; i++) { + patched = mem->drums[i]; + if (patched != NULL) { + drum = PATCH(patched, mem); + mem->drums[i] = drum; + if (drum->loaded == 0) { + patch_sound(&drum->sound, mem, patchInfo); + patched = drum->envelope; + drum->envelope = BASE_OFFSET(patched, mem); + drum->loaded = 1; + } + + } + } + } + + if (numInstruments > 0) { + itInstrs = (void **) mem->instruments; + end = numInstruments + (struct Instrument **) itInstrs; + + do { + if (*itInstrs != NULL) { + *itInstrs = BASE_OFFSET(*itInstrs, mem); + instrument = *itInstrs; + + if (instrument->loaded == 0) { + if (instrument->normalRangeLo != 0) { + patch_sound(&instrument->lowNotesSound, mem, patchInfo); + } + patch_sound(&instrument->normalNotesSound, mem, patchInfo); + if (instrument->normalRangeHi != 0x7F) { + patch_sound(&instrument->highNotesSound, mem, patchInfo); + } + patched = instrument->envelope; + + instrument->envelope = BASE_OFFSET(patched, mem); + instrument->loaded = 1; + } + } + itInstrs = (void **) ((struct Instrument **) itInstrs) + 1; + } while ((struct Instrument **) itInstrs != ((void) 0, end)); //! This is definitely fake + } + gCtlEntries[bankId].drums = mem->drums; + gCtlEntries[bankId].instruments = mem->instruments; +#undef PATCH_MEM +#undef PATCH +#undef BASE_OFFSET +} + +extern char shindouDebugPrint81[]; // "FastCopy" +extern char shindouDebugPrint82[]; // "FastCopy" +void func_sh_802f3c38(uintptr_t devAddr, void *vAddr, size_t nbytes, s32 medium) { + nbytes = ALIGN16(nbytes); + osInvalDCache(vAddr, nbytes); + +again: + if (gAudioLoadLockSH != 0) { + goto again; + } + + if (nbytes >= 0x400U) { + func_sh_802f3dd0(&gAudioDmaIoMesg, 1, 0, devAddr, vAddr, 0x400, &gAudioDmaMesgQueue, medium, shindouDebugPrint81); + osRecvMesg(&gAudioDmaMesgQueue, NULL, 1); + nbytes = nbytes - 0x400; + devAddr = devAddr + 0x400; + vAddr = (u8*)vAddr + 0x400; + goto again; + } + + if (nbytes != 0) { + func_sh_802f3dd0(&gAudioDmaIoMesg, 1, 0, devAddr, vAddr, nbytes, &gAudioDmaMesgQueue, medium, shindouDebugPrint82); + osRecvMesg(&gAudioDmaMesgQueue, NULL, 1); + } +} + +void func_sh_802f3d78(uintptr_t devAddr, void *vAddr, size_t nbytes, s32 arg3) { + uintptr_t sp1C; + + sp1C = devAddr; + osInvalDCache(vAddr, nbytes); + func_sh_802f3ed4(func_sh_802f3ec4(arg3, &sp1C), sp1C, vAddr, nbytes); +} + +s32 func_sh_802f3dd0(OSIoMesg *m, s32 pri, s32 direction, uintptr_t devAddr, void *dramAddr, s32 size, OSMesgQueue *retQueue, s32 medium, UNUSED const char *reason) { + OSPiHandle *handle; + if (gAudioLoadLockSH >= 0x11U) { + return -1; + } + switch (medium) { + case 2: + handle = osCartRomInit(); + break; + case 3: + handle = osDriveRomInit(); + break; + default: + return 0; + } + if ((size & 0xf) != 0) { + size = ALIGN16(size); + } + m->hdr.pri = pri; + m->hdr.retQueue = retQueue; + m->dramAddr = dramAddr; + m->devAddr = devAddr; + m->size = size; + handle->transferInfo.cmdType = 2; + osEPiStartDma(handle, m, direction); + return 0; +} + +s32 func_sh_802f3ec4(UNUSED s32 arg0, UNUSED uintptr_t *arg1) { + return 0; +} + +void func_sh_802f3ed4(UNUSED s32 arg0, UNUSED s32 arg1, UNUSED void *vAddr, UNUSED size_t nbytes) { +} + +void *func_sh_802f3ee8(s32 poolIdx, s32 idx) { + s32 temp; + return func_sh_802f3764(poolIdx, idx, &temp); +} + +void *func_802f3f08(s32 poolIdx, s32 idx, s32 numChunks, s32 arg3, OSMesgQueue *retQueue) { + s32 size; + ALSeqFile *f; + void *vAddr; + s32 medium; + s32 sp18; + uintptr_t devAddr; + s32 loadStatus; + + switch (poolIdx) { + case 0: + if (gSeqLoadStatus[idx] == SOUND_LOAD_STATUS_IN_PROGRESS) { + return 0; + } + break; + case 1: + if (gBankLoadStatus[idx] == SOUND_LOAD_STATUS_IN_PROGRESS) { + return 0; + } + break; + case 2: + if (gUnkLoadStatus[idx] == SOUND_LOAD_STATUS_IN_PROGRESS) { + return 0; + } + break; + + } + vAddr = get_bank_or_seq_wrapper(poolIdx, idx); + if (vAddr != NULL) { + loadStatus = 2; + osSendMesg(retQueue, (OSMesg) (arg3 << 0x18), 0); + } else { + f = get_audio_file_header(poolIdx); + size = f->seqArray[idx].len; + size = ALIGN16(size); + medium = f->seqArray[idx].medium; + sp18 = f->seqArray[idx].magic; + devAddr = (uintptr_t) f->seqArray[idx].offset; + loadStatus = 2; + + switch (sp18) { + case 0: + vAddr = unk_pool1_alloc(poolIdx, idx, size); + if (vAddr == NULL) { + return vAddr; + } + loadStatus = SOUND_LOAD_STATUS_5; + break; + case 1: + vAddr = alloc_bank_or_seq(poolIdx, size, 1, idx); + if (vAddr == NULL) { + return vAddr; + } + break; + case 2: + vAddr = alloc_bank_or_seq(poolIdx, size, 0, idx); + if (vAddr == NULL) { + return vAddr; + } + break; + + case 4: + case 3: + vAddr = alloc_bank_or_seq(poolIdx, size, 2, idx); + if (vAddr == NULL) { + return vAddr; + } + break; + } + + func_sh_802f4cb4(devAddr, vAddr, size, medium, numChunks, retQueue, (arg3 << 0x18) | (poolIdx << 0x10) | (idx << 8) | loadStatus); + loadStatus = SOUND_LOAD_STATUS_IN_PROGRESS; + } + + switch (poolIdx) { + case 0: + if (gSeqLoadStatus[idx] != SOUND_LOAD_STATUS_5) { + gSeqLoadStatus[idx] = loadStatus; + } + break; + + case 1: + if (gBankLoadStatus[idx] != SOUND_LOAD_STATUS_5) { + gBankLoadStatus[idx] = loadStatus; + } + break; + + case 2: + if (gUnkLoadStatus[idx] != SOUND_LOAD_STATUS_5) { + gUnkLoadStatus[idx] = loadStatus; + } + break; + } + + return vAddr; +} + +void func_sh_802f41e4(s32 audioResetStatus) { + func_sh_802f4a4c(audioResetStatus); + func_sh_802f573c(audioResetStatus); + func_sh_802f4dcc(audioResetStatus); +} + +#if defined(VERSION_SH) +u8 gShindouSoundBanksHeader[] = { +#include "sound/ctl_header.inc.c" +}; + +u8 gBankSetsData[] = { +#include "sound/bank_sets.inc.c" +}; + +u8 gShindouSampleBanksHeader[] = { +#include "sound/tbl_header.inc.c" +}; + +u8 gShindouSequencesHeader[] = { +#include "sound/sequences_header.inc.c" +}; +#endif + +// (void) must be omitted from parameters +void audio_init() { + UNUSED s8 pad[0x34]; + s32 i, j, k; + s32 lim; + u64 *ptr64; + void *data; + UNUSED u8 pad2[4]; + s32 seqCount; + + gAudioLoadLockSH = 0; + + for (i = 0; i < gAudioHeapSize / 8; i++) { + ((u64 *) gAudioHeap)[i] = 0; + } + +#ifdef TARGET_N64 + // It seems boot.s doesn't clear the .bss area for audio, so do it here. + lim = ((uintptr_t) &gAudioGlobalsEndMarker - (uintptr_t) &gAudioGlobalsStartMarker) / 8; + ptr64 = &gAudioGlobalsStartMarker; + for (k = lim; k >= 0; k--) { + *ptr64++ = 0; + } +#endif + + D_EU_802298D0 = 16.713f; + gRefreshRate = 60; + port_eu_init(); + +#ifdef TARGET_N64 + eu_stubbed_printf_3("Clear Workarea %x -%x size %x \n", + (uintptr_t) &gAudioGlobalsStartMarker, + (uintptr_t) &gAudioGlobalsEndMarker, + (uintptr_t) &gAudioGlobalsEndMarker - (uintptr_t) &gAudioGlobalsStartMarker + ); +#endif + + eu_stubbed_printf_1("AudioHeap is %x\n", gAudioHeapSize); + + for (i = 0; i < NUMAIBUFFERS; i++) { + gAiBufferLengths[i] = 0xa0; + } + + gAudioFrameCount = 0; + gAudioTaskIndex = 0; + gCurrAiBufferIndex = 0; + gSoundMode = 0; + gAudioTask = NULL; + gAudioTasks[0].task.t.data_size = 0; + gAudioTasks[1].task.t.data_size = 0; + osCreateMesgQueue(&gAudioDmaMesgQueue, &gAudioDmaMesg, 1); + osCreateMesgQueue(&gCurrAudioFrameDmaQueue, gCurrAudioFrameDmaMesgBufs, + ARRAY_COUNT(gCurrAudioFrameDmaMesgBufs)); + osCreateMesgQueue(&gUnkQueue1, gUnkMesgBufs1, 0x10); + osCreateMesgQueue(&gUnkQueue2, gUnkMesgBufs2, 0x10); + gCurrAudioFrameDmaCount = 0; + gSampleDmaNumListItems = 0; + + sound_init_main_pools(gAudioInitPoolSize); + + for (i = 0; i < NUMAIBUFFERS; i++) { + gAiBuffers[i] = sound_alloc_uninitialized(&gAudioInitPool, AIBUFFER_LEN); + + for (j = 0; j < (s32) (AIBUFFER_LEN / sizeof(s16)); j++) { + gAiBuffers[i][j] = 0; + } + } + + gAudioResetPresetIdToLoad = 0; + gAudioResetStatus = 1; + audio_shut_down_and_reset_step(); + + // Not sure about these prints + eu_stubbed_printf_1("Heap reset.Synth Change %x \n", 0); + eu_stubbed_printf_3("Heap %x %x %x\n", 0, 0, 0); + eu_stubbed_printf_0("Main Heap Initialize.\n"); + + // Load headers for sounds and sequences + gSeqFileHeader = (ALSeqFile *) gShindouSequencesHeader; + gAlCtlHeader = (ALSeqFile *) gShindouSoundBanksHeader; + gAlTbl = (ALSeqFile *) gShindouSampleBanksHeader; + gAlBankSets = gBankSetsData; + gSequenceCount = (s16) gSeqFileHeader->seqCount; + patch_seq_file(gSeqFileHeader, gMusicData, D_SH_80315EF4); + patch_seq_file(gAlCtlHeader, gSoundDataADSR, D_SH_80315EF8); + patch_seq_file(gAlTbl, gSoundDataRaw, D_SH_80315EFC); + seqCount = gAlCtlHeader->seqCount; + gCtlEntries = sound_alloc_uninitialized(&gAudioInitPool, seqCount * sizeof(struct CtlEntry)); + for (i = 0; i < seqCount; i++) { + gCtlEntries[i].bankId1 = (u8) ((gAlCtlHeader->seqArray[i].ctl.as_s16.bankAndFf >> 8) & 0xff); + gCtlEntries[i].bankId2 = (u8) (gAlCtlHeader->seqArray[i].ctl.as_s16.bankAndFf & 0xff); + gCtlEntries[i].numInstruments = (u8) ((gAlCtlHeader->seqArray[i].ctl.as_s16.numInstrumentsAndDrums >> 8) & 0xff); + gCtlEntries[i].numDrums = (u8) (gAlCtlHeader->seqArray[i].ctl.as_s16.numInstrumentsAndDrums & 0xff); + } + data = sound_alloc_uninitialized(&gAudioInitPool, D_SH_80315EF0); + if (data == NULL) { + D_SH_80315EF0 = 0; + } + sound_alloc_pool_init(&gUnkPool1.pool, data, D_SH_80315EF0); + init_sequence_players(); +} + +s32 func_sh_802f47c8(s32 bankId, u8 idx, s8 *io) { + struct AudioBankSample *sample = func_sh_802f4978(bankId, idx); + struct PendingDmaSample *temp; + if (sample == NULL) { + *io = 0; + return -1; + } + if (sample->medium == 0) { + *io = 2; + return 0; + } + temp = &D_SH_80343D00.arr[D_SH_80343D00.someIndex]; + if (temp->state == 3) { + temp->state = 0; + } + temp->sample = *sample; + temp->io = io; + temp->vAddr = func_sh_802f1d40(sample->size, bankId, sample->sampleAddr, sample->medium); + if (temp->vAddr == NULL) { + if (sample->medium == 1 || sample->codec == CODEC_SKIP) { + *io = 0; + return -1; + } else { + *io = 3; + return -1; + } + } + temp->state = 1; + temp->remaining = ALIGN16(sample->size); + temp->resultSampleAddr = (u8 *) temp->vAddr; + temp->devAddr = (uintptr_t) sample->sampleAddr; + temp->medium = sample->medium; + temp->bankId = bankId; + temp->idx = idx; + D_SH_80343D00.someIndex ^= 1; + return 0; +} + +struct AudioBankSample *func_sh_802f4978(s32 bankId, s32 idx) { + struct Drum *drum; + struct Instrument *inst; + struct AudioBankSample *ret; + + if (idx < 128) { + inst = get_instrument_inner(bankId, idx); + if (inst == 0) { + return NULL; + } + ret = inst->normalNotesSound.sample; + } else { + drum = get_drum(bankId, idx - 128); + if (drum == 0) { + return NULL; + } + ret = drum->sound.sample; + } + return ret; +} + +void stub_sh_802f49dc(void) { +} + +void func_sh_802f49e4(struct PendingDmaSample *arg0) { + struct AudioBankSample *sample = func_sh_802f4978(arg0->bankId, arg0->idx); + if (sample != NULL) { + arg0->sample = *sample; + sample->sampleAddr = arg0->resultSampleAddr; + sample->medium = 0; + } +} + +void func_sh_802f4a4c(s32 audioResetStatus) { + ALSeqFile *alTbl; + struct PendingDmaSample *entry; + + s32 i; + + alTbl = gAlTbl; + + for (i = 0; i < 2; i++) { + entry = &D_SH_80343D00.arr[i]; + switch (entry->state) { + case 2: + osRecvMesg(&entry->queue, NULL, 1); + if (audioResetStatus != 0) { + entry->state = 3; + break; + } + // fallthrough + case 1: + entry->state = 2; + if (entry->remaining == 0) { + func_sh_802f49e4(entry); + entry->state = 3; + *entry->io = 1; + } else if (entry->remaining < 0x1000) { + if (entry->medium == 1) { + func_sh_802f4c5c(entry->devAddr, entry->vAddr, entry->remaining, alTbl->unk2); + } else { + func_sh_802f4bd8(entry, entry->remaining); + } + entry->remaining = 0; + } else { + if (entry->medium == 1) { + func_sh_802f4c5c(entry->devAddr, entry->vAddr, 0x1000, alTbl->unk2); + } else { + func_sh_802f4bd8(entry, 0x1000); + } + entry->remaining = (s32) (entry->remaining - 0x1000); + entry->vAddr = (u8 *) entry->vAddr + 0x1000; + entry->devAddr = entry->devAddr + 0x1000; + } + break; + } + } +} + +extern char shindouDebugPrint102[]; // "SLOWCOPY" +void func_sh_802f4bd8(struct PendingDmaSample *arg0, s32 len) { // len must be signed + osInvalDCache(arg0->vAddr, len); + osCreateMesgQueue(&arg0->queue, arg0->mesgs, 1); + func_sh_802f3dd0(&arg0->ioMesg, 0, 0, arg0->devAddr, arg0->vAddr, len, &arg0->queue, arg0->medium, shindouDebugPrint102); +} + +void func_sh_802f4c5c(uintptr_t devAddr, void *vAddr, size_t nbytes, s32 arg3) { + uintptr_t sp1C; + + sp1C = devAddr; + osInvalDCache(vAddr, nbytes); + func_sh_802f3ed4(func_sh_802f3ec4(arg3, &sp1C), sp1C, vAddr, nbytes); +} + +struct PendingDmaAudioBank *func_sh_802f4cb4(uintptr_t devAddr, void *vAddr, s32 size, s32 medium, s32 numChunks, OSMesgQueue *retQueue, s32 encodedInfo) { + struct PendingDmaAudioBank *item; + s32 i; + + for (i = 0; i < ARRAY_COUNT(sPendingDmaAudioBanks); i++) { + if (sPendingDmaAudioBanks[i].inProgress == 0) { + item = &sPendingDmaAudioBanks[i]; + break; + } + } + if (i == ARRAY_COUNT(sPendingDmaAudioBanks)) { + return NULL; + } + + item->inProgress = 1; + item->devAddr = devAddr; + item->audioBank = vAddr; + item->vAddr = vAddr; + item->remaining = size; + if (numChunks == 0) { + item->transferSize = 0x1000; + } else { + item->transferSize = ((size / numChunks) + 0xFF) & ~0xFF; + if (item->transferSize < 0x100) { + item->transferSize = 0x100; + } + } + item->retQueue = retQueue; + item->timer = 3; + item->medium = medium; + item->encodedInfo = encodedInfo; + osCreateMesgQueue(&item->dmaRetQueue, item->mesgs, 1); + return item; +} + +void func_sh_802f4dcc(s32 audioResetStatus) { + s32 i; + + if (gAudioLoadLockSH != 1) { + for (i = 0; i < ARRAY_COUNT(sPendingDmaAudioBanks); i++) { + if (sPendingDmaAudioBanks[i].inProgress == 1) { + func_sh_802f4e50(&sPendingDmaAudioBanks[i], audioResetStatus); + } + } + } +} + +void func_sh_802f4e50(struct PendingDmaAudioBank *audioBank, s32 audioResetStatus) { + ALSeqFile *alSeqFile; + u32 *encodedInfo; + OSMesg mesg; + u32 temp; + u32 bankId; + s32 bankId1; + s32 bankId2; + struct PatchStruct patchStruct; + alSeqFile = gAlTbl; + if (audioBank->timer >= 2) { + audioBank->timer--; + return; + } + if (audioBank->timer == 1) { + audioBank->timer = 0; + } else { + if (audioResetStatus != 0) { + osRecvMesg(&audioBank->dmaRetQueue, NULL, OS_MESG_BLOCK); + audioBank->inProgress = 0; + return; + } + if (osRecvMesg(&audioBank->dmaRetQueue, NULL, OS_MESG_NOBLOCK) == -1) { + return; + } + } + + encodedInfo = &audioBank->encodedInfo; + if (audioBank->remaining == 0) { + mesg = (OSMesg) audioBank->encodedInfo; +#pragma GCC diagnostic push +#if defined(__clang__) +#pragma GCC diagnostic ignored "-Wself-assign" +#endif + mesg = mesg; //! needs an extra read from mesg here to match... +#pragma GCC diagnostic pop + temp = *encodedInfo; + bankId = (temp >> 8) & 0xFF; + switch ((u8) (temp >> 0x10)) { + case 0: + if (gSeqLoadStatus[bankId] != SOUND_LOAD_STATUS_5) { + gSeqLoadStatus[bankId] = (u8) (temp & 0xFF); + } + break; + case 2: + if (gUnkLoadStatus[bankId] != SOUND_LOAD_STATUS_5) { + gUnkLoadStatus[bankId] = (u8) (temp & 0xFF); + } + break; + case 1: + if (gBankLoadStatus[bankId] != SOUND_LOAD_STATUS_5) { + gBankLoadStatus[bankId] = (u8) (temp & 0xFF); + } + bankId1 = gCtlEntries[bankId].bankId1; + bankId2 = gCtlEntries[bankId].bankId2; + patchStruct.bankId1 = bankId1; + patchStruct.bankId2 = bankId2; + if (bankId1 != 0xFF) { + patchStruct.baseAddr1 = func_sh_802f3598(bankId1, &patchStruct.medium1); + } else { + patchStruct.baseAddr1 = NULL; + } + if (bankId2 != 0xFF) { + patchStruct.baseAddr2 = func_sh_802f3598(bankId2, &patchStruct.medium2); + } else { + patchStruct.baseAddr2 = NULL; + } + + func_sh_802f5310(bankId, audioBank->audioBank, &patchStruct, 1); + break; + } + mesg = (OSMesg) audioBank->encodedInfo; + audioBank->inProgress = 0; + osSendMesg(audioBank->retQueue, mesg, OS_MESG_NOBLOCK); + } else if (audioBank->remaining < audioBank->transferSize) { + if (audioBank->medium == 1) { + func_sh_802f517c(audioBank->devAddr, audioBank->vAddr, audioBank->remaining, alSeqFile->unk2); + } else { + func_sh_802f50ec(audioBank, audioBank->remaining); + } + + audioBank->remaining = 0; + } else { + if (audioBank->medium == 1) { + func_sh_802f517c(audioBank->devAddr, audioBank->vAddr, audioBank->transferSize, alSeqFile->unk2); + } else { + func_sh_802f50ec(audioBank, audioBank->transferSize); + } + + audioBank->remaining -= audioBank->transferSize; + audioBank->devAddr += audioBank->transferSize; + audioBank->vAddr = ((u8 *) audioBank->vAddr) + audioBank->transferSize; + } +} + +extern char shindouDebugPrint110[]; // "BGCOPY" +void func_sh_802f50ec(struct PendingDmaAudioBank *arg0, size_t len) { + len += 0xf; + len &= ~0xf; + osInvalDCache(arg0->vAddr, len); + osCreateMesgQueue(&arg0->dmaRetQueue, arg0->mesgs, 1); + func_sh_802f3dd0(&arg0->ioMesg, 0, 0, arg0->devAddr, arg0->vAddr, len, &arg0->dmaRetQueue, arg0->medium, shindouDebugPrint110); +} + + +void func_sh_802f517c(uintptr_t devAddr, void *vAddr, size_t nbytes, s32 arg3) { + uintptr_t sp1C; + + sp1C = devAddr; + osInvalDCache(vAddr, nbytes); + func_sh_802f3ed4(func_sh_802f3ec4(arg3, &sp1C), sp1C, vAddr, nbytes); +} + +void patch_sound(struct AudioBankSound *sound, struct AudioBank *memBase, struct PatchStruct *patchInfo) { + struct AudioBankSample *sample; + void *patched; + +#define PATCH(x, base) (patched = (void *)((uintptr_t) (x) + (uintptr_t) base)) + + if ((uintptr_t) sound->sample <= 0x80000000) { + sample = sound->sample = PATCH(sound->sample, memBase); + if (sample->size != 0 && sample->isPatched != TRUE) { + sample->loop = PATCH(sample->loop, memBase); + sample->book = PATCH(sample->book, memBase); + switch (sample->medium) { + case 0: + sample->sampleAddr = PATCH(sample->sampleAddr, patchInfo->baseAddr1); + sample->medium = patchInfo->medium1; + break; + case 1: + sample->sampleAddr = PATCH(sample->sampleAddr, patchInfo->baseAddr2); + sample->medium = patchInfo->medium2; + break; + + case 2: + case 3: + break; + } + sample->isPatched = TRUE; + if (sample->bit1 && sample->medium != 0) { + D_SH_8034EA88[D_SH_8034F688++] = sample; + } + } + } +#undef PATCH +} + +BAD_RETURN(s32) func_sh_802f5310(s32 bankId, struct AudioBank *mem, struct PatchStruct *patchInfo, s32 arg3) { + UNUSED u32 pad[2]; + u8 *addr; + UNUSED u32 pad1[3]; + s32 sp4C; + struct AudioBankSample *temp_s0; + s32 i; + uintptr_t count; + s32 temp; + + sp4C = 0; + if (D_SH_8034F68C != 0) { + sp4C = 1; + } else { + D_SH_80343CF0 = 0; + } + D_SH_8034F688 = 0; + patch_audio_bank(bankId, mem, patchInfo); + + count = 0; + for (i = 0; i < D_SH_8034F688; i++) { + count += ALIGN16(D_SH_8034EA88[i]->size); + } + + for (i = 0; i < D_SH_8034F688; i++) { + if (D_SH_8034F68C != 0x78) { + temp_s0 = D_SH_8034EA88[i]; + switch (arg3) { + case 0: + temp = temp_s0->medium = patchInfo->medium1; + if (temp != 0) { + if (temp_s0->size) { + } + addr = func_sh_802f1d90(temp_s0->size, patchInfo->bankId1, temp_s0->sampleAddr, temp_s0->medium); + } else { + temp = temp_s0->medium = patchInfo->medium2; + if (temp != 0) { + addr = func_sh_802f1d90(temp_s0->size, patchInfo->bankId2, temp_s0->sampleAddr, temp_s0->medium); + } + } + break; + + case 1: + temp = temp_s0->medium = patchInfo->medium1; + if (temp != 0) { + addr = func_sh_802f1d40(temp_s0->size, patchInfo->bankId1, temp_s0->sampleAddr, temp_s0->medium); + } else { + temp = temp_s0->medium = patchInfo->medium2; + if (temp != 0) { + addr = func_sh_802f1d40(temp_s0->size, patchInfo->bankId2, temp_s0->sampleAddr, temp_s0->medium); + } + } + break; + } + switch ((uintptr_t) addr) { + case 0: + break; + default: + switch (arg3) { + case 0: + if (temp_s0->medium == 1) { + func_sh_802f3d78((uintptr_t) temp_s0->sampleAddr, addr, temp_s0->size, gAlTbl->unk2); + temp_s0->sampleAddr = addr; + temp_s0->medium = 0; + } else { + func_sh_802f3c38((uintptr_t) temp_s0->sampleAddr, addr, temp_s0->size, temp_s0->medium); + temp_s0->sampleAddr = addr; + temp_s0->medium = 0; + } + break; + + case 1: + D_SH_8034EC88[D_SH_8034F68C].sample = temp_s0; + D_SH_8034EC88[D_SH_8034F68C].ramAddr = addr; + D_SH_8034EC88[D_SH_8034F68C].encodedInfo = (D_SH_8034F68C << 24) | 0xffffff; + D_SH_8034EC88[D_SH_8034F68C].isFree = FALSE; + D_SH_8034EC88[D_SH_8034F68C].endAndMediumIdentification = temp_s0->sampleAddr + temp_s0->size + temp_s0->medium; + D_SH_8034F68C++; + break; + } + } + continue; + } + break; + } + + D_SH_8034F688 = 0; + if (D_SH_8034F68C != 0 && sp4C == 0) { + temp_s0 = D_SH_8034EC88[D_SH_8034F68C - 1].sample; + temp = (temp_s0->size >> 12); + temp += 1; + count = (uintptr_t) temp_s0->sampleAddr; + func_sh_802f4cb4( + count, + D_SH_8034EC88[D_SH_8034F68C - 1].ramAddr, + temp_s0->size, + temp_s0->medium, + temp, + &gUnkQueue2, + D_SH_8034EC88[D_SH_8034F68C - 1].encodedInfo); + } +} + +s32 func_sh_802f573c(s32 audioResetStatus) { + struct AudioBankSample *sample; + u32 idx; + u8 *sampleAddr; + u32 size; + s32 unk; + u8 *added; + + if (D_SH_8034F68C > 0) { + if (audioResetStatus != 0) { + if (osRecvMesg(&gUnkQueue2, (OSMesg *) &idx, OS_MESG_NOBLOCK)){ + } + D_SH_8034F68C = 0; + return 0; + } + if (osRecvMesg(&gUnkQueue2, (OSMesg *) &idx, OS_MESG_NOBLOCK) == -1) { + return 0; + } + idx >>= 0x18; + if (D_SH_8034EC88[idx].isFree == FALSE) { + sample = D_SH_8034EC88[idx].sample; + added = (sample->sampleAddr + sample->size + sample->medium); + if (added == D_SH_8034EC88[idx].endAndMediumIdentification) { + sample->sampleAddr = D_SH_8034EC88[idx].ramAddr; + sample->medium = 0; + } + D_SH_8034EC88[idx].isFree = TRUE; + } + +next: + if (D_SH_8034F68C > 0) { + if (D_SH_8034EC88[D_SH_8034F68C - 1].isFree == TRUE) { + D_SH_8034F68C--; + goto next; + } + sample = D_SH_8034EC88[D_SH_8034F68C - 1].sample; + sampleAddr = sample->sampleAddr; + size = sample->size; + unk = size >> 0xC; + unk += 1; + added = ((sampleAddr + size) + sample->medium); + if (added != D_SH_8034EC88[D_SH_8034F68C - 1].endAndMediumIdentification) { + D_SH_8034EC88[D_SH_8034F68C - 1].isFree = TRUE; + D_SH_8034F68C--; + goto next; + } + size = sample->size; + func_sh_802f4cb4((uintptr_t) sampleAddr, D_SH_8034EC88[D_SH_8034F68C - 1].ramAddr, size, sample->medium, + unk, &gUnkQueue2, D_SH_8034EC88[D_SH_8034F68C - 1].encodedInfo); + } + } + return 1; +} + +s32 func_sh_802f5900(struct AudioBankSample *sample, s32 numLoaded, struct AudioBankSample *arg2[]) { + s32 i; + + for (i = 0; i < numLoaded; i++) { + if (sample->sampleAddr == arg2[i]->sampleAddr) { + break; + } + } + if (i == numLoaded) { + arg2[numLoaded++] = sample; + } + return numLoaded; +} + +s32 func_sh_802f5948(s32 bankId, struct AudioBankSample *list[]) { + s32 i; + struct Drum *drum; + struct Instrument *inst; + s32 numLoaded; + s32 numDrums; + s32 numInstruments; + + numLoaded = 0; + numDrums = gCtlEntries[bankId].numDrums; + numInstruments = gCtlEntries[bankId].numInstruments; + + for (i = 0; i < numDrums; i++) { + drum = get_drum(bankId, i); + if (drum == NULL) { + continue; + } + numLoaded = func_sh_802f5900(drum->sound.sample, numLoaded, list); + } + for (i = 0; i < numInstruments; i++) { + inst = get_instrument_inner(bankId, i); + if (inst == NULL) { + continue; + + } + if (inst->normalRangeLo != 0) { + numLoaded = func_sh_802f5900(inst->lowNotesSound.sample, numLoaded, list); + } + if (inst->normalRangeHi != 127) { + numLoaded = func_sh_802f5900(inst->highNotesSound.sample, numLoaded, list); + } + numLoaded = func_sh_802f5900(inst->normalNotesSound.sample, numLoaded, list); + } + return numLoaded; +} +#endif diff --git a/src/decomp/audio/playback.c b/src/decomp/audio/playback.c new file mode 100644 index 0000000..ff42e76 --- /dev/null +++ b/src/decomp/audio/playback.c @@ -0,0 +1,1472 @@ +#include + +#include "heap.h" +#include "data.h" +#include "load.h" +#include "seqplayer.h" +#include "playback.h" +#include "synthesis.h" +#include "effects.h" +#include "external.h" + +void note_set_resampling_rate(struct Note *note, f32 resamplingRateInput); + +#if defined(VERSION_EU) || defined(VERSION_SH) +#ifdef VERSION_SH +void note_set_vel_pan_reverb(struct Note *note, struct ReverbInfo *reverbInfo) +#else +void note_set_vel_pan_reverb(struct Note *note, f32 velocity, u8 pan, u8 reverbVol) +#endif +{ + struct NoteSubEu *sub = ¬e->noteSubEu; + f32 volRight, volLeft; + u8 strongRight; + u8 strongLeft; + s32 smallPanIndex; +#ifdef VERSION_EU + u16 unkMask = ~0x80; +#else + UNUSED u32 pad; + UNUSED u32 pad1; + f32 velocity; + u8 pan; + u8 reverbVol; + struct ReverbBitsData reverbBits; +#endif + +#ifdef VERSION_SH + note_set_resampling_rate(note, reverbInfo->freqScale); + velocity = reverbInfo->velocity; + pan = reverbInfo->pan; + reverbVol = reverbInfo->reverbVol; + reverbBits = reverbInfo->reverbBits.s; + pan &= 0x7f; +#else + pan &= unkMask; +#endif + + if (note->noteSubEu.stereoHeadsetEffects && gSoundMode == SOUND_MODE_HEADSET) { +#ifdef VERSION_SH + smallPanIndex = pan >> 1; +#else + smallPanIndex = pan >> 3; +#endif + if (smallPanIndex >= ARRAY_COUNT(gHeadsetPanQuantization)) { + smallPanIndex = ARRAY_COUNT(gHeadsetPanQuantization) - 1; + } + + sub->headsetPanLeft = gHeadsetPanQuantization[smallPanIndex]; + sub->headsetPanRight = gHeadsetPanQuantization[ARRAY_COUNT(gHeadsetPanQuantization) - 1 - smallPanIndex]; + sub->stereoStrongRight = FALSE; + sub->stereoStrongLeft = FALSE; + sub->usesHeadsetPanEffects = TRUE; + + volLeft = gHeadsetPanVolume[pan]; + volRight = gHeadsetPanVolume[127 - pan]; + } else if (sub->stereoHeadsetEffects && gSoundMode == SOUND_MODE_STEREO) { +#ifdef VERSION_SH + strongRight = FALSE; + strongLeft = FALSE; + sub->headsetPanRight = 0; + sub->headsetPanLeft = 0; +#else + strongLeft = FALSE; + strongRight = FALSE; + sub->headsetPanLeft = 0; + sub->headsetPanRight = 0; +#endif + + sub->usesHeadsetPanEffects = FALSE; + + volLeft = gStereoPanVolume[pan]; + volRight = gStereoPanVolume[127 - pan]; + if (pan < 0x20) { + strongLeft = TRUE; + } else if (pan > 0x60) { + strongRight = TRUE; + } + + sub->stereoStrongRight = strongRight; + sub->stereoStrongLeft = strongLeft; + +#ifdef VERSION_SH + switch (reverbBits.stereoHeadsetEffects) { + case 0: + sub->stereoStrongRight = reverbBits.strongRight; + sub->stereoStrongLeft = reverbBits.strongLeft; + break; + + case 1: + break; + + case 2: + sub->stereoStrongRight = reverbBits.strongRight | strongRight; + sub->stereoStrongLeft = reverbBits.strongLeft | strongLeft; + break; + + case 3: + sub->stereoStrongRight = reverbBits.strongRight ^ strongRight; + sub->stereoStrongLeft = reverbBits.strongLeft ^ strongLeft; + break; + } +#endif + } else if (gSoundMode == SOUND_MODE_MONO) { + volLeft = 0.707f; + volRight = 0.707f; + } else { + volLeft = gDefaultPanVolume[pan]; + volRight = gDefaultPanVolume[127 - pan]; + } + +#ifdef VERSION_SH + if (velocity < 0.0f) { + velocity = 0.0f; + } + if (velocity > 1.0f) { + velocity = 1.0f; + } + + sub->targetVolLeft = ((s32) (velocity * volLeft * 4095.999f)); + sub->targetVolRight = ((s32) (velocity * volRight * 4095.999f)); + sub->synthesisVolume = reverbInfo->synthesisVolume; + sub->filter = reverbInfo->filter; +#else + if (velocity < 0.0f) { + stubbed_printf("Audio: setvol: volume minus %f\n", velocity); + velocity = 0.0f; + } + if (velocity > 32767.f) { + stubbed_printf("Audio: setvol: volume overflow %f\n", velocity); + velocity = 32767.f; + } + + sub->targetVolLeft = ((s32) (velocity * volLeft) & 0xffff) >> 5; + sub->targetVolRight = ((s32) (velocity * volRight) & 0xffff) >> 5; +#endif + + //! @bug for the change to UQ0.7, the if statement should also have been changed accordingly + if (sub->reverbVol != reverbVol) { +#ifdef VERSION_SH + sub->reverbVol = reverbVol >> 1; +#else + sub->reverbVol = reverbVol; +#endif + sub->envMixerNeedsInit = TRUE; + return; + } + + if (sub->needsInit) { + sub->envMixerNeedsInit = TRUE; + } else { + sub->envMixerNeedsInit = FALSE; + } +} + +#ifdef VERSION_SH +#define MIN_RESAMPLING_RATE 1.99998f +#else +#define MIN_RESAMPLING_RATE 1.99996f +#endif + +void note_set_resampling_rate(struct Note *note, f32 resamplingRateInput) { + f32 resamplingRate = 0.0f; + struct NoteSubEu *tempSub = ¬e->noteSubEu; + +#ifdef VERSION_EU + if (resamplingRateInput < 0.0f) { + stubbed_printf("Audio: setpitch: pitch minus %f\n", resamplingRateInput); + resamplingRateInput = 0.0f; + } +#endif + if (resamplingRateInput < 2.0f) { + tempSub->hasTwoAdpcmParts = 0; + + if (MIN_RESAMPLING_RATE < resamplingRateInput) { + resamplingRate = MIN_RESAMPLING_RATE; + } else { + resamplingRate = resamplingRateInput; + } + + } else { + tempSub->hasTwoAdpcmParts = 1; + if (2 * MIN_RESAMPLING_RATE < resamplingRateInput) { + resamplingRate = MIN_RESAMPLING_RATE; + } else { + resamplingRate = resamplingRateInput * 0.5f; + } + } + note->noteSubEu.resamplingRateFixedPoint = (s32) (resamplingRate * 32768.0f); +} + +#ifdef VERSION_EU +struct AudioBankSound *instrument_get_audio_bank_sound(struct Instrument *instrument, s32 semitone) { + struct AudioBankSound *sound; + if (semitone < instrument->normalRangeLo) { + sound = &instrument->lowNotesSound; + } else if (semitone <= instrument->normalRangeHi) { + sound = &instrument->normalNotesSound; + } else { + sound = &instrument->highNotesSound; + } + return sound; +} + +struct Instrument *get_instrument_inner(s32 bankId, s32 instId) { + struct Instrument *inst; + + if (IS_BANK_LOAD_COMPLETE(bankId) == FALSE) { + stubbed_printf("Audio: voiceman: No bank error %d\n", bankId); + gAudioErrorFlags = bankId + 0x10000000; + return NULL; + } + + if (instId >= gCtlEntries[bankId].numInstruments) { + stubbed_printf("Audio: voiceman: progNo. overflow %d,%d\n", + instId, gCtlEntries[bankId].numInstruments); + gAudioErrorFlags = ((bankId << 8) + instId) + 0x3000000; + return NULL; + } + + inst = gCtlEntries[bankId].instruments[instId]; + if (inst == NULL) { + stubbed_printf("Audio: voiceman: progNo. undefined %d,%d\n", bankId, instId); + gAudioErrorFlags = ((bankId << 8) + instId) + 0x1000000; + return inst; + } + +#ifdef VERSION_EU + if (((uintptr_t) gBankLoadedPool.persistent.pool.start <= (uintptr_t) inst + && (uintptr_t) inst <= (uintptr_t)(gBankLoadedPool.persistent.pool.start + + gBankLoadedPool.persistent.pool.size)) + || ((uintptr_t) gBankLoadedPool.temporary.pool.start <= (uintptr_t) inst + && (uintptr_t) inst <= (uintptr_t)(gBankLoadedPool.temporary.pool.start + + gBankLoadedPool.temporary.pool.size))) { + return inst; + } + + stubbed_printf("Audio: voiceman: BAD Voicepointer %x,%d,%d\n", inst, bankId, instId); + gAudioErrorFlags = ((bankId << 8) + instId) + 0x2000000; + return NULL; +#else + return inst; +#endif +} + +struct Drum *get_drum(s32 bankId, s32 drumId) { + struct Drum *drum; + +#ifdef VERSION_SH + if (IS_BANK_LOAD_COMPLETE(bankId) == FALSE) { + stubbed_printf("Audio: voiceman: No bank error %d\n", bankId); + gAudioErrorFlags = bankId + 0x10000000; + return NULL; + } +#endif + + if (drumId >= gCtlEntries[bankId].numDrums) { + stubbed_printf("Audio: voiceman: Percussion Overflow %d,%d\n", + drumId, gCtlEntries[bankId].numDrums); + gAudioErrorFlags = ((bankId << 8) + drumId) + 0x4000000; + return NULL; + } + +#ifndef NO_SEGMENTED_MEMORY + if ((uintptr_t) gCtlEntries[bankId].drums < 0x80000000U) { + stubbed_printf("Percussion Pointer Error\n"); + return NULL; + } +#endif + + drum = gCtlEntries[bankId].drums[drumId]; + if (drum == NULL) { + stubbed_printf("Audio: voiceman: Percpointer NULL %d,%d\n", bankId, drumId); + gAudioErrorFlags = ((bankId << 8) + drumId) + 0x5000000; + } + return drum; +} +#endif +#endif // VERSION_EU + +#if defined(VERSION_EU) || defined(VERSION_SH) +void note_init_for_layer(struct Note *note, struct SequenceChannelLayer *seqLayer); +#else +s32 note_init_for_layer(struct Note *note, struct SequenceChannelLayer *seqLayer); +#endif + +void note_init(struct Note *note) { + if (note->parentLayer->adsr.releaseRate == 0) { + adsr_init(¬e->adsr, note->parentLayer->seqChannel->adsr.envelope, ¬e->adsrVolScale); + } else { + adsr_init(¬e->adsr, note->parentLayer->adsr.envelope, ¬e->adsrVolScale); + } +#ifdef VERSION_SH + note->unkSH34 = 0; +#endif + note->adsr.state = ADSR_STATE_INITIAL; +#if defined(VERSION_EU) || defined(VERSION_SH) + note->noteSubEu = gDefaultNoteSub; +#else + note_init_volume(note); + note_enable(note); +#endif +} + +#if defined(VERSION_EU) || defined(VERSION_SH) +#define note_disable2 note_disable +void note_disable(struct Note *note) { + if (note->noteSubEu.needsInit == TRUE) { + note->noteSubEu.needsInit = FALSE; + } +#ifdef VERSION_EU + else { + note_set_vel_pan_reverb(note, 0, 0x40, 0); + } +#endif + note->priority = NOTE_PRIORITY_DISABLED; +#ifdef VERSION_SH + note->unkSH34 = 0; +#endif + note->parentLayer = NO_LAYER; + note->prevParentLayer = NO_LAYER; + note->noteSubEu.enabled = FALSE; + note->noteSubEu.finished = FALSE; +#ifdef VERSION_SH + note->adsr.state = ADSR_STATE_DISABLED; + note->adsr.current = 0; +#endif +} +#else +void note_disable2(struct Note *note) { + note_disable(note); +} +#endif // VERSION_EU || VERSION_SH + +void process_notes(void) { + f32 scale; +#ifndef VERSION_SH + f32 frequency; +#if defined(VERSION_JP) || defined(VERSION_US) + u8 reverbVol; +#endif + f32 velocity; +#if defined(VERSION_JP) || defined(VERSION_US) + f32 pan; + f32 cap; +#endif +#endif + struct Note *note; +#if defined(VERSION_EU) || defined(VERSION_SH) + struct NotePlaybackState *playbackState; + struct NoteSubEu *noteSubEu; +#ifndef VERSION_SH + UNUSED u8 pad[12]; + u8 reverbVol; + UNUSED u8 pad3; + u8 pan; +#else + UNUSED u8 pad[8]; + struct ReverbInfo reverbInfo; +#endif + u8 bookOffset; +#endif + struct NoteAttributes *attributes; +#if defined(VERSION_JP) || defined(VERSION_US) + struct AudioListItem *it; +#endif + s32 i; + + // Macro versions of audio_list_push_front and audio_list_remove. + // Should ideally be changed to use copt. +#define PREPEND(item, head_arg) \ + ((it = (item), it->prev != NULL) \ + ? it \ + : (it->prev = (head_arg), it->next = (head_arg)->next, (head_arg)->next->prev = it, \ + (head_arg)->next = it, (head_arg)->u.count++, it->pool = (head_arg)->pool, it)) +#define POP(item) \ + ((it = (item), it->prev == NULL) \ + ? it \ + : (it->prev->next = it->next, it->next->prev = it->prev, it->prev = NULL, it)) + + for (i = 0; i < gMaxSimultaneousNotes; i++) { + note = &gNotes[i]; +#if defined(VERSION_EU) || defined(VERSION_SH) + playbackState = (struct NotePlaybackState *) ¬e->priority; + if (note->parentLayer != NO_LAYER) { +#ifndef NO_SEGMENTED_MEMORY + if ((uintptr_t) playbackState->parentLayer < 0x7fffffffU) { + continue; + } +#endif +#ifdef VERSION_SH + if (note != playbackState->parentLayer->note && playbackState->unkSH34 == 0) { + playbackState->adsr.action |= ADSR_ACTION_RELEASE; + playbackState->adsr.fadeOutVel = gAudioBufferParameters.updatesPerFrameInv; + playbackState->priority = 1; + playbackState->unkSH34 = 2; + goto d; + } else if (!playbackState->parentLayer->enabled && playbackState->unkSH34 == 0 && + playbackState->priority >= 1) { + // do nothing + } else if (playbackState->parentLayer->seqChannel->seqPlayer == NULL) { + sequence_channel_disable(playbackState->parentLayer->seqChannel); + playbackState->priority = 1; + playbackState->unkSH34 = 1; + continue; + } else if (playbackState->parentLayer->seqChannel->seqPlayer->muted && + (playbackState->parentLayer->seqChannel->muteBehavior + & (MUTE_BEHAVIOR_STOP_NOTES))) { + // do nothing + } else { + goto d; + } + + seq_channel_layer_note_release(playbackState->parentLayer); + audio_list_remove(¬e->listItem); + audio_list_push_front(¬e->listItem.pool->decaying, ¬e->listItem); + playbackState->priority = 1; + playbackState->unkSH34 = 2; + } else if (playbackState->unkSH34 == 0 && playbackState->priority >= 1) { + continue; + } +#else + if (!playbackState->parentLayer->enabled && playbackState->priority >= NOTE_PRIORITY_MIN) { + goto c; + } else if (playbackState->parentLayer->seqChannel->seqPlayer == NULL) { + eu_stubbed_printf_0("CAUTION:SUB IS SEPARATED FROM GROUP"); + sequence_channel_disable(playbackState->parentLayer->seqChannel); + playbackState->priority = NOTE_PRIORITY_STOPPING; + continue; + } else if (playbackState->parentLayer->seqChannel->seqPlayer->muted) { + if ((playbackState->parentLayer->seqChannel->muteBehavior + & (MUTE_BEHAVIOR_STOP_SCRIPT | MUTE_BEHAVIOR_STOP_NOTES))) { + goto c; + } + } + goto d; + if (1) { + c: + seq_channel_layer_note_release(playbackState->parentLayer); + audio_list_remove(¬e->listItem); + audio_list_push_front(¬e->listItem.pool->decaying, ¬e->listItem); + playbackState->priority = NOTE_PRIORITY_STOPPING; + } + } else if (playbackState->priority >= NOTE_PRIORITY_MIN) { + continue; + } +#endif + d: + if (playbackState->priority != NOTE_PRIORITY_DISABLED) { +#ifdef VERSION_SH + if (1) {} +#endif + noteSubEu = ¬e->noteSubEu; +#ifdef VERSION_SH + if (playbackState->unkSH34 >= 1 || noteSubEu->finished) { +#else + if (playbackState->priority == NOTE_PRIORITY_STOPPING || noteSubEu->finished) { +#endif + if (playbackState->adsr.state == ADSR_STATE_DISABLED || noteSubEu->finished) { + if (playbackState->wantedParentLayer != NO_LAYER) { + note_disable(note); + if (playbackState->wantedParentLayer->seqChannel != NULL) { + note_init_for_layer(note, playbackState->wantedParentLayer); + note_vibrato_init(note); + audio_list_remove(¬e->listItem); + audio_list_push_back(¬e->listItem.pool->active, ¬e->listItem); + playbackState->wantedParentLayer = NO_LAYER; + // don't skip + } else { + eu_stubbed_printf_0("Error:Wait Track disappear\n"); + note_disable(note); + audio_list_remove(¬e->listItem); + audio_list_push_back(¬e->listItem.pool->disabled, ¬e->listItem); + playbackState->wantedParentLayer = NO_LAYER; + goto skip; + } + } else { + note_disable(note); + audio_list_remove(¬e->listItem); + audio_list_push_back(¬e->listItem.pool->disabled, ¬e->listItem); + goto skip; + } + } +#ifndef VERSION_SH + if (1) { + } +#endif + } else if (playbackState->adsr.state == ADSR_STATE_DISABLED) { + note_disable(note); + audio_list_remove(¬e->listItem); + audio_list_push_back(¬e->listItem.pool->disabled, ¬e->listItem); + goto skip; + } + + scale = adsr_update(&playbackState->adsr); + note_vibrato_update(note); + attributes = &playbackState->attributes; +#ifdef VERSION_SH + if (playbackState->unkSH34 == 1 || playbackState->unkSH34 == 2) { + reverbInfo.freqScale = attributes->freqScale; + reverbInfo.velocity = attributes->velocity; + reverbInfo.pan = attributes->pan; + reverbInfo.reverbVol = attributes->reverbVol; + reverbInfo.reverbBits = attributes->reverbBits; + reverbInfo.synthesisVolume = attributes->synthesisVolume; + reverbInfo.filter = attributes->filter; + bookOffset = noteSubEu->bookOffset; + } else { + reverbInfo.freqScale = playbackState->parentLayer->noteFreqScale; + reverbInfo.velocity = playbackState->parentLayer->noteVelocity; + reverbInfo.pan = playbackState->parentLayer->notePan; + reverbInfo.reverbBits = playbackState->parentLayer->reverbBits; + reverbInfo.reverbVol = playbackState->parentLayer->seqChannel->reverbVol; + reverbInfo.synthesisVolume = playbackState->parentLayer->seqChannel->synthesisVolume; + reverbInfo.filter = playbackState->parentLayer->seqChannel->filter; + bookOffset = playbackState->parentLayer->seqChannel->bookOffset & 0x7; + if (playbackState->parentLayer->seqChannel->seqPlayer->muted + && (playbackState->parentLayer->seqChannel->muteBehavior & 8)) { + reverbInfo.freqScale = 0.0f; + reverbInfo.velocity = 0.0f; + } + } + + reverbInfo.freqScale *= playbackState->vibratoFreqScale * playbackState->portamentoFreqScale; + reverbInfo.freqScale *= gAudioBufferParameters.resampleRate; + reverbInfo.velocity *= scale; + note_set_vel_pan_reverb(note, &reverbInfo); +#else + if (playbackState->priority == NOTE_PRIORITY_STOPPING) { + frequency = attributes->freqScale; + velocity = attributes->velocity; + pan = attributes->pan; + reverbVol = attributes->reverbVol; + if (1) { + } + bookOffset = noteSubEu->bookOffset; + } else { + frequency = playbackState->parentLayer->noteFreqScale; + velocity = playbackState->parentLayer->noteVelocity; + pan = playbackState->parentLayer->notePan; + reverbVol = playbackState->parentLayer->seqChannel->reverbVol; + bookOffset = playbackState->parentLayer->seqChannel->bookOffset & 0x7; + } + + frequency *= playbackState->vibratoFreqScale * playbackState->portamentoFreqScale; + frequency *= gAudioBufferParameters.resampleRate; + velocity = velocity * scale * scale; + note_set_resampling_rate(note, frequency); + note_set_vel_pan_reverb(note, velocity, pan, reverbVol); +#endif + noteSubEu->bookOffset = bookOffset; + skip:; + } +#else + if (note->priority != NOTE_PRIORITY_DISABLED) { + if (note->priority == NOTE_PRIORITY_STOPPING || note->finished) { + if (note->adsrVolScale == 0 || note->finished) { + if (note->wantedParentLayer != NO_LAYER) { + note_disable2(note); + if (note->wantedParentLayer->seqChannel != NULL) { + if (note_init_for_layer(note, note->wantedParentLayer) == TRUE) { + note_disable2(note); + POP(¬e->listItem); + PREPEND(¬e->listItem, &gNoteFreeLists.disabled); + } else { + note_vibrato_init(note); + audio_list_push_back(¬e->listItem.pool->active, + POP(¬e->listItem)); + note->wantedParentLayer = NO_LAYER; + } + } else { + note_disable2(note); + audio_list_push_back(¬e->listItem.pool->disabled, POP(¬e->listItem)); + note->wantedParentLayer = NO_LAYER; + continue; + } + } else { + note_disable2(note); + audio_list_push_back(¬e->listItem.pool->disabled, POP(¬e->listItem)); + continue; + } + } + } else { + if (note->adsr.state == ADSR_STATE_DISABLED) { + note_disable2(note); + audio_list_push_back(¬e->listItem.pool->disabled, POP(¬e->listItem)); + continue; + } + } + + adsr_update(¬e->adsr); + note_vibrato_update(note); + attributes = ¬e->attributes; + if (note->priority == NOTE_PRIORITY_STOPPING) { + frequency = attributes->freqScale; + velocity = attributes->velocity; + pan = attributes->pan; + reverbVol = attributes->reverbVol; + } else { + frequency = note->parentLayer->noteFreqScale; + velocity = note->parentLayer->noteVelocity; + pan = note->parentLayer->notePan; + reverbVol = note->parentLayer->seqChannel->reverbVol; + } + + scale = note->adsrVolScale; + frequency *= note->vibratoFreqScale * note->portamentoFreqScale; + cap = 3.99992f; + if (gAiFrequency != 32006) { + frequency *= US_FLOAT(32000.0) / (f32) gAiFrequency; + } + frequency = (frequency < cap ? frequency : cap); + scale *= 4.3498e-5f; // ~1 / 23000 + velocity = velocity * scale * scale; + note_set_frequency(note, frequency); + note_set_vel_pan_reverb(note, velocity, pan, reverbVol); + continue; + } +#endif + } +#undef PREPEND +#undef POP +} + +#if defined(VERSION_SH) +// These three are matching but have been moved from above in shindou: +struct AudioBankSound *instrument_get_audio_bank_sound(struct Instrument *instrument, s32 semitone) { + struct AudioBankSound *sound; + if (semitone < instrument->normalRangeLo) { + sound = &instrument->lowNotesSound; + } else if (semitone <= instrument->normalRangeHi) { + sound = &instrument->normalNotesSound; + } else { + sound = &instrument->highNotesSound; + } + return sound; +} +struct Instrument *get_instrument_inner(s32 bankId, s32 instId) { + struct Instrument *inst; + + if (IS_BANK_LOAD_COMPLETE(bankId) == FALSE) { + gAudioErrorFlags = bankId + 0x10000000; + return NULL; + } + + if (instId >= gCtlEntries[bankId].numInstruments) { + gAudioErrorFlags = ((bankId << 8) + instId) + 0x3000000; + return NULL; + } + + inst = gCtlEntries[bankId].instruments[instId]; + if (inst == NULL) { + gAudioErrorFlags = ((bankId << 8) + instId) + 0x1000000; + return inst; + } + + return inst; +} + +struct Drum *get_drum(s32 bankId, s32 drumId) { + struct Drum *drum; + + if (IS_BANK_LOAD_COMPLETE(bankId) == FALSE) { + gAudioErrorFlags = bankId + 0x10000000; + return NULL; + } + + if (drumId >= gCtlEntries[bankId].numDrums) { + gAudioErrorFlags = ((bankId << 8) + drumId) + 0x4000000; + return NULL; + } + +#ifndef NO_SEGMENTED_MEMORY + if ((uintptr_t) gCtlEntries[bankId].drums < 0x80000000U) { + return NULL; + } +#endif + + drum = gCtlEntries[bankId].drums[drumId]; + if (drum == NULL) { + gAudioErrorFlags = ((bankId << 8) + drumId) + 0x5000000; + } + return drum; +} +#endif + +void seq_channel_layer_decay_release_internal(struct SequenceChannelLayer *seqLayer, s32 target) { + struct Note *note; + struct NoteAttributes *attributes; + + if (seqLayer == NO_LAYER) { + return; + } + +#ifdef VERSION_SH + seqLayer->status = SOUND_LOAD_STATUS_NOT_LOADED; +#endif + + if (seqLayer->note == NULL) { + return; + } + + note = seqLayer->note; + attributes = ¬e->attributes; + +#if defined(VERSION_JP) || defined(VERSION_US) + if (seqLayer->seqChannel != NULL && seqLayer->seqChannel->noteAllocPolicy == 0) { + seqLayer->note = NULL; + } +#endif + + if (note->wantedParentLayer == seqLayer) { + note->wantedParentLayer = NO_LAYER; + } + + if (note->parentLayer != seqLayer) { + +#if defined(VERSION_EU) || defined(VERSION_SH) + if (note->parentLayer == NO_LAYER && note->wantedParentLayer == NO_LAYER && + note->prevParentLayer == seqLayer && target != ADSR_STATE_DECAY) { + // Just guessing that this printf goes here... it's hard to parse. + eu_stubbed_printf_0("Slow Release Batting\n"); + note->adsr.fadeOutVel = gAudioBufferParameters.updatesPerFrameInv; + note->adsr.action |= ADSR_ACTION_RELEASE; + } +#endif + return; + } + +#ifndef VERSION_SH + seqLayer->status = SOUND_LOAD_STATUS_NOT_LOADED; +#endif + if (note->adsr.state != ADSR_STATE_DECAY) { + attributes->freqScale = seqLayer->noteFreqScale; + attributes->velocity = seqLayer->noteVelocity; + attributes->pan = seqLayer->notePan; +#ifdef VERSION_SH + attributes->reverbBits = seqLayer->reverbBits; +#endif + if (seqLayer->seqChannel != NULL) { + attributes->reverbVol = seqLayer->seqChannel->reverbVol; +#ifdef VERSION_SH + attributes->synthesisVolume = seqLayer->seqChannel->synthesisVolume; + attributes->filter = seqLayer->seqChannel->filter; + if (seqLayer->seqChannel->seqPlayer->muted && (seqLayer->seqChannel->muteBehavior & 8) != 0) { + note->noteSubEu.finished = TRUE; + } + note->priority = seqLayer->seqChannel->unkSH06; +#endif + } +#ifdef VERSION_SH + else { +#endif + note->priority = NOTE_PRIORITY_STOPPING; +#ifdef VERSION_SH + } +#endif + note->prevParentLayer = note->parentLayer; + note->parentLayer = NO_LAYER; + if (target == ADSR_STATE_RELEASE) { +#if defined(VERSION_EU) || defined(VERSION_SH) + note->adsr.fadeOutVel = gAudioBufferParameters.updatesPerFrameInv; +#else + note->adsr.fadeOutVel = 0x8000 / gAudioUpdatesPerFrame; +#endif + note->adsr.action |= ADSR_ACTION_RELEASE; +#ifdef VERSION_SH + note->unkSH34 = 2; +#endif + } else { +#ifdef VERSION_SH + note->unkSH34 = 1; +#endif + note->adsr.action |= ADSR_ACTION_DECAY; +#if defined(VERSION_EU) || defined(VERSION_SH) + if (seqLayer->adsr.releaseRate == 0) { + note->adsr.fadeOutVel = seqLayer->seqChannel->adsr.releaseRate * gAudioBufferParameters.unkUpdatesPerFrameScaled; + } else { + note->adsr.fadeOutVel = seqLayer->adsr.releaseRate * gAudioBufferParameters.unkUpdatesPerFrameScaled; + } + note->adsr.sustain = (FLOAT_CAST(seqLayer->seqChannel->adsr.sustain) * note->adsr.current) / 256.0f; +#else + if (seqLayer->adsr.releaseRate == 0) { + note->adsr.fadeOutVel = seqLayer->seqChannel->adsr.releaseRate * 24; + } else { + note->adsr.fadeOutVel = seqLayer->adsr.releaseRate * 24; + } + note->adsr.sustain = (note->adsr.current * seqLayer->seqChannel->adsr.sustain) / 0x10000; +#endif + } + } + + if (target == ADSR_STATE_DECAY) { + audio_list_remove(¬e->listItem); + audio_list_push_front(¬e->listItem.pool->decaying, ¬e->listItem); + } +} + +void seq_channel_layer_note_decay(struct SequenceChannelLayer *seqLayer) { + seq_channel_layer_decay_release_internal(seqLayer, ADSR_STATE_DECAY); +} + +void seq_channel_layer_note_release(struct SequenceChannelLayer *seqLayer) { + seq_channel_layer_decay_release_internal(seqLayer, ADSR_STATE_RELEASE); +} + +#if defined(VERSION_EU) || defined(VERSION_SH) +s32 build_synthetic_wave(struct Note *note, struct SequenceChannelLayer *seqLayer, s32 waveId) { + f32 freqScale; + f32 ratio; + u8 sampleCountIndex; + + if (waveId < 128) { +#ifdef VERSION_EU + stubbed_printf("Audio:Wavemem: Bad voiceno (%d)\n", waveId); +#endif + waveId = 128; + } + + freqScale = seqLayer->freqScale; + if (seqLayer->portamento.mode != 0 && 0.0f < seqLayer->portamento.extent) { + freqScale *= (seqLayer->portamento.extent + 1.0f); + } + if (freqScale < 1.0f) { + sampleCountIndex = 0; + ratio = 1.0465f; + } else if (freqScale < 2.0f) { + sampleCountIndex = 1; + ratio = 0.52325f; + } else if (freqScale < 4.0f) { + sampleCountIndex = 2; + ratio = 0.26263f; + } else { + sampleCountIndex = 3; + ratio = 0.13081f; + } + seqLayer->freqScale *= ratio; + note->waveId = waveId; + note->sampleCountIndex = sampleCountIndex; + + note->noteSubEu.sound.samples = &gWaveSamples[waveId - 128][sampleCountIndex * 64]; + + return sampleCountIndex; +} + +#else +void build_synthetic_wave(struct Note *note, struct SequenceChannelLayer *seqLayer) { + s32 i; + s32 j; + s32 pos; + s32 stepSize; + s32 offset; + u8 lim; + u8 origSampleCount = note->sampleCount; + + if (seqLayer->freqScale < US_FLOAT(1.0)) { + note->sampleCount = 64; + seqLayer->freqScale *= US_FLOAT(1.0465); + stepSize = 1; + } else if (seqLayer->freqScale < US_FLOAT(2.0)) { + note->sampleCount = 32; + seqLayer->freqScale *= US_FLOAT(0.52325); + stepSize = 2; + } else if (seqLayer->freqScale < US_FLOAT(4.0)) { + note->sampleCount = 16; + seqLayer->freqScale *= US_FLOAT(0.26263); + stepSize = 4; + } else { + note->sampleCount = 8; + seqLayer->freqScale *= US_FLOAT(0.13081); + stepSize = 8; + } + + if (note->sampleCount == origSampleCount && seqLayer->seqChannel->instOrWave == note->instOrWave) { + return; + } + + // Load wave sample + note->instOrWave = (u8) seqLayer->seqChannel->instOrWave; + for (i = -1, pos = 0; pos < 0x40; pos += stepSize) { + i++; + note->synthesisBuffers->samples[i] = gWaveSamples[seqLayer->seqChannel->instOrWave - 0x80][pos]; + } + + // Repeat sample + for (offset = note->sampleCount; offset < 0x40; offset += note->sampleCount) { + lim = note->sampleCount; + if (offset < 0 || offset > 0) { + for (j = 0; j < lim; j++) { + note->synthesisBuffers->samples[offset + j] = note->synthesisBuffers->samples[j]; + } + } else { + for (j = 0; j < lim; j++) { + note->synthesisBuffers->samples[offset + j] = note->synthesisBuffers->samples[j]; + } + } + } + + osWritebackDCache(note->synthesisBuffers->samples, sizeof(note->synthesisBuffers->samples)); +} +#endif + +void init_synthetic_wave(struct Note *note, struct SequenceChannelLayer *seqLayer) { +#if defined(VERSION_EU) || defined(VERSION_SH) + s32 sampleCountIndex; + s32 waveSampleCountIndex; + s32 waveId = seqLayer->instOrWave; + if (waveId == 0xff) { + waveId = seqLayer->seqChannel->instOrWave; + } + sampleCountIndex = note->sampleCountIndex; + waveSampleCountIndex = build_synthetic_wave(note, seqLayer, waveId); +#if defined(VERSION_EU) || defined(VERSION_SH) + note->synthesisState.samplePosInt = note->synthesisState.samplePosInt * euUnknownData_8030194c[waveSampleCountIndex] / euUnknownData_8030194c[sampleCountIndex]; +#else // Not a real change. Just temporary so I can remove this variable. + note->synthesisState.samplePosInt = note->synthesisState.samplePosInt * gDefaultShortNoteVelocityTable[waveSampleCountIndex] / gDefaultShortNoteVelocityTable[sampleCountIndex]; +#endif +#else + s32 sampleCount = note->sampleCount; + build_synthetic_wave(note, seqLayer); + if (sampleCount != 0) { + note->samplePosInt *= note->sampleCount / sampleCount; + } else { + note->samplePosInt = 0; + } +#endif +} + +void init_note_list(struct AudioListItem *list) { + list->prev = list; + list->next = list; + list->u.count = 0; +} + +void init_note_lists(struct NotePool *pool) { + init_note_list(&pool->disabled); + init_note_list(&pool->decaying); + init_note_list(&pool->releasing); + init_note_list(&pool->active); + pool->disabled.pool = pool; + pool->decaying.pool = pool; + pool->releasing.pool = pool; + pool->active.pool = pool; +} + +void init_note_free_list(void) { + s32 i; + + init_note_lists(&gNoteFreeLists); + for (i = 0; i < gMaxSimultaneousNotes; i++) { + gNotes[i].listItem.u.value = &gNotes[i]; + gNotes[i].listItem.prev = NULL; + audio_list_push_back(&gNoteFreeLists.disabled, &gNotes[i].listItem); + } +} + +void note_pool_clear(struct NotePool *pool) { + s32 i; + struct AudioListItem *source; + struct AudioListItem *cur; + struct AudioListItem *dest; + UNUSED s32 j; // unused in EU + + for (i = 0; i < 4; i++) { + switch (i) { + case 0: + source = &pool->disabled; + dest = &gNoteFreeLists.disabled; + break; + + case 1: + source = &pool->decaying; + dest = &gNoteFreeLists.decaying; + break; + + case 2: + source = &pool->releasing; + dest = &gNoteFreeLists.releasing; + break; + + case 3: + source = &pool->active; + dest = &gNoteFreeLists.active; + break; + } + +#if defined(VERSION_EU) || defined(VERSION_SH) + for (;;) { + cur = source->next; + if (cur == source) { + break; + } + if (cur == NULL) { + eu_stubbed_printf_0("Audio: C-Alloc : Dealloc voice is NULL\n"); + break; + } + audio_list_remove(cur); + audio_list_push_back(dest, cur); + } +#else + j = 0; + do { + cur = source->next; + if (cur == source) { + break; + } + audio_list_remove(cur); + audio_list_push_back(dest, cur); + j++; + } while (j <= gMaxSimultaneousNotes); +#endif + } +} + +void note_pool_fill(struct NotePool *pool, s32 count) { + s32 i; + s32 j; + struct Note *note; + struct AudioListItem *source; + struct AudioListItem *dest; + + note_pool_clear(pool); + + for (i = 0, j = 0; j < count; i++) { + if (i == 4) { + eu_stubbed_printf_1("Alloc Error:Dim voice-Alloc %d", count); + return; + } + + switch (i) { + case 0: + source = &gNoteFreeLists.disabled; + dest = &pool->disabled; + break; + + case 1: + source = &gNoteFreeLists.decaying; + dest = &pool->decaying; + break; + + case 2: + source = &gNoteFreeLists.releasing; + dest = &pool->releasing; + break; + + case 3: + source = &gNoteFreeLists.active; + dest = &pool->active; + break; + } + + while (j < count) { + note = audio_list_pop_back(source); + if (note == NULL) { + break; + } + audio_list_push_back(dest, ¬e->listItem); + j++; + } + } +} + +void audio_list_push_front(struct AudioListItem *list, struct AudioListItem *item) { + // add 'item' to the front of the list given by 'list', if it's not in any list + if (item->prev != NULL) { + eu_stubbed_printf_0("Error:Same List Add\n"); + } else { + item->prev = list; + item->next = list->next; + list->next->prev = item; + list->next = item; + list->u.count++; + item->pool = list->pool; + } +} + +void audio_list_remove(struct AudioListItem *item) { + // remove 'item' from the list it's in, if any + if (item->prev == NULL) { + eu_stubbed_printf_0("Already Cut\n"); + } else { + item->prev->next = item->next; + item->next->prev = item->prev; + item->prev = NULL; + } +} + +struct Note *pop_node_with_lower_prio(struct AudioListItem *list, s32 limit) { + struct AudioListItem *cur = list->next; + struct AudioListItem *best; + + if (cur == list) { + return NULL; + } + + for (best = cur; cur != list; cur = cur->next) { + if (((struct Note *) best->u.value)->priority >= ((struct Note *) cur->u.value)->priority) { + best = cur; + } + } + +#if defined(VERSION_EU) || defined(VERSION_SH) + if (best == NULL) { + return NULL; + } + + if (limit <= ((struct Note *) best->u.value)->priority) { + return NULL; + } +#else + if (limit < ((struct Note *) best->u.value)->priority) { + return NULL; + } +#endif + +#ifndef VERSION_SH + audio_list_remove(best); +#endif + return best->u.value; +} + +#if defined(VERSION_EU) || defined(VERSION_SH) +void note_init_for_layer(struct Note *note, struct SequenceChannelLayer *seqLayer) { + UNUSED s32 pad[4]; + s16 instId; + struct NoteSubEu *sub = ¬e->noteSubEu; + + note->prevParentLayer = NO_LAYER; + note->parentLayer = seqLayer; + note->priority = seqLayer->seqChannel->notePriority; + seqLayer->notePropertiesNeedInit = TRUE; + seqLayer->status = SOUND_LOAD_STATUS_DISCARDABLE; // "loaded" + seqLayer->note = note; + seqLayer->seqChannel->noteUnused = note; + seqLayer->seqChannel->layerUnused = seqLayer; + seqLayer->noteVelocity = 0.0f; + note_init(note); + instId = seqLayer->instOrWave; + if (instId == 0xff) { + instId = seqLayer->seqChannel->instOrWave; + } + sub->sound.audioBankSound = seqLayer->sound; + + if (instId >= 0x80) { + sub->isSyntheticWave = TRUE; + } else { + sub->isSyntheticWave = FALSE; + } + + if (sub->isSyntheticWave) { + build_synthetic_wave(note, seqLayer, instId); + } +#ifdef VERSION_SH + note->bankId = seqLayer->seqChannel->bankId; +#else + sub->bankId = seqLayer->seqChannel->bankId; +#endif + sub->stereoHeadsetEffects = seqLayer->seqChannel->stereoHeadsetEffects; + sub->reverbIndex = seqLayer->seqChannel->reverbIndex & 3; +} +#else +s32 note_init_for_layer(struct Note *note, struct SequenceChannelLayer *seqLayer) { + note->prevParentLayer = NO_LAYER; + note->parentLayer = seqLayer; + note->priority = seqLayer->seqChannel->notePriority; + if (IS_BANK_LOAD_COMPLETE(seqLayer->seqChannel->bankId) == FALSE) { + return TRUE; + } + + note->bankId = seqLayer->seqChannel->bankId; + note->stereoHeadsetEffects = seqLayer->seqChannel->stereoHeadsetEffects; + note->sound = seqLayer->sound; + seqLayer->status = SOUND_LOAD_STATUS_DISCARDABLE; // "loaded" + seqLayer->note = note; + seqLayer->seqChannel->noteUnused = note; + seqLayer->seqChannel->layerUnused = seqLayer; + if (note->sound == NULL) { + build_synthetic_wave(note, seqLayer); + } + note_init(note); + return FALSE; +} +#endif + +void func_80319728(struct Note *note, struct SequenceChannelLayer *seqLayer) { + seq_channel_layer_note_release(note->parentLayer); + note->wantedParentLayer = seqLayer; +} + +void note_release_and_take_ownership(struct Note *note, struct SequenceChannelLayer *seqLayer) { + note->wantedParentLayer = seqLayer; +#ifdef VERSION_SH + note->priority = seqLayer->seqChannel->notePriority; +#else + note->priority = NOTE_PRIORITY_STOPPING; +#endif + +#if defined(VERSION_EU) || defined(VERSION_SH) + note->adsr.fadeOutVel = gAudioBufferParameters.updatesPerFrameInv; +#else + note->adsr.fadeOutVel = 0x8000 / gAudioUpdatesPerFrame; +#endif + note->adsr.action |= ADSR_ACTION_RELEASE; +} + +struct Note *alloc_note_from_disabled(struct NotePool *pool, struct SequenceChannelLayer *seqLayer) { + struct Note *note = audio_list_pop_back(&pool->disabled); + if (note != NULL) { +#if defined(VERSION_EU) || defined(VERSION_SH) + note_init_for_layer(note, seqLayer); +#else + if (note_init_for_layer(note, seqLayer) == TRUE) { + audio_list_push_front(&gNoteFreeLists.disabled, ¬e->listItem); + return NULL; + } +#endif + audio_list_push_front(&pool->active, ¬e->listItem); + } + return note; +} + +struct Note *alloc_note_from_decaying(struct NotePool *pool, struct SequenceChannelLayer *seqLayer) { + struct Note *note = audio_list_pop_back(&pool->decaying); + if (note != NULL) { + note_release_and_take_ownership(note, seqLayer); + audio_list_push_back(&pool->releasing, ¬e->listItem); + } + return note; +} + +struct Note *alloc_note_from_active(struct NotePool *pool, struct SequenceChannelLayer *seqLayer) { +#ifdef VERSION_SH + struct Note *rNote; +#endif + struct Note *aNote; +#ifdef VERSION_SH + s32 rPriority, aPriority; + rPriority = aPriority = 0x10; + + rNote = pop_node_with_lower_prio(&pool->releasing, seqLayer->seqChannel->notePriority); + + if (rNote != NULL) { + rPriority = rNote->priority; + } +#endif + + aNote = pop_node_with_lower_prio(&pool->active, seqLayer->seqChannel->notePriority); + + if (aNote == NULL) { + eu_stubbed_printf_0("Audio: C-Alloc : lowerPrio is NULL\n"); + } else { +#ifdef VERSION_SH + aPriority = aNote->priority; +#else + func_80319728(aNote, seqLayer); + audio_list_push_back(&pool->releasing, &aNote->listItem); +#endif + } + +#ifdef VERSION_SH + if (rNote == NULL && aNote == NULL) { + return NULL; + } + + if (aPriority < rPriority) { + audio_list_remove(&aNote->listItem); + func_80319728(aNote, seqLayer); + audio_list_push_back(&pool->releasing, &aNote->listItem); + aNote->priority = seqLayer->seqChannel->notePriority; + return aNote; + } + rNote->wantedParentLayer = seqLayer; + rNote->priority = seqLayer->seqChannel->notePriority; + return rNote; +#else + return aNote; +#endif +} + +struct Note *alloc_note(struct SequenceChannelLayer *seqLayer) { + struct Note *ret; + u32 policy = seqLayer->seqChannel->noteAllocPolicy; + + if (policy & NOTE_ALLOC_LAYER) { + ret = seqLayer->note; + if (ret != NULL && ret->prevParentLayer == seqLayer +#if defined(VERSION_EU) || defined(VERSION_SH) + && ret->wantedParentLayer == NO_LAYER +#endif + ) { + note_release_and_take_ownership(ret, seqLayer); + audio_list_remove(&ret->listItem); +#if defined(VERSION_EU) || defined(VERSION_SH) + audio_list_push_back(&ret->listItem.pool->releasing, &ret->listItem); +#else + audio_list_push_back(&gNoteFreeLists.releasing, &ret->listItem); +#endif + return ret; + } + } + + if (policy & NOTE_ALLOC_CHANNEL) { + if (!(ret = alloc_note_from_disabled(&seqLayer->seqChannel->notePool, seqLayer)) + && !(ret = alloc_note_from_decaying(&seqLayer->seqChannel->notePool, seqLayer)) + && !(ret = alloc_note_from_active(&seqLayer->seqChannel->notePool, seqLayer))) { +#ifdef VERSION_SH + goto null_return; +#else + eu_stubbed_printf_0("Sub Limited Warning: Drop Voice"); + seqLayer->status = SOUND_LOAD_STATUS_NOT_LOADED; + return NULL; +#endif + } + return ret; + } + + if (policy & NOTE_ALLOC_SEQ) { + if (!(ret = alloc_note_from_disabled(&seqLayer->seqChannel->notePool, seqLayer)) + && !(ret = alloc_note_from_disabled(&seqLayer->seqChannel->seqPlayer->notePool, seqLayer)) + && !(ret = alloc_note_from_decaying(&seqLayer->seqChannel->notePool, seqLayer)) + && !(ret = alloc_note_from_decaying(&seqLayer->seqChannel->seqPlayer->notePool, seqLayer)) + && !(ret = alloc_note_from_active(&seqLayer->seqChannel->notePool, seqLayer)) + && !(ret = alloc_note_from_active(&seqLayer->seqChannel->seqPlayer->notePool, seqLayer))) { +#ifdef VERSION_SH + goto null_return; +#else + eu_stubbed_printf_0("Warning: Drop Voice"); + seqLayer->status = SOUND_LOAD_STATUS_NOT_LOADED; + return NULL; +#endif + } + return ret; + } + + if (policy & NOTE_ALLOC_GLOBAL_FREELIST) { + if (!(ret = alloc_note_from_disabled(&gNoteFreeLists, seqLayer)) + && !(ret = alloc_note_from_decaying(&gNoteFreeLists, seqLayer)) + && !(ret = alloc_note_from_active(&gNoteFreeLists, seqLayer))) { +#ifdef VERSION_SH + goto null_return; +#else + eu_stubbed_printf_0("Warning: Drop Voice"); + seqLayer->status = SOUND_LOAD_STATUS_NOT_LOADED; + return NULL; +#endif + } + return ret; + } + + if (!(ret = alloc_note_from_disabled(&seqLayer->seqChannel->notePool, seqLayer)) + && !(ret = alloc_note_from_disabled(&seqLayer->seqChannel->seqPlayer->notePool, seqLayer)) + && !(ret = alloc_note_from_disabled(&gNoteFreeLists, seqLayer)) + && !(ret = alloc_note_from_decaying(&seqLayer->seqChannel->notePool, seqLayer)) + && !(ret = alloc_note_from_decaying(&seqLayer->seqChannel->seqPlayer->notePool, seqLayer)) + && !(ret = alloc_note_from_decaying(&gNoteFreeLists, seqLayer)) + && !(ret = alloc_note_from_active(&seqLayer->seqChannel->notePool, seqLayer)) + && !(ret = alloc_note_from_active(&seqLayer->seqChannel->seqPlayer->notePool, seqLayer)) + && !(ret = alloc_note_from_active(&gNoteFreeLists, seqLayer))) { +#ifdef VERSION_SH + goto null_return; +#else + eu_stubbed_printf_0("Warning: Drop Voice"); + seqLayer->status = SOUND_LOAD_STATUS_NOT_LOADED; + return NULL; +#endif + } + return ret; + +#ifdef VERSION_SH +null_return: + seqLayer->status = SOUND_LOAD_STATUS_NOT_LOADED; + return NULL; +#endif +} + +#if defined(VERSION_JP) || defined(VERSION_US) +void reclaim_notes(void) { + struct Note *note; + s32 i; + s32 cond; + + for (i = 0; i < gMaxSimultaneousNotes; i++) { + note = &gNotes[i]; + if (note->parentLayer != NO_LAYER) { + cond = FALSE; + if (!note->parentLayer->enabled && note->priority >= NOTE_PRIORITY_MIN) { + cond = TRUE; + } else if (note->parentLayer->seqChannel == NULL) { + audio_list_push_back(&gLayerFreeList, ¬e->parentLayer->listItem); + seq_channel_layer_disable(note->parentLayer); + note->priority = NOTE_PRIORITY_STOPPING; + } else if (note->parentLayer->seqChannel->seqPlayer == NULL) { + sequence_channel_disable(note->parentLayer->seqChannel); + note->priority = NOTE_PRIORITY_STOPPING; + } else if (note->parentLayer->seqChannel->seqPlayer->muted) { + if (note->parentLayer->seqChannel->muteBehavior + & (MUTE_BEHAVIOR_STOP_SCRIPT | MUTE_BEHAVIOR_STOP_NOTES)) { + cond = TRUE; + } + } else { + cond = FALSE; + } + + if (cond) { + seq_channel_layer_note_release(note->parentLayer); + audio_list_remove(¬e->listItem); + audio_list_push_front(¬e->listItem.pool->disabled, ¬e->listItem); + note->priority = NOTE_PRIORITY_STOPPING; + } + } + } +} +#endif + +void note_init_all(void) { + struct Note *note; + s32 i; + + for (i = 0; i < gMaxSimultaneousNotes; i++) { + note = &gNotes[i]; +#if defined(VERSION_EU) || defined(VERSION_SH) + note->noteSubEu = gZeroNoteSub; +#else + note->enabled = FALSE; + note->stereoStrongRight = FALSE; + note->stereoStrongLeft = FALSE; + note->stereoHeadsetEffects = FALSE; +#endif + note->priority = NOTE_PRIORITY_DISABLED; +#ifdef VERSION_SH + note->unkSH34 = 0; +#endif + note->parentLayer = NO_LAYER; + note->wantedParentLayer = NO_LAYER; + note->prevParentLayer = NO_LAYER; +#if defined(VERSION_EU) || defined(VERSION_SH) + note->waveId = 0; +#else + note->reverbVol = 0; + note->usesHeadsetPanEffects = FALSE; + note->sampleCount = 0; + note->instOrWave = 0; + note->targetVolLeft = 0; + note->targetVolRight = 0; + note->frequency = 0.0f; + note->unused1 = 0x3f; +#endif + note->attributes.velocity = 0.0f; + note->adsrVolScale = 0; + note->adsr.state = ADSR_STATE_DISABLED; + note->adsr.action = 0; + note->vibratoState.active = FALSE; + note->portamento.cur = 0.0f; + note->portamento.speed = 0.0f; +#if defined(VERSION_SH) + note->synthesisState.synthesisBuffers = sound_alloc_uninitialized(&gNotesAndBuffersPool, sizeof(struct NoteSynthesisBuffers)); +#elif defined(VERSION_EU) + note->synthesisState.synthesisBuffers = soundAlloc(&gNotesAndBuffersPool, sizeof(struct NoteSynthesisBuffers)); +#else + note->synthesisBuffers = soundAlloc(&gNotesAndBuffersPool, sizeof(struct NoteSynthesisBuffers)); +#endif + } +} diff --git a/src/decomp/audio/playback.h b/src/decomp/audio/playback.h new file mode 100644 index 0000000..e2e15bf --- /dev/null +++ b/src/decomp/audio/playback.h @@ -0,0 +1,50 @@ +#ifndef AUDIO_PLAYBACK_H +#define AUDIO_PLAYBACK_H + +#include + +#include "internal.h" + +// Mask bits denoting where to allocate notes from, according to a channel's +// noteAllocPolicy. Despite being checked as bitmask bits, the bits are not +// orthogonal; rather, the smallest bit wins, except for NOTE_ALLOC_LAYER, +// which *is* orthogonal to the other. SEQ implicitly includes CHANNEL. +// If none of the CHANNEL/SEQ/GLOBAL_FREELIST bits are set, all three locations +// are tried. +#define NOTE_ALLOC_LAYER 1 +#define NOTE_ALLOC_CHANNEL 2 +#define NOTE_ALLOC_SEQ 4 +#define NOTE_ALLOC_GLOBAL_FREELIST 8 + +void process_notes(void); +void seq_channel_layer_note_decay(struct SequenceChannelLayer *seqLayer); +void seq_channel_layer_note_release(struct SequenceChannelLayer *seqLayer); +void init_synthetic_wave(struct Note *note, struct SequenceChannelLayer *seqLayer); +void init_note_lists(struct NotePool *pool); +void init_note_free_list(void); +void note_pool_clear(struct NotePool *pool); +void note_pool_fill(struct NotePool *pool, s32 count); +void audio_list_push_front(struct AudioListItem *list, struct AudioListItem *item); +void audio_list_remove(struct AudioListItem *item); +struct Note *alloc_note(struct SequenceChannelLayer *seqLayer); +void reclaim_notes(void); +void note_init_all(void); + +#if defined(VERSION_SH) +void note_set_vel_pan_reverb(struct Note *note, struct ReverbInfo *reverbInfo); +#elif defined(VERSION_EU) +void note_set_vel_pan_reverb(struct Note *note, f32 velocity, u8 pan, u8 reverbVol); +#endif + +#if defined(VERSION_EU) || defined(VERSION_SH) +struct AudioBankSound *instrument_get_audio_bank_sound(struct Instrument *instrument, s32 semitone); +struct Instrument *get_instrument_inner(s32 bankId, s32 instId); +struct Drum *get_drum(s32 bankId, s32 drumId); +void note_init_volume(struct Note *note); +void note_set_frequency(struct Note *note, f32 frequency); +void note_enable(struct Note *note); +void note_disable(struct Note *note); +#endif + + +#endif // AUDIO_PLAYBACK_H diff --git a/src/decomp/audio/port_eu.c b/src/decomp/audio/port_eu.c new file mode 100644 index 0000000..d607f77 --- /dev/null +++ b/src/decomp/audio/port_eu.c @@ -0,0 +1,351 @@ +#include +#include "internal.h" +#include "load.h" +#include "data.h" +#include "seqplayer.h" +#include "synthesis.h" + +#ifdef VERSION_EU + +#ifdef __sgi +#define stubbed_printf +#else +#define stubbed_printf(...) +#endif + +#define SAMPLES_TO_OVERPRODUCE 0x10 +#define EXTRA_BUFFERED_AI_SAMPLES_TARGET 0x40 + +#ifdef VERSION_JP +typedef u16 FadeT; +#else +typedef s32 FadeT; +#endif + +extern volatile u8 gAudioResetStatus; +extern u8 gAudioResetPresetIdToLoad; +extern OSMesgQueue *OSMesgQueues[]; +extern struct EuAudioCmd sAudioCmd[0x100]; + +void func_8031D690(s32 player, FadeT fadeInTime); +void seq_player_fade_to_zero_volume(s32 player, FadeT fadeOutTime); +void decrease_sample_dma_ttls(void); +s32 audio_shut_down_and_reset_step(void); +void func_802ad7ec(u32); + +#ifdef TARGET_N64 +struct SPTask *create_next_audio_frame_task(void) { + u32 samplesRemainingInAI; + s32 writtenCmds; + s32 index; + OSTask_t *task; + s32 flags; + s16 *currAiBuffer; + s32 oldDmaCount; + OSMesg sp30; + OSMesg sp2C; + + gAudioFrameCount++; + if (gAudioFrameCount % gAudioBufferParameters.presetUnk4 != 0) { + stubbed_printf("DAC:Lost 1 Frame.\n"); + return NULL; + } + + osSendMesg(OSMesgQueues[0], (OSMesg) gAudioFrameCount, 0); + + gAudioTaskIndex ^= 1; + gCurrAiBufferIndex++; + gCurrAiBufferIndex %= NUMAIBUFFERS; + index = (gCurrAiBufferIndex - 2 + NUMAIBUFFERS) % NUMAIBUFFERS; + samplesRemainingInAI = osAiGetLength() / 4; + + if (gAiBufferLengths[index] != 0) { + osAiSetNextBuffer(gAiBuffers[index], gAiBufferLengths[index] * 4); + } + + oldDmaCount = gCurrAudioFrameDmaCount; + if (oldDmaCount > AUDIO_FRAME_DMA_QUEUE_SIZE) { + stubbed_printf("DMA: Request queue over.( %d )\n", oldDmaCount); + } + gCurrAudioFrameDmaCount = 0; + + decrease_sample_dma_ttls(); + if (osRecvMesg(OSMesgQueues[2], &sp30, 0) != -1) { + gAudioResetPresetIdToLoad = (u8) (s32) sp30; + gAudioResetStatus = 5; + } + + if (gAudioResetStatus != 0) { + if (audio_shut_down_and_reset_step() == 0) { + if (gAudioResetStatus == 0) { + osSendMesg(OSMesgQueues[3], (OSMesg) (s32) gAudioResetPresetIdToLoad, OS_MESG_NOBLOCK); + } + return NULL; + } + } + + gAudioTask = &gAudioTasks[gAudioTaskIndex]; + gAudioCmd = gAudioCmdBuffers[gAudioTaskIndex]; + index = gCurrAiBufferIndex; + currAiBuffer = gAiBuffers[index]; + + gAiBufferLengths[index] = ((gAudioBufferParameters.samplesPerFrameTarget - samplesRemainingInAI + + EXTRA_BUFFERED_AI_SAMPLES_TARGET) & ~0xf) + SAMPLES_TO_OVERPRODUCE; + if (gAiBufferLengths[index] < gAudioBufferParameters.minAiBufferLength) { + gAiBufferLengths[index] = gAudioBufferParameters.minAiBufferLength; + } + if (gAiBufferLengths[index] > gAudioBufferParameters.maxAiBufferLength) { + gAiBufferLengths[index] = gAudioBufferParameters.maxAiBufferLength; + } + + if (osRecvMesg(OSMesgQueues[1], &sp2C, OS_MESG_NOBLOCK) != -1) { + func_802ad7ec((u32) sp2C); + } + + flags = 0; + gAudioCmd = synthesis_execute(gAudioCmd, &writtenCmds, currAiBuffer, gAiBufferLengths[index]); + gAudioRandom = ((gAudioRandom + gAudioFrameCount) * gAudioFrameCount); + gAudioRandom = gAudioRandom + writtenCmds / 8; + + index = gAudioTaskIndex; + gAudioTask->msgqueue = NULL; + gAudioTask->msg = NULL; + + task = &gAudioTask->task.t; + task->type = M_AUDTASK; + task->flags = flags; + task->ucode_boot = rspF3DBootStart; + task->ucode_boot_size = (u8 *) rspF3DBootEnd - (u8 *) rspF3DBootStart; + task->ucode = rspAspMainStart; + task->ucode_data = rspAspMainDataStart; + task->ucode_size = 0x800; // (this size is ignored) + task->ucode_data_size = (rspAspMainDataEnd - rspAspMainDataStart) * sizeof(u64); + task->dram_stack = NULL; + task->dram_stack_size = 0; + task->output_buff = NULL; + task->output_buff_size = NULL; + task->data_ptr = gAudioCmdBuffers[index]; + task->data_size = writtenCmds * sizeof(u64); + task->yield_data_ptr = NULL; + task->yield_data_size = 0; + return gAudioTask; +} +#else +struct SPTask *create_next_audio_frame_task(void) { + return NULL; +} +void create_next_audio_buffer(s16 *samples, u32 num_samples) { + s32 writtenCmds; + OSMesg msg; + gAudioFrameCount++; + decrease_sample_dma_ttls(); + if (osRecvMesg(OSMesgQueues[2], &msg, 0) != -1) { + gAudioResetPresetIdToLoad = (u8) (intptr_t) msg; + gAudioResetStatus = 5; + } + + if (gAudioResetStatus != 0) { + audio_reset_session(); + gAudioResetStatus = 0; + } + if (osRecvMesg(OSMesgQueues[1], &msg, OS_MESG_NOBLOCK) != -1) { + func_802ad7ec((u32) msg); + } + synthesis_execute(gAudioCmdBuffers[0], &writtenCmds, samples, num_samples); + gAudioRandom = ((gAudioRandom + gAudioFrameCount) * gAudioFrameCount); + gAudioRandom = gAudioRandom + writtenCmds / 8; +} +#endif + +void eu_process_audio_cmd(struct EuAudioCmd *cmd) { + s32 i; + + switch (cmd->u.s.op) { + case 0x81: + preload_sequence(cmd->u.s.arg2, 3); + break; + + case 0x82: + case 0x88: + load_sequence(cmd->u.s.arg1, cmd->u.s.arg2, cmd->u.s.arg3); + func_8031D690(cmd->u.s.arg1, cmd->u2.as_s32); + break; + + case 0x83: + if (gSequencePlayers[cmd->u.s.arg1].enabled != FALSE) { + if (cmd->u2.as_s32 == 0) { + sequence_player_disable(&gSequencePlayers[cmd->u.s.arg1]); + } + else { + seq_player_fade_to_zero_volume(cmd->u.s.arg1, cmd->u2.as_s32); + } + } + break; + + case 0xf0: + gSoundMode = cmd->u2.as_s32; + break; + + case 0xf1: + for (i = 0; i < 4; i++) { + gSequencePlayers[i].muted = TRUE; + gSequencePlayers[i].recalculateVolume = TRUE; + } + break; + + case 0xf2: + for (i = 0; i < 4; i++) { + gSequencePlayers[i].muted = FALSE; + gSequencePlayers[i].recalculateVolume = TRUE; + } + break; + } +} + +const char undefportcmd[] = "Undefined Port Command %d\n"; + +extern OSMesgQueue *OSMesgQueues[]; +extern u8 D_EU_80302010; +extern u8 D_EU_80302014; +extern OSMesg OSMesg0; +extern OSMesg OSMesg1; +extern OSMesg OSMesg2; +extern OSMesg OSMesg3; + +void seq_player_fade_to_zero_volume(s32 player, FadeT fadeOutTime) { + if (fadeOutTime == 0) { + fadeOutTime = 1; + } + gSequencePlayers[player].fadeVelocity = -(gSequencePlayers[player].fadeVolume / fadeOutTime); + gSequencePlayers[player].state = 2; + gSequencePlayers[player].fadeRemainingFrames = fadeOutTime; + +} + +void func_8031D690(s32 player, FadeT fadeInTime) { + if (fadeInTime != 0) { + gSequencePlayers[player].state = 1; + gSequencePlayers[player].fadeTimerUnkEu = fadeInTime; + gSequencePlayers[player].fadeRemainingFrames = fadeInTime; + gSequencePlayers[player].fadeVolume = 0.0f; + gSequencePlayers[player].fadeVelocity = 0.0f; + } +} + +void port_eu_init_queues(void) { + D_EU_80302010 = 0; + D_EU_80302014 = 0; + osCreateMesgQueue(OSMesgQueues[0], &OSMesg0, 1); + osCreateMesgQueue(OSMesgQueues[1], &OSMesg1, 4); + osCreateMesgQueue(OSMesgQueues[2], &OSMesg2, 1); + osCreateMesgQueue(OSMesgQueues[3], &OSMesg3, 1); +} + +void func_802ad6f0(s32 arg0, s32 *arg1) { + struct EuAudioCmd *cmd = &sAudioCmd[D_EU_80302010 & 0xff]; + cmd->u.first = arg0; + cmd->u2.as_u32 = *arg1; + D_EU_80302010++; +} + +void func_802ad728(u32 arg0, f32 arg1) { + func_802ad6f0(arg0, (s32*) &arg1); +} + +void func_802ad74c(u32 arg0, u32 arg1) { + func_802ad6f0(arg0, (s32*) &arg1); +} + +void func_802ad770(u32 arg0, s8 arg1) { + s32 sp1C = arg1 << 24; + func_802ad6f0(arg0, &sp1C); +} + +void func_802ad7a0(void) { + osSendMesg(OSMesgQueues[1], + (OSMesg)(u32)((D_EU_80302014 & 0xff) << 8 | (D_EU_80302010 & 0xff)), + OS_MESG_NOBLOCK); + D_EU_80302014 = D_EU_80302010; +} + +void func_802ad7ec(u32 arg0) { + struct EuAudioCmd *cmd; + struct SequencePlayer *seqPlayer; + struct SequenceChannel *chan; + u8 end = arg0 & 0xff; + u8 i = (arg0 >> 8) & 0xff; + + for (;;) { + if (i == end) break; + cmd = &sAudioCmd[i++ & 0xff]; + + if (cmd->u.s.arg1 < SEQUENCE_PLAYERS) { + seqPlayer = &gSequencePlayers[cmd->u.s.arg1]; + if ((cmd->u.s.op & 0x80) != 0) { + eu_process_audio_cmd(cmd); + } + else if ((cmd->u.s.op & 0x40) != 0) { + switch (cmd->u.s.op) { + case 0x41: + seqPlayer->fadeVolumeScale = cmd->u2.as_f32; + seqPlayer->recalculateVolume = TRUE; + break; + + case 0x47: + seqPlayer->tempo = cmd->u2.as_s32 * TATUMS_PER_BEAT; + break; + + case 0x48: + seqPlayer->transposition = cmd->u2.as_s8; + break; + + case 0x46: + seqPlayer->seqVariationEu[cmd->u.s.arg3] = cmd->u2.as_s8; + break; + } + } + else if (seqPlayer->enabled != FALSE && cmd->u.s.arg2 < 0x10) { + chan = seqPlayer->channels[cmd->u.s.arg2]; + if (IS_SEQUENCE_CHANNEL_VALID(chan)) + { + switch (cmd->u.s.op) { + case 1: + chan->volumeScale = cmd->u2.as_f32; + chan->changes.as_bitfields.volume = TRUE; + break; + case 2: + chan->volume = cmd->u2.as_f32; + chan->changes.as_bitfields.volume = TRUE; + break; + case 3: + chan->newPan = cmd->u2.as_s8; + chan->changes.as_bitfields.pan = TRUE; + break; + case 4: + chan->freqScale = cmd->u2.as_f32; + chan->changes.as_bitfields.freqScale = TRUE; + break; + case 5: + chan->reverbVol = cmd->u2.as_s8; + break; + case 6: + if (cmd->u.s.arg3 < 8) { + chan->soundScriptIO[cmd->u.s.arg3] = cmd->u2.as_s8; + } + break; + case 8: + chan->stopSomething2 = cmd->u2.as_s8; + } + } + } + } + + cmd->u.s.op = 0; + } +} + +void port_eu_init(void) { + port_eu_init_queues(); +} + +#endif diff --git a/src/decomp/audio/port_sh.c b/src/decomp/audio/port_sh.c new file mode 100644 index 0000000..66cbc3b --- /dev/null +++ b/src/decomp/audio/port_sh.c @@ -0,0 +1,597 @@ +#ifdef VERSION_SH +// TODO: merge this with port_eu.c? + +#include + +#include "data.h" +#include "heap.h" +#include "load.h" +#include "synthesis.h" +#include "internal.h" +#include "seqplayer.h" + +#define EXTRA_BUFFERED_AI_SAMPLES_TARGET 0x80 +#define SAMPLES_TO_OVERPRODUCE 0x10 + +extern s32 D_SH_80314FC8; +extern struct SPTask *D_SH_80314FCC; +extern u8 D_SH_80315098; +extern u8 D_SH_8031509C; +extern OSMesgQueue *D_SH_80350F68; + +void func_8031D690(s32 playerIndex, s32 numFrames); +void seq_player_fade_to_zero_volume(s32 arg0, s32 numFrames); +void func_802ad7ec(u32 arg0); + +#ifdef TARGET_N64 +struct SPTask *create_next_audio_frame_task(void) { + u32 samplesRemainingInAI; + s32 writtenCmds; + s32 index; + OSTask_t *task; + s32 flags; + s16 *currAiBuffer; + s32 oldDmaCount; + s32 sp38; + s32 sp34; + s32 writtenCmdsCopy; + + gAudioFrameCount++; + if (gAudioFrameCount % gAudioBufferParameters.presetUnk4 != 0) { + if ((gAudioFrameCount % gAudioBufferParameters.presetUnk4) + 1 == gAudioBufferParameters.presetUnk4) { + return D_SH_80314FCC; + } + return NULL; + } + osSendMesg(D_SH_80350F38, (OSMesg) gAudioFrameCount, OS_MESG_NOBLOCK); + + gAudioTaskIndex ^= 1; + gCurrAiBufferIndex++; + gCurrAiBufferIndex %= NUMAIBUFFERS; + index = (gCurrAiBufferIndex - 2 + NUMAIBUFFERS) % NUMAIBUFFERS; + samplesRemainingInAI = osAiGetLength() / 4; + + if (gAudioLoadLockSH < 0x10U) { + if (gAiBufferLengths[index] != 0) { + osAiSetNextBuffer(gAiBuffers[index], gAiBufferLengths[index] * 4); + } + } + + oldDmaCount = gCurrAudioFrameDmaCount; + if (oldDmaCount > AUDIO_FRAME_DMA_QUEUE_SIZE) { + } + gCurrAudioFrameDmaCount = 0; + + decrease_sample_dma_ttls(); + func_sh_802f41e4(gAudioResetStatus); + if (osRecvMesg(D_SH_80350F88, (OSMesg *) &sp38, OS_MESG_NOBLOCK) != -1) { + if (gAudioResetStatus == 0) { + gAudioResetStatus = 5; + } + gAudioResetPresetIdToLoad = (u8) sp38; + } + + if (gAudioResetStatus != 0) { + if (audio_shut_down_and_reset_step() == 0) { + if (gAudioResetStatus == 0) { + osSendMesg(D_SH_80350FA8, (OSMesg) (s32) gAudioResetPresetIdToLoad, OS_MESG_NOBLOCK); + } + D_SH_80314FCC = 0; + return NULL; + } + } + if (gAudioLoadLockSH >= 0x11U) { + return NULL; + } + if (gAudioLoadLockSH != 0) { + gAudioLoadLockSH++; + } + + gAudioTask = &gAudioTasks[gAudioTaskIndex]; + gAudioCmd = (u64 *) gAudioCmdBuffers[gAudioTaskIndex]; + index = gCurrAiBufferIndex; + currAiBuffer = gAiBuffers[index]; + + gAiBufferLengths[index] = (s16) ((((gAudioBufferParameters.samplesPerFrameTarget - samplesRemainingInAI) + + EXTRA_BUFFERED_AI_SAMPLES_TARGET) & ~0xf) + SAMPLES_TO_OVERPRODUCE); + if (gAiBufferLengths[index] < gAudioBufferParameters.minAiBufferLength) { + gAiBufferLengths[index] = gAudioBufferParameters.minAiBufferLength; + } + if (gAiBufferLengths[index] > gAudioBufferParameters.maxAiBufferLength) { + gAiBufferLengths[index] = gAudioBufferParameters.maxAiBufferLength; + } + + if (osRecvMesg(D_SH_80350F68, (OSMesg *) &sp34, 0) != -1) { + do { + func_802ad7ec(sp34); + } while (osRecvMesg(D_SH_80350F68, (OSMesg *) &sp34, 0) != -1); + } + + flags = 0; + gAudioCmd = synthesis_execute(gAudioCmd, &writtenCmds, currAiBuffer, gAiBufferLengths[index]); + gAudioRandom = (u32) (osGetCount() * (gAudioRandom + gAudioFrameCount)); + gAudioRandom = (u32) (gAiBuffers[index][gAudioFrameCount & 0xFF] + gAudioRandom); + + index = gAudioTaskIndex; + gAudioTask->msgqueue = NULL; + gAudioTask->msg = NULL; + + task = &gAudioTask->task.t; + task->type = M_AUDTASK; + task->flags = flags; + task->ucode_boot = rspF3DBootStart; + task->ucode_boot_size = (u8 *) rspF3DStart - (u8 *) rspF3DBootStart; + task->ucode = rspAspMainStart; + task->ucode_data = rspAspMainDataStart; + task->ucode_size = 0x1000; + task->ucode_data_size = (rspAspMainDataEnd - rspAspMainDataStart) * sizeof(u64); + task->dram_stack = NULL; + task->dram_stack_size = 0; + task->output_buff = NULL; + task->output_buff_size = NULL; + task->data_ptr = gAudioCmdBuffers[index]; + task->data_size = writtenCmds * sizeof(u64); + task->yield_data_ptr = NULL; + task->yield_data_size = 0; + + writtenCmdsCopy = writtenCmds; + if (D_SH_80314FC8 < writtenCmdsCopy) { + D_SH_80314FC8 = writtenCmdsCopy; + } + + if (gAudioBufferParameters.presetUnk4 == 1) { + return gAudioTask; + } else { + D_SH_80314FCC = gAudioTask; + return NULL; + } +} +#else +struct SPTask *create_next_audio_frame_task(void) { + return NULL; +} +void create_next_audio_buffer(s16 *samples, u32 num_samples) { + s32 writtenCmds; + OSMesg msg; + gAudioFrameCount++; + decrease_sample_dma_ttls(); + if (osRecvMesg(D_SH_80350F88, &msg, 0) != -1) { + gAudioResetPresetIdToLoad = (u8) (intptr_t) msg; + if (gAudioResetStatus == 0) { + gAudioResetStatus = 5; + } + } + + if (gAudioResetStatus != 0) { + audio_reset_session(); + gAudioResetStatus = 0; + } + while (osRecvMesg(D_SH_80350F68, &msg, OS_MESG_NOBLOCK) != -1) { + func_802ad7ec((u32) msg); + } + synthesis_execute(gAudioCmdBuffers[0], &writtenCmds, samples, num_samples); + gAudioRandom = ((gAudioRandom + gAudioFrameCount) * gAudioFrameCount); + gAudioRandom = gAudioRandom + writtenCmds / 8; + gCurrAudioFrameDmaCount = 0; +} +#endif + +void eu_process_audio_cmd(struct EuAudioCmd *cmd) { + s32 i; + struct Note *note; + struct NoteSubEu *sub; + + switch (cmd->u.s.op) { + case 0x81: + preload_sequence(cmd->u.s.arg2, 3); + break; + + case 0x82: + case 0x88: + load_sequence(cmd->u.s.arg1, cmd->u.s.arg2, cmd->u.s.arg3); + func_8031D690(cmd->u.s.arg1, cmd->u2.as_s32); + break; + + case 0x83: + if (gSequencePlayers[cmd->u.s.arg1].enabled != FALSE) { + if (cmd->u2.as_s32 == 0) { + sequence_player_disable(&gSequencePlayers[cmd->u.s.arg1]); + } + else { + seq_player_fade_to_zero_volume(cmd->u.s.arg1, cmd->u2.as_s32); + } + } + break; + + case 0x84: + break; + + case 0xf0: + gSoundMode = cmd->u2.as_s32; + break; + + case 0xf1: + for (i = 0; i < 4; i++) { + gSequencePlayers[i].muted = TRUE; + gSequencePlayers[i].recalculateVolume = TRUE; + } + break; + + case 0xf2: + if (cmd->u2.as_s32 == 1) { + for (i = 0; i < gMaxSimultaneousNotes; i++) { + note = &gNotes[i]; + sub = ¬e->noteSubEu; + if (note->noteSubEu.enabled && note->unkSH34 == 0) { + if ((note->parentLayer->seqChannel->muteBehavior & 8) != 0) { + sub->finished = TRUE; + } + } + } + } + for (i = 0; i < 4; i++) { + gSequencePlayers[i].muted = FALSE; + gSequencePlayers[i].recalculateVolume = TRUE; + } + break; + + case 0xf3: + func_sh_802f3024(cmd->u.s.arg1, cmd->u.s.arg2, cmd->u.s.arg3); + break; + + case 0xf4: + func_sh_802f30f4(cmd->u.s.arg1, cmd->u.s.arg2, cmd->u.s.arg3, &gUnkQueue1); + break; + + case 0xf5: + func_sh_802f3158(cmd->u.s.arg1, cmd->u.s.arg2, cmd->u.s.arg3, &gUnkQueue1); + break; + + case 0xf6: + func_sh_802f3288(cmd->u.s.arg2); + break; + } +} + +void seq_player_fade_to_zero_volume(s32 arg0, s32 fadeOutTime) { + struct SequencePlayer *player; + + if (fadeOutTime == 0) { + fadeOutTime = 1; + } + player = &gSequencePlayers[arg0]; + player->state = 2; + player->fadeRemainingFrames = fadeOutTime; + player->fadeVelocity = -(player->fadeVolume / (f32) fadeOutTime); +} + +void func_8031D690(s32 playerIndex, s32 fadeInTime) { + struct SequencePlayer *player; + + if (fadeInTime != 0) { + player = &gSequencePlayers[playerIndex]; + player->state = 1; + player->fadeTimerUnkEu = fadeInTime; + player->fadeRemainingFrames = fadeInTime; + player->fadeVolume = 0.0f; + player->fadeVelocity = 0.0f; + } +} + +void port_eu_init_queues(void) { + D_SH_80350F18 = 0; + D_SH_80350F19 = 0; + D_SH_80350F38 = &D_SH_80350F20; + D_SH_80350F68 = &D_SH_80350F50; + D_SH_80350F88 = &D_SH_80350F70; + D_SH_80350FA8 = &D_SH_80350F90; + osCreateMesgQueue(D_SH_80350F38, D_SH_80350F1C, 1); + osCreateMesgQueue(D_SH_80350F68, D_SH_80350F40, 4); + osCreateMesgQueue(D_SH_80350F88, D_SH_80350F6C, 1); + osCreateMesgQueue(D_SH_80350FA8, D_SH_80350F8C, 1); +} + +extern struct EuAudioCmd sAudioCmd[0x100]; +void func_802ad6f0(s32 arg0, s32 *arg1) { + struct EuAudioCmd *cmd = &sAudioCmd[D_SH_80350F18 & 0xff]; + cmd->u.first = arg0; + cmd->u2.as_u32 = *arg1; + D_SH_80350F18++; + if (D_SH_80350F18 == D_SH_80350F19) { + D_SH_80350F18--; + } +} + +void func_802ad728(u32 arg0, f32 arg1) { + func_802ad6f0(arg0, (s32 *) &arg1); +} + +void func_802ad74c(u32 arg0, u32 arg1) { + func_802ad6f0(arg0, (s32 *) &arg1); +} + +void func_802ad770(u32 arg0, s8 arg1) { + s32 sp1C = arg1 << 24; + func_802ad6f0(arg0, &sp1C); +} + +char shindouDebugPrint133[] = "AudioSend: %d -> %d (%d)\n"; + +void func_sh_802F64C8(void) { + static s32 D_SH_8031503C = 0; + s32 mesg; + + if (((D_SH_80350F18 - D_SH_80350F19 + 0x100) & 0xff) > D_SH_8031503C) { + D_SH_8031503C = (D_SH_80350F18 - D_SH_80350F19 + 0x100) & 0xff; + } + mesg = ((D_SH_80350F19 & 0xff) << 8) | (D_SH_80350F18 & 0xff); + osSendMesg(D_SH_80350F68, (OSMesg)mesg, OS_MESG_NOBLOCK); + D_SH_80350F19 = D_SH_80350F18; +} + +void func_sh_802f6540(void) { + D_SH_80350F19 = D_SH_80350F18; +} + +void func_802ad7ec(u32 arg0) { + struct EuAudioCmd *cmd; + struct SequencePlayer *seqPlayer; + struct SequenceChannel *chan; + u8 end; + + UNUSED static char shindouDebugPrint134[] = "Continue Port\n"; + UNUSED static char shindouDebugPrint135[] = "%d -> %d\n"; + UNUSED static char shindouDebugPrint136[] = "Sync-Frame Break. (Remain %d)\n"; + UNUSED static char shindouDebugPrint137[] = "Undefined Port Command %d\n"; + + static u8 D_SH_80315098 = 0; + static u8 D_SH_8031509C = 0; + + if (D_SH_8031509C == 0) { + D_SH_80315098 = (arg0 >> 8) & 0xff; + } + + end = arg0 & 0xff; + + for (;;) { + if (D_SH_80315098 == end) { + D_SH_8031509C = 0; + break; + } + cmd = &sAudioCmd[D_SH_80315098 & 0xff]; + D_SH_80315098++; + if (cmd->u.s.op == 0xf8) { + D_SH_8031509C = 1; + break; + } + else if ((cmd->u.s.op & 0xf0) == 0xf0) { + eu_process_audio_cmd(cmd); + } + else if (cmd->u.s.arg1 < SEQUENCE_PLAYERS) { + seqPlayer = &gSequencePlayers[cmd->u.s.arg1]; + if ((cmd->u.s.op & 0x80) != 0) { + eu_process_audio_cmd(cmd); + } + else if ((cmd->u.s.op & 0x40) != 0) { + switch (cmd->u.s.op) { + case 0x41: + if (seqPlayer->fadeVolumeScale != cmd->u2.as_f32) { + seqPlayer->fadeVolumeScale = cmd->u2.as_f32; + seqPlayer->recalculateVolume = TRUE; + } + break; + + case 0x47: + seqPlayer->tempo = cmd->u2.as_s32 * TATUMS_PER_BEAT; + break; + + case 0x49: + seqPlayer->tempoAdd = cmd->u2.as_s32 * TEMPO_SCALE; + break; + + case 0x48: + seqPlayer->transposition = cmd->u2.as_s8; + break; + + case 0x46: + seqPlayer->seqVariationEu[cmd->u.s.arg3] = cmd->u2.as_s8; + break; + } + } + else if (seqPlayer->enabled != FALSE && cmd->u.s.arg2 < 0x10) { + chan = seqPlayer->channels[cmd->u.s.arg2]; + if (IS_SEQUENCE_CHANNEL_VALID(chan)) + { + switch (cmd->u.s.op) { + case 1: + if (chan->volumeScale != cmd->u2.as_f32) { + chan->volumeScale = cmd->u2.as_f32; + chan->changes.as_bitfields.volume = TRUE; + } + break; + case 2: + if (chan->volume != cmd->u2.as_f32) { + chan->volume = cmd->u2.as_f32; + chan->changes.as_bitfields.volume = TRUE; + } + break; + case 3: + if (chan->newPan != cmd->u2.as_s8) { + chan->newPan = cmd->u2.as_s8; + chan->changes.as_bitfields.pan = TRUE; + } + break; + case 4: + if (chan->freqScale != cmd->u2.as_f32) { + chan->freqScale = cmd->u2.as_f32; + chan->changes.as_bitfields.freqScale = TRUE; + } + break; + case 5: + //! @bug u8 s8 comparison (but harmless) + if (chan->reverbVol != cmd->u2.as_s8) { + chan->reverbVol = cmd->u2.as_s8; + } + break; + case 6: + if (cmd->u.s.arg3 < 8) { + chan->soundScriptIO[cmd->u.s.arg3] = cmd->u2.as_s8; + } + break; + case 8: + chan->stopSomething2 = cmd->u2.as_s8; + break; + case 9: + chan->muteBehavior = cmd->u2.as_s8; + } + } + } + } + + cmd->u.s.op = 0; + } +} + +u32 func_sh_802f6878(s32 *arg0) { + u32 sp1C; + + if (osRecvMesg(&gUnkQueue1, (OSMesg *) &sp1C, 0) == -1) { + *arg0 = 0; + return 0U; + } + *arg0 = (s32) (sp1C & 0xFFFFFF); + return sp1C >> 0x18; +} + +u8 *func_sh_802f68e0(u32 index, u32 *a1) { + return func_sh_802f3220(index, a1); +} + +s32 func_sh_802f6900(void) { + s32 ret; + s32 sp18; + + ret = osRecvMesg(D_SH_80350FA8, (OSMesg *) &sp18, 0); + + if (ret == -1) { + return 0; + } + if (sp18 != gAudioResetPresetIdToLoad) { + return 0; + } else { + return 1; + } +} + +// TODO: (Scrub C) +void func_sh_802f6958(OSMesg mesg) { + s32 a; + OSMesg recvMesg; + + do { + a = -1; + } while (osRecvMesg(D_SH_80350FA8, &recvMesg, OS_MESG_NOBLOCK) != a); + func_sh_802f6540(); + osSendMesg(D_SH_80350F88, mesg, OS_MESG_NOBLOCK); +} + +void func_sh_802f69cc(void) { + gAudioLoadLockSH = 1; + func_sh_802f6958(0); + gAudioResetStatus = 0; +} + +s32 func_sh_802f6a08(s32 playerIndex, s32 channelIndex, s32 soundScriptIOIndex) { + struct SequenceChannel *seqChannel; + struct SequencePlayer *player; + + player = &gSequencePlayers[playerIndex]; + if (player->enabled) { + seqChannel = player->channels[channelIndex]; + if (IS_SEQUENCE_CHANNEL_VALID(seqChannel)) { + return seqChannel->soundScriptIO[soundScriptIOIndex]; + } + } + return -1; +} + +s8 func_sh_802f6a6c(s32 playerIndex, s32 index) { + return gSequencePlayers[playerIndex].seqVariationEu[index]; +} + +void port_eu_init(void) { + port_eu_init_queues(); +} + +char shindouDebugPrint138[] = "specchg conjunction error (Msg:%d Cur:%d)\n"; +char shindouDebugPrint139[] = "Error : Queue is not empty ( %x ) \n"; +char shindouDebugPrint140[] = "Audio: setvol: volume minus %f\n"; +char shindouDebugPrint141[] = "Audio: setvol: volume overflow %f\n"; +char shindouDebugPrint142[] = "Audio: setpitch: pitch zero or minus %f\n"; +char shindouDebugPrint143[] = "----------------------Double-Error CH: %x %f\n"; +char shindouDebugPrint144[] = "----------------------Double-Error NT: %x\n"; +char shindouDebugPrint145[] = "CAUTION:SUB IS SEPARATED FROM GROUP\n"; +char shindouDebugPrint146[] = "CAUTION:PAUSE EMERGENCY\n"; +char shindouDebugPrint147[] = "Error:Wait Track disappear\n"; +char shindouDebugPrint148[] = "Audio: voiceman: No bank error %d\n"; +char shindouDebugPrint149[] = "Audio: voiceman: progNo. overflow %d,%d\n"; +char shindouDebugPrint150[] = "ptr2 %x\n"; +char shindouDebugPrint151[] = "Audio: voiceman: progNo. undefined %d,%d\n"; +char shindouDebugPrint152[] = "Audio: voiceman: No bank error %d\n"; +char shindouDebugPrint153[] = "Audio: voiceman: Percussion Overflow %d,%d\n"; +char shindouDebugPrint154[] = "Audio: voiceman: Percussion table pointer (bank %d) is irregular %x.\n"; +char shindouDebugPrint155[] = "Audio: voiceman: Percpointer NULL %d,%d\n"; +char shindouDebugPrint156[] = "--4 %x\n"; +char shindouDebugPrint157[] = "NoteOff Comes during wait release %x (note %x)\n"; +char shindouDebugPrint158[] = "Slow Release Batting\n"; +u8 euUnknownData_8030194c[4] = { 0x40, 0x20, 0x10, 0x08 }; +char shindouDebugPrint159[] = "Audio:Wavemem: Bad voiceno (%d)\n"; +char shindouDebugPrint160[] = "Audio: C-Alloc : Dealloc voice is NULL\n"; +char shindouDebugPrint161[] = "Alloc Error:Dim voice-Alloc %d"; +char shindouDebugPrint162[] = "Error:Same List Add\n"; +char shindouDebugPrint163[] = "Already Cut\n"; +char shindouDebugPrint164[] = "Audio: C-Alloc : lowerPrio is NULL\n"; +char shindouDebugPrint165[] = "Intterupt UseStop %d (Kill %d)\n"; +char shindouDebugPrint166[] = "Intterupt RelWait %d (Kill %d)\n"; +char shindouDebugPrint167[] = "Drop Voice (Prio %x)\n"; +s32 D_SH_803154CC = 0; // file boundary + +// effects.c +char shindouDebugPrint168[] = "Audio:Envp: overflow %f\n"; +s32 D_SH_803154EC = 0; // file boundary + +// seqplayer.c +char shindouDebugPrint169[] = "Audio:Track:Warning: No Free Notetrack\n"; +char shindouDebugPrint170[] = "SUBTRACK DIM\n"; +char shindouDebugPrint171[] = "Audio:Track: Warning :SUBTRACK had been stolen by other Group.\n"; +char shindouDebugPrint172[] = "SEQID %d,BANKID %d\n"; +char shindouDebugPrint173[] = "ERR:SUBTRACK %d NOT ALLOCATED\n"; +char shindouDebugPrint174[] = "Stop Release\n"; +char shindouDebugPrint175[] = "Error:Same List Add\n"; +char shindouDebugPrint176[] = "Wait Time out!\n"; +char shindouDebugPrint177[] = "Macro Level Over Error!\n"; +char shindouDebugPrint178[] = "Macro Level Over Error!\n"; // Again +char shindouDebugPrint179[] = "WARNING: NPRG: cannot change %d\n"; +char shindouDebugPrint180[] = "Audio:Track:NOTE:UNDEFINED NOTE COM. %x\n"; +char shindouDebugPrint181[] = "Error: Subtrack no prg.\n"; +char shindouDebugPrint182[] = "ERR %x\n"; +char shindouDebugPrint183[] = "Note OverFlow %d\n"; +char shindouDebugPrint184[] = "trs %d , %d, %d\n"; +char shindouDebugPrint185[] = "Audio: Note:Velocity Error %d\n"; +char shindouDebugPrint186[] = "Audio:Track :Call Macro Level Over Error!\n"; +char shindouDebugPrint187[] = "Audio:Track :Loops Macro Level Over Error!\n"; +char shindouDebugPrint188[] = "SUB:ERR:BANK %d NOT CACHED.\n"; +char shindouDebugPrint189[] = "SUB:ERR:BANK %d NOT CACHED.\n"; +char shindouDebugPrint190[] = "Audio:Track: CTBLCALL Macro Level Over Error!\n"; +char shindouDebugPrint191[] = "Set Noise %d\n"; +char shindouDebugPrint192[] = "[%2x] \n"; +char shindouDebugPrint193[] = "Err :Sub %x ,address %x:Undefined SubTrack Function %x"; +char shindouDebugPrint194[] = "VoiceLoad Error Bank:%d,Prog:%d\n"; +char shindouDebugPrint195[] = "Disappear Sequence or Bank %d\n"; +char shindouDebugPrint196[] = "[FIN] group.\n"; +char shindouDebugPrint197[] = "Macro Level Over Error!\n"; +char shindouDebugPrint198[] = "Macro Level Over Error!\n"; +char shindouDebugPrint199[] = "Group:Undefine upper C0h command (%x)\n"; +char shindouDebugPrint200[] = "Group:Undefined Command\n"; + +#endif diff --git a/src/decomp/audio/seqplayer.c b/src/decomp/audio/seqplayer.c new file mode 100644 index 0000000..9055160 --- /dev/null +++ b/src/decomp/audio/seqplayer.c @@ -0,0 +1,2853 @@ +#include + +#include "data.h" +#include "effects.h" +#include "external.h" +#include "heap.h" +#include "load.h" +#include "seqplayer.h" + +#define PORTAMENTO_IS_SPECIAL(x) ((x).mode & 0x80) +#define PORTAMENTO_MODE(x) ((x).mode & ~0x80) +#define PORTAMENTO_MODE_1 1 +#define PORTAMENTO_MODE_2 2 +#define PORTAMENTO_MODE_3 3 +#define PORTAMENTO_MODE_4 4 +#define PORTAMENTO_MODE_5 5 + +#ifdef VERSION_SH +void seq_channel_layer_process_script_part1(struct SequenceChannelLayer *layer); +s32 seq_channel_layer_process_script_part2(struct SequenceChannelLayer *layer); +s32 seq_channel_layer_process_script_part3(struct SequenceChannelLayer *layer, s32 cmd); +s32 seq_channel_layer_process_script_part4(struct SequenceChannelLayer *layer, s32 cmd); +s32 seq_channel_layer_process_script_part5(struct SequenceChannelLayer *layer, s32 cmd); +#endif +void seq_channel_layer_process_script(struct SequenceChannelLayer *layer); +void sequence_channel_process_script(struct SequenceChannel *seqChannel); +u8 get_instrument(struct SequenceChannel *seqChannel, u8 instId, struct Instrument **instOut, + struct AdsrSettings *adsr); + +void sequence_channel_init(struct SequenceChannel *seqChannel) { + s32 i; + + seqChannel->enabled = FALSE; + seqChannel->finished = FALSE; + seqChannel->stopScript = FALSE; + seqChannel->stopSomething2 = FALSE; + seqChannel->hasInstrument = FALSE; + seqChannel->stereoHeadsetEffects = FALSE; + seqChannel->transposition = 0; + seqChannel->largeNotes = FALSE; +#if defined(VERSION_EU) || defined(VERSION_SH) + seqChannel->bookOffset = 0; + seqChannel->changes.as_u8 = 0xff; + seqChannel->scriptState.depth = 0; + seqChannel->newPan = 0x40; + seqChannel->panChannelWeight = 0x80; + seqChannel->noteUnused = NULL; + seqChannel->reverbIndex = 0; +#else + seqChannel->scriptState.depth = 0; + seqChannel->volume = 1.0f; + seqChannel->volumeScale = 1.0f; + seqChannel->freqScale = 1.0f; + seqChannel->pan = 0.5f; + seqChannel->panChannelWeight = 1.0f; + seqChannel->noteUnused = NULL; +#endif + seqChannel->reverbVol = 0; +#ifdef VERSION_SH + seqChannel->synthesisVolume = 0; +#endif + seqChannel->notePriority = NOTE_PRIORITY_DEFAULT; +#ifdef VERSION_SH + seqChannel->unkSH06 = 1; +#endif + seqChannel->delay = 0; + seqChannel->adsr.envelope = gDefaultEnvelope; + seqChannel->adsr.releaseRate = 0x20; + seqChannel->adsr.sustain = 0; +#if defined(VERSION_JP) || defined(VERSION_US) + seqChannel->updatesPerFrameUnused = gAudioUpdatesPerFrame; +#endif + seqChannel->vibratoRateTarget = 0x800; + seqChannel->vibratoRateStart = 0x800; + seqChannel->vibratoExtentTarget = 0; + seqChannel->vibratoExtentStart = 0; + seqChannel->vibratoRateChangeDelay = 0; + seqChannel->vibratoExtentChangeDelay = 0; + seqChannel->vibratoDelay = 0; +#ifdef VERSION_SH + seqChannel->filter = NULL; +#endif +#if defined(VERSION_EU) || defined(VERSION_SH) + seqChannel->volume = 1.0f; + seqChannel->volumeScale = 1.0f; + seqChannel->freqScale = 1.0f; +#endif + + for (i = 0; i < 8; i++) { + seqChannel->soundScriptIO[i] = -1; + } + + seqChannel->unused = FALSE; + init_note_lists(&seqChannel->notePool); +} + +s32 seq_channel_set_layer(struct SequenceChannel *seqChannel, s32 layerIndex) { + struct SequenceChannelLayer *layer; + + if (seqChannel->layers[layerIndex] == NULL) { +#if defined(VERSION_EU) || defined(VERSION_SH) + struct SequenceChannelLayer *layer; +#endif + layer = audio_list_pop_back(&gLayerFreeList); + seqChannel->layers[layerIndex] = layer; + if (layer == NULL) { + seqChannel->layers[layerIndex] = NULL; + return -1; + } + } else { + seq_channel_layer_note_decay(seqChannel->layers[layerIndex]); + } + + layer = seqChannel->layers[layerIndex]; + layer->seqChannel = seqChannel; + layer->adsr = seqChannel->adsr; + layer->adsr.releaseRate = 0; + layer->enabled = TRUE; + layer->stopSomething = FALSE; + layer->continuousNotes = FALSE; + layer->finished = FALSE; +#if defined(VERSION_EU) || defined(VERSION_SH) + layer->ignoreDrumPan = FALSE; +#endif +#ifdef VERSION_SH + layer->reverbBits.asByte = 0x40; +#endif + layer->portamento.mode = 0; + layer->scriptState.depth = 0; + layer->status = SOUND_LOAD_STATUS_NOT_LOADED; + layer->noteDuration = 0x80; +#if defined(VERSION_EU) || defined(VERSION_SH) + layer->pan = 0x40; +#endif + layer->transposition = 0; + layer->delay = 0; + layer->duration = 0; + layer->delayUnused = 0; + layer->note = NULL; + layer->instrument = NULL; +#if defined(VERSION_EU) || defined(VERSION_SH) + layer->freqScale = 1.0f; + layer->velocitySquare = 0.0f; +#ifdef VERSION_SH + layer->freqScaleMultiplier = 1.0f; +#endif + layer->instOrWave = 0xff; +#else + layer->velocitySquare = 0.0f; + layer->pan = 0.5f; +#endif + return 0; +} + +void seq_channel_layer_disable(struct SequenceChannelLayer *layer) { + if (layer != NULL) { + seq_channel_layer_note_decay(layer); + layer->enabled = FALSE; + layer->finished = TRUE; + } +} + +void seq_channel_layer_free(struct SequenceChannel *seqChannel, s32 layerIndex) { + struct SequenceChannelLayer *layer = seqChannel->layers[layerIndex]; + + if (layer != NULL) { +#if defined(VERSION_EU) || defined(VERSION_SH) + audio_list_push_back(&gLayerFreeList, &layer->listItem); +#else + struct AudioListItem *item = &layer->listItem; + if (item->prev == NULL) { + gLayerFreeList.prev->next = item; + item->prev = gLayerFreeList.prev; + item->next = &gLayerFreeList; + gLayerFreeList.prev = item; + gLayerFreeList.u.count++; + item->pool = gLayerFreeList.pool; + } +#endif + seq_channel_layer_disable(layer); + seqChannel->layers[layerIndex] = NULL; + } +} + +void sequence_channel_disable(struct SequenceChannel *seqChannel) { + s32 i; + for (i = 0; i < LAYERS_MAX; i++) { + seq_channel_layer_free(seqChannel, i); + } + + note_pool_clear(&seqChannel->notePool); + seqChannel->enabled = FALSE; + seqChannel->finished = TRUE; +} + +struct SequenceChannel *allocate_sequence_channel(void) { + s32 i; + for (i = 0; i < ARRAY_COUNT(gSequenceChannels); i++) { + if (gSequenceChannels[i].seqPlayer == NULL) { +#if defined(VERSION_EU) || defined(VERSION_SH) + return &gSequenceChannels[i]; +#else + return gSequenceChannels + i; +#endif + } + } + return &gSequenceChannelNone; +} + +void sequence_player_init_channels(struct SequencePlayer *seqPlayer, u16 channelBits) { + struct SequenceChannel *seqChannel; + s32 i; + + for (i = 0; i < CHANNELS_MAX; i++) { + if (channelBits & 1) { + seqChannel = seqPlayer->channels[i]; + if (IS_SEQUENCE_CHANNEL_VALID(seqChannel) == TRUE && seqChannel->seqPlayer == seqPlayer) { + sequence_channel_disable(seqChannel); + seqChannel->seqPlayer = NULL; + } + seqChannel = allocate_sequence_channel(); + if (IS_SEQUENCE_CHANNEL_VALID(seqChannel) == FALSE) { + eu_stubbed_printf_0("Audio:Track:Warning: No Free Notetrack\n"); + gAudioErrorFlags = i + 0x10000; + seqPlayer->channels[i] = seqChannel; + } else { + sequence_channel_init(seqChannel); + seqPlayer->channels[i] = seqChannel; + seqChannel->seqPlayer = seqPlayer; + seqChannel->bankId = seqPlayer->defaultBank[0]; + seqChannel->muteBehavior = seqPlayer->muteBehavior; + seqChannel->noteAllocPolicy = seqPlayer->noteAllocPolicy; + } + } +#if defined(VERSION_EU) || defined(VERSION_SH) + channelBits = channelBits >> 1; +#else + channelBits >>= 1; +#endif + } +} + +void sequence_player_disable_channels(struct SequencePlayer *seqPlayer, u16 channelBits) { + struct SequenceChannel *seqChannel; + s32 i; + + eu_stubbed_printf_0("SUBTRACK DIM\n"); + for (i = 0; i < CHANNELS_MAX; i++) { + if (channelBits & 1) { + seqChannel = seqPlayer->channels[i]; + if (IS_SEQUENCE_CHANNEL_VALID(seqChannel) == TRUE) { + if (seqChannel->seqPlayer == seqPlayer) { + sequence_channel_disable(seqChannel); + seqChannel->seqPlayer = NULL; + } +#if defined(VERSION_EU) || defined(VERSION_SH) + else { +#ifdef VERSION_EU + stubbed_printf("Audio:Track: Warning SUBTRACK PARENT CHANGED\n"); +#endif + } +#endif + seqPlayer->channels[i] = &gSequenceChannelNone; + } + } +#if defined(VERSION_EU) || defined(VERSION_SH) + channelBits = channelBits >> 1; +#else + channelBits >>= 1; +#endif + } +} + +void sequence_channel_enable(struct SequencePlayer *seqPlayer, u8 channelIndex, void *script) { + struct SequenceChannel *seqChannel = seqPlayer->channels[channelIndex]; + s32 i; + if (IS_SEQUENCE_CHANNEL_VALID(seqChannel) == FALSE) { +#ifdef VERSION_EU + struct SequencePlayer *bgMusic = &gSequencePlayers[0]; + struct SequencePlayer *miscMusic = &gSequencePlayers[1]; + + if (seqPlayer == bgMusic) { + stubbed_printf("GROUP 0:"); + } else if (seqPlayer == miscMusic) { + stubbed_printf("GROUP 1:"); + } else { + stubbed_printf("SEQID %d,BANKID %d\n", + seqPlayer->seqId, seqPlayer->defaultBank[0]); + } + stubbed_printf("ERR:SUBTRACK %d NOT ALLOCATED\n", channelIndex); +#endif + } else { + seqChannel->enabled = TRUE; + seqChannel->finished = FALSE; + seqChannel->scriptState.depth = 0; + seqChannel->scriptState.pc = script; + seqChannel->delay = 0; + for (i = 0; i < LAYERS_MAX; i++) { + if (seqChannel->layers[i] != NULL) { + seq_channel_layer_free(seqChannel, i); + } + } + } +} + +void sequence_player_disable(struct SequencePlayer *seqPlayer) { + sequence_player_disable_channels(seqPlayer, 0xffff); + note_pool_clear(&seqPlayer->notePool); + seqPlayer->finished = TRUE; + seqPlayer->enabled = FALSE; + + if (IS_SEQ_LOAD_COMPLETE(seqPlayer->seqId) +#ifdef VERSION_SH + && gSeqLoadStatus[seqPlayer->seqId] != 5 +#endif + ) { + gSeqLoadStatus[seqPlayer->seqId] = SOUND_LOAD_STATUS_DISCARDABLE; + } + + if (IS_BANK_LOAD_COMPLETE(seqPlayer->defaultBank[0]) +#ifdef VERSION_SH + && gBankLoadStatus[seqPlayer->defaultBank[0]] != 5 +#endif + ) { +#ifdef VERSION_SH + gBankLoadStatus[seqPlayer->defaultBank[0]] = 4; +#else + gBankLoadStatus[seqPlayer->defaultBank[0]] = SOUND_LOAD_STATUS_DISCARDABLE; +#endif + } + + // (Note that if this is called from alloc_bank_or_seq, the side will get swapped + // later in that function. Thus, we signal that we want to load into the slot + // of the bank that we no longer need.) +#if defined(VERSION_EU) || defined(VERSION_SH) + if (seqPlayer->defaultBank[0] == gBankLoadedPool.temporary.entries[0].id) { + gBankLoadedPool.temporary.nextSide = 1; + } else if (seqPlayer->defaultBank[0] == gBankLoadedPool.temporary.entries[1].id) { + gBankLoadedPool.temporary.nextSide = 0; + } +#else + if (gBankLoadedPool.temporary.entries[0].id == seqPlayer->defaultBank[0]) { + gBankLoadedPool.temporary.nextSide = 1; + } else if (gBankLoadedPool.temporary.entries[1].id == seqPlayer->defaultBank[0]) { + gBankLoadedPool.temporary.nextSide = 0; + } +#endif +} + +/** + * Add an item to the end of a list, if it's not already in any list. + */ +void audio_list_push_back(struct AudioListItem *list, struct AudioListItem *item) { + if (item->prev != NULL) { + eu_stubbed_printf_0("Error:Same List Add\n"); + } else { + list->prev->next = item; + item->prev = list->prev; + item->next = list; + list->prev = item; + list->u.count++; + item->pool = list->pool; + } +} + +/** + * Remove the last item from a list, and return it (or NULL if empty). + */ +void *audio_list_pop_back(struct AudioListItem *list) { + struct AudioListItem *item = list->prev; + if (item == list) { + return NULL; + } + item->prev->next = list; + list->prev = item->prev; + item->prev = NULL; + list->u.count--; + return item->u.value; +} + +void init_layer_freelist(void) { + s32 i; + + gLayerFreeList.prev = &gLayerFreeList; + gLayerFreeList.next = &gLayerFreeList; + gLayerFreeList.u.count = 0; + gLayerFreeList.pool = NULL; + + for (i = 0; i < ARRAY_COUNT(gSequenceLayers); i++) { +#if defined(VERSION_EU) || defined(VERSION_SH) + gSequenceLayers[i].listItem.u.value = &gSequenceLayers[i]; +#else + gSequenceLayers[i].listItem.u.value = gSequenceLayers + i; +#endif + gSequenceLayers[i].listItem.prev = NULL; + audio_list_push_back(&gLayerFreeList, &gSequenceLayers[i].listItem); + } +} + +u8 m64_read_u8(struct M64ScriptState *state) { +#if defined(VERSION_EU) || defined(VERSION_SH) + return *(state->pc++); +#else + u8 *midiArg = state->pc++; + return *midiArg; +#endif +} + +s16 m64_read_s16(struct M64ScriptState *state) { + s16 ret = *(state->pc++) << 8; + ret = *(state->pc++) | ret; + return ret; +} + +u16 m64_read_compressed_u16(struct M64ScriptState *state) { + u16 ret = *(state->pc++); + if (ret & 0x80) { + ret = (ret << 8) & 0x7f00; + ret = *(state->pc++) | ret; + } + return ret; +} + +#if defined(VERSION_SH) +void seq_channel_layer_process_script(struct SequenceChannelLayer *layer) { + s32 cmd; + + if (layer->enabled == FALSE) { + return; + } + + if (layer->delay > 1) { + layer->delay--; + if (!layer->stopSomething && layer->delay <= layer->duration) { + seq_channel_layer_note_decay(layer); + layer->stopSomething = TRUE; + } + return; + } + + seq_channel_layer_process_script_part1(layer); + cmd = seq_channel_layer_process_script_part2(layer); + if (cmd != -1) { + cmd = seq_channel_layer_process_script_part3(layer, cmd); + if (cmd != -1) { + cmd = seq_channel_layer_process_script_part4(layer, cmd); + } + if (cmd != -1) { + seq_channel_layer_process_script_part5(layer, cmd); + } + + if (layer->stopSomething == TRUE) { + if (layer->note != NULL || layer->continuousNotes) { + seq_channel_layer_note_decay(layer); + } + } + } +} +#elif defined(VERSION_EU) +void seq_channel_layer_process_script(struct SequenceChannelLayer *layer) { + struct SequencePlayer *seqPlayer; + struct SequenceChannel *seqChannel; +#ifdef VERSION_EU + UNUSED u32 pad0; +#endif + struct M64ScriptState *state; + struct Portamento *portamento; + struct AudioBankSound *sound; + struct Instrument *instrument; + struct Drum *drum; + s32 temp_a0_5; +#ifdef VERSION_EU + u16 sp3A; + s32 sameSound; +#endif + UNUSED u32 pad1; +#ifndef VERSION_EU + u8 sameSound; +#endif + u8 cmd; + UNUSED u8 cmdSemitone; +#ifndef VERSION_EU + u16 sp3A; +#endif + f32 tuning; + s32 vel; + UNUSED s32 usedSemitone; + f32 freqScale; +#ifndef VERSION_EU + UNUSED f32 sp24; +#endif + f32 temp_f12; + f32 temp_f2; + + sameSound = TRUE; + if (layer->enabled == FALSE) { + return; + } + + if (layer->delay > 1) { + layer->delay--; + if (!layer->stopSomething && layer->delay <= layer->duration) { + seq_channel_layer_note_decay(layer); + layer->stopSomething = TRUE; + } + return; + } + + if (!layer->continuousNotes) { + seq_channel_layer_note_decay(layer); + } + + if (PORTAMENTO_MODE(layer->portamento) == PORTAMENTO_MODE_1 || + PORTAMENTO_MODE(layer->portamento) == PORTAMENTO_MODE_2) { + layer->portamento.mode = 0; + } + + seqChannel = layer->seqChannel; + seqPlayer = seqChannel->seqPlayer; +#if defined(VERSION_EU) || defined(VERSION_SH) + layer->notePropertiesNeedInit = TRUE; +#endif + + for (;;) { + state = &layer->scriptState; + cmd = m64_read_u8(state); + + if (cmd <= 0xc0) { + break; + } + + switch (cmd) { + case 0xff: // layer_end; function return or end of script + if (state->depth == 0) { + // N.B. this function call is *not* inlined even though it's + // within the same file, unlike in the rest of this function. + seq_channel_layer_disable(layer); + return; + } + state->pc = state->stack[--state->depth]; + break; + + case 0xfc: // layer_call + if (0 && state->depth >= 4) { + eu_stubbed_printf_0("Macro Level Over Error!\n"); + } + sp3A = m64_read_s16(state); + state->stack[state->depth++] = state->pc; + state->pc = seqPlayer->seqData + sp3A; + break; + + case 0xf8: // layer_loop; loop start, N iterations (or 256 if N = 0) + if (0 && state->depth >= 4) { + eu_stubbed_printf_0("Macro Level Over Error!\n"); + } + state->remLoopIters[state->depth] = m64_read_u8(state); + state->stack[state->depth++] = state->pc; + break; + + case 0xf7: // layer_loopend + if (--state->remLoopIters[state->depth - 1] != 0) { + state->pc = state->stack[state->depth - 1]; + } else { + state->depth--; + } + break; + + case 0xfb: // layer_jump + sp3A = m64_read_s16(state); + state->pc = seqPlayer->seqData + sp3A; + break; + +#if defined(VERSION_EU) || defined(VERSION_SH) + case 0xf4: + state->pc += (s8)m64_read_u8(state); + break; +#endif + + case 0xc1: // layer_setshortnotevelocity + case 0xca: // layer_setpan + temp_a0_5 = *(state->pc++); + if (cmd == 0xc1) { + layer->velocitySquare = (f32)(temp_a0_5 * temp_a0_5); + } else { +#if defined(VERSION_EU) || defined(VERSION_SH) + layer->pan = temp_a0_5; +#else + layer->pan = (f32) temp_a0_5 / US_FLOAT(128.0); +#endif + } + break; + + case 0xc2: // layer_transpose; set transposition in semitones + case 0xc9: // layer_setshortnoteduration + temp_a0_5 = *(state->pc++); + if (cmd == 0xc9) { + layer->noteDuration = temp_a0_5; + } else { + layer->transposition = temp_a0_5; + } + break; + + case 0xc4: // layer_somethingon + case 0xc5: // layer_somethingoff + if (cmd == 0xc4) { + layer->continuousNotes = TRUE; + } else { + layer->continuousNotes = FALSE; + } + seq_channel_layer_note_decay(layer); + break; + + case 0xc3: // layer_setshortnotedefaultplaypercentage + sp3A = m64_read_compressed_u16(state); + layer->shortNoteDefaultPlayPercentage = sp3A; + break; + + case 0xc6: // layer_setinstr + cmd = m64_read_u8(state); +#if defined(VERSION_JP) || defined(VERSION_US) + if (cmd < 127) { + cmd = get_instrument(seqChannel, cmd, &layer->instrument, &layer->adsr); + } +#else + if (cmd >= 0x7f) { + if (cmd == 0x7f) { + layer->instOrWave = 0; + } else { + layer->instOrWave = cmd; + layer->instrument = NULL; + } + + if (1) { + } + + if (cmd == 0xff) { + layer->adsr.releaseRate = 0; + } + break; + } + + if ((layer->instOrWave = get_instrument(seqChannel, cmd, &layer->instrument, &layer->adsr)) == 0) { + eu_stubbed_printf_1("WARNING: NPRG: cannot change %d\n", cmd); + layer->instOrWave = 0xff; + } +#endif + break; + + case 0xc7: // layer_portamento + layer->portamento.mode = m64_read_u8(state); + + // cmd is reused for the portamento's semitone + cmd = m64_read_u8(state) + seqChannel->transposition + + layer->transposition + seqPlayer->transposition; + + if (cmd >= 0x80) { + cmd = 0; + } + + layer->portamentoTargetNote = cmd; + + // If special, the next param is u8 instead of var + if (PORTAMENTO_IS_SPECIAL(layer->portamento)) { + layer->portamentoTime = *((state)->pc++); + break; + } + + sp3A = m64_read_compressed_u16(state); + layer->portamentoTime = sp3A; + break; + + case 0xc8: // layer_disableportamento + layer->portamento.mode = 0; + break; + +#if defined(VERSION_EU) || defined(VERSION_SH) + case 0xcb: + sp3A = m64_read_s16(state); + layer->adsr.envelope = (struct AdsrEnvelope *) (seqPlayer->seqData + sp3A); + layer->adsr.releaseRate = m64_read_u8(state); + break; + + case 0xcc: + layer->ignoreDrumPan = TRUE; + break; +#endif + + default: + switch (cmd & 0xf0) { + case 0xd0: // layer_setshortnotevelocityfromtable + sp3A = seqPlayer->shortNoteVelocityTable[cmd & 0xf]; + layer->velocitySquare = (f32)(sp3A * sp3A); + break; + case 0xe0: // layer_setshortnotedurationfromtable + layer->noteDuration = seqPlayer->shortNoteDurationTable[cmd & 0xf]; + break; + default: + eu_stubbed_printf_1("Audio:Track:NOTE:UNDEFINED NOTE COM. %x\n", cmd); + break; + } + } + } + + if (cmd == 0xc0) { // layer_delay + layer->delay = m64_read_compressed_u16(state); + layer->stopSomething = TRUE; + } else { + layer->stopSomething = FALSE; + + if (seqChannel->largeNotes == TRUE) { + switch (cmd & 0xc0) { + case 0x00: // layer_note0 (play percentage, velocity, duration) + sp3A = m64_read_compressed_u16(state); + vel = *(state->pc++); + layer->noteDuration = *(state->pc++); + layer->playPercentage = sp3A; + break; + + case 0x40: // layer_note1 (play percentage, velocity) + sp3A = m64_read_compressed_u16(state); + vel = *(state->pc++); + layer->noteDuration = 0; + layer->playPercentage = sp3A; + break; + + case 0x80: // layer_note2 (velocity, duration; uses last play percentage) + sp3A = layer->playPercentage; + vel = *(state->pc++); + layer->noteDuration = *(state->pc++); + break; + } + + // the remaining bits are used for the semitone + cmd -= (cmd & 0xc0); +#if defined(VERSION_EU) || defined(VERSION_SH) + layer->velocitySquare = (f32)(vel) * (f32)vel; +#else + layer->velocitySquare = vel * vel; +#endif + } else { + switch (cmd & 0xc0) { + case 0x00: // play note, type 0 (play percentage) + sp3A = m64_read_compressed_u16(state); + layer->playPercentage = sp3A; + break; + + case 0x40: // play note, type 1 (uses default play percentage) + sp3A = layer->shortNoteDefaultPlayPercentage; + break; + + case 0x80: // play note, type 2 (uses last play percentage) + sp3A = layer->playPercentage; + break; + } + + // the remaining bits are used for the semitone + cmd -= cmd & 0xc0; + } + + layer->delay = sp3A; +#if defined(VERSION_EU) || defined(VERSION_SH) + layer->duration = layer->noteDuration * sp3A >> 8; +#else + layer->duration = layer->noteDuration * sp3A / 256; +#endif + if ((seqPlayer->muted && (seqChannel->muteBehavior & MUTE_BEHAVIOR_STOP_NOTES) != 0) + || seqChannel->stopSomething2 +#if defined(VERSION_JP) || defined(VERSION_US) + || !seqChannel->hasInstrument +#endif + ) { + layer->stopSomething = TRUE; + } else { +#if defined(VERSION_EU) || defined(VERSION_SH) + s32 temp = layer->instOrWave; + if (temp == 0xff) temp = seqChannel->instOrWave; + if (temp == 0) +#else + if (seqChannel->instOrWave == 0) +#endif + { // drum + // cmd is reused for the drum semitone + cmd += seqChannel->transposition + layer->transposition; + +#if defined(VERSION_EU) + drum = get_drum(seqChannel->bankId, cmd); +#else + if (cmd >= gCtlEntries[seqChannel->bankId].numDrums) { + cmd = gCtlEntries[seqChannel->bankId].numDrums; + if (cmd == 0) { + // this goto looks a bit like a function return... + layer->stopSomething = TRUE; + goto skip; + } + + cmd--; + } + + drum = gCtlEntries[seqChannel->bankId].drums[cmd]; +#endif + if (drum == NULL) { + layer->stopSomething = TRUE; + } else { + layer->adsr.envelope = drum->envelope; + layer->adsr.releaseRate = drum->releaseRate; +#if defined(VERSION_EU) || defined(VERSION_SH) + if (!layer->ignoreDrumPan) { + layer->pan = drum->pan; + } +#else + layer->pan = FLOAT_CAST(drum->pan) / US_FLOAT(128.0); +#endif + layer->sound = &drum->sound; + layer->freqScale = layer->sound->tuning; + } +#if defined(VERSION_JP) || defined(VERSION_US) || defined(VERSION_SH) + skip:; +#endif + } else { // instrument + // cmd is reused for the instrument semitone + cmd += seqPlayer->transposition + seqChannel->transposition + layer->transposition; + + if (cmd >= 0x80) { + layer->stopSomething = TRUE; + } else { +#if defined(VERSION_EU) || defined(VERSION_SH) + if (layer->instOrWave == 0xffu) { + instrument = seqChannel->instrument; + } else { + instrument = layer->instrument; + } +#else + instrument = layer->instrument; + if (instrument == NULL) { + instrument = seqChannel->instrument; + } +#endif + + if (layer->portamento.mode != 0) { + if (layer->portamentoTargetNote < cmd) { + vel = cmd; + } else { + vel = layer->portamentoTargetNote; + } + + if (instrument != NULL) { +#if defined(VERSION_EU) + sound = instrument_get_audio_bank_sound(instrument, vel); +#else + sound = (u8) vel < instrument->normalRangeLo ? &instrument->lowNotesSound + : (u8) vel <= instrument->normalRangeHi ? + &instrument->normalNotesSound : &instrument->highNotesSound; +#endif + sameSound = (sound == layer->sound); + layer->sound = sound; + tuning = sound->tuning; + } else { + layer->sound = NULL; + tuning = 1.0f; + } + + temp_f2 = gNoteFrequencies[cmd] * tuning; + temp_f12 = gNoteFrequencies[layer->portamentoTargetNote] * tuning; + + portamento = &layer->portamento; + switch (PORTAMENTO_MODE(layer->portamento)) { + case PORTAMENTO_MODE_1: + case PORTAMENTO_MODE_3: + case PORTAMENTO_MODE_5: +#if defined(VERSION_JP) || defined(VERSION_US) + sp24 = temp_f2; +#endif + freqScale = temp_f12; + break; + + case PORTAMENTO_MODE_2: + case PORTAMENTO_MODE_4: +#if defined(VERSION_EU) || defined(VERSION_SH) + default: +#endif + freqScale = temp_f2; +#if defined(VERSION_JP) || defined(VERSION_US) + sp24 = temp_f12; +#endif + break; + } + +#if defined(VERSION_EU) || defined(VERSION_SH) + portamento->extent = temp_f2 / freqScale - 1.0f; +#else + portamento->extent = sp24 / freqScale - US_FLOAT(1.0); +#endif + + if (PORTAMENTO_IS_SPECIAL(layer->portamento)) { + portamento->speed = US_FLOAT(32512.0) * FLOAT_CAST(seqPlayer->tempo) + / ((f32) layer->delay * (f32) gTempoInternalToExternal + * FLOAT_CAST(layer->portamentoTime)); + } else { + portamento->speed = US_FLOAT(127.0) / FLOAT_CAST(layer->portamentoTime); + } + portamento->cur = 0.0f; + layer->freqScale = freqScale; + if (PORTAMENTO_MODE(layer->portamento) == PORTAMENTO_MODE_5) { + layer->portamentoTargetNote = cmd; + } + } else if (instrument != NULL) { +#if defined(VERSION_EU) + sound = instrument_get_audio_bank_sound(instrument, cmd); +#else + sound = cmd < instrument->normalRangeLo ? + &instrument->lowNotesSound : cmd <= instrument->normalRangeHi ? + &instrument->normalNotesSound : &instrument->highNotesSound; +#endif + sameSound = (sound == layer->sound); + layer->sound = sound; + layer->freqScale = gNoteFrequencies[cmd] * sound->tuning; + } else { + layer->sound = NULL; + layer->freqScale = gNoteFrequencies[cmd]; + } + } + } + layer->delayUnused = layer->delay; + } + } + + if (layer->stopSomething == TRUE) { + if (layer->note != NULL || layer->continuousNotes) { + seq_channel_layer_note_decay(layer); + } + return; + } + + cmd = FALSE; + if (!layer->continuousNotes) { + cmd = TRUE; + } else if (layer->note == NULL || layer->status == SOUND_LOAD_STATUS_NOT_LOADED) { + cmd = TRUE; + } else if (sameSound == FALSE) { + seq_channel_layer_note_decay(layer); + cmd = TRUE; + } +#if defined(VERSION_EU) || defined(VERSION_SH) + else if (layer != layer->note->parentLayer) { + cmd = TRUE; + } +#endif + else if (layer->sound == NULL) { + init_synthetic_wave(layer->note, layer); + } + + if (cmd != FALSE) { + layer->note = alloc_note(layer); + } + + if (layer->note != NULL && layer->note->parentLayer == layer) { + note_vibrato_init(layer->note); + } +#if defined(VERSION_EU) || defined(VERSION_SH) + if (seqChannel) { + } +#endif +} + +#ifdef VERSION_EU +u8 audioString106[] = "Audio: Note:Velocity Error %d\n"; +u8 audioString107[] = "Error: Your assignchannel is stolen.\n"; +#endif + +#else +// US/JP version with macros to simulate inlining by copt. Edit if you dare. +#include "copt/seq_channel_layer_process_script_copt.inc.c" +#endif + +#ifdef VERSION_SH +void seq_channel_layer_process_script_part1(struct SequenceChannelLayer *layer) { + if (!layer->continuousNotes) { + seq_channel_layer_note_decay(layer); + } else if (layer->note != NULL && layer->note->wantedParentLayer == layer) { + seq_channel_layer_note_decay(layer); + } + + if (PORTAMENTO_MODE(layer->portamento) == PORTAMENTO_MODE_1 || + PORTAMENTO_MODE(layer->portamento) == PORTAMENTO_MODE_2) { + layer->portamento.mode = 0; + } + + layer->notePropertiesNeedInit = TRUE; +} + +s32 seq_channel_layer_process_script_part5(struct SequenceChannelLayer *layer, s32 cmd) { + if (!layer->stopSomething && layer->sound != NULL && layer->sound->sample->codec == CODEC_SKIP && + layer->sound->sample->medium != 0) { + layer->stopSomething = TRUE; + return -1; + } + + if (layer->continuousNotes == 1 && layer->note != NULL && layer->status && cmd == 1 && + layer->note->parentLayer == layer) { + if (layer->sound == NULL) { + init_synthetic_wave(layer->note, layer); + } + } else { + if (cmd == 0) { + seq_channel_layer_note_decay(layer); + } + layer->note = alloc_note(layer); + } + if (layer->note != NULL && layer->note->parentLayer == layer) { + note_vibrato_init(layer->note); + } + return 0; +} + +s32 seq_channel_layer_process_script_part2(struct SequenceChannelLayer *layer) { + struct SequenceChannel *seqChannel = layer->seqChannel; + struct SequencePlayer *seqPlayer = seqChannel->seqPlayer; + struct M64ScriptState *state; + s32 temp_a0_5; + u16 sp3A; + u8 cmd; + + for (;;) { + state = &layer->scriptState; + cmd = m64_read_u8(state); + + if (cmd <= 0xc0) { + return cmd; + } + + switch (cmd) { + case 0xff: // layer_end; function return or end of script + if (state->depth == 0) { + // N.B. this function call is *not* inlined even though it's + // within the same file, unlike in the rest of this function. + seq_channel_layer_disable(layer); + return -1; + } + state->pc = state->stack[--state->depth]; + break; + + case 0xfc: // layer_call + if (0 && state->depth >= 4) { + eu_stubbed_printf_0("Macro Level Over Error!\n"); + } + sp3A = m64_read_s16(state); + state->stack[state->depth++] = state->pc; + state->pc = seqPlayer->seqData + sp3A; + break; + + case 0xf8: // layer_loop; loop start, N iterations (or 256 if N = 0) + if (0 && state->depth >= 4) { + eu_stubbed_printf_0("Macro Level Over Error!\n"); + } + state->remLoopIters[state->depth] = m64_read_u8(state); + state->stack[state->depth++] = state->pc; + break; + + case 0xf7: // layer_loopend + if (--state->remLoopIters[state->depth - 1] != 0) { + state->pc = state->stack[state->depth - 1]; + } else { + state->depth--; + } + break; + + case 0xfb: // layer_jump + sp3A = m64_read_s16(state); + state->pc = seqPlayer->seqData + sp3A; + break; + + case 0xf4: + state->pc += (s8)m64_read_u8(state); + break; + + case 0xc1: // layer_setshortnotevelocity + case 0xca: // layer_setpan + temp_a0_5 = *(state->pc++); + if (cmd == 0xc1) { + layer->velocitySquare = (f32) (temp_a0_5 * temp_a0_5) / (f32) (127 * 127); + } else { + layer->pan = temp_a0_5; + } + break; + + case 0xc2: // layer_transpose; set transposition in semitones + case 0xc9: // layer_setshortnoteduration + temp_a0_5 = *(state->pc++); + if (cmd == 0xc9) { + layer->noteDuration = temp_a0_5; + } else { + layer->transposition = temp_a0_5; + } + break; + + case 0xc4: // layer_somethingon + case 0xc5: // layer_somethingoff + if (cmd == 0xc4) { + layer->continuousNotes = TRUE; + } else { + layer->continuousNotes = FALSE; + } + seq_channel_layer_note_decay(layer); + break; + + case 0xc3: // layer_setshortnotedefaultplaypercentage + sp3A = m64_read_compressed_u16(state); + layer->shortNoteDefaultPlayPercentage = sp3A; + break; + + case 0xc6: // layer_setinstr + cmd = m64_read_u8(state); + if (cmd >= 0x7f) { + if (cmd == 0x7f) { + layer->instOrWave = 0; + } else { + layer->instOrWave = cmd; + layer->instrument = NULL; + } + + if (1) { + } + + if (cmd == 0xff) { + layer->adsr.releaseRate = 0; + } + break; + } + + if ((layer->instOrWave = get_instrument(seqChannel, cmd, &layer->instrument, &layer->adsr)) == 0) { + eu_stubbed_printf_1("WARNING: NPRG: cannot change %d\n", cmd); + layer->instOrWave = 0xff; + } + break; + + case 0xc7: // layer_portamento + layer->portamento.mode = m64_read_u8(state); + + // cmd is reused for the portamento's semitone + cmd = m64_read_u8(state) + seqChannel->transposition + + layer->transposition + seqPlayer->transposition; + + if (cmd >= 0x80) { + cmd = 0; + } + + layer->portamentoTargetNote = cmd; + + // If special, the next param is u8 instead of var + if (PORTAMENTO_IS_SPECIAL(layer->portamento)) { + layer->portamentoTime = *((state)->pc++); + break; + } + + sp3A = m64_read_compressed_u16(state); + layer->portamentoTime = sp3A; + break; + + case 0xc8: // layer_disableportamento + layer->portamento.mode = 0; + break; + + case 0xcb: + sp3A = m64_read_s16(state); + layer->adsr.envelope = (struct AdsrEnvelope *) (seqPlayer->seqData + sp3A); + layer->adsr.releaseRate = m64_read_u8(state); + break; + + case 0xcc: + layer->ignoreDrumPan = TRUE; + break; + + case 0xcd: + layer->reverbBits.asByte = m64_read_u8(state); + break; + + case 0xce: + cmd = m64_read_u8(state) + 0x80; + layer->freqScaleMultiplier = unk_sh_data_1[cmd]; + // missing break :) + + default: + switch (cmd & 0xf0) { + case 0xd0: // layer_setshortnotevelocityfromtable + sp3A = seqPlayer->shortNoteVelocityTable[cmd & 0xf]; + layer->velocitySquare = (f32) (sp3A * sp3A) / (f32) (127 * 127); + break; + case 0xe0: // layer_setshortnotedurationfromtable + layer->noteDuration = seqPlayer->shortNoteDurationTable[cmd & 0xf]; + break; + default: + eu_stubbed_printf_1("Audio:Track:NOTE:UNDEFINED NOTE COM. %x\n", cmd); + break; + } + } + } + return cmd; +} + +s32 seq_channel_layer_process_script_part4(struct SequenceChannelLayer *layer, s32 cmd1) { + s32 sameSound = TRUE; + struct SequenceChannel *seqChannel = layer->seqChannel; + struct Portamento *portamento; + struct AudioBankSound *sound; + struct Instrument *instrument; + struct Drum *drum; + f32 tuning; + s32 vel; + f32 freqScale; + f32 sp24; + f32 temp_f12; + UNUSED s32 pad[2]; + struct SequencePlayer *seqPlayer = seqChannel->seqPlayer; + u8 cmd = cmd1; + f32 temp_f2; + + s32 temp = layer->instOrWave; + if (temp == 0xff) { + if (!seqChannel->hasInstrument) { + return -1; + } + temp = seqChannel->instOrWave; + } + if (temp == 0) { // drum + // cmd is reused for the drum semitone + cmd += seqChannel->transposition + layer->transposition; + + drum = get_drum(seqChannel->bankId, cmd); + if (drum == NULL) { + layer->stopSomething = TRUE; + layer->delayUnused = layer->delay; + return -1; + } else { + layer->adsr.envelope = drum->envelope; + layer->adsr.releaseRate = drum->releaseRate; + if (!layer->ignoreDrumPan) { + layer->pan = drum->pan; + } + layer->sound = &drum->sound; + layer->freqScale = layer->sound->tuning; + } + } else { // instrument + // cmd is reused for the instrument semitone + cmd += seqPlayer->transposition + seqChannel->transposition + layer->transposition; + + if (cmd >= 0x80) { + layer->stopSomething = TRUE; + return -1; + } else { + if (layer->instOrWave == 0xff) { + instrument = seqChannel->instrument; + } else { + instrument = layer->instrument; + } + + if (layer->portamento.mode != 0) { + if (layer->portamentoTargetNote < cmd) { + vel = cmd; + } else { + vel = layer->portamentoTargetNote; + } + + if (instrument != NULL) { + sound = instrument_get_audio_bank_sound(instrument, vel); + sameSound = (sound == layer->sound); + layer->sound = sound; + tuning = sound->tuning; + } else { + layer->sound = NULL; + tuning = 1.0f; + } + + temp_f2 = gNoteFrequencies[cmd] * tuning; + temp_f12 = gNoteFrequencies[layer->portamentoTargetNote] * tuning; + + portamento = &layer->portamento; + switch (PORTAMENTO_MODE(layer->portamento)) { + case PORTAMENTO_MODE_1: + case PORTAMENTO_MODE_3: + case PORTAMENTO_MODE_5: + sp24 = temp_f2; + freqScale = temp_f12; + break; + + case PORTAMENTO_MODE_2: + case PORTAMENTO_MODE_4: + freqScale = temp_f2; + sp24 = temp_f12; + break; + + default: + freqScale = temp_f2; + sp24 = temp_f2; + break; + } + + portamento->extent = sp24 / freqScale - 1.0f; + + if (PORTAMENTO_IS_SPECIAL(layer->portamento)) { + portamento->speed = US_FLOAT(32512.0) * FLOAT_CAST(seqPlayer->tempo) + / ((f32) layer->delay * (f32) gTempoInternalToExternal + * FLOAT_CAST(layer->portamentoTime)); + } else { + portamento->speed = US_FLOAT(127.0) / FLOAT_CAST(layer->portamentoTime); + } + portamento->cur = 0.0f; + layer->freqScale = freqScale; + if (PORTAMENTO_MODE(layer->portamento) == PORTAMENTO_MODE_5) { + layer->portamentoTargetNote = cmd; + } + } else if (instrument != NULL) { + sound = instrument_get_audio_bank_sound(instrument, cmd); + sameSound = (sound == layer->sound); + layer->sound = sound; + layer->freqScale = gNoteFrequencies[cmd] * sound->tuning; + } else { + layer->sound = NULL; + layer->freqScale = gNoteFrequencies[cmd]; + } + } + } + layer->delayUnused = layer->delay; + layer->freqScale *= layer->freqScaleMultiplier; + return sameSound; +} + +s32 seq_channel_layer_process_script_part3(struct SequenceChannelLayer *layer, s32 cmd) { + struct M64ScriptState *state = &layer->scriptState; + u16 sp3A; + s32 vel; + struct SequenceChannel *seqChannel = layer->seqChannel; + struct SequencePlayer *seqPlayer = seqChannel->seqPlayer; + + if (cmd == 0xc0) { // layer_delay + layer->delay = m64_read_compressed_u16(state); + layer->stopSomething = TRUE; + return -1; + } + + layer->stopSomething = FALSE; + + if (seqChannel->largeNotes == TRUE) { + switch (cmd & 0xc0) { + case 0x00: // layer_note0 (play percentage, velocity, duration) + sp3A = m64_read_compressed_u16(state); + vel = *(state->pc++); + layer->noteDuration = *(state->pc++); + layer->playPercentage = sp3A; + break; + + case 0x40: // layer_note1 (play percentage, velocity) + sp3A = m64_read_compressed_u16(state); + vel = *(state->pc++); + layer->noteDuration = 0; + layer->playPercentage = sp3A; + break; + + case 0x80: // layer_note2 (velocity, duration; uses last play percentage) + sp3A = layer->playPercentage; + vel = *(state->pc++); + layer->noteDuration = *(state->pc++); + break; + } + if (vel >= 0x80 || vel < 0) { + vel = 0x7f; + } + layer->velocitySquare = ((f32) vel * (f32) vel) / (f32) (0x7f * 0x7f); + // the remaining bits are used for the semitone + cmd -= (cmd & 0xc0); + } else { + switch (cmd & 0xc0) { + case 0x00: // play note, type 0 (play percentage) + sp3A = m64_read_compressed_u16(state); + layer->playPercentage = sp3A; + break; + + case 0x40: // play note, type 1 (uses default play percentage) + sp3A = layer->shortNoteDefaultPlayPercentage; + break; + + case 0x80: // play note, type 2 (uses last play percentage) + sp3A = layer->playPercentage; + break; + } + + // the remaining bits are used for the semitone + cmd -= cmd & 0xc0; + } + + layer->delay = sp3A; + layer->duration = layer->noteDuration * sp3A >> 8; + if ((seqPlayer->muted && (seqChannel->muteBehavior & 0x50) != 0) + || seqChannel->stopSomething2) + { + layer->stopSomething = TRUE; + return -1; + } + + return cmd; +} +#endif + +u8 get_instrument(struct SequenceChannel *seqChannel, u8 instId, struct Instrument **instOut, struct AdsrSettings *adsr) { + struct Instrument *inst; +#if defined(VERSION_EU) || defined(VERSION_SH) + inst = get_instrument_inner(seqChannel->bankId, instId); + if (inst == NULL) + { + *instOut = NULL; + return 0; + } + adsr->envelope = inst->envelope; + adsr->releaseRate = inst->releaseRate; + *instOut = inst; + instId++; + return instId; +#else + UNUSED u32 pad; + + if (instId >= gCtlEntries[seqChannel->bankId].numInstruments) { + instId = gCtlEntries[seqChannel->bankId].numInstruments; + if (instId == 0) { + return 0; + } + instId--; + } + + inst = gCtlEntries[seqChannel->bankId].instruments[instId]; + if (inst == NULL) { + struct SequenceChannel seqChannelCpy = *seqChannel; + + while (instId != 0xff) { + inst = gCtlEntries[seqChannelCpy.bankId].instruments[instId]; + if (inst != NULL) { + break; + } + instId--; + } + } + + if (((uintptr_t) gBankLoadedPool.persistent.pool.start <= (uintptr_t) inst + && (uintptr_t) inst <= (uintptr_t)(gBankLoadedPool.persistent.pool.start + + gBankLoadedPool.persistent.pool.size)) + || ((uintptr_t) gBankLoadedPool.temporary.pool.start <= (uintptr_t) inst + && (uintptr_t) inst <= (uintptr_t)(gBankLoadedPool.temporary.pool.start + + gBankLoadedPool.temporary.pool.size))) { + adsr->envelope = inst->envelope; + adsr->releaseRate = inst->releaseRate; + *instOut = inst; + instId++; + return instId; + } + + gAudioErrorFlags = instId + 0x20000; + *instOut = NULL; + return 0; +#endif +} + +void set_instrument(struct SequenceChannel *seqChannel, u8 instId) { + if (instId >= 0x80) { + seqChannel->instOrWave = instId; + seqChannel->instrument = NULL; + } else if (instId == 0x7f) { + seqChannel->instOrWave = 0; + seqChannel->instrument = (struct Instrument *) 1; + } else { +#if defined(VERSION_EU) || defined(VERSION_SH) + if ((seqChannel->instOrWave = + get_instrument(seqChannel, instId, &seqChannel->instrument, &seqChannel->adsr)) == 0) +#else + seqChannel->instOrWave = + get_instrument(seqChannel, instId, &seqChannel->instrument, &seqChannel->adsr); + if (seqChannel->instOrWave == 0) +#endif + { + seqChannel->hasInstrument = FALSE; + return; + } + } + seqChannel->hasInstrument = TRUE; +} + +void sequence_channel_set_volume(struct SequenceChannel *seqChannel, u8 volume) { + seqChannel->volume = FLOAT_CAST(volume) / US_FLOAT(127.0); +} + +void sequence_channel_process_script(struct SequenceChannel *seqChannel) { + struct M64ScriptState *state; + struct SequencePlayer *seqPlayer; + u8 cmd; + s8 temp; + u8 loBits; + u16 sp5A; + s32 sp38; + s8 value; + s32 i; + u8 *seqData; + + if (!seqChannel->enabled) { + return; + } + + if (seqChannel->stopScript) { + for (i = 0; i < LAYERS_MAX; i++) { + if (seqChannel->layers[i] != NULL) { + seq_channel_layer_process_script(seqChannel->layers[i]); + } + } + return; + } + + seqPlayer = seqChannel->seqPlayer; + if (seqPlayer->muted && (seqChannel->muteBehavior & MUTE_BEHAVIOR_STOP_SCRIPT) != 0) { + return; + } + + if (seqChannel->delay != 0) { + seqChannel->delay--; + } + + state = &seqChannel->scriptState; + if (seqChannel->delay == 0) { + for (;;) { + cmd = m64_read_u8(state); +#if !defined(VERSION_EU) && !defined(VERSION_SH) + if (cmd == 0xff) // chan_end + { + if (state->depth == 0) { + sequence_channel_disable(seqChannel); + break; + } + state->depth--, state->pc = state->stack[state->depth]; + } + if (cmd == 0xfe) // chan_delay1 + { + break; + } + if (cmd == 0xfd) // chan_delay + { + seqChannel->delay = m64_read_compressed_u16(state); + break; + } + if (cmd == 0xf3) // chan_hang + { + seqChannel->stopScript = TRUE; + break; + } +#endif + +#ifdef VERSION_SH + if (cmd >= 0xb0) +#else + if (cmd > 0xc0) +#endif + { + switch (cmd) { + case 0xff: // chan_end +#if defined(VERSION_EU) || defined(VERSION_SH) + if (state->depth == 0) { + sequence_channel_disable(seqChannel); + goto out; + } else { + state->pc = state->stack[--state->depth]; + } +#endif + break; + +#if defined(VERSION_EU) || defined(VERSION_SH) + case 0xfe: // chan_delay1 + goto out; + + case 0xfd: // chan_delay + seqChannel->delay = m64_read_compressed_u16(state); + goto out; + + case 0xea: + seqChannel->stopScript = TRUE; + goto out; +#endif + case 0xfc: // chan_call + if (0 && state->depth >= 4) { + eu_stubbed_printf_0("Audio:Track :Call Macro Level Over Error!\n"); + } + sp5A = m64_read_s16(state); +#if defined(VERSION_EU) || defined(VERSION_SH) + state->stack[state->depth++] = state->pc; +#else + state->depth++, state->stack[state->depth - 1] = state->pc; +#endif + state->pc = seqPlayer->seqData + sp5A; + break; + + case 0xf8: // chan_loop; loop start, N iterations (or 256 if N = 0) + if (0 && state->depth >= 4) { + eu_stubbed_printf_0("Audio:Track :Loops Macro Level Over Error!\n"); + } + state->remLoopIters[state->depth] = m64_read_u8(state); +#if defined(VERSION_EU) || defined(VERSION_SH) + state->stack[state->depth++] = state->pc; +#else + state->depth++, state->stack[state->depth - 1] = state->pc; +#endif + break; + + case 0xf7: // chan_loopend + state->remLoopIters[state->depth - 1]--; + if (state->remLoopIters[state->depth - 1] != 0) { + state->pc = state->stack[state->depth - 1]; + } else { + state->depth--; + } + break; + + case 0xf6: // chan_break; break loop, if combined with jump + state->depth--; + break; + + case 0xfb: // chan_jump + case 0xfa: // chan_beqz + case 0xf9: // chan_bltz + case 0xf5: // chan_bgez + sp5A = m64_read_s16(state); + if (cmd == 0xfa && value != 0) + break; + if (cmd == 0xf9 && value >= 0) + break; + if (cmd == 0xf5 && value < 0) + break; + state->pc = seqPlayer->seqData + sp5A; + break; + +#if defined(VERSION_EU) || defined(VERSION_SH) + case 0xf4: // chan_jump_rel + case 0xf3: // chan_beqz_rel + case 0xf2: // chan_bltz_rel + temp = m64_read_u8(state); + if (cmd == 0xf3 && value != 0) + break; + if (cmd == 0xf2 && value >= 0) + break; + state->pc += temp; + break; +#endif + +#if defined(VERSION_EU) || defined(VERSION_SH) + case 0xf1: // chan_reservenotes +#else + case 0xf2: // chan_reservenotes +#endif + note_pool_clear(&seqChannel->notePool); + note_pool_fill(&seqChannel->notePool, m64_read_u8(state)); + break; + +#if defined(VERSION_EU) || defined(VERSION_SH) + case 0xf0: // chan_unreservenotes +#else + case 0xf1: // chan_unreservenotes +#endif + note_pool_clear(&seqChannel->notePool); + break; + + case 0xc2: // chan_setdyntable + sp5A = m64_read_s16(state); + seqChannel->dynTable = (void *) (seqPlayer->seqData + sp5A); + break; + + case 0xc5: // chan_dynsetdyntable + if (value != -1) { +#if defined(VERSION_EU) || defined(VERSION_SH) + seqData = (*seqChannel->dynTable)[value]; + sp38 = (u16)((seqData[0] << 8) + seqData[1]); + seqChannel->dynTable = (void *) (seqPlayer->seqData + sp38); +#else + sp5A = (u16)((((*seqChannel->dynTable)[value])[0] << 8) + (((*seqChannel->dynTable)[value])[1])); + seqChannel->dynTable = (void *) (seqPlayer->seqData + sp5A); +#endif + } + break; + +#if defined(VERSION_EU) || defined(VERSION_SH) + case 0xeb: // chan_setbankandinstr + cmd = m64_read_u8(state); + // Switch to the cmd's (0-indexed) bank in this sequence's + // bank set. Note that in the binary format (not in the JSON!) + // the banks are listed backwards, so we counts from the back. + // (gAlBankSets[offset] is number of banks) + sp38 = ((u16 *) gAlBankSets)[seqPlayer->seqId]; + loBits = *(sp38 + gAlBankSets); + cmd = gAlBankSets[(s32)sp38 + loBits - cmd]; + +#ifdef VERSION_SH + if (get_bank_or_seq(1, 2, cmd) != NULL) +#else + if (get_bank_or_seq(&gBankLoadedPool, 2, cmd) != NULL) +#endif + { + seqChannel->bankId = cmd; + } else { + eu_stubbed_printf_1("SUB:ERR:BANK %d NOT CACHED.\n", cmd); + } + // fallthrough +#endif + + case 0xc1: // chan_setinstr ("set program"?) + set_instrument(seqChannel, m64_read_u8(state)); + break; + + case 0xc3: // chan_largenotesoff + seqChannel->largeNotes = FALSE; + break; + + case 0xc4: // chan_largenoteson + seqChannel->largeNotes = TRUE; + break; + + case 0xdf: // chan_setvol + sequence_channel_set_volume(seqChannel, m64_read_u8(state)); +#if defined(VERSION_EU) || defined(VERSION_SH) + seqChannel->changes.as_bitfields.volume = TRUE; +#endif + break; + + case 0xe0: // chan_setvolscale + seqChannel->volumeScale = FLOAT_CAST(m64_read_u8(state)) / US_FLOAT(128.0); +#if defined(VERSION_EU) || defined(VERSION_SH) + seqChannel->changes.as_bitfields.volume = TRUE; +#endif + break; + + case 0xde: // chan_freqscale; pitch bend using raw frequency multiplier N/2^15 (N is u16) + sp5A = m64_read_s16(state); + seqChannel->freqScale = FLOAT_CAST(sp5A) / US_FLOAT(32768.0); +#if defined(VERSION_EU) || defined(VERSION_SH) + seqChannel->changes.as_bitfields.freqScale = TRUE; +#endif + break; + + case 0xd3: // chan_pitchbend; pitch bend by <= 1 octave in either direction (-127..127) + // (m64_read_u8(state) is really s8 here) +#ifdef VERSION_SH + cmd = m64_read_u8(state) + 128; +#else + cmd = m64_read_u8(state) + 127; +#endif + seqChannel->freqScale = gPitchBendFrequencyScale[cmd]; +#if defined(VERSION_EU) || defined(VERSION_SH) + seqChannel->changes.as_bitfields.freqScale = TRUE; +#endif + break; + +#ifdef VERSION_SH + case 0xee: + cmd = m64_read_u8(state) + 0x80; + seqChannel->freqScale = unk_sh_data_1[cmd]; + seqChannel->changes.as_bitfields.freqScale = TRUE; + break; +#endif + + case 0xdd: // chan_setpan +#if defined(VERSION_EU) || defined(VERSION_SH) + seqChannel->newPan = m64_read_u8(state); + seqChannel->changes.as_bitfields.pan = TRUE; +#else + seqChannel->pan = FLOAT_CAST(m64_read_u8(state)) / US_FLOAT(128.0); +#endif + break; + + case 0xdc: // chan_setpanmix; set proportion of pan to come from channel (0..128) +#if defined(VERSION_EU) || defined(VERSION_SH) + seqChannel->panChannelWeight = m64_read_u8(state); + seqChannel->changes.as_bitfields.pan = TRUE; +#else + seqChannel->panChannelWeight = FLOAT_CAST(m64_read_u8(state)) / US_FLOAT(128.0); +#endif + break; + + case 0xdb: // chan_transpose; set transposition in semitones + temp = *state->pc++; + seqChannel->transposition = temp; + break; + + case 0xda: // chan_setenvelope + sp5A = m64_read_s16(state); + seqChannel->adsr.envelope = (struct AdsrEnvelope *) (seqPlayer->seqData + sp5A); + break; + + case 0xd9: // chan_setdecayrelease + seqChannel->adsr.releaseRate = m64_read_u8(state); + break; + + case 0xd8: // chan_setvibratoextent + seqChannel->vibratoExtentTarget = m64_read_u8(state) * 8; + seqChannel->vibratoExtentStart = 0; + seqChannel->vibratoExtentChangeDelay = 0; + break; + + case 0xd7: // chan_setvibratorate + seqChannel->vibratoRateStart = seqChannel->vibratoRateTarget = + m64_read_u8(state) * 32; + seqChannel->vibratoRateChangeDelay = 0; + break; + + case 0xe2: // chan_setvibratoextentlinear + seqChannel->vibratoExtentStart = m64_read_u8(state) * 8; + seqChannel->vibratoExtentTarget = m64_read_u8(state) * 8; + seqChannel->vibratoExtentChangeDelay = m64_read_u8(state) * 16; + break; + + case 0xe1: // chan_setvibratoratelinear + seqChannel->vibratoRateStart = m64_read_u8(state) * 32; + seqChannel->vibratoRateTarget = m64_read_u8(state) * 32; + seqChannel->vibratoRateChangeDelay = m64_read_u8(state) * 16; + break; + + case 0xe3: // chan_setvibratodelay + seqChannel->vibratoDelay = m64_read_u8(state) * 16; + break; + +#if defined(VERSION_JP) || defined(VERSION_US) + case 0xd6: // chan_setupdatesperframe_unimplemented + cmd = m64_read_u8(state); + if (cmd == 0) { + cmd = gAudioUpdatesPerFrame; + } + seqChannel->updatesPerFrameUnused = cmd; + break; +#endif + + case 0xd4: // chan_setreverb + seqChannel->reverbVol = m64_read_u8(state); + break; + + case 0xc6: // chan_setbank; switch bank within set + cmd = m64_read_u8(state); + // Switch to the temp's (0-indexed) bank in this sequence's + // bank set. Note that in the binary format (not in the JSON!) + // the banks are listed backwards, so we counts from the back. + // (gAlBankSets[offset] is number of banks) +#if defined(VERSION_EU) || defined(VERSION_SH) + sp38 = ((u16 *) gAlBankSets)[seqPlayer->seqId]; + loBits = *(sp38 + gAlBankSets); + cmd = gAlBankSets[(s32)sp38 + loBits - cmd]; +#else + sp5A = ((u16 *) gAlBankSets)[seqPlayer->seqId]; + loBits = *(sp5A + gAlBankSets); + cmd = gAlBankSets[sp5A + loBits - cmd]; +#endif +#ifdef VERSION_SH + if (get_bank_or_seq(1, 2, cmd) != NULL) +#else + if (get_bank_or_seq(&gBankLoadedPool, 2, cmd) != NULL) +#endif + { + seqChannel->bankId = cmd; + } else { + eu_stubbed_printf_1("SUB:ERR:BANK %d NOT CACHED.\n", cmd); + } + break; + + case 0xc7: // chan_writeseq; write to sequence data (!) + { +#if !defined(VERSION_EU) && !defined(VERSION_SH) + u8 *seqData; +#endif + cmd = m64_read_u8(state); + sp5A = m64_read_s16(state); + seqData = seqPlayer->seqData + sp5A; + *seqData = (u8)value + cmd; + } + break; + + case 0xc8: // chan_subtract + case 0xc9: // chan_bitand + case 0xcc: // chan_setval + temp = m64_read_u8(state); + if (cmd == 0xc8) { + value -= temp; + } else if (cmd == 0xcc) { + value = temp; + } else { + value &= temp; + } + break; + +#ifdef VERSION_SH + case 0xcd: + sequence_channel_disable(seqPlayer->channels[m64_read_u8(state)]); + break; +#endif + + case 0xca: // chan_setmutebhv + seqChannel->muteBehavior = m64_read_u8(state); +#ifdef VERSION_SH + seqChannel->changes.as_bitfields.volume = TRUE; +#endif + break; + + case 0xcb: // chan_readseq + sp38 = (u16)m64_read_s16(state) + value; + value = seqPlayer->seqData[sp38]; + break; + +#ifdef VERSION_SH + case 0xce: + seqChannel->unkC8 = m64_read_s16(state); + break; + + case 0xcf: + sp5A = m64_read_s16(state); + seqData = seqPlayer->seqData + sp5A; + seqData[0] = (seqChannel->unkC8 >> 8) & 0xffff; + seqData[1] = (seqChannel->unkC8) & 0xffff; + break; +#endif + + case 0xd0: // chan_stereoheadseteffects + seqChannel->stereoHeadsetEffects = m64_read_u8(state); + break; + + case 0xd1: // chan_setnoteallocationpolicy + seqChannel->noteAllocPolicy = m64_read_u8(state); + break; + + case 0xd2: // chan_setsustain +#if defined(VERSION_EU) || defined(VERSION_SH) + seqChannel->adsr.sustain = m64_read_u8(state); +#else + seqChannel->adsr.sustain = m64_read_u8(state) << 8; +#endif + break; +#if defined(VERSION_EU) || defined(VERSION_SH) + case 0xe5: + seqChannel->reverbIndex = m64_read_u8(state); + break; +#endif + case 0xe4: // chan_dyncall + if (value != -1) { +#if defined(VERSION_EU) || defined(VERSION_SH) + if (state->depth >= 4) { + eu_stubbed_printf_0("Audio:Track: CTBLCALL Macro Level Over Error!\n"); + } +#endif + seqData = (*seqChannel->dynTable)[value]; +#if defined(VERSION_EU) || defined(VERSION_SH) + state->stack[state->depth++] = state->pc; + sp38 = (u16)((seqData[0] << 8) + seqData[1]); + state->pc = seqPlayer->seqData + sp38; + + if (0 && sp38 >= gSeqFileHeader->seqArray[seqPlayer->seqId].len) { + eu_stubbed_printf_3("Err :Sub %x ,address %x:Undefined SubTrack Function %x", seqChannel, state->pc, sp38); + } +#else + state->depth++, state->stack[state->depth - 1] = state->pc; + sp5A = ((seqData[0] << 8) + seqData[1]); + state->pc = seqPlayer->seqData + sp5A; +#endif + } + break; + +#if defined(VERSION_EU) || defined(VERSION_SH) + case 0xe6: + seqChannel->bookOffset = m64_read_u8(state); + break; + + case 0xe7: + sp5A = m64_read_s16(state); + seqData = seqPlayer->seqData + sp5A; + seqChannel->muteBehavior = *seqData++; + seqChannel->noteAllocPolicy = *seqData++; + seqChannel->notePriority = *seqData++; + seqChannel->transposition = (s8) *seqData++; + seqChannel->newPan = *seqData++; + seqChannel->panChannelWeight = *seqData++; + seqChannel->reverbVol = *seqData++; + seqChannel->reverbIndex = *seqData++; + seqChannel->changes.as_bitfields.pan = TRUE; + break; + + case 0xe8: + seqChannel->muteBehavior = m64_read_u8(state); + seqChannel->noteAllocPolicy = m64_read_u8(state); + seqChannel->notePriority = m64_read_u8(state); + seqChannel->transposition = (s8) m64_read_u8(state); + seqChannel->newPan = m64_read_u8(state); + seqChannel->panChannelWeight = m64_read_u8(state); + seqChannel->reverbVol = m64_read_u8(state); + seqChannel->reverbIndex = m64_read_u8(state); + seqChannel->changes.as_bitfields.pan = TRUE; + break; + + case 0xec: + seqChannel->vibratoExtentTarget = 0; + seqChannel->vibratoExtentStart = 0; + seqChannel->vibratoExtentChangeDelay = 0; + seqChannel->vibratoRateTarget = 0; + seqChannel->vibratoRateStart = 0; + seqChannel->vibratoRateChangeDelay = 0; + seqChannel->freqScale = 1.0f; + break; + + case 0xe9: // chan_setnotepriority +#ifdef VERSION_SH + cmd = m64_read_u8(state); + if ((cmd & 0xf) != 0) { + seqChannel->notePriority = cmd & 0xf; + } + cmd = cmd >> 4; + if (cmd != 0) { + seqChannel->unkSH06 = cmd; + } +#else + seqChannel->notePriority = m64_read_u8(state); +#endif + break; +#endif +#ifdef VERSION_SH + case 0xed: + seqChannel->synthesisVolume = m64_read_u8(state); + break; + + case 0xef: + m64_read_s16(state); + m64_read_u8(state); + break; + + case 0xb0: + sp5A = m64_read_s16(state); + seqData = seqPlayer->seqData + sp5A; + seqChannel->filter = (s16 *) (seqData); + break; + + case 0xb1: + seqChannel->filter = NULL; + break; + + case 0xb3: + if (seqChannel->filter != NULL) { + cmd = m64_read_u8(state); + if (cmd == 0) { + seqChannel->filter = NULL; + } else { + loBits = (cmd >> 4) & 0xf; + cmd &= 0xf; + fill_filter(seqChannel->filter, loBits, cmd); + } + } + break; + + case 0xb2: + i = (value * 2); + sp5A = m64_read_s16(state); + sp38 = sp5A + i; + seqChannel->unkC8 = *(u16 *) (seqPlayer->seqData + sp38); + break; + + case 0xb4: + seqChannel->dynTable = (void *) (seqPlayer->seqData + seqChannel->unkC8); + break; + + case 0xb5: + seqChannel->unkC8 = *(u16 *) (*seqChannel->dynTable)[value]; + break; + + case 0xb6: + value = (*seqChannel->dynTable)[0][value]; + break; +#endif + } + } else { +#ifdef VERSION_SH + if (cmd >= 0x80) { + loBits = cmd & 7; + switch (cmd & 0xf8) { + case 0x80: + if (seqChannel->layers[loBits] != NULL) { + value = seqChannel->layers[loBits]->finished; + } else { + value = -1; + } + break; + + case 0x88: + sp5A = m64_read_s16(state); + if (seq_channel_set_layer(seqChannel, loBits) == 0) { + if (1) {} + seqChannel->layers[loBits]->scriptState.pc = seqPlayer->seqData + sp5A; + } + break; + + case 0x90: + seq_channel_layer_free(seqChannel, loBits); + break; + + case 0x98: + if (value != -1 && seq_channel_set_layer(seqChannel, loBits) != -1) { + seqData = (*seqChannel->dynTable)[value]; + sp5A = ((seqData[0] << 8) + seqData[1]); + seqChannel->layers[loBits]->scriptState.pc = seqPlayer->seqData + sp5A; + } + break; + } + } else { +#endif + loBits = cmd & 0xf; + + switch (cmd & 0xf0) { +#ifdef VERSION_SH + case 0x00: + seqChannel->delay = loBits; + goto out; + + case 0x10: + seqChannel->soundScriptIO[loBits] = -1; + if (func_sh_802f47c8(seqChannel->bankId, (u8)value, &seqChannel->soundScriptIO[loBits]) == -1) { + } + break; +#else + case 0x00: // chan_testlayerfinished + if (seqChannel->layers[loBits] != NULL) { + value = seqChannel->layers[loBits]->finished; + } +#ifdef VERSION_EU + else { + value = -1; + } +#endif + break; +#endif + + // sh: 0x70 + case 0x70: // chan_iowriteval; write data back to audio lib + seqChannel->soundScriptIO[loBits] = value; + break; + +#ifdef VERSION_SH + case 0x60: +#else + case 0x80: // chan_ioreadval; read data from audio lib +#endif + value = seqChannel->soundScriptIO[loBits]; + if (loBits < 4) { + seqChannel->soundScriptIO[loBits] = -1; + } + break; + + // sh: 0x50 + case 0x50: // chan_ioreadvalsub; subtract with read data from audio lib + value -= seqChannel->soundScriptIO[loBits]; + break; + +#ifndef VERSION_SH +#ifdef VERSION_EU + // sh: 0x00 + case 0x60: // chan_delayshort + seqChannel->delay = loBits; + goto out; +#endif + + case 0x90: // chan_setlayer + sp5A = m64_read_s16(state); + if (seq_channel_set_layer(seqChannel, loBits) == 0) { +#ifdef VERSION_EU + if (1) {} +#endif + seqChannel->layers[loBits]->scriptState.pc = seqPlayer->seqData + sp5A; + } + break; + + case 0xa0: // chan_freelayer + seq_channel_layer_free(seqChannel, loBits); + break; + + case 0xb0: // chan_dynsetlayer + if (value != -1 && seq_channel_set_layer(seqChannel, loBits) != -1) { + seqData = (*seqChannel->dynTable)[value]; + sp5A = ((seqData[0] << 8) + seqData[1]); + seqChannel->layers[loBits]->scriptState.pc = seqPlayer->seqData + sp5A; + } + break; + +#ifndef VERSION_EU + case 0x60: // chan_setnotepriority (arg must be >= 2) + seqChannel->notePriority = loBits; + break; +#endif +#endif + +#ifdef VERSION_SH + case 0x20: +#else + case 0x10: // chan_startchannel +#endif + sp5A = m64_read_s16(state); + sequence_channel_enable(seqPlayer, loBits, seqPlayer->seqData + sp5A); + break; + +#ifndef VERSION_SH + case 0x20: // chan_disablechannel + sequence_channel_disable(seqPlayer->channels[loBits]); + break; +#endif + + case 0x30: // chan_iowriteval2; write data back to audio lib for another channel + cmd = m64_read_u8(state); + seqPlayer->channels[loBits]->soundScriptIO[cmd] = value; + break; + + case 0x40: // chan_ioreadval2; read data from audio lib from another channel + cmd = m64_read_u8(state); + value = seqPlayer->channels[loBits]->soundScriptIO[cmd]; + break; + } +#ifdef VERSION_SH + } +#endif + } + } + } +#if defined(VERSION_EU) || defined(VERSION_SH) + out: +#endif + + for (i = 0; i < LAYERS_MAX; i++) { + if (seqChannel->layers[i] != 0) { + seq_channel_layer_process_script(seqChannel->layers[i]); + } + } +} + +void sequence_player_process_sequence(struct SequencePlayer *seqPlayer) { + u8 cmd; +#ifdef VERSION_SH + UNUSED u32 pad; +#endif + u8 loBits; + u8 temp; + s32 value; + s32 i; + u16 u16v; + u8 *seqData; + struct M64ScriptState *state; +#if defined(VERSION_EU) || defined(VERSION_SH) + s32 temp32; +#endif + + if (seqPlayer->enabled == FALSE) { + return; + } + +#ifndef VERSION_SH + if (seqPlayer->bankDmaInProgress == TRUE) { +#ifdef VERSION_EU + if (osRecvMesg(&seqPlayer->bankDmaMesgQueue, NULL, 0) == -1) { + return; + } + if (seqPlayer->bankDmaRemaining == 0) { + seqPlayer->bankDmaInProgress = FALSE; + patch_audio_bank( + (struct AudioBank *) (gCtlEntries[seqPlayer->loadingBankId].instruments - 1), + gAlTbl->seqArray[seqPlayer->loadingBankId].offset, + gCtlEntries[seqPlayer->loadingBankId].numInstruments, + gCtlEntries[seqPlayer->loadingBankId].numDrums); + gCtlEntries[seqPlayer->loadingBankId].drums = + ((struct AudioBank *) (gCtlEntries[seqPlayer->loadingBankId].instruments - 1))->drums; + gBankLoadStatus[seqPlayer->loadingBankId] = SOUND_LOAD_STATUS_COMPLETE; + } else { + audio_dma_partial_copy_async(&seqPlayer->bankDmaCurrDevAddr, &seqPlayer->bankDmaCurrMemAddr, + &seqPlayer->bankDmaRemaining, &seqPlayer->bankDmaMesgQueue, + &seqPlayer->bankDmaIoMesg); + } +#else + if (seqPlayer->bankDmaMesg == NULL) { + return; + } + if (seqPlayer->bankDmaRemaining == 0) { + seqPlayer->bankDmaInProgress = FALSE; + patch_audio_bank(seqPlayer->loadingBank, gAlTbl->seqArray[seqPlayer->loadingBankId].offset, + seqPlayer->loadingBankNumInstruments, seqPlayer->loadingBankNumDrums); + gCtlEntries[seqPlayer->loadingBankId].numInstruments = seqPlayer->loadingBankNumInstruments; + gCtlEntries[seqPlayer->loadingBankId].numDrums = seqPlayer->loadingBankNumDrums; + gCtlEntries[seqPlayer->loadingBankId].instruments = seqPlayer->loadingBank->instruments; + gCtlEntries[seqPlayer->loadingBankId].drums = seqPlayer->loadingBank->drums; + gBankLoadStatus[seqPlayer->loadingBankId] = SOUND_LOAD_STATUS_COMPLETE; + } else { + osCreateMesgQueue(&seqPlayer->bankDmaMesgQueue, &seqPlayer->bankDmaMesg, 1); + seqPlayer->bankDmaMesg = NULL; + audio_dma_partial_copy_async(&seqPlayer->bankDmaCurrDevAddr, &seqPlayer->bankDmaCurrMemAddr, + &seqPlayer->bankDmaRemaining, &seqPlayer->bankDmaMesgQueue, + &seqPlayer->bankDmaIoMesg); + } +#endif + return; + } + + if (seqPlayer->seqDmaInProgress == TRUE) { +#ifdef VERSION_EU + if (osRecvMesg(&seqPlayer->seqDmaMesgQueue, NULL, 0) == -1) { + return; + } +#ifndef AVOID_UB + if (temp) { + } +#endif +#else + if (seqPlayer->seqDmaMesg == NULL) { + return; + } +#endif + seqPlayer->seqDmaInProgress = FALSE; + gSeqLoadStatus[seqPlayer->seqId] = SOUND_LOAD_STATUS_COMPLETE; + } +#endif + + // If discarded, bail out. + if (IS_SEQ_LOAD_COMPLETE(seqPlayer->seqId) == FALSE + || ( +#ifdef VERSION_SH + seqPlayer->defaultBank[0] != 0xff && +#endif + IS_BANK_LOAD_COMPLETE(seqPlayer->defaultBank[0]) == FALSE)) { + eu_stubbed_printf_1("Disappear Sequence or Bank %d\n", seqPlayer->seqId); + sequence_player_disable(seqPlayer); + return; + } + + // Remove possible SOUND_LOAD_STATUS_DISCARDABLE marks. +#ifdef VERSION_SH + if (gSeqLoadStatus[seqPlayer->seqId] != 5) +#endif + gSeqLoadStatus[seqPlayer->seqId] = SOUND_LOAD_STATUS_COMPLETE; + +#ifdef VERSION_SH + if (gBankLoadStatus[seqPlayer->defaultBank[0]] != 5) +#endif + gBankLoadStatus[seqPlayer->defaultBank[0]] = SOUND_LOAD_STATUS_COMPLETE; + + if (seqPlayer->muted && (seqPlayer->muteBehavior & MUTE_BEHAVIOR_STOP_SCRIPT) != 0) { + return; + } + + // Check if we surpass the number of ticks needed for a tatum, else stop. + seqPlayer->tempoAcc += seqPlayer->tempo; +#ifdef VERSION_SH + seqPlayer->tempoAcc += seqPlayer->tempoAdd; +#endif + if (seqPlayer->tempoAcc < gTempoInternalToExternal) { + return; + } + seqPlayer->tempoAcc -= (u16) gTempoInternalToExternal; + + state = &seqPlayer->scriptState; + if (seqPlayer->delay > 1) { +#ifndef AVOID_UB + if (temp) { + } +#endif + seqPlayer->delay--; + } else { +#if defined(VERSION_EU) || defined(VERSION_SH) + seqPlayer->recalculateVolume = 1; +#endif + for (;;) { + cmd = m64_read_u8(state); + if (cmd == 0xff) // seq_end + { + if (state->depth == 0) { + sequence_player_disable(seqPlayer); + break; + } +#if defined(VERSION_EU) || defined(VERSION_SH) + state->pc = state->stack[--state->depth]; +#else + state->depth--, state->pc = state->stack[state->depth]; +#endif + } + + if (cmd == 0xfd) // seq_delay + { + seqPlayer->delay = m64_read_compressed_u16(state); + break; + } + + if (cmd == 0xfe) // seq_delay1 + { + seqPlayer->delay = 1; + break; + } + + if (cmd >= 0xc0) { + switch (cmd) { + case 0xff: // seq_end + break; + + case 0xfc: // seq_call + u16v = m64_read_s16(state); + if (0 && state->depth >= 4) { + eu_stubbed_printf_0("Macro Level Over Error!\n"); + } +#if defined(VERSION_EU) || defined(VERSION_SH) + state->stack[state->depth++] = state->pc; +#else + state->depth++, state->stack[state->depth - 1] = state->pc; +#endif + state->pc = seqPlayer->seqData + u16v; + break; + + case 0xf8: // seq_loop; loop start, N iterations (or 256 if N = 0) + if (0 && state->depth >= 4) { + eu_stubbed_printf_0("Macro Level Over Error!\n"); + } + state->remLoopIters[state->depth] = m64_read_u8(state); +#if defined(VERSION_EU) || defined(VERSION_SH) + state->stack[state->depth++] = state->pc; +#else + state->depth++, state->stack[state->depth - 1] = state->pc; +#endif + break; + + case 0xf7: // seq_loopend + state->remLoopIters[state->depth - 1]--; + if (state->remLoopIters[state->depth - 1] != 0) { + state->pc = state->stack[state->depth - 1]; + } else { + state->depth--; + } + break; + + case 0xfb: // seq_jump + case 0xfa: // seq_beqz; jump if == 0 + case 0xf9: // seq_bltz; jump if < 0 + case 0xf5: // seq_bgez; jump if >= 0 + u16v = m64_read_s16(state); + if (cmd == 0xfa && value != 0) { + break; + } + if (cmd == 0xf9 && value >= 0) { + break; + } + if (cmd == 0xf5 && value < 0) { + break; + } + state->pc = seqPlayer->seqData + u16v; + break; + +#if defined(VERSION_EU) || defined(VERSION_SH) + case 0xf4: + case 0xf3: + case 0xf2: + temp = m64_read_u8(state); + if (cmd == 0xf3 && value != 0) { + break; + } + if (cmd == 0xf2 && value >= 0) { + break; + } + state->pc += (s8) temp; + break; +#endif + +#if defined(VERSION_EU) || defined(VERSION_SH) + case 0xf1: // seq_reservenotes +#else + case 0xf2: // seq_reservenotes +#endif + note_pool_clear(&seqPlayer->notePool); + note_pool_fill(&seqPlayer->notePool, m64_read_u8(state)); + break; + +#if defined(VERSION_EU) || defined(VERSION_SH) + case 0xf0: // seq_unreservenotes +#else + case 0xf1: // seq_unreservenotes +#endif + note_pool_clear(&seqPlayer->notePool); + break; + + case 0xdf: // seq_transpose; set transposition in semitones + seqPlayer->transposition = 0; + // fallthrough + + case 0xde: // seq_transposerel; add transposition + seqPlayer->transposition += (s8) m64_read_u8(state); + break; + + case 0xdd: // seq_settempo (bpm) +#ifndef VERSION_SH + case 0xdc: // seq_addtempo (bpm) +#endif +#ifdef VERSION_SH + seqPlayer->tempo = m64_read_u8(state) * TEMPO_SCALE; +#else + temp = m64_read_u8(state); + if (cmd == 0xdd) { + seqPlayer->tempo = temp * TEMPO_SCALE; + } else { + seqPlayer->tempo += (s8) temp * TEMPO_SCALE; + } +#endif + + if (seqPlayer->tempo > gTempoInternalToExternal) { + seqPlayer->tempo = gTempoInternalToExternal; + } + + //if (cmd){} + + if ((s16) seqPlayer->tempo <= 0) { + seqPlayer->tempo = 1; + } + break; + +#ifdef VERSION_SH + case 0xdc: // seq_addtempo (bpm) + seqPlayer->tempoAdd = (s8) m64_read_u8(state) * TEMPO_SCALE; + break; +#endif + +#if defined(VERSION_EU) || defined(VERSION_SH) + case 0xda: + cmd = m64_read_u8(state); + u16v = m64_read_s16(state); + switch (cmd) { + case SEQUENCE_PLAYER_STATE_0: + case SEQUENCE_PLAYER_STATE_FADE_OUT: + if (seqPlayer->state != SEQUENCE_PLAYER_STATE_2) { + seqPlayer->fadeTimerUnkEu = u16v; + seqPlayer->state = cmd; + } + break; + case SEQUENCE_PLAYER_STATE_2: + seqPlayer->fadeRemainingFrames = u16v; + seqPlayer->state = cmd; + seqPlayer->fadeVelocity = + (0.0f - seqPlayer->fadeVolume) / (s32)(u16v & 0xFFFFu); + break; + } + break; + + case 0xdb: + temp32 = m64_read_u8(state); + switch (seqPlayer->state) { + case SEQUENCE_PLAYER_STATE_2: + break; + case SEQUENCE_PLAYER_STATE_FADE_OUT: + seqPlayer->state = SEQUENCE_PLAYER_STATE_0; + seqPlayer->fadeVolume = 0.0f; + // fallthrough + case SEQUENCE_PLAYER_STATE_0: + seqPlayer->fadeRemainingFrames = seqPlayer->fadeTimerUnkEu; + if (seqPlayer->fadeTimerUnkEu != 0) { + seqPlayer->fadeVelocity = (temp32 / 127.0f - seqPlayer->fadeVolume) / FLOAT_CAST(seqPlayer->fadeRemainingFrames); + } else { + seqPlayer->fadeVolume = temp32 / 127.0f; + } + } + break; +#else + case 0xdb: // seq_setvol + cmd = m64_read_u8(state); + switch (seqPlayer->state) { + case SEQUENCE_PLAYER_STATE_2: + if (seqPlayer->fadeRemainingFrames != 0) { + f32 targetVolume = FLOAT_CAST(cmd) / US_FLOAT(127.0); + seqPlayer->fadeVelocity = (targetVolume - seqPlayer->fadeVolume) + / FLOAT_CAST(seqPlayer->fadeRemainingFrames); + break; + } + // fallthrough + case SEQUENCE_PLAYER_STATE_0: + seqPlayer->fadeVolume = FLOAT_CAST(cmd) / US_FLOAT(127.0); + break; + case SEQUENCE_PLAYER_STATE_FADE_OUT: + case SEQUENCE_PLAYER_STATE_4: + seqPlayer->volume = FLOAT_CAST(cmd) / US_FLOAT(127.0); + break; + } + break; + + case 0xda: // seq_changevol + temp = m64_read_u8(state); + seqPlayer->fadeVolume = + seqPlayer->fadeVolume + (f32)(s8) temp / US_FLOAT(127.0); + break; +#endif + +#if defined(VERSION_EU) || defined(VERSION_SH) + case 0xd9: + temp = m64_read_u8(state); + seqPlayer->fadeVolumeScale = (s8) temp / 127.0f; + break; +#endif + + case 0xd7: // seq_initchannels + u16v = m64_read_s16(state); + sequence_player_init_channels(seqPlayer, u16v); + break; + + case 0xd6: // seq_disablechannels + u16v = m64_read_s16(state); + sequence_player_disable_channels(seqPlayer, u16v); + break; + + case 0xd5: // seq_setmutescale + temp = m64_read_u8(state); + seqPlayer->muteVolumeScale = (f32)(s8) temp / US_FLOAT(127.0); + break; + + case 0xd4: // seq_mute + seqPlayer->muted = TRUE; + break; + + case 0xd3: // seq_setmutebhv + seqPlayer->muteBehavior = m64_read_u8(state); + break; + + case 0xd2: // seq_setshortnotevelocitytable + case 0xd1: // seq_setshortnotedurationtable + u16v = m64_read_s16(state); + seqData = seqPlayer->seqData + u16v; + if (cmd == 0xd2) { + seqPlayer->shortNoteVelocityTable = seqData; + } else { + seqPlayer->shortNoteDurationTable = seqData; + } + break; + + case 0xd0: // seq_setnoteallocationpolicy + seqPlayer->noteAllocPolicy = m64_read_u8(state); + break; + + case 0xcc: // seq_setval + value = m64_read_u8(state); + break; + + case 0xc9: // seq_bitand +#if defined(VERSION_EU) || defined(VERSION_SH) + value &= m64_read_u8(state); +#else + value = m64_read_u8(state) & value; +#endif + break; + + case 0xc8: // seq_subtract + value = value - m64_read_u8(state); + break; + +#ifdef VERSION_SH + case 0xc7: + cmd = m64_read_u8(state); + u16v = m64_read_s16(state); + seqData = seqPlayer->seqData + u16v; + *seqData = (u8)value + cmd; + break; + + case 0xc6: + seqPlayer->unkSh = TRUE; + return; +#endif + + default: + eu_stubbed_printf_1("Group:Undefine upper C0h command (%x)\n", cmd); + break; + } + } else { + loBits = cmd & 0xf; + switch (cmd & 0xf0) { + case 0x00: // seq_testchdisabled +#if defined(VERSION_EU) || defined(VERSION_SH) + value = seqPlayer->channels[loBits]->finished; +#else + if (IS_SEQUENCE_CHANNEL_VALID(seqPlayer->channels[loBits]) == TRUE) { + value = seqPlayer->channels[loBits]->finished; + } +#endif + break; + case 0x10: + break; + case 0x20: + break; + case 0x40: + break; + case 0x50: // seq_subvariation +#if defined(VERSION_EU) || defined(VERSION_SH) + value -= seqPlayer->seqVariationEu[0]; +#else + value -= seqPlayer->seqVariation; +#endif + break; + case 0x60: + break; + case 0x70: // seq_setvariation +#if defined(VERSION_EU) || defined(VERSION_SH) + seqPlayer->seqVariationEu[0] = value; +#else + seqPlayer->seqVariation = value; +#endif + break; + case 0x80: // seq_getvariation +#if defined(VERSION_EU) || defined(VERSION_SH) + value = seqPlayer->seqVariationEu[0]; +#else + value = seqPlayer->seqVariation; +#endif + break; + case 0x90: // seq_startchannel + u16v = m64_read_s16(state); + sequence_channel_enable(seqPlayer, loBits, seqPlayer->seqData + u16v); + break; + case 0xa0: + break; +#if !defined(VERSION_EU) && !defined(VERSION_SH) + case 0xd8: // (this makes no sense) + break; + case 0xd9: + break; +#endif + + default: + eu_stubbed_printf_0("Group:Undefined Command\n"); + break; + } + } + } + } + + for (i = 0; i < CHANNELS_MAX; i++) { +#if defined(VERSION_EU) || defined(VERSION_SH) + if (IS_SEQUENCE_CHANNEL_VALID(seqPlayer->channels[i]) == TRUE) { + sequence_channel_process_script(seqPlayer->channels[i]); + } +#else + if (seqPlayer->channels[i] != &gSequenceChannelNone) { + sequence_channel_process_script(seqPlayer->channels[i]); + } +#endif + } +} + +// This runs 240 times per second. +void process_sequences(UNUSED s32 iterationsRemaining) { + s32 i; + for (i = 0; i < SEQUENCE_PLAYERS; i++) { + if (gSequencePlayers[i].enabled == TRUE) { +#if defined(VERSION_EU) || defined(VERSION_SH) + sequence_player_process_sequence(&gSequencePlayers[i]); + sequence_player_process_sound(&gSequencePlayers[i]); +#else + sequence_player_process_sequence(gSequencePlayers + i); + sequence_player_process_sound(gSequencePlayers + i); +#endif + } + } +#if defined(VERSION_JP) || defined(VERSION_US) + reclaim_notes(); +#endif + process_notes(); +} + +void init_sequence_player(u32 player) { + struct SequencePlayer *seqPlayer = &gSequencePlayers[player]; +#if defined(VERSION_EU) || defined(VERSION_SH) + sequence_player_disable(seqPlayer); +#endif +#ifdef VERSION_SH + seqPlayer->unkSh = FALSE; +#else + seqPlayer->muted = FALSE; +#endif + seqPlayer->delay = 0; +#if defined(VERSION_EU) || defined(VERSION_SH) + seqPlayer->state = 1; +#else + seqPlayer->state = SEQUENCE_PLAYER_STATE_0; +#endif + seqPlayer->fadeRemainingFrames = 0; +#if defined(VERSION_EU) || defined(VERSION_SH) + seqPlayer->fadeTimerUnkEu = 0; +#endif + seqPlayer->tempoAcc = 0; + seqPlayer->tempo = 120 * TEMPO_SCALE; // 120 BPM +#ifdef VERSION_SH + seqPlayer->tempoAdd = 0; +#endif + seqPlayer->transposition = 0; +#ifndef VERSION_SH + seqPlayer->muteBehavior = MUTE_BEHAVIOR_STOP_SCRIPT | MUTE_BEHAVIOR_STOP_NOTES | MUTE_BEHAVIOR_SOFTEN; +#endif + seqPlayer->noteAllocPolicy = 0; + seqPlayer->shortNoteVelocityTable = gDefaultShortNoteVelocityTable; + seqPlayer->shortNoteDurationTable = gDefaultShortNoteDurationTable; + seqPlayer->fadeVolume = 1.0f; +#if defined(VERSION_EU) || defined(VERSION_SH) + seqPlayer->fadeVolumeScale = 1.0f; +#endif + seqPlayer->fadeVelocity = 0.0f; + seqPlayer->volume = 0.0f; + seqPlayer->muteVolumeScale = 0.5f; +} + +void init_sequence_players(void) { + // Initialization function, called from audio_init + s32 i, j; + + for (i = 0; i < ARRAY_COUNT(gSequenceChannels); i++) { + gSequenceChannels[i].seqPlayer = NULL; + gSequenceChannels[i].enabled = FALSE; +#if defined(VERSION_JP) || defined(VERSION_US) + } + + for (i = 0; i < ARRAY_COUNT(gSequenceChannels); i++) { +#endif + // @bug Size of wrong array. Zeroes out second half of gSequenceChannels[0], + // all of gSequenceChannels[1..31], and part of gSequenceLayers[0]. + // However, this is only called at startup, so it's harmless. +#ifdef AVOID_UB +#define LAYERS_SIZE LAYERS_MAX +#else +#define LAYERS_SIZE ARRAY_COUNT(gSequenceLayers) +#endif + for (j = 0; j < LAYERS_SIZE; j++) { + gSequenceChannels[i].layers[j] = NULL; + } + } + + init_layer_freelist(); + + for (i = 0; i < ARRAY_COUNT(gSequenceLayers); i++) { + gSequenceLayers[i].seqChannel = NULL; + gSequenceLayers[i].enabled = FALSE; + } + + for (i = 0; i < SEQUENCE_PLAYERS; i++) { + for (j = 0; j < CHANNELS_MAX; j++) { + gSequencePlayers[i].channels[j] = &gSequenceChannelNone; + } + +#if defined(VERSION_EU) || defined(VERSION_SH) + gSequencePlayers[i].seqVariationEu[0] = -1; +#else + gSequencePlayers[i].seqVariation = -1; +#endif +#ifdef VERSION_SH + gSequencePlayers[i].muteBehavior = MUTE_BEHAVIOR_STOP_SCRIPT | MUTE_BEHAVIOR_STOP_NOTES | MUTE_BEHAVIOR_SOFTEN; + gSequencePlayers[i].enabled = FALSE; + gSequencePlayers[i].muted = FALSE; +#endif + gSequencePlayers[i].bankDmaInProgress = FALSE; + gSequencePlayers[i].seqDmaInProgress = FALSE; + init_note_lists(&gSequencePlayers[i].notePool); + init_sequence_player(i); + } +} + diff --git a/src/decomp/audio/seqplayer.h b/src/decomp/audio/seqplayer.h new file mode 100644 index 0000000..d2fc134 --- /dev/null +++ b/src/decomp/audio/seqplayer.h @@ -0,0 +1,18 @@ +#ifndef AUDIO_SEQPLAYER_H +#define AUDIO_SEQPLAYER_H + +#include + +#include "internal.h" +#include "playback.h" + +void seq_channel_layer_disable(struct SequenceChannelLayer *seqPlayer); +void sequence_channel_disable(struct SequenceChannel *seqPlayer); +void sequence_player_disable(struct SequencePlayer* seqPlayer); +void audio_list_push_back(struct AudioListItem *list, struct AudioListItem *item); +void *audio_list_pop_back(struct AudioListItem *list); +void process_sequences(s32 iterationsRemaining); +void init_sequence_player(u32 player); +void init_sequence_players(void); + +#endif // AUDIO_SEQPLAYER_H diff --git a/src/decomp/audio/shindou_debug_prints.c b/src/decomp/audio/shindou_debug_prints.c new file mode 100644 index 0000000..261d452 --- /dev/null +++ b/src/decomp/audio/shindou_debug_prints.c @@ -0,0 +1,148 @@ +#include + +#ifdef VERSION_SH +// synthesis.c +char shindouDebugPrint1[] = "Terminate-Canceled Channel %d,Phase %d\n"; +char shindouDebugPrint2[] = "S->W\n"; +char shindouDebugPrint3[] = "W->S\n"; +char shindouDebugPrint4[] = "S-Resample Pitch %x (old %d -> delay %d)\n"; +s32 shindouDebugPrintPadding1[] = {0,0,0}; + +// heap.c +char shindouDebugPrint5[] = "Warning:Kill Note %x \n"; +char shindouDebugPrint6[] = "Kill Voice %d (ID %d) %d\n"; +char shindouDebugPrint7[] = "Warning: Running Sequence's data disappear!\n"; +char shindouDebugPrint8[] = "%x %x %x\n"; +char shindouDebugPrint9[] = "Audio:Memory:Heap OverFlow : Not Allocate %d!\n"; +char shindouDebugPrint10[] = "%x %x %x\n"; // Again +char shindouDebugPrint11[] = "Audio:Memory:Heap OverFlow : Not Allocate %d!\n"; // Again +char shindouDebugPrint12[] = "Audio:Memory:DataHeap Not Allocate \n"; +char shindouDebugPrint13[] = "StayHeap Not Allocate %d\n"; +char shindouDebugPrint14[] = "AutoHeap Not Allocate %d\n"; +char shindouDebugPrint15[] = "Status ID0 : %d ID1 : %d\n"; +char shindouDebugPrint16[] = "id 0 is Stopping\n"; +char shindouDebugPrint17[] = "id 0 is Stop\n"; +char shindouDebugPrint18[] = "id 1 is Stopping\n"; +char shindouDebugPrint19[] = "id 1 is Stop\n"; +char shindouDebugPrint20[] = "WARNING: NO FREE AUTOSEQ AREA.\n"; +char shindouDebugPrint21[] = "WARNING: NO STOP AUTO AREA.\n"; +char shindouDebugPrint22[] = " AND TRY FORCE TO STOP SIDE \n"; +char shindouDebugPrint23[] = "Check ID0 (seq ID %d) Useing ...\n"; +char shindouDebugPrint24[] = "Check ID1 (seq ID %d) Useing ...\n"; +char shindouDebugPrint25[] = "No Free Seq area.\n"; +char shindouDebugPrint26[] = "CH %d: ID %d\n"; +char shindouDebugPrint27[] = "TWO SIDES ARE LOADING... ALLOC CANCELED.\n"; +char shindouDebugPrint28[] = "WARNING: Before Area Overlaid After."; +char shindouDebugPrint29[] = "WARNING: After Area Overlaid Before."; +char shindouDebugPrint30[] = "MEMORY:SzHeapAlloc ERROR: sza->side %d\n"; +char shindouDebugPrint31[] = "Audio:MEMORY:SzHeap Overflow error. (%d bytes)\n"; +char shindouDebugPrint32[] = "Auto Heap Unhit for ID %d\n"; +char shindouDebugPrint33[] = "Heap Reconstruct Start %x\n"; +char shindouDebugPrint34[] = "---------------------------------------TEMPO %d %f\n"; +char shindouDebugPrint35[] = "%f \n"; +char shindouDebugPrint36[] = "%f \n"; // Again +char shindouDebugPrint37[] = "AHPBASE %x\n"; +char shindouDebugPrint38[] = "AHPCUR %x\n"; +char shindouDebugPrint39[] = "HeapTop %x\n"; +char shindouDebugPrint40[] = "SynoutRate %d / %d \n"; +char shindouDebugPrint41[] = "FXSIZE %d\n"; +char shindouDebugPrint42[] = "FXCOMP %d\n"; +char shindouDebugPrint43[] = "FXDOWN %d\n"; +char shindouDebugPrint44[] = "WaveCacheLen: %d\n"; +char shindouDebugPrint45[] = "SpecChange Finished\n"; +char shindouDebugPrint46[] = "Warning:Emem Over,not alloc %d\n"; +char shindouDebugPrint47[] = "Single AutoSize %d\n"; +char shindouDebugPrint48[] = "Single Ptr %x\n"; +char shindouDebugPrint49[] = "Request--------Single-Auto, %d\n"; +char shindouDebugPrint50[] = "Retry %x, %x, len %x\n"; +char shindouDebugPrint51[] = "DMAing list %d is killed.\n"; +char shindouDebugPrint52[] = "Try Kill %d \n"; +char shindouDebugPrint53[] = "Try Kill %x %x\n"; +char shindouDebugPrint54[] = "Try Kill %x %x %x\n"; +char shindouDebugPrint55[] = "Rom back %x %x \n"; +char shindouDebugPrint56[] = "Error sw NULL \n"; +char shindouDebugPrint57[] = "Request--------Single-Stay, %d\n"; +char shindouDebugPrint58[] = "Try Kill %d \n"; +char shindouDebugPrint59[] = "Try Kill %x %x\n"; +char shindouDebugPrint60[] = "Try Kill %x %x %x\n"; +s32 shindouDebugPrintPadding[] = {0, 0, 0}; + +// load.c +char shindouDebugPrint61[] = "CAUTION:WAVE CACHE FULL %d"; +char shindouDebugPrint62[] = "SUPERDMA"; +char shindouDebugPrint63[] = "Bank Change... top %d lba %d\n"; +char shindouDebugPrint64[] = "BankCount %d\n"; +char shindouDebugPrint65[] = "BANK LOAD MISS! FOR %d\n"; +char shindouDebugPrint66[] = "BankCount %d\n"; +char shindouDebugPrint67[] = "Flush Start\n"; +char shindouDebugPrint68[] = "%d ->%d\n"; +char shindouDebugPrint69[] = "useflag %d\n"; +char shindouDebugPrint70[] = "BankCount %d\n"; +char shindouDebugPrint71[] = "%2x "; +char shindouDebugPrint72[] = "StartSeq (Group %d,Seq %d) Process finish\n"; +char shindouDebugPrint73[] = "LoadCtrl, Ptr %x and Media is %d\n"; +char shindouDebugPrint74[] = "Load Bank, Type %d , ID %d\n"; +char shindouDebugPrint75[] = "get auto\n"; +char shindouDebugPrint76[] = "get s-auto %x\n"; +char shindouDebugPrint77[] = "Seq %d Write ID OK %d!\n"; +char shindouDebugPrint78[] = "Banknumber %d\n"; +char shindouDebugPrint79[] = "Bank Offset %x %d %d\n"; +char shindouDebugPrint80[] = "PEP Touch %x \n"; +char shindouDebugPrint81[] = "FastCopy"; +char shindouDebugPrint82[] = "FastCopy"; +char shindouDebugPrint83[] = "Error: Cannot DMA Media [%d]\n"; +char shindouDebugPrint84[] = "Warning: size not align 16 %x (%s)\n"; +char shindouDebugPrint85[] = "Load Bank BG, Type %d , ID %d\n"; +char shindouDebugPrint86[] = "get auto\n"; +char shindouDebugPrint87[] = "get s-auto %x\n"; +char shindouDebugPrint88[] = "Clear Workarea %x -%x size %x \n"; +char shindouDebugPrint89[] = "AudioHeap is %x\n"; +char shindouDebugPrint90[] = "Heap reset.Synth Change %x \n"; +char shindouDebugPrint91[] = "Heap %x %x %x\n"; +char shindouDebugPrint92[] = "Main Heap Initialize.\n"; +char shindouDebugPrint93[] = "%d :WaveA %d WaveB %d Inst %d,Perc %d\n"; +char shindouDebugPrint94[] = "---------- Init Completed. ------------\n"; +char shindouDebugPrint95[] = " Syndrv :[%6d]\n"; +char shindouDebugPrint96[] = " Seqdrv :[%6d]\n"; +char shindouDebugPrint97[] = " audiodata :[%6d]\n"; +char shindouDebugPrint98[] = "---------------------------------------\n"; +char shindouDebugPrint99[] = "Entry--- %d %d\n"; +char shindouDebugPrint100[] = "---Block LPS here\n"; +char shindouDebugPrint101[] = "===Block LPS end\n"; +char shindouDebugPrint102[] = "SLOWCOPY"; +char shindouDebugPrint103[] = "Req: Src %x Dest %x Len %x,media %d,retcode %d\n"; +char shindouDebugPrint104[] = "Remain Size %d\n"; +char shindouDebugPrint105[] = "---Block BG here\n"; +char shindouDebugPrint106[] = "===Block BG end\n"; +char shindouDebugPrint107[] = "Retcode %x\n"; +char shindouDebugPrint108[] = "Other Type: Not Write ID.\n"; +char shindouDebugPrint109[] = "BGLOAD:Error: dma length 0\n"; +char shindouDebugPrint110[] = "BGCOPY"; +char shindouDebugPrint111[] = "Error: Already wavetable is touched %x.\n"; +char shindouDebugPrint112[] = "Touch Warning: Length zero %x\n"; +char shindouDebugPrint113[] = "It's busy now!!!!! %d\n"; // This one's my favorite +char shindouDebugPrint114[] = "BG LOAD BUFFER is OVER.\n"; +char shindouDebugPrint115[] = "Warning: Length zero %x\n"; +char shindouDebugPrint116[] = "Wave Load %d \n"; +char shindouDebugPrint117[] = "Total Bg Wave Load %d \n"; +char shindouDebugPrint118[] = "Receive %d\n"; +char shindouDebugPrint119[] = "============Error: Magic is Broken after loading.\n"; +char shindouDebugPrint120[] = "Remain DMA: %d\n"; +char shindouDebugPrint121[] = "N start %d\n"; +char shindouDebugPrint122[] = "============Error: Magic is Broken: %x\n"; +char shindouDebugPrint123[] = "Error: No Handle.\n"; +char shindouDebugPrint124[] = "Success: %x\n"; + +// port_eu.c +char shindouDebugPrint125[] = "DAC:Lost 1 Frame.\n"; +char shindouDebugPrint126[] = "DMA: Request queue over.( %d )\n"; +char shindouDebugPrint127[] = "Spec Change Override. %d -> %d\n"; +char shindouDebugPrint128[] = "Audio:now-max tasklen is %d / %d\n"; +char shindouDebugPrint129[] = "Audio:Warning:ABI Tasklist length over (%d)\n"; +s32 D_SH_80314FC8 = 0x80; +struct SPTask *D_SH_80314FCC = NULL; +char shindouDebugPrint130[] = "BGLOAD Start %d\n"; +char shindouDebugPrint131[] = "Error: OverFlow Your Request\n"; +char shindouDebugPrint132[] = "---AudioSending (%d->%d) \n"; +// These continue in unk_shindou_audio_file.c +#endif diff --git a/src/decomp/audio/synthesis.c b/src/decomp/audio/synthesis.c new file mode 100644 index 0000000..727f195 --- /dev/null +++ b/src/decomp/audio/synthesis.c @@ -0,0 +1,1544 @@ +#ifndef VERSION_SH +#include + +#include "synthesis.h" +#include "heap.h" +#include "data.h" +#include "load.h" +#include "seqplayer.h" +#include "internal.h" +#include "external.h" + +#ifndef TARGET_N64 +#include "../pc/mixer.h" +#endif + +#define DMEM_ADDR_TEMP 0x0 +#define DMEM_ADDR_RESAMPLED 0x20 +#define DMEM_ADDR_RESAMPLED2 0x160 +#define DMEM_ADDR_UNCOMPRESSED_NOTE 0x180 +#define DMEM_ADDR_NOTE_PAN_TEMP 0x200 +#define DMEM_ADDR_STEREO_STRONG_TEMP_DRY 0x200 +#define DMEM_ADDR_STEREO_STRONG_TEMP_WET 0x340 +#define DMEM_ADDR_COMPRESSED_ADPCM_DATA 0x3f0 +#define DMEM_ADDR_LEFT_CH 0x4c0 +#define DMEM_ADDR_RIGHT_CH 0x600 +#define DMEM_ADDR_WET_LEFT_CH 0x740 +#define DMEM_ADDR_WET_RIGHT_CH 0x880 + +#define aSetLoadBufferPair(pkt, c, off) \ + aSetBuffer(pkt, 0, c + DMEM_ADDR_WET_LEFT_CH, 0, DEFAULT_LEN_1CH - c); \ + aLoadBuffer(pkt, VIRTUAL_TO_PHYSICAL2(gSynthesisReverb.ringBuffer.left + (off))); \ + aSetBuffer(pkt, 0, c + DMEM_ADDR_WET_RIGHT_CH, 0, DEFAULT_LEN_1CH - c); \ + aLoadBuffer(pkt, VIRTUAL_TO_PHYSICAL2(gSynthesisReverb.ringBuffer.right + (off))) + +#define aSetSaveBufferPair(pkt, c, d, off) \ + aSetBuffer(pkt, 0, 0, c + DMEM_ADDR_WET_LEFT_CH, d); \ + aSaveBuffer(pkt, VIRTUAL_TO_PHYSICAL2(gSynthesisReverb.ringBuffer.left + (off))); \ + aSetBuffer(pkt, 0, 0, c + DMEM_ADDR_WET_RIGHT_CH, d); \ + aSaveBuffer(pkt, VIRTUAL_TO_PHYSICAL2(gSynthesisReverb.ringBuffer.right + (off))); + +#define ALIGN(val, amnt) (((val) + (1 << amnt) - 1) & ~((1 << amnt) - 1)) + +struct VolumeChange { + u16 sourceLeft; + u16 sourceRight; + u16 targetLeft; + u16 targetRight; +}; + +u64 *synthesis_do_one_audio_update(s16 *aiBuf, s32 bufLen, u64 *cmd, s32 updateIndex); +#ifdef VERSION_EU +u64 *synthesis_process_note(struct Note *note, struct NoteSubEu *noteSubEu, struct NoteSynthesisState *synthesisState, s16 *aiBuf, s32 bufLen, u64 *cmd); +u64 *load_wave_samples(u64 *cmd, struct NoteSubEu *noteSubEu, struct NoteSynthesisState *synthesisState, s32 nSamplesToLoad); +u64 *final_resample(u64 *cmd, struct NoteSynthesisState *synthesisState, s32 count, u16 pitch, u16 dmemIn, u32 flags); +u64 *process_envelope(u64 *cmd, struct NoteSubEu *noteSubEu, struct NoteSynthesisState *synthesisState, s32 nSamples, u16 inBuf, s32 headsetPanSettings, u32 flags); +u64 *note_apply_headset_pan_effects(u64 *cmd, struct NoteSubEu *noteSubEu, struct NoteSynthesisState *note, s32 bufLen, s32 flags, s32 leftRight); +#else +u64 *synthesis_process_notes(s16 *aiBuf, s32 bufLen, u64 *cmd); +u64 *load_wave_samples(u64 *cmd, struct Note *note, s32 nSamplesToLoad); +u64 *final_resample(u64 *cmd, struct Note *note, s32 count, u16 pitch, u16 dmemIn, u32 flags); +u64 *process_envelope(u64 *cmd, struct Note *note, s32 nSamples, u16 inBuf, s32 headsetPanSettings, + u32 flags); +u64 *process_envelope_inner(u64 *cmd, struct Note *note, s32 nSamples, u16 inBuf, + s32 headsetPanSettings, struct VolumeChange *vol); +u64 *note_apply_headset_pan_effects(u64 *cmd, struct Note *note, s32 bufLen, s32 flags, s32 leftRight); +#endif + +#ifdef VERSION_EU +struct SynthesisReverb gSynthesisReverbs[4]; +u8 sAudioSynthesisPad[0x10]; +#else +struct SynthesisReverb gSynthesisReverb; +u8 sAudioSynthesisPad[0x20]; +#endif + +#ifdef VERSION_EU +s16 gVolume; +s8 gUseReverb; +s8 gNumSynthesisReverbs; +struct NoteSubEu *gNoteSubsEu; +#endif + +#ifdef VERSION_EU +f32 gLeftVolRampings[3][1024]; +f32 gRightVolRampings[3][1024]; +f32 *gCurrentLeftVolRamping; // Points to any of the three left buffers above +f32 *gCurrentRightVolRamping; // Points to any of the three right buffers above + +u8 audioString1[] = "pitch %x: delaybytes %d : olddelay %d\n"; +u8 audioString2[] = "cont %x: delaybytes %d : olddelay %d\n"; +#endif + +#ifdef VERSION_EU +// Equivalent functionality as the US/JP version, +// just that the reverb structure is chosen from an array with index +void prepare_reverb_ring_buffer(s32 chunkLen, u32 updateIndex, s32 reverbIndex) { + struct ReverbRingBufferItem *item; + struct SynthesisReverb *reverb = &gSynthesisReverbs[reverbIndex]; + s32 srcPos; + s32 dstPos; + s32 nSamples; + s32 excessiveSamples; + s32 UNUSED pad[3]; + if (reverb->downsampleRate != 1) { + if (reverb->framesLeftToIgnore == 0) { + // Now that the RSP has finished, downsample the samples produced two frames ago by skipping + // samples. + item = &reverb->items[reverb->curFrame][updateIndex]; + + // Touches both left and right since they are adjacent in memory + osInvalDCache(item->toDownsampleLeft, DEFAULT_LEN_2CH); + + for (srcPos = 0, dstPos = 0; dstPos < item->lengthA / 2; + srcPos += reverb->downsampleRate, dstPos++) { + reverb->ringBuffer.left[item->startPos + dstPos] = + item->toDownsampleLeft[srcPos]; + reverb->ringBuffer.right[item->startPos + dstPos] = + item->toDownsampleRight[srcPos]; + } + for (dstPos = 0; dstPos < item->lengthB / 2; srcPos += reverb->downsampleRate, dstPos++) { + reverb->ringBuffer.left[dstPos] = item->toDownsampleLeft[srcPos]; + reverb->ringBuffer.right[dstPos] = item->toDownsampleRight[srcPos]; + } + } + } + + item = &reverb->items[reverb->curFrame][updateIndex]; + nSamples = chunkLen / reverb->downsampleRate; + excessiveSamples = (nSamples + reverb->nextRingBufferPos) - reverb->bufSizePerChannel; + if (excessiveSamples < 0) { + // There is space in the ring buffer before it wraps around + item->lengthA = nSamples * 2; + item->lengthB = 0; + item->startPos = (s32) reverb->nextRingBufferPos; + reverb->nextRingBufferPos += nSamples; + } else { + // Ring buffer wrapped around + item->lengthA = (nSamples - excessiveSamples) * 2; + item->lengthB = excessiveSamples * 2; + item->startPos = reverb->nextRingBufferPos; + reverb->nextRingBufferPos = excessiveSamples; + } + // These fields are never read later + item->numSamplesAfterDownsampling = nSamples; + item->chunkLen = chunkLen; +} +#else +void prepare_reverb_ring_buffer(s32 chunkLen, u32 updateIndex) { + struct ReverbRingBufferItem *item; + s32 srcPos; + s32 dstPos; + s32 nSamples; + s32 numSamplesAfterDownsampling; + s32 excessiveSamples; + if (gReverbDownsampleRate != 1) { + if (gSynthesisReverb.framesLeftToIgnore == 0) { + // Now that the RSP has finished, downsample the samples produced two frames ago by skipping + // samples. + item = &gSynthesisReverb.items[gSynthesisReverb.curFrame][updateIndex]; + + // Touches both left and right since they are adjacent in memory + osInvalDCache(item->toDownsampleLeft, DEFAULT_LEN_2CH); + + for (srcPos = 0, dstPos = 0; dstPos < item->lengthA / 2; + srcPos += gReverbDownsampleRate, dstPos++) { + gSynthesisReverb.ringBuffer.left[dstPos + item->startPos] = + item->toDownsampleLeft[srcPos]; + gSynthesisReverb.ringBuffer.right[dstPos + item->startPos] = + item->toDownsampleRight[srcPos]; + } + for (dstPos = 0; dstPos < item->lengthB / 2; srcPos += gReverbDownsampleRate, dstPos++) { + gSynthesisReverb.ringBuffer.left[dstPos] = item->toDownsampleLeft[srcPos]; + gSynthesisReverb.ringBuffer.right[dstPos] = item->toDownsampleRight[srcPos]; + } + } + } + item = &gSynthesisReverb.items[gSynthesisReverb.curFrame][updateIndex]; + + numSamplesAfterDownsampling = chunkLen / gReverbDownsampleRate; + if (((numSamplesAfterDownsampling + gSynthesisReverb.nextRingBufferPos) - gSynthesisReverb.bufSizePerChannel) < 0) { + // There is space in the ring buffer before it wraps around + item->lengthA = numSamplesAfterDownsampling * 2; + item->lengthB = 0; + item->startPos = (s32) gSynthesisReverb.nextRingBufferPos; + gSynthesisReverb.nextRingBufferPos += numSamplesAfterDownsampling; + } else { + // Ring buffer wrapped around + excessiveSamples = + (numSamplesAfterDownsampling + gSynthesisReverb.nextRingBufferPos) - gSynthesisReverb.bufSizePerChannel; + nSamples = numSamplesAfterDownsampling - excessiveSamples; + item->lengthA = nSamples * 2; + item->lengthB = excessiveSamples * 2; + item->startPos = gSynthesisReverb.nextRingBufferPos; + gSynthesisReverb.nextRingBufferPos = excessiveSamples; + } + // These fields are never read later + item->numSamplesAfterDownsampling = numSamplesAfterDownsampling; + item->chunkLen = chunkLen; +} +#endif + +#ifdef VERSION_EU +u64 *synthesis_load_reverb_ring_buffer(u64 *cmd, u16 addr, u16 srcOffset, s32 len, s32 reverbIndex) { + aSetBuffer(cmd++, 0, addr, 0, len); + aLoadBuffer(cmd++, VIRTUAL_TO_PHYSICAL2(&gSynthesisReverbs[reverbIndex].ringBuffer.left[srcOffset])); + + aSetBuffer(cmd++, 0, addr + DEFAULT_LEN_1CH, 0, len); + aLoadBuffer(cmd++, VIRTUAL_TO_PHYSICAL2(&gSynthesisReverbs[reverbIndex].ringBuffer.right[srcOffset])); + + return cmd; +} +#endif + +#ifdef VERSION_EU +u64 *synthesis_save_reverb_ring_buffer(u64 *cmd, u16 addr, u16 destOffset, s32 len, s32 reverbIndex) { + aSetBuffer(cmd++, 0, 0, addr, len); + aSaveBuffer(cmd++, VIRTUAL_TO_PHYSICAL2(&gSynthesisReverbs[reverbIndex].ringBuffer.left[destOffset])); + + aSetBuffer(cmd++, 0, 0, addr + DEFAULT_LEN_1CH, len); + aSaveBuffer(cmd++, VIRTUAL_TO_PHYSICAL2(&gSynthesisReverbs[reverbIndex].ringBuffer.right[destOffset])); + + return cmd; +} +#endif + +#ifdef VERSION_EU +void synthesis_load_note_subs_eu(s32 updateIndex) { + struct NoteSubEu *src; + struct NoteSubEu *dest; + s32 i; + + for (i = 0; i < gMaxSimultaneousNotes; i++) { + src = &gNotes[i].noteSubEu; + dest = &gNoteSubsEu[gMaxSimultaneousNotes * updateIndex + i]; + if (src->enabled) { + *dest = *src; + src->needsInit = FALSE; + } else { + dest->enabled = FALSE; + } + } +} +#endif + +#ifndef VERSION_EU +s32 get_volume_ramping(u16 sourceVol, u16 targetVol, s32 arg2) { + // This roughly computes 2^16 * (targetVol / sourceVol) ^ (8 / arg2), + // but with discretizations of targetVol, sourceVol and arg2. + f32 ret; + switch (arg2) { + default: + ret = gVolRampingLhs136[targetVol >> 8] * gVolRampingRhs136[sourceVol >> 8]; + break; + case 128: + ret = gVolRampingLhs128[targetVol >> 8] * gVolRampingRhs128[sourceVol >> 8]; + break; + case 136: + ret = gVolRampingLhs136[targetVol >> 8] * gVolRampingRhs136[sourceVol >> 8]; + break; + case 144: + ret = gVolRampingLhs144[targetVol >> 8] * gVolRampingRhs144[sourceVol >> 8]; + break; + } + return ret; +} +#endif + +#ifdef VERSION_EU +// TODO: (Scrub C) pointless mask and whitespace +u64 *synthesis_execute(u64 *cmdBuf, s32 *writtenCmds, s16 *aiBuf, s32 bufLen) { + s32 i, j; + f32 *leftVolRamp; + f32 *rightVolRamp; + u32 *aiBufPtr; + u64 *cmd = cmdBuf; + s32 chunkLen; + s32 nextVolRampTable; + + for (i = gAudioBufferParameters.updatesPerFrame; i > 0; i--) { + process_sequences(i - 1); + synthesis_load_note_subs_eu(gAudioBufferParameters.updatesPerFrame - i); + } + aSegment(cmd++, 0, 0); + aiBufPtr = (u32 *) aiBuf; + for (i = gAudioBufferParameters.updatesPerFrame; i > 0; i--) { + if (i == 1) { +#pragma GCC diagnostic push +#if defined(__clang__) +#pragma GCC diagnostic ignored "-Wself-assign" +#endif + // self-assignment has no affect when added here, could possibly simplify a macro definition + chunkLen = bufLen; nextVolRampTable = nextVolRampTable; leftVolRamp = gLeftVolRampings[nextVolRampTable]; rightVolRamp = gRightVolRampings[nextVolRampTable & 0xFFFFFFFF]; +#pragma GCC diagnostic pop + } else { + if (bufLen / i >= gAudioBufferParameters.samplesPerUpdateMax) { + chunkLen = gAudioBufferParameters.samplesPerUpdateMax; nextVolRampTable = 2; leftVolRamp = gLeftVolRampings[2]; rightVolRamp = gRightVolRampings[2]; + } else if (bufLen / i <= gAudioBufferParameters.samplesPerUpdateMin) { + chunkLen = gAudioBufferParameters.samplesPerUpdateMin; nextVolRampTable = 0; leftVolRamp = gLeftVolRampings[0]; rightVolRamp = gRightVolRampings[0]; + } else { + chunkLen = gAudioBufferParameters.samplesPerUpdate; nextVolRampTable = 1; leftVolRamp = gLeftVolRampings[1]; rightVolRamp = gRightVolRampings[1]; + } + } + gCurrentLeftVolRamping = leftVolRamp; + gCurrentRightVolRamping = rightVolRamp; + for (j = 0; j < gNumSynthesisReverbs; j++) { + if (gSynthesisReverbs[j].useReverb != 0) { + prepare_reverb_ring_buffer(chunkLen, gAudioBufferParameters.updatesPerFrame - i, j); + } + } + cmd = synthesis_do_one_audio_update((s16 *) aiBufPtr, chunkLen, cmd, gAudioBufferParameters.updatesPerFrame - i); + bufLen -= chunkLen; + aiBufPtr += chunkLen; + } + + for (j = 0; j < gNumSynthesisReverbs; j++) { + if (gSynthesisReverbs[j].framesLeftToIgnore != 0) { + gSynthesisReverbs[j].framesLeftToIgnore--; + } + gSynthesisReverbs[j].curFrame ^= 1; + } + *writtenCmds = cmd - cmdBuf; + return cmd; +} +#else +// bufLen will be divisible by 16 +u64 *synthesis_execute(u64 *cmdBuf, s32 *writtenCmds, s16 *aiBuf, s32 bufLen) { + s32 chunkLen; + s32 i; + u32 *aiBufPtr = (u32 *) aiBuf; + u64 *cmd = cmdBuf + 1; + s32 v0; + + aSegment(cmdBuf, 0, 0); + + for (i = gAudioUpdatesPerFrame; i > 0; i--) { + if (i == 1) { + // 'bufLen' will automatically be divisible by 8, no need to round + chunkLen = bufLen; + } else { + v0 = bufLen / i; + // chunkLen = v0 rounded to nearest multiple of 8 + chunkLen = v0 - (v0 & 7); + + if ((v0 & 7) >= 4) { + chunkLen += 8; + } + } + process_sequences(i - 1); + if (gSynthesisReverb.useReverb != 0) { + prepare_reverb_ring_buffer(chunkLen, gAudioUpdatesPerFrame - i); + } + cmd = synthesis_do_one_audio_update((s16 *) aiBufPtr, chunkLen, cmd, gAudioUpdatesPerFrame - i); + bufLen -= chunkLen; + aiBufPtr += chunkLen; + } + if (gSynthesisReverb.framesLeftToIgnore != 0) { + gSynthesisReverb.framesLeftToIgnore--; + } + gSynthesisReverb.curFrame ^= 1; + *writtenCmds = cmd - cmdBuf; + return cmd; +} +#endif + + +#ifdef VERSION_EU +u64 *synthesis_resample_and_mix_reverb(u64 *cmd, s32 bufLen, s16 reverbIndex, s16 updateIndex) { + struct ReverbRingBufferItem *item; + s16 startPad; + s16 paddedLengthA; + + item = &gSynthesisReverbs[reverbIndex].items[gSynthesisReverbs[reverbIndex].curFrame][updateIndex]; + + aClearBuffer(cmd++, DMEM_ADDR_WET_LEFT_CH, DEFAULT_LEN_2CH); + if (gSynthesisReverbs[reverbIndex].downsampleRate == 1) { + cmd = synthesis_load_reverb_ring_buffer(cmd, DMEM_ADDR_WET_LEFT_CH, item->startPos, item->lengthA, reverbIndex); + if (item->lengthB != 0) { + cmd = synthesis_load_reverb_ring_buffer(cmd, DMEM_ADDR_WET_LEFT_CH + item->lengthA, 0, item->lengthB, reverbIndex); + } + aSetBuffer(cmd++, 0, 0, 0, DEFAULT_LEN_2CH); + aMix(cmd++, 0, 0x7fff, DMEM_ADDR_WET_LEFT_CH, DMEM_ADDR_LEFT_CH); + aMix(cmd++, 0, 0x8000 + gSynthesisReverbs[reverbIndex].reverbGain, DMEM_ADDR_WET_LEFT_CH, DMEM_ADDR_WET_LEFT_CH); + } else { + startPad = (item->startPos % 8u) * 2; + paddedLengthA = ALIGN(startPad + item->lengthA, 4); + + cmd = synthesis_load_reverb_ring_buffer(cmd, DMEM_ADDR_RESAMPLED, (item->startPos - startPad / 2), DEFAULT_LEN_1CH, reverbIndex); + if (item->lengthB != 0) { + cmd = synthesis_load_reverb_ring_buffer(cmd, DMEM_ADDR_RESAMPLED + paddedLengthA, 0, DEFAULT_LEN_1CH - paddedLengthA, reverbIndex); + } + + aSetBuffer(cmd++, 0, DMEM_ADDR_RESAMPLED + startPad, DMEM_ADDR_WET_LEFT_CH, bufLen * 2); + aResample(cmd++, gSynthesisReverbs[reverbIndex].resampleFlags, gSynthesisReverbs[reverbIndex].resampleRate, VIRTUAL_TO_PHYSICAL2(gSynthesisReverbs[reverbIndex].resampleStateLeft)); + + aSetBuffer(cmd++, 0, DMEM_ADDR_RESAMPLED2 + startPad, DMEM_ADDR_WET_RIGHT_CH, bufLen * 2); + aResample(cmd++, gSynthesisReverbs[reverbIndex].resampleFlags, gSynthesisReverbs[reverbIndex].resampleRate, VIRTUAL_TO_PHYSICAL2(gSynthesisReverbs[reverbIndex].resampleStateRight)); + + aSetBuffer(cmd++, 0, 0, 0, DEFAULT_LEN_2CH); + aMix(cmd++, 0, 0x7fff, DMEM_ADDR_WET_LEFT_CH, DMEM_ADDR_LEFT_CH); + aMix(cmd++, 0, 0x8000 + gSynthesisReverbs[reverbIndex].reverbGain, DMEM_ADDR_WET_LEFT_CH, DMEM_ADDR_WET_LEFT_CH); + } + return cmd; +} + +u64 *synthesis_save_reverb_samples(u64 *cmd, s16 reverbIndex, s16 updateIndex) { + struct ReverbRingBufferItem *item; + + item = &gSynthesisReverbs[reverbIndex].items[gSynthesisReverbs[reverbIndex].curFrame][updateIndex]; + if (gSynthesisReverbs[reverbIndex].useReverb != 0) { + switch (gSynthesisReverbs[reverbIndex].downsampleRate) { + case 1: + // Put the oldest samples in the ring buffer into the wet channels + cmd = synthesis_save_reverb_ring_buffer(cmd, DMEM_ADDR_WET_LEFT_CH, item->startPos, item->lengthA, reverbIndex); + if (item->lengthB != 0) { + // Ring buffer wrapped + cmd = synthesis_save_reverb_ring_buffer(cmd, DMEM_ADDR_WET_LEFT_CH + item->lengthA, 0, item->lengthB, reverbIndex); + } + break; + + default: + // Downsampling is done later by CPU when RSP is done, therefore we need to have double + // buffering. Left and right buffers are adjacent in memory. + aSetBuffer(cmd++, 0, 0, DMEM_ADDR_WET_LEFT_CH, DEFAULT_LEN_2CH); + aSaveBuffer(cmd++, VIRTUAL_TO_PHYSICAL2(gSynthesisReverbs[reverbIndex].items[gSynthesisReverbs[reverbIndex].curFrame][updateIndex].toDownsampleLeft)); + gSynthesisReverbs[reverbIndex].resampleFlags = 0; + break; + } + } + return cmd; +} +#endif + +#ifdef VERSION_EU +u64 *synthesis_do_one_audio_update(s16 *aiBuf, s32 bufLen, u64 *cmd, s32 updateIndex) { + struct NoteSubEu *noteSubEu; + u8 noteIndices[56]; + s32 temp; + s32 i; + s16 j; + s16 notePos = 0; + + if (gNumSynthesisReverbs == 0) { + for (i = 0; i < gMaxSimultaneousNotes; i++) { + if (gNoteSubsEu[gMaxSimultaneousNotes * updateIndex + i].enabled) { + noteIndices[notePos++] = i; + } + } + } else { + for (j = 0; j < gNumSynthesisReverbs; j++) { + for (i = 0; i < gMaxSimultaneousNotes; i++) { + noteSubEu = &gNoteSubsEu[gMaxSimultaneousNotes * updateIndex + i]; + if (noteSubEu->enabled && j == noteSubEu->reverbIndex) { + noteIndices[notePos++] = i; + } + } + } + + for (i = 0; i < gMaxSimultaneousNotes; i++) { + noteSubEu = &gNoteSubsEu[gMaxSimultaneousNotes * updateIndex + i]; + if (noteSubEu->enabled && noteSubEu->reverbIndex >= gNumSynthesisReverbs) { + noteIndices[notePos++] = i; + } + } + } + aClearBuffer(cmd++, DMEM_ADDR_LEFT_CH, DEFAULT_LEN_2CH); + i = 0; + for (j = 0; j < gNumSynthesisReverbs; j++) { + gUseReverb = gSynthesisReverbs[j].useReverb; + if (gUseReverb != 0) { + cmd = synthesis_resample_and_mix_reverb(cmd, bufLen, j, updateIndex); + } + for (; i < notePos; i++) { + temp = updateIndex * gMaxSimultaneousNotes; + if (j == gNoteSubsEu[temp + noteIndices[i]].reverbIndex) { + cmd = synthesis_process_note(&gNotes[noteIndices[i]], + &gNoteSubsEu[temp + noteIndices[i]], + &gNotes[noteIndices[i]].synthesisState, + aiBuf, bufLen, cmd); + continue; + } else { + break; + } + } + if (gSynthesisReverbs[j].useReverb != 0) { + cmd = synthesis_save_reverb_samples(cmd, j, updateIndex); + } + } + for (; i < notePos; i++) { + temp = updateIndex * gMaxSimultaneousNotes; + if (IS_BANK_LOAD_COMPLETE(gNoteSubsEu[temp + noteIndices[i]].bankId) == TRUE) { + cmd = synthesis_process_note(&gNotes[noteIndices[i]], + &gNoteSubsEu[temp + noteIndices[i]], + &gNotes[noteIndices[i]].synthesisState, + aiBuf, bufLen, cmd); + } else { + gAudioErrorFlags = (gNoteSubsEu[temp + noteIndices[i]].bankId + (i << 8)) + 0x10000000; + } + } + + temp = bufLen * 2; + aSetBuffer(cmd++, 0, 0, DMEM_ADDR_TEMP, temp); + aInterleave(cmd++, DMEM_ADDR_LEFT_CH, DMEM_ADDR_RIGHT_CH); + aSetBuffer(cmd++, 0, 0, DMEM_ADDR_TEMP, temp * 2); + aSaveBuffer(cmd++, VIRTUAL_TO_PHYSICAL2(aiBuf)); + return cmd; +} +#else +u64 *synthesis_do_one_audio_update(s16 *aiBuf, s32 bufLen, u64 *cmd, s32 updateIndex) { + UNUSED s32 pad1[1]; + s16 ra; + s16 t4; + UNUSED s32 pad[2]; + struct ReverbRingBufferItem *v1; + UNUSED s32 pad2[1]; + s16 temp; + + v1 = &gSynthesisReverb.items[gSynthesisReverb.curFrame][updateIndex]; + + if (gSynthesisReverb.useReverb == 0) { + aClearBuffer(cmd++, DMEM_ADDR_LEFT_CH, DEFAULT_LEN_2CH); + cmd = synthesis_process_notes(aiBuf, bufLen, cmd); + } else { + if (gReverbDownsampleRate == 1) { + // Put the oldest samples in the ring buffer into the wet channels + aSetLoadBufferPair(cmd++, 0, v1->startPos); + if (v1->lengthB != 0) { + // Ring buffer wrapped + aSetLoadBufferPair(cmd++, v1->lengthA, 0); + temp = 0; + } + + // Use the reverb sound as initial sound for this audio update + aDMEMMove(cmd++, DMEM_ADDR_WET_LEFT_CH, DMEM_ADDR_LEFT_CH, DEFAULT_LEN_2CH); + + // (Hopefully) lower the volume of the wet channels. New reverb will later be mixed into + // these channels. + aSetBuffer(cmd++, 0, 0, 0, DEFAULT_LEN_2CH); + // 0x8000 here is -100% + aMix(cmd++, 0, /*gain*/ 0x8000 + gSynthesisReverb.reverbGain, /*in*/ DMEM_ADDR_WET_LEFT_CH, + /*out*/ DMEM_ADDR_WET_LEFT_CH); + } else { + // Same as above but upsample the previously downsampled samples used for reverb first + temp = 0; //! jesus christ + t4 = (v1->startPos & 7) * 2; + ra = ALIGN(v1->lengthA + t4, 4); + aSetLoadBufferPair(cmd++, 0, v1->startPos - t4 / 2); + if (v1->lengthB != 0) { + // Ring buffer wrapped + aSetLoadBufferPair(cmd++, ra, 0); + //! We need an empty statement (even an empty ';') here to make the function match (because IDO). + //! However, copt removes extraneous statements and dead code. So we need to trick copt + //! into thinking 'temp' could be undefined, and luckily the compiler optimizes out the + //! useless assignment. + ra = ra + temp; + } + aSetBuffer(cmd++, 0, t4 + DMEM_ADDR_WET_LEFT_CH, DMEM_ADDR_LEFT_CH, bufLen << 1); + aResample(cmd++, gSynthesisReverb.resampleFlags, (u16) gSynthesisReverb.resampleRate, VIRTUAL_TO_PHYSICAL2(gSynthesisReverb.resampleStateLeft)); + aSetBuffer(cmd++, 0, t4 + DMEM_ADDR_WET_RIGHT_CH, DMEM_ADDR_RIGHT_CH, bufLen << 1); + aResample(cmd++, gSynthesisReverb.resampleFlags, (u16) gSynthesisReverb.resampleRate, VIRTUAL_TO_PHYSICAL2(gSynthesisReverb.resampleStateRight)); + aSetBuffer(cmd++, 0, 0, 0, DEFAULT_LEN_2CH); + aMix(cmd++, 0, /*gain*/ 0x8000 + gSynthesisReverb.reverbGain, /*in*/ DMEM_ADDR_LEFT_CH, /*out*/ DMEM_ADDR_LEFT_CH); + aDMEMMove(cmd++, DMEM_ADDR_LEFT_CH, DMEM_ADDR_WET_LEFT_CH, DEFAULT_LEN_2CH); + } + cmd = synthesis_process_notes(aiBuf, bufLen, cmd); + if (gReverbDownsampleRate == 1) { + aSetSaveBufferPair(cmd++, 0, v1->lengthA, v1->startPos); + if (v1->lengthB != 0) { + // Ring buffer wrapped + aSetSaveBufferPair(cmd++, v1->lengthA, v1->lengthB, 0); + } + } else { + // Downsampling is done later by CPU when RSP is done, therefore we need to have double + // buffering. Left and right buffers are adjacent in memory. + aSetBuffer(cmd++, 0, 0, DMEM_ADDR_WET_LEFT_CH, DEFAULT_LEN_2CH); + aSaveBuffer(cmd++, VIRTUAL_TO_PHYSICAL2(gSynthesisReverb.items[gSynthesisReverb.curFrame][updateIndex].toDownsampleLeft)); + gSynthesisReverb.resampleFlags = 0; + } + } + return cmd; +} +#endif + +#ifdef VERSION_EU +// Processes just one note, not all +u64 *synthesis_process_note(struct Note *note, struct NoteSubEu *noteSubEu, struct NoteSynthesisState *synthesisState, UNUSED s16 *aiBuf, s32 bufLen, u64 *cmd) { + UNUSED s32 pad0[3]; +#else +u64 *synthesis_process_notes(s16 *aiBuf, s32 bufLen, u64 *cmd) { + s32 noteIndex; // sp174 + struct Note *note; // s7 + UNUSED u8 pad0[0x08]; +#endif + struct AudioBankSample *audioBookSample; // sp164, sp138 + struct AdpcmLoop *loopInfo; // sp160, sp134 + s16 *curLoadedBook = NULL; // sp154, sp130 +#ifdef VERSION_EU + UNUSED u8 padEU[0x04]; +#endif + UNUSED u8 pad8[0x04]; +#ifndef VERSION_EU + u16 resamplingRateFixedPoint; // sp5c, sp11A +#endif + s32 noteFinished; // 150 t2, sp124 + s32 restart; // 14c t3, sp120 + s32 flags; // sp148, sp11C +#ifdef VERSION_EU + u16 resamplingRateFixedPoint; // sp5c, sp11A +#endif + UNUSED u8 pad7[0x0c]; // sp100 + UNUSED s32 tempBufLen; +#ifdef VERSION_EU + s32 sp130; //sp128, sp104 + UNUSED u32 pad9; +#else + UNUSED u32 pad9; + s32 sp130; //sp128, sp104 +#endif + s32 nAdpcmSamplesProcessed; // signed required for US + s32 t0; +#ifdef VERSION_EU + u8 *sampleAddr; // sp120, spF4 + s32 s6; +#else + s32 s6; + u8 *sampleAddr; // sp120, spF4 +#endif + +#ifdef VERSION_EU + s32 samplesLenAdjusted; // 108, spEC + // Might have been used to store (samplesLenFixedPoint >> 0x10), but doing so causes strange + // behavior with the break near the end of the loop, causing US and JP to need a goto instead + UNUSED s32 samplesLenInt; + s32 endPos; // sp110, spE4 + s32 nSamplesToProcess; // sp10c/a0, spE0 + s32 s2; +#else + // Might have been used to store (samplesLenFixedPoint >> 0x10), but doing so causes strange + // behavior with the break near the end of the loop, causing US and JP to need a goto instead + UNUSED s32 samplesLenInt; + s32 samplesLenAdjusted; // 108 + s32 s2; + s32 endPos; // sp110, spE4 + s32 nSamplesToProcess; // sp10c/a0, spE0 +#endif + + s32 leftRight; + s32 s3; + s32 s5; //s4 + + u32 samplesLenFixedPoint; // v1_1 + s32 nSamplesInThisIteration; // v1_2 + u32 a3; +#ifndef VERSION_EU + s32 t9; +#endif + u8 *v0_2; + s32 nParts; // spE8, spBC + s32 curPart; // spE4, spB8 + +#ifndef VERSION_EU + f32 resamplingRate; // f12 +#endif + s32 temp; + +#ifdef VERSION_EU + s32 s5Aligned; +#endif + s32 resampledTempLen; // spD8, spAC + u16 noteSamplesDmemAddrBeforeResampling; // spD6, spAA + + +#ifndef VERSION_EU + for (noteIndex = 0; noteIndex < gMaxSimultaneousNotes; noteIndex++) { + note = &gNotes[noteIndex]; +#ifdef VERSION_US + //! This function requires note->enabled to be volatile, but it breaks other functions like note_enable. + //! Casting to a struct with just the volatile bitfield works, but there may be a better way to match. + if (((struct vNote *)note)->enabled && IS_BANK_LOAD_COMPLETE(note->bankId) == FALSE) { +#else + if (IS_BANK_LOAD_COMPLETE(note->bankId) == FALSE) { +#endif + gAudioErrorFlags = (note->bankId << 8) + noteIndex + 0x1000000; + } else if (((struct vNote *)note)->enabled) { +#else + if (note->noteSubEu.enabled == FALSE) { + return cmd; + } else { +#endif + flags = 0; +#ifdef VERSION_EU + tempBufLen = bufLen; +#endif + +#ifdef VERSION_EU + if (noteSubEu->needsInit == TRUE) { +#else + if (note->needsInit == TRUE) { +#endif + flags = A_INIT; +#ifndef VERSION_EU + note->samplePosInt = 0; + note->samplePosFrac = 0; +#else + synthesisState->restart = FALSE; + synthesisState->samplePosInt = 0; + synthesisState->samplePosFrac = 0; + synthesisState->curVolLeft = 1; + synthesisState->curVolRight = 1; + synthesisState->prevHeadsetPanRight = 0; + synthesisState->prevHeadsetPanLeft = 0; +#endif + } + +#ifndef VERSION_EU + if (note->frequency < US_FLOAT(2.0)) { + nParts = 1; + if (note->frequency > US_FLOAT(1.99996)) { + note->frequency = US_FLOAT(1.99996); + } + resamplingRate = note->frequency; + } else { + // If frequency is > 2.0, the processing must be split into two parts + nParts = 2; + if (note->frequency >= US_FLOAT(3.99993)) { + note->frequency = US_FLOAT(3.99993); + } + resamplingRate = note->frequency * US_FLOAT(.5); + } + + resamplingRateFixedPoint = (u16)(s32)(resamplingRate * 32768.0f); + samplesLenFixedPoint = note->samplePosFrac + (resamplingRateFixedPoint * bufLen) * 2; + note->samplePosFrac = samplesLenFixedPoint & 0xFFFF; // 16-bit store, can't reuse +#else + resamplingRateFixedPoint = noteSubEu->resamplingRateFixedPoint; + nParts = noteSubEu->hasTwoAdpcmParts + 1; + samplesLenFixedPoint = (resamplingRateFixedPoint * tempBufLen * 2) + synthesisState->samplePosFrac; + synthesisState->samplePosFrac = samplesLenFixedPoint & 0xFFFF; +#endif + +#ifdef VERSION_EU + if (noteSubEu->isSyntheticWave) { + cmd = load_wave_samples(cmd, noteSubEu, synthesisState, samplesLenFixedPoint >> 0x10); + noteSamplesDmemAddrBeforeResampling = (synthesisState->samplePosInt * 2) + DMEM_ADDR_UNCOMPRESSED_NOTE; + synthesisState->samplePosInt += samplesLenFixedPoint >> 0x10; + } +#else + if (note->sound == NULL) { + // A wave synthesis note (not ADPCM) + + cmd = load_wave_samples(cmd, note, samplesLenFixedPoint >> 0x10); + noteSamplesDmemAddrBeforeResampling = DMEM_ADDR_UNCOMPRESSED_NOTE + note->samplePosInt * 2; + note->samplePosInt += (samplesLenFixedPoint >> 0x10); + flags = 0; + } +#endif + else { + // ADPCM note + +#ifdef VERSION_EU + audioBookSample = noteSubEu->sound.audioBankSound->sample; +#else + audioBookSample = note->sound->sample; +#endif + + loopInfo = audioBookSample->loop; + endPos = loopInfo->end; + sampleAddr = audioBookSample->sampleAddr; + resampledTempLen = 0; + for (curPart = 0; curPart < nParts; curPart++) { + nAdpcmSamplesProcessed = 0; // s8 + s5 = 0; // s4 + + if (nParts == 1) { + samplesLenAdjusted = samplesLenFixedPoint >> 0x10; + } else if ((samplesLenFixedPoint >> 0x10) & 1) { + samplesLenAdjusted = ((samplesLenFixedPoint >> 0x10) & ~1) + (curPart * 2); + } + else { + samplesLenAdjusted = (samplesLenFixedPoint >> 0x10); + } + + if (curLoadedBook != audioBookSample->book->book) { + u32 nEntries; // v1 + curLoadedBook = audioBookSample->book->book; +#ifdef VERSION_EU + nEntries = 16 * audioBookSample->book->order * audioBookSample->book->npredictors; + aLoadADPCM(cmd++, nEntries, VIRTUAL_TO_PHYSICAL2(curLoadedBook + noteSubEu->bookOffset)); +#else + nEntries = audioBookSample->book->order * audioBookSample->book->npredictors; + aLoadADPCM(cmd++, nEntries * 16, VIRTUAL_TO_PHYSICAL2(curLoadedBook)); +#endif + } + +#ifdef VERSION_EU + if (noteSubEu->bookOffset) { + curLoadedBook = euUnknownData_80301950; // what's this? never read + } +#endif + + while (nAdpcmSamplesProcessed != samplesLenAdjusted) { + s32 samplesRemaining; // v1 + s32 s0; + + noteFinished = FALSE; + restart = FALSE; + nSamplesToProcess = samplesLenAdjusted - nAdpcmSamplesProcessed; +#ifdef VERSION_EU + s2 = synthesisState->samplePosInt & 0xf; + samplesRemaining = endPos - synthesisState->samplePosInt; +#else + s2 = note->samplePosInt & 0xf; + samplesRemaining = endPos - note->samplePosInt; +#endif + +#ifdef VERSION_EU + if (s2 == 0 && synthesisState->restart == FALSE) { + s2 = 16; + } +#else + if (s2 == 0 && note->restart == FALSE) { + s2 = 16; + } +#endif + s6 = 16 - s2; // a1 + + if (nSamplesToProcess < samplesRemaining) { + t0 = (nSamplesToProcess - s6 + 0xf) / 16; + s0 = t0 * 16; + s3 = s6 + s0 - nSamplesToProcess; + } else { +#ifndef VERSION_EU + s0 = samplesRemaining + s2 - 0x10; +#else + s0 = samplesRemaining - s6; +#endif + s3 = 0; + if (s0 <= 0) { + s0 = 0; + s6 = samplesRemaining; + } + t0 = (s0 + 0xf) / 16; + if (loopInfo->count != 0) { + // Loop around and restart + restart = 1; + } else { + noteFinished = 1; + } + } + + if (t0 != 0) { +#ifdef VERSION_EU + temp = (synthesisState->samplePosInt - s2 + 0x10) / 16; + if (audioBookSample->loaded == 0x81) { + v0_2 = sampleAddr + temp * 9; + } else { + v0_2 = dma_sample_data( + (uintptr_t) (sampleAddr + temp * 9), + t0 * 9, flags, &synthesisState->sampleDmaIndex); + } +#else + temp = (note->samplePosInt - s2 + 0x10) / 16; + v0_2 = dma_sample_data( + (uintptr_t) (sampleAddr + temp * 9), + t0 * 9, flags, ¬e->sampleDmaIndex); +#endif + a3 = (u32)((uintptr_t) v0_2 & 0xf); + aSetBuffer(cmd++, 0, DMEM_ADDR_COMPRESSED_ADPCM_DATA, 0, t0 * 9 + a3); + aLoadBuffer(cmd++, VIRTUAL_TO_PHYSICAL2(v0_2 - a3)); + } else { + s0 = 0; + a3 = 0; + } + +#ifdef VERSION_EU + if (synthesisState->restart != FALSE) { + aSetLoop(cmd++, VIRTUAL_TO_PHYSICAL2(audioBookSample->loop->state)); + flags = A_LOOP; // = 2 + synthesisState->restart = FALSE; + } +#else + if (note->restart != FALSE) { + aSetLoop(cmd++, VIRTUAL_TO_PHYSICAL2(audioBookSample->loop->state)); + flags = A_LOOP; // = 2 + note->restart = FALSE; + } +#endif + + nSamplesInThisIteration = s0 + s6 - s3; +#ifdef VERSION_EU + if (nAdpcmSamplesProcessed == 0) { + aSetBuffer(cmd++, 0, DMEM_ADDR_COMPRESSED_ADPCM_DATA + a3, + DMEM_ADDR_UNCOMPRESSED_NOTE, s0 * 2); + aADPCMdec(cmd++, flags, + VIRTUAL_TO_PHYSICAL2(synthesisState->synthesisBuffers->adpcmdecState)); + sp130 = s2 * 2; + } else { + s5Aligned = ALIGN(s5, 5); + aSetBuffer(cmd++, 0, DMEM_ADDR_COMPRESSED_ADPCM_DATA + a3, + DMEM_ADDR_UNCOMPRESSED_NOTE + s5Aligned, s0 * 2); + aADPCMdec(cmd++, flags, + VIRTUAL_TO_PHYSICAL2(synthesisState->synthesisBuffers->adpcmdecState)); + aDMEMMove(cmd++, DMEM_ADDR_UNCOMPRESSED_NOTE + s5Aligned + (s2 * 2), + DMEM_ADDR_UNCOMPRESSED_NOTE + s5, (nSamplesInThisIteration) * 2); + } +#else + if (nAdpcmSamplesProcessed == 0) { + aSetBuffer(cmd++, 0, DMEM_ADDR_COMPRESSED_ADPCM_DATA + a3, DMEM_ADDR_UNCOMPRESSED_NOTE, s0 * 2); + aADPCMdec(cmd++, flags, VIRTUAL_TO_PHYSICAL2(note->synthesisBuffers->adpcmdecState)); + sp130 = s2 * 2; + } else { + aSetBuffer(cmd++, 0, DMEM_ADDR_COMPRESSED_ADPCM_DATA + a3, DMEM_ADDR_UNCOMPRESSED_NOTE + ALIGN(s5, 5), s0 * 2); + aADPCMdec(cmd++, flags, VIRTUAL_TO_PHYSICAL2(note->synthesisBuffers->adpcmdecState)); + aDMEMMove(cmd++, DMEM_ADDR_UNCOMPRESSED_NOTE + ALIGN(s5, 5) + (s2 * 2), DMEM_ADDR_UNCOMPRESSED_NOTE + s5, (nSamplesInThisIteration) * 2); + } +#endif + + nAdpcmSamplesProcessed += nSamplesInThisIteration; + + switch (flags) { + case A_INIT: // = 1 + sp130 = 0; + s5 = s0 * 2 + s5; + break; + + case A_LOOP: // = 2 + s5 = nSamplesInThisIteration * 2 + s5; + break; + + default: + if (s5 != 0) { + s5 = nSamplesInThisIteration * 2 + s5; + } else { + s5 = (s2 + nSamplesInThisIteration) * 2; + } + break; + } + flags = 0; + + if (noteFinished) { + aClearBuffer(cmd++, DMEM_ADDR_UNCOMPRESSED_NOTE + s5, + (samplesLenAdjusted - nAdpcmSamplesProcessed) * 2); +#ifdef VERSION_EU + noteSubEu->finished = 1; + note->noteSubEu.finished = 1; + note->noteSubEu.enabled = 0; +#else + note->samplePosInt = 0; + note->finished = 1; + ((struct vNote *)note)->enabled = 0; +#endif + break; + } +#ifdef VERSION_EU + if (restart) { + synthesisState->restart = TRUE; + synthesisState->samplePosInt = loopInfo->start; + } else { + synthesisState->samplePosInt += nSamplesToProcess; + } +#else + if (restart) { + note->restart = TRUE; + note->samplePosInt = loopInfo->start; + } else { + note->samplePosInt += nSamplesToProcess; + } +#endif + } + + switch (nParts) { + case 1: + noteSamplesDmemAddrBeforeResampling = DMEM_ADDR_UNCOMPRESSED_NOTE + sp130; + break; + + case 2: + switch (curPart) { + case 0: + aSetBuffer(cmd++, 0, DMEM_ADDR_UNCOMPRESSED_NOTE + sp130, DMEM_ADDR_RESAMPLED, samplesLenAdjusted + 4); +#ifdef VERSION_EU + aResample(cmd++, A_INIT, 0xff60, VIRTUAL_TO_PHYSICAL2(synthesisState->synthesisBuffers->dummyResampleState)); +#else + aResample(cmd++, A_INIT, 0xff60, VIRTUAL_TO_PHYSICAL2(note->synthesisBuffers->dummyResampleState)); +#endif + resampledTempLen = samplesLenAdjusted + 4; + noteSamplesDmemAddrBeforeResampling = DMEM_ADDR_RESAMPLED + 4; +#ifdef VERSION_EU + if (noteSubEu->finished != FALSE) { +#else + if (note->finished != FALSE) { +#endif + aClearBuffer(cmd++, DMEM_ADDR_RESAMPLED + resampledTempLen, samplesLenAdjusted + 0x10); + } + break; + + case 1: + aSetBuffer(cmd++, 0, DMEM_ADDR_UNCOMPRESSED_NOTE + sp130, + DMEM_ADDR_RESAMPLED2, + samplesLenAdjusted + 8); +#ifdef VERSION_EU + aResample(cmd++, A_INIT, 0xff60, + VIRTUAL_TO_PHYSICAL2( + synthesisState->synthesisBuffers->dummyResampleState)); +#else + aResample(cmd++, A_INIT, 0xff60, + VIRTUAL_TO_PHYSICAL2( + note->synthesisBuffers->dummyResampleState)); +#endif + aDMEMMove(cmd++, DMEM_ADDR_RESAMPLED2 + 4, + DMEM_ADDR_RESAMPLED + resampledTempLen, + samplesLenAdjusted + 4); + break; + } + } + +#ifdef VERSION_EU + if (noteSubEu->finished != FALSE) { +#else + if (note->finished != FALSE) { +#endif + break; + } + } + } + + flags = 0; + +#ifdef VERSION_EU + if (noteSubEu->needsInit == TRUE) { + flags = A_INIT; + noteSubEu->needsInit = FALSE; + } + + cmd = final_resample(cmd, synthesisState, bufLen * 2, resamplingRateFixedPoint, + noteSamplesDmemAddrBeforeResampling, flags); +#else + if (note->needsInit == TRUE) { + flags = A_INIT; + note->needsInit = FALSE; + } + + cmd = final_resample(cmd, note, bufLen * 2, resamplingRateFixedPoint, + noteSamplesDmemAddrBeforeResampling, flags); +#endif + +#ifdef VERSION_EU + if (noteSubEu->headsetPanRight != 0 || synthesisState->prevHeadsetPanRight != 0) { + leftRight = 1; + } else if (noteSubEu->headsetPanLeft != 0 || synthesisState->prevHeadsetPanLeft != 0) { + leftRight = 2; +#else + if (note->headsetPanRight != 0 || note->prevHeadsetPanRight != 0) { + leftRight = 1; + } else if (note->headsetPanLeft != 0 || note->prevHeadsetPanLeft != 0) { + leftRight = 2; +#endif + } else { + leftRight = 0; + } + +#ifdef VERSION_EU + cmd = process_envelope(cmd, noteSubEu, synthesisState, bufLen, 0, leftRight, flags); +#else + cmd = process_envelope(cmd, note, bufLen, 0, leftRight, flags); +#endif + +#ifdef VERSION_EU + if (noteSubEu->usesHeadsetPanEffects) { + cmd = note_apply_headset_pan_effects(cmd, noteSubEu, synthesisState, bufLen * 2, flags, leftRight); + } +#else + if (note->usesHeadsetPanEffects) { + cmd = note_apply_headset_pan_effects(cmd, note, bufLen * 2, flags, leftRight); + } +#endif + } +#ifndef VERSION_EU + } + + t9 = bufLen * 2; + aSetBuffer(cmd++, 0, 0, DMEM_ADDR_TEMP, t9); + aInterleave(cmd++, DMEM_ADDR_LEFT_CH, DMEM_ADDR_RIGHT_CH); + t9 *= 2; + aSetBuffer(cmd++, 0, 0, DMEM_ADDR_TEMP, t9); + aSaveBuffer(cmd++, VIRTUAL_TO_PHYSICAL2(aiBuf)); +#endif + + return cmd; +} + +#ifdef VERSION_EU +u64 *load_wave_samples(u64 *cmd, struct NoteSubEu *noteSubEu, struct NoteSynthesisState *synthesisState, s32 nSamplesToLoad) { + s32 a3; + s32 repeats; + s32 i; + aSetBuffer(cmd++, /*flags*/ 0, /*dmemin*/ DMEM_ADDR_UNCOMPRESSED_NOTE, /*dmemout*/ 0, /*count*/ 128); + aLoadBuffer(cmd++, VIRTUAL_TO_PHYSICAL2(noteSubEu->sound.samples)); + + synthesisState->samplePosInt &= 0x3f; + a3 = 64 - synthesisState->samplePosInt; + if (a3 < nSamplesToLoad) { + repeats = (nSamplesToLoad - a3 + 63) / 64; + for (i = 0; i < repeats; i++) { + aDMEMMove(cmd++, + /*dmemin*/ DMEM_ADDR_UNCOMPRESSED_NOTE, + /*dmemout*/ DMEM_ADDR_UNCOMPRESSED_NOTE + (1 + i) * 128, + /*count*/ 128); + } + } + return cmd; +} +#else +u64 *load_wave_samples(u64 *cmd, struct Note *note, s32 nSamplesToLoad) { + s32 a3; + s32 i; + aSetBuffer(cmd++, /*flags*/ 0, /*dmemin*/ DMEM_ADDR_UNCOMPRESSED_NOTE, /*dmemout*/ 0, + /*count*/ sizeof(note->synthesisBuffers->samples)); + aLoadBuffer(cmd++, VIRTUAL_TO_PHYSICAL2(note->synthesisBuffers->samples)); + note->samplePosInt &= (note->sampleCount - 1); + a3 = 64 - note->samplePosInt; + if (a3 < nSamplesToLoad) { + for (i = 0; i <= (nSamplesToLoad - a3 + 63) / 64 - 1; i++) { + aDMEMMove(cmd++, /*dmemin*/ DMEM_ADDR_UNCOMPRESSED_NOTE, /*dmemout*/ DMEM_ADDR_UNCOMPRESSED_NOTE + (1 + i) * sizeof(note->synthesisBuffers->samples), /*count*/ sizeof(note->synthesisBuffers->samples)); + } + } + return cmd; +} +#endif + +#ifdef VERSION_EU +u64 *final_resample(u64 *cmd, struct NoteSynthesisState *synthesisState, s32 count, u16 pitch, u16 dmemIn, u32 flags) { + aSetBuffer(cmd++, /*flags*/ 0, dmemIn, /*dmemout*/ DMEM_ADDR_TEMP, count); + aResample(cmd++, flags, pitch, VIRTUAL_TO_PHYSICAL2(synthesisState->synthesisBuffers->finalResampleState)); + return cmd; +} +#else +u64 *final_resample(u64 *cmd, struct Note *note, s32 count, u16 pitch, u16 dmemIn, u32 flags) { + aSetBuffer(cmd++, /*flags*/ 0, dmemIn, /*dmemout*/ DMEM_ADDR_TEMP, count); + aResample(cmd++, flags, pitch, VIRTUAL_TO_PHYSICAL2(note->synthesisBuffers->finalResampleState)); + return cmd; +} +#endif + +#ifndef VERSION_EU +u64 *process_envelope(u64 *cmd, struct Note *note, s32 nSamples, u16 inBuf, s32 headsetPanSettings, + UNUSED u32 flags) { + UNUSED u8 pad[16]; + struct VolumeChange vol; + vol.sourceLeft = note->curVolLeft; + vol.sourceRight = note->curVolRight; + vol.targetLeft = note->targetVolLeft; + vol.targetRight = note->targetVolRight; + note->curVolLeft = vol.targetLeft; + note->curVolRight = vol.targetRight; + return process_envelope_inner(cmd, note, nSamples, inBuf, headsetPanSettings, &vol); +} + +u64 *process_envelope_inner(u64 *cmd, struct Note *note, s32 nSamples, u16 inBuf, + s32 headsetPanSettings, struct VolumeChange *vol) { + UNUSED u8 pad[3]; + u8 mixerFlags; + UNUSED u8 pad2[8]; + s32 rampLeft, rampRight; +#elif defined(VERSION_EU) +u64 *process_envelope(u64 *cmd, struct NoteSubEu *note, struct NoteSynthesisState *synthesisState, s32 nSamples, u16 inBuf, s32 headsetPanSettings, UNUSED u32 flags) { + UNUSED u8 pad1[20]; + u16 sourceRight; + u16 sourceLeft; + UNUSED u8 pad2[4]; + u16 targetLeft; + u16 targetRight; + s32 mixerFlags; + s32 rampLeft; + s32 rampRight; + + sourceLeft = synthesisState->curVolLeft; + sourceRight = synthesisState->curVolRight; + targetLeft = (note->targetVolLeft << 5); + targetRight = (note->targetVolRight << 5); + if (targetLeft == 0) { + targetLeft++; + } + if (targetRight == 0) { + targetRight++; + } + synthesisState->curVolLeft = targetLeft; + synthesisState->curVolRight = targetRight; +#endif + + // For aEnvMixer, five buffers and count are set using aSetBuffer. + // in, dry left, count without A_AUX flag. + // dry right, wet left, wet right with A_AUX flag. + + if (note->usesHeadsetPanEffects) { + aClearBuffer(cmd++, DMEM_ADDR_NOTE_PAN_TEMP, DEFAULT_LEN_1CH); + + switch (headsetPanSettings) { + case 1: + aSetBuffer(cmd++, 0, inBuf, DMEM_ADDR_NOTE_PAN_TEMP, nSamples * 2); + aSetBuffer(cmd++, A_AUX, DMEM_ADDR_RIGHT_CH, DMEM_ADDR_WET_LEFT_CH, + DMEM_ADDR_WET_RIGHT_CH); + break; + case 2: + aSetBuffer(cmd++, 0, inBuf, DMEM_ADDR_LEFT_CH, nSamples * 2); + aSetBuffer(cmd++, A_AUX, DMEM_ADDR_NOTE_PAN_TEMP, DMEM_ADDR_WET_LEFT_CH, + DMEM_ADDR_WET_RIGHT_CH); + break; + default: + aSetBuffer(cmd++, 0, inBuf, DMEM_ADDR_LEFT_CH, nSamples * 2); + aSetBuffer(cmd++, A_AUX, DMEM_ADDR_RIGHT_CH, DMEM_ADDR_WET_LEFT_CH, + DMEM_ADDR_WET_RIGHT_CH); + break; + } + } else { + // It's a bit unclear what the "stereo strong" concept does. + // Instead of mixing the opposite channel to the normal buffers, the sound is first + // mixed into a temporary buffer and then subtracted from the normal buffer. + if (note->stereoStrongRight) { + aClearBuffer(cmd++, DMEM_ADDR_STEREO_STRONG_TEMP_DRY, DEFAULT_LEN_2CH); + aSetBuffer(cmd++, 0, inBuf, DMEM_ADDR_STEREO_STRONG_TEMP_DRY, nSamples * 2); + aSetBuffer(cmd++, A_AUX, DMEM_ADDR_RIGHT_CH, DMEM_ADDR_STEREO_STRONG_TEMP_WET, + DMEM_ADDR_WET_RIGHT_CH); + } else if (note->stereoStrongLeft) { + aClearBuffer(cmd++, DMEM_ADDR_STEREO_STRONG_TEMP_DRY, DEFAULT_LEN_2CH); + aSetBuffer(cmd++, 0, inBuf, DMEM_ADDR_LEFT_CH, nSamples * 2); + aSetBuffer(cmd++, A_AUX, DMEM_ADDR_STEREO_STRONG_TEMP_DRY, DMEM_ADDR_WET_LEFT_CH, + DMEM_ADDR_STEREO_STRONG_TEMP_WET); + } else { + aSetBuffer(cmd++, 0, inBuf, DMEM_ADDR_LEFT_CH, nSamples * 2); + aSetBuffer(cmd++, A_AUX, DMEM_ADDR_RIGHT_CH, DMEM_ADDR_WET_LEFT_CH, DMEM_ADDR_WET_RIGHT_CH); + } + } + +#ifdef VERSION_EU + if (targetLeft == sourceLeft && targetRight == sourceRight && !note->envMixerNeedsInit) { +#else + if (vol->targetLeft == vol->sourceLeft && vol->targetRight == vol->sourceRight + && !note->envMixerNeedsInit) { +#endif + mixerFlags = A_CONTINUE; + } else { + mixerFlags = A_INIT; + +#ifdef VERSION_EU + rampLeft = gCurrentLeftVolRamping[targetLeft >> 5] * gCurrentRightVolRamping[sourceLeft >> 5]; + rampRight = gCurrentLeftVolRamping[targetRight >> 5] * gCurrentRightVolRamping[sourceRight >> 5]; +#else + rampLeft = get_volume_ramping(vol->sourceLeft, vol->targetLeft, nSamples); + rampRight = get_volume_ramping(vol->sourceRight, vol->targetRight, nSamples); +#endif + + // The operation's parameters change meanings depending on flags +#ifdef VERSION_EU + aSetVolume(cmd++, A_VOL | A_LEFT, sourceLeft, 0, 0); + aSetVolume(cmd++, A_VOL | A_RIGHT, sourceRight, 0, 0); + aSetVolume32(cmd++, A_RATE | A_LEFT, targetLeft, rampLeft); + aSetVolume32(cmd++, A_RATE | A_RIGHT, targetRight, rampRight); + aSetVolume(cmd++, A_AUX, gVolume, 0, note->reverbVol << 8); +#else + aSetVolume(cmd++, A_VOL | A_LEFT, vol->sourceLeft, 0, 0); + aSetVolume(cmd++, A_VOL | A_RIGHT, vol->sourceRight, 0, 0); + aSetVolume32(cmd++, A_RATE | A_LEFT, vol->targetLeft, rampLeft); + aSetVolume32(cmd++, A_RATE | A_RIGHT, vol->targetRight, rampRight); + aSetVolume(cmd++, A_AUX, gVolume, 0, note->reverbVolShifted); +#endif + } + +#ifdef VERSION_EU + if (gUseReverb && note->reverbVol != 0) { + aEnvMixer(cmd++, mixerFlags | A_AUX, + VIRTUAL_TO_PHYSICAL2(synthesisState->synthesisBuffers->mixEnvelopeState)); +#else + if (gSynthesisReverb.useReverb && note->reverbVol != 0) { + aEnvMixer(cmd++, mixerFlags | A_AUX, + VIRTUAL_TO_PHYSICAL2(note->synthesisBuffers->mixEnvelopeState)); +#endif + if (note->stereoStrongRight) { + aSetBuffer(cmd++, 0, 0, 0, nSamples * 2); + // 0x8000 is -100%, so subtract sound instead of adding... + aMix(cmd++, 0, /*gain*/ 0x8000, /*in*/ DMEM_ADDR_STEREO_STRONG_TEMP_DRY, + /*out*/ DMEM_ADDR_LEFT_CH); + aMix(cmd++, 0, /*gain*/ 0x8000, /*in*/ DMEM_ADDR_STEREO_STRONG_TEMP_WET, + /*out*/ DMEM_ADDR_WET_LEFT_CH); + } else if (note->stereoStrongLeft) { + aSetBuffer(cmd++, 0, 0, 0, nSamples * 2); + aMix(cmd++, 0, /*gain*/ 0x8000, /*in*/ DMEM_ADDR_STEREO_STRONG_TEMP_DRY, + /*out*/ DMEM_ADDR_RIGHT_CH); + aMix(cmd++, 0, /*gain*/ 0x8000, /*in*/ DMEM_ADDR_STEREO_STRONG_TEMP_WET, + /*out*/ DMEM_ADDR_WET_RIGHT_CH); + } + } else { +#ifdef VERSION_EU + aEnvMixer(cmd++, mixerFlags, VIRTUAL_TO_PHYSICAL2(synthesisState->synthesisBuffers->mixEnvelopeState)); +#else + aEnvMixer(cmd++, mixerFlags, VIRTUAL_TO_PHYSICAL2(note->synthesisBuffers->mixEnvelopeState)); +#endif + if (note->stereoStrongRight) { + aSetBuffer(cmd++, 0, 0, 0, nSamples * 2); + aMix(cmd++, 0, /*gain*/ 0x8000, /*in*/ DMEM_ADDR_STEREO_STRONG_TEMP_DRY, + /*out*/ DMEM_ADDR_LEFT_CH); + } else if (note->stereoStrongLeft) { + aSetBuffer(cmd++, 0, 0, 0, nSamples * 2); + aMix(cmd++, 0, /*gain*/ 0x8000, /*in*/ DMEM_ADDR_STEREO_STRONG_TEMP_DRY, + /*out*/ DMEM_ADDR_RIGHT_CH); + } + } + return cmd; +} + +#ifdef VERSION_EU +u64 *note_apply_headset_pan_effects(u64 *cmd, struct NoteSubEu *noteSubEu, struct NoteSynthesisState *note, s32 bufLen, s32 flags, s32 leftRight) { +#else +u64 *note_apply_headset_pan_effects(u64 *cmd, struct Note *note, s32 bufLen, s32 flags, s32 leftRight) { +#endif + u16 dest; + u16 pitch; +#ifdef VERSION_EU + u8 prevPanShift; + u8 panShift; + UNUSED u8 unkDebug; +#else + u16 prevPanShift; + u16 panShift; +#endif + + switch (leftRight) { + case 1: + dest = DMEM_ADDR_LEFT_CH; +#ifdef VERSION_EU + panShift = noteSubEu->headsetPanRight; +#else + panShift = note->headsetPanRight; +#endif + note->prevHeadsetPanLeft = 0; + prevPanShift = note->prevHeadsetPanRight; + note->prevHeadsetPanRight = panShift; + break; + case 2: + dest = DMEM_ADDR_RIGHT_CH; +#ifdef VERSION_EU + panShift = noteSubEu->headsetPanLeft; +#else + panShift = note->headsetPanLeft; +#endif + note->prevHeadsetPanRight = 0; + + prevPanShift = note->prevHeadsetPanLeft; + note->prevHeadsetPanLeft = panShift; + break; + default: + return cmd; + } + + if (flags != 1) { // A_INIT? + // Slightly adjust the sample rate in order to fit a change in pan shift + if (prevPanShift == 0) { + // Kind of a hack that moves the first samples into the resample state + aDMEMMove(cmd++, DMEM_ADDR_NOTE_PAN_TEMP, DMEM_ADDR_TEMP, 8); + aClearBuffer(cmd++, 8, 8); // Set pitch accumulator to 0 in the resample state + aDMEMMove(cmd++, DMEM_ADDR_NOTE_PAN_TEMP, DMEM_ADDR_TEMP + 0x10, + 0x10); // No idea, result seems to be overwritten later + + aSetBuffer(cmd++, 0, 0, DMEM_ADDR_TEMP, 32); + aSaveBuffer(cmd++, VIRTUAL_TO_PHYSICAL2(note->synthesisBuffers->panResampleState)); + +#ifdef VERSION_EU + pitch = (bufLen << 0xf) / (bufLen + panShift - prevPanShift + 8); + if (pitch) { + } +#else + pitch = (bufLen << 0xf) / (panShift + bufLen - prevPanShift + 8); +#endif + aSetBuffer(cmd++, 0, DMEM_ADDR_NOTE_PAN_TEMP + 8, DMEM_ADDR_TEMP, panShift + bufLen - prevPanShift); + aResample(cmd++, 0, pitch, VIRTUAL_TO_PHYSICAL2(note->synthesisBuffers->panResampleState)); + } else { + if (panShift == 0) { + pitch = (bufLen << 0xf) / (bufLen - prevPanShift - 4); + } else { + pitch = (bufLen << 0xf) / (bufLen + panShift - prevPanShift); + } + +#if defined(VERSION_EU) && !defined(AVOID_UB) + if (unkDebug) { // UB + } +#endif + aSetBuffer(cmd++, 0, DMEM_ADDR_NOTE_PAN_TEMP, DMEM_ADDR_TEMP, panShift + bufLen - prevPanShift); + aResample(cmd++, 0, pitch, VIRTUAL_TO_PHYSICAL2(note->synthesisBuffers->panResampleState)); + } + + if (prevPanShift != 0) { + aSetBuffer(cmd++, 0, DMEM_ADDR_NOTE_PAN_TEMP, 0, prevPanShift); + aLoadBuffer(cmd++, VIRTUAL_TO_PHYSICAL2(note->synthesisBuffers->panSamplesBuffer)); + aDMEMMove(cmd++, DMEM_ADDR_TEMP, DMEM_ADDR_NOTE_PAN_TEMP + prevPanShift, panShift + bufLen - prevPanShift); + } else { + aDMEMMove(cmd++, DMEM_ADDR_TEMP, DMEM_ADDR_NOTE_PAN_TEMP, panShift + bufLen - prevPanShift); + } + } else { + // Just shift right + aDMEMMove(cmd++, DMEM_ADDR_NOTE_PAN_TEMP, DMEM_ADDR_TEMP, bufLen); + aDMEMMove(cmd++, DMEM_ADDR_TEMP, DMEM_ADDR_NOTE_PAN_TEMP + panShift, bufLen); + aClearBuffer(cmd++, DMEM_ADDR_NOTE_PAN_TEMP, panShift); + } + + if (panShift) { + // Save excessive samples for next iteration + aSetBuffer(cmd++, 0, 0, DMEM_ADDR_NOTE_PAN_TEMP + bufLen, panShift); + aSaveBuffer(cmd++, VIRTUAL_TO_PHYSICAL2(note->synthesisBuffers->panSamplesBuffer)); + } + + aSetBuffer(cmd++, 0, 0, 0, bufLen); + aMix(cmd++, 0, /*gain*/ 0x7fff, /*in*/ DMEM_ADDR_NOTE_PAN_TEMP, /*out*/ dest); + + return cmd; +} + +#ifndef VERSION_EU +// Moved to playback.c in EU + +void note_init_volume(struct Note *note) { + note->targetVolLeft = 0; + note->targetVolRight = 0; + note->reverbVol = 0; + note->reverbVolShifted = 0; + note->unused2 = 0; + note->curVolLeft = 1; + note->curVolRight = 1; + note->frequency = 0.0f; +} + +void note_set_vel_pan_reverb(struct Note *note, f32 velocity, f32 pan, u8 reverbVol) { + s32 panIndex; + f32 volLeft; + f32 volRight; + // Anding with 127 avoids out-of-bounds reads when pan is outside of [0, 1]. + // This can occur during PU movement -- see the bug comment in get_sound_pan + // in external.c. An out-of-bounds read by itself doesn't crash, but if the + // resulting value is a nan or denormal, performing arithmetic on it crashes + // on console. +#ifdef VERSION_JP + panIndex = MIN((s32)(pan * 127.5), 127); +#else + panIndex = (s32)(pan * 127.5f) & 127; +#endif + if (note->stereoHeadsetEffects && gSoundMode == SOUND_MODE_HEADSET) { + s8 smallPanIndex; + s8 temp = (s8)(pan * 10.0f); + if (temp < 9) { + smallPanIndex = temp; + } else { + smallPanIndex = 9; + } + note->headsetPanLeft = gHeadsetPanQuantization[smallPanIndex]; + note->headsetPanRight = gHeadsetPanQuantization[9 - smallPanIndex]; + note->stereoStrongRight = FALSE; + note->stereoStrongLeft = FALSE; + note->usesHeadsetPanEffects = TRUE; + volLeft = gHeadsetPanVolume[panIndex]; + volRight = gHeadsetPanVolume[127 - panIndex]; + } else if (note->stereoHeadsetEffects && gSoundMode == SOUND_MODE_STEREO) { + u8 strongLeft; + u8 strongRight; + strongLeft = FALSE; + strongRight = FALSE; + note->headsetPanLeft = 0; + note->headsetPanRight = 0; + note->usesHeadsetPanEffects = FALSE; + volLeft = gStereoPanVolume[panIndex]; + volRight = gStereoPanVolume[127 - panIndex]; + if (panIndex < 0x20) { + strongLeft = TRUE; + } else if (panIndex > 0x60) { + strongRight = TRUE; + } + note->stereoStrongRight = strongRight; + note->stereoStrongLeft = strongLeft; + } else if (gSoundMode == SOUND_MODE_MONO) { + volLeft = .707f; + volRight = .707f; + } else { + volLeft = gDefaultPanVolume[panIndex]; + volRight = gDefaultPanVolume[127 - panIndex]; + } + + if (velocity < 0) { + velocity = 0; + } +#ifdef VERSION_JP + note->targetVolLeft = (u16)(velocity * volLeft) & ~0x80FF; // 0x7F00, but that doesn't match + note->targetVolRight = (u16)(velocity * volRight) & ~0x80FF; +#else + note->targetVolLeft = (u16)(s32)(velocity * volLeft) & ~0x80FF; + note->targetVolRight = (u16)(s32)(velocity * volRight) & ~0x80FF; +#endif + if (note->targetVolLeft == 0) { + note->targetVolLeft++; + } + if (note->targetVolRight == 0) { + note->targetVolRight++; + } + if (note->reverbVol != reverbVol) { + note->reverbVol = reverbVol; + note->reverbVolShifted = reverbVol << 8; + note->envMixerNeedsInit = TRUE; + return; + } + + if (note->needsInit) { + note->envMixerNeedsInit = TRUE; + } else { + note->envMixerNeedsInit = FALSE; + } +} + +void note_set_frequency(struct Note *note, f32 frequency) { + note->frequency = frequency; +} + +void note_enable(struct Note *note) { + note->enabled = TRUE; + note->needsInit = TRUE; + note->restart = FALSE; + note->finished = FALSE; + note->stereoStrongRight = FALSE; + note->stereoStrongLeft = FALSE; + note->usesHeadsetPanEffects = FALSE; + note->headsetPanLeft = 0; + note->headsetPanRight = 0; + note->prevHeadsetPanRight = 0; + note->prevHeadsetPanLeft = 0; +} + +void note_disable(struct Note *note) { + if (note->needsInit == TRUE) { + note->needsInit = FALSE; + } else { + note_set_vel_pan_reverb(note, 0, .5, 0); + } + note->priority = NOTE_PRIORITY_DISABLED; + note->enabled = FALSE; + note->finished = FALSE; + note->parentLayer = NO_LAYER; + note->prevParentLayer = NO_LAYER; +} +#endif +#endif diff --git a/src/decomp/audio/synthesis.h b/src/decomp/audio/synthesis.h new file mode 100644 index 0000000..9ca8643 --- /dev/null +++ b/src/decomp/audio/synthesis.h @@ -0,0 +1,99 @@ +#ifndef AUDIO_SYNTHESIS_H +#define AUDIO_SYNTHESIS_H + +#include "internal.h" + +#ifdef VERSION_SH +#define DEFAULT_LEN_1CH 0x180 +#define DEFAULT_LEN_2CH 0x300 +#else +#define DEFAULT_LEN_1CH 0x140 +#define DEFAULT_LEN_2CH 0x280 +#endif + +#if defined(VERSION_EU) || defined(VERSION_SH) +#define MAX_UPDATES_PER_FRAME 5 +#else +#define MAX_UPDATES_PER_FRAME 4 +#endif + +struct ReverbRingBufferItem +{ + s16 numSamplesAfterDownsampling; + s16 chunkLen; // never read + s16 *toDownsampleLeft; + s16 *toDownsampleRight; // data pointed to by left and right are adjacent in memory + s32 startPos; // start pos in ring buffer + s16 lengthA; // first length in ring buffer (from startPos, at most until end) + s16 lengthB; // second length in ring buffer (from pos 0) +}; // size = 0x14 + +struct SynthesisReverb +{ + /*0x00, 0x00, 0x00*/ u8 resampleFlags; + /*0x01, 0x01, 0x01*/ u8 useReverb; + /*0x02, 0x02, 0x02*/ u8 framesLeftToIgnore; + /*0x03, 0x03, 0x03*/ u8 curFrame; +#if defined(VERSION_EU) || defined(VERSION_SH) + /* 0x04, 0x04*/ u8 downsampleRate; +#ifdef VERSION_SH + /* 0x05*/ s8 unk5; +#endif + /* 0x06, 0x06*/ u16 windowSize; // same as bufSizePerChannel +#endif +#ifdef VERSION_SH + /* 0x08*/ u16 unk08; +#endif + /*0x04, 0x08, 0x0A*/ u16 reverbGain; + /*0x06, 0x0A, 0x0C*/ u16 resampleRate; +#ifdef VERSION_SH + /* 0x0E*/ u16 panRight; + /* 0x10*/ u16 panLeft; +#endif + /*0x08, 0x0C, 0x14*/ s32 nextRingBufferPos; + /*0x0C, 0x10, 0x18*/ s32 unkC; // never read + /*0x10, 0x14, 0x1C*/ s32 bufSizePerChannel; + struct + { + s16 *left; + s16 *right; + } ringBuffer; + /*0x1C, 0x20, 0x28*/ s16 *resampleStateLeft; + /*0x20, 0x24, 0x2C*/ s16 *resampleStateRight; + /*0x24, 0x28, 0x30*/ s16 *unk24; // never read + /*0x28, 0x2C, 0x34*/ s16 *unk28; // never read + /*0x2C, 0x30, 0x38*/ struct ReverbRingBufferItem items[2][MAX_UPDATES_PER_FRAME]; +#if defined(VERSION_EU) || defined(VERSION_SH) + // Only used in sh: + /* 0x100*/ s16 *unk100; + /* 0x104*/ s16 *unk104; + /* 0x108*/ s16 *unk108; + /* 0x10C*/ s16 *unk10C; +#endif +}; // 0xCC <= size <= 0x100 +#if defined(VERSION_EU) || defined(VERSION_SH) +extern struct SynthesisReverb gSynthesisReverbs[4]; +extern s8 gNumSynthesisReverbs; +extern struct NoteSubEu *gNoteSubsEu; +extern f32 gLeftVolRampings[3][1024]; +extern f32 gRightVolRampings[3][1024]; +extern f32 *gCurrentLeftVolRamping; // Points to any of the three left buffers above +extern f32 *gCurrentRightVolRamping; // Points to any of the three right buffers above +#else +extern struct SynthesisReverb gSynthesisReverb; +#endif + +#ifdef VERSION_SH +extern s16 D_SH_803479B4; +#endif + +u64 *synthesis_execute(u64 *cmdBuf, s32 *writtenCmds, s16 *aiBuf, s32 bufLen); +#if defined(VERSION_JP) || defined(VERSION_US) +void note_init_volume(struct Note *note); +void note_set_vel_pan_reverb(struct Note *note, f32 velocity, f32 pan, u8 reverbVol); +void note_set_frequency(struct Note *note, f32 frequency); +void note_enable(struct Note *note); +void note_disable(struct Note *note); +#endif + +#endif // AUDIO_SYNTHESIS_H diff --git a/src/decomp/audio/synthesis_sh.c b/src/decomp/audio/synthesis_sh.c new file mode 100644 index 0000000..706d5d8 --- /dev/null +++ b/src/decomp/audio/synthesis_sh.c @@ -0,0 +1,914 @@ +#ifdef VERSION_SH +#include + +#include "synthesis.h" +#include "heap.h" +#include "data.h" +#include "load.h" +#include "seqplayer.h" +#include "internal.h" +#include "external.h" + +#ifndef TARGET_N64 +#include "../pc/mixer.h" +#endif + + +#define DMEM_ADDR_TEMP 0x450 +#define DMEM_ADDR_RESAMPLED 0x470 +#define DMEM_ADDR_RESAMPLED2 0x5f0 +#define DMEM_ADDR_UNCOMPRESSED_NOTE 0x5f0 +#define DMEM_ADDR_NOTE_PAN_TEMP 0x650 +#define DMEM_ADDR_COMPRESSED_ADPCM_DATA 0x990 +#define DMEM_ADDR_LEFT_CH 0x990 +#define DMEM_ADDR_RIGHT_CH 0xb10 +#define DMEM_ADDR_WET_LEFT_CH 0xc90 +#define DMEM_ADDR_WET_RIGHT_CH 0xe10 + +#define aSetLoadBufferPair(pkt, c, off) \ + aSetBuffer(pkt, 0, c + DMEM_ADDR_WET_LEFT_CH, 0, DEFAULT_LEN_1CH - c); \ + aLoadBuffer(pkt, VIRTUAL_TO_PHYSICAL2(gSynthesisReverb.ringBuffer.left + (off))); \ + aSetBuffer(pkt, 0, c + DMEM_ADDR_WET_RIGHT_CH, 0, DEFAULT_LEN_1CH - c); \ + aLoadBuffer(pkt, VIRTUAL_TO_PHYSICAL2(gSynthesisReverb.ringBuffer.right + (off))) + +#define aSetSaveBufferPair(pkt, c, d, off) \ + aSetBuffer(pkt, 0, 0, c + DMEM_ADDR_WET_LEFT_CH, d); \ + aSaveBuffer(pkt, VIRTUAL_TO_PHYSICAL2(gSynthesisReverb.ringBuffer.left + (off))); \ + aSetBuffer(pkt, 0, 0, c + DMEM_ADDR_WET_RIGHT_CH, d); \ + aSaveBuffer(pkt, VIRTUAL_TO_PHYSICAL2(gSynthesisReverb.ringBuffer.right + (off))); + +#define ALIGN(val, amnt) (((val) + (1 << amnt) - 1) & ~((1 << amnt) - 1)) + +struct VolumeChange { + u16 sourceLeft; + u16 sourceRight; + u16 targetLeft; + u16 targetRight; +}; + +u64 *synthesis_do_one_audio_update(s16 *aiBuf, s32 bufLen, u64 *cmd, s32 updateIndex); +u64 *synthesis_process_note(s32 noteIndex, struct NoteSubEu *noteSubEu, struct NoteSynthesisState *synthesisState, s16 *aiBuf, s32 bufLen, u64 *cmd, s32 updateIndex); +u64 *load_wave_samples(u64 *cmd, struct NoteSubEu *noteSubEu, struct NoteSynthesisState *synthesisState, s32 nSamplesToLoad); +u64 *final_resample(u64 *cmd, struct NoteSynthesisState *synthesisState, s32 count, u16 pitch, u16 dmemIn, u32 flags); +u64 *process_envelope(u64 *cmd, struct NoteSubEu *noteSubEu, struct NoteSynthesisState *synthesisState, s32 nSamples, u16 inBuf, s32 headsetPanSettings, u32 flags); +u64 *note_apply_headset_pan_effects(u64 *cmd, struct NoteSubEu *noteSubEu, struct NoteSynthesisState *note, s32 bufLen, s32 flags, s32 leftRight); + +struct SynthesisReverb gSynthesisReverbs[4]; +u8 sAudioSynthesisPad[0x10]; + +s16 gVolume; +s8 gUseReverb; +s8 gNumSynthesisReverbs; +s16 D_SH_803479B4; // contains 4096 +struct NoteSubEu *gNoteSubsEu; + +// Equivalent functionality as the US/JP version, +// just that the reverb structure is chosen from an array with index +// Identical in EU. +void prepare_reverb_ring_buffer(s32 chunkLen, u32 updateIndex, s32 reverbIndex) { + struct ReverbRingBufferItem *item; + struct SynthesisReverb *reverb = &gSynthesisReverbs[reverbIndex]; + s32 srcPos; + s32 dstPos; + s32 nSamples; + s32 excessiveSamples; + s32 UNUSED pad[3]; + if (reverb->downsampleRate != 1) { + if (reverb->framesLeftToIgnore == 0) { + // Now that the RSP has finished, downsample the samples produced two frames ago by skipping + // samples. + item = &reverb->items[reverb->curFrame][updateIndex]; + + // Touches both left and right since they are adjacent in memory + osInvalDCache(item->toDownsampleLeft, DEFAULT_LEN_2CH); + + for (srcPos = 0, dstPos = 0; dstPos < item->lengthA / 2; + srcPos += reverb->downsampleRate, dstPos++) { + reverb->ringBuffer.left[item->startPos + dstPos] = + item->toDownsampleLeft[srcPos]; + reverb->ringBuffer.right[item->startPos + dstPos] = + item->toDownsampleRight[srcPos]; + } + for (dstPos = 0; dstPos < item->lengthB / 2; srcPos += reverb->downsampleRate, dstPos++) { + reverb->ringBuffer.left[dstPos] = item->toDownsampleLeft[srcPos]; + reverb->ringBuffer.right[dstPos] = item->toDownsampleRight[srcPos]; + } + } + } + + item = &reverb->items[reverb->curFrame][updateIndex]; + nSamples = chunkLen / reverb->downsampleRate; + excessiveSamples = (nSamples + reverb->nextRingBufferPos) - reverb->bufSizePerChannel; + if (excessiveSamples < 0) { + // There is space in the ring buffer before it wraps around + item->lengthA = nSamples * 2; + item->lengthB = 0; + item->startPos = (s32) reverb->nextRingBufferPos; + reverb->nextRingBufferPos += nSamples; + } else { + // Ring buffer wrapped around + item->lengthA = (nSamples - excessiveSamples) * 2; + item->lengthB = excessiveSamples * 2; + item->startPos = reverb->nextRingBufferPos; + reverb->nextRingBufferPos = excessiveSamples; + } + // These fields are never read later + item->numSamplesAfterDownsampling = nSamples; + item->chunkLen = chunkLen; +} + +u64 *synthesis_load_reverb_ring_buffer(u64 *cmd, u16 addr, u16 srcOffset, s32 len, s32 reverbIndex) { + aLoadBuffer(cmd++, VIRTUAL_TO_PHYSICAL2(&gSynthesisReverbs[reverbIndex].ringBuffer.left[srcOffset]), + addr, len); + aLoadBuffer(cmd++, VIRTUAL_TO_PHYSICAL2(&gSynthesisReverbs[reverbIndex].ringBuffer.right[srcOffset]), + addr + DEFAULT_LEN_1CH, len); + return cmd; +} + +u64 *synthesis_save_reverb_ring_buffer(u64 *cmd, u16 addr, u16 destOffset, s32 len, s32 reverbIndex) { + aSaveBuffer(cmd++, addr, + VIRTUAL_TO_PHYSICAL2(&gSynthesisReverbs[reverbIndex].ringBuffer.left[destOffset]), len); + aSaveBuffer(cmd++, addr + DEFAULT_LEN_1CH, + VIRTUAL_TO_PHYSICAL2(&gSynthesisReverbs[reverbIndex].ringBuffer.right[destOffset]), len); + return cmd; +} + +void func_sh_802ed644(s32 updateIndexStart, s32 noteIndex) { + s32 i; + + for (i = updateIndexStart + 1; i < gAudioBufferParameters.updatesPerFrame; i++) { + if (!gNoteSubsEu[gMaxSimultaneousNotes * i + noteIndex].needsInit) { + gNoteSubsEu[gMaxSimultaneousNotes * i + noteIndex].enabled = FALSE; + } else { + break; + } + } +} + +void synthesis_load_note_subs_eu(s32 updateIndex) { + struct NoteSubEu *src; + struct NoteSubEu *dest; + s32 i; + + for (i = 0; i < gMaxSimultaneousNotes; i++) { + src = &gNotes[i].noteSubEu; + dest = &gNoteSubsEu[gMaxSimultaneousNotes * updateIndex + i]; + if (src->enabled) { + *dest = *src; + src->needsInit = FALSE; + } else { + dest->enabled = FALSE; + } + } +} + +// TODO: (Scrub C) pointless mask and whitespace +u64 *synthesis_execute(u64 *cmdBuf, s32 *writtenCmds, s16 *aiBuf, s32 bufLen) { + s32 i, j; + u32 *aiBufPtr; + u64 *cmd = cmdBuf; + s32 chunkLen; + + for (i = gAudioBufferParameters.updatesPerFrame; i > 0; i--) { + process_sequences(i - 1); + synthesis_load_note_subs_eu(gAudioBufferParameters.updatesPerFrame - i); + } + aiBufPtr = (u32 *) aiBuf; + for (i = gAudioBufferParameters.updatesPerFrame; i > 0; i--) { + if (i == 1) { + chunkLen = bufLen; + } else { + if (bufLen / i >= gAudioBufferParameters.samplesPerUpdateMax) { + chunkLen = gAudioBufferParameters.samplesPerUpdateMax; + } else if (bufLen / i <= gAudioBufferParameters.samplesPerUpdateMin) { + chunkLen = gAudioBufferParameters.samplesPerUpdateMin; + } else { + chunkLen = gAudioBufferParameters.samplesPerUpdate; + } + } + for (j = 0; j < gNumSynthesisReverbs; j++) { + if (gSynthesisReverbs[j].useReverb != 0) { + prepare_reverb_ring_buffer(chunkLen, gAudioBufferParameters.updatesPerFrame - i, j); + } + } + cmd = synthesis_do_one_audio_update((s16 *) aiBufPtr, chunkLen, cmd, gAudioBufferParameters.updatesPerFrame - i); + bufLen -= chunkLen; + aiBufPtr += chunkLen; + } + + for (j = 0; j < gNumSynthesisReverbs; j++) { + if (gSynthesisReverbs[j].framesLeftToIgnore != 0) { + gSynthesisReverbs[j].framesLeftToIgnore--; + } + gSynthesisReverbs[j].curFrame ^= 1; + } + *writtenCmds = cmd - cmdBuf; + return cmd; +} + +u64 *synthesis_resample_and_mix_reverb(u64 *cmd, s32 bufLen, s16 reverbIndex, s16 updateIndex) { + struct ReverbRingBufferItem *item; + s16 startPad; + s16 paddedLengthA; + + item = &gSynthesisReverbs[reverbIndex].items[gSynthesisReverbs[reverbIndex].curFrame][updateIndex]; + + if (gSynthesisReverbs[reverbIndex].downsampleRate == 1) { + cmd = synthesis_load_reverb_ring_buffer(cmd, DMEM_ADDR_WET_LEFT_CH, item->startPos, item->lengthA, reverbIndex); + if (item->lengthB != 0) { + cmd = synthesis_load_reverb_ring_buffer(cmd, DMEM_ADDR_WET_LEFT_CH + item->lengthA, 0, item->lengthB, reverbIndex); + } + aAddMixer(cmd++, DMEM_ADDR_WET_LEFT_CH, DMEM_ADDR_LEFT_CH, DEFAULT_LEN_2CH); + aMix(cmd++, 0x8000 + gSynthesisReverbs[reverbIndex].reverbGain, DMEM_ADDR_WET_LEFT_CH, DMEM_ADDR_WET_LEFT_CH, DEFAULT_LEN_2CH); + } else { + startPad = (item->startPos % 8u) * 2; + paddedLengthA = ALIGN(startPad + item->lengthA, 4); + + cmd = synthesis_load_reverb_ring_buffer(cmd, DMEM_ADDR_RESAMPLED, (item->startPos - startPad / 2), DEFAULT_LEN_1CH, reverbIndex); + if (item->lengthB != 0) { + cmd = synthesis_load_reverb_ring_buffer(cmd, DMEM_ADDR_RESAMPLED + paddedLengthA, 0, DEFAULT_LEN_1CH - paddedLengthA, reverbIndex); + } + + aSetBuffer(cmd++, 0, DMEM_ADDR_RESAMPLED + startPad, DMEM_ADDR_WET_LEFT_CH, bufLen * 2); + aResample(cmd++, gSynthesisReverbs[reverbIndex].resampleFlags, gSynthesisReverbs[reverbIndex].resampleRate, VIRTUAL_TO_PHYSICAL2(gSynthesisReverbs[reverbIndex].resampleStateLeft)); + + aSetBuffer(cmd++, 0, DMEM_ADDR_RESAMPLED2 + startPad, DMEM_ADDR_WET_RIGHT_CH, bufLen * 2); + aResample(cmd++, gSynthesisReverbs[reverbIndex].resampleFlags, gSynthesisReverbs[reverbIndex].resampleRate, VIRTUAL_TO_PHYSICAL2(gSynthesisReverbs[reverbIndex].resampleStateRight)); + + aAddMixer(cmd++, DMEM_ADDR_WET_LEFT_CH, DMEM_ADDR_LEFT_CH, DEFAULT_LEN_2CH); + aMix(cmd++, 0x8000 + gSynthesisReverbs[reverbIndex].reverbGain, DMEM_ADDR_WET_LEFT_CH, DMEM_ADDR_WET_LEFT_CH, DEFAULT_LEN_2CH); + } + if (gSynthesisReverbs[reverbIndex].panRight != 0 || gSynthesisReverbs[reverbIndex].panLeft != 0) { + // Leak some audio from the left reverb channel into the right reverb channel and vice versa (pan) + aDMEMMove(cmd++, DMEM_ADDR_WET_LEFT_CH, DMEM_ADDR_RESAMPLED, DEFAULT_LEN_1CH); + aMix(cmd++, gSynthesisReverbs[reverbIndex].panRight, DMEM_ADDR_WET_RIGHT_CH, DMEM_ADDR_WET_LEFT_CH, DEFAULT_LEN_1CH); + aMix(cmd++, gSynthesisReverbs[reverbIndex].panLeft, DMEM_ADDR_RESAMPLED, DMEM_ADDR_WET_RIGHT_CH, DEFAULT_LEN_1CH); + } + return cmd; +} + +u64 *synthesis_load_reverb_samples(u64 *cmd, s16 reverbIndex, s16 updateIndex) { + struct ReverbRingBufferItem *item; + struct SynthesisReverb *reverb; + + reverb = &gSynthesisReverbs[reverbIndex]; + item = &reverb->items[reverb->curFrame][updateIndex]; + // Get the oldest samples in the ring buffer into the wet channels + cmd = synthesis_load_reverb_ring_buffer(cmd, DMEM_ADDR_RESAMPLED, item->startPos, item->lengthA, reverbIndex); + if (item->lengthB != 0) { + // Ring buffer wrapped + cmd = synthesis_load_reverb_ring_buffer(cmd, DMEM_ADDR_RESAMPLED + item->lengthA, 0, item->lengthB, reverbIndex); + } + return cmd; +} + +u64 *synthesis_save_reverb_samples(u64 *cmd, s16 reverbIndex, s16 updateIndex) { + struct ReverbRingBufferItem *item; + + item = &gSynthesisReverbs[reverbIndex].items[gSynthesisReverbs[reverbIndex].curFrame][updateIndex]; + switch (gSynthesisReverbs[reverbIndex].downsampleRate) { + case 1: + // Put the oldest samples in the ring buffer into the wet channels + cmd = synthesis_save_reverb_ring_buffer(cmd, DMEM_ADDR_WET_LEFT_CH, item->startPos, item->lengthA, reverbIndex); + if (item->lengthB != 0) { + // Ring buffer wrapped + cmd = synthesis_save_reverb_ring_buffer(cmd, DMEM_ADDR_WET_LEFT_CH + item->lengthA, 0, item->lengthB, reverbIndex); + } + break; + + default: + // Downsampling is done later by CPU when RSP is done, therefore we need to have double + // buffering. Left and right buffers are adjacent in memory. + aSaveBuffer(cmd++, DMEM_ADDR_WET_LEFT_CH, + VIRTUAL_TO_PHYSICAL2(gSynthesisReverbs[reverbIndex].items[gSynthesisReverbs[reverbIndex].curFrame][updateIndex].toDownsampleLeft), DEFAULT_LEN_2CH); + break; + } + gSynthesisReverbs[reverbIndex].resampleFlags = 0; + return cmd; +} + +u64 *func_sh_802EDF24(u64 *cmd, s16 reverbIndex, s16 updateIndex) { + struct ReverbRingBufferItem *item; + struct SynthesisReverb *reverb; + + reverb = &gSynthesisReverbs[reverbIndex]; + item = &reverb->items[reverb->curFrame][updateIndex]; + // Put the oldest samples in the ring buffer into the wet channels + cmd = synthesis_save_reverb_ring_buffer(cmd, DMEM_ADDR_RESAMPLED, item->startPos, item->lengthA, reverbIndex); + if (item->lengthB != 0) { + // Ring buffer wrapped + cmd = synthesis_save_reverb_ring_buffer(cmd, DMEM_ADDR_RESAMPLED + item->lengthA, 0, item->lengthB, reverbIndex); + } + return cmd; +} + +u64 *synthesis_do_one_audio_update(s16 *aiBuf, s32 bufLen, u64 *cmd, s32 updateIndex) { + struct NoteSubEu *noteSubEu; + u8 noteIndices[56]; + s32 temp; + s32 i; + s16 j; + s16 notePos = 0; + + if (gNumSynthesisReverbs == 0) { + for (i = 0; i < gMaxSimultaneousNotes; i++) { + if (gNoteSubsEu[gMaxSimultaneousNotes * updateIndex + i].enabled) { + noteIndices[notePos++] = i; + } + } + } else { + for (j = 0; j < gNumSynthesisReverbs; j++) { + for (i = 0; i < gMaxSimultaneousNotes; i++) { + noteSubEu = &gNoteSubsEu[gMaxSimultaneousNotes * updateIndex + i]; + if (noteSubEu->enabled && j == noteSubEu->reverbIndex) { + noteIndices[notePos++] = i; + } + } + } + + for (i = 0; i < gMaxSimultaneousNotes; i++) { + noteSubEu = &gNoteSubsEu[gMaxSimultaneousNotes * updateIndex + i]; + if (noteSubEu->enabled && noteSubEu->reverbIndex >= gNumSynthesisReverbs) { + noteIndices[notePos++] = i; + } + } + } + aClearBuffer(cmd++, DMEM_ADDR_LEFT_CH, DEFAULT_LEN_2CH); + i = 0; + for (j = 0; j < gNumSynthesisReverbs; j++) { + gUseReverb = gSynthesisReverbs[j].useReverb; + if (gUseReverb != 0) { + cmd = synthesis_resample_and_mix_reverb(cmd, bufLen, j, updateIndex); + } + for (; i < notePos; i++) { + temp = updateIndex * gMaxSimultaneousNotes; + if (j == gNoteSubsEu[temp + noteIndices[i]].reverbIndex) { + cmd = synthesis_process_note(noteIndices[i], + &gNoteSubsEu[temp + noteIndices[i]], + &gNotes[noteIndices[i]].synthesisState, + aiBuf, bufLen, cmd, updateIndex); + continue; + } else { + break; + } + } + if (gSynthesisReverbs[j].useReverb != 0) { + if (gSynthesisReverbs[j].unk100 != NULL) { + aFilter(cmd++, 0x02, bufLen * 2, gSynthesisReverbs[j].unk100); + aFilter(cmd++, gSynthesisReverbs[j].resampleFlags, DMEM_ADDR_WET_LEFT_CH, gSynthesisReverbs[j].unk108); + } + if (gSynthesisReverbs[j].unk104 != NULL) { + aFilter(cmd++, 0x02, bufLen * 2, gSynthesisReverbs[j].unk104); + aFilter(cmd++, gSynthesisReverbs[j].resampleFlags, DMEM_ADDR_WET_RIGHT_CH, gSynthesisReverbs[j].unk10C); + } + cmd = synthesis_save_reverb_samples(cmd, j, updateIndex); + if (gSynthesisReverbs[j].unk5 != -1) { + if (gSynthesisReverbs[gSynthesisReverbs[j].unk5].downsampleRate == 1) { + cmd = synthesis_load_reverb_samples(cmd, gSynthesisReverbs[j].unk5, updateIndex); + aMix(cmd++, gSynthesisReverbs[j].unk08, DMEM_ADDR_WET_LEFT_CH, DMEM_ADDR_RESAMPLED, DEFAULT_LEN_2CH); + cmd = func_sh_802EDF24(cmd++, gSynthesisReverbs[j].unk5, updateIndex); + } + } + } + } + for (; i < notePos; i++) { + struct NoteSubEu *noteSubEu2 = &gNoteSubsEu[updateIndex * gMaxSimultaneousNotes + noteIndices[i]]; + cmd = synthesis_process_note(noteIndices[i], + noteSubEu2, + &gNotes[noteIndices[i]].synthesisState, + aiBuf, bufLen, cmd, updateIndex); + } + + temp = bufLen * 2; + aInterleave(cmd++, DMEM_ADDR_TEMP, DMEM_ADDR_LEFT_CH, DMEM_ADDR_RIGHT_CH, temp); + aSaveBuffer(cmd++, DMEM_ADDR_TEMP, VIRTUAL_TO_PHYSICAL2(aiBuf), temp * 2); + return cmd; +} + +u64 *synthesis_process_note(s32 noteIndex, struct NoteSubEu *noteSubEu, struct NoteSynthesisState *synthesisState, UNUSED s16 *aiBuf, s32 bufLen, u64 *cmd, s32 updateIndex) { + UNUSED s32 pad0[3]; + struct AudioBankSample *audioBookSample; // sp164, sp138 + struct AdpcmLoop *loopInfo; // sp160, sp134 + s16 *curLoadedBook; // sp154, sp130 + UNUSED u8 padEU[0x04]; + UNUSED u8 pad8[0x04]; + s32 noteFinished; // 150 t2, sp124 + s32 restart; // 14c t3, sp120 + s32 flags; // sp148, sp11C, t8 + u16 resamplingRateFixedPoint; // sp5c, sp11A + s32 nSamplesToLoad; //s0, Ec + UNUSED u8 pad7[0x0c]; // sp100 + s32 sp130; //sp128, sp104 + UNUSED s32 tempBufLen; + UNUSED u32 pad9; + s32 t0; + u8 *sampleAddr; // sp120, spF4 + s32 s6; + s32 samplesLenAdjusted; // 108, spEC + s32 nAdpcmSamplesProcessed; // signed required for US // spc0 + s32 endPos; // sp110, spE4 + s32 nSamplesToProcess; // sp10c/a0, spE0 + // Might have been used to store (samplesLenFixedPoint >> 0x10), but doing so causes strange + // behavior with the break near the end of the loop, causing US and JP to need a goto instead + UNUSED s32 samplesLenInt; + s32 s2; + s32 leftRight; //s0 + s32 s5; //s4 + u32 samplesLenFixedPoint; // v1_1 + s32 s3; // spA0 + s32 nSamplesInThisIteration; // v1_2 + u32 a3; + u8 *v0_2; + s32 unk_s6; // sp90 + s32 s5Aligned; + s32 sp88; + s32 sp84; + u32 temp; + s32 nParts; // spE8, spBC + s32 curPart; // spE4, spB8 + s32 aligned; + UNUSED u32 padSH1; + s32 resampledTempLen; // spD8, spAC, sp6c + u16 noteSamplesDmemAddrBeforeResampling; // spD6, spAA, sp6a -- 6C + UNUSED u32 padSH2; + UNUSED u32 padSH3; + UNUSED u32 padSH4; + struct Note *note; // sp58 + u16 sp56; // sp56 + u16 addr; + u8 synthesisVolume; + + curLoadedBook = NULL; + note = &gNotes[noteIndex]; + flags = 0; + if (noteSubEu->needsInit == TRUE) { + flags = A_INIT; + synthesisState->restart = 0; + synthesisState->samplePosInt = 0; + synthesisState->samplePosFrac = 0; + synthesisState->curVolLeft = 0; + synthesisState->curVolRight = 0; + synthesisState->prevHeadsetPanRight = 0; + synthesisState->prevHeadsetPanLeft = 0; + synthesisState->reverbVol = noteSubEu->reverbVol; + synthesisState->unk5 = 0; + note->noteSubEu.finished = 0; + } + + resamplingRateFixedPoint = noteSubEu->resamplingRateFixedPoint; + nParts = noteSubEu->hasTwoAdpcmParts + 1; + samplesLenFixedPoint = (resamplingRateFixedPoint * bufLen * 2) + synthesisState->samplePosFrac; + nSamplesToLoad = (samplesLenFixedPoint >> 0x10); + synthesisState->samplePosFrac = samplesLenFixedPoint & 0xFFFF; + + if ((synthesisState->unk5 == 1) && (nParts == 2)) { + nSamplesToLoad += 2; + sp56 = 2; + } else if ((synthesisState->unk5 == 2) && (nParts == 1)) { + nSamplesToLoad -= 4; + sp56 = 4; + } else { + sp56 = 0; + } + + + synthesisState->unk5 = nParts; + + if (noteSubEu->isSyntheticWave) { + cmd = load_wave_samples(cmd, noteSubEu, synthesisState, nSamplesToLoad); + noteSamplesDmemAddrBeforeResampling = (synthesisState->samplePosInt * 2) + DMEM_ADDR_UNCOMPRESSED_NOTE; + synthesisState->samplePosInt += nSamplesToLoad; + } else { + // ADPCM note + audioBookSample = noteSubEu->sound.audioBankSound->sample; + loopInfo = audioBookSample->loop; + endPos = loopInfo->end; + sampleAddr = audioBookSample->sampleAddr; + resampledTempLen = 0; + for (curPart = 0; curPart < nParts; curPart++) { + nAdpcmSamplesProcessed = 0; // s8 + s5 = 0; // s4 + + if (nParts == 1) { + samplesLenAdjusted = nSamplesToLoad; + } else if (nSamplesToLoad & 1) { + samplesLenAdjusted = (nSamplesToLoad & ~1) + (curPart * 2); + } else { + samplesLenAdjusted = nSamplesToLoad; + } + + if (audioBookSample->codec == CODEC_ADPCM) { + if (curLoadedBook != (*audioBookSample->book).book) { + u32 nEntries; + switch (noteSubEu->bookOffset) { + case 1: + curLoadedBook = euUnknownData_80301950 + 1; + break; + case 2: + curLoadedBook = euUnknownData_80301950 + 2; + break; + case 3: + default: + curLoadedBook = audioBookSample->book->book; + break; + } + nEntries = 16 * audioBookSample->book->order * audioBookSample->book->npredictors; + aLoadADPCM(cmd++, nEntries, VIRTUAL_TO_PHYSICAL2(curLoadedBook)); + } + } + + while (nAdpcmSamplesProcessed != samplesLenAdjusted) { + s32 samplesRemaining; // v1 + s32 s0; + + noteFinished = FALSE; + restart = FALSE; + s2 = synthesisState->samplePosInt & 0xf; + samplesRemaining = endPos - synthesisState->samplePosInt; + nSamplesToProcess = samplesLenAdjusted - nAdpcmSamplesProcessed; + + if (s2 == 0 && synthesisState->restart == FALSE) { + s2 = 16; + } + s6 = 16 - s2; // a1 + if (nSamplesToProcess < samplesRemaining) { + t0 = (nSamplesToProcess - s6 + 0xf) / 16; + s0 = t0 * 16; + s3 = s6 + s0 - nSamplesToProcess; + } else { + s0 = samplesRemaining - s6; + s3 = 0; + if (s0 <= 0) { + s0 = 0; + s6 = samplesRemaining; + } + t0 = (s0 + 0xf) / 16; + if (loopInfo->count != 0) { + // Loop around and restart + restart = 1; + } else { + noteFinished = 1; + } + } + switch (audioBookSample->codec) { + case CODEC_ADPCM: + unk_s6 = 9; + sp88 = 0x10; + sp84 = 0; + break; + case CODEC_S8: + unk_s6 = 0x10; + sp88 = 0x10; + sp84 = 0; + break; + case CODEC_SKIP: goto skip; + } + if (t0 != 0) { + temp = (synthesisState->samplePosInt + sp88 - s2) / 16; + if (audioBookSample->medium == 0) { + v0_2 = sp84 + (temp * unk_s6) + sampleAddr; + } else { + v0_2 = dma_sample_data((uintptr_t)(sp84 + (temp * unk_s6) + sampleAddr), + ALIGN(t0 * unk_s6 + 16, 4), flags, &synthesisState->sampleDmaIndex, audioBookSample->medium); + } + + a3 = ((uintptr_t)v0_2 & 0xf); + aligned = ALIGN(t0 * unk_s6 + 16, 4); + addr = (DMEM_ADDR_COMPRESSED_ADPCM_DATA - aligned) & 0xffff; + aLoadBuffer(cmd++, VIRTUAL_TO_PHYSICAL2(v0_2 - a3), addr, ALIGN(t0 * unk_s6 + 16, 4)); + } else { + s0 = 0; + a3 = 0; + } + if (synthesisState->restart != FALSE) { + aSetLoop(cmd++, VIRTUAL_TO_PHYSICAL2(audioBookSample->loop->state)); + flags = A_LOOP; // = 2 + synthesisState->restart = FALSE; + } + nSamplesInThisIteration = s0 + s6 - s3; + if (nAdpcmSamplesProcessed == 0) { + switch (audioBookSample->codec) { + case CODEC_ADPCM: + aligned = ALIGN(t0 * unk_s6 + 16, 4); + addr = (DMEM_ADDR_COMPRESSED_ADPCM_DATA - aligned) & 0xffff; + aSetBuffer(cmd++, 0, addr + a3, DMEM_ADDR_UNCOMPRESSED_NOTE, s0 * 2); + aADPCMdec(cmd++, flags, VIRTUAL_TO_PHYSICAL2(synthesisState->synthesisBuffers->adpcmdecState)); + break; + case CODEC_S8: + aligned = ALIGN(t0 * unk_s6 + 16, 4); + addr = (DMEM_ADDR_COMPRESSED_ADPCM_DATA - aligned) & 0xffff; + aSetBuffer(cmd++, 0, addr + a3, DMEM_ADDR_UNCOMPRESSED_NOTE, s0 * 2); + aS8Dec(cmd++, flags, VIRTUAL_TO_PHYSICAL2(synthesisState->synthesisBuffers->adpcmdecState)); + break; + } + sp130 = s2 * 2; + } else { + s5Aligned = ALIGN(s5 + 16, 4); + switch (audioBookSample->codec) { + case CODEC_ADPCM: + aligned = ALIGN(t0 * unk_s6 + 16, 4); + addr = (DMEM_ADDR_COMPRESSED_ADPCM_DATA - aligned) & 0xffff; + aSetBuffer(cmd++, 0, addr + a3, DMEM_ADDR_UNCOMPRESSED_NOTE + s5Aligned, s0 * 2); + aADPCMdec(cmd++, flags, VIRTUAL_TO_PHYSICAL2(synthesisState->synthesisBuffers->adpcmdecState)); + break; + case CODEC_S8: + aligned = ALIGN(t0 * unk_s6 + 16, 4); + addr = (DMEM_ADDR_COMPRESSED_ADPCM_DATA - aligned) & 0xffff; + aSetBuffer(cmd++, 0, addr + a3, DMEM_ADDR_UNCOMPRESSED_NOTE + s5Aligned, s0 * 2); + aS8Dec(cmd++, flags, VIRTUAL_TO_PHYSICAL2(synthesisState->synthesisBuffers->adpcmdecState)); + break; + } + aDMEMMove(cmd++, DMEM_ADDR_UNCOMPRESSED_NOTE + s5Aligned + (s2 * 2), DMEM_ADDR_UNCOMPRESSED_NOTE + s5, (nSamplesInThisIteration) * 2); + } + nAdpcmSamplesProcessed += nSamplesInThisIteration; + switch (flags) { + case A_INIT: // = 1 + sp130 = 0x20; + s5 = (s0 + 0x10) * 2; + break; + case A_LOOP: // = 2 + s5 = (nSamplesInThisIteration) * 2 + s5; + break; + default: + if (s5 != 0) { + s5 = (nSamplesInThisIteration) * 2 + s5; + } else { + s5 = (s2 + (nSamplesInThisIteration)) * 2; + } + break; + } + flags = 0; +skip: + if (noteFinished) { + aClearBuffer(cmd++, DMEM_ADDR_UNCOMPRESSED_NOTE + s5, + (samplesLenAdjusted - nAdpcmSamplesProcessed) * 2); + noteSubEu->finished = 1; + note->noteSubEu.finished = 1; + func_sh_802ed644(updateIndex, noteIndex); + break; + } + if (restart != 0) { + synthesisState->restart = TRUE; + synthesisState->samplePosInt = loopInfo->start; + } else { + synthesisState->samplePosInt += nSamplesToProcess; + } + } + + switch (nParts) { + case 1: + noteSamplesDmemAddrBeforeResampling = DMEM_ADDR_UNCOMPRESSED_NOTE + sp130; + break; + case 2: + switch (curPart) { + case 0: + aDownsampleHalf(cmd++, ALIGN(samplesLenAdjusted / 2, 3), DMEM_ADDR_UNCOMPRESSED_NOTE + sp130, DMEM_ADDR_RESAMPLED); + resampledTempLen = samplesLenAdjusted; + noteSamplesDmemAddrBeforeResampling = DMEM_ADDR_RESAMPLED; + if (noteSubEu->finished != FALSE) { + aClearBuffer(cmd++, noteSamplesDmemAddrBeforeResampling + resampledTempLen, samplesLenAdjusted + 0x10); + } + break; + case 1: + aDownsampleHalf(cmd++, ALIGN(samplesLenAdjusted / 2, 3), DMEM_ADDR_UNCOMPRESSED_NOTE + sp130, resampledTempLen + DMEM_ADDR_RESAMPLED); + break; + } + } + if (noteSubEu->finished != FALSE) { + break; + } + } + } + flags = 0; + if (noteSubEu->needsInit == TRUE) { + flags = A_INIT; + noteSubEu->needsInit = FALSE; + } + flags = flags | sp56; + cmd = final_resample(cmd, synthesisState, bufLen * 2, resamplingRateFixedPoint, + noteSamplesDmemAddrBeforeResampling, flags); + if ((flags & 1) != 0) { + flags = 1; + } + + if (noteSubEu->filter) { + aFilter(cmd++, 0x02, bufLen * 2, noteSubEu->filter); + aFilter(cmd++, flags, DMEM_ADDR_TEMP, synthesisState->synthesisBuffers->filterBuffer); + + } + + if (noteSubEu->bookOffset == 3) { + aUnknown25(cmd++, 0, bufLen * 2, DMEM_ADDR_TEMP, DMEM_ADDR_TEMP); + } + + synthesisVolume = noteSubEu->synthesisVolume; + if (synthesisVolume != 0) { + if (synthesisVolume < 0x10) { + synthesisVolume = 0x10; + } + + aHiLoGain(cmd++, synthesisVolume, (bufLen + 0x10) * 2, DMEM_ADDR_TEMP); + } + + if (noteSubEu->headsetPanRight != 0 || synthesisState->prevHeadsetPanRight != 0) { + leftRight = 1; + } else if (noteSubEu->headsetPanLeft != 0 || synthesisState->prevHeadsetPanLeft != 0) { + leftRight = 2; + } else { + leftRight = 0; + } + cmd = process_envelope(cmd, noteSubEu, synthesisState, bufLen, DMEM_ADDR_TEMP, leftRight, flags); + if (noteSubEu->usesHeadsetPanEffects) { + if ((flags & 1) == 0) { + flags = 0; + } + cmd = note_apply_headset_pan_effects(cmd, noteSubEu, synthesisState, bufLen * 2, flags, leftRight); + } + + return cmd; +} + +u64 *load_wave_samples(u64 *cmd, struct NoteSubEu *noteSubEu, struct NoteSynthesisState *synthesisState, s32 nSamplesToLoad) { + s32 a3; + s32 repeats; + aLoadBuffer(cmd++, VIRTUAL_TO_PHYSICAL2(noteSubEu->sound.samples), + DMEM_ADDR_UNCOMPRESSED_NOTE, 128); + + synthesisState->samplePosInt &= 0x3f; + a3 = 64 - synthesisState->samplePosInt; + if (a3 < nSamplesToLoad) { + repeats = (nSamplesToLoad - a3 + 63) / 64; + if (repeats != 0) { + aDuplicate(cmd++, + /*dmemin*/ DMEM_ADDR_UNCOMPRESSED_NOTE, + /*dmemout*/ DMEM_ADDR_UNCOMPRESSED_NOTE + 128, + /*copies*/ repeats); + } + } + return cmd; +} + +u64 *final_resample(u64 *cmd, struct NoteSynthesisState *synthesisState, s32 count, u16 pitch, u16 dmemIn, u32 flags) { + if (pitch == 0) { + aClearBuffer(cmd++, DMEM_ADDR_TEMP, count); + } else { + aSetBuffer(cmd++, /*flags*/ 0, dmemIn, /*dmemout*/ DMEM_ADDR_TEMP, count); + aResample(cmd++, flags, pitch, VIRTUAL_TO_PHYSICAL2(synthesisState->synthesisBuffers->finalResampleState)); + } + return cmd; +} + +u64 *process_envelope(u64 *cmd, struct NoteSubEu *note, struct NoteSynthesisState *synthesisState, s32 nSamples, u16 inBuf, s32 headsetPanSettings, UNUSED u32 flags) { + u16 sourceRight; + u16 sourceLeft; + u16 targetLeft; + u16 targetRight; + s16 rampLeft; + s16 rampRight; + s32 sourceReverbVol; + s16 rampReverb; + s32 reverbVolDiff = 0; + + sourceLeft = synthesisState->curVolLeft; + sourceRight = synthesisState->curVolRight; + targetLeft = note->targetVolLeft; + targetRight = note->targetVolRight; + targetLeft <<= 4; + targetRight <<= 4; + + if (targetLeft != sourceLeft) { + rampLeft = (targetLeft - sourceLeft) / (nSamples >> 3); + } else { + rampLeft = 0; + } + if (targetRight != sourceRight) { + rampRight = (targetRight - sourceRight) / (nSamples >> 3); + } else { + rampRight = 0; + } + + sourceReverbVol = synthesisState->reverbVol; + if (note->reverbVol != sourceReverbVol) { + reverbVolDiff = ((note->reverbVol & 0x7f) - (sourceReverbVol & 0x7f)) << 9; + rampReverb = reverbVolDiff / (nSamples >> 3); + synthesisState->reverbVol = note->reverbVol; + } else { + rampReverb = 0; + } + synthesisState->curVolLeft = sourceLeft + rampLeft * (nSamples >> 3); + synthesisState->curVolRight = sourceRight + rampRight * (nSamples >> 3); + + if (note->usesHeadsetPanEffects) { + aClearBuffer(cmd++, DMEM_ADDR_NOTE_PAN_TEMP, DEFAULT_LEN_1CH); + aEnvSetup1(cmd++, (sourceReverbVol & 0x7f) * 2, rampReverb, rampLeft, rampRight); + aEnvSetup2(cmd++, sourceLeft, sourceRight); + + switch (headsetPanSettings) { + case 1: + aEnvMixer(cmd++, + inBuf, nSamples, + (sourceReverbVol & 0x80) >> 7, + note->stereoStrongRight, note->stereoStrongLeft, + DMEM_ADDR_NOTE_PAN_TEMP, + DMEM_ADDR_RIGHT_CH, + DMEM_ADDR_WET_LEFT_CH, + DMEM_ADDR_WET_RIGHT_CH); + break; + case 2: + aEnvMixer(cmd++, + inBuf, nSamples, + (sourceReverbVol & 0x80) >> 7, + note->stereoStrongRight, note->stereoStrongLeft, + DMEM_ADDR_LEFT_CH, + DMEM_ADDR_NOTE_PAN_TEMP, + DMEM_ADDR_WET_LEFT_CH, + DMEM_ADDR_WET_RIGHT_CH); + break; + default: + aEnvMixer(cmd++, + inBuf, nSamples, + (sourceReverbVol & 0x80) >> 7, + note->stereoStrongRight, note->stereoStrongLeft, + DMEM_ADDR_LEFT_CH, + DMEM_ADDR_RIGHT_CH, + DMEM_ADDR_WET_LEFT_CH, + DMEM_ADDR_WET_RIGHT_CH); + break; + } + } else { + aEnvSetup1(cmd++, (sourceReverbVol & 0x7f) * 2, rampReverb, rampLeft, rampRight); + aEnvSetup2(cmd++, sourceLeft, sourceRight); + aEnvMixer(cmd++, + inBuf, nSamples, + (sourceReverbVol & 0x80) >> 7, + note->stereoStrongRight, note->stereoStrongLeft, + DMEM_ADDR_LEFT_CH, + DMEM_ADDR_RIGHT_CH, + DMEM_ADDR_WET_LEFT_CH, + DMEM_ADDR_WET_RIGHT_CH); + } + return cmd; +} + +u64 *note_apply_headset_pan_effects(u64 *cmd, struct NoteSubEu *noteSubEu, struct NoteSynthesisState *note, s32 bufLen, s32 flags, s32 leftRight) { + u16 dest; + u16 pitch; + u8 prevPanShift; + u8 panShift; + UNUSED u8 unkDebug; + + switch (leftRight) { + case 1: + dest = DMEM_ADDR_LEFT_CH; + panShift = noteSubEu->headsetPanRight; + note->prevHeadsetPanLeft = 0; + prevPanShift = note->prevHeadsetPanRight; + note->prevHeadsetPanRight = panShift; + break; + case 2: + dest = DMEM_ADDR_RIGHT_CH; + panShift = noteSubEu->headsetPanLeft; + note->prevHeadsetPanRight = 0; + + prevPanShift = note->prevHeadsetPanLeft; + note->prevHeadsetPanLeft = panShift; + break; + default: + return cmd; + } + + if (flags != 1) { // A_INIT? + // Slightly adjust the sample rate in order to fit a change in pan shift + if (panShift != prevPanShift) { + pitch = (((bufLen << 0xf) / 2) - 1) / ((bufLen + panShift - prevPanShift - 2) / 2); + aSetBuffer(cmd++, 0, DMEM_ADDR_NOTE_PAN_TEMP, DMEM_ADDR_TEMP, (bufLen + panShift) - prevPanShift); + aResampleZoh(cmd++, pitch, 0); + } else { + aDMEMMove(cmd++, DMEM_ADDR_NOTE_PAN_TEMP, DMEM_ADDR_TEMP, bufLen); + } + + if (prevPanShift != 0) { + aLoadBuffer(cmd++, VIRTUAL_TO_PHYSICAL2(note->synthesisBuffers->panSamplesBuffer), + DMEM_ADDR_NOTE_PAN_TEMP, ALIGN(prevPanShift, 4)); + aDMEMMove(cmd++, DMEM_ADDR_TEMP, DMEM_ADDR_NOTE_PAN_TEMP + prevPanShift, bufLen + panShift - prevPanShift); + } else { + aDMEMMove(cmd++, DMEM_ADDR_TEMP, DMEM_ADDR_NOTE_PAN_TEMP, bufLen + panShift); + } + } else { + // Just shift right + aDMEMMove(cmd++, DMEM_ADDR_NOTE_PAN_TEMP, DMEM_ADDR_TEMP, bufLen); + aClearBuffer(cmd++, DMEM_ADDR_NOTE_PAN_TEMP, panShift); + aDMEMMove(cmd++, DMEM_ADDR_TEMP, DMEM_ADDR_NOTE_PAN_TEMP + panShift, bufLen); + } + + if (panShift) { + // Save excessive samples for next iteration + aSaveBuffer(cmd++, DMEM_ADDR_NOTE_PAN_TEMP + bufLen, + VIRTUAL_TO_PHYSICAL2(note->synthesisBuffers->panSamplesBuffer), ALIGN(panShift, 4)); + } + + aAddMixer(cmd++, DMEM_ADDR_NOTE_PAN_TEMP, dest, (bufLen + 0x3f) & 0xffc0); + + return cmd; +} +#endif From 7df97a3333e3ee9607e150b65dcb467d1a928fc5 Mon Sep 17 00:00:00 2001 From: MeltyPlayer Date: Fri, 21 Oct 2022 00:27:03 -0500 Subject: [PATCH 02/16] Included more files from the decomp. --- src/decomp/include/PR/abi.h | 996 +++++++++++++++++++++++++++ src/decomp/include/PR/libaudio.h | 51 ++ src/decomp/include/PR/libultra.h | 18 + src/decomp/include/PR/os.h | 800 +++++++++++++++++++++ src/decomp/include/PR/os_ai.h | 92 +++ src/decomp/include/PR/os_cache.h | 96 +++ src/decomp/include/PR/os_eeprom.h | 107 +++ src/decomp/include/PR/os_exception.h | 119 ++++ src/decomp/include/PR/os_internal.h | 19 + src/decomp/include/PR/os_libc.h | 10 + src/decomp/include/PR/os_message.h | 164 +++++ src/decomp/include/PR/os_misc.h | 11 + src/decomp/include/PR/os_pi.h | 88 +++ src/decomp/include/PR/os_rdp.h | 92 +++ src/decomp/include/PR/os_thread.h | 75 ++ src/decomp/include/PR/os_time.h | 27 + src/decomp/include/PR/os_tlb.h | 107 +++ src/decomp/include/PR/os_vi.h | 117 ++++ src/decomp/include/PR/sptask.h | 116 ++++ src/decomp/include/PR/ucode.h | 23 + src/decomp/include/ultra64.h | 31 + 21 files changed, 3159 insertions(+) create mode 100644 src/decomp/include/PR/abi.h create mode 100644 src/decomp/include/PR/libaudio.h create mode 100644 src/decomp/include/PR/libultra.h create mode 100644 src/decomp/include/PR/os.h create mode 100644 src/decomp/include/PR/os_ai.h create mode 100644 src/decomp/include/PR/os_cache.h create mode 100644 src/decomp/include/PR/os_eeprom.h create mode 100644 src/decomp/include/PR/os_exception.h create mode 100644 src/decomp/include/PR/os_internal.h create mode 100644 src/decomp/include/PR/os_libc.h create mode 100644 src/decomp/include/PR/os_message.h create mode 100644 src/decomp/include/PR/os_misc.h create mode 100644 src/decomp/include/PR/os_pi.h create mode 100644 src/decomp/include/PR/os_rdp.h create mode 100644 src/decomp/include/PR/os_thread.h create mode 100644 src/decomp/include/PR/os_time.h create mode 100644 src/decomp/include/PR/os_tlb.h create mode 100644 src/decomp/include/PR/os_vi.h create mode 100644 src/decomp/include/PR/sptask.h create mode 100644 src/decomp/include/PR/ucode.h create mode 100644 src/decomp/include/ultra64.h diff --git a/src/decomp/include/PR/abi.h b/src/decomp/include/PR/abi.h new file mode 100644 index 0000000..b73cb72 --- /dev/null +++ b/src/decomp/include/PR/abi.h @@ -0,0 +1,996 @@ +#ifndef _ABI_H_ +#define _ABI_H_ + +/************************************************************************** + * * + * Copyright (C) 1994, Silicon Graphics, Inc. * + * * + * These coded instructions, statements, and computer programs contain * + * unpublished proprietary information of Silicon Graphics, Inc., and * + * are protected by Federal copyright law. They may not be disclosed * + * to third parties or copied or duplicated in any form, in whole or * + * in part, without the prior written consent of Silicon Graphics, Inc. * + * * + **************************************************************************/ + +/************************************************************************** + * + * $Revision: 1.32 $ + * $Date: 1997/02/11 08:16:37 $ + * $Source: /exdisk2/cvs/N64OS/Master/cvsmdev2/PR/include/abi.h,v $ + * + **************************************************************************/ + +/* + * Header file for the Audio Binary Interface. + * This is included in the Media Binary Interface file + * mbi.h. + * + * This file follows the framework used for graphics. + * + */ + +/* Audio commands: */ +#define A_SPNOOP 0 +#define A_ADPCM 1 +#define A_CLEARBUFF 2 +#define A_RESAMPLE 5 +#define A_SETBUFF 8 +#define A_DMEMMOVE 10 +#define A_LOADADPCM 11 +#define A_MIXER 12 +#define A_INTERLEAVE 13 +#define A_SETLOOP 15 + +#ifndef VERSION_SH + +#define A_ENVMIXER 3 +#define A_LOADBUFF 4 +#define A_RESAMPLE 5 +#define A_SAVEBUFF 6 +#define A_SEGMENT 7 +#define A_SETVOL 9 +#define A_POLEF 14 + +#else + +#define A_ADDMIXER 4 +#define A_RESAMPLE_ZOH 6 +#define A_DMEMMOVE2 16 +#define A_DOWNSAMPLE_HALF 17 +#define A_ENVSETUP1 18 +#define A_ENVMIXER 19 +#define A_LOADBUFF 20 +#define A_SAVEBUFF 21 +#define A_ENVSETUP2 22 +#define A_S8DEC 23 +#define A_HILOGAIN 24 +#define A_UNK_25 25 +#define A_DUPLICATE 26 +#define A_FILTER 27 + +#endif + +#define ACMD_SIZE 32 +/* + * Audio flags + */ + +#define A_INIT 0x01 +#define A_CONTINUE 0x00 +#define A_LOOP 0x02 +#define A_OUT 0x02 +#define A_LEFT 0x02 +#define A_RIGHT 0x00 +#define A_VOL 0x04 +#define A_RATE 0x00 +#define A_AUX 0x08 +#define A_NOAUX 0x00 +#define A_MAIN 0x00 +#define A_MIX 0x10 + +/* + * BEGIN C-specific section: (typedef's) + */ +#if defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) + +/* + * Data Structures. + */ + +typedef struct { + unsigned int cmd:8; + unsigned int flags:8; + unsigned int gain:16; + unsigned int addr; +} Aadpcm; + +typedef struct { + unsigned int cmd:8; + unsigned int flags:8; + unsigned int gain:16; + unsigned int addr; +} Apolef; + +typedef struct { + unsigned int cmd:8; + unsigned int flags:8; + unsigned int pad1:16; + unsigned int addr; +} Aenvelope; + +typedef struct { + unsigned int cmd:8; + unsigned int pad1:8; + unsigned int dmem:16; + unsigned int pad2:16; + unsigned int count:16; +} Aclearbuff; + +typedef struct { + unsigned int cmd:8; + unsigned int pad1:8; + unsigned int pad2:16; + unsigned int inL:16; + unsigned int inR:16; +} Ainterleave; + +typedef struct { + unsigned int cmd:8; + unsigned int pad1:24; + unsigned int addr; +} Aloadbuff; + +typedef struct { + unsigned int cmd:8; + unsigned int flags:8; + unsigned int pad1:16; + unsigned int addr; +} Aenvmixer; + +typedef struct { + unsigned int cmd:8; + unsigned int flags:8; + unsigned int gain:16; + unsigned int dmemi:16; + unsigned int dmemo:16; +} Amixer; + +typedef struct { + unsigned int cmd:8; + unsigned int flags:8; + unsigned int dmem2:16; + unsigned int addr; +} Apan; + +typedef struct { + unsigned int cmd:8; + unsigned int flags:8; + unsigned int pitch:16; + unsigned int addr; +} Aresample; + +typedef struct { + unsigned int cmd:8; + unsigned int flags:8; + unsigned int pad1:16; + unsigned int addr; +} Areverb; + +typedef struct { + unsigned int cmd:8; + unsigned int pad1:24; + unsigned int addr; +} Asavebuff; + +typedef struct { + unsigned int cmd:8; + unsigned int pad1:24; + unsigned int pad2:2; + unsigned int number:4; + unsigned int base:24; +} Asegment; + +typedef struct { + unsigned int cmd:8; + unsigned int flags:8; + unsigned int dmemin:16; + unsigned int dmemout:16; + unsigned int count:16; +} Asetbuff; + +typedef struct { + unsigned int cmd:8; + unsigned int flags:8; + unsigned int vol:16; + unsigned int voltgt:16; + unsigned int volrate:16; +} Asetvol; + +typedef struct { + unsigned int cmd:8; + unsigned int pad1:8; + unsigned int dmemin:16; + unsigned int dmemout:16; + unsigned int count:16; +} Admemmove; + +typedef struct { + unsigned int cmd:8; + unsigned int pad1:8; + unsigned int count:16; + unsigned int addr; +} Aloadadpcm; + +typedef struct { + unsigned int cmd:8; + unsigned int pad1:8; + unsigned int pad2:16; + unsigned int addr; +} Asetloop; + +/* + * Generic Acmd Packet + */ + +typedef struct { + uintptr_t w0; + uintptr_t w1; +} Awords; + +typedef union { + Awords words; +#if IS_BIG_ENDIAN && !IS_64_BIT + Aadpcm adpcm; + Apolef polef; + Aclearbuff clearbuff; + Aenvelope envelope; + Ainterleave interleave; + Aloadbuff loadbuff; + Aenvmixer envmixer; + Aresample resample; + Areverb reverb; + Asavebuff savebuff; + Asegment segment; + Asetbuff setbuff; + Asetvol setvol; + Admemmove dmemmove; + Aloadadpcm loadadpcm; + Amixer mixer; + Asetloop setloop; +#endif + long long int force_union_align; /* dummy, force alignment */ +} Acmd; + +/* + * ADPCM State + */ +typedef short ADPCM_STATE[16]; + +/* + * Pole filter state + */ +typedef short POLEF_STATE[4]; + +/* + * Resampler state + */ +typedef short RESAMPLE_STATE[16]; + +/* + * Resampler constants + */ +#define UNITY_PITCH 0x8000 +#define MAX_RATIO 1.99996 /* within .03 cents of +1 octave */ + +/* + * Enveloper/Mixer state + */ +typedef short ENVMIX_STATE[40]; + +/* + * Macros to assemble the audio command list + */ + +/* + * Info about parameters: + * + * A "count" in the following macros is always measured in bytes. + * + * All volumes/gains are in Q1.15 signed fixed point numbers: + * 0x8000 is the minimum volume (-100%), negating the audio curve. + * 0x0000 is silent. + * 0x7fff is maximum volume (99.997%). + * + * All DRAM addresses refer to segmented addresses. A segment table shall + * first be set up by calling aSegment for each segment. When a DRAM + * address is later used as parameter, the 8 high bits will be an index + * to the segment table and the lower 24 bits are added to the base address + * stored in the segment table for this entry. The result is the physical address. + * With the newer rsp audio code, this segment table is not used. The address is + * used directly instead. + * + * Transfers to/from DRAM are executed using DMA and hence follow these restrictions: + * All DRAM addresses should be aligned by 8 bytes, or they will be + * rounded down to the nearest multiple of 8 bytes. + * All DRAM lengths should be aligned by 8 bytes, or they will be + * rounded up to the nearest multiple of 8 bytes. + */ + +/* + * Decompresses ADPCM data. + * Possible flags: A_INIT and A_LOOP. + * + * First set up internal data in DMEM: + * aLoadADPCM(cmd++, nEntries * 16, physicalAddressOfBook) + * aSetLoop(cmd++, physicalAddressOfLoopState) (if A_LOOP is set) + * + * Then before this command, call: + * aSetBuffer(cmd++, 0, in, out, count) + * + * Note: count will be rounded up to the nearest multiple of 32 bytes. + * + * ADPCM decompression works on a block of 16 (uncompressed) samples. + * The previous 2 samples and 9 bytes of input are decompressed to + * 16 new samples using the code book previously loaded. + * + * Before the algorithm starts, the previous 16 samples are loaded according to flag: + * A_INIT: all zeros + * A_LOOP: the address set by aSetLoop + * no flags: the DRAM address in the s parameter + * These 16 samples are immediately copied to the destination address. + * + * The result of "count" bytes will be written after these 16 initial samples. + * The last 16 samples written to the destination will also be written to + * the state address in DRAM. + */ +#define aADPCMdec(pkt, f, s) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = _SHIFTL(A_ADPCM, 24, 8) | _SHIFTL(f, 16, 8); \ + _a->words.w1 = (uintptr_t)(s); \ +} + +/* + * Not used in SM64. + */ +#define aPoleFilter(pkt, f, g, s) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = (_SHIFTL(A_POLEF, 24, 8) | _SHIFTL(f, 16, 8) | \ + _SHIFTL(g, 0, 16)); \ + _a->words.w1 = (uintptr_t)(s); \ +} + +/* + * Clears DMEM data, where d is address and c is count, by writing zeros. + * + * Note: c is rounded up to the nearest multiple of 16 bytes. + */ +#define aClearBuffer(pkt, d, c) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = _SHIFTL(A_CLEARBUFF, 24, 8) | _SHIFTL(d, 0, 24); \ + _a->words.w1 = (uintptr_t)(c); \ +} + +/* + * Mixes an envelope with mono sound into 2 or 4 channels. + * Possible flags: A_INIT, A_AUX (indicates that 4 channels should be used). + * + * Before this command, call: + * aSetBuffer(cmd++, 0, inBuf, dryLeft, count) + * aSetBuffer(cmd++, A_AUX, dryRight, wetLeft, wetRight) + * + * The first time (A_INIT is set), volume also needs to be set: + * aSetVolume(cmd++, A_VOL | A_LEFT, initialVolumeLeft, 0, 0) + * aSetVolume(cmd++, A_VOL | A_RIGHT, initialVolumeRight, 0, 0) + * aSetVolume32(cmd++, A_RATE | A_LEFT, targetVolumeLeft, rampLeft) + * aSetVolume32(cmd++, A_RATE | A_RIGHT, targetVolumeRight, rampRight) + * aSetVolume(cmd++, A_AUX, dryVolume, 0, wetVolume) + * + * This command will now mix samples in inBuf into the destination buffers (dry and wet), + * but with the volume increased (or decreased) from initial volumes to target volumes, + * with the specified ramp rate. Once the target volume is reached, the volume stays + * at that level. Before the samples are finally mixed (added) into the destination + * buffers (dry and wet), the volume is changed according to dryVolume and wetVolume. + * + * Note: count will be rounded up to the nearest multiple of 16 bytes. + * Note: the wet channels are used for reverb. + * + */ +#define aEnvMixer(pkt, f, s) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = _SHIFTL(A_ENVMIXER, 24, 8) | _SHIFTL(f, 16, 8); \ + _a->words.w1 = (uintptr_t)(s); \ +} + +/* + * Interleaves two mono channels into stereo. + * + * First call: + * aSetBuffer(cmd++, 0, 0, output, count) + * + * The count refers to the size of each input. Hence 2 * count bytes will be written out. + * A left sample will be placed before the right sample. + * + * Note: count will be rounded up to the nearest multiple of 16 bytes. + */ +#define aInterleave(pkt, l, r) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = _SHIFTL(A_INTERLEAVE, 24, 8); \ + _a->words.w1 = _SHIFTL(l, 16, 16) | _SHIFTL(r, 0, 16); \ +} + +/* + * Loads a buffer from DRAM to DMEM. + * + * First call: + * aSetBuffer(cmd++, 0, in, 0, count) + * + * The in parameter to aSetBuffer is the destination in DMEM and the + * s parameter to this command is the source in DRAM. + */ +#define aLoadBuffer(pkt, s) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = _SHIFTL(A_LOADBUFF, 24, 8); \ + _a->words.w1 = (uintptr_t)(s); \ +} + +/* + * Mixes audio. + * Possible flags: no flags used, although parameter present. + * + * First call: + * aSetBuffer(cmd++, 0, 0, 0, count) + * + * Input and output addresses are taken from the i and o parameters. + * The volume with which the input is changed is taken from the g parameter. + * After the volume of the input samples have been changed, the result + * is added to the output. + * + * Note: count will be rounded up to the nearest multiple of 32 bytes. + */ +#define aMix(pkt, f, g, i, o) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = (_SHIFTL(A_MIXER, 24, 8) | _SHIFTL(f, 16, 8) | \ + _SHIFTL(g, 0, 16)); \ + _a->words.w1 = _SHIFTL(i,16, 16) | _SHIFTL(o, 0, 16); \ +} + +// Not present in the audio microcode. +#define aPan(pkt, f, d, s) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = (_SHIFTL(A_PAN, 24, 8) | _SHIFTL(f, 16, 8) | \ + _SHIFTL(d, 0, 16)); \ + _a->words.w1 = (uintptr_t)(s); \ +} + +/* + * Resamples audio. + * Possible flags: A_INIT, A_OUT? (not used in SM64). + * + * First call: + * aSetBuffer(cmd++, 0, in, out, count) + * + * This command resamples the audio using the given frequency ratio (pitch) + * using a filter that uses a window of 4 source samples. This can be used + * either for just resampling audio to be able to be played back at a different + * sample rate, or to change the pitch if the result is played back at + * the same sample rate as the input. + * + * The frequency ratio is given in UQ1.15 fixed point format. + * For no change in frequency, use pitch 0x8000. + * For 1 octave up or downsampling to (roughly) half number of samples, use pitch 0xffff. + * For 1 octave down or upsampling to double as many samples, use pitch 0x4000. + * + * Note: count represents the number of output sample bytes and is rounded up to + * the nearest multiple of 16 bytes. + * + * The state consists of the four following source samples when the algorithm stopped as + * well as a fractional position, and is initialized to all zeros if A_INIT is given. + * Otherwise it is loaded from DRAM at address s. + * + * The algorithm starts by writing the four source samples from the state (or zero) + * to just before the input address given. It then creates one output sample by examining + * the four next source samples and then moving the source position zero or more + * samples forward. The first output sample (when A_INIT is given) is always 0. + * + * When "count" bytes have been written, the following four source samples + * are written to the state in DRAM as well as a fractional position. + */ +#define aResample(pkt, f, p, s) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = (_SHIFTL(A_RESAMPLE, 24, 8) | _SHIFTL(f, 16, 8) |\ + _SHIFTL(p, 0, 16)); \ + _a->words.w1 = (uintptr_t)(s); \ +} + +/* + * Stores a buffer in DMEM to DRAM. + * + * First call: + * aSetBuffer(cmd++, 0, 0, out, count) + * + * The out parameter to aSetBuffer is the source in DMEM and the + * s parameter to this command is the destination in DRAM. + */ +#define aSaveBuffer(pkt, s) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = _SHIFTL(A_SAVEBUFF, 24, 8); \ + _a->words.w1 = (uintptr_t)(s); \ +} + +/* + * Sets up an entry in the segment table. + * + * The s parameter is a segment index, 0 to 15. + * The b parameter is the base offset. + */ +#define aSegment(pkt, s, b) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = _SHIFTL(A_SEGMENT, 24, 8); \ + _a->words.w1 = _SHIFTL(s, 24, 8) | _SHIFTL(b, 0, 24); \ +} + +/* + * Sets internal DMEM buffer addresses used for later commands. + * See each command for how to use aSetBuffer. + */ +#define aSetBuffer(pkt, f, i, o, c) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = (_SHIFTL(A_SETBUFF, 24, 8) | _SHIFTL(f, 16, 8) | \ + _SHIFTL(i, 0, 16)); \ + _a->words.w1 = _SHIFTL(o, 16, 16) | _SHIFTL(c, 0, 16); \ +} + +/* + * Sets internal volume parameters. + * See aEnvMixer for more info. + */ +#define aSetVolume(pkt, f, v, t, r) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = (_SHIFTL(A_SETVOL, 24, 8) | _SHIFTL(f, 16, 16) | \ + _SHIFTL(v, 0, 16)); \ + _a->words.w1 = _SHIFTL(t, 16, 16) | _SHIFTL(r, 0, 16); \ +} + +/* + * Sets the address to ADPCM loop state. + * + * The a parameter is a DRAM address. + * See aADPCMdec for more info. + */ +#define aSetLoop(pkt, a) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + _a->words.w0 = _SHIFTL(A_SETLOOP, 24, 8); \ + _a->words.w1 = (uintptr_t)(a); \ +} + +/* + * Copies memory in DMEM. + * + * Copies c bytes from address i to address o. + * + * Note: count is rounded up to the nearest multiple of 16 bytes. + * + * Note: This acts as memcpy where 16 bytes are moved at a time, therefore + * if input and output overlap, output address should be less than input address. + */ +#define aDMEMMove(pkt, i, o, c) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = _SHIFTL(A_DMEMMOVE, 24, 8) | _SHIFTL(i, 0, 24); \ + _a->words.w1 = _SHIFTL(o, 16, 16) | _SHIFTL(c, 0, 16); \ +} + +/* + * Loads ADPCM book from DRAM into DMEM. + * + * This command loads ADPCM table entries from DRAM to DMEM. + * + * The count parameter c should be a multiple of 16 bytes. + * The d parameter is a DRAM address. + */ +#define aLoadADPCM(pkt, c, d) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = _SHIFTL(A_LOADADPCM, 24, 8) | _SHIFTL(c, 0, 24); \ + _a->words.w1 = (uintptr_t) (d); \ +} + +// This is a version of aSetVolume which takes a single 32-bit parameter +// instead of two 16-bit ones. According to AziAudio, it is used to set +// ramping values when neither bit 4 nor bit 8 is set in the flags parameter. +// It does not appear in the official abi.h header. +/* + * Sets internal volume parameters. + * See aEnvMixer for more info. + */ +#define aSetVolume32(pkt, f, v, tr) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = (_SHIFTL(A_SETVOL, 24, 8) | _SHIFTL(f, 16, 16) | \ + _SHIFTL(v, 0, 16)); \ + _a->words.w1 = (uintptr_t)(tr); \ +} + +#ifdef VERSION_SH +#undef aLoadBuffer +#undef aSaveBuffer +#undef aMix +#undef aEnvMixer +#undef aInterleave + +// New or modified operations in the new audio microcode below + +/** + * Decompresses S8 data. + * Possible flags: A_INIT and A_LOOP. + * + * First set up internal data in DMEM: + * aSetLoop(cmd++, physicalAddressOfLoopState) (if A_LOOP is set) + * + * Then before this command, call: + * aSetBuffer(cmd++, 0, in, out, count) + * + * Note: count will be rounded up to the nearest multiple of 32 bytes. + * + * S8 decompression works by expanding s8 bytes into s16 numbers, + * by performing a left shift of 8 steps. + * + * Before the algorithm starts, the previous 16 samples are loaded according to flag: + * A_INIT: all zeros + * A_LOOP: the address set by aSetLoop + * no flags: the DRAM address in the s parameter + * These 16 samples are immediately copied to the destination address. + * + * The result of "count" bytes will be written after these 16 initial samples. + * The last 16 samples written to the destination will also be written to + * the state address in DRAM. + */ +#define aS8Dec(pkt, f, s) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = _SHIFTL(A_S8DEC, 24, 8) | _SHIFTL(f, 16, 8); \ + _a->words.w1 = (uintptr_t)(s); \ +} + +/* + * Mix two tracks by simple clamped addition. + * + * s: DMEM source track 1 + * d: DMEM source track 2 and destination + * c: number of bytes to write + * + * Note: count is first rounded down to the nearest multiple of 16 bytes + * and then rounded up to the nearest multiple of 64 bytes. + */ +#define aAddMixer(pkt, s, d, c) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = (_SHIFTL(A_ADDMIXER, 24, 8) | \ + _SHIFTL((c) >> 4, 16, 8) | _SHIFTL(0x7fff, 0, 16)); \ + _a->words.w1 = (_SHIFTL(s, 16, 16) | _SHIFTL(d, 0, 16)); \ +} + +/* + * Loads a buffer from DRAM to DMEM. + * + * s: DRAM source + * d: DMEM destination + * c: number of bytes to copy (rounded down to 16 byte alignment) + */ +#define aLoadBuffer(pkt, s, d, c) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = _SHIFTL(A_LOADBUFF, 24, 8) | \ + _SHIFTL((c) >> 4, 16, 8) | _SHIFTL(d, 0, 16); \ + _a->words.w1 = (uintptr_t)(s); \ +} + +/* + * Stores a buffer from DMEM to DRAM. + * + * s: DMEM source + * d: DRAM destination + * c: number of bytes to copy (rounded down to 16 byte alignment) + */ +#define aSaveBuffer(pkt, s, d, c) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = _SHIFTL(A_SAVEBUFF, 24, 8) | \ + _SHIFTL((c) >> 4, 16, 8) | _SHIFTL(s, 0, 16); \ + _a->words.w1 = (uintptr_t)(d); \ +} + +/* + * Duplicates 128 bytes of data a number of times. + * + * 128 bytes are read from source DMEM address s. + * Then c identical copies of these bytes are written to DMEM address d. + */ +#define aDuplicate(pkt, s, d, c) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = (_SHIFTL(A_DUPLICATE, 24, 8) | \ + _SHIFTL(c, 16, 8) | _SHIFTL(s, 0, 16)); \ + _a->words.w1 = (_SHIFTL(d, 16, 16) | _SHIFTL(0x80, 0, 16)); \ +} + +/* + * Copies memory in DMEM, second version. + * + * Copies t * c bytes from address i to address o. + * + * Note: count is first rounded up to the nearest multiple of 32 bytes, + * before the multiplication by t. + * + * Note: This acts as memcpy where 32 bytes are moved at a time, therefore + * if input and output overlap, output address should be less than input address. + * + * Not used in SM64. + */ +#define aDMEMMove2(pkt, t, i, o, c) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = _SHIFTL(A_DMEMMOVE2, 24, 8) | \ + _SHIFTL(t, 16, 8) | _SHIFTL(i, 0, 16); \ + _a->words.w1 = _SHIFTL(o, 16, 16) | _SHIFTL(c, 0, 16); \ +} + +/* + * Fast resample. + * + * Before this command, call: + * aSetBuffer(cmd++, 0, in, out, count) + * + * This works like the other resample command but just takes the "nearest" sample, + * instead of a function of the four nearest samples. + * + * Initially the current position is calculated as (in << 16) + startFract. + * For every sample to create, the value is simply taken from the sample + * at address ((position >> 17) << 1). Then the current position is incremented + * by (pitch << 2). + * + * Note: count represents the number of output bytes to create, and is + * rounded up to the nearest multiple of 8 bytes. + */ +#define aResampleZoh(pkt, pitch, startFract) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = (_SHIFTL(A_RESAMPLE_ZOH, 24, 8) | \ + _SHIFTL(pitch, 0, 16)); \ + _a->words.w1 = _SHIFTL(startFract, 0, 16); \ +} + +/* + * Fast downsampling by taking every other sample, discarding others. + * + * Note: nSamples refers to the number of output samples to create, and + * is first rounded up to the nearest multiple of 8. + */ +#define aDownsampleHalf(pkt, nSamples, i, o) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = (_SHIFTL(A_DOWNSAMPLE_HALF, 24, 8) | \ + _SHIFTL(nSamples, 0, 16)); \ + _a->words.w1 = _SHIFTL(i, 16, 16) | _SHIFTL(o, 0, 16); \ +} + +/* + * Mixes audio. + * + * Input and output addresses are taken from the i and o parameters. + * The volume with which the input is changed is taken from the g parameter. + * After the volume of the input samples have been changed, the result + * is added to the output. + * + * Note: count is first rounded down to the nearest multiple of 16 bytes + * and then rounded up to the nearest multiple of 32 bytes. + */ +#define aMix(pkt, g, i, o, c) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = (_SHIFTL(A_MIXER, 24, 8) | \ + _SHIFTL((c) >> 4, 16, 8) | _SHIFTL(g, 0, 16)); \ + _a->words.w1 = _SHIFTL(i, 16, 16) | _SHIFTL(o, 0, 16); \ +} + +/* + * See aEnvMixer for more info. + */ +#define aEnvSetup1(pkt, initialVolReverb, rampReverb, rampLeft, rampRight) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = (_SHIFTL(A_ENVSETUP1, 24, 8) | \ + _SHIFTL(initialVolReverb, 16, 8) | \ + _SHIFTL(rampReverb, 0, 16)); \ + _a->words.w1 = _SHIFTL(rampLeft, 16, 16) | \ + _SHIFTL(rampRight, 0, 16); \ +} + +/* + * See aEnvMixer for more info. + */ +#define aEnvSetup2(pkt, initialVolLeft, initialVolRight) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = _SHIFTL(A_ENVSETUP2, 24, 8); \ + _a->words.w1 = _SHIFTL(initialVolLeft, 16, 16) | \ + _SHIFTL(initialVolRight, 0, 16); \ +} + +/* + * Mixes an envelope with mono sound into 4 channels. + * + * To allow for many parameters, a sequence of aEnvSetup1, aEnvSetup2, + * aEnvMixer shall always be called. + * + * The function works in blocks of 8 samples. + * However, nSamples is rounded up to the nearest multiple of 16 samples. + * + * For each sample in a block: + * 1. sampleLeft = in * volLeft * (negLeft ? -1 : 1) + * 2. sampleRight = in * volRight * (negRight ? -1 : 1) + * 3. dryLeft += sampleLeft + * 4. dryRight += sampleRight + * 5. if swapReverb: swap sampleLeft and sampleRight + * 6. wetLeft += sampleLeft * volReverb + * 7. wetRight += sampleRight * volReverb + * + * After each block, all vol variables are added by their corresponding + * ramp value. + * + * Each volume variable is treated as a UQ0.16 number. Make sure + * the ramp additions don't overflow, or wrapping will occur. + * The initialVolReverb parameter is only 8 bits, but will be left + * shifted 8 bits by the rsp. + */ +#define aEnvMixer(pkt, inBuf, nSamples, swapReverb, negLeft, negRight, \ + dryLeft, dryRight, wetLeft, wetRight) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = (_SHIFTL(A_ENVMIXER, 24, 8) | \ + _SHIFTL((inBuf) >> 4, 16, 8) | \ + _SHIFTL(nSamples, 8, 8)) | \ + _SHIFTL(swapReverb, 2, 1) | _SHIFTL(negLeft, 1, 1) |\ + _SHIFTL(negRight, 0, 1); \ + _a->words.w1 = _SHIFTL((dryLeft) >> 4, 24, 8) | \ + _SHIFTL((dryRight) >> 4, 16, 8) | \ + _SHIFTL((wetLeft) >> 4, 8, 8) | \ + _SHIFTL((wetRight) >> 4, 0, 8); \ +} + +/* + * Interleaves two mono channels into stereo. + * + * The count refers to the size of each input. Hence 2 * count bytes + * will be written out. + * + * A left sample will be placed before the right sample. + * All addresses (output, left, right) are DMEM addresses. + * + * Note: count will be rounded up to the nearest multiple of 8 bytes. + * The previous version of this function rounded up to the nearest + * multiple of 16 bytes. + */ +#define aInterleave(pkt, o, l, r, c) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = _SHIFTL(A_INTERLEAVE, 24, 8) | \ + _SHIFTL((c) >> 4, 16, 8) | _SHIFTL(o, 0, 16); \ + _a->words.w1 = _SHIFTL(l, 16, 16) | _SHIFTL(r, 0, 16); \ +} + +/* + * Linear filter function. + * + * Calculates out[i] = sum all elements in the vector in[i..i-7] * filter[0..7], + * where "*" represents dot multiplication. The input/output contains s16 + * samples and filter contains Q1.15 signed fixed point numbers. + * Every result sample is rounded and clamped. + * + * First initiate by calling with the flag f set to 2, countOrBuf contains + * the length in bytes that shall be processed in the next call. The addr + * parameter shall contain the DRAM address to the filter table (16 bytes). + * The count will be rounded up to the nearest multiple of 16 bytes. + * + * The aFilter function shall then be called in direct succession, with flag + * set to either 0 or 1. The countOrBuf parameter shall contain the DMEM + * address for the input/output. The addr parameter shall contain the DRAM + * address for the state, containing the last previous 8 input samples. + * The state is always written to upon exit, but is only read at entry if + * the flag is 0 (otherwise all-zero samples are used instead). + */ +#define aFilter(pkt, f, countOrBuf, addr) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = _SHIFTL(A_FILTER, 24, 8) | _SHIFTL((f), 16, 8) | \ + _SHIFTL((countOrBuf), 0, 16); \ + _a->words.w1 = (uintptr_t)(addr); \ +} + +/* + * Modifies the volume of samples using a simple UQ4.4 gain multiplier. + * + * Performs the following: + * + * 1. Count c is rounded up to 32 byte alignment + * 2. g is a u8 that contains a UQ4.4 number + * 3. Modify each sample s, so that s = clamp_s16(s * g >> 4) + */ +#define aHiLoGain(pkt, g, buflen, i) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = _SHIFTL(A_HILOGAIN, 24, 8) | \ + _SHIFTL((g), 16, 8) | _SHIFTL((buflen), 0, 16); \ + _a->words.w1 = _SHIFTL((i), 16, 16); \ +} + +/* + * Performs the following: + * + * 1. Count c is rounded up to 64 byte alignment + * 2. f is added to i + * 3. i and o are from now treated as s16 pointers + * 4. 32 s16 samples are loaded from i to tbl + * 5. for (u32 idx = 0; idx * sizeof(s16) < c; idx++) + * o[idx] = clamp_s16((s32)o[idx] * (s32)tbl[idx % 32]); + */ +#define aUnknown25(pkt, f, c, o, i) \ +{ \ + Acmd *_a = (Acmd *)pkt; \ + \ + _a->words.w0 = (_SHIFTL(A_UNK_25, 24, 8) | \ + _SHIFTL((f), 16, 8) | _SHIFTL((c), 0, 16)); \ + _a->words.w1 = _SHIFTL((o), 16, 16) | _SHIFTL((i), 0, 16); \ +} + +#endif + +#endif /* _LANGUAGE_C */ + +#endif /* !_ABI_H_ */ diff --git a/src/decomp/include/PR/libaudio.h b/src/decomp/include/PR/libaudio.h new file mode 100644 index 0000000..cb7a5b1 --- /dev/null +++ b/src/decomp/include/PR/libaudio.h @@ -0,0 +1,51 @@ +#ifndef _ULTRA64_LIBAUDIO_H_ +#define _ULTRA64_LIBAUDIO_H_ + +#include "abi.h" + +typedef struct +{ + u8 *offset; + s32 len; +#ifdef VERSION_SH + s8 medium; + s8 magic; // tbl: 0x04, otherwise: 0x03 + + // for ctl (else zeros): + union { + // unused, just for clarification (big endian) + struct { + u8 bank; + u8 ff; + u8 numInstruments; + u8 numDrums; + } as_u8; + + // used + struct { + s16 bankAndFf; + s16 numInstrumentsAndDrums; + } as_s16; + } ctl; +#endif +} ALSeqData; + +typedef struct +{ +#ifndef VERSION_SH + s16 revision; +#endif + s16 seqCount; +#ifdef VERSION_SH + s16 unk2; + u8 *data; +#if !IS_64_BIT + s32 pad[2]; +#endif +#endif + ALSeqData seqArray[1]; +} ALSeqFile; + +void alSeqFileNew(ALSeqFile *f, u8 *base); + +#endif diff --git a/src/decomp/include/PR/libultra.h b/src/decomp/include/PR/libultra.h new file mode 100644 index 0000000..f0dab41 --- /dev/null +++ b/src/decomp/include/PR/libultra.h @@ -0,0 +1,18 @@ +#ifndef _LIBULTRA_H +#define _LIBULTRA_H + +#define TV_TYPE_NTSC 1 +#define TV_TYPE_PAL 0 +#define TV_TYPE_MPAL 2 + +#define RESET_TYPE_COLD_RESET 0 +#define RESET_TYPE_NMI 1 +#define RESET_TYPE_BOOT_DISK 2 + +extern u32 osTvType; +extern u32 osRomBase; +extern u32 osResetType; +extern u32 osMemSize; +extern u8 osAppNmiBuffer[64]; + +#endif /* _LIBULTRA_H */ diff --git a/src/decomp/include/PR/os.h b/src/decomp/include/PR/os.h new file mode 100644 index 0000000..c8de719 --- /dev/null +++ b/src/decomp/include/PR/os.h @@ -0,0 +1,800 @@ + +/*==================================================================== + * os.h + * + * Copyright 1995, Silicon Graphics, Inc. + * All Rights Reserved. + * + * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, + * Inc.; the contents of this file may not be disclosed to third + * parties, copied or duplicated in any form, in whole or in part, + * without the prior written permission of Silicon Graphics, Inc. + * + * RESTRICTED RIGHTS LEGEND: + * Use, duplication or disclosure by the Government is subject to + * restrictions as set forth in subdivision (c)(1)(ii) of the Rights + * in Technical Data and Computer Software clause at DFARS + * 252.227-7013, and/or in similar or successor clauses in the FAR, + * DOD or NASA FAR Supplement. Unpublished - rights reserved under the + * Copyright Laws of the United States. + *====================================================================*/ + +/************************************************************************** + * + * $Revision: 1.149 $ + * $Date: 1997/12/15 04:30:52 $ + * $Source: /disk6/Master/cvsmdev2/PR/include/os.h,v $ + * + **************************************************************************/ + + +#ifndef _OS_H_ +#define _OS_H_ + +#ifdef _LANGUAGE_C_PLUS_PLUS +extern "C" { +#endif + +#include "ultratypes.h" +#include "PR/os_message.h" + +#if defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) + +/************************************************************************** + * + * Type definitions + * + */ + +/* + * Structure for device manager block + */ +typedef struct { + s32 active; /* Status flag */ + OSThread *thread; /* Calling thread */ + OSMesgQueue *cmdQueue; /* Command queue */ + OSMesgQueue *evtQueue; /* Event queue */ + OSMesgQueue *acsQueue; /* Access queue */ + /* Raw DMA routine */ + s32 (*dma)(s32, u32, void *, u32); + s32 (*edma)(OSPiHandle *, s32, u32, void *, u32); +} OSDevMgr; + +/* + * Structure for file system + */ + + + +typedef struct { + int status; + OSMesgQueue *queue; + int channel; + u8 id[32]; + u8 label[32]; + int version; + int dir_size; + int inode_table; /* block location */ + int minode_table; /* mirrioring inode_table */ + int dir_table; /* block location */ + int inode_start_page; /* page # */ + u8 banks; + u8 activebank; +} OSPfs; + + +typedef struct { + u32 file_size; /* bytes */ + u32 game_code; + u16 company_code; + char ext_name[4]; + char game_name[16]; +} OSPfsState; + +/* + * Structure for Profiler + */ +typedef struct { + u16 *histo_base; /* histogram base */ + u32 histo_size; /* histogram size */ + u32 *text_start; /* start of text segment */ + u32 *text_end; /* end of text segment */ +} OSProf; + +#endif /* defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) */ + +/************************************************************************** + * + * Global definitions + * + */ + +/* Thread states */ + +#define OS_STATE_STOPPED 1 +#define OS_STATE_RUNNABLE 2 +#define OS_STATE_RUNNING 4 +#define OS_STATE_WAITING 8 + +/* Events */ +#ifdef _FINALROM +#define OS_NUM_EVENTS 15 +#else +#define OS_NUM_EVENTS 23 +#endif + +#define OS_EVENT_SW1 0 /* CPU SW1 interrupt */ +#define OS_EVENT_SW2 1 /* CPU SW2 interrupt */ +#define OS_EVENT_CART 2 /* Cartridge interrupt: used by rmon */ +#define OS_EVENT_COUNTER 3 /* Counter int: used by VI/Timer Mgr */ +#define OS_EVENT_SP 4 /* SP task done interrupt */ +#define OS_EVENT_SI 5 /* SI (controller) interrupt */ +#define OS_EVENT_AI 6 /* AI interrupt */ +#define OS_EVENT_VI 7 /* VI interrupt: used by VI/Timer Mgr */ +#define OS_EVENT_PI 8 /* PI interrupt: used by PI Manager */ +#define OS_EVENT_DP 9 /* DP full sync interrupt */ +#define OS_EVENT_CPU_BREAK 10 /* CPU breakpoint: used by rmon */ +#define OS_EVENT_SP_BREAK 11 /* SP breakpoint: used by rmon */ +#define OS_EVENT_FAULT 12 /* CPU fault event: used by rmon */ +#define OS_EVENT_THREADSTATUS 13 /* CPU thread status: used by rmon */ +#define OS_EVENT_PRENMI 14 /* Pre NMI interrupt */ +#ifndef _FINALROM +#define OS_EVENT_RDB_READ_DONE 15 /* RDB read ok event: used by rmon */ +#define OS_EVENT_RDB_LOG_DONE 16 /* read of log data complete */ +#define OS_EVENT_RDB_DATA_DONE 17 /* read of hostio data complete */ +#define OS_EVENT_RDB_REQ_RAMROM 18 /* host needs ramrom access */ +#define OS_EVENT_RDB_FREE_RAMROM 19 /* host is done with ramrom access */ +#define OS_EVENT_RDB_DBG_DONE 20 +#define OS_EVENT_RDB_FLUSH_PROF 21 +#define OS_EVENT_RDB_ACK_PROF 22 +#endif + +/* Flags for debugging purpose */ + +#define OS_FLAG_CPU_BREAK 1 /* Break exception has occurred */ +#define OS_FLAG_FAULT 2 /* CPU fault has occurred */ + +/* Interrupt masks */ + +#define OS_IM_NONE 0x00000001 +#define OS_IM_SW1 0x00000501 +#define OS_IM_SW2 0x00000601 +#define OS_IM_CART 0x00000c01 +#define OS_IM_PRENMI 0x00001401 +#define OS_IM_RDBWRITE 0x00002401 +#define OS_IM_RDBREAD 0x00004401 +#define OS_IM_COUNTER 0x00008401 +#define OS_IM_CPU 0x0000ff01 +#define OS_IM_SP 0x00010401 +#define OS_IM_SI 0x00020401 +#define OS_IM_AI 0x00040401 +#define OS_IM_VI 0x00080401 +#define OS_IM_PI 0x00100401 +#define OS_IM_DP 0x00200401 +#define OS_IM_ALL 0x003fff01 +#define RCP_IMASK 0x003f0000 +#define RCP_IMASKSHIFT 16 + +/* Recommended thread priorities for the system threads */ + +#define OS_PRIORITY_MAX 255 +#define OS_PRIORITY_VIMGR 254 +#define OS_PRIORITY_RMON 250 +#define OS_PRIORITY_RMONSPIN 200 +#define OS_PRIORITY_PIMGR 150 +#define OS_PRIORITY_SIMGR 140 +#define OS_PRIORITY_APPMAX 127 +#define OS_PRIORITY_IDLE 0 /* Must be 0 */ + + +/* Flags to turn blocking on/off when sending/receiving message */ + +#define OS_MESG_NOBLOCK 0 +#define OS_MESG_BLOCK 1 + +/* Flags to indicate direction of data transfer */ + +#define OS_READ 0 /* device -> RDRAM */ +#define OS_WRITE 1 /* device <- RDRAM */ +#define OS_OTHERS 2 /* for Leo disk only */ + +/* + * I/O message types + */ +#define OS_MESG_TYPE_BASE (10) +#define OS_MESG_TYPE_LOOPBACK (OS_MESG_TYPE_BASE+0) +#define OS_MESG_TYPE_DMAREAD (OS_MESG_TYPE_BASE+1) +#define OS_MESG_TYPE_DMAWRITE (OS_MESG_TYPE_BASE+2) +#define OS_MESG_TYPE_VRETRACE (OS_MESG_TYPE_BASE+3) +#define OS_MESG_TYPE_COUNTER (OS_MESG_TYPE_BASE+4) +#define OS_MESG_TYPE_EDMAREAD (OS_MESG_TYPE_BASE+5) +#define OS_MESG_TYPE_EDMAWRITE (OS_MESG_TYPE_BASE+6) + +/* + * I/O message priority + */ +#define OS_MESG_PRI_NORMAL 0 +#define OS_MESG_PRI_HIGH 1 + +/* + * Page size argument for TLB routines + */ +#define OS_PM_4K 0x0000000 +#define OS_PM_16K 0x0006000 +#define OS_PM_64K 0x001e000 +#define OS_PM_256K 0x007e000 +#define OS_PM_1M 0x01fe000 +#define OS_PM_4M 0x07fe000 +#define OS_PM_16M 0x1ffe000 + +/* + * Stack size for I/O device managers: PIM (PI Manager), VIM (VI Manager), + * SIM (SI Manager) + * + */ +#define OS_PIM_STACKSIZE 4096 +#define OS_VIM_STACKSIZE 4096 +#define OS_SIM_STACKSIZE 4096 + +#define OS_MIN_STACKSIZE 72 + +/* + * Values for osTvType + */ +#define OS_TV_PAL 0 +#define OS_TV_NTSC 1 +#define OS_TV_MPAL 2 + +/* + * Video Interface (VI) mode type + */ +#define OS_VI_NTSC_LPN1 0 /* NTSC */ +#define OS_VI_NTSC_LPF1 1 +#define OS_VI_NTSC_LAN1 2 +#define OS_VI_NTSC_LAF1 3 +#define OS_VI_NTSC_LPN2 4 +#define OS_VI_NTSC_LPF2 5 +#define OS_VI_NTSC_LAN2 6 +#define OS_VI_NTSC_LAF2 7 +#define OS_VI_NTSC_HPN1 8 +#define OS_VI_NTSC_HPF1 9 +#define OS_VI_NTSC_HAN1 10 +#define OS_VI_NTSC_HAF1 11 +#define OS_VI_NTSC_HPN2 12 +#define OS_VI_NTSC_HPF2 13 + +#define OS_VI_PAL_LPN1 14 /* PAL */ +#define OS_VI_PAL_LPF1 15 +#define OS_VI_PAL_LAN1 16 +#define OS_VI_PAL_LAF1 17 +#define OS_VI_PAL_LPN2 18 +#define OS_VI_PAL_LPF2 19 +#define OS_VI_PAL_LAN2 20 +#define OS_VI_PAL_LAF2 21 +#define OS_VI_PAL_HPN1 22 +#define OS_VI_PAL_HPF1 23 +#define OS_VI_PAL_HAN1 24 +#define OS_VI_PAL_HAF1 25 +#define OS_VI_PAL_HPN2 26 +#define OS_VI_PAL_HPF2 27 + +#define OS_VI_MPAL_LPN1 28 /* MPAL - mainly Brazil */ +#define OS_VI_MPAL_LPF1 29 +#define OS_VI_MPAL_LAN1 30 +#define OS_VI_MPAL_LAF1 31 +#define OS_VI_MPAL_LPN2 32 +#define OS_VI_MPAL_LPF2 33 +#define OS_VI_MPAL_LAN2 34 +#define OS_VI_MPAL_LAF2 35 +#define OS_VI_MPAL_HPN1 36 +#define OS_VI_MPAL_HPF1 37 +#define OS_VI_MPAL_HAN1 38 +#define OS_VI_MPAL_HAF1 39 +#define OS_VI_MPAL_HPN2 40 +#define OS_VI_MPAL_HPF2 41 + +/* + * Video Interface (VI) special features + */ +#define OS_VI_GAMMA_ON 0x0001 +#define OS_VI_GAMMA_OFF 0x0002 +#define OS_VI_GAMMA_DITHER_ON 0x0004 +#define OS_VI_GAMMA_DITHER_OFF 0x0008 +#define OS_VI_DIVOT_ON 0x0010 +#define OS_VI_DIVOT_OFF 0x0020 +#define OS_VI_DITHER_FILTER_ON 0x0040 +#define OS_VI_DITHER_FILTER_OFF 0x0080 + +/* + * Video Interface (VI) mode attribute bit + */ +#define OS_VI_BIT_NONINTERLACE 0x0001 /* lo-res */ +#define OS_VI_BIT_INTERLACE 0x0002 /* lo-res */ +#define OS_VI_BIT_NORMALINTERLACE 0x0004 /* hi-res */ +#define OS_VI_BIT_DEFLICKINTERLACE 0x0008 /* hi-res */ +#define OS_VI_BIT_ANTIALIAS 0x0010 +#define OS_VI_BIT_POINTSAMPLE 0x0020 +#define OS_VI_BIT_16PIXEL 0x0040 +#define OS_VI_BIT_32PIXEL 0x0080 +#define OS_VI_BIT_LORES 0x0100 +#define OS_VI_BIT_HIRES 0x0200 +#define OS_VI_BIT_NTSC 0x0400 +#define OS_VI_BIT_PAL 0x0800 + +/* + * Leo Disk + */ + +/* transfer mode */ + +#define LEO_BLOCK_MODE 1 +#define LEO_TRACK_MODE 2 +#define LEO_SECTOR_MODE 3 + +/* + * Controllers number + */ + +#ifndef _HW_VERSION_1 +#define MAXCONTROLLERS 4 +#else +#define MAXCONTROLLERS 6 +#endif + +/* controller errors */ +#define CONT_NO_RESPONSE_ERROR 0x8 +#define CONT_OVERRUN_ERROR 0x4 +#ifdef _HW_VERSION_1 +#define CONT_FRAME_ERROR 0x2 +#define CONT_COLLISION_ERROR 0x1 +#endif + +/* Controller type */ + +#define CONT_ABSOLUTE 0x0001 +#define CONT_RELATIVE 0x0002 +#define CONT_JOYPORT 0x0004 +#define CONT_EEPROM 0x8000 +#define CONT_EEP16K 0x4000 +#define CONT_TYPE_MASK 0x1f07 +#define CONT_TYPE_NORMAL 0x0005 +#define CONT_TYPE_MOUSE 0x0002 + +/* Controller status */ + +#define CONT_CARD_ON 0x01 +#define CONT_CARD_PULL 0x02 +#define CONT_ADDR_CRC_ER 0x04 +#define CONT_EEPROM_BUSY 0x80 + +/* EEPROM TYPE */ + +#define EEPROM_TYPE_4K 0x01 +#define EEPROM_TYPE_16K 0x02 + +/* Buttons */ + +#define CONT_A 0x8000 +#define CONT_B 0x4000 +#define CONT_G 0x2000 +#define CONT_START 0x1000 +#define CONT_UP 0x0800 +#define CONT_DOWN 0x0400 +#define CONT_LEFT 0x0200 +#define CONT_RIGHT 0x0100 +#define CONT_L 0x0020 +#define CONT_R 0x0010 +#define CONT_E 0x0008 +#define CONT_D 0x0004 +#define CONT_C 0x0002 +#define CONT_F 0x0001 + +/* Nintendo's official button names */ + +#define A_BUTTON CONT_A +#define B_BUTTON CONT_B +#define L_TRIG CONT_L +#define R_TRIG CONT_R +#define Z_TRIG CONT_G +#define START_BUTTON CONT_START +#define U_JPAD CONT_UP +#define L_JPAD CONT_LEFT +#define R_JPAD CONT_RIGHT +#define D_JPAD CONT_DOWN +#define U_CBUTTONS CONT_E +#define L_CBUTTONS CONT_C +#define R_CBUTTONS CONT_F +#define D_CBUTTONS CONT_D + +/* File System size */ +#define OS_PFS_VERSION 0x0200 +#define OS_PFS_VERSION_HI (OS_PFS_VERSION >> 8) +#define OS_PFS_VERSION_LO (OS_PFS_VERSION & 255) + +#define PFS_FILE_NAME_LEN 16 +#define PFS_FILE_EXT_LEN 4 +#define BLOCKSIZE 32 /* bytes */ +#define PFS_ONE_PAGE 8 /* blocks */ +#define PFS_MAX_BANKS 62 + +/* File System flag */ + +#define PFS_READ 0 +#define PFS_WRITE 1 +#define PFS_CREATE 2 + +/* File System status */ +#define PFS_INITIALIZED 0x1 +#define PFS_CORRUPTED 0x2 /* File system was corrupted */ + +/* File System error number */ + +#define PFS_ERR_NOPACK 1 /* no memory card is plugged or */ +#define PFS_ERR_NEW_PACK 2 /* ram pack has been changed to a */ + /* different one */ +#define PFS_ERR_INCONSISTENT 3 /* need to run Pfschecker */ +#define PFS_ERR_CONTRFAIL CONT_OVERRUN_ERROR +#define PFS_ERR_INVALID 5 /* invalid parameter or file not exist*/ +#define PFS_ERR_BAD_DATA 6 /* the data read from pack are bad*/ +#define PFS_DATA_FULL 7 /* no free pages on ram pack */ +#define PFS_DIR_FULL 8 /* no free directories on ram pack*/ +#define PFS_ERR_EXIST 9 /* file exists */ +#define PFS_ERR_ID_FATAL 10 /* dead ram pack */ +#define PFS_ERR_DEVICE 11 /* wrong device type*/ + +/* definition for EEPROM */ + +#define EEPROM_MAXBLOCKS 64 +#define EEP16K_MAXBLOCKS 256 +#define EEPROM_BLOCK_SIZE 8 + +/* + * PI/EPI + */ +#define PI_DOMAIN1 0 +#define PI_DOMAIN2 1 + +/* + * Profiler constants + */ +#define PROF_MIN_INTERVAL 50 /* microseconds */ + +/* + * Boot addresses + */ +#define BOOT_ADDRESS_ULTRA 0x80000400 +#define BOOT_ADDRESS_COSIM 0x80002000 +#define BOOT_ADDRESS_EMU 0x20010000 +#define BOOT_ADDRESS_INDY 0x88100000 + +/* + * Size of buffer the retains contents after NMI + */ +#define OS_APP_NMI_BUFSIZE 64 + +#if defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) + +/************************************************************************** + * + * Macro definitions + * + */ + +/* PARTNER-N64 */ +#ifdef PTN64 +#define osReadHost osReadHost_pt +#define osWriteHost osWriteHost_pt +#endif + +/* Get count of valid messages in queue */ +#define MQ_GET_COUNT(mq) ((mq)->validCount) + +/* Figure out if message queue is empty or full */ +#define MQ_IS_EMPTY(mq) (MQ_GET_COUNT(mq) == 0) +#define MQ_IS_FULL(mq) (MQ_GET_COUNT(mq) >= (mq)->msgCount) + +/* + * CPU counter increments at 3/4 of bus clock rate: + * + * Bus Clock Proc Clock Counter (1/2 Proc Clock) + * --------- ---------- ------------------------ + * 62.5 Mhz 93.75 Mhz 46.875 Mhz + */ +extern u64 osClockRate; + +#define OS_CLOCK_RATE 62500000LL +#define OS_CPU_COUNTER (OS_CLOCK_RATE*3/4) +#define OS_NSEC_TO_CYCLES(n) (((u64)(n)*(OS_CPU_COUNTER/15625000LL))/(1000000000LL/15625000LL)) +#define OS_USEC_TO_CYCLES(n) (((u64)(n)*(OS_CPU_COUNTER/15625LL))/(1000000LL/15625LL)) +#define OS_CYCLES_TO_NSEC(c) (((u64)(c)*(1000000000LL/15625000LL))/(OS_CPU_COUNTER/15625000LL)) +#define OS_CYCLES_TO_USEC(c) (((u64)(c)*(1000000LL/15625LL))/(OS_CPU_COUNTER/15625LL)) + +/************************************************************************** + * + * Extern variables + * + */ +extern OSViMode osViModeTable[]; /* Global VI mode table */ + +extern OSViMode osViModeNtscLpn1; /* Individual VI NTSC modes */ +extern OSViMode osViModeNtscLpf1; +extern OSViMode osViModeNtscLan1; +extern OSViMode osViModeNtscLaf1; +extern OSViMode osViModeNtscLpn2; +extern OSViMode osViModeNtscLpf2; +extern OSViMode osViModeNtscLan2; +extern OSViMode osViModeNtscLaf2; +extern OSViMode osViModeNtscHpn1; +extern OSViMode osViModeNtscHpf1; +extern OSViMode osViModeNtscHan1; +extern OSViMode osViModeNtscHaf1; +extern OSViMode osViModeNtscHpn2; +extern OSViMode osViModeNtscHpf2; + +extern OSViMode osViModePalLpn1; /* Individual VI PAL modes */ +extern OSViMode osViModePalLpf1; +extern OSViMode osViModePalLan1; +extern OSViMode osViModePalLaf1; +extern OSViMode osViModePalLpn2; +extern OSViMode osViModePalLpf2; +extern OSViMode osViModePalLan2; +extern OSViMode osViModePalLaf2; +extern OSViMode osViModePalHpn1; +extern OSViMode osViModePalHpf1; +extern OSViMode osViModePalHan1; +extern OSViMode osViModePalHaf1; +extern OSViMode osViModePalHpn2; +extern OSViMode osViModePalHpf2; + +extern OSViMode osViModeMpalLpn1; /* Individual VI MPAL modes */ +extern OSViMode osViModeMpalLpf1; +extern OSViMode osViModeMpalLan1; +extern OSViMode osViModeMpalLaf1; +extern OSViMode osViModeMpalLpn2; +extern OSViMode osViModeMpalLpf2; +extern OSViMode osViModeMpalLan2; +extern OSViMode osViModeMpalLaf2; +extern OSViMode osViModeMpalHpn1; +extern OSViMode osViModeMpalHpf1; +extern OSViMode osViModeMpalHan1; +extern OSViMode osViModeMpalHaf1; +extern OSViMode osViModeMpalHpn2; +extern OSViMode osViModeMpalHpf2; + +extern s32 osRomType; /* Bulk or cartridge ROM. 0=cartridge 1=bulk */ +extern u32 osRomBase; /* Rom base address of the game image */ +extern u32 osTvType; /* 0 = PAL, 1 = NTSC, 2 = MPAL */ +extern u32 osResetType; /* 0 = cold reset, 1 = NMI */ +extern s32 osCicId; +extern s32 osVersion; +extern u32 osMemSize; /* Memory Size */ +extern s32 osAppNMIBuffer[]; + +extern OSIntMask __OSGlobalIntMask; /* global interrupt mask */ +extern OSPiHandle *__osPiTable; /* The head of OSPiHandle link list */ +extern OSPiHandle *__osDiskHandle; /* For exceptasm to get disk info*/ + + + +/************************************************************************** + * + * Function prototypes + * + */ + +/* Thread operations */ + +extern void osCreateThread(OSThread *, OSId, void (*)(void *), + void *, void *, OSPri); +extern void osDestroyThread(OSThread *); +extern void osYieldThread(void); +extern void osStartThread(OSThread *); +extern void osStopThread(OSThread *); +extern OSId osGetThreadId(OSThread *); +extern void osSetThreadPri(OSThread *, OSPri); +extern OSPri osGetThreadPri(OSThread *); + +/* Message operations */ + +extern void osCreateMesgQueue(OSMesgQueue *, OSMesg *, s32); +extern s32 osSendMesg(OSMesgQueue *, OSMesg, s32); +extern s32 osJamMesg(OSMesgQueue *, OSMesg, s32); +extern s32 osRecvMesg(OSMesgQueue *, OSMesg *, s32); + +/* Event operations */ + +extern void osSetEventMesg(OSEvent, OSMesgQueue *, OSMesg); + +/* Interrupt operations */ + +extern OSIntMask osGetIntMask(void); +extern OSIntMask osSetIntMask(OSIntMask); + +/* RDB port operations */ + +extern void osInitRdb(u8 *sendBuf, u32 sendSize); + +/* Cache operations and macros */ + +extern void osInvalDCache(void *, size_t); +extern void osInvalICache(void *, size_t); +extern void osWritebackDCache(void *, size_t); +extern void osWritebackDCacheAll(void); + +#define OS_DCACHE_ROUNDUP_ADDR(x) (void *)(((((u32)(x)+0xf)/0x10)*0x10)) +#define OS_DCACHE_ROUNDUP_SIZE(x) (u32)(((((u32)(x)+0xf)/0x10)*0x10)) + +/* TLB management routines */ + +extern void osMapTLB(s32, OSPageMask, void *, u32, u32, s32); +extern void osMapTLBRdb(void); +extern void osUnmapTLB(s32); +extern void osUnmapTLBAll(void); +extern void osSetTLBASID(s32); + +/* Address translation routines and macros */ + +extern u32 osVirtualToPhysical(void *); +extern void * osPhysicalToVirtual(u32); + +#define OS_K0_TO_PHYSICAL(x) (u32)(((char *)(x)-0x80000000)) +#define OS_K1_TO_PHYSICAL(x) (u32)(((char *)(x)-0xa0000000)) + +#define OS_PHYSICAL_TO_K0(x) (void *)(((u32)(x)+0x80000000)) +#define OS_PHYSICAL_TO_K1(x) (void *)(((u32)(x)+0xa0000000)) + +/* I/O operations */ + +/* Audio interface (Ai) */ +extern u32 osAiGetStatus(void); +extern u32 osAiGetLength(void); +extern s32 osAiSetFrequency(u32); +extern s32 osAiSetNextBuffer(void *, u32); + +/* Display processor interface (Dp) */ +extern u32 osDpGetStatus(void); +extern void osDpSetStatus(u32); +extern void osDpGetCounters(u32 *); +extern s32 osDpSetNextBuffer(void *, u64); + +/* Peripheral interface (Pi) */ +extern u32 osPiGetStatus(void); +extern s32 osPiGetDeviceType(void); +extern s32 osPiRawWriteIo(u32, u32); +extern s32 osPiRawReadIo(u32, u32 *); +extern s32 osPiRawStartDma(s32, u32, void *, u32); +extern s32 osPiWriteIo(u32, u32); +extern s32 osPiReadIo(u32, u32 *); +extern s32 osPiStartDma(OSIoMesg *, s32, s32, u32, void *, u32, + OSMesgQueue *); +extern void osCreatePiManager(OSPri, OSMesgQueue *, OSMesg *, s32); + +/* Video interface (Vi) */ +extern u32 osViGetStatus(void); +extern u32 osViGetCurrentMode(void); +extern u32 osViGetCurrentLine(void); +extern u32 osViGetCurrentField(void); +extern void *osViGetCurrentFramebuffer(void); +extern void *osViGetNextFramebuffer(void); +extern void osViSetXScale(f32); +extern void osViSetYScale(f32); +extern void osViSetSpecialFeatures(u32); +extern void osViSetMode(OSViMode *); +extern void osViSetEvent(OSMesgQueue *, OSMesg, u32); +extern void osViSwapBuffer(void *); +extern void osViBlack(u8); +extern void osViFade(u8, u16); +extern void osViRepeatLine(u8); +extern void osCreateViManager(OSPri); + +/* Timer interface */ + +extern OSTime osGetTime(void); +extern void osSetTime(OSTime); +extern u32 osSetTimer(OSTimer *, OSTime, OSTime, + OSMesgQueue *, OSMesg); +extern int osStopTimer(OSTimer *); + +/* Controller interface */ + +extern s32 osContInit(OSMesgQueue *, u8 *, OSContStatus *); +extern s32 osContReset(OSMesgQueue *, OSContStatus *); +extern s32 osContStartQuery(OSMesgQueue *); +extern s32 osContStartReadData(OSMesgQueue *); +#ifndef _HW_VERSION_1 +extern s32 osContSetCh(u8); +#endif +extern void osContGetQuery(OSContStatus *); +extern void osContGetReadData(OSContPad *); + +/* file system interface */ + +extern s32 osPfsInitPak(OSMesgQueue *, OSPfs *, int); +extern s32 osPfsRepairId(OSPfs *); +extern s32 osPfsInit(OSMesgQueue *, OSPfs *, int); +extern s32 osPfsReFormat(OSPfs *, OSMesgQueue *, int); +extern s32 osPfsChecker(OSPfs *); +extern s32 osPfsAllocateFile(OSPfs *, u16, u32, u8 *, u8 *, int, s32 *); +extern s32 osPfsFindFile(OSPfs *, u16, u32, u8 *, u8 *, s32 *); +extern s32 osPfsDeleteFile(OSPfs *, u16, u32, u8 *, u8 *); +extern s32 osPfsReadWriteFile(OSPfs *, s32, u8, int, int, u8 *); +extern s32 osPfsFileState(OSPfs *, s32, OSPfsState *); +extern s32 osPfsGetLabel(OSPfs *, u8 *, int *); +extern s32 osPfsSetLabel(OSPfs *, u8 *); +extern s32 osPfsIsPlug(OSMesgQueue *, u8 *); +extern s32 osPfsFreeBlocks(OSPfs *, s32 *); +extern s32 osPfsNumFiles(OSPfs *, s32 *, s32 *); + +/* EEPROM interface */ + +extern s32 osEepromProbe(OSMesgQueue *); +extern s32 osEepromRead(OSMesgQueue *, u8, u8 *); +extern s32 osEepromWrite(OSMesgQueue *, u8, u8 *); +extern s32 osEepromLongRead(OSMesgQueue *, u8, u8 *, int); +extern s32 osEepromLongWrite(OSMesgQueue *, u8, u8 *, int); + +/* MOTOR interface */ + +extern s32 osMotorInit(OSMesgQueue *, OSPfs *, int); +extern s32 osMotorStop(OSPfs *); +extern s32 osMotorStart(OSPfs *); + +/* Enhanced PI interface */ + +extern OSPiHandle *osCartRomInit(void); +extern OSPiHandle *osLeoDiskInit(void); +extern OSPiHandle *osDriveRomInit(void); + +extern s32 osEPiDeviceType(OSPiHandle *, OSPiInfo *); +extern s32 osEPiRawWriteIo(OSPiHandle *, u32 , u32); +extern s32 osEPiRawReadIo(OSPiHandle *, u32 , u32 *); +extern s32 osEPiRawStartDma(OSPiHandle *, s32 , u32 , void *, u32 ); +extern s32 osEPiWriteIo(OSPiHandle *, u32 , u32 ); +extern s32 osEPiReadIo(OSPiHandle *, u32 , u32 *); +extern s32 osEPiStartDma(OSPiHandle *, OSIoMesg *, s32); +extern s32 osEPiLinkHandle(OSPiHandle *); + +/* Profiler Interface */ + +extern void osProfileInit(OSProf *, u32 profcnt); +extern void osProfileStart(u32); +extern void osProfileFlush(void); +extern void osProfileStop(void); + +/* Game <> Host data transfer functions */ + +extern s32 osTestHost(void); +extern void osReadHost(void *, u32); +extern void osWriteHost(void *, u32); +extern void osAckRamromRead(void); +extern void osAckRamromWrite(void); + + +/* byte string operations */ + +extern void bcopy(const void *, void *, size_t); +extern int bcmp(const void *, const void *, int); +extern void bzero(void *, size_t); + +/* Miscellaneous operations */ + +extern void osInitialize(void); +extern u32 osGetCount(void); +extern void osExit(void); +extern u32 osGetMemSize(void); + +/* Printf */ + +extern int sprintf(char *s, const char *fmt, ...); +extern void osSyncPrintf(const char *fmt, ...); +extern void osAsyncPrintf(const char *fmt, ...); +extern int osSyncGetChars(char *buf); +extern int osAsyncGetChars(char *buf); + +#endif /* defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) */ + +#ifdef _LANGUAGE_C_PLUS_PLUS +} +#endif + +#endif /* !_OS_H */ diff --git a/src/decomp/include/PR/os_ai.h b/src/decomp/include/PR/os_ai.h new file mode 100644 index 0000000..b9df406 --- /dev/null +++ b/src/decomp/include/PR/os_ai.h @@ -0,0 +1,92 @@ + +/*==================================================================== + * os_ai.h + * + * Copyright 1995, Silicon Graphics, Inc. + * All Rights Reserved. + * + * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, + * Inc.; the contents of this file may not be disclosed to third + * parties, copied or duplicated in any form, in whole or in part, + * without the prior written permission of Silicon Graphics, Inc. + * + * RESTRICTED RIGHTS LEGEND: + * Use, duplication or disclosure by the Government is subject to + * restrictions as set forth in subdivision (c)(1)(ii) of the Rights + * in Technical Data and Computer Software clause at DFARS + * 252.227-7013, and/or in similar or successor clauses in the FAR, + * DOD or NASA FAR Supplement. Unpublished - rights reserved under the + * Copyright Laws of the United States. + *====================================================================*/ + +/*---------------------------------------------------------------------* + Copyright (C) 1998 Nintendo. (Originated by SGI) + + $RCSfile: os_ai.h,v $ + $Revision: 1.1 $ + $Date: 1998/10/09 08:01:04 $ + *---------------------------------------------------------------------*/ + +#ifndef _OS_AI_H_ +#define _OS_AI_H_ + +#ifdef _LANGUAGE_C_PLUS_PLUS +extern "C" { +#endif + +#include "ultratypes.h" + +#if defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) + +/************************************************************************** + * + * Type definitions + * + */ + + +#endif /* defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) */ + +/************************************************************************** + * + * Global definitions + * + */ + + +#if defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) + +/************************************************************************** + * + * Macro definitions + * + */ + + +/************************************************************************** + * + * Extern variables + * + */ + + +/************************************************************************** + * + * Function prototypes + * + */ + +/* Audio interface (Ai) */ +extern u32 osAiGetStatus(void); +extern u32 osAiGetLength(void); +extern s32 osAiSetFrequency(u32); +extern s32 osAiSetNextBuffer(void *, u32); + + +#endif /* defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) */ + +#ifdef _LANGUAGE_C_PLUS_PLUS +} +#endif + +#endif /* !_OS_AI_H_ */ diff --git a/src/decomp/include/PR/os_cache.h b/src/decomp/include/PR/os_cache.h new file mode 100644 index 0000000..e313840 --- /dev/null +++ b/src/decomp/include/PR/os_cache.h @@ -0,0 +1,96 @@ + +/*==================================================================== + * os_cache.h + * + * Copyright 1995, Silicon Graphics, Inc. + * All Rights Reserved. + * + * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, + * Inc.; the contents of this file may not be disclosed to third + * parties, copied or duplicated in any form, in whole or in part, + * without the prior written permission of Silicon Graphics, Inc. + * + * RESTRICTED RIGHTS LEGEND: + * Use, duplication or disclosure by the Government is subject to + * restrictions as set forth in subdivision (c)(1)(ii) of the Rights + * in Technical Data and Computer Software clause at DFARS + * 252.227-7013, and/or in similar or successor clauses in the FAR, + * DOD or NASA FAR Supplement. Unpublished - rights reserved under the + * Copyright Laws of the United States. + *====================================================================*/ + +/*---------------------------------------------------------------------* + Copyright (C) 1998 Nintendo. (Originated by SGI) + + $RCSfile: os_cache.h,v $ + $Revision: 1.1 $ + $Date: 1998/10/09 08:01:04 $ + *---------------------------------------------------------------------*/ + +#ifndef _OS_CACHE_H_ +#define _OS_CACHE_H_ + +#ifdef _LANGUAGE_C_PLUS_PLUS +extern "C" { +#endif + +#include "ultratypes.h" + +#if defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) + +/************************************************************************** + * + * Type definitions + * + */ + + +#endif /* defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) */ + +/************************************************************************** + * + * Global definitions + * + */ + + +#if defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) + +/************************************************************************** + * + * Macro definitions + * + */ + +#define OS_DCACHE_ROUNDUP_ADDR(x) (void *)(((((u32)(x)+0xf)/0x10)*0x10)) +#define OS_DCACHE_ROUNDUP_SIZE(x) (u32)(((((u32)(x)+0xf)/0x10)*0x10)) + + +/************************************************************************** + * + * Extern variables + * + */ + + +/************************************************************************** + * + * Function prototypes + * + */ + +/* Cache operations and macros */ + +extern void osInvalDCache(void *, size_t); +extern void osInvalICache(void *, size_t); +extern void osWritebackDCache(void *, size_t); +extern void osWritebackDCacheAll(void); + + +#endif /* defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) */ + +#ifdef _LANGUAGE_C_PLUS_PLUS +} +#endif + +#endif /* !_OS_CACHE_H_ */ diff --git a/src/decomp/include/PR/os_eeprom.h b/src/decomp/include/PR/os_eeprom.h new file mode 100644 index 0000000..2a03fb5 --- /dev/null +++ b/src/decomp/include/PR/os_eeprom.h @@ -0,0 +1,107 @@ + +/*==================================================================== + * os_eeprom.h + * + * Copyright 1995, Silicon Graphics, Inc. + * All Rights Reserved. + * + * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, + * Inc.; the contents of this file may not be disclosed to third + * parties, copied or duplicated in any form, in whole or in part, + * without the prior written permission of Silicon Graphics, Inc. + * + * RESTRICTED RIGHTS LEGEND: + * Use, duplication or disclosure by the Government is subject to + * restrictions as set forth in subdivision (c)(1)(ii) of the Rights + * in Technical Data and Computer Software clause at DFARS + * 252.227-7013, and/or in similar or successor clauses in the FAR, + * DOD or NASA FAR Supplement. Unpublished - rights reserved under the + * Copyright Laws of the United States. + *====================================================================*/ + +/*---------------------------------------------------------------------* + Copyright (C) 1998 Nintendo. (Originated by SGI) + + $RCSfile: os_eeprom.h,v $ + $Revision: 1.1 $ + $Date: 1998/10/09 08:01:06 $ + *---------------------------------------------------------------------*/ + +#ifndef _OS_EEPROM_H_ +#define _OS_EEPROM_H_ + +#ifdef _LANGUAGE_C_PLUS_PLUS +extern "C" { +#endif + +#include "ultratypes.h" +#include "os_message.h" + + +#if defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) + +/************************************************************************** + * + * Type definitions + * + */ + + +#endif /* defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) */ + +/************************************************************************** + * + * Global definitions + * + */ + +/* EEPROM TYPE */ + +#define EEPROM_TYPE_4K 0x01 +#define EEPROM_TYPE_16K 0x02 + +/* definition for EEPROM */ + +#define EEPROM_MAXBLOCKS 64 +#define EEP16K_MAXBLOCKS 256 +#define EEPROM_BLOCK_SIZE 8 + + +#if defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) + +/************************************************************************** + * + * Macro definitions + * + */ + + +/************************************************************************** + * + * Extern variables + * + */ + + +/************************************************************************** + * + * Function prototypes + * + */ + +/* EEPROM interface */ + +extern s32 osEepromProbe(OSMesgQueue *); +extern s32 osEepromRead(OSMesgQueue *, u8, u8 *); +extern s32 osEepromWrite(OSMesgQueue *, u8, u8 *); +extern s32 osEepromLongRead(OSMesgQueue *, u8, u8 *, int); +extern s32 osEepromLongWrite(OSMesgQueue *, u8, u8 *, int); + + +#endif /* defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) */ + +#ifdef _LANGUAGE_C_PLUS_PLUS +} +#endif + +#endif /* !_OS_EEPROM_H_ */ diff --git a/src/decomp/include/PR/os_exception.h b/src/decomp/include/PR/os_exception.h new file mode 100644 index 0000000..2750769 --- /dev/null +++ b/src/decomp/include/PR/os_exception.h @@ -0,0 +1,119 @@ + +/*==================================================================== + * os_exception.h + * + * Copyright 1995, Silicon Graphics, Inc. + * All Rights Reserved. + * + * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, + * Inc.; the contents of this file may not be disclosed to third + * parties, copied or duplicated in any form, in whole or in part, + * without the prior written permission of Silicon Graphics, Inc. + * + * RESTRICTED RIGHTS LEGEND: + * Use, duplication or disclosure by the Government is subject to + * restrictions as set forth in subdivision (c)(1)(ii) of the Rights + * in Technical Data and Computer Software clause at DFARS + * 252.227-7013, and/or in similar or successor clauses in the FAR, + * DOD or NASA FAR Supplement. Unpublished - rights reserved under the + * Copyright Laws of the United States. + *====================================================================*/ + +/*---------------------------------------------------------------------* + Copyright (C) 1998 Nintendo. (Originated by SGI) + + $RCSfile: os_exception.h,v $ + $Revision: 1.1 $ + $Date: 1998/10/09 08:01:07 $ + *---------------------------------------------------------------------*/ + +#ifndef _OS_EXCEPTION_H_ +#define _OS_EXCEPTION_H_ + +#ifdef _LANGUAGE_C_PLUS_PLUS +extern "C" { +#endif + +#include "ultratypes.h" + +#if defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) + +/************************************************************************** + * + * Type definitions + * + */ + +typedef u32 OSIntMask; +typedef u32 OSHWIntr; + +#endif /* defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) */ + +/************************************************************************** + * + * Global definitions + * + */ + +/* Flags for debugging purpose */ + +#define OS_FLAG_CPU_BREAK 1 /* Break exception has occurred */ +#define OS_FLAG_FAULT 2 /* CPU fault has occurred */ + +/* Interrupt masks */ + +#define OS_IM_NONE 0x00000001 +#define OS_IM_SW1 0x00000501 +#define OS_IM_SW2 0x00000601 +#define OS_IM_CART 0x00000c01 +#define OS_IM_PRENMI 0x00001401 +#define OS_IM_RDBWRITE 0x00002401 +#define OS_IM_RDBREAD 0x00004401 +#define OS_IM_COUNTER 0x00008401 +#define OS_IM_CPU 0x0000ff01 +#define OS_IM_SP 0x00010401 +#define OS_IM_SI 0x00020401 +#define OS_IM_AI 0x00040401 +#define OS_IM_VI 0x00080401 +#define OS_IM_PI 0x00100401 +#define OS_IM_DP 0x00200401 +#define OS_IM_ALL 0x003fff01 +#define RCP_IMASK 0x003f0000 +#define RCP_IMASKSHIFT 16 + + +#if defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) + +/************************************************************************** + * + * Macro definitions + * + */ + + +/************************************************************************** + * + * Extern variables + * + */ + + +/************************************************************************** + * + * Function prototypes + * + */ + +/* Interrupt operations */ + +extern OSIntMask osGetIntMask(void); +extern OSIntMask osSetIntMask(OSIntMask); + + +#endif /* defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) */ + +#ifdef _LANGUAGE_C_PLUS_PLUS +} +#endif + +#endif /* !_OS_EXCEPTION_H_ */ diff --git a/src/decomp/include/PR/os_internal.h b/src/decomp/include/PR/os_internal.h new file mode 100644 index 0000000..f07f5b7 --- /dev/null +++ b/src/decomp/include/PR/os_internal.h @@ -0,0 +1,19 @@ +#ifndef _ULTRA64_OS_INTERNAL_H_ +#define _ULTRA64_OS_INTERNAL_H_ +#include "os_message.h" + +/* Internal functions used by the operating system */ +/* Do not include this header in application code */ + +/* Variables */ + +//extern u64 osClockRate; + +/* Functions */ + +/*u32 __osProbeTLB(void *); +u32 __osDisableInt(void); +void __osRestoreInt(u32);*/ +OSThread *__osGetCurrFaultedThread(void); + +#endif diff --git a/src/decomp/include/PR/os_libc.h b/src/decomp/include/PR/os_libc.h new file mode 100644 index 0000000..94111c0 --- /dev/null +++ b/src/decomp/include/PR/os_libc.h @@ -0,0 +1,10 @@ +#ifndef _OS_LIBC_H_ +#define _OS_LIBC_H_ + +#include "ultratypes.h" + +// Old deprecated functions from strings.h, replaced by memcpy/memset. +extern void bcopy(const void *, void *, size_t); +extern void bzero(void *, size_t); + +#endif /* !_OS_LIBC_H_ */ diff --git a/src/decomp/include/PR/os_message.h b/src/decomp/include/PR/os_message.h new file mode 100644 index 0000000..51396c0 --- /dev/null +++ b/src/decomp/include/PR/os_message.h @@ -0,0 +1,164 @@ + +/*==================================================================== + * os_message.h + * + * Copyright 1995, Silicon Graphics, Inc. + * All Rights Reserved. + * + * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, + * Inc.; the contents of this file may not be disclosed to third + * parties, copied or duplicated in any form, in whole or in part, + * without the prior written permission of Silicon Graphics, Inc. + * + * RESTRICTED RIGHTS LEGEND: + * Use, duplication or disclosure by the Government is subject to + * restrictions as set forth in subdivision (c)(1)(ii) of the Rights + * in Technical Data and Computer Software clause at DFARS + * 252.227-7013, and/or in similar or successor clauses in the FAR, + * DOD or NASA FAR Supplement. Unpublished - rights reserved under the + * Copyright Laws of the United States. + *====================================================================*/ + +/*---------------------------------------------------------------------* + Copyright (C) 1998 Nintendo. (Originated by SGI) + + $RCSfile: os_message.h,v $ + $Revision: 1.1 $ + $Date: 1998/10/09 08:01:15 $ + *---------------------------------------------------------------------*/ + +#ifndef _OS_MESSAGE_H_ +#define _OS_MESSAGE_H_ + +#ifdef _LANGUAGE_C_PLUS_PLUS +extern "C" { +#endif + +#include "ultratypes.h" +#include "os_thread.h" + +#if defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) + +/************************************************************************** + * + * Type definitions + * + */ + +typedef u32 OSEvent; + +/* + * Structure for message + */ +typedef void * OSMesg; + +/* + * Structure for message queue + */ +typedef struct OSMesgQueue_s { + OSThread *mtqueue; /* Queue to store threads blocked + on empty mailboxes (receive) */ + OSThread *fullqueue; /* Queue to store threads blocked + on full mailboxes (send) */ + s32 validCount; /* Contains number of valid message */ + s32 first; /* Points to first valid message */ + s32 msgCount; /* Contains total # of messages */ + OSMesg *msg; /* Points to message buffer array */ +} OSMesgQueue; + + +#endif /* defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) */ + +/************************************************************************** + * + * Global definitions + * + */ + +/* Events */ +#ifdef _FINALROM +#define OS_NUM_EVENTS 15 +#else +#define OS_NUM_EVENTS 23 +#endif + +#define OS_EVENT_SW1 0 /* CPU SW1 interrupt */ +#define OS_EVENT_SW2 1 /* CPU SW2 interrupt */ +#define OS_EVENT_CART 2 /* Cartridge interrupt: used by rmon */ +#define OS_EVENT_COUNTER 3 /* Counter int: used by VI/Timer Mgr */ +#define OS_EVENT_SP 4 /* SP task done interrupt */ +#define OS_EVENT_SI 5 /* SI (controller) interrupt */ +#define OS_EVENT_AI 6 /* AI interrupt */ +#define OS_EVENT_VI 7 /* VI interrupt: used by VI/Timer Mgr */ +#define OS_EVENT_PI 8 /* PI interrupt: used by PI Manager */ +#define OS_EVENT_DP 9 /* DP full sync interrupt */ +#define OS_EVENT_CPU_BREAK 10 /* CPU breakpoint: used by rmon */ +#define OS_EVENT_SP_BREAK 11 /* SP breakpoint: used by rmon */ +#define OS_EVENT_FAULT 12 /* CPU fault event: used by rmon */ +#define OS_EVENT_THREADSTATUS 13 /* CPU thread status: used by rmon */ +#define OS_EVENT_PRENMI 14 /* Pre NMI interrupt */ +#ifndef _FINALROM +#define OS_EVENT_RDB_READ_DONE 15 /* RDB read ok event: used by rmon */ +#define OS_EVENT_RDB_LOG_DONE 16 /* read of log data complete */ +#define OS_EVENT_RDB_DATA_DONE 17 /* read of hostio data complete */ +#define OS_EVENT_RDB_REQ_RAMROM 18 /* host needs ramrom access */ +#define OS_EVENT_RDB_FREE_RAMROM 19 /* host is done with ramrom access */ +#define OS_EVENT_RDB_DBG_DONE 20 +#define OS_EVENT_RDB_FLUSH_PROF 21 +#define OS_EVENT_RDB_ACK_PROF 22 +#endif + +/* Flags to turn blocking on/off when sending/receiving message */ + +#define OS_MESG_NOBLOCK 0 +#define OS_MESG_BLOCK 1 + + +#if defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) + +/************************************************************************** + * + * Macro definitions + * + */ + +/* Get count of valid messages in queue */ +#define MQ_GET_COUNT(mq) ((mq)->validCount) + +/* Figure out if message queue is empty or full */ +#define MQ_IS_EMPTY(mq) (MQ_GET_COUNT(mq) == 0) +#define MQ_IS_FULL(mq) (MQ_GET_COUNT(mq) >= (mq)->msgCount) + + +/************************************************************************** + * + * Extern variables + * + */ + + +/************************************************************************** + * + * Function prototypes + * + */ + +/* Message operations */ + +extern void osCreateMesgQueue(OSMesgQueue *, OSMesg *, s32); +extern s32 osSendMesg(OSMesgQueue *, OSMesg, s32); +extern s32 osJamMesg(OSMesgQueue *, OSMesg, s32); +extern s32 osRecvMesg(OSMesgQueue *, OSMesg *, s32); + +/* Event operations */ + +extern void osSetEventMesg(OSEvent, OSMesgQueue *, OSMesg); + + +#endif /* defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) */ + +#ifdef _LANGUAGE_C_PLUS_PLUS +} +#endif + +#endif /* !_OS_MESSAGE_H_ */ diff --git a/src/decomp/include/PR/os_misc.h b/src/decomp/include/PR/os_misc.h new file mode 100644 index 0000000..eb0c793 --- /dev/null +++ b/src/decomp/include/PR/os_misc.h @@ -0,0 +1,11 @@ +#ifndef _ULTRA64_OS_MISC_H_ +#define _ULTRA64_OS_MISC_H_ +#include "ultratypes.h" +/* Miscellaneous OS functions */ + +void osInitialize(void); +u32 osGetCount(void); + +uintptr_t osVirtualToPhysical(void *); + +#endif diff --git a/src/decomp/include/PR/os_pi.h b/src/decomp/include/PR/os_pi.h new file mode 100644 index 0000000..8da37e2 --- /dev/null +++ b/src/decomp/include/PR/os_pi.h @@ -0,0 +1,88 @@ +#ifndef _ULTRA64_PI_H_ +#define _ULTRA64_PI_H_ +#include + +/* Ultra64 Parallel Interface */ + +/* Types */ + +typedef struct { +#if !defined(VERSION_EU) + u32 errStatus; +#endif + void *dramAddr; + void *C2Addr; + u32 sectorSize; + u32 C1ErrNum; + u32 C1ErrSector[4]; +} __OSBlockInfo; + +typedef struct { + u32 cmdType; // 0 + u16 transferMode; // 4 + u16 blockNum; // 6 + s32 sectorNum; // 8 + uintptr_t devAddr; // c +#if defined(VERSION_EU) + u32 errStatus; //error status added moved to blockinfo +#endif + u32 bmCtlShadow; // 10 + u32 seqCtlShadow; // 14 + __OSBlockInfo block[2]; // 18 +} __OSTranxInfo; + +typedef struct OSPiHandle_s { + struct OSPiHandle_s *next; + u8 type; + u8 latency; + u8 pageSize; + u8 relDuration; + u8 pulse; + u8 domain; + u32 baseAddress; + u32 speed; + __OSTranxInfo transferInfo; +} OSPiHandle; + +typedef struct { + u8 type; + uintptr_t address; +} OSPiInfo; + +typedef struct { + u16 type; + u8 pri; + u8 status; + OSMesgQueue *retQueue; +} OSIoMesgHdr; + +typedef struct { + /*0x00*/ OSIoMesgHdr hdr; + /*0x08*/ void *dramAddr; + /*0x0C*/ uintptr_t devAddr; + /*0x10*/ size_t size; +#if defined(VERSION_EU) || defined(VERSION_SH) + OSPiHandle *piHandle; // from the official definition +#endif +} OSIoMesg; + +/* Definitions */ + +#define OS_READ 0 // device -> RDRAM +#define OS_WRITE 1 // device <- RDRAM + +#define OS_MESG_PRI_NORMAL 0 +#define OS_MESG_PRI_HIGH 1 + +/* Functions */ + +s32 osPiStartDma(OSIoMesg *mb, s32 priority, s32 direction, uintptr_t devAddr, void *vAddr, + size_t nbytes, OSMesgQueue *mq); +void osCreatePiManager(OSPri pri, OSMesgQueue *cmdQ, OSMesg *cmdBuf, s32 cmdMsgCnt); +OSMesgQueue *osPiGetCmdQueue(void); +s32 osPiWriteIo(uintptr_t devAddr, u32 data); +s32 osPiReadIo(uintptr_t devAddr, u32 *data); + +s32 osPiRawStartDma(s32 dir, u32 cart_addr, void *dram_addr, size_t size); +s32 osEPiRawStartDma(OSPiHandle *piHandle, s32 dir, u32 cart_addr, void *dram_addr, size_t size); +#endif diff --git a/src/decomp/include/PR/os_rdp.h b/src/decomp/include/PR/os_rdp.h new file mode 100644 index 0000000..76077ba --- /dev/null +++ b/src/decomp/include/PR/os_rdp.h @@ -0,0 +1,92 @@ + +/*==================================================================== + * os_rdp.h + * + * Copyright 1995, Silicon Graphics, Inc. + * All Rights Reserved. + * + * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, + * Inc.; the contents of this file may not be disclosed to third + * parties, copied or duplicated in any form, in whole or in part, + * without the prior written permission of Silicon Graphics, Inc. + * + * RESTRICTED RIGHTS LEGEND: + * Use, duplication or disclosure by the Government is subject to + * restrictions as set forth in subdivision (c)(1)(ii) of the Rights + * in Technical Data and Computer Software clause at DFARS + * 252.227-7013, and/or in similar or successor clauses in the FAR, + * DOD or NASA FAR Supplement. Unpublished - rights reserved under the + * Copyright Laws of the United States. + *====================================================================*/ + +/*---------------------------------------------------------------------* + Copyright (C) 1998 Nintendo. (Originated by SGI) + + $RCSfile: os_rdp.h,v $ + $Revision: 1.1 $ + $Date: 1998/10/09 08:01:16 $ + *---------------------------------------------------------------------*/ + +#ifndef _OS_RDP_H_ +#define _OS_RDP_H_ + +#ifdef _LANGUAGE_C_PLUS_PLUS +extern "C" { +#endif + +#include "ultratypes.h" + +#if defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) + +/************************************************************************** + * + * Type definitions + * + */ + + +#endif /* defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) */ + +/************************************************************************** + * + * Global definitions + * + */ + + +#if defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) + +/************************************************************************** + * + * Macro definitions + * + */ + + +/************************************************************************** + * + * Extern variables + * + */ + + +/************************************************************************** + * + * Function prototypes + * + */ + +/* Display processor interface (Dp) */ +extern u32 osDpGetStatus(void); +extern void osDpSetStatus(u32); +extern void osDpGetCounters(u32 *); +extern s32 osDpSetNextBuffer(void *, u64); + + +#endif /* defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) */ + +#ifdef _LANGUAGE_C_PLUS_PLUS +} +#endif + +#endif /* !_OS_RDP_H_ */ diff --git a/src/decomp/include/PR/os_thread.h b/src/decomp/include/PR/os_thread.h new file mode 100644 index 0000000..76e528b --- /dev/null +++ b/src/decomp/include/PR/os_thread.h @@ -0,0 +1,75 @@ +#ifndef _ULTRA64_THREAD_H_ +#define _ULTRA64_THREAD_H_ +#include "ultratypes.h" +/* Recommended priorities for system threads */ +#define OS_PRIORITY_MAX 255 +#define OS_PRIORITY_VIMGR 254 +#define OS_PRIORITY_RMON 250 +#define OS_PRIORITY_RMONSPIN 200 +#define OS_PRIORITY_PIMGR 150 +#define OS_PRIORITY_SIMGR 140 +#define OS_PRIORITY_APPMAX 127 +#define OS_PRIORITY_IDLE 0 + +#define OS_STATE_STOPPED 1 +#define OS_STATE_RUNNABLE 2 +#define OS_STATE_RUNNING 4 +#define OS_STATE_WAITING 8 + +/* Types */ + +typedef s32 OSPri; +typedef s32 OSId; + +typedef union +{ + struct {f32 f_odd; f32 f_even;} f; +} __OSfp; + +typedef struct +{ + /* registers */ + /*0x20*/ u64 at, v0, v1, a0, a1, a2, a3; + /*0x58*/ u64 t0, t1, t2, t3, t4, t5, t6, t7; + /*0x98*/ u64 s0, s1, s2, s3, s4, s5, s6, s7; + /*0xD8*/ u64 t8, t9, gp, sp, s8, ra; + /*0x108*/ u64 lo, hi; + /*0x118*/ u32 sr, pc, cause, badvaddr, rcp; + /*0x12C*/ u32 fpcsr; + __OSfp fp0, fp2, fp4, fp6, fp8, fp10, fp12, fp14; + __OSfp fp16, fp18, fp20, fp22, fp24, fp26, fp28, fp30; +} __OSThreadContext; + +typedef struct +{ + u32 flag; + u32 count; + u64 time; +} __OSThreadprofile_s; + +typedef struct OSThread_s +{ + /*0x00*/ struct OSThread_s *next; + /*0x04*/ OSPri priority; + /*0x08*/ struct OSThread_s **queue; + /*0x0C*/ struct OSThread_s *tlnext; + /*0x10*/ u16 state; + /*0x12*/ u16 flags; + /*0x14*/ OSId id; + /*0x18*/ int fp; + /*0x1C*/ __OSThreadprofile_s *thprof; + /*0x20*/ __OSThreadContext context; +} OSThread; + + +/* Functions */ + +void osCreateThread(OSThread *thread, OSId id, void (*entry)(void *), + void *arg, void *sp, OSPri pri); +OSId osGetThreadId(OSThread *thread); +OSPri osGetThreadPri(OSThread *thread); +void osSetThreadPri(OSThread *thread, OSPri pri); +void osStartThread(OSThread *thread); +void osStopThread(OSThread *thread); + +#endif diff --git a/src/decomp/include/PR/os_time.h b/src/decomp/include/PR/os_time.h new file mode 100644 index 0000000..8c7c65f --- /dev/null +++ b/src/decomp/include/PR/os_time.h @@ -0,0 +1,27 @@ +#ifndef _ULTRA64_TIME_H_ +#define _ULTRA64_TIME_H_ + +#include "ultratypes.h" +#include "os_message.h" + +/* Types */ + +typedef struct OSTimer_str +{ + struct OSTimer_str *next; + struct OSTimer_str *prev; + u64 interval; + u64 remaining; + OSMesgQueue *mq; + OSMesg *msg; +} OSTimer; + +typedef u64 OSTime; + +/* Functions */ + +OSTime osGetTime(void); +void osSetTime(OSTime time); +u32 osSetTimer(OSTimer *, OSTime, OSTime, OSMesgQueue *, OSMesg); + +#endif diff --git a/src/decomp/include/PR/os_tlb.h b/src/decomp/include/PR/os_tlb.h new file mode 100644 index 0000000..15b485a --- /dev/null +++ b/src/decomp/include/PR/os_tlb.h @@ -0,0 +1,107 @@ + +/*==================================================================== + * os_tlb.h + * + * Copyright 1995, Silicon Graphics, Inc. + * All Rights Reserved. + * + * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, + * Inc.; the contents of this file may not be disclosed to third + * parties, copied or duplicated in any form, in whole or in part, + * without the prior written permission of Silicon Graphics, Inc. + * + * RESTRICTED RIGHTS LEGEND: + * Use, duplication or disclosure by the Government is subject to + * restrictions as set forth in subdivision (c)(1)(ii) of the Rights + * in Technical Data and Computer Software clause at DFARS + * 252.227-7013, and/or in similar or successor clauses in the FAR, + * DOD or NASA FAR Supplement. Unpublished - rights reserved under the + * Copyright Laws of the United States. + *====================================================================*/ + +/*---------------------------------------------------------------------* + Copyright (C) 1998 Nintendo. (Originated by SGI) + + $RCSfile: os_tlb.h,v $ + $Revision: 1.1 $ + $Date: 1998/10/09 08:01:20 $ + *---------------------------------------------------------------------*/ + +#ifndef _OS_TLB_H_ +#define _OS_TLB_H_ + +#ifdef _LANGUAGE_C_PLUS_PLUS +extern "C" { +#endif + +#include "ultratypes.h" + +#if defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) + +/************************************************************************** + * + * Type definitions + * + */ + +typedef u32 OSPageMask; + + +#endif /* defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) */ + +/************************************************************************** + * + * Global definitions + * + */ + +/* + * Page size argument for TLB routines + */ +#define OS_PM_4K 0x0000000 +#define OS_PM_16K 0x0006000 +#define OS_PM_64K 0x001e000 +#define OS_PM_256K 0x007e000 +#define OS_PM_1M 0x01fe000 +#define OS_PM_4M 0x07fe000 +#define OS_PM_16M 0x1ffe000 + + +#if defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) + +/************************************************************************** + * + * Macro definitions + * + */ + + +/************************************************************************** + * + * Extern variables + * + */ + + +/************************************************************************** + * + * Function prototypes + * + */ + +/* TLB management routines */ + +extern void osMapTLB(s32, OSPageMask, void *, u32, u32, s32); +extern void osMapTLBRdb(void); +extern void osUnmapTLB(s32); +extern void osUnmapTLBAll(void); +extern void osSetTLBASID(s32); + + +#endif /* defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) */ + +#ifdef _LANGUAGE_C_PLUS_PLUS +} +#endif + +#endif /* !_OS_TLB_H_ */ diff --git a/src/decomp/include/PR/os_vi.h b/src/decomp/include/PR/os_vi.h new file mode 100644 index 0000000..b487d1d --- /dev/null +++ b/src/decomp/include/PR/os_vi.h @@ -0,0 +1,117 @@ +#ifndef _ULTRA64_VI_H_ +#define _ULTRA64_VI_H_ + +#include "ultratypes.h" +#include "os_message.h" + +/* Ultra64 Video Interface */ + + +/* Special Features */ +#define OS_VI_GAMMA_ON 0x0001 +#define OS_VI_GAMMA_OFF 0x0002 +#define OS_VI_GAMMA_DITHER_ON 0x0004 +#define OS_VI_GAMMA_DITHER_OFF 0x0008 +#define OS_VI_DIVOT_ON 0x0010 +#define OS_VI_DIVOT_OFF 0x0020 +#define OS_VI_DITHER_FILTER_ON 0x0040 +#define OS_VI_DITHER_FILTER_OFF 0x0080 + +#define OS_VI_GAMMA 0x08 +#define OS_VI_GAMMA_DITHER 0x04 +#define OS_VI_DIVOT 0x10 +#define OS_VI_DITHER_FILTER 0x10000 +#define OS_VI_UNK200 0x200 +#define OS_VI_UNK100 0x100 + + +/* Types */ + +typedef struct +{ + u32 ctrl; + u32 width; + u32 burst; + u32 vSync; + u32 hSync; + u32 leap; + u32 hStart; + u32 xScale; + u32 vCurrent; +} OSViCommonRegs; + +typedef struct +{ + u32 origin; + u32 yScale; + u32 vStart; + u32 vBurst; + u32 vIntr; +} OSViFieldRegs; + +typedef struct +{ + u8 type; + OSViCommonRegs comRegs; + OSViFieldRegs fldRegs[2]; +} OSViMode; + +typedef struct +{ + /* 0x00 */ u16 unk00; //some kind of flags. swap buffer sets to 0x10 + /* 0x02 */ u16 retraceCount; + /* 0x04 */ void* buffer; + /* 0x08 */ OSViMode *modep; + /* 0x0c */ u32 features; + /* 0x10 */ OSMesgQueue *mq; + /* 0x14 */ OSMesg *msg; + /* 0x18 */ u32 unk18; + /* 0x1c */ u32 unk1c; + /* 0x20 */ u32 unk20; + /* 0x24 */ f32 unk24; + /* 0x28 */ u16 unk28; + /* 0x2c */ u32 unk2c; +} OSViContext; + +void osCreateViManager(OSPri pri); +void osViSetMode(OSViMode *mode); +void osViSetEvent(OSMesgQueue *mq, OSMesg msg, u32 retraceCount); +void osViBlack(u8 active); +void osViSetSpecialFeatures(u32 func); +void osViSwapBuffer(void *vaddr); + + +#define OS_VI_NTSC_LPN1 0 /* NTSC */ +#define OS_VI_NTSC_LPF1 1 +#define OS_VI_NTSC_LAN1 2 +#define OS_VI_NTSC_LAF1 3 +#define OS_VI_NTSC_LPN2 4 +#define OS_VI_NTSC_LPF2 5 +#define OS_VI_NTSC_LAN2 6 +#define OS_VI_NTSC_LAF2 7 +#define OS_VI_NTSC_HPN1 8 +#define OS_VI_NTSC_HPF1 9 +#define OS_VI_NTSC_HAN1 10 +#define OS_VI_NTSC_HAF1 11 +#define OS_VI_NTSC_HPN2 12 +#define OS_VI_NTSC_HPF2 13 + +#define OS_VI_PAL_LPN1 14 /* PAL */ +#define OS_VI_PAL_LPF1 15 +#define OS_VI_PAL_LAN1 16 +#define OS_VI_PAL_LAF1 17 +#define OS_VI_PAL_LPN2 18 +#define OS_VI_PAL_LPF2 19 +#define OS_VI_PAL_LAN2 20 +#define OS_VI_PAL_LAF2 21 +#define OS_VI_PAL_HPN1 22 +#define OS_VI_PAL_HPF1 23 +#define OS_VI_PAL_HAN1 24 +#define OS_VI_PAL_HAF1 25 +#define OS_VI_PAL_HPN2 26 +#define OS_VI_PAL_HPF2 27 + +extern OSViMode osViModeTable[]; /* Global VI mode table */ + + +#endif diff --git a/src/decomp/include/PR/sptask.h b/src/decomp/include/PR/sptask.h new file mode 100644 index 0000000..ec443ef --- /dev/null +++ b/src/decomp/include/PR/sptask.h @@ -0,0 +1,116 @@ +#ifndef _ULTRA64_SPTASK_H_ +#define _ULTRA64_SPTASK_H_ + +/* Task Types */ +#define M_GFXTASK 1 +#define M_AUDTASK 2 +#define M_VIDTASK 3 +#define M_HVQTASK 6 +#define M_HVQMTASK 7 + +#if (defined(F3DEX_GBI) || defined(F3DLP_GBI) || defined(F3DEX_GBI_2)) +#define OS_YIELD_DATA_SIZE 0xc00 +#else +#define OS_YIELD_DATA_SIZE 0x900 +#endif +#define OS_YIELD_AUDIO_SIZE 0x400 + +/* Flags */ +#define M_TASK_FLAG0 1 +#define M_TASK_FLAG1 2 +#ifdef VERSION_SH +#define M_TASK_FLAG2 4 +#endif + +/* SpStatus */ +#define SPSTATUS_CLEAR_HALT 0x00000001 +#define SPSTATUS_SET_HALT 0x00000002 +#define SPSTATUS_CLEAR_BROKE 0x00000004 +#define SPSTATUS_CLEAR_INTR 0x00000008 +#define SPSTATUS_SET_INTR 0x00000010 +#define SPSTATUS_CLEAR_SSTEP 0x00000020 +#define SPSTATUS_SET_SSTEP 0x00000040 +#define SPSTATUS_CLEAR_INTR_ON_BREAK 0x00000080 +#define SPSTATUS_SET_INTR_ON_BREAK 0x00000100 +#define SPSTATUS_CLEAR_SIGNAL0 0x00000200 +#define SPSTATUS_SET_SIGNAL0 0x00000400 +#define SPSTATUS_CLEAR_SIGNAL1 0x00000800 +#define SPSTATUS_SET_SIGNAL1 0x00001000 +#define SPSTATUS_CLEAR_SIGNAL2 0x00002000 +#define SPSTATUS_SET_SIGNAL2 0x00004000 +#define SPSTATUS_CLEAR_SIGNAL3 0x00008000 +#define SPSTATUS_SET_SIGNAL3 0x00010000 +#define SPSTATUS_CLEAR_SIGNAL4 0x00020000 +#define SPSTATUS_SET_SIGNAL4 0x00040000 +#define SPSTATUS_CLEAR_SIGNAL5 0x00080000 +#define SPSTATUS_SET_SIGNAL5 0x00100000 +#define SPSTATUS_CLEAR_SIGNAL6 0x00200000 +#define SPSTATUS_SET_SIGNAL6 0x00800000 +#define SPSTATUS_CLEAR_SIGNAL7 0x01000000 +#define SPSTATUS_SET_SIGNAL7 0x02000000 + +#define SPSTATUS_HALT 0x0001 +#define SPSTATUS_BROKE 0x0002 +#define SPSTATUS_DMA_BUSY 0x0004 +#define SPSTATUS_DMA_FULL 0x0008 +#define SPSTATUS_IO_FULL 0x0010 +#define SPSTATUS_SINGLE_STEP 0x0020 +#define SPSTATUS_INTERRUPT_ON_BREAK 0x0040 +#define SPSTATUS_SIGNAL0_SET 0x0080 +#define SPSTATUS_SIGNAL1_SET 0x0100 +#define SPSTATUS_SIGNAL2_SET 0x0200 +#define SPSTATUS_SIGNAL3_SET 0x0400 +#define SPSTATUS_SIGNAL4_SET 0x0800 +#define SPSTATUS_SIGNAL5_SET 0x1000 +#define SPSTATUS_SIGNAL6_SET 0x2000 +#define SPSTATUS_SIGNAL7_SET 0x4000 + +/* Types */ +/* Types */ + +typedef struct +{ + /*0x00*/ u32 type; + /*0x04*/ u32 flags; + + /*0x08*/ u64 *ucode_boot; + /*0x0C*/ u32 ucode_boot_size; + + /*0x10*/ u64 *ucode; + /*0x14*/ u32 ucode_size; + + /*0x18*/ u64 *ucode_data; + /*0x1C*/ u32 ucode_data_size; + + /*0x20*/ u64 *dram_stack; + /*0x24*/ u32 dram_stack_size; + + /*0x28*/ u64 *output_buff; + /*0x2C*/ u64 *output_buff_size; + + /*0x30*/ u64 *data_ptr; + /*0x34*/ u32 data_size; + + /*0x38*/ u64 *yield_data_ptr; + /*0x3C*/ u32 yield_data_size; +} OSTask_t; // size = 0x40 + +typedef union { + OSTask_t t; + long long int force_structure_alignment; +} OSTask; + +typedef u32 OSYieldResult; + +/* Functions */ + +#define osSpTaskStart(p) \ + osSpTaskLoad(p); \ + osSpTaskStartGo(p); + +void osSpTaskLoad(OSTask *task); +void osSpTaskStartGo(OSTask *task); +void osSpTaskYield(void); +OSYieldResult osSpTaskYielded(OSTask *task); + +#endif diff --git a/src/decomp/include/PR/ucode.h b/src/decomp/include/PR/ucode.h new file mode 100644 index 0000000..37fd197 --- /dev/null +++ b/src/decomp/include/PR/ucode.h @@ -0,0 +1,23 @@ +#ifndef _ULTRA64_UCODE_H_ +#define _ULTRA64_UCODE_H_ + +#define SP_DRAM_STACK_SIZE8 0x400 +#define SP_UCODE_SIZE 0x1000 +#define SP_UCODE_DATA_SIZE 0x800 + +// standard boot ucode +extern u64 rspF3DBootStart[], rspF3DBootEnd[]; + +// F3D ucode +extern u64 rspF3DStart[], rspF3DEnd[]; + +// F3D ucode data +extern u64 rspF3DDataStart[], rspF3DDataEnd[]; + +// aspMain (audio) ucode +extern u64 rspAspMainStart[], rspAspMainEnd[]; + +// aspMain ucode data +extern u64 rspAspMainDataStart[], rspAspMainDataEnd[]; + +#endif diff --git a/src/decomp/include/ultra64.h b/src/decomp/include/ultra64.h new file mode 100644 index 0000000..b8d9e4d --- /dev/null +++ b/src/decomp/include/ultra64.h @@ -0,0 +1,31 @@ +#ifndef _ULTRA64_H_ +#define _ULTRA64_H_ + +#include + +#ifndef _LANGUAGE_C +#define _LANGUAGE_C +#endif + +#include "PR/ultratypes.h" +#include "PR/os_exception.h" +#include "PR/os_misc.h" +#include "PR/os_rdp.h" +#include "PR/os_thread.h" +#include "PR/os_time.h" +#include "PR/os_message.h" +#include "PR/os_cont.h" +#include "PR/os_tlb.h" +#include "PR/sptask.h" +#include "PR/ucode.h" +#include "PR/os_cache.h" +#include "PR/os_vi.h" +#include "PR/os_pi.h" +#include "PR/os_internal.h" +#include "PR/os_eeprom.h" +#include "PR/os_libc.h" +#include "PR/os_ai.h" +#include "PR/libaudio.h" +#include "PR/libultra.h" + +#endif From 37c8ce046c6c7d3642c72e40b8e3337abf4a9606 Mon Sep 17 00:00:00 2001 From: MeltyPlayer Date: Fri, 21 Oct 2022 01:04:56 -0500 Subject: [PATCH 03/16] Loaded and returned audio banks. Let's see if this actually works, though... --- Makefile | 6 +- src/decomp/audio/external.c | 10 - src/decomp/audio/external.h | 1 - src/decomp/audio/load.h | 2 + src/decomp/include/audio_defines.h | 37 +- src/decomp/include/types.h | 28 +- src/decomp/pc/alBnkfNew.c | 93 + src/decomp/pc/audio/audio_alsa.c | 170 + src/decomp/pc/audio/audio_alsa.h | 13 + src/decomp/pc/audio/audio_api.h | 15 + src/decomp/pc/audio/audio_null.c | 24 + src/decomp/pc/audio/audio_null.h | 8 + src/decomp/pc/audio/audio_pulse.c | 206 + src/decomp/pc/audio/audio_pulse.h | 13 + src/decomp/pc/audio/audio_wasapi.cpp | 219 + src/decomp/pc/audio/audio_wasapi.h | 12 + src/decomp/pc/compat.h | 8 + src/decomp/pc/configfile.c | 236 + src/decomp/pc/configfile.h | 22 + src/decomp/pc/controller/controller_api.h | 11 + .../controller_emscripten_keyboard.c | 151 + .../controller_emscripten_keyboard.h | 8 + .../pc/controller/controller_entry_point.c | 53 + .../pc/controller/controller_keyboard.c | 88 + .../pc/controller/controller_keyboard.h | 19 + .../pc/controller/controller_recorded_tas.c | 29 + .../pc/controller/controller_recorded_tas.h | 8 + src/decomp/pc/controller/controller_sdl.c | 103 + src/decomp/pc/controller/controller_sdl.h | 8 + src/decomp/pc/controller/controller_wup.c | 51 + src/decomp/pc/controller/controller_wup.h | 12 + src/decomp/pc/controller/controller_xinput.c | 51 + src/decomp/pc/controller/controller_xinput.h | 12 + src/decomp/pc/controller/wup.c | 362 + src/decomp/pc/dlmalloc.c | 6289 ++++++ src/decomp/pc/gfx/LICENSE.txt | 19 + src/decomp/pc/gfx/README.md | 33 + src/decomp/pc/gfx/dxsdk/d3d12.h | 17258 ++++++++++++++++ src/decomp/pc/gfx/dxsdk/d3d12sdklayers.h | 3230 +++ src/decomp/pc/gfx/dxsdk/d3dcommon.h | 1009 + src/decomp/pc/gfx/dxsdk/d3dx12.h | 3440 +++ src/decomp/pc/gfx/gfx_cc.c | 41 + src/decomp/pc/gfx/gfx_cc.h | 58 + src/decomp/pc/gfx/gfx_direct3d11.cpp | 731 + src/decomp/pc/gfx/gfx_direct3d11.h | 12 + src/decomp/pc/gfx/gfx_direct3d12.cpp | 966 + src/decomp/pc/gfx/gfx_direct3d12.h | 12 + src/decomp/pc/gfx/gfx_direct3d12_guids.h | 62 + src/decomp/pc/gfx/gfx_direct3d_common.cpp | 313 + src/decomp/pc/gfx/gfx_direct3d_common.h | 14 + src/decomp/pc/gfx/gfx_dummy.c | 192 + src/decomp/pc/gfx/gfx_dummy.h | 14 + src/decomp/pc/gfx/gfx_dxgi.cpp | 614 + src/decomp/pc/gfx/gfx_dxgi.h | 16 + src/decomp/pc/gfx/gfx_glx.c | 620 + src/decomp/pc/gfx/gfx_glx.h | 8 + src/decomp/pc/gfx/gfx_opengl.c | 531 + src/decomp/pc/gfx/gfx_opengl.h | 8 + src/decomp/pc/gfx/gfx_pc.c | 1691 ++ src/decomp/pc/gfx/gfx_pc.h | 30 + src/decomp/pc/gfx/gfx_rendering_api.h | 35 + src/decomp/pc/gfx/gfx_screen_config.h | 7 + src/decomp/pc/gfx/gfx_sdl.h | 8 + src/decomp/pc/gfx/gfx_sdl2.c | 315 + src/decomp/pc/gfx/gfx_window_manager_api.h | 21 + src/decomp/pc/libaudio_internal.h | 127 + src/decomp/pc/libultra_internal.h | 99 + src/decomp/pc/mixer.c | 1185 ++ src/decomp/pc/mixer.h | 117 + src/decomp/pc/ultra_reimplementation.c | 216 + src/libsm64.c | 5 + src/libsm64.h | 2 + src/load_audio_data.c | 16 + src/load_audio_data.h | 8 + 74 files changed, 41432 insertions(+), 29 deletions(-) create mode 100644 src/decomp/pc/alBnkfNew.c create mode 100644 src/decomp/pc/audio/audio_alsa.c create mode 100644 src/decomp/pc/audio/audio_alsa.h create mode 100644 src/decomp/pc/audio/audio_api.h create mode 100644 src/decomp/pc/audio/audio_null.c create mode 100644 src/decomp/pc/audio/audio_null.h create mode 100644 src/decomp/pc/audio/audio_pulse.c create mode 100644 src/decomp/pc/audio/audio_pulse.h create mode 100644 src/decomp/pc/audio/audio_wasapi.cpp create mode 100644 src/decomp/pc/audio/audio_wasapi.h create mode 100644 src/decomp/pc/compat.h create mode 100644 src/decomp/pc/configfile.c create mode 100644 src/decomp/pc/configfile.h create mode 100644 src/decomp/pc/controller/controller_api.h create mode 100644 src/decomp/pc/controller/controller_emscripten_keyboard.c create mode 100644 src/decomp/pc/controller/controller_emscripten_keyboard.h create mode 100644 src/decomp/pc/controller/controller_entry_point.c create mode 100644 src/decomp/pc/controller/controller_keyboard.c create mode 100644 src/decomp/pc/controller/controller_keyboard.h create mode 100644 src/decomp/pc/controller/controller_recorded_tas.c create mode 100644 src/decomp/pc/controller/controller_recorded_tas.h create mode 100644 src/decomp/pc/controller/controller_sdl.c create mode 100644 src/decomp/pc/controller/controller_sdl.h create mode 100644 src/decomp/pc/controller/controller_wup.c create mode 100644 src/decomp/pc/controller/controller_wup.h create mode 100644 src/decomp/pc/controller/controller_xinput.c create mode 100644 src/decomp/pc/controller/controller_xinput.h create mode 100644 src/decomp/pc/controller/wup.c create mode 100644 src/decomp/pc/dlmalloc.c create mode 100644 src/decomp/pc/gfx/LICENSE.txt create mode 100644 src/decomp/pc/gfx/README.md create mode 100644 src/decomp/pc/gfx/dxsdk/d3d12.h create mode 100644 src/decomp/pc/gfx/dxsdk/d3d12sdklayers.h create mode 100644 src/decomp/pc/gfx/dxsdk/d3dcommon.h create mode 100644 src/decomp/pc/gfx/dxsdk/d3dx12.h create mode 100644 src/decomp/pc/gfx/gfx_cc.c create mode 100644 src/decomp/pc/gfx/gfx_cc.h create mode 100644 src/decomp/pc/gfx/gfx_direct3d11.cpp create mode 100644 src/decomp/pc/gfx/gfx_direct3d11.h create mode 100644 src/decomp/pc/gfx/gfx_direct3d12.cpp create mode 100644 src/decomp/pc/gfx/gfx_direct3d12.h create mode 100644 src/decomp/pc/gfx/gfx_direct3d12_guids.h create mode 100644 src/decomp/pc/gfx/gfx_direct3d_common.cpp create mode 100644 src/decomp/pc/gfx/gfx_direct3d_common.h create mode 100644 src/decomp/pc/gfx/gfx_dummy.c create mode 100644 src/decomp/pc/gfx/gfx_dummy.h create mode 100644 src/decomp/pc/gfx/gfx_dxgi.cpp create mode 100644 src/decomp/pc/gfx/gfx_dxgi.h create mode 100644 src/decomp/pc/gfx/gfx_glx.c create mode 100644 src/decomp/pc/gfx/gfx_glx.h create mode 100644 src/decomp/pc/gfx/gfx_opengl.c create mode 100644 src/decomp/pc/gfx/gfx_opengl.h create mode 100644 src/decomp/pc/gfx/gfx_pc.c create mode 100644 src/decomp/pc/gfx/gfx_pc.h create mode 100644 src/decomp/pc/gfx/gfx_rendering_api.h create mode 100644 src/decomp/pc/gfx/gfx_screen_config.h create mode 100644 src/decomp/pc/gfx/gfx_sdl.h create mode 100644 src/decomp/pc/gfx/gfx_sdl2.c create mode 100644 src/decomp/pc/gfx/gfx_window_manager_api.h create mode 100644 src/decomp/pc/libaudio_internal.h create mode 100644 src/decomp/pc/libultra_internal.h create mode 100644 src/decomp/pc/mixer.c create mode 100644 src/decomp/pc/mixer.h create mode 100644 src/decomp/pc/ultra_reimplementation.c create mode 100644 src/load_audio_data.c create mode 100644 src/load_audio_data.h diff --git a/Makefile b/Makefile index b3fc266..ba4d43e 100644 --- a/Makefile +++ b/Makefile @@ -7,9 +7,9 @@ else CC := cc LDFLAGS := -lm -shared endif -CFLAGS := -g -Wall -fPIC -DSM64_LIB_EXPORT -DGBI_FLOATS +CFLAGS := -g -Wall -fPIC -DSM64_LIB_EXPORT -DGBI_FLOATS -DVERSION_US -SRC_DIRS := src src/decomp src/decomp/engine src/decomp/game src/decomp/mario src/decomp/tools +SRC_DIRS := src src/decomp src/decomp/engine src/decomp/include/PR src/decomp/game src/decomp/pc src/decomp/pc/audio src/decomp/mario src/decomp/tools src/decomp/audio BUILD_DIR := build DIST_DIR := dist ALL_DIRS := $(addprefix $(BUILD_DIR)/,$(SRC_DIRS)) @@ -42,7 +42,7 @@ src/decomp/mario/geo.inc.c: ./import-mario-geo.py $(BUILD_DIR)/%.o: %.c $(IMPORTED) @$(CC) $(CFLAGS) -MM -MP -MT $@ -MF $(BUILD_DIR)/$*.d $< - $(CC) -c $(CFLAGS) -o $@ $< + $(CC) -c $(CFLAGS) -I src/decomp/include -o $@ $< $(LIB_FILE): $(O_FILES) $(CC) $(LDFLAGS) -o $@ $^ diff --git a/src/decomp/audio/external.c b/src/decomp/audio/external.c index 7e9edab..fabb36f 100644 --- a/src/decomp/audio/external.c +++ b/src/decomp/audio/external.c @@ -807,16 +807,6 @@ void create_next_audio_buffer(s16 *samples, u32 num_samples) { #endif #endif -/** - * Called from threads: thread5_game_loop - */ -void play_sound(s32 soundBits, f32 *pos) { - sSoundRequests[sSoundRequestCount].soundBits = soundBits; - sSoundRequests[sSoundRequestCount].position = pos; - sSoundRequestCount++; - //DEBUG_PRINT("play_sound(%d) request#%d; pos %f %f %f\n", soundBits,sSoundRequestCount,pos[0],pos[1],pos[2]); -} - /** * Called from threads: thread4_sound, thread5_game_loop (EU only) */ diff --git a/src/decomp/audio/external.h b/src/decomp/audio/external.h index 10fd35a..53f97d2 100644 --- a/src/decomp/audio/external.h +++ b/src/decomp/audio/external.h @@ -28,7 +28,6 @@ extern u8 gAudioSPTaskYieldBuffer[]; // ucode yield data ptr; only used in JP struct SPTask *create_next_audio_frame_task(void); void create_next_audio_buffer(s16 *samples, u32 num_samples); -void play_sound(s32 soundBits, f32 *pos); void audio_signal_game_loop_tick(void); void seq_player_fade_out(u8 player, u16 fadeDuration); void fade_volume_scale(u8 player, u8 targetScale, u16 fadeDuration); diff --git a/src/decomp/audio/load.h b/src/decomp/audio/load.h index 63379d2..86f8fa8 100644 --- a/src/decomp/audio/load.h +++ b/src/decomp/audio/load.h @@ -76,6 +76,8 @@ struct PatchStruct { extern struct UnkStructSH8034EC88 D_SH_8034EC88[0x80]; #endif +struct AudioBank *bank_load_immediate(s32 bankId, s32 arg1); + void audio_dma_partial_copy_async(uintptr_t *devAddr, u8 **vAddr, ssize_t *remaining, OSMesgQueue *queue, OSIoMesg *mesg); void decrease_sample_dma_ttls(void); #ifdef VERSION_SH diff --git a/src/decomp/include/audio_defines.h b/src/decomp/include/audio_defines.h index 021d2d8..7517191 100644 --- a/src/decomp/include/audio_defines.h +++ b/src/decomp/include/audio_defines.h @@ -21,21 +21,56 @@ #define SOUNDARGS_SHIFT_SOUNDID 16 #define SOUNDARGS_SHIFT_PRIORITY 8 +/* Sound banks */ +#define SOUND_BANK_ACTION 0 +#define SOUND_BANK_MOVING 1 +#define SOUND_BANK_VOICE 2 +#define SOUND_BANK_GENERAL 3 +#define SOUND_BANK_ENV 4 +#define SOUND_BANK_OBJ 5 +#define SOUND_BANK_AIR 6 +#define SOUND_BANK_MENU 7 +#define SOUND_BANK_GENERAL2 8 +#define SOUND_BANK_OBJ2 9 +#define SOUND_BANK_COUNT 10 + +#define SOUND_BANKS_ALL_BITS 0xffff +#define SOUND_BANKS_ALL ((1 << SOUND_BANK_COUNT) - 1) +#define SOUND_BANKS_FOREGROUND (\ + (1 << SOUND_BANK_ACTION) |\ + (1 << SOUND_BANK_VOICE) |\ + (1 << SOUND_BANK_MENU)) +#define SOUND_BANKS_BACKGROUND (SOUND_BANKS_ALL & ~SOUND_BANKS_FOREGROUND) +#define SOUND_BANKS_DISABLED_DURING_INTRO_CUTSCENE (\ + (1 << SOUND_BANK_ENV) |\ + (1 << SOUND_BANK_OBJ) |\ + (1 << SOUND_BANK_GENERAL2) |\ + (1 << SOUND_BANK_OBJ2)) +#define SOUND_BANKS_DISABLED_AFTER_CREDITS (\ + (1 << SOUND_BANK_ACTION) |\ + (1 << SOUND_BANK_MOVING) |\ + (1 << SOUND_BANK_VOICE) |\ + (1 << SOUND_BANK_GENERAL)) + /* Audio Status */ #define SOUND_STATUS_STOPPED 0 #define SOUND_STATUS_STARTING 1 +#define SOUND_STATUS_WAITING SOUND_STATUS_STARTING #define SOUND_STATUS_PLAYING 2 /* Audio lower bitflags. TODO: Figure out what these mean and use them below. */ #define SOUND_LO_BITFLAG_UNK1 0x10 // fade in? +#define SOUND_LOWER_BACKGROUND_MUSIC SOUND_LO_BITFLAG_UNK1 #define SOUND_NO_ECHO 0x20 // not in JP #define SOUND_LO_BITFLAG_UNK8 0x80 // restart playing on each play_sound call? +#define SOUND_DISCRETE SOUND_LO_BITFLAG_UNK8 /* Audio playback bitflags. */ #define SOUND_NO_VOLUME_LOSS 0x1000000 // No volume loss with distance #define SOUND_VIBRATO 0x2000000 // Randomly alter frequency each audio frame #define SOUND_NO_PRIORITY_LOSS 0x4000000 // Do not prioritize closer sounds #define SOUND_NO_FREQUENCY_LOSS 0x8000000 // Frequency scale does not change with distance +#define SOUND_CONSTANT_FREQUENCY SOUND_NO_FREQUENCY_LOSS // silence #define NO_SOUND 0 @@ -558,4 +593,4 @@ #define SOUND_OBJ2_BOSS_DIALOG_GRUNT SOUND_ARG_LOAD(9, 0, 0x69, 0x40, 8) #define SOUND_OBJ2_MRI_SPINNING SOUND_ARG_LOAD(9, 0, 0x6B, 0x00, 8) -#endif // AUDIO_DEFINES_H +#endif // AUDIO_DEFINES_H \ No newline at end of file diff --git a/src/decomp/include/types.h b/src/decomp/include/types.h index eb008b0..9d2bb8c 100644 --- a/src/decomp/include/types.h +++ b/src/decomp/include/types.h @@ -4,7 +4,7 @@ // This file contains various data types used in Super Mario 64 that don't yet // have an appropriate header. -// #include +#include "ultra64.h" #include "macros.h" #include "PR/ultratypes.h" @@ -62,19 +62,19 @@ enum SpTaskState { SPTASK_STATE_FINISHED_DP }; -// struct SPTask -// { -// /*0x00*/ OSTask task; -// /*0x40*/ OSMesgQueue *msgqueue; -// /*0x44*/ OSMesg msg; -// /*0x48*/ enum SpTaskState state; -// }; // size = 0x4C, align = 0x8 -// -// struct VblankHandler -// { -// OSMesgQueue *queue; -// OSMesg msg; -// }; +struct SPTask +{ + /*0x00*/ OSTask task; + /*0x40*/ OSMesgQueue *msgqueue; + /*0x44*/ OSMesg msg; + /*0x48*/ enum SpTaskState state; +}; // size = 0x4C, align = 0x8 + +struct VblankHandler +{ + OSMesgQueue *queue; + OSMesg msg; +}; #define ANIM_FLAG_NOLOOP (1 << 0) // 0x01 #define ANIM_FLAG_FORWARD (1 << 1) // 0x02 diff --git a/src/decomp/pc/alBnkfNew.c b/src/decomp/pc/alBnkfNew.c new file mode 100644 index 0000000..bb04df3 --- /dev/null +++ b/src/decomp/pc/alBnkfNew.c @@ -0,0 +1,93 @@ +#include "libultra_internal.h" +#include "libaudio_internal.h" + +#define PATCH(SRC, BASE, TYPE) //SRC = (TYPE)((uintptr_t) SRC + (uintptr_t) BASE) + +void alSeqFileNew(ALSeqFile *f, u8 *base) { + int i; + for (i = 0; i < f->seqCount; i++) { + PATCH(f->seqArray[i].offset, base, u8 *); + } +} + +static void _bnkfPatchBank(ALInstrument *inst, ALBankFile *f, u8 *table) { + int i; + ALSound *sound; + ALWaveTable *wavetable; + u8 *table2; + + if (inst->flags) { + return; + } + + inst->flags = 1; + + for (i = 0; i < inst->soundCount; i++) { + PATCH(inst->soundArray[i], f, ALSound *); + sound = inst->soundArray[i]; + if (sound->flags) { + continue; + } + + table2 = table; + + sound->flags = 1; + PATCH(sound->envelope, f, ALEnvelope *); + PATCH(sound->keyMap, f, ALKeyMap *); + PATCH(sound->wavetable, f, ALWaveTable *); + wavetable = sound->wavetable; + if (wavetable->flags) { + continue; + } + + wavetable->flags = 1; + PATCH(wavetable->base, table2, u8 *); + if (wavetable->type == 0) { + PATCH(wavetable->waveInfo.adpcmWave.book, f, ALADPCMBook *); + if (wavetable->waveInfo.adpcmWave.loop != NULL) { + PATCH(wavetable->waveInfo.adpcmWave.loop, f, ALADPCMloop *); + } + } else if (wavetable->type == 1) { + if (wavetable->waveInfo.rawWave.loop != NULL) { + PATCH(wavetable->waveInfo.rawWave.loop, f, ALRawLoop *); + } + } + } +} + +// Force adding another jr $ra. Has to be called or it doesn't get put in the +// right place. +static void unused(void) { +} + +void alBnkfNew(ALBankFile *f, u8 *table) { + ALBank *bank; + int i; + int j; + unused(); + if (f->revision != AL_BANK_VERSION) { + return; + } + + for (i = 0; i < f->bankCount; i++) { + PATCH(f->bankArray[i], f, ALBank *); + if (f->bankArray[i] == NULL) { + continue; + } + + bank = f->bankArray[i]; + if (bank->flags == 0) { + bank->flags = 1; + if (bank->percussion != NULL) { + PATCH(bank->percussion, f, ALInstrument *); + _bnkfPatchBank(bank->percussion, f, table); + } + for (j = 0; j < bank->instCount; j++) { + PATCH(bank->instArray[j], f, ALInstrument *); + if (bank->instArray[j] != NULL) { + _bnkfPatchBank(bank->instArray[j], f, table); + } + } + } + } +} diff --git a/src/decomp/pc/audio/audio_alsa.c b/src/decomp/pc/audio/audio_alsa.c new file mode 100644 index 0000000..7884130 --- /dev/null +++ b/src/decomp/pc/audio/audio_alsa.c @@ -0,0 +1,170 @@ +#include "../compat.h" + +#if (defined(__linux__) || defined(__BSD__)) && !defined(TARGET_WEB) +/* + Simple sound playback using ALSA API and libasound. + Dependencies: libasound, alsa + Build-Dependencies: liasound-dev + Compile: gcc -lasound -o play sound_playback.c + Usage: ./play < + Examples: + ./play 44100 2 5 < /dev/urandom + ./play 22050 1 8 < /path/to/file.wav + + Copyright (C) 2009 Alessandro Ghedini + -------------------------------------------------------------- + "THE BEER-WARE LICENSE" (Revision 42): + Alessandro Ghedini wrote this file. As long as you retain this + notice you can do whatever you want with this stuff. If we + meet some day, and you think this stuff is worth it, you can + buy me a beer in return. + -------------------------------------------------------------- +*/ + +#include +#include +#include +#include +#include +#include + +#include + +#include +#include + +#include "audio_api.h" + +#define PCM_DEVICE "default" +static snd_pcm_t *pcm_handle; +static unsigned long int alsa_buffer_size; + +static unsigned long get_time(void) { + struct timespec ts; + clock_gettime(CLOCK_MONOTONIC, &ts); + return (unsigned long)ts.tv_sec * 1000000 + ts.tv_nsec / 1000; +} + +static bool audio_alsa_init(void) { + int pcm; + unsigned int tmp; + unsigned int rate, channels; + snd_pcm_hw_params_t *params; + snd_pcm_uframes_t frames; + + rate = 32000; + channels = 2; + + /* Open the PCM device in playback mode */ + if ((pcm = snd_pcm_open(&pcm_handle, PCM_DEVICE, + SND_PCM_STREAM_PLAYBACK, 0)) < 0) { + printf("ERROR: Can't open \"%s\" PCM device. %s\n", + PCM_DEVICE, snd_strerror(pcm)); + return false; + } + + /* Allocate parameters object and fill it with default values*/ + snd_pcm_hw_params_alloca(¶ms); + + snd_pcm_hw_params_any(pcm_handle, params); + + /* Set parameters */ + if ((pcm = snd_pcm_hw_params_set_access(pcm_handle, params, + SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) + printf("ERROR: Can't set interleaved mode. %s\n", snd_strerror(pcm)); + + if ((pcm = snd_pcm_hw_params_set_format(pcm_handle, params, + SND_PCM_FORMAT_S16_LE)) < 0) + printf("ERROR: Can't set format. %s\n", snd_strerror(pcm)); + + if ((pcm = snd_pcm_hw_params_set_channels(pcm_handle, params, channels)) < 0) + printf("ERROR: Can't set channels number. %s\n", snd_strerror(pcm)); + + if ((pcm = snd_pcm_hw_params_set_rate_near(pcm_handle, params, &rate, 0)) < 0) + printf("ERROR: Can't set rate. %s\n", snd_strerror(pcm)); + + alsa_buffer_size = 1600 + 528 + 544; // five audio buffers from the game + if ((pcm = snd_pcm_hw_params_set_buffer_size_near(pcm_handle, params, &alsa_buffer_size)) < 0) + printf("ERROR: Can't set buffer size. %s\n", snd_strerror(pcm)); + + /* Write parameters */ + if ((pcm = snd_pcm_hw_params(pcm_handle, params)) < 0) + printf("ERROR: Can't set harware parameters. %s\n", snd_strerror(pcm)); + + /* Resume information */ + printf("PCM name: '%s'\n", snd_pcm_name(pcm_handle)); + + printf("PCM state: %s\n", snd_pcm_state_name(snd_pcm_state(pcm_handle))); + + snd_pcm_hw_params_get_channels(params, &tmp); + printf("channels: %i ", tmp); + + if (tmp == 1) + printf("(mono)\n"); + else if (tmp == 2) + printf("(stereo)\n"); + + snd_pcm_hw_params_get_rate(params, &tmp, 0); + printf("rate: %d bps\n", tmp); + + snd_pcm_hw_params_get_buffer_size(params, &alsa_buffer_size); + printf("buffer size: %lu\n", alsa_buffer_size); + + /* Allocate buffer to hold single period */ + snd_pcm_hw_params_get_period_size(params, &frames, 0); + printf("frames: %lu\n", frames); + + snd_pcm_hw_params_get_period_time(params, &tmp, NULL); + printf("time: %d\n", tmp); + + return true; +} + +static int audio_alsa_buffered(void) { + if (!pcm_handle) { + return 0; + } + snd_pcm_sframes_t ret = snd_pcm_avail(pcm_handle); + if (ret < 0) { + return 0; + } + ret = alsa_buffer_size - ret; + return ret < 0 ? 0 : ret; +} + +static int audio_alsa_get_desired_buffered(void) { + return 1100; +} + +static void audio_alsa_play(const uint8_t* buff, size_t len) { + if (!pcm_handle) { + audio_alsa_init(); + } + //unsigned long t1 = get_time(); + int frames = len / 4; + int pcm; + if ((pcm = snd_pcm_writei(pcm_handle, buff, frames)) == -EPIPE) { + printf("XRUN.\n"); + snd_pcm_prepare(pcm_handle); + // Add some silence to avoid another XRUN + char buf[1100 * 4 + len]; + memset(buf, 0, 1100 * 4); + memcpy(buf + 1100 * 4, buff, len); + if ((pcm = snd_pcm_writei(pcm_handle, buf, 1100 + frames)) < 0) { + printf("Failed again %d\n", pcm); + } + } else if (pcm < 0) { + printf("ERROR. Can't write to PCM device. %s\n", snd_strerror(pcm)); + return; + } + //fprintf(stderr, "%u ", get_time() - t1); +} + +struct AudioAPI audio_alsa = { + audio_alsa_init, + audio_alsa_buffered, + audio_alsa_get_desired_buffered, + audio_alsa_play +}; + +#endif diff --git a/src/decomp/pc/audio/audio_alsa.h b/src/decomp/pc/audio/audio_alsa.h new file mode 100644 index 0000000..199d9cf --- /dev/null +++ b/src/decomp/pc/audio/audio_alsa.h @@ -0,0 +1,13 @@ +#ifndef AUDIO_ALSA_H +#define AUDIO_ALSA_H + +#include "../compat.h" + +#if defined(__linux__) || defined(__BSD__) +extern struct AudioAPI audio_alsa; +#define HAVE_ALSA 1 +#else +#define HAVE_ALSA 0 +#endif + +#endif diff --git a/src/decomp/pc/audio/audio_api.h b/src/decomp/pc/audio/audio_api.h new file mode 100644 index 0000000..26794dd --- /dev/null +++ b/src/decomp/pc/audio/audio_api.h @@ -0,0 +1,15 @@ +#ifndef AUDIO_API_H +#define AUDIO_API_H + +#include +#include +#include + +struct AudioAPI { + bool (*init)(void); + int (*buffered)(void); + int (*get_desired_buffered)(void); + void (*play)(const uint8_t *buf, size_t len); +}; + +#endif diff --git a/src/decomp/pc/audio/audio_null.c b/src/decomp/pc/audio/audio_null.c new file mode 100644 index 0000000..aa87add --- /dev/null +++ b/src/decomp/pc/audio/audio_null.c @@ -0,0 +1,24 @@ +#include +#include "audio_api.h" + +static bool audio_null_init(void) { + return true; +} + +static int audio_null_buffered(void) { + return 0; +} + +static int audio_null_get_desired_buffered(void) { + return 0; +} + +static void audio_null_play(UNUSED const uint8_t *buf, UNUSED size_t len) { +} + +struct AudioAPI audio_null = { + audio_null_init, + audio_null_buffered, + audio_null_get_desired_buffered, + audio_null_play +}; diff --git a/src/decomp/pc/audio/audio_null.h b/src/decomp/pc/audio/audio_null.h new file mode 100644 index 0000000..59748bc --- /dev/null +++ b/src/decomp/pc/audio/audio_null.h @@ -0,0 +1,8 @@ +#ifndef AUDIO_NULL_H +#define AUDIO_NULL_H + +#include "audio_api.h" + +extern struct AudioAPI audio_null; + +#endif diff --git a/src/decomp/pc/audio/audio_pulse.c b/src/decomp/pc/audio/audio_pulse.c new file mode 100644 index 0000000..385cb5e --- /dev/null +++ b/src/decomp/pc/audio/audio_pulse.c @@ -0,0 +1,206 @@ +#include "../compat.h" + +#if defined(__linux__) || defined(__BSD__) + +#include +#include +#include + +#include "macros.h" +#include "audio_api.h" + +static struct { + pa_mainloop *mainloop; + pa_context *context; + pa_stream *stream; + pa_buffer_attr attr; + bool write_complete; +} pas; + +static void pas_context_state_cb(pa_context *c, void *userdata) { + switch (pa_context_get_state(c)) { + case PA_CONTEXT_READY: + case PA_CONTEXT_TERMINATED: + case PA_CONTEXT_FAILED: + *((bool *)userdata) = true; + break; + default: + break; + } +} + +static void pas_stream_state_cb(pa_stream *s, void *userdata) { + switch (pa_stream_get_state(s)) { + case PA_STREAM_READY: + case PA_STREAM_FAILED: + case PA_STREAM_TERMINATED: + *((bool *)userdata) = true; + break; + default: + break; + } +} + +static void pas_stream_write_cb(UNUSED pa_stream *s, UNUSED size_t length, UNUSED void *userdata) { + //size_t ws = pa_stream_writable_size(pas.stream); + //printf("write cb: %d %d\n", (int)length, (int)ws); +} + +static bool audio_pulse_init(void) { + // Create mainloop + pas.mainloop = pa_mainloop_new(); + if (pas.mainloop == NULL) { + return false; + } + + // Create context and connect + pas.context = pa_context_new(pa_mainloop_get_api(pas.mainloop), "Super Mario 64"); + if (pas.context == NULL) { + goto fail; + } + + bool done = false; + pa_context_set_state_callback(pas.context, pas_context_state_cb, &done); + + if (pa_context_connect(pas.context, NULL, 0, NULL) < 0) { + goto fail; + } + + while (!done) { + pa_mainloop_iterate(pas.mainloop, true, NULL); + } + pa_context_set_state_callback(pas.context, NULL, NULL); + if (pa_context_get_state(pas.context) != PA_CONTEXT_READY) { + goto fail; + } + + // Create stream + pa_sample_spec ss; + ss.format = PA_SAMPLE_S16LE; + ss.rate = 32000; + ss.channels = 2; + + pa_buffer_attr attr; + attr.maxlength = (1600 + 544 + 528 + 1600) * 4; + attr.tlength = (528*2 + 544) * 4; + attr.prebuf = 1500 * 4; + attr.minreq = 161 * 4; + attr.fragsize = (uint32_t)-1; + + pas.stream = pa_stream_new(pas.context, "mario", &ss, NULL); + if (pas.stream == NULL) { + goto fail; + } + + done = false; + pa_stream_set_state_callback(pas.stream, pas_stream_state_cb, &done); + pa_stream_set_write_callback(pas.stream, pas_stream_write_cb, NULL); + if (pa_stream_connect_playback(pas.stream, NULL, &attr, PA_STREAM_ADJUST_LATENCY, NULL, NULL) < 0) { + goto fail; + } + + while (!done) { + pa_mainloop_iterate(pas.mainloop, true, NULL); + } + pa_stream_set_state_callback(pas.stream, NULL, NULL); + if (pa_stream_get_state(pas.stream) != PA_STREAM_READY) { + goto fail; + } + + const pa_buffer_attr *applied_attr = pa_stream_get_buffer_attr(pas.stream); + printf("maxlength: %u\ntlength: %u\nprebuf: %u\nminreq: %u\nfragsize: %u\n", + applied_attr->maxlength, applied_attr->tlength, applied_attr->prebuf, applied_attr->minreq, applied_attr->fragsize); + pas.attr = *applied_attr; + + return true; + +fail: + if (pas.stream != NULL) { + pa_stream_unref(pas.stream); + pas.stream = NULL; + } + if (pas.context != NULL) { + pa_context_disconnect(pas.context); + pa_context_unref(pas.context); + pas.context = NULL; + } + if (pas.mainloop != NULL) { + pa_mainloop_free(pas.mainloop); + pas.mainloop = NULL; + } + return false; +} + +static void pas_update_complete(UNUSED pa_stream *stream, UNUSED int success, void *userdata) { + *(bool *)userdata = true; +} + +static void pas_update(void) { + bool done = false; + pa_stream_update_timing_info(pas.stream, pas_update_complete, &done); + while (!done) { + pa_mainloop_iterate(pas.mainloop, true, NULL); + } +} + +static void pas_write_complete(UNUSED void *p) { + pas.write_complete = true; +} + +static int audio_pulse_buffered(void) { + if (pas.stream == NULL) { + return 0; + } + pas_update(); + const pa_timing_info *info = pa_stream_get_timing_info(pas.stream); + if (info == NULL) { + printf("pa_stream_get_timing_info failed, state is %d\n", pa_stream_get_state(pas.stream)); + } + /*int diff = info->write_index - info->read_index + (int)(info->sink_usec * 0.128); + pa_usec_t usec; + pa_stream_get_time(pas.stream, &usec); + int32_t t = info->timestamp.tv_sec * 1000000 + info->timestamp.tv_usec - (usec - info->transport_usec); + static int t0; + if (t0 == 0) t0 = t;*/ + + /*int r = pa_mainloop_iterate(pas.mainloop, false, NULL); + size_t ws = pa_stream_writable_size(pas.stream); + printf("Writable: %d (%d) %d %d %d %d %llu %d\n", (int)ws, r, (int)(info->write_index - info->read_index), diff, (int)info->sink_usec, (int)info->transport_usec, (unsigned long long)usec, t - t0);*/ + //return (pas.attr.tlength - ws) / 4; + return (info->write_index - info->read_index) / 4; +} + +static int audio_pulse_get_desired_buffered(void) { + return 1100; +} + +static void audio_pulse_play(const uint8_t *buf, size_t len) { + if (pas.stream == NULL) { + if (!audio_pulse_init()) { + return; + } + } + //size_t ws = pa_stream_writable_size(pas.stream); + size_t ws = pas.attr.maxlength - audio_pulse_buffered() * 4; + if (ws < len) { + //printf("Warning: can't write everything: %d vs %d\n", (int)len, (int)ws); + len = ws; + } + if (pa_stream_write(pas.stream, buf, len, pas_write_complete, 0LL, PA_SEEK_RELATIVE) < 0) { + printf("pa_stream_write failed\n"); + return; + } + while (!pas.write_complete) { + pa_mainloop_iterate(pas.mainloop, true, NULL); + } + pas.write_complete = false; +} + +struct AudioAPI audio_pulse = { + audio_pulse_init, + audio_pulse_buffered, + audio_pulse_get_desired_buffered, + audio_pulse_play +}; + +#endif diff --git a/src/decomp/pc/audio/audio_pulse.h b/src/decomp/pc/audio/audio_pulse.h new file mode 100644 index 0000000..c4d7e4b --- /dev/null +++ b/src/decomp/pc/audio/audio_pulse.h @@ -0,0 +1,13 @@ +#ifndef AUDIO_PULSE_H +#define AUDIO_PULSE_H + +#include "../compat.h" + +#if defined(__linux__) || defined(__BSD__) +extern struct AudioAPI audio_pulse; +#define HAVE_PULSE_AUDIO 1 +#else +#define HAVE_PULSE_AUDIO 0 +#endif + +#endif diff --git a/src/decomp/pc/audio/audio_wasapi.cpp b/src/decomp/pc/audio/audio_wasapi.cpp new file mode 100644 index 0000000..427d66a --- /dev/null +++ b/src/decomp/pc/audio/audio_wasapi.cpp @@ -0,0 +1,219 @@ +#if defined(_WIN32) || defined(_WIN64) + +#include +#include + +#include +#include +#include +#include +#include + +#include "audio_api.h" + +#include "../../../debug_print.h" + +// These constants are currently missing from the MinGW headers. +#ifndef AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM +# define AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM 0x80000000 +#endif +#ifndef AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY +# define AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY 0x08000000 +#endif + +using namespace Microsoft::WRL; + +const CLSID CLSID_MMDeviceEnumerator = __uuidof(MMDeviceEnumerator); +const IID IID_IMMDeviceEnumerator = __uuidof(IMMDeviceEnumerator); +const IID IID_IAudioClient = __uuidof(IAudioClient); +const IID IID_IAudioRenderClient = __uuidof(IAudioRenderClient); + +static ComPtr immdev_enumerator; + +static struct WasapiState { + ComPtr device; + ComPtr client; + ComPtr rclient; + UINT32 buffer_frame_count; + bool initialized; + bool started; +} wasapi; + +static class NotificationClient : public IMMNotificationClient { + LONG refcount; +public: + NotificationClient() : refcount(1) { + } + + virtual HRESULT STDMETHODCALLTYPE OnDeviceStateChanged(LPCWSTR pwstrDeviceId, DWORD dwNewState) { + return S_OK; + } + + virtual HRESULT STDMETHODCALLTYPE OnDeviceAdded(LPCWSTR pwstrDeviceId) { + return S_OK; + } + + virtual HRESULT STDMETHODCALLTYPE OnDeviceRemoved(LPCWSTR pwstrDeviceId) { + return S_OK; + } + + virtual HRESULT STDMETHODCALLTYPE OnDefaultDeviceChanged(EDataFlow flow, ERole role, LPCWSTR pwstrDefaultDeviceId) { + if (flow == eRender && role == eConsole) { + // This callback runs on a separate thread, + // but it's not important how fast this write takes effect. + wasapi.initialized = false; + } + return S_OK; + } + + virtual HRESULT STDMETHODCALLTYPE OnPropertyValueChanged(LPCWSTR pwstrDeviceId, const PROPERTYKEY key) { + return S_OK; + } + + virtual ULONG STDMETHODCALLTYPE AddRef() { + return InterlockedIncrement(&refcount); + } + + virtual ULONG STDMETHODCALLTYPE Release() { + ULONG rc = InterlockedDecrement(&refcount); + if (rc == 0) { + delete this; + } + return rc; + } + + virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, VOID **ppvInterface) { + if (riid == __uuidof(IUnknown)) { + AddRef(); + *ppvInterface = (IUnknown *)this; + } else if (riid == __uuidof(IMMNotificationClient)) { + AddRef(); + *ppvInterface = (IMMNotificationClient *)this; + } else { + *ppvInterface = nullptr; + return E_NOINTERFACE; + } + return S_OK; + } +} notification_client; + +static void ThrowIfFailed(HRESULT res) { + if (FAILED(res)) { + throw res; + } +} + +bool audio_wasapi_init(void) { + CoInitialize(NULL); + //DEBUG_PRINT("audio init!!!"); + try { + ThrowIfFailed(CoCreateInstance(CLSID_MMDeviceEnumerator, nullptr, CLSCTX_ALL, IID_PPV_ARGS(&immdev_enumerator))); + } catch (HRESULT res) { + //DEBUG_PRINT("audio init fail!!! %d", res); + return false; + } + + ThrowIfFailed(immdev_enumerator->RegisterEndpointNotificationCallback(new NotificationClient())); + //DEBUG_PRINT("audio init OK!!!"); + return true; +} + +static bool audio_wasapi_setup_stream(void) { + //DEBUG_PRINT("audio audio_wasapi_setup_stream!!!"); + wasapi = WasapiState(); + + try { + ThrowIfFailed(immdev_enumerator->GetDefaultAudioEndpoint(eRender, eConsole, &wasapi.device)); + ThrowIfFailed(wasapi.device->Activate(IID_IAudioClient, CLSCTX_ALL, nullptr, IID_PPV_ARGS_Helper(&wasapi.client))); + + WAVEFORMATEX desired; + desired.wFormatTag = WAVE_FORMAT_PCM; + desired.nChannels = 2; + desired.nSamplesPerSec = 32000; + desired.nAvgBytesPerSec = 32000 * 2 * 2; + desired.nBlockAlign = 4; + desired.wBitsPerSample = 16; + desired.cbSize = 0; + + ThrowIfFailed(wasapi.client->Initialize(AUDCLNT_SHAREMODE_SHARED, AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM | AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY, 2000000, 0, &desired, nullptr)); + + ThrowIfFailed(wasapi.client->GetBufferSize(&wasapi.buffer_frame_count)); + ThrowIfFailed(wasapi.client->GetService(IID_PPV_ARGS(&wasapi.rclient))); + + wasapi.started = false; + wasapi.initialized = true; + } catch (HRESULT res) { + wasapi = WasapiState(); + return false; + } + + return true; +} + +static int audio_wasapi_buffered(void) { + //DEBUG_PRINT("audio audio_wasapi_buffered!!!"); + if (!wasapi.initialized) { + if (!audio_wasapi_setup_stream()) { + return 0; + } + } + try { + UINT32 padding; + ThrowIfFailed(wasapi.client->GetCurrentPadding(&padding)); + return padding; + } catch (HRESULT res) { + wasapi = WasapiState(); + return 0; + } +} + +static int audio_wasapi_get_desired_buffered(void) { + //DEBUG_PRINT("audio audio_wasapi_get_desired_buffered!!!"); + return 1100; +} + +//#include +static void audio_wasapi_play(const uint8_t *buf, size_t len) { + //DEBUG_PRINT("audio audio_wasapi_play!!!"); + if (!wasapi.initialized) { + if (!audio_wasapi_setup_stream()) { + return; + } + } + try { + UINT32 frames = len / 4; + + UINT32 padding; + ThrowIfFailed(wasapi.client->GetCurrentPadding(&padding)); + if(padding >= 5400) + return; + //printf("%u %u\n", frames, padding); + + UINT32 available = wasapi.buffer_frame_count - padding; + if (available < frames) { + frames = available; + + } + + BYTE *data; + ThrowIfFailed(wasapi.rclient->GetBuffer(frames, &data)); + memcpy(data, buf, frames * 4); + ThrowIfFailed(wasapi.rclient->ReleaseBuffer(frames, 0)); + + if (!wasapi.started && padding + frames > 1500) { + wasapi.started = true; + ThrowIfFailed(wasapi.client->Start()); + } + } catch (HRESULT res) { + wasapi = WasapiState(); + } +} + +struct AudioAPI audio_wasapi = { + audio_wasapi_init, + audio_wasapi_buffered, + audio_wasapi_get_desired_buffered, + audio_wasapi_play +}; + +#endif diff --git a/src/decomp/pc/audio/audio_wasapi.h b/src/decomp/pc/audio/audio_wasapi.h new file mode 100644 index 0000000..b0aab11 --- /dev/null +++ b/src/decomp/pc/audio/audio_wasapi.h @@ -0,0 +1,12 @@ +#ifndef AUDIO_WASAPI_H +#define AUDIO_WASAPI_H + +#if defined(_WIN32) || defined(_WIN64) +#include "audio_api.h" +extern struct AudioAPI audio_wasapi; +#define HAVE_WASAPI 1 +#else +#define HAVE_WASAPI 0 +#endif + +#endif diff --git a/src/decomp/pc/compat.h b/src/decomp/pc/compat.h new file mode 100644 index 0000000..8d6a3d4 --- /dev/null +++ b/src/decomp/pc/compat.h @@ -0,0 +1,8 @@ +#ifndef COMPAT_H +#define COMPAT_H value + +#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) +#define __BSD__ +#endif + +#endif \ No newline at end of file diff --git a/src/decomp/pc/configfile.c b/src/decomp/pc/configfile.c new file mode 100644 index 0000000..10ff1e6 --- /dev/null +++ b/src/decomp/pc/configfile.c @@ -0,0 +1,236 @@ +// configfile.c - handles loading and saving the configuration options +#include +#include +#include +#include +#include +#include + +#include "configfile.h" + +#define ARRAY_LEN(arr) (sizeof(arr) / sizeof(arr[0])) + +enum ConfigOptionType { + CONFIG_TYPE_BOOL, + CONFIG_TYPE_UINT, + CONFIG_TYPE_FLOAT, +}; + +struct ConfigOption { + const char *name; + enum ConfigOptionType type; + union { + bool *boolValue; + unsigned int *uintValue; + float *floatValue; + }; +}; + +/* + *Config options and default values + */ +bool configFullscreen = false; +// Keyboard mappings (scancode values) +unsigned int configKeyA = 0x26; +unsigned int configKeyB = 0x33; +unsigned int configKeyStart = 0x39; +unsigned int configKeyR = 0x36; +unsigned int configKeyZ = 0x25; +unsigned int configKeyCUp = 0x148; +unsigned int configKeyCDown = 0x150; +unsigned int configKeyCLeft = 0x14B; +unsigned int configKeyCRight = 0x14D; +unsigned int configKeyStickUp = 0x11; +unsigned int configKeyStickDown = 0x1F; +unsigned int configKeyStickLeft = 0x1E; +unsigned int configKeyStickRight = 0x20; + + +static const struct ConfigOption options[] = { + {.name = "fullscreen", .type = CONFIG_TYPE_BOOL, .boolValue = &configFullscreen}, + {.name = "key_a", .type = CONFIG_TYPE_UINT, .uintValue = &configKeyA}, + {.name = "key_b", .type = CONFIG_TYPE_UINT, .uintValue = &configKeyB}, + {.name = "key_start", .type = CONFIG_TYPE_UINT, .uintValue = &configKeyStart}, + {.name = "key_r", .type = CONFIG_TYPE_UINT, .uintValue = &configKeyR}, + {.name = "key_z", .type = CONFIG_TYPE_UINT, .uintValue = &configKeyZ}, + {.name = "key_cup", .type = CONFIG_TYPE_UINT, .uintValue = &configKeyCUp}, + {.name = "key_cdown", .type = CONFIG_TYPE_UINT, .uintValue = &configKeyCDown}, + {.name = "key_cleft", .type = CONFIG_TYPE_UINT, .uintValue = &configKeyCLeft}, + {.name = "key_cright", .type = CONFIG_TYPE_UINT, .uintValue = &configKeyCRight}, + {.name = "key_stickup", .type = CONFIG_TYPE_UINT, .uintValue = &configKeyStickUp}, + {.name = "key_stickdown", .type = CONFIG_TYPE_UINT, .uintValue = &configKeyStickDown}, + {.name = "key_stickleft", .type = CONFIG_TYPE_UINT, .uintValue = &configKeyStickLeft}, + {.name = "key_stickright", .type = CONFIG_TYPE_UINT, .uintValue = &configKeyStickRight}, +}; + +// Reads an entire line from a file (excluding the newline character) and returns an allocated string +// Returns NULL if no lines could be read from the file +static char *read_file_line(FILE *file) { + char *buffer; + size_t bufferSize = 8; + size_t offset = 0; // offset in buffer to write + + buffer = malloc(bufferSize); + while (1) { + // Read a line from the file + if (fgets(buffer + offset, bufferSize - offset, file) == NULL) { + free(buffer); + return NULL; // Nothing could be read. + } + offset = strlen(buffer); + assert(offset > 0); + + // If a newline was found, remove the trailing newline and exit + if (buffer[offset - 1] == '\n') { + buffer[offset - 1] = '\0'; + break; + } + + if (feof(file)) // EOF was reached + break; + + // If no newline or EOF was reached, then the whole line wasn't read. + bufferSize *= 2; // Increase buffer size + buffer = realloc(buffer, bufferSize); + assert(buffer != NULL); + } + + return buffer; +} + +// Returns the position of the first non-whitespace character +static char *skip_whitespace(char *str) { + while (isspace(*str)) + str++; + return str; +} + +// NULL-terminates the current whitespace-delimited word, and returns a pointer to the next word +static char *word_split(char *str) { + // Precondition: str must not point to whitespace + assert(!isspace(*str)); + + // Find either the next whitespace char or end of string + while (!isspace(*str) && *str != '\0') + str++; + if (*str == '\0') // End of string + return str; + + // Terminate current word + *(str++) = '\0'; + + // Skip whitespace to next word + return skip_whitespace(str); +} + +// Splits a string into words, and stores the words into the 'tokens' array +// 'maxTokens' is the length of the 'tokens' array +// Returns the number of tokens parsed +static unsigned int tokenize_string(char *str, int maxTokens, char **tokens) { + int count = 0; + + str = skip_whitespace(str); + while (str[0] != '\0' && count < maxTokens) { + tokens[count] = str; + str = word_split(str); + count++; + } + return count; +} + +// Loads the config file specified by 'filename' +void configfile_load(const char *filename) { + FILE *file; + char *line; + + printf("Loading configuration from '%s'\n", filename); + + file = fopen(filename, "r"); + if (file == NULL) { + // Create a new config file and save defaults + printf("Config file '%s' not found. Creating it.\n", filename); + configfile_save(filename); + return; + } + + // Go through each line in the file + while ((line = read_file_line(file)) != NULL) { + char *p = line; + char *tokens[2]; + int numTokens; + + while (isspace(*p)) + p++; + numTokens = tokenize_string(p, 2, tokens); + if (numTokens != 0) { + if (numTokens == 2) { + const struct ConfigOption *option = NULL; + + for (unsigned int i = 0; i < ARRAY_LEN(options); i++) { + if (strcmp(tokens[0], options[i].name) == 0) { + option = &options[i]; + break; + } + } + if (option == NULL) + printf("unknown option '%s'\n", tokens[0]); + else { + switch (option->type) { + case CONFIG_TYPE_BOOL: + if (strcmp(tokens[1], "true") == 0) + *option->boolValue = true; + else if (strcmp(tokens[1], "false") == 0) + *option->boolValue = false; + break; + case CONFIG_TYPE_UINT: + sscanf(tokens[1], "%u", option->uintValue); + break; + case CONFIG_TYPE_FLOAT: + sscanf(tokens[1], "%f", option->floatValue); + break; + default: + assert(0); // bad type + } + printf("option: '%s', value: '%s'\n", tokens[0], tokens[1]); + } + } else + puts("error: expected value"); + } + free(line); + } + + fclose(file); +} + +// Writes the config file to 'filename' +void configfile_save(const char *filename) { + FILE *file; + + printf("Saving configuration to '%s'\n", filename); + + file = fopen(filename, "w"); + if (file == NULL) { + // error + return; + } + + for (unsigned int i = 0; i < ARRAY_LEN(options); i++) { + const struct ConfigOption *option = &options[i]; + + switch (option->type) { + case CONFIG_TYPE_BOOL: + fprintf(file, "%s %s\n", option->name, *option->boolValue ? "true" : "false"); + break; + case CONFIG_TYPE_UINT: + fprintf(file, "%s %u\n", option->name, *option->uintValue); + break; + case CONFIG_TYPE_FLOAT: + fprintf(file, "%s %f\n", option->name, *option->floatValue); + break; + default: + assert(0); // unknown type + } + } + + fclose(file); +} diff --git a/src/decomp/pc/configfile.h b/src/decomp/pc/configfile.h new file mode 100644 index 0000000..ae9070b --- /dev/null +++ b/src/decomp/pc/configfile.h @@ -0,0 +1,22 @@ +#ifndef CONFIGFILE_H +#define CONFIGFILE_H + +extern bool configFullscreen; +extern unsigned int configKeyA; +extern unsigned int configKeyB; +extern unsigned int configKeyStart; +extern unsigned int configKeyR; +extern unsigned int configKeyZ; +extern unsigned int configKeyCUp; +extern unsigned int configKeyCDown; +extern unsigned int configKeyCLeft; +extern unsigned int configKeyCRight; +extern unsigned int configKeyStickUp; +extern unsigned int configKeyStickDown; +extern unsigned int configKeyStickLeft; +extern unsigned int configKeyStickRight; + +void configfile_load(const char *filename); +void configfile_save(const char *filename); + +#endif diff --git a/src/decomp/pc/controller/controller_api.h b/src/decomp/pc/controller/controller_api.h new file mode 100644 index 0000000..dd318a8 --- /dev/null +++ b/src/decomp/pc/controller/controller_api.h @@ -0,0 +1,11 @@ +#ifndef CONTROLLER_API +#define CONTROLLER_API + +#include + +struct ControllerAPI { + void (*init)(void); + void (*read)(OSContPad *pad); +}; + +#endif diff --git a/src/decomp/pc/controller/controller_emscripten_keyboard.c b/src/decomp/pc/controller/controller_emscripten_keyboard.c new file mode 100644 index 0000000..cf78cf6 --- /dev/null +++ b/src/decomp/pc/controller/controller_emscripten_keyboard.c @@ -0,0 +1,151 @@ +#ifdef TARGET_WEB + +#include +#include +#include "macros.h" +#include "controller_keyboard.h" + +static const struct { + const char *code; + int scancode; +} keymap_browser[] = { + {"Escape", 0x01}, + {"Digit1", 0x02 }, + {"Digit2", 0x03 }, + {"Digit3", 0x04 }, + {"Digit4", 0x05 }, + {"Digit5", 0x06 }, + {"Digit6", 0x07 }, + {"Digit7", 0x08 }, + {"Digit8", 0x09 }, + {"Digit9", 0x0a }, + {"Digit0", 0x0b }, + {"Minus", 0x0c }, + {"Equal", 0x0d }, + {"Backspace", 0x0e }, + {"Tab", 0x0f }, + {"KeyQ", 0x10 }, + {"KeyW", 0x11 }, + {"KeyE", 0x12 }, + {"KeyR", 0x13 }, + {"KeyT", 0x14 }, + {"KeyY", 0x15 }, + {"KeyU", 0x16 }, + {"KeyI", 0x17 }, + {"KeyO", 0x18 }, + {"KeyP", 0x19 }, + {"BracketLeft", 0x1a }, + {"BracketRight", 0x1b }, + {"Enter", 0x1c }, + {"ControlLeft", 0x1d }, + {"KeyA", 0x1e }, + {"KeyS", 0x1f }, + {"KeyD", 0x20 }, + {"KeyF", 0x21 }, + {"KeyG", 0x22 }, + {"KeyH", 0x23 }, + {"KeyJ", 0x24 }, + {"KeyK", 0x25 }, + {"KeyL", 0x26 }, + {"Semicolon", 0x27 }, + {"Quote", 0x28 }, + {"Backquote", 0x29 }, + {"ShiftLeft", 0x2a }, + {"Backslash", 0x2b }, + {"KeyZ", 0x2c }, + {"KeyX", 0x2d }, + {"KeyC", 0x2e }, + {"KeyV", 0x2f }, + {"KeyB", 0x30 }, + {"KeyN", 0x31 }, + {"KeyM", 0x32 }, + {"Comma", 0x33 }, + {"Period", 0x34 }, + {"Slash", 0x35 }, + {"ShiftRight", 0x36 }, + {"NumpadMultiply", 0x37 }, + {"AltLeft", 0x38 }, + {"Space", 0x39 }, + {"CapsLock", 0x3a }, + {"F1", 0x3b }, + {"F2", 0x3c }, + {"F3", 0x3d }, + {"F4", 0x3e }, + {"F5", 0x3f }, + {"F6", 0x40 }, + {"F7", 0x41 }, + {"F8", 0x42 }, + {"F9", 0x43 }, + {"F10", 0x44 }, + {"NumLock", 0x45 }, + {"ScrollLock", 0x46 }, + {"Numpad7", 0x47 }, + {"Numpad8", 0x48 }, + {"Numpad9", 0x49 }, + {"NumpadSubtract", 0x4a }, + {"Numpad4", 0x4b }, + {"Numpad5", 0x4c }, + {"Numpad6", 0x4d }, + {"NumpadAdd", 0x4e }, + {"Numpad1", 0x4f }, + {"Numpad2", 0x50 }, + {"Numpad3", 0x51 }, + {"Numpad0", 0x52 }, + {"NumpadDecimal", 0x53 }, + {"PrintScreen", 0x54 }, + // 0x55 + {"IntlBackslash", 0x56 }, + {"F11", 0x57 }, + {"F12", 0x58 }, + {"IntlRo", 0x59 }, + //{"Katakana", 0 }, + //{"Hiragana", 0 }, + {"NumpadEnter", 0x11c }, + {"ControlRight", 0x11d }, + {"NumpadDivide", 0x135 }, + {"AltRight", 0x138 }, + {"Home", 0x147 }, + {"ArrowUp", 0x148 }, + {"PageUp", 0x149 }, + {"ArrowLeft", 0x14b }, + {"ArrowRight", 0x14d }, + {"End", 0x14f }, + {"ArrowDown", 0x150 }, + {"PageDown", 0x151 }, + {"Insert", 0x152 }, + {"Delete", 0x153 }, + {"Pause", 0x21d }, + {"MetaLeft", 0x15b }, + {"MetaRight", 0x15c }, + {"ContextMenu", 0x15d }, +}; + +static EM_BOOL controller_emscripten_keyboard_handler(int event_type, const EmscriptenKeyboardEvent *key_event, UNUSED void *user_data) { + for (size_t i = 0; i < sizeof(keymap_browser) / sizeof(keymap_browser[0]); i++) { + if (strcmp(key_event->code, keymap_browser[i].code) == 0) { + if (event_type == EMSCRIPTEN_EVENT_KEYDOWN) { + return keyboard_on_key_down(keymap_browser[i].scancode); + } else if (event_type == EMSCRIPTEN_EVENT_KEYUP) { + return keyboard_on_key_up(keymap_browser[i].scancode); + } + break; + } + } + return EM_FALSE; +} + +static EM_BOOL controller_emscripten_keyboard_blur_handler(UNUSED int event_type, UNUSED const EmscriptenFocusEvent *focus_event, UNUSED void *user_data) { + keyboard_on_all_keys_up(); + return EM_TRUE; +} + +void controller_emscripten_keyboard_init(void) { + // Should be #window according to docs, but that crashes + const char *target = EMSCRIPTEN_EVENT_TARGET_WINDOW; + + emscripten_set_keydown_callback(target, NULL, EM_FALSE, controller_emscripten_keyboard_handler); + emscripten_set_keyup_callback(target, NULL, EM_FALSE, controller_emscripten_keyboard_handler); + emscripten_set_blur_callback(target, NULL, EM_FALSE, controller_emscripten_keyboard_blur_handler); +} + +#endif diff --git a/src/decomp/pc/controller/controller_emscripten_keyboard.h b/src/decomp/pc/controller/controller_emscripten_keyboard.h new file mode 100644 index 0000000..9b72873 --- /dev/null +++ b/src/decomp/pc/controller/controller_emscripten_keyboard.h @@ -0,0 +1,8 @@ +#ifndef CONTROLLER_KEYBOARD_EMSCRIPTEN_H +#define CONTROLLER_KEYBOARD_EMSCRIPTEN_H + +#ifdef TARGET_WEB +void controller_emscripten_keyboard_init(void); +#endif + +#endif diff --git a/src/decomp/pc/controller/controller_entry_point.c b/src/decomp/pc/controller/controller_entry_point.c new file mode 100644 index 0000000..f86cf0d --- /dev/null +++ b/src/decomp/pc/controller/controller_entry_point.c @@ -0,0 +1,53 @@ +#include "macros.h" + +#include "lib/src/libultra_internal.h" +#include "lib/src/osContInternal.h" + +#include "controller_recorded_tas.h" +#include "controller_keyboard.h" + +#if defined(_WIN32) || defined(_WIN64) +#include "controller_xinput.h" +#else +#include "controller_sdl.h" +#endif + +#ifdef __linux__ +#include "controller_wup.h" +#endif + +static struct ControllerAPI *controller_implementations[] = { + &controller_recorded_tas, +#if defined(_WIN32) || defined(_WIN64) + &controller_xinput, +#else + &controller_sdl, +#endif +#ifdef __linux__ + &controller_wup, +#endif + &controller_keyboard, +}; + +s32 osContInit(UNUSED OSMesgQueue *mq, u8 *controllerBits, UNUSED OSContStatus *status) { + for (size_t i = 0; i < sizeof(controller_implementations) / sizeof(struct ControllerAPI *); i++) { + controller_implementations[i]->init(); + } + *controllerBits = 1; + return 0; +} + +s32 osContStartReadData(UNUSED OSMesgQueue *mesg) { + return 0; +} + +void osContGetReadData(OSContPad *pad) { + pad->button = 0; + pad->stick_x = 0; + pad->stick_y = 0; + pad->errnum = 0; + + for (size_t i = 0; i < sizeof(controller_implementations) / sizeof(struct ControllerAPI *); i++) { + controller_implementations[i]->read(pad); + } +} diff --git a/src/decomp/pc/controller/controller_keyboard.c b/src/decomp/pc/controller/controller_keyboard.c new file mode 100644 index 0000000..a49b86a --- /dev/null +++ b/src/decomp/pc/controller/controller_keyboard.c @@ -0,0 +1,88 @@ +#include +#include + +#include "controller_api.h" + +#ifdef TARGET_WEB +#include "controller_emscripten_keyboard.h" +#endif + +#include "../configfile.h" + +static int keyboard_buttons_down; + +static int keyboard_mapping[13][2]; + +static int keyboard_map_scancode(int scancode) { + int ret = 0; + for (size_t i = 0; i < sizeof(keyboard_mapping) / sizeof(keyboard_mapping[0]); i++) { + if (keyboard_mapping[i][0] == scancode) { + ret |= keyboard_mapping[i][1]; + } + } + return ret; +} + +bool keyboard_on_key_down(int scancode) { + int mapped = keyboard_map_scancode(scancode); + keyboard_buttons_down |= mapped; + return mapped != 0; +} + +bool keyboard_on_key_up(int scancode) { + int mapped = keyboard_map_scancode(scancode); + keyboard_buttons_down &= ~mapped; + return mapped != 0; +} + +void keyboard_on_all_keys_up(void) { + keyboard_buttons_down = 0; +} + +static void set_keyboard_mapping(int index, int mask, int scancode) { + keyboard_mapping[index][0] = scancode; + keyboard_mapping[index][1] = mask; +} + +static void keyboard_init(void) { + int i = 0; + + set_keyboard_mapping(i++, 0x80000, configKeyStickUp); + set_keyboard_mapping(i++, 0x10000, configKeyStickLeft); + set_keyboard_mapping(i++, 0x40000, configKeyStickDown); + set_keyboard_mapping(i++, 0x20000, configKeyStickRight); + set_keyboard_mapping(i++, A_BUTTON, configKeyA); + set_keyboard_mapping(i++, B_BUTTON, configKeyB); + set_keyboard_mapping(i++, Z_TRIG, configKeyZ); + set_keyboard_mapping(i++, U_CBUTTONS, configKeyCUp); + set_keyboard_mapping(i++, L_CBUTTONS, configKeyCLeft); + set_keyboard_mapping(i++, D_CBUTTONS, configKeyCDown); + set_keyboard_mapping(i++, R_CBUTTONS, configKeyCRight); + set_keyboard_mapping(i++, R_TRIG, configKeyR); + set_keyboard_mapping(i++, START_BUTTON, configKeyStart); + +#ifdef TARGET_WEB + controller_emscripten_keyboard_init(); +#endif +} + +static void keyboard_read(OSContPad *pad) { + pad->button |= keyboard_buttons_down; + if ((keyboard_buttons_down & 0x30000) == 0x10000) { + pad->stick_x = -128; + } + if ((keyboard_buttons_down & 0x30000) == 0x20000) { + pad->stick_x = 127; + } + if ((keyboard_buttons_down & 0xc0000) == 0x40000) { + pad->stick_y = -128; + } + if ((keyboard_buttons_down & 0xc0000) == 0x80000) { + pad->stick_y = 127; + } +} + +struct ControllerAPI controller_keyboard = { + keyboard_init, + keyboard_read +}; diff --git a/src/decomp/pc/controller/controller_keyboard.h b/src/decomp/pc/controller/controller_keyboard.h new file mode 100644 index 0000000..e2c0858 --- /dev/null +++ b/src/decomp/pc/controller/controller_keyboard.h @@ -0,0 +1,19 @@ +#ifndef CONTROLLER_KEYBOARD_H +#define CONTROLLER_KEYBOARD_H + +#include +#include "controller_api.h" + +#ifdef __cplusplus +extern "C" { +#endif +bool keyboard_on_key_down(int scancode); +bool keyboard_on_key_up(int scancode); +void keyboard_on_all_keys_up(void); +#ifdef __cplusplus +} +#endif + +extern struct ControllerAPI controller_keyboard; + +#endif diff --git a/src/decomp/pc/controller/controller_recorded_tas.c b/src/decomp/pc/controller/controller_recorded_tas.c new file mode 100644 index 0000000..4f5c1bb --- /dev/null +++ b/src/decomp/pc/controller/controller_recorded_tas.c @@ -0,0 +1,29 @@ +#include +#include + +#include "controller_api.h" + +static FILE *fp; + +static void tas_init(void) { + fp = fopen("cont.m64", "rb"); + if (fp != NULL) { + uint8_t buf[0x400]; + fread(buf, 1, sizeof(buf), fp); + } +} + +static void tas_read(OSContPad *pad) { + if (fp != NULL) { + uint8_t bytes[4] = {0}; + fread(bytes, 1, 4, fp); + pad->button = (bytes[0] << 8) | bytes[1]; + pad->stick_x = bytes[2]; + pad->stick_y = bytes[3]; + } +} + +struct ControllerAPI controller_recorded_tas = { + tas_init, + tas_read +}; diff --git a/src/decomp/pc/controller/controller_recorded_tas.h b/src/decomp/pc/controller/controller_recorded_tas.h new file mode 100644 index 0000000..15ead4b --- /dev/null +++ b/src/decomp/pc/controller/controller_recorded_tas.h @@ -0,0 +1,8 @@ +#ifndef CONTROLLER_RECORDED_TAS_H +#define CONTROLLER_RECORDED_TAS_H + +#include "controller_api.h" + +extern struct ControllerAPI controller_recorded_tas; + +#endif diff --git a/src/decomp/pc/controller/controller_sdl.c b/src/decomp/pc/controller/controller_sdl.c new file mode 100644 index 0000000..f6880e7 --- /dev/null +++ b/src/decomp/pc/controller/controller_sdl.c @@ -0,0 +1,103 @@ +#if !defined(_WIN32) && !defined(_WIN64) + +#include +#include +#include +#include + +#include + +#include + +#include "controller_api.h" + +#define DEADZONE 4960 + +static bool init_ok; +static SDL_GameController *sdl_cntrl; + +static void controller_sdl_init(void) { + if (SDL_Init(SDL_INIT_GAMECONTROLLER) != 0) { + fprintf(stderr, "SDL init error: %s\n", SDL_GetError()); + return; + } + + init_ok = true; +} + +static void controller_sdl_read(OSContPad *pad) { + if (!init_ok) { + return; + } + + SDL_GameControllerUpdate(); + + if (sdl_cntrl != NULL && !SDL_GameControllerGetAttached(sdl_cntrl)) { + SDL_GameControllerClose(sdl_cntrl); + sdl_cntrl = NULL; + } + if (sdl_cntrl == NULL) { + for (int i = 0; i < SDL_NumJoysticks(); i++) { + if (SDL_IsGameController(i)) { + sdl_cntrl = SDL_GameControllerOpen(i); + if (sdl_cntrl != NULL) { + break; + } + } + } + if (sdl_cntrl == NULL) { + return; + } + } + + if (SDL_GameControllerGetButton(sdl_cntrl, SDL_CONTROLLER_BUTTON_START)) pad->button |= START_BUTTON; + if (SDL_GameControllerGetButton(sdl_cntrl, SDL_CONTROLLER_BUTTON_LEFTSHOULDER)) pad->button |= Z_TRIG; + if (SDL_GameControllerGetButton(sdl_cntrl, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER)) pad->button |= R_TRIG; + if (SDL_GameControllerGetButton(sdl_cntrl, SDL_CONTROLLER_BUTTON_A)) pad->button |= A_BUTTON; + if (SDL_GameControllerGetButton(sdl_cntrl, SDL_CONTROLLER_BUTTON_X)) pad->button |= B_BUTTON; + + int16_t leftx = SDL_GameControllerGetAxis(sdl_cntrl, SDL_CONTROLLER_AXIS_LEFTX); + int16_t lefty = SDL_GameControllerGetAxis(sdl_cntrl, SDL_CONTROLLER_AXIS_LEFTY); + int16_t rightx = SDL_GameControllerGetAxis(sdl_cntrl, SDL_CONTROLLER_AXIS_RIGHTX); + int16_t righty = SDL_GameControllerGetAxis(sdl_cntrl, SDL_CONTROLLER_AXIS_RIGHTY); + + int16_t ltrig = SDL_GameControllerGetAxis(sdl_cntrl, SDL_CONTROLLER_AXIS_TRIGGERLEFT); + int16_t rtrig = SDL_GameControllerGetAxis(sdl_cntrl, SDL_CONTROLLER_AXIS_TRIGGERRIGHT); + +#ifdef TARGET_WEB + // Firefox has a bug: https://bugzilla.mozilla.org/show_bug.cgi?id=1606562 + // It sets down y to 32768.0f / 32767.0f, which is greater than the allowed 1.0f, + // which SDL then converts to a int16_t by multiplying by 32767.0f, which overflows into -32768. + // Maximum up will hence never become -32768 with the current version of SDL2, + // so this workaround should be safe in compliant browsers. + if (lefty == -32768) { + lefty = 32767; + } + if (righty == -32768) { + righty = 32767; + } +#endif + + if (rightx < -0x4000) pad->button |= L_CBUTTONS; + if (rightx > 0x4000) pad->button |= R_CBUTTONS; + if (righty < -0x4000) pad->button |= U_CBUTTONS; + if (righty > 0x4000) pad->button |= D_CBUTTONS; + + if (ltrig > 30 * 256) pad->button |= Z_TRIG; + if (rtrig > 30 * 256) pad->button |= R_TRIG; + + uint32_t magnitude_sq = (uint32_t)(leftx * leftx) + (uint32_t)(lefty * lefty); + if (magnitude_sq > (uint32_t)(DEADZONE * DEADZONE)) { + // Game expects stick coordinates within -80..80 + // 32768 / 409 = ~80 + pad->stick_x = leftx / 409; + pad->stick_y = -lefty / 409; + } +} + +struct ControllerAPI controller_sdl = { + controller_sdl_init, + controller_sdl_read +}; + +#endif diff --git a/src/decomp/pc/controller/controller_sdl.h b/src/decomp/pc/controller/controller_sdl.h new file mode 100644 index 0000000..02aec8d --- /dev/null +++ b/src/decomp/pc/controller/controller_sdl.h @@ -0,0 +1,8 @@ +#ifndef CONTROLLER_SDL_H +#define CONTROLLER_SDL_H + +#include "controller_api.h" + +extern struct ControllerAPI controller_sdl; + +#endif diff --git a/src/decomp/pc/controller/controller_wup.c b/src/decomp/pc/controller/controller_wup.c new file mode 100644 index 0000000..0a675ff --- /dev/null +++ b/src/decomp/pc/controller/controller_wup.c @@ -0,0 +1,51 @@ +#ifdef __linux__ + +#include +#include + +#include + +#include "controller_api.h" + +void *wup_start(void *a); +bool wup_get_controller_input(uint16_t *buttons, uint8_t axis[6]); + +static int8_t saturate(int v) { + v = v * 3 / 2; + return v < -128 ? -128 : v > 127 ? 127 : v; +} + +static void controller_wup_init(void) { + pthread_t pid; + pthread_create(&pid, NULL, wup_start, NULL); +} + +static void controller_wup_read(OSContPad *pad) { + uint16_t buttons; + uint8_t axis[6]; + if (wup_get_controller_input(&buttons, axis)) { + if (buttons & 0x0001) pad->button |= START_BUTTON; + if (buttons & 0x0008) pad->button |= Z_TRIG; + if (buttons & 0x0004) pad->button |= R_TRIG; + if (buttons & 0x0100) pad->button |= A_BUTTON; + if (buttons & 0x0200) pad->button |= B_BUTTON; + if (buttons & 0x1000) pad->button |= L_TRIG; + if (axis[2] < 0x40) pad->button |= L_CBUTTONS; + if (axis[2] > 0xC0) pad->button |= R_CBUTTONS; + if (axis[3] < 0x40) pad->button |= D_CBUTTONS; + if (axis[3] > 0xC0) pad->button |= U_CBUTTONS; + int8_t stick_x = saturate(axis[0] - 128 - 0); + int8_t stick_y = saturate(axis[1] - 128 - 0); + if (stick_x != 0 || stick_y != 0) { + pad->stick_x = stick_x; + pad->stick_y = stick_y; + } + } +} + +struct ControllerAPI controller_wup = { + controller_wup_init, + controller_wup_read +}; + +#endif diff --git a/src/decomp/pc/controller/controller_wup.h b/src/decomp/pc/controller/controller_wup.h new file mode 100644 index 0000000..3c5674c --- /dev/null +++ b/src/decomp/pc/controller/controller_wup.h @@ -0,0 +1,12 @@ +#ifndef CONTROLLER_WUP_H +#define CONTROLLER_WUP_H + +#ifdef __linux__ + +#include "controller_api.h" + +extern struct ControllerAPI controller_wup; + +#endif + +#endif diff --git a/src/decomp/pc/controller/controller_xinput.c b/src/decomp/pc/controller/controller_xinput.c new file mode 100644 index 0000000..e8634d7 --- /dev/null +++ b/src/decomp/pc/controller/controller_xinput.c @@ -0,0 +1,51 @@ +#if defined(_WIN32) || defined(_WIN64) + +#include +#include + +#include + +#include "controller_api.h" + +#define DEADZONE 4960 + +static void xinput_init(void) { +} + +static void xinput_read(OSContPad *pad) { + for (int i = 0; i < XUSER_MAX_COUNT; i++) { + XINPUT_STATE state; + memset(&state, 0, sizeof(XINPUT_STATE)); + if (XInputGetState(i, &state) == ERROR_SUCCESS) { + XINPUT_GAMEPAD *gp = &state.Gamepad; + if (gp->wButtons & XINPUT_GAMEPAD_START) pad->button |= START_BUTTON; + if (gp->wButtons & XINPUT_GAMEPAD_LEFT_SHOULDER) pad->button |= Z_TRIG; + if (gp->bLeftTrigger > XINPUT_GAMEPAD_TRIGGER_THRESHOLD) pad->button |= Z_TRIG; + if (gp->wButtons & XINPUT_GAMEPAD_RIGHT_SHOULDER) pad->button |= R_TRIG; + if (gp->bRightTrigger > XINPUT_GAMEPAD_TRIGGER_THRESHOLD) pad->button |= R_TRIG; + if (gp->wButtons & XINPUT_GAMEPAD_A) pad->button |= A_BUTTON; + if (gp->wButtons & XINPUT_GAMEPAD_X) pad->button |= B_BUTTON; + if (gp->wButtons & XINPUT_GAMEPAD_DPAD_LEFT) pad->button |= L_TRIG; + if (gp->sThumbRX < -0x4000) pad->button |= L_CBUTTONS; + if (gp->sThumbRX > 0x4000) pad->button |= R_CBUTTONS; + if (gp->sThumbRY < -0x4000) pad->button |= D_CBUTTONS; + if (gp->sThumbRY > 0x4000) pad->button |= U_CBUTTONS; + + uint32_t magnitude_sq = (uint32_t)(gp->sThumbLX * gp->sThumbLX) + (uint32_t)(gp->sThumbLY * gp->sThumbLY); + if (magnitude_sq > (uint32_t)(DEADZONE * DEADZONE)) { + // Game expects stick coordinates within -80..80 + // 32768 / 409 = ~80 + pad->stick_x = gp->sThumbLX / 409; + pad->stick_y = gp->sThumbLY / 409; + } + break; + } + } +} + +struct ControllerAPI controller_xinput = { + xinput_init, + xinput_read +}; + +#endif diff --git a/src/decomp/pc/controller/controller_xinput.h b/src/decomp/pc/controller/controller_xinput.h new file mode 100644 index 0000000..be1e68c --- /dev/null +++ b/src/decomp/pc/controller/controller_xinput.h @@ -0,0 +1,12 @@ +#ifndef CONTROLLER_XINPUT_H +#define CONTROLLER_XINPUT_H + +#if defined(_WIN32) || defined(_WIN64) + +#include "controller_api.h" + +extern struct ControllerAPI controller_xinput; + +#endif + +#endif diff --git a/src/decomp/pc/controller/wup.c b/src/decomp/pc/controller/wup.c new file mode 100644 index 0000000..9de54c1 --- /dev/null +++ b/src/decomp/pc/controller/wup.c @@ -0,0 +1,362 @@ +#if !defined(__MINGW32__) && !defined(__BSD__) && !defined(TARGET_WEB) +// See LICENSE for license + +#define _XOPEN_SOURCE 600 + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +//#include +#include +#include + +#include "macros.h" + +#if (!defined(LIBUSBX_API_VERSION) || LIBUSBX_API_VERSION < 0x01000102) && (!defined(LIBUSB_API_VERSION) || LIBUSB_API_VERSION < 0x01000102) +#error libusb(x) 1.0.16 or higher is required +#endif + +#define EP_IN 0x81 +#define EP_OUT 0x02 + +#define STATE_NORMAL 0x10 +#define STATE_WAVEBIRD 0x20 + +const int BUTTON_OFFSET_VALUES[16] = { + BTN_START, + BTN_TR2, + BTN_TR, + BTN_TL, + -1, + -1, + -1, + -1, + BTN_SOUTH, + BTN_WEST, + BTN_EAST, + BTN_NORTH, + BTN_DPAD_LEFT, + BTN_DPAD_RIGHT, + BTN_DPAD_DOWN, + BTN_DPAD_UP, +}; + +const int AXIS_OFFSET_VALUES[6] = { + ABS_X, + ABS_Y, + ABS_RX, + ABS_RY, + ABS_Z, + ABS_RZ +}; + +struct ports +{ + bool connected; + bool extra_power; + unsigned char type; + uint16_t buttons; + uint8_t axis[6]; +}; + +struct adapter +{ + volatile bool quitting; + struct libusb_device *device; + struct libusb_device_handle *handle; + pthread_t thread; + unsigned char rumble[5]; + struct ports controllers[4]; + struct adapter *next; +}; + +static bool raw_mode; + +static volatile int quitting; + +static struct adapter adapters; + +static const char *uinput_path; + +bool wup_get_controller_input(uint16_t *buttons, uint8_t axis[6]) { + struct adapter *adapter = adapters.next; + if (adapter != NULL) { + *buttons = adapter->controllers[0].buttons; + memcpy(axis, adapter->controllers[0].axis, 6); + return true; + } else { + return false; + } +} + +static unsigned char connected_type(unsigned char status) +{ + unsigned char type = status & (STATE_NORMAL | STATE_WAVEBIRD); + switch (type) + { + case STATE_NORMAL: + case STATE_WAVEBIRD: + return type; + default: + return 0; + } +} + +static void handle_payload(int i, struct ports *port, unsigned char *payload) +{ + unsigned char status = payload[0]; + unsigned char type = connected_type(status); + + if (type != 0 && !port->connected) + { + //uinput_create(i, port, type); + port->type = type; + port->connected = true; + } + else if (type == 0 && port->connected) + { + //uinput_destroy(i, port); + port->connected = false; + } + + if (!port->connected) + return; + + port->extra_power = ((status & 0x04) != 0); + + if (type != port->type) + { + fprintf(stderr, "controller on port %d changed controller type???", i+1); + port->type = type; + } + + uint16_t btns = (uint16_t) payload[1] << 8 | (uint16_t) payload[2]; + port->buttons = btns; + //printf("Btns: %04x\n", btns); + + //printf("Axis:"); + for (int j = 0; j < 6; j++) + { + unsigned char value = payload[j+3]; + port->axis[j] = value; + //printf(" %02x", value); + } + //puts(""); +} + +static int64_t to_ms(struct timespec* t) { + return t->tv_sec * 1000 + t->tv_nsec / 1000000; +} + +static void *adapter_thread(void *data) +{ + struct adapter *a = (struct adapter *)data; + + int bytes_transferred; + unsigned char payload[1] = { 0x13 }; + + int transfer_ret = libusb_interrupt_transfer(a->handle, EP_OUT, payload, sizeof(payload), &bytes_transferred, 0); + + if (transfer_ret != 0) { + fprintf(stderr, "libusb_interrupt_transfer: %s\n", libusb_error_name(transfer_ret)); + return NULL; + } + if (bytes_transferred != sizeof(payload)) { + fprintf(stderr, "libusb_interrupt_transfer %d/%lu bytes transferred.\n", bytes_transferred, sizeof(payload)); + return NULL; + } + + while (!a->quitting) + { + //struct timespec time_before = { 0 }, time_after = { 0 }; + unsigned char payload[37]; + int size = 0; + //clock_gettime(CLOCK_MONOTONIC, &time_before); + int transfer_ret = libusb_interrupt_transfer(a->handle, EP_IN, payload, sizeof(payload), &size, 0); + //clock_gettime(CLOCK_MONOTONIC, &time_after); + //printf("Time taken: %d\n", (int)(to_ms(&time_after) - to_ms(&time_before))); + if (transfer_ret != 0) { + fprintf(stderr, "libusb_interrupt_transfer error %d\n", transfer_ret); + a->quitting = true; + break; + } + if (size != 37 || payload[0] != 0x21) + continue; + + unsigned char *controller = &payload[1]; + + unsigned char rumble[5] = { 0x11, 0, 0, 0, 0 }; + //struct timespec current_time = { 0 }; + //clock_gettime(CLOCK_REALTIME, ¤t_time); + //printf("Time: %d %d\n", (int)current_time.tv_sec, (int)current_time.tv_nsec); + for (int i = 0; i < 4; i++, controller += 9) + { + handle_payload(i, &a->controllers[i], controller); + rumble[i+1] = 0; + /*if (a->controllers[i].extra_power && a->controllers[i].type == STATE_NORMAL) + { + for (int j = 0; j < MAX_FF_EVENTS; j++) + { + struct ff_event *e = &a->controllers[i].ff_events[j]; + if (e->in_use) + { + if (ts_lessthan(&e->start_time, ¤t_time) && ts_greaterthan(&e->end_time, ¤t_time)) + rumble[i+1] = 1; + else + update_ff_start_stop(e, ¤t_time); + } + } + }*/ + } + + if (memcmp(rumble, a->rumble, sizeof(rumble)) != 0) + { + memcpy(a->rumble, rumble, sizeof(rumble)); + transfer_ret = libusb_interrupt_transfer(a->handle, EP_OUT, a->rumble, sizeof(a->rumble), &size, 0); + if (transfer_ret != 0) { + fprintf(stderr, "libusb_interrupt_transfer error %d\n", transfer_ret); + a->quitting = true; + break; + } + } + } + + for (int i = 0; i < 4; i++) + { + /*if (a->controllers[i].connected) + uinput_destroy(i, &a->controllers[i]);*/ + } + + return NULL; +} + +static void add_adapter(struct libusb_device *dev) +{ + struct adapter *a = calloc(1, sizeof(struct adapter)); + if (a == NULL) + { + fprintf(stderr, "FATAL: calloc() failed"); + exit(-1); + } + a->device = dev; + + if (libusb_open(a->device, &a->handle) != 0) + { + fprintf(stderr, "Error opening device 0x%p\n", a->device); + return; + } + + if (libusb_kernel_driver_active(a->handle, 0) == 1) { + fprintf(stderr, "Detaching kernel driver\n"); + if (libusb_detach_kernel_driver(a->handle, 0)) { + fprintf(stderr, "Error detaching handle 0x%p from kernel\n", a->handle); + return; + } + } + + struct adapter *old_head = adapters.next; + adapters.next = a; + a->next = old_head; + + pthread_create(&a->thread, NULL, adapter_thread, a); + + fprintf(stderr, "adapter 0x%p connected\n", a->device); +} + +static void remove_adapter(struct libusb_device *dev) +{ + struct adapter *a = &adapters; + while (a->next != NULL) + { + if (a->next->device == dev) + { + a->next->quitting = true; + pthread_join(a->next->thread, NULL); + fprintf(stderr, "adapter 0x%p disconnected\n", a->next->device); + libusb_close(a->next->handle); + struct adapter *new_next = a->next->next; + free(a->next); + a->next = new_next; + return; + } + + a = a->next; + } +} + +static int LIBUSB_CALL hotplug_callback(struct libusb_context *ctx, struct libusb_device *dev, libusb_hotplug_event event, void *user_data) +{ + (void)ctx; + (void)user_data; + if (event == LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED) + { + add_adapter(dev); + } + else if (event == LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT) + { + remove_adapter(dev); + } + + return 0; +} + +void *wup_start(UNUSED void *a) +{ + libusb_init(NULL); + + struct libusb_device **devices; + + int count = libusb_get_device_list(NULL, &devices); + + for (int i = 0; i < count; i++) + { + struct libusb_device_descriptor desc; + libusb_get_device_descriptor(devices[i], &desc); + if (desc.idVendor == 0x057e && desc.idProduct == 0x0337) + add_adapter(devices[i]); + } + + if (count > 0) + libusb_free_device_list(devices, 1); + + libusb_hotplug_callback_handle callback; + + int hotplug_capability = libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG); + if (hotplug_capability) { + int hotplug_ret = libusb_hotplug_register_callback(NULL, + LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED | LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT, + LIBUSB_HOTPLUG_NO_FLAGS, 0x057e, 0x0337, + LIBUSB_HOTPLUG_MATCH_ANY, hotplug_callback, NULL, &callback); + + if (hotplug_ret != LIBUSB_SUCCESS) { + fprintf(stderr, "cannot register hotplug callback, hotplugging not enabled\n"); + hotplug_capability = 0; + } + } + + // pump events until shutdown & all helper threads finish cleaning up + while (!quitting) + libusb_handle_events_completed(NULL, (int *)&quitting); + + while (adapters.next) + remove_adapter(adapters.next->device); + + if (hotplug_capability) + libusb_hotplug_deregister_callback(NULL, callback); + + libusb_exit(NULL); + return (void *)0; +} +#endif diff --git a/src/decomp/pc/dlmalloc.c b/src/decomp/pc/dlmalloc.c new file mode 100644 index 0000000..27322a6 --- /dev/null +++ b/src/decomp/pc/dlmalloc.c @@ -0,0 +1,6289 @@ +// Windows has terrible malloc/free performance, so use dlmalloc +// instead. This makes malloc/free time per frame go from order of +// milliseconds to tens of microseconds. +#ifdef _WIN32 +#include +#define FORCEINLINE // define this to nothing to make gcc happy +#define USE_LOCKS 1 + +/* + This is a version (aka dlmalloc) of malloc/free/realloc written by + Doug Lea and released to the public domain, as explained at + http://creativecommons.org/publicdomain/zero/1.0/ Send questions, + comments, complaints, performance data, etc to dl@cs.oswego.edu + +* Version 2.8.6 Wed Aug 29 06:57:58 2012 Doug Lea + Note: There may be an updated version of this malloc obtainable at + ftp://gee.cs.oswego.edu/pub/misc/malloc.c + Check before installing! + +* Quickstart + + This library is all in one file to simplify the most common usage: + ftp it, compile it (-O3), and link it into another program. All of + the compile-time options default to reasonable values for use on + most platforms. You might later want to step through various + compile-time and dynamic tuning options. + + For convenience, an include file for code using this malloc is at: + ftp://gee.cs.oswego.edu/pub/misc/malloc-2.8.6.h + You don't really need this .h file unless you call functions not + defined in your system include files. The .h file contains only the + excerpts from this file needed for using this malloc on ANSI C/C++ + systems, so long as you haven't changed compile-time options about + naming and tuning parameters. If you do, then you can create your + own malloc.h that does include all settings by cutting at the point + indicated below. Note that you may already by default be using a C + library containing a malloc that is based on some version of this + malloc (for example in linux). You might still want to use the one + in this file to customize settings or to avoid overheads associated + with library versions. + +* Vital statistics: + + Supported pointer/size_t representation: 4 or 8 bytes + size_t MUST be an unsigned type of the same width as + pointers. (If you are using an ancient system that declares + size_t as a signed type, or need it to be a different width + than pointers, you can use a previous release of this malloc + (e.g. 2.7.2) supporting these.) + + Alignment: 8 bytes (minimum) + This suffices for nearly all current machines and C compilers. + However, you can define MALLOC_ALIGNMENT to be wider than this + if necessary (up to 128bytes), at the expense of using more space. + + Minimum overhead per allocated chunk: 4 or 8 bytes (if 4byte sizes) + 8 or 16 bytes (if 8byte sizes) + Each malloced chunk has a hidden word of overhead holding size + and status information, and additional cross-check word + if FOOTERS is defined. + + Minimum allocated size: 4-byte ptrs: 16 bytes (including overhead) + 8-byte ptrs: 32 bytes (including overhead) + + Even a request for zero bytes (i.e., malloc(0)) returns a + pointer to something of the minimum allocatable size. + The maximum overhead wastage (i.e., number of extra bytes + allocated than were requested in malloc) is less than or equal + to the minimum size, except for requests >= mmap_threshold that + are serviced via mmap(), where the worst case wastage is about + 32 bytes plus the remainder from a system page (the minimal + mmap unit); typically 4096 or 8192 bytes. + + Security: static-safe; optionally more or less + The "security" of malloc refers to the ability of malicious + code to accentuate the effects of errors (for example, freeing + space that is not currently malloc'ed or overwriting past the + ends of chunks) in code that calls malloc. This malloc + guarantees not to modify any memory locations below the base of + heap, i.e., static variables, even in the presence of usage + errors. The routines additionally detect most improper frees + and reallocs. All this holds as long as the static bookkeeping + for malloc itself is not corrupted by some other means. This + is only one aspect of security -- these checks do not, and + cannot, detect all possible programming errors. + + If FOOTERS is defined nonzero, then each allocated chunk + carries an additional check word to verify that it was malloced + from its space. These check words are the same within each + execution of a program using malloc, but differ across + executions, so externally crafted fake chunks cannot be + freed. This improves security by rejecting frees/reallocs that + could corrupt heap memory, in addition to the checks preventing + writes to statics that are always on. This may further improve + security at the expense of time and space overhead. (Note that + FOOTERS may also be worth using with MSPACES.) + + By default detected errors cause the program to abort (calling + "abort()"). You can override this to instead proceed past + errors by defining PROCEED_ON_ERROR. In this case, a bad free + has no effect, and a malloc that encounters a bad address + caused by user overwrites will ignore the bad address by + dropping pointers and indices to all known memory. This may + be appropriate for programs that should continue if at all + possible in the face of programming errors, although they may + run out of memory because dropped memory is never reclaimed. + + If you don't like either of these options, you can define + CORRUPTION_ERROR_ACTION and USAGE_ERROR_ACTION to do anything + else. And if if you are sure that your program using malloc has + no errors or vulnerabilities, you can define INSECURE to 1, + which might (or might not) provide a small performance improvement. + + It is also possible to limit the maximum total allocatable + space, using malloc_set_footprint_limit. This is not + designed as a security feature in itself (calls to set limits + are not screened or privileged), but may be useful as one + aspect of a secure implementation. + + Thread-safety: NOT thread-safe unless USE_LOCKS defined non-zero + When USE_LOCKS is defined, each public call to malloc, free, + etc is surrounded with a lock. By default, this uses a plain + pthread mutex, win32 critical section, or a spin-lock if if + available for the platform and not disabled by setting + USE_SPIN_LOCKS=0. However, if USE_RECURSIVE_LOCKS is defined, + recursive versions are used instead (which are not required for + base functionality but may be needed in layered extensions). + Using a global lock is not especially fast, and can be a major + bottleneck. It is designed only to provide minimal protection + in concurrent environments, and to provide a basis for + extensions. If you are using malloc in a concurrent program, + consider instead using nedmalloc + (http://www.nedprod.com/programs/portable/nedmalloc/) or + ptmalloc (See http://www.malloc.de), which are derived from + versions of this malloc. + + System requirements: Any combination of MORECORE and/or MMAP/MUNMAP + This malloc can use unix sbrk or any emulation (invoked using + the CALL_MORECORE macro) and/or mmap/munmap or any emulation + (invoked using CALL_MMAP/CALL_MUNMAP) to get and release system + memory. On most unix systems, it tends to work best if both + MORECORE and MMAP are enabled. On Win32, it uses emulations + based on VirtualAlloc. It also uses common C library functions + like memset. + + Compliance: I believe it is compliant with the Single Unix Specification + (See http://www.unix.org). Also SVID/XPG, ANSI C, and probably + others as well. + +* Overview of algorithms + + This is not the fastest, most space-conserving, most portable, or + most tunable malloc ever written. However it is among the fastest + while also being among the most space-conserving, portable and + tunable. Consistent balance across these factors results in a good + general-purpose allocator for malloc-intensive programs. + + In most ways, this malloc is a best-fit allocator. Generally, it + chooses the best-fitting existing chunk for a request, with ties + broken in approximately least-recently-used order. (This strategy + normally maintains low fragmentation.) However, for requests less + than 256bytes, it deviates from best-fit when there is not an + exactly fitting available chunk by preferring to use space adjacent + to that used for the previous small request, as well as by breaking + ties in approximately most-recently-used order. (These enhance + locality of series of small allocations.) And for very large requests + (>= 256Kb by default), it relies on system memory mapping + facilities, if supported. (This helps avoid carrying around and + possibly fragmenting memory used only for large chunks.) + + All operations (except malloc_stats and mallinfo) have execution + times that are bounded by a constant factor of the number of bits in + a size_t, not counting any clearing in calloc or copying in realloc, + or actions surrounding MORECORE and MMAP that have times + proportional to the number of non-contiguous regions returned by + system allocation routines, which is often just 1. In real-time + applications, you can optionally suppress segment traversals using + NO_SEGMENT_TRAVERSAL, which assures bounded execution even when + system allocators return non-contiguous spaces, at the typical + expense of carrying around more memory and increased fragmentation. + + The implementation is not very modular and seriously overuses + macros. Perhaps someday all C compilers will do as good a job + inlining modular code as can now be done by brute-force expansion, + but now, enough of them seem not to. + + Some compilers issue a lot of warnings about code that is + dead/unreachable only on some platforms, and also about intentional + uses of negation on unsigned types. All known cases of each can be + ignored. + + For a longer but out of date high-level description, see + http://gee.cs.oswego.edu/dl/html/malloc.html + +* MSPACES + If MSPACES is defined, then in addition to malloc, free, etc., + this file also defines mspace_malloc, mspace_free, etc. These + are versions of malloc routines that take an "mspace" argument + obtained using create_mspace, to control all internal bookkeeping. + If ONLY_MSPACES is defined, only these versions are compiled. + So if you would like to use this allocator for only some allocations, + and your system malloc for others, you can compile with + ONLY_MSPACES and then do something like... + static mspace mymspace = create_mspace(0,0); // for example + #define mymalloc(bytes) mspace_malloc(mymspace, bytes) + + (Note: If you only need one instance of an mspace, you can instead + use "USE_DL_PREFIX" to relabel the global malloc.) + + You can similarly create thread-local allocators by storing + mspaces as thread-locals. For example: + static __thread mspace tlms = 0; + void* tlmalloc(size_t bytes) { + if (tlms == 0) tlms = create_mspace(0, 0); + return mspace_malloc(tlms, bytes); + } + void tlfree(void* mem) { mspace_free(tlms, mem); } + + Unless FOOTERS is defined, each mspace is completely independent. + You cannot allocate from one and free to another (although + conformance is only weakly checked, so usage errors are not always + caught). If FOOTERS is defined, then each chunk carries around a tag + indicating its originating mspace, and frees are directed to their + originating spaces. Normally, this requires use of locks. + + ------------------------- Compile-time options --------------------------- + +Be careful in setting #define values for numerical constants of type +size_t. On some systems, literal values are not automatically extended +to size_t precision unless they are explicitly casted. You can also +use the symbolic values MAX_SIZE_T, SIZE_T_ONE, etc below. + +WIN32 default: defined if _WIN32 defined + Defining WIN32 sets up defaults for MS environment and compilers. + Otherwise defaults are for unix. Beware that there seem to be some + cases where this malloc might not be a pure drop-in replacement for + Win32 malloc: Random-looking failures from Win32 GDI API's (eg; + SetDIBits()) may be due to bugs in some video driver implementations + when pixel buffers are malloc()ed, and the region spans more than + one VirtualAlloc()ed region. Because dlmalloc uses a small (64Kb) + default granularity, pixel buffers may straddle virtual allocation + regions more often than when using the Microsoft allocator. You can + avoid this by using VirtualAlloc() and VirtualFree() for all pixel + buffers rather than using malloc(). If this is not possible, + recompile this malloc with a larger DEFAULT_GRANULARITY. Note: + in cases where MSC and gcc (cygwin) are known to differ on WIN32, + conditions use _MSC_VER to distinguish them. + +DLMALLOC_EXPORT default: extern + Defines how public APIs are declared. If you want to export via a + Windows DLL, you might define this as + #define DLMALLOC_EXPORT extern __declspec(dllexport) + If you want a POSIX ELF shared object, you might use + #define DLMALLOC_EXPORT extern __attribute__((visibility("default"))) + +MALLOC_ALIGNMENT default: (size_t)(2 * sizeof(void *)) + Controls the minimum alignment for malloc'ed chunks. It must be a + power of two and at least 8, even on machines for which smaller + alignments would suffice. It may be defined as larger than this + though. Note however that code and data structures are optimized for + the case of 8-byte alignment. + +MSPACES default: 0 (false) + If true, compile in support for independent allocation spaces. + This is only supported if HAVE_MMAP is true. + +ONLY_MSPACES default: 0 (false) + If true, only compile in mspace versions, not regular versions. + +USE_LOCKS default: 0 (false) + Causes each call to each public routine to be surrounded with + pthread or WIN32 mutex lock/unlock. (If set true, this can be + overridden on a per-mspace basis for mspace versions.) If set to a + non-zero value other than 1, locks are used, but their + implementation is left out, so lock functions must be supplied manually, + as described below. + +USE_SPIN_LOCKS default: 1 iff USE_LOCKS and spin locks available + If true, uses custom spin locks for locking. This is currently + supported only gcc >= 4.1, older gccs on x86 platforms, and recent + MS compilers. Otherwise, posix locks or win32 critical sections are + used. + +USE_RECURSIVE_LOCKS default: not defined + If defined nonzero, uses recursive (aka reentrant) locks, otherwise + uses plain mutexes. This is not required for malloc proper, but may + be needed for layered allocators such as nedmalloc. + +LOCK_AT_FORK default: not defined + If defined nonzero, performs pthread_atfork upon initialization + to initialize child lock while holding parent lock. The implementation + assumes that pthread locks (not custom locks) are being used. In other + cases, you may need to customize the implementation. + +FOOTERS default: 0 + If true, provide extra checking and dispatching by placing + information in the footers of allocated chunks. This adds + space and time overhead. + +INSECURE default: 0 + If true, omit checks for usage errors and heap space overwrites. + +USE_DL_PREFIX default: NOT defined + Causes compiler to prefix all public routines with the string 'dl'. + This can be useful when you only want to use this malloc in one part + of a program, using your regular system malloc elsewhere. + +MALLOC_INSPECT_ALL default: NOT defined + If defined, compiles malloc_inspect_all and mspace_inspect_all, that + perform traversal of all heap space. Unless access to these + functions is otherwise restricted, you probably do not want to + include them in secure implementations. + +ABORT default: defined as abort() + Defines how to abort on failed checks. On most systems, a failed + check cannot die with an "assert" or even print an informative + message, because the underlying print routines in turn call malloc, + which will fail again. Generally, the best policy is to simply call + abort(). It's not very useful to do more than this because many + errors due to overwriting will show up as address faults (null, odd + addresses etc) rather than malloc-triggered checks, so will also + abort. Also, most compilers know that abort() does not return, so + can better optimize code conditionally calling it. + +PROCEED_ON_ERROR default: defined as 0 (false) + Controls whether detected bad addresses cause them to bypassed + rather than aborting. If set, detected bad arguments to free and + realloc are ignored. And all bookkeeping information is zeroed out + upon a detected overwrite of freed heap space, thus losing the + ability to ever return it from malloc again, but enabling the + application to proceed. If PROCEED_ON_ERROR is defined, the + static variable malloc_corruption_error_count is compiled in + and can be examined to see if errors have occurred. This option + generates slower code than the default abort policy. + +DEBUG default: NOT defined + The DEBUG setting is mainly intended for people trying to modify + this code or diagnose problems when porting to new platforms. + However, it may also be able to better isolate user errors than just + using runtime checks. The assertions in the check routines spell + out in more detail the assumptions and invariants underlying the + algorithms. The checking is fairly extensive, and will slow down + execution noticeably. Calling malloc_stats or mallinfo with DEBUG + set will attempt to check every non-mmapped allocated and free chunk + in the course of computing the summaries. + +ABORT_ON_ASSERT_FAILURE default: defined as 1 (true) + Debugging assertion failures can be nearly impossible if your + version of the assert macro causes malloc to be called, which will + lead to a cascade of further failures, blowing the runtime stack. + ABORT_ON_ASSERT_FAILURE cause assertions failures to call abort(), + which will usually make debugging easier. + +MALLOC_FAILURE_ACTION default: sets errno to ENOMEM, or no-op on win32 + The action to take before "return 0" when malloc fails to be able to + return memory because there is none available. + +HAVE_MORECORE default: 1 (true) unless win32 or ONLY_MSPACES + True if this system supports sbrk or an emulation of it. + +MORECORE default: sbrk + The name of the sbrk-style system routine to call to obtain more + memory. See below for guidance on writing custom MORECORE + functions. The type of the argument to sbrk/MORECORE varies across + systems. It cannot be size_t, because it supports negative + arguments, so it is normally the signed type of the same width as + size_t (sometimes declared as "intptr_t"). It doesn't much matter + though. Internally, we only call it with arguments less than half + the max value of a size_t, which should work across all reasonable + possibilities, although sometimes generating compiler warnings. + +MORECORE_CONTIGUOUS default: 1 (true) if HAVE_MORECORE + If true, take advantage of fact that consecutive calls to MORECORE + with positive arguments always return contiguous increasing + addresses. This is true of unix sbrk. It does not hurt too much to + set it true anyway, since malloc copes with non-contiguities. + Setting it false when definitely non-contiguous saves time + and possibly wasted space it would take to discover this though. + +MORECORE_CANNOT_TRIM default: NOT defined + True if MORECORE cannot release space back to the system when given + negative arguments. This is generally necessary only if you are + using a hand-crafted MORECORE function that cannot handle negative + arguments. + +NO_SEGMENT_TRAVERSAL default: 0 + If non-zero, suppresses traversals of memory segments + returned by either MORECORE or CALL_MMAP. This disables + merging of segments that are contiguous, and selectively + releasing them to the OS if unused, but bounds execution times. + +HAVE_MMAP default: 1 (true) + True if this system supports mmap or an emulation of it. If so, and + HAVE_MORECORE is not true, MMAP is used for all system + allocation. If set and HAVE_MORECORE is true as well, MMAP is + primarily used to directly allocate very large blocks. It is also + used as a backup strategy in cases where MORECORE fails to provide + space from system. Note: A single call to MUNMAP is assumed to be + able to unmap memory that may have be allocated using multiple calls + to MMAP, so long as they are adjacent. + +HAVE_MREMAP default: 1 on linux, else 0 + If true realloc() uses mremap() to re-allocate large blocks and + extend or shrink allocation spaces. + +MMAP_CLEARS default: 1 except on WINCE. + True if mmap clears memory so calloc doesn't need to. This is true + for standard unix mmap using /dev/zero and on WIN32 except for WINCE. + +USE_BUILTIN_FFS default: 0 (i.e., not used) + Causes malloc to use the builtin ffs() function to compute indices. + Some compilers may recognize and intrinsify ffs to be faster than the + supplied C version. Also, the case of x86 using gcc is special-cased + to an asm instruction, so is already as fast as it can be, and so + this setting has no effect. Similarly for Win32 under recent MS compilers. + (On most x86s, the asm version is only slightly faster than the C version.) + +malloc_getpagesize default: derive from system includes, or 4096. + The system page size. To the extent possible, this malloc manages + memory from the system in page-size units. This may be (and + usually is) a function rather than a constant. This is ignored + if WIN32, where page size is determined using getSystemInfo during + initialization. + +USE_DEV_RANDOM default: 0 (i.e., not used) + Causes malloc to use /dev/random to initialize secure magic seed for + stamping footers. Otherwise, the current time is used. + +NO_MALLINFO default: 0 + If defined, don't compile "mallinfo". This can be a simple way + of dealing with mismatches between system declarations and + those in this file. + +MALLINFO_FIELD_TYPE default: size_t + The type of the fields in the mallinfo struct. This was originally + defined as "int" in SVID etc, but is more usefully defined as + size_t. The value is used only if HAVE_USR_INCLUDE_MALLOC_H is not set + +NO_MALLOC_STATS default: 0 + If defined, don't compile "malloc_stats". This avoids calls to + fprintf and bringing in stdio dependencies you might not want. + +REALLOC_ZERO_BYTES_FREES default: not defined + This should be set if a call to realloc with zero bytes should + be the same as a call to free. Some people think it should. Otherwise, + since this malloc returns a unique pointer for malloc(0), so does + realloc(p, 0). + +LACKS_UNISTD_H, LACKS_FCNTL_H, LACKS_SYS_PARAM_H, LACKS_SYS_MMAN_H +LACKS_STRINGS_H, LACKS_STRING_H, LACKS_SYS_TYPES_H, LACKS_ERRNO_H +LACKS_STDLIB_H LACKS_SCHED_H LACKS_TIME_H default: NOT defined unless on WIN32 + Define these if your system does not have these header files. + You might need to manually insert some of the declarations they provide. + +DEFAULT_GRANULARITY default: page size if MORECORE_CONTIGUOUS, + system_info.dwAllocationGranularity in WIN32, + otherwise 64K. + Also settable using mallopt(M_GRANULARITY, x) + The unit for allocating and deallocating memory from the system. On + most systems with contiguous MORECORE, there is no reason to + make this more than a page. However, systems with MMAP tend to + either require or encourage larger granularities. You can increase + this value to prevent system allocation functions to be called so + often, especially if they are slow. The value must be at least one + page and must be a power of two. Setting to 0 causes initialization + to either page size or win32 region size. (Note: In previous + versions of malloc, the equivalent of this option was called + "TOP_PAD") + +DEFAULT_TRIM_THRESHOLD default: 2MB + Also settable using mallopt(M_TRIM_THRESHOLD, x) + The maximum amount of unused top-most memory to keep before + releasing via malloc_trim in free(). Automatic trimming is mainly + useful in long-lived programs using contiguous MORECORE. Because + trimming via sbrk can be slow on some systems, and can sometimes be + wasteful (in cases where programs immediately afterward allocate + more large chunks) the value should be high enough so that your + overall system performance would improve by releasing this much + memory. As a rough guide, you might set to a value close to the + average size of a process (program) running on your system. + Releasing this much memory would allow such a process to run in + memory. Generally, it is worth tuning trim thresholds when a + program undergoes phases where several large chunks are allocated + and released in ways that can reuse each other's storage, perhaps + mixed with phases where there are no such chunks at all. The trim + value must be greater than page size to have any useful effect. To + disable trimming completely, you can set to MAX_SIZE_T. Note that the trick + some people use of mallocing a huge space and then freeing it at + program startup, in an attempt to reserve system memory, doesn't + have the intended effect under automatic trimming, since that memory + will immediately be returned to the system. + +DEFAULT_MMAP_THRESHOLD default: 256K + Also settable using mallopt(M_MMAP_THRESHOLD, x) + The request size threshold for using MMAP to directly service a + request. Requests of at least this size that cannot be allocated + using already-existing space will be serviced via mmap. (If enough + normal freed space already exists it is used instead.) Using mmap + segregates relatively large chunks of memory so that they can be + individually obtained and released from the host system. A request + serviced through mmap is never reused by any other request (at least + not directly; the system may just so happen to remap successive + requests to the same locations). Segregating space in this way has + the benefits that: Mmapped space can always be individually released + back to the system, which helps keep the system level memory demands + of a long-lived program low. Also, mapped memory doesn't become + `locked' between other chunks, as can happen with normally allocated + chunks, which means that even trimming via malloc_trim would not + release them. However, it has the disadvantage that the space + cannot be reclaimed, consolidated, and then used to service later + requests, as happens with normal chunks. The advantages of mmap + nearly always outweigh disadvantages for "large" chunks, but the + value of "large" may vary across systems. The default is an + empirically derived value that works well in most systems. You can + disable mmap by setting to MAX_SIZE_T. + +MAX_RELEASE_CHECK_RATE default: 4095 unless not HAVE_MMAP + The number of consolidated frees between checks to release + unused segments when freeing. When using non-contiguous segments, + especially with multiple mspaces, checking only for topmost space + doesn't always suffice to trigger trimming. To compensate for this, + free() will, with a period of MAX_RELEASE_CHECK_RATE (or the + current number of segments, if greater) try to release unused + segments to the OS when freeing chunks that result in + consolidation. The best value for this parameter is a compromise + between slowing down frees with relatively costly checks that + rarely trigger versus holding on to unused memory. To effectively + disable, set to MAX_SIZE_T. This may lead to a very slight speed + improvement at the expense of carrying around more memory. +*/ + +/* Version identifier to allow people to support multiple versions */ +#ifndef DLMALLOC_VERSION +#define DLMALLOC_VERSION 20806 +#endif /* DLMALLOC_VERSION */ + +#ifndef DLMALLOC_EXPORT +#define DLMALLOC_EXPORT extern +#endif + +#ifndef WIN32 +#ifdef _WIN32 +#define WIN32 1 +#endif /* _WIN32 */ +#ifdef _WIN32_WCE +#define LACKS_FCNTL_H +#define WIN32 1 +#endif /* _WIN32_WCE */ +#endif /* WIN32 */ +#ifdef WIN32 +#define WIN32_LEAN_AND_MEAN +#include +#include +#define HAVE_MMAP 1 +#define HAVE_MORECORE 0 +#define LACKS_UNISTD_H +#define LACKS_SYS_PARAM_H +#define LACKS_SYS_MMAN_H +#define LACKS_STRING_H +#define LACKS_STRINGS_H +#define LACKS_SYS_TYPES_H +#define LACKS_ERRNO_H +#define LACKS_SCHED_H +#ifndef MALLOC_FAILURE_ACTION +#define MALLOC_FAILURE_ACTION +#endif /* MALLOC_FAILURE_ACTION */ +#ifndef MMAP_CLEARS +#ifdef _WIN32_WCE /* WINCE reportedly does not clear */ +#define MMAP_CLEARS 0 +#else +#define MMAP_CLEARS 1 +#endif /* _WIN32_WCE */ +#endif /*MMAP_CLEARS */ +#endif /* WIN32 */ + +#if defined(DARWIN) || defined(_DARWIN) +/* Mac OSX docs advise not to use sbrk; it seems better to use mmap */ +#ifndef HAVE_MORECORE +#define HAVE_MORECORE 0 +#define HAVE_MMAP 1 +/* OSX allocators provide 16 byte alignment */ +#ifndef MALLOC_ALIGNMENT +#define MALLOC_ALIGNMENT ((size_t)16U) +#endif +#endif /* HAVE_MORECORE */ +#endif /* DARWIN */ + +#ifndef LACKS_SYS_TYPES_H +#include /* For size_t */ +#endif /* LACKS_SYS_TYPES_H */ + +/* The maximum possible size_t value has all bits set */ +#define MAX_SIZE_T (~(size_t)0) + +#ifndef USE_LOCKS /* ensure true if spin or recursive locks set */ +#define USE_LOCKS ((defined(USE_SPIN_LOCKS) && USE_SPIN_LOCKS != 0) || \ + (defined(USE_RECURSIVE_LOCKS) && USE_RECURSIVE_LOCKS != 0)) +#endif /* USE_LOCKS */ + +#if USE_LOCKS /* Spin locks for gcc >= 4.1, older gcc on x86, MSC >= 1310 */ +#if ((defined(__GNUC__) && \ + ((__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)) || \ + defined(__i386__) || defined(__x86_64__))) || \ + (defined(_MSC_VER) && _MSC_VER>=1310)) +#ifndef USE_SPIN_LOCKS +#define USE_SPIN_LOCKS 1 +#endif /* USE_SPIN_LOCKS */ +#elif USE_SPIN_LOCKS +#error "USE_SPIN_LOCKS defined without implementation" +#endif /* ... locks available... */ +#elif !defined(USE_SPIN_LOCKS) +#define USE_SPIN_LOCKS 0 +#endif /* USE_LOCKS */ + +#ifndef ONLY_MSPACES +#define ONLY_MSPACES 0 +#endif /* ONLY_MSPACES */ +#ifndef MSPACES +#if ONLY_MSPACES +#define MSPACES 1 +#else /* ONLY_MSPACES */ +#define MSPACES 0 +#endif /* ONLY_MSPACES */ +#endif /* MSPACES */ +#ifndef MALLOC_ALIGNMENT +#define MALLOC_ALIGNMENT ((size_t)(2 * sizeof(void *))) +#endif /* MALLOC_ALIGNMENT */ +#ifndef FOOTERS +#define FOOTERS 0 +#endif /* FOOTERS */ +#ifndef ABORT +#define ABORT abort() +#endif /* ABORT */ +#ifndef ABORT_ON_ASSERT_FAILURE +#define ABORT_ON_ASSERT_FAILURE 1 +#endif /* ABORT_ON_ASSERT_FAILURE */ +#ifndef PROCEED_ON_ERROR +#define PROCEED_ON_ERROR 0 +#endif /* PROCEED_ON_ERROR */ + +#ifndef INSECURE +#define INSECURE 0 +#endif /* INSECURE */ +#ifndef MALLOC_INSPECT_ALL +#define MALLOC_INSPECT_ALL 0 +#endif /* MALLOC_INSPECT_ALL */ +#ifndef HAVE_MMAP +#define HAVE_MMAP 1 +#endif /* HAVE_MMAP */ +#ifndef MMAP_CLEARS +#define MMAP_CLEARS 1 +#endif /* MMAP_CLEARS */ +#ifndef HAVE_MREMAP +#ifdef linux +#define HAVE_MREMAP 1 +#define _GNU_SOURCE /* Turns on mremap() definition */ +#else /* linux */ +#define HAVE_MREMAP 0 +#endif /* linux */ +#endif /* HAVE_MREMAP */ +#ifndef MALLOC_FAILURE_ACTION +#define MALLOC_FAILURE_ACTION errno = ENOMEM; +#endif /* MALLOC_FAILURE_ACTION */ +#ifndef HAVE_MORECORE +#if ONLY_MSPACES +#define HAVE_MORECORE 0 +#else /* ONLY_MSPACES */ +#define HAVE_MORECORE 1 +#endif /* ONLY_MSPACES */ +#endif /* HAVE_MORECORE */ +#if !HAVE_MORECORE +#define MORECORE_CONTIGUOUS 0 +#else /* !HAVE_MORECORE */ +#define MORECORE_DEFAULT sbrk +#ifndef MORECORE_CONTIGUOUS +#define MORECORE_CONTIGUOUS 1 +#endif /* MORECORE_CONTIGUOUS */ +#endif /* HAVE_MORECORE */ +#ifndef DEFAULT_GRANULARITY +#if (MORECORE_CONTIGUOUS || defined(WIN32)) +#define DEFAULT_GRANULARITY (0) /* 0 means to compute in init_mparams */ +#else /* MORECORE_CONTIGUOUS */ +#define DEFAULT_GRANULARITY ((size_t)64U * (size_t)1024U) +#endif /* MORECORE_CONTIGUOUS */ +#endif /* DEFAULT_GRANULARITY */ +#ifndef DEFAULT_TRIM_THRESHOLD +#ifndef MORECORE_CANNOT_TRIM +#define DEFAULT_TRIM_THRESHOLD ((size_t)2U * (size_t)1024U * (size_t)1024U) +#else /* MORECORE_CANNOT_TRIM */ +#define DEFAULT_TRIM_THRESHOLD MAX_SIZE_T +#endif /* MORECORE_CANNOT_TRIM */ +#endif /* DEFAULT_TRIM_THRESHOLD */ +#ifndef DEFAULT_MMAP_THRESHOLD +#if HAVE_MMAP +#define DEFAULT_MMAP_THRESHOLD ((size_t)256U * (size_t)1024U) +#else /* HAVE_MMAP */ +#define DEFAULT_MMAP_THRESHOLD MAX_SIZE_T +#endif /* HAVE_MMAP */ +#endif /* DEFAULT_MMAP_THRESHOLD */ +#ifndef MAX_RELEASE_CHECK_RATE +#if HAVE_MMAP +#define MAX_RELEASE_CHECK_RATE 4095 +#else +#define MAX_RELEASE_CHECK_RATE MAX_SIZE_T +#endif /* HAVE_MMAP */ +#endif /* MAX_RELEASE_CHECK_RATE */ +#ifndef USE_BUILTIN_FFS +#define USE_BUILTIN_FFS 0 +#endif /* USE_BUILTIN_FFS */ +#ifndef USE_DEV_RANDOM +#define USE_DEV_RANDOM 0 +#endif /* USE_DEV_RANDOM */ +#ifndef NO_MALLINFO +#define NO_MALLINFO 0 +#endif /* NO_MALLINFO */ +#ifndef MALLINFO_FIELD_TYPE +#define MALLINFO_FIELD_TYPE size_t +#endif /* MALLINFO_FIELD_TYPE */ +#ifndef NO_MALLOC_STATS +#define NO_MALLOC_STATS 0 +#endif /* NO_MALLOC_STATS */ +#ifndef NO_SEGMENT_TRAVERSAL +#define NO_SEGMENT_TRAVERSAL 0 +#endif /* NO_SEGMENT_TRAVERSAL */ + +/* + mallopt tuning options. SVID/XPG defines four standard parameter + numbers for mallopt, normally defined in malloc.h. None of these + are used in this malloc, so setting them has no effect. But this + malloc does support the following options. +*/ + +#define M_TRIM_THRESHOLD (-1) +#define M_GRANULARITY (-2) +#define M_MMAP_THRESHOLD (-3) + +/* ------------------------ Mallinfo declarations ------------------------ */ + +#if !NO_MALLINFO +/* + This version of malloc supports the standard SVID/XPG mallinfo + routine that returns a struct containing usage properties and + statistics. It should work on any system that has a + /usr/include/malloc.h defining struct mallinfo. The main + declaration needed is the mallinfo struct that is returned (by-copy) + by mallinfo(). The malloinfo struct contains a bunch of fields that + are not even meaningful in this version of malloc. These fields are + are instead filled by mallinfo() with other numbers that might be of + interest. + + HAVE_USR_INCLUDE_MALLOC_H should be set if you have a + /usr/include/malloc.h file that includes a declaration of struct + mallinfo. If so, it is included; else a compliant version is + declared below. These must be precisely the same for mallinfo() to + work. The original SVID version of this struct, defined on most + systems with mallinfo, declares all fields as ints. But some others + define as unsigned long. If your system defines the fields using a + type of different width than listed here, you MUST #include your + system version and #define HAVE_USR_INCLUDE_MALLOC_H. +*/ + +/* #define HAVE_USR_INCLUDE_MALLOC_H */ + +#ifdef HAVE_USR_INCLUDE_MALLOC_H +#include "/usr/include/malloc.h" +#else /* HAVE_USR_INCLUDE_MALLOC_H */ +#ifndef STRUCT_MALLINFO_DECLARED +/* HP-UX (and others?) redefines mallinfo unless _STRUCT_MALLINFO is defined */ +#define _STRUCT_MALLINFO +#define STRUCT_MALLINFO_DECLARED 1 +struct mallinfo { + MALLINFO_FIELD_TYPE arena; /* non-mmapped space allocated from system */ + MALLINFO_FIELD_TYPE ordblks; /* number of free chunks */ + MALLINFO_FIELD_TYPE smblks; /* always 0 */ + MALLINFO_FIELD_TYPE hblks; /* always 0 */ + MALLINFO_FIELD_TYPE hblkhd; /* space in mmapped regions */ + MALLINFO_FIELD_TYPE usmblks; /* maximum total allocated space */ + MALLINFO_FIELD_TYPE fsmblks; /* always 0 */ + MALLINFO_FIELD_TYPE uordblks; /* total allocated space */ + MALLINFO_FIELD_TYPE fordblks; /* total free space */ + MALLINFO_FIELD_TYPE keepcost; /* releasable (via malloc_trim) space */ +}; +#endif /* STRUCT_MALLINFO_DECLARED */ +#endif /* HAVE_USR_INCLUDE_MALLOC_H */ +#endif /* NO_MALLINFO */ + +/* + Try to persuade compilers to inline. The most critical functions for + inlining are defined as macros, so these aren't used for them. +*/ + +#ifndef FORCEINLINE + #if defined(__GNUC__) +#define FORCEINLINE __inline __attribute__ ((always_inline)) + #elif defined(_MSC_VER) + #define FORCEINLINE __forceinline + #endif +#endif +#ifndef NOINLINE + #if defined(__GNUC__) + #define NOINLINE __attribute__ ((noinline)) + #elif defined(_MSC_VER) + #define NOINLINE __declspec(noinline) + #else + #define NOINLINE + #endif +#endif + +#ifdef __cplusplus +extern "C" { +#ifndef FORCEINLINE + #define FORCEINLINE inline +#endif +#endif /* __cplusplus */ +#ifndef FORCEINLINE + #define FORCEINLINE +#endif + +#if !ONLY_MSPACES + +/* ------------------- Declarations of public routines ------------------- */ + +#ifndef USE_DL_PREFIX +#define dlcalloc calloc +#define dlfree free +#define dlmalloc malloc +#define dlmemalign memalign +#define dlposix_memalign posix_memalign +#define dlrealloc realloc +#define dlrealloc_in_place realloc_in_place +#define dlvalloc valloc +#define dlpvalloc pvalloc +#define dlmallinfo mallinfo +#define dlmallopt mallopt +#define dlmalloc_trim malloc_trim +#define dlmalloc_stats malloc_stats +#define dlmalloc_usable_size malloc_usable_size +#define dlmalloc_footprint malloc_footprint +#define dlmalloc_max_footprint malloc_max_footprint +#define dlmalloc_footprint_limit malloc_footprint_limit +#define dlmalloc_set_footprint_limit malloc_set_footprint_limit +#define dlmalloc_inspect_all malloc_inspect_all +#define dlindependent_calloc independent_calloc +#define dlindependent_comalloc independent_comalloc +#define dlbulk_free bulk_free +#endif /* USE_DL_PREFIX */ + +/* + malloc(size_t n) + Returns a pointer to a newly allocated chunk of at least n bytes, or + null if no space is available, in which case errno is set to ENOMEM + on ANSI C systems. + + If n is zero, malloc returns a minimum-sized chunk. (The minimum + size is 16 bytes on most 32bit systems, and 32 bytes on 64bit + systems.) Note that size_t is an unsigned type, so calls with + arguments that would be negative if signed are interpreted as + requests for huge amounts of space, which will often fail. The + maximum supported value of n differs across systems, but is in all + cases less than the maximum representable value of a size_t. +*/ +DLMALLOC_EXPORT void* dlmalloc(size_t); + +/* + free(void* p) + Releases the chunk of memory pointed to by p, that had been previously + allocated using malloc or a related routine such as realloc. + It has no effect if p is null. If p was not malloced or already + freed, free(p) will by default cause the current program to abort. +*/ +DLMALLOC_EXPORT void dlfree(void*); + +/* + calloc(size_t n_elements, size_t element_size); + Returns a pointer to n_elements * element_size bytes, with all locations + set to zero. +*/ +DLMALLOC_EXPORT void* dlcalloc(size_t, size_t); + +/* + realloc(void* p, size_t n) + Returns a pointer to a chunk of size n that contains the same data + as does chunk p up to the minimum of (n, p's size) bytes, or null + if no space is available. + + The returned pointer may or may not be the same as p. The algorithm + prefers extending p in most cases when possible, otherwise it + employs the equivalent of a malloc-copy-free sequence. + + If p is null, realloc is equivalent to malloc. + + If space is not available, realloc returns null, errno is set (if on + ANSI) and p is NOT freed. + + if n is for fewer bytes than already held by p, the newly unused + space is lopped off and freed if possible. realloc with a size + argument of zero (re)allocates a minimum-sized chunk. + + The old unix realloc convention of allowing the last-free'd chunk + to be used as an argument to realloc is not supported. +*/ +DLMALLOC_EXPORT void* dlrealloc(void*, size_t); + +/* + realloc_in_place(void* p, size_t n) + Resizes the space allocated for p to size n, only if this can be + done without moving p (i.e., only if there is adjacent space + available if n is greater than p's current allocated size, or n is + less than or equal to p's size). This may be used instead of plain + realloc if an alternative allocation strategy is needed upon failure + to expand space; for example, reallocation of a buffer that must be + memory-aligned or cleared. You can use realloc_in_place to trigger + these alternatives only when needed. + + Returns p if successful; otherwise null. +*/ +DLMALLOC_EXPORT void* dlrealloc_in_place(void*, size_t); + +/* + memalign(size_t alignment, size_t n); + Returns a pointer to a newly allocated chunk of n bytes, aligned + in accord with the alignment argument. + + The alignment argument should be a power of two. If the argument is + not a power of two, the nearest greater power is used. + 8-byte alignment is guaranteed by normal malloc calls, so don't + bother calling memalign with an argument of 8 or less. + + Overreliance on memalign is a sure way to fragment space. +*/ +DLMALLOC_EXPORT void* dlmemalign(size_t, size_t); + +/* + int posix_memalign(void** pp, size_t alignment, size_t n); + Allocates a chunk of n bytes, aligned in accord with the alignment + argument. Differs from memalign only in that it (1) assigns the + allocated memory to *pp rather than returning it, (2) fails and + returns EINVAL if the alignment is not a power of two (3) fails and + returns ENOMEM if memory cannot be allocated. +*/ +DLMALLOC_EXPORT int dlposix_memalign(void**, size_t, size_t); + +/* + valloc(size_t n); + Equivalent to memalign(pagesize, n), where pagesize is the page + size of the system. If the pagesize is unknown, 4096 is used. +*/ +DLMALLOC_EXPORT void* dlvalloc(size_t); + +/* + mallopt(int parameter_number, int parameter_value) + Sets tunable parameters The format is to provide a + (parameter-number, parameter-value) pair. mallopt then sets the + corresponding parameter to the argument value if it can (i.e., so + long as the value is meaningful), and returns 1 if successful else + 0. To workaround the fact that mallopt is specified to use int, + not size_t parameters, the value -1 is specially treated as the + maximum unsigned size_t value. + + SVID/XPG/ANSI defines four standard param numbers for mallopt, + normally defined in malloc.h. None of these are use in this malloc, + so setting them has no effect. But this malloc also supports other + options in mallopt. See below for details. Briefly, supported + parameters are as follows (listed defaults are for "typical" + configurations). + + Symbol param # default allowed param values + M_TRIM_THRESHOLD -1 2*1024*1024 any (-1 disables) + M_GRANULARITY -2 page size any power of 2 >= page size + M_MMAP_THRESHOLD -3 256*1024 any (or 0 if no MMAP support) +*/ +DLMALLOC_EXPORT int dlmallopt(int, int); + +/* + malloc_footprint(); + Returns the number of bytes obtained from the system. The total + number of bytes allocated by malloc, realloc etc., is less than this + value. Unlike mallinfo, this function returns only a precomputed + result, so can be called frequently to monitor memory consumption. + Even if locks are otherwise defined, this function does not use them, + so results might not be up to date. +*/ +DLMALLOC_EXPORT size_t dlmalloc_footprint(void); + +/* + malloc_max_footprint(); + Returns the maximum number of bytes obtained from the system. This + value will be greater than current footprint if deallocated space + has been reclaimed by the system. The peak number of bytes allocated + by malloc, realloc etc., is less than this value. Unlike mallinfo, + this function returns only a precomputed result, so can be called + frequently to monitor memory consumption. Even if locks are + otherwise defined, this function does not use them, so results might + not be up to date. +*/ +DLMALLOC_EXPORT size_t dlmalloc_max_footprint(void); + +/* + malloc_footprint_limit(); + Returns the number of bytes that the heap is allowed to obtain from + the system, returning the last value returned by + malloc_set_footprint_limit, or the maximum size_t value if + never set. The returned value reflects a permission. There is no + guarantee that this number of bytes can actually be obtained from + the system. +*/ +DLMALLOC_EXPORT size_t dlmalloc_footprint_limit(); + +/* + malloc_set_footprint_limit(); + Sets the maximum number of bytes to obtain from the system, causing + failure returns from malloc and related functions upon attempts to + exceed this value. The argument value may be subject to page + rounding to an enforceable limit; this actual value is returned. + Using an argument of the maximum possible size_t effectively + disables checks. If the argument is less than or equal to the + current malloc_footprint, then all future allocations that require + additional system memory will fail. However, invocation cannot + retroactively deallocate existing used memory. +*/ +DLMALLOC_EXPORT size_t dlmalloc_set_footprint_limit(size_t bytes); + +#if MALLOC_INSPECT_ALL +/* + malloc_inspect_all(void(*handler)(void *start, + void *end, + size_t used_bytes, + void* callback_arg), + void* arg); + Traverses the heap and calls the given handler for each managed + region, skipping all bytes that are (or may be) used for bookkeeping + purposes. Traversal does not include include chunks that have been + directly memory mapped. Each reported region begins at the start + address, and continues up to but not including the end address. The + first used_bytes of the region contain allocated data. If + used_bytes is zero, the region is unallocated. The handler is + invoked with the given callback argument. If locks are defined, they + are held during the entire traversal. It is a bad idea to invoke + other malloc functions from within the handler. + + For example, to count the number of in-use chunks with size greater + than 1000, you could write: + static int count = 0; + void count_chunks(void* start, void* end, size_t used, void* arg) { + if (used >= 1000) ++count; + } + then: + malloc_inspect_all(count_chunks, NULL); + + malloc_inspect_all is compiled only if MALLOC_INSPECT_ALL is defined. +*/ +DLMALLOC_EXPORT void dlmalloc_inspect_all(void(*handler)(void*, void *, size_t, void*), + void* arg); + +#endif /* MALLOC_INSPECT_ALL */ + +#if !NO_MALLINFO +/* + mallinfo() + Returns (by copy) a struct containing various summary statistics: + + arena: current total non-mmapped bytes allocated from system + ordblks: the number of free chunks + smblks: always zero. + hblks: current number of mmapped regions + hblkhd: total bytes held in mmapped regions + usmblks: the maximum total allocated space. This will be greater + than current total if trimming has occurred. + fsmblks: always zero + uordblks: current total allocated space (normal or mmapped) + fordblks: total free space + keepcost: the maximum number of bytes that could ideally be released + back to system via malloc_trim. ("ideally" means that + it ignores page restrictions etc.) + + Because these fields are ints, but internal bookkeeping may + be kept as longs, the reported values may wrap around zero and + thus be inaccurate. +*/ +DLMALLOC_EXPORT struct mallinfo dlmallinfo(void); +#endif /* NO_MALLINFO */ + +/* + independent_calloc(size_t n_elements, size_t element_size, void* chunks[]); + + independent_calloc is similar to calloc, but instead of returning a + single cleared space, it returns an array of pointers to n_elements + independent elements that can hold contents of size elem_size, each + of which starts out cleared, and can be independently freed, + realloc'ed etc. The elements are guaranteed to be adjacently + allocated (this is not guaranteed to occur with multiple callocs or + mallocs), which may also improve cache locality in some + applications. + + The "chunks" argument is optional (i.e., may be null, which is + probably the most typical usage). If it is null, the returned array + is itself dynamically allocated and should also be freed when it is + no longer needed. Otherwise, the chunks array must be of at least + n_elements in length. It is filled in with the pointers to the + chunks. + + In either case, independent_calloc returns this pointer array, or + null if the allocation failed. If n_elements is zero and "chunks" + is null, it returns a chunk representing an array with zero elements + (which should be freed if not wanted). + + Each element must be freed when it is no longer needed. This can be + done all at once using bulk_free. + + independent_calloc simplifies and speeds up implementations of many + kinds of pools. It may also be useful when constructing large data + structures that initially have a fixed number of fixed-sized nodes, + but the number is not known at compile time, and some of the nodes + may later need to be freed. For example: + + struct Node { int item; struct Node* next; }; + + struct Node* build_list() { + struct Node** pool; + int n = read_number_of_nodes_needed(); + if (n <= 0) return 0; + pool = (struct Node**)(independent_calloc(n, sizeof(struct Node), 0); + if (pool == 0) die(); + // organize into a linked list... + struct Node* first = pool[0]; + for (i = 0; i < n-1; ++i) + pool[i]->next = pool[i+1]; + free(pool); // Can now free the array (or not, if it is needed later) + return first; + } +*/ +DLMALLOC_EXPORT void** dlindependent_calloc(size_t, size_t, void**); + +/* + independent_comalloc(size_t n_elements, size_t sizes[], void* chunks[]); + + independent_comalloc allocates, all at once, a set of n_elements + chunks with sizes indicated in the "sizes" array. It returns + an array of pointers to these elements, each of which can be + independently freed, realloc'ed etc. The elements are guaranteed to + be adjacently allocated (this is not guaranteed to occur with + multiple callocs or mallocs), which may also improve cache locality + in some applications. + + The "chunks" argument is optional (i.e., may be null). If it is null + the returned array is itself dynamically allocated and should also + be freed when it is no longer needed. Otherwise, the chunks array + must be of at least n_elements in length. It is filled in with the + pointers to the chunks. + + In either case, independent_comalloc returns this pointer array, or + null if the allocation failed. If n_elements is zero and chunks is + null, it returns a chunk representing an array with zero elements + (which should be freed if not wanted). + + Each element must be freed when it is no longer needed. This can be + done all at once using bulk_free. + + independent_comallac differs from independent_calloc in that each + element may have a different size, and also that it does not + automatically clear elements. + + independent_comalloc can be used to speed up allocation in cases + where several structs or objects must always be allocated at the + same time. For example: + + struct Head { ... } + struct Foot { ... } + + void send_message(char* msg) { + int msglen = strlen(msg); + size_t sizes[3] = { sizeof(struct Head), msglen, sizeof(struct Foot) }; + void* chunks[3]; + if (independent_comalloc(3, sizes, chunks) == 0) + die(); + struct Head* head = (struct Head*)(chunks[0]); + char* body = (char*)(chunks[1]); + struct Foot* foot = (struct Foot*)(chunks[2]); + // ... + } + + In general though, independent_comalloc is worth using only for + larger values of n_elements. For small values, you probably won't + detect enough difference from series of malloc calls to bother. + + Overuse of independent_comalloc can increase overall memory usage, + since it cannot reuse existing noncontiguous small chunks that + might be available for some of the elements. +*/ +DLMALLOC_EXPORT void** dlindependent_comalloc(size_t, size_t*, void**); + +/* + bulk_free(void* array[], size_t n_elements) + Frees and clears (sets to null) each non-null pointer in the given + array. This is likely to be faster than freeing them one-by-one. + If footers are used, pointers that have been allocated in different + mspaces are not freed or cleared, and the count of all such pointers + is returned. For large arrays of pointers with poor locality, it + may be worthwhile to sort this array before calling bulk_free. +*/ +DLMALLOC_EXPORT size_t dlbulk_free(void**, size_t n_elements); + +/* + pvalloc(size_t n); + Equivalent to valloc(minimum-page-that-holds(n)), that is, + round up n to nearest pagesize. + */ +DLMALLOC_EXPORT void* dlpvalloc(size_t); + +/* + malloc_trim(size_t pad); + + If possible, gives memory back to the system (via negative arguments + to sbrk) if there is unused memory at the `high' end of the malloc + pool or in unused MMAP segments. You can call this after freeing + large blocks of memory to potentially reduce the system-level memory + requirements of a program. However, it cannot guarantee to reduce + memory. Under some allocation patterns, some large free blocks of + memory will be locked between two used chunks, so they cannot be + given back to the system. + + The `pad' argument to malloc_trim represents the amount of free + trailing space to leave untrimmed. If this argument is zero, only + the minimum amount of memory to maintain internal data structures + will be left. Non-zero arguments can be supplied to maintain enough + trailing space to service future expected allocations without having + to re-obtain memory from the system. + + Malloc_trim returns 1 if it actually released any memory, else 0. +*/ +DLMALLOC_EXPORT int dlmalloc_trim(size_t); + +/* + malloc_stats(); + Prints on stderr the amount of space obtained from the system (both + via sbrk and mmap), the maximum amount (which may be more than + current if malloc_trim and/or munmap got called), and the current + number of bytes allocated via malloc (or realloc, etc) but not yet + freed. Note that this is the number of bytes allocated, not the + number requested. It will be larger than the number requested + because of alignment and bookkeeping overhead. Because it includes + alignment wastage as being in use, this figure may be greater than + zero even when no user-level chunks are allocated. + + The reported current and maximum system memory can be inaccurate if + a program makes other calls to system memory allocation functions + (normally sbrk) outside of malloc. + + malloc_stats prints only the most commonly interesting statistics. + More information can be obtained by calling mallinfo. +*/ +DLMALLOC_EXPORT void dlmalloc_stats(void); + +/* + malloc_usable_size(void* p); + + Returns the number of bytes you can actually use in + an allocated chunk, which may be more than you requested (although + often not) due to alignment and minimum size constraints. + You can use this many bytes without worrying about + overwriting other allocated objects. This is not a particularly great + programming practice. malloc_usable_size can be more useful in + debugging and assertions, for example: + + p = malloc(n); + assert(malloc_usable_size(p) >= 256); +*/ +size_t dlmalloc_usable_size(void*); + +#endif /* ONLY_MSPACES */ + +#if MSPACES + +/* + mspace is an opaque type representing an independent + region of space that supports mspace_malloc, etc. +*/ +typedef void* mspace; + +/* + create_mspace creates and returns a new independent space with the + given initial capacity, or, if 0, the default granularity size. It + returns null if there is no system memory available to create the + space. If argument locked is non-zero, the space uses a separate + lock to control access. The capacity of the space will grow + dynamically as needed to service mspace_malloc requests. You can + control the sizes of incremental increases of this space by + compiling with a different DEFAULT_GRANULARITY or dynamically + setting with mallopt(M_GRANULARITY, value). +*/ +DLMALLOC_EXPORT mspace create_mspace(size_t capacity, int locked); + +/* + destroy_mspace destroys the given space, and attempts to return all + of its memory back to the system, returning the total number of + bytes freed. After destruction, the results of access to all memory + used by the space become undefined. +*/ +DLMALLOC_EXPORT size_t destroy_mspace(mspace msp); + +/* + create_mspace_with_base uses the memory supplied as the initial base + of a new mspace. Part (less than 128*sizeof(size_t) bytes) of this + space is used for bookkeeping, so the capacity must be at least this + large. (Otherwise 0 is returned.) When this initial space is + exhausted, additional memory will be obtained from the system. + Destroying this space will deallocate all additionally allocated + space (if possible) but not the initial base. +*/ +DLMALLOC_EXPORT mspace create_mspace_with_base(void* base, size_t capacity, int locked); + +/* + mspace_track_large_chunks controls whether requests for large chunks + are allocated in their own untracked mmapped regions, separate from + others in this mspace. By default large chunks are not tracked, + which reduces fragmentation. However, such chunks are not + necessarily released to the system upon destroy_mspace. Enabling + tracking by setting to true may increase fragmentation, but avoids + leakage when relying on destroy_mspace to release all memory + allocated using this space. The function returns the previous + setting. +*/ +DLMALLOC_EXPORT int mspace_track_large_chunks(mspace msp, int enable); + + +/* + mspace_malloc behaves as malloc, but operates within + the given space. +*/ +DLMALLOC_EXPORT void* mspace_malloc(mspace msp, size_t bytes); + +/* + mspace_free behaves as free, but operates within + the given space. + + If compiled with FOOTERS==1, mspace_free is not actually needed. + free may be called instead of mspace_free because freed chunks from + any space are handled by their originating spaces. +*/ +DLMALLOC_EXPORT void mspace_free(mspace msp, void* mem); + +/* + mspace_realloc behaves as realloc, but operates within + the given space. + + If compiled with FOOTERS==1, mspace_realloc is not actually + needed. realloc may be called instead of mspace_realloc because + realloced chunks from any space are handled by their originating + spaces. +*/ +DLMALLOC_EXPORT void* mspace_realloc(mspace msp, void* mem, size_t newsize); + +/* + mspace_calloc behaves as calloc, but operates within + the given space. +*/ +DLMALLOC_EXPORT void* mspace_calloc(mspace msp, size_t n_elements, size_t elem_size); + +/* + mspace_memalign behaves as memalign, but operates within + the given space. +*/ +DLMALLOC_EXPORT void* mspace_memalign(mspace msp, size_t alignment, size_t bytes); + +/* + mspace_independent_calloc behaves as independent_calloc, but + operates within the given space. +*/ +DLMALLOC_EXPORT void** mspace_independent_calloc(mspace msp, size_t n_elements, + size_t elem_size, void* chunks[]); + +/* + mspace_independent_comalloc behaves as independent_comalloc, but + operates within the given space. +*/ +DLMALLOC_EXPORT void** mspace_independent_comalloc(mspace msp, size_t n_elements, + size_t sizes[], void* chunks[]); + +/* + mspace_footprint() returns the number of bytes obtained from the + system for this space. +*/ +DLMALLOC_EXPORT size_t mspace_footprint(mspace msp); + +/* + mspace_max_footprint() returns the peak number of bytes obtained from the + system for this space. +*/ +DLMALLOC_EXPORT size_t mspace_max_footprint(mspace msp); + + +#if !NO_MALLINFO +/* + mspace_mallinfo behaves as mallinfo, but reports properties of + the given space. +*/ +DLMALLOC_EXPORT struct mallinfo mspace_mallinfo(mspace msp); +#endif /* NO_MALLINFO */ + +/* + malloc_usable_size(void* p) behaves the same as malloc_usable_size; +*/ +DLMALLOC_EXPORT size_t mspace_usable_size(const void* mem); + +/* + mspace_malloc_stats behaves as malloc_stats, but reports + properties of the given space. +*/ +DLMALLOC_EXPORT void mspace_malloc_stats(mspace msp); + +/* + mspace_trim behaves as malloc_trim, but + operates within the given space. +*/ +DLMALLOC_EXPORT int mspace_trim(mspace msp, size_t pad); + +/* + An alias for mallopt. +*/ +DLMALLOC_EXPORT int mspace_mallopt(int, int); + +#endif /* MSPACES */ + +#ifdef __cplusplus +} /* end of extern "C" */ +#endif /* __cplusplus */ + +/* + ======================================================================== + To make a fully customizable malloc.h header file, cut everything + above this line, put into file malloc.h, edit to suit, and #include it + on the next line, as well as in programs that use this malloc. + ======================================================================== +*/ + +/* #include "malloc.h" */ + +/*------------------------------ internal #includes ---------------------- */ + +#ifdef _MSC_VER +#pragma warning( disable : 4146 ) /* no "unsigned" warnings */ +#endif /* _MSC_VER */ +#if !NO_MALLOC_STATS +#include /* for printing in malloc_stats */ +#endif /* NO_MALLOC_STATS */ +#ifndef LACKS_ERRNO_H +#include /* for MALLOC_FAILURE_ACTION */ +#endif /* LACKS_ERRNO_H */ +#ifdef DEBUG +#if ABORT_ON_ASSERT_FAILURE +#undef assert +#define assert(x) if(!(x)) ABORT +#else /* ABORT_ON_ASSERT_FAILURE */ +#include +#endif /* ABORT_ON_ASSERT_FAILURE */ +#else /* DEBUG */ +#ifndef assert +#define assert(x) +#endif +#define DEBUG 0 +#endif /* DEBUG */ +#if !defined(WIN32) && !defined(LACKS_TIME_H) +#include /* for magic initialization */ +#endif /* WIN32 */ +#ifndef LACKS_STDLIB_H +#include /* for abort() */ +#endif /* LACKS_STDLIB_H */ +#ifndef LACKS_STRING_H +#include /* for memset etc */ +#endif /* LACKS_STRING_H */ +#if USE_BUILTIN_FFS +#ifndef LACKS_STRINGS_H +#include /* for ffs */ +#endif /* LACKS_STRINGS_H */ +#endif /* USE_BUILTIN_FFS */ +#if HAVE_MMAP +#ifndef LACKS_SYS_MMAN_H +/* On some versions of linux, mremap decl in mman.h needs __USE_GNU set */ +#if (defined(linux) && !defined(__USE_GNU)) +#define __USE_GNU 1 +#include /* for mmap */ +#undef __USE_GNU +#else +#include /* for mmap */ +#endif /* linux */ +#endif /* LACKS_SYS_MMAN_H */ +#ifndef LACKS_FCNTL_H +#include +#endif /* LACKS_FCNTL_H */ +#endif /* HAVE_MMAP */ +#ifndef LACKS_UNISTD_H +#include /* for sbrk, sysconf */ +#else /* LACKS_UNISTD_H */ +#if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__NetBSD__) +extern void* sbrk(ptrdiff_t); +#endif /* FreeBSD etc */ +#endif /* LACKS_UNISTD_H */ + +/* Declarations for locking */ +#if USE_LOCKS +#ifndef WIN32 +#if defined (__SVR4) && defined (__sun) /* solaris */ +#include +#elif !defined(LACKS_SCHED_H) +#include +#endif /* solaris or LACKS_SCHED_H */ +#if (defined(USE_RECURSIVE_LOCKS) && USE_RECURSIVE_LOCKS != 0) || !USE_SPIN_LOCKS +#include +#endif /* USE_RECURSIVE_LOCKS ... */ +#elif defined(_MSC_VER) +#ifndef _M_AMD64 +/* These are already defined on AMD64 builds */ +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ +LONG __cdecl _InterlockedCompareExchange(LONG volatile *Dest, LONG Exchange, LONG Comp); +LONG __cdecl _InterlockedExchange(LONG volatile *Target, LONG Value); +#ifdef __cplusplus +} +#endif /* __cplusplus */ +#endif /* _M_AMD64 */ +#pragma intrinsic (_InterlockedCompareExchange) +#pragma intrinsic (_InterlockedExchange) +#define interlockedcompareexchange _InterlockedCompareExchange +#define interlockedexchange _InterlockedExchange +#elif defined(WIN32) && defined(__GNUC__) +#define interlockedcompareexchange(a, b, c) __sync_val_compare_and_swap(a, c, b) +#define interlockedexchange __sync_lock_test_and_set +#endif /* Win32 */ +#else /* USE_LOCKS */ +#endif /* USE_LOCKS */ + +#ifndef LOCK_AT_FORK +#define LOCK_AT_FORK 0 +#endif + +/* Declarations for bit scanning on win32 */ +#if defined(_MSC_VER) && _MSC_VER>=1300 +#ifndef BitScanForward /* Try to avoid pulling in WinNT.h */ +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ +unsigned char _BitScanForward(unsigned long *index, unsigned long mask); +unsigned char _BitScanReverse(unsigned long *index, unsigned long mask); +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#define BitScanForward _BitScanForward +#define BitScanReverse _BitScanReverse +#pragma intrinsic(_BitScanForward) +#pragma intrinsic(_BitScanReverse) +#endif /* BitScanForward */ +#endif /* defined(_MSC_VER) && _MSC_VER>=1300 */ + +#ifndef WIN32 +#ifndef malloc_getpagesize +# ifdef _SC_PAGESIZE /* some SVR4 systems omit an underscore */ +# ifndef _SC_PAGE_SIZE +# define _SC_PAGE_SIZE _SC_PAGESIZE +# endif +# endif +# ifdef _SC_PAGE_SIZE +# define malloc_getpagesize sysconf(_SC_PAGE_SIZE) +# else +# if defined(BSD) || defined(DGUX) || defined(HAVE_GETPAGESIZE) + extern size_t getpagesize(); +# define malloc_getpagesize getpagesize() +# else +# ifdef WIN32 /* use supplied emulation of getpagesize */ +# define malloc_getpagesize getpagesize() +# else +# ifndef LACKS_SYS_PARAM_H +# include +# endif +# ifdef EXEC_PAGESIZE +# define malloc_getpagesize EXEC_PAGESIZE +# else +# ifdef NBPG +# ifndef CLSIZE +# define malloc_getpagesize NBPG +# else +# define malloc_getpagesize (NBPG * CLSIZE) +# endif +# else +# ifdef NBPC +# define malloc_getpagesize NBPC +# else +# ifdef PAGESIZE +# define malloc_getpagesize PAGESIZE +# else /* just guess */ +# define malloc_getpagesize ((size_t)4096U) +# endif +# endif +# endif +# endif +# endif +# endif +# endif +#endif +#endif + +/* ------------------- size_t and alignment properties -------------------- */ + +/* The byte and bit size of a size_t */ +#define SIZE_T_SIZE (sizeof(size_t)) +#define SIZE_T_BITSIZE (sizeof(size_t) << 3) + +/* Some constants coerced to size_t */ +/* Annoying but necessary to avoid errors on some platforms */ +#define SIZE_T_ZERO ((size_t)0) +#define SIZE_T_ONE ((size_t)1) +#define SIZE_T_TWO ((size_t)2) +#define SIZE_T_FOUR ((size_t)4) +#define TWO_SIZE_T_SIZES (SIZE_T_SIZE<<1) +#define FOUR_SIZE_T_SIZES (SIZE_T_SIZE<<2) +#define SIX_SIZE_T_SIZES (FOUR_SIZE_T_SIZES+TWO_SIZE_T_SIZES) +#define HALF_MAX_SIZE_T (MAX_SIZE_T / 2U) + +/* The bit mask value corresponding to MALLOC_ALIGNMENT */ +#define CHUNK_ALIGN_MASK (MALLOC_ALIGNMENT - SIZE_T_ONE) + +/* True if address a has acceptable alignment */ +#define is_aligned(A) (((size_t)((A)) & (CHUNK_ALIGN_MASK)) == 0) + +/* the number of bytes to offset an address to align it */ +#define align_offset(A)\ + ((((size_t)(A) & CHUNK_ALIGN_MASK) == 0)? 0 :\ + ((MALLOC_ALIGNMENT - ((size_t)(A) & CHUNK_ALIGN_MASK)) & CHUNK_ALIGN_MASK)) + +/* -------------------------- MMAP preliminaries ------------------------- */ + +/* + If HAVE_MORECORE or HAVE_MMAP are false, we just define calls and + checks to fail so compiler optimizer can delete code rather than + using so many "#if"s. +*/ + + +/* MORECORE and MMAP must return MFAIL on failure */ +#define MFAIL ((void*)(MAX_SIZE_T)) +#define CMFAIL ((char*)(MFAIL)) /* defined for convenience */ + +#if HAVE_MMAP + +#ifndef WIN32 +#define MUNMAP_DEFAULT(a, s) munmap((a), (s)) +#define MMAP_PROT (PROT_READ|PROT_WRITE) +#if !defined(MAP_ANONYMOUS) && defined(MAP_ANON) +#define MAP_ANONYMOUS MAP_ANON +#endif /* MAP_ANON */ +#ifdef MAP_ANONYMOUS +#define MMAP_FLAGS (MAP_PRIVATE|MAP_ANONYMOUS) +#define MMAP_DEFAULT(s) mmap(0, (s), MMAP_PROT, MMAP_FLAGS, -1, 0) +#else /* MAP_ANONYMOUS */ +/* + Nearly all versions of mmap support MAP_ANONYMOUS, so the following + is unlikely to be needed, but is supplied just in case. +*/ +#define MMAP_FLAGS (MAP_PRIVATE) +static int dev_zero_fd = -1; /* Cached file descriptor for /dev/zero. */ +#define MMAP_DEFAULT(s) ((dev_zero_fd < 0) ? \ + (dev_zero_fd = open("/dev/zero", O_RDWR), \ + mmap(0, (s), MMAP_PROT, MMAP_FLAGS, dev_zero_fd, 0)) : \ + mmap(0, (s), MMAP_PROT, MMAP_FLAGS, dev_zero_fd, 0)) +#endif /* MAP_ANONYMOUS */ + +#define DIRECT_MMAP_DEFAULT(s) MMAP_DEFAULT(s) + +#else /* WIN32 */ + +/* Win32 MMAP via VirtualAlloc */ +static FORCEINLINE void* win32mmap(size_t size) { + void* ptr = VirtualAlloc(0, size, MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE); + return (ptr != 0)? ptr: MFAIL; +} + +/* For direct MMAP, use MEM_TOP_DOWN to minimize interference */ +static FORCEINLINE void* win32direct_mmap(size_t size) { + void* ptr = VirtualAlloc(0, size, MEM_RESERVE|MEM_COMMIT|MEM_TOP_DOWN, + PAGE_READWRITE); + return (ptr != 0)? ptr: MFAIL; +} + +/* This function supports releasing coalesed segments */ +static FORCEINLINE int win32munmap(void* ptr, size_t size) { + MEMORY_BASIC_INFORMATION minfo; + char* cptr = (char*)ptr; + while (size) { + if (VirtualQuery(cptr, &minfo, sizeof(minfo)) == 0) + return -1; + if (minfo.BaseAddress != cptr || minfo.AllocationBase != cptr || + minfo.State != MEM_COMMIT || minfo.RegionSize > size) + return -1; + if (VirtualFree(cptr, 0, MEM_RELEASE) == 0) + return -1; + cptr += minfo.RegionSize; + size -= minfo.RegionSize; + } + return 0; +} + +#define MMAP_DEFAULT(s) win32mmap(s) +#define MUNMAP_DEFAULT(a, s) win32munmap((a), (s)) +#define DIRECT_MMAP_DEFAULT(s) win32direct_mmap(s) +#endif /* WIN32 */ +#endif /* HAVE_MMAP */ + +#if HAVE_MREMAP +#ifndef WIN32 +#define MREMAP_DEFAULT(addr, osz, nsz, mv) mremap((addr), (osz), (nsz), (mv)) +#endif /* WIN32 */ +#endif /* HAVE_MREMAP */ + +/** + * Define CALL_MORECORE + */ +#if HAVE_MORECORE + #ifdef MORECORE + #define CALL_MORECORE(S) MORECORE(S) + #else /* MORECORE */ + #define CALL_MORECORE(S) MORECORE_DEFAULT(S) + #endif /* MORECORE */ +#else /* HAVE_MORECORE */ + #define CALL_MORECORE(S) MFAIL +#endif /* HAVE_MORECORE */ + +/** + * Define CALL_MMAP/CALL_MUNMAP/CALL_DIRECT_MMAP + */ +#if HAVE_MMAP + #define USE_MMAP_BIT (SIZE_T_ONE) + + #ifdef MMAP + #define CALL_MMAP(s) MMAP(s) + #else /* MMAP */ + #define CALL_MMAP(s) MMAP_DEFAULT(s) + #endif /* MMAP */ + #ifdef MUNMAP + #define CALL_MUNMAP(a, s) MUNMAP((a), (s)) + #else /* MUNMAP */ + #define CALL_MUNMAP(a, s) MUNMAP_DEFAULT((a), (s)) + #endif /* MUNMAP */ + #ifdef DIRECT_MMAP + #define CALL_DIRECT_MMAP(s) DIRECT_MMAP(s) + #else /* DIRECT_MMAP */ + #define CALL_DIRECT_MMAP(s) DIRECT_MMAP_DEFAULT(s) + #endif /* DIRECT_MMAP */ +#else /* HAVE_MMAP */ + #define USE_MMAP_BIT (SIZE_T_ZERO) + + #define MMAP(s) MFAIL + #define MUNMAP(a, s) (-1) + #define DIRECT_MMAP(s) MFAIL + #define CALL_DIRECT_MMAP(s) DIRECT_MMAP(s) + #define CALL_MMAP(s) MMAP(s) + #define CALL_MUNMAP(a, s) MUNMAP((a), (s)) +#endif /* HAVE_MMAP */ + +/** + * Define CALL_MREMAP + */ +#if HAVE_MMAP && HAVE_MREMAP + #ifdef MREMAP + #define CALL_MREMAP(addr, osz, nsz, mv) MREMAP((addr), (osz), (nsz), (mv)) + #else /* MREMAP */ + #define CALL_MREMAP(addr, osz, nsz, mv) MREMAP_DEFAULT((addr), (osz), (nsz), (mv)) + #endif /* MREMAP */ +#else /* HAVE_MMAP && HAVE_MREMAP */ + #define CALL_MREMAP(addr, osz, nsz, mv) MFAIL +#endif /* HAVE_MMAP && HAVE_MREMAP */ + +/* mstate bit set if continguous morecore disabled or failed */ +#define USE_NONCONTIGUOUS_BIT (4U) + +/* segment bit set in create_mspace_with_base */ +#define EXTERN_BIT (8U) + + +/* --------------------------- Lock preliminaries ------------------------ */ + +/* + When locks are defined, there is one global lock, plus + one per-mspace lock. + + The global lock_ensures that mparams.magic and other unique + mparams values are initialized only once. It also protects + sequences of calls to MORECORE. In many cases sys_alloc requires + two calls, that should not be interleaved with calls by other + threads. This does not protect against direct calls to MORECORE + by other threads not using this lock, so there is still code to + cope the best we can on interference. + + Per-mspace locks surround calls to malloc, free, etc. + By default, locks are simple non-reentrant mutexes. + + Because lock-protected regions generally have bounded times, it is + OK to use the supplied simple spinlocks. Spinlocks are likely to + improve performance for lightly contended applications, but worsen + performance under heavy contention. + + If USE_LOCKS is > 1, the definitions of lock routines here are + bypassed, in which case you will need to define the type MLOCK_T, + and at least INITIAL_LOCK, DESTROY_LOCK, ACQUIRE_LOCK, RELEASE_LOCK + and TRY_LOCK. You must also declare a + static MLOCK_T malloc_global_mutex = { initialization values };. + +*/ + +#if !USE_LOCKS +#define USE_LOCK_BIT (0U) +#define INITIAL_LOCK(l) (0) +#define DESTROY_LOCK(l) (0) +#define ACQUIRE_MALLOC_GLOBAL_LOCK() +#define RELEASE_MALLOC_GLOBAL_LOCK() + +#else +#if USE_LOCKS > 1 +/* ----------------------- User-defined locks ------------------------ */ +/* Define your own lock implementation here */ +/* #define INITIAL_LOCK(lk) ... */ +/* #define DESTROY_LOCK(lk) ... */ +/* #define ACQUIRE_LOCK(lk) ... */ +/* #define RELEASE_LOCK(lk) ... */ +/* #define TRY_LOCK(lk) ... */ +/* static MLOCK_T malloc_global_mutex = ... */ + +#elif USE_SPIN_LOCKS + +/* First, define CAS_LOCK and CLEAR_LOCK on ints */ +/* Note CAS_LOCK defined to return 0 on success */ + +#if defined(__GNUC__)&& (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)) +#define CAS_LOCK(sl) __sync_lock_test_and_set(sl, 1) +#define CLEAR_LOCK(sl) __sync_lock_release(sl) + +#elif (defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))) +/* Custom spin locks for older gcc on x86 */ +static FORCEINLINE int x86_cas_lock(int *sl) { + int ret; + int val = 1; + int cmp = 0; + __asm__ __volatile__ ("lock; cmpxchgl %1, %2" + : "=a" (ret) + : "r" (val), "m" (*(sl)), "0"(cmp) + : "memory", "cc"); + return ret; +} + +static FORCEINLINE void x86_clear_lock(int* sl) { + assert(*sl != 0); + int prev = 0; + int ret; + __asm__ __volatile__ ("lock; xchgl %0, %1" + : "=r" (ret) + : "m" (*(sl)), "0"(prev) + : "memory"); +} + +#define CAS_LOCK(sl) x86_cas_lock(sl) +#define CLEAR_LOCK(sl) x86_clear_lock(sl) + +#else /* Win32 MSC */ +#define CAS_LOCK(sl) interlockedexchange(sl, (LONG)1) +#define CLEAR_LOCK(sl) interlockedexchange (sl, (LONG)0) + +#endif /* ... gcc spins locks ... */ + +/* How to yield for a spin lock */ +#define SPINS_PER_YIELD 63 +#if defined(_MSC_VER) +#define SLEEP_EX_DURATION 50 /* delay for yield/sleep */ +#define SPIN_LOCK_YIELD SleepEx(SLEEP_EX_DURATION, FALSE) +#elif defined (__SVR4) && defined (__sun) /* solaris */ +#define SPIN_LOCK_YIELD thr_yield(); +#elif !defined(LACKS_SCHED_H) +#define SPIN_LOCK_YIELD sched_yield(); +#else +#define SPIN_LOCK_YIELD +#endif /* ... yield ... */ + +#if !defined(USE_RECURSIVE_LOCKS) || USE_RECURSIVE_LOCKS == 0 +/* Plain spin locks use single word (embedded in malloc_states) */ +static int spin_acquire_lock(int *sl) { + int spins = 0; + while (*(volatile int *)sl != 0 || CAS_LOCK(sl)) { + if ((++spins & SPINS_PER_YIELD) == 0) { + SPIN_LOCK_YIELD; + } + } + return 0; +} + +#define MLOCK_T int +#define TRY_LOCK(sl) !CAS_LOCK(sl) +#define RELEASE_LOCK(sl) CLEAR_LOCK(sl) +#define ACQUIRE_LOCK(sl) (CAS_LOCK(sl)? spin_acquire_lock(sl) : 0) +#define INITIAL_LOCK(sl) (*sl = 0) +#define DESTROY_LOCK(sl) (0) +static MLOCK_T malloc_global_mutex = 0; + +#else /* USE_RECURSIVE_LOCKS */ +/* types for lock owners */ +#ifdef WIN32 +#define THREAD_ID_T DWORD +#define CURRENT_THREAD GetCurrentThreadId() +#define EQ_OWNER(X,Y) ((X) == (Y)) +#else +/* + Note: the following assume that pthread_t is a type that can be + initialized to (casted) zero. If this is not the case, you will need to + somehow redefine these or not use spin locks. +*/ +#define THREAD_ID_T pthread_t +#define CURRENT_THREAD pthread_self() +#define EQ_OWNER(X,Y) pthread_equal(X, Y) +#endif + +struct malloc_recursive_lock { + int sl; + unsigned int c; + THREAD_ID_T threadid; +}; + +#define MLOCK_T struct malloc_recursive_lock +static MLOCK_T malloc_global_mutex = { 0, 0, (THREAD_ID_T)0}; + +static FORCEINLINE void recursive_release_lock(MLOCK_T *lk) { + assert(lk->sl != 0); + if (--lk->c == 0) { + CLEAR_LOCK(&lk->sl); + } +} + +static FORCEINLINE int recursive_acquire_lock(MLOCK_T *lk) { + THREAD_ID_T mythreadid = CURRENT_THREAD; + int spins = 0; + for (;;) { + if (*((volatile int *)(&lk->sl)) == 0) { + if (!CAS_LOCK(&lk->sl)) { + lk->threadid = mythreadid; + lk->c = 1; + return 0; + } + } + else if (EQ_OWNER(lk->threadid, mythreadid)) { + ++lk->c; + return 0; + } + if ((++spins & SPINS_PER_YIELD) == 0) { + SPIN_LOCK_YIELD; + } + } +} + +static FORCEINLINE int recursive_try_lock(MLOCK_T *lk) { + THREAD_ID_T mythreadid = CURRENT_THREAD; + if (*((volatile int *)(&lk->sl)) == 0) { + if (!CAS_LOCK(&lk->sl)) { + lk->threadid = mythreadid; + lk->c = 1; + return 1; + } + } + else if (EQ_OWNER(lk->threadid, mythreadid)) { + ++lk->c; + return 1; + } + return 0; +} + +#define RELEASE_LOCK(lk) recursive_release_lock(lk) +#define TRY_LOCK(lk) recursive_try_lock(lk) +#define ACQUIRE_LOCK(lk) recursive_acquire_lock(lk) +#define INITIAL_LOCK(lk) ((lk)->threadid = (THREAD_ID_T)0, (lk)->sl = 0, (lk)->c = 0) +#define DESTROY_LOCK(lk) (0) +#endif /* USE_RECURSIVE_LOCKS */ + +#elif defined(WIN32) /* Win32 critical sections */ +#define MLOCK_T CRITICAL_SECTION +#define ACQUIRE_LOCK(lk) (EnterCriticalSection(lk), 0) +#define RELEASE_LOCK(lk) LeaveCriticalSection(lk) +#define TRY_LOCK(lk) TryEnterCriticalSection(lk) +#define INITIAL_LOCK(lk) (!InitializeCriticalSectionAndSpinCount((lk), 0x80000000|4000)) +#define DESTROY_LOCK(lk) (DeleteCriticalSection(lk), 0) +#define NEED_GLOBAL_LOCK_INIT + +static MLOCK_T malloc_global_mutex; +static volatile LONG malloc_global_mutex_status; + +/* Use spin loop to initialize global lock */ +static void init_malloc_global_mutex() { + for (;;) { + long stat = malloc_global_mutex_status; + if (stat > 0) + return; + /* transition to < 0 while initializing, then to > 0) */ + if (stat == 0 && + interlockedcompareexchange(&malloc_global_mutex_status, (LONG)-1, (LONG)0) == 0) { + InitializeCriticalSection(&malloc_global_mutex); + interlockedexchange(&malloc_global_mutex_status, (LONG)1); + return; + } + SleepEx(0, FALSE); + } +} + +#else /* pthreads-based locks */ +#define MLOCK_T pthread_mutex_t +#define ACQUIRE_LOCK(lk) pthread_mutex_lock(lk) +#define RELEASE_LOCK(lk) pthread_mutex_unlock(lk) +#define TRY_LOCK(lk) (!pthread_mutex_trylock(lk)) +#define INITIAL_LOCK(lk) pthread_init_lock(lk) +#define DESTROY_LOCK(lk) pthread_mutex_destroy(lk) + +#if defined(USE_RECURSIVE_LOCKS) && USE_RECURSIVE_LOCKS != 0 && defined(linux) && !defined(PTHREAD_MUTEX_RECURSIVE) +/* Cope with old-style linux recursive lock initialization by adding */ +/* skipped internal declaration from pthread.h */ +extern int pthread_mutexattr_setkind_np __P ((pthread_mutexattr_t *__attr, + int __kind)); +#define PTHREAD_MUTEX_RECURSIVE PTHREAD_MUTEX_RECURSIVE_NP +#define pthread_mutexattr_settype(x,y) pthread_mutexattr_setkind_np(x,y) +#endif /* USE_RECURSIVE_LOCKS ... */ + +static MLOCK_T malloc_global_mutex = PTHREAD_MUTEX_INITIALIZER; + +static int pthread_init_lock (MLOCK_T *lk) { + pthread_mutexattr_t attr; + if (pthread_mutexattr_init(&attr)) return 1; +#if defined(USE_RECURSIVE_LOCKS) && USE_RECURSIVE_LOCKS != 0 + if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE)) return 1; +#endif + if (pthread_mutex_init(lk, &attr)) return 1; + if (pthread_mutexattr_destroy(&attr)) return 1; + return 0; +} + +#endif /* ... lock types ... */ + +/* Common code for all lock types */ +#define USE_LOCK_BIT (2U) + +#ifndef ACQUIRE_MALLOC_GLOBAL_LOCK +#define ACQUIRE_MALLOC_GLOBAL_LOCK() ACQUIRE_LOCK(&malloc_global_mutex); +#endif + +#ifndef RELEASE_MALLOC_GLOBAL_LOCK +#define RELEASE_MALLOC_GLOBAL_LOCK() RELEASE_LOCK(&malloc_global_mutex); +#endif + +#endif /* USE_LOCKS */ + +/* ----------------------- Chunk representations ------------------------ */ + +/* + (The following includes lightly edited explanations by Colin Plumb.) + + The malloc_chunk declaration below is misleading (but accurate and + necessary). It declares a "view" into memory allowing access to + necessary fields at known offsets from a given base. + + Chunks of memory are maintained using a `boundary tag' method as + originally described by Knuth. (See the paper by Paul Wilson + ftp://ftp.cs.utexas.edu/pub/garbage/allocsrv.ps for a survey of such + techniques.) Sizes of free chunks are stored both in the front of + each chunk and at the end. This makes consolidating fragmented + chunks into bigger chunks fast. The head fields also hold bits + representing whether chunks are free or in use. + + Here are some pictures to make it clearer. They are "exploded" to + show that the state of a chunk can be thought of as extending from + the high 31 bits of the head field of its header through the + prev_foot and PINUSE_BIT bit of the following chunk header. + + A chunk that's in use looks like: + + chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Size of previous chunk (if P = 0) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |P| + | Size of this chunk 1| +-+ + mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | | + +- -+ + | | + +- -+ + | : + +- size - sizeof(size_t) available payload bytes -+ + : | + chunk-> +- -+ + | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |1| + | Size of next chunk (may or may not be in use) | +-+ + mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + And if it's free, it looks like this: + + chunk-> +- -+ + | User payload (must be in use, or we would have merged!) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |P| + | Size of this chunk 0| +-+ + mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Next pointer | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Prev pointer | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | : + +- size - sizeof(struct chunk) unused bytes -+ + : | + chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Size of this chunk | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |0| + | Size of next chunk (must be in use, or we would have merged)| +-+ + mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | : + +- User payload -+ + : | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + |0| + +-+ + Note that since we always merge adjacent free chunks, the chunks + adjacent to a free chunk must be in use. + + Given a pointer to a chunk (which can be derived trivially from the + payload pointer) we can, in O(1) time, find out whether the adjacent + chunks are free, and if so, unlink them from the lists that they + are on and merge them with the current chunk. + + Chunks always begin on even word boundaries, so the mem portion + (which is returned to the user) is also on an even word boundary, and + thus at least double-word aligned. + + The P (PINUSE_BIT) bit, stored in the unused low-order bit of the + chunk size (which is always a multiple of two words), is an in-use + bit for the *previous* chunk. If that bit is *clear*, then the + word before the current chunk size contains the previous chunk + size, and can be used to find the front of the previous chunk. + The very first chunk allocated always has this bit set, preventing + access to non-existent (or non-owned) memory. If pinuse is set for + any given chunk, then you CANNOT determine the size of the + previous chunk, and might even get a memory addressing fault when + trying to do so. + + The C (CINUSE_BIT) bit, stored in the unused second-lowest bit of + the chunk size redundantly records whether the current chunk is + inuse (unless the chunk is mmapped). This redundancy enables usage + checks within free and realloc, and reduces indirection when freeing + and consolidating chunks. + + Each freshly allocated chunk must have both cinuse and pinuse set. + That is, each allocated chunk borders either a previously allocated + and still in-use chunk, or the base of its memory arena. This is + ensured by making all allocations from the `lowest' part of any + found chunk. Further, no free chunk physically borders another one, + so each free chunk is known to be preceded and followed by either + inuse chunks or the ends of memory. + + Note that the `foot' of the current chunk is actually represented + as the prev_foot of the NEXT chunk. This makes it easier to + deal with alignments etc but can be very confusing when trying + to extend or adapt this code. + + The exceptions to all this are + + 1. The special chunk `top' is the top-most available chunk (i.e., + the one bordering the end of available memory). It is treated + specially. Top is never included in any bin, is used only if + no other chunk is available, and is released back to the + system if it is very large (see M_TRIM_THRESHOLD). In effect, + the top chunk is treated as larger (and thus less well + fitting) than any other available chunk. The top chunk + doesn't update its trailing size field since there is no next + contiguous chunk that would have to index off it. However, + space is still allocated for it (TOP_FOOT_SIZE) to enable + separation or merging when space is extended. + + 3. Chunks allocated via mmap, have both cinuse and pinuse bits + cleared in their head fields. Because they are allocated + one-by-one, each must carry its own prev_foot field, which is + also used to hold the offset this chunk has within its mmapped + region, which is needed to preserve alignment. Each mmapped + chunk is trailed by the first two fields of a fake next-chunk + for sake of usage checks. + +*/ + +struct malloc_chunk { + size_t prev_foot; /* Size of previous chunk (if free). */ + size_t head; /* Size and inuse bits. */ + struct malloc_chunk* fd; /* double links -- used only if free. */ + struct malloc_chunk* bk; +}; + +typedef struct malloc_chunk mchunk; +typedef struct malloc_chunk* mchunkptr; +typedef struct malloc_chunk* sbinptr; /* The type of bins of chunks */ +typedef unsigned int bindex_t; /* Described below */ +typedef unsigned int binmap_t; /* Described below */ +typedef unsigned int flag_t; /* The type of various bit flag sets */ + +/* ------------------- Chunks sizes and alignments ----------------------- */ + +#define MCHUNK_SIZE (sizeof(mchunk)) + +#if FOOTERS +#define CHUNK_OVERHEAD (TWO_SIZE_T_SIZES) +#else /* FOOTERS */ +#define CHUNK_OVERHEAD (SIZE_T_SIZE) +#endif /* FOOTERS */ + +/* MMapped chunks need a second word of overhead ... */ +#define MMAP_CHUNK_OVERHEAD (TWO_SIZE_T_SIZES) +/* ... and additional padding for fake next-chunk at foot */ +#define MMAP_FOOT_PAD (FOUR_SIZE_T_SIZES) + +/* The smallest size we can malloc is an aligned minimal chunk */ +#define MIN_CHUNK_SIZE\ + ((MCHUNK_SIZE + CHUNK_ALIGN_MASK) & ~CHUNK_ALIGN_MASK) + +/* conversion from malloc headers to user pointers, and back */ +#define chunk2mem(p) ((void*)((char*)(p) + TWO_SIZE_T_SIZES)) +#define mem2chunk(mem) ((mchunkptr)((char*)(mem) - TWO_SIZE_T_SIZES)) +/* chunk associated with aligned address A */ +#define align_as_chunk(A) (mchunkptr)((A) + align_offset(chunk2mem(A))) + +/* Bounds on request (not chunk) sizes. */ +#define MAX_REQUEST ((-MIN_CHUNK_SIZE) << 2) +#define MIN_REQUEST (MIN_CHUNK_SIZE - CHUNK_OVERHEAD - SIZE_T_ONE) + +/* pad request bytes into a usable size */ +#define pad_request(req) \ + (((req) + CHUNK_OVERHEAD + CHUNK_ALIGN_MASK) & ~CHUNK_ALIGN_MASK) + +/* pad request, checking for minimum (but not maximum) */ +#define request2size(req) \ + (((req) < MIN_REQUEST)? MIN_CHUNK_SIZE : pad_request(req)) + + +/* ------------------ Operations on head and foot fields ----------------- */ + +/* + The head field of a chunk is or'ed with PINUSE_BIT when previous + adjacent chunk in use, and or'ed with CINUSE_BIT if this chunk is in + use, unless mmapped, in which case both bits are cleared. + + FLAG4_BIT is not used by this malloc, but might be useful in extensions. +*/ + +#define PINUSE_BIT (SIZE_T_ONE) +#define CINUSE_BIT (SIZE_T_TWO) +#define FLAG4_BIT (SIZE_T_FOUR) +#define INUSE_BITS (PINUSE_BIT|CINUSE_BIT) +#define FLAG_BITS (PINUSE_BIT|CINUSE_BIT|FLAG4_BIT) + +/* Head value for fenceposts */ +#define FENCEPOST_HEAD (INUSE_BITS|SIZE_T_SIZE) + +/* extraction of fields from head words */ +#define cinuse(p) ((p)->head & CINUSE_BIT) +#define pinuse(p) ((p)->head & PINUSE_BIT) +#define flag4inuse(p) ((p)->head & FLAG4_BIT) +#define is_inuse(p) (((p)->head & INUSE_BITS) != PINUSE_BIT) +#define is_mmapped(p) (((p)->head & INUSE_BITS) == 0) + +#define chunksize(p) ((p)->head & ~(FLAG_BITS)) + +#define clear_pinuse(p) ((p)->head &= ~PINUSE_BIT) +#define set_flag4(p) ((p)->head |= FLAG4_BIT) +#define clear_flag4(p) ((p)->head &= ~FLAG4_BIT) + +/* Treat space at ptr +/- offset as a chunk */ +#define chunk_plus_offset(p, s) ((mchunkptr)(((char*)(p)) + (s))) +#define chunk_minus_offset(p, s) ((mchunkptr)(((char*)(p)) - (s))) + +/* Ptr to next or previous physical malloc_chunk. */ +#define next_chunk(p) ((mchunkptr)( ((char*)(p)) + ((p)->head & ~FLAG_BITS))) +#define prev_chunk(p) ((mchunkptr)( ((char*)(p)) - ((p)->prev_foot) )) + +/* extract next chunk's pinuse bit */ +#define next_pinuse(p) ((next_chunk(p)->head) & PINUSE_BIT) + +/* Get/set size at footer */ +#define get_foot(p, s) (((mchunkptr)((char*)(p) + (s)))->prev_foot) +#define set_foot(p, s) (((mchunkptr)((char*)(p) + (s)))->prev_foot = (s)) + +/* Set size, pinuse bit, and foot */ +#define set_size_and_pinuse_of_free_chunk(p, s)\ + ((p)->head = (s|PINUSE_BIT), set_foot(p, s)) + +/* Set size, pinuse bit, foot, and clear next pinuse */ +#define set_free_with_pinuse(p, s, n)\ + (clear_pinuse(n), set_size_and_pinuse_of_free_chunk(p, s)) + +/* Get the internal overhead associated with chunk p */ +#define overhead_for(p)\ + (is_mmapped(p)? MMAP_CHUNK_OVERHEAD : CHUNK_OVERHEAD) + +/* Return true if malloced space is not necessarily cleared */ +#if MMAP_CLEARS +#define calloc_must_clear(p) (!is_mmapped(p)) +#else /* MMAP_CLEARS */ +#define calloc_must_clear(p) (1) +#endif /* MMAP_CLEARS */ + +/* ---------------------- Overlaid data structures ----------------------- */ + +/* + When chunks are not in use, they are treated as nodes of either + lists or trees. + + "Small" chunks are stored in circular doubly-linked lists, and look + like this: + + chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Size of previous chunk | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + `head:' | Size of chunk, in bytes |P| + mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Forward pointer to next chunk in list | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Back pointer to previous chunk in list | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Unused space (may be 0 bytes long) . + . . + . | +nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + `foot:' | Size of chunk, in bytes | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + Larger chunks are kept in a form of bitwise digital trees (aka + tries) keyed on chunksizes. Because malloc_tree_chunks are only for + free chunks greater than 256 bytes, their size doesn't impose any + constraints on user chunk sizes. Each node looks like: + + chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Size of previous chunk | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + `head:' | Size of chunk, in bytes |P| + mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Forward pointer to next chunk of same size | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Back pointer to previous chunk of same size | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Pointer to left child (child[0]) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Pointer to right child (child[1]) | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Pointer to parent | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | bin index of this chunk | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Unused space . + . | +nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + `foot:' | Size of chunk, in bytes | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + Each tree holding treenodes is a tree of unique chunk sizes. Chunks + of the same size are arranged in a circularly-linked list, with only + the oldest chunk (the next to be used, in our FIFO ordering) + actually in the tree. (Tree members are distinguished by a non-null + parent pointer.) If a chunk with the same size an an existing node + is inserted, it is linked off the existing node using pointers that + work in the same way as fd/bk pointers of small chunks. + + Each tree contains a power of 2 sized range of chunk sizes (the + smallest is 0x100 <= x < 0x180), which is is divided in half at each + tree level, with the chunks in the smaller half of the range (0x100 + <= x < 0x140 for the top nose) in the left subtree and the larger + half (0x140 <= x < 0x180) in the right subtree. This is, of course, + done by inspecting individual bits. + + Using these rules, each node's left subtree contains all smaller + sizes than its right subtree. However, the node at the root of each + subtree has no particular ordering relationship to either. (The + dividing line between the subtree sizes is based on trie relation.) + If we remove the last chunk of a given size from the interior of the + tree, we need to replace it with a leaf node. The tree ordering + rules permit a node to be replaced by any leaf below it. + + The smallest chunk in a tree (a common operation in a best-fit + allocator) can be found by walking a path to the leftmost leaf in + the tree. Unlike a usual binary tree, where we follow left child + pointers until we reach a null, here we follow the right child + pointer any time the left one is null, until we reach a leaf with + both child pointers null. The smallest chunk in the tree will be + somewhere along that path. + + The worst case number of steps to add, find, or remove a node is + bounded by the number of bits differentiating chunks within + bins. Under current bin calculations, this ranges from 6 up to 21 + (for 32 bit sizes) or up to 53 (for 64 bit sizes). The typical case + is of course much better. +*/ + +struct malloc_tree_chunk { + /* The first four fields must be compatible with malloc_chunk */ + size_t prev_foot; + size_t head; + struct malloc_tree_chunk* fd; + struct malloc_tree_chunk* bk; + + struct malloc_tree_chunk* child[2]; + struct malloc_tree_chunk* parent; + bindex_t index; +}; + +typedef struct malloc_tree_chunk tchunk; +typedef struct malloc_tree_chunk* tchunkptr; +typedef struct malloc_tree_chunk* tbinptr; /* The type of bins of trees */ + +/* A little helper macro for trees */ +#define leftmost_child(t) ((t)->child[0] != 0? (t)->child[0] : (t)->child[1]) + +/* ----------------------------- Segments -------------------------------- */ + +/* + Each malloc space may include non-contiguous segments, held in a + list headed by an embedded malloc_segment record representing the + top-most space. Segments also include flags holding properties of + the space. Large chunks that are directly allocated by mmap are not + included in this list. They are instead independently created and + destroyed without otherwise keeping track of them. + + Segment management mainly comes into play for spaces allocated by + MMAP. Any call to MMAP might or might not return memory that is + adjacent to an existing segment. MORECORE normally contiguously + extends the current space, so this space is almost always adjacent, + which is simpler and faster to deal with. (This is why MORECORE is + used preferentially to MMAP when both are available -- see + sys_alloc.) When allocating using MMAP, we don't use any of the + hinting mechanisms (inconsistently) supported in various + implementations of unix mmap, or distinguish reserving from + committing memory. Instead, we just ask for space, and exploit + contiguity when we get it. It is probably possible to do + better than this on some systems, but no general scheme seems + to be significantly better. + + Management entails a simpler variant of the consolidation scheme + used for chunks to reduce fragmentation -- new adjacent memory is + normally prepended or appended to an existing segment. However, + there are limitations compared to chunk consolidation that mostly + reflect the fact that segment processing is relatively infrequent + (occurring only when getting memory from system) and that we + don't expect to have huge numbers of segments: + + * Segments are not indexed, so traversal requires linear scans. (It + would be possible to index these, but is not worth the extra + overhead and complexity for most programs on most platforms.) + * New segments are only appended to old ones when holding top-most + memory; if they cannot be prepended to others, they are held in + different segments. + + Except for the top-most segment of an mstate, each segment record + is kept at the tail of its segment. Segments are added by pushing + segment records onto the list headed by &mstate.seg for the + containing mstate. + + Segment flags control allocation/merge/deallocation policies: + * If EXTERN_BIT set, then we did not allocate this segment, + and so should not try to deallocate or merge with others. + (This currently holds only for the initial segment passed + into create_mspace_with_base.) + * If USE_MMAP_BIT set, the segment may be merged with + other surrounding mmapped segments and trimmed/de-allocated + using munmap. + * If neither bit is set, then the segment was obtained using + MORECORE so can be merged with surrounding MORECORE'd segments + and deallocated/trimmed using MORECORE with negative arguments. +*/ + +struct malloc_segment { + char* base; /* base address */ + size_t size; /* allocated size */ + struct malloc_segment* next; /* ptr to next segment */ + flag_t sflags; /* mmap and extern flag */ +}; + +#define is_mmapped_segment(S) ((S)->sflags & USE_MMAP_BIT) +#define is_extern_segment(S) ((S)->sflags & EXTERN_BIT) + +typedef struct malloc_segment msegment; +typedef struct malloc_segment* msegmentptr; + +/* ---------------------------- malloc_state ----------------------------- */ + +/* + A malloc_state holds all of the bookkeeping for a space. + The main fields are: + + Top + The topmost chunk of the currently active segment. Its size is + cached in topsize. The actual size of topmost space is + topsize+TOP_FOOT_SIZE, which includes space reserved for adding + fenceposts and segment records if necessary when getting more + space from the system. The size at which to autotrim top is + cached from mparams in trim_check, except that it is disabled if + an autotrim fails. + + Designated victim (dv) + This is the preferred chunk for servicing small requests that + don't have exact fits. It is normally the chunk split off most + recently to service another small request. Its size is cached in + dvsize. The link fields of this chunk are not maintained since it + is not kept in a bin. + + SmallBins + An array of bin headers for free chunks. These bins hold chunks + with sizes less than MIN_LARGE_SIZE bytes. Each bin contains + chunks of all the same size, spaced 8 bytes apart. To simplify + use in double-linked lists, each bin header acts as a malloc_chunk + pointing to the real first node, if it exists (else pointing to + itself). This avoids special-casing for headers. But to avoid + waste, we allocate only the fd/bk pointers of bins, and then use + repositioning tricks to treat these as the fields of a chunk. + + TreeBins + Treebins are pointers to the roots of trees holding a range of + sizes. There are 2 equally spaced treebins for each power of two + from TREE_SHIFT to TREE_SHIFT+16. The last bin holds anything + larger. + + Bin maps + There is one bit map for small bins ("smallmap") and one for + treebins ("treemap). Each bin sets its bit when non-empty, and + clears the bit when empty. Bit operations are then used to avoid + bin-by-bin searching -- nearly all "search" is done without ever + looking at bins that won't be selected. The bit maps + conservatively use 32 bits per map word, even if on 64bit system. + For a good description of some of the bit-based techniques used + here, see Henry S. Warren Jr's book "Hacker's Delight" (and + supplement at http://hackersdelight.org/). Many of these are + intended to reduce the branchiness of paths through malloc etc, as + well as to reduce the number of memory locations read or written. + + Segments + A list of segments headed by an embedded malloc_segment record + representing the initial space. + + Address check support + The least_addr field is the least address ever obtained from + MORECORE or MMAP. Attempted frees and reallocs of any address less + than this are trapped (unless INSECURE is defined). + + Magic tag + A cross-check field that should always hold same value as mparams.magic. + + Max allowed footprint + The maximum allowed bytes to allocate from system (zero means no limit) + + Flags + Bits recording whether to use MMAP, locks, or contiguous MORECORE + + Statistics + Each space keeps track of current and maximum system memory + obtained via MORECORE or MMAP. + + Trim support + Fields holding the amount of unused topmost memory that should trigger + trimming, and a counter to force periodic scanning to release unused + non-topmost segments. + + Locking + If USE_LOCKS is defined, the "mutex" lock is acquired and released + around every public call using this mspace. + + Extension support + A void* pointer and a size_t field that can be used to help implement + extensions to this malloc. +*/ + +/* Bin types, widths and sizes */ +#define NSMALLBINS (32U) +#define NTREEBINS (32U) +#define SMALLBIN_SHIFT (3U) +#define SMALLBIN_WIDTH (SIZE_T_ONE << SMALLBIN_SHIFT) +#define TREEBIN_SHIFT (8U) +#define MIN_LARGE_SIZE (SIZE_T_ONE << TREEBIN_SHIFT) +#define MAX_SMALL_SIZE (MIN_LARGE_SIZE - SIZE_T_ONE) +#define MAX_SMALL_REQUEST (MAX_SMALL_SIZE - CHUNK_ALIGN_MASK - CHUNK_OVERHEAD) + +struct malloc_state { + binmap_t smallmap; + binmap_t treemap; + size_t dvsize; + size_t topsize; + char* least_addr; + mchunkptr dv; + mchunkptr top; + size_t trim_check; + size_t release_checks; + size_t magic; + mchunkptr smallbins[(NSMALLBINS+1)*2]; + tbinptr treebins[NTREEBINS]; + size_t footprint; + size_t max_footprint; + size_t footprint_limit; /* zero means no limit */ + flag_t mflags; +#if USE_LOCKS + MLOCK_T mutex; /* locate lock among fields that rarely change */ +#endif /* USE_LOCKS */ + msegment seg; + void* extp; /* Unused but available for extensions */ + size_t exts; +}; + +typedef struct malloc_state* mstate; + +/* ------------- Global malloc_state and malloc_params ------------------- */ + +/* + malloc_params holds global properties, including those that can be + dynamically set using mallopt. There is a single instance, mparams, + initialized in init_mparams. Note that the non-zeroness of "magic" + also serves as an initialization flag. +*/ + +struct malloc_params { + size_t magic; + size_t page_size; + size_t granularity; + size_t mmap_threshold; + size_t trim_threshold; + flag_t default_mflags; +}; + +static struct malloc_params mparams; + +/* Ensure mparams initialized */ +#define ensure_initialization() (void)(mparams.magic != 0 || init_mparams()) + +#if !ONLY_MSPACES + +/* The global malloc_state used for all non-"mspace" calls */ +static struct malloc_state _gm_; +#define gm (&_gm_) +#define is_global(M) ((M) == &_gm_) + +#endif /* !ONLY_MSPACES */ + +#define is_initialized(M) ((M)->top != 0) + +/* -------------------------- system alloc setup ------------------------- */ + +/* Operations on mflags */ + +#define use_lock(M) ((M)->mflags & USE_LOCK_BIT) +#define enable_lock(M) ((M)->mflags |= USE_LOCK_BIT) +#if USE_LOCKS +#define disable_lock(M) ((M)->mflags &= ~USE_LOCK_BIT) +#else +#define disable_lock(M) +#endif + +#define use_mmap(M) ((M)->mflags & USE_MMAP_BIT) +#define enable_mmap(M) ((M)->mflags |= USE_MMAP_BIT) +#if HAVE_MMAP +#define disable_mmap(M) ((M)->mflags &= ~USE_MMAP_BIT) +#else +#define disable_mmap(M) +#endif + +#define use_noncontiguous(M) ((M)->mflags & USE_NONCONTIGUOUS_BIT) +#define disable_contiguous(M) ((M)->mflags |= USE_NONCONTIGUOUS_BIT) + +#define set_lock(M,L)\ + ((M)->mflags = (L)?\ + ((M)->mflags | USE_LOCK_BIT) :\ + ((M)->mflags & ~USE_LOCK_BIT)) + +/* page-align a size */ +#define page_align(S)\ + (((S) + (mparams.page_size - SIZE_T_ONE)) & ~(mparams.page_size - SIZE_T_ONE)) + +/* granularity-align a size */ +#define granularity_align(S)\ + (((S) + (mparams.granularity - SIZE_T_ONE))\ + & ~(mparams.granularity - SIZE_T_ONE)) + + +/* For mmap, use granularity alignment on windows, else page-align */ +#ifdef WIN32 +#define mmap_align(S) granularity_align(S) +#else +#define mmap_align(S) page_align(S) +#endif + +/* For sys_alloc, enough padding to ensure can malloc request on success */ +#define SYS_ALLOC_PADDING (TOP_FOOT_SIZE + MALLOC_ALIGNMENT) + +#define is_page_aligned(S)\ + (((size_t)(S) & (mparams.page_size - SIZE_T_ONE)) == 0) +#define is_granularity_aligned(S)\ + (((size_t)(S) & (mparams.granularity - SIZE_T_ONE)) == 0) + +/* True if segment S holds address A */ +#define segment_holds(S, A)\ + ((char*)(A) >= S->base && (char*)(A) < S->base + S->size) + +/* Return segment holding given address */ +static msegmentptr segment_holding(mstate m, char* addr) { + msegmentptr sp = &m->seg; + for (;;) { + if (addr >= sp->base && addr < sp->base + sp->size) + return sp; + if ((sp = sp->next) == 0) + return 0; + } +} + +/* Return true if segment contains a segment link */ +static int has_segment_link(mstate m, msegmentptr ss) { + msegmentptr sp = &m->seg; + for (;;) { + if ((char*)sp >= ss->base && (char*)sp < ss->base + ss->size) + return 1; + if ((sp = sp->next) == 0) + return 0; + } +} + +#ifndef MORECORE_CANNOT_TRIM +#define should_trim(M,s) ((s) > (M)->trim_check) +#else /* MORECORE_CANNOT_TRIM */ +#define should_trim(M,s) (0) +#endif /* MORECORE_CANNOT_TRIM */ + +/* + TOP_FOOT_SIZE is padding at the end of a segment, including space + that may be needed to place segment records and fenceposts when new + noncontiguous segments are added. +*/ +#define TOP_FOOT_SIZE\ + (align_offset(chunk2mem(0))+pad_request(sizeof(struct malloc_segment))+MIN_CHUNK_SIZE) + + +/* ------------------------------- Hooks -------------------------------- */ + +/* + PREACTION should be defined to return 0 on success, and nonzero on + failure. If you are not using locking, you can redefine these to do + anything you like. +*/ + +#if USE_LOCKS +#define PREACTION(M) ((use_lock(M))? ACQUIRE_LOCK(&(M)->mutex) : 0) +#define POSTACTION(M) { if (use_lock(M)) RELEASE_LOCK(&(M)->mutex); } +#else /* USE_LOCKS */ + +#ifndef PREACTION +#define PREACTION(M) (0) +#endif /* PREACTION */ + +#ifndef POSTACTION +#define POSTACTION(M) +#endif /* POSTACTION */ + +#endif /* USE_LOCKS */ + +/* + CORRUPTION_ERROR_ACTION is triggered upon detected bad addresses. + USAGE_ERROR_ACTION is triggered on detected bad frees and + reallocs. The argument p is an address that might have triggered the + fault. It is ignored by the two predefined actions, but might be + useful in custom actions that try to help diagnose errors. +*/ + +#if PROCEED_ON_ERROR + +/* A count of the number of corruption errors causing resets */ +int malloc_corruption_error_count; + +/* default corruption action */ +static void reset_on_error(mstate m); + +#define CORRUPTION_ERROR_ACTION(m) reset_on_error(m) +#define USAGE_ERROR_ACTION(m, p) + +#else /* PROCEED_ON_ERROR */ + +#ifndef CORRUPTION_ERROR_ACTION +#define CORRUPTION_ERROR_ACTION(m) ABORT +#endif /* CORRUPTION_ERROR_ACTION */ + +#ifndef USAGE_ERROR_ACTION +#define USAGE_ERROR_ACTION(m,p) ABORT +#endif /* USAGE_ERROR_ACTION */ + +#endif /* PROCEED_ON_ERROR */ + + +/* -------------------------- Debugging setup ---------------------------- */ + +#if ! DEBUG + +#define check_free_chunk(M,P) +#define check_inuse_chunk(M,P) +#define check_malloced_chunk(M,P,N) +#define check_mmapped_chunk(M,P) +#define check_malloc_state(M) +#define check_top_chunk(M,P) + +#else /* DEBUG */ +#define check_free_chunk(M,P) do_check_free_chunk(M,P) +#define check_inuse_chunk(M,P) do_check_inuse_chunk(M,P) +#define check_top_chunk(M,P) do_check_top_chunk(M,P) +#define check_malloced_chunk(M,P,N) do_check_malloced_chunk(M,P,N) +#define check_mmapped_chunk(M,P) do_check_mmapped_chunk(M,P) +#define check_malloc_state(M) do_check_malloc_state(M) + +static void do_check_any_chunk(mstate m, mchunkptr p); +static void do_check_top_chunk(mstate m, mchunkptr p); +static void do_check_mmapped_chunk(mstate m, mchunkptr p); +static void do_check_inuse_chunk(mstate m, mchunkptr p); +static void do_check_free_chunk(mstate m, mchunkptr p); +static void do_check_malloced_chunk(mstate m, void* mem, size_t s); +static void do_check_tree(mstate m, tchunkptr t); +static void do_check_treebin(mstate m, bindex_t i); +static void do_check_smallbin(mstate m, bindex_t i); +static void do_check_malloc_state(mstate m); +static int bin_find(mstate m, mchunkptr x); +static size_t traverse_and_check(mstate m); +#endif /* DEBUG */ + +/* ---------------------------- Indexing Bins ---------------------------- */ + +#define is_small(s) (((s) >> SMALLBIN_SHIFT) < NSMALLBINS) +#define small_index(s) (bindex_t)((s) >> SMALLBIN_SHIFT) +#define small_index2size(i) ((i) << SMALLBIN_SHIFT) +#define MIN_SMALL_INDEX (small_index(MIN_CHUNK_SIZE)) + +/* addressing by index. See above about smallbin repositioning */ +#define smallbin_at(M, i) ((sbinptr)((char*)&((M)->smallbins[(i)<<1]))) +#define treebin_at(M,i) (&((M)->treebins[i])) + +/* assign tree index for size S to variable I. Use x86 asm if possible */ +#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) +#define compute_tree_index(S, I)\ +{\ + unsigned int X = S >> TREEBIN_SHIFT;\ + if (X == 0)\ + I = 0;\ + else if (X > 0xFFFF)\ + I = NTREEBINS-1;\ + else {\ + unsigned int K = (unsigned) sizeof(X)*__CHAR_BIT__ - 1 - (unsigned) __builtin_clz(X); \ + I = (bindex_t)((K << 1) + ((S >> (K + (TREEBIN_SHIFT-1)) & 1)));\ + }\ +} + +#elif defined (__INTEL_COMPILER) +#define compute_tree_index(S, I)\ +{\ + size_t X = S >> TREEBIN_SHIFT;\ + if (X == 0)\ + I = 0;\ + else if (X > 0xFFFF)\ + I = NTREEBINS-1;\ + else {\ + unsigned int K = _bit_scan_reverse (X); \ + I = (bindex_t)((K << 1) + ((S >> (K + (TREEBIN_SHIFT-1)) & 1)));\ + }\ +} + +#elif defined(_MSC_VER) && _MSC_VER>=1300 +#define compute_tree_index(S, I)\ +{\ + size_t X = S >> TREEBIN_SHIFT;\ + if (X == 0)\ + I = 0;\ + else if (X > 0xFFFF)\ + I = NTREEBINS-1;\ + else {\ + unsigned int K;\ + _BitScanReverse((DWORD *) &K, (DWORD) X);\ + I = (bindex_t)((K << 1) + ((S >> (K + (TREEBIN_SHIFT-1)) & 1)));\ + }\ +} + +#else /* GNUC */ +#define compute_tree_index(S, I)\ +{\ + size_t X = S >> TREEBIN_SHIFT;\ + if (X == 0)\ + I = 0;\ + else if (X > 0xFFFF)\ + I = NTREEBINS-1;\ + else {\ + unsigned int Y = (unsigned int)X;\ + unsigned int N = ((Y - 0x100) >> 16) & 8;\ + unsigned int K = (((Y <<= N) - 0x1000) >> 16) & 4;\ + N += K;\ + N += K = (((Y <<= K) - 0x4000) >> 16) & 2;\ + K = 14 - N + ((Y <<= K) >> 15);\ + I = (K << 1) + ((S >> (K + (TREEBIN_SHIFT-1)) & 1));\ + }\ +} +#endif /* GNUC */ + +/* Bit representing maximum resolved size in a treebin at i */ +#define bit_for_tree_index(i) \ + (i == NTREEBINS-1)? (SIZE_T_BITSIZE-1) : (((i) >> 1) + TREEBIN_SHIFT - 2) + +/* Shift placing maximum resolved bit in a treebin at i as sign bit */ +#define leftshift_for_tree_index(i) \ + ((i == NTREEBINS-1)? 0 : \ + ((SIZE_T_BITSIZE-SIZE_T_ONE) - (((i) >> 1) + TREEBIN_SHIFT - 2))) + +/* The size of the smallest chunk held in bin with index i */ +#define minsize_for_tree_index(i) \ + ((SIZE_T_ONE << (((i) >> 1) + TREEBIN_SHIFT)) | \ + (((size_t)((i) & SIZE_T_ONE)) << (((i) >> 1) + TREEBIN_SHIFT - 1))) + + +/* ------------------------ Operations on bin maps ----------------------- */ + +/* bit corresponding to given index */ +#define idx2bit(i) ((binmap_t)(1) << (i)) + +/* Mark/Clear bits with given index */ +#define mark_smallmap(M,i) ((M)->smallmap |= idx2bit(i)) +#define clear_smallmap(M,i) ((M)->smallmap &= ~idx2bit(i)) +#define smallmap_is_marked(M,i) ((M)->smallmap & idx2bit(i)) + +#define mark_treemap(M,i) ((M)->treemap |= idx2bit(i)) +#define clear_treemap(M,i) ((M)->treemap &= ~idx2bit(i)) +#define treemap_is_marked(M,i) ((M)->treemap & idx2bit(i)) + +/* isolate the least set bit of a bitmap */ +#define least_bit(x) ((x) & -(x)) + +/* mask with all bits to left of least bit of x on */ +#define left_bits(x) ((x<<1) | -(x<<1)) + +/* mask with all bits to left of or equal to least bit of x on */ +#define same_or_left_bits(x) ((x) | -(x)) + +/* index corresponding to given bit. Use x86 asm if possible */ + +#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) +#define compute_bit2idx(X, I)\ +{\ + unsigned int J;\ + J = __builtin_ctz(X); \ + I = (bindex_t)J;\ +} + +#elif defined (__INTEL_COMPILER) +#define compute_bit2idx(X, I)\ +{\ + unsigned int J;\ + J = _bit_scan_forward (X); \ + I = (bindex_t)J;\ +} + +#elif defined(_MSC_VER) && _MSC_VER>=1300 +#define compute_bit2idx(X, I)\ +{\ + unsigned int J;\ + _BitScanForward((DWORD *) &J, X);\ + I = (bindex_t)J;\ +} + +#elif USE_BUILTIN_FFS +#define compute_bit2idx(X, I) I = ffs(X)-1 + +#else +#define compute_bit2idx(X, I)\ +{\ + unsigned int Y = X - 1;\ + unsigned int K = Y >> (16-4) & 16;\ + unsigned int N = K; Y >>= K;\ + N += K = Y >> (8-3) & 8; Y >>= K;\ + N += K = Y >> (4-2) & 4; Y >>= K;\ + N += K = Y >> (2-1) & 2; Y >>= K;\ + N += K = Y >> (1-0) & 1; Y >>= K;\ + I = (bindex_t)(N + Y);\ +} +#endif /* GNUC */ + + +/* ----------------------- Runtime Check Support ------------------------- */ + +/* + For security, the main invariant is that malloc/free/etc never + writes to a static address other than malloc_state, unless static + malloc_state itself has been corrupted, which cannot occur via + malloc (because of these checks). In essence this means that we + believe all pointers, sizes, maps etc held in malloc_state, but + check all of those linked or offsetted from other embedded data + structures. These checks are interspersed with main code in a way + that tends to minimize their run-time cost. + + When FOOTERS is defined, in addition to range checking, we also + verify footer fields of inuse chunks, which can be used guarantee + that the mstate controlling malloc/free is intact. This is a + streamlined version of the approach described by William Robertson + et al in "Run-time Detection of Heap-based Overflows" LISA'03 + http://www.usenix.org/events/lisa03/tech/robertson.html The footer + of an inuse chunk holds the xor of its mstate and a random seed, + that is checked upon calls to free() and realloc(). This is + (probabalistically) unguessable from outside the program, but can be + computed by any code successfully malloc'ing any chunk, so does not + itself provide protection against code that has already broken + security through some other means. Unlike Robertson et al, we + always dynamically check addresses of all offset chunks (previous, + next, etc). This turns out to be cheaper than relying on hashes. +*/ + +#if !INSECURE +/* Check if address a is at least as high as any from MORECORE or MMAP */ +#define ok_address(M, a) ((char*)(a) >= (M)->least_addr) +/* Check if address of next chunk n is higher than base chunk p */ +#define ok_next(p, n) ((char*)(p) < (char*)(n)) +/* Check if p has inuse status */ +#define ok_inuse(p) is_inuse(p) +/* Check if p has its pinuse bit on */ +#define ok_pinuse(p) pinuse(p) + +#else /* !INSECURE */ +#define ok_address(M, a) (1) +#define ok_next(b, n) (1) +#define ok_inuse(p) (1) +#define ok_pinuse(p) (1) +#endif /* !INSECURE */ + +#if (FOOTERS && !INSECURE) +/* Check if (alleged) mstate m has expected magic field */ +#define ok_magic(M) ((M)->magic == mparams.magic) +#else /* (FOOTERS && !INSECURE) */ +#define ok_magic(M) (1) +#endif /* (FOOTERS && !INSECURE) */ + +/* In gcc, use __builtin_expect to minimize impact of checks */ +#if !INSECURE +#if defined(__GNUC__) && __GNUC__ >= 3 +#define RTCHECK(e) __builtin_expect(e, 1) +#else /* GNUC */ +#define RTCHECK(e) (e) +#endif /* GNUC */ +#else /* !INSECURE */ +#define RTCHECK(e) (1) +#endif /* !INSECURE */ + +/* macros to set up inuse chunks with or without footers */ + +#if !FOOTERS + +#define mark_inuse_foot(M,p,s) + +/* Macros for setting head/foot of non-mmapped chunks */ + +/* Set cinuse bit and pinuse bit of next chunk */ +#define set_inuse(M,p,s)\ + ((p)->head = (((p)->head & PINUSE_BIT)|s|CINUSE_BIT),\ + ((mchunkptr)(((char*)(p)) + (s)))->head |= PINUSE_BIT) + +/* Set cinuse and pinuse of this chunk and pinuse of next chunk */ +#define set_inuse_and_pinuse(M,p,s)\ + ((p)->head = (s|PINUSE_BIT|CINUSE_BIT),\ + ((mchunkptr)(((char*)(p)) + (s)))->head |= PINUSE_BIT) + +/* Set size, cinuse and pinuse bit of this chunk */ +#define set_size_and_pinuse_of_inuse_chunk(M, p, s)\ + ((p)->head = (s|PINUSE_BIT|CINUSE_BIT)) + +#else /* FOOTERS */ + +/* Set foot of inuse chunk to be xor of mstate and seed */ +#define mark_inuse_foot(M,p,s)\ + (((mchunkptr)((char*)(p) + (s)))->prev_foot = ((size_t)(M) ^ mparams.magic)) + +#define get_mstate_for(p)\ + ((mstate)(((mchunkptr)((char*)(p) +\ + (chunksize(p))))->prev_foot ^ mparams.magic)) + +#define set_inuse(M,p,s)\ + ((p)->head = (((p)->head & PINUSE_BIT)|s|CINUSE_BIT),\ + (((mchunkptr)(((char*)(p)) + (s)))->head |= PINUSE_BIT), \ + mark_inuse_foot(M,p,s)) + +#define set_inuse_and_pinuse(M,p,s)\ + ((p)->head = (s|PINUSE_BIT|CINUSE_BIT),\ + (((mchunkptr)(((char*)(p)) + (s)))->head |= PINUSE_BIT),\ + mark_inuse_foot(M,p,s)) + +#define set_size_and_pinuse_of_inuse_chunk(M, p, s)\ + ((p)->head = (s|PINUSE_BIT|CINUSE_BIT),\ + mark_inuse_foot(M, p, s)) + +#endif /* !FOOTERS */ + +/* ---------------------------- setting mparams -------------------------- */ + +#if LOCK_AT_FORK +static void pre_fork(void) { ACQUIRE_LOCK(&(gm)->mutex); } +static void post_fork_parent(void) { RELEASE_LOCK(&(gm)->mutex); } +static void post_fork_child(void) { INITIAL_LOCK(&(gm)->mutex); } +#endif /* LOCK_AT_FORK */ + +/* Initialize mparams */ +static int init_mparams(void) { +#ifdef NEED_GLOBAL_LOCK_INIT + if (malloc_global_mutex_status <= 0) + init_malloc_global_mutex(); +#endif + + ACQUIRE_MALLOC_GLOBAL_LOCK(); + if (mparams.magic == 0) { + size_t magic; + size_t psize; + size_t gsize; + +#ifndef WIN32 + psize = malloc_getpagesize; + gsize = ((DEFAULT_GRANULARITY != 0)? DEFAULT_GRANULARITY : psize); +#else /* WIN32 */ + { + SYSTEM_INFO system_info; + GetSystemInfo(&system_info); + psize = system_info.dwPageSize; + gsize = ((DEFAULT_GRANULARITY != 0)? + DEFAULT_GRANULARITY : system_info.dwAllocationGranularity); + } +#endif /* WIN32 */ + + /* Sanity-check configuration: + size_t must be unsigned and as wide as pointer type. + ints must be at least 4 bytes. + alignment must be at least 8. + Alignment, min chunk size, and page size must all be powers of 2. + */ + if ((sizeof(size_t) != sizeof(char*)) || + (MAX_SIZE_T < MIN_CHUNK_SIZE) || + (sizeof(int) < 4) || + (MALLOC_ALIGNMENT < (size_t)8U) || + ((MALLOC_ALIGNMENT & (MALLOC_ALIGNMENT-SIZE_T_ONE)) != 0) || + ((MCHUNK_SIZE & (MCHUNK_SIZE-SIZE_T_ONE)) != 0) || + ((gsize & (gsize-SIZE_T_ONE)) != 0) || + ((psize & (psize-SIZE_T_ONE)) != 0)) + ABORT; + mparams.granularity = gsize; + mparams.page_size = psize; + mparams.mmap_threshold = DEFAULT_MMAP_THRESHOLD; + mparams.trim_threshold = DEFAULT_TRIM_THRESHOLD; +#if MORECORE_CONTIGUOUS + mparams.default_mflags = USE_LOCK_BIT|USE_MMAP_BIT; +#else /* MORECORE_CONTIGUOUS */ + mparams.default_mflags = USE_LOCK_BIT|USE_MMAP_BIT|USE_NONCONTIGUOUS_BIT; +#endif /* MORECORE_CONTIGUOUS */ + +#if !ONLY_MSPACES + /* Set up lock for main malloc area */ + gm->mflags = mparams.default_mflags; + (void)INITIAL_LOCK(&gm->mutex); +#endif +#if LOCK_AT_FORK + pthread_atfork(&pre_fork, &post_fork_parent, &post_fork_child); +#endif + + { +#if USE_DEV_RANDOM + int fd; + unsigned char buf[sizeof(size_t)]; + /* Try to use /dev/urandom, else fall back on using time */ + if ((fd = open("/dev/urandom", O_RDONLY)) >= 0 && + read(fd, buf, sizeof(buf)) == sizeof(buf)) { + magic = *((size_t *) buf); + close(fd); + } + else +#endif /* USE_DEV_RANDOM */ +#ifdef WIN32 + magic = (size_t)(GetTickCount() ^ (size_t)0x55555555U); +#elif defined(LACKS_TIME_H) + magic = (size_t)&magic ^ (size_t)0x55555555U; +#else + magic = (size_t)(time(0) ^ (size_t)0x55555555U); +#endif + magic |= (size_t)8U; /* ensure nonzero */ + magic &= ~(size_t)7U; /* improve chances of fault for bad values */ + /* Until memory modes commonly available, use volatile-write */ + (*(volatile size_t *)(&(mparams.magic))) = magic; + } + } + + RELEASE_MALLOC_GLOBAL_LOCK(); + return 1; +} + +/* support for mallopt */ +static int change_mparam(int param_number, int value) { + size_t val; + ensure_initialization(); + val = (value == -1)? MAX_SIZE_T : (size_t)value; + switch(param_number) { + case M_TRIM_THRESHOLD: + mparams.trim_threshold = val; + return 1; + case M_GRANULARITY: + if (val >= mparams.page_size && ((val & (val-1)) == 0)) { + mparams.granularity = val; + return 1; + } + else + return 0; + case M_MMAP_THRESHOLD: + mparams.mmap_threshold = val; + return 1; + default: + return 0; + } +} + +#if DEBUG +/* ------------------------- Debugging Support --------------------------- */ + +/* Check properties of any chunk, whether free, inuse, mmapped etc */ +static void do_check_any_chunk(mstate m, mchunkptr p) { + assert((is_aligned(chunk2mem(p))) || (p->head == FENCEPOST_HEAD)); + assert(ok_address(m, p)); +} + +/* Check properties of top chunk */ +static void do_check_top_chunk(mstate m, mchunkptr p) { + msegmentptr sp = segment_holding(m, (char*)p); + size_t sz = p->head & ~INUSE_BITS; /* third-lowest bit can be set! */ + assert(sp != 0); + assert((is_aligned(chunk2mem(p))) || (p->head == FENCEPOST_HEAD)); + assert(ok_address(m, p)); + assert(sz == m->topsize); + assert(sz > 0); + assert(sz == ((sp->base + sp->size) - (char*)p) - TOP_FOOT_SIZE); + assert(pinuse(p)); + assert(!pinuse(chunk_plus_offset(p, sz))); +} + +/* Check properties of (inuse) mmapped chunks */ +static void do_check_mmapped_chunk(mstate m, mchunkptr p) { + size_t sz = chunksize(p); + size_t len = (sz + (p->prev_foot) + MMAP_FOOT_PAD); + assert(is_mmapped(p)); + assert(use_mmap(m)); + assert((is_aligned(chunk2mem(p))) || (p->head == FENCEPOST_HEAD)); + assert(ok_address(m, p)); + assert(!is_small(sz)); + assert((len & (mparams.page_size-SIZE_T_ONE)) == 0); + assert(chunk_plus_offset(p, sz)->head == FENCEPOST_HEAD); + assert(chunk_plus_offset(p, sz+SIZE_T_SIZE)->head == 0); +} + +/* Check properties of inuse chunks */ +static void do_check_inuse_chunk(mstate m, mchunkptr p) { + do_check_any_chunk(m, p); + assert(is_inuse(p)); + assert(next_pinuse(p)); + /* If not pinuse and not mmapped, previous chunk has OK offset */ + assert(is_mmapped(p) || pinuse(p) || next_chunk(prev_chunk(p)) == p); + if (is_mmapped(p)) + do_check_mmapped_chunk(m, p); +} + +/* Check properties of free chunks */ +static void do_check_free_chunk(mstate m, mchunkptr p) { + size_t sz = chunksize(p); + mchunkptr next = chunk_plus_offset(p, sz); + do_check_any_chunk(m, p); + assert(!is_inuse(p)); + assert(!next_pinuse(p)); + assert (!is_mmapped(p)); + if (p != m->dv && p != m->top) { + if (sz >= MIN_CHUNK_SIZE) { + assert((sz & CHUNK_ALIGN_MASK) == 0); + assert(is_aligned(chunk2mem(p))); + assert(next->prev_foot == sz); + assert(pinuse(p)); + assert (next == m->top || is_inuse(next)); + assert(p->fd->bk == p); + assert(p->bk->fd == p); + } + else /* markers are always of size SIZE_T_SIZE */ + assert(sz == SIZE_T_SIZE); + } +} + +/* Check properties of malloced chunks at the point they are malloced */ +static void do_check_malloced_chunk(mstate m, void* mem, size_t s) { + if (mem != 0) { + mchunkptr p = mem2chunk(mem); + size_t sz = p->head & ~INUSE_BITS; + do_check_inuse_chunk(m, p); + assert((sz & CHUNK_ALIGN_MASK) == 0); + assert(sz >= MIN_CHUNK_SIZE); + assert(sz >= s); + /* unless mmapped, size is less than MIN_CHUNK_SIZE more than request */ + assert(is_mmapped(p) || sz < (s + MIN_CHUNK_SIZE)); + } +} + +/* Check a tree and its subtrees. */ +static void do_check_tree(mstate m, tchunkptr t) { + tchunkptr head = 0; + tchunkptr u = t; + bindex_t tindex = t->index; + size_t tsize = chunksize(t); + bindex_t idx; + compute_tree_index(tsize, idx); + assert(tindex == idx); + assert(tsize >= MIN_LARGE_SIZE); + assert(tsize >= minsize_for_tree_index(idx)); + assert((idx == NTREEBINS-1) || (tsize < minsize_for_tree_index((idx+1)))); + + do { /* traverse through chain of same-sized nodes */ + do_check_any_chunk(m, ((mchunkptr)u)); + assert(u->index == tindex); + assert(chunksize(u) == tsize); + assert(!is_inuse(u)); + assert(!next_pinuse(u)); + assert(u->fd->bk == u); + assert(u->bk->fd == u); + if (u->parent == 0) { + assert(u->child[0] == 0); + assert(u->child[1] == 0); + } + else { + assert(head == 0); /* only one node on chain has parent */ + head = u; + assert(u->parent != u); + assert (u->parent->child[0] == u || + u->parent->child[1] == u || + *((tbinptr*)(u->parent)) == u); + if (u->child[0] != 0) { + assert(u->child[0]->parent == u); + assert(u->child[0] != u); + do_check_tree(m, u->child[0]); + } + if (u->child[1] != 0) { + assert(u->child[1]->parent == u); + assert(u->child[1] != u); + do_check_tree(m, u->child[1]); + } + if (u->child[0] != 0 && u->child[1] != 0) { + assert(chunksize(u->child[0]) < chunksize(u->child[1])); + } + } + u = u->fd; + } while (u != t); + assert(head != 0); +} + +/* Check all the chunks in a treebin. */ +static void do_check_treebin(mstate m, bindex_t i) { + tbinptr* tb = treebin_at(m, i); + tchunkptr t = *tb; + int empty = (m->treemap & (1U << i)) == 0; + if (t == 0) + assert(empty); + if (!empty) + do_check_tree(m, t); +} + +/* Check all the chunks in a smallbin. */ +static void do_check_smallbin(mstate m, bindex_t i) { + sbinptr b = smallbin_at(m, i); + mchunkptr p = b->bk; + unsigned int empty = (m->smallmap & (1U << i)) == 0; + if (p == b) + assert(empty); + if (!empty) { + for (; p != b; p = p->bk) { + size_t size = chunksize(p); + mchunkptr q; + /* each chunk claims to be free */ + do_check_free_chunk(m, p); + /* chunk belongs in bin */ + assert(small_index(size) == i); + assert(p->bk == b || chunksize(p->bk) == chunksize(p)); + /* chunk is followed by an inuse chunk */ + q = next_chunk(p); + if (q->head != FENCEPOST_HEAD) + do_check_inuse_chunk(m, q); + } + } +} + +/* Find x in a bin. Used in other check functions. */ +static int bin_find(mstate m, mchunkptr x) { + size_t size = chunksize(x); + if (is_small(size)) { + bindex_t sidx = small_index(size); + sbinptr b = smallbin_at(m, sidx); + if (smallmap_is_marked(m, sidx)) { + mchunkptr p = b; + do { + if (p == x) + return 1; + } while ((p = p->fd) != b); + } + } + else { + bindex_t tidx; + compute_tree_index(size, tidx); + if (treemap_is_marked(m, tidx)) { + tchunkptr t = *treebin_at(m, tidx); + size_t sizebits = size << leftshift_for_tree_index(tidx); + while (t != 0 && chunksize(t) != size) { + t = t->child[(sizebits >> (SIZE_T_BITSIZE-SIZE_T_ONE)) & 1]; + sizebits <<= 1; + } + if (t != 0) { + tchunkptr u = t; + do { + if (u == (tchunkptr)x) + return 1; + } while ((u = u->fd) != t); + } + } + } + return 0; +} + +/* Traverse each chunk and check it; return total */ +static size_t traverse_and_check(mstate m) { + size_t sum = 0; + if (is_initialized(m)) { + msegmentptr s = &m->seg; + sum += m->topsize + TOP_FOOT_SIZE; + while (s != 0) { + mchunkptr q = align_as_chunk(s->base); + mchunkptr lastq = 0; + assert(pinuse(q)); + while (segment_holds(s, q) && + q != m->top && q->head != FENCEPOST_HEAD) { + sum += chunksize(q); + if (is_inuse(q)) { + assert(!bin_find(m, q)); + do_check_inuse_chunk(m, q); + } + else { + assert(q == m->dv || bin_find(m, q)); + assert(lastq == 0 || is_inuse(lastq)); /* Not 2 consecutive free */ + do_check_free_chunk(m, q); + } + lastq = q; + q = next_chunk(q); + } + s = s->next; + } + } + return sum; +} + + +/* Check all properties of malloc_state. */ +static void do_check_malloc_state(mstate m) { + bindex_t i; + size_t total; + /* check bins */ + for (i = 0; i < NSMALLBINS; ++i) + do_check_smallbin(m, i); + for (i = 0; i < NTREEBINS; ++i) + do_check_treebin(m, i); + + if (m->dvsize != 0) { /* check dv chunk */ + do_check_any_chunk(m, m->dv); + assert(m->dvsize == chunksize(m->dv)); + assert(m->dvsize >= MIN_CHUNK_SIZE); + assert(bin_find(m, m->dv) == 0); + } + + if (m->top != 0) { /* check top chunk */ + do_check_top_chunk(m, m->top); + /*assert(m->topsize == chunksize(m->top)); redundant */ + assert(m->topsize > 0); + assert(bin_find(m, m->top) == 0); + } + + total = traverse_and_check(m); + assert(total <= m->footprint); + assert(m->footprint <= m->max_footprint); +} +#endif /* DEBUG */ + +/* ----------------------------- statistics ------------------------------ */ + +#if !NO_MALLINFO +static struct mallinfo internal_mallinfo(mstate m) { + struct mallinfo nm = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; + ensure_initialization(); + if (!PREACTION(m)) { + check_malloc_state(m); + if (is_initialized(m)) { + size_t nfree = SIZE_T_ONE; /* top always free */ + size_t mfree = m->topsize + TOP_FOOT_SIZE; + size_t sum = mfree; + msegmentptr s = &m->seg; + while (s != 0) { + mchunkptr q = align_as_chunk(s->base); + while (segment_holds(s, q) && + q != m->top && q->head != FENCEPOST_HEAD) { + size_t sz = chunksize(q); + sum += sz; + if (!is_inuse(q)) { + mfree += sz; + ++nfree; + } + q = next_chunk(q); + } + s = s->next; + } + + nm.arena = sum; + nm.ordblks = nfree; + nm.hblkhd = m->footprint - sum; + nm.usmblks = m->max_footprint; + nm.uordblks = m->footprint - mfree; + nm.fordblks = mfree; + nm.keepcost = m->topsize; + } + + POSTACTION(m); + } + return nm; +} +#endif /* !NO_MALLINFO */ + +#if !NO_MALLOC_STATS +static void internal_malloc_stats(mstate m) { + ensure_initialization(); + if (!PREACTION(m)) { + size_t maxfp = 0; + size_t fp = 0; + size_t used = 0; + check_malloc_state(m); + if (is_initialized(m)) { + msegmentptr s = &m->seg; + maxfp = m->max_footprint; + fp = m->footprint; + used = fp - (m->topsize + TOP_FOOT_SIZE); + + while (s != 0) { + mchunkptr q = align_as_chunk(s->base); + while (segment_holds(s, q) && + q != m->top && q->head != FENCEPOST_HEAD) { + if (!is_inuse(q)) + used -= chunksize(q); + q = next_chunk(q); + } + s = s->next; + } + } + POSTACTION(m); /* drop lock */ + fprintf(stderr, "max system bytes = %10lu\n", (unsigned long)(maxfp)); + fprintf(stderr, "system bytes = %10lu\n", (unsigned long)(fp)); + fprintf(stderr, "in use bytes = %10lu\n", (unsigned long)(used)); + } +} +#endif /* NO_MALLOC_STATS */ + +/* ----------------------- Operations on smallbins ----------------------- */ + +/* + Various forms of linking and unlinking are defined as macros. Even + the ones for trees, which are very long but have very short typical + paths. This is ugly but reduces reliance on inlining support of + compilers. +*/ + +/* Link a free chunk into a smallbin */ +#define insert_small_chunk(M, P, S) {\ + bindex_t I = small_index(S);\ + mchunkptr B = smallbin_at(M, I);\ + mchunkptr F = B;\ + assert(S >= MIN_CHUNK_SIZE);\ + if (!smallmap_is_marked(M, I))\ + mark_smallmap(M, I);\ + else if (RTCHECK(ok_address(M, B->fd)))\ + F = B->fd;\ + else {\ + CORRUPTION_ERROR_ACTION(M);\ + }\ + B->fd = P;\ + F->bk = P;\ + P->fd = F;\ + P->bk = B;\ +} + +/* Unlink a chunk from a smallbin */ +#define unlink_small_chunk(M, P, S) {\ + mchunkptr F = P->fd;\ + mchunkptr B = P->bk;\ + bindex_t I = small_index(S);\ + assert(P != B);\ + assert(P != F);\ + assert(chunksize(P) == small_index2size(I));\ + if (RTCHECK(F == smallbin_at(M,I) || (ok_address(M, F) && F->bk == P))) { \ + if (B == F) {\ + clear_smallmap(M, I);\ + }\ + else if (RTCHECK(B == smallbin_at(M,I) ||\ + (ok_address(M, B) && B->fd == P))) {\ + F->bk = B;\ + B->fd = F;\ + }\ + else {\ + CORRUPTION_ERROR_ACTION(M);\ + }\ + }\ + else {\ + CORRUPTION_ERROR_ACTION(M);\ + }\ +} + +/* Unlink the first chunk from a smallbin */ +#define unlink_first_small_chunk(M, B, P, I) {\ + mchunkptr F = P->fd;\ + assert(P != B);\ + assert(P != F);\ + assert(chunksize(P) == small_index2size(I));\ + if (B == F) {\ + clear_smallmap(M, I);\ + }\ + else if (RTCHECK(ok_address(M, F) && F->bk == P)) {\ + F->bk = B;\ + B->fd = F;\ + }\ + else {\ + CORRUPTION_ERROR_ACTION(M);\ + }\ +} + +/* Replace dv node, binning the old one */ +/* Used only when dvsize known to be small */ +#define replace_dv(M, P, S) {\ + size_t DVS = M->dvsize;\ + assert(is_small(DVS));\ + if (DVS != 0) {\ + mchunkptr DV = M->dv;\ + insert_small_chunk(M, DV, DVS);\ + }\ + M->dvsize = S;\ + M->dv = P;\ +} + +/* ------------------------- Operations on trees ------------------------- */ + +/* Insert chunk into tree */ +#define insert_large_chunk(M, X, S) {\ + tbinptr* H;\ + bindex_t I;\ + compute_tree_index(S, I);\ + H = treebin_at(M, I);\ + X->index = I;\ + X->child[0] = X->child[1] = 0;\ + if (!treemap_is_marked(M, I)) {\ + mark_treemap(M, I);\ + *H = X;\ + X->parent = (tchunkptr)H;\ + X->fd = X->bk = X;\ + }\ + else {\ + tchunkptr T = *H;\ + size_t K = S << leftshift_for_tree_index(I);\ + for (;;) {\ + if (chunksize(T) != S) {\ + tchunkptr* C = &(T->child[(K >> (SIZE_T_BITSIZE-SIZE_T_ONE)) & 1]);\ + K <<= 1;\ + if (*C != 0)\ + T = *C;\ + else if (RTCHECK(ok_address(M, C))) {\ + *C = X;\ + X->parent = T;\ + X->fd = X->bk = X;\ + break;\ + }\ + else {\ + CORRUPTION_ERROR_ACTION(M);\ + break;\ + }\ + }\ + else {\ + tchunkptr F = T->fd;\ + if (RTCHECK(ok_address(M, T) && ok_address(M, F))) {\ + T->fd = F->bk = X;\ + X->fd = F;\ + X->bk = T;\ + X->parent = 0;\ + break;\ + }\ + else {\ + CORRUPTION_ERROR_ACTION(M);\ + break;\ + }\ + }\ + }\ + }\ +} + +/* + Unlink steps: + + 1. If x is a chained node, unlink it from its same-sized fd/bk links + and choose its bk node as its replacement. + 2. If x was the last node of its size, but not a leaf node, it must + be replaced with a leaf node (not merely one with an open left or + right), to make sure that lefts and rights of descendents + correspond properly to bit masks. We use the rightmost descendent + of x. We could use any other leaf, but this is easy to locate and + tends to counteract removal of leftmosts elsewhere, and so keeps + paths shorter than minimally guaranteed. This doesn't loop much + because on average a node in a tree is near the bottom. + 3. If x is the base of a chain (i.e., has parent links) relink + x's parent and children to x's replacement (or null if none). +*/ + +#define unlink_large_chunk(M, X) {\ + tchunkptr XP = X->parent;\ + tchunkptr R;\ + if (X->bk != X) {\ + tchunkptr F = X->fd;\ + R = X->bk;\ + if (RTCHECK(ok_address(M, F) && F->bk == X && R->fd == X)) {\ + F->bk = R;\ + R->fd = F;\ + }\ + else {\ + CORRUPTION_ERROR_ACTION(M);\ + }\ + }\ + else {\ + tchunkptr* RP;\ + if (((R = *(RP = &(X->child[1]))) != 0) ||\ + ((R = *(RP = &(X->child[0]))) != 0)) {\ + tchunkptr* CP;\ + while ((*(CP = &(R->child[1])) != 0) ||\ + (*(CP = &(R->child[0])) != 0)) {\ + R = *(RP = CP);\ + }\ + if (RTCHECK(ok_address(M, RP)))\ + *RP = 0;\ + else {\ + CORRUPTION_ERROR_ACTION(M);\ + }\ + }\ + }\ + if (XP != 0) {\ + tbinptr* H = treebin_at(M, X->index);\ + if (X == *H) {\ + if ((*H = R) == 0) \ + clear_treemap(M, X->index);\ + }\ + else if (RTCHECK(ok_address(M, XP))) {\ + if (XP->child[0] == X) \ + XP->child[0] = R;\ + else \ + XP->child[1] = R;\ + }\ + else\ + CORRUPTION_ERROR_ACTION(M);\ + if (R != 0) {\ + if (RTCHECK(ok_address(M, R))) {\ + tchunkptr C0, C1;\ + R->parent = XP;\ + if ((C0 = X->child[0]) != 0) {\ + if (RTCHECK(ok_address(M, C0))) {\ + R->child[0] = C0;\ + C0->parent = R;\ + }\ + else\ + CORRUPTION_ERROR_ACTION(M);\ + }\ + if ((C1 = X->child[1]) != 0) {\ + if (RTCHECK(ok_address(M, C1))) {\ + R->child[1] = C1;\ + C1->parent = R;\ + }\ + else\ + CORRUPTION_ERROR_ACTION(M);\ + }\ + }\ + else\ + CORRUPTION_ERROR_ACTION(M);\ + }\ + }\ +} + +/* Relays to large vs small bin operations */ + +#define insert_chunk(M, P, S)\ + if (is_small(S)) insert_small_chunk(M, P, S)\ + else { tchunkptr TP = (tchunkptr)(P); insert_large_chunk(M, TP, S); } + +#define unlink_chunk(M, P, S)\ + if (is_small(S)) unlink_small_chunk(M, P, S)\ + else { tchunkptr TP = (tchunkptr)(P); unlink_large_chunk(M, TP); } + + +/* Relays to internal calls to malloc/free from realloc, memalign etc */ + +#if ONLY_MSPACES +#define internal_malloc(m, b) mspace_malloc(m, b) +#define internal_free(m, mem) mspace_free(m,mem); +#else /* ONLY_MSPACES */ +#if MSPACES +#define internal_malloc(m, b)\ + ((m == gm)? dlmalloc(b) : mspace_malloc(m, b)) +#define internal_free(m, mem)\ + if (m == gm) dlfree(mem); else mspace_free(m,mem); +#else /* MSPACES */ +#define internal_malloc(m, b) dlmalloc(b) +#define internal_free(m, mem) dlfree(mem) +#endif /* MSPACES */ +#endif /* ONLY_MSPACES */ + +/* ----------------------- Direct-mmapping chunks ----------------------- */ + +/* + Directly mmapped chunks are set up with an offset to the start of + the mmapped region stored in the prev_foot field of the chunk. This + allows reconstruction of the required argument to MUNMAP when freed, + and also allows adjustment of the returned chunk to meet alignment + requirements (especially in memalign). +*/ + +/* Malloc using mmap */ +static void* mmap_alloc(mstate m, size_t nb) { + size_t mmsize = mmap_align(nb + SIX_SIZE_T_SIZES + CHUNK_ALIGN_MASK); + if (m->footprint_limit != 0) { + size_t fp = m->footprint + mmsize; + if (fp <= m->footprint || fp > m->footprint_limit) + return 0; + } + if (mmsize > nb) { /* Check for wrap around 0 */ + char* mm = (char*)(CALL_DIRECT_MMAP(mmsize)); + if (mm != CMFAIL) { + size_t offset = align_offset(chunk2mem(mm)); + size_t psize = mmsize - offset - MMAP_FOOT_PAD; + mchunkptr p = (mchunkptr)(mm + offset); + p->prev_foot = offset; + p->head = psize; + mark_inuse_foot(m, p, psize); + chunk_plus_offset(p, psize)->head = FENCEPOST_HEAD; + chunk_plus_offset(p, psize+SIZE_T_SIZE)->head = 0; + + if (m->least_addr == 0 || mm < m->least_addr) + m->least_addr = mm; + if ((m->footprint += mmsize) > m->max_footprint) + m->max_footprint = m->footprint; + assert(is_aligned(chunk2mem(p))); + check_mmapped_chunk(m, p); + return chunk2mem(p); + } + } + return 0; +} + +/* Realloc using mmap */ +static mchunkptr mmap_resize(mstate m, mchunkptr oldp, size_t nb, int flags) { + size_t oldsize = chunksize(oldp); + (void)flags; /* placate people compiling -Wunused */ + if (is_small(nb)) /* Can't shrink mmap regions below small size */ + return 0; + /* Keep old chunk if big enough but not too big */ + if (oldsize >= nb + SIZE_T_SIZE && + (oldsize - nb) <= (mparams.granularity << 1)) + return oldp; + else { + size_t offset = oldp->prev_foot; + size_t oldmmsize = oldsize + offset + MMAP_FOOT_PAD; + size_t newmmsize = mmap_align(nb + SIX_SIZE_T_SIZES + CHUNK_ALIGN_MASK); + char* cp = (char*)CALL_MREMAP((char*)oldp - offset, + oldmmsize, newmmsize, flags); + if (cp != CMFAIL) { + mchunkptr newp = (mchunkptr)(cp + offset); + size_t psize = newmmsize - offset - MMAP_FOOT_PAD; + newp->head = psize; + mark_inuse_foot(m, newp, psize); + chunk_plus_offset(newp, psize)->head = FENCEPOST_HEAD; + chunk_plus_offset(newp, psize+SIZE_T_SIZE)->head = 0; + + if (cp < m->least_addr) + m->least_addr = cp; + if ((m->footprint += newmmsize - oldmmsize) > m->max_footprint) + m->max_footprint = m->footprint; + check_mmapped_chunk(m, newp); + return newp; + } + } + return 0; +} + + +/* -------------------------- mspace management -------------------------- */ + +/* Initialize top chunk and its size */ +static void init_top(mstate m, mchunkptr p, size_t psize) { + /* Ensure alignment */ + size_t offset = align_offset(chunk2mem(p)); + p = (mchunkptr)((char*)p + offset); + psize -= offset; + + m->top = p; + m->topsize = psize; + p->head = psize | PINUSE_BIT; + /* set size of fake trailing chunk holding overhead space only once */ + chunk_plus_offset(p, psize)->head = TOP_FOOT_SIZE; + m->trim_check = mparams.trim_threshold; /* reset on each update */ +} + +/* Initialize bins for a new mstate that is otherwise zeroed out */ +static void init_bins(mstate m) { + /* Establish circular links for smallbins */ + bindex_t i; + for (i = 0; i < NSMALLBINS; ++i) { + sbinptr bin = smallbin_at(m,i); + bin->fd = bin->bk = bin; + } +} + +#if PROCEED_ON_ERROR + +/* default corruption action */ +static void reset_on_error(mstate m) { + int i; + ++malloc_corruption_error_count; + /* Reinitialize fields to forget about all memory */ + m->smallmap = m->treemap = 0; + m->dvsize = m->topsize = 0; + m->seg.base = 0; + m->seg.size = 0; + m->seg.next = 0; + m->top = m->dv = 0; + for (i = 0; i < NTREEBINS; ++i) + *treebin_at(m, i) = 0; + init_bins(m); +} +#endif /* PROCEED_ON_ERROR */ + +/* Allocate chunk and prepend remainder with chunk in successor base. */ +static void* prepend_alloc(mstate m, char* newbase, char* oldbase, + size_t nb) { + mchunkptr p = align_as_chunk(newbase); + mchunkptr oldfirst = align_as_chunk(oldbase); + size_t psize = (char*)oldfirst - (char*)p; + mchunkptr q = chunk_plus_offset(p, nb); + size_t qsize = psize - nb; + set_size_and_pinuse_of_inuse_chunk(m, p, nb); + + assert((char*)oldfirst > (char*)q); + assert(pinuse(oldfirst)); + assert(qsize >= MIN_CHUNK_SIZE); + + /* consolidate remainder with first chunk of old base */ + if (oldfirst == m->top) { + size_t tsize = m->topsize += qsize; + m->top = q; + q->head = tsize | PINUSE_BIT; + check_top_chunk(m, q); + } + else if (oldfirst == m->dv) { + size_t dsize = m->dvsize += qsize; + m->dv = q; + set_size_and_pinuse_of_free_chunk(q, dsize); + } + else { + if (!is_inuse(oldfirst)) { + size_t nsize = chunksize(oldfirst); + unlink_chunk(m, oldfirst, nsize); + oldfirst = chunk_plus_offset(oldfirst, nsize); + qsize += nsize; + } + set_free_with_pinuse(q, qsize, oldfirst); + insert_chunk(m, q, qsize); + check_free_chunk(m, q); + } + + check_malloced_chunk(m, chunk2mem(p), nb); + return chunk2mem(p); +} + +/* Add a segment to hold a new noncontiguous region */ +static void add_segment(mstate m, char* tbase, size_t tsize, flag_t mmapped) { + /* Determine locations and sizes of segment, fenceposts, old top */ + char* old_top = (char*)m->top; + msegmentptr oldsp = segment_holding(m, old_top); + char* old_end = oldsp->base + oldsp->size; + size_t ssize = pad_request(sizeof(struct malloc_segment)); + char* rawsp = old_end - (ssize + FOUR_SIZE_T_SIZES + CHUNK_ALIGN_MASK); + size_t offset = align_offset(chunk2mem(rawsp)); + char* asp = rawsp + offset; + char* csp = (asp < (old_top + MIN_CHUNK_SIZE))? old_top : asp; + mchunkptr sp = (mchunkptr)csp; + msegmentptr ss = (msegmentptr)(chunk2mem(sp)); + mchunkptr tnext = chunk_plus_offset(sp, ssize); + mchunkptr p = tnext; + int nfences = 0; + + /* reset top to new space */ + init_top(m, (mchunkptr)tbase, tsize - TOP_FOOT_SIZE); + + /* Set up segment record */ + assert(is_aligned(ss)); + set_size_and_pinuse_of_inuse_chunk(m, sp, ssize); + *ss = m->seg; /* Push current record */ + m->seg.base = tbase; + m->seg.size = tsize; + m->seg.sflags = mmapped; + m->seg.next = ss; + + /* Insert trailing fenceposts */ + for (;;) { + mchunkptr nextp = chunk_plus_offset(p, SIZE_T_SIZE); + p->head = FENCEPOST_HEAD; + ++nfences; + if ((char*)(&(nextp->head)) < old_end) + p = nextp; + else + break; + } + assert(nfences >= 2); + + /* Insert the rest of old top into a bin as an ordinary free chunk */ + if (csp != old_top) { + mchunkptr q = (mchunkptr)old_top; + size_t psize = csp - old_top; + mchunkptr tn = chunk_plus_offset(q, psize); + set_free_with_pinuse(q, psize, tn); + insert_chunk(m, q, psize); + } + + check_top_chunk(m, m->top); +} + +/* -------------------------- System allocation -------------------------- */ + +/* Get memory from system using MORECORE or MMAP */ +static void* sys_alloc(mstate m, size_t nb) { + char* tbase = CMFAIL; + size_t tsize = 0; + flag_t mmap_flag = 0; + size_t asize; /* allocation size */ + + ensure_initialization(); + + /* Directly map large chunks, but only if already initialized */ + if (use_mmap(m) && nb >= mparams.mmap_threshold && m->topsize != 0) { + void* mem = mmap_alloc(m, nb); + if (mem != 0) + return mem; + } + + asize = granularity_align(nb + SYS_ALLOC_PADDING); + if (asize <= nb) + return 0; /* wraparound */ + if (m->footprint_limit != 0) { + size_t fp = m->footprint + asize; + if (fp <= m->footprint || fp > m->footprint_limit) + return 0; + } + + /* + Try getting memory in any of three ways (in most-preferred to + least-preferred order): + 1. A call to MORECORE that can normally contiguously extend memory. + (disabled if not MORECORE_CONTIGUOUS or not HAVE_MORECORE or + or main space is mmapped or a previous contiguous call failed) + 2. A call to MMAP new space (disabled if not HAVE_MMAP). + Note that under the default settings, if MORECORE is unable to + fulfill a request, and HAVE_MMAP is true, then mmap is + used as a noncontiguous system allocator. This is a useful backup + strategy for systems with holes in address spaces -- in this case + sbrk cannot contiguously expand the heap, but mmap may be able to + find space. + 3. A call to MORECORE that cannot usually contiguously extend memory. + (disabled if not HAVE_MORECORE) + + In all cases, we need to request enough bytes from system to ensure + we can malloc nb bytes upon success, so pad with enough space for + top_foot, plus alignment-pad to make sure we don't lose bytes if + not on boundary, and round this up to a granularity unit. + */ + + if (MORECORE_CONTIGUOUS && !use_noncontiguous(m)) { + char* br = CMFAIL; + size_t ssize = asize; /* sbrk call size */ + msegmentptr ss = (m->top == 0)? 0 : segment_holding(m, (char*)m->top); + ACQUIRE_MALLOC_GLOBAL_LOCK(); + + if (ss == 0) { /* First time through or recovery */ + char* base = (char*)CALL_MORECORE(0); + if (base != CMFAIL) { + size_t fp; + /* Adjust to end on a page boundary */ + if (!is_page_aligned(base)) + ssize += (page_align((size_t)base) - (size_t)base); + fp = m->footprint + ssize; /* recheck limits */ + if (ssize > nb && ssize < HALF_MAX_SIZE_T && + (m->footprint_limit == 0 || + (fp > m->footprint && fp <= m->footprint_limit)) && + (br = (char*)(CALL_MORECORE(ssize))) == base) { + tbase = base; + tsize = ssize; + } + } + } + else { + /* Subtract out existing available top space from MORECORE request. */ + ssize = granularity_align(nb - m->topsize + SYS_ALLOC_PADDING); + /* Use mem here only if it did continuously extend old space */ + if (ssize < HALF_MAX_SIZE_T && + (br = (char*)(CALL_MORECORE(ssize))) == ss->base+ss->size) { + tbase = br; + tsize = ssize; + } + } + + if (tbase == CMFAIL) { /* Cope with partial failure */ + if (br != CMFAIL) { /* Try to use/extend the space we did get */ + if (ssize < HALF_MAX_SIZE_T && + ssize < nb + SYS_ALLOC_PADDING) { + size_t esize = granularity_align(nb + SYS_ALLOC_PADDING - ssize); + if (esize < HALF_MAX_SIZE_T) { + char* end = (char*)CALL_MORECORE(esize); + if (end != CMFAIL) + ssize += esize; + else { /* Can't use; try to release */ + (void) CALL_MORECORE(-ssize); + br = CMFAIL; + } + } + } + } + if (br != CMFAIL) { /* Use the space we did get */ + tbase = br; + tsize = ssize; + } + else + disable_contiguous(m); /* Don't try contiguous path in the future */ + } + + RELEASE_MALLOC_GLOBAL_LOCK(); + } + + if (HAVE_MMAP && tbase == CMFAIL) { /* Try MMAP */ + char* mp = (char*)(CALL_MMAP(asize)); + if (mp != CMFAIL) { + tbase = mp; + tsize = asize; + mmap_flag = USE_MMAP_BIT; + } + } + + if (HAVE_MORECORE && tbase == CMFAIL) { /* Try noncontiguous MORECORE */ + if (asize < HALF_MAX_SIZE_T) { + char* br = CMFAIL; + char* end = CMFAIL; + ACQUIRE_MALLOC_GLOBAL_LOCK(); + br = (char*)(CALL_MORECORE(asize)); + end = (char*)(CALL_MORECORE(0)); + RELEASE_MALLOC_GLOBAL_LOCK(); + if (br != CMFAIL && end != CMFAIL && br < end) { + size_t ssize = end - br; + if (ssize > nb + TOP_FOOT_SIZE) { + tbase = br; + tsize = ssize; + } + } + } + } + + if (tbase != CMFAIL) { + + if ((m->footprint += tsize) > m->max_footprint) + m->max_footprint = m->footprint; + + if (!is_initialized(m)) { /* first-time initialization */ + if (m->least_addr == 0 || tbase < m->least_addr) + m->least_addr = tbase; + m->seg.base = tbase; + m->seg.size = tsize; + m->seg.sflags = mmap_flag; + m->magic = mparams.magic; + m->release_checks = MAX_RELEASE_CHECK_RATE; + init_bins(m); +#if !ONLY_MSPACES + if (is_global(m)) + init_top(m, (mchunkptr)tbase, tsize - TOP_FOOT_SIZE); + else +#endif + { + /* Offset top by embedded malloc_state */ + mchunkptr mn = next_chunk(mem2chunk(m)); + init_top(m, mn, (size_t)((tbase + tsize) - (char*)mn) -TOP_FOOT_SIZE); + } + } + + else { + /* Try to merge with an existing segment */ + msegmentptr sp = &m->seg; + /* Only consider most recent segment if traversal suppressed */ + while (sp != 0 && tbase != sp->base + sp->size) + sp = (NO_SEGMENT_TRAVERSAL) ? 0 : sp->next; + if (sp != 0 && + !is_extern_segment(sp) && + (sp->sflags & USE_MMAP_BIT) == mmap_flag && + segment_holds(sp, m->top)) { /* append */ + sp->size += tsize; + init_top(m, m->top, m->topsize + tsize); + } + else { + if (tbase < m->least_addr) + m->least_addr = tbase; + sp = &m->seg; + while (sp != 0 && sp->base != tbase + tsize) + sp = (NO_SEGMENT_TRAVERSAL) ? 0 : sp->next; + if (sp != 0 && + !is_extern_segment(sp) && + (sp->sflags & USE_MMAP_BIT) == mmap_flag) { + char* oldbase = sp->base; + sp->base = tbase; + sp->size += tsize; + return prepend_alloc(m, tbase, oldbase, nb); + } + else + add_segment(m, tbase, tsize, mmap_flag); + } + } + + if (nb < m->topsize) { /* Allocate from new or extended top space */ + size_t rsize = m->topsize -= nb; + mchunkptr p = m->top; + mchunkptr r = m->top = chunk_plus_offset(p, nb); + r->head = rsize | PINUSE_BIT; + set_size_and_pinuse_of_inuse_chunk(m, p, nb); + check_top_chunk(m, m->top); + check_malloced_chunk(m, chunk2mem(p), nb); + return chunk2mem(p); + } + } + + MALLOC_FAILURE_ACTION; + return 0; +} + +/* ----------------------- system deallocation -------------------------- */ + +/* Unmap and unlink any mmapped segments that don't contain used chunks */ +static size_t release_unused_segments(mstate m) { + size_t released = 0; + int nsegs = 0; + msegmentptr pred = &m->seg; + msegmentptr sp = pred->next; + while (sp != 0) { + char* base = sp->base; + size_t size = sp->size; + msegmentptr next = sp->next; + ++nsegs; + if (is_mmapped_segment(sp) && !is_extern_segment(sp)) { + mchunkptr p = align_as_chunk(base); + size_t psize = chunksize(p); + /* Can unmap if first chunk holds entire segment and not pinned */ + if (!is_inuse(p) && (char*)p + psize >= base + size - TOP_FOOT_SIZE) { + tchunkptr tp = (tchunkptr)p; + assert(segment_holds(sp, (char*)sp)); + if (p == m->dv) { + m->dv = 0; + m->dvsize = 0; + } + else { + unlink_large_chunk(m, tp); + } + if (CALL_MUNMAP(base, size) == 0) { + released += size; + m->footprint -= size; + /* unlink obsoleted record */ + sp = pred; + sp->next = next; + } + else { /* back out if cannot unmap */ + insert_large_chunk(m, tp, psize); + } + } + } + if (NO_SEGMENT_TRAVERSAL) /* scan only first segment */ + break; + pred = sp; + sp = next; + } + /* Reset check counter */ + m->release_checks = (((size_t) nsegs > (size_t) MAX_RELEASE_CHECK_RATE)? + (size_t) nsegs : (size_t) MAX_RELEASE_CHECK_RATE); + return released; +} + +static int sys_trim(mstate m, size_t pad) { + size_t released = 0; + ensure_initialization(); + if (pad < MAX_REQUEST && is_initialized(m)) { + pad += TOP_FOOT_SIZE; /* ensure enough room for segment overhead */ + + if (m->topsize > pad) { + /* Shrink top space in granularity-size units, keeping at least one */ + size_t unit = mparams.granularity; + size_t extra = ((m->topsize - pad + (unit - SIZE_T_ONE)) / unit - + SIZE_T_ONE) * unit; + msegmentptr sp = segment_holding(m, (char*)m->top); + + if (!is_extern_segment(sp)) { + if (is_mmapped_segment(sp)) { + if (HAVE_MMAP && + sp->size >= extra && + !has_segment_link(m, sp)) { /* can't shrink if pinned */ + size_t newsize = sp->size - extra; + (void)newsize; /* placate people compiling -Wunused-variable */ + /* Prefer mremap, fall back to munmap */ + if ((CALL_MREMAP(sp->base, sp->size, newsize, 0) != MFAIL) || + (CALL_MUNMAP(sp->base + newsize, extra) == 0)) { + released = extra; + } + } + } + else if (HAVE_MORECORE) { + if (extra >= HALF_MAX_SIZE_T) /* Avoid wrapping negative */ + extra = (HALF_MAX_SIZE_T) + SIZE_T_ONE - unit; + ACQUIRE_MALLOC_GLOBAL_LOCK(); + { + /* Make sure end of memory is where we last set it. */ + char* old_br = (char*)(CALL_MORECORE(0)); + if (old_br == sp->base + sp->size) { + char* rel_br = (char*)(CALL_MORECORE(-extra)); + char* new_br = (char*)(CALL_MORECORE(0)); + if (rel_br != CMFAIL && new_br < old_br) + released = old_br - new_br; + } + } + RELEASE_MALLOC_GLOBAL_LOCK(); + } + } + + if (released != 0) { + sp->size -= released; + m->footprint -= released; + init_top(m, m->top, m->topsize - released); + check_top_chunk(m, m->top); + } + } + + /* Unmap any unused mmapped segments */ + if (HAVE_MMAP) + released += release_unused_segments(m); + + /* On failure, disable autotrim to avoid repeated failed future calls */ + if (released == 0 && m->topsize > m->trim_check) + m->trim_check = MAX_SIZE_T; + } + + return (released != 0)? 1 : 0; +} + +/* Consolidate and bin a chunk. Differs from exported versions + of free mainly in that the chunk need not be marked as inuse. +*/ +static void dispose_chunk(mstate m, mchunkptr p, size_t psize) { + mchunkptr next = chunk_plus_offset(p, psize); + if (!pinuse(p)) { + mchunkptr prev; + size_t prevsize = p->prev_foot; + if (is_mmapped(p)) { + psize += prevsize + MMAP_FOOT_PAD; + if (CALL_MUNMAP((char*)p - prevsize, psize) == 0) + m->footprint -= psize; + return; + } + prev = chunk_minus_offset(p, prevsize); + psize += prevsize; + p = prev; + if (RTCHECK(ok_address(m, prev))) { /* consolidate backward */ + if (p != m->dv) { + unlink_chunk(m, p, prevsize); + } + else if ((next->head & INUSE_BITS) == INUSE_BITS) { + m->dvsize = psize; + set_free_with_pinuse(p, psize, next); + return; + } + } + else { + CORRUPTION_ERROR_ACTION(m); + return; + } + } + if (RTCHECK(ok_address(m, next))) { + if (!cinuse(next)) { /* consolidate forward */ + if (next == m->top) { + size_t tsize = m->topsize += psize; + m->top = p; + p->head = tsize | PINUSE_BIT; + if (p == m->dv) { + m->dv = 0; + m->dvsize = 0; + } + return; + } + else if (next == m->dv) { + size_t dsize = m->dvsize += psize; + m->dv = p; + set_size_and_pinuse_of_free_chunk(p, dsize); + return; + } + else { + size_t nsize = chunksize(next); + psize += nsize; + unlink_chunk(m, next, nsize); + set_size_and_pinuse_of_free_chunk(p, psize); + if (p == m->dv) { + m->dvsize = psize; + return; + } + } + } + else { + set_free_with_pinuse(p, psize, next); + } + insert_chunk(m, p, psize); + } + else { + CORRUPTION_ERROR_ACTION(m); + } +} + +/* ---------------------------- malloc --------------------------- */ + +/* allocate a large request from the best fitting chunk in a treebin */ +static void* tmalloc_large(mstate m, size_t nb) { + tchunkptr v = 0; + size_t rsize = -nb; /* Unsigned negation */ + tchunkptr t; + bindex_t idx; + compute_tree_index(nb, idx); + if ((t = *treebin_at(m, idx)) != 0) { + /* Traverse tree for this bin looking for node with size == nb */ + size_t sizebits = nb << leftshift_for_tree_index(idx); + tchunkptr rst = 0; /* The deepest untaken right subtree */ + for (;;) { + tchunkptr rt; + size_t trem = chunksize(t) - nb; + if (trem < rsize) { + v = t; + if ((rsize = trem) == 0) + break; + } + rt = t->child[1]; + t = t->child[(sizebits >> (SIZE_T_BITSIZE-SIZE_T_ONE)) & 1]; + if (rt != 0 && rt != t) + rst = rt; + if (t == 0) { + t = rst; /* set t to least subtree holding sizes > nb */ + break; + } + sizebits <<= 1; + } + } + if (t == 0 && v == 0) { /* set t to root of next non-empty treebin */ + binmap_t leftbits = left_bits(idx2bit(idx)) & m->treemap; + if (leftbits != 0) { + bindex_t i; + binmap_t leastbit = least_bit(leftbits); + compute_bit2idx(leastbit, i); + t = *treebin_at(m, i); + } + } + + while (t != 0) { /* find smallest of tree or subtree */ + size_t trem = chunksize(t) - nb; + if (trem < rsize) { + rsize = trem; + v = t; + } + t = leftmost_child(t); + } + + /* If dv is a better fit, return 0 so malloc will use it */ + if (v != 0 && rsize < (size_t)(m->dvsize - nb)) { + if (RTCHECK(ok_address(m, v))) { /* split */ + mchunkptr r = chunk_plus_offset(v, nb); + assert(chunksize(v) == rsize + nb); + if (RTCHECK(ok_next(v, r))) { + unlink_large_chunk(m, v); + if (rsize < MIN_CHUNK_SIZE) + set_inuse_and_pinuse(m, v, (rsize + nb)); + else { + set_size_and_pinuse_of_inuse_chunk(m, v, nb); + set_size_and_pinuse_of_free_chunk(r, rsize); + insert_chunk(m, r, rsize); + } + return chunk2mem(v); + } + } + CORRUPTION_ERROR_ACTION(m); + } + return 0; +} + +/* allocate a small request from the best fitting chunk in a treebin */ +static void* tmalloc_small(mstate m, size_t nb) { + tchunkptr t, v; + size_t rsize; + bindex_t i; + binmap_t leastbit = least_bit(m->treemap); + compute_bit2idx(leastbit, i); + v = t = *treebin_at(m, i); + rsize = chunksize(t) - nb; + + while ((t = leftmost_child(t)) != 0) { + size_t trem = chunksize(t) - nb; + if (trem < rsize) { + rsize = trem; + v = t; + } + } + + if (RTCHECK(ok_address(m, v))) { + mchunkptr r = chunk_plus_offset(v, nb); + assert(chunksize(v) == rsize + nb); + if (RTCHECK(ok_next(v, r))) { + unlink_large_chunk(m, v); + if (rsize < MIN_CHUNK_SIZE) + set_inuse_and_pinuse(m, v, (rsize + nb)); + else { + set_size_and_pinuse_of_inuse_chunk(m, v, nb); + set_size_and_pinuse_of_free_chunk(r, rsize); + replace_dv(m, r, rsize); + } + return chunk2mem(v); + } + } + + CORRUPTION_ERROR_ACTION(m); + return 0; +} + +#if !ONLY_MSPACES + +void* dlmalloc(size_t bytes) { + /* + Basic algorithm: + If a small request (< 256 bytes minus per-chunk overhead): + 1. If one exists, use a remainderless chunk in associated smallbin. + (Remainderless means that there are too few excess bytes to + represent as a chunk.) + 2. If it is big enough, use the dv chunk, which is normally the + chunk adjacent to the one used for the most recent small request. + 3. If one exists, split the smallest available chunk in a bin, + saving remainder in dv. + 4. If it is big enough, use the top chunk. + 5. If available, get memory from system and use it + Otherwise, for a large request: + 1. Find the smallest available binned chunk that fits, and use it + if it is better fitting than dv chunk, splitting if necessary. + 2. If better fitting than any binned chunk, use the dv chunk. + 3. If it is big enough, use the top chunk. + 4. If request size >= mmap threshold, try to directly mmap this chunk. + 5. If available, get memory from system and use it + + The ugly goto's here ensure that postaction occurs along all paths. + */ + +#if USE_LOCKS + ensure_initialization(); /* initialize in sys_alloc if not using locks */ +#endif + + if (!PREACTION(gm)) { + void* mem; + size_t nb; + if (bytes <= MAX_SMALL_REQUEST) { + bindex_t idx; + binmap_t smallbits; + nb = (bytes < MIN_REQUEST)? MIN_CHUNK_SIZE : pad_request(bytes); + idx = small_index(nb); + smallbits = gm->smallmap >> idx; + + if ((smallbits & 0x3U) != 0) { /* Remainderless fit to a smallbin. */ + mchunkptr b, p; + idx += ~smallbits & 1; /* Uses next bin if idx empty */ + b = smallbin_at(gm, idx); + p = b->fd; + assert(chunksize(p) == small_index2size(idx)); + unlink_first_small_chunk(gm, b, p, idx); + set_inuse_and_pinuse(gm, p, small_index2size(idx)); + mem = chunk2mem(p); + check_malloced_chunk(gm, mem, nb); + goto postaction; + } + + else if (nb > gm->dvsize) { + if (smallbits != 0) { /* Use chunk in next nonempty smallbin */ + mchunkptr b, p, r; + size_t rsize; + bindex_t i; + binmap_t leftbits = (smallbits << idx) & left_bits(idx2bit(idx)); + binmap_t leastbit = least_bit(leftbits); + compute_bit2idx(leastbit, i); + b = smallbin_at(gm, i); + p = b->fd; + assert(chunksize(p) == small_index2size(i)); + unlink_first_small_chunk(gm, b, p, i); + rsize = small_index2size(i) - nb; + /* Fit here cannot be remainderless if 4byte sizes */ + if (SIZE_T_SIZE != 4 && rsize < MIN_CHUNK_SIZE) + set_inuse_and_pinuse(gm, p, small_index2size(i)); + else { + set_size_and_pinuse_of_inuse_chunk(gm, p, nb); + r = chunk_plus_offset(p, nb); + set_size_and_pinuse_of_free_chunk(r, rsize); + replace_dv(gm, r, rsize); + } + mem = chunk2mem(p); + check_malloced_chunk(gm, mem, nb); + goto postaction; + } + + else if (gm->treemap != 0 && (mem = tmalloc_small(gm, nb)) != 0) { + check_malloced_chunk(gm, mem, nb); + goto postaction; + } + } + } + else if (bytes >= MAX_REQUEST) + nb = MAX_SIZE_T; /* Too big to allocate. Force failure (in sys alloc) */ + else { + nb = pad_request(bytes); + if (gm->treemap != 0 && (mem = tmalloc_large(gm, nb)) != 0) { + check_malloced_chunk(gm, mem, nb); + goto postaction; + } + } + + if (nb <= gm->dvsize) { + size_t rsize = gm->dvsize - nb; + mchunkptr p = gm->dv; + if (rsize >= MIN_CHUNK_SIZE) { /* split dv */ + mchunkptr r = gm->dv = chunk_plus_offset(p, nb); + gm->dvsize = rsize; + set_size_and_pinuse_of_free_chunk(r, rsize); + set_size_and_pinuse_of_inuse_chunk(gm, p, nb); + } + else { /* exhaust dv */ + size_t dvs = gm->dvsize; + gm->dvsize = 0; + gm->dv = 0; + set_inuse_and_pinuse(gm, p, dvs); + } + mem = chunk2mem(p); + check_malloced_chunk(gm, mem, nb); + goto postaction; + } + + else if (nb < gm->topsize) { /* Split top */ + size_t rsize = gm->topsize -= nb; + mchunkptr p = gm->top; + mchunkptr r = gm->top = chunk_plus_offset(p, nb); + r->head = rsize | PINUSE_BIT; + set_size_and_pinuse_of_inuse_chunk(gm, p, nb); + mem = chunk2mem(p); + check_top_chunk(gm, gm->top); + check_malloced_chunk(gm, mem, nb); + goto postaction; + } + + mem = sys_alloc(gm, nb); + + postaction: + POSTACTION(gm); + return mem; + } + + return 0; +} + +/* ---------------------------- free --------------------------- */ + +void dlfree(void* mem) { + /* + Consolidate freed chunks with preceeding or succeeding bordering + free chunks, if they exist, and then place in a bin. Intermixed + with special cases for top, dv, mmapped chunks, and usage errors. + */ + + if (mem != 0) { + mchunkptr p = mem2chunk(mem); +#if FOOTERS + mstate fm = get_mstate_for(p); + if (!ok_magic(fm)) { + USAGE_ERROR_ACTION(fm, p); + return; + } +#else /* FOOTERS */ +#define fm gm +#endif /* FOOTERS */ + if (!PREACTION(fm)) { + check_inuse_chunk(fm, p); + if (RTCHECK(ok_address(fm, p) && ok_inuse(p))) { + size_t psize = chunksize(p); + mchunkptr next = chunk_plus_offset(p, psize); + if (!pinuse(p)) { + size_t prevsize = p->prev_foot; + if (is_mmapped(p)) { + psize += prevsize + MMAP_FOOT_PAD; + if (CALL_MUNMAP((char*)p - prevsize, psize) == 0) + fm->footprint -= psize; + goto postaction; + } + else { + mchunkptr prev = chunk_minus_offset(p, prevsize); + psize += prevsize; + p = prev; + if (RTCHECK(ok_address(fm, prev))) { /* consolidate backward */ + if (p != fm->dv) { + unlink_chunk(fm, p, prevsize); + } + else if ((next->head & INUSE_BITS) == INUSE_BITS) { + fm->dvsize = psize; + set_free_with_pinuse(p, psize, next); + goto postaction; + } + } + else + goto erroraction; + } + } + + if (RTCHECK(ok_next(p, next) && ok_pinuse(next))) { + if (!cinuse(next)) { /* consolidate forward */ + if (next == fm->top) { + size_t tsize = fm->topsize += psize; + fm->top = p; + p->head = tsize | PINUSE_BIT; + if (p == fm->dv) { + fm->dv = 0; + fm->dvsize = 0; + } + if (should_trim(fm, tsize)) + sys_trim(fm, 0); + goto postaction; + } + else if (next == fm->dv) { + size_t dsize = fm->dvsize += psize; + fm->dv = p; + set_size_and_pinuse_of_free_chunk(p, dsize); + goto postaction; + } + else { + size_t nsize = chunksize(next); + psize += nsize; + unlink_chunk(fm, next, nsize); + set_size_and_pinuse_of_free_chunk(p, psize); + if (p == fm->dv) { + fm->dvsize = psize; + goto postaction; + } + } + } + else + set_free_with_pinuse(p, psize, next); + + if (is_small(psize)) { + insert_small_chunk(fm, p, psize); + check_free_chunk(fm, p); + } + else { + tchunkptr tp = (tchunkptr)p; + insert_large_chunk(fm, tp, psize); + check_free_chunk(fm, p); + if (--fm->release_checks == 0) + release_unused_segments(fm); + } + goto postaction; + } + } + erroraction: + USAGE_ERROR_ACTION(fm, p); + postaction: + POSTACTION(fm); + } + } +#if !FOOTERS +#undef fm +#endif /* FOOTERS */ +} + +void* dlcalloc(size_t n_elements, size_t elem_size) { + void* mem; + size_t req = 0; + if (n_elements != 0) { + req = n_elements * elem_size; + if (((n_elements | elem_size) & ~(size_t)0xffff) && + (req / n_elements != elem_size)) + req = MAX_SIZE_T; /* force downstream failure on overflow */ + } + mem = dlmalloc(req); + if (mem != 0 && calloc_must_clear(mem2chunk(mem))) + memset(mem, 0, req); + return mem; +} + +#endif /* !ONLY_MSPACES */ + +/* ------------ Internal support for realloc, memalign, etc -------------- */ + +/* Try to realloc; only in-place unless can_move true */ +static mchunkptr try_realloc_chunk(mstate m, mchunkptr p, size_t nb, + int can_move) { + mchunkptr newp = 0; + size_t oldsize = chunksize(p); + mchunkptr next = chunk_plus_offset(p, oldsize); + if (RTCHECK(ok_address(m, p) && ok_inuse(p) && + ok_next(p, next) && ok_pinuse(next))) { + if (is_mmapped(p)) { + newp = mmap_resize(m, p, nb, can_move); + } + else if (oldsize >= nb) { /* already big enough */ + size_t rsize = oldsize - nb; + if (rsize >= MIN_CHUNK_SIZE) { /* split off remainder */ + mchunkptr r = chunk_plus_offset(p, nb); + set_inuse(m, p, nb); + set_inuse(m, r, rsize); + dispose_chunk(m, r, rsize); + } + newp = p; + } + else if (next == m->top) { /* extend into top */ + if (oldsize + m->topsize > nb) { + size_t newsize = oldsize + m->topsize; + size_t newtopsize = newsize - nb; + mchunkptr newtop = chunk_plus_offset(p, nb); + set_inuse(m, p, nb); + newtop->head = newtopsize |PINUSE_BIT; + m->top = newtop; + m->topsize = newtopsize; + newp = p; + } + } + else if (next == m->dv) { /* extend into dv */ + size_t dvs = m->dvsize; + if (oldsize + dvs >= nb) { + size_t dsize = oldsize + dvs - nb; + if (dsize >= MIN_CHUNK_SIZE) { + mchunkptr r = chunk_plus_offset(p, nb); + mchunkptr n = chunk_plus_offset(r, dsize); + set_inuse(m, p, nb); + set_size_and_pinuse_of_free_chunk(r, dsize); + clear_pinuse(n); + m->dvsize = dsize; + m->dv = r; + } + else { /* exhaust dv */ + size_t newsize = oldsize + dvs; + set_inuse(m, p, newsize); + m->dvsize = 0; + m->dv = 0; + } + newp = p; + } + } + else if (!cinuse(next)) { /* extend into next free chunk */ + size_t nextsize = chunksize(next); + if (oldsize + nextsize >= nb) { + size_t rsize = oldsize + nextsize - nb; + unlink_chunk(m, next, nextsize); + if (rsize < MIN_CHUNK_SIZE) { + size_t newsize = oldsize + nextsize; + set_inuse(m, p, newsize); + } + else { + mchunkptr r = chunk_plus_offset(p, nb); + set_inuse(m, p, nb); + set_inuse(m, r, rsize); + dispose_chunk(m, r, rsize); + } + newp = p; + } + } + } + else { + USAGE_ERROR_ACTION(m, chunk2mem(p)); + } + return newp; +} + +static void* internal_memalign(mstate m, size_t alignment, size_t bytes) { + void* mem = 0; + if (alignment < MIN_CHUNK_SIZE) /* must be at least a minimum chunk size */ + alignment = MIN_CHUNK_SIZE; + if ((alignment & (alignment-SIZE_T_ONE)) != 0) {/* Ensure a power of 2 */ + size_t a = MALLOC_ALIGNMENT << 1; + while (a < alignment) a <<= 1; + alignment = a; + } + if (bytes >= MAX_REQUEST - alignment) { + if (m != 0) { /* Test isn't needed but avoids compiler warning */ + MALLOC_FAILURE_ACTION; + } + } + else { + size_t nb = request2size(bytes); + size_t req = nb + alignment + MIN_CHUNK_SIZE - CHUNK_OVERHEAD; + mem = internal_malloc(m, req); + if (mem != 0) { + mchunkptr p = mem2chunk(mem); + if (PREACTION(m)) + return 0; + if ((((size_t)(mem)) & (alignment - 1)) != 0) { /* misaligned */ + /* + Find an aligned spot inside chunk. Since we need to give + back leading space in a chunk of at least MIN_CHUNK_SIZE, if + the first calculation places us at a spot with less than + MIN_CHUNK_SIZE leader, we can move to the next aligned spot. + We've allocated enough total room so that this is always + possible. + */ + char* br = (char*)mem2chunk((size_t)(((size_t)((char*)mem + alignment - + SIZE_T_ONE)) & + -alignment)); + char* pos = ((size_t)(br - (char*)(p)) >= MIN_CHUNK_SIZE)? + br : br+alignment; + mchunkptr newp = (mchunkptr)pos; + size_t leadsize = pos - (char*)(p); + size_t newsize = chunksize(p) - leadsize; + + if (is_mmapped(p)) { /* For mmapped chunks, just adjust offset */ + newp->prev_foot = p->prev_foot + leadsize; + newp->head = newsize; + } + else { /* Otherwise, give back leader, use the rest */ + set_inuse(m, newp, newsize); + set_inuse(m, p, leadsize); + dispose_chunk(m, p, leadsize); + } + p = newp; + } + + /* Give back spare room at the end */ + if (!is_mmapped(p)) { + size_t size = chunksize(p); + if (size > nb + MIN_CHUNK_SIZE) { + size_t remainder_size = size - nb; + mchunkptr remainder = chunk_plus_offset(p, nb); + set_inuse(m, p, nb); + set_inuse(m, remainder, remainder_size); + dispose_chunk(m, remainder, remainder_size); + } + } + + mem = chunk2mem(p); + assert (chunksize(p) >= nb); + assert(((size_t)mem & (alignment - 1)) == 0); + check_inuse_chunk(m, p); + POSTACTION(m); + } + } + return mem; +} + +/* + Common support for independent_X routines, handling + all of the combinations that can result. + The opts arg has: + bit 0 set if all elements are same size (using sizes[0]) + bit 1 set if elements should be zeroed +*/ +static void** ialloc(mstate m, + size_t n_elements, + size_t* sizes, + int opts, + void* chunks[]) { + + size_t element_size; /* chunksize of each element, if all same */ + size_t contents_size; /* total size of elements */ + size_t array_size; /* request size of pointer array */ + void* mem; /* malloced aggregate space */ + mchunkptr p; /* corresponding chunk */ + size_t remainder_size; /* remaining bytes while splitting */ + void** marray; /* either "chunks" or malloced ptr array */ + mchunkptr array_chunk; /* chunk for malloced ptr array */ + flag_t was_enabled; /* to disable mmap */ + size_t size; + size_t i; + + ensure_initialization(); + /* compute array length, if needed */ + if (chunks != 0) { + if (n_elements == 0) + return chunks; /* nothing to do */ + marray = chunks; + array_size = 0; + } + else { + /* if empty req, must still return chunk representing empty array */ + if (n_elements == 0) + return (void**)internal_malloc(m, 0); + marray = 0; + array_size = request2size(n_elements * (sizeof(void*))); + } + + /* compute total element size */ + if (opts & 0x1) { /* all-same-size */ + element_size = request2size(*sizes); + contents_size = n_elements * element_size; + } + else { /* add up all the sizes */ + element_size = 0; + contents_size = 0; + for (i = 0; i != n_elements; ++i) + contents_size += request2size(sizes[i]); + } + + size = contents_size + array_size; + + /* + Allocate the aggregate chunk. First disable direct-mmapping so + malloc won't use it, since we would not be able to later + free/realloc space internal to a segregated mmap region. + */ + was_enabled = use_mmap(m); + disable_mmap(m); + mem = internal_malloc(m, size - CHUNK_OVERHEAD); + if (was_enabled) + enable_mmap(m); + if (mem == 0) + return 0; + + if (PREACTION(m)) return 0; + p = mem2chunk(mem); + remainder_size = chunksize(p); + + assert(!is_mmapped(p)); + + if (opts & 0x2) { /* optionally clear the elements */ + memset((size_t*)mem, 0, remainder_size - SIZE_T_SIZE - array_size); + } + + /* If not provided, allocate the pointer array as final part of chunk */ + if (marray == 0) { + size_t array_chunk_size; + array_chunk = chunk_plus_offset(p, contents_size); + array_chunk_size = remainder_size - contents_size; + marray = (void**) (chunk2mem(array_chunk)); + set_size_and_pinuse_of_inuse_chunk(m, array_chunk, array_chunk_size); + remainder_size = contents_size; + } + + /* split out elements */ + for (i = 0; ; ++i) { + marray[i] = chunk2mem(p); + if (i != n_elements-1) { + if (element_size != 0) + size = element_size; + else + size = request2size(sizes[i]); + remainder_size -= size; + set_size_and_pinuse_of_inuse_chunk(m, p, size); + p = chunk_plus_offset(p, size); + } + else { /* the final element absorbs any overallocation slop */ + set_size_and_pinuse_of_inuse_chunk(m, p, remainder_size); + break; + } + } + +#if DEBUG + if (marray != chunks) { + /* final element must have exactly exhausted chunk */ + if (element_size != 0) { + assert(remainder_size == element_size); + } + else { + assert(remainder_size == request2size(sizes[i])); + } + check_inuse_chunk(m, mem2chunk(marray)); + } + for (i = 0; i != n_elements; ++i) + check_inuse_chunk(m, mem2chunk(marray[i])); + +#endif /* DEBUG */ + + POSTACTION(m); + return marray; +} + +/* Try to free all pointers in the given array. + Note: this could be made faster, by delaying consolidation, + at the price of disabling some user integrity checks, We + still optimize some consolidations by combining adjacent + chunks before freeing, which will occur often if allocated + with ialloc or the array is sorted. +*/ +static size_t internal_bulk_free(mstate m, void* array[], size_t nelem) { + size_t unfreed = 0; + if (!PREACTION(m)) { + void** a; + void** fence = &(array[nelem]); + for (a = array; a != fence; ++a) { + void* mem = *a; + if (mem != 0) { + mchunkptr p = mem2chunk(mem); + size_t psize = chunksize(p); +#if FOOTERS + if (get_mstate_for(p) != m) { + ++unfreed; + continue; + } +#endif + check_inuse_chunk(m, p); + *a = 0; + if (RTCHECK(ok_address(m, p) && ok_inuse(p))) { + void ** b = a + 1; /* try to merge with next chunk */ + mchunkptr next = next_chunk(p); + if (b != fence && *b == chunk2mem(next)) { + size_t newsize = chunksize(next) + psize; + set_inuse(m, p, newsize); + *b = chunk2mem(p); + } + else + dispose_chunk(m, p, psize); + } + else { + CORRUPTION_ERROR_ACTION(m); + break; + } + } + } + if (should_trim(m, m->topsize)) + sys_trim(m, 0); + POSTACTION(m); + } + return unfreed; +} + +/* Traversal */ +#if MALLOC_INSPECT_ALL +static void internal_inspect_all(mstate m, + void(*handler)(void *start, + void *end, + size_t used_bytes, + void* callback_arg), + void* arg) { + if (is_initialized(m)) { + mchunkptr top = m->top; + msegmentptr s; + for (s = &m->seg; s != 0; s = s->next) { + mchunkptr q = align_as_chunk(s->base); + while (segment_holds(s, q) && q->head != FENCEPOST_HEAD) { + mchunkptr next = next_chunk(q); + size_t sz = chunksize(q); + size_t used; + void* start; + if (is_inuse(q)) { + used = sz - CHUNK_OVERHEAD; /* must not be mmapped */ + start = chunk2mem(q); + } + else { + used = 0; + if (is_small(sz)) { /* offset by possible bookkeeping */ + start = (void*)((char*)q + sizeof(struct malloc_chunk)); + } + else { + start = (void*)((char*)q + sizeof(struct malloc_tree_chunk)); + } + } + if (start < (void*)next) /* skip if all space is bookkeeping */ + handler(start, next, used, arg); + if (q == top) + break; + q = next; + } + } + } +} +#endif /* MALLOC_INSPECT_ALL */ + +/* ------------------ Exported realloc, memalign, etc -------------------- */ + +#if !ONLY_MSPACES + +void* dlrealloc(void* oldmem, size_t bytes) { + void* mem = 0; + if (oldmem == 0) { + mem = dlmalloc(bytes); + } + else if (bytes >= MAX_REQUEST) { + MALLOC_FAILURE_ACTION; + } +#ifdef REALLOC_ZERO_BYTES_FREES + else if (bytes == 0) { + dlfree(oldmem); + } +#endif /* REALLOC_ZERO_BYTES_FREES */ + else { + size_t nb = request2size(bytes); + mchunkptr oldp = mem2chunk(oldmem); +#if ! FOOTERS + mstate m = gm; +#else /* FOOTERS */ + mstate m = get_mstate_for(oldp); + if (!ok_magic(m)) { + USAGE_ERROR_ACTION(m, oldmem); + return 0; + } +#endif /* FOOTERS */ + if (!PREACTION(m)) { + mchunkptr newp = try_realloc_chunk(m, oldp, nb, 1); + POSTACTION(m); + if (newp != 0) { + check_inuse_chunk(m, newp); + mem = chunk2mem(newp); + } + else { + mem = internal_malloc(m, bytes); + if (mem != 0) { + size_t oc = chunksize(oldp) - overhead_for(oldp); + memcpy(mem, oldmem, (oc < bytes)? oc : bytes); + internal_free(m, oldmem); + } + } + } + } + return mem; +} + +void* dlrealloc_in_place(void* oldmem, size_t bytes) { + void* mem = 0; + if (oldmem != 0) { + if (bytes >= MAX_REQUEST) { + MALLOC_FAILURE_ACTION; + } + else { + size_t nb = request2size(bytes); + mchunkptr oldp = mem2chunk(oldmem); +#if ! FOOTERS + mstate m = gm; +#else /* FOOTERS */ + mstate m = get_mstate_for(oldp); + if (!ok_magic(m)) { + USAGE_ERROR_ACTION(m, oldmem); + return 0; + } +#endif /* FOOTERS */ + if (!PREACTION(m)) { + mchunkptr newp = try_realloc_chunk(m, oldp, nb, 0); + POSTACTION(m); + if (newp == oldp) { + check_inuse_chunk(m, newp); + mem = oldmem; + } + } + } + } + return mem; +} + +void* dlmemalign(size_t alignment, size_t bytes) { + if (alignment <= MALLOC_ALIGNMENT) { + return dlmalloc(bytes); + } + return internal_memalign(gm, alignment, bytes); +} + +int dlposix_memalign(void** pp, size_t alignment, size_t bytes) { + void* mem = 0; + if (alignment == MALLOC_ALIGNMENT) + mem = dlmalloc(bytes); + else { + size_t d = alignment / sizeof(void*); + size_t r = alignment % sizeof(void*); + if (r != 0 || d == 0 || (d & (d-SIZE_T_ONE)) != 0) + return EINVAL; + else if (bytes <= MAX_REQUEST - alignment) { + if (alignment < MIN_CHUNK_SIZE) + alignment = MIN_CHUNK_SIZE; + mem = internal_memalign(gm, alignment, bytes); + } + } + if (mem == 0) + return ENOMEM; + else { + *pp = mem; + return 0; + } +} + +void* dlvalloc(size_t bytes) { + size_t pagesz; + ensure_initialization(); + pagesz = mparams.page_size; + return dlmemalign(pagesz, bytes); +} + +void* dlpvalloc(size_t bytes) { + size_t pagesz; + ensure_initialization(); + pagesz = mparams.page_size; + return dlmemalign(pagesz, (bytes + pagesz - SIZE_T_ONE) & ~(pagesz - SIZE_T_ONE)); +} + +void** dlindependent_calloc(size_t n_elements, size_t elem_size, + void* chunks[]) { + size_t sz = elem_size; /* serves as 1-element array */ + return ialloc(gm, n_elements, &sz, 3, chunks); +} + +void** dlindependent_comalloc(size_t n_elements, size_t sizes[], + void* chunks[]) { + return ialloc(gm, n_elements, sizes, 0, chunks); +} + +size_t dlbulk_free(void* array[], size_t nelem) { + return internal_bulk_free(gm, array, nelem); +} + +#if MALLOC_INSPECT_ALL +void dlmalloc_inspect_all(void(*handler)(void *start, + void *end, + size_t used_bytes, + void* callback_arg), + void* arg) { + ensure_initialization(); + if (!PREACTION(gm)) { + internal_inspect_all(gm, handler, arg); + POSTACTION(gm); + } +} +#endif /* MALLOC_INSPECT_ALL */ + +int dlmalloc_trim(size_t pad) { + int result = 0; + ensure_initialization(); + if (!PREACTION(gm)) { + result = sys_trim(gm, pad); + POSTACTION(gm); + } + return result; +} + +size_t dlmalloc_footprint(void) { + return gm->footprint; +} + +size_t dlmalloc_max_footprint(void) { + return gm->max_footprint; +} + +size_t dlmalloc_footprint_limit(void) { + size_t maf = gm->footprint_limit; + return maf == 0 ? MAX_SIZE_T : maf; +} + +size_t dlmalloc_set_footprint_limit(size_t bytes) { + size_t result; /* invert sense of 0 */ + if (bytes == 0) + result = granularity_align(1); /* Use minimal size */ + if (bytes == MAX_SIZE_T) + result = 0; /* disable */ + else + result = granularity_align(bytes); + return gm->footprint_limit = result; +} + +#if !NO_MALLINFO +struct mallinfo dlmallinfo(void) { + return internal_mallinfo(gm); +} +#endif /* NO_MALLINFO */ + +#if !NO_MALLOC_STATS +void dlmalloc_stats() { + internal_malloc_stats(gm); +} +#endif /* NO_MALLOC_STATS */ + +int dlmallopt(int param_number, int value) { + return change_mparam(param_number, value); +} + +size_t dlmalloc_usable_size(void* mem) { + if (mem != 0) { + mchunkptr p = mem2chunk(mem); + if (is_inuse(p)) + return chunksize(p) - overhead_for(p); + } + return 0; +} + +#endif /* !ONLY_MSPACES */ + +/* ----------------------------- user mspaces ---------------------------- */ + +#if MSPACES + +static mstate init_user_mstate(char* tbase, size_t tsize) { + size_t msize = pad_request(sizeof(struct malloc_state)); + mchunkptr mn; + mchunkptr msp = align_as_chunk(tbase); + mstate m = (mstate)(chunk2mem(msp)); + memset(m, 0, msize); + (void)INITIAL_LOCK(&m->mutex); + msp->head = (msize|INUSE_BITS); + m->seg.base = m->least_addr = tbase; + m->seg.size = m->footprint = m->max_footprint = tsize; + m->magic = mparams.magic; + m->release_checks = MAX_RELEASE_CHECK_RATE; + m->mflags = mparams.default_mflags; + m->extp = 0; + m->exts = 0; + disable_contiguous(m); + init_bins(m); + mn = next_chunk(mem2chunk(m)); + init_top(m, mn, (size_t)((tbase + tsize) - (char*)mn) - TOP_FOOT_SIZE); + check_top_chunk(m, m->top); + return m; +} + +mspace create_mspace(size_t capacity, int locked) { + mstate m = 0; + size_t msize; + ensure_initialization(); + msize = pad_request(sizeof(struct malloc_state)); + if (capacity < (size_t) -(msize + TOP_FOOT_SIZE + mparams.page_size)) { + size_t rs = ((capacity == 0)? mparams.granularity : + (capacity + TOP_FOOT_SIZE + msize)); + size_t tsize = granularity_align(rs); + char* tbase = (char*)(CALL_MMAP(tsize)); + if (tbase != CMFAIL) { + m = init_user_mstate(tbase, tsize); + m->seg.sflags = USE_MMAP_BIT; + set_lock(m, locked); + } + } + return (mspace)m; +} + +mspace create_mspace_with_base(void* base, size_t capacity, int locked) { + mstate m = 0; + size_t msize; + ensure_initialization(); + msize = pad_request(sizeof(struct malloc_state)); + if (capacity > msize + TOP_FOOT_SIZE && + capacity < (size_t) -(msize + TOP_FOOT_SIZE + mparams.page_size)) { + m = init_user_mstate((char*)base, capacity); + m->seg.sflags = EXTERN_BIT; + set_lock(m, locked); + } + return (mspace)m; +} + +int mspace_track_large_chunks(mspace msp, int enable) { + int ret = 0; + mstate ms = (mstate)msp; + if (!PREACTION(ms)) { + if (!use_mmap(ms)) { + ret = 1; + } + if (!enable) { + enable_mmap(ms); + } else { + disable_mmap(ms); + } + POSTACTION(ms); + } + return ret; +} + +size_t destroy_mspace(mspace msp) { + size_t freed = 0; + mstate ms = (mstate)msp; + if (ok_magic(ms)) { + msegmentptr sp = &ms->seg; + (void)DESTROY_LOCK(&ms->mutex); /* destroy before unmapped */ + while (sp != 0) { + char* base = sp->base; + size_t size = sp->size; + flag_t flag = sp->sflags; + (void)base; /* placate people compiling -Wunused-variable */ + sp = sp->next; + if ((flag & USE_MMAP_BIT) && !(flag & EXTERN_BIT) && + CALL_MUNMAP(base, size) == 0) + freed += size; + } + } + else { + USAGE_ERROR_ACTION(ms,ms); + } + return freed; +} + +/* + mspace versions of routines are near-clones of the global + versions. This is not so nice but better than the alternatives. +*/ + +void* mspace_malloc(mspace msp, size_t bytes) { + mstate ms = (mstate)msp; + if (!ok_magic(ms)) { + USAGE_ERROR_ACTION(ms,ms); + return 0; + } + if (!PREACTION(ms)) { + void* mem; + size_t nb; + if (bytes <= MAX_SMALL_REQUEST) { + bindex_t idx; + binmap_t smallbits; + nb = (bytes < MIN_REQUEST)? MIN_CHUNK_SIZE : pad_request(bytes); + idx = small_index(nb); + smallbits = ms->smallmap >> idx; + + if ((smallbits & 0x3U) != 0) { /* Remainderless fit to a smallbin. */ + mchunkptr b, p; + idx += ~smallbits & 1; /* Uses next bin if idx empty */ + b = smallbin_at(ms, idx); + p = b->fd; + assert(chunksize(p) == small_index2size(idx)); + unlink_first_small_chunk(ms, b, p, idx); + set_inuse_and_pinuse(ms, p, small_index2size(idx)); + mem = chunk2mem(p); + check_malloced_chunk(ms, mem, nb); + goto postaction; + } + + else if (nb > ms->dvsize) { + if (smallbits != 0) { /* Use chunk in next nonempty smallbin */ + mchunkptr b, p, r; + size_t rsize; + bindex_t i; + binmap_t leftbits = (smallbits << idx) & left_bits(idx2bit(idx)); + binmap_t leastbit = least_bit(leftbits); + compute_bit2idx(leastbit, i); + b = smallbin_at(ms, i); + p = b->fd; + assert(chunksize(p) == small_index2size(i)); + unlink_first_small_chunk(ms, b, p, i); + rsize = small_index2size(i) - nb; + /* Fit here cannot be remainderless if 4byte sizes */ + if (SIZE_T_SIZE != 4 && rsize < MIN_CHUNK_SIZE) + set_inuse_and_pinuse(ms, p, small_index2size(i)); + else { + set_size_and_pinuse_of_inuse_chunk(ms, p, nb); + r = chunk_plus_offset(p, nb); + set_size_and_pinuse_of_free_chunk(r, rsize); + replace_dv(ms, r, rsize); + } + mem = chunk2mem(p); + check_malloced_chunk(ms, mem, nb); + goto postaction; + } + + else if (ms->treemap != 0 && (mem = tmalloc_small(ms, nb)) != 0) { + check_malloced_chunk(ms, mem, nb); + goto postaction; + } + } + } + else if (bytes >= MAX_REQUEST) + nb = MAX_SIZE_T; /* Too big to allocate. Force failure (in sys alloc) */ + else { + nb = pad_request(bytes); + if (ms->treemap != 0 && (mem = tmalloc_large(ms, nb)) != 0) { + check_malloced_chunk(ms, mem, nb); + goto postaction; + } + } + + if (nb <= ms->dvsize) { + size_t rsize = ms->dvsize - nb; + mchunkptr p = ms->dv; + if (rsize >= MIN_CHUNK_SIZE) { /* split dv */ + mchunkptr r = ms->dv = chunk_plus_offset(p, nb); + ms->dvsize = rsize; + set_size_and_pinuse_of_free_chunk(r, rsize); + set_size_and_pinuse_of_inuse_chunk(ms, p, nb); + } + else { /* exhaust dv */ + size_t dvs = ms->dvsize; + ms->dvsize = 0; + ms->dv = 0; + set_inuse_and_pinuse(ms, p, dvs); + } + mem = chunk2mem(p); + check_malloced_chunk(ms, mem, nb); + goto postaction; + } + + else if (nb < ms->topsize) { /* Split top */ + size_t rsize = ms->topsize -= nb; + mchunkptr p = ms->top; + mchunkptr r = ms->top = chunk_plus_offset(p, nb); + r->head = rsize | PINUSE_BIT; + set_size_and_pinuse_of_inuse_chunk(ms, p, nb); + mem = chunk2mem(p); + check_top_chunk(ms, ms->top); + check_malloced_chunk(ms, mem, nb); + goto postaction; + } + + mem = sys_alloc(ms, nb); + + postaction: + POSTACTION(ms); + return mem; + } + + return 0; +} + +void mspace_free(mspace msp, void* mem) { + if (mem != 0) { + mchunkptr p = mem2chunk(mem); +#if FOOTERS + mstate fm = get_mstate_for(p); + (void)msp; /* placate people compiling -Wunused */ +#else /* FOOTERS */ + mstate fm = (mstate)msp; +#endif /* FOOTERS */ + if (!ok_magic(fm)) { + USAGE_ERROR_ACTION(fm, p); + return; + } + if (!PREACTION(fm)) { + check_inuse_chunk(fm, p); + if (RTCHECK(ok_address(fm, p) && ok_inuse(p))) { + size_t psize = chunksize(p); + mchunkptr next = chunk_plus_offset(p, psize); + if (!pinuse(p)) { + size_t prevsize = p->prev_foot; + if (is_mmapped(p)) { + psize += prevsize + MMAP_FOOT_PAD; + if (CALL_MUNMAP((char*)p - prevsize, psize) == 0) + fm->footprint -= psize; + goto postaction; + } + else { + mchunkptr prev = chunk_minus_offset(p, prevsize); + psize += prevsize; + p = prev; + if (RTCHECK(ok_address(fm, prev))) { /* consolidate backward */ + if (p != fm->dv) { + unlink_chunk(fm, p, prevsize); + } + else if ((next->head & INUSE_BITS) == INUSE_BITS) { + fm->dvsize = psize; + set_free_with_pinuse(p, psize, next); + goto postaction; + } + } + else + goto erroraction; + } + } + + if (RTCHECK(ok_next(p, next) && ok_pinuse(next))) { + if (!cinuse(next)) { /* consolidate forward */ + if (next == fm->top) { + size_t tsize = fm->topsize += psize; + fm->top = p; + p->head = tsize | PINUSE_BIT; + if (p == fm->dv) { + fm->dv = 0; + fm->dvsize = 0; + } + if (should_trim(fm, tsize)) + sys_trim(fm, 0); + goto postaction; + } + else if (next == fm->dv) { + size_t dsize = fm->dvsize += psize; + fm->dv = p; + set_size_and_pinuse_of_free_chunk(p, dsize); + goto postaction; + } + else { + size_t nsize = chunksize(next); + psize += nsize; + unlink_chunk(fm, next, nsize); + set_size_and_pinuse_of_free_chunk(p, psize); + if (p == fm->dv) { + fm->dvsize = psize; + goto postaction; + } + } + } + else + set_free_with_pinuse(p, psize, next); + + if (is_small(psize)) { + insert_small_chunk(fm, p, psize); + check_free_chunk(fm, p); + } + else { + tchunkptr tp = (tchunkptr)p; + insert_large_chunk(fm, tp, psize); + check_free_chunk(fm, p); + if (--fm->release_checks == 0) + release_unused_segments(fm); + } + goto postaction; + } + } + erroraction: + USAGE_ERROR_ACTION(fm, p); + postaction: + POSTACTION(fm); + } + } +} + +void* mspace_calloc(mspace msp, size_t n_elements, size_t elem_size) { + void* mem; + size_t req = 0; + mstate ms = (mstate)msp; + if (!ok_magic(ms)) { + USAGE_ERROR_ACTION(ms,ms); + return 0; + } + if (n_elements != 0) { + req = n_elements * elem_size; + if (((n_elements | elem_size) & ~(size_t)0xffff) && + (req / n_elements != elem_size)) + req = MAX_SIZE_T; /* force downstream failure on overflow */ + } + mem = internal_malloc(ms, req); + if (mem != 0 && calloc_must_clear(mem2chunk(mem))) + memset(mem, 0, req); + return mem; +} + +void* mspace_realloc(mspace msp, void* oldmem, size_t bytes) { + void* mem = 0; + if (oldmem == 0) { + mem = mspace_malloc(msp, bytes); + } + else if (bytes >= MAX_REQUEST) { + MALLOC_FAILURE_ACTION; + } +#ifdef REALLOC_ZERO_BYTES_FREES + else if (bytes == 0) { + mspace_free(msp, oldmem); + } +#endif /* REALLOC_ZERO_BYTES_FREES */ + else { + size_t nb = request2size(bytes); + mchunkptr oldp = mem2chunk(oldmem); +#if ! FOOTERS + mstate m = (mstate)msp; +#else /* FOOTERS */ + mstate m = get_mstate_for(oldp); + if (!ok_magic(m)) { + USAGE_ERROR_ACTION(m, oldmem); + return 0; + } +#endif /* FOOTERS */ + if (!PREACTION(m)) { + mchunkptr newp = try_realloc_chunk(m, oldp, nb, 1); + POSTACTION(m); + if (newp != 0) { + check_inuse_chunk(m, newp); + mem = chunk2mem(newp); + } + else { + mem = mspace_malloc(m, bytes); + if (mem != 0) { + size_t oc = chunksize(oldp) - overhead_for(oldp); + memcpy(mem, oldmem, (oc < bytes)? oc : bytes); + mspace_free(m, oldmem); + } + } + } + } + return mem; +} + +void* mspace_realloc_in_place(mspace msp, void* oldmem, size_t bytes) { + void* mem = 0; + if (oldmem != 0) { + if (bytes >= MAX_REQUEST) { + MALLOC_FAILURE_ACTION; + } + else { + size_t nb = request2size(bytes); + mchunkptr oldp = mem2chunk(oldmem); +#if ! FOOTERS + mstate m = (mstate)msp; +#else /* FOOTERS */ + mstate m = get_mstate_for(oldp); + (void)msp; /* placate people compiling -Wunused */ + if (!ok_magic(m)) { + USAGE_ERROR_ACTION(m, oldmem); + return 0; + } +#endif /* FOOTERS */ + if (!PREACTION(m)) { + mchunkptr newp = try_realloc_chunk(m, oldp, nb, 0); + POSTACTION(m); + if (newp == oldp) { + check_inuse_chunk(m, newp); + mem = oldmem; + } + } + } + } + return mem; +} + +void* mspace_memalign(mspace msp, size_t alignment, size_t bytes) { + mstate ms = (mstate)msp; + if (!ok_magic(ms)) { + USAGE_ERROR_ACTION(ms,ms); + return 0; + } + if (alignment <= MALLOC_ALIGNMENT) + return mspace_malloc(msp, bytes); + return internal_memalign(ms, alignment, bytes); +} + +void** mspace_independent_calloc(mspace msp, size_t n_elements, + size_t elem_size, void* chunks[]) { + size_t sz = elem_size; /* serves as 1-element array */ + mstate ms = (mstate)msp; + if (!ok_magic(ms)) { + USAGE_ERROR_ACTION(ms,ms); + return 0; + } + return ialloc(ms, n_elements, &sz, 3, chunks); +} + +void** mspace_independent_comalloc(mspace msp, size_t n_elements, + size_t sizes[], void* chunks[]) { + mstate ms = (mstate)msp; + if (!ok_magic(ms)) { + USAGE_ERROR_ACTION(ms,ms); + return 0; + } + return ialloc(ms, n_elements, sizes, 0, chunks); +} + +size_t mspace_bulk_free(mspace msp, void* array[], size_t nelem) { + return internal_bulk_free((mstate)msp, array, nelem); +} + +#if MALLOC_INSPECT_ALL +void mspace_inspect_all(mspace msp, + void(*handler)(void *start, + void *end, + size_t used_bytes, + void* callback_arg), + void* arg) { + mstate ms = (mstate)msp; + if (ok_magic(ms)) { + if (!PREACTION(ms)) { + internal_inspect_all(ms, handler, arg); + POSTACTION(ms); + } + } + else { + USAGE_ERROR_ACTION(ms,ms); + } +} +#endif /* MALLOC_INSPECT_ALL */ + +int mspace_trim(mspace msp, size_t pad) { + int result = 0; + mstate ms = (mstate)msp; + if (ok_magic(ms)) { + if (!PREACTION(ms)) { + result = sys_trim(ms, pad); + POSTACTION(ms); + } + } + else { + USAGE_ERROR_ACTION(ms,ms); + } + return result; +} + +#if !NO_MALLOC_STATS +void mspace_malloc_stats(mspace msp) { + mstate ms = (mstate)msp; + if (ok_magic(ms)) { + internal_malloc_stats(ms); + } + else { + USAGE_ERROR_ACTION(ms,ms); + } +} +#endif /* NO_MALLOC_STATS */ + +size_t mspace_footprint(mspace msp) { + size_t result = 0; + mstate ms = (mstate)msp; + if (ok_magic(ms)) { + result = ms->footprint; + } + else { + USAGE_ERROR_ACTION(ms,ms); + } + return result; +} + +size_t mspace_max_footprint(mspace msp) { + size_t result = 0; + mstate ms = (mstate)msp; + if (ok_magic(ms)) { + result = ms->max_footprint; + } + else { + USAGE_ERROR_ACTION(ms,ms); + } + return result; +} + +size_t mspace_footprint_limit(mspace msp) { + size_t result = 0; + mstate ms = (mstate)msp; + if (ok_magic(ms)) { + size_t maf = ms->footprint_limit; + result = (maf == 0) ? MAX_SIZE_T : maf; + } + else { + USAGE_ERROR_ACTION(ms,ms); + } + return result; +} + +size_t mspace_set_footprint_limit(mspace msp, size_t bytes) { + size_t result = 0; + mstate ms = (mstate)msp; + if (ok_magic(ms)) { + if (bytes == 0) + result = granularity_align(1); /* Use minimal size */ + if (bytes == MAX_SIZE_T) + result = 0; /* disable */ + else + result = granularity_align(bytes); + ms->footprint_limit = result; + } + else { + USAGE_ERROR_ACTION(ms,ms); + } + return result; +} + +#if !NO_MALLINFO +struct mallinfo mspace_mallinfo(mspace msp) { + mstate ms = (mstate)msp; + if (!ok_magic(ms)) { + USAGE_ERROR_ACTION(ms,ms); + } + return internal_mallinfo(ms); +} +#endif /* NO_MALLINFO */ + +size_t mspace_usable_size(const void* mem) { + if (mem != 0) { + mchunkptr p = mem2chunk(mem); + if (is_inuse(p)) + return chunksize(p) - overhead_for(p); + } + return 0; +} + +int mspace_mallopt(int param_number, int value) { + return change_mparam(param_number, value); +} + +#endif /* MSPACES */ + + +/* -------------------- Alternative MORECORE functions ------------------- */ + +/* + Guidelines for creating a custom version of MORECORE: + + * For best performance, MORECORE should allocate in multiples of pagesize. + * MORECORE may allocate more memory than requested. (Or even less, + but this will usually result in a malloc failure.) + * MORECORE must not allocate memory when given argument zero, but + instead return one past the end address of memory from previous + nonzero call. + * For best performance, consecutive calls to MORECORE with positive + arguments should return increasing addresses, indicating that + space has been contiguously extended. + * Even though consecutive calls to MORECORE need not return contiguous + addresses, it must be OK for malloc'ed chunks to span multiple + regions in those cases where they do happen to be contiguous. + * MORECORE need not handle negative arguments -- it may instead + just return MFAIL when given negative arguments. + Negative arguments are always multiples of pagesize. MORECORE + must not misinterpret negative args as large positive unsigned + args. You can suppress all such calls from even occurring by defining + MORECORE_CANNOT_TRIM, + + As an example alternative MORECORE, here is a custom allocator + kindly contributed for pre-OSX macOS. It uses virtually but not + necessarily physically contiguous non-paged memory (locked in, + present and won't get swapped out). You can use it by uncommenting + this section, adding some #includes, and setting up the appropriate + defines above: + + #define MORECORE osMoreCore + + There is also a shutdown routine that should somehow be called for + cleanup upon program exit. + + #define MAX_POOL_ENTRIES 100 + #define MINIMUM_MORECORE_SIZE (64 * 1024U) + static int next_os_pool; + void *our_os_pools[MAX_POOL_ENTRIES]; + + void *osMoreCore(int size) + { + void *ptr = 0; + static void *sbrk_top = 0; + + if (size > 0) + { + if (size < MINIMUM_MORECORE_SIZE) + size = MINIMUM_MORECORE_SIZE; + if (CurrentExecutionLevel() == kTaskLevel) + ptr = PoolAllocateResident(size + RM_PAGE_SIZE, 0); + if (ptr == 0) + { + return (void *) MFAIL; + } + // save ptrs so they can be freed during cleanup + our_os_pools[next_os_pool] = ptr; + next_os_pool++; + ptr = (void *) ((((size_t) ptr) + RM_PAGE_MASK) & ~RM_PAGE_MASK); + sbrk_top = (char *) ptr + size; + return ptr; + } + else if (size < 0) + { + // we don't currently support shrink behavior + return (void *) MFAIL; + } + else + { + return sbrk_top; + } + } + + // cleanup any allocated memory pools + // called as last thing before shutting down driver + + void osCleanupMem(void) + { + void **ptr; + + for (ptr = our_os_pools; ptr < &our_os_pools[MAX_POOL_ENTRIES]; ptr++) + if (*ptr) + { + PoolDeallocate(*ptr); + *ptr = 0; + } + } + +*/ + + +/* ----------------------------------------------------------------------- +History: + v2.8.6 Wed Aug 29 06:57:58 2012 Doug Lea + * fix bad comparison in dlposix_memalign + * don't reuse adjusted asize in sys_alloc + * add LOCK_AT_FORK -- thanks to Kirill Artamonov for the suggestion + * reduce compiler warnings -- thanks to all who reported/suggested these + + v2.8.5 Sun May 22 10:26:02 2011 Doug Lea (dl at gee) + * Always perform unlink checks unless INSECURE + * Add posix_memalign. + * Improve realloc to expand in more cases; expose realloc_in_place. + Thanks to Peter Buhr for the suggestion. + * Add footprint_limit, inspect_all, bulk_free. Thanks + to Barry Hayes and others for the suggestions. + * Internal refactorings to avoid calls while holding locks + * Use non-reentrant locks by default. Thanks to Roland McGrath + for the suggestion. + * Small fixes to mspace_destroy, reset_on_error. + * Various configuration extensions/changes. Thanks + to all who contributed these. + + V2.8.4a Thu Apr 28 14:39:43 2011 (dl at gee.cs.oswego.edu) + * Update Creative Commons URL + + V2.8.4 Wed May 27 09:56:23 2009 Doug Lea (dl at gee) + * Use zeros instead of prev foot for is_mmapped + * Add mspace_track_large_chunks; thanks to Jean Brouwers + * Fix set_inuse in internal_realloc; thanks to Jean Brouwers + * Fix insufficient sys_alloc padding when using 16byte alignment + * Fix bad error check in mspace_footprint + * Adaptations for ptmalloc; thanks to Wolfram Gloger. + * Reentrant spin locks; thanks to Earl Chew and others + * Win32 improvements; thanks to Niall Douglas and Earl Chew + * Add NO_SEGMENT_TRAVERSAL and MAX_RELEASE_CHECK_RATE options + * Extension hook in malloc_state + * Various small adjustments to reduce warnings on some compilers + * Various configuration extensions/changes for more platforms. Thanks + to all who contributed these. + + V2.8.3 Thu Sep 22 11:16:32 2005 Doug Lea (dl at gee) + * Add max_footprint functions + * Ensure all appropriate literals are size_t + * Fix conditional compilation problem for some #define settings + * Avoid concatenating segments with the one provided + in create_mspace_with_base + * Rename some variables to avoid compiler shadowing warnings + * Use explicit lock initialization. + * Better handling of sbrk interference. + * Simplify and fix segment insertion, trimming and mspace_destroy + * Reinstate REALLOC_ZERO_BYTES_FREES option from 2.7.x + * Thanks especially to Dennis Flanagan for help on these. + + V2.8.2 Sun Jun 12 16:01:10 2005 Doug Lea (dl at gee) + * Fix memalign brace error. + + V2.8.1 Wed Jun 8 16:11:46 2005 Doug Lea (dl at gee) + * Fix improper #endif nesting in C++ + * Add explicit casts needed for C++ + + V2.8.0 Mon May 30 14:09:02 2005 Doug Lea (dl at gee) + * Use trees for large bins + * Support mspaces + * Use segments to unify sbrk-based and mmap-based system allocation, + removing need for emulation on most platforms without sbrk. + * Default safety checks + * Optional footer checks. Thanks to William Robertson for the idea. + * Internal code refactoring + * Incorporate suggestions and platform-specific changes. + Thanks to Dennis Flanagan, Colin Plumb, Niall Douglas, + Aaron Bachmann, Emery Berger, and others. + * Speed up non-fastbin processing enough to remove fastbins. + * Remove useless cfree() to avoid conflicts with other apps. + * Remove internal memcpy, memset. Compilers handle builtins better. + * Remove some options that no one ever used and rename others. + + V2.7.2 Sat Aug 17 09:07:30 2002 Doug Lea (dl at gee) + * Fix malloc_state bitmap array misdeclaration + + V2.7.1 Thu Jul 25 10:58:03 2002 Doug Lea (dl at gee) + * Allow tuning of FIRST_SORTED_BIN_SIZE + * Use PTR_UINT as type for all ptr->int casts. Thanks to John Belmonte. + * Better detection and support for non-contiguousness of MORECORE. + Thanks to Andreas Mueller, Conal Walsh, and Wolfram Gloger + * Bypass most of malloc if no frees. Thanks To Emery Berger. + * Fix freeing of old top non-contiguous chunk im sysmalloc. + * Raised default trim and map thresholds to 256K. + * Fix mmap-related #defines. Thanks to Lubos Lunak. + * Fix copy macros; added LACKS_FCNTL_H. Thanks to Neal Walfield. + * Branch-free bin calculation + * Default trim and mmap thresholds now 256K. + + V2.7.0 Sun Mar 11 14:14:06 2001 Doug Lea (dl at gee) + * Introduce independent_comalloc and independent_calloc. + Thanks to Michael Pachos for motivation and help. + * Make optional .h file available + * Allow > 2GB requests on 32bit systems. + * new WIN32 sbrk, mmap, munmap, lock code from . + Thanks also to Andreas Mueller , + and Anonymous. + * Allow override of MALLOC_ALIGNMENT (Thanks to Ruud Waij for + helping test this.) + * memalign: check alignment arg + * realloc: don't try to shift chunks backwards, since this + leads to more fragmentation in some programs and doesn't + seem to help in any others. + * Collect all cases in malloc requiring system memory into sysmalloc + * Use mmap as backup to sbrk + * Place all internal state in malloc_state + * Introduce fastbins (although similar to 2.5.1) + * Many minor tunings and cosmetic improvements + * Introduce USE_PUBLIC_MALLOC_WRAPPERS, USE_MALLOC_LOCK + * Introduce MALLOC_FAILURE_ACTION, MORECORE_CONTIGUOUS + Thanks to Tony E. Bennett and others. + * Include errno.h to support default failure action. + + V2.6.6 Sun Dec 5 07:42:19 1999 Doug Lea (dl at gee) + * return null for negative arguments + * Added Several WIN32 cleanups from Martin C. Fong + * Add 'LACKS_SYS_PARAM_H' for those systems without 'sys/param.h' + (e.g. WIN32 platforms) + * Cleanup header file inclusion for WIN32 platforms + * Cleanup code to avoid Microsoft Visual C++ compiler complaints + * Add 'USE_DL_PREFIX' to quickly allow co-existence with existing + memory allocation routines + * Set 'malloc_getpagesize' for WIN32 platforms (needs more work) + * Use 'assert' rather than 'ASSERT' in WIN32 code to conform to + usage of 'assert' in non-WIN32 code + * Improve WIN32 'sbrk()' emulation's 'findRegion()' routine to + avoid infinite loop + * Always call 'fREe()' rather than 'free()' + + V2.6.5 Wed Jun 17 15:57:31 1998 Doug Lea (dl at gee) + * Fixed ordering problem with boundary-stamping + + V2.6.3 Sun May 19 08:17:58 1996 Doug Lea (dl at gee) + * Added pvalloc, as recommended by H.J. Liu + * Added 64bit pointer support mainly from Wolfram Gloger + * Added anonymously donated WIN32 sbrk emulation + * Malloc, calloc, getpagesize: add optimizations from Raymond Nijssen + * malloc_extend_top: fix mask error that caused wastage after + foreign sbrks + * Add linux mremap support code from HJ Liu + + V2.6.2 Tue Dec 5 06:52:55 1995 Doug Lea (dl at gee) + * Integrated most documentation with the code. + * Add support for mmap, with help from + Wolfram Gloger (Gloger@lrz.uni-muenchen.de). + * Use last_remainder in more cases. + * Pack bins using idea from colin@nyx10.cs.du.edu + * Use ordered bins instead of best-fit threshhold + * Eliminate block-local decls to simplify tracing and debugging. + * Support another case of realloc via move into top + * Fix error occuring when initial sbrk_base not word-aligned. + * Rely on page size for units instead of SBRK_UNIT to + avoid surprises about sbrk alignment conventions. + * Add mallinfo, mallopt. Thanks to Raymond Nijssen + (raymond@es.ele.tue.nl) for the suggestion. + * Add `pad' argument to malloc_trim and top_pad mallopt parameter. + * More precautions for cases where other routines call sbrk, + courtesy of Wolfram Gloger (Gloger@lrz.uni-muenchen.de). + * Added macros etc., allowing use in linux libc from + H.J. Lu (hjl@gnu.ai.mit.edu) + * Inverted this history list + + V2.6.1 Sat Dec 2 14:10:57 1995 Doug Lea (dl at gee) + * Re-tuned and fixed to behave more nicely with V2.6.0 changes. + * Removed all preallocation code since under current scheme + the work required to undo bad preallocations exceeds + the work saved in good cases for most test programs. + * No longer use return list or unconsolidated bins since + no scheme using them consistently outperforms those that don't + given above changes. + * Use best fit for very large chunks to prevent some worst-cases. + * Added some support for debugging + + V2.6.0 Sat Nov 4 07:05:23 1995 Doug Lea (dl at gee) + * Removed footers when chunks are in use. Thanks to + Paul Wilson (wilson@cs.texas.edu) for the suggestion. + + V2.5.4 Wed Nov 1 07:54:51 1995 Doug Lea (dl at gee) + * Added malloc_trim, with help from Wolfram Gloger + (wmglo@Dent.MED.Uni-Muenchen.DE). + + V2.5.3 Tue Apr 26 10:16:01 1994 Doug Lea (dl at g) + + V2.5.2 Tue Apr 5 16:20:40 1994 Doug Lea (dl at g) + * realloc: try to expand in both directions + * malloc: swap order of clean-bin strategy; + * realloc: only conditionally expand backwards + * Try not to scavenge used bins + * Use bin counts as a guide to preallocation + * Occasionally bin return list chunks in first scan + * Add a few optimizations from colin@nyx10.cs.du.edu + + V2.5.1 Sat Aug 14 15:40:43 1993 Doug Lea (dl at g) + * faster bin computation & slightly different binning + * merged all consolidations to one part of malloc proper + (eliminating old malloc_find_space & malloc_clean_bin) + * Scan 2 returns chunks (not just 1) + * Propagate failure in realloc if malloc returns 0 + * Add stuff to allow compilation on non-ANSI compilers + from kpv@research.att.com + + V2.5 Sat Aug 7 07:41:59 1993 Doug Lea (dl at g.oswego.edu) + * removed potential for odd address access in prev_chunk + * removed dependency on getpagesize.h + * misc cosmetics and a bit more internal documentation + * anticosmetics: mangled names in macros to evade debugger strangeness + * tested on sparc, hp-700, dec-mips, rs6000 + with gcc & native cc (hp, dec only) allowing + Detlefs & Zorn comparison study (in SIGPLAN Notices.) + + Trial version Fri Aug 28 13:14:29 1992 Doug Lea (dl at g.oswego.edu) + * Based loosely on libg++-1.2X malloc. (It retains some of the overall + structure of old version, but most details differ.) + +*/ +#endif diff --git a/src/decomp/pc/gfx/LICENSE.txt b/src/decomp/pc/gfx/LICENSE.txt new file mode 100644 index 0000000..5a1a079 --- /dev/null +++ b/src/decomp/pc/gfx/LICENSE.txt @@ -0,0 +1,19 @@ +Copyright (c) 2020 Emill, MaikelChan + +Redistribution and use in source forms, with or without modification, +are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. +2. Redistributions in binary form are not allowed. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/src/decomp/pc/gfx/README.md b/src/decomp/pc/gfx/README.md new file mode 100644 index 0000000..3f36b1c --- /dev/null +++ b/src/decomp/pc/gfx/README.md @@ -0,0 +1,33 @@ +# Nintendo 64 Fast3D renderer + +Implementation of a Fast3D renderer for games built originally for the Nintendo 64 platform. + +For rendering OpenGL, Direct3D 11 and Direct3D 12 are supported. + +Supported windowing systems are GLX (used on Linux), DXGI (used on Windows) and SDL (generic). + +# Usage + +See `gfx_pc.h`. You will also need a copy of `PR/gbi.h`, found in libultra. + +First call `gfx_init(struct GfxWindowManagerAPI *wapi, struct GfxRenderingAPI *rapi, const char *game_name, bool start_in_fullscreen)` and supply the desired backends at program start. + +Some callbacks can be set on `wapi`. See `gfx_window_manager_api.h` for more info. + +Each game main loop iteration should look like this: + +```C +gfx_start_frame(); // Handles input events such as keyboard and window events +// perform game logic here +gfx_run(cmds); // submit display list and render a frame +// do more expensive work here, such as play audio +gfx_end_frame(); // this just waits until the frame is shown on the screen (vsync), to provide correct game timing +``` + +When you are ready to start the main loop, call `wapi->main_loop(one_iteration_func)`. + +For the best experience, please change the Vtx and Mtx structures to use floats instead of fixed point arithmetic (`GBI_FLOATS`). + +# License + +See LICENSE.txt. Redistributions are allowed only in source form, not in binary form. diff --git a/src/decomp/pc/gfx/dxsdk/d3d12.h b/src/decomp/pc/gfx/dxsdk/d3d12.h new file mode 100644 index 0000000..06e98dc --- /dev/null +++ b/src/decomp/pc/gfx/dxsdk/d3d12.h @@ -0,0 +1,17258 @@ +/*------------------------------------------------------------------------------------- + * + * Copyright (c) Microsoft Corporation + * + *-------------------------------------------------------------------------------------*/ + + +/* this ALWAYS GENERATED file contains the definitions for the interfaces */ + + + /* File created by MIDL compiler version 8.01.0622 */ + + + +/* verify that the version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCNDR_H_VERSION__ +#define __REQUIRED_RPCNDR_H_VERSION__ 500 +#endif + +/* verify that the version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCSAL_H_VERSION__ +#define __REQUIRED_RPCSAL_H_VERSION__ 100 +#endif + +#include "rpc.h" +#include "rpcndr.h" + +#ifndef __RPCNDR_H_VERSION__ +#error this stub requires an updated version of +#endif /* __RPCNDR_H_VERSION__ */ + +#ifndef COM_NO_WINDOWS_H +#include "windows.h" +#include "ole2.h" +#endif /*COM_NO_WINDOWS_H*/ + +#ifndef __d3d12_h__ +#define __d3d12_h__ + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#pragma once +#endif + +/* Forward Declarations */ + +#ifndef __ID3D12Object_FWD_DEFINED__ +#define __ID3D12Object_FWD_DEFINED__ +typedef interface ID3D12Object ID3D12Object; + +#endif /* __ID3D12Object_FWD_DEFINED__ */ + + +#ifndef __ID3D12DeviceChild_FWD_DEFINED__ +#define __ID3D12DeviceChild_FWD_DEFINED__ +typedef interface ID3D12DeviceChild ID3D12DeviceChild; + +#endif /* __ID3D12DeviceChild_FWD_DEFINED__ */ + + +#ifndef __ID3D12RootSignature_FWD_DEFINED__ +#define __ID3D12RootSignature_FWD_DEFINED__ +typedef interface ID3D12RootSignature ID3D12RootSignature; + +#endif /* __ID3D12RootSignature_FWD_DEFINED__ */ + + +#ifndef __ID3D12RootSignatureDeserializer_FWD_DEFINED__ +#define __ID3D12RootSignatureDeserializer_FWD_DEFINED__ +typedef interface ID3D12RootSignatureDeserializer ID3D12RootSignatureDeserializer; + +#endif /* __ID3D12RootSignatureDeserializer_FWD_DEFINED__ */ + + +#ifndef __ID3D12VersionedRootSignatureDeserializer_FWD_DEFINED__ +#define __ID3D12VersionedRootSignatureDeserializer_FWD_DEFINED__ +typedef interface ID3D12VersionedRootSignatureDeserializer ID3D12VersionedRootSignatureDeserializer; + +#endif /* __ID3D12VersionedRootSignatureDeserializer_FWD_DEFINED__ */ + + +#ifndef __ID3D12Pageable_FWD_DEFINED__ +#define __ID3D12Pageable_FWD_DEFINED__ +typedef interface ID3D12Pageable ID3D12Pageable; + +#endif /* __ID3D12Pageable_FWD_DEFINED__ */ + + +#ifndef __ID3D12Heap_FWD_DEFINED__ +#define __ID3D12Heap_FWD_DEFINED__ +typedef interface ID3D12Heap ID3D12Heap; + +#endif /* __ID3D12Heap_FWD_DEFINED__ */ + + +#ifndef __ID3D12Resource_FWD_DEFINED__ +#define __ID3D12Resource_FWD_DEFINED__ +typedef interface ID3D12Resource ID3D12Resource; + +#endif /* __ID3D12Resource_FWD_DEFINED__ */ + + +#ifndef __ID3D12CommandAllocator_FWD_DEFINED__ +#define __ID3D12CommandAllocator_FWD_DEFINED__ +typedef interface ID3D12CommandAllocator ID3D12CommandAllocator; + +#endif /* __ID3D12CommandAllocator_FWD_DEFINED__ */ + + +#ifndef __ID3D12Fence_FWD_DEFINED__ +#define __ID3D12Fence_FWD_DEFINED__ +typedef interface ID3D12Fence ID3D12Fence; + +#endif /* __ID3D12Fence_FWD_DEFINED__ */ + + +#ifndef __ID3D12Fence1_FWD_DEFINED__ +#define __ID3D12Fence1_FWD_DEFINED__ +typedef interface ID3D12Fence1 ID3D12Fence1; + +#endif /* __ID3D12Fence1_FWD_DEFINED__ */ + + +#ifndef __ID3D12PipelineState_FWD_DEFINED__ +#define __ID3D12PipelineState_FWD_DEFINED__ +typedef interface ID3D12PipelineState ID3D12PipelineState; + +#endif /* __ID3D12PipelineState_FWD_DEFINED__ */ + + +#ifndef __ID3D12DescriptorHeap_FWD_DEFINED__ +#define __ID3D12DescriptorHeap_FWD_DEFINED__ +typedef interface ID3D12DescriptorHeap ID3D12DescriptorHeap; + +#endif /* __ID3D12DescriptorHeap_FWD_DEFINED__ */ + + +#ifndef __ID3D12QueryHeap_FWD_DEFINED__ +#define __ID3D12QueryHeap_FWD_DEFINED__ +typedef interface ID3D12QueryHeap ID3D12QueryHeap; + +#endif /* __ID3D12QueryHeap_FWD_DEFINED__ */ + + +#ifndef __ID3D12CommandSignature_FWD_DEFINED__ +#define __ID3D12CommandSignature_FWD_DEFINED__ +typedef interface ID3D12CommandSignature ID3D12CommandSignature; + +#endif /* __ID3D12CommandSignature_FWD_DEFINED__ */ + + +#ifndef __ID3D12CommandList_FWD_DEFINED__ +#define __ID3D12CommandList_FWD_DEFINED__ +typedef interface ID3D12CommandList ID3D12CommandList; + +#endif /* __ID3D12CommandList_FWD_DEFINED__ */ + + +#ifndef __ID3D12GraphicsCommandList_FWD_DEFINED__ +#define __ID3D12GraphicsCommandList_FWD_DEFINED__ +typedef interface ID3D12GraphicsCommandList ID3D12GraphicsCommandList; + +#endif /* __ID3D12GraphicsCommandList_FWD_DEFINED__ */ + + +#ifndef __ID3D12GraphicsCommandList1_FWD_DEFINED__ +#define __ID3D12GraphicsCommandList1_FWD_DEFINED__ +typedef interface ID3D12GraphicsCommandList1 ID3D12GraphicsCommandList1; + +#endif /* __ID3D12GraphicsCommandList1_FWD_DEFINED__ */ + + +#ifndef __ID3D12GraphicsCommandList2_FWD_DEFINED__ +#define __ID3D12GraphicsCommandList2_FWD_DEFINED__ +typedef interface ID3D12GraphicsCommandList2 ID3D12GraphicsCommandList2; + +#endif /* __ID3D12GraphicsCommandList2_FWD_DEFINED__ */ + + +#ifndef __ID3D12CommandQueue_FWD_DEFINED__ +#define __ID3D12CommandQueue_FWD_DEFINED__ +typedef interface ID3D12CommandQueue ID3D12CommandQueue; + +#endif /* __ID3D12CommandQueue_FWD_DEFINED__ */ + + +#ifndef __ID3D12Device_FWD_DEFINED__ +#define __ID3D12Device_FWD_DEFINED__ +typedef interface ID3D12Device ID3D12Device; + +#endif /* __ID3D12Device_FWD_DEFINED__ */ + + +#ifndef __ID3D12PipelineLibrary_FWD_DEFINED__ +#define __ID3D12PipelineLibrary_FWD_DEFINED__ +typedef interface ID3D12PipelineLibrary ID3D12PipelineLibrary; + +#endif /* __ID3D12PipelineLibrary_FWD_DEFINED__ */ + + +#ifndef __ID3D12PipelineLibrary1_FWD_DEFINED__ +#define __ID3D12PipelineLibrary1_FWD_DEFINED__ +typedef interface ID3D12PipelineLibrary1 ID3D12PipelineLibrary1; + +#endif /* __ID3D12PipelineLibrary1_FWD_DEFINED__ */ + + +#ifndef __ID3D12Device1_FWD_DEFINED__ +#define __ID3D12Device1_FWD_DEFINED__ +typedef interface ID3D12Device1 ID3D12Device1; + +#endif /* __ID3D12Device1_FWD_DEFINED__ */ + + +#ifndef __ID3D12Device2_FWD_DEFINED__ +#define __ID3D12Device2_FWD_DEFINED__ +typedef interface ID3D12Device2 ID3D12Device2; + +#endif /* __ID3D12Device2_FWD_DEFINED__ */ + + +#ifndef __ID3D12Device3_FWD_DEFINED__ +#define __ID3D12Device3_FWD_DEFINED__ +typedef interface ID3D12Device3 ID3D12Device3; + +#endif /* __ID3D12Device3_FWD_DEFINED__ */ + + +#ifndef __ID3D12ProtectedSession_FWD_DEFINED__ +#define __ID3D12ProtectedSession_FWD_DEFINED__ +typedef interface ID3D12ProtectedSession ID3D12ProtectedSession; + +#endif /* __ID3D12ProtectedSession_FWD_DEFINED__ */ + + +#ifndef __ID3D12ProtectedResourceSession_FWD_DEFINED__ +#define __ID3D12ProtectedResourceSession_FWD_DEFINED__ +typedef interface ID3D12ProtectedResourceSession ID3D12ProtectedResourceSession; + +#endif /* __ID3D12ProtectedResourceSession_FWD_DEFINED__ */ + + +#ifndef __ID3D12Device4_FWD_DEFINED__ +#define __ID3D12Device4_FWD_DEFINED__ +typedef interface ID3D12Device4 ID3D12Device4; + +#endif /* __ID3D12Device4_FWD_DEFINED__ */ + + +#ifndef __ID3D12LifetimeOwner_FWD_DEFINED__ +#define __ID3D12LifetimeOwner_FWD_DEFINED__ +typedef interface ID3D12LifetimeOwner ID3D12LifetimeOwner; + +#endif /* __ID3D12LifetimeOwner_FWD_DEFINED__ */ + + +#ifndef __ID3D12SwapChainAssistant_FWD_DEFINED__ +#define __ID3D12SwapChainAssistant_FWD_DEFINED__ +typedef interface ID3D12SwapChainAssistant ID3D12SwapChainAssistant; + +#endif /* __ID3D12SwapChainAssistant_FWD_DEFINED__ */ + + +#ifndef __ID3D12LifetimeTracker_FWD_DEFINED__ +#define __ID3D12LifetimeTracker_FWD_DEFINED__ +typedef interface ID3D12LifetimeTracker ID3D12LifetimeTracker; + +#endif /* __ID3D12LifetimeTracker_FWD_DEFINED__ */ + + +#ifndef __ID3D12StateObject_FWD_DEFINED__ +#define __ID3D12StateObject_FWD_DEFINED__ +typedef interface ID3D12StateObject ID3D12StateObject; + +#endif /* __ID3D12StateObject_FWD_DEFINED__ */ + + +#ifndef __ID3D12StateObjectProperties_FWD_DEFINED__ +#define __ID3D12StateObjectProperties_FWD_DEFINED__ +typedef interface ID3D12StateObjectProperties ID3D12StateObjectProperties; + +#endif /* __ID3D12StateObjectProperties_FWD_DEFINED__ */ + + +#ifndef __ID3D12Device5_FWD_DEFINED__ +#define __ID3D12Device5_FWD_DEFINED__ +typedef interface ID3D12Device5 ID3D12Device5; + +#endif /* __ID3D12Device5_FWD_DEFINED__ */ + + +#ifndef __ID3D12DeviceRemovedExtendedDataSettings_FWD_DEFINED__ +#define __ID3D12DeviceRemovedExtendedDataSettings_FWD_DEFINED__ +typedef interface ID3D12DeviceRemovedExtendedDataSettings ID3D12DeviceRemovedExtendedDataSettings; + +#endif /* __ID3D12DeviceRemovedExtendedDataSettings_FWD_DEFINED__ */ + + +#ifndef __ID3D12DeviceRemovedExtendedData_FWD_DEFINED__ +#define __ID3D12DeviceRemovedExtendedData_FWD_DEFINED__ +typedef interface ID3D12DeviceRemovedExtendedData ID3D12DeviceRemovedExtendedData; + +#endif /* __ID3D12DeviceRemovedExtendedData_FWD_DEFINED__ */ + + +#ifndef __ID3D12Device6_FWD_DEFINED__ +#define __ID3D12Device6_FWD_DEFINED__ +typedef interface ID3D12Device6 ID3D12Device6; + +#endif /* __ID3D12Device6_FWD_DEFINED__ */ + + +#ifndef __ID3D12Resource1_FWD_DEFINED__ +#define __ID3D12Resource1_FWD_DEFINED__ +typedef interface ID3D12Resource1 ID3D12Resource1; + +#endif /* __ID3D12Resource1_FWD_DEFINED__ */ + + +#ifndef __ID3D12Heap1_FWD_DEFINED__ +#define __ID3D12Heap1_FWD_DEFINED__ +typedef interface ID3D12Heap1 ID3D12Heap1; + +#endif /* __ID3D12Heap1_FWD_DEFINED__ */ + + +#ifndef __ID3D12GraphicsCommandList3_FWD_DEFINED__ +#define __ID3D12GraphicsCommandList3_FWD_DEFINED__ +typedef interface ID3D12GraphicsCommandList3 ID3D12GraphicsCommandList3; + +#endif /* __ID3D12GraphicsCommandList3_FWD_DEFINED__ */ + + +#ifndef __ID3D12MetaCommand_FWD_DEFINED__ +#define __ID3D12MetaCommand_FWD_DEFINED__ +typedef interface ID3D12MetaCommand ID3D12MetaCommand; + +#endif /* __ID3D12MetaCommand_FWD_DEFINED__ */ + + +#ifndef __ID3D12GraphicsCommandList4_FWD_DEFINED__ +#define __ID3D12GraphicsCommandList4_FWD_DEFINED__ +typedef interface ID3D12GraphicsCommandList4 ID3D12GraphicsCommandList4; + +#endif /* __ID3D12GraphicsCommandList4_FWD_DEFINED__ */ + + +#ifndef __ID3D12Tools_FWD_DEFINED__ +#define __ID3D12Tools_FWD_DEFINED__ +typedef interface ID3D12Tools ID3D12Tools; + +#endif /* __ID3D12Tools_FWD_DEFINED__ */ + + +#ifndef __ID3D12GraphicsCommandList5_FWD_DEFINED__ +#define __ID3D12GraphicsCommandList5_FWD_DEFINED__ +typedef interface ID3D12GraphicsCommandList5 ID3D12GraphicsCommandList5; + +#endif /* __ID3D12GraphicsCommandList5_FWD_DEFINED__ */ + + +/* header files for imported files */ +#include "oaidl.h" +#include "ocidl.h" +#include "dxgicommon.h" +#include "dxgiformat.h" +#include "d3dcommon.h" + +#ifdef __cplusplus +extern "C"{ +#endif + + +/* interface __MIDL_itf_d3d12_0000_0000 */ +/* [local] */ + +#include +#pragma region App Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) +#ifndef _D3D12_CONSTANTS +#define _D3D12_CONSTANTS +#define D3D12_16BIT_INDEX_STRIP_CUT_VALUE ( 0xffff ) + +#define D3D12_32BIT_INDEX_STRIP_CUT_VALUE ( 0xffffffff ) + +#define D3D12_8BIT_INDEX_STRIP_CUT_VALUE ( 0xff ) + +#define D3D12_APPEND_ALIGNED_ELEMENT ( 0xffffffff ) + +#define D3D12_ARRAY_AXIS_ADDRESS_RANGE_BIT_COUNT ( 9 ) + +#define D3D12_CLIP_OR_CULL_DISTANCE_COUNT ( 8 ) + +#define D3D12_CLIP_OR_CULL_DISTANCE_ELEMENT_COUNT ( 2 ) + +#define D3D12_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT ( 14 ) + +#define D3D12_COMMONSHADER_CONSTANT_BUFFER_COMPONENTS ( 4 ) + +#define D3D12_COMMONSHADER_CONSTANT_BUFFER_COMPONENT_BIT_COUNT ( 32 ) + +#define D3D12_COMMONSHADER_CONSTANT_BUFFER_HW_SLOT_COUNT ( 15 ) + +#define D3D12_COMMONSHADER_CONSTANT_BUFFER_PARTIAL_UPDATE_EXTENTS_BYTE_ALIGNMENT ( 16 ) + +#define D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COMPONENTS ( 4 ) + +#define D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COUNT ( 15 ) + +#define D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READS_PER_INST ( 1 ) + +#define D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READ_PORTS ( 1 ) + +#define D3D12_COMMONSHADER_FLOWCONTROL_NESTING_LIMIT ( 64 ) + +#define D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COMPONENTS ( 4 ) + +#define D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COUNT ( 1 ) + +#define D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READS_PER_INST ( 1 ) + +#define D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READ_PORTS ( 1 ) + +#define D3D12_COMMONSHADER_IMMEDIATE_VALUE_COMPONENT_BIT_COUNT ( 32 ) + +#define D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_COMPONENTS ( 1 ) + +#define D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_COUNT ( 128 ) + +#define D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_READS_PER_INST ( 1 ) + +#define D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_READ_PORTS ( 1 ) + +#define D3D12_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT ( 128 ) + +#define D3D12_COMMONSHADER_SAMPLER_REGISTER_COMPONENTS ( 1 ) + +#define D3D12_COMMONSHADER_SAMPLER_REGISTER_COUNT ( 16 ) + +#define D3D12_COMMONSHADER_SAMPLER_REGISTER_READS_PER_INST ( 1 ) + +#define D3D12_COMMONSHADER_SAMPLER_REGISTER_READ_PORTS ( 1 ) + +#define D3D12_COMMONSHADER_SAMPLER_SLOT_COUNT ( 16 ) + +#define D3D12_COMMONSHADER_SUBROUTINE_NESTING_LIMIT ( 32 ) + +#define D3D12_COMMONSHADER_TEMP_REGISTER_COMPONENTS ( 4 ) + +#define D3D12_COMMONSHADER_TEMP_REGISTER_COMPONENT_BIT_COUNT ( 32 ) + +#define D3D12_COMMONSHADER_TEMP_REGISTER_COUNT ( 4096 ) + +#define D3D12_COMMONSHADER_TEMP_REGISTER_READS_PER_INST ( 3 ) + +#define D3D12_COMMONSHADER_TEMP_REGISTER_READ_PORTS ( 3 ) + +#define D3D12_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MAX ( 10 ) + +#define D3D12_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MIN ( -10 ) + +#define D3D12_COMMONSHADER_TEXEL_OFFSET_MAX_NEGATIVE ( -8 ) + +#define D3D12_COMMONSHADER_TEXEL_OFFSET_MAX_POSITIVE ( 7 ) + +#define D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT ( 256 ) + +#define D3D12_CS_4_X_BUCKET00_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 256 ) + +#define D3D12_CS_4_X_BUCKET00_MAX_NUM_THREADS_PER_GROUP ( 64 ) + +#define D3D12_CS_4_X_BUCKET01_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 240 ) + +#define D3D12_CS_4_X_BUCKET01_MAX_NUM_THREADS_PER_GROUP ( 68 ) + +#define D3D12_CS_4_X_BUCKET02_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 224 ) + +#define D3D12_CS_4_X_BUCKET02_MAX_NUM_THREADS_PER_GROUP ( 72 ) + +#define D3D12_CS_4_X_BUCKET03_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 208 ) + +#define D3D12_CS_4_X_BUCKET03_MAX_NUM_THREADS_PER_GROUP ( 76 ) + +#define D3D12_CS_4_X_BUCKET04_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 192 ) + +#define D3D12_CS_4_X_BUCKET04_MAX_NUM_THREADS_PER_GROUP ( 84 ) + +#define D3D12_CS_4_X_BUCKET05_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 176 ) + +#define D3D12_CS_4_X_BUCKET05_MAX_NUM_THREADS_PER_GROUP ( 92 ) + +#define D3D12_CS_4_X_BUCKET06_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 160 ) + +#define D3D12_CS_4_X_BUCKET06_MAX_NUM_THREADS_PER_GROUP ( 100 ) + +#define D3D12_CS_4_X_BUCKET07_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 144 ) + +#define D3D12_CS_4_X_BUCKET07_MAX_NUM_THREADS_PER_GROUP ( 112 ) + +#define D3D12_CS_4_X_BUCKET08_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 128 ) + +#define D3D12_CS_4_X_BUCKET08_MAX_NUM_THREADS_PER_GROUP ( 128 ) + +#define D3D12_CS_4_X_BUCKET09_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 112 ) + +#define D3D12_CS_4_X_BUCKET09_MAX_NUM_THREADS_PER_GROUP ( 144 ) + +#define D3D12_CS_4_X_BUCKET10_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 96 ) + +#define D3D12_CS_4_X_BUCKET10_MAX_NUM_THREADS_PER_GROUP ( 168 ) + +#define D3D12_CS_4_X_BUCKET11_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 80 ) + +#define D3D12_CS_4_X_BUCKET11_MAX_NUM_THREADS_PER_GROUP ( 204 ) + +#define D3D12_CS_4_X_BUCKET12_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 64 ) + +#define D3D12_CS_4_X_BUCKET12_MAX_NUM_THREADS_PER_GROUP ( 256 ) + +#define D3D12_CS_4_X_BUCKET13_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 48 ) + +#define D3D12_CS_4_X_BUCKET13_MAX_NUM_THREADS_PER_GROUP ( 340 ) + +#define D3D12_CS_4_X_BUCKET14_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 32 ) + +#define D3D12_CS_4_X_BUCKET14_MAX_NUM_THREADS_PER_GROUP ( 512 ) + +#define D3D12_CS_4_X_BUCKET15_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 16 ) + +#define D3D12_CS_4_X_BUCKET15_MAX_NUM_THREADS_PER_GROUP ( 768 ) + +#define D3D12_CS_4_X_DISPATCH_MAX_THREAD_GROUPS_IN_Z_DIMENSION ( 1 ) + +#define D3D12_CS_4_X_RAW_UAV_BYTE_ALIGNMENT ( 256 ) + +#define D3D12_CS_4_X_THREAD_GROUP_MAX_THREADS_PER_GROUP ( 768 ) + +#define D3D12_CS_4_X_THREAD_GROUP_MAX_X ( 768 ) + +#define D3D12_CS_4_X_THREAD_GROUP_MAX_Y ( 768 ) + +#define D3D12_CS_4_X_UAV_REGISTER_COUNT ( 1 ) + +#define D3D12_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION ( 65535 ) + +#define D3D12_CS_TGSM_REGISTER_COUNT ( 8192 ) + +#define D3D12_CS_TGSM_REGISTER_READS_PER_INST ( 1 ) + +#define D3D12_CS_TGSM_RESOURCE_REGISTER_COMPONENTS ( 1 ) + +#define D3D12_CS_TGSM_RESOURCE_REGISTER_READ_PORTS ( 1 ) + +#define D3D12_CS_THREADGROUPID_REGISTER_COMPONENTS ( 3 ) + +#define D3D12_CS_THREADGROUPID_REGISTER_COUNT ( 1 ) + +#define D3D12_CS_THREADIDINGROUPFLATTENED_REGISTER_COMPONENTS ( 1 ) + +#define D3D12_CS_THREADIDINGROUPFLATTENED_REGISTER_COUNT ( 1 ) + +#define D3D12_CS_THREADIDINGROUP_REGISTER_COMPONENTS ( 3 ) + +#define D3D12_CS_THREADIDINGROUP_REGISTER_COUNT ( 1 ) + +#define D3D12_CS_THREADID_REGISTER_COMPONENTS ( 3 ) + +#define D3D12_CS_THREADID_REGISTER_COUNT ( 1 ) + +#define D3D12_CS_THREAD_GROUP_MAX_THREADS_PER_GROUP ( 1024 ) + +#define D3D12_CS_THREAD_GROUP_MAX_X ( 1024 ) + +#define D3D12_CS_THREAD_GROUP_MAX_Y ( 1024 ) + +#define D3D12_CS_THREAD_GROUP_MAX_Z ( 64 ) + +#define D3D12_CS_THREAD_GROUP_MIN_X ( 1 ) + +#define D3D12_CS_THREAD_GROUP_MIN_Y ( 1 ) + +#define D3D12_CS_THREAD_GROUP_MIN_Z ( 1 ) + +#define D3D12_CS_THREAD_LOCAL_TEMP_REGISTER_POOL ( 16384 ) + +#define D3D12_DEFAULT_BLEND_FACTOR_ALPHA ( 1.0f ) +#define D3D12_DEFAULT_BLEND_FACTOR_BLUE ( 1.0f ) +#define D3D12_DEFAULT_BLEND_FACTOR_GREEN ( 1.0f ) +#define D3D12_DEFAULT_BLEND_FACTOR_RED ( 1.0f ) +#define D3D12_DEFAULT_BORDER_COLOR_COMPONENT ( 0.0f ) +#define D3D12_DEFAULT_DEPTH_BIAS ( 0 ) + +#define D3D12_DEFAULT_DEPTH_BIAS_CLAMP ( 0.0f ) +#define D3D12_DEFAULT_MAX_ANISOTROPY ( 16 ) + +#define D3D12_DEFAULT_MIP_LOD_BIAS ( 0.0f ) +#define D3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENT ( 4194304 ) + +#define D3D12_DEFAULT_RENDER_TARGET_ARRAY_INDEX ( 0 ) + +#define D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT ( 65536 ) + +#define D3D12_DEFAULT_SAMPLE_MASK ( 0xffffffff ) + +#define D3D12_DEFAULT_SCISSOR_ENDX ( 0 ) + +#define D3D12_DEFAULT_SCISSOR_ENDY ( 0 ) + +#define D3D12_DEFAULT_SCISSOR_STARTX ( 0 ) + +#define D3D12_DEFAULT_SCISSOR_STARTY ( 0 ) + +#define D3D12_DEFAULT_SLOPE_SCALED_DEPTH_BIAS ( 0.0f ) +#define D3D12_DEFAULT_STENCIL_READ_MASK ( 0xff ) + +#define D3D12_DEFAULT_STENCIL_REFERENCE ( 0 ) + +#define D3D12_DEFAULT_STENCIL_WRITE_MASK ( 0xff ) + +#define D3D12_DEFAULT_VIEWPORT_AND_SCISSORRECT_INDEX ( 0 ) + +#define D3D12_DEFAULT_VIEWPORT_HEIGHT ( 0 ) + +#define D3D12_DEFAULT_VIEWPORT_MAX_DEPTH ( 0.0f ) +#define D3D12_DEFAULT_VIEWPORT_MIN_DEPTH ( 0.0f ) +#define D3D12_DEFAULT_VIEWPORT_TOPLEFTX ( 0 ) + +#define D3D12_DEFAULT_VIEWPORT_TOPLEFTY ( 0 ) + +#define D3D12_DEFAULT_VIEWPORT_WIDTH ( 0 ) + +#define D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND ( 0xffffffff ) + +#define D3D12_DRIVER_RESERVED_REGISTER_SPACE_VALUES_END ( 0xfffffff7 ) + +#define D3D12_DRIVER_RESERVED_REGISTER_SPACE_VALUES_START ( 0xfffffff0 ) + +#define D3D12_DS_INPUT_CONTROL_POINTS_MAX_TOTAL_SCALARS ( 3968 ) + +#define D3D12_DS_INPUT_CONTROL_POINT_REGISTER_COMPONENTS ( 4 ) + +#define D3D12_DS_INPUT_CONTROL_POINT_REGISTER_COMPONENT_BIT_COUNT ( 32 ) + +#define D3D12_DS_INPUT_CONTROL_POINT_REGISTER_COUNT ( 32 ) + +#define D3D12_DS_INPUT_CONTROL_POINT_REGISTER_READS_PER_INST ( 2 ) + +#define D3D12_DS_INPUT_CONTROL_POINT_REGISTER_READ_PORTS ( 1 ) + +#define D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_COMPONENTS ( 3 ) + +#define D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_COMPONENT_BIT_COUNT ( 32 ) + +#define D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_COUNT ( 1 ) + +#define D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_READS_PER_INST ( 2 ) + +#define D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_READ_PORTS ( 1 ) + +#define D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_COMPONENTS ( 4 ) + +#define D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_COMPONENT_BIT_COUNT ( 32 ) + +#define D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_COUNT ( 32 ) + +#define D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_READS_PER_INST ( 2 ) + +#define D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_READ_PORTS ( 1 ) + +#define D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENTS ( 1 ) + +#define D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENT_BIT_COUNT ( 32 ) + +#define D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_COUNT ( 1 ) + +#define D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_READS_PER_INST ( 2 ) + +#define D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_READ_PORTS ( 1 ) + +#define D3D12_DS_OUTPUT_REGISTER_COMPONENTS ( 4 ) + +#define D3D12_DS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT ( 32 ) + +#define D3D12_DS_OUTPUT_REGISTER_COUNT ( 32 ) + +#define D3D12_FLOAT16_FUSED_TOLERANCE_IN_ULP ( 0.6 ) +#define D3D12_FLOAT32_MAX ( 3.402823466e+38f ) +#define D3D12_FLOAT32_TO_INTEGER_TOLERANCE_IN_ULP ( 0.6f ) +#define D3D12_FLOAT_TO_SRGB_EXPONENT_DENOMINATOR ( 2.4f ) +#define D3D12_FLOAT_TO_SRGB_EXPONENT_NUMERATOR ( 1.0f ) +#define D3D12_FLOAT_TO_SRGB_OFFSET ( 0.055f ) +#define D3D12_FLOAT_TO_SRGB_SCALE_1 ( 12.92f ) +#define D3D12_FLOAT_TO_SRGB_SCALE_2 ( 1.055f ) +#define D3D12_FLOAT_TO_SRGB_THRESHOLD ( 0.0031308f ) +#define D3D12_FTOI_INSTRUCTION_MAX_INPUT ( 2147483647.999f ) +#define D3D12_FTOI_INSTRUCTION_MIN_INPUT ( -2147483648.999f ) +#define D3D12_FTOU_INSTRUCTION_MAX_INPUT ( 4294967295.999f ) +#define D3D12_FTOU_INSTRUCTION_MIN_INPUT ( 0.0f ) +#define D3D12_GS_INPUT_INSTANCE_ID_READS_PER_INST ( 2 ) + +#define D3D12_GS_INPUT_INSTANCE_ID_READ_PORTS ( 1 ) + +#define D3D12_GS_INPUT_INSTANCE_ID_REGISTER_COMPONENTS ( 1 ) + +#define D3D12_GS_INPUT_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNT ( 32 ) + +#define D3D12_GS_INPUT_INSTANCE_ID_REGISTER_COUNT ( 1 ) + +#define D3D12_GS_INPUT_PRIM_CONST_REGISTER_COMPONENTS ( 1 ) + +#define D3D12_GS_INPUT_PRIM_CONST_REGISTER_COMPONENT_BIT_COUNT ( 32 ) + +#define D3D12_GS_INPUT_PRIM_CONST_REGISTER_COUNT ( 1 ) + +#define D3D12_GS_INPUT_PRIM_CONST_REGISTER_READS_PER_INST ( 2 ) + +#define D3D12_GS_INPUT_PRIM_CONST_REGISTER_READ_PORTS ( 1 ) + +#define D3D12_GS_INPUT_REGISTER_COMPONENTS ( 4 ) + +#define D3D12_GS_INPUT_REGISTER_COMPONENT_BIT_COUNT ( 32 ) + +#define D3D12_GS_INPUT_REGISTER_COUNT ( 32 ) + +#define D3D12_GS_INPUT_REGISTER_READS_PER_INST ( 2 ) + +#define D3D12_GS_INPUT_REGISTER_READ_PORTS ( 1 ) + +#define D3D12_GS_INPUT_REGISTER_VERTICES ( 32 ) + +#define D3D12_GS_MAX_INSTANCE_COUNT ( 32 ) + +#define D3D12_GS_MAX_OUTPUT_VERTEX_COUNT_ACROSS_INSTANCES ( 1024 ) + +#define D3D12_GS_OUTPUT_ELEMENTS ( 32 ) + +#define D3D12_GS_OUTPUT_REGISTER_COMPONENTS ( 4 ) + +#define D3D12_GS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT ( 32 ) + +#define D3D12_GS_OUTPUT_REGISTER_COUNT ( 32 ) + +#define D3D12_HS_CONTROL_POINT_PHASE_INPUT_REGISTER_COUNT ( 32 ) + +#define D3D12_HS_CONTROL_POINT_PHASE_OUTPUT_REGISTER_COUNT ( 32 ) + +#define D3D12_HS_CONTROL_POINT_REGISTER_COMPONENTS ( 4 ) + +#define D3D12_HS_CONTROL_POINT_REGISTER_COMPONENT_BIT_COUNT ( 32 ) + +#define D3D12_HS_CONTROL_POINT_REGISTER_READS_PER_INST ( 2 ) + +#define D3D12_HS_CONTROL_POINT_REGISTER_READ_PORTS ( 1 ) + +#define D3D12_HS_FORK_PHASE_INSTANCE_COUNT_UPPER_BOUND ( 0xffffffff ) + +#define D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COMPONENTS ( 1 ) + +#define D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNT ( 32 ) + +#define D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COUNT ( 1 ) + +#define D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_READS_PER_INST ( 2 ) + +#define D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_READ_PORTS ( 1 ) + +#define D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COMPONENTS ( 1 ) + +#define D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNT ( 32 ) + +#define D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COUNT ( 1 ) + +#define D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_READS_PER_INST ( 2 ) + +#define D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_READ_PORTS ( 1 ) + +#define D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENTS ( 1 ) + +#define D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENT_BIT_COUNT ( 32 ) + +#define D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_COUNT ( 1 ) + +#define D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_READS_PER_INST ( 2 ) + +#define D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_READ_PORTS ( 1 ) + +#define D3D12_HS_JOIN_PHASE_INSTANCE_COUNT_UPPER_BOUND ( 0xffffffff ) + +#define D3D12_HS_MAXTESSFACTOR_LOWER_BOUND ( 1.0f ) +#define D3D12_HS_MAXTESSFACTOR_UPPER_BOUND ( 64.0f ) +#define D3D12_HS_OUTPUT_CONTROL_POINTS_MAX_TOTAL_SCALARS ( 3968 ) + +#define D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COMPONENTS ( 1 ) + +#define D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COMPONENT_BIT_COUNT ( 32 ) + +#define D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COUNT ( 1 ) + +#define D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_READS_PER_INST ( 2 ) + +#define D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_READ_PORTS ( 1 ) + +#define D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COMPONENTS ( 4 ) + +#define D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COMPONENT_BIT_COUNT ( 32 ) + +#define D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COUNT ( 32 ) + +#define D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_READS_PER_INST ( 2 ) + +#define D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_READ_PORTS ( 1 ) + +#define D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_SCALAR_COMPONENTS ( 128 ) + +#define D3D12_IA_DEFAULT_INDEX_BUFFER_OFFSET_IN_BYTES ( 0 ) + +#define D3D12_IA_DEFAULT_PRIMITIVE_TOPOLOGY ( 0 ) + +#define D3D12_IA_DEFAULT_VERTEX_BUFFER_OFFSET_IN_BYTES ( 0 ) + +#define D3D12_IA_INDEX_INPUT_RESOURCE_SLOT_COUNT ( 1 ) + +#define D3D12_IA_INSTANCE_ID_BIT_COUNT ( 32 ) + +#define D3D12_IA_INTEGER_ARITHMETIC_BIT_COUNT ( 32 ) + +#define D3D12_IA_PATCH_MAX_CONTROL_POINT_COUNT ( 32 ) + +#define D3D12_IA_PRIMITIVE_ID_BIT_COUNT ( 32 ) + +#define D3D12_IA_VERTEX_ID_BIT_COUNT ( 32 ) + +#define D3D12_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT ( 32 ) + +#define D3D12_IA_VERTEX_INPUT_STRUCTURE_ELEMENTS_COMPONENTS ( 128 ) + +#define D3D12_IA_VERTEX_INPUT_STRUCTURE_ELEMENT_COUNT ( 32 ) + +#define D3D12_INTEGER_DIVIDE_BY_ZERO_QUOTIENT ( 0xffffffff ) + +#define D3D12_INTEGER_DIVIDE_BY_ZERO_REMAINDER ( 0xffffffff ) + +#define D3D12_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL ( 0xffffffff ) + +#define D3D12_KEEP_UNORDERED_ACCESS_VIEWS ( 0xffffffff ) + +#define D3D12_LINEAR_GAMMA ( 1.0f ) +#define D3D12_MAJOR_VERSION ( 12 ) + +#define D3D12_MAX_BORDER_COLOR_COMPONENT ( 1.0f ) +#define D3D12_MAX_DEPTH ( 1.0f ) +#define D3D12_MAX_LIVE_STATIC_SAMPLERS ( 2032 ) + +#define D3D12_MAX_MAXANISOTROPY ( 16 ) + +#define D3D12_MAX_MULTISAMPLE_SAMPLE_COUNT ( 32 ) + +#define D3D12_MAX_POSITION_VALUE ( 3.402823466e+34f ) +#define D3D12_MAX_ROOT_COST ( 64 ) + +#define D3D12_MAX_SHADER_VISIBLE_DESCRIPTOR_HEAP_SIZE_TIER_1 ( 1000000 ) + +#define D3D12_MAX_SHADER_VISIBLE_DESCRIPTOR_HEAP_SIZE_TIER_2 ( 1000000 ) + +#define D3D12_MAX_SHADER_VISIBLE_SAMPLER_HEAP_SIZE ( 2048 ) + +#define D3D12_MAX_TEXTURE_DIMENSION_2_TO_EXP ( 17 ) + +#define D3D12_MAX_VIEW_INSTANCE_COUNT ( 4 ) + +#define D3D12_MINOR_VERSION ( 0 ) + +#define D3D12_MIN_BORDER_COLOR_COMPONENT ( 0.0f ) +#define D3D12_MIN_DEPTH ( 0.0f ) +#define D3D12_MIN_MAXANISOTROPY ( 0 ) + +#define D3D12_MIP_LOD_BIAS_MAX ( 15.99f ) +#define D3D12_MIP_LOD_BIAS_MIN ( -16.0f ) +#define D3D12_MIP_LOD_FRACTIONAL_BIT_COUNT ( 8 ) + +#define D3D12_MIP_LOD_RANGE_BIT_COUNT ( 8 ) + +#define D3D12_MULTISAMPLE_ANTIALIAS_LINE_WIDTH ( 1.4f ) +#define D3D12_NONSAMPLE_FETCH_OUT_OF_RANGE_ACCESS_RESULT ( 0 ) + +#define D3D12_OS_RESERVED_REGISTER_SPACE_VALUES_END ( 0xffffffff ) + +#define D3D12_OS_RESERVED_REGISTER_SPACE_VALUES_START ( 0xfffffff8 ) + +#define D3D12_PACKED_TILE ( 0xffffffff ) + +#define D3D12_PIXEL_ADDRESS_RANGE_BIT_COUNT ( 15 ) + +#define D3D12_PRE_SCISSOR_PIXEL_ADDRESS_RANGE_BIT_COUNT ( 16 ) + +#define D3D12_PS_CS_UAV_REGISTER_COMPONENTS ( 1 ) + +#define D3D12_PS_CS_UAV_REGISTER_COUNT ( 8 ) + +#define D3D12_PS_CS_UAV_REGISTER_READS_PER_INST ( 1 ) + +#define D3D12_PS_CS_UAV_REGISTER_READ_PORTS ( 1 ) + +#define D3D12_PS_FRONTFACING_DEFAULT_VALUE ( 0xffffffff ) + +#define D3D12_PS_FRONTFACING_FALSE_VALUE ( 0 ) + +#define D3D12_PS_FRONTFACING_TRUE_VALUE ( 0xffffffff ) + +#define D3D12_PS_INPUT_REGISTER_COMPONENTS ( 4 ) + +#define D3D12_PS_INPUT_REGISTER_COMPONENT_BIT_COUNT ( 32 ) + +#define D3D12_PS_INPUT_REGISTER_COUNT ( 32 ) + +#define D3D12_PS_INPUT_REGISTER_READS_PER_INST ( 2 ) + +#define D3D12_PS_INPUT_REGISTER_READ_PORTS ( 1 ) + +#define D3D12_PS_LEGACY_PIXEL_CENTER_FRACTIONAL_COMPONENT ( 0.0f ) +#define D3D12_PS_OUTPUT_DEPTH_REGISTER_COMPONENTS ( 1 ) + +#define D3D12_PS_OUTPUT_DEPTH_REGISTER_COMPONENT_BIT_COUNT ( 32 ) + +#define D3D12_PS_OUTPUT_DEPTH_REGISTER_COUNT ( 1 ) + +#define D3D12_PS_OUTPUT_MASK_REGISTER_COMPONENTS ( 1 ) + +#define D3D12_PS_OUTPUT_MASK_REGISTER_COMPONENT_BIT_COUNT ( 32 ) + +#define D3D12_PS_OUTPUT_MASK_REGISTER_COUNT ( 1 ) + +#define D3D12_PS_OUTPUT_REGISTER_COMPONENTS ( 4 ) + +#define D3D12_PS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT ( 32 ) + +#define D3D12_PS_OUTPUT_REGISTER_COUNT ( 8 ) + +#define D3D12_PS_PIXEL_CENTER_FRACTIONAL_COMPONENT ( 0.5f ) +#define D3D12_RAW_UAV_SRV_BYTE_ALIGNMENT ( 16 ) + +#define D3D12_RAYTRACING_AABB_BYTE_ALIGNMENT ( 8 ) + +#define D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BYTE_ALIGNMENT ( 256 ) + +#define D3D12_RAYTRACING_INSTANCE_DESCS_BYTE_ALIGNMENT ( 16 ) + +#define D3D12_RAYTRACING_MAX_ATTRIBUTE_SIZE_IN_BYTES ( 32 ) + +#define D3D12_RAYTRACING_MAX_DECLARABLE_TRACE_RECURSION_DEPTH ( 31 ) + +#define D3D12_RAYTRACING_MAX_GEOMETRIES_PER_BOTTOM_LEVEL_ACCELERATION_STRUCTURE ( 16777216 ) + +#define D3D12_RAYTRACING_MAX_INSTANCES_PER_TOP_LEVEL_ACCELERATION_STRUCTURE ( 16777216 ) + +#define D3D12_RAYTRACING_MAX_PRIMITIVES_PER_BOTTOM_LEVEL_ACCELERATION_STRUCTURE ( 536870912 ) + +#define D3D12_RAYTRACING_MAX_RAY_GENERATION_SHADER_THREADS ( 1073741824 ) + +#define D3D12_RAYTRACING_MAX_SHADER_RECORD_STRIDE ( 4096 ) + +#define D3D12_RAYTRACING_SHADER_RECORD_BYTE_ALIGNMENT ( 32 ) + +#define D3D12_RAYTRACING_SHADER_TABLE_BYTE_ALIGNMENT ( 64 ) + +#define D3D12_RAYTRACING_TRANSFORM3X4_BYTE_ALIGNMENT ( 16 ) + +#define D3D12_REQ_BLEND_OBJECT_COUNT_PER_DEVICE ( 4096 ) + +#define D3D12_REQ_BUFFER_RESOURCE_TEXEL_COUNT_2_TO_EXP ( 27 ) + +#define D3D12_REQ_CONSTANT_BUFFER_ELEMENT_COUNT ( 4096 ) + +#define D3D12_REQ_DEPTH_STENCIL_OBJECT_COUNT_PER_DEVICE ( 4096 ) + +#define D3D12_REQ_DRAWINDEXED_INDEX_COUNT_2_TO_EXP ( 32 ) + +#define D3D12_REQ_DRAW_VERTEX_COUNT_2_TO_EXP ( 32 ) + +#define D3D12_REQ_FILTERING_HW_ADDRESSABLE_RESOURCE_DIMENSION ( 16384 ) + +#define D3D12_REQ_GS_INVOCATION_32BIT_OUTPUT_COMPONENT_LIMIT ( 1024 ) + +#define D3D12_REQ_IMMEDIATE_CONSTANT_BUFFER_ELEMENT_COUNT ( 4096 ) + +#define D3D12_REQ_MAXANISOTROPY ( 16 ) + +#define D3D12_REQ_MIP_LEVELS ( 15 ) + +#define D3D12_REQ_MULTI_ELEMENT_STRUCTURE_SIZE_IN_BYTES ( 2048 ) + +#define D3D12_REQ_RASTERIZER_OBJECT_COUNT_PER_DEVICE ( 4096 ) + +#define D3D12_REQ_RENDER_TO_BUFFER_WINDOW_WIDTH ( 16384 ) + +#define D3D12_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_A_TERM ( 128 ) + +#define D3D12_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_B_TERM ( 0.25f ) +#define D3D12_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_C_TERM ( 2048 ) + +#define D3D12_REQ_RESOURCE_VIEW_COUNT_PER_DEVICE_2_TO_EXP ( 20 ) + +#define D3D12_REQ_SAMPLER_OBJECT_COUNT_PER_DEVICE ( 4096 ) + +#define D3D12_REQ_SUBRESOURCES ( 30720 ) + +#define D3D12_REQ_TEXTURE1D_ARRAY_AXIS_DIMENSION ( 2048 ) + +#define D3D12_REQ_TEXTURE1D_U_DIMENSION ( 16384 ) + +#define D3D12_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION ( 2048 ) + +#define D3D12_REQ_TEXTURE2D_U_OR_V_DIMENSION ( 16384 ) + +#define D3D12_REQ_TEXTURE3D_U_V_OR_W_DIMENSION ( 2048 ) + +#define D3D12_REQ_TEXTURECUBE_DIMENSION ( 16384 ) + +#define D3D12_RESINFO_INSTRUCTION_MISSING_COMPONENT_RETVAL ( 0 ) + +#define D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES ( 0xffffffff ) + +#define D3D12_RS_SET_SHADING_RATE_COMBINER_COUNT ( 2 ) + +#define D3D12_SHADER_IDENTIFIER_SIZE_IN_BYTES ( 32 ) + +#define D3D12_SHADER_MAJOR_VERSION ( 5 ) + +#define D3D12_SHADER_MAX_INSTANCES ( 65535 ) + +#define D3D12_SHADER_MAX_INTERFACES ( 253 ) + +#define D3D12_SHADER_MAX_INTERFACE_CALL_SITES ( 4096 ) + +#define D3D12_SHADER_MAX_TYPES ( 65535 ) + +#define D3D12_SHADER_MINOR_VERSION ( 1 ) + +#define D3D12_SHIFT_INSTRUCTION_PAD_VALUE ( 0 ) + +#define D3D12_SHIFT_INSTRUCTION_SHIFT_VALUE_BIT_COUNT ( 5 ) + +#define D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT ( 8 ) + +#define D3D12_SMALL_MSAA_RESOURCE_PLACEMENT_ALIGNMENT ( 65536 ) + +#define D3D12_SMALL_RESOURCE_PLACEMENT_ALIGNMENT ( 4096 ) + +#define D3D12_SO_BUFFER_MAX_STRIDE_IN_BYTES ( 2048 ) + +#define D3D12_SO_BUFFER_MAX_WRITE_WINDOW_IN_BYTES ( 512 ) + +#define D3D12_SO_BUFFER_SLOT_COUNT ( 4 ) + +#define D3D12_SO_DDI_REGISTER_INDEX_DENOTING_GAP ( 0xffffffff ) + +#define D3D12_SO_NO_RASTERIZED_STREAM ( 0xffffffff ) + +#define D3D12_SO_OUTPUT_COMPONENT_COUNT ( 128 ) + +#define D3D12_SO_STREAM_COUNT ( 4 ) + +#define D3D12_SPEC_DATE_DAY ( 14 ) + +#define D3D12_SPEC_DATE_MONTH ( 11 ) + +#define D3D12_SPEC_DATE_YEAR ( 2014 ) + +#define D3D12_SPEC_VERSION ( 1.16 ) +#define D3D12_SRGB_GAMMA ( 2.2f ) +#define D3D12_SRGB_TO_FLOAT_DENOMINATOR_1 ( 12.92f ) +#define D3D12_SRGB_TO_FLOAT_DENOMINATOR_2 ( 1.055f ) +#define D3D12_SRGB_TO_FLOAT_EXPONENT ( 2.4f ) +#define D3D12_SRGB_TO_FLOAT_OFFSET ( 0.055f ) +#define D3D12_SRGB_TO_FLOAT_THRESHOLD ( 0.04045f ) +#define D3D12_SRGB_TO_FLOAT_TOLERANCE_IN_ULP ( 0.5f ) +#define D3D12_STANDARD_COMPONENT_BIT_COUNT ( 32 ) + +#define D3D12_STANDARD_COMPONENT_BIT_COUNT_DOUBLED ( 64 ) + +#define D3D12_STANDARD_MAXIMUM_ELEMENT_ALIGNMENT_BYTE_MULTIPLE ( 4 ) + +#define D3D12_STANDARD_PIXEL_COMPONENT_COUNT ( 128 ) + +#define D3D12_STANDARD_PIXEL_ELEMENT_COUNT ( 32 ) + +#define D3D12_STANDARD_VECTOR_SIZE ( 4 ) + +#define D3D12_STANDARD_VERTEX_ELEMENT_COUNT ( 32 ) + +#define D3D12_STANDARD_VERTEX_TOTAL_COMPONENT_COUNT ( 64 ) + +#define D3D12_SUBPIXEL_FRACTIONAL_BIT_COUNT ( 8 ) + +#define D3D12_SUBTEXEL_FRACTIONAL_BIT_COUNT ( 8 ) + +#define D3D12_SYSTEM_RESERVED_REGISTER_SPACE_VALUES_END ( 0xffffffff ) + +#define D3D12_SYSTEM_RESERVED_REGISTER_SPACE_VALUES_START ( 0xfffffff0 ) + +#define D3D12_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR ( 64 ) + +#define D3D12_TESSELLATOR_MAX_ISOLINE_DENSITY_TESSELLATION_FACTOR ( 64 ) + +#define D3D12_TESSELLATOR_MAX_ODD_TESSELLATION_FACTOR ( 63 ) + +#define D3D12_TESSELLATOR_MAX_TESSELLATION_FACTOR ( 64 ) + +#define D3D12_TESSELLATOR_MIN_EVEN_TESSELLATION_FACTOR ( 2 ) + +#define D3D12_TESSELLATOR_MIN_ISOLINE_DENSITY_TESSELLATION_FACTOR ( 1 ) + +#define D3D12_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR ( 1 ) + +#define D3D12_TEXEL_ADDRESS_RANGE_BIT_COUNT ( 16 ) + +#define D3D12_TEXTURE_DATA_PITCH_ALIGNMENT ( 256 ) + +#define D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT ( 512 ) + +#define D3D12_TILED_RESOURCE_TILE_SIZE_IN_BYTES ( 65536 ) + +#define D3D12_TRACKED_WORKLOAD_MAX_INSTANCES ( 32 ) + +#define D3D12_UAV_COUNTER_PLACEMENT_ALIGNMENT ( 4096 ) + +#define D3D12_UAV_SLOT_COUNT ( 64 ) + +#define D3D12_UNBOUND_MEMORY_ACCESS_RESULT ( 0 ) + +#define D3D12_VIDEO_DECODE_MAX_ARGUMENTS ( 10 ) + +#define D3D12_VIDEO_DECODE_MAX_HISTOGRAM_COMPONENTS ( 4 ) + +#define D3D12_VIDEO_DECODE_MIN_BITSTREAM_OFFSET_ALIGNMENT ( 256 ) + +#define D3D12_VIDEO_DECODE_MIN_HISTOGRAM_OFFSET_ALIGNMENT ( 256 ) + +#define D3D12_VIDEO_DECODE_STATUS_MACROBLOCKS_AFFECTED_UNKNOWN ( 0xffffffff ) + +#define D3D12_VIDEO_PROCESS_MAX_FILTERS ( 32 ) + +#define D3D12_VIDEO_PROCESS_STEREO_VIEWS ( 2 ) + +#define D3D12_VIEWPORT_AND_SCISSORRECT_MAX_INDEX ( 15 ) + +#define D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE ( 16 ) + +#define D3D12_VIEWPORT_BOUNDS_MAX ( 32767 ) + +#define D3D12_VIEWPORT_BOUNDS_MIN ( -32768 ) + +#define D3D12_VS_INPUT_REGISTER_COMPONENTS ( 4 ) + +#define D3D12_VS_INPUT_REGISTER_COMPONENT_BIT_COUNT ( 32 ) + +#define D3D12_VS_INPUT_REGISTER_COUNT ( 32 ) + +#define D3D12_VS_INPUT_REGISTER_READS_PER_INST ( 2 ) + +#define D3D12_VS_INPUT_REGISTER_READ_PORTS ( 1 ) + +#define D3D12_VS_OUTPUT_REGISTER_COMPONENTS ( 4 ) + +#define D3D12_VS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT ( 32 ) + +#define D3D12_VS_OUTPUT_REGISTER_COUNT ( 32 ) + +#define D3D12_WHQL_CONTEXT_COUNT_FOR_RESOURCE_LIMIT ( 10 ) + +#define D3D12_WHQL_DRAWINDEXED_INDEX_COUNT_2_TO_EXP ( 25 ) + +#define D3D12_WHQL_DRAW_VERTEX_COUNT_2_TO_EXP ( 25 ) + +#endif + +typedef UINT64 D3D12_GPU_VIRTUAL_ADDRESS; + +typedef +enum D3D12_COMMAND_LIST_TYPE + { + D3D12_COMMAND_LIST_TYPE_DIRECT = 0, + D3D12_COMMAND_LIST_TYPE_BUNDLE = 1, + D3D12_COMMAND_LIST_TYPE_COMPUTE = 2, + D3D12_COMMAND_LIST_TYPE_COPY = 3, + D3D12_COMMAND_LIST_TYPE_VIDEO_DECODE = 4, + D3D12_COMMAND_LIST_TYPE_VIDEO_PROCESS = 5, + D3D12_COMMAND_LIST_TYPE_VIDEO_ENCODE = 6 + } D3D12_COMMAND_LIST_TYPE; + +typedef +enum D3D12_COMMAND_QUEUE_FLAGS + { + D3D12_COMMAND_QUEUE_FLAG_NONE = 0, + D3D12_COMMAND_QUEUE_FLAG_DISABLE_GPU_TIMEOUT = 0x1 + } D3D12_COMMAND_QUEUE_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_QUEUE_FLAGS ); +typedef +enum D3D12_COMMAND_QUEUE_PRIORITY + { + D3D12_COMMAND_QUEUE_PRIORITY_NORMAL = 0, + D3D12_COMMAND_QUEUE_PRIORITY_HIGH = 100, + D3D12_COMMAND_QUEUE_PRIORITY_GLOBAL_REALTIME = 10000 + } D3D12_COMMAND_QUEUE_PRIORITY; + +typedef struct D3D12_COMMAND_QUEUE_DESC + { + D3D12_COMMAND_LIST_TYPE Type; + INT Priority; + D3D12_COMMAND_QUEUE_FLAGS Flags; + UINT NodeMask; + } D3D12_COMMAND_QUEUE_DESC; + +typedef +enum D3D12_PRIMITIVE_TOPOLOGY_TYPE + { + D3D12_PRIMITIVE_TOPOLOGY_TYPE_UNDEFINED = 0, + D3D12_PRIMITIVE_TOPOLOGY_TYPE_POINT = 1, + D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE = 2, + D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE = 3, + D3D12_PRIMITIVE_TOPOLOGY_TYPE_PATCH = 4 + } D3D12_PRIMITIVE_TOPOLOGY_TYPE; + +typedef +enum D3D12_INPUT_CLASSIFICATION + { + D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA = 0, + D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA = 1 + } D3D12_INPUT_CLASSIFICATION; + +typedef struct D3D12_INPUT_ELEMENT_DESC + { + LPCSTR SemanticName; + UINT SemanticIndex; + DXGI_FORMAT Format; + UINT InputSlot; + UINT AlignedByteOffset; + D3D12_INPUT_CLASSIFICATION InputSlotClass; + UINT InstanceDataStepRate; + } D3D12_INPUT_ELEMENT_DESC; + +typedef +enum D3D12_FILL_MODE + { + D3D12_FILL_MODE_WIREFRAME = 2, + D3D12_FILL_MODE_SOLID = 3 + } D3D12_FILL_MODE; + +typedef D3D_PRIMITIVE_TOPOLOGY D3D12_PRIMITIVE_TOPOLOGY; + +typedef D3D_PRIMITIVE D3D12_PRIMITIVE; + +typedef +enum D3D12_CULL_MODE + { + D3D12_CULL_MODE_NONE = 1, + D3D12_CULL_MODE_FRONT = 2, + D3D12_CULL_MODE_BACK = 3 + } D3D12_CULL_MODE; + +typedef struct D3D12_SO_DECLARATION_ENTRY + { + UINT Stream; + LPCSTR SemanticName; + UINT SemanticIndex; + BYTE StartComponent; + BYTE ComponentCount; + BYTE OutputSlot; + } D3D12_SO_DECLARATION_ENTRY; + +typedef struct D3D12_VIEWPORT + { + FLOAT TopLeftX; + FLOAT TopLeftY; + FLOAT Width; + FLOAT Height; + FLOAT MinDepth; + FLOAT MaxDepth; + } D3D12_VIEWPORT; + +typedef RECT D3D12_RECT; + +typedef struct D3D12_BOX + { + UINT left; + UINT top; + UINT front; + UINT right; + UINT bottom; + UINT back; + } D3D12_BOX; + +typedef +enum D3D12_COMPARISON_FUNC + { + D3D12_COMPARISON_FUNC_NEVER = 1, + D3D12_COMPARISON_FUNC_LESS = 2, + D3D12_COMPARISON_FUNC_EQUAL = 3, + D3D12_COMPARISON_FUNC_LESS_EQUAL = 4, + D3D12_COMPARISON_FUNC_GREATER = 5, + D3D12_COMPARISON_FUNC_NOT_EQUAL = 6, + D3D12_COMPARISON_FUNC_GREATER_EQUAL = 7, + D3D12_COMPARISON_FUNC_ALWAYS = 8 + } D3D12_COMPARISON_FUNC; + +typedef +enum D3D12_DEPTH_WRITE_MASK + { + D3D12_DEPTH_WRITE_MASK_ZERO = 0, + D3D12_DEPTH_WRITE_MASK_ALL = 1 + } D3D12_DEPTH_WRITE_MASK; + +typedef +enum D3D12_STENCIL_OP + { + D3D12_STENCIL_OP_KEEP = 1, + D3D12_STENCIL_OP_ZERO = 2, + D3D12_STENCIL_OP_REPLACE = 3, + D3D12_STENCIL_OP_INCR_SAT = 4, + D3D12_STENCIL_OP_DECR_SAT = 5, + D3D12_STENCIL_OP_INVERT = 6, + D3D12_STENCIL_OP_INCR = 7, + D3D12_STENCIL_OP_DECR = 8 + } D3D12_STENCIL_OP; + +typedef struct D3D12_DEPTH_STENCILOP_DESC + { + D3D12_STENCIL_OP StencilFailOp; + D3D12_STENCIL_OP StencilDepthFailOp; + D3D12_STENCIL_OP StencilPassOp; + D3D12_COMPARISON_FUNC StencilFunc; + } D3D12_DEPTH_STENCILOP_DESC; + +typedef struct D3D12_DEPTH_STENCIL_DESC + { + BOOL DepthEnable; + D3D12_DEPTH_WRITE_MASK DepthWriteMask; + D3D12_COMPARISON_FUNC DepthFunc; + BOOL StencilEnable; + UINT8 StencilReadMask; + UINT8 StencilWriteMask; + D3D12_DEPTH_STENCILOP_DESC FrontFace; + D3D12_DEPTH_STENCILOP_DESC BackFace; + } D3D12_DEPTH_STENCIL_DESC; + +typedef struct D3D12_DEPTH_STENCIL_DESC1 + { + BOOL DepthEnable; + D3D12_DEPTH_WRITE_MASK DepthWriteMask; + D3D12_COMPARISON_FUNC DepthFunc; + BOOL StencilEnable; + UINT8 StencilReadMask; + UINT8 StencilWriteMask; + D3D12_DEPTH_STENCILOP_DESC FrontFace; + D3D12_DEPTH_STENCILOP_DESC BackFace; + BOOL DepthBoundsTestEnable; + } D3D12_DEPTH_STENCIL_DESC1; + +typedef +enum D3D12_BLEND + { + D3D12_BLEND_ZERO = 1, + D3D12_BLEND_ONE = 2, + D3D12_BLEND_SRC_COLOR = 3, + D3D12_BLEND_INV_SRC_COLOR = 4, + D3D12_BLEND_SRC_ALPHA = 5, + D3D12_BLEND_INV_SRC_ALPHA = 6, + D3D12_BLEND_DEST_ALPHA = 7, + D3D12_BLEND_INV_DEST_ALPHA = 8, + D3D12_BLEND_DEST_COLOR = 9, + D3D12_BLEND_INV_DEST_COLOR = 10, + D3D12_BLEND_SRC_ALPHA_SAT = 11, + D3D12_BLEND_BLEND_FACTOR = 14, + D3D12_BLEND_INV_BLEND_FACTOR = 15, + D3D12_BLEND_SRC1_COLOR = 16, + D3D12_BLEND_INV_SRC1_COLOR = 17, + D3D12_BLEND_SRC1_ALPHA = 18, + D3D12_BLEND_INV_SRC1_ALPHA = 19 + } D3D12_BLEND; + +typedef +enum D3D12_BLEND_OP + { + D3D12_BLEND_OP_ADD = 1, + D3D12_BLEND_OP_SUBTRACT = 2, + D3D12_BLEND_OP_REV_SUBTRACT = 3, + D3D12_BLEND_OP_MIN = 4, + D3D12_BLEND_OP_MAX = 5 + } D3D12_BLEND_OP; + +typedef +enum D3D12_COLOR_WRITE_ENABLE + { + D3D12_COLOR_WRITE_ENABLE_RED = 1, + D3D12_COLOR_WRITE_ENABLE_GREEN = 2, + D3D12_COLOR_WRITE_ENABLE_BLUE = 4, + D3D12_COLOR_WRITE_ENABLE_ALPHA = 8, + D3D12_COLOR_WRITE_ENABLE_ALL = ( ( ( D3D12_COLOR_WRITE_ENABLE_RED | D3D12_COLOR_WRITE_ENABLE_GREEN ) | D3D12_COLOR_WRITE_ENABLE_BLUE ) | D3D12_COLOR_WRITE_ENABLE_ALPHA ) + } D3D12_COLOR_WRITE_ENABLE; + +typedef +enum D3D12_LOGIC_OP + { + D3D12_LOGIC_OP_CLEAR = 0, + D3D12_LOGIC_OP_SET = ( D3D12_LOGIC_OP_CLEAR + 1 ) , + D3D12_LOGIC_OP_COPY = ( D3D12_LOGIC_OP_SET + 1 ) , + D3D12_LOGIC_OP_COPY_INVERTED = ( D3D12_LOGIC_OP_COPY + 1 ) , + D3D12_LOGIC_OP_NOOP = ( D3D12_LOGIC_OP_COPY_INVERTED + 1 ) , + D3D12_LOGIC_OP_INVERT = ( D3D12_LOGIC_OP_NOOP + 1 ) , + D3D12_LOGIC_OP_AND = ( D3D12_LOGIC_OP_INVERT + 1 ) , + D3D12_LOGIC_OP_NAND = ( D3D12_LOGIC_OP_AND + 1 ) , + D3D12_LOGIC_OP_OR = ( D3D12_LOGIC_OP_NAND + 1 ) , + D3D12_LOGIC_OP_NOR = ( D3D12_LOGIC_OP_OR + 1 ) , + D3D12_LOGIC_OP_XOR = ( D3D12_LOGIC_OP_NOR + 1 ) , + D3D12_LOGIC_OP_EQUIV = ( D3D12_LOGIC_OP_XOR + 1 ) , + D3D12_LOGIC_OP_AND_REVERSE = ( D3D12_LOGIC_OP_EQUIV + 1 ) , + D3D12_LOGIC_OP_AND_INVERTED = ( D3D12_LOGIC_OP_AND_REVERSE + 1 ) , + D3D12_LOGIC_OP_OR_REVERSE = ( D3D12_LOGIC_OP_AND_INVERTED + 1 ) , + D3D12_LOGIC_OP_OR_INVERTED = ( D3D12_LOGIC_OP_OR_REVERSE + 1 ) + } D3D12_LOGIC_OP; + +typedef struct D3D12_RENDER_TARGET_BLEND_DESC + { + BOOL BlendEnable; + BOOL LogicOpEnable; + D3D12_BLEND SrcBlend; + D3D12_BLEND DestBlend; + D3D12_BLEND_OP BlendOp; + D3D12_BLEND SrcBlendAlpha; + D3D12_BLEND DestBlendAlpha; + D3D12_BLEND_OP BlendOpAlpha; + D3D12_LOGIC_OP LogicOp; + UINT8 RenderTargetWriteMask; + } D3D12_RENDER_TARGET_BLEND_DESC; + +typedef struct D3D12_BLEND_DESC + { + BOOL AlphaToCoverageEnable; + BOOL IndependentBlendEnable; + D3D12_RENDER_TARGET_BLEND_DESC RenderTarget[ 8 ]; + } D3D12_BLEND_DESC; + +/* Note, the array size for RenderTarget[] above is D3D12_SIMULTANEOUS_RENDERTARGET_COUNT. + IDL processing/generation of this header replaces the define; this comment is merely explaining what happened. */ +typedef +enum D3D12_CONSERVATIVE_RASTERIZATION_MODE + { + D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF = 0, + D3D12_CONSERVATIVE_RASTERIZATION_MODE_ON = 1 + } D3D12_CONSERVATIVE_RASTERIZATION_MODE; + +typedef struct D3D12_RASTERIZER_DESC + { + D3D12_FILL_MODE FillMode; + D3D12_CULL_MODE CullMode; + BOOL FrontCounterClockwise; + INT DepthBias; + FLOAT DepthBiasClamp; + FLOAT SlopeScaledDepthBias; + BOOL DepthClipEnable; + BOOL MultisampleEnable; + BOOL AntialiasedLineEnable; + UINT ForcedSampleCount; + D3D12_CONSERVATIVE_RASTERIZATION_MODE ConservativeRaster; + } D3D12_RASTERIZER_DESC; + + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0000_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0000_v0_0_s_ifspec; + +#ifndef __ID3D12Object_INTERFACE_DEFINED__ +#define __ID3D12Object_INTERFACE_DEFINED__ + +/* interface ID3D12Object */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12Object; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("c4fec28f-7966-4e95-9f94-f431cb56c3b8") + ID3D12Object : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetPrivateData( + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetPrivateData( + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetPrivateDataInterface( + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetName( + _In_z_ LPCWSTR Name) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12ObjectVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12Object * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12Object * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12Object * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12Object * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12Object * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12Object * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12Object * This, + _In_z_ LPCWSTR Name); + + END_INTERFACE + } ID3D12ObjectVtbl; + + interface ID3D12Object + { + CONST_VTBL struct ID3D12ObjectVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12Object_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12Object_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12Object_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12Object_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12Object_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12Object_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12Object_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12Object_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12DeviceChild_INTERFACE_DEFINED__ +#define __ID3D12DeviceChild_INTERFACE_DEFINED__ + +/* interface ID3D12DeviceChild */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12DeviceChild; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("905db94b-a00c-4140-9df5-2b64ca9ea357") + ID3D12DeviceChild : public ID3D12Object + { + public: + virtual HRESULT STDMETHODCALLTYPE GetDevice( + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12DeviceChildVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12DeviceChild * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12DeviceChild * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12DeviceChild * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12DeviceChild * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12DeviceChild * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12DeviceChild * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12DeviceChild * This, + _In_z_ LPCWSTR Name); + + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12DeviceChild * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + END_INTERFACE + } ID3D12DeviceChildVtbl; + + interface ID3D12DeviceChild + { + CONST_VTBL struct ID3D12DeviceChildVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12DeviceChild_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12DeviceChild_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12DeviceChild_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12DeviceChild_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12DeviceChild_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12DeviceChild_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12DeviceChild_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12DeviceChild_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12DeviceChild_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12RootSignature_INTERFACE_DEFINED__ +#define __ID3D12RootSignature_INTERFACE_DEFINED__ + +/* interface ID3D12RootSignature */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12RootSignature; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("c54a6b66-72df-4ee8-8be5-a946a1429214") + ID3D12RootSignature : public ID3D12DeviceChild + { + public: + }; + + +#else /* C style interface */ + + typedef struct ID3D12RootSignatureVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12RootSignature * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12RootSignature * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12RootSignature * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12RootSignature * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12RootSignature * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12RootSignature * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12RootSignature * This, + _In_z_ LPCWSTR Name); + + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12RootSignature * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + END_INTERFACE + } ID3D12RootSignatureVtbl; + + interface ID3D12RootSignature + { + CONST_VTBL struct ID3D12RootSignatureVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12RootSignature_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12RootSignature_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12RootSignature_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12RootSignature_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12RootSignature_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12RootSignature_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12RootSignature_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12RootSignature_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12RootSignature_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12_0000_0001 */ +/* [local] */ + +typedef struct D3D12_SHADER_BYTECODE + { + _Field_size_bytes_full_(BytecodeLength) const void *pShaderBytecode; + SIZE_T BytecodeLength; + } D3D12_SHADER_BYTECODE; + +typedef struct D3D12_STREAM_OUTPUT_DESC + { + _Field_size_full_(NumEntries) const D3D12_SO_DECLARATION_ENTRY *pSODeclaration; + UINT NumEntries; + _Field_size_full_(NumStrides) const UINT *pBufferStrides; + UINT NumStrides; + UINT RasterizedStream; + } D3D12_STREAM_OUTPUT_DESC; + +typedef struct D3D12_INPUT_LAYOUT_DESC + { + _Field_size_full_(NumElements) const D3D12_INPUT_ELEMENT_DESC *pInputElementDescs; + UINT NumElements; + } D3D12_INPUT_LAYOUT_DESC; + +typedef +enum D3D12_INDEX_BUFFER_STRIP_CUT_VALUE + { + D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_DISABLED = 0, + D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_0xFFFF = 1, + D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_0xFFFFFFFF = 2 + } D3D12_INDEX_BUFFER_STRIP_CUT_VALUE; + +typedef struct D3D12_CACHED_PIPELINE_STATE + { + _Field_size_bytes_full_(CachedBlobSizeInBytes) const void *pCachedBlob; + SIZE_T CachedBlobSizeInBytes; + } D3D12_CACHED_PIPELINE_STATE; + +typedef +enum D3D12_PIPELINE_STATE_FLAGS + { + D3D12_PIPELINE_STATE_FLAG_NONE = 0, + D3D12_PIPELINE_STATE_FLAG_TOOL_DEBUG = 0x1 + } D3D12_PIPELINE_STATE_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_PIPELINE_STATE_FLAGS ); +typedef struct D3D12_GRAPHICS_PIPELINE_STATE_DESC + { + ID3D12RootSignature *pRootSignature; + D3D12_SHADER_BYTECODE VS; + D3D12_SHADER_BYTECODE PS; + D3D12_SHADER_BYTECODE DS; + D3D12_SHADER_BYTECODE HS; + D3D12_SHADER_BYTECODE GS; + D3D12_STREAM_OUTPUT_DESC StreamOutput; + D3D12_BLEND_DESC BlendState; + UINT SampleMask; + D3D12_RASTERIZER_DESC RasterizerState; + D3D12_DEPTH_STENCIL_DESC DepthStencilState; + D3D12_INPUT_LAYOUT_DESC InputLayout; + D3D12_INDEX_BUFFER_STRIP_CUT_VALUE IBStripCutValue; + D3D12_PRIMITIVE_TOPOLOGY_TYPE PrimitiveTopologyType; + UINT NumRenderTargets; + DXGI_FORMAT RTVFormats[ 8 ]; + DXGI_FORMAT DSVFormat; + DXGI_SAMPLE_DESC SampleDesc; + UINT NodeMask; + D3D12_CACHED_PIPELINE_STATE CachedPSO; + D3D12_PIPELINE_STATE_FLAGS Flags; + } D3D12_GRAPHICS_PIPELINE_STATE_DESC; + +typedef struct D3D12_COMPUTE_PIPELINE_STATE_DESC + { + ID3D12RootSignature *pRootSignature; + D3D12_SHADER_BYTECODE CS; + UINT NodeMask; + D3D12_CACHED_PIPELINE_STATE CachedPSO; + D3D12_PIPELINE_STATE_FLAGS Flags; + } D3D12_COMPUTE_PIPELINE_STATE_DESC; + +struct D3D12_RT_FORMAT_ARRAY + { + DXGI_FORMAT RTFormats[ 8 ]; + UINT NumRenderTargets; + } ; +typedef struct D3D12_PIPELINE_STATE_STREAM_DESC + { + _In_ SIZE_T SizeInBytes; + _In_reads_(_Inexpressible_("Dependent on size of subobjects")) void *pPipelineStateSubobjectStream; + } D3D12_PIPELINE_STATE_STREAM_DESC; + +typedef +enum D3D12_PIPELINE_STATE_SUBOBJECT_TYPE + { + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_ROOT_SIGNATURE = 0, + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VS = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_ROOT_SIGNATURE + 1 ) , + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PS = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VS + 1 ) , + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DS = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PS + 1 ) , + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_HS = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DS + 1 ) , + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_GS = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_HS + 1 ) , + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CS = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_GS + 1 ) , + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_STREAM_OUTPUT = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CS + 1 ) , + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_BLEND = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_STREAM_OUTPUT + 1 ) , + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_MASK = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_BLEND + 1 ) , + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RASTERIZER = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_MASK + 1 ) , + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RASTERIZER + 1 ) , + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_INPUT_LAYOUT = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL + 1 ) , + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_IB_STRIP_CUT_VALUE = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_INPUT_LAYOUT + 1 ) , + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PRIMITIVE_TOPOLOGY = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_IB_STRIP_CUT_VALUE + 1 ) , + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RENDER_TARGET_FORMATS = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PRIMITIVE_TOPOLOGY + 1 ) , + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL_FORMAT = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RENDER_TARGET_FORMATS + 1 ) , + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_DESC = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL_FORMAT + 1 ) , + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_NODE_MASK = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_DESC + 1 ) , + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CACHED_PSO = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_NODE_MASK + 1 ) , + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_FLAGS = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CACHED_PSO + 1 ) , + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1 = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_FLAGS + 1 ) , + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VIEW_INSTANCING = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1 + 1 ) , + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MAX_VALID = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VIEW_INSTANCING + 1 ) + } D3D12_PIPELINE_STATE_SUBOBJECT_TYPE; + +typedef +enum D3D12_FEATURE + { + D3D12_FEATURE_D3D12_OPTIONS = 0, + D3D12_FEATURE_ARCHITECTURE = 1, + D3D12_FEATURE_FEATURE_LEVELS = 2, + D3D12_FEATURE_FORMAT_SUPPORT = 3, + D3D12_FEATURE_MULTISAMPLE_QUALITY_LEVELS = 4, + D3D12_FEATURE_FORMAT_INFO = 5, + D3D12_FEATURE_GPU_VIRTUAL_ADDRESS_SUPPORT = 6, + D3D12_FEATURE_SHADER_MODEL = 7, + D3D12_FEATURE_D3D12_OPTIONS1 = 8, + D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_SUPPORT = 10, + D3D12_FEATURE_ROOT_SIGNATURE = 12, + D3D12_FEATURE_ARCHITECTURE1 = 16, + D3D12_FEATURE_D3D12_OPTIONS2 = 18, + D3D12_FEATURE_SHADER_CACHE = 19, + D3D12_FEATURE_COMMAND_QUEUE_PRIORITY = 20, + D3D12_FEATURE_D3D12_OPTIONS3 = 21, + D3D12_FEATURE_EXISTING_HEAPS = 22, + D3D12_FEATURE_D3D12_OPTIONS4 = 23, + D3D12_FEATURE_SERIALIZATION = 24, + D3D12_FEATURE_CROSS_NODE = 25, + D3D12_FEATURE_D3D12_OPTIONS5 = 27, + D3D12_FEATURE_D3D12_OPTIONS6 = 30, + D3D12_FEATURE_QUERY_META_COMMAND = 31 + } D3D12_FEATURE; + +typedef +enum D3D12_SHADER_MIN_PRECISION_SUPPORT + { + D3D12_SHADER_MIN_PRECISION_SUPPORT_NONE = 0, + D3D12_SHADER_MIN_PRECISION_SUPPORT_10_BIT = 0x1, + D3D12_SHADER_MIN_PRECISION_SUPPORT_16_BIT = 0x2 + } D3D12_SHADER_MIN_PRECISION_SUPPORT; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_SHADER_MIN_PRECISION_SUPPORT ); +typedef +enum D3D12_TILED_RESOURCES_TIER + { + D3D12_TILED_RESOURCES_TIER_NOT_SUPPORTED = 0, + D3D12_TILED_RESOURCES_TIER_1 = 1, + D3D12_TILED_RESOURCES_TIER_2 = 2, + D3D12_TILED_RESOURCES_TIER_3 = 3, + D3D12_TILED_RESOURCES_TIER_4 = 4 + } D3D12_TILED_RESOURCES_TIER; + +typedef +enum D3D12_RESOURCE_BINDING_TIER + { + D3D12_RESOURCE_BINDING_TIER_1 = 1, + D3D12_RESOURCE_BINDING_TIER_2 = 2, + D3D12_RESOURCE_BINDING_TIER_3 = 3 + } D3D12_RESOURCE_BINDING_TIER; + +typedef +enum D3D12_CONSERVATIVE_RASTERIZATION_TIER + { + D3D12_CONSERVATIVE_RASTERIZATION_TIER_NOT_SUPPORTED = 0, + D3D12_CONSERVATIVE_RASTERIZATION_TIER_1 = 1, + D3D12_CONSERVATIVE_RASTERIZATION_TIER_2 = 2, + D3D12_CONSERVATIVE_RASTERIZATION_TIER_3 = 3 + } D3D12_CONSERVATIVE_RASTERIZATION_TIER; + +typedef +enum D3D12_FORMAT_SUPPORT1 + { + D3D12_FORMAT_SUPPORT1_NONE = 0, + D3D12_FORMAT_SUPPORT1_BUFFER = 0x1, + D3D12_FORMAT_SUPPORT1_IA_VERTEX_BUFFER = 0x2, + D3D12_FORMAT_SUPPORT1_IA_INDEX_BUFFER = 0x4, + D3D12_FORMAT_SUPPORT1_SO_BUFFER = 0x8, + D3D12_FORMAT_SUPPORT1_TEXTURE1D = 0x10, + D3D12_FORMAT_SUPPORT1_TEXTURE2D = 0x20, + D3D12_FORMAT_SUPPORT1_TEXTURE3D = 0x40, + D3D12_FORMAT_SUPPORT1_TEXTURECUBE = 0x80, + D3D12_FORMAT_SUPPORT1_SHADER_LOAD = 0x100, + D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE = 0x200, + D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE_COMPARISON = 0x400, + D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE_MONO_TEXT = 0x800, + D3D12_FORMAT_SUPPORT1_MIP = 0x1000, + D3D12_FORMAT_SUPPORT1_RENDER_TARGET = 0x4000, + D3D12_FORMAT_SUPPORT1_BLENDABLE = 0x8000, + D3D12_FORMAT_SUPPORT1_DEPTH_STENCIL = 0x10000, + D3D12_FORMAT_SUPPORT1_MULTISAMPLE_RESOLVE = 0x40000, + D3D12_FORMAT_SUPPORT1_DISPLAY = 0x80000, + D3D12_FORMAT_SUPPORT1_CAST_WITHIN_BIT_LAYOUT = 0x100000, + D3D12_FORMAT_SUPPORT1_MULTISAMPLE_RENDERTARGET = 0x200000, + D3D12_FORMAT_SUPPORT1_MULTISAMPLE_LOAD = 0x400000, + D3D12_FORMAT_SUPPORT1_SHADER_GATHER = 0x800000, + D3D12_FORMAT_SUPPORT1_BACK_BUFFER_CAST = 0x1000000, + D3D12_FORMAT_SUPPORT1_TYPED_UNORDERED_ACCESS_VIEW = 0x2000000, + D3D12_FORMAT_SUPPORT1_SHADER_GATHER_COMPARISON = 0x4000000, + D3D12_FORMAT_SUPPORT1_DECODER_OUTPUT = 0x8000000, + D3D12_FORMAT_SUPPORT1_VIDEO_PROCESSOR_OUTPUT = 0x10000000, + D3D12_FORMAT_SUPPORT1_VIDEO_PROCESSOR_INPUT = 0x20000000, + D3D12_FORMAT_SUPPORT1_VIDEO_ENCODER = 0x40000000 + } D3D12_FORMAT_SUPPORT1; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_FORMAT_SUPPORT1 ); +typedef +enum D3D12_FORMAT_SUPPORT2 + { + D3D12_FORMAT_SUPPORT2_NONE = 0, + D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_ADD = 0x1, + D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_BITWISE_OPS = 0x2, + D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_COMPARE_STORE_OR_COMPARE_EXCHANGE = 0x4, + D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_EXCHANGE = 0x8, + D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_SIGNED_MIN_OR_MAX = 0x10, + D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_UNSIGNED_MIN_OR_MAX = 0x20, + D3D12_FORMAT_SUPPORT2_UAV_TYPED_LOAD = 0x40, + D3D12_FORMAT_SUPPORT2_UAV_TYPED_STORE = 0x80, + D3D12_FORMAT_SUPPORT2_OUTPUT_MERGER_LOGIC_OP = 0x100, + D3D12_FORMAT_SUPPORT2_TILED = 0x200, + D3D12_FORMAT_SUPPORT2_MULTIPLANE_OVERLAY = 0x4000 + } D3D12_FORMAT_SUPPORT2; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_FORMAT_SUPPORT2 ); +typedef +enum D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS + { + D3D12_MULTISAMPLE_QUALITY_LEVELS_FLAG_NONE = 0, + D3D12_MULTISAMPLE_QUALITY_LEVELS_FLAG_TILED_RESOURCE = 0x1 + } D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS ); +typedef +enum D3D12_CROSS_NODE_SHARING_TIER + { + D3D12_CROSS_NODE_SHARING_TIER_NOT_SUPPORTED = 0, + D3D12_CROSS_NODE_SHARING_TIER_1_EMULATED = 1, + D3D12_CROSS_NODE_SHARING_TIER_1 = 2, + D3D12_CROSS_NODE_SHARING_TIER_2 = 3, + D3D12_CROSS_NODE_SHARING_TIER_3 = 4 + } D3D12_CROSS_NODE_SHARING_TIER; + +typedef +enum D3D12_RESOURCE_HEAP_TIER + { + D3D12_RESOURCE_HEAP_TIER_1 = 1, + D3D12_RESOURCE_HEAP_TIER_2 = 2 + } D3D12_RESOURCE_HEAP_TIER; + +typedef +enum D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER + { + D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_NOT_SUPPORTED = 0, + D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_1 = 1, + D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_2 = 2 + } D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER; + +typedef +enum D3D12_VIEW_INSTANCING_TIER + { + D3D12_VIEW_INSTANCING_TIER_NOT_SUPPORTED = 0, + D3D12_VIEW_INSTANCING_TIER_1 = 1, + D3D12_VIEW_INSTANCING_TIER_2 = 2, + D3D12_VIEW_INSTANCING_TIER_3 = 3 + } D3D12_VIEW_INSTANCING_TIER; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS + { + _Out_ BOOL DoublePrecisionFloatShaderOps; + _Out_ BOOL OutputMergerLogicOp; + _Out_ D3D12_SHADER_MIN_PRECISION_SUPPORT MinPrecisionSupport; + _Out_ D3D12_TILED_RESOURCES_TIER TiledResourcesTier; + _Out_ D3D12_RESOURCE_BINDING_TIER ResourceBindingTier; + _Out_ BOOL PSSpecifiedStencilRefSupported; + _Out_ BOOL TypedUAVLoadAdditionalFormats; + _Out_ BOOL ROVsSupported; + _Out_ D3D12_CONSERVATIVE_RASTERIZATION_TIER ConservativeRasterizationTier; + _Out_ UINT MaxGPUVirtualAddressBitsPerResource; + _Out_ BOOL StandardSwizzle64KBSupported; + _Out_ D3D12_CROSS_NODE_SHARING_TIER CrossNodeSharingTier; + _Out_ BOOL CrossAdapterRowMajorTextureSupported; + _Out_ BOOL VPAndRTArrayIndexFromAnyShaderFeedingRasterizerSupportedWithoutGSEmulation; + _Out_ D3D12_RESOURCE_HEAP_TIER ResourceHeapTier; + } D3D12_FEATURE_DATA_D3D12_OPTIONS; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS1 + { + _Out_ BOOL WaveOps; + _Out_ UINT WaveLaneCountMin; + _Out_ UINT WaveLaneCountMax; + _Out_ UINT TotalLaneCount; + _Out_ BOOL ExpandedComputeResourceStates; + _Out_ BOOL Int64ShaderOps; + } D3D12_FEATURE_DATA_D3D12_OPTIONS1; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS2 + { + _Out_ BOOL DepthBoundsTestSupported; + _Out_ D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER ProgrammableSamplePositionsTier; + } D3D12_FEATURE_DATA_D3D12_OPTIONS2; + +typedef +enum D3D_ROOT_SIGNATURE_VERSION + { + D3D_ROOT_SIGNATURE_VERSION_1 = 0x1, + D3D_ROOT_SIGNATURE_VERSION_1_0 = 0x1, + D3D_ROOT_SIGNATURE_VERSION_1_1 = 0x2 + } D3D_ROOT_SIGNATURE_VERSION; + +typedef struct D3D12_FEATURE_DATA_ROOT_SIGNATURE + { + _Inout_ D3D_ROOT_SIGNATURE_VERSION HighestVersion; + } D3D12_FEATURE_DATA_ROOT_SIGNATURE; + +typedef struct D3D12_FEATURE_DATA_ARCHITECTURE + { + _In_ UINT NodeIndex; + _Out_ BOOL TileBasedRenderer; + _Out_ BOOL UMA; + _Out_ BOOL CacheCoherentUMA; + } D3D12_FEATURE_DATA_ARCHITECTURE; + +typedef struct D3D12_FEATURE_DATA_ARCHITECTURE1 + { + _In_ UINT NodeIndex; + _Out_ BOOL TileBasedRenderer; + _Out_ BOOL UMA; + _Out_ BOOL CacheCoherentUMA; + _Out_ BOOL IsolatedMMU; + } D3D12_FEATURE_DATA_ARCHITECTURE1; + +typedef struct D3D12_FEATURE_DATA_FEATURE_LEVELS + { + _In_ UINT NumFeatureLevels; + _In_reads_(NumFeatureLevels) const D3D_FEATURE_LEVEL *pFeatureLevelsRequested; + _Out_ D3D_FEATURE_LEVEL MaxSupportedFeatureLevel; + } D3D12_FEATURE_DATA_FEATURE_LEVELS; + +typedef +enum D3D_SHADER_MODEL + { + D3D_SHADER_MODEL_5_1 = 0x51, + D3D_SHADER_MODEL_6_0 = 0x60, + D3D_SHADER_MODEL_6_1 = 0x61, + D3D_SHADER_MODEL_6_2 = 0x62, + D3D_SHADER_MODEL_6_3 = 0x63, + D3D_SHADER_MODEL_6_4 = 0x64, + D3D_SHADER_MODEL_6_5 = 0x65 + } D3D_SHADER_MODEL; + +typedef struct D3D12_FEATURE_DATA_SHADER_MODEL + { + _Inout_ D3D_SHADER_MODEL HighestShaderModel; + } D3D12_FEATURE_DATA_SHADER_MODEL; + +typedef struct D3D12_FEATURE_DATA_FORMAT_SUPPORT + { + _In_ DXGI_FORMAT Format; + _Out_ D3D12_FORMAT_SUPPORT1 Support1; + _Out_ D3D12_FORMAT_SUPPORT2 Support2; + } D3D12_FEATURE_DATA_FORMAT_SUPPORT; + +typedef struct D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS + { + _In_ DXGI_FORMAT Format; + _In_ UINT SampleCount; + _In_ D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS Flags; + _Out_ UINT NumQualityLevels; + } D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS; + +typedef struct D3D12_FEATURE_DATA_FORMAT_INFO + { + DXGI_FORMAT Format; + UINT8 PlaneCount; + } D3D12_FEATURE_DATA_FORMAT_INFO; + +typedef struct D3D12_FEATURE_DATA_GPU_VIRTUAL_ADDRESS_SUPPORT + { + UINT MaxGPUVirtualAddressBitsPerResource; + UINT MaxGPUVirtualAddressBitsPerProcess; + } D3D12_FEATURE_DATA_GPU_VIRTUAL_ADDRESS_SUPPORT; + +typedef +enum D3D12_SHADER_CACHE_SUPPORT_FLAGS + { + D3D12_SHADER_CACHE_SUPPORT_NONE = 0, + D3D12_SHADER_CACHE_SUPPORT_SINGLE_PSO = 0x1, + D3D12_SHADER_CACHE_SUPPORT_LIBRARY = 0x2, + D3D12_SHADER_CACHE_SUPPORT_AUTOMATIC_INPROC_CACHE = 0x4, + D3D12_SHADER_CACHE_SUPPORT_AUTOMATIC_DISK_CACHE = 0x8 + } D3D12_SHADER_CACHE_SUPPORT_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_SHADER_CACHE_SUPPORT_FLAGS ); +typedef struct D3D12_FEATURE_DATA_SHADER_CACHE + { + _Out_ D3D12_SHADER_CACHE_SUPPORT_FLAGS SupportFlags; + } D3D12_FEATURE_DATA_SHADER_CACHE; + +typedef struct D3D12_FEATURE_DATA_COMMAND_QUEUE_PRIORITY + { + _In_ D3D12_COMMAND_LIST_TYPE CommandListType; + _In_ UINT Priority; + _Out_ BOOL PriorityForTypeIsSupported; + } D3D12_FEATURE_DATA_COMMAND_QUEUE_PRIORITY; + +typedef +enum D3D12_COMMAND_LIST_SUPPORT_FLAGS + { + D3D12_COMMAND_LIST_SUPPORT_FLAG_NONE = 0, + D3D12_COMMAND_LIST_SUPPORT_FLAG_DIRECT = ( 1 << D3D12_COMMAND_LIST_TYPE_DIRECT ) , + D3D12_COMMAND_LIST_SUPPORT_FLAG_BUNDLE = ( 1 << D3D12_COMMAND_LIST_TYPE_BUNDLE ) , + D3D12_COMMAND_LIST_SUPPORT_FLAG_COMPUTE = ( 1 << D3D12_COMMAND_LIST_TYPE_COMPUTE ) , + D3D12_COMMAND_LIST_SUPPORT_FLAG_COPY = ( 1 << D3D12_COMMAND_LIST_TYPE_COPY ) , + D3D12_COMMAND_LIST_SUPPORT_FLAG_VIDEO_DECODE = ( 1 << D3D12_COMMAND_LIST_TYPE_VIDEO_DECODE ) , + D3D12_COMMAND_LIST_SUPPORT_FLAG_VIDEO_PROCESS = ( 1 << D3D12_COMMAND_LIST_TYPE_VIDEO_PROCESS ) , + D3D12_COMMAND_LIST_SUPPORT_FLAG_VIDEO_ENCODE = ( 1 << D3D12_COMMAND_LIST_TYPE_VIDEO_ENCODE ) + } D3D12_COMMAND_LIST_SUPPORT_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_LIST_SUPPORT_FLAGS ); +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS3 + { + _Out_ BOOL CopyQueueTimestampQueriesSupported; + _Out_ BOOL CastingFullyTypedFormatSupported; + _Out_ D3D12_COMMAND_LIST_SUPPORT_FLAGS WriteBufferImmediateSupportFlags; + _Out_ D3D12_VIEW_INSTANCING_TIER ViewInstancingTier; + _Out_ BOOL BarycentricsSupported; + } D3D12_FEATURE_DATA_D3D12_OPTIONS3; + +typedef struct D3D12_FEATURE_DATA_EXISTING_HEAPS + { + _Out_ BOOL Supported; + } D3D12_FEATURE_DATA_EXISTING_HEAPS; + +typedef +enum D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER + { + D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_0 = 0, + D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_1 = ( D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_0 + 1 ) + } D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS4 + { + _Out_ BOOL MSAA64KBAlignedTextureSupported; + _Out_ D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER SharedResourceCompatibilityTier; + _Out_ BOOL Native16BitShaderOpsSupported; + } D3D12_FEATURE_DATA_D3D12_OPTIONS4; + +typedef +enum D3D12_HEAP_SERIALIZATION_TIER + { + D3D12_HEAP_SERIALIZATION_TIER_0 = 0, + D3D12_HEAP_SERIALIZATION_TIER_10 = 10 + } D3D12_HEAP_SERIALIZATION_TIER; + +typedef struct D3D12_FEATURE_DATA_SERIALIZATION + { + _In_ UINT NodeIndex; + _Out_ D3D12_HEAP_SERIALIZATION_TIER HeapSerializationTier; + } D3D12_FEATURE_DATA_SERIALIZATION; + +typedef struct D3D12_FEATURE_DATA_CROSS_NODE + { + D3D12_CROSS_NODE_SHARING_TIER SharingTier; + BOOL AtomicShaderInstructions; + } D3D12_FEATURE_DATA_CROSS_NODE; + +typedef +enum D3D12_RENDER_PASS_TIER + { + D3D12_RENDER_PASS_TIER_0 = 0, + D3D12_RENDER_PASS_TIER_1 = 1, + D3D12_RENDER_PASS_TIER_2 = 2 + } D3D12_RENDER_PASS_TIER; + +typedef +enum D3D12_RAYTRACING_TIER + { + D3D12_RAYTRACING_TIER_NOT_SUPPORTED = 0, + D3D12_RAYTRACING_TIER_1_0 = 10 + } D3D12_RAYTRACING_TIER; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS5 + { + _Out_ BOOL SRVOnlyTiledResourceTier3; + _Out_ D3D12_RENDER_PASS_TIER RenderPassesTier; + _Out_ D3D12_RAYTRACING_TIER RaytracingTier; + } D3D12_FEATURE_DATA_D3D12_OPTIONS5; + +typedef +enum D3D12_VARIABLE_SHADING_RATE_TIER + { + D3D12_VARIABLE_SHADING_RATE_TIER_NOT_SUPPORTED = 0, + D3D12_VARIABLE_SHADING_RATE_TIER_1 = 1, + D3D12_VARIABLE_SHADING_RATE_TIER_2 = 2 + } D3D12_VARIABLE_SHADING_RATE_TIER; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS6 + { + _Out_ BOOL AdditionalShadingRatesSupported; + _Out_ BOOL PerPrimitiveShadingRateSupportedWithViewportIndexing; + _Out_ D3D12_VARIABLE_SHADING_RATE_TIER VariableShadingRateTier; + _Out_ UINT ShadingRateImageTileSize; + _Out_ BOOL BackgroundProcessingSupported; + } D3D12_FEATURE_DATA_D3D12_OPTIONS6; + +typedef struct D3D12_FEATURE_DATA_QUERY_META_COMMAND + { + _In_ GUID CommandId; + _In_ UINT NodeMask; + _Field_size_bytes_full_opt_( QueryInputDataSizeInBytes ) const void *pQueryInputData; + _In_ SIZE_T QueryInputDataSizeInBytes; + _Field_size_bytes_full_( QueryOutputDataSizeInBytes ) void *pQueryOutputData; + _In_ SIZE_T QueryOutputDataSizeInBytes; + } D3D12_FEATURE_DATA_QUERY_META_COMMAND; + +typedef struct D3D12_RESOURCE_ALLOCATION_INFO + { + UINT64 SizeInBytes; + UINT64 Alignment; + } D3D12_RESOURCE_ALLOCATION_INFO; + +typedef struct D3D12_RESOURCE_ALLOCATION_INFO1 + { + UINT64 Offset; + UINT64 Alignment; + UINT64 SizeInBytes; + } D3D12_RESOURCE_ALLOCATION_INFO1; + +typedef +enum D3D12_HEAP_TYPE + { + D3D12_HEAP_TYPE_DEFAULT = 1, + D3D12_HEAP_TYPE_UPLOAD = 2, + D3D12_HEAP_TYPE_READBACK = 3, + D3D12_HEAP_TYPE_CUSTOM = 4 + } D3D12_HEAP_TYPE; + +typedef +enum D3D12_CPU_PAGE_PROPERTY + { + D3D12_CPU_PAGE_PROPERTY_UNKNOWN = 0, + D3D12_CPU_PAGE_PROPERTY_NOT_AVAILABLE = 1, + D3D12_CPU_PAGE_PROPERTY_WRITE_COMBINE = 2, + D3D12_CPU_PAGE_PROPERTY_WRITE_BACK = 3 + } D3D12_CPU_PAGE_PROPERTY; + +typedef +enum D3D12_MEMORY_POOL + { + D3D12_MEMORY_POOL_UNKNOWN = 0, + D3D12_MEMORY_POOL_L0 = 1, + D3D12_MEMORY_POOL_L1 = 2 + } D3D12_MEMORY_POOL; + +typedef struct D3D12_HEAP_PROPERTIES + { + D3D12_HEAP_TYPE Type; + D3D12_CPU_PAGE_PROPERTY CPUPageProperty; + D3D12_MEMORY_POOL MemoryPoolPreference; + UINT CreationNodeMask; + UINT VisibleNodeMask; + } D3D12_HEAP_PROPERTIES; + +typedef +enum D3D12_HEAP_FLAGS + { + D3D12_HEAP_FLAG_NONE = 0, + D3D12_HEAP_FLAG_SHARED = 0x1, + D3D12_HEAP_FLAG_DENY_BUFFERS = 0x4, + D3D12_HEAP_FLAG_ALLOW_DISPLAY = 0x8, + D3D12_HEAP_FLAG_SHARED_CROSS_ADAPTER = 0x20, + D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES = 0x40, + D3D12_HEAP_FLAG_DENY_NON_RT_DS_TEXTURES = 0x80, + D3D12_HEAP_FLAG_HARDWARE_PROTECTED = 0x100, + D3D12_HEAP_FLAG_ALLOW_WRITE_WATCH = 0x200, + D3D12_HEAP_FLAG_ALLOW_SHADER_ATOMICS = 0x400, + D3D12_HEAP_FLAG_ALLOW_ALL_BUFFERS_AND_TEXTURES = 0, + D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS = 0xc0, + D3D12_HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES = 0x44, + D3D12_HEAP_FLAG_ALLOW_ONLY_RT_DS_TEXTURES = 0x84 + } D3D12_HEAP_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_HEAP_FLAGS ); +typedef struct D3D12_HEAP_DESC + { + UINT64 SizeInBytes; + D3D12_HEAP_PROPERTIES Properties; + UINT64 Alignment; + D3D12_HEAP_FLAGS Flags; + } D3D12_HEAP_DESC; + +typedef +enum D3D12_RESOURCE_DIMENSION + { + D3D12_RESOURCE_DIMENSION_UNKNOWN = 0, + D3D12_RESOURCE_DIMENSION_BUFFER = 1, + D3D12_RESOURCE_DIMENSION_TEXTURE1D = 2, + D3D12_RESOURCE_DIMENSION_TEXTURE2D = 3, + D3D12_RESOURCE_DIMENSION_TEXTURE3D = 4 + } D3D12_RESOURCE_DIMENSION; + +typedef +enum D3D12_TEXTURE_LAYOUT + { + D3D12_TEXTURE_LAYOUT_UNKNOWN = 0, + D3D12_TEXTURE_LAYOUT_ROW_MAJOR = 1, + D3D12_TEXTURE_LAYOUT_64KB_UNDEFINED_SWIZZLE = 2, + D3D12_TEXTURE_LAYOUT_64KB_STANDARD_SWIZZLE = 3 + } D3D12_TEXTURE_LAYOUT; + +typedef +enum D3D12_RESOURCE_FLAGS + { + D3D12_RESOURCE_FLAG_NONE = 0, + D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET = 0x1, + D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL = 0x2, + D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS = 0x4, + D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE = 0x8, + D3D12_RESOURCE_FLAG_ALLOW_CROSS_ADAPTER = 0x10, + D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS = 0x20, + D3D12_RESOURCE_FLAG_VIDEO_DECODE_REFERENCE_ONLY = 0x40 + } D3D12_RESOURCE_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_RESOURCE_FLAGS ); +typedef struct D3D12_RESOURCE_DESC + { + D3D12_RESOURCE_DIMENSION Dimension; + UINT64 Alignment; + UINT64 Width; + UINT Height; + UINT16 DepthOrArraySize; + UINT16 MipLevels; + DXGI_FORMAT Format; + DXGI_SAMPLE_DESC SampleDesc; + D3D12_TEXTURE_LAYOUT Layout; + D3D12_RESOURCE_FLAGS Flags; + } D3D12_RESOURCE_DESC; + +typedef struct D3D12_DEPTH_STENCIL_VALUE + { + FLOAT Depth; + UINT8 Stencil; + } D3D12_DEPTH_STENCIL_VALUE; + +typedef struct D3D12_CLEAR_VALUE + { + DXGI_FORMAT Format; + union + { + FLOAT Color[ 4 ]; + D3D12_DEPTH_STENCIL_VALUE DepthStencil; + } ; + } D3D12_CLEAR_VALUE; + +typedef struct D3D12_RANGE + { + SIZE_T Begin; + SIZE_T End; + } D3D12_RANGE; + +typedef struct D3D12_RANGE_UINT64 + { + UINT64 Begin; + UINT64 End; + } D3D12_RANGE_UINT64; + +typedef struct D3D12_SUBRESOURCE_RANGE_UINT64 + { + UINT Subresource; + D3D12_RANGE_UINT64 Range; + } D3D12_SUBRESOURCE_RANGE_UINT64; + +typedef struct D3D12_SUBRESOURCE_INFO + { + UINT64 Offset; + UINT RowPitch; + UINT DepthPitch; + } D3D12_SUBRESOURCE_INFO; + +typedef struct D3D12_TILED_RESOURCE_COORDINATE + { + UINT X; + UINT Y; + UINT Z; + UINT Subresource; + } D3D12_TILED_RESOURCE_COORDINATE; + +typedef struct D3D12_TILE_REGION_SIZE + { + UINT NumTiles; + BOOL UseBox; + UINT Width; + UINT16 Height; + UINT16 Depth; + } D3D12_TILE_REGION_SIZE; + +typedef +enum D3D12_TILE_RANGE_FLAGS + { + D3D12_TILE_RANGE_FLAG_NONE = 0, + D3D12_TILE_RANGE_FLAG_NULL = 1, + D3D12_TILE_RANGE_FLAG_SKIP = 2, + D3D12_TILE_RANGE_FLAG_REUSE_SINGLE_TILE = 4 + } D3D12_TILE_RANGE_FLAGS; + +typedef struct D3D12_SUBRESOURCE_TILING + { + UINT WidthInTiles; + UINT16 HeightInTiles; + UINT16 DepthInTiles; + UINT StartTileIndexInOverallResource; + } D3D12_SUBRESOURCE_TILING; + +typedef struct D3D12_TILE_SHAPE + { + UINT WidthInTexels; + UINT HeightInTexels; + UINT DepthInTexels; + } D3D12_TILE_SHAPE; + +typedef struct D3D12_PACKED_MIP_INFO + { + UINT8 NumStandardMips; + UINT8 NumPackedMips; + UINT NumTilesForPackedMips; + UINT StartTileIndexInOverallResource; + } D3D12_PACKED_MIP_INFO; + +typedef +enum D3D12_TILE_MAPPING_FLAGS + { + D3D12_TILE_MAPPING_FLAG_NONE = 0, + D3D12_TILE_MAPPING_FLAG_NO_HAZARD = 0x1 + } D3D12_TILE_MAPPING_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_TILE_MAPPING_FLAGS ); +typedef +enum D3D12_TILE_COPY_FLAGS + { + D3D12_TILE_COPY_FLAG_NONE = 0, + D3D12_TILE_COPY_FLAG_NO_HAZARD = 0x1, + D3D12_TILE_COPY_FLAG_LINEAR_BUFFER_TO_SWIZZLED_TILED_RESOURCE = 0x2, + D3D12_TILE_COPY_FLAG_SWIZZLED_TILED_RESOURCE_TO_LINEAR_BUFFER = 0x4 + } D3D12_TILE_COPY_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_TILE_COPY_FLAGS ); +typedef +enum D3D12_RESOURCE_STATES + { + D3D12_RESOURCE_STATE_COMMON = 0, + D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER = 0x1, + D3D12_RESOURCE_STATE_INDEX_BUFFER = 0x2, + D3D12_RESOURCE_STATE_RENDER_TARGET = 0x4, + D3D12_RESOURCE_STATE_UNORDERED_ACCESS = 0x8, + D3D12_RESOURCE_STATE_DEPTH_WRITE = 0x10, + D3D12_RESOURCE_STATE_DEPTH_READ = 0x20, + D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE = 0x40, + D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE = 0x80, + D3D12_RESOURCE_STATE_STREAM_OUT = 0x100, + D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT = 0x200, + D3D12_RESOURCE_STATE_COPY_DEST = 0x400, + D3D12_RESOURCE_STATE_COPY_SOURCE = 0x800, + D3D12_RESOURCE_STATE_RESOLVE_DEST = 0x1000, + D3D12_RESOURCE_STATE_RESOLVE_SOURCE = 0x2000, + D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE = 0x400000, + D3D12_RESOURCE_STATE_SHADING_RATE_SOURCE = 0x1000000, + D3D12_RESOURCE_STATE_GENERIC_READ = ( ( ( ( ( 0x1 | 0x2 ) | 0x40 ) | 0x80 ) | 0x200 ) | 0x800 ) , + D3D12_RESOURCE_STATE_PRESENT = 0, + D3D12_RESOURCE_STATE_PREDICATION = 0x200, + D3D12_RESOURCE_STATE_VIDEO_DECODE_READ = 0x10000, + D3D12_RESOURCE_STATE_VIDEO_DECODE_WRITE = 0x20000, + D3D12_RESOURCE_STATE_VIDEO_PROCESS_READ = 0x40000, + D3D12_RESOURCE_STATE_VIDEO_PROCESS_WRITE = 0x80000, + D3D12_RESOURCE_STATE_VIDEO_ENCODE_READ = 0x200000, + D3D12_RESOURCE_STATE_VIDEO_ENCODE_WRITE = 0x800000 + } D3D12_RESOURCE_STATES; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_RESOURCE_STATES ); +typedef +enum D3D12_RESOURCE_BARRIER_TYPE + { + D3D12_RESOURCE_BARRIER_TYPE_TRANSITION = 0, + D3D12_RESOURCE_BARRIER_TYPE_ALIASING = ( D3D12_RESOURCE_BARRIER_TYPE_TRANSITION + 1 ) , + D3D12_RESOURCE_BARRIER_TYPE_UAV = ( D3D12_RESOURCE_BARRIER_TYPE_ALIASING + 1 ) + } D3D12_RESOURCE_BARRIER_TYPE; + + +typedef struct D3D12_RESOURCE_TRANSITION_BARRIER + { + ID3D12Resource *pResource; + UINT Subresource; + D3D12_RESOURCE_STATES StateBefore; + D3D12_RESOURCE_STATES StateAfter; + } D3D12_RESOURCE_TRANSITION_BARRIER; + +typedef struct D3D12_RESOURCE_ALIASING_BARRIER + { + ID3D12Resource *pResourceBefore; + ID3D12Resource *pResourceAfter; + } D3D12_RESOURCE_ALIASING_BARRIER; + +typedef struct D3D12_RESOURCE_UAV_BARRIER + { + ID3D12Resource *pResource; + } D3D12_RESOURCE_UAV_BARRIER; + +typedef +enum D3D12_RESOURCE_BARRIER_FLAGS + { + D3D12_RESOURCE_BARRIER_FLAG_NONE = 0, + D3D12_RESOURCE_BARRIER_FLAG_BEGIN_ONLY = 0x1, + D3D12_RESOURCE_BARRIER_FLAG_END_ONLY = 0x2 + } D3D12_RESOURCE_BARRIER_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_RESOURCE_BARRIER_FLAGS ); +typedef struct D3D12_RESOURCE_BARRIER + { + D3D12_RESOURCE_BARRIER_TYPE Type; + D3D12_RESOURCE_BARRIER_FLAGS Flags; + union + { + D3D12_RESOURCE_TRANSITION_BARRIER Transition; + D3D12_RESOURCE_ALIASING_BARRIER Aliasing; + D3D12_RESOURCE_UAV_BARRIER UAV; + } ; + } D3D12_RESOURCE_BARRIER; + +typedef struct D3D12_SUBRESOURCE_FOOTPRINT + { + DXGI_FORMAT Format; + UINT Width; + UINT Height; + UINT Depth; + UINT RowPitch; + } D3D12_SUBRESOURCE_FOOTPRINT; + +typedef struct D3D12_PLACED_SUBRESOURCE_FOOTPRINT + { + UINT64 Offset; + D3D12_SUBRESOURCE_FOOTPRINT Footprint; + } D3D12_PLACED_SUBRESOURCE_FOOTPRINT; + +typedef +enum D3D12_TEXTURE_COPY_TYPE + { + D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX = 0, + D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT = 1 + } D3D12_TEXTURE_COPY_TYPE; + +typedef struct D3D12_TEXTURE_COPY_LOCATION + { + ID3D12Resource *pResource; + D3D12_TEXTURE_COPY_TYPE Type; + union + { + D3D12_PLACED_SUBRESOURCE_FOOTPRINT PlacedFootprint; + UINT SubresourceIndex; + } ; + } D3D12_TEXTURE_COPY_LOCATION; + +typedef +enum D3D12_RESOLVE_MODE + { + D3D12_RESOLVE_MODE_DECOMPRESS = 0, + D3D12_RESOLVE_MODE_MIN = 1, + D3D12_RESOLVE_MODE_MAX = 2, + D3D12_RESOLVE_MODE_AVERAGE = 3 + } D3D12_RESOLVE_MODE; + +typedef struct D3D12_SAMPLE_POSITION + { + INT8 X; + INT8 Y; + } D3D12_SAMPLE_POSITION; + +typedef struct D3D12_VIEW_INSTANCE_LOCATION + { + UINT ViewportArrayIndex; + UINT RenderTargetArrayIndex; + } D3D12_VIEW_INSTANCE_LOCATION; + +typedef +enum D3D12_VIEW_INSTANCING_FLAGS + { + D3D12_VIEW_INSTANCING_FLAG_NONE = 0, + D3D12_VIEW_INSTANCING_FLAG_ENABLE_VIEW_INSTANCE_MASKING = 0x1 + } D3D12_VIEW_INSTANCING_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_VIEW_INSTANCING_FLAGS ); +typedef struct D3D12_VIEW_INSTANCING_DESC + { + UINT ViewInstanceCount; + _Field_size_full_(ViewInstanceCount) const D3D12_VIEW_INSTANCE_LOCATION *pViewInstanceLocations; + D3D12_VIEW_INSTANCING_FLAGS Flags; + } D3D12_VIEW_INSTANCING_DESC; + +typedef +enum D3D12_SHADER_COMPONENT_MAPPING + { + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_0 = 0, + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_1 = 1, + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_2 = 2, + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_3 = 3, + D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_0 = 4, + D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_1 = 5 + } D3D12_SHADER_COMPONENT_MAPPING; + +#define D3D12_SHADER_COMPONENT_MAPPING_MASK 0x7 +#define D3D12_SHADER_COMPONENT_MAPPING_SHIFT 3 +#define D3D12_SHADER_COMPONENT_MAPPING_ALWAYS_SET_BIT_AVOIDING_ZEROMEM_MISTAKES (1<<(D3D12_SHADER_COMPONENT_MAPPING_SHIFT*4)) +#define D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING(Src0,Src1,Src2,Src3) ((((Src0)&D3D12_SHADER_COMPONENT_MAPPING_MASK)| \ + (((Src1)&D3D12_SHADER_COMPONENT_MAPPING_MASK)<> (D3D12_SHADER_COMPONENT_MAPPING_SHIFT*ComponentToExtract) & D3D12_SHADER_COMPONENT_MAPPING_MASK)) +#define D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING(0,1,2,3) +typedef +enum D3D12_BUFFER_SRV_FLAGS + { + D3D12_BUFFER_SRV_FLAG_NONE = 0, + D3D12_BUFFER_SRV_FLAG_RAW = 0x1 + } D3D12_BUFFER_SRV_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_BUFFER_SRV_FLAGS ); +typedef struct D3D12_BUFFER_SRV + { + UINT64 FirstElement; + UINT NumElements; + UINT StructureByteStride; + D3D12_BUFFER_SRV_FLAGS Flags; + } D3D12_BUFFER_SRV; + +typedef struct D3D12_TEX1D_SRV + { + UINT MostDetailedMip; + UINT MipLevels; + FLOAT ResourceMinLODClamp; + } D3D12_TEX1D_SRV; + +typedef struct D3D12_TEX1D_ARRAY_SRV + { + UINT MostDetailedMip; + UINT MipLevels; + UINT FirstArraySlice; + UINT ArraySize; + FLOAT ResourceMinLODClamp; + } D3D12_TEX1D_ARRAY_SRV; + +typedef struct D3D12_TEX2D_SRV + { + UINT MostDetailedMip; + UINT MipLevels; + UINT PlaneSlice; + FLOAT ResourceMinLODClamp; + } D3D12_TEX2D_SRV; + +typedef struct D3D12_TEX2D_ARRAY_SRV + { + UINT MostDetailedMip; + UINT MipLevels; + UINT FirstArraySlice; + UINT ArraySize; + UINT PlaneSlice; + FLOAT ResourceMinLODClamp; + } D3D12_TEX2D_ARRAY_SRV; + +typedef struct D3D12_TEX3D_SRV + { + UINT MostDetailedMip; + UINT MipLevels; + FLOAT ResourceMinLODClamp; + } D3D12_TEX3D_SRV; + +typedef struct D3D12_TEXCUBE_SRV + { + UINT MostDetailedMip; + UINT MipLevels; + FLOAT ResourceMinLODClamp; + } D3D12_TEXCUBE_SRV; + +typedef struct D3D12_TEXCUBE_ARRAY_SRV + { + UINT MostDetailedMip; + UINT MipLevels; + UINT First2DArrayFace; + UINT NumCubes; + FLOAT ResourceMinLODClamp; + } D3D12_TEXCUBE_ARRAY_SRV; + +typedef struct D3D12_TEX2DMS_SRV + { + UINT UnusedField_NothingToDefine; + } D3D12_TEX2DMS_SRV; + +typedef struct D3D12_TEX2DMS_ARRAY_SRV + { + UINT FirstArraySlice; + UINT ArraySize; + } D3D12_TEX2DMS_ARRAY_SRV; + +typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_SRV + { + D3D12_GPU_VIRTUAL_ADDRESS Location; + } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_SRV; + +typedef +enum D3D12_SRV_DIMENSION + { + D3D12_SRV_DIMENSION_UNKNOWN = 0, + D3D12_SRV_DIMENSION_BUFFER = 1, + D3D12_SRV_DIMENSION_TEXTURE1D = 2, + D3D12_SRV_DIMENSION_TEXTURE1DARRAY = 3, + D3D12_SRV_DIMENSION_TEXTURE2D = 4, + D3D12_SRV_DIMENSION_TEXTURE2DARRAY = 5, + D3D12_SRV_DIMENSION_TEXTURE2DMS = 6, + D3D12_SRV_DIMENSION_TEXTURE2DMSARRAY = 7, + D3D12_SRV_DIMENSION_TEXTURE3D = 8, + D3D12_SRV_DIMENSION_TEXTURECUBE = 9, + D3D12_SRV_DIMENSION_TEXTURECUBEARRAY = 10, + D3D12_SRV_DIMENSION_RAYTRACING_ACCELERATION_STRUCTURE = 11 + } D3D12_SRV_DIMENSION; + +typedef struct D3D12_SHADER_RESOURCE_VIEW_DESC + { + DXGI_FORMAT Format; + D3D12_SRV_DIMENSION ViewDimension; + UINT Shader4ComponentMapping; + union + { + D3D12_BUFFER_SRV Buffer; + D3D12_TEX1D_SRV Texture1D; + D3D12_TEX1D_ARRAY_SRV Texture1DArray; + D3D12_TEX2D_SRV Texture2D; + D3D12_TEX2D_ARRAY_SRV Texture2DArray; + D3D12_TEX2DMS_SRV Texture2DMS; + D3D12_TEX2DMS_ARRAY_SRV Texture2DMSArray; + D3D12_TEX3D_SRV Texture3D; + D3D12_TEXCUBE_SRV TextureCube; + D3D12_TEXCUBE_ARRAY_SRV TextureCubeArray; + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_SRV RaytracingAccelerationStructure; + } ; + } D3D12_SHADER_RESOURCE_VIEW_DESC; + +typedef struct D3D12_CONSTANT_BUFFER_VIEW_DESC + { + D3D12_GPU_VIRTUAL_ADDRESS BufferLocation; + UINT SizeInBytes; + } D3D12_CONSTANT_BUFFER_VIEW_DESC; + +typedef +enum D3D12_FILTER + { + D3D12_FILTER_MIN_MAG_MIP_POINT = 0, + D3D12_FILTER_MIN_MAG_POINT_MIP_LINEAR = 0x1, + D3D12_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x4, + D3D12_FILTER_MIN_POINT_MAG_MIP_LINEAR = 0x5, + D3D12_FILTER_MIN_LINEAR_MAG_MIP_POINT = 0x10, + D3D12_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x11, + D3D12_FILTER_MIN_MAG_LINEAR_MIP_POINT = 0x14, + D3D12_FILTER_MIN_MAG_MIP_LINEAR = 0x15, + D3D12_FILTER_ANISOTROPIC = 0x55, + D3D12_FILTER_COMPARISON_MIN_MAG_MIP_POINT = 0x80, + D3D12_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR = 0x81, + D3D12_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x84, + D3D12_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR = 0x85, + D3D12_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT = 0x90, + D3D12_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x91, + D3D12_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT = 0x94, + D3D12_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR = 0x95, + D3D12_FILTER_COMPARISON_ANISOTROPIC = 0xd5, + D3D12_FILTER_MINIMUM_MIN_MAG_MIP_POINT = 0x100, + D3D12_FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR = 0x101, + D3D12_FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x104, + D3D12_FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR = 0x105, + D3D12_FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT = 0x110, + D3D12_FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x111, + D3D12_FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT = 0x114, + D3D12_FILTER_MINIMUM_MIN_MAG_MIP_LINEAR = 0x115, + D3D12_FILTER_MINIMUM_ANISOTROPIC = 0x155, + D3D12_FILTER_MAXIMUM_MIN_MAG_MIP_POINT = 0x180, + D3D12_FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR = 0x181, + D3D12_FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x184, + D3D12_FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR = 0x185, + D3D12_FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT = 0x190, + D3D12_FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x191, + D3D12_FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT = 0x194, + D3D12_FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR = 0x195, + D3D12_FILTER_MAXIMUM_ANISOTROPIC = 0x1d5 + } D3D12_FILTER; + +typedef +enum D3D12_FILTER_TYPE + { + D3D12_FILTER_TYPE_POINT = 0, + D3D12_FILTER_TYPE_LINEAR = 1 + } D3D12_FILTER_TYPE; + +typedef +enum D3D12_FILTER_REDUCTION_TYPE + { + D3D12_FILTER_REDUCTION_TYPE_STANDARD = 0, + D3D12_FILTER_REDUCTION_TYPE_COMPARISON = 1, + D3D12_FILTER_REDUCTION_TYPE_MINIMUM = 2, + D3D12_FILTER_REDUCTION_TYPE_MAXIMUM = 3 + } D3D12_FILTER_REDUCTION_TYPE; + +#define D3D12_FILTER_REDUCTION_TYPE_MASK ( 0x3 ) + +#define D3D12_FILTER_REDUCTION_TYPE_SHIFT ( 7 ) + +#define D3D12_FILTER_TYPE_MASK ( 0x3 ) + +#define D3D12_MIN_FILTER_SHIFT ( 4 ) + +#define D3D12_MAG_FILTER_SHIFT ( 2 ) + +#define D3D12_MIP_FILTER_SHIFT ( 0 ) + +#define D3D12_ANISOTROPIC_FILTERING_BIT ( 0x40 ) + +#define D3D12_ENCODE_BASIC_FILTER( min, mag, mip, reduction ) \ + ( ( D3D12_FILTER ) ( \ + ( ( ( min ) & D3D12_FILTER_TYPE_MASK ) << D3D12_MIN_FILTER_SHIFT ) | \ + ( ( ( mag ) & D3D12_FILTER_TYPE_MASK ) << D3D12_MAG_FILTER_SHIFT ) | \ + ( ( ( mip ) & D3D12_FILTER_TYPE_MASK ) << D3D12_MIP_FILTER_SHIFT ) | \ + ( ( ( reduction ) & D3D12_FILTER_REDUCTION_TYPE_MASK ) << D3D12_FILTER_REDUCTION_TYPE_SHIFT ) ) ) +#define D3D12_ENCODE_ANISOTROPIC_FILTER( reduction ) \ + ( ( D3D12_FILTER ) ( \ + D3D12_ANISOTROPIC_FILTERING_BIT | \ + D3D12_ENCODE_BASIC_FILTER( D3D12_FILTER_TYPE_LINEAR, \ + D3D12_FILTER_TYPE_LINEAR, \ + D3D12_FILTER_TYPE_LINEAR, \ + reduction ) ) ) +#define D3D12_DECODE_MIN_FILTER( D3D12Filter ) \ + ( ( D3D12_FILTER_TYPE ) \ + ( ( ( D3D12Filter ) >> D3D12_MIN_FILTER_SHIFT ) & D3D12_FILTER_TYPE_MASK ) ) +#define D3D12_DECODE_MAG_FILTER( D3D12Filter ) \ + ( ( D3D12_FILTER_TYPE ) \ + ( ( ( D3D12Filter ) >> D3D12_MAG_FILTER_SHIFT ) & D3D12_FILTER_TYPE_MASK ) ) +#define D3D12_DECODE_MIP_FILTER( D3D12Filter ) \ + ( ( D3D12_FILTER_TYPE ) \ + ( ( ( D3D12Filter ) >> D3D12_MIP_FILTER_SHIFT ) & D3D12_FILTER_TYPE_MASK ) ) +#define D3D12_DECODE_FILTER_REDUCTION( D3D12Filter ) \ + ( ( D3D12_FILTER_REDUCTION_TYPE ) \ + ( ( ( D3D12Filter ) >> D3D12_FILTER_REDUCTION_TYPE_SHIFT ) & D3D12_FILTER_REDUCTION_TYPE_MASK ) ) +#define D3D12_DECODE_IS_COMPARISON_FILTER( D3D12Filter ) \ + ( D3D12_DECODE_FILTER_REDUCTION( D3D12Filter ) == D3D12_FILTER_REDUCTION_TYPE_COMPARISON ) +#define D3D12_DECODE_IS_ANISOTROPIC_FILTER( D3D12Filter ) \ + ( ( ( D3D12Filter ) & D3D12_ANISOTROPIC_FILTERING_BIT ) && \ + ( D3D12_FILTER_TYPE_LINEAR == D3D12_DECODE_MIN_FILTER( D3D12Filter ) ) && \ + ( D3D12_FILTER_TYPE_LINEAR == D3D12_DECODE_MAG_FILTER( D3D12Filter ) ) && \ + ( D3D12_FILTER_TYPE_LINEAR == D3D12_DECODE_MIP_FILTER( D3D12Filter ) ) ) +typedef +enum D3D12_TEXTURE_ADDRESS_MODE + { + D3D12_TEXTURE_ADDRESS_MODE_WRAP = 1, + D3D12_TEXTURE_ADDRESS_MODE_MIRROR = 2, + D3D12_TEXTURE_ADDRESS_MODE_CLAMP = 3, + D3D12_TEXTURE_ADDRESS_MODE_BORDER = 4, + D3D12_TEXTURE_ADDRESS_MODE_MIRROR_ONCE = 5 + } D3D12_TEXTURE_ADDRESS_MODE; + +typedef struct D3D12_SAMPLER_DESC + { + D3D12_FILTER Filter; + D3D12_TEXTURE_ADDRESS_MODE AddressU; + D3D12_TEXTURE_ADDRESS_MODE AddressV; + D3D12_TEXTURE_ADDRESS_MODE AddressW; + FLOAT MipLODBias; + UINT MaxAnisotropy; + D3D12_COMPARISON_FUNC ComparisonFunc; + FLOAT BorderColor[ 4 ]; + FLOAT MinLOD; + FLOAT MaxLOD; + } D3D12_SAMPLER_DESC; + +typedef +enum D3D12_BUFFER_UAV_FLAGS + { + D3D12_BUFFER_UAV_FLAG_NONE = 0, + D3D12_BUFFER_UAV_FLAG_RAW = 0x1 + } D3D12_BUFFER_UAV_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_BUFFER_UAV_FLAGS ); +typedef struct D3D12_BUFFER_UAV + { + UINT64 FirstElement; + UINT NumElements; + UINT StructureByteStride; + UINT64 CounterOffsetInBytes; + D3D12_BUFFER_UAV_FLAGS Flags; + } D3D12_BUFFER_UAV; + +typedef struct D3D12_TEX1D_UAV + { + UINT MipSlice; + } D3D12_TEX1D_UAV; + +typedef struct D3D12_TEX1D_ARRAY_UAV + { + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; + } D3D12_TEX1D_ARRAY_UAV; + +typedef struct D3D12_TEX2D_UAV + { + UINT MipSlice; + UINT PlaneSlice; + } D3D12_TEX2D_UAV; + +typedef struct D3D12_TEX2D_ARRAY_UAV + { + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; + UINT PlaneSlice; + } D3D12_TEX2D_ARRAY_UAV; + +typedef struct D3D12_TEX3D_UAV + { + UINT MipSlice; + UINT FirstWSlice; + UINT WSize; + } D3D12_TEX3D_UAV; + +typedef +enum D3D12_UAV_DIMENSION + { + D3D12_UAV_DIMENSION_UNKNOWN = 0, + D3D12_UAV_DIMENSION_BUFFER = 1, + D3D12_UAV_DIMENSION_TEXTURE1D = 2, + D3D12_UAV_DIMENSION_TEXTURE1DARRAY = 3, + D3D12_UAV_DIMENSION_TEXTURE2D = 4, + D3D12_UAV_DIMENSION_TEXTURE2DARRAY = 5, + D3D12_UAV_DIMENSION_TEXTURE3D = 8 + } D3D12_UAV_DIMENSION; + +typedef struct D3D12_UNORDERED_ACCESS_VIEW_DESC + { + DXGI_FORMAT Format; + D3D12_UAV_DIMENSION ViewDimension; + union + { + D3D12_BUFFER_UAV Buffer; + D3D12_TEX1D_UAV Texture1D; + D3D12_TEX1D_ARRAY_UAV Texture1DArray; + D3D12_TEX2D_UAV Texture2D; + D3D12_TEX2D_ARRAY_UAV Texture2DArray; + D3D12_TEX3D_UAV Texture3D; + } ; + } D3D12_UNORDERED_ACCESS_VIEW_DESC; + +typedef struct D3D12_BUFFER_RTV + { + UINT64 FirstElement; + UINT NumElements; + } D3D12_BUFFER_RTV; + +typedef struct D3D12_TEX1D_RTV + { + UINT MipSlice; + } D3D12_TEX1D_RTV; + +typedef struct D3D12_TEX1D_ARRAY_RTV + { + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; + } D3D12_TEX1D_ARRAY_RTV; + +typedef struct D3D12_TEX2D_RTV + { + UINT MipSlice; + UINT PlaneSlice; + } D3D12_TEX2D_RTV; + +typedef struct D3D12_TEX2DMS_RTV + { + UINT UnusedField_NothingToDefine; + } D3D12_TEX2DMS_RTV; + +typedef struct D3D12_TEX2D_ARRAY_RTV + { + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; + UINT PlaneSlice; + } D3D12_TEX2D_ARRAY_RTV; + +typedef struct D3D12_TEX2DMS_ARRAY_RTV + { + UINT FirstArraySlice; + UINT ArraySize; + } D3D12_TEX2DMS_ARRAY_RTV; + +typedef struct D3D12_TEX3D_RTV + { + UINT MipSlice; + UINT FirstWSlice; + UINT WSize; + } D3D12_TEX3D_RTV; + +typedef +enum D3D12_RTV_DIMENSION + { + D3D12_RTV_DIMENSION_UNKNOWN = 0, + D3D12_RTV_DIMENSION_BUFFER = 1, + D3D12_RTV_DIMENSION_TEXTURE1D = 2, + D3D12_RTV_DIMENSION_TEXTURE1DARRAY = 3, + D3D12_RTV_DIMENSION_TEXTURE2D = 4, + D3D12_RTV_DIMENSION_TEXTURE2DARRAY = 5, + D3D12_RTV_DIMENSION_TEXTURE2DMS = 6, + D3D12_RTV_DIMENSION_TEXTURE2DMSARRAY = 7, + D3D12_RTV_DIMENSION_TEXTURE3D = 8 + } D3D12_RTV_DIMENSION; + +typedef struct D3D12_RENDER_TARGET_VIEW_DESC + { + DXGI_FORMAT Format; + D3D12_RTV_DIMENSION ViewDimension; + union + { + D3D12_BUFFER_RTV Buffer; + D3D12_TEX1D_RTV Texture1D; + D3D12_TEX1D_ARRAY_RTV Texture1DArray; + D3D12_TEX2D_RTV Texture2D; + D3D12_TEX2D_ARRAY_RTV Texture2DArray; + D3D12_TEX2DMS_RTV Texture2DMS; + D3D12_TEX2DMS_ARRAY_RTV Texture2DMSArray; + D3D12_TEX3D_RTV Texture3D; + } ; + } D3D12_RENDER_TARGET_VIEW_DESC; + +typedef struct D3D12_TEX1D_DSV + { + UINT MipSlice; + } D3D12_TEX1D_DSV; + +typedef struct D3D12_TEX1D_ARRAY_DSV + { + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; + } D3D12_TEX1D_ARRAY_DSV; + +typedef struct D3D12_TEX2D_DSV + { + UINT MipSlice; + } D3D12_TEX2D_DSV; + +typedef struct D3D12_TEX2D_ARRAY_DSV + { + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; + } D3D12_TEX2D_ARRAY_DSV; + +typedef struct D3D12_TEX2DMS_DSV + { + UINT UnusedField_NothingToDefine; + } D3D12_TEX2DMS_DSV; + +typedef struct D3D12_TEX2DMS_ARRAY_DSV + { + UINT FirstArraySlice; + UINT ArraySize; + } D3D12_TEX2DMS_ARRAY_DSV; + +typedef +enum D3D12_DSV_FLAGS + { + D3D12_DSV_FLAG_NONE = 0, + D3D12_DSV_FLAG_READ_ONLY_DEPTH = 0x1, + D3D12_DSV_FLAG_READ_ONLY_STENCIL = 0x2 + } D3D12_DSV_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_DSV_FLAGS ); +typedef +enum D3D12_DSV_DIMENSION + { + D3D12_DSV_DIMENSION_UNKNOWN = 0, + D3D12_DSV_DIMENSION_TEXTURE1D = 1, + D3D12_DSV_DIMENSION_TEXTURE1DARRAY = 2, + D3D12_DSV_DIMENSION_TEXTURE2D = 3, + D3D12_DSV_DIMENSION_TEXTURE2DARRAY = 4, + D3D12_DSV_DIMENSION_TEXTURE2DMS = 5, + D3D12_DSV_DIMENSION_TEXTURE2DMSARRAY = 6 + } D3D12_DSV_DIMENSION; + +typedef struct D3D12_DEPTH_STENCIL_VIEW_DESC + { + DXGI_FORMAT Format; + D3D12_DSV_DIMENSION ViewDimension; + D3D12_DSV_FLAGS Flags; + union + { + D3D12_TEX1D_DSV Texture1D; + D3D12_TEX1D_ARRAY_DSV Texture1DArray; + D3D12_TEX2D_DSV Texture2D; + D3D12_TEX2D_ARRAY_DSV Texture2DArray; + D3D12_TEX2DMS_DSV Texture2DMS; + D3D12_TEX2DMS_ARRAY_DSV Texture2DMSArray; + } ; + } D3D12_DEPTH_STENCIL_VIEW_DESC; + +typedef +enum D3D12_CLEAR_FLAGS + { + D3D12_CLEAR_FLAG_DEPTH = 0x1, + D3D12_CLEAR_FLAG_STENCIL = 0x2 + } D3D12_CLEAR_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_CLEAR_FLAGS ); +typedef +enum D3D12_FENCE_FLAGS + { + D3D12_FENCE_FLAG_NONE = 0, + D3D12_FENCE_FLAG_SHARED = 0x1, + D3D12_FENCE_FLAG_SHARED_CROSS_ADAPTER = 0x2, + D3D12_FENCE_FLAG_NON_MONITORED = 0x4 + } D3D12_FENCE_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_FENCE_FLAGS ); +typedef +enum D3D12_DESCRIPTOR_HEAP_TYPE + { + D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV = 0, + D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER = ( D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV + 1 ) , + D3D12_DESCRIPTOR_HEAP_TYPE_RTV = ( D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER + 1 ) , + D3D12_DESCRIPTOR_HEAP_TYPE_DSV = ( D3D12_DESCRIPTOR_HEAP_TYPE_RTV + 1 ) , + D3D12_DESCRIPTOR_HEAP_TYPE_NUM_TYPES = ( D3D12_DESCRIPTOR_HEAP_TYPE_DSV + 1 ) + } D3D12_DESCRIPTOR_HEAP_TYPE; + +typedef +enum D3D12_DESCRIPTOR_HEAP_FLAGS + { + D3D12_DESCRIPTOR_HEAP_FLAG_NONE = 0, + D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE = 0x1 + } D3D12_DESCRIPTOR_HEAP_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_DESCRIPTOR_HEAP_FLAGS ); +typedef struct D3D12_DESCRIPTOR_HEAP_DESC + { + D3D12_DESCRIPTOR_HEAP_TYPE Type; + UINT NumDescriptors; + D3D12_DESCRIPTOR_HEAP_FLAGS Flags; + UINT NodeMask; + } D3D12_DESCRIPTOR_HEAP_DESC; + +typedef +enum D3D12_DESCRIPTOR_RANGE_TYPE + { + D3D12_DESCRIPTOR_RANGE_TYPE_SRV = 0, + D3D12_DESCRIPTOR_RANGE_TYPE_UAV = ( D3D12_DESCRIPTOR_RANGE_TYPE_SRV + 1 ) , + D3D12_DESCRIPTOR_RANGE_TYPE_CBV = ( D3D12_DESCRIPTOR_RANGE_TYPE_UAV + 1 ) , + D3D12_DESCRIPTOR_RANGE_TYPE_SAMPLER = ( D3D12_DESCRIPTOR_RANGE_TYPE_CBV + 1 ) + } D3D12_DESCRIPTOR_RANGE_TYPE; + +typedef struct D3D12_DESCRIPTOR_RANGE + { + D3D12_DESCRIPTOR_RANGE_TYPE RangeType; + UINT NumDescriptors; + UINT BaseShaderRegister; + UINT RegisterSpace; + UINT OffsetInDescriptorsFromTableStart; + } D3D12_DESCRIPTOR_RANGE; + +typedef struct D3D12_ROOT_DESCRIPTOR_TABLE + { + UINT NumDescriptorRanges; + _Field_size_full_(NumDescriptorRanges) const D3D12_DESCRIPTOR_RANGE *pDescriptorRanges; + } D3D12_ROOT_DESCRIPTOR_TABLE; + +typedef struct D3D12_ROOT_CONSTANTS + { + UINT ShaderRegister; + UINT RegisterSpace; + UINT Num32BitValues; + } D3D12_ROOT_CONSTANTS; + +typedef struct D3D12_ROOT_DESCRIPTOR + { + UINT ShaderRegister; + UINT RegisterSpace; + } D3D12_ROOT_DESCRIPTOR; + +typedef +enum D3D12_SHADER_VISIBILITY + { + D3D12_SHADER_VISIBILITY_ALL = 0, + D3D12_SHADER_VISIBILITY_VERTEX = 1, + D3D12_SHADER_VISIBILITY_HULL = 2, + D3D12_SHADER_VISIBILITY_DOMAIN = 3, + D3D12_SHADER_VISIBILITY_GEOMETRY = 4, + D3D12_SHADER_VISIBILITY_PIXEL = 5 + } D3D12_SHADER_VISIBILITY; + +typedef +enum D3D12_ROOT_PARAMETER_TYPE + { + D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE = 0, + D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS = ( D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE + 1 ) , + D3D12_ROOT_PARAMETER_TYPE_CBV = ( D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS + 1 ) , + D3D12_ROOT_PARAMETER_TYPE_SRV = ( D3D12_ROOT_PARAMETER_TYPE_CBV + 1 ) , + D3D12_ROOT_PARAMETER_TYPE_UAV = ( D3D12_ROOT_PARAMETER_TYPE_SRV + 1 ) + } D3D12_ROOT_PARAMETER_TYPE; + +typedef struct D3D12_ROOT_PARAMETER + { + D3D12_ROOT_PARAMETER_TYPE ParameterType; + union + { + D3D12_ROOT_DESCRIPTOR_TABLE DescriptorTable; + D3D12_ROOT_CONSTANTS Constants; + D3D12_ROOT_DESCRIPTOR Descriptor; + } ; + D3D12_SHADER_VISIBILITY ShaderVisibility; + } D3D12_ROOT_PARAMETER; + +typedef +enum D3D12_ROOT_SIGNATURE_FLAGS + { + D3D12_ROOT_SIGNATURE_FLAG_NONE = 0, + D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT = 0x1, + D3D12_ROOT_SIGNATURE_FLAG_DENY_VERTEX_SHADER_ROOT_ACCESS = 0x2, + D3D12_ROOT_SIGNATURE_FLAG_DENY_HULL_SHADER_ROOT_ACCESS = 0x4, + D3D12_ROOT_SIGNATURE_FLAG_DENY_DOMAIN_SHADER_ROOT_ACCESS = 0x8, + D3D12_ROOT_SIGNATURE_FLAG_DENY_GEOMETRY_SHADER_ROOT_ACCESS = 0x10, + D3D12_ROOT_SIGNATURE_FLAG_DENY_PIXEL_SHADER_ROOT_ACCESS = 0x20, + D3D12_ROOT_SIGNATURE_FLAG_ALLOW_STREAM_OUTPUT = 0x40, + D3D12_ROOT_SIGNATURE_FLAG_LOCAL_ROOT_SIGNATURE = 0x80 + } D3D12_ROOT_SIGNATURE_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_ROOT_SIGNATURE_FLAGS ); +typedef +enum D3D12_STATIC_BORDER_COLOR + { + D3D12_STATIC_BORDER_COLOR_TRANSPARENT_BLACK = 0, + D3D12_STATIC_BORDER_COLOR_OPAQUE_BLACK = ( D3D12_STATIC_BORDER_COLOR_TRANSPARENT_BLACK + 1 ) , + D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE = ( D3D12_STATIC_BORDER_COLOR_OPAQUE_BLACK + 1 ) + } D3D12_STATIC_BORDER_COLOR; + +typedef struct D3D12_STATIC_SAMPLER_DESC + { + D3D12_FILTER Filter; + D3D12_TEXTURE_ADDRESS_MODE AddressU; + D3D12_TEXTURE_ADDRESS_MODE AddressV; + D3D12_TEXTURE_ADDRESS_MODE AddressW; + FLOAT MipLODBias; + UINT MaxAnisotropy; + D3D12_COMPARISON_FUNC ComparisonFunc; + D3D12_STATIC_BORDER_COLOR BorderColor; + FLOAT MinLOD; + FLOAT MaxLOD; + UINT ShaderRegister; + UINT RegisterSpace; + D3D12_SHADER_VISIBILITY ShaderVisibility; + } D3D12_STATIC_SAMPLER_DESC; + +typedef struct D3D12_ROOT_SIGNATURE_DESC + { + UINT NumParameters; + _Field_size_full_(NumParameters) const D3D12_ROOT_PARAMETER *pParameters; + UINT NumStaticSamplers; + _Field_size_full_(NumStaticSamplers) const D3D12_STATIC_SAMPLER_DESC *pStaticSamplers; + D3D12_ROOT_SIGNATURE_FLAGS Flags; + } D3D12_ROOT_SIGNATURE_DESC; + +typedef +enum D3D12_DESCRIPTOR_RANGE_FLAGS + { + D3D12_DESCRIPTOR_RANGE_FLAG_NONE = 0, + D3D12_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_VOLATILE = 0x1, + D3D12_DESCRIPTOR_RANGE_FLAG_DATA_VOLATILE = 0x2, + D3D12_DESCRIPTOR_RANGE_FLAG_DATA_STATIC_WHILE_SET_AT_EXECUTE = 0x4, + D3D12_DESCRIPTOR_RANGE_FLAG_DATA_STATIC = 0x8, + D3D12_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS = 0x10000 + } D3D12_DESCRIPTOR_RANGE_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_DESCRIPTOR_RANGE_FLAGS ); +typedef struct D3D12_DESCRIPTOR_RANGE1 + { + D3D12_DESCRIPTOR_RANGE_TYPE RangeType; + UINT NumDescriptors; + UINT BaseShaderRegister; + UINT RegisterSpace; + D3D12_DESCRIPTOR_RANGE_FLAGS Flags; + UINT OffsetInDescriptorsFromTableStart; + } D3D12_DESCRIPTOR_RANGE1; + +typedef struct D3D12_ROOT_DESCRIPTOR_TABLE1 + { + UINT NumDescriptorRanges; + _Field_size_full_(NumDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1 *pDescriptorRanges; + } D3D12_ROOT_DESCRIPTOR_TABLE1; + +typedef +enum D3D12_ROOT_DESCRIPTOR_FLAGS + { + D3D12_ROOT_DESCRIPTOR_FLAG_NONE = 0, + D3D12_ROOT_DESCRIPTOR_FLAG_DATA_VOLATILE = 0x2, + D3D12_ROOT_DESCRIPTOR_FLAG_DATA_STATIC_WHILE_SET_AT_EXECUTE = 0x4, + D3D12_ROOT_DESCRIPTOR_FLAG_DATA_STATIC = 0x8 + } D3D12_ROOT_DESCRIPTOR_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_ROOT_DESCRIPTOR_FLAGS ); +typedef struct D3D12_ROOT_DESCRIPTOR1 + { + UINT ShaderRegister; + UINT RegisterSpace; + D3D12_ROOT_DESCRIPTOR_FLAGS Flags; + } D3D12_ROOT_DESCRIPTOR1; + +typedef struct D3D12_ROOT_PARAMETER1 + { + D3D12_ROOT_PARAMETER_TYPE ParameterType; + union + { + D3D12_ROOT_DESCRIPTOR_TABLE1 DescriptorTable; + D3D12_ROOT_CONSTANTS Constants; + D3D12_ROOT_DESCRIPTOR1 Descriptor; + } ; + D3D12_SHADER_VISIBILITY ShaderVisibility; + } D3D12_ROOT_PARAMETER1; + +typedef struct D3D12_ROOT_SIGNATURE_DESC1 + { + UINT NumParameters; + _Field_size_full_(NumParameters) const D3D12_ROOT_PARAMETER1 *pParameters; + UINT NumStaticSamplers; + _Field_size_full_(NumStaticSamplers) const D3D12_STATIC_SAMPLER_DESC *pStaticSamplers; + D3D12_ROOT_SIGNATURE_FLAGS Flags; + } D3D12_ROOT_SIGNATURE_DESC1; + +typedef struct D3D12_VERSIONED_ROOT_SIGNATURE_DESC + { + D3D_ROOT_SIGNATURE_VERSION Version; + union + { + D3D12_ROOT_SIGNATURE_DESC Desc_1_0; + D3D12_ROOT_SIGNATURE_DESC1 Desc_1_1; + } ; + } D3D12_VERSIONED_ROOT_SIGNATURE_DESC; + + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0001_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0001_v0_0_s_ifspec; + +#ifndef __ID3D12RootSignatureDeserializer_INTERFACE_DEFINED__ +#define __ID3D12RootSignatureDeserializer_INTERFACE_DEFINED__ + +/* interface ID3D12RootSignatureDeserializer */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12RootSignatureDeserializer; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("34AB647B-3CC8-46AC-841B-C0965645C046") + ID3D12RootSignatureDeserializer : public IUnknown + { + public: + virtual const D3D12_ROOT_SIGNATURE_DESC *STDMETHODCALLTYPE GetRootSignatureDesc( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12RootSignatureDeserializerVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12RootSignatureDeserializer * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12RootSignatureDeserializer * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12RootSignatureDeserializer * This); + + const D3D12_ROOT_SIGNATURE_DESC *( STDMETHODCALLTYPE *GetRootSignatureDesc )( + ID3D12RootSignatureDeserializer * This); + + END_INTERFACE + } ID3D12RootSignatureDeserializerVtbl; + + interface ID3D12RootSignatureDeserializer + { + CONST_VTBL struct ID3D12RootSignatureDeserializerVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12RootSignatureDeserializer_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12RootSignatureDeserializer_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12RootSignatureDeserializer_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12RootSignatureDeserializer_GetRootSignatureDesc(This) \ + ( (This)->lpVtbl -> GetRootSignatureDesc(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12RootSignatureDeserializer_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12VersionedRootSignatureDeserializer_INTERFACE_DEFINED__ +#define __ID3D12VersionedRootSignatureDeserializer_INTERFACE_DEFINED__ + +/* interface ID3D12VersionedRootSignatureDeserializer */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12VersionedRootSignatureDeserializer; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("7F91CE67-090C-4BB7-B78E-ED8FF2E31DA0") + ID3D12VersionedRootSignatureDeserializer : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetRootSignatureDescAtVersion( + D3D_ROOT_SIGNATURE_VERSION convertToVersion, + _Out_ const D3D12_VERSIONED_ROOT_SIGNATURE_DESC **ppDesc) = 0; + + virtual const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *STDMETHODCALLTYPE GetUnconvertedRootSignatureDesc( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12VersionedRootSignatureDeserializerVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12VersionedRootSignatureDeserializer * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12VersionedRootSignatureDeserializer * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12VersionedRootSignatureDeserializer * This); + + HRESULT ( STDMETHODCALLTYPE *GetRootSignatureDescAtVersion )( + ID3D12VersionedRootSignatureDeserializer * This, + D3D_ROOT_SIGNATURE_VERSION convertToVersion, + _Out_ const D3D12_VERSIONED_ROOT_SIGNATURE_DESC **ppDesc); + + const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *( STDMETHODCALLTYPE *GetUnconvertedRootSignatureDesc )( + ID3D12VersionedRootSignatureDeserializer * This); + + END_INTERFACE + } ID3D12VersionedRootSignatureDeserializerVtbl; + + interface ID3D12VersionedRootSignatureDeserializer + { + CONST_VTBL struct ID3D12VersionedRootSignatureDeserializerVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12VersionedRootSignatureDeserializer_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12VersionedRootSignatureDeserializer_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12VersionedRootSignatureDeserializer_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12VersionedRootSignatureDeserializer_GetRootSignatureDescAtVersion(This,convertToVersion,ppDesc) \ + ( (This)->lpVtbl -> GetRootSignatureDescAtVersion(This,convertToVersion,ppDesc) ) + +#define ID3D12VersionedRootSignatureDeserializer_GetUnconvertedRootSignatureDesc(This) \ + ( (This)->lpVtbl -> GetUnconvertedRootSignatureDesc(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12VersionedRootSignatureDeserializer_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12_0000_0003 */ +/* [local] */ + +typedef HRESULT (WINAPI* PFN_D3D12_SERIALIZE_ROOT_SIGNATURE)( + _In_ const D3D12_ROOT_SIGNATURE_DESC* pRootSignature, + _In_ D3D_ROOT_SIGNATURE_VERSION Version, + _Out_ ID3DBlob** ppBlob, + _Always_(_Outptr_opt_result_maybenull_) ID3DBlob** ppErrorBlob); + +HRESULT WINAPI D3D12SerializeRootSignature( + _In_ const D3D12_ROOT_SIGNATURE_DESC* pRootSignature, + _In_ D3D_ROOT_SIGNATURE_VERSION Version, + _Out_ ID3DBlob** ppBlob, + _Always_(_Outptr_opt_result_maybenull_) ID3DBlob** ppErrorBlob); + +typedef HRESULT (WINAPI* PFN_D3D12_CREATE_ROOT_SIGNATURE_DESERIALIZER)( + _In_reads_bytes_(SrcDataSizeInBytes) LPCVOID pSrcData, + _In_ SIZE_T SrcDataSizeInBytes, + _In_ REFIID pRootSignatureDeserializerInterface, + _Out_ void** ppRootSignatureDeserializer); + +HRESULT WINAPI D3D12CreateRootSignatureDeserializer( + _In_reads_bytes_(SrcDataSizeInBytes) LPCVOID pSrcData, + _In_ SIZE_T SrcDataSizeInBytes, + _In_ REFIID pRootSignatureDeserializerInterface, + _Out_ void** ppRootSignatureDeserializer); + +typedef HRESULT (WINAPI* PFN_D3D12_SERIALIZE_VERSIONED_ROOT_SIGNATURE)( + _In_ const D3D12_VERSIONED_ROOT_SIGNATURE_DESC* pRootSignature, + _Out_ ID3DBlob** ppBlob, + _Always_(_Outptr_opt_result_maybenull_) ID3DBlob** ppErrorBlob); + +HRESULT WINAPI D3D12SerializeVersionedRootSignature( + _In_ const D3D12_VERSIONED_ROOT_SIGNATURE_DESC* pRootSignature, + _Out_ ID3DBlob** ppBlob, + _Always_(_Outptr_opt_result_maybenull_) ID3DBlob** ppErrorBlob); + +typedef HRESULT (WINAPI* PFN_D3D12_CREATE_VERSIONED_ROOT_SIGNATURE_DESERIALIZER)( + _In_reads_bytes_(SrcDataSizeInBytes) LPCVOID pSrcData, + _In_ SIZE_T SrcDataSizeInBytes, + _In_ REFIID pRootSignatureDeserializerInterface, + _Out_ void** ppRootSignatureDeserializer); + +HRESULT WINAPI D3D12CreateVersionedRootSignatureDeserializer( + _In_reads_bytes_(SrcDataSizeInBytes) LPCVOID pSrcData, + _In_ SIZE_T SrcDataSizeInBytes, + _In_ REFIID pRootSignatureDeserializerInterface, + _Out_ void** ppRootSignatureDeserializer); + +typedef struct D3D12_CPU_DESCRIPTOR_HANDLE + { + SIZE_T ptr; + } D3D12_CPU_DESCRIPTOR_HANDLE; + +typedef struct D3D12_GPU_DESCRIPTOR_HANDLE + { + UINT64 ptr; + } D3D12_GPU_DESCRIPTOR_HANDLE; + +// If rects are supplied in D3D12_DISCARD_REGION, below, the resource +// must have 2D subresources with all specified subresources the same dimension. +typedef struct D3D12_DISCARD_REGION + { + UINT NumRects; + _In_reads_(NumRects) const D3D12_RECT *pRects; + UINT FirstSubresource; + UINT NumSubresources; + } D3D12_DISCARD_REGION; + +typedef +enum D3D12_QUERY_HEAP_TYPE + { + D3D12_QUERY_HEAP_TYPE_OCCLUSION = 0, + D3D12_QUERY_HEAP_TYPE_TIMESTAMP = 1, + D3D12_QUERY_HEAP_TYPE_PIPELINE_STATISTICS = 2, + D3D12_QUERY_HEAP_TYPE_SO_STATISTICS = 3, + D3D12_QUERY_HEAP_TYPE_VIDEO_DECODE_STATISTICS = 4, + D3D12_QUERY_HEAP_TYPE_COPY_QUEUE_TIMESTAMP = 5 + } D3D12_QUERY_HEAP_TYPE; + +typedef struct D3D12_QUERY_HEAP_DESC + { + D3D12_QUERY_HEAP_TYPE Type; + UINT Count; + UINT NodeMask; + } D3D12_QUERY_HEAP_DESC; + +typedef +enum D3D12_QUERY_TYPE + { + D3D12_QUERY_TYPE_OCCLUSION = 0, + D3D12_QUERY_TYPE_BINARY_OCCLUSION = 1, + D3D12_QUERY_TYPE_TIMESTAMP = 2, + D3D12_QUERY_TYPE_PIPELINE_STATISTICS = 3, + D3D12_QUERY_TYPE_SO_STATISTICS_STREAM0 = 4, + D3D12_QUERY_TYPE_SO_STATISTICS_STREAM1 = 5, + D3D12_QUERY_TYPE_SO_STATISTICS_STREAM2 = 6, + D3D12_QUERY_TYPE_SO_STATISTICS_STREAM3 = 7, + D3D12_QUERY_TYPE_VIDEO_DECODE_STATISTICS = 8 + } D3D12_QUERY_TYPE; + +typedef +enum D3D12_PREDICATION_OP + { + D3D12_PREDICATION_OP_EQUAL_ZERO = 0, + D3D12_PREDICATION_OP_NOT_EQUAL_ZERO = 1 + } D3D12_PREDICATION_OP; + +typedef struct D3D12_QUERY_DATA_PIPELINE_STATISTICS + { + UINT64 IAVertices; + UINT64 IAPrimitives; + UINT64 VSInvocations; + UINT64 GSInvocations; + UINT64 GSPrimitives; + UINT64 CInvocations; + UINT64 CPrimitives; + UINT64 PSInvocations; + UINT64 HSInvocations; + UINT64 DSInvocations; + UINT64 CSInvocations; + } D3D12_QUERY_DATA_PIPELINE_STATISTICS; + +typedef struct D3D12_QUERY_DATA_SO_STATISTICS + { + UINT64 NumPrimitivesWritten; + UINT64 PrimitivesStorageNeeded; + } D3D12_QUERY_DATA_SO_STATISTICS; + +typedef struct D3D12_STREAM_OUTPUT_BUFFER_VIEW + { + D3D12_GPU_VIRTUAL_ADDRESS BufferLocation; + UINT64 SizeInBytes; + D3D12_GPU_VIRTUAL_ADDRESS BufferFilledSizeLocation; + } D3D12_STREAM_OUTPUT_BUFFER_VIEW; + +typedef struct D3D12_DRAW_ARGUMENTS + { + UINT VertexCountPerInstance; + UINT InstanceCount; + UINT StartVertexLocation; + UINT StartInstanceLocation; + } D3D12_DRAW_ARGUMENTS; + +typedef struct D3D12_DRAW_INDEXED_ARGUMENTS + { + UINT IndexCountPerInstance; + UINT InstanceCount; + UINT StartIndexLocation; + INT BaseVertexLocation; + UINT StartInstanceLocation; + } D3D12_DRAW_INDEXED_ARGUMENTS; + +typedef struct D3D12_DISPATCH_ARGUMENTS + { + UINT ThreadGroupCountX; + UINT ThreadGroupCountY; + UINT ThreadGroupCountZ; + } D3D12_DISPATCH_ARGUMENTS; + +typedef struct D3D12_VERTEX_BUFFER_VIEW + { + D3D12_GPU_VIRTUAL_ADDRESS BufferLocation; + UINT SizeInBytes; + UINT StrideInBytes; + } D3D12_VERTEX_BUFFER_VIEW; + +typedef struct D3D12_INDEX_BUFFER_VIEW + { + D3D12_GPU_VIRTUAL_ADDRESS BufferLocation; + UINT SizeInBytes; + DXGI_FORMAT Format; + } D3D12_INDEX_BUFFER_VIEW; + +typedef +enum D3D12_INDIRECT_ARGUMENT_TYPE + { + D3D12_INDIRECT_ARGUMENT_TYPE_DRAW = 0, + D3D12_INDIRECT_ARGUMENT_TYPE_DRAW_INDEXED = ( D3D12_INDIRECT_ARGUMENT_TYPE_DRAW + 1 ) , + D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH = ( D3D12_INDIRECT_ARGUMENT_TYPE_DRAW_INDEXED + 1 ) , + D3D12_INDIRECT_ARGUMENT_TYPE_VERTEX_BUFFER_VIEW = ( D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH + 1 ) , + D3D12_INDIRECT_ARGUMENT_TYPE_INDEX_BUFFER_VIEW = ( D3D12_INDIRECT_ARGUMENT_TYPE_VERTEX_BUFFER_VIEW + 1 ) , + D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT = ( D3D12_INDIRECT_ARGUMENT_TYPE_INDEX_BUFFER_VIEW + 1 ) , + D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT_BUFFER_VIEW = ( D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT + 1 ) , + D3D12_INDIRECT_ARGUMENT_TYPE_SHADER_RESOURCE_VIEW = ( D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT_BUFFER_VIEW + 1 ) , + D3D12_INDIRECT_ARGUMENT_TYPE_UNORDERED_ACCESS_VIEW = ( D3D12_INDIRECT_ARGUMENT_TYPE_SHADER_RESOURCE_VIEW + 1 ) + } D3D12_INDIRECT_ARGUMENT_TYPE; + +typedef struct D3D12_INDIRECT_ARGUMENT_DESC + { + D3D12_INDIRECT_ARGUMENT_TYPE Type; + union + { + struct + { + UINT Slot; + } VertexBuffer; + struct + { + UINT RootParameterIndex; + UINT DestOffsetIn32BitValues; + UINT Num32BitValuesToSet; + } Constant; + struct + { + UINT RootParameterIndex; + } ConstantBufferView; + struct + { + UINT RootParameterIndex; + } ShaderResourceView; + struct + { + UINT RootParameterIndex; + } UnorderedAccessView; + } ; + } D3D12_INDIRECT_ARGUMENT_DESC; + +typedef struct D3D12_COMMAND_SIGNATURE_DESC + { + UINT ByteStride; + UINT NumArgumentDescs; + _Field_size_full_(NumArgumentDescs) const D3D12_INDIRECT_ARGUMENT_DESC *pArgumentDescs; + UINT NodeMask; + } D3D12_COMMAND_SIGNATURE_DESC; + + + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0003_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0003_v0_0_s_ifspec; + +#ifndef __ID3D12Pageable_INTERFACE_DEFINED__ +#define __ID3D12Pageable_INTERFACE_DEFINED__ + +/* interface ID3D12Pageable */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12Pageable; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("63ee58fb-1268-4835-86da-f008ce62f0d6") + ID3D12Pageable : public ID3D12DeviceChild + { + public: + }; + + +#else /* C style interface */ + + typedef struct ID3D12PageableVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12Pageable * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12Pageable * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12Pageable * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12Pageable * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12Pageable * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12Pageable * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12Pageable * This, + _In_z_ LPCWSTR Name); + + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12Pageable * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + END_INTERFACE + } ID3D12PageableVtbl; + + interface ID3D12Pageable + { + CONST_VTBL struct ID3D12PageableVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12Pageable_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12Pageable_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12Pageable_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12Pageable_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12Pageable_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12Pageable_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12Pageable_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12Pageable_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12Pageable_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12Heap_INTERFACE_DEFINED__ +#define __ID3D12Heap_INTERFACE_DEFINED__ + +/* interface ID3D12Heap */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12Heap; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("6b3b2502-6e51-45b3-90ee-9884265e8df3") + ID3D12Heap : public ID3D12Pageable + { + public: + virtual D3D12_HEAP_DESC STDMETHODCALLTYPE GetDesc( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12HeapVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12Heap * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12Heap * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12Heap * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12Heap * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12Heap * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12Heap * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12Heap * This, + _In_z_ LPCWSTR Name); + + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12Heap * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + D3D12_HEAP_DESC ( STDMETHODCALLTYPE *GetDesc )( + ID3D12Heap * This); + + END_INTERFACE + } ID3D12HeapVtbl; + + interface ID3D12Heap + { + CONST_VTBL struct ID3D12HeapVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12Heap_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12Heap_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12Heap_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12Heap_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12Heap_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12Heap_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12Heap_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12Heap_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + + +#define ID3D12Heap_GetDesc(This) \ + ( (This)->lpVtbl -> GetDesc(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + + + + + +#endif /* __ID3D12Heap_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12Resource_INTERFACE_DEFINED__ +#define __ID3D12Resource_INTERFACE_DEFINED__ + +/* interface ID3D12Resource */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12Resource; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("696442be-a72e-4059-bc79-5b5c98040fad") + ID3D12Resource : public ID3D12Pageable + { + public: + virtual HRESULT STDMETHODCALLTYPE Map( + UINT Subresource, + _In_opt_ const D3D12_RANGE *pReadRange, + _Outptr_opt_result_bytebuffer_(_Inexpressible_("Dependent on resource")) void **ppData) = 0; + + virtual void STDMETHODCALLTYPE Unmap( + UINT Subresource, + _In_opt_ const D3D12_RANGE *pWrittenRange) = 0; + + virtual D3D12_RESOURCE_DESC STDMETHODCALLTYPE GetDesc( void) = 0; + + virtual D3D12_GPU_VIRTUAL_ADDRESS STDMETHODCALLTYPE GetGPUVirtualAddress( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE WriteToSubresource( + UINT DstSubresource, + _In_opt_ const D3D12_BOX *pDstBox, + _In_ const void *pSrcData, + UINT SrcRowPitch, + UINT SrcDepthPitch) = 0; + + virtual HRESULT STDMETHODCALLTYPE ReadFromSubresource( + _Out_ void *pDstData, + UINT DstRowPitch, + UINT DstDepthPitch, + UINT SrcSubresource, + _In_opt_ const D3D12_BOX *pSrcBox) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetHeapProperties( + _Out_opt_ D3D12_HEAP_PROPERTIES *pHeapProperties, + _Out_opt_ D3D12_HEAP_FLAGS *pHeapFlags) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12ResourceVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12Resource * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12Resource * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12Resource * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12Resource * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12Resource * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12Resource * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12Resource * This, + _In_z_ LPCWSTR Name); + + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12Resource * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + HRESULT ( STDMETHODCALLTYPE *Map )( + ID3D12Resource * This, + UINT Subresource, + _In_opt_ const D3D12_RANGE *pReadRange, + _Outptr_opt_result_bytebuffer_(_Inexpressible_("Dependent on resource")) void **ppData); + + void ( STDMETHODCALLTYPE *Unmap )( + ID3D12Resource * This, + UINT Subresource, + _In_opt_ const D3D12_RANGE *pWrittenRange); + + D3D12_RESOURCE_DESC ( STDMETHODCALLTYPE *GetDesc )( + ID3D12Resource * This); + + D3D12_GPU_VIRTUAL_ADDRESS ( STDMETHODCALLTYPE *GetGPUVirtualAddress )( + ID3D12Resource * This); + + HRESULT ( STDMETHODCALLTYPE *WriteToSubresource )( + ID3D12Resource * This, + UINT DstSubresource, + _In_opt_ const D3D12_BOX *pDstBox, + _In_ const void *pSrcData, + UINT SrcRowPitch, + UINT SrcDepthPitch); + + HRESULT ( STDMETHODCALLTYPE *ReadFromSubresource )( + ID3D12Resource * This, + _Out_ void *pDstData, + UINT DstRowPitch, + UINT DstDepthPitch, + UINT SrcSubresource, + _In_opt_ const D3D12_BOX *pSrcBox); + + HRESULT ( STDMETHODCALLTYPE *GetHeapProperties )( + ID3D12Resource * This, + _Out_opt_ D3D12_HEAP_PROPERTIES *pHeapProperties, + _Out_opt_ D3D12_HEAP_FLAGS *pHeapFlags); + + END_INTERFACE + } ID3D12ResourceVtbl; + + interface ID3D12Resource + { + CONST_VTBL struct ID3D12ResourceVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12Resource_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12Resource_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12Resource_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12Resource_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12Resource_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12Resource_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12Resource_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12Resource_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + + +#define ID3D12Resource_Map(This,Subresource,pReadRange,ppData) \ + ( (This)->lpVtbl -> Map(This,Subresource,pReadRange,ppData) ) + +#define ID3D12Resource_Unmap(This,Subresource,pWrittenRange) \ + ( (This)->lpVtbl -> Unmap(This,Subresource,pWrittenRange) ) + +#define ID3D12Resource_GetDesc(This) \ + ( (This)->lpVtbl -> GetDesc(This) ) + +#define ID3D12Resource_GetGPUVirtualAddress(This) \ + ( (This)->lpVtbl -> GetGPUVirtualAddress(This) ) + +#define ID3D12Resource_WriteToSubresource(This,DstSubresource,pDstBox,pSrcData,SrcRowPitch,SrcDepthPitch) \ + ( (This)->lpVtbl -> WriteToSubresource(This,DstSubresource,pDstBox,pSrcData,SrcRowPitch,SrcDepthPitch) ) + +#define ID3D12Resource_ReadFromSubresource(This,pDstData,DstRowPitch,DstDepthPitch,SrcSubresource,pSrcBox) \ + ( (This)->lpVtbl -> ReadFromSubresource(This,pDstData,DstRowPitch,DstDepthPitch,SrcSubresource,pSrcBox) ) + +#define ID3D12Resource_GetHeapProperties(This,pHeapProperties,pHeapFlags) \ + ( (This)->lpVtbl -> GetHeapProperties(This,pHeapProperties,pHeapFlags) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + + + + + +#endif /* __ID3D12Resource_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12CommandAllocator_INTERFACE_DEFINED__ +#define __ID3D12CommandAllocator_INTERFACE_DEFINED__ + +/* interface ID3D12CommandAllocator */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12CommandAllocator; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("6102dee4-af59-4b09-b999-b44d73f09b24") + ID3D12CommandAllocator : public ID3D12Pageable + { + public: + virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12CommandAllocatorVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12CommandAllocator * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12CommandAllocator * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12CommandAllocator * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12CommandAllocator * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12CommandAllocator * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12CommandAllocator * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12CommandAllocator * This, + _In_z_ LPCWSTR Name); + + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12CommandAllocator * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + HRESULT ( STDMETHODCALLTYPE *Reset )( + ID3D12CommandAllocator * This); + + END_INTERFACE + } ID3D12CommandAllocatorVtbl; + + interface ID3D12CommandAllocator + { + CONST_VTBL struct ID3D12CommandAllocatorVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12CommandAllocator_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12CommandAllocator_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12CommandAllocator_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12CommandAllocator_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12CommandAllocator_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12CommandAllocator_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12CommandAllocator_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12CommandAllocator_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + + +#define ID3D12CommandAllocator_Reset(This) \ + ( (This)->lpVtbl -> Reset(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12CommandAllocator_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12Fence_INTERFACE_DEFINED__ +#define __ID3D12Fence_INTERFACE_DEFINED__ + +/* interface ID3D12Fence */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12Fence; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("0a753dcf-c4d8-4b91-adf6-be5a60d95a76") + ID3D12Fence : public ID3D12Pageable + { + public: + virtual UINT64 STDMETHODCALLTYPE GetCompletedValue( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetEventOnCompletion( + UINT64 Value, + HANDLE hEvent) = 0; + + virtual HRESULT STDMETHODCALLTYPE Signal( + UINT64 Value) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12FenceVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12Fence * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12Fence * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12Fence * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12Fence * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12Fence * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12Fence * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12Fence * This, + _In_z_ LPCWSTR Name); + + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12Fence * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + UINT64 ( STDMETHODCALLTYPE *GetCompletedValue )( + ID3D12Fence * This); + + HRESULT ( STDMETHODCALLTYPE *SetEventOnCompletion )( + ID3D12Fence * This, + UINT64 Value, + HANDLE hEvent); + + HRESULT ( STDMETHODCALLTYPE *Signal )( + ID3D12Fence * This, + UINT64 Value); + + END_INTERFACE + } ID3D12FenceVtbl; + + interface ID3D12Fence + { + CONST_VTBL struct ID3D12FenceVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12Fence_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12Fence_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12Fence_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12Fence_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12Fence_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12Fence_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12Fence_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12Fence_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + + +#define ID3D12Fence_GetCompletedValue(This) \ + ( (This)->lpVtbl -> GetCompletedValue(This) ) + +#define ID3D12Fence_SetEventOnCompletion(This,Value,hEvent) \ + ( (This)->lpVtbl -> SetEventOnCompletion(This,Value,hEvent) ) + +#define ID3D12Fence_Signal(This,Value) \ + ( (This)->lpVtbl -> Signal(This,Value) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12Fence_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12Fence1_INTERFACE_DEFINED__ +#define __ID3D12Fence1_INTERFACE_DEFINED__ + +/* interface ID3D12Fence1 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12Fence1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("433685fe-e22b-4ca0-a8db-b5b4f4dd0e4a") + ID3D12Fence1 : public ID3D12Fence + { + public: + virtual D3D12_FENCE_FLAGS STDMETHODCALLTYPE GetCreationFlags( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12Fence1Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12Fence1 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12Fence1 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12Fence1 * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12Fence1 * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12Fence1 * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12Fence1 * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12Fence1 * This, + _In_z_ LPCWSTR Name); + + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12Fence1 * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + UINT64 ( STDMETHODCALLTYPE *GetCompletedValue )( + ID3D12Fence1 * This); + + HRESULT ( STDMETHODCALLTYPE *SetEventOnCompletion )( + ID3D12Fence1 * This, + UINT64 Value, + HANDLE hEvent); + + HRESULT ( STDMETHODCALLTYPE *Signal )( + ID3D12Fence1 * This, + UINT64 Value); + + D3D12_FENCE_FLAGS ( STDMETHODCALLTYPE *GetCreationFlags )( + ID3D12Fence1 * This); + + END_INTERFACE + } ID3D12Fence1Vtbl; + + interface ID3D12Fence1 + { + CONST_VTBL struct ID3D12Fence1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12Fence1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12Fence1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12Fence1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12Fence1_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12Fence1_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12Fence1_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12Fence1_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12Fence1_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + + +#define ID3D12Fence1_GetCompletedValue(This) \ + ( (This)->lpVtbl -> GetCompletedValue(This) ) + +#define ID3D12Fence1_SetEventOnCompletion(This,Value,hEvent) \ + ( (This)->lpVtbl -> SetEventOnCompletion(This,Value,hEvent) ) + +#define ID3D12Fence1_Signal(This,Value) \ + ( (This)->lpVtbl -> Signal(This,Value) ) + + +#define ID3D12Fence1_GetCreationFlags(This) \ + ( (This)->lpVtbl -> GetCreationFlags(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12Fence1_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12PipelineState_INTERFACE_DEFINED__ +#define __ID3D12PipelineState_INTERFACE_DEFINED__ + +/* interface ID3D12PipelineState */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12PipelineState; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("765a30f3-f624-4c6f-a828-ace948622445") + ID3D12PipelineState : public ID3D12Pageable + { + public: + virtual HRESULT STDMETHODCALLTYPE GetCachedBlob( + _COM_Outptr_ ID3DBlob **ppBlob) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12PipelineStateVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12PipelineState * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12PipelineState * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12PipelineState * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12PipelineState * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12PipelineState * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12PipelineState * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12PipelineState * This, + _In_z_ LPCWSTR Name); + + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12PipelineState * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + HRESULT ( STDMETHODCALLTYPE *GetCachedBlob )( + ID3D12PipelineState * This, + _COM_Outptr_ ID3DBlob **ppBlob); + + END_INTERFACE + } ID3D12PipelineStateVtbl; + + interface ID3D12PipelineState + { + CONST_VTBL struct ID3D12PipelineStateVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12PipelineState_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12PipelineState_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12PipelineState_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12PipelineState_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12PipelineState_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12PipelineState_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12PipelineState_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12PipelineState_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + + +#define ID3D12PipelineState_GetCachedBlob(This,ppBlob) \ + ( (This)->lpVtbl -> GetCachedBlob(This,ppBlob) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12PipelineState_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12DescriptorHeap_INTERFACE_DEFINED__ +#define __ID3D12DescriptorHeap_INTERFACE_DEFINED__ + +/* interface ID3D12DescriptorHeap */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12DescriptorHeap; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("8efb471d-616c-4f49-90f7-127bb763fa51") + ID3D12DescriptorHeap : public ID3D12Pageable + { + public: + virtual D3D12_DESCRIPTOR_HEAP_DESC STDMETHODCALLTYPE GetDesc( void) = 0; + + virtual D3D12_CPU_DESCRIPTOR_HANDLE STDMETHODCALLTYPE GetCPUDescriptorHandleForHeapStart( void) = 0; + + virtual D3D12_GPU_DESCRIPTOR_HANDLE STDMETHODCALLTYPE GetGPUDescriptorHandleForHeapStart( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12DescriptorHeapVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12DescriptorHeap * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12DescriptorHeap * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12DescriptorHeap * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12DescriptorHeap * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12DescriptorHeap * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12DescriptorHeap * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12DescriptorHeap * This, + _In_z_ LPCWSTR Name); + + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12DescriptorHeap * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + D3D12_DESCRIPTOR_HEAP_DESC ( STDMETHODCALLTYPE *GetDesc )( + ID3D12DescriptorHeap * This); + + D3D12_CPU_DESCRIPTOR_HANDLE ( STDMETHODCALLTYPE *GetCPUDescriptorHandleForHeapStart )( + ID3D12DescriptorHeap * This); + + D3D12_GPU_DESCRIPTOR_HANDLE ( STDMETHODCALLTYPE *GetGPUDescriptorHandleForHeapStart )( + ID3D12DescriptorHeap * This); + + END_INTERFACE + } ID3D12DescriptorHeapVtbl; + + interface ID3D12DescriptorHeap + { + CONST_VTBL struct ID3D12DescriptorHeapVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12DescriptorHeap_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12DescriptorHeap_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12DescriptorHeap_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12DescriptorHeap_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12DescriptorHeap_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12DescriptorHeap_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12DescriptorHeap_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12DescriptorHeap_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + + +#define ID3D12DescriptorHeap_GetDesc(This) \ + ( (This)->lpVtbl -> GetDesc(This) ) + +#define ID3D12DescriptorHeap_GetCPUDescriptorHandleForHeapStart(This) \ + ( (This)->lpVtbl -> GetCPUDescriptorHandleForHeapStart(This) ) + +#define ID3D12DescriptorHeap_GetGPUDescriptorHandleForHeapStart(This) \ + ( (This)->lpVtbl -> GetGPUDescriptorHandleForHeapStart(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + + + + + + + + + + + + + +#endif /* __ID3D12DescriptorHeap_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12QueryHeap_INTERFACE_DEFINED__ +#define __ID3D12QueryHeap_INTERFACE_DEFINED__ + +/* interface ID3D12QueryHeap */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12QueryHeap; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("0d9658ae-ed45-469e-a61d-970ec583cab4") + ID3D12QueryHeap : public ID3D12Pageable + { + public: + }; + + +#else /* C style interface */ + + typedef struct ID3D12QueryHeapVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12QueryHeap * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12QueryHeap * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12QueryHeap * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12QueryHeap * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12QueryHeap * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12QueryHeap * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12QueryHeap * This, + _In_z_ LPCWSTR Name); + + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12QueryHeap * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + END_INTERFACE + } ID3D12QueryHeapVtbl; + + interface ID3D12QueryHeap + { + CONST_VTBL struct ID3D12QueryHeapVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12QueryHeap_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12QueryHeap_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12QueryHeap_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12QueryHeap_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12QueryHeap_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12QueryHeap_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12QueryHeap_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12QueryHeap_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12QueryHeap_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12CommandSignature_INTERFACE_DEFINED__ +#define __ID3D12CommandSignature_INTERFACE_DEFINED__ + +/* interface ID3D12CommandSignature */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12CommandSignature; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("c36a797c-ec80-4f0a-8985-a7b2475082d1") + ID3D12CommandSignature : public ID3D12Pageable + { + public: + }; + + +#else /* C style interface */ + + typedef struct ID3D12CommandSignatureVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12CommandSignature * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12CommandSignature * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12CommandSignature * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12CommandSignature * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12CommandSignature * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12CommandSignature * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12CommandSignature * This, + _In_z_ LPCWSTR Name); + + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12CommandSignature * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + END_INTERFACE + } ID3D12CommandSignatureVtbl; + + interface ID3D12CommandSignature + { + CONST_VTBL struct ID3D12CommandSignatureVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12CommandSignature_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12CommandSignature_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12CommandSignature_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12CommandSignature_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12CommandSignature_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12CommandSignature_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12CommandSignature_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12CommandSignature_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12CommandSignature_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12CommandList_INTERFACE_DEFINED__ +#define __ID3D12CommandList_INTERFACE_DEFINED__ + +/* interface ID3D12CommandList */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12CommandList; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("7116d91c-e7e4-47ce-b8c6-ec8168f437e5") + ID3D12CommandList : public ID3D12DeviceChild + { + public: + virtual D3D12_COMMAND_LIST_TYPE STDMETHODCALLTYPE GetType( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12CommandListVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12CommandList * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12CommandList * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12CommandList * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12CommandList * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12CommandList * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12CommandList * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12CommandList * This, + _In_z_ LPCWSTR Name); + + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12CommandList * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( + ID3D12CommandList * This); + + END_INTERFACE + } ID3D12CommandListVtbl; + + interface ID3D12CommandList + { + CONST_VTBL struct ID3D12CommandListVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12CommandList_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12CommandList_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12CommandList_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12CommandList_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12CommandList_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12CommandList_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12CommandList_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12CommandList_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + +#define ID3D12CommandList_GetType(This) \ + ( (This)->lpVtbl -> GetType(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12CommandList_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12GraphicsCommandList_INTERFACE_DEFINED__ +#define __ID3D12GraphicsCommandList_INTERFACE_DEFINED__ + +/* interface ID3D12GraphicsCommandList */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12GraphicsCommandList; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("5b160d0f-ac1b-4185-8ba8-b3ae42a5a455") + ID3D12GraphicsCommandList : public ID3D12CommandList + { + public: + virtual HRESULT STDMETHODCALLTYPE Close( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reset( + _In_ ID3D12CommandAllocator *pAllocator, + _In_opt_ ID3D12PipelineState *pInitialState) = 0; + + virtual void STDMETHODCALLTYPE ClearState( + _In_opt_ ID3D12PipelineState *pPipelineState) = 0; + + virtual void STDMETHODCALLTYPE DrawInstanced( + _In_ UINT VertexCountPerInstance, + _In_ UINT InstanceCount, + _In_ UINT StartVertexLocation, + _In_ UINT StartInstanceLocation) = 0; + + virtual void STDMETHODCALLTYPE DrawIndexedInstanced( + _In_ UINT IndexCountPerInstance, + _In_ UINT InstanceCount, + _In_ UINT StartIndexLocation, + _In_ INT BaseVertexLocation, + _In_ UINT StartInstanceLocation) = 0; + + virtual void STDMETHODCALLTYPE Dispatch( + _In_ UINT ThreadGroupCountX, + _In_ UINT ThreadGroupCountY, + _In_ UINT ThreadGroupCountZ) = 0; + + virtual void STDMETHODCALLTYPE CopyBufferRegion( + _In_ ID3D12Resource *pDstBuffer, + UINT64 DstOffset, + _In_ ID3D12Resource *pSrcBuffer, + UINT64 SrcOffset, + UINT64 NumBytes) = 0; + + virtual void STDMETHODCALLTYPE CopyTextureRegion( + _In_ const D3D12_TEXTURE_COPY_LOCATION *pDst, + UINT DstX, + UINT DstY, + UINT DstZ, + _In_ const D3D12_TEXTURE_COPY_LOCATION *pSrc, + _In_opt_ const D3D12_BOX *pSrcBox) = 0; + + virtual void STDMETHODCALLTYPE CopyResource( + _In_ ID3D12Resource *pDstResource, + _In_ ID3D12Resource *pSrcResource) = 0; + + virtual void STDMETHODCALLTYPE CopyTiles( + _In_ ID3D12Resource *pTiledResource, + _In_ const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate, + _In_ const D3D12_TILE_REGION_SIZE *pTileRegionSize, + _In_ ID3D12Resource *pBuffer, + UINT64 BufferStartOffsetInBytes, + D3D12_TILE_COPY_FLAGS Flags) = 0; + + virtual void STDMETHODCALLTYPE ResolveSubresource( + _In_ ID3D12Resource *pDstResource, + _In_ UINT DstSubresource, + _In_ ID3D12Resource *pSrcResource, + _In_ UINT SrcSubresource, + _In_ DXGI_FORMAT Format) = 0; + + virtual void STDMETHODCALLTYPE IASetPrimitiveTopology( + _In_ D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology) = 0; + + virtual void STDMETHODCALLTYPE RSSetViewports( + _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumViewports, + _In_reads_( NumViewports) const D3D12_VIEWPORT *pViewports) = 0; + + virtual void STDMETHODCALLTYPE RSSetScissorRects( + _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumRects, + _In_reads_( NumRects) const D3D12_RECT *pRects) = 0; + + virtual void STDMETHODCALLTYPE OMSetBlendFactor( + _In_reads_opt_(4) const FLOAT BlendFactor[ 4 ]) = 0; + + virtual void STDMETHODCALLTYPE OMSetStencilRef( + _In_ UINT StencilRef) = 0; + + virtual void STDMETHODCALLTYPE SetPipelineState( + _In_ ID3D12PipelineState *pPipelineState) = 0; + + virtual void STDMETHODCALLTYPE ResourceBarrier( + _In_ UINT NumBarriers, + _In_reads_(NumBarriers) const D3D12_RESOURCE_BARRIER *pBarriers) = 0; + + virtual void STDMETHODCALLTYPE ExecuteBundle( + _In_ ID3D12GraphicsCommandList *pCommandList) = 0; + + virtual void STDMETHODCALLTYPE SetDescriptorHeaps( + _In_ UINT NumDescriptorHeaps, + _In_reads_(NumDescriptorHeaps) ID3D12DescriptorHeap *const *ppDescriptorHeaps) = 0; + + virtual void STDMETHODCALLTYPE SetComputeRootSignature( + _In_opt_ ID3D12RootSignature *pRootSignature) = 0; + + virtual void STDMETHODCALLTYPE SetGraphicsRootSignature( + _In_opt_ ID3D12RootSignature *pRootSignature) = 0; + + virtual void STDMETHODCALLTYPE SetComputeRootDescriptorTable( + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor) = 0; + + virtual void STDMETHODCALLTYPE SetGraphicsRootDescriptorTable( + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor) = 0; + + virtual void STDMETHODCALLTYPE SetComputeRoot32BitConstant( + _In_ UINT RootParameterIndex, + _In_ UINT SrcData, + _In_ UINT DestOffsetIn32BitValues) = 0; + + virtual void STDMETHODCALLTYPE SetGraphicsRoot32BitConstant( + _In_ UINT RootParameterIndex, + _In_ UINT SrcData, + _In_ UINT DestOffsetIn32BitValues) = 0; + + virtual void STDMETHODCALLTYPE SetComputeRoot32BitConstants( + _In_ UINT RootParameterIndex, + _In_ UINT Num32BitValuesToSet, + _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, + _In_ UINT DestOffsetIn32BitValues) = 0; + + virtual void STDMETHODCALLTYPE SetGraphicsRoot32BitConstants( + _In_ UINT RootParameterIndex, + _In_ UINT Num32BitValuesToSet, + _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, + _In_ UINT DestOffsetIn32BitValues) = 0; + + virtual void STDMETHODCALLTYPE SetComputeRootConstantBufferView( + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation) = 0; + + virtual void STDMETHODCALLTYPE SetGraphicsRootConstantBufferView( + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation) = 0; + + virtual void STDMETHODCALLTYPE SetComputeRootShaderResourceView( + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation) = 0; + + virtual void STDMETHODCALLTYPE SetGraphicsRootShaderResourceView( + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation) = 0; + + virtual void STDMETHODCALLTYPE SetComputeRootUnorderedAccessView( + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation) = 0; + + virtual void STDMETHODCALLTYPE SetGraphicsRootUnorderedAccessView( + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation) = 0; + + virtual void STDMETHODCALLTYPE IASetIndexBuffer( + _In_opt_ const D3D12_INDEX_BUFFER_VIEW *pView) = 0; + + virtual void STDMETHODCALLTYPE IASetVertexBuffers( + _In_ UINT StartSlot, + _In_ UINT NumViews, + _In_reads_opt_(NumViews) const D3D12_VERTEX_BUFFER_VIEW *pViews) = 0; + + virtual void STDMETHODCALLTYPE SOSetTargets( + _In_ UINT StartSlot, + _In_ UINT NumViews, + _In_reads_opt_(NumViews) const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews) = 0; + + virtual void STDMETHODCALLTYPE OMSetRenderTargets( + _In_ UINT NumRenderTargetDescriptors, + _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors, + _In_ BOOL RTsSingleHandleToDescriptorRange, + _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pDepthStencilDescriptor) = 0; + + virtual void STDMETHODCALLTYPE ClearDepthStencilView( + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView, + _In_ D3D12_CLEAR_FLAGS ClearFlags, + _In_ FLOAT Depth, + _In_ UINT8 Stencil, + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects) = 0; + + virtual void STDMETHODCALLTYPE ClearRenderTargetView( + _In_ D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView, + _In_ const FLOAT ColorRGBA[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects) = 0; + + virtual void STDMETHODCALLTYPE ClearUnorderedAccessViewUint( + _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, + _In_ ID3D12Resource *pResource, + _In_ const UINT Values[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects) = 0; + + virtual void STDMETHODCALLTYPE ClearUnorderedAccessViewFloat( + _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, + _In_ ID3D12Resource *pResource, + _In_ const FLOAT Values[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects) = 0; + + virtual void STDMETHODCALLTYPE DiscardResource( + _In_ ID3D12Resource *pResource, + _In_opt_ const D3D12_DISCARD_REGION *pRegion) = 0; + + virtual void STDMETHODCALLTYPE BeginQuery( + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT Index) = 0; + + virtual void STDMETHODCALLTYPE EndQuery( + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT Index) = 0; + + virtual void STDMETHODCALLTYPE ResolveQueryData( + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT StartIndex, + _In_ UINT NumQueries, + _In_ ID3D12Resource *pDestinationBuffer, + _In_ UINT64 AlignedDestinationBufferOffset) = 0; + + virtual void STDMETHODCALLTYPE SetPredication( + _In_opt_ ID3D12Resource *pBuffer, + _In_ UINT64 AlignedBufferOffset, + _In_ D3D12_PREDICATION_OP Operation) = 0; + + virtual void STDMETHODCALLTYPE SetMarker( + UINT Metadata, + _In_reads_bytes_opt_(Size) const void *pData, + UINT Size) = 0; + + virtual void STDMETHODCALLTYPE BeginEvent( + UINT Metadata, + _In_reads_bytes_opt_(Size) const void *pData, + UINT Size) = 0; + + virtual void STDMETHODCALLTYPE EndEvent( void) = 0; + + virtual void STDMETHODCALLTYPE ExecuteIndirect( + _In_ ID3D12CommandSignature *pCommandSignature, + _In_ UINT MaxCommandCount, + _In_ ID3D12Resource *pArgumentBuffer, + _In_ UINT64 ArgumentBufferOffset, + _In_opt_ ID3D12Resource *pCountBuffer, + _In_ UINT64 CountBufferOffset) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12GraphicsCommandListVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12GraphicsCommandList * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12GraphicsCommandList * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12GraphicsCommandList * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12GraphicsCommandList * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12GraphicsCommandList * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12GraphicsCommandList * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12GraphicsCommandList * This, + _In_z_ LPCWSTR Name); + + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12GraphicsCommandList * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( + ID3D12GraphicsCommandList * This); + + HRESULT ( STDMETHODCALLTYPE *Close )( + ID3D12GraphicsCommandList * This); + + HRESULT ( STDMETHODCALLTYPE *Reset )( + ID3D12GraphicsCommandList * This, + _In_ ID3D12CommandAllocator *pAllocator, + _In_opt_ ID3D12PipelineState *pInitialState); + + void ( STDMETHODCALLTYPE *ClearState )( + ID3D12GraphicsCommandList * This, + _In_opt_ ID3D12PipelineState *pPipelineState); + + void ( STDMETHODCALLTYPE *DrawInstanced )( + ID3D12GraphicsCommandList * This, + _In_ UINT VertexCountPerInstance, + _In_ UINT InstanceCount, + _In_ UINT StartVertexLocation, + _In_ UINT StartInstanceLocation); + + void ( STDMETHODCALLTYPE *DrawIndexedInstanced )( + ID3D12GraphicsCommandList * This, + _In_ UINT IndexCountPerInstance, + _In_ UINT InstanceCount, + _In_ UINT StartIndexLocation, + _In_ INT BaseVertexLocation, + _In_ UINT StartInstanceLocation); + + void ( STDMETHODCALLTYPE *Dispatch )( + ID3D12GraphicsCommandList * This, + _In_ UINT ThreadGroupCountX, + _In_ UINT ThreadGroupCountY, + _In_ UINT ThreadGroupCountZ); + + void ( STDMETHODCALLTYPE *CopyBufferRegion )( + ID3D12GraphicsCommandList * This, + _In_ ID3D12Resource *pDstBuffer, + UINT64 DstOffset, + _In_ ID3D12Resource *pSrcBuffer, + UINT64 SrcOffset, + UINT64 NumBytes); + + void ( STDMETHODCALLTYPE *CopyTextureRegion )( + ID3D12GraphicsCommandList * This, + _In_ const D3D12_TEXTURE_COPY_LOCATION *pDst, + UINT DstX, + UINT DstY, + UINT DstZ, + _In_ const D3D12_TEXTURE_COPY_LOCATION *pSrc, + _In_opt_ const D3D12_BOX *pSrcBox); + + void ( STDMETHODCALLTYPE *CopyResource )( + ID3D12GraphicsCommandList * This, + _In_ ID3D12Resource *pDstResource, + _In_ ID3D12Resource *pSrcResource); + + void ( STDMETHODCALLTYPE *CopyTiles )( + ID3D12GraphicsCommandList * This, + _In_ ID3D12Resource *pTiledResource, + _In_ const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate, + _In_ const D3D12_TILE_REGION_SIZE *pTileRegionSize, + _In_ ID3D12Resource *pBuffer, + UINT64 BufferStartOffsetInBytes, + D3D12_TILE_COPY_FLAGS Flags); + + void ( STDMETHODCALLTYPE *ResolveSubresource )( + ID3D12GraphicsCommandList * This, + _In_ ID3D12Resource *pDstResource, + _In_ UINT DstSubresource, + _In_ ID3D12Resource *pSrcResource, + _In_ UINT SrcSubresource, + _In_ DXGI_FORMAT Format); + + void ( STDMETHODCALLTYPE *IASetPrimitiveTopology )( + ID3D12GraphicsCommandList * This, + _In_ D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology); + + void ( STDMETHODCALLTYPE *RSSetViewports )( + ID3D12GraphicsCommandList * This, + _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumViewports, + _In_reads_( NumViewports) const D3D12_VIEWPORT *pViewports); + + void ( STDMETHODCALLTYPE *RSSetScissorRects )( + ID3D12GraphicsCommandList * This, + _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumRects, + _In_reads_( NumRects) const D3D12_RECT *pRects); + + void ( STDMETHODCALLTYPE *OMSetBlendFactor )( + ID3D12GraphicsCommandList * This, + _In_reads_opt_(4) const FLOAT BlendFactor[ 4 ]); + + void ( STDMETHODCALLTYPE *OMSetStencilRef )( + ID3D12GraphicsCommandList * This, + _In_ UINT StencilRef); + + void ( STDMETHODCALLTYPE *SetPipelineState )( + ID3D12GraphicsCommandList * This, + _In_ ID3D12PipelineState *pPipelineState); + + void ( STDMETHODCALLTYPE *ResourceBarrier )( + ID3D12GraphicsCommandList * This, + _In_ UINT NumBarriers, + _In_reads_(NumBarriers) const D3D12_RESOURCE_BARRIER *pBarriers); + + void ( STDMETHODCALLTYPE *ExecuteBundle )( + ID3D12GraphicsCommandList * This, + _In_ ID3D12GraphicsCommandList *pCommandList); + + void ( STDMETHODCALLTYPE *SetDescriptorHeaps )( + ID3D12GraphicsCommandList * This, + _In_ UINT NumDescriptorHeaps, + _In_reads_(NumDescriptorHeaps) ID3D12DescriptorHeap *const *ppDescriptorHeaps); + + void ( STDMETHODCALLTYPE *SetComputeRootSignature )( + ID3D12GraphicsCommandList * This, + _In_opt_ ID3D12RootSignature *pRootSignature); + + void ( STDMETHODCALLTYPE *SetGraphicsRootSignature )( + ID3D12GraphicsCommandList * This, + _In_opt_ ID3D12RootSignature *pRootSignature); + + void ( STDMETHODCALLTYPE *SetComputeRootDescriptorTable )( + ID3D12GraphicsCommandList * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); + + void ( STDMETHODCALLTYPE *SetGraphicsRootDescriptorTable )( + ID3D12GraphicsCommandList * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); + + void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstant )( + ID3D12GraphicsCommandList * This, + _In_ UINT RootParameterIndex, + _In_ UINT SrcData, + _In_ UINT DestOffsetIn32BitValues); + + void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstant )( + ID3D12GraphicsCommandList * This, + _In_ UINT RootParameterIndex, + _In_ UINT SrcData, + _In_ UINT DestOffsetIn32BitValues); + + void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstants )( + ID3D12GraphicsCommandList * This, + _In_ UINT RootParameterIndex, + _In_ UINT Num32BitValuesToSet, + _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, + _In_ UINT DestOffsetIn32BitValues); + + void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstants )( + ID3D12GraphicsCommandList * This, + _In_ UINT RootParameterIndex, + _In_ UINT Num32BitValuesToSet, + _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, + _In_ UINT DestOffsetIn32BitValues); + + void ( STDMETHODCALLTYPE *SetComputeRootConstantBufferView )( + ID3D12GraphicsCommandList * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *SetGraphicsRootConstantBufferView )( + ID3D12GraphicsCommandList * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *SetComputeRootShaderResourceView )( + ID3D12GraphicsCommandList * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *SetGraphicsRootShaderResourceView )( + ID3D12GraphicsCommandList * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *SetComputeRootUnorderedAccessView )( + ID3D12GraphicsCommandList * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *SetGraphicsRootUnorderedAccessView )( + ID3D12GraphicsCommandList * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *IASetIndexBuffer )( + ID3D12GraphicsCommandList * This, + _In_opt_ const D3D12_INDEX_BUFFER_VIEW *pView); + + void ( STDMETHODCALLTYPE *IASetVertexBuffers )( + ID3D12GraphicsCommandList * This, + _In_ UINT StartSlot, + _In_ UINT NumViews, + _In_reads_opt_(NumViews) const D3D12_VERTEX_BUFFER_VIEW *pViews); + + void ( STDMETHODCALLTYPE *SOSetTargets )( + ID3D12GraphicsCommandList * This, + _In_ UINT StartSlot, + _In_ UINT NumViews, + _In_reads_opt_(NumViews) const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews); + + void ( STDMETHODCALLTYPE *OMSetRenderTargets )( + ID3D12GraphicsCommandList * This, + _In_ UINT NumRenderTargetDescriptors, + _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors, + _In_ BOOL RTsSingleHandleToDescriptorRange, + _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pDepthStencilDescriptor); + + void ( STDMETHODCALLTYPE *ClearDepthStencilView )( + ID3D12GraphicsCommandList * This, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView, + _In_ D3D12_CLEAR_FLAGS ClearFlags, + _In_ FLOAT Depth, + _In_ UINT8 Stencil, + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); + + void ( STDMETHODCALLTYPE *ClearRenderTargetView )( + ID3D12GraphicsCommandList * This, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView, + _In_ const FLOAT ColorRGBA[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); + + void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewUint )( + ID3D12GraphicsCommandList * This, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, + _In_ ID3D12Resource *pResource, + _In_ const UINT Values[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); + + void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewFloat )( + ID3D12GraphicsCommandList * This, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, + _In_ ID3D12Resource *pResource, + _In_ const FLOAT Values[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); + + void ( STDMETHODCALLTYPE *DiscardResource )( + ID3D12GraphicsCommandList * This, + _In_ ID3D12Resource *pResource, + _In_opt_ const D3D12_DISCARD_REGION *pRegion); + + void ( STDMETHODCALLTYPE *BeginQuery )( + ID3D12GraphicsCommandList * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT Index); + + void ( STDMETHODCALLTYPE *EndQuery )( + ID3D12GraphicsCommandList * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT Index); + + void ( STDMETHODCALLTYPE *ResolveQueryData )( + ID3D12GraphicsCommandList * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT StartIndex, + _In_ UINT NumQueries, + _In_ ID3D12Resource *pDestinationBuffer, + _In_ UINT64 AlignedDestinationBufferOffset); + + void ( STDMETHODCALLTYPE *SetPredication )( + ID3D12GraphicsCommandList * This, + _In_opt_ ID3D12Resource *pBuffer, + _In_ UINT64 AlignedBufferOffset, + _In_ D3D12_PREDICATION_OP Operation); + + void ( STDMETHODCALLTYPE *SetMarker )( + ID3D12GraphicsCommandList * This, + UINT Metadata, + _In_reads_bytes_opt_(Size) const void *pData, + UINT Size); + + void ( STDMETHODCALLTYPE *BeginEvent )( + ID3D12GraphicsCommandList * This, + UINT Metadata, + _In_reads_bytes_opt_(Size) const void *pData, + UINT Size); + + void ( STDMETHODCALLTYPE *EndEvent )( + ID3D12GraphicsCommandList * This); + + void ( STDMETHODCALLTYPE *ExecuteIndirect )( + ID3D12GraphicsCommandList * This, + _In_ ID3D12CommandSignature *pCommandSignature, + _In_ UINT MaxCommandCount, + _In_ ID3D12Resource *pArgumentBuffer, + _In_ UINT64 ArgumentBufferOffset, + _In_opt_ ID3D12Resource *pCountBuffer, + _In_ UINT64 CountBufferOffset); + + END_INTERFACE + } ID3D12GraphicsCommandListVtbl; + + interface ID3D12GraphicsCommandList + { + CONST_VTBL struct ID3D12GraphicsCommandListVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12GraphicsCommandList_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12GraphicsCommandList_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12GraphicsCommandList_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12GraphicsCommandList_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12GraphicsCommandList_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12GraphicsCommandList_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12GraphicsCommandList_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12GraphicsCommandList_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + +#define ID3D12GraphicsCommandList_GetType(This) \ + ( (This)->lpVtbl -> GetType(This) ) + + +#define ID3D12GraphicsCommandList_Close(This) \ + ( (This)->lpVtbl -> Close(This) ) + +#define ID3D12GraphicsCommandList_Reset(This,pAllocator,pInitialState) \ + ( (This)->lpVtbl -> Reset(This,pAllocator,pInitialState) ) + +#define ID3D12GraphicsCommandList_ClearState(This,pPipelineState) \ + ( (This)->lpVtbl -> ClearState(This,pPipelineState) ) + +#define ID3D12GraphicsCommandList_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) \ + ( (This)->lpVtbl -> DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) ) + +#define ID3D12GraphicsCommandList_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) \ + ( (This)->lpVtbl -> DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) ) + +#define ID3D12GraphicsCommandList_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ + ( (This)->lpVtbl -> Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) + +#define ID3D12GraphicsCommandList_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) \ + ( (This)->lpVtbl -> CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) ) + +#define ID3D12GraphicsCommandList_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) \ + ( (This)->lpVtbl -> CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) ) + +#define ID3D12GraphicsCommandList_CopyResource(This,pDstResource,pSrcResource) \ + ( (This)->lpVtbl -> CopyResource(This,pDstResource,pSrcResource) ) + +#define ID3D12GraphicsCommandList_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) \ + ( (This)->lpVtbl -> CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) ) + +#define ID3D12GraphicsCommandList_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) \ + ( (This)->lpVtbl -> ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) ) + +#define ID3D12GraphicsCommandList_IASetPrimitiveTopology(This,PrimitiveTopology) \ + ( (This)->lpVtbl -> IASetPrimitiveTopology(This,PrimitiveTopology) ) + +#define ID3D12GraphicsCommandList_RSSetViewports(This,NumViewports,pViewports) \ + ( (This)->lpVtbl -> RSSetViewports(This,NumViewports,pViewports) ) + +#define ID3D12GraphicsCommandList_RSSetScissorRects(This,NumRects,pRects) \ + ( (This)->lpVtbl -> RSSetScissorRects(This,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList_OMSetBlendFactor(This,BlendFactor) \ + ( (This)->lpVtbl -> OMSetBlendFactor(This,BlendFactor) ) + +#define ID3D12GraphicsCommandList_OMSetStencilRef(This,StencilRef) \ + ( (This)->lpVtbl -> OMSetStencilRef(This,StencilRef) ) + +#define ID3D12GraphicsCommandList_SetPipelineState(This,pPipelineState) \ + ( (This)->lpVtbl -> SetPipelineState(This,pPipelineState) ) + +#define ID3D12GraphicsCommandList_ResourceBarrier(This,NumBarriers,pBarriers) \ + ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) + +#define ID3D12GraphicsCommandList_ExecuteBundle(This,pCommandList) \ + ( (This)->lpVtbl -> ExecuteBundle(This,pCommandList) ) + +#define ID3D12GraphicsCommandList_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) \ + ( (This)->lpVtbl -> SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) ) + +#define ID3D12GraphicsCommandList_SetComputeRootSignature(This,pRootSignature) \ + ( (This)->lpVtbl -> SetComputeRootSignature(This,pRootSignature) ) + +#define ID3D12GraphicsCommandList_SetGraphicsRootSignature(This,pRootSignature) \ + ( (This)->lpVtbl -> SetGraphicsRootSignature(This,pRootSignature) ) + +#define ID3D12GraphicsCommandList_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ + ( (This)->lpVtbl -> SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) + +#define ID3D12GraphicsCommandList_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ + ( (This)->lpVtbl -> SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) + +#define ID3D12GraphicsCommandList_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) + +#define ID3D12GraphicsCommandList_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) + +#define ID3D12GraphicsCommandList_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) + +#define ID3D12GraphicsCommandList_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) + +#define ID3D12GraphicsCommandList_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList_IASetIndexBuffer(This,pView) \ + ( (This)->lpVtbl -> IASetIndexBuffer(This,pView) ) + +#define ID3D12GraphicsCommandList_IASetVertexBuffers(This,StartSlot,NumViews,pViews) \ + ( (This)->lpVtbl -> IASetVertexBuffers(This,StartSlot,NumViews,pViews) ) + +#define ID3D12GraphicsCommandList_SOSetTargets(This,StartSlot,NumViews,pViews) \ + ( (This)->lpVtbl -> SOSetTargets(This,StartSlot,NumViews,pViews) ) + +#define ID3D12GraphicsCommandList_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) \ + ( (This)->lpVtbl -> OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) ) + +#define ID3D12GraphicsCommandList_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList_DiscardResource(This,pResource,pRegion) \ + ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) + +#define ID3D12GraphicsCommandList_BeginQuery(This,pQueryHeap,Type,Index) \ + ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) + +#define ID3D12GraphicsCommandList_EndQuery(This,pQueryHeap,Type,Index) \ + ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) + +#define ID3D12GraphicsCommandList_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) \ + ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) + +#define ID3D12GraphicsCommandList_SetPredication(This,pBuffer,AlignedBufferOffset,Operation) \ + ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) + +#define ID3D12GraphicsCommandList_SetMarker(This,Metadata,pData,Size) \ + ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) + +#define ID3D12GraphicsCommandList_BeginEvent(This,Metadata,pData,Size) \ + ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) + +#define ID3D12GraphicsCommandList_EndEvent(This) \ + ( (This)->lpVtbl -> EndEvent(This) ) + +#define ID3D12GraphicsCommandList_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) \ + ( (This)->lpVtbl -> ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12GraphicsCommandList_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12GraphicsCommandList1_INTERFACE_DEFINED__ +#define __ID3D12GraphicsCommandList1_INTERFACE_DEFINED__ + +/* interface ID3D12GraphicsCommandList1 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12GraphicsCommandList1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("553103fb-1fe7-4557-bb38-946d7d0e7ca7") + ID3D12GraphicsCommandList1 : public ID3D12GraphicsCommandList + { + public: + virtual void STDMETHODCALLTYPE AtomicCopyBufferUINT( + _In_ ID3D12Resource *pDstBuffer, + UINT64 DstOffset, + _In_ ID3D12Resource *pSrcBuffer, + UINT64 SrcOffset, + UINT Dependencies, + _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, + _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges) = 0; + + virtual void STDMETHODCALLTYPE AtomicCopyBufferUINT64( + _In_ ID3D12Resource *pDstBuffer, + UINT64 DstOffset, + _In_ ID3D12Resource *pSrcBuffer, + UINT64 SrcOffset, + UINT Dependencies, + _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, + _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges) = 0; + + virtual void STDMETHODCALLTYPE OMSetDepthBounds( + _In_ FLOAT Min, + _In_ FLOAT Max) = 0; + + virtual void STDMETHODCALLTYPE SetSamplePositions( + _In_ UINT NumSamplesPerPixel, + _In_ UINT NumPixels, + _In_reads_(NumSamplesPerPixel*NumPixels) D3D12_SAMPLE_POSITION *pSamplePositions) = 0; + + virtual void STDMETHODCALLTYPE ResolveSubresourceRegion( + _In_ ID3D12Resource *pDstResource, + _In_ UINT DstSubresource, + _In_ UINT DstX, + _In_ UINT DstY, + _In_ ID3D12Resource *pSrcResource, + _In_ UINT SrcSubresource, + _In_opt_ D3D12_RECT *pSrcRect, + _In_ DXGI_FORMAT Format, + _In_ D3D12_RESOLVE_MODE ResolveMode) = 0; + + virtual void STDMETHODCALLTYPE SetViewInstanceMask( + _In_ UINT Mask) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12GraphicsCommandList1Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12GraphicsCommandList1 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12GraphicsCommandList1 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12GraphicsCommandList1 * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12GraphicsCommandList1 * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12GraphicsCommandList1 * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12GraphicsCommandList1 * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12GraphicsCommandList1 * This, + _In_z_ LPCWSTR Name); + + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12GraphicsCommandList1 * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( + ID3D12GraphicsCommandList1 * This); + + HRESULT ( STDMETHODCALLTYPE *Close )( + ID3D12GraphicsCommandList1 * This); + + HRESULT ( STDMETHODCALLTYPE *Reset )( + ID3D12GraphicsCommandList1 * This, + _In_ ID3D12CommandAllocator *pAllocator, + _In_opt_ ID3D12PipelineState *pInitialState); + + void ( STDMETHODCALLTYPE *ClearState )( + ID3D12GraphicsCommandList1 * This, + _In_opt_ ID3D12PipelineState *pPipelineState); + + void ( STDMETHODCALLTYPE *DrawInstanced )( + ID3D12GraphicsCommandList1 * This, + _In_ UINT VertexCountPerInstance, + _In_ UINT InstanceCount, + _In_ UINT StartVertexLocation, + _In_ UINT StartInstanceLocation); + + void ( STDMETHODCALLTYPE *DrawIndexedInstanced )( + ID3D12GraphicsCommandList1 * This, + _In_ UINT IndexCountPerInstance, + _In_ UINT InstanceCount, + _In_ UINT StartIndexLocation, + _In_ INT BaseVertexLocation, + _In_ UINT StartInstanceLocation); + + void ( STDMETHODCALLTYPE *Dispatch )( + ID3D12GraphicsCommandList1 * This, + _In_ UINT ThreadGroupCountX, + _In_ UINT ThreadGroupCountY, + _In_ UINT ThreadGroupCountZ); + + void ( STDMETHODCALLTYPE *CopyBufferRegion )( + ID3D12GraphicsCommandList1 * This, + _In_ ID3D12Resource *pDstBuffer, + UINT64 DstOffset, + _In_ ID3D12Resource *pSrcBuffer, + UINT64 SrcOffset, + UINT64 NumBytes); + + void ( STDMETHODCALLTYPE *CopyTextureRegion )( + ID3D12GraphicsCommandList1 * This, + _In_ const D3D12_TEXTURE_COPY_LOCATION *pDst, + UINT DstX, + UINT DstY, + UINT DstZ, + _In_ const D3D12_TEXTURE_COPY_LOCATION *pSrc, + _In_opt_ const D3D12_BOX *pSrcBox); + + void ( STDMETHODCALLTYPE *CopyResource )( + ID3D12GraphicsCommandList1 * This, + _In_ ID3D12Resource *pDstResource, + _In_ ID3D12Resource *pSrcResource); + + void ( STDMETHODCALLTYPE *CopyTiles )( + ID3D12GraphicsCommandList1 * This, + _In_ ID3D12Resource *pTiledResource, + _In_ const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate, + _In_ const D3D12_TILE_REGION_SIZE *pTileRegionSize, + _In_ ID3D12Resource *pBuffer, + UINT64 BufferStartOffsetInBytes, + D3D12_TILE_COPY_FLAGS Flags); + + void ( STDMETHODCALLTYPE *ResolveSubresource )( + ID3D12GraphicsCommandList1 * This, + _In_ ID3D12Resource *pDstResource, + _In_ UINT DstSubresource, + _In_ ID3D12Resource *pSrcResource, + _In_ UINT SrcSubresource, + _In_ DXGI_FORMAT Format); + + void ( STDMETHODCALLTYPE *IASetPrimitiveTopology )( + ID3D12GraphicsCommandList1 * This, + _In_ D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology); + + void ( STDMETHODCALLTYPE *RSSetViewports )( + ID3D12GraphicsCommandList1 * This, + _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumViewports, + _In_reads_( NumViewports) const D3D12_VIEWPORT *pViewports); + + void ( STDMETHODCALLTYPE *RSSetScissorRects )( + ID3D12GraphicsCommandList1 * This, + _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumRects, + _In_reads_( NumRects) const D3D12_RECT *pRects); + + void ( STDMETHODCALLTYPE *OMSetBlendFactor )( + ID3D12GraphicsCommandList1 * This, + _In_reads_opt_(4) const FLOAT BlendFactor[ 4 ]); + + void ( STDMETHODCALLTYPE *OMSetStencilRef )( + ID3D12GraphicsCommandList1 * This, + _In_ UINT StencilRef); + + void ( STDMETHODCALLTYPE *SetPipelineState )( + ID3D12GraphicsCommandList1 * This, + _In_ ID3D12PipelineState *pPipelineState); + + void ( STDMETHODCALLTYPE *ResourceBarrier )( + ID3D12GraphicsCommandList1 * This, + _In_ UINT NumBarriers, + _In_reads_(NumBarriers) const D3D12_RESOURCE_BARRIER *pBarriers); + + void ( STDMETHODCALLTYPE *ExecuteBundle )( + ID3D12GraphicsCommandList1 * This, + _In_ ID3D12GraphicsCommandList *pCommandList); + + void ( STDMETHODCALLTYPE *SetDescriptorHeaps )( + ID3D12GraphicsCommandList1 * This, + _In_ UINT NumDescriptorHeaps, + _In_reads_(NumDescriptorHeaps) ID3D12DescriptorHeap *const *ppDescriptorHeaps); + + void ( STDMETHODCALLTYPE *SetComputeRootSignature )( + ID3D12GraphicsCommandList1 * This, + _In_opt_ ID3D12RootSignature *pRootSignature); + + void ( STDMETHODCALLTYPE *SetGraphicsRootSignature )( + ID3D12GraphicsCommandList1 * This, + _In_opt_ ID3D12RootSignature *pRootSignature); + + void ( STDMETHODCALLTYPE *SetComputeRootDescriptorTable )( + ID3D12GraphicsCommandList1 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); + + void ( STDMETHODCALLTYPE *SetGraphicsRootDescriptorTable )( + ID3D12GraphicsCommandList1 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); + + void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstant )( + ID3D12GraphicsCommandList1 * This, + _In_ UINT RootParameterIndex, + _In_ UINT SrcData, + _In_ UINT DestOffsetIn32BitValues); + + void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstant )( + ID3D12GraphicsCommandList1 * This, + _In_ UINT RootParameterIndex, + _In_ UINT SrcData, + _In_ UINT DestOffsetIn32BitValues); + + void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstants )( + ID3D12GraphicsCommandList1 * This, + _In_ UINT RootParameterIndex, + _In_ UINT Num32BitValuesToSet, + _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, + _In_ UINT DestOffsetIn32BitValues); + + void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstants )( + ID3D12GraphicsCommandList1 * This, + _In_ UINT RootParameterIndex, + _In_ UINT Num32BitValuesToSet, + _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, + _In_ UINT DestOffsetIn32BitValues); + + void ( STDMETHODCALLTYPE *SetComputeRootConstantBufferView )( + ID3D12GraphicsCommandList1 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *SetGraphicsRootConstantBufferView )( + ID3D12GraphicsCommandList1 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *SetComputeRootShaderResourceView )( + ID3D12GraphicsCommandList1 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *SetGraphicsRootShaderResourceView )( + ID3D12GraphicsCommandList1 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *SetComputeRootUnorderedAccessView )( + ID3D12GraphicsCommandList1 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *SetGraphicsRootUnorderedAccessView )( + ID3D12GraphicsCommandList1 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *IASetIndexBuffer )( + ID3D12GraphicsCommandList1 * This, + _In_opt_ const D3D12_INDEX_BUFFER_VIEW *pView); + + void ( STDMETHODCALLTYPE *IASetVertexBuffers )( + ID3D12GraphicsCommandList1 * This, + _In_ UINT StartSlot, + _In_ UINT NumViews, + _In_reads_opt_(NumViews) const D3D12_VERTEX_BUFFER_VIEW *pViews); + + void ( STDMETHODCALLTYPE *SOSetTargets )( + ID3D12GraphicsCommandList1 * This, + _In_ UINT StartSlot, + _In_ UINT NumViews, + _In_reads_opt_(NumViews) const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews); + + void ( STDMETHODCALLTYPE *OMSetRenderTargets )( + ID3D12GraphicsCommandList1 * This, + _In_ UINT NumRenderTargetDescriptors, + _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors, + _In_ BOOL RTsSingleHandleToDescriptorRange, + _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pDepthStencilDescriptor); + + void ( STDMETHODCALLTYPE *ClearDepthStencilView )( + ID3D12GraphicsCommandList1 * This, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView, + _In_ D3D12_CLEAR_FLAGS ClearFlags, + _In_ FLOAT Depth, + _In_ UINT8 Stencil, + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); + + void ( STDMETHODCALLTYPE *ClearRenderTargetView )( + ID3D12GraphicsCommandList1 * This, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView, + _In_ const FLOAT ColorRGBA[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); + + void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewUint )( + ID3D12GraphicsCommandList1 * This, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, + _In_ ID3D12Resource *pResource, + _In_ const UINT Values[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); + + void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewFloat )( + ID3D12GraphicsCommandList1 * This, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, + _In_ ID3D12Resource *pResource, + _In_ const FLOAT Values[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); + + void ( STDMETHODCALLTYPE *DiscardResource )( + ID3D12GraphicsCommandList1 * This, + _In_ ID3D12Resource *pResource, + _In_opt_ const D3D12_DISCARD_REGION *pRegion); + + void ( STDMETHODCALLTYPE *BeginQuery )( + ID3D12GraphicsCommandList1 * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT Index); + + void ( STDMETHODCALLTYPE *EndQuery )( + ID3D12GraphicsCommandList1 * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT Index); + + void ( STDMETHODCALLTYPE *ResolveQueryData )( + ID3D12GraphicsCommandList1 * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT StartIndex, + _In_ UINT NumQueries, + _In_ ID3D12Resource *pDestinationBuffer, + _In_ UINT64 AlignedDestinationBufferOffset); + + void ( STDMETHODCALLTYPE *SetPredication )( + ID3D12GraphicsCommandList1 * This, + _In_opt_ ID3D12Resource *pBuffer, + _In_ UINT64 AlignedBufferOffset, + _In_ D3D12_PREDICATION_OP Operation); + + void ( STDMETHODCALLTYPE *SetMarker )( + ID3D12GraphicsCommandList1 * This, + UINT Metadata, + _In_reads_bytes_opt_(Size) const void *pData, + UINT Size); + + void ( STDMETHODCALLTYPE *BeginEvent )( + ID3D12GraphicsCommandList1 * This, + UINT Metadata, + _In_reads_bytes_opt_(Size) const void *pData, + UINT Size); + + void ( STDMETHODCALLTYPE *EndEvent )( + ID3D12GraphicsCommandList1 * This); + + void ( STDMETHODCALLTYPE *ExecuteIndirect )( + ID3D12GraphicsCommandList1 * This, + _In_ ID3D12CommandSignature *pCommandSignature, + _In_ UINT MaxCommandCount, + _In_ ID3D12Resource *pArgumentBuffer, + _In_ UINT64 ArgumentBufferOffset, + _In_opt_ ID3D12Resource *pCountBuffer, + _In_ UINT64 CountBufferOffset); + + void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT )( + ID3D12GraphicsCommandList1 * This, + _In_ ID3D12Resource *pDstBuffer, + UINT64 DstOffset, + _In_ ID3D12Resource *pSrcBuffer, + UINT64 SrcOffset, + UINT Dependencies, + _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, + _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); + + void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT64 )( + ID3D12GraphicsCommandList1 * This, + _In_ ID3D12Resource *pDstBuffer, + UINT64 DstOffset, + _In_ ID3D12Resource *pSrcBuffer, + UINT64 SrcOffset, + UINT Dependencies, + _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, + _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); + + void ( STDMETHODCALLTYPE *OMSetDepthBounds )( + ID3D12GraphicsCommandList1 * This, + _In_ FLOAT Min, + _In_ FLOAT Max); + + void ( STDMETHODCALLTYPE *SetSamplePositions )( + ID3D12GraphicsCommandList1 * This, + _In_ UINT NumSamplesPerPixel, + _In_ UINT NumPixels, + _In_reads_(NumSamplesPerPixel*NumPixels) D3D12_SAMPLE_POSITION *pSamplePositions); + + void ( STDMETHODCALLTYPE *ResolveSubresourceRegion )( + ID3D12GraphicsCommandList1 * This, + _In_ ID3D12Resource *pDstResource, + _In_ UINT DstSubresource, + _In_ UINT DstX, + _In_ UINT DstY, + _In_ ID3D12Resource *pSrcResource, + _In_ UINT SrcSubresource, + _In_opt_ D3D12_RECT *pSrcRect, + _In_ DXGI_FORMAT Format, + _In_ D3D12_RESOLVE_MODE ResolveMode); + + void ( STDMETHODCALLTYPE *SetViewInstanceMask )( + ID3D12GraphicsCommandList1 * This, + _In_ UINT Mask); + + END_INTERFACE + } ID3D12GraphicsCommandList1Vtbl; + + interface ID3D12GraphicsCommandList1 + { + CONST_VTBL struct ID3D12GraphicsCommandList1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12GraphicsCommandList1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12GraphicsCommandList1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12GraphicsCommandList1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12GraphicsCommandList1_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12GraphicsCommandList1_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12GraphicsCommandList1_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12GraphicsCommandList1_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12GraphicsCommandList1_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + +#define ID3D12GraphicsCommandList1_GetType(This) \ + ( (This)->lpVtbl -> GetType(This) ) + + +#define ID3D12GraphicsCommandList1_Close(This) \ + ( (This)->lpVtbl -> Close(This) ) + +#define ID3D12GraphicsCommandList1_Reset(This,pAllocator,pInitialState) \ + ( (This)->lpVtbl -> Reset(This,pAllocator,pInitialState) ) + +#define ID3D12GraphicsCommandList1_ClearState(This,pPipelineState) \ + ( (This)->lpVtbl -> ClearState(This,pPipelineState) ) + +#define ID3D12GraphicsCommandList1_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) \ + ( (This)->lpVtbl -> DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) ) + +#define ID3D12GraphicsCommandList1_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) \ + ( (This)->lpVtbl -> DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) ) + +#define ID3D12GraphicsCommandList1_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ + ( (This)->lpVtbl -> Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) + +#define ID3D12GraphicsCommandList1_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) \ + ( (This)->lpVtbl -> CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) ) + +#define ID3D12GraphicsCommandList1_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) \ + ( (This)->lpVtbl -> CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) ) + +#define ID3D12GraphicsCommandList1_CopyResource(This,pDstResource,pSrcResource) \ + ( (This)->lpVtbl -> CopyResource(This,pDstResource,pSrcResource) ) + +#define ID3D12GraphicsCommandList1_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) \ + ( (This)->lpVtbl -> CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) ) + +#define ID3D12GraphicsCommandList1_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) \ + ( (This)->lpVtbl -> ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) ) + +#define ID3D12GraphicsCommandList1_IASetPrimitiveTopology(This,PrimitiveTopology) \ + ( (This)->lpVtbl -> IASetPrimitiveTopology(This,PrimitiveTopology) ) + +#define ID3D12GraphicsCommandList1_RSSetViewports(This,NumViewports,pViewports) \ + ( (This)->lpVtbl -> RSSetViewports(This,NumViewports,pViewports) ) + +#define ID3D12GraphicsCommandList1_RSSetScissorRects(This,NumRects,pRects) \ + ( (This)->lpVtbl -> RSSetScissorRects(This,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList1_OMSetBlendFactor(This,BlendFactor) \ + ( (This)->lpVtbl -> OMSetBlendFactor(This,BlendFactor) ) + +#define ID3D12GraphicsCommandList1_OMSetStencilRef(This,StencilRef) \ + ( (This)->lpVtbl -> OMSetStencilRef(This,StencilRef) ) + +#define ID3D12GraphicsCommandList1_SetPipelineState(This,pPipelineState) \ + ( (This)->lpVtbl -> SetPipelineState(This,pPipelineState) ) + +#define ID3D12GraphicsCommandList1_ResourceBarrier(This,NumBarriers,pBarriers) \ + ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) + +#define ID3D12GraphicsCommandList1_ExecuteBundle(This,pCommandList) \ + ( (This)->lpVtbl -> ExecuteBundle(This,pCommandList) ) + +#define ID3D12GraphicsCommandList1_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) \ + ( (This)->lpVtbl -> SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) ) + +#define ID3D12GraphicsCommandList1_SetComputeRootSignature(This,pRootSignature) \ + ( (This)->lpVtbl -> SetComputeRootSignature(This,pRootSignature) ) + +#define ID3D12GraphicsCommandList1_SetGraphicsRootSignature(This,pRootSignature) \ + ( (This)->lpVtbl -> SetGraphicsRootSignature(This,pRootSignature) ) + +#define ID3D12GraphicsCommandList1_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ + ( (This)->lpVtbl -> SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) + +#define ID3D12GraphicsCommandList1_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ + ( (This)->lpVtbl -> SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) + +#define ID3D12GraphicsCommandList1_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) + +#define ID3D12GraphicsCommandList1_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) + +#define ID3D12GraphicsCommandList1_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) + +#define ID3D12GraphicsCommandList1_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) + +#define ID3D12GraphicsCommandList1_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList1_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList1_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList1_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList1_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList1_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList1_IASetIndexBuffer(This,pView) \ + ( (This)->lpVtbl -> IASetIndexBuffer(This,pView) ) + +#define ID3D12GraphicsCommandList1_IASetVertexBuffers(This,StartSlot,NumViews,pViews) \ + ( (This)->lpVtbl -> IASetVertexBuffers(This,StartSlot,NumViews,pViews) ) + +#define ID3D12GraphicsCommandList1_SOSetTargets(This,StartSlot,NumViews,pViews) \ + ( (This)->lpVtbl -> SOSetTargets(This,StartSlot,NumViews,pViews) ) + +#define ID3D12GraphicsCommandList1_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) \ + ( (This)->lpVtbl -> OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) ) + +#define ID3D12GraphicsCommandList1_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList1_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList1_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList1_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList1_DiscardResource(This,pResource,pRegion) \ + ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) + +#define ID3D12GraphicsCommandList1_BeginQuery(This,pQueryHeap,Type,Index) \ + ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) + +#define ID3D12GraphicsCommandList1_EndQuery(This,pQueryHeap,Type,Index) \ + ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) + +#define ID3D12GraphicsCommandList1_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) \ + ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) + +#define ID3D12GraphicsCommandList1_SetPredication(This,pBuffer,AlignedBufferOffset,Operation) \ + ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) + +#define ID3D12GraphicsCommandList1_SetMarker(This,Metadata,pData,Size) \ + ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) + +#define ID3D12GraphicsCommandList1_BeginEvent(This,Metadata,pData,Size) \ + ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) + +#define ID3D12GraphicsCommandList1_EndEvent(This) \ + ( (This)->lpVtbl -> EndEvent(This) ) + +#define ID3D12GraphicsCommandList1_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) \ + ( (This)->lpVtbl -> ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) ) + + +#define ID3D12GraphicsCommandList1_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ + ( (This)->lpVtbl -> AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) + +#define ID3D12GraphicsCommandList1_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ + ( (This)->lpVtbl -> AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) + +#define ID3D12GraphicsCommandList1_OMSetDepthBounds(This,Min,Max) \ + ( (This)->lpVtbl -> OMSetDepthBounds(This,Min,Max) ) + +#define ID3D12GraphicsCommandList1_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) \ + ( (This)->lpVtbl -> SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) ) + +#define ID3D12GraphicsCommandList1_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) \ + ( (This)->lpVtbl -> ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) ) + +#define ID3D12GraphicsCommandList1_SetViewInstanceMask(This,Mask) \ + ( (This)->lpVtbl -> SetViewInstanceMask(This,Mask) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12GraphicsCommandList1_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12_0000_0018 */ +/* [local] */ + +typedef struct D3D12_WRITEBUFFERIMMEDIATE_PARAMETER + { + D3D12_GPU_VIRTUAL_ADDRESS Dest; + UINT32 Value; + } D3D12_WRITEBUFFERIMMEDIATE_PARAMETER; + +typedef +enum D3D12_WRITEBUFFERIMMEDIATE_MODE + { + D3D12_WRITEBUFFERIMMEDIATE_MODE_DEFAULT = 0, + D3D12_WRITEBUFFERIMMEDIATE_MODE_MARKER_IN = 0x1, + D3D12_WRITEBUFFERIMMEDIATE_MODE_MARKER_OUT = 0x2 + } D3D12_WRITEBUFFERIMMEDIATE_MODE; + + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0018_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0018_v0_0_s_ifspec; + +#ifndef __ID3D12GraphicsCommandList2_INTERFACE_DEFINED__ +#define __ID3D12GraphicsCommandList2_INTERFACE_DEFINED__ + +/* interface ID3D12GraphicsCommandList2 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12GraphicsCommandList2; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("38C3E585-FF17-412C-9150-4FC6F9D72A28") + ID3D12GraphicsCommandList2 : public ID3D12GraphicsCommandList1 + { + public: + virtual void STDMETHODCALLTYPE WriteBufferImmediate( + UINT Count, + _In_reads_(Count) const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams, + _In_reads_opt_(Count) const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12GraphicsCommandList2Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12GraphicsCommandList2 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12GraphicsCommandList2 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12GraphicsCommandList2 * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12GraphicsCommandList2 * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12GraphicsCommandList2 * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12GraphicsCommandList2 * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12GraphicsCommandList2 * This, + _In_z_ LPCWSTR Name); + + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12GraphicsCommandList2 * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( + ID3D12GraphicsCommandList2 * This); + + HRESULT ( STDMETHODCALLTYPE *Close )( + ID3D12GraphicsCommandList2 * This); + + HRESULT ( STDMETHODCALLTYPE *Reset )( + ID3D12GraphicsCommandList2 * This, + _In_ ID3D12CommandAllocator *pAllocator, + _In_opt_ ID3D12PipelineState *pInitialState); + + void ( STDMETHODCALLTYPE *ClearState )( + ID3D12GraphicsCommandList2 * This, + _In_opt_ ID3D12PipelineState *pPipelineState); + + void ( STDMETHODCALLTYPE *DrawInstanced )( + ID3D12GraphicsCommandList2 * This, + _In_ UINT VertexCountPerInstance, + _In_ UINT InstanceCount, + _In_ UINT StartVertexLocation, + _In_ UINT StartInstanceLocation); + + void ( STDMETHODCALLTYPE *DrawIndexedInstanced )( + ID3D12GraphicsCommandList2 * This, + _In_ UINT IndexCountPerInstance, + _In_ UINT InstanceCount, + _In_ UINT StartIndexLocation, + _In_ INT BaseVertexLocation, + _In_ UINT StartInstanceLocation); + + void ( STDMETHODCALLTYPE *Dispatch )( + ID3D12GraphicsCommandList2 * This, + _In_ UINT ThreadGroupCountX, + _In_ UINT ThreadGroupCountY, + _In_ UINT ThreadGroupCountZ); + + void ( STDMETHODCALLTYPE *CopyBufferRegion )( + ID3D12GraphicsCommandList2 * This, + _In_ ID3D12Resource *pDstBuffer, + UINT64 DstOffset, + _In_ ID3D12Resource *pSrcBuffer, + UINT64 SrcOffset, + UINT64 NumBytes); + + void ( STDMETHODCALLTYPE *CopyTextureRegion )( + ID3D12GraphicsCommandList2 * This, + _In_ const D3D12_TEXTURE_COPY_LOCATION *pDst, + UINT DstX, + UINT DstY, + UINT DstZ, + _In_ const D3D12_TEXTURE_COPY_LOCATION *pSrc, + _In_opt_ const D3D12_BOX *pSrcBox); + + void ( STDMETHODCALLTYPE *CopyResource )( + ID3D12GraphicsCommandList2 * This, + _In_ ID3D12Resource *pDstResource, + _In_ ID3D12Resource *pSrcResource); + + void ( STDMETHODCALLTYPE *CopyTiles )( + ID3D12GraphicsCommandList2 * This, + _In_ ID3D12Resource *pTiledResource, + _In_ const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate, + _In_ const D3D12_TILE_REGION_SIZE *pTileRegionSize, + _In_ ID3D12Resource *pBuffer, + UINT64 BufferStartOffsetInBytes, + D3D12_TILE_COPY_FLAGS Flags); + + void ( STDMETHODCALLTYPE *ResolveSubresource )( + ID3D12GraphicsCommandList2 * This, + _In_ ID3D12Resource *pDstResource, + _In_ UINT DstSubresource, + _In_ ID3D12Resource *pSrcResource, + _In_ UINT SrcSubresource, + _In_ DXGI_FORMAT Format); + + void ( STDMETHODCALLTYPE *IASetPrimitiveTopology )( + ID3D12GraphicsCommandList2 * This, + _In_ D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology); + + void ( STDMETHODCALLTYPE *RSSetViewports )( + ID3D12GraphicsCommandList2 * This, + _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumViewports, + _In_reads_( NumViewports) const D3D12_VIEWPORT *pViewports); + + void ( STDMETHODCALLTYPE *RSSetScissorRects )( + ID3D12GraphicsCommandList2 * This, + _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumRects, + _In_reads_( NumRects) const D3D12_RECT *pRects); + + void ( STDMETHODCALLTYPE *OMSetBlendFactor )( + ID3D12GraphicsCommandList2 * This, + _In_reads_opt_(4) const FLOAT BlendFactor[ 4 ]); + + void ( STDMETHODCALLTYPE *OMSetStencilRef )( + ID3D12GraphicsCommandList2 * This, + _In_ UINT StencilRef); + + void ( STDMETHODCALLTYPE *SetPipelineState )( + ID3D12GraphicsCommandList2 * This, + _In_ ID3D12PipelineState *pPipelineState); + + void ( STDMETHODCALLTYPE *ResourceBarrier )( + ID3D12GraphicsCommandList2 * This, + _In_ UINT NumBarriers, + _In_reads_(NumBarriers) const D3D12_RESOURCE_BARRIER *pBarriers); + + void ( STDMETHODCALLTYPE *ExecuteBundle )( + ID3D12GraphicsCommandList2 * This, + _In_ ID3D12GraphicsCommandList *pCommandList); + + void ( STDMETHODCALLTYPE *SetDescriptorHeaps )( + ID3D12GraphicsCommandList2 * This, + _In_ UINT NumDescriptorHeaps, + _In_reads_(NumDescriptorHeaps) ID3D12DescriptorHeap *const *ppDescriptorHeaps); + + void ( STDMETHODCALLTYPE *SetComputeRootSignature )( + ID3D12GraphicsCommandList2 * This, + _In_opt_ ID3D12RootSignature *pRootSignature); + + void ( STDMETHODCALLTYPE *SetGraphicsRootSignature )( + ID3D12GraphicsCommandList2 * This, + _In_opt_ ID3D12RootSignature *pRootSignature); + + void ( STDMETHODCALLTYPE *SetComputeRootDescriptorTable )( + ID3D12GraphicsCommandList2 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); + + void ( STDMETHODCALLTYPE *SetGraphicsRootDescriptorTable )( + ID3D12GraphicsCommandList2 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); + + void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstant )( + ID3D12GraphicsCommandList2 * This, + _In_ UINT RootParameterIndex, + _In_ UINT SrcData, + _In_ UINT DestOffsetIn32BitValues); + + void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstant )( + ID3D12GraphicsCommandList2 * This, + _In_ UINT RootParameterIndex, + _In_ UINT SrcData, + _In_ UINT DestOffsetIn32BitValues); + + void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstants )( + ID3D12GraphicsCommandList2 * This, + _In_ UINT RootParameterIndex, + _In_ UINT Num32BitValuesToSet, + _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, + _In_ UINT DestOffsetIn32BitValues); + + void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstants )( + ID3D12GraphicsCommandList2 * This, + _In_ UINT RootParameterIndex, + _In_ UINT Num32BitValuesToSet, + _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, + _In_ UINT DestOffsetIn32BitValues); + + void ( STDMETHODCALLTYPE *SetComputeRootConstantBufferView )( + ID3D12GraphicsCommandList2 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *SetGraphicsRootConstantBufferView )( + ID3D12GraphicsCommandList2 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *SetComputeRootShaderResourceView )( + ID3D12GraphicsCommandList2 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *SetGraphicsRootShaderResourceView )( + ID3D12GraphicsCommandList2 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *SetComputeRootUnorderedAccessView )( + ID3D12GraphicsCommandList2 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *SetGraphicsRootUnorderedAccessView )( + ID3D12GraphicsCommandList2 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *IASetIndexBuffer )( + ID3D12GraphicsCommandList2 * This, + _In_opt_ const D3D12_INDEX_BUFFER_VIEW *pView); + + void ( STDMETHODCALLTYPE *IASetVertexBuffers )( + ID3D12GraphicsCommandList2 * This, + _In_ UINT StartSlot, + _In_ UINT NumViews, + _In_reads_opt_(NumViews) const D3D12_VERTEX_BUFFER_VIEW *pViews); + + void ( STDMETHODCALLTYPE *SOSetTargets )( + ID3D12GraphicsCommandList2 * This, + _In_ UINT StartSlot, + _In_ UINT NumViews, + _In_reads_opt_(NumViews) const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews); + + void ( STDMETHODCALLTYPE *OMSetRenderTargets )( + ID3D12GraphicsCommandList2 * This, + _In_ UINT NumRenderTargetDescriptors, + _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors, + _In_ BOOL RTsSingleHandleToDescriptorRange, + _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pDepthStencilDescriptor); + + void ( STDMETHODCALLTYPE *ClearDepthStencilView )( + ID3D12GraphicsCommandList2 * This, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView, + _In_ D3D12_CLEAR_FLAGS ClearFlags, + _In_ FLOAT Depth, + _In_ UINT8 Stencil, + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); + + void ( STDMETHODCALLTYPE *ClearRenderTargetView )( + ID3D12GraphicsCommandList2 * This, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView, + _In_ const FLOAT ColorRGBA[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); + + void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewUint )( + ID3D12GraphicsCommandList2 * This, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, + _In_ ID3D12Resource *pResource, + _In_ const UINT Values[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); + + void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewFloat )( + ID3D12GraphicsCommandList2 * This, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, + _In_ ID3D12Resource *pResource, + _In_ const FLOAT Values[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); + + void ( STDMETHODCALLTYPE *DiscardResource )( + ID3D12GraphicsCommandList2 * This, + _In_ ID3D12Resource *pResource, + _In_opt_ const D3D12_DISCARD_REGION *pRegion); + + void ( STDMETHODCALLTYPE *BeginQuery )( + ID3D12GraphicsCommandList2 * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT Index); + + void ( STDMETHODCALLTYPE *EndQuery )( + ID3D12GraphicsCommandList2 * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT Index); + + void ( STDMETHODCALLTYPE *ResolveQueryData )( + ID3D12GraphicsCommandList2 * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT StartIndex, + _In_ UINT NumQueries, + _In_ ID3D12Resource *pDestinationBuffer, + _In_ UINT64 AlignedDestinationBufferOffset); + + void ( STDMETHODCALLTYPE *SetPredication )( + ID3D12GraphicsCommandList2 * This, + _In_opt_ ID3D12Resource *pBuffer, + _In_ UINT64 AlignedBufferOffset, + _In_ D3D12_PREDICATION_OP Operation); + + void ( STDMETHODCALLTYPE *SetMarker )( + ID3D12GraphicsCommandList2 * This, + UINT Metadata, + _In_reads_bytes_opt_(Size) const void *pData, + UINT Size); + + void ( STDMETHODCALLTYPE *BeginEvent )( + ID3D12GraphicsCommandList2 * This, + UINT Metadata, + _In_reads_bytes_opt_(Size) const void *pData, + UINT Size); + + void ( STDMETHODCALLTYPE *EndEvent )( + ID3D12GraphicsCommandList2 * This); + + void ( STDMETHODCALLTYPE *ExecuteIndirect )( + ID3D12GraphicsCommandList2 * This, + _In_ ID3D12CommandSignature *pCommandSignature, + _In_ UINT MaxCommandCount, + _In_ ID3D12Resource *pArgumentBuffer, + _In_ UINT64 ArgumentBufferOffset, + _In_opt_ ID3D12Resource *pCountBuffer, + _In_ UINT64 CountBufferOffset); + + void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT )( + ID3D12GraphicsCommandList2 * This, + _In_ ID3D12Resource *pDstBuffer, + UINT64 DstOffset, + _In_ ID3D12Resource *pSrcBuffer, + UINT64 SrcOffset, + UINT Dependencies, + _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, + _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); + + void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT64 )( + ID3D12GraphicsCommandList2 * This, + _In_ ID3D12Resource *pDstBuffer, + UINT64 DstOffset, + _In_ ID3D12Resource *pSrcBuffer, + UINT64 SrcOffset, + UINT Dependencies, + _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, + _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); + + void ( STDMETHODCALLTYPE *OMSetDepthBounds )( + ID3D12GraphicsCommandList2 * This, + _In_ FLOAT Min, + _In_ FLOAT Max); + + void ( STDMETHODCALLTYPE *SetSamplePositions )( + ID3D12GraphicsCommandList2 * This, + _In_ UINT NumSamplesPerPixel, + _In_ UINT NumPixels, + _In_reads_(NumSamplesPerPixel*NumPixels) D3D12_SAMPLE_POSITION *pSamplePositions); + + void ( STDMETHODCALLTYPE *ResolveSubresourceRegion )( + ID3D12GraphicsCommandList2 * This, + _In_ ID3D12Resource *pDstResource, + _In_ UINT DstSubresource, + _In_ UINT DstX, + _In_ UINT DstY, + _In_ ID3D12Resource *pSrcResource, + _In_ UINT SrcSubresource, + _In_opt_ D3D12_RECT *pSrcRect, + _In_ DXGI_FORMAT Format, + _In_ D3D12_RESOLVE_MODE ResolveMode); + + void ( STDMETHODCALLTYPE *SetViewInstanceMask )( + ID3D12GraphicsCommandList2 * This, + _In_ UINT Mask); + + void ( STDMETHODCALLTYPE *WriteBufferImmediate )( + ID3D12GraphicsCommandList2 * This, + UINT Count, + _In_reads_(Count) const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams, + _In_reads_opt_(Count) const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes); + + END_INTERFACE + } ID3D12GraphicsCommandList2Vtbl; + + interface ID3D12GraphicsCommandList2 + { + CONST_VTBL struct ID3D12GraphicsCommandList2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12GraphicsCommandList2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12GraphicsCommandList2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12GraphicsCommandList2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12GraphicsCommandList2_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12GraphicsCommandList2_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12GraphicsCommandList2_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12GraphicsCommandList2_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12GraphicsCommandList2_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + +#define ID3D12GraphicsCommandList2_GetType(This) \ + ( (This)->lpVtbl -> GetType(This) ) + + +#define ID3D12GraphicsCommandList2_Close(This) \ + ( (This)->lpVtbl -> Close(This) ) + +#define ID3D12GraphicsCommandList2_Reset(This,pAllocator,pInitialState) \ + ( (This)->lpVtbl -> Reset(This,pAllocator,pInitialState) ) + +#define ID3D12GraphicsCommandList2_ClearState(This,pPipelineState) \ + ( (This)->lpVtbl -> ClearState(This,pPipelineState) ) + +#define ID3D12GraphicsCommandList2_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) \ + ( (This)->lpVtbl -> DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) ) + +#define ID3D12GraphicsCommandList2_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) \ + ( (This)->lpVtbl -> DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) ) + +#define ID3D12GraphicsCommandList2_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ + ( (This)->lpVtbl -> Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) + +#define ID3D12GraphicsCommandList2_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) \ + ( (This)->lpVtbl -> CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) ) + +#define ID3D12GraphicsCommandList2_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) \ + ( (This)->lpVtbl -> CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) ) + +#define ID3D12GraphicsCommandList2_CopyResource(This,pDstResource,pSrcResource) \ + ( (This)->lpVtbl -> CopyResource(This,pDstResource,pSrcResource) ) + +#define ID3D12GraphicsCommandList2_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) \ + ( (This)->lpVtbl -> CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) ) + +#define ID3D12GraphicsCommandList2_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) \ + ( (This)->lpVtbl -> ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) ) + +#define ID3D12GraphicsCommandList2_IASetPrimitiveTopology(This,PrimitiveTopology) \ + ( (This)->lpVtbl -> IASetPrimitiveTopology(This,PrimitiveTopology) ) + +#define ID3D12GraphicsCommandList2_RSSetViewports(This,NumViewports,pViewports) \ + ( (This)->lpVtbl -> RSSetViewports(This,NumViewports,pViewports) ) + +#define ID3D12GraphicsCommandList2_RSSetScissorRects(This,NumRects,pRects) \ + ( (This)->lpVtbl -> RSSetScissorRects(This,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList2_OMSetBlendFactor(This,BlendFactor) \ + ( (This)->lpVtbl -> OMSetBlendFactor(This,BlendFactor) ) + +#define ID3D12GraphicsCommandList2_OMSetStencilRef(This,StencilRef) \ + ( (This)->lpVtbl -> OMSetStencilRef(This,StencilRef) ) + +#define ID3D12GraphicsCommandList2_SetPipelineState(This,pPipelineState) \ + ( (This)->lpVtbl -> SetPipelineState(This,pPipelineState) ) + +#define ID3D12GraphicsCommandList2_ResourceBarrier(This,NumBarriers,pBarriers) \ + ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) + +#define ID3D12GraphicsCommandList2_ExecuteBundle(This,pCommandList) \ + ( (This)->lpVtbl -> ExecuteBundle(This,pCommandList) ) + +#define ID3D12GraphicsCommandList2_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) \ + ( (This)->lpVtbl -> SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) ) + +#define ID3D12GraphicsCommandList2_SetComputeRootSignature(This,pRootSignature) \ + ( (This)->lpVtbl -> SetComputeRootSignature(This,pRootSignature) ) + +#define ID3D12GraphicsCommandList2_SetGraphicsRootSignature(This,pRootSignature) \ + ( (This)->lpVtbl -> SetGraphicsRootSignature(This,pRootSignature) ) + +#define ID3D12GraphicsCommandList2_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ + ( (This)->lpVtbl -> SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) + +#define ID3D12GraphicsCommandList2_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ + ( (This)->lpVtbl -> SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) + +#define ID3D12GraphicsCommandList2_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) + +#define ID3D12GraphicsCommandList2_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) + +#define ID3D12GraphicsCommandList2_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) + +#define ID3D12GraphicsCommandList2_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) + +#define ID3D12GraphicsCommandList2_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList2_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList2_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList2_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList2_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList2_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList2_IASetIndexBuffer(This,pView) \ + ( (This)->lpVtbl -> IASetIndexBuffer(This,pView) ) + +#define ID3D12GraphicsCommandList2_IASetVertexBuffers(This,StartSlot,NumViews,pViews) \ + ( (This)->lpVtbl -> IASetVertexBuffers(This,StartSlot,NumViews,pViews) ) + +#define ID3D12GraphicsCommandList2_SOSetTargets(This,StartSlot,NumViews,pViews) \ + ( (This)->lpVtbl -> SOSetTargets(This,StartSlot,NumViews,pViews) ) + +#define ID3D12GraphicsCommandList2_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) \ + ( (This)->lpVtbl -> OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) ) + +#define ID3D12GraphicsCommandList2_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList2_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList2_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList2_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList2_DiscardResource(This,pResource,pRegion) \ + ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) + +#define ID3D12GraphicsCommandList2_BeginQuery(This,pQueryHeap,Type,Index) \ + ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) + +#define ID3D12GraphicsCommandList2_EndQuery(This,pQueryHeap,Type,Index) \ + ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) + +#define ID3D12GraphicsCommandList2_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) \ + ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) + +#define ID3D12GraphicsCommandList2_SetPredication(This,pBuffer,AlignedBufferOffset,Operation) \ + ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) + +#define ID3D12GraphicsCommandList2_SetMarker(This,Metadata,pData,Size) \ + ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) + +#define ID3D12GraphicsCommandList2_BeginEvent(This,Metadata,pData,Size) \ + ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) + +#define ID3D12GraphicsCommandList2_EndEvent(This) \ + ( (This)->lpVtbl -> EndEvent(This) ) + +#define ID3D12GraphicsCommandList2_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) \ + ( (This)->lpVtbl -> ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) ) + + +#define ID3D12GraphicsCommandList2_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ + ( (This)->lpVtbl -> AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) + +#define ID3D12GraphicsCommandList2_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ + ( (This)->lpVtbl -> AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) + +#define ID3D12GraphicsCommandList2_OMSetDepthBounds(This,Min,Max) \ + ( (This)->lpVtbl -> OMSetDepthBounds(This,Min,Max) ) + +#define ID3D12GraphicsCommandList2_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) \ + ( (This)->lpVtbl -> SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) ) + +#define ID3D12GraphicsCommandList2_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) \ + ( (This)->lpVtbl -> ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) ) + +#define ID3D12GraphicsCommandList2_SetViewInstanceMask(This,Mask) \ + ( (This)->lpVtbl -> SetViewInstanceMask(This,Mask) ) + + +#define ID3D12GraphicsCommandList2_WriteBufferImmediate(This,Count,pParams,pModes) \ + ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12GraphicsCommandList2_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12CommandQueue_INTERFACE_DEFINED__ +#define __ID3D12CommandQueue_INTERFACE_DEFINED__ + +/* interface ID3D12CommandQueue */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12CommandQueue; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("0ec870a6-5d7e-4c22-8cfc-5baae07616ed") + ID3D12CommandQueue : public ID3D12Pageable + { + public: + virtual void STDMETHODCALLTYPE UpdateTileMappings( + _In_ ID3D12Resource *pResource, + UINT NumResourceRegions, + _In_reads_opt_(NumResourceRegions) const D3D12_TILED_RESOURCE_COORDINATE *pResourceRegionStartCoordinates, + _In_reads_opt_(NumResourceRegions) const D3D12_TILE_REGION_SIZE *pResourceRegionSizes, + _In_opt_ ID3D12Heap *pHeap, + UINT NumRanges, + _In_reads_opt_(NumRanges) const D3D12_TILE_RANGE_FLAGS *pRangeFlags, + _In_reads_opt_(NumRanges) const UINT *pHeapRangeStartOffsets, + _In_reads_opt_(NumRanges) const UINT *pRangeTileCounts, + D3D12_TILE_MAPPING_FLAGS Flags) = 0; + + virtual void STDMETHODCALLTYPE CopyTileMappings( + _In_ ID3D12Resource *pDstResource, + _In_ const D3D12_TILED_RESOURCE_COORDINATE *pDstRegionStartCoordinate, + _In_ ID3D12Resource *pSrcResource, + _In_ const D3D12_TILED_RESOURCE_COORDINATE *pSrcRegionStartCoordinate, + _In_ const D3D12_TILE_REGION_SIZE *pRegionSize, + D3D12_TILE_MAPPING_FLAGS Flags) = 0; + + virtual void STDMETHODCALLTYPE ExecuteCommandLists( + _In_ UINT NumCommandLists, + _In_reads_(NumCommandLists) ID3D12CommandList *const *ppCommandLists) = 0; + + virtual void STDMETHODCALLTYPE SetMarker( + UINT Metadata, + _In_reads_bytes_opt_(Size) const void *pData, + UINT Size) = 0; + + virtual void STDMETHODCALLTYPE BeginEvent( + UINT Metadata, + _In_reads_bytes_opt_(Size) const void *pData, + UINT Size) = 0; + + virtual void STDMETHODCALLTYPE EndEvent( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Signal( + ID3D12Fence *pFence, + UINT64 Value) = 0; + + virtual HRESULT STDMETHODCALLTYPE Wait( + ID3D12Fence *pFence, + UINT64 Value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTimestampFrequency( + _Out_ UINT64 *pFrequency) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetClockCalibration( + _Out_ UINT64 *pGpuTimestamp, + _Out_ UINT64 *pCpuTimestamp) = 0; + + virtual D3D12_COMMAND_QUEUE_DESC STDMETHODCALLTYPE GetDesc( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12CommandQueueVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12CommandQueue * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12CommandQueue * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12CommandQueue * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12CommandQueue * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12CommandQueue * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12CommandQueue * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12CommandQueue * This, + _In_z_ LPCWSTR Name); + + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12CommandQueue * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + void ( STDMETHODCALLTYPE *UpdateTileMappings )( + ID3D12CommandQueue * This, + _In_ ID3D12Resource *pResource, + UINT NumResourceRegions, + _In_reads_opt_(NumResourceRegions) const D3D12_TILED_RESOURCE_COORDINATE *pResourceRegionStartCoordinates, + _In_reads_opt_(NumResourceRegions) const D3D12_TILE_REGION_SIZE *pResourceRegionSizes, + _In_opt_ ID3D12Heap *pHeap, + UINT NumRanges, + _In_reads_opt_(NumRanges) const D3D12_TILE_RANGE_FLAGS *pRangeFlags, + _In_reads_opt_(NumRanges) const UINT *pHeapRangeStartOffsets, + _In_reads_opt_(NumRanges) const UINT *pRangeTileCounts, + D3D12_TILE_MAPPING_FLAGS Flags); + + void ( STDMETHODCALLTYPE *CopyTileMappings )( + ID3D12CommandQueue * This, + _In_ ID3D12Resource *pDstResource, + _In_ const D3D12_TILED_RESOURCE_COORDINATE *pDstRegionStartCoordinate, + _In_ ID3D12Resource *pSrcResource, + _In_ const D3D12_TILED_RESOURCE_COORDINATE *pSrcRegionStartCoordinate, + _In_ const D3D12_TILE_REGION_SIZE *pRegionSize, + D3D12_TILE_MAPPING_FLAGS Flags); + + void ( STDMETHODCALLTYPE *ExecuteCommandLists )( + ID3D12CommandQueue * This, + _In_ UINT NumCommandLists, + _In_reads_(NumCommandLists) ID3D12CommandList *const *ppCommandLists); + + void ( STDMETHODCALLTYPE *SetMarker )( + ID3D12CommandQueue * This, + UINT Metadata, + _In_reads_bytes_opt_(Size) const void *pData, + UINT Size); + + void ( STDMETHODCALLTYPE *BeginEvent )( + ID3D12CommandQueue * This, + UINT Metadata, + _In_reads_bytes_opt_(Size) const void *pData, + UINT Size); + + void ( STDMETHODCALLTYPE *EndEvent )( + ID3D12CommandQueue * This); + + HRESULT ( STDMETHODCALLTYPE *Signal )( + ID3D12CommandQueue * This, + ID3D12Fence *pFence, + UINT64 Value); + + HRESULT ( STDMETHODCALLTYPE *Wait )( + ID3D12CommandQueue * This, + ID3D12Fence *pFence, + UINT64 Value); + + HRESULT ( STDMETHODCALLTYPE *GetTimestampFrequency )( + ID3D12CommandQueue * This, + _Out_ UINT64 *pFrequency); + + HRESULT ( STDMETHODCALLTYPE *GetClockCalibration )( + ID3D12CommandQueue * This, + _Out_ UINT64 *pGpuTimestamp, + _Out_ UINT64 *pCpuTimestamp); + + D3D12_COMMAND_QUEUE_DESC ( STDMETHODCALLTYPE *GetDesc )( + ID3D12CommandQueue * This); + + END_INTERFACE + } ID3D12CommandQueueVtbl; + + interface ID3D12CommandQueue + { + CONST_VTBL struct ID3D12CommandQueueVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12CommandQueue_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12CommandQueue_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12CommandQueue_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12CommandQueue_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12CommandQueue_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12CommandQueue_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12CommandQueue_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12CommandQueue_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + + +#define ID3D12CommandQueue_UpdateTileMappings(This,pResource,NumResourceRegions,pResourceRegionStartCoordinates,pResourceRegionSizes,pHeap,NumRanges,pRangeFlags,pHeapRangeStartOffsets,pRangeTileCounts,Flags) \ + ( (This)->lpVtbl -> UpdateTileMappings(This,pResource,NumResourceRegions,pResourceRegionStartCoordinates,pResourceRegionSizes,pHeap,NumRanges,pRangeFlags,pHeapRangeStartOffsets,pRangeTileCounts,Flags) ) + +#define ID3D12CommandQueue_CopyTileMappings(This,pDstResource,pDstRegionStartCoordinate,pSrcResource,pSrcRegionStartCoordinate,pRegionSize,Flags) \ + ( (This)->lpVtbl -> CopyTileMappings(This,pDstResource,pDstRegionStartCoordinate,pSrcResource,pSrcRegionStartCoordinate,pRegionSize,Flags) ) + +#define ID3D12CommandQueue_ExecuteCommandLists(This,NumCommandLists,ppCommandLists) \ + ( (This)->lpVtbl -> ExecuteCommandLists(This,NumCommandLists,ppCommandLists) ) + +#define ID3D12CommandQueue_SetMarker(This,Metadata,pData,Size) \ + ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) + +#define ID3D12CommandQueue_BeginEvent(This,Metadata,pData,Size) \ + ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) + +#define ID3D12CommandQueue_EndEvent(This) \ + ( (This)->lpVtbl -> EndEvent(This) ) + +#define ID3D12CommandQueue_Signal(This,pFence,Value) \ + ( (This)->lpVtbl -> Signal(This,pFence,Value) ) + +#define ID3D12CommandQueue_Wait(This,pFence,Value) \ + ( (This)->lpVtbl -> Wait(This,pFence,Value) ) + +#define ID3D12CommandQueue_GetTimestampFrequency(This,pFrequency) \ + ( (This)->lpVtbl -> GetTimestampFrequency(This,pFrequency) ) + +#define ID3D12CommandQueue_GetClockCalibration(This,pGpuTimestamp,pCpuTimestamp) \ + ( (This)->lpVtbl -> GetClockCalibration(This,pGpuTimestamp,pCpuTimestamp) ) + +#define ID3D12CommandQueue_GetDesc(This) \ + ( (This)->lpVtbl -> GetDesc(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + + + + + +#endif /* __ID3D12CommandQueue_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12_0000_0020 */ +/* [local] */ + +#ifdef __midl +#ifndef LUID_DEFINED +#define LUID_DEFINED 1 +typedef struct __LUID + { + DWORD LowPart; + LONG HighPart; + } LUID; + +typedef struct __LUID *PLUID; + +#endif +#endif + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0020_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0020_v0_0_s_ifspec; + +#ifndef __ID3D12Device_INTERFACE_DEFINED__ +#define __ID3D12Device_INTERFACE_DEFINED__ + +/* interface ID3D12Device */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12Device; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("189819f1-1db6-4b57-be54-1821339b85f7") + ID3D12Device : public ID3D12Object + { + public: + virtual UINT STDMETHODCALLTYPE GetNodeCount( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateCommandQueue( + _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppCommandQueue) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateCommandAllocator( + _In_ D3D12_COMMAND_LIST_TYPE type, + REFIID riid, + _COM_Outptr_ void **ppCommandAllocator) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateGraphicsPipelineState( + _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateComputePipelineState( + _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateCommandList( + _In_ UINT nodeMask, + _In_ D3D12_COMMAND_LIST_TYPE type, + _In_ ID3D12CommandAllocator *pCommandAllocator, + _In_opt_ ID3D12PipelineState *pInitialState, + REFIID riid, + _COM_Outptr_ void **ppCommandList) = 0; + + virtual HRESULT STDMETHODCALLTYPE CheckFeatureSupport( + D3D12_FEATURE Feature, + _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, + UINT FeatureSupportDataSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateDescriptorHeap( + _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, + REFIID riid, + _COM_Outptr_ void **ppvHeap) = 0; + + virtual UINT STDMETHODCALLTYPE GetDescriptorHandleIncrementSize( + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateRootSignature( + _In_ UINT nodeMask, + _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, + _In_ SIZE_T blobLengthInBytes, + REFIID riid, + _COM_Outptr_ void **ppvRootSignature) = 0; + + virtual void STDMETHODCALLTYPE CreateConstantBufferView( + _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0; + + virtual void STDMETHODCALLTYPE CreateShaderResourceView( + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0; + + virtual void STDMETHODCALLTYPE CreateUnorderedAccessView( + _In_opt_ ID3D12Resource *pResource, + _In_opt_ ID3D12Resource *pCounterResource, + _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0; + + virtual void STDMETHODCALLTYPE CreateRenderTargetView( + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0; + + virtual void STDMETHODCALLTYPE CreateDepthStencilView( + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0; + + virtual void STDMETHODCALLTYPE CreateSampler( + _In_ const D3D12_SAMPLER_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0; + + virtual void STDMETHODCALLTYPE CopyDescriptors( + _In_ UINT NumDestDescriptorRanges, + _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts, + _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes, + _In_ UINT NumSrcDescriptorRanges, + _In_reads_(NumSrcDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts, + _In_reads_opt_(NumSrcDescriptorRanges) const UINT *pSrcDescriptorRangeSizes, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType) = 0; + + virtual void STDMETHODCALLTYPE CopyDescriptorsSimple( + _In_ UINT NumDescriptors, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType) = 0; + + virtual D3D12_RESOURCE_ALLOCATION_INFO STDMETHODCALLTYPE GetResourceAllocationInfo( + _In_ UINT visibleMask, + _In_ UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs) = 0; + + virtual D3D12_HEAP_PROPERTIES STDMETHODCALLTYPE GetCustomHeapProperties( + _In_ UINT nodeMask, + D3D12_HEAP_TYPE heapType) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateCommittedResource( + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateHeap( + _In_ const D3D12_HEAP_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreatePlacedResource( + _In_ ID3D12Heap *pHeap, + UINT64 HeapOffset, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateReservedResource( + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateSharedHandle( + _In_ ID3D12DeviceChild *pObject, + _In_opt_ const SECURITY_ATTRIBUTES *pAttributes, + DWORD Access, + _In_opt_ LPCWSTR Name, + _Out_ HANDLE *pHandle) = 0; + + virtual HRESULT STDMETHODCALLTYPE OpenSharedHandle( + _In_ HANDLE NTHandle, + REFIID riid, + _COM_Outptr_opt_ void **ppvObj) = 0; + + virtual HRESULT STDMETHODCALLTYPE OpenSharedHandleByName( + _In_ LPCWSTR Name, + DWORD Access, + /* [annotation][out] */ + _Out_ HANDLE *pNTHandle) = 0; + + virtual HRESULT STDMETHODCALLTYPE MakeResident( + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects) = 0; + + virtual HRESULT STDMETHODCALLTYPE Evict( + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateFence( + UINT64 InitialValue, + D3D12_FENCE_FLAGS Flags, + REFIID riid, + _COM_Outptr_ void **ppFence) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDeviceRemovedReason( void) = 0; + + virtual void STDMETHODCALLTYPE GetCopyableFootprints( + _In_ const D3D12_RESOURCE_DESC *pResourceDesc, + _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, + _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, + UINT64 BaseOffset, + _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, + _Out_writes_opt_(NumSubresources) UINT *pNumRows, + _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, + _Out_opt_ UINT64 *pTotalBytes) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateQueryHeap( + _In_ const D3D12_QUERY_HEAP_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetStablePowerState( + BOOL Enable) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateCommandSignature( + _In_ const D3D12_COMMAND_SIGNATURE_DESC *pDesc, + _In_opt_ ID3D12RootSignature *pRootSignature, + REFIID riid, + _COM_Outptr_opt_ void **ppvCommandSignature) = 0; + + virtual void STDMETHODCALLTYPE GetResourceTiling( + _In_ ID3D12Resource *pTiledResource, + _Out_opt_ UINT *pNumTilesForEntireResource, + _Out_opt_ D3D12_PACKED_MIP_INFO *pPackedMipDesc, + _Out_opt_ D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips, + _Inout_opt_ UINT *pNumSubresourceTilings, + _In_ UINT FirstSubresourceTilingToGet, + _Out_writes_(*pNumSubresourceTilings) D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips) = 0; + + virtual LUID STDMETHODCALLTYPE GetAdapterLuid( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12DeviceVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12Device * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12Device * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12Device * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12Device * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12Device * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12Device * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12Device * This, + _In_z_ LPCWSTR Name); + + UINT ( STDMETHODCALLTYPE *GetNodeCount )( + ID3D12Device * This); + + HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( + ID3D12Device * This, + _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppCommandQueue); + + HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( + ID3D12Device * This, + _In_ D3D12_COMMAND_LIST_TYPE type, + REFIID riid, + _COM_Outptr_ void **ppCommandAllocator); + + HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( + ID3D12Device * This, + _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( + ID3D12Device * This, + _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( + ID3D12Device * This, + _In_ UINT nodeMask, + _In_ D3D12_COMMAND_LIST_TYPE type, + _In_ ID3D12CommandAllocator *pCommandAllocator, + _In_opt_ ID3D12PipelineState *pInitialState, + REFIID riid, + _COM_Outptr_ void **ppCommandList); + + HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( + ID3D12Device * This, + D3D12_FEATURE Feature, + _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, + UINT FeatureSupportDataSize); + + HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( + ID3D12Device * This, + _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, + REFIID riid, + _COM_Outptr_ void **ppvHeap); + + UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( + ID3D12Device * This, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType); + + HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( + ID3D12Device * This, + _In_ UINT nodeMask, + _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, + _In_ SIZE_T blobLengthInBytes, + REFIID riid, + _COM_Outptr_ void **ppvRootSignature); + + void ( STDMETHODCALLTYPE *CreateConstantBufferView )( + ID3D12Device * This, + _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateShaderResourceView )( + ID3D12Device * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( + ID3D12Device * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ ID3D12Resource *pCounterResource, + _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateRenderTargetView )( + ID3D12Device * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateDepthStencilView )( + ID3D12Device * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateSampler )( + ID3D12Device * This, + _In_ const D3D12_SAMPLER_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CopyDescriptors )( + ID3D12Device * This, + _In_ UINT NumDestDescriptorRanges, + _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts, + _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes, + _In_ UINT NumSrcDescriptorRanges, + _In_reads_(NumSrcDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts, + _In_reads_opt_(NumSrcDescriptorRanges) const UINT *pSrcDescriptorRangeSizes, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + + void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( + ID3D12Device * This, + _In_ UINT NumDescriptors, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( + ID3D12Device * This, + _In_ UINT visibleMask, + _In_ UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); + + D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( + ID3D12Device * This, + _In_ UINT nodeMask, + D3D12_HEAP_TYPE heapType); + + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( + ID3D12Device * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); + + HRESULT ( STDMETHODCALLTYPE *CreateHeap )( + ID3D12Device * This, + _In_ const D3D12_HEAP_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); + + HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( + ID3D12Device * This, + _In_ ID3D12Heap *pHeap, + UINT64 HeapOffset, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( + ID3D12Device * This, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( + ID3D12Device * This, + _In_ ID3D12DeviceChild *pObject, + _In_opt_ const SECURITY_ATTRIBUTES *pAttributes, + DWORD Access, + _In_opt_ LPCWSTR Name, + _Out_ HANDLE *pHandle); + + HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( + ID3D12Device * This, + _In_ HANDLE NTHandle, + REFIID riid, + _COM_Outptr_opt_ void **ppvObj); + + HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( + ID3D12Device * This, + _In_ LPCWSTR Name, + DWORD Access, + /* [annotation][out] */ + _Out_ HANDLE *pNTHandle); + + HRESULT ( STDMETHODCALLTYPE *MakeResident )( + ID3D12Device * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); + + HRESULT ( STDMETHODCALLTYPE *Evict )( + ID3D12Device * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); + + HRESULT ( STDMETHODCALLTYPE *CreateFence )( + ID3D12Device * This, + UINT64 InitialValue, + D3D12_FENCE_FLAGS Flags, + REFIID riid, + _COM_Outptr_ void **ppFence); + + HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( + ID3D12Device * This); + + void ( STDMETHODCALLTYPE *GetCopyableFootprints )( + ID3D12Device * This, + _In_ const D3D12_RESOURCE_DESC *pResourceDesc, + _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, + _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, + UINT64 BaseOffset, + _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, + _Out_writes_opt_(NumSubresources) UINT *pNumRows, + _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, + _Out_opt_ UINT64 *pTotalBytes); + + HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( + ID3D12Device * This, + _In_ const D3D12_QUERY_HEAP_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); + + HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( + ID3D12Device * This, + BOOL Enable); + + HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( + ID3D12Device * This, + _In_ const D3D12_COMMAND_SIGNATURE_DESC *pDesc, + _In_opt_ ID3D12RootSignature *pRootSignature, + REFIID riid, + _COM_Outptr_opt_ void **ppvCommandSignature); + + void ( STDMETHODCALLTYPE *GetResourceTiling )( + ID3D12Device * This, + _In_ ID3D12Resource *pTiledResource, + _Out_opt_ UINT *pNumTilesForEntireResource, + _Out_opt_ D3D12_PACKED_MIP_INFO *pPackedMipDesc, + _Out_opt_ D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips, + _Inout_opt_ UINT *pNumSubresourceTilings, + _In_ UINT FirstSubresourceTilingToGet, + _Out_writes_(*pNumSubresourceTilings) D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips); + + LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( + ID3D12Device * This); + + END_INTERFACE + } ID3D12DeviceVtbl; + + interface ID3D12Device + { + CONST_VTBL struct ID3D12DeviceVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12Device_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12Device_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12Device_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12Device_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12Device_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12Device_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12Device_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12Device_GetNodeCount(This) \ + ( (This)->lpVtbl -> GetNodeCount(This) ) + +#define ID3D12Device_CreateCommandQueue(This,pDesc,riid,ppCommandQueue) \ + ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) + +#define ID3D12Device_CreateCommandAllocator(This,type,riid,ppCommandAllocator) \ + ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) + +#define ID3D12Device_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) + +#define ID3D12Device_CreateComputePipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) + +#define ID3D12Device_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) \ + ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) + +#define ID3D12Device_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) \ + ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) + +#define ID3D12Device_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) + +#define ID3D12Device_GetDescriptorHandleIncrementSize(This,DescriptorHeapType) \ + ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) + +#define ID3D12Device_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) \ + ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) + +#define ID3D12Device_CreateConstantBufferView(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) + +#define ID3D12Device_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) + +#define ID3D12Device_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device_CreateSampler(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) + +#define ID3D12Device_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) \ + ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) + +#define ID3D12Device_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) \ + ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) + +#define ID3D12Device_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) + +#define ID3D12Device_GetCustomHeapProperties(This,nodeMask,heapType) \ + ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) + +#define ID3D12Device_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) + +#define ID3D12Device_CreateHeap(This,pDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) + +#define ID3D12Device_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) + +#define ID3D12Device_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) + +#define ID3D12Device_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) \ + ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) + +#define ID3D12Device_OpenSharedHandle(This,NTHandle,riid,ppvObj) \ + ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) + +#define ID3D12Device_OpenSharedHandleByName(This,Name,Access,pNTHandle) \ + ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) + +#define ID3D12Device_MakeResident(This,NumObjects,ppObjects) \ + ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) + +#define ID3D12Device_Evict(This,NumObjects,ppObjects) \ + ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) + +#define ID3D12Device_CreateFence(This,InitialValue,Flags,riid,ppFence) \ + ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) + +#define ID3D12Device_GetDeviceRemovedReason(This) \ + ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) + +#define ID3D12Device_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ + ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) + +#define ID3D12Device_CreateQueryHeap(This,pDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) + +#define ID3D12Device_SetStablePowerState(This,Enable) \ + ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) + +#define ID3D12Device_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) \ + ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) + +#define ID3D12Device_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) \ + ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) + +#define ID3D12Device_GetAdapterLuid(This) \ + ( (This)->lpVtbl -> GetAdapterLuid(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + + + + + + + + + + + + + +#endif /* __ID3D12Device_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12PipelineLibrary_INTERFACE_DEFINED__ +#define __ID3D12PipelineLibrary_INTERFACE_DEFINED__ + +/* interface ID3D12PipelineLibrary */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12PipelineLibrary; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("c64226a8-9201-46af-b4cc-53fb9ff7414f") + ID3D12PipelineLibrary : public ID3D12DeviceChild + { + public: + virtual HRESULT STDMETHODCALLTYPE StorePipeline( + _In_opt_ LPCWSTR pName, + _In_ ID3D12PipelineState *pPipeline) = 0; + + virtual HRESULT STDMETHODCALLTYPE LoadGraphicsPipeline( + _In_ LPCWSTR pName, + _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState) = 0; + + virtual HRESULT STDMETHODCALLTYPE LoadComputePipeline( + _In_ LPCWSTR pName, + _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState) = 0; + + virtual SIZE_T STDMETHODCALLTYPE GetSerializedSize( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Serialize( + _Out_writes_(DataSizeInBytes) void *pData, + SIZE_T DataSizeInBytes) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12PipelineLibraryVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12PipelineLibrary * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12PipelineLibrary * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12PipelineLibrary * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12PipelineLibrary * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12PipelineLibrary * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12PipelineLibrary * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12PipelineLibrary * This, + _In_z_ LPCWSTR Name); + + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12PipelineLibrary * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + HRESULT ( STDMETHODCALLTYPE *StorePipeline )( + ID3D12PipelineLibrary * This, + _In_opt_ LPCWSTR pName, + _In_ ID3D12PipelineState *pPipeline); + + HRESULT ( STDMETHODCALLTYPE *LoadGraphicsPipeline )( + ID3D12PipelineLibrary * This, + _In_ LPCWSTR pName, + _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + HRESULT ( STDMETHODCALLTYPE *LoadComputePipeline )( + ID3D12PipelineLibrary * This, + _In_ LPCWSTR pName, + _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + SIZE_T ( STDMETHODCALLTYPE *GetSerializedSize )( + ID3D12PipelineLibrary * This); + + HRESULT ( STDMETHODCALLTYPE *Serialize )( + ID3D12PipelineLibrary * This, + _Out_writes_(DataSizeInBytes) void *pData, + SIZE_T DataSizeInBytes); + + END_INTERFACE + } ID3D12PipelineLibraryVtbl; + + interface ID3D12PipelineLibrary + { + CONST_VTBL struct ID3D12PipelineLibraryVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12PipelineLibrary_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12PipelineLibrary_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12PipelineLibrary_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12PipelineLibrary_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12PipelineLibrary_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12PipelineLibrary_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12PipelineLibrary_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12PipelineLibrary_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + +#define ID3D12PipelineLibrary_StorePipeline(This,pName,pPipeline) \ + ( (This)->lpVtbl -> StorePipeline(This,pName,pPipeline) ) + +#define ID3D12PipelineLibrary_LoadGraphicsPipeline(This,pName,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> LoadGraphicsPipeline(This,pName,pDesc,riid,ppPipelineState) ) + +#define ID3D12PipelineLibrary_LoadComputePipeline(This,pName,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> LoadComputePipeline(This,pName,pDesc,riid,ppPipelineState) ) + +#define ID3D12PipelineLibrary_GetSerializedSize(This) \ + ( (This)->lpVtbl -> GetSerializedSize(This) ) + +#define ID3D12PipelineLibrary_Serialize(This,pData,DataSizeInBytes) \ + ( (This)->lpVtbl -> Serialize(This,pData,DataSizeInBytes) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12PipelineLibrary_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12PipelineLibrary1_INTERFACE_DEFINED__ +#define __ID3D12PipelineLibrary1_INTERFACE_DEFINED__ + +/* interface ID3D12PipelineLibrary1 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12PipelineLibrary1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("80eabf42-2568-4e5e-bd82-c37f86961dc3") + ID3D12PipelineLibrary1 : public ID3D12PipelineLibrary + { + public: + virtual HRESULT STDMETHODCALLTYPE LoadPipeline( + _In_ LPCWSTR pName, + _In_ const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12PipelineLibrary1Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12PipelineLibrary1 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12PipelineLibrary1 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12PipelineLibrary1 * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12PipelineLibrary1 * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12PipelineLibrary1 * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12PipelineLibrary1 * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12PipelineLibrary1 * This, + _In_z_ LPCWSTR Name); + + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12PipelineLibrary1 * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + HRESULT ( STDMETHODCALLTYPE *StorePipeline )( + ID3D12PipelineLibrary1 * This, + _In_opt_ LPCWSTR pName, + _In_ ID3D12PipelineState *pPipeline); + + HRESULT ( STDMETHODCALLTYPE *LoadGraphicsPipeline )( + ID3D12PipelineLibrary1 * This, + _In_ LPCWSTR pName, + _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + HRESULT ( STDMETHODCALLTYPE *LoadComputePipeline )( + ID3D12PipelineLibrary1 * This, + _In_ LPCWSTR pName, + _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + SIZE_T ( STDMETHODCALLTYPE *GetSerializedSize )( + ID3D12PipelineLibrary1 * This); + + HRESULT ( STDMETHODCALLTYPE *Serialize )( + ID3D12PipelineLibrary1 * This, + _Out_writes_(DataSizeInBytes) void *pData, + SIZE_T DataSizeInBytes); + + HRESULT ( STDMETHODCALLTYPE *LoadPipeline )( + ID3D12PipelineLibrary1 * This, + _In_ LPCWSTR pName, + _In_ const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + END_INTERFACE + } ID3D12PipelineLibrary1Vtbl; + + interface ID3D12PipelineLibrary1 + { + CONST_VTBL struct ID3D12PipelineLibrary1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12PipelineLibrary1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12PipelineLibrary1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12PipelineLibrary1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12PipelineLibrary1_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12PipelineLibrary1_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12PipelineLibrary1_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12PipelineLibrary1_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12PipelineLibrary1_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + +#define ID3D12PipelineLibrary1_StorePipeline(This,pName,pPipeline) \ + ( (This)->lpVtbl -> StorePipeline(This,pName,pPipeline) ) + +#define ID3D12PipelineLibrary1_LoadGraphicsPipeline(This,pName,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> LoadGraphicsPipeline(This,pName,pDesc,riid,ppPipelineState) ) + +#define ID3D12PipelineLibrary1_LoadComputePipeline(This,pName,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> LoadComputePipeline(This,pName,pDesc,riid,ppPipelineState) ) + +#define ID3D12PipelineLibrary1_GetSerializedSize(This) \ + ( (This)->lpVtbl -> GetSerializedSize(This) ) + +#define ID3D12PipelineLibrary1_Serialize(This,pData,DataSizeInBytes) \ + ( (This)->lpVtbl -> Serialize(This,pData,DataSizeInBytes) ) + + +#define ID3D12PipelineLibrary1_LoadPipeline(This,pName,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> LoadPipeline(This,pName,pDesc,riid,ppPipelineState) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12PipelineLibrary1_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12_0000_0023 */ +/* [local] */ + +typedef +enum D3D12_MULTIPLE_FENCE_WAIT_FLAGS + { + D3D12_MULTIPLE_FENCE_WAIT_FLAG_NONE = 0, + D3D12_MULTIPLE_FENCE_WAIT_FLAG_ANY = 0x1, + D3D12_MULTIPLE_FENCE_WAIT_FLAG_ALL = 0 + } D3D12_MULTIPLE_FENCE_WAIT_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_MULTIPLE_FENCE_WAIT_FLAGS ); +typedef +enum D3D12_RESIDENCY_PRIORITY + { + D3D12_RESIDENCY_PRIORITY_MINIMUM = 0x28000000, + D3D12_RESIDENCY_PRIORITY_LOW = 0x50000000, + D3D12_RESIDENCY_PRIORITY_NORMAL = 0x78000000, + D3D12_RESIDENCY_PRIORITY_HIGH = 0xa0010000, + D3D12_RESIDENCY_PRIORITY_MAXIMUM = 0xc8000000 + } D3D12_RESIDENCY_PRIORITY; + + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0023_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0023_v0_0_s_ifspec; + +#ifndef __ID3D12Device1_INTERFACE_DEFINED__ +#define __ID3D12Device1_INTERFACE_DEFINED__ + +/* interface ID3D12Device1 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12Device1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("77acce80-638e-4e65-8895-c1f23386863e") + ID3D12Device1 : public ID3D12Device + { + public: + virtual HRESULT STDMETHODCALLTYPE CreatePipelineLibrary( + _In_reads_(BlobLength) const void *pLibraryBlob, + SIZE_T BlobLength, + REFIID riid, + _COM_Outptr_ void **ppPipelineLibrary) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetEventOnMultipleFenceCompletion( + _In_reads_(NumFences) ID3D12Fence *const *ppFences, + _In_reads_(NumFences) const UINT64 *pFenceValues, + UINT NumFences, + D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags, + HANDLE hEvent) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetResidencyPriority( + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, + _In_reads_(NumObjects) const D3D12_RESIDENCY_PRIORITY *pPriorities) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12Device1Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12Device1 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12Device1 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12Device1 * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12Device1 * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12Device1 * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12Device1 * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12Device1 * This, + _In_z_ LPCWSTR Name); + + UINT ( STDMETHODCALLTYPE *GetNodeCount )( + ID3D12Device1 * This); + + HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( + ID3D12Device1 * This, + _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppCommandQueue); + + HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( + ID3D12Device1 * This, + _In_ D3D12_COMMAND_LIST_TYPE type, + REFIID riid, + _COM_Outptr_ void **ppCommandAllocator); + + HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( + ID3D12Device1 * This, + _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( + ID3D12Device1 * This, + _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( + ID3D12Device1 * This, + _In_ UINT nodeMask, + _In_ D3D12_COMMAND_LIST_TYPE type, + _In_ ID3D12CommandAllocator *pCommandAllocator, + _In_opt_ ID3D12PipelineState *pInitialState, + REFIID riid, + _COM_Outptr_ void **ppCommandList); + + HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( + ID3D12Device1 * This, + D3D12_FEATURE Feature, + _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, + UINT FeatureSupportDataSize); + + HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( + ID3D12Device1 * This, + _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, + REFIID riid, + _COM_Outptr_ void **ppvHeap); + + UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( + ID3D12Device1 * This, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType); + + HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( + ID3D12Device1 * This, + _In_ UINT nodeMask, + _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, + _In_ SIZE_T blobLengthInBytes, + REFIID riid, + _COM_Outptr_ void **ppvRootSignature); + + void ( STDMETHODCALLTYPE *CreateConstantBufferView )( + ID3D12Device1 * This, + _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateShaderResourceView )( + ID3D12Device1 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( + ID3D12Device1 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ ID3D12Resource *pCounterResource, + _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateRenderTargetView )( + ID3D12Device1 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateDepthStencilView )( + ID3D12Device1 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateSampler )( + ID3D12Device1 * This, + _In_ const D3D12_SAMPLER_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CopyDescriptors )( + ID3D12Device1 * This, + _In_ UINT NumDestDescriptorRanges, + _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts, + _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes, + _In_ UINT NumSrcDescriptorRanges, + _In_reads_(NumSrcDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts, + _In_reads_opt_(NumSrcDescriptorRanges) const UINT *pSrcDescriptorRangeSizes, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + + void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( + ID3D12Device1 * This, + _In_ UINT NumDescriptors, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( + ID3D12Device1 * This, + _In_ UINT visibleMask, + _In_ UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); + + D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( + ID3D12Device1 * This, + _In_ UINT nodeMask, + D3D12_HEAP_TYPE heapType); + + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( + ID3D12Device1 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); + + HRESULT ( STDMETHODCALLTYPE *CreateHeap )( + ID3D12Device1 * This, + _In_ const D3D12_HEAP_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); + + HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( + ID3D12Device1 * This, + _In_ ID3D12Heap *pHeap, + UINT64 HeapOffset, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( + ID3D12Device1 * This, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( + ID3D12Device1 * This, + _In_ ID3D12DeviceChild *pObject, + _In_opt_ const SECURITY_ATTRIBUTES *pAttributes, + DWORD Access, + _In_opt_ LPCWSTR Name, + _Out_ HANDLE *pHandle); + + HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( + ID3D12Device1 * This, + _In_ HANDLE NTHandle, + REFIID riid, + _COM_Outptr_opt_ void **ppvObj); + + HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( + ID3D12Device1 * This, + _In_ LPCWSTR Name, + DWORD Access, + /* [annotation][out] */ + _Out_ HANDLE *pNTHandle); + + HRESULT ( STDMETHODCALLTYPE *MakeResident )( + ID3D12Device1 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); + + HRESULT ( STDMETHODCALLTYPE *Evict )( + ID3D12Device1 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); + + HRESULT ( STDMETHODCALLTYPE *CreateFence )( + ID3D12Device1 * This, + UINT64 InitialValue, + D3D12_FENCE_FLAGS Flags, + REFIID riid, + _COM_Outptr_ void **ppFence); + + HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( + ID3D12Device1 * This); + + void ( STDMETHODCALLTYPE *GetCopyableFootprints )( + ID3D12Device1 * This, + _In_ const D3D12_RESOURCE_DESC *pResourceDesc, + _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, + _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, + UINT64 BaseOffset, + _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, + _Out_writes_opt_(NumSubresources) UINT *pNumRows, + _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, + _Out_opt_ UINT64 *pTotalBytes); + + HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( + ID3D12Device1 * This, + _In_ const D3D12_QUERY_HEAP_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); + + HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( + ID3D12Device1 * This, + BOOL Enable); + + HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( + ID3D12Device1 * This, + _In_ const D3D12_COMMAND_SIGNATURE_DESC *pDesc, + _In_opt_ ID3D12RootSignature *pRootSignature, + REFIID riid, + _COM_Outptr_opt_ void **ppvCommandSignature); + + void ( STDMETHODCALLTYPE *GetResourceTiling )( + ID3D12Device1 * This, + _In_ ID3D12Resource *pTiledResource, + _Out_opt_ UINT *pNumTilesForEntireResource, + _Out_opt_ D3D12_PACKED_MIP_INFO *pPackedMipDesc, + _Out_opt_ D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips, + _Inout_opt_ UINT *pNumSubresourceTilings, + _In_ UINT FirstSubresourceTilingToGet, + _Out_writes_(*pNumSubresourceTilings) D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips); + + LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( + ID3D12Device1 * This); + + HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( + ID3D12Device1 * This, + _In_reads_(BlobLength) const void *pLibraryBlob, + SIZE_T BlobLength, + REFIID riid, + _COM_Outptr_ void **ppPipelineLibrary); + + HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( + ID3D12Device1 * This, + _In_reads_(NumFences) ID3D12Fence *const *ppFences, + _In_reads_(NumFences) const UINT64 *pFenceValues, + UINT NumFences, + D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags, + HANDLE hEvent); + + HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( + ID3D12Device1 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, + _In_reads_(NumObjects) const D3D12_RESIDENCY_PRIORITY *pPriorities); + + END_INTERFACE + } ID3D12Device1Vtbl; + + interface ID3D12Device1 + { + CONST_VTBL struct ID3D12Device1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12Device1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12Device1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12Device1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12Device1_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12Device1_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12Device1_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12Device1_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12Device1_GetNodeCount(This) \ + ( (This)->lpVtbl -> GetNodeCount(This) ) + +#define ID3D12Device1_CreateCommandQueue(This,pDesc,riid,ppCommandQueue) \ + ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) + +#define ID3D12Device1_CreateCommandAllocator(This,type,riid,ppCommandAllocator) \ + ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) + +#define ID3D12Device1_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) + +#define ID3D12Device1_CreateComputePipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) + +#define ID3D12Device1_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) \ + ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) + +#define ID3D12Device1_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) \ + ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) + +#define ID3D12Device1_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) + +#define ID3D12Device1_GetDescriptorHandleIncrementSize(This,DescriptorHeapType) \ + ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) + +#define ID3D12Device1_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) \ + ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) + +#define ID3D12Device1_CreateConstantBufferView(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) + +#define ID3D12Device1_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device1_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) + +#define ID3D12Device1_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device1_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device1_CreateSampler(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) + +#define ID3D12Device1_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) \ + ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) + +#define ID3D12Device1_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) \ + ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) + +#define ID3D12Device1_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) + +#define ID3D12Device1_GetCustomHeapProperties(This,nodeMask,heapType) \ + ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) + +#define ID3D12Device1_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) + +#define ID3D12Device1_CreateHeap(This,pDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) + +#define ID3D12Device1_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) + +#define ID3D12Device1_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) + +#define ID3D12Device1_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) \ + ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) + +#define ID3D12Device1_OpenSharedHandle(This,NTHandle,riid,ppvObj) \ + ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) + +#define ID3D12Device1_OpenSharedHandleByName(This,Name,Access,pNTHandle) \ + ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) + +#define ID3D12Device1_MakeResident(This,NumObjects,ppObjects) \ + ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) + +#define ID3D12Device1_Evict(This,NumObjects,ppObjects) \ + ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) + +#define ID3D12Device1_CreateFence(This,InitialValue,Flags,riid,ppFence) \ + ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) + +#define ID3D12Device1_GetDeviceRemovedReason(This) \ + ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) + +#define ID3D12Device1_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ + ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) + +#define ID3D12Device1_CreateQueryHeap(This,pDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) + +#define ID3D12Device1_SetStablePowerState(This,Enable) \ + ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) + +#define ID3D12Device1_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) \ + ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) + +#define ID3D12Device1_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) \ + ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) + +#define ID3D12Device1_GetAdapterLuid(This) \ + ( (This)->lpVtbl -> GetAdapterLuid(This) ) + + +#define ID3D12Device1_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) \ + ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) + +#define ID3D12Device1_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) \ + ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) + +#define ID3D12Device1_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) \ + ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12Device1_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12Device2_INTERFACE_DEFINED__ +#define __ID3D12Device2_INTERFACE_DEFINED__ + +/* interface ID3D12Device2 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12Device2; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("30baa41e-b15b-475c-a0bb-1af5c5b64328") + ID3D12Device2 : public ID3D12Device1 + { + public: + virtual HRESULT STDMETHODCALLTYPE CreatePipelineState( + const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12Device2Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12Device2 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12Device2 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12Device2 * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12Device2 * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12Device2 * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12Device2 * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12Device2 * This, + _In_z_ LPCWSTR Name); + + UINT ( STDMETHODCALLTYPE *GetNodeCount )( + ID3D12Device2 * This); + + HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( + ID3D12Device2 * This, + _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppCommandQueue); + + HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( + ID3D12Device2 * This, + _In_ D3D12_COMMAND_LIST_TYPE type, + REFIID riid, + _COM_Outptr_ void **ppCommandAllocator); + + HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( + ID3D12Device2 * This, + _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( + ID3D12Device2 * This, + _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( + ID3D12Device2 * This, + _In_ UINT nodeMask, + _In_ D3D12_COMMAND_LIST_TYPE type, + _In_ ID3D12CommandAllocator *pCommandAllocator, + _In_opt_ ID3D12PipelineState *pInitialState, + REFIID riid, + _COM_Outptr_ void **ppCommandList); + + HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( + ID3D12Device2 * This, + D3D12_FEATURE Feature, + _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, + UINT FeatureSupportDataSize); + + HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( + ID3D12Device2 * This, + _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, + REFIID riid, + _COM_Outptr_ void **ppvHeap); + + UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( + ID3D12Device2 * This, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType); + + HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( + ID3D12Device2 * This, + _In_ UINT nodeMask, + _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, + _In_ SIZE_T blobLengthInBytes, + REFIID riid, + _COM_Outptr_ void **ppvRootSignature); + + void ( STDMETHODCALLTYPE *CreateConstantBufferView )( + ID3D12Device2 * This, + _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateShaderResourceView )( + ID3D12Device2 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( + ID3D12Device2 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ ID3D12Resource *pCounterResource, + _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateRenderTargetView )( + ID3D12Device2 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateDepthStencilView )( + ID3D12Device2 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateSampler )( + ID3D12Device2 * This, + _In_ const D3D12_SAMPLER_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CopyDescriptors )( + ID3D12Device2 * This, + _In_ UINT NumDestDescriptorRanges, + _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts, + _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes, + _In_ UINT NumSrcDescriptorRanges, + _In_reads_(NumSrcDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts, + _In_reads_opt_(NumSrcDescriptorRanges) const UINT *pSrcDescriptorRangeSizes, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + + void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( + ID3D12Device2 * This, + _In_ UINT NumDescriptors, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( + ID3D12Device2 * This, + _In_ UINT visibleMask, + _In_ UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); + + D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( + ID3D12Device2 * This, + _In_ UINT nodeMask, + D3D12_HEAP_TYPE heapType); + + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( + ID3D12Device2 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); + + HRESULT ( STDMETHODCALLTYPE *CreateHeap )( + ID3D12Device2 * This, + _In_ const D3D12_HEAP_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); + + HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( + ID3D12Device2 * This, + _In_ ID3D12Heap *pHeap, + UINT64 HeapOffset, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( + ID3D12Device2 * This, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( + ID3D12Device2 * This, + _In_ ID3D12DeviceChild *pObject, + _In_opt_ const SECURITY_ATTRIBUTES *pAttributes, + DWORD Access, + _In_opt_ LPCWSTR Name, + _Out_ HANDLE *pHandle); + + HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( + ID3D12Device2 * This, + _In_ HANDLE NTHandle, + REFIID riid, + _COM_Outptr_opt_ void **ppvObj); + + HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( + ID3D12Device2 * This, + _In_ LPCWSTR Name, + DWORD Access, + /* [annotation][out] */ + _Out_ HANDLE *pNTHandle); + + HRESULT ( STDMETHODCALLTYPE *MakeResident )( + ID3D12Device2 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); + + HRESULT ( STDMETHODCALLTYPE *Evict )( + ID3D12Device2 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); + + HRESULT ( STDMETHODCALLTYPE *CreateFence )( + ID3D12Device2 * This, + UINT64 InitialValue, + D3D12_FENCE_FLAGS Flags, + REFIID riid, + _COM_Outptr_ void **ppFence); + + HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( + ID3D12Device2 * This); + + void ( STDMETHODCALLTYPE *GetCopyableFootprints )( + ID3D12Device2 * This, + _In_ const D3D12_RESOURCE_DESC *pResourceDesc, + _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, + _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, + UINT64 BaseOffset, + _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, + _Out_writes_opt_(NumSubresources) UINT *pNumRows, + _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, + _Out_opt_ UINT64 *pTotalBytes); + + HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( + ID3D12Device2 * This, + _In_ const D3D12_QUERY_HEAP_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); + + HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( + ID3D12Device2 * This, + BOOL Enable); + + HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( + ID3D12Device2 * This, + _In_ const D3D12_COMMAND_SIGNATURE_DESC *pDesc, + _In_opt_ ID3D12RootSignature *pRootSignature, + REFIID riid, + _COM_Outptr_opt_ void **ppvCommandSignature); + + void ( STDMETHODCALLTYPE *GetResourceTiling )( + ID3D12Device2 * This, + _In_ ID3D12Resource *pTiledResource, + _Out_opt_ UINT *pNumTilesForEntireResource, + _Out_opt_ D3D12_PACKED_MIP_INFO *pPackedMipDesc, + _Out_opt_ D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips, + _Inout_opt_ UINT *pNumSubresourceTilings, + _In_ UINT FirstSubresourceTilingToGet, + _Out_writes_(*pNumSubresourceTilings) D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips); + + LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( + ID3D12Device2 * This); + + HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( + ID3D12Device2 * This, + _In_reads_(BlobLength) const void *pLibraryBlob, + SIZE_T BlobLength, + REFIID riid, + _COM_Outptr_ void **ppPipelineLibrary); + + HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( + ID3D12Device2 * This, + _In_reads_(NumFences) ID3D12Fence *const *ppFences, + _In_reads_(NumFences) const UINT64 *pFenceValues, + UINT NumFences, + D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags, + HANDLE hEvent); + + HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( + ID3D12Device2 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, + _In_reads_(NumObjects) const D3D12_RESIDENCY_PRIORITY *pPriorities); + + HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( + ID3D12Device2 * This, + const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + END_INTERFACE + } ID3D12Device2Vtbl; + + interface ID3D12Device2 + { + CONST_VTBL struct ID3D12Device2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12Device2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12Device2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12Device2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12Device2_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12Device2_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12Device2_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12Device2_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12Device2_GetNodeCount(This) \ + ( (This)->lpVtbl -> GetNodeCount(This) ) + +#define ID3D12Device2_CreateCommandQueue(This,pDesc,riid,ppCommandQueue) \ + ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) + +#define ID3D12Device2_CreateCommandAllocator(This,type,riid,ppCommandAllocator) \ + ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) + +#define ID3D12Device2_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) + +#define ID3D12Device2_CreateComputePipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) + +#define ID3D12Device2_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) \ + ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) + +#define ID3D12Device2_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) \ + ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) + +#define ID3D12Device2_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) + +#define ID3D12Device2_GetDescriptorHandleIncrementSize(This,DescriptorHeapType) \ + ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) + +#define ID3D12Device2_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) \ + ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) + +#define ID3D12Device2_CreateConstantBufferView(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) + +#define ID3D12Device2_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device2_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) + +#define ID3D12Device2_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device2_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device2_CreateSampler(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) + +#define ID3D12Device2_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) \ + ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) + +#define ID3D12Device2_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) \ + ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) + +#define ID3D12Device2_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) + +#define ID3D12Device2_GetCustomHeapProperties(This,nodeMask,heapType) \ + ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) + +#define ID3D12Device2_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) + +#define ID3D12Device2_CreateHeap(This,pDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) + +#define ID3D12Device2_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) + +#define ID3D12Device2_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) + +#define ID3D12Device2_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) \ + ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) + +#define ID3D12Device2_OpenSharedHandle(This,NTHandle,riid,ppvObj) \ + ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) + +#define ID3D12Device2_OpenSharedHandleByName(This,Name,Access,pNTHandle) \ + ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) + +#define ID3D12Device2_MakeResident(This,NumObjects,ppObjects) \ + ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) + +#define ID3D12Device2_Evict(This,NumObjects,ppObjects) \ + ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) + +#define ID3D12Device2_CreateFence(This,InitialValue,Flags,riid,ppFence) \ + ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) + +#define ID3D12Device2_GetDeviceRemovedReason(This) \ + ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) + +#define ID3D12Device2_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ + ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) + +#define ID3D12Device2_CreateQueryHeap(This,pDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) + +#define ID3D12Device2_SetStablePowerState(This,Enable) \ + ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) + +#define ID3D12Device2_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) \ + ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) + +#define ID3D12Device2_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) \ + ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) + +#define ID3D12Device2_GetAdapterLuid(This) \ + ( (This)->lpVtbl -> GetAdapterLuid(This) ) + + +#define ID3D12Device2_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) \ + ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) + +#define ID3D12Device2_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) \ + ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) + +#define ID3D12Device2_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) \ + ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) + + +#define ID3D12Device2_CreatePipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12Device2_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12_0000_0025 */ +/* [local] */ + +typedef +enum D3D12_RESIDENCY_FLAGS + { + D3D12_RESIDENCY_FLAG_NONE = 0, + D3D12_RESIDENCY_FLAG_DENY_OVERBUDGET = 0x1 + } D3D12_RESIDENCY_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_RESIDENCY_FLAGS ); + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0025_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0025_v0_0_s_ifspec; + +#ifndef __ID3D12Device3_INTERFACE_DEFINED__ +#define __ID3D12Device3_INTERFACE_DEFINED__ + +/* interface ID3D12Device3 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12Device3; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("81dadc15-2bad-4392-93c5-101345c4aa98") + ID3D12Device3 : public ID3D12Device2 + { + public: + virtual HRESULT STDMETHODCALLTYPE OpenExistingHeapFromAddress( + _In_ const void *pAddress, + REFIID riid, + _COM_Outptr_ void **ppvHeap) = 0; + + virtual HRESULT STDMETHODCALLTYPE OpenExistingHeapFromFileMapping( + _In_ HANDLE hFileMapping, + REFIID riid, + _COM_Outptr_ void **ppvHeap) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnqueueMakeResident( + D3D12_RESIDENCY_FLAGS Flags, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, + _In_ ID3D12Fence *pFenceToSignal, + UINT64 FenceValueToSignal) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12Device3Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12Device3 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12Device3 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12Device3 * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12Device3 * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12Device3 * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12Device3 * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12Device3 * This, + _In_z_ LPCWSTR Name); + + UINT ( STDMETHODCALLTYPE *GetNodeCount )( + ID3D12Device3 * This); + + HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( + ID3D12Device3 * This, + _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppCommandQueue); + + HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( + ID3D12Device3 * This, + _In_ D3D12_COMMAND_LIST_TYPE type, + REFIID riid, + _COM_Outptr_ void **ppCommandAllocator); + + HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( + ID3D12Device3 * This, + _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( + ID3D12Device3 * This, + _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( + ID3D12Device3 * This, + _In_ UINT nodeMask, + _In_ D3D12_COMMAND_LIST_TYPE type, + _In_ ID3D12CommandAllocator *pCommandAllocator, + _In_opt_ ID3D12PipelineState *pInitialState, + REFIID riid, + _COM_Outptr_ void **ppCommandList); + + HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( + ID3D12Device3 * This, + D3D12_FEATURE Feature, + _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, + UINT FeatureSupportDataSize); + + HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( + ID3D12Device3 * This, + _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, + REFIID riid, + _COM_Outptr_ void **ppvHeap); + + UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( + ID3D12Device3 * This, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType); + + HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( + ID3D12Device3 * This, + _In_ UINT nodeMask, + _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, + _In_ SIZE_T blobLengthInBytes, + REFIID riid, + _COM_Outptr_ void **ppvRootSignature); + + void ( STDMETHODCALLTYPE *CreateConstantBufferView )( + ID3D12Device3 * This, + _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateShaderResourceView )( + ID3D12Device3 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( + ID3D12Device3 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ ID3D12Resource *pCounterResource, + _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateRenderTargetView )( + ID3D12Device3 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateDepthStencilView )( + ID3D12Device3 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateSampler )( + ID3D12Device3 * This, + _In_ const D3D12_SAMPLER_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CopyDescriptors )( + ID3D12Device3 * This, + _In_ UINT NumDestDescriptorRanges, + _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts, + _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes, + _In_ UINT NumSrcDescriptorRanges, + _In_reads_(NumSrcDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts, + _In_reads_opt_(NumSrcDescriptorRanges) const UINT *pSrcDescriptorRangeSizes, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + + void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( + ID3D12Device3 * This, + _In_ UINT NumDescriptors, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( + ID3D12Device3 * This, + _In_ UINT visibleMask, + _In_ UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); + + D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( + ID3D12Device3 * This, + _In_ UINT nodeMask, + D3D12_HEAP_TYPE heapType); + + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( + ID3D12Device3 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); + + HRESULT ( STDMETHODCALLTYPE *CreateHeap )( + ID3D12Device3 * This, + _In_ const D3D12_HEAP_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); + + HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( + ID3D12Device3 * This, + _In_ ID3D12Heap *pHeap, + UINT64 HeapOffset, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( + ID3D12Device3 * This, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( + ID3D12Device3 * This, + _In_ ID3D12DeviceChild *pObject, + _In_opt_ const SECURITY_ATTRIBUTES *pAttributes, + DWORD Access, + _In_opt_ LPCWSTR Name, + _Out_ HANDLE *pHandle); + + HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( + ID3D12Device3 * This, + _In_ HANDLE NTHandle, + REFIID riid, + _COM_Outptr_opt_ void **ppvObj); + + HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( + ID3D12Device3 * This, + _In_ LPCWSTR Name, + DWORD Access, + /* [annotation][out] */ + _Out_ HANDLE *pNTHandle); + + HRESULT ( STDMETHODCALLTYPE *MakeResident )( + ID3D12Device3 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); + + HRESULT ( STDMETHODCALLTYPE *Evict )( + ID3D12Device3 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); + + HRESULT ( STDMETHODCALLTYPE *CreateFence )( + ID3D12Device3 * This, + UINT64 InitialValue, + D3D12_FENCE_FLAGS Flags, + REFIID riid, + _COM_Outptr_ void **ppFence); + + HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( + ID3D12Device3 * This); + + void ( STDMETHODCALLTYPE *GetCopyableFootprints )( + ID3D12Device3 * This, + _In_ const D3D12_RESOURCE_DESC *pResourceDesc, + _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, + _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, + UINT64 BaseOffset, + _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, + _Out_writes_opt_(NumSubresources) UINT *pNumRows, + _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, + _Out_opt_ UINT64 *pTotalBytes); + + HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( + ID3D12Device3 * This, + _In_ const D3D12_QUERY_HEAP_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); + + HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( + ID3D12Device3 * This, + BOOL Enable); + + HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( + ID3D12Device3 * This, + _In_ const D3D12_COMMAND_SIGNATURE_DESC *pDesc, + _In_opt_ ID3D12RootSignature *pRootSignature, + REFIID riid, + _COM_Outptr_opt_ void **ppvCommandSignature); + + void ( STDMETHODCALLTYPE *GetResourceTiling )( + ID3D12Device3 * This, + _In_ ID3D12Resource *pTiledResource, + _Out_opt_ UINT *pNumTilesForEntireResource, + _Out_opt_ D3D12_PACKED_MIP_INFO *pPackedMipDesc, + _Out_opt_ D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips, + _Inout_opt_ UINT *pNumSubresourceTilings, + _In_ UINT FirstSubresourceTilingToGet, + _Out_writes_(*pNumSubresourceTilings) D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips); + + LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( + ID3D12Device3 * This); + + HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( + ID3D12Device3 * This, + _In_reads_(BlobLength) const void *pLibraryBlob, + SIZE_T BlobLength, + REFIID riid, + _COM_Outptr_ void **ppPipelineLibrary); + + HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( + ID3D12Device3 * This, + _In_reads_(NumFences) ID3D12Fence *const *ppFences, + _In_reads_(NumFences) const UINT64 *pFenceValues, + UINT NumFences, + D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags, + HANDLE hEvent); + + HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( + ID3D12Device3 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, + _In_reads_(NumObjects) const D3D12_RESIDENCY_PRIORITY *pPriorities); + + HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( + ID3D12Device3 * This, + const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress )( + ID3D12Device3 * This, + _In_ const void *pAddress, + REFIID riid, + _COM_Outptr_ void **ppvHeap); + + HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromFileMapping )( + ID3D12Device3 * This, + _In_ HANDLE hFileMapping, + REFIID riid, + _COM_Outptr_ void **ppvHeap); + + HRESULT ( STDMETHODCALLTYPE *EnqueueMakeResident )( + ID3D12Device3 * This, + D3D12_RESIDENCY_FLAGS Flags, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, + _In_ ID3D12Fence *pFenceToSignal, + UINT64 FenceValueToSignal); + + END_INTERFACE + } ID3D12Device3Vtbl; + + interface ID3D12Device3 + { + CONST_VTBL struct ID3D12Device3Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12Device3_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12Device3_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12Device3_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12Device3_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12Device3_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12Device3_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12Device3_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12Device3_GetNodeCount(This) \ + ( (This)->lpVtbl -> GetNodeCount(This) ) + +#define ID3D12Device3_CreateCommandQueue(This,pDesc,riid,ppCommandQueue) \ + ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) + +#define ID3D12Device3_CreateCommandAllocator(This,type,riid,ppCommandAllocator) \ + ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) + +#define ID3D12Device3_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) + +#define ID3D12Device3_CreateComputePipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) + +#define ID3D12Device3_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) \ + ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) + +#define ID3D12Device3_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) \ + ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) + +#define ID3D12Device3_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) + +#define ID3D12Device3_GetDescriptorHandleIncrementSize(This,DescriptorHeapType) \ + ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) + +#define ID3D12Device3_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) \ + ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) + +#define ID3D12Device3_CreateConstantBufferView(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) + +#define ID3D12Device3_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device3_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) + +#define ID3D12Device3_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device3_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device3_CreateSampler(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) + +#define ID3D12Device3_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) \ + ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) + +#define ID3D12Device3_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) \ + ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) + +#define ID3D12Device3_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) + +#define ID3D12Device3_GetCustomHeapProperties(This,nodeMask,heapType) \ + ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) + +#define ID3D12Device3_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) + +#define ID3D12Device3_CreateHeap(This,pDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) + +#define ID3D12Device3_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) + +#define ID3D12Device3_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) + +#define ID3D12Device3_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) \ + ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) + +#define ID3D12Device3_OpenSharedHandle(This,NTHandle,riid,ppvObj) \ + ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) + +#define ID3D12Device3_OpenSharedHandleByName(This,Name,Access,pNTHandle) \ + ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) + +#define ID3D12Device3_MakeResident(This,NumObjects,ppObjects) \ + ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) + +#define ID3D12Device3_Evict(This,NumObjects,ppObjects) \ + ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) + +#define ID3D12Device3_CreateFence(This,InitialValue,Flags,riid,ppFence) \ + ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) + +#define ID3D12Device3_GetDeviceRemovedReason(This) \ + ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) + +#define ID3D12Device3_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ + ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) + +#define ID3D12Device3_CreateQueryHeap(This,pDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) + +#define ID3D12Device3_SetStablePowerState(This,Enable) \ + ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) + +#define ID3D12Device3_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) \ + ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) + +#define ID3D12Device3_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) \ + ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) + +#define ID3D12Device3_GetAdapterLuid(This) \ + ( (This)->lpVtbl -> GetAdapterLuid(This) ) + + +#define ID3D12Device3_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) \ + ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) + +#define ID3D12Device3_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) \ + ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) + +#define ID3D12Device3_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) \ + ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) + + +#define ID3D12Device3_CreatePipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) + + +#define ID3D12Device3_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) \ + ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) + +#define ID3D12Device3_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) \ + ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) + +#define ID3D12Device3_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) \ + ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12Device3_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12_0000_0026 */ +/* [local] */ + +typedef +enum D3D12_COMMAND_LIST_FLAGS + { + D3D12_COMMAND_LIST_FLAG_NONE = 0 + } D3D12_COMMAND_LIST_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_LIST_FLAGS ); +typedef +enum D3D12_COMMAND_POOL_FLAGS + { + D3D12_COMMAND_POOL_FLAG_NONE = 0 + } D3D12_COMMAND_POOL_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_POOL_FLAGS ); +typedef +enum D3D12_COMMAND_RECORDER_FLAGS + { + D3D12_COMMAND_RECORDER_FLAG_NONE = 0 + } D3D12_COMMAND_RECORDER_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_RECORDER_FLAGS ); +typedef +enum D3D12_PROTECTED_SESSION_STATUS + { + D3D12_PROTECTED_SESSION_STATUS_OK = 0, + D3D12_PROTECTED_SESSION_STATUS_INVALID = 1 + } D3D12_PROTECTED_SESSION_STATUS; + + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0026_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0026_v0_0_s_ifspec; + +#ifndef __ID3D12ProtectedSession_INTERFACE_DEFINED__ +#define __ID3D12ProtectedSession_INTERFACE_DEFINED__ + +/* interface ID3D12ProtectedSession */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12ProtectedSession; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("A1533D18-0AC1-4084-85B9-89A96116806B") + ID3D12ProtectedSession : public ID3D12DeviceChild + { + public: + virtual HRESULT STDMETHODCALLTYPE GetStatusFence( + REFIID riid, + _COM_Outptr_opt_ void **ppFence) = 0; + + virtual D3D12_PROTECTED_SESSION_STATUS STDMETHODCALLTYPE GetSessionStatus( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12ProtectedSessionVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12ProtectedSession * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12ProtectedSession * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12ProtectedSession * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12ProtectedSession * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12ProtectedSession * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12ProtectedSession * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12ProtectedSession * This, + _In_z_ LPCWSTR Name); + + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12ProtectedSession * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + HRESULT ( STDMETHODCALLTYPE *GetStatusFence )( + ID3D12ProtectedSession * This, + REFIID riid, + _COM_Outptr_opt_ void **ppFence); + + D3D12_PROTECTED_SESSION_STATUS ( STDMETHODCALLTYPE *GetSessionStatus )( + ID3D12ProtectedSession * This); + + END_INTERFACE + } ID3D12ProtectedSessionVtbl; + + interface ID3D12ProtectedSession + { + CONST_VTBL struct ID3D12ProtectedSessionVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12ProtectedSession_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12ProtectedSession_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12ProtectedSession_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12ProtectedSession_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12ProtectedSession_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12ProtectedSession_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12ProtectedSession_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12ProtectedSession_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + +#define ID3D12ProtectedSession_GetStatusFence(This,riid,ppFence) \ + ( (This)->lpVtbl -> GetStatusFence(This,riid,ppFence) ) + +#define ID3D12ProtectedSession_GetSessionStatus(This) \ + ( (This)->lpVtbl -> GetSessionStatus(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12ProtectedSession_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12_0000_0027 */ +/* [local] */ + +typedef +enum D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS + { + D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_NONE = 0, + D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_SUPPORTED = 0x1 + } D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS ); +typedef struct D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_SUPPORT + { + UINT NodeIndex; + D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS Support; + } D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_SUPPORT; + +typedef +enum D3D12_PROTECTED_RESOURCE_SESSION_FLAGS + { + D3D12_PROTECTED_RESOURCE_SESSION_FLAG_NONE = 0 + } D3D12_PROTECTED_RESOURCE_SESSION_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_PROTECTED_RESOURCE_SESSION_FLAGS ); +typedef struct D3D12_PROTECTED_RESOURCE_SESSION_DESC + { + UINT NodeMask; + D3D12_PROTECTED_RESOURCE_SESSION_FLAGS Flags; + } D3D12_PROTECTED_RESOURCE_SESSION_DESC; + + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0027_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0027_v0_0_s_ifspec; + +#ifndef __ID3D12ProtectedResourceSession_INTERFACE_DEFINED__ +#define __ID3D12ProtectedResourceSession_INTERFACE_DEFINED__ + +/* interface ID3D12ProtectedResourceSession */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12ProtectedResourceSession; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("6CD696F4-F289-40CC-8091-5A6C0A099C3D") + ID3D12ProtectedResourceSession : public ID3D12ProtectedSession + { + public: + virtual D3D12_PROTECTED_RESOURCE_SESSION_DESC STDMETHODCALLTYPE GetDesc( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12ProtectedResourceSessionVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12ProtectedResourceSession * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12ProtectedResourceSession * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12ProtectedResourceSession * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12ProtectedResourceSession * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12ProtectedResourceSession * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12ProtectedResourceSession * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12ProtectedResourceSession * This, + _In_z_ LPCWSTR Name); + + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12ProtectedResourceSession * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + HRESULT ( STDMETHODCALLTYPE *GetStatusFence )( + ID3D12ProtectedResourceSession * This, + REFIID riid, + _COM_Outptr_opt_ void **ppFence); + + D3D12_PROTECTED_SESSION_STATUS ( STDMETHODCALLTYPE *GetSessionStatus )( + ID3D12ProtectedResourceSession * This); + + D3D12_PROTECTED_RESOURCE_SESSION_DESC ( STDMETHODCALLTYPE *GetDesc )( + ID3D12ProtectedResourceSession * This); + + END_INTERFACE + } ID3D12ProtectedResourceSessionVtbl; + + interface ID3D12ProtectedResourceSession + { + CONST_VTBL struct ID3D12ProtectedResourceSessionVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12ProtectedResourceSession_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12ProtectedResourceSession_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12ProtectedResourceSession_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12ProtectedResourceSession_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12ProtectedResourceSession_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12ProtectedResourceSession_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12ProtectedResourceSession_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12ProtectedResourceSession_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + +#define ID3D12ProtectedResourceSession_GetStatusFence(This,riid,ppFence) \ + ( (This)->lpVtbl -> GetStatusFence(This,riid,ppFence) ) + +#define ID3D12ProtectedResourceSession_GetSessionStatus(This) \ + ( (This)->lpVtbl -> GetSessionStatus(This) ) + + +#define ID3D12ProtectedResourceSession_GetDesc(This) \ + ( (This)->lpVtbl -> GetDesc(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + + + + + +#endif /* __ID3D12ProtectedResourceSession_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12Device4_INTERFACE_DEFINED__ +#define __ID3D12Device4_INTERFACE_DEFINED__ + +/* interface ID3D12Device4 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12Device4; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("e865df17-a9ee-46f9-a463-3098315aa2e5") + ID3D12Device4 : public ID3D12Device3 + { + public: + virtual HRESULT STDMETHODCALLTYPE CreateCommandList1( + _In_ UINT nodeMask, + _In_ D3D12_COMMAND_LIST_TYPE type, + _In_ D3D12_COMMAND_LIST_FLAGS flags, + REFIID riid, + _COM_Outptr_ void **ppCommandList) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateProtectedResourceSession( + _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC *pDesc, + _In_ REFIID riid, + _COM_Outptr_ void **ppSession) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateCommittedResource1( + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateHeap1( + _In_ const D3D12_HEAP_DESC *pDesc, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateReservedResource1( + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource) = 0; + + virtual D3D12_RESOURCE_ALLOCATION_INFO STDMETHODCALLTYPE GetResourceAllocationInfo1( + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12Device4Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12Device4 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12Device4 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12Device4 * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12Device4 * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12Device4 * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12Device4 * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12Device4 * This, + _In_z_ LPCWSTR Name); + + UINT ( STDMETHODCALLTYPE *GetNodeCount )( + ID3D12Device4 * This); + + HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( + ID3D12Device4 * This, + _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppCommandQueue); + + HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( + ID3D12Device4 * This, + _In_ D3D12_COMMAND_LIST_TYPE type, + REFIID riid, + _COM_Outptr_ void **ppCommandAllocator); + + HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( + ID3D12Device4 * This, + _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( + ID3D12Device4 * This, + _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( + ID3D12Device4 * This, + _In_ UINT nodeMask, + _In_ D3D12_COMMAND_LIST_TYPE type, + _In_ ID3D12CommandAllocator *pCommandAllocator, + _In_opt_ ID3D12PipelineState *pInitialState, + REFIID riid, + _COM_Outptr_ void **ppCommandList); + + HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( + ID3D12Device4 * This, + D3D12_FEATURE Feature, + _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, + UINT FeatureSupportDataSize); + + HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( + ID3D12Device4 * This, + _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, + REFIID riid, + _COM_Outptr_ void **ppvHeap); + + UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( + ID3D12Device4 * This, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType); + + HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( + ID3D12Device4 * This, + _In_ UINT nodeMask, + _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, + _In_ SIZE_T blobLengthInBytes, + REFIID riid, + _COM_Outptr_ void **ppvRootSignature); + + void ( STDMETHODCALLTYPE *CreateConstantBufferView )( + ID3D12Device4 * This, + _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateShaderResourceView )( + ID3D12Device4 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( + ID3D12Device4 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ ID3D12Resource *pCounterResource, + _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateRenderTargetView )( + ID3D12Device4 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateDepthStencilView )( + ID3D12Device4 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateSampler )( + ID3D12Device4 * This, + _In_ const D3D12_SAMPLER_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CopyDescriptors )( + ID3D12Device4 * This, + _In_ UINT NumDestDescriptorRanges, + _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts, + _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes, + _In_ UINT NumSrcDescriptorRanges, + _In_reads_(NumSrcDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts, + _In_reads_opt_(NumSrcDescriptorRanges) const UINT *pSrcDescriptorRangeSizes, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + + void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( + ID3D12Device4 * This, + _In_ UINT NumDescriptors, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( + ID3D12Device4 * This, + _In_ UINT visibleMask, + _In_ UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); + + D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( + ID3D12Device4 * This, + _In_ UINT nodeMask, + D3D12_HEAP_TYPE heapType); + + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( + ID3D12Device4 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); + + HRESULT ( STDMETHODCALLTYPE *CreateHeap )( + ID3D12Device4 * This, + _In_ const D3D12_HEAP_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); + + HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( + ID3D12Device4 * This, + _In_ ID3D12Heap *pHeap, + UINT64 HeapOffset, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( + ID3D12Device4 * This, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( + ID3D12Device4 * This, + _In_ ID3D12DeviceChild *pObject, + _In_opt_ const SECURITY_ATTRIBUTES *pAttributes, + DWORD Access, + _In_opt_ LPCWSTR Name, + _Out_ HANDLE *pHandle); + + HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( + ID3D12Device4 * This, + _In_ HANDLE NTHandle, + REFIID riid, + _COM_Outptr_opt_ void **ppvObj); + + HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( + ID3D12Device4 * This, + _In_ LPCWSTR Name, + DWORD Access, + /* [annotation][out] */ + _Out_ HANDLE *pNTHandle); + + HRESULT ( STDMETHODCALLTYPE *MakeResident )( + ID3D12Device4 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); + + HRESULT ( STDMETHODCALLTYPE *Evict )( + ID3D12Device4 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); + + HRESULT ( STDMETHODCALLTYPE *CreateFence )( + ID3D12Device4 * This, + UINT64 InitialValue, + D3D12_FENCE_FLAGS Flags, + REFIID riid, + _COM_Outptr_ void **ppFence); + + HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( + ID3D12Device4 * This); + + void ( STDMETHODCALLTYPE *GetCopyableFootprints )( + ID3D12Device4 * This, + _In_ const D3D12_RESOURCE_DESC *pResourceDesc, + _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, + _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, + UINT64 BaseOffset, + _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, + _Out_writes_opt_(NumSubresources) UINT *pNumRows, + _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, + _Out_opt_ UINT64 *pTotalBytes); + + HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( + ID3D12Device4 * This, + _In_ const D3D12_QUERY_HEAP_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); + + HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( + ID3D12Device4 * This, + BOOL Enable); + + HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( + ID3D12Device4 * This, + _In_ const D3D12_COMMAND_SIGNATURE_DESC *pDesc, + _In_opt_ ID3D12RootSignature *pRootSignature, + REFIID riid, + _COM_Outptr_opt_ void **ppvCommandSignature); + + void ( STDMETHODCALLTYPE *GetResourceTiling )( + ID3D12Device4 * This, + _In_ ID3D12Resource *pTiledResource, + _Out_opt_ UINT *pNumTilesForEntireResource, + _Out_opt_ D3D12_PACKED_MIP_INFO *pPackedMipDesc, + _Out_opt_ D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips, + _Inout_opt_ UINT *pNumSubresourceTilings, + _In_ UINT FirstSubresourceTilingToGet, + _Out_writes_(*pNumSubresourceTilings) D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips); + + LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( + ID3D12Device4 * This); + + HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( + ID3D12Device4 * This, + _In_reads_(BlobLength) const void *pLibraryBlob, + SIZE_T BlobLength, + REFIID riid, + _COM_Outptr_ void **ppPipelineLibrary); + + HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( + ID3D12Device4 * This, + _In_reads_(NumFences) ID3D12Fence *const *ppFences, + _In_reads_(NumFences) const UINT64 *pFenceValues, + UINT NumFences, + D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags, + HANDLE hEvent); + + HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( + ID3D12Device4 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, + _In_reads_(NumObjects) const D3D12_RESIDENCY_PRIORITY *pPriorities); + + HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( + ID3D12Device4 * This, + const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress )( + ID3D12Device4 * This, + _In_ const void *pAddress, + REFIID riid, + _COM_Outptr_ void **ppvHeap); + + HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromFileMapping )( + ID3D12Device4 * This, + _In_ HANDLE hFileMapping, + REFIID riid, + _COM_Outptr_ void **ppvHeap); + + HRESULT ( STDMETHODCALLTYPE *EnqueueMakeResident )( + ID3D12Device4 * This, + D3D12_RESIDENCY_FLAGS Flags, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, + _In_ ID3D12Fence *pFenceToSignal, + UINT64 FenceValueToSignal); + + HRESULT ( STDMETHODCALLTYPE *CreateCommandList1 )( + ID3D12Device4 * This, + _In_ UINT nodeMask, + _In_ D3D12_COMMAND_LIST_TYPE type, + _In_ D3D12_COMMAND_LIST_FLAGS flags, + REFIID riid, + _COM_Outptr_ void **ppCommandList); + + HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession )( + ID3D12Device4 * This, + _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC *pDesc, + _In_ REFIID riid, + _COM_Outptr_ void **ppSession); + + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource1 )( + ID3D12Device4 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); + + HRESULT ( STDMETHODCALLTYPE *CreateHeap1 )( + ID3D12Device4 * This, + _In_ const D3D12_HEAP_DESC *pDesc, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); + + HRESULT ( STDMETHODCALLTYPE *CreateReservedResource1 )( + ID3D12Device4 * This, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( + ID3D12Device4 * This, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); + + END_INTERFACE + } ID3D12Device4Vtbl; + + interface ID3D12Device4 + { + CONST_VTBL struct ID3D12Device4Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12Device4_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12Device4_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12Device4_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12Device4_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12Device4_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12Device4_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12Device4_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12Device4_GetNodeCount(This) \ + ( (This)->lpVtbl -> GetNodeCount(This) ) + +#define ID3D12Device4_CreateCommandQueue(This,pDesc,riid,ppCommandQueue) \ + ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) + +#define ID3D12Device4_CreateCommandAllocator(This,type,riid,ppCommandAllocator) \ + ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) + +#define ID3D12Device4_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) + +#define ID3D12Device4_CreateComputePipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) + +#define ID3D12Device4_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) \ + ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) + +#define ID3D12Device4_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) \ + ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) + +#define ID3D12Device4_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) + +#define ID3D12Device4_GetDescriptorHandleIncrementSize(This,DescriptorHeapType) \ + ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) + +#define ID3D12Device4_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) \ + ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) + +#define ID3D12Device4_CreateConstantBufferView(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) + +#define ID3D12Device4_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device4_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) + +#define ID3D12Device4_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device4_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device4_CreateSampler(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) + +#define ID3D12Device4_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) \ + ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) + +#define ID3D12Device4_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) \ + ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) + +#define ID3D12Device4_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) + +#define ID3D12Device4_GetCustomHeapProperties(This,nodeMask,heapType) \ + ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) + +#define ID3D12Device4_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) + +#define ID3D12Device4_CreateHeap(This,pDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) + +#define ID3D12Device4_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) + +#define ID3D12Device4_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) + +#define ID3D12Device4_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) \ + ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) + +#define ID3D12Device4_OpenSharedHandle(This,NTHandle,riid,ppvObj) \ + ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) + +#define ID3D12Device4_OpenSharedHandleByName(This,Name,Access,pNTHandle) \ + ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) + +#define ID3D12Device4_MakeResident(This,NumObjects,ppObjects) \ + ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) + +#define ID3D12Device4_Evict(This,NumObjects,ppObjects) \ + ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) + +#define ID3D12Device4_CreateFence(This,InitialValue,Flags,riid,ppFence) \ + ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) + +#define ID3D12Device4_GetDeviceRemovedReason(This) \ + ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) + +#define ID3D12Device4_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ + ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) + +#define ID3D12Device4_CreateQueryHeap(This,pDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) + +#define ID3D12Device4_SetStablePowerState(This,Enable) \ + ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) + +#define ID3D12Device4_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) \ + ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) + +#define ID3D12Device4_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) \ + ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) + +#define ID3D12Device4_GetAdapterLuid(This) \ + ( (This)->lpVtbl -> GetAdapterLuid(This) ) + + +#define ID3D12Device4_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) \ + ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) + +#define ID3D12Device4_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) \ + ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) + +#define ID3D12Device4_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) \ + ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) + + +#define ID3D12Device4_CreatePipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) + + +#define ID3D12Device4_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) \ + ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) + +#define ID3D12Device4_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) \ + ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) + +#define ID3D12Device4_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) \ + ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) + + +#define ID3D12Device4_CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) \ + ( (This)->lpVtbl -> CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) ) + +#define ID3D12Device4_CreateProtectedResourceSession(This,pDesc,riid,ppSession) \ + ( (This)->lpVtbl -> CreateProtectedResourceSession(This,pDesc,riid,ppSession) ) + +#define ID3D12Device4_CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) + +#define ID3D12Device4_CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) ) + +#define ID3D12Device4_CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) \ + ( (This)->lpVtbl -> CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) ) + +#define ID3D12Device4_GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + + + + + +#endif /* __ID3D12Device4_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12_0000_0029 */ +/* [local] */ + +typedef +enum D3D12_LIFETIME_STATE + { + D3D12_LIFETIME_STATE_IN_USE = 0, + D3D12_LIFETIME_STATE_NOT_IN_USE = ( D3D12_LIFETIME_STATE_IN_USE + 1 ) + } D3D12_LIFETIME_STATE; + + + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0029_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0029_v0_0_s_ifspec; + +#ifndef __ID3D12LifetimeOwner_INTERFACE_DEFINED__ +#define __ID3D12LifetimeOwner_INTERFACE_DEFINED__ + +/* interface ID3D12LifetimeOwner */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12LifetimeOwner; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("e667af9f-cd56-4f46-83ce-032e595d70a8") + ID3D12LifetimeOwner : public IUnknown + { + public: + virtual void STDMETHODCALLTYPE LifetimeStateUpdated( + D3D12_LIFETIME_STATE NewState) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12LifetimeOwnerVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12LifetimeOwner * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12LifetimeOwner * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12LifetimeOwner * This); + + void ( STDMETHODCALLTYPE *LifetimeStateUpdated )( + ID3D12LifetimeOwner * This, + D3D12_LIFETIME_STATE NewState); + + END_INTERFACE + } ID3D12LifetimeOwnerVtbl; + + interface ID3D12LifetimeOwner + { + CONST_VTBL struct ID3D12LifetimeOwnerVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12LifetimeOwner_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12LifetimeOwner_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12LifetimeOwner_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12LifetimeOwner_LifetimeStateUpdated(This,NewState) \ + ( (This)->lpVtbl -> LifetimeStateUpdated(This,NewState) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12LifetimeOwner_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12SwapChainAssistant_INTERFACE_DEFINED__ +#define __ID3D12SwapChainAssistant_INTERFACE_DEFINED__ + +/* interface ID3D12SwapChainAssistant */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12SwapChainAssistant; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("f1df64b6-57fd-49cd-8807-c0eb88b45c8f") + ID3D12SwapChainAssistant : public IUnknown + { + public: + virtual LUID STDMETHODCALLTYPE GetLUID( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSwapChainObject( + REFIID riid, + _COM_Outptr_ void **ppv) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCurrentResourceAndCommandQueue( + REFIID riidResource, + _COM_Outptr_ void **ppvResource, + REFIID riidQueue, + _COM_Outptr_ void **ppvQueue) = 0; + + virtual HRESULT STDMETHODCALLTYPE InsertImplicitSync( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12SwapChainAssistantVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12SwapChainAssistant * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12SwapChainAssistant * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12SwapChainAssistant * This); + + LUID ( STDMETHODCALLTYPE *GetLUID )( + ID3D12SwapChainAssistant * This); + + HRESULT ( STDMETHODCALLTYPE *GetSwapChainObject )( + ID3D12SwapChainAssistant * This, + REFIID riid, + _COM_Outptr_ void **ppv); + + HRESULT ( STDMETHODCALLTYPE *GetCurrentResourceAndCommandQueue )( + ID3D12SwapChainAssistant * This, + REFIID riidResource, + _COM_Outptr_ void **ppvResource, + REFIID riidQueue, + _COM_Outptr_ void **ppvQueue); + + HRESULT ( STDMETHODCALLTYPE *InsertImplicitSync )( + ID3D12SwapChainAssistant * This); + + END_INTERFACE + } ID3D12SwapChainAssistantVtbl; + + interface ID3D12SwapChainAssistant + { + CONST_VTBL struct ID3D12SwapChainAssistantVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12SwapChainAssistant_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12SwapChainAssistant_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12SwapChainAssistant_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12SwapChainAssistant_GetLUID(This) \ + ( (This)->lpVtbl -> GetLUID(This) ) + +#define ID3D12SwapChainAssistant_GetSwapChainObject(This,riid,ppv) \ + ( (This)->lpVtbl -> GetSwapChainObject(This,riid,ppv) ) + +#define ID3D12SwapChainAssistant_GetCurrentResourceAndCommandQueue(This,riidResource,ppvResource,riidQueue,ppvQueue) \ + ( (This)->lpVtbl -> GetCurrentResourceAndCommandQueue(This,riidResource,ppvResource,riidQueue,ppvQueue) ) + +#define ID3D12SwapChainAssistant_InsertImplicitSync(This) \ + ( (This)->lpVtbl -> InsertImplicitSync(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + + + + + +#endif /* __ID3D12SwapChainAssistant_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12LifetimeTracker_INTERFACE_DEFINED__ +#define __ID3D12LifetimeTracker_INTERFACE_DEFINED__ + +/* interface ID3D12LifetimeTracker */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12LifetimeTracker; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("3fd03d36-4eb1-424a-a582-494ecb8ba813") + ID3D12LifetimeTracker : public ID3D12DeviceChild + { + public: + virtual HRESULT STDMETHODCALLTYPE DestroyOwnedObject( + _In_ ID3D12DeviceChild *pObject) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12LifetimeTrackerVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12LifetimeTracker * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12LifetimeTracker * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12LifetimeTracker * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12LifetimeTracker * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12LifetimeTracker * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12LifetimeTracker * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12LifetimeTracker * This, + _In_z_ LPCWSTR Name); + + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12LifetimeTracker * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + HRESULT ( STDMETHODCALLTYPE *DestroyOwnedObject )( + ID3D12LifetimeTracker * This, + _In_ ID3D12DeviceChild *pObject); + + END_INTERFACE + } ID3D12LifetimeTrackerVtbl; + + interface ID3D12LifetimeTracker + { + CONST_VTBL struct ID3D12LifetimeTrackerVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12LifetimeTracker_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12LifetimeTracker_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12LifetimeTracker_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12LifetimeTracker_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12LifetimeTracker_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12LifetimeTracker_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12LifetimeTracker_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12LifetimeTracker_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + +#define ID3D12LifetimeTracker_DestroyOwnedObject(This,pObject) \ + ( (This)->lpVtbl -> DestroyOwnedObject(This,pObject) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12LifetimeTracker_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12_0000_0032 */ +/* [local] */ + +typedef +enum D3D12_META_COMMAND_PARAMETER_TYPE + { + D3D12_META_COMMAND_PARAMETER_TYPE_FLOAT = 0, + D3D12_META_COMMAND_PARAMETER_TYPE_UINT64 = 1, + D3D12_META_COMMAND_PARAMETER_TYPE_GPU_VIRTUAL_ADDRESS = 2, + D3D12_META_COMMAND_PARAMETER_TYPE_CPU_DESCRIPTOR_HANDLE_HEAP_TYPE_CBV_SRV_UAV = 3, + D3D12_META_COMMAND_PARAMETER_TYPE_GPU_DESCRIPTOR_HANDLE_HEAP_TYPE_CBV_SRV_UAV = 4 + } D3D12_META_COMMAND_PARAMETER_TYPE; + +typedef +enum D3D12_META_COMMAND_PARAMETER_FLAGS + { + D3D12_META_COMMAND_PARAMETER_FLAG_INPUT = 0x1, + D3D12_META_COMMAND_PARAMETER_FLAG_OUTPUT = 0x2 + } D3D12_META_COMMAND_PARAMETER_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_META_COMMAND_PARAMETER_FLAGS ); +typedef +enum D3D12_META_COMMAND_PARAMETER_STAGE + { + D3D12_META_COMMAND_PARAMETER_STAGE_CREATION = 0, + D3D12_META_COMMAND_PARAMETER_STAGE_INITIALIZATION = 1, + D3D12_META_COMMAND_PARAMETER_STAGE_EXECUTION = 2 + } D3D12_META_COMMAND_PARAMETER_STAGE; + +typedef struct D3D12_META_COMMAND_PARAMETER_DESC + { + LPCWSTR Name; + D3D12_META_COMMAND_PARAMETER_TYPE Type; + D3D12_META_COMMAND_PARAMETER_FLAGS Flags; + D3D12_RESOURCE_STATES RequiredResourceState; + UINT StructureOffset; + } D3D12_META_COMMAND_PARAMETER_DESC; + +typedef +enum D3D12_GRAPHICS_STATES + { + D3D12_GRAPHICS_STATE_NONE = 0, + D3D12_GRAPHICS_STATE_IA_VERTEX_BUFFERS = ( 1 << 0 ) , + D3D12_GRAPHICS_STATE_IA_INDEX_BUFFER = ( 1 << 1 ) , + D3D12_GRAPHICS_STATE_IA_PRIMITIVE_TOPOLOGY = ( 1 << 2 ) , + D3D12_GRAPHICS_STATE_DESCRIPTOR_HEAP = ( 1 << 3 ) , + D3D12_GRAPHICS_STATE_GRAPHICS_ROOT_SIGNATURE = ( 1 << 4 ) , + D3D12_GRAPHICS_STATE_COMPUTE_ROOT_SIGNATURE = ( 1 << 5 ) , + D3D12_GRAPHICS_STATE_RS_VIEWPORTS = ( 1 << 6 ) , + D3D12_GRAPHICS_STATE_RS_SCISSOR_RECTS = ( 1 << 7 ) , + D3D12_GRAPHICS_STATE_PREDICATION = ( 1 << 8 ) , + D3D12_GRAPHICS_STATE_OM_RENDER_TARGETS = ( 1 << 9 ) , + D3D12_GRAPHICS_STATE_OM_STENCIL_REF = ( 1 << 10 ) , + D3D12_GRAPHICS_STATE_OM_BLEND_FACTOR = ( 1 << 11 ) , + D3D12_GRAPHICS_STATE_PIPELINE_STATE = ( 1 << 12 ) , + D3D12_GRAPHICS_STATE_SO_TARGETS = ( 1 << 13 ) , + D3D12_GRAPHICS_STATE_OM_DEPTH_BOUNDS = ( 1 << 14 ) , + D3D12_GRAPHICS_STATE_SAMPLE_POSITIONS = ( 1 << 15 ) , + D3D12_GRAPHICS_STATE_VIEW_INSTANCE_MASK = ( 1 << 16 ) + } D3D12_GRAPHICS_STATES; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_GRAPHICS_STATES ); +typedef struct D3D12_META_COMMAND_DESC + { + GUID Id; + LPCWSTR Name; + D3D12_GRAPHICS_STATES InitializationDirtyState; + D3D12_GRAPHICS_STATES ExecutionDirtyState; + } D3D12_META_COMMAND_DESC; + + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0032_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0032_v0_0_s_ifspec; + +#ifndef __ID3D12StateObject_INTERFACE_DEFINED__ +#define __ID3D12StateObject_INTERFACE_DEFINED__ + +/* interface ID3D12StateObject */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12StateObject; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("47016943-fca8-4594-93ea-af258b55346d") + ID3D12StateObject : public ID3D12Pageable + { + public: + }; + + +#else /* C style interface */ + + typedef struct ID3D12StateObjectVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12StateObject * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12StateObject * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12StateObject * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12StateObject * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12StateObject * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12StateObject * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12StateObject * This, + _In_z_ LPCWSTR Name); + + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12StateObject * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + END_INTERFACE + } ID3D12StateObjectVtbl; + + interface ID3D12StateObject + { + CONST_VTBL struct ID3D12StateObjectVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12StateObject_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12StateObject_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12StateObject_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12StateObject_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12StateObject_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12StateObject_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12StateObject_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12StateObject_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12StateObject_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12StateObjectProperties_INTERFACE_DEFINED__ +#define __ID3D12StateObjectProperties_INTERFACE_DEFINED__ + +/* interface ID3D12StateObjectProperties */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12StateObjectProperties; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("de5fa827-9bf9-4f26-89ff-d7f56fde3860") + ID3D12StateObjectProperties : public IUnknown + { + public: + virtual void *STDMETHODCALLTYPE GetShaderIdentifier( + _In_ LPCWSTR pExportName) = 0; + + virtual UINT64 STDMETHODCALLTYPE GetShaderStackSize( + _In_ LPCWSTR pExportName) = 0; + + virtual UINT64 STDMETHODCALLTYPE GetPipelineStackSize( void) = 0; + + virtual void STDMETHODCALLTYPE SetPipelineStackSize( + UINT64 PipelineStackSizeInBytes) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12StateObjectPropertiesVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12StateObjectProperties * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12StateObjectProperties * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12StateObjectProperties * This); + + void *( STDMETHODCALLTYPE *GetShaderIdentifier )( + ID3D12StateObjectProperties * This, + _In_ LPCWSTR pExportName); + + UINT64 ( STDMETHODCALLTYPE *GetShaderStackSize )( + ID3D12StateObjectProperties * This, + _In_ LPCWSTR pExportName); + + UINT64 ( STDMETHODCALLTYPE *GetPipelineStackSize )( + ID3D12StateObjectProperties * This); + + void ( STDMETHODCALLTYPE *SetPipelineStackSize )( + ID3D12StateObjectProperties * This, + UINT64 PipelineStackSizeInBytes); + + END_INTERFACE + } ID3D12StateObjectPropertiesVtbl; + + interface ID3D12StateObjectProperties + { + CONST_VTBL struct ID3D12StateObjectPropertiesVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12StateObjectProperties_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12StateObjectProperties_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12StateObjectProperties_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12StateObjectProperties_GetShaderIdentifier(This,pExportName) \ + ( (This)->lpVtbl -> GetShaderIdentifier(This,pExportName) ) + +#define ID3D12StateObjectProperties_GetShaderStackSize(This,pExportName) \ + ( (This)->lpVtbl -> GetShaderStackSize(This,pExportName) ) + +#define ID3D12StateObjectProperties_GetPipelineStackSize(This) \ + ( (This)->lpVtbl -> GetPipelineStackSize(This) ) + +#define ID3D12StateObjectProperties_SetPipelineStackSize(This,PipelineStackSizeInBytes) \ + ( (This)->lpVtbl -> SetPipelineStackSize(This,PipelineStackSizeInBytes) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12StateObjectProperties_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12_0000_0034 */ +/* [local] */ + +typedef +enum D3D12_STATE_SUBOBJECT_TYPE + { + D3D12_STATE_SUBOBJECT_TYPE_STATE_OBJECT_CONFIG = 0, + D3D12_STATE_SUBOBJECT_TYPE_GLOBAL_ROOT_SIGNATURE = 1, + D3D12_STATE_SUBOBJECT_TYPE_LOCAL_ROOT_SIGNATURE = 2, + D3D12_STATE_SUBOBJECT_TYPE_NODE_MASK = 3, + D3D12_STATE_SUBOBJECT_TYPE_DXIL_LIBRARY = 5, + D3D12_STATE_SUBOBJECT_TYPE_EXISTING_COLLECTION = 6, + D3D12_STATE_SUBOBJECT_TYPE_SUBOBJECT_TO_EXPORTS_ASSOCIATION = 7, + D3D12_STATE_SUBOBJECT_TYPE_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION = 8, + D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_SHADER_CONFIG = 9, + D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG = 10, + D3D12_STATE_SUBOBJECT_TYPE_HIT_GROUP = 11, + D3D12_STATE_SUBOBJECT_TYPE_MAX_VALID = ( D3D12_STATE_SUBOBJECT_TYPE_HIT_GROUP + 1 ) + } D3D12_STATE_SUBOBJECT_TYPE; + +typedef struct D3D12_STATE_SUBOBJECT + { + D3D12_STATE_SUBOBJECT_TYPE Type; + const void *pDesc; + } D3D12_STATE_SUBOBJECT; + +typedef +enum D3D12_STATE_OBJECT_FLAGS + { + D3D12_STATE_OBJECT_FLAG_NONE = 0, + D3D12_STATE_OBJECT_FLAG_ALLOW_LOCAL_DEPENDENCIES_ON_EXTERNAL_DEFINITIONS = 0x1, + D3D12_STATE_OBJECT_FLAG_ALLOW_EXTERNAL_DEPENDENCIES_ON_LOCAL_DEFINITIONS = 0x2 + } D3D12_STATE_OBJECT_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_STATE_OBJECT_FLAGS ); +typedef struct D3D12_STATE_OBJECT_CONFIG + { + D3D12_STATE_OBJECT_FLAGS Flags; + } D3D12_STATE_OBJECT_CONFIG; + +typedef struct D3D12_GLOBAL_ROOT_SIGNATURE + { + ID3D12RootSignature *pGlobalRootSignature; + } D3D12_GLOBAL_ROOT_SIGNATURE; + +typedef struct D3D12_LOCAL_ROOT_SIGNATURE + { + ID3D12RootSignature *pLocalRootSignature; + } D3D12_LOCAL_ROOT_SIGNATURE; + +typedef struct D3D12_NODE_MASK + { + UINT NodeMask; + } D3D12_NODE_MASK; + +typedef +enum D3D12_EXPORT_FLAGS + { + D3D12_EXPORT_FLAG_NONE = 0 + } D3D12_EXPORT_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_EXPORT_FLAGS ); +typedef struct D3D12_EXPORT_DESC + { + LPCWSTR Name; + _In_opt_ LPCWSTR ExportToRename; + D3D12_EXPORT_FLAGS Flags; + } D3D12_EXPORT_DESC; + +typedef struct D3D12_DXIL_LIBRARY_DESC + { + D3D12_SHADER_BYTECODE DXILLibrary; + UINT NumExports; + _In_reads_(NumExports) D3D12_EXPORT_DESC *pExports; + } D3D12_DXIL_LIBRARY_DESC; + +typedef struct D3D12_EXISTING_COLLECTION_DESC + { + ID3D12StateObject *pExistingCollection; + UINT NumExports; + _In_reads_(NumExports) D3D12_EXPORT_DESC *pExports; + } D3D12_EXISTING_COLLECTION_DESC; + +typedef struct D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION + { + const D3D12_STATE_SUBOBJECT *pSubobjectToAssociate; + UINT NumExports; + _In_reads_(NumExports) LPCWSTR *pExports; + } D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION; + +typedef struct D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION + { + LPCWSTR SubobjectToAssociate; + UINT NumExports; + _In_reads_(NumExports) LPCWSTR *pExports; + } D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION; + +typedef +enum D3D12_HIT_GROUP_TYPE + { + D3D12_HIT_GROUP_TYPE_TRIANGLES = 0, + D3D12_HIT_GROUP_TYPE_PROCEDURAL_PRIMITIVE = 0x1 + } D3D12_HIT_GROUP_TYPE; + +typedef struct D3D12_HIT_GROUP_DESC + { + LPCWSTR HitGroupExport; + D3D12_HIT_GROUP_TYPE Type; + _In_opt_ LPCWSTR AnyHitShaderImport; + _In_opt_ LPCWSTR ClosestHitShaderImport; + _In_opt_ LPCWSTR IntersectionShaderImport; + } D3D12_HIT_GROUP_DESC; + +typedef struct D3D12_RAYTRACING_SHADER_CONFIG + { + UINT MaxPayloadSizeInBytes; + UINT MaxAttributeSizeInBytes; + } D3D12_RAYTRACING_SHADER_CONFIG; + +typedef struct D3D12_RAYTRACING_PIPELINE_CONFIG + { + UINT MaxTraceRecursionDepth; + } D3D12_RAYTRACING_PIPELINE_CONFIG; + +typedef +enum D3D12_STATE_OBJECT_TYPE + { + D3D12_STATE_OBJECT_TYPE_COLLECTION = 0, + D3D12_STATE_OBJECT_TYPE_RAYTRACING_PIPELINE = 3 + } D3D12_STATE_OBJECT_TYPE; + +typedef struct D3D12_STATE_OBJECT_DESC + { + D3D12_STATE_OBJECT_TYPE Type; + UINT NumSubobjects; + _In_reads_(NumSubobjects) const D3D12_STATE_SUBOBJECT *pSubobjects; + } D3D12_STATE_OBJECT_DESC; + +typedef +enum D3D12_RAYTRACING_GEOMETRY_FLAGS + { + D3D12_RAYTRACING_GEOMETRY_FLAG_NONE = 0, + D3D12_RAYTRACING_GEOMETRY_FLAG_OPAQUE = 0x1, + D3D12_RAYTRACING_GEOMETRY_FLAG_NO_DUPLICATE_ANYHIT_INVOCATION = 0x2 + } D3D12_RAYTRACING_GEOMETRY_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAYTRACING_GEOMETRY_FLAGS ); +typedef +enum D3D12_RAYTRACING_GEOMETRY_TYPE + { + D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES = 0, + D3D12_RAYTRACING_GEOMETRY_TYPE_PROCEDURAL_PRIMITIVE_AABBS = ( D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES + 1 ) + } D3D12_RAYTRACING_GEOMETRY_TYPE; + +typedef +enum D3D12_RAYTRACING_INSTANCE_FLAGS + { + D3D12_RAYTRACING_INSTANCE_FLAG_NONE = 0, + D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_CULL_DISABLE = 0x1, + D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_FRONT_COUNTERCLOCKWISE = 0x2, + D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_OPAQUE = 0x4, + D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_NON_OPAQUE = 0x8 + } D3D12_RAYTRACING_INSTANCE_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAYTRACING_INSTANCE_FLAGS ); +typedef struct D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE + { + D3D12_GPU_VIRTUAL_ADDRESS StartAddress; + UINT64 StrideInBytes; + } D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE; + +typedef struct D3D12_GPU_VIRTUAL_ADDRESS_RANGE + { + D3D12_GPU_VIRTUAL_ADDRESS StartAddress; + UINT64 SizeInBytes; + } D3D12_GPU_VIRTUAL_ADDRESS_RANGE; + +typedef struct D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE + { + D3D12_GPU_VIRTUAL_ADDRESS StartAddress; + UINT64 SizeInBytes; + UINT64 StrideInBytes; + } D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE; + +typedef struct D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC + { + D3D12_GPU_VIRTUAL_ADDRESS Transform3x4; + DXGI_FORMAT IndexFormat; + DXGI_FORMAT VertexFormat; + UINT IndexCount; + UINT VertexCount; + D3D12_GPU_VIRTUAL_ADDRESS IndexBuffer; + D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE VertexBuffer; + } D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC; + +typedef struct D3D12_RAYTRACING_AABB + { + FLOAT MinX; + FLOAT MinY; + FLOAT MinZ; + FLOAT MaxX; + FLOAT MaxY; + FLOAT MaxZ; + } D3D12_RAYTRACING_AABB; + +typedef struct D3D12_RAYTRACING_GEOMETRY_AABBS_DESC + { + UINT64 AABBCount; + D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE AABBs; + } D3D12_RAYTRACING_GEOMETRY_AABBS_DESC; + +typedef +enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS + { + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_NONE = 0, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_UPDATE = 0x1, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_COMPACTION = 0x2, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_TRACE = 0x4, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_BUILD = 0x8, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_MINIMIZE_MEMORY = 0x10, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PERFORM_UPDATE = 0x20 + } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS ); +typedef +enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE + { + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_CLONE = 0, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_COMPACT = 0x1, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_VISUALIZATION_DECODE_FOR_TOOLS = 0x2, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_SERIALIZE = 0x3, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_DESERIALIZE = 0x4 + } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE; + +typedef +enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE + { + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL = 0, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL = 0x1 + } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE; + +typedef +enum D3D12_ELEMENTS_LAYOUT + { + D3D12_ELEMENTS_LAYOUT_ARRAY = 0, + D3D12_ELEMENTS_LAYOUT_ARRAY_OF_POINTERS = 0x1 + } D3D12_ELEMENTS_LAYOUT; + +typedef +enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE + { + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE = 0, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION = 0x1, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION = 0x2, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE = 0x3 + } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE; + +typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC + { + D3D12_GPU_VIRTUAL_ADDRESS DestBuffer; + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE InfoType; + } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC; + +typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE_DESC + { + UINT64 CompactedSizeInBytes; + } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE_DESC; + +typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION_DESC + { + UINT64 DecodedSizeInBytes; + } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION_DESC; + +typedef struct D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER + { + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE Type; + UINT NumDescs; + } D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER; + +// Regarding D3D12_BUILD_RAY_TRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER above, +// depending on Type field, NumDescs above is followed by either: +// D3D12_RAY_TRACING_INSTANCE_DESC InstanceDescs[NumDescs] +// or D3D12_RAY_TRACING_GEOMETRY_DESC GeometryDescs[NumDescs]. +// There is 4 bytes of padding between GeometryDesc structs in the array so alignment is natural when viewed by CPU. + +typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION_DESC + { + UINT64 SerializedSizeInBytes; + UINT64 NumBottomLevelAccelerationStructurePointers; + } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION_DESC; + +typedef struct D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER + { + GUID DriverOpaqueGUID; + BYTE DriverOpaqueVersioningData[ 16 ]; + } D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER; + +typedef +enum D3D12_SERIALIZED_DATA_TYPE + { + D3D12_SERIALIZED_DATA_RAYTRACING_ACCELERATION_STRUCTURE = 0 + } D3D12_SERIALIZED_DATA_TYPE; + +typedef +enum D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS + { + D3D12_DRIVER_MATCHING_IDENTIFIER_COMPATIBLE_WITH_DEVICE = 0, + D3D12_DRIVER_MATCHING_IDENTIFIER_UNSUPPORTED_TYPE = 0x1, + D3D12_DRIVER_MATCHING_IDENTIFIER_UNRECOGNIZED = 0x2, + D3D12_DRIVER_MATCHING_IDENTIFIER_INCOMPATIBLE_VERSION = 0x3, + D3D12_DRIVER_MATCHING_IDENTIFIER_INCOMPATIBLE_TYPE = 0x4 + } D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS; + +typedef struct D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER + { + D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER DriverMatchingIdentifier; + UINT64 SerializedSizeInBytesIncludingHeader; + UINT64 DeserializedSizeInBytes; + UINT64 NumBottomLevelAccelerationStructurePointersAfterHeader; + } D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER; + +typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE_DESC + { + UINT64 CurrentSizeInBytes; + } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE_DESC; + +typedef struct D3D12_RAYTRACING_INSTANCE_DESC + { + FLOAT Transform[ 3 ][ 4 ]; + UINT InstanceID : 24; + UINT InstanceMask : 8; + UINT InstanceContributionToHitGroupIndex : 24; + UINT Flags : 8; + D3D12_GPU_VIRTUAL_ADDRESS AccelerationStructure; + } D3D12_RAYTRACING_INSTANCE_DESC; + +typedef struct D3D12_RAYTRACING_GEOMETRY_DESC + { + D3D12_RAYTRACING_GEOMETRY_TYPE Type; + D3D12_RAYTRACING_GEOMETRY_FLAGS Flags; + union + { + D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC Triangles; + D3D12_RAYTRACING_GEOMETRY_AABBS_DESC AABBs; + } ; + } D3D12_RAYTRACING_GEOMETRY_DESC; + +typedef struct D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS + { + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE Type; + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS Flags; + UINT NumDescs; + D3D12_ELEMENTS_LAYOUT DescsLayout; + union + { + D3D12_GPU_VIRTUAL_ADDRESS InstanceDescs; + const D3D12_RAYTRACING_GEOMETRY_DESC *pGeometryDescs; + const D3D12_RAYTRACING_GEOMETRY_DESC *const *ppGeometryDescs; + } ; + } D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS; + +typedef struct D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC + { + D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData; + D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS Inputs; + _In_opt_ D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData; + D3D12_GPU_VIRTUAL_ADDRESS ScratchAccelerationStructureData; + } D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC; + +typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO + { + UINT64 ResultDataMaxSizeInBytes; + UINT64 ScratchDataSizeInBytes; + UINT64 UpdateScratchDataSizeInBytes; + } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO; + +typedef +enum D3D12_RAY_FLAGS + { + D3D12_RAY_FLAG_NONE = 0, + D3D12_RAY_FLAG_FORCE_OPAQUE = 0x1, + D3D12_RAY_FLAG_FORCE_NON_OPAQUE = 0x2, + D3D12_RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH = 0x4, + D3D12_RAY_FLAG_SKIP_CLOSEST_HIT_SHADER = 0x8, + D3D12_RAY_FLAG_CULL_BACK_FACING_TRIANGLES = 0x10, + D3D12_RAY_FLAG_CULL_FRONT_FACING_TRIANGLES = 0x20, + D3D12_RAY_FLAG_CULL_OPAQUE = 0x40, + D3D12_RAY_FLAG_CULL_NON_OPAQUE = 0x80 + } D3D12_RAY_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAY_FLAGS ); +typedef +enum D3D12_HIT_KIND + { + D3D12_HIT_KIND_TRIANGLE_FRONT_FACE = 0xfe, + D3D12_HIT_KIND_TRIANGLE_BACK_FACE = 0xff + } D3D12_HIT_KIND; + + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0034_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0034_v0_0_s_ifspec; + +#ifndef __ID3D12Device5_INTERFACE_DEFINED__ +#define __ID3D12Device5_INTERFACE_DEFINED__ + +/* interface ID3D12Device5 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12Device5; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("8b4f173b-2fea-4b80-8f58-4307191ab95d") + ID3D12Device5 : public ID3D12Device4 + { + public: + virtual HRESULT STDMETHODCALLTYPE CreateLifetimeTracker( + _In_ ID3D12LifetimeOwner *pOwner, + REFIID riid, + _COM_Outptr_ void **ppvTracker) = 0; + + virtual void STDMETHODCALLTYPE RemoveDevice( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnumerateMetaCommands( + _Inout_ UINT *pNumMetaCommands, + _Out_writes_opt_(*pNumMetaCommands) D3D12_META_COMMAND_DESC *pDescs) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnumerateMetaCommandParameters( + _In_ REFGUID CommandId, + _In_ D3D12_META_COMMAND_PARAMETER_STAGE Stage, + _Out_opt_ UINT *pTotalStructureSizeInBytes, + _Inout_ UINT *pParameterCount, + _Out_writes_opt_(*pParameterCount) D3D12_META_COMMAND_PARAMETER_DESC *pParameterDescs) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateMetaCommand( + _In_ REFGUID CommandId, + _In_ UINT NodeMask, + _In_reads_bytes_opt_(CreationParametersDataSizeInBytes) const void *pCreationParametersData, + _In_ SIZE_T CreationParametersDataSizeInBytes, + REFIID riid, + _COM_Outptr_ void **ppMetaCommand) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateStateObject( + const D3D12_STATE_OBJECT_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppStateObject) = 0; + + virtual void STDMETHODCALLTYPE GetRaytracingAccelerationStructurePrebuildInfo( + _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *pDesc, + _Out_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo) = 0; + + virtual D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS STDMETHODCALLTYPE CheckDriverMatchingIdentifier( + _In_ D3D12_SERIALIZED_DATA_TYPE SerializedDataType, + _In_ const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *pIdentifierToCheck) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12Device5Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12Device5 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12Device5 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12Device5 * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12Device5 * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12Device5 * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12Device5 * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12Device5 * This, + _In_z_ LPCWSTR Name); + + UINT ( STDMETHODCALLTYPE *GetNodeCount )( + ID3D12Device5 * This); + + HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( + ID3D12Device5 * This, + _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppCommandQueue); + + HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( + ID3D12Device5 * This, + _In_ D3D12_COMMAND_LIST_TYPE type, + REFIID riid, + _COM_Outptr_ void **ppCommandAllocator); + + HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( + ID3D12Device5 * This, + _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( + ID3D12Device5 * This, + _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( + ID3D12Device5 * This, + _In_ UINT nodeMask, + _In_ D3D12_COMMAND_LIST_TYPE type, + _In_ ID3D12CommandAllocator *pCommandAllocator, + _In_opt_ ID3D12PipelineState *pInitialState, + REFIID riid, + _COM_Outptr_ void **ppCommandList); + + HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( + ID3D12Device5 * This, + D3D12_FEATURE Feature, + _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, + UINT FeatureSupportDataSize); + + HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( + ID3D12Device5 * This, + _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, + REFIID riid, + _COM_Outptr_ void **ppvHeap); + + UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( + ID3D12Device5 * This, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType); + + HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( + ID3D12Device5 * This, + _In_ UINT nodeMask, + _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, + _In_ SIZE_T blobLengthInBytes, + REFIID riid, + _COM_Outptr_ void **ppvRootSignature); + + void ( STDMETHODCALLTYPE *CreateConstantBufferView )( + ID3D12Device5 * This, + _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateShaderResourceView )( + ID3D12Device5 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( + ID3D12Device5 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ ID3D12Resource *pCounterResource, + _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateRenderTargetView )( + ID3D12Device5 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateDepthStencilView )( + ID3D12Device5 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateSampler )( + ID3D12Device5 * This, + _In_ const D3D12_SAMPLER_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CopyDescriptors )( + ID3D12Device5 * This, + _In_ UINT NumDestDescriptorRanges, + _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts, + _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes, + _In_ UINT NumSrcDescriptorRanges, + _In_reads_(NumSrcDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts, + _In_reads_opt_(NumSrcDescriptorRanges) const UINT *pSrcDescriptorRangeSizes, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + + void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( + ID3D12Device5 * This, + _In_ UINT NumDescriptors, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( + ID3D12Device5 * This, + _In_ UINT visibleMask, + _In_ UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); + + D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( + ID3D12Device5 * This, + _In_ UINT nodeMask, + D3D12_HEAP_TYPE heapType); + + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( + ID3D12Device5 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); + + HRESULT ( STDMETHODCALLTYPE *CreateHeap )( + ID3D12Device5 * This, + _In_ const D3D12_HEAP_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); + + HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( + ID3D12Device5 * This, + _In_ ID3D12Heap *pHeap, + UINT64 HeapOffset, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( + ID3D12Device5 * This, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( + ID3D12Device5 * This, + _In_ ID3D12DeviceChild *pObject, + _In_opt_ const SECURITY_ATTRIBUTES *pAttributes, + DWORD Access, + _In_opt_ LPCWSTR Name, + _Out_ HANDLE *pHandle); + + HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( + ID3D12Device5 * This, + _In_ HANDLE NTHandle, + REFIID riid, + _COM_Outptr_opt_ void **ppvObj); + + HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( + ID3D12Device5 * This, + _In_ LPCWSTR Name, + DWORD Access, + /* [annotation][out] */ + _Out_ HANDLE *pNTHandle); + + HRESULT ( STDMETHODCALLTYPE *MakeResident )( + ID3D12Device5 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); + + HRESULT ( STDMETHODCALLTYPE *Evict )( + ID3D12Device5 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); + + HRESULT ( STDMETHODCALLTYPE *CreateFence )( + ID3D12Device5 * This, + UINT64 InitialValue, + D3D12_FENCE_FLAGS Flags, + REFIID riid, + _COM_Outptr_ void **ppFence); + + HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( + ID3D12Device5 * This); + + void ( STDMETHODCALLTYPE *GetCopyableFootprints )( + ID3D12Device5 * This, + _In_ const D3D12_RESOURCE_DESC *pResourceDesc, + _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, + _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, + UINT64 BaseOffset, + _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, + _Out_writes_opt_(NumSubresources) UINT *pNumRows, + _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, + _Out_opt_ UINT64 *pTotalBytes); + + HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( + ID3D12Device5 * This, + _In_ const D3D12_QUERY_HEAP_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); + + HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( + ID3D12Device5 * This, + BOOL Enable); + + HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( + ID3D12Device5 * This, + _In_ const D3D12_COMMAND_SIGNATURE_DESC *pDesc, + _In_opt_ ID3D12RootSignature *pRootSignature, + REFIID riid, + _COM_Outptr_opt_ void **ppvCommandSignature); + + void ( STDMETHODCALLTYPE *GetResourceTiling )( + ID3D12Device5 * This, + _In_ ID3D12Resource *pTiledResource, + _Out_opt_ UINT *pNumTilesForEntireResource, + _Out_opt_ D3D12_PACKED_MIP_INFO *pPackedMipDesc, + _Out_opt_ D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips, + _Inout_opt_ UINT *pNumSubresourceTilings, + _In_ UINT FirstSubresourceTilingToGet, + _Out_writes_(*pNumSubresourceTilings) D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips); + + LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( + ID3D12Device5 * This); + + HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( + ID3D12Device5 * This, + _In_reads_(BlobLength) const void *pLibraryBlob, + SIZE_T BlobLength, + REFIID riid, + _COM_Outptr_ void **ppPipelineLibrary); + + HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( + ID3D12Device5 * This, + _In_reads_(NumFences) ID3D12Fence *const *ppFences, + _In_reads_(NumFences) const UINT64 *pFenceValues, + UINT NumFences, + D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags, + HANDLE hEvent); + + HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( + ID3D12Device5 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, + _In_reads_(NumObjects) const D3D12_RESIDENCY_PRIORITY *pPriorities); + + HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( + ID3D12Device5 * This, + const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress )( + ID3D12Device5 * This, + _In_ const void *pAddress, + REFIID riid, + _COM_Outptr_ void **ppvHeap); + + HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromFileMapping )( + ID3D12Device5 * This, + _In_ HANDLE hFileMapping, + REFIID riid, + _COM_Outptr_ void **ppvHeap); + + HRESULT ( STDMETHODCALLTYPE *EnqueueMakeResident )( + ID3D12Device5 * This, + D3D12_RESIDENCY_FLAGS Flags, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, + _In_ ID3D12Fence *pFenceToSignal, + UINT64 FenceValueToSignal); + + HRESULT ( STDMETHODCALLTYPE *CreateCommandList1 )( + ID3D12Device5 * This, + _In_ UINT nodeMask, + _In_ D3D12_COMMAND_LIST_TYPE type, + _In_ D3D12_COMMAND_LIST_FLAGS flags, + REFIID riid, + _COM_Outptr_ void **ppCommandList); + + HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession )( + ID3D12Device5 * This, + _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC *pDesc, + _In_ REFIID riid, + _COM_Outptr_ void **ppSession); + + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource1 )( + ID3D12Device5 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); + + HRESULT ( STDMETHODCALLTYPE *CreateHeap1 )( + ID3D12Device5 * This, + _In_ const D3D12_HEAP_DESC *pDesc, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); + + HRESULT ( STDMETHODCALLTYPE *CreateReservedResource1 )( + ID3D12Device5 * This, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( + ID3D12Device5 * This, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); + + HRESULT ( STDMETHODCALLTYPE *CreateLifetimeTracker )( + ID3D12Device5 * This, + _In_ ID3D12LifetimeOwner *pOwner, + REFIID riid, + _COM_Outptr_ void **ppvTracker); + + void ( STDMETHODCALLTYPE *RemoveDevice )( + ID3D12Device5 * This); + + HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommands )( + ID3D12Device5 * This, + _Inout_ UINT *pNumMetaCommands, + _Out_writes_opt_(*pNumMetaCommands) D3D12_META_COMMAND_DESC *pDescs); + + HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommandParameters )( + ID3D12Device5 * This, + _In_ REFGUID CommandId, + _In_ D3D12_META_COMMAND_PARAMETER_STAGE Stage, + _Out_opt_ UINT *pTotalStructureSizeInBytes, + _Inout_ UINT *pParameterCount, + _Out_writes_opt_(*pParameterCount) D3D12_META_COMMAND_PARAMETER_DESC *pParameterDescs); + + HRESULT ( STDMETHODCALLTYPE *CreateMetaCommand )( + ID3D12Device5 * This, + _In_ REFGUID CommandId, + _In_ UINT NodeMask, + _In_reads_bytes_opt_(CreationParametersDataSizeInBytes) const void *pCreationParametersData, + _In_ SIZE_T CreationParametersDataSizeInBytes, + REFIID riid, + _COM_Outptr_ void **ppMetaCommand); + + HRESULT ( STDMETHODCALLTYPE *CreateStateObject )( + ID3D12Device5 * This, + const D3D12_STATE_OBJECT_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppStateObject); + + void ( STDMETHODCALLTYPE *GetRaytracingAccelerationStructurePrebuildInfo )( + ID3D12Device5 * This, + _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *pDesc, + _Out_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo); + + D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS ( STDMETHODCALLTYPE *CheckDriverMatchingIdentifier )( + ID3D12Device5 * This, + _In_ D3D12_SERIALIZED_DATA_TYPE SerializedDataType, + _In_ const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *pIdentifierToCheck); + + END_INTERFACE + } ID3D12Device5Vtbl; + + interface ID3D12Device5 + { + CONST_VTBL struct ID3D12Device5Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12Device5_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12Device5_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12Device5_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12Device5_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12Device5_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12Device5_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12Device5_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12Device5_GetNodeCount(This) \ + ( (This)->lpVtbl -> GetNodeCount(This) ) + +#define ID3D12Device5_CreateCommandQueue(This,pDesc,riid,ppCommandQueue) \ + ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) + +#define ID3D12Device5_CreateCommandAllocator(This,type,riid,ppCommandAllocator) \ + ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) + +#define ID3D12Device5_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) + +#define ID3D12Device5_CreateComputePipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) + +#define ID3D12Device5_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) \ + ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) + +#define ID3D12Device5_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) \ + ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) + +#define ID3D12Device5_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) + +#define ID3D12Device5_GetDescriptorHandleIncrementSize(This,DescriptorHeapType) \ + ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) + +#define ID3D12Device5_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) \ + ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) + +#define ID3D12Device5_CreateConstantBufferView(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) + +#define ID3D12Device5_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device5_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) + +#define ID3D12Device5_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device5_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device5_CreateSampler(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) + +#define ID3D12Device5_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) \ + ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) + +#define ID3D12Device5_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) \ + ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) + +#define ID3D12Device5_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) + +#define ID3D12Device5_GetCustomHeapProperties(This,nodeMask,heapType) \ + ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) + +#define ID3D12Device5_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) + +#define ID3D12Device5_CreateHeap(This,pDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) + +#define ID3D12Device5_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) + +#define ID3D12Device5_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) + +#define ID3D12Device5_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) \ + ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) + +#define ID3D12Device5_OpenSharedHandle(This,NTHandle,riid,ppvObj) \ + ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) + +#define ID3D12Device5_OpenSharedHandleByName(This,Name,Access,pNTHandle) \ + ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) + +#define ID3D12Device5_MakeResident(This,NumObjects,ppObjects) \ + ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) + +#define ID3D12Device5_Evict(This,NumObjects,ppObjects) \ + ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) + +#define ID3D12Device5_CreateFence(This,InitialValue,Flags,riid,ppFence) \ + ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) + +#define ID3D12Device5_GetDeviceRemovedReason(This) \ + ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) + +#define ID3D12Device5_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ + ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) + +#define ID3D12Device5_CreateQueryHeap(This,pDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) + +#define ID3D12Device5_SetStablePowerState(This,Enable) \ + ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) + +#define ID3D12Device5_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) \ + ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) + +#define ID3D12Device5_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) \ + ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) + +#define ID3D12Device5_GetAdapterLuid(This) \ + ( (This)->lpVtbl -> GetAdapterLuid(This) ) + + +#define ID3D12Device5_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) \ + ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) + +#define ID3D12Device5_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) \ + ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) + +#define ID3D12Device5_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) \ + ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) + + +#define ID3D12Device5_CreatePipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) + + +#define ID3D12Device5_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) \ + ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) + +#define ID3D12Device5_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) \ + ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) + +#define ID3D12Device5_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) \ + ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) + + +#define ID3D12Device5_CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) \ + ( (This)->lpVtbl -> CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) ) + +#define ID3D12Device5_CreateProtectedResourceSession(This,pDesc,riid,ppSession) \ + ( (This)->lpVtbl -> CreateProtectedResourceSession(This,pDesc,riid,ppSession) ) + +#define ID3D12Device5_CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) + +#define ID3D12Device5_CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) ) + +#define ID3D12Device5_CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) \ + ( (This)->lpVtbl -> CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) ) + +#define ID3D12Device5_GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) + + +#define ID3D12Device5_CreateLifetimeTracker(This,pOwner,riid,ppvTracker) \ + ( (This)->lpVtbl -> CreateLifetimeTracker(This,pOwner,riid,ppvTracker) ) + +#define ID3D12Device5_RemoveDevice(This) \ + ( (This)->lpVtbl -> RemoveDevice(This) ) + +#define ID3D12Device5_EnumerateMetaCommands(This,pNumMetaCommands,pDescs) \ + ( (This)->lpVtbl -> EnumerateMetaCommands(This,pNumMetaCommands,pDescs) ) + +#define ID3D12Device5_EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) \ + ( (This)->lpVtbl -> EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) ) + +#define ID3D12Device5_CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) \ + ( (This)->lpVtbl -> CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) ) + +#define ID3D12Device5_CreateStateObject(This,pDesc,riid,ppStateObject) \ + ( (This)->lpVtbl -> CreateStateObject(This,pDesc,riid,ppStateObject) ) + +#define ID3D12Device5_GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) \ + ( (This)->lpVtbl -> GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) ) + +#define ID3D12Device5_CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) \ + ( (This)->lpVtbl -> CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12Device5_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12_0000_0035 */ +/* [local] */ + +typedef +enum D3D12_AUTO_BREADCRUMB_OP + { + D3D12_AUTO_BREADCRUMB_OP_SETMARKER = 0, + D3D12_AUTO_BREADCRUMB_OP_BEGINEVENT = 1, + D3D12_AUTO_BREADCRUMB_OP_ENDEVENT = 2, + D3D12_AUTO_BREADCRUMB_OP_DRAWINSTANCED = 3, + D3D12_AUTO_BREADCRUMB_OP_DRAWINDEXEDINSTANCED = 4, + D3D12_AUTO_BREADCRUMB_OP_EXECUTEINDIRECT = 5, + D3D12_AUTO_BREADCRUMB_OP_DISPATCH = 6, + D3D12_AUTO_BREADCRUMB_OP_COPYBUFFERREGION = 7, + D3D12_AUTO_BREADCRUMB_OP_COPYTEXTUREREGION = 8, + D3D12_AUTO_BREADCRUMB_OP_COPYRESOURCE = 9, + D3D12_AUTO_BREADCRUMB_OP_COPYTILES = 10, + D3D12_AUTO_BREADCRUMB_OP_RESOLVESUBRESOURCE = 11, + D3D12_AUTO_BREADCRUMB_OP_CLEARRENDERTARGETVIEW = 12, + D3D12_AUTO_BREADCRUMB_OP_CLEARUNORDEREDACCESSVIEW = 13, + D3D12_AUTO_BREADCRUMB_OP_CLEARDEPTHSTENCILVIEW = 14, + D3D12_AUTO_BREADCRUMB_OP_RESOURCEBARRIER = 15, + D3D12_AUTO_BREADCRUMB_OP_EXECUTEBUNDLE = 16, + D3D12_AUTO_BREADCRUMB_OP_PRESENT = 17, + D3D12_AUTO_BREADCRUMB_OP_RESOLVEQUERYDATA = 18, + D3D12_AUTO_BREADCRUMB_OP_BEGINSUBMISSION = 19, + D3D12_AUTO_BREADCRUMB_OP_ENDSUBMISSION = 20, + D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME = 21, + D3D12_AUTO_BREADCRUMB_OP_PROCESSFRAMES = 22, + D3D12_AUTO_BREADCRUMB_OP_ATOMICCOPYBUFFERUINT = 23, + D3D12_AUTO_BREADCRUMB_OP_ATOMICCOPYBUFFERUINT64 = 24, + D3D12_AUTO_BREADCRUMB_OP_RESOLVESUBRESOURCEREGION = 25, + D3D12_AUTO_BREADCRUMB_OP_WRITEBUFFERIMMEDIATE = 26, + D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME1 = 27, + D3D12_AUTO_BREADCRUMB_OP_SETPROTECTEDRESOURCESESSION = 28, + D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME2 = 29, + D3D12_AUTO_BREADCRUMB_OP_PROCESSFRAMES1 = 30, + D3D12_AUTO_BREADCRUMB_OP_BUILDRAYTRACINGACCELERATIONSTRUCTURE = 31, + D3D12_AUTO_BREADCRUMB_OP_EMITRAYTRACINGACCELERATIONSTRUCTUREPOSTBUILDINFO = 32, + D3D12_AUTO_BREADCRUMB_OP_COPYRAYTRACINGACCELERATIONSTRUCTURE = 33, + D3D12_AUTO_BREADCRUMB_OP_DISPATCHRAYS = 34, + D3D12_AUTO_BREADCRUMB_OP_INITIALIZEMETACOMMAND = 35, + D3D12_AUTO_BREADCRUMB_OP_EXECUTEMETACOMMAND = 36, + D3D12_AUTO_BREADCRUMB_OP_ESTIMATEMOTION = 37, + D3D12_AUTO_BREADCRUMB_OP_RESOLVEMOTIONVECTORHEAP = 38, + D3D12_AUTO_BREADCRUMB_OP_SETPIPELINESTATE1 = 39, + D3D12_AUTO_BREADCRUMB_OP_INITIALIZEEXTENSIONCOMMAND = 40, + D3D12_AUTO_BREADCRUMB_OP_EXECUTEEXTENSIONCOMMAND = 41 + } D3D12_AUTO_BREADCRUMB_OP; + +typedef struct D3D12_AUTO_BREADCRUMB_NODE + { + const char *pCommandListDebugNameA; + const wchar_t *pCommandListDebugNameW; + const char *pCommandQueueDebugNameA; + const wchar_t *pCommandQueueDebugNameW; + ID3D12GraphicsCommandList *pCommandList; + ID3D12CommandQueue *pCommandQueue; + UINT32 BreadcrumbCount; + const UINT32 *pLastBreadcrumbValue; + const D3D12_AUTO_BREADCRUMB_OP *pCommandHistory; + const struct D3D12_AUTO_BREADCRUMB_NODE *pNext; + } D3D12_AUTO_BREADCRUMB_NODE; + +typedef +enum D3D12_DRED_VERSION + { + D3D12_DRED_VERSION_1_0 = 0x1, + D3D12_DRED_VERSION_1_1 = 0x2 + } D3D12_DRED_VERSION; + +typedef +enum D3D12_DRED_FLAGS + { + D3D12_DRED_FLAG_NONE = 0, + D3D12_DRED_FLAG_FORCE_ENABLE = 1, + D3D12_DRED_FLAG_DISABLE_AUTOBREADCRUMBS = 2 + } D3D12_DRED_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_DRED_FLAGS ); +typedef +enum D3D12_DRED_ENABLEMENT + { + D3D12_DRED_ENABLEMENT_SYSTEM_CONTROLLED = 0, + D3D12_DRED_ENABLEMENT_FORCED_OFF = 1, + D3D12_DRED_ENABLEMENT_FORCED_ON = 2 + } D3D12_DRED_ENABLEMENT; + +typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA + { + _In_ D3D12_DRED_FLAGS Flags; + _Out_ D3D12_AUTO_BREADCRUMB_NODE *pHeadAutoBreadcrumbNode; + } D3D12_DEVICE_REMOVED_EXTENDED_DATA; + +typedef +enum D3D12_DRED_ALLOCATION_TYPE + { + D3D12_DRED_ALLOCATION_TYPE_COMMAND_QUEUE = 19, + D3D12_DRED_ALLOCATION_TYPE_COMMAND_ALLOCATOR = 20, + D3D12_DRED_ALLOCATION_TYPE_PIPELINE_STATE = 21, + D3D12_DRED_ALLOCATION_TYPE_COMMAND_LIST = 22, + D3D12_DRED_ALLOCATION_TYPE_FENCE = 23, + D3D12_DRED_ALLOCATION_TYPE_DESCRIPTOR_HEAP = 24, + D3D12_DRED_ALLOCATION_TYPE_HEAP = 25, + D3D12_DRED_ALLOCATION_TYPE_QUERY_HEAP = 27, + D3D12_DRED_ALLOCATION_TYPE_COMMAND_SIGNATURE = 28, + D3D12_DRED_ALLOCATION_TYPE_PIPELINE_LIBRARY = 29, + D3D12_DRED_ALLOCATION_TYPE_VIDEO_DECODER = 30, + D3D12_DRED_ALLOCATION_TYPE_VIDEO_PROCESSOR = 32, + D3D12_DRED_ALLOCATION_TYPE_RESOURCE = 34, + D3D12_DRED_ALLOCATION_TYPE_PASS = 35, + D3D12_DRED_ALLOCATION_TYPE_CRYPTOSESSION = 36, + D3D12_DRED_ALLOCATION_TYPE_CRYPTOSESSIONPOLICY = 37, + D3D12_DRED_ALLOCATION_TYPE_PROTECTEDRESOURCESESSION = 38, + D3D12_DRED_ALLOCATION_TYPE_VIDEO_DECODER_HEAP = 39, + D3D12_DRED_ALLOCATION_TYPE_COMMAND_POOL = 40, + D3D12_DRED_ALLOCATION_TYPE_COMMAND_RECORDER = 41, + D3D12_DRED_ALLOCATION_TYPE_STATE_OBJECT = 42, + D3D12_DRED_ALLOCATION_TYPE_METACOMMAND = 43, + D3D12_DRED_ALLOCATION_TYPE_SCHEDULINGGROUP = 44, + D3D12_DRED_ALLOCATION_TYPE_VIDEO_MOTION_ESTIMATOR = 45, + D3D12_DRED_ALLOCATION_TYPE_VIDEO_MOTION_VECTOR_HEAP = 46, + D3D12_DRED_ALLOCATION_TYPE_VIDEO_EXTENSION_COMMAND = 47, + D3D12_DRED_ALLOCATION_TYPE_INVALID = 0xffffffff + } D3D12_DRED_ALLOCATION_TYPE; + +typedef struct D3D12_DRED_ALLOCATION_NODE + { + const char *ObjectNameA; + const wchar_t *ObjectNameW; + D3D12_DRED_ALLOCATION_TYPE AllocationType; + const struct D3D12_DRED_ALLOCATION_NODE *pNext; + } D3D12_DRED_ALLOCATION_NODE; + +typedef struct D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT + { + _Out_ const D3D12_AUTO_BREADCRUMB_NODE *pHeadAutoBreadcrumbNode; + } D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT; + +typedef struct D3D12_DRED_PAGE_FAULT_OUTPUT + { + D3D12_GPU_VIRTUAL_ADDRESS PageFaultVA; + _Out_ const D3D12_DRED_ALLOCATION_NODE *pHeadExistingAllocationNode; + _Out_ const D3D12_DRED_ALLOCATION_NODE *pHeadRecentFreedAllocationNode; + } D3D12_DRED_PAGE_FAULT_OUTPUT; + +typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA1 + { + HRESULT DeviceRemovedReason; + D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT AutoBreadcrumbsOutput; + D3D12_DRED_PAGE_FAULT_OUTPUT PageFaultOutput; + } D3D12_DEVICE_REMOVED_EXTENDED_DATA1; + +typedef struct D3D12_VERSIONED_DEVICE_REMOVED_EXTENDED_DATA + { + D3D12_DRED_VERSION Version; + union + { + D3D12_DEVICE_REMOVED_EXTENDED_DATA Dred_1_0; + D3D12_DEVICE_REMOVED_EXTENDED_DATA1 Dred_1_1; + } ; + } D3D12_VERSIONED_DEVICE_REMOVED_EXTENDED_DATA; + + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0035_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0035_v0_0_s_ifspec; + +#ifndef __ID3D12DeviceRemovedExtendedDataSettings_INTERFACE_DEFINED__ +#define __ID3D12DeviceRemovedExtendedDataSettings_INTERFACE_DEFINED__ + +/* interface ID3D12DeviceRemovedExtendedDataSettings */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12DeviceRemovedExtendedDataSettings; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("82BC481C-6B9B-4030-AEDB-7EE3D1DF1E63") + ID3D12DeviceRemovedExtendedDataSettings : public IUnknown + { + public: + virtual void STDMETHODCALLTYPE SetAutoBreadcrumbsEnablement( + D3D12_DRED_ENABLEMENT __MIDL__ID3D12DeviceRemovedExtendedDataSettings0000) = 0; + + virtual void STDMETHODCALLTYPE SetPageFaultEnablement( + D3D12_DRED_ENABLEMENT __MIDL__ID3D12DeviceRemovedExtendedDataSettings0001) = 0; + + virtual void STDMETHODCALLTYPE SetWatsonDumpEnablement( + D3D12_DRED_ENABLEMENT __MIDL__ID3D12DeviceRemovedExtendedDataSettings0002) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12DeviceRemovedExtendedDataSettingsVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12DeviceRemovedExtendedDataSettings * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12DeviceRemovedExtendedDataSettings * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12DeviceRemovedExtendedDataSettings * This); + + void ( STDMETHODCALLTYPE *SetAutoBreadcrumbsEnablement )( + ID3D12DeviceRemovedExtendedDataSettings * This, + D3D12_DRED_ENABLEMENT __MIDL__ID3D12DeviceRemovedExtendedDataSettings0000); + + void ( STDMETHODCALLTYPE *SetPageFaultEnablement )( + ID3D12DeviceRemovedExtendedDataSettings * This, + D3D12_DRED_ENABLEMENT __MIDL__ID3D12DeviceRemovedExtendedDataSettings0001); + + void ( STDMETHODCALLTYPE *SetWatsonDumpEnablement )( + ID3D12DeviceRemovedExtendedDataSettings * This, + D3D12_DRED_ENABLEMENT __MIDL__ID3D12DeviceRemovedExtendedDataSettings0002); + + END_INTERFACE + } ID3D12DeviceRemovedExtendedDataSettingsVtbl; + + interface ID3D12DeviceRemovedExtendedDataSettings + { + CONST_VTBL struct ID3D12DeviceRemovedExtendedDataSettingsVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12DeviceRemovedExtendedDataSettings_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12DeviceRemovedExtendedDataSettings_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12DeviceRemovedExtendedDataSettings_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12DeviceRemovedExtendedDataSettings_SetAutoBreadcrumbsEnablement(This,__MIDL__ID3D12DeviceRemovedExtendedDataSettings0000) \ + ( (This)->lpVtbl -> SetAutoBreadcrumbsEnablement(This,__MIDL__ID3D12DeviceRemovedExtendedDataSettings0000) ) + +#define ID3D12DeviceRemovedExtendedDataSettings_SetPageFaultEnablement(This,__MIDL__ID3D12DeviceRemovedExtendedDataSettings0001) \ + ( (This)->lpVtbl -> SetPageFaultEnablement(This,__MIDL__ID3D12DeviceRemovedExtendedDataSettings0001) ) + +#define ID3D12DeviceRemovedExtendedDataSettings_SetWatsonDumpEnablement(This,__MIDL__ID3D12DeviceRemovedExtendedDataSettings0002) \ + ( (This)->lpVtbl -> SetWatsonDumpEnablement(This,__MIDL__ID3D12DeviceRemovedExtendedDataSettings0002) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12DeviceRemovedExtendedDataSettings_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12DeviceRemovedExtendedData_INTERFACE_DEFINED__ +#define __ID3D12DeviceRemovedExtendedData_INTERFACE_DEFINED__ + +/* interface ID3D12DeviceRemovedExtendedData */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12DeviceRemovedExtendedData; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("98931D33-5AE8-4791-AA3C-1A73A2934E71") + ID3D12DeviceRemovedExtendedData : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetAutoBreadcrumbsOutput( + D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT *pOutput) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPageFaultAllocationOutput( + D3D12_DRED_PAGE_FAULT_OUTPUT *pOutput) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12DeviceRemovedExtendedDataVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12DeviceRemovedExtendedData * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12DeviceRemovedExtendedData * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12DeviceRemovedExtendedData * This); + + HRESULT ( STDMETHODCALLTYPE *GetAutoBreadcrumbsOutput )( + ID3D12DeviceRemovedExtendedData * This, + D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT *pOutput); + + HRESULT ( STDMETHODCALLTYPE *GetPageFaultAllocationOutput )( + ID3D12DeviceRemovedExtendedData * This, + D3D12_DRED_PAGE_FAULT_OUTPUT *pOutput); + + END_INTERFACE + } ID3D12DeviceRemovedExtendedDataVtbl; + + interface ID3D12DeviceRemovedExtendedData + { + CONST_VTBL struct ID3D12DeviceRemovedExtendedDataVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12DeviceRemovedExtendedData_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12DeviceRemovedExtendedData_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12DeviceRemovedExtendedData_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12DeviceRemovedExtendedData_GetAutoBreadcrumbsOutput(This,pOutput) \ + ( (This)->lpVtbl -> GetAutoBreadcrumbsOutput(This,pOutput) ) + +#define ID3D12DeviceRemovedExtendedData_GetPageFaultAllocationOutput(This,pOutput) \ + ( (This)->lpVtbl -> GetPageFaultAllocationOutput(This,pOutput) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12DeviceRemovedExtendedData_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12_0000_0037 */ +/* [local] */ + +typedef +enum D3D12_BACKGROUND_PROCESSING_MODE + { + D3D12_BACKGROUND_PROCESSING_MODE_ALLOWED = 0, + D3D12_BACKGROUND_PROCESSING_MODE_ALLOW_INTRUSIVE_MEASUREMENTS = ( D3D12_BACKGROUND_PROCESSING_MODE_ALLOWED + 1 ) , + D3D12_BACKGROUND_PROCESSING_MODE_DISABLE_BACKGROUND_WORK = ( D3D12_BACKGROUND_PROCESSING_MODE_ALLOW_INTRUSIVE_MEASUREMENTS + 1 ) , + D3D12_BACKGROUND_PROCESSING_MODE_DISABLE_PROFILING_BY_SYSTEM = ( D3D12_BACKGROUND_PROCESSING_MODE_DISABLE_BACKGROUND_WORK + 1 ) + } D3D12_BACKGROUND_PROCESSING_MODE; + +typedef +enum D3D12_MEASUREMENTS_ACTION + { + D3D12_MEASUREMENTS_ACTION_KEEP_ALL = 0, + D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS = ( D3D12_MEASUREMENTS_ACTION_KEEP_ALL + 1 ) , + D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS_HIGH_PRIORITY = ( D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS + 1 ) , + D3D12_MEASUREMENTS_ACTION_DISCARD_PREVIOUS = ( D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS_HIGH_PRIORITY + 1 ) + } D3D12_MEASUREMENTS_ACTION; + + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0037_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0037_v0_0_s_ifspec; + +#ifndef __ID3D12Device6_INTERFACE_DEFINED__ +#define __ID3D12Device6_INTERFACE_DEFINED__ + +/* interface ID3D12Device6 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12Device6; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("c70b221b-40e4-4a17-89af-025a0727a6dc") + ID3D12Device6 : public ID3D12Device5 + { + public: + virtual HRESULT STDMETHODCALLTYPE SetBackgroundProcessingMode( + D3D12_BACKGROUND_PROCESSING_MODE Mode, + D3D12_MEASUREMENTS_ACTION MeasurementsAction, + _In_opt_ HANDLE hEventToSignalUponCompletion, + _Out_opt_ BOOL *pbFurtherMeasurementsDesired) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12Device6Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12Device6 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12Device6 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12Device6 * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12Device6 * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12Device6 * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12Device6 * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12Device6 * This, + _In_z_ LPCWSTR Name); + + UINT ( STDMETHODCALLTYPE *GetNodeCount )( + ID3D12Device6 * This); + + HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( + ID3D12Device6 * This, + _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppCommandQueue); + + HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( + ID3D12Device6 * This, + _In_ D3D12_COMMAND_LIST_TYPE type, + REFIID riid, + _COM_Outptr_ void **ppCommandAllocator); + + HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( + ID3D12Device6 * This, + _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( + ID3D12Device6 * This, + _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( + ID3D12Device6 * This, + _In_ UINT nodeMask, + _In_ D3D12_COMMAND_LIST_TYPE type, + _In_ ID3D12CommandAllocator *pCommandAllocator, + _In_opt_ ID3D12PipelineState *pInitialState, + REFIID riid, + _COM_Outptr_ void **ppCommandList); + + HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( + ID3D12Device6 * This, + D3D12_FEATURE Feature, + _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, + UINT FeatureSupportDataSize); + + HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( + ID3D12Device6 * This, + _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, + REFIID riid, + _COM_Outptr_ void **ppvHeap); + + UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( + ID3D12Device6 * This, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType); + + HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( + ID3D12Device6 * This, + _In_ UINT nodeMask, + _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, + _In_ SIZE_T blobLengthInBytes, + REFIID riid, + _COM_Outptr_ void **ppvRootSignature); + + void ( STDMETHODCALLTYPE *CreateConstantBufferView )( + ID3D12Device6 * This, + _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateShaderResourceView )( + ID3D12Device6 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( + ID3D12Device6 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ ID3D12Resource *pCounterResource, + _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateRenderTargetView )( + ID3D12Device6 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateDepthStencilView )( + ID3D12Device6 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CreateSampler )( + ID3D12Device6 * This, + _In_ const D3D12_SAMPLER_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + void ( STDMETHODCALLTYPE *CopyDescriptors )( + ID3D12Device6 * This, + _In_ UINT NumDestDescriptorRanges, + _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts, + _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes, + _In_ UINT NumSrcDescriptorRanges, + _In_reads_(NumSrcDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts, + _In_reads_opt_(NumSrcDescriptorRanges) const UINT *pSrcDescriptorRangeSizes, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + + void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( + ID3D12Device6 * This, + _In_ UINT NumDescriptors, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( + ID3D12Device6 * This, + _In_ UINT visibleMask, + _In_ UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); + + D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( + ID3D12Device6 * This, + _In_ UINT nodeMask, + D3D12_HEAP_TYPE heapType); + + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( + ID3D12Device6 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); + + HRESULT ( STDMETHODCALLTYPE *CreateHeap )( + ID3D12Device6 * This, + _In_ const D3D12_HEAP_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); + + HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( + ID3D12Device6 * This, + _In_ ID3D12Heap *pHeap, + UINT64 HeapOffset, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( + ID3D12Device6 * This, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( + ID3D12Device6 * This, + _In_ ID3D12DeviceChild *pObject, + _In_opt_ const SECURITY_ATTRIBUTES *pAttributes, + DWORD Access, + _In_opt_ LPCWSTR Name, + _Out_ HANDLE *pHandle); + + HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( + ID3D12Device6 * This, + _In_ HANDLE NTHandle, + REFIID riid, + _COM_Outptr_opt_ void **ppvObj); + + HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( + ID3D12Device6 * This, + _In_ LPCWSTR Name, + DWORD Access, + /* [annotation][out] */ + _Out_ HANDLE *pNTHandle); + + HRESULT ( STDMETHODCALLTYPE *MakeResident )( + ID3D12Device6 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); + + HRESULT ( STDMETHODCALLTYPE *Evict )( + ID3D12Device6 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); + + HRESULT ( STDMETHODCALLTYPE *CreateFence )( + ID3D12Device6 * This, + UINT64 InitialValue, + D3D12_FENCE_FLAGS Flags, + REFIID riid, + _COM_Outptr_ void **ppFence); + + HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( + ID3D12Device6 * This); + + void ( STDMETHODCALLTYPE *GetCopyableFootprints )( + ID3D12Device6 * This, + _In_ const D3D12_RESOURCE_DESC *pResourceDesc, + _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, + _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, + UINT64 BaseOffset, + _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, + _Out_writes_opt_(NumSubresources) UINT *pNumRows, + _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, + _Out_opt_ UINT64 *pTotalBytes); + + HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( + ID3D12Device6 * This, + _In_ const D3D12_QUERY_HEAP_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); + + HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( + ID3D12Device6 * This, + BOOL Enable); + + HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( + ID3D12Device6 * This, + _In_ const D3D12_COMMAND_SIGNATURE_DESC *pDesc, + _In_opt_ ID3D12RootSignature *pRootSignature, + REFIID riid, + _COM_Outptr_opt_ void **ppvCommandSignature); + + void ( STDMETHODCALLTYPE *GetResourceTiling )( + ID3D12Device6 * This, + _In_ ID3D12Resource *pTiledResource, + _Out_opt_ UINT *pNumTilesForEntireResource, + _Out_opt_ D3D12_PACKED_MIP_INFO *pPackedMipDesc, + _Out_opt_ D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips, + _Inout_opt_ UINT *pNumSubresourceTilings, + _In_ UINT FirstSubresourceTilingToGet, + _Out_writes_(*pNumSubresourceTilings) D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips); + + LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( + ID3D12Device6 * This); + + HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( + ID3D12Device6 * This, + _In_reads_(BlobLength) const void *pLibraryBlob, + SIZE_T BlobLength, + REFIID riid, + _COM_Outptr_ void **ppPipelineLibrary); + + HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( + ID3D12Device6 * This, + _In_reads_(NumFences) ID3D12Fence *const *ppFences, + _In_reads_(NumFences) const UINT64 *pFenceValues, + UINT NumFences, + D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags, + HANDLE hEvent); + + HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( + ID3D12Device6 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, + _In_reads_(NumObjects) const D3D12_RESIDENCY_PRIORITY *pPriorities); + + HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( + ID3D12Device6 * This, + const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress )( + ID3D12Device6 * This, + _In_ const void *pAddress, + REFIID riid, + _COM_Outptr_ void **ppvHeap); + + HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromFileMapping )( + ID3D12Device6 * This, + _In_ HANDLE hFileMapping, + REFIID riid, + _COM_Outptr_ void **ppvHeap); + + HRESULT ( STDMETHODCALLTYPE *EnqueueMakeResident )( + ID3D12Device6 * This, + D3D12_RESIDENCY_FLAGS Flags, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, + _In_ ID3D12Fence *pFenceToSignal, + UINT64 FenceValueToSignal); + + HRESULT ( STDMETHODCALLTYPE *CreateCommandList1 )( + ID3D12Device6 * This, + _In_ UINT nodeMask, + _In_ D3D12_COMMAND_LIST_TYPE type, + _In_ D3D12_COMMAND_LIST_FLAGS flags, + REFIID riid, + _COM_Outptr_ void **ppCommandList); + + HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession )( + ID3D12Device6 * This, + _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC *pDesc, + _In_ REFIID riid, + _COM_Outptr_ void **ppSession); + + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource1 )( + ID3D12Device6 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); + + HRESULT ( STDMETHODCALLTYPE *CreateHeap1 )( + ID3D12Device6 * This, + _In_ const D3D12_HEAP_DESC *pDesc, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); + + HRESULT ( STDMETHODCALLTYPE *CreateReservedResource1 )( + ID3D12Device6 * This, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( + ID3D12Device6 * This, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); + + HRESULT ( STDMETHODCALLTYPE *CreateLifetimeTracker )( + ID3D12Device6 * This, + _In_ ID3D12LifetimeOwner *pOwner, + REFIID riid, + _COM_Outptr_ void **ppvTracker); + + void ( STDMETHODCALLTYPE *RemoveDevice )( + ID3D12Device6 * This); + + HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommands )( + ID3D12Device6 * This, + _Inout_ UINT *pNumMetaCommands, + _Out_writes_opt_(*pNumMetaCommands) D3D12_META_COMMAND_DESC *pDescs); + + HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommandParameters )( + ID3D12Device6 * This, + _In_ REFGUID CommandId, + _In_ D3D12_META_COMMAND_PARAMETER_STAGE Stage, + _Out_opt_ UINT *pTotalStructureSizeInBytes, + _Inout_ UINT *pParameterCount, + _Out_writes_opt_(*pParameterCount) D3D12_META_COMMAND_PARAMETER_DESC *pParameterDescs); + + HRESULT ( STDMETHODCALLTYPE *CreateMetaCommand )( + ID3D12Device6 * This, + _In_ REFGUID CommandId, + _In_ UINT NodeMask, + _In_reads_bytes_opt_(CreationParametersDataSizeInBytes) const void *pCreationParametersData, + _In_ SIZE_T CreationParametersDataSizeInBytes, + REFIID riid, + _COM_Outptr_ void **ppMetaCommand); + + HRESULT ( STDMETHODCALLTYPE *CreateStateObject )( + ID3D12Device6 * This, + const D3D12_STATE_OBJECT_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppStateObject); + + void ( STDMETHODCALLTYPE *GetRaytracingAccelerationStructurePrebuildInfo )( + ID3D12Device6 * This, + _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *pDesc, + _Out_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo); + + D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS ( STDMETHODCALLTYPE *CheckDriverMatchingIdentifier )( + ID3D12Device6 * This, + _In_ D3D12_SERIALIZED_DATA_TYPE SerializedDataType, + _In_ const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *pIdentifierToCheck); + + HRESULT ( STDMETHODCALLTYPE *SetBackgroundProcessingMode )( + ID3D12Device6 * This, + D3D12_BACKGROUND_PROCESSING_MODE Mode, + D3D12_MEASUREMENTS_ACTION MeasurementsAction, + _In_opt_ HANDLE hEventToSignalUponCompletion, + _Out_opt_ BOOL *pbFurtherMeasurementsDesired); + + END_INTERFACE + } ID3D12Device6Vtbl; + + interface ID3D12Device6 + { + CONST_VTBL struct ID3D12Device6Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12Device6_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12Device6_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12Device6_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12Device6_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12Device6_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12Device6_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12Device6_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12Device6_GetNodeCount(This) \ + ( (This)->lpVtbl -> GetNodeCount(This) ) + +#define ID3D12Device6_CreateCommandQueue(This,pDesc,riid,ppCommandQueue) \ + ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) + +#define ID3D12Device6_CreateCommandAllocator(This,type,riid,ppCommandAllocator) \ + ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) + +#define ID3D12Device6_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) + +#define ID3D12Device6_CreateComputePipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) + +#define ID3D12Device6_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) \ + ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) + +#define ID3D12Device6_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) \ + ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) + +#define ID3D12Device6_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) + +#define ID3D12Device6_GetDescriptorHandleIncrementSize(This,DescriptorHeapType) \ + ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) + +#define ID3D12Device6_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) \ + ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) + +#define ID3D12Device6_CreateConstantBufferView(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) + +#define ID3D12Device6_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device6_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) + +#define ID3D12Device6_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device6_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device6_CreateSampler(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) + +#define ID3D12Device6_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) \ + ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) + +#define ID3D12Device6_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) \ + ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) + +#define ID3D12Device6_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) + +#define ID3D12Device6_GetCustomHeapProperties(This,nodeMask,heapType) \ + ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) + +#define ID3D12Device6_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) + +#define ID3D12Device6_CreateHeap(This,pDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) + +#define ID3D12Device6_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) + +#define ID3D12Device6_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) + +#define ID3D12Device6_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) \ + ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) + +#define ID3D12Device6_OpenSharedHandle(This,NTHandle,riid,ppvObj) \ + ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) + +#define ID3D12Device6_OpenSharedHandleByName(This,Name,Access,pNTHandle) \ + ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) + +#define ID3D12Device6_MakeResident(This,NumObjects,ppObjects) \ + ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) + +#define ID3D12Device6_Evict(This,NumObjects,ppObjects) \ + ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) + +#define ID3D12Device6_CreateFence(This,InitialValue,Flags,riid,ppFence) \ + ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) + +#define ID3D12Device6_GetDeviceRemovedReason(This) \ + ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) + +#define ID3D12Device6_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ + ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) + +#define ID3D12Device6_CreateQueryHeap(This,pDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) + +#define ID3D12Device6_SetStablePowerState(This,Enable) \ + ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) + +#define ID3D12Device6_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) \ + ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) + +#define ID3D12Device6_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) \ + ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) + +#define ID3D12Device6_GetAdapterLuid(This) \ + ( (This)->lpVtbl -> GetAdapterLuid(This) ) + + +#define ID3D12Device6_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) \ + ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) + +#define ID3D12Device6_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) \ + ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) + +#define ID3D12Device6_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) \ + ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) + + +#define ID3D12Device6_CreatePipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) + + +#define ID3D12Device6_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) \ + ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) + +#define ID3D12Device6_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) \ + ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) + +#define ID3D12Device6_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) \ + ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) + + +#define ID3D12Device6_CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) \ + ( (This)->lpVtbl -> CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) ) + +#define ID3D12Device6_CreateProtectedResourceSession(This,pDesc,riid,ppSession) \ + ( (This)->lpVtbl -> CreateProtectedResourceSession(This,pDesc,riid,ppSession) ) + +#define ID3D12Device6_CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) + +#define ID3D12Device6_CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) ) + +#define ID3D12Device6_CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) \ + ( (This)->lpVtbl -> CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) ) + +#define ID3D12Device6_GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) + + +#define ID3D12Device6_CreateLifetimeTracker(This,pOwner,riid,ppvTracker) \ + ( (This)->lpVtbl -> CreateLifetimeTracker(This,pOwner,riid,ppvTracker) ) + +#define ID3D12Device6_RemoveDevice(This) \ + ( (This)->lpVtbl -> RemoveDevice(This) ) + +#define ID3D12Device6_EnumerateMetaCommands(This,pNumMetaCommands,pDescs) \ + ( (This)->lpVtbl -> EnumerateMetaCommands(This,pNumMetaCommands,pDescs) ) + +#define ID3D12Device6_EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) \ + ( (This)->lpVtbl -> EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) ) + +#define ID3D12Device6_CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) \ + ( (This)->lpVtbl -> CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) ) + +#define ID3D12Device6_CreateStateObject(This,pDesc,riid,ppStateObject) \ + ( (This)->lpVtbl -> CreateStateObject(This,pDesc,riid,ppStateObject) ) + +#define ID3D12Device6_GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) \ + ( (This)->lpVtbl -> GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) ) + +#define ID3D12Device6_CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) \ + ( (This)->lpVtbl -> CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) ) + + +#define ID3D12Device6_SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) \ + ( (This)->lpVtbl -> SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12Device6_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12Resource1_INTERFACE_DEFINED__ +#define __ID3D12Resource1_INTERFACE_DEFINED__ + +/* interface ID3D12Resource1 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12Resource1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("9D5E227A-4430-4161-88B3-3ECA6BB16E19") + ID3D12Resource1 : public ID3D12Resource + { + public: + virtual HRESULT STDMETHODCALLTYPE GetProtectedResourceSession( + REFIID riid, + _COM_Outptr_opt_ void **ppProtectedSession) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12Resource1Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12Resource1 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12Resource1 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12Resource1 * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12Resource1 * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12Resource1 * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12Resource1 * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12Resource1 * This, + _In_z_ LPCWSTR Name); + + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12Resource1 * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + HRESULT ( STDMETHODCALLTYPE *Map )( + ID3D12Resource1 * This, + UINT Subresource, + _In_opt_ const D3D12_RANGE *pReadRange, + _Outptr_opt_result_bytebuffer_(_Inexpressible_("Dependent on resource")) void **ppData); + + void ( STDMETHODCALLTYPE *Unmap )( + ID3D12Resource1 * This, + UINT Subresource, + _In_opt_ const D3D12_RANGE *pWrittenRange); + + D3D12_RESOURCE_DESC ( STDMETHODCALLTYPE *GetDesc )( + ID3D12Resource1 * This); + + D3D12_GPU_VIRTUAL_ADDRESS ( STDMETHODCALLTYPE *GetGPUVirtualAddress )( + ID3D12Resource1 * This); + + HRESULT ( STDMETHODCALLTYPE *WriteToSubresource )( + ID3D12Resource1 * This, + UINT DstSubresource, + _In_opt_ const D3D12_BOX *pDstBox, + _In_ const void *pSrcData, + UINT SrcRowPitch, + UINT SrcDepthPitch); + + HRESULT ( STDMETHODCALLTYPE *ReadFromSubresource )( + ID3D12Resource1 * This, + _Out_ void *pDstData, + UINT DstRowPitch, + UINT DstDepthPitch, + UINT SrcSubresource, + _In_opt_ const D3D12_BOX *pSrcBox); + + HRESULT ( STDMETHODCALLTYPE *GetHeapProperties )( + ID3D12Resource1 * This, + _Out_opt_ D3D12_HEAP_PROPERTIES *pHeapProperties, + _Out_opt_ D3D12_HEAP_FLAGS *pHeapFlags); + + HRESULT ( STDMETHODCALLTYPE *GetProtectedResourceSession )( + ID3D12Resource1 * This, + REFIID riid, + _COM_Outptr_opt_ void **ppProtectedSession); + + END_INTERFACE + } ID3D12Resource1Vtbl; + + interface ID3D12Resource1 + { + CONST_VTBL struct ID3D12Resource1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12Resource1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12Resource1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12Resource1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12Resource1_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12Resource1_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12Resource1_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12Resource1_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12Resource1_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + + +#define ID3D12Resource1_Map(This,Subresource,pReadRange,ppData) \ + ( (This)->lpVtbl -> Map(This,Subresource,pReadRange,ppData) ) + +#define ID3D12Resource1_Unmap(This,Subresource,pWrittenRange) \ + ( (This)->lpVtbl -> Unmap(This,Subresource,pWrittenRange) ) + +#define ID3D12Resource1_GetDesc(This) \ + ( (This)->lpVtbl -> GetDesc(This) ) + +#define ID3D12Resource1_GetGPUVirtualAddress(This) \ + ( (This)->lpVtbl -> GetGPUVirtualAddress(This) ) + +#define ID3D12Resource1_WriteToSubresource(This,DstSubresource,pDstBox,pSrcData,SrcRowPitch,SrcDepthPitch) \ + ( (This)->lpVtbl -> WriteToSubresource(This,DstSubresource,pDstBox,pSrcData,SrcRowPitch,SrcDepthPitch) ) + +#define ID3D12Resource1_ReadFromSubresource(This,pDstData,DstRowPitch,DstDepthPitch,SrcSubresource,pSrcBox) \ + ( (This)->lpVtbl -> ReadFromSubresource(This,pDstData,DstRowPitch,DstDepthPitch,SrcSubresource,pSrcBox) ) + +#define ID3D12Resource1_GetHeapProperties(This,pHeapProperties,pHeapFlags) \ + ( (This)->lpVtbl -> GetHeapProperties(This,pHeapProperties,pHeapFlags) ) + + +#define ID3D12Resource1_GetProtectedResourceSession(This,riid,ppProtectedSession) \ + ( (This)->lpVtbl -> GetProtectedResourceSession(This,riid,ppProtectedSession) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12Resource1_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12Heap1_INTERFACE_DEFINED__ +#define __ID3D12Heap1_INTERFACE_DEFINED__ + +/* interface ID3D12Heap1 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12Heap1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("572F7389-2168-49E3-9693-D6DF5871BF6D") + ID3D12Heap1 : public ID3D12Heap + { + public: + virtual HRESULT STDMETHODCALLTYPE GetProtectedResourceSession( + REFIID riid, + _COM_Outptr_opt_ void **ppProtectedSession) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12Heap1Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12Heap1 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12Heap1 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12Heap1 * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12Heap1 * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12Heap1 * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12Heap1 * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12Heap1 * This, + _In_z_ LPCWSTR Name); + + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12Heap1 * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + D3D12_HEAP_DESC ( STDMETHODCALLTYPE *GetDesc )( + ID3D12Heap1 * This); + + HRESULT ( STDMETHODCALLTYPE *GetProtectedResourceSession )( + ID3D12Heap1 * This, + REFIID riid, + _COM_Outptr_opt_ void **ppProtectedSession); + + END_INTERFACE + } ID3D12Heap1Vtbl; + + interface ID3D12Heap1 + { + CONST_VTBL struct ID3D12Heap1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12Heap1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12Heap1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12Heap1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12Heap1_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12Heap1_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12Heap1_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12Heap1_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12Heap1_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + + +#define ID3D12Heap1_GetDesc(This) \ + ( (This)->lpVtbl -> GetDesc(This) ) + + +#define ID3D12Heap1_GetProtectedResourceSession(This,riid,ppProtectedSession) \ + ( (This)->lpVtbl -> GetProtectedResourceSession(This,riid,ppProtectedSession) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12Heap1_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12GraphicsCommandList3_INTERFACE_DEFINED__ +#define __ID3D12GraphicsCommandList3_INTERFACE_DEFINED__ + +/* interface ID3D12GraphicsCommandList3 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12GraphicsCommandList3; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("6FDA83A7-B84C-4E38-9AC8-C7BD22016B3D") + ID3D12GraphicsCommandList3 : public ID3D12GraphicsCommandList2 + { + public: + virtual void STDMETHODCALLTYPE SetProtectedResourceSession( + _In_opt_ ID3D12ProtectedResourceSession *pProtectedResourceSession) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12GraphicsCommandList3Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12GraphicsCommandList3 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12GraphicsCommandList3 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12GraphicsCommandList3 * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12GraphicsCommandList3 * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12GraphicsCommandList3 * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12GraphicsCommandList3 * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12GraphicsCommandList3 * This, + _In_z_ LPCWSTR Name); + + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12GraphicsCommandList3 * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( + ID3D12GraphicsCommandList3 * This); + + HRESULT ( STDMETHODCALLTYPE *Close )( + ID3D12GraphicsCommandList3 * This); + + HRESULT ( STDMETHODCALLTYPE *Reset )( + ID3D12GraphicsCommandList3 * This, + _In_ ID3D12CommandAllocator *pAllocator, + _In_opt_ ID3D12PipelineState *pInitialState); + + void ( STDMETHODCALLTYPE *ClearState )( + ID3D12GraphicsCommandList3 * This, + _In_opt_ ID3D12PipelineState *pPipelineState); + + void ( STDMETHODCALLTYPE *DrawInstanced )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT VertexCountPerInstance, + _In_ UINT InstanceCount, + _In_ UINT StartVertexLocation, + _In_ UINT StartInstanceLocation); + + void ( STDMETHODCALLTYPE *DrawIndexedInstanced )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT IndexCountPerInstance, + _In_ UINT InstanceCount, + _In_ UINT StartIndexLocation, + _In_ INT BaseVertexLocation, + _In_ UINT StartInstanceLocation); + + void ( STDMETHODCALLTYPE *Dispatch )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT ThreadGroupCountX, + _In_ UINT ThreadGroupCountY, + _In_ UINT ThreadGroupCountZ); + + void ( STDMETHODCALLTYPE *CopyBufferRegion )( + ID3D12GraphicsCommandList3 * This, + _In_ ID3D12Resource *pDstBuffer, + UINT64 DstOffset, + _In_ ID3D12Resource *pSrcBuffer, + UINT64 SrcOffset, + UINT64 NumBytes); + + void ( STDMETHODCALLTYPE *CopyTextureRegion )( + ID3D12GraphicsCommandList3 * This, + _In_ const D3D12_TEXTURE_COPY_LOCATION *pDst, + UINT DstX, + UINT DstY, + UINT DstZ, + _In_ const D3D12_TEXTURE_COPY_LOCATION *pSrc, + _In_opt_ const D3D12_BOX *pSrcBox); + + void ( STDMETHODCALLTYPE *CopyResource )( + ID3D12GraphicsCommandList3 * This, + _In_ ID3D12Resource *pDstResource, + _In_ ID3D12Resource *pSrcResource); + + void ( STDMETHODCALLTYPE *CopyTiles )( + ID3D12GraphicsCommandList3 * This, + _In_ ID3D12Resource *pTiledResource, + _In_ const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate, + _In_ const D3D12_TILE_REGION_SIZE *pTileRegionSize, + _In_ ID3D12Resource *pBuffer, + UINT64 BufferStartOffsetInBytes, + D3D12_TILE_COPY_FLAGS Flags); + + void ( STDMETHODCALLTYPE *ResolveSubresource )( + ID3D12GraphicsCommandList3 * This, + _In_ ID3D12Resource *pDstResource, + _In_ UINT DstSubresource, + _In_ ID3D12Resource *pSrcResource, + _In_ UINT SrcSubresource, + _In_ DXGI_FORMAT Format); + + void ( STDMETHODCALLTYPE *IASetPrimitiveTopology )( + ID3D12GraphicsCommandList3 * This, + _In_ D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology); + + void ( STDMETHODCALLTYPE *RSSetViewports )( + ID3D12GraphicsCommandList3 * This, + _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumViewports, + _In_reads_( NumViewports) const D3D12_VIEWPORT *pViewports); + + void ( STDMETHODCALLTYPE *RSSetScissorRects )( + ID3D12GraphicsCommandList3 * This, + _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumRects, + _In_reads_( NumRects) const D3D12_RECT *pRects); + + void ( STDMETHODCALLTYPE *OMSetBlendFactor )( + ID3D12GraphicsCommandList3 * This, + _In_reads_opt_(4) const FLOAT BlendFactor[ 4 ]); + + void ( STDMETHODCALLTYPE *OMSetStencilRef )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT StencilRef); + + void ( STDMETHODCALLTYPE *SetPipelineState )( + ID3D12GraphicsCommandList3 * This, + _In_ ID3D12PipelineState *pPipelineState); + + void ( STDMETHODCALLTYPE *ResourceBarrier )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT NumBarriers, + _In_reads_(NumBarriers) const D3D12_RESOURCE_BARRIER *pBarriers); + + void ( STDMETHODCALLTYPE *ExecuteBundle )( + ID3D12GraphicsCommandList3 * This, + _In_ ID3D12GraphicsCommandList *pCommandList); + + void ( STDMETHODCALLTYPE *SetDescriptorHeaps )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT NumDescriptorHeaps, + _In_reads_(NumDescriptorHeaps) ID3D12DescriptorHeap *const *ppDescriptorHeaps); + + void ( STDMETHODCALLTYPE *SetComputeRootSignature )( + ID3D12GraphicsCommandList3 * This, + _In_opt_ ID3D12RootSignature *pRootSignature); + + void ( STDMETHODCALLTYPE *SetGraphicsRootSignature )( + ID3D12GraphicsCommandList3 * This, + _In_opt_ ID3D12RootSignature *pRootSignature); + + void ( STDMETHODCALLTYPE *SetComputeRootDescriptorTable )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); + + void ( STDMETHODCALLTYPE *SetGraphicsRootDescriptorTable )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); + + void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstant )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT RootParameterIndex, + _In_ UINT SrcData, + _In_ UINT DestOffsetIn32BitValues); + + void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstant )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT RootParameterIndex, + _In_ UINT SrcData, + _In_ UINT DestOffsetIn32BitValues); + + void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstants )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT RootParameterIndex, + _In_ UINT Num32BitValuesToSet, + _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, + _In_ UINT DestOffsetIn32BitValues); + + void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstants )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT RootParameterIndex, + _In_ UINT Num32BitValuesToSet, + _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, + _In_ UINT DestOffsetIn32BitValues); + + void ( STDMETHODCALLTYPE *SetComputeRootConstantBufferView )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *SetGraphicsRootConstantBufferView )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *SetComputeRootShaderResourceView )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *SetGraphicsRootShaderResourceView )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *SetComputeRootUnorderedAccessView )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *SetGraphicsRootUnorderedAccessView )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *IASetIndexBuffer )( + ID3D12GraphicsCommandList3 * This, + _In_opt_ const D3D12_INDEX_BUFFER_VIEW *pView); + + void ( STDMETHODCALLTYPE *IASetVertexBuffers )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT StartSlot, + _In_ UINT NumViews, + _In_reads_opt_(NumViews) const D3D12_VERTEX_BUFFER_VIEW *pViews); + + void ( STDMETHODCALLTYPE *SOSetTargets )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT StartSlot, + _In_ UINT NumViews, + _In_reads_opt_(NumViews) const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews); + + void ( STDMETHODCALLTYPE *OMSetRenderTargets )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT NumRenderTargetDescriptors, + _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors, + _In_ BOOL RTsSingleHandleToDescriptorRange, + _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pDepthStencilDescriptor); + + void ( STDMETHODCALLTYPE *ClearDepthStencilView )( + ID3D12GraphicsCommandList3 * This, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView, + _In_ D3D12_CLEAR_FLAGS ClearFlags, + _In_ FLOAT Depth, + _In_ UINT8 Stencil, + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); + + void ( STDMETHODCALLTYPE *ClearRenderTargetView )( + ID3D12GraphicsCommandList3 * This, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView, + _In_ const FLOAT ColorRGBA[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); + + void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewUint )( + ID3D12GraphicsCommandList3 * This, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, + _In_ ID3D12Resource *pResource, + _In_ const UINT Values[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); + + void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewFloat )( + ID3D12GraphicsCommandList3 * This, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, + _In_ ID3D12Resource *pResource, + _In_ const FLOAT Values[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); + + void ( STDMETHODCALLTYPE *DiscardResource )( + ID3D12GraphicsCommandList3 * This, + _In_ ID3D12Resource *pResource, + _In_opt_ const D3D12_DISCARD_REGION *pRegion); + + void ( STDMETHODCALLTYPE *BeginQuery )( + ID3D12GraphicsCommandList3 * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT Index); + + void ( STDMETHODCALLTYPE *EndQuery )( + ID3D12GraphicsCommandList3 * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT Index); + + void ( STDMETHODCALLTYPE *ResolveQueryData )( + ID3D12GraphicsCommandList3 * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT StartIndex, + _In_ UINT NumQueries, + _In_ ID3D12Resource *pDestinationBuffer, + _In_ UINT64 AlignedDestinationBufferOffset); + + void ( STDMETHODCALLTYPE *SetPredication )( + ID3D12GraphicsCommandList3 * This, + _In_opt_ ID3D12Resource *pBuffer, + _In_ UINT64 AlignedBufferOffset, + _In_ D3D12_PREDICATION_OP Operation); + + void ( STDMETHODCALLTYPE *SetMarker )( + ID3D12GraphicsCommandList3 * This, + UINT Metadata, + _In_reads_bytes_opt_(Size) const void *pData, + UINT Size); + + void ( STDMETHODCALLTYPE *BeginEvent )( + ID3D12GraphicsCommandList3 * This, + UINT Metadata, + _In_reads_bytes_opt_(Size) const void *pData, + UINT Size); + + void ( STDMETHODCALLTYPE *EndEvent )( + ID3D12GraphicsCommandList3 * This); + + void ( STDMETHODCALLTYPE *ExecuteIndirect )( + ID3D12GraphicsCommandList3 * This, + _In_ ID3D12CommandSignature *pCommandSignature, + _In_ UINT MaxCommandCount, + _In_ ID3D12Resource *pArgumentBuffer, + _In_ UINT64 ArgumentBufferOffset, + _In_opt_ ID3D12Resource *pCountBuffer, + _In_ UINT64 CountBufferOffset); + + void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT )( + ID3D12GraphicsCommandList3 * This, + _In_ ID3D12Resource *pDstBuffer, + UINT64 DstOffset, + _In_ ID3D12Resource *pSrcBuffer, + UINT64 SrcOffset, + UINT Dependencies, + _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, + _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); + + void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT64 )( + ID3D12GraphicsCommandList3 * This, + _In_ ID3D12Resource *pDstBuffer, + UINT64 DstOffset, + _In_ ID3D12Resource *pSrcBuffer, + UINT64 SrcOffset, + UINT Dependencies, + _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, + _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); + + void ( STDMETHODCALLTYPE *OMSetDepthBounds )( + ID3D12GraphicsCommandList3 * This, + _In_ FLOAT Min, + _In_ FLOAT Max); + + void ( STDMETHODCALLTYPE *SetSamplePositions )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT NumSamplesPerPixel, + _In_ UINT NumPixels, + _In_reads_(NumSamplesPerPixel*NumPixels) D3D12_SAMPLE_POSITION *pSamplePositions); + + void ( STDMETHODCALLTYPE *ResolveSubresourceRegion )( + ID3D12GraphicsCommandList3 * This, + _In_ ID3D12Resource *pDstResource, + _In_ UINT DstSubresource, + _In_ UINT DstX, + _In_ UINT DstY, + _In_ ID3D12Resource *pSrcResource, + _In_ UINT SrcSubresource, + _In_opt_ D3D12_RECT *pSrcRect, + _In_ DXGI_FORMAT Format, + _In_ D3D12_RESOLVE_MODE ResolveMode); + + void ( STDMETHODCALLTYPE *SetViewInstanceMask )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT Mask); + + void ( STDMETHODCALLTYPE *WriteBufferImmediate )( + ID3D12GraphicsCommandList3 * This, + UINT Count, + _In_reads_(Count) const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams, + _In_reads_opt_(Count) const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes); + + void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( + ID3D12GraphicsCommandList3 * This, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedResourceSession); + + END_INTERFACE + } ID3D12GraphicsCommandList3Vtbl; + + interface ID3D12GraphicsCommandList3 + { + CONST_VTBL struct ID3D12GraphicsCommandList3Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12GraphicsCommandList3_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12GraphicsCommandList3_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12GraphicsCommandList3_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12GraphicsCommandList3_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12GraphicsCommandList3_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12GraphicsCommandList3_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12GraphicsCommandList3_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12GraphicsCommandList3_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + +#define ID3D12GraphicsCommandList3_GetType(This) \ + ( (This)->lpVtbl -> GetType(This) ) + + +#define ID3D12GraphicsCommandList3_Close(This) \ + ( (This)->lpVtbl -> Close(This) ) + +#define ID3D12GraphicsCommandList3_Reset(This,pAllocator,pInitialState) \ + ( (This)->lpVtbl -> Reset(This,pAllocator,pInitialState) ) + +#define ID3D12GraphicsCommandList3_ClearState(This,pPipelineState) \ + ( (This)->lpVtbl -> ClearState(This,pPipelineState) ) + +#define ID3D12GraphicsCommandList3_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) \ + ( (This)->lpVtbl -> DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) ) + +#define ID3D12GraphicsCommandList3_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) \ + ( (This)->lpVtbl -> DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) ) + +#define ID3D12GraphicsCommandList3_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ + ( (This)->lpVtbl -> Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) + +#define ID3D12GraphicsCommandList3_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) \ + ( (This)->lpVtbl -> CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) ) + +#define ID3D12GraphicsCommandList3_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) \ + ( (This)->lpVtbl -> CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) ) + +#define ID3D12GraphicsCommandList3_CopyResource(This,pDstResource,pSrcResource) \ + ( (This)->lpVtbl -> CopyResource(This,pDstResource,pSrcResource) ) + +#define ID3D12GraphicsCommandList3_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) \ + ( (This)->lpVtbl -> CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) ) + +#define ID3D12GraphicsCommandList3_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) \ + ( (This)->lpVtbl -> ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) ) + +#define ID3D12GraphicsCommandList3_IASetPrimitiveTopology(This,PrimitiveTopology) \ + ( (This)->lpVtbl -> IASetPrimitiveTopology(This,PrimitiveTopology) ) + +#define ID3D12GraphicsCommandList3_RSSetViewports(This,NumViewports,pViewports) \ + ( (This)->lpVtbl -> RSSetViewports(This,NumViewports,pViewports) ) + +#define ID3D12GraphicsCommandList3_RSSetScissorRects(This,NumRects,pRects) \ + ( (This)->lpVtbl -> RSSetScissorRects(This,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList3_OMSetBlendFactor(This,BlendFactor) \ + ( (This)->lpVtbl -> OMSetBlendFactor(This,BlendFactor) ) + +#define ID3D12GraphicsCommandList3_OMSetStencilRef(This,StencilRef) \ + ( (This)->lpVtbl -> OMSetStencilRef(This,StencilRef) ) + +#define ID3D12GraphicsCommandList3_SetPipelineState(This,pPipelineState) \ + ( (This)->lpVtbl -> SetPipelineState(This,pPipelineState) ) + +#define ID3D12GraphicsCommandList3_ResourceBarrier(This,NumBarriers,pBarriers) \ + ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) + +#define ID3D12GraphicsCommandList3_ExecuteBundle(This,pCommandList) \ + ( (This)->lpVtbl -> ExecuteBundle(This,pCommandList) ) + +#define ID3D12GraphicsCommandList3_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) \ + ( (This)->lpVtbl -> SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) ) + +#define ID3D12GraphicsCommandList3_SetComputeRootSignature(This,pRootSignature) \ + ( (This)->lpVtbl -> SetComputeRootSignature(This,pRootSignature) ) + +#define ID3D12GraphicsCommandList3_SetGraphicsRootSignature(This,pRootSignature) \ + ( (This)->lpVtbl -> SetGraphicsRootSignature(This,pRootSignature) ) + +#define ID3D12GraphicsCommandList3_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ + ( (This)->lpVtbl -> SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) + +#define ID3D12GraphicsCommandList3_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ + ( (This)->lpVtbl -> SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) + +#define ID3D12GraphicsCommandList3_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) + +#define ID3D12GraphicsCommandList3_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) + +#define ID3D12GraphicsCommandList3_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) + +#define ID3D12GraphicsCommandList3_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) + +#define ID3D12GraphicsCommandList3_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList3_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList3_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList3_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList3_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList3_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList3_IASetIndexBuffer(This,pView) \ + ( (This)->lpVtbl -> IASetIndexBuffer(This,pView) ) + +#define ID3D12GraphicsCommandList3_IASetVertexBuffers(This,StartSlot,NumViews,pViews) \ + ( (This)->lpVtbl -> IASetVertexBuffers(This,StartSlot,NumViews,pViews) ) + +#define ID3D12GraphicsCommandList3_SOSetTargets(This,StartSlot,NumViews,pViews) \ + ( (This)->lpVtbl -> SOSetTargets(This,StartSlot,NumViews,pViews) ) + +#define ID3D12GraphicsCommandList3_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) \ + ( (This)->lpVtbl -> OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) ) + +#define ID3D12GraphicsCommandList3_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList3_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList3_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList3_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList3_DiscardResource(This,pResource,pRegion) \ + ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) + +#define ID3D12GraphicsCommandList3_BeginQuery(This,pQueryHeap,Type,Index) \ + ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) + +#define ID3D12GraphicsCommandList3_EndQuery(This,pQueryHeap,Type,Index) \ + ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) + +#define ID3D12GraphicsCommandList3_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) \ + ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) + +#define ID3D12GraphicsCommandList3_SetPredication(This,pBuffer,AlignedBufferOffset,Operation) \ + ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) + +#define ID3D12GraphicsCommandList3_SetMarker(This,Metadata,pData,Size) \ + ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) + +#define ID3D12GraphicsCommandList3_BeginEvent(This,Metadata,pData,Size) \ + ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) + +#define ID3D12GraphicsCommandList3_EndEvent(This) \ + ( (This)->lpVtbl -> EndEvent(This) ) + +#define ID3D12GraphicsCommandList3_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) \ + ( (This)->lpVtbl -> ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) ) + + +#define ID3D12GraphicsCommandList3_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ + ( (This)->lpVtbl -> AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) + +#define ID3D12GraphicsCommandList3_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ + ( (This)->lpVtbl -> AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) + +#define ID3D12GraphicsCommandList3_OMSetDepthBounds(This,Min,Max) \ + ( (This)->lpVtbl -> OMSetDepthBounds(This,Min,Max) ) + +#define ID3D12GraphicsCommandList3_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) \ + ( (This)->lpVtbl -> SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) ) + +#define ID3D12GraphicsCommandList3_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) \ + ( (This)->lpVtbl -> ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) ) + +#define ID3D12GraphicsCommandList3_SetViewInstanceMask(This,Mask) \ + ( (This)->lpVtbl -> SetViewInstanceMask(This,Mask) ) + + +#define ID3D12GraphicsCommandList3_WriteBufferImmediate(This,Count,pParams,pModes) \ + ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) + + +#define ID3D12GraphicsCommandList3_SetProtectedResourceSession(This,pProtectedResourceSession) \ + ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12GraphicsCommandList3_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12_0000_0041 */ +/* [local] */ + +typedef +enum D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE + { + D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_DISCARD = 0, + D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE = ( D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_DISCARD + 1 ) , + D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR = ( D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE + 1 ) , + D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_NO_ACCESS = ( D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR + 1 ) + } D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE; + +typedef struct D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS + { + D3D12_CLEAR_VALUE ClearValue; + } D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS; + +typedef struct D3D12_RENDER_PASS_BEGINNING_ACCESS + { + D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE Type; + union + { + D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS Clear; + } ; + } D3D12_RENDER_PASS_BEGINNING_ACCESS; + +typedef +enum D3D12_RENDER_PASS_ENDING_ACCESS_TYPE + { + D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_DISCARD = 0, + D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE = ( D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_DISCARD + 1 ) , + D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_RESOLVE = ( D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE + 1 ) , + D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_NO_ACCESS = ( D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_RESOLVE + 1 ) + } D3D12_RENDER_PASS_ENDING_ACCESS_TYPE; + +typedef struct D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS + { + UINT SrcSubresource; + UINT DstSubresource; + UINT DstX; + UINT DstY; + D3D12_RECT SrcRect; + } D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS; + +typedef struct D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS + { + ID3D12Resource *pSrcResource; + ID3D12Resource *pDstResource; + UINT SubresourceCount; + _Field_size_full_(SubresourceCount) const D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS *pSubresourceParameters; + DXGI_FORMAT Format; + D3D12_RESOLVE_MODE ResolveMode; + BOOL PreserveResolveSource; + } D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS; + +typedef struct D3D12_RENDER_PASS_ENDING_ACCESS + { + D3D12_RENDER_PASS_ENDING_ACCESS_TYPE Type; + union + { + D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS Resolve; + } ; + } D3D12_RENDER_PASS_ENDING_ACCESS; + +typedef struct D3D12_RENDER_PASS_RENDER_TARGET_DESC + { + D3D12_CPU_DESCRIPTOR_HANDLE cpuDescriptor; + D3D12_RENDER_PASS_BEGINNING_ACCESS BeginningAccess; + D3D12_RENDER_PASS_ENDING_ACCESS EndingAccess; + } D3D12_RENDER_PASS_RENDER_TARGET_DESC; + +typedef struct D3D12_RENDER_PASS_DEPTH_STENCIL_DESC + { + D3D12_CPU_DESCRIPTOR_HANDLE cpuDescriptor; + D3D12_RENDER_PASS_BEGINNING_ACCESS DepthBeginningAccess; + D3D12_RENDER_PASS_BEGINNING_ACCESS StencilBeginningAccess; + D3D12_RENDER_PASS_ENDING_ACCESS DepthEndingAccess; + D3D12_RENDER_PASS_ENDING_ACCESS StencilEndingAccess; + } D3D12_RENDER_PASS_DEPTH_STENCIL_DESC; + +typedef +enum D3D12_RENDER_PASS_FLAGS + { + D3D12_RENDER_PASS_FLAG_NONE = 0, + D3D12_RENDER_PASS_FLAG_ALLOW_UAV_WRITES = 0x1, + D3D12_RENDER_PASS_FLAG_SUSPENDING_PASS = 0x2, + D3D12_RENDER_PASS_FLAG_RESUMING_PASS = 0x4 + } D3D12_RENDER_PASS_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_RENDER_PASS_FLAGS ); + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0041_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0041_v0_0_s_ifspec; + +#ifndef __ID3D12MetaCommand_INTERFACE_DEFINED__ +#define __ID3D12MetaCommand_INTERFACE_DEFINED__ + +/* interface ID3D12MetaCommand */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12MetaCommand; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("DBB84C27-36CE-4FC9-B801-F048C46AC570") + ID3D12MetaCommand : public ID3D12Pageable + { + public: + virtual UINT64 STDMETHODCALLTYPE GetRequiredParameterResourceSize( + _In_ D3D12_META_COMMAND_PARAMETER_STAGE Stage, + _In_ UINT ParameterIndex) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12MetaCommandVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12MetaCommand * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12MetaCommand * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12MetaCommand * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12MetaCommand * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12MetaCommand * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12MetaCommand * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12MetaCommand * This, + _In_z_ LPCWSTR Name); + + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12MetaCommand * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + UINT64 ( STDMETHODCALLTYPE *GetRequiredParameterResourceSize )( + ID3D12MetaCommand * This, + _In_ D3D12_META_COMMAND_PARAMETER_STAGE Stage, + _In_ UINT ParameterIndex); + + END_INTERFACE + } ID3D12MetaCommandVtbl; + + interface ID3D12MetaCommand + { + CONST_VTBL struct ID3D12MetaCommandVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12MetaCommand_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12MetaCommand_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12MetaCommand_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12MetaCommand_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12MetaCommand_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12MetaCommand_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12MetaCommand_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12MetaCommand_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + + +#define ID3D12MetaCommand_GetRequiredParameterResourceSize(This,Stage,ParameterIndex) \ + ( (This)->lpVtbl -> GetRequiredParameterResourceSize(This,Stage,ParameterIndex) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12MetaCommand_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12_0000_0042 */ +/* [local] */ + +typedef struct D3D12_DISPATCH_RAYS_DESC + { + D3D12_GPU_VIRTUAL_ADDRESS_RANGE RayGenerationShaderRecord; + D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE MissShaderTable; + D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE HitGroupTable; + D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE CallableShaderTable; + UINT Width; + UINT Height; + UINT Depth; + } D3D12_DISPATCH_RAYS_DESC; + + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0042_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0042_v0_0_s_ifspec; + +#ifndef __ID3D12GraphicsCommandList4_INTERFACE_DEFINED__ +#define __ID3D12GraphicsCommandList4_INTERFACE_DEFINED__ + +/* interface ID3D12GraphicsCommandList4 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12GraphicsCommandList4; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("8754318e-d3a9-4541-98cf-645b50dc4874") + ID3D12GraphicsCommandList4 : public ID3D12GraphicsCommandList3 + { + public: + virtual void STDMETHODCALLTYPE BeginRenderPass( + _In_ UINT NumRenderTargets, + _In_reads_opt_(NumRenderTargets) const D3D12_RENDER_PASS_RENDER_TARGET_DESC *pRenderTargets, + _In_opt_ const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *pDepthStencil, + D3D12_RENDER_PASS_FLAGS Flags) = 0; + + virtual void STDMETHODCALLTYPE EndRenderPass( void) = 0; + + virtual void STDMETHODCALLTYPE InitializeMetaCommand( + _In_ ID3D12MetaCommand *pMetaCommand, + _In_reads_bytes_opt_(InitializationParametersDataSizeInBytes) const void *pInitializationParametersData, + _In_ SIZE_T InitializationParametersDataSizeInBytes) = 0; + + virtual void STDMETHODCALLTYPE ExecuteMetaCommand( + _In_ ID3D12MetaCommand *pMetaCommand, + _In_reads_bytes_opt_(ExecutionParametersDataSizeInBytes) const void *pExecutionParametersData, + _In_ SIZE_T ExecutionParametersDataSizeInBytes) = 0; + + virtual void STDMETHODCALLTYPE BuildRaytracingAccelerationStructure( + _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC *pDesc, + _In_ UINT NumPostbuildInfoDescs, + _In_reads_opt_(NumPostbuildInfoDescs) const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pPostbuildInfoDescs) = 0; + + virtual void STDMETHODCALLTYPE EmitRaytracingAccelerationStructurePostbuildInfo( + _In_ const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pDesc, + _In_ UINT NumSourceAccelerationStructures, + _In_reads_( NumSourceAccelerationStructures ) const D3D12_GPU_VIRTUAL_ADDRESS *pSourceAccelerationStructureData) = 0; + + virtual void STDMETHODCALLTYPE CopyRaytracingAccelerationStructure( + _In_ D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData, + _In_ D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData, + _In_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE Mode) = 0; + + virtual void STDMETHODCALLTYPE SetPipelineState1( + _In_ ID3D12StateObject *pStateObject) = 0; + + virtual void STDMETHODCALLTYPE DispatchRays( + _In_ const D3D12_DISPATCH_RAYS_DESC *pDesc) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12GraphicsCommandList4Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12GraphicsCommandList4 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12GraphicsCommandList4 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12GraphicsCommandList4 * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12GraphicsCommandList4 * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12GraphicsCommandList4 * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12GraphicsCommandList4 * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12GraphicsCommandList4 * This, + _In_z_ LPCWSTR Name); + + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12GraphicsCommandList4 * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( + ID3D12GraphicsCommandList4 * This); + + HRESULT ( STDMETHODCALLTYPE *Close )( + ID3D12GraphicsCommandList4 * This); + + HRESULT ( STDMETHODCALLTYPE *Reset )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12CommandAllocator *pAllocator, + _In_opt_ ID3D12PipelineState *pInitialState); + + void ( STDMETHODCALLTYPE *ClearState )( + ID3D12GraphicsCommandList4 * This, + _In_opt_ ID3D12PipelineState *pPipelineState); + + void ( STDMETHODCALLTYPE *DrawInstanced )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT VertexCountPerInstance, + _In_ UINT InstanceCount, + _In_ UINT StartVertexLocation, + _In_ UINT StartInstanceLocation); + + void ( STDMETHODCALLTYPE *DrawIndexedInstanced )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT IndexCountPerInstance, + _In_ UINT InstanceCount, + _In_ UINT StartIndexLocation, + _In_ INT BaseVertexLocation, + _In_ UINT StartInstanceLocation); + + void ( STDMETHODCALLTYPE *Dispatch )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT ThreadGroupCountX, + _In_ UINT ThreadGroupCountY, + _In_ UINT ThreadGroupCountZ); + + void ( STDMETHODCALLTYPE *CopyBufferRegion )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12Resource *pDstBuffer, + UINT64 DstOffset, + _In_ ID3D12Resource *pSrcBuffer, + UINT64 SrcOffset, + UINT64 NumBytes); + + void ( STDMETHODCALLTYPE *CopyTextureRegion )( + ID3D12GraphicsCommandList4 * This, + _In_ const D3D12_TEXTURE_COPY_LOCATION *pDst, + UINT DstX, + UINT DstY, + UINT DstZ, + _In_ const D3D12_TEXTURE_COPY_LOCATION *pSrc, + _In_opt_ const D3D12_BOX *pSrcBox); + + void ( STDMETHODCALLTYPE *CopyResource )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12Resource *pDstResource, + _In_ ID3D12Resource *pSrcResource); + + void ( STDMETHODCALLTYPE *CopyTiles )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12Resource *pTiledResource, + _In_ const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate, + _In_ const D3D12_TILE_REGION_SIZE *pTileRegionSize, + _In_ ID3D12Resource *pBuffer, + UINT64 BufferStartOffsetInBytes, + D3D12_TILE_COPY_FLAGS Flags); + + void ( STDMETHODCALLTYPE *ResolveSubresource )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12Resource *pDstResource, + _In_ UINT DstSubresource, + _In_ ID3D12Resource *pSrcResource, + _In_ UINT SrcSubresource, + _In_ DXGI_FORMAT Format); + + void ( STDMETHODCALLTYPE *IASetPrimitiveTopology )( + ID3D12GraphicsCommandList4 * This, + _In_ D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology); + + void ( STDMETHODCALLTYPE *RSSetViewports )( + ID3D12GraphicsCommandList4 * This, + _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumViewports, + _In_reads_( NumViewports) const D3D12_VIEWPORT *pViewports); + + void ( STDMETHODCALLTYPE *RSSetScissorRects )( + ID3D12GraphicsCommandList4 * This, + _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumRects, + _In_reads_( NumRects) const D3D12_RECT *pRects); + + void ( STDMETHODCALLTYPE *OMSetBlendFactor )( + ID3D12GraphicsCommandList4 * This, + _In_reads_opt_(4) const FLOAT BlendFactor[ 4 ]); + + void ( STDMETHODCALLTYPE *OMSetStencilRef )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT StencilRef); + + void ( STDMETHODCALLTYPE *SetPipelineState )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12PipelineState *pPipelineState); + + void ( STDMETHODCALLTYPE *ResourceBarrier )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT NumBarriers, + _In_reads_(NumBarriers) const D3D12_RESOURCE_BARRIER *pBarriers); + + void ( STDMETHODCALLTYPE *ExecuteBundle )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12GraphicsCommandList *pCommandList); + + void ( STDMETHODCALLTYPE *SetDescriptorHeaps )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT NumDescriptorHeaps, + _In_reads_(NumDescriptorHeaps) ID3D12DescriptorHeap *const *ppDescriptorHeaps); + + void ( STDMETHODCALLTYPE *SetComputeRootSignature )( + ID3D12GraphicsCommandList4 * This, + _In_opt_ ID3D12RootSignature *pRootSignature); + + void ( STDMETHODCALLTYPE *SetGraphicsRootSignature )( + ID3D12GraphicsCommandList4 * This, + _In_opt_ ID3D12RootSignature *pRootSignature); + + void ( STDMETHODCALLTYPE *SetComputeRootDescriptorTable )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); + + void ( STDMETHODCALLTYPE *SetGraphicsRootDescriptorTable )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); + + void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstant )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT RootParameterIndex, + _In_ UINT SrcData, + _In_ UINT DestOffsetIn32BitValues); + + void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstant )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT RootParameterIndex, + _In_ UINT SrcData, + _In_ UINT DestOffsetIn32BitValues); + + void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstants )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT RootParameterIndex, + _In_ UINT Num32BitValuesToSet, + _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, + _In_ UINT DestOffsetIn32BitValues); + + void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstants )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT RootParameterIndex, + _In_ UINT Num32BitValuesToSet, + _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, + _In_ UINT DestOffsetIn32BitValues); + + void ( STDMETHODCALLTYPE *SetComputeRootConstantBufferView )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *SetGraphicsRootConstantBufferView )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *SetComputeRootShaderResourceView )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *SetGraphicsRootShaderResourceView )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *SetComputeRootUnorderedAccessView )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *SetGraphicsRootUnorderedAccessView )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *IASetIndexBuffer )( + ID3D12GraphicsCommandList4 * This, + _In_opt_ const D3D12_INDEX_BUFFER_VIEW *pView); + + void ( STDMETHODCALLTYPE *IASetVertexBuffers )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT StartSlot, + _In_ UINT NumViews, + _In_reads_opt_(NumViews) const D3D12_VERTEX_BUFFER_VIEW *pViews); + + void ( STDMETHODCALLTYPE *SOSetTargets )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT StartSlot, + _In_ UINT NumViews, + _In_reads_opt_(NumViews) const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews); + + void ( STDMETHODCALLTYPE *OMSetRenderTargets )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT NumRenderTargetDescriptors, + _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors, + _In_ BOOL RTsSingleHandleToDescriptorRange, + _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pDepthStencilDescriptor); + + void ( STDMETHODCALLTYPE *ClearDepthStencilView )( + ID3D12GraphicsCommandList4 * This, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView, + _In_ D3D12_CLEAR_FLAGS ClearFlags, + _In_ FLOAT Depth, + _In_ UINT8 Stencil, + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); + + void ( STDMETHODCALLTYPE *ClearRenderTargetView )( + ID3D12GraphicsCommandList4 * This, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView, + _In_ const FLOAT ColorRGBA[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); + + void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewUint )( + ID3D12GraphicsCommandList4 * This, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, + _In_ ID3D12Resource *pResource, + _In_ const UINT Values[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); + + void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewFloat )( + ID3D12GraphicsCommandList4 * This, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, + _In_ ID3D12Resource *pResource, + _In_ const FLOAT Values[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); + + void ( STDMETHODCALLTYPE *DiscardResource )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12Resource *pResource, + _In_opt_ const D3D12_DISCARD_REGION *pRegion); + + void ( STDMETHODCALLTYPE *BeginQuery )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT Index); + + void ( STDMETHODCALLTYPE *EndQuery )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT Index); + + void ( STDMETHODCALLTYPE *ResolveQueryData )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT StartIndex, + _In_ UINT NumQueries, + _In_ ID3D12Resource *pDestinationBuffer, + _In_ UINT64 AlignedDestinationBufferOffset); + + void ( STDMETHODCALLTYPE *SetPredication )( + ID3D12GraphicsCommandList4 * This, + _In_opt_ ID3D12Resource *pBuffer, + _In_ UINT64 AlignedBufferOffset, + _In_ D3D12_PREDICATION_OP Operation); + + void ( STDMETHODCALLTYPE *SetMarker )( + ID3D12GraphicsCommandList4 * This, + UINT Metadata, + _In_reads_bytes_opt_(Size) const void *pData, + UINT Size); + + void ( STDMETHODCALLTYPE *BeginEvent )( + ID3D12GraphicsCommandList4 * This, + UINT Metadata, + _In_reads_bytes_opt_(Size) const void *pData, + UINT Size); + + void ( STDMETHODCALLTYPE *EndEvent )( + ID3D12GraphicsCommandList4 * This); + + void ( STDMETHODCALLTYPE *ExecuteIndirect )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12CommandSignature *pCommandSignature, + _In_ UINT MaxCommandCount, + _In_ ID3D12Resource *pArgumentBuffer, + _In_ UINT64 ArgumentBufferOffset, + _In_opt_ ID3D12Resource *pCountBuffer, + _In_ UINT64 CountBufferOffset); + + void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12Resource *pDstBuffer, + UINT64 DstOffset, + _In_ ID3D12Resource *pSrcBuffer, + UINT64 SrcOffset, + UINT Dependencies, + _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, + _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); + + void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT64 )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12Resource *pDstBuffer, + UINT64 DstOffset, + _In_ ID3D12Resource *pSrcBuffer, + UINT64 SrcOffset, + UINT Dependencies, + _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, + _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); + + void ( STDMETHODCALLTYPE *OMSetDepthBounds )( + ID3D12GraphicsCommandList4 * This, + _In_ FLOAT Min, + _In_ FLOAT Max); + + void ( STDMETHODCALLTYPE *SetSamplePositions )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT NumSamplesPerPixel, + _In_ UINT NumPixels, + _In_reads_(NumSamplesPerPixel*NumPixels) D3D12_SAMPLE_POSITION *pSamplePositions); + + void ( STDMETHODCALLTYPE *ResolveSubresourceRegion )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12Resource *pDstResource, + _In_ UINT DstSubresource, + _In_ UINT DstX, + _In_ UINT DstY, + _In_ ID3D12Resource *pSrcResource, + _In_ UINT SrcSubresource, + _In_opt_ D3D12_RECT *pSrcRect, + _In_ DXGI_FORMAT Format, + _In_ D3D12_RESOLVE_MODE ResolveMode); + + void ( STDMETHODCALLTYPE *SetViewInstanceMask )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT Mask); + + void ( STDMETHODCALLTYPE *WriteBufferImmediate )( + ID3D12GraphicsCommandList4 * This, + UINT Count, + _In_reads_(Count) const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams, + _In_reads_opt_(Count) const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes); + + void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( + ID3D12GraphicsCommandList4 * This, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedResourceSession); + + void ( STDMETHODCALLTYPE *BeginRenderPass )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT NumRenderTargets, + _In_reads_opt_(NumRenderTargets) const D3D12_RENDER_PASS_RENDER_TARGET_DESC *pRenderTargets, + _In_opt_ const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *pDepthStencil, + D3D12_RENDER_PASS_FLAGS Flags); + + void ( STDMETHODCALLTYPE *EndRenderPass )( + ID3D12GraphicsCommandList4 * This); + + void ( STDMETHODCALLTYPE *InitializeMetaCommand )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12MetaCommand *pMetaCommand, + _In_reads_bytes_opt_(InitializationParametersDataSizeInBytes) const void *pInitializationParametersData, + _In_ SIZE_T InitializationParametersDataSizeInBytes); + + void ( STDMETHODCALLTYPE *ExecuteMetaCommand )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12MetaCommand *pMetaCommand, + _In_reads_bytes_opt_(ExecutionParametersDataSizeInBytes) const void *pExecutionParametersData, + _In_ SIZE_T ExecutionParametersDataSizeInBytes); + + void ( STDMETHODCALLTYPE *BuildRaytracingAccelerationStructure )( + ID3D12GraphicsCommandList4 * This, + _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC *pDesc, + _In_ UINT NumPostbuildInfoDescs, + _In_reads_opt_(NumPostbuildInfoDescs) const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pPostbuildInfoDescs); + + void ( STDMETHODCALLTYPE *EmitRaytracingAccelerationStructurePostbuildInfo )( + ID3D12GraphicsCommandList4 * This, + _In_ const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pDesc, + _In_ UINT NumSourceAccelerationStructures, + _In_reads_( NumSourceAccelerationStructures ) const D3D12_GPU_VIRTUAL_ADDRESS *pSourceAccelerationStructureData); + + void ( STDMETHODCALLTYPE *CopyRaytracingAccelerationStructure )( + ID3D12GraphicsCommandList4 * This, + _In_ D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData, + _In_ D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData, + _In_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE Mode); + + void ( STDMETHODCALLTYPE *SetPipelineState1 )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12StateObject *pStateObject); + + void ( STDMETHODCALLTYPE *DispatchRays )( + ID3D12GraphicsCommandList4 * This, + _In_ const D3D12_DISPATCH_RAYS_DESC *pDesc); + + END_INTERFACE + } ID3D12GraphicsCommandList4Vtbl; + + interface ID3D12GraphicsCommandList4 + { + CONST_VTBL struct ID3D12GraphicsCommandList4Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12GraphicsCommandList4_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12GraphicsCommandList4_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12GraphicsCommandList4_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12GraphicsCommandList4_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12GraphicsCommandList4_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12GraphicsCommandList4_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12GraphicsCommandList4_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12GraphicsCommandList4_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + +#define ID3D12GraphicsCommandList4_GetType(This) \ + ( (This)->lpVtbl -> GetType(This) ) + + +#define ID3D12GraphicsCommandList4_Close(This) \ + ( (This)->lpVtbl -> Close(This) ) + +#define ID3D12GraphicsCommandList4_Reset(This,pAllocator,pInitialState) \ + ( (This)->lpVtbl -> Reset(This,pAllocator,pInitialState) ) + +#define ID3D12GraphicsCommandList4_ClearState(This,pPipelineState) \ + ( (This)->lpVtbl -> ClearState(This,pPipelineState) ) + +#define ID3D12GraphicsCommandList4_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) \ + ( (This)->lpVtbl -> DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) ) + +#define ID3D12GraphicsCommandList4_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) \ + ( (This)->lpVtbl -> DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) ) + +#define ID3D12GraphicsCommandList4_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ + ( (This)->lpVtbl -> Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) + +#define ID3D12GraphicsCommandList4_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) \ + ( (This)->lpVtbl -> CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) ) + +#define ID3D12GraphicsCommandList4_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) \ + ( (This)->lpVtbl -> CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) ) + +#define ID3D12GraphicsCommandList4_CopyResource(This,pDstResource,pSrcResource) \ + ( (This)->lpVtbl -> CopyResource(This,pDstResource,pSrcResource) ) + +#define ID3D12GraphicsCommandList4_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) \ + ( (This)->lpVtbl -> CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) ) + +#define ID3D12GraphicsCommandList4_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) \ + ( (This)->lpVtbl -> ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) ) + +#define ID3D12GraphicsCommandList4_IASetPrimitiveTopology(This,PrimitiveTopology) \ + ( (This)->lpVtbl -> IASetPrimitiveTopology(This,PrimitiveTopology) ) + +#define ID3D12GraphicsCommandList4_RSSetViewports(This,NumViewports,pViewports) \ + ( (This)->lpVtbl -> RSSetViewports(This,NumViewports,pViewports) ) + +#define ID3D12GraphicsCommandList4_RSSetScissorRects(This,NumRects,pRects) \ + ( (This)->lpVtbl -> RSSetScissorRects(This,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList4_OMSetBlendFactor(This,BlendFactor) \ + ( (This)->lpVtbl -> OMSetBlendFactor(This,BlendFactor) ) + +#define ID3D12GraphicsCommandList4_OMSetStencilRef(This,StencilRef) \ + ( (This)->lpVtbl -> OMSetStencilRef(This,StencilRef) ) + +#define ID3D12GraphicsCommandList4_SetPipelineState(This,pPipelineState) \ + ( (This)->lpVtbl -> SetPipelineState(This,pPipelineState) ) + +#define ID3D12GraphicsCommandList4_ResourceBarrier(This,NumBarriers,pBarriers) \ + ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) + +#define ID3D12GraphicsCommandList4_ExecuteBundle(This,pCommandList) \ + ( (This)->lpVtbl -> ExecuteBundle(This,pCommandList) ) + +#define ID3D12GraphicsCommandList4_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) \ + ( (This)->lpVtbl -> SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) ) + +#define ID3D12GraphicsCommandList4_SetComputeRootSignature(This,pRootSignature) \ + ( (This)->lpVtbl -> SetComputeRootSignature(This,pRootSignature) ) + +#define ID3D12GraphicsCommandList4_SetGraphicsRootSignature(This,pRootSignature) \ + ( (This)->lpVtbl -> SetGraphicsRootSignature(This,pRootSignature) ) + +#define ID3D12GraphicsCommandList4_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ + ( (This)->lpVtbl -> SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) + +#define ID3D12GraphicsCommandList4_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ + ( (This)->lpVtbl -> SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) + +#define ID3D12GraphicsCommandList4_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) + +#define ID3D12GraphicsCommandList4_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) + +#define ID3D12GraphicsCommandList4_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) + +#define ID3D12GraphicsCommandList4_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) + +#define ID3D12GraphicsCommandList4_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList4_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList4_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList4_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList4_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList4_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList4_IASetIndexBuffer(This,pView) \ + ( (This)->lpVtbl -> IASetIndexBuffer(This,pView) ) + +#define ID3D12GraphicsCommandList4_IASetVertexBuffers(This,StartSlot,NumViews,pViews) \ + ( (This)->lpVtbl -> IASetVertexBuffers(This,StartSlot,NumViews,pViews) ) + +#define ID3D12GraphicsCommandList4_SOSetTargets(This,StartSlot,NumViews,pViews) \ + ( (This)->lpVtbl -> SOSetTargets(This,StartSlot,NumViews,pViews) ) + +#define ID3D12GraphicsCommandList4_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) \ + ( (This)->lpVtbl -> OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) ) + +#define ID3D12GraphicsCommandList4_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList4_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList4_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList4_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList4_DiscardResource(This,pResource,pRegion) \ + ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) + +#define ID3D12GraphicsCommandList4_BeginQuery(This,pQueryHeap,Type,Index) \ + ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) + +#define ID3D12GraphicsCommandList4_EndQuery(This,pQueryHeap,Type,Index) \ + ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) + +#define ID3D12GraphicsCommandList4_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) \ + ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) + +#define ID3D12GraphicsCommandList4_SetPredication(This,pBuffer,AlignedBufferOffset,Operation) \ + ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) + +#define ID3D12GraphicsCommandList4_SetMarker(This,Metadata,pData,Size) \ + ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) + +#define ID3D12GraphicsCommandList4_BeginEvent(This,Metadata,pData,Size) \ + ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) + +#define ID3D12GraphicsCommandList4_EndEvent(This) \ + ( (This)->lpVtbl -> EndEvent(This) ) + +#define ID3D12GraphicsCommandList4_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) \ + ( (This)->lpVtbl -> ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) ) + + +#define ID3D12GraphicsCommandList4_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ + ( (This)->lpVtbl -> AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) + +#define ID3D12GraphicsCommandList4_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ + ( (This)->lpVtbl -> AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) + +#define ID3D12GraphicsCommandList4_OMSetDepthBounds(This,Min,Max) \ + ( (This)->lpVtbl -> OMSetDepthBounds(This,Min,Max) ) + +#define ID3D12GraphicsCommandList4_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) \ + ( (This)->lpVtbl -> SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) ) + +#define ID3D12GraphicsCommandList4_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) \ + ( (This)->lpVtbl -> ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) ) + +#define ID3D12GraphicsCommandList4_SetViewInstanceMask(This,Mask) \ + ( (This)->lpVtbl -> SetViewInstanceMask(This,Mask) ) + + +#define ID3D12GraphicsCommandList4_WriteBufferImmediate(This,Count,pParams,pModes) \ + ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) + + +#define ID3D12GraphicsCommandList4_SetProtectedResourceSession(This,pProtectedResourceSession) \ + ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) + + +#define ID3D12GraphicsCommandList4_BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) \ + ( (This)->lpVtbl -> BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) ) + +#define ID3D12GraphicsCommandList4_EndRenderPass(This) \ + ( (This)->lpVtbl -> EndRenderPass(This) ) + +#define ID3D12GraphicsCommandList4_InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) \ + ( (This)->lpVtbl -> InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) ) + +#define ID3D12GraphicsCommandList4_ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) \ + ( (This)->lpVtbl -> ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) ) + +#define ID3D12GraphicsCommandList4_BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) \ + ( (This)->lpVtbl -> BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) ) + +#define ID3D12GraphicsCommandList4_EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) \ + ( (This)->lpVtbl -> EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) ) + +#define ID3D12GraphicsCommandList4_CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) \ + ( (This)->lpVtbl -> CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) ) + +#define ID3D12GraphicsCommandList4_SetPipelineState1(This,pStateObject) \ + ( (This)->lpVtbl -> SetPipelineState1(This,pStateObject) ) + +#define ID3D12GraphicsCommandList4_DispatchRays(This,pDesc) \ + ( (This)->lpVtbl -> DispatchRays(This,pDesc) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12GraphicsCommandList4_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12Tools_INTERFACE_DEFINED__ +#define __ID3D12Tools_INTERFACE_DEFINED__ + +/* interface ID3D12Tools */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12Tools; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("7071e1f0-e84b-4b33-974f-12fa49de65c5") + ID3D12Tools : public IUnknown + { + public: + virtual void STDMETHODCALLTYPE EnableShaderInstrumentation( + BOOL bEnable) = 0; + + virtual BOOL STDMETHODCALLTYPE ShaderInstrumentationEnabled( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12ToolsVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12Tools * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12Tools * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12Tools * This); + + void ( STDMETHODCALLTYPE *EnableShaderInstrumentation )( + ID3D12Tools * This, + BOOL bEnable); + + BOOL ( STDMETHODCALLTYPE *ShaderInstrumentationEnabled )( + ID3D12Tools * This); + + END_INTERFACE + } ID3D12ToolsVtbl; + + interface ID3D12Tools + { + CONST_VTBL struct ID3D12ToolsVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12Tools_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12Tools_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12Tools_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12Tools_EnableShaderInstrumentation(This,bEnable) \ + ( (This)->lpVtbl -> EnableShaderInstrumentation(This,bEnable) ) + +#define ID3D12Tools_ShaderInstrumentationEnabled(This) \ + ( (This)->lpVtbl -> ShaderInstrumentationEnabled(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12Tools_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12_0000_0044 */ +/* [local] */ + +typedef struct D3D12_SUBRESOURCE_DATA + { + const void *pData; + LONG_PTR RowPitch; + LONG_PTR SlicePitch; + } D3D12_SUBRESOURCE_DATA; + +typedef struct D3D12_MEMCPY_DEST + { + void *pData; + SIZE_T RowPitch; + SIZE_T SlicePitch; + } D3D12_MEMCPY_DEST; + +#if !defined( D3D12_IGNORE_SDK_LAYERS ) +#include "d3d12sdklayers.h" +#endif + +/////////////////////////////////////////////////////////////////////////// +// D3D12CreateDevice +// ------------------ +// +// pAdapter +// If NULL, D3D12CreateDevice will choose the primary adapter. +// If non-NULL, D3D12CreateDevice will use the provided adapter. +// MinimumFeatureLevel +// The minimum feature level required for successful device creation. +// riid +// The interface IID of the device to be returned. Expected: ID3D12Device. +// ppDevice +// Pointer to returned interface. May be NULL. +// +// Return Values +// Any of those documented for +// CreateDXGIFactory1 +// IDXGIFactory::EnumAdapters +// D3D12CreateDevice +// +/////////////////////////////////////////////////////////////////////////// +typedef HRESULT (WINAPI* PFN_D3D12_CREATE_DEVICE)( _In_opt_ IUnknown*, + D3D_FEATURE_LEVEL, + _In_ REFIID, _COM_Outptr_opt_ void** ); + +HRESULT WINAPI D3D12CreateDevice( + _In_opt_ IUnknown* pAdapter, + D3D_FEATURE_LEVEL MinimumFeatureLevel, + _In_ REFIID riid, // Expected: ID3D12Device + _COM_Outptr_opt_ void** ppDevice ); + + +typedef HRESULT (WINAPI* PFN_D3D12_GET_DEBUG_INTERFACE)( _In_ REFIID, _COM_Outptr_opt_ void** ); + +HRESULT WINAPI D3D12GetDebugInterface( _In_ REFIID riid, _COM_Outptr_opt_ void** ppvDebug ); + +// -------------------------------------------------------------------------------------------------------------------------------- +// D3D12EnableExperimentalFeatures +// +// Pass in a list of feature GUIDs to be enabled together. +// +// If a particular feature requires some configuration information on enablement, it will have +// a configuration struct that can be passed alongside the GUID. +// +// Some features might use an interface IID as the GUID. For these, once the feature is enabled via +// D3D12EnableExperimentalFeatures, D3D12GetDebugInterface can then be called with the IID to retrieve the interface +// for manipulating the feature. This allows for control that might not cleanly be expressed by just +// the configuration struct that D3D12EnableExperimentalFeatures provides. +// +// If this method is called and a change to existing feature enablement is made, +// all current D3D12 devices are set to DEVICE_REMOVED state, since under the covers there is really only one +// singleton device for a process. Removing the devices when configuration changes prevents +// mismatched expectations of how a device is supposed to work after it has been created from the app's point of view. +// +// The call returns E_NOINTERFACE if an unrecognized feature is passed in or Windows Developer mode is not on. +// The call returns E_INVALIDARG if the configuration of a feature is incorrect, the set of features passed +// in are known to be incompatible with each other, or other errors. +// Returns S_OK otherwise. +// +// -------------------------------------------------------------------------------------------------------------------------------- +HRESULT WINAPI D3D12EnableExperimentalFeatures( + UINT NumFeatures, + __in_ecount(NumFeatures) const IID* pIIDs, + __in_ecount_opt(NumFeatures) void* pConfigurationStructs, + __in_ecount_opt(NumFeatures) UINT* pConfigurationStructSizes); + +// -------------------------------------------------------------------------------------------------------------------------------- +// Experimental Feature: D3D12ExperimentalShaderModels +// +// Use with D3D12EnableExperimentalFeatures to enable experimental shader model support, +// meaning shader models that haven't been finalized for use in retail. +// +// Enabling D3D12ExperimentalShaderModels needs no configuration struct, pass NULL in the pConfigurationStructs array. +// +// -------------------------------------------------------------------------------------------------------------------------------- +static const UUID D3D12ExperimentalShaderModels = { /* 76f5573e-f13a-40f5-b297-81ce9e18933f */ + 0x76f5573e, + 0xf13a, + 0x40f5, + { 0xb2, 0x97, 0x81, 0xce, 0x9e, 0x18, 0x93, 0x3f } +}; +// -------------------------------------------------------------------------------------------------------------------------------- +// Experimental Feature: D3D12TiledResourceTier4 +// +// Use with D3D12EnableExperimentalFeatures to enable tiled resource tier 4 support, +// meaning texture tile data-inheritance is allowed. +// +// Enabling D3D12TiledResourceTier4 needs no configuration struct, pass NULL in the pConfigurationStructs array. +// +// -------------------------------------------------------------------------------------------------------------------------------- +static const UUID D3D12TiledResourceTier4 = { /* c9c4725f-a81a-4f56-8c5b-c51039d694fb */ + 0xc9c4725f, + 0xa81a, + 0x4f56, + { 0x8c, 0x5b, 0xc5, 0x10, 0x39, 0xd6, 0x94, 0xfb } +}; +// -------------------------------------------------------------------------------------------------------------------------------- +// Experimental Feature: D3D12MetaCommand +// +// Use with D3D12EnableExperimentalFeatures to enable the D3D12 Meta Command. +// +// Enabling D3D12MetaCommand needs no configuration struct, pass NULL in the pConfigurationStructs array. +// +// -------------------------------------------------------------------------------------------------------------------------------- +static const UUID D3D12MetaCommand = { /* C734C97E-8077-48C8-9FDC-D9D1DD31DD77 */ + 0xc734c97e, + 0x8077, + 0x48c8, + { 0x9f, 0xdc, 0xd9, 0xd1, 0xdd, 0x31, 0xdd, 0x77 } +}; +// -------------------------------------------------------------------------------------------------------------------------------- +// Experimental Feature: D3D12ComputeOnlyDevices +// +// Use with D3D12EnableExperimentalFeatures to enable compute only devices (D3D_FEATURE_LEVEL_1_0_CORE). +// +// Enabling D3D12ComputeOnlyDevices needs no configuration struct, pass NULL in the pConfigurationStructs array. +// +// -------------------------------------------------------------------------------------------------------------------------------- +static const UUID D3D12ComputeOnlyDevices = { /* 50f7ab08-4b6d-4e14-89a5-5d16cd272594 */ + 0x50f7ab08, + 0x4b6d, + 0x4e14, + {0x89, 0xa5, 0x5d, 0x16, 0xcd, 0x27, 0x25, 0x94} +}; +typedef +enum D3D12_AXIS_SHADING_RATE + { + D3D12_AXIS_SHADING_RATE_1X = 0, + D3D12_AXIS_SHADING_RATE_2X = 0x1, + D3D12_AXIS_SHADING_RATE_4X = 0x2 + } D3D12_AXIS_SHADING_RATE; + +#define D3D12_SHADING_RATE_X_AXIS_SHIFT 2 +#define D3D12_SHADING_RATE_VALID_MASK 3 +#define D3D12_MAKE_COARSE_SHADING_RATE(x,y) ((x) << D3D12_SHADING_RATE_X_AXIS_SHIFT | (y)) +#define D3D12_GET_COARSE_SHADING_RATE_X_AXIS(x) (((x) >> D3D12_SHADING_RATE_X_AXIS_SHIFT) & D3D12_SHADING_RATE_VALID_MASK) +#define D3D12_GET_COARSE_SHADING_RATE_Y_AXIS(y) ((y) & D3D12_SHADING_RATE_VALID_MASK) +typedef +enum D3D12_SHADING_RATE + { + D3D12_SHADING_RATE_1X1 = 0, + D3D12_SHADING_RATE_1X2 = 0x1, + D3D12_SHADING_RATE_2X1 = 0x4, + D3D12_SHADING_RATE_2X2 = 0x5, + D3D12_SHADING_RATE_2X4 = 0x6, + D3D12_SHADING_RATE_4X2 = 0x9, + D3D12_SHADING_RATE_4X4 = 0xa + } D3D12_SHADING_RATE; + +typedef +enum D3D12_SHADING_RATE_COMBINER + { + D3D12_SHADING_RATE_COMBINER_PASSTHROUGH = 0, + D3D12_SHADING_RATE_COMBINER_OVERRIDE = 1, + D3D12_SHADING_RATE_COMBINER_MIN = 2, + D3D12_SHADING_RATE_COMBINER_MAX = 3, + D3D12_SHADING_RATE_COMBINER_SUM = 4 + } D3D12_SHADING_RATE_COMBINER; + + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0044_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0044_v0_0_s_ifspec; + +#ifndef __ID3D12GraphicsCommandList5_INTERFACE_DEFINED__ +#define __ID3D12GraphicsCommandList5_INTERFACE_DEFINED__ + +/* interface ID3D12GraphicsCommandList5 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12GraphicsCommandList5; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("55050859-4024-474c-87f5-6472eaee44ea") + ID3D12GraphicsCommandList5 : public ID3D12GraphicsCommandList4 + { + public: + virtual void STDMETHODCALLTYPE RSSetShadingRate( + _In_ D3D12_SHADING_RATE baseShadingRate, + _In_reads_opt_(D3D12_RS_SET_SHADING_RATE_COMBINER_COUNT) const D3D12_SHADING_RATE_COMBINER *combiners) = 0; + + virtual void STDMETHODCALLTYPE RSSetShadingRateImage( + _In_opt_ ID3D12Resource *shadingRateImage) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12GraphicsCommandList5Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12GraphicsCommandList5 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12GraphicsCommandList5 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12GraphicsCommandList5 * This); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12GraphicsCommandList5 * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12GraphicsCommandList5 * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12GraphicsCommandList5 * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12GraphicsCommandList5 * This, + _In_z_ LPCWSTR Name); + + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12GraphicsCommandList5 * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( + ID3D12GraphicsCommandList5 * This); + + HRESULT ( STDMETHODCALLTYPE *Close )( + ID3D12GraphicsCommandList5 * This); + + HRESULT ( STDMETHODCALLTYPE *Reset )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12CommandAllocator *pAllocator, + _In_opt_ ID3D12PipelineState *pInitialState); + + void ( STDMETHODCALLTYPE *ClearState )( + ID3D12GraphicsCommandList5 * This, + _In_opt_ ID3D12PipelineState *pPipelineState); + + void ( STDMETHODCALLTYPE *DrawInstanced )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT VertexCountPerInstance, + _In_ UINT InstanceCount, + _In_ UINT StartVertexLocation, + _In_ UINT StartInstanceLocation); + + void ( STDMETHODCALLTYPE *DrawIndexedInstanced )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT IndexCountPerInstance, + _In_ UINT InstanceCount, + _In_ UINT StartIndexLocation, + _In_ INT BaseVertexLocation, + _In_ UINT StartInstanceLocation); + + void ( STDMETHODCALLTYPE *Dispatch )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT ThreadGroupCountX, + _In_ UINT ThreadGroupCountY, + _In_ UINT ThreadGroupCountZ); + + void ( STDMETHODCALLTYPE *CopyBufferRegion )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12Resource *pDstBuffer, + UINT64 DstOffset, + _In_ ID3D12Resource *pSrcBuffer, + UINT64 SrcOffset, + UINT64 NumBytes); + + void ( STDMETHODCALLTYPE *CopyTextureRegion )( + ID3D12GraphicsCommandList5 * This, + _In_ const D3D12_TEXTURE_COPY_LOCATION *pDst, + UINT DstX, + UINT DstY, + UINT DstZ, + _In_ const D3D12_TEXTURE_COPY_LOCATION *pSrc, + _In_opt_ const D3D12_BOX *pSrcBox); + + void ( STDMETHODCALLTYPE *CopyResource )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12Resource *pDstResource, + _In_ ID3D12Resource *pSrcResource); + + void ( STDMETHODCALLTYPE *CopyTiles )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12Resource *pTiledResource, + _In_ const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate, + _In_ const D3D12_TILE_REGION_SIZE *pTileRegionSize, + _In_ ID3D12Resource *pBuffer, + UINT64 BufferStartOffsetInBytes, + D3D12_TILE_COPY_FLAGS Flags); + + void ( STDMETHODCALLTYPE *ResolveSubresource )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12Resource *pDstResource, + _In_ UINT DstSubresource, + _In_ ID3D12Resource *pSrcResource, + _In_ UINT SrcSubresource, + _In_ DXGI_FORMAT Format); + + void ( STDMETHODCALLTYPE *IASetPrimitiveTopology )( + ID3D12GraphicsCommandList5 * This, + _In_ D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology); + + void ( STDMETHODCALLTYPE *RSSetViewports )( + ID3D12GraphicsCommandList5 * This, + _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumViewports, + _In_reads_( NumViewports) const D3D12_VIEWPORT *pViewports); + + void ( STDMETHODCALLTYPE *RSSetScissorRects )( + ID3D12GraphicsCommandList5 * This, + _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumRects, + _In_reads_( NumRects) const D3D12_RECT *pRects); + + void ( STDMETHODCALLTYPE *OMSetBlendFactor )( + ID3D12GraphicsCommandList5 * This, + _In_reads_opt_(4) const FLOAT BlendFactor[ 4 ]); + + void ( STDMETHODCALLTYPE *OMSetStencilRef )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT StencilRef); + + void ( STDMETHODCALLTYPE *SetPipelineState )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12PipelineState *pPipelineState); + + void ( STDMETHODCALLTYPE *ResourceBarrier )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT NumBarriers, + _In_reads_(NumBarriers) const D3D12_RESOURCE_BARRIER *pBarriers); + + void ( STDMETHODCALLTYPE *ExecuteBundle )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12GraphicsCommandList *pCommandList); + + void ( STDMETHODCALLTYPE *SetDescriptorHeaps )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT NumDescriptorHeaps, + _In_reads_(NumDescriptorHeaps) ID3D12DescriptorHeap *const *ppDescriptorHeaps); + + void ( STDMETHODCALLTYPE *SetComputeRootSignature )( + ID3D12GraphicsCommandList5 * This, + _In_opt_ ID3D12RootSignature *pRootSignature); + + void ( STDMETHODCALLTYPE *SetGraphicsRootSignature )( + ID3D12GraphicsCommandList5 * This, + _In_opt_ ID3D12RootSignature *pRootSignature); + + void ( STDMETHODCALLTYPE *SetComputeRootDescriptorTable )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); + + void ( STDMETHODCALLTYPE *SetGraphicsRootDescriptorTable )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); + + void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstant )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT RootParameterIndex, + _In_ UINT SrcData, + _In_ UINT DestOffsetIn32BitValues); + + void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstant )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT RootParameterIndex, + _In_ UINT SrcData, + _In_ UINT DestOffsetIn32BitValues); + + void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstants )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT RootParameterIndex, + _In_ UINT Num32BitValuesToSet, + _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, + _In_ UINT DestOffsetIn32BitValues); + + void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstants )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT RootParameterIndex, + _In_ UINT Num32BitValuesToSet, + _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, + _In_ UINT DestOffsetIn32BitValues); + + void ( STDMETHODCALLTYPE *SetComputeRootConstantBufferView )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *SetGraphicsRootConstantBufferView )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *SetComputeRootShaderResourceView )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *SetGraphicsRootShaderResourceView )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *SetComputeRootUnorderedAccessView )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *SetGraphicsRootUnorderedAccessView )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + void ( STDMETHODCALLTYPE *IASetIndexBuffer )( + ID3D12GraphicsCommandList5 * This, + _In_opt_ const D3D12_INDEX_BUFFER_VIEW *pView); + + void ( STDMETHODCALLTYPE *IASetVertexBuffers )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT StartSlot, + _In_ UINT NumViews, + _In_reads_opt_(NumViews) const D3D12_VERTEX_BUFFER_VIEW *pViews); + + void ( STDMETHODCALLTYPE *SOSetTargets )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT StartSlot, + _In_ UINT NumViews, + _In_reads_opt_(NumViews) const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews); + + void ( STDMETHODCALLTYPE *OMSetRenderTargets )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT NumRenderTargetDescriptors, + _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors, + _In_ BOOL RTsSingleHandleToDescriptorRange, + _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pDepthStencilDescriptor); + + void ( STDMETHODCALLTYPE *ClearDepthStencilView )( + ID3D12GraphicsCommandList5 * This, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView, + _In_ D3D12_CLEAR_FLAGS ClearFlags, + _In_ FLOAT Depth, + _In_ UINT8 Stencil, + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); + + void ( STDMETHODCALLTYPE *ClearRenderTargetView )( + ID3D12GraphicsCommandList5 * This, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView, + _In_ const FLOAT ColorRGBA[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); + + void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewUint )( + ID3D12GraphicsCommandList5 * This, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, + _In_ ID3D12Resource *pResource, + _In_ const UINT Values[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); + + void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewFloat )( + ID3D12GraphicsCommandList5 * This, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, + _In_ ID3D12Resource *pResource, + _In_ const FLOAT Values[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); + + void ( STDMETHODCALLTYPE *DiscardResource )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12Resource *pResource, + _In_opt_ const D3D12_DISCARD_REGION *pRegion); + + void ( STDMETHODCALLTYPE *BeginQuery )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT Index); + + void ( STDMETHODCALLTYPE *EndQuery )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT Index); + + void ( STDMETHODCALLTYPE *ResolveQueryData )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT StartIndex, + _In_ UINT NumQueries, + _In_ ID3D12Resource *pDestinationBuffer, + _In_ UINT64 AlignedDestinationBufferOffset); + + void ( STDMETHODCALLTYPE *SetPredication )( + ID3D12GraphicsCommandList5 * This, + _In_opt_ ID3D12Resource *pBuffer, + _In_ UINT64 AlignedBufferOffset, + _In_ D3D12_PREDICATION_OP Operation); + + void ( STDMETHODCALLTYPE *SetMarker )( + ID3D12GraphicsCommandList5 * This, + UINT Metadata, + _In_reads_bytes_opt_(Size) const void *pData, + UINT Size); + + void ( STDMETHODCALLTYPE *BeginEvent )( + ID3D12GraphicsCommandList5 * This, + UINT Metadata, + _In_reads_bytes_opt_(Size) const void *pData, + UINT Size); + + void ( STDMETHODCALLTYPE *EndEvent )( + ID3D12GraphicsCommandList5 * This); + + void ( STDMETHODCALLTYPE *ExecuteIndirect )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12CommandSignature *pCommandSignature, + _In_ UINT MaxCommandCount, + _In_ ID3D12Resource *pArgumentBuffer, + _In_ UINT64 ArgumentBufferOffset, + _In_opt_ ID3D12Resource *pCountBuffer, + _In_ UINT64 CountBufferOffset); + + void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12Resource *pDstBuffer, + UINT64 DstOffset, + _In_ ID3D12Resource *pSrcBuffer, + UINT64 SrcOffset, + UINT Dependencies, + _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, + _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); + + void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT64 )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12Resource *pDstBuffer, + UINT64 DstOffset, + _In_ ID3D12Resource *pSrcBuffer, + UINT64 SrcOffset, + UINT Dependencies, + _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, + _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); + + void ( STDMETHODCALLTYPE *OMSetDepthBounds )( + ID3D12GraphicsCommandList5 * This, + _In_ FLOAT Min, + _In_ FLOAT Max); + + void ( STDMETHODCALLTYPE *SetSamplePositions )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT NumSamplesPerPixel, + _In_ UINT NumPixels, + _In_reads_(NumSamplesPerPixel*NumPixels) D3D12_SAMPLE_POSITION *pSamplePositions); + + void ( STDMETHODCALLTYPE *ResolveSubresourceRegion )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12Resource *pDstResource, + _In_ UINT DstSubresource, + _In_ UINT DstX, + _In_ UINT DstY, + _In_ ID3D12Resource *pSrcResource, + _In_ UINT SrcSubresource, + _In_opt_ D3D12_RECT *pSrcRect, + _In_ DXGI_FORMAT Format, + _In_ D3D12_RESOLVE_MODE ResolveMode); + + void ( STDMETHODCALLTYPE *SetViewInstanceMask )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT Mask); + + void ( STDMETHODCALLTYPE *WriteBufferImmediate )( + ID3D12GraphicsCommandList5 * This, + UINT Count, + _In_reads_(Count) const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams, + _In_reads_opt_(Count) const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes); + + void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( + ID3D12GraphicsCommandList5 * This, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedResourceSession); + + void ( STDMETHODCALLTYPE *BeginRenderPass )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT NumRenderTargets, + _In_reads_opt_(NumRenderTargets) const D3D12_RENDER_PASS_RENDER_TARGET_DESC *pRenderTargets, + _In_opt_ const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *pDepthStencil, + D3D12_RENDER_PASS_FLAGS Flags); + + void ( STDMETHODCALLTYPE *EndRenderPass )( + ID3D12GraphicsCommandList5 * This); + + void ( STDMETHODCALLTYPE *InitializeMetaCommand )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12MetaCommand *pMetaCommand, + _In_reads_bytes_opt_(InitializationParametersDataSizeInBytes) const void *pInitializationParametersData, + _In_ SIZE_T InitializationParametersDataSizeInBytes); + + void ( STDMETHODCALLTYPE *ExecuteMetaCommand )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12MetaCommand *pMetaCommand, + _In_reads_bytes_opt_(ExecutionParametersDataSizeInBytes) const void *pExecutionParametersData, + _In_ SIZE_T ExecutionParametersDataSizeInBytes); + + void ( STDMETHODCALLTYPE *BuildRaytracingAccelerationStructure )( + ID3D12GraphicsCommandList5 * This, + _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC *pDesc, + _In_ UINT NumPostbuildInfoDescs, + _In_reads_opt_(NumPostbuildInfoDescs) const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pPostbuildInfoDescs); + + void ( STDMETHODCALLTYPE *EmitRaytracingAccelerationStructurePostbuildInfo )( + ID3D12GraphicsCommandList5 * This, + _In_ const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pDesc, + _In_ UINT NumSourceAccelerationStructures, + _In_reads_( NumSourceAccelerationStructures ) const D3D12_GPU_VIRTUAL_ADDRESS *pSourceAccelerationStructureData); + + void ( STDMETHODCALLTYPE *CopyRaytracingAccelerationStructure )( + ID3D12GraphicsCommandList5 * This, + _In_ D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData, + _In_ D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData, + _In_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE Mode); + + void ( STDMETHODCALLTYPE *SetPipelineState1 )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12StateObject *pStateObject); + + void ( STDMETHODCALLTYPE *DispatchRays )( + ID3D12GraphicsCommandList5 * This, + _In_ const D3D12_DISPATCH_RAYS_DESC *pDesc); + + void ( STDMETHODCALLTYPE *RSSetShadingRate )( + ID3D12GraphicsCommandList5 * This, + _In_ D3D12_SHADING_RATE baseShadingRate, + _In_reads_opt_(D3D12_RS_SET_SHADING_RATE_COMBINER_COUNT) const D3D12_SHADING_RATE_COMBINER *combiners); + + void ( STDMETHODCALLTYPE *RSSetShadingRateImage )( + ID3D12GraphicsCommandList5 * This, + _In_opt_ ID3D12Resource *shadingRateImage); + + END_INTERFACE + } ID3D12GraphicsCommandList5Vtbl; + + interface ID3D12GraphicsCommandList5 + { + CONST_VTBL struct ID3D12GraphicsCommandList5Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12GraphicsCommandList5_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12GraphicsCommandList5_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12GraphicsCommandList5_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12GraphicsCommandList5_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12GraphicsCommandList5_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12GraphicsCommandList5_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12GraphicsCommandList5_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12GraphicsCommandList5_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + +#define ID3D12GraphicsCommandList5_GetType(This) \ + ( (This)->lpVtbl -> GetType(This) ) + + +#define ID3D12GraphicsCommandList5_Close(This) \ + ( (This)->lpVtbl -> Close(This) ) + +#define ID3D12GraphicsCommandList5_Reset(This,pAllocator,pInitialState) \ + ( (This)->lpVtbl -> Reset(This,pAllocator,pInitialState) ) + +#define ID3D12GraphicsCommandList5_ClearState(This,pPipelineState) \ + ( (This)->lpVtbl -> ClearState(This,pPipelineState) ) + +#define ID3D12GraphicsCommandList5_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) \ + ( (This)->lpVtbl -> DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) ) + +#define ID3D12GraphicsCommandList5_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) \ + ( (This)->lpVtbl -> DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) ) + +#define ID3D12GraphicsCommandList5_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ + ( (This)->lpVtbl -> Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) + +#define ID3D12GraphicsCommandList5_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) \ + ( (This)->lpVtbl -> CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) ) + +#define ID3D12GraphicsCommandList5_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) \ + ( (This)->lpVtbl -> CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) ) + +#define ID3D12GraphicsCommandList5_CopyResource(This,pDstResource,pSrcResource) \ + ( (This)->lpVtbl -> CopyResource(This,pDstResource,pSrcResource) ) + +#define ID3D12GraphicsCommandList5_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) \ + ( (This)->lpVtbl -> CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) ) + +#define ID3D12GraphicsCommandList5_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) \ + ( (This)->lpVtbl -> ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) ) + +#define ID3D12GraphicsCommandList5_IASetPrimitiveTopology(This,PrimitiveTopology) \ + ( (This)->lpVtbl -> IASetPrimitiveTopology(This,PrimitiveTopology) ) + +#define ID3D12GraphicsCommandList5_RSSetViewports(This,NumViewports,pViewports) \ + ( (This)->lpVtbl -> RSSetViewports(This,NumViewports,pViewports) ) + +#define ID3D12GraphicsCommandList5_RSSetScissorRects(This,NumRects,pRects) \ + ( (This)->lpVtbl -> RSSetScissorRects(This,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList5_OMSetBlendFactor(This,BlendFactor) \ + ( (This)->lpVtbl -> OMSetBlendFactor(This,BlendFactor) ) + +#define ID3D12GraphicsCommandList5_OMSetStencilRef(This,StencilRef) \ + ( (This)->lpVtbl -> OMSetStencilRef(This,StencilRef) ) + +#define ID3D12GraphicsCommandList5_SetPipelineState(This,pPipelineState) \ + ( (This)->lpVtbl -> SetPipelineState(This,pPipelineState) ) + +#define ID3D12GraphicsCommandList5_ResourceBarrier(This,NumBarriers,pBarriers) \ + ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) + +#define ID3D12GraphicsCommandList5_ExecuteBundle(This,pCommandList) \ + ( (This)->lpVtbl -> ExecuteBundle(This,pCommandList) ) + +#define ID3D12GraphicsCommandList5_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) \ + ( (This)->lpVtbl -> SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) ) + +#define ID3D12GraphicsCommandList5_SetComputeRootSignature(This,pRootSignature) \ + ( (This)->lpVtbl -> SetComputeRootSignature(This,pRootSignature) ) + +#define ID3D12GraphicsCommandList5_SetGraphicsRootSignature(This,pRootSignature) \ + ( (This)->lpVtbl -> SetGraphicsRootSignature(This,pRootSignature) ) + +#define ID3D12GraphicsCommandList5_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ + ( (This)->lpVtbl -> SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) + +#define ID3D12GraphicsCommandList5_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ + ( (This)->lpVtbl -> SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) + +#define ID3D12GraphicsCommandList5_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) + +#define ID3D12GraphicsCommandList5_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) + +#define ID3D12GraphicsCommandList5_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) + +#define ID3D12GraphicsCommandList5_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) + +#define ID3D12GraphicsCommandList5_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList5_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList5_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList5_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList5_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList5_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList5_IASetIndexBuffer(This,pView) \ + ( (This)->lpVtbl -> IASetIndexBuffer(This,pView) ) + +#define ID3D12GraphicsCommandList5_IASetVertexBuffers(This,StartSlot,NumViews,pViews) \ + ( (This)->lpVtbl -> IASetVertexBuffers(This,StartSlot,NumViews,pViews) ) + +#define ID3D12GraphicsCommandList5_SOSetTargets(This,StartSlot,NumViews,pViews) \ + ( (This)->lpVtbl -> SOSetTargets(This,StartSlot,NumViews,pViews) ) + +#define ID3D12GraphicsCommandList5_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) \ + ( (This)->lpVtbl -> OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) ) + +#define ID3D12GraphicsCommandList5_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList5_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList5_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList5_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList5_DiscardResource(This,pResource,pRegion) \ + ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) + +#define ID3D12GraphicsCommandList5_BeginQuery(This,pQueryHeap,Type,Index) \ + ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) + +#define ID3D12GraphicsCommandList5_EndQuery(This,pQueryHeap,Type,Index) \ + ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) + +#define ID3D12GraphicsCommandList5_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) \ + ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) + +#define ID3D12GraphicsCommandList5_SetPredication(This,pBuffer,AlignedBufferOffset,Operation) \ + ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) + +#define ID3D12GraphicsCommandList5_SetMarker(This,Metadata,pData,Size) \ + ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) + +#define ID3D12GraphicsCommandList5_BeginEvent(This,Metadata,pData,Size) \ + ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) + +#define ID3D12GraphicsCommandList5_EndEvent(This) \ + ( (This)->lpVtbl -> EndEvent(This) ) + +#define ID3D12GraphicsCommandList5_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) \ + ( (This)->lpVtbl -> ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) ) + + +#define ID3D12GraphicsCommandList5_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ + ( (This)->lpVtbl -> AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) + +#define ID3D12GraphicsCommandList5_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ + ( (This)->lpVtbl -> AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) + +#define ID3D12GraphicsCommandList5_OMSetDepthBounds(This,Min,Max) \ + ( (This)->lpVtbl -> OMSetDepthBounds(This,Min,Max) ) + +#define ID3D12GraphicsCommandList5_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) \ + ( (This)->lpVtbl -> SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) ) + +#define ID3D12GraphicsCommandList5_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) \ + ( (This)->lpVtbl -> ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) ) + +#define ID3D12GraphicsCommandList5_SetViewInstanceMask(This,Mask) \ + ( (This)->lpVtbl -> SetViewInstanceMask(This,Mask) ) + + +#define ID3D12GraphicsCommandList5_WriteBufferImmediate(This,Count,pParams,pModes) \ + ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) + + +#define ID3D12GraphicsCommandList5_SetProtectedResourceSession(This,pProtectedResourceSession) \ + ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) + + +#define ID3D12GraphicsCommandList5_BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) \ + ( (This)->lpVtbl -> BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) ) + +#define ID3D12GraphicsCommandList5_EndRenderPass(This) \ + ( (This)->lpVtbl -> EndRenderPass(This) ) + +#define ID3D12GraphicsCommandList5_InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) \ + ( (This)->lpVtbl -> InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) ) + +#define ID3D12GraphicsCommandList5_ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) \ + ( (This)->lpVtbl -> ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) ) + +#define ID3D12GraphicsCommandList5_BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) \ + ( (This)->lpVtbl -> BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) ) + +#define ID3D12GraphicsCommandList5_EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) \ + ( (This)->lpVtbl -> EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) ) + +#define ID3D12GraphicsCommandList5_CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) \ + ( (This)->lpVtbl -> CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) ) + +#define ID3D12GraphicsCommandList5_SetPipelineState1(This,pStateObject) \ + ( (This)->lpVtbl -> SetPipelineState1(This,pStateObject) ) + +#define ID3D12GraphicsCommandList5_DispatchRays(This,pDesc) \ + ( (This)->lpVtbl -> DispatchRays(This,pDesc) ) + + +#define ID3D12GraphicsCommandList5_RSSetShadingRate(This,baseShadingRate,combiners) \ + ( (This)->lpVtbl -> RSSetShadingRate(This,baseShadingRate,combiners) ) + +#define ID3D12GraphicsCommandList5_RSSetShadingRateImage(This,shadingRateImage) \ + ( (This)->lpVtbl -> RSSetShadingRateImage(This,shadingRateImage) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12GraphicsCommandList5_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12_0000_0045 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */ +#pragma endregion +DEFINE_GUID(IID_ID3D12Object,0xc4fec28f,0x7966,0x4e95,0x9f,0x94,0xf4,0x31,0xcb,0x56,0xc3,0xb8); +DEFINE_GUID(IID_ID3D12DeviceChild,0x905db94b,0xa00c,0x4140,0x9d,0xf5,0x2b,0x64,0xca,0x9e,0xa3,0x57); +DEFINE_GUID(IID_ID3D12RootSignature,0xc54a6b66,0x72df,0x4ee8,0x8b,0xe5,0xa9,0x46,0xa1,0x42,0x92,0x14); +DEFINE_GUID(IID_ID3D12RootSignatureDeserializer,0x34AB647B,0x3CC8,0x46AC,0x84,0x1B,0xC0,0x96,0x56,0x45,0xC0,0x46); +DEFINE_GUID(IID_ID3D12VersionedRootSignatureDeserializer,0x7F91CE67,0x090C,0x4BB7,0xB7,0x8E,0xED,0x8F,0xF2,0xE3,0x1D,0xA0); +DEFINE_GUID(IID_ID3D12Pageable,0x63ee58fb,0x1268,0x4835,0x86,0xda,0xf0,0x08,0xce,0x62,0xf0,0xd6); +DEFINE_GUID(IID_ID3D12Heap,0x6b3b2502,0x6e51,0x45b3,0x90,0xee,0x98,0x84,0x26,0x5e,0x8d,0xf3); +DEFINE_GUID(IID_ID3D12Resource,0x696442be,0xa72e,0x4059,0xbc,0x79,0x5b,0x5c,0x98,0x04,0x0f,0xad); +DEFINE_GUID(IID_ID3D12CommandAllocator,0x6102dee4,0xaf59,0x4b09,0xb9,0x99,0xb4,0x4d,0x73,0xf0,0x9b,0x24); +DEFINE_GUID(IID_ID3D12Fence,0x0a753dcf,0xc4d8,0x4b91,0xad,0xf6,0xbe,0x5a,0x60,0xd9,0x5a,0x76); +DEFINE_GUID(IID_ID3D12Fence1,0x433685fe,0xe22b,0x4ca0,0xa8,0xdb,0xb5,0xb4,0xf4,0xdd,0x0e,0x4a); +DEFINE_GUID(IID_ID3D12PipelineState,0x765a30f3,0xf624,0x4c6f,0xa8,0x28,0xac,0xe9,0x48,0x62,0x24,0x45); +DEFINE_GUID(IID_ID3D12DescriptorHeap,0x8efb471d,0x616c,0x4f49,0x90,0xf7,0x12,0x7b,0xb7,0x63,0xfa,0x51); +DEFINE_GUID(IID_ID3D12QueryHeap,0x0d9658ae,0xed45,0x469e,0xa6,0x1d,0x97,0x0e,0xc5,0x83,0xca,0xb4); +DEFINE_GUID(IID_ID3D12CommandSignature,0xc36a797c,0xec80,0x4f0a,0x89,0x85,0xa7,0xb2,0x47,0x50,0x82,0xd1); +DEFINE_GUID(IID_ID3D12CommandList,0x7116d91c,0xe7e4,0x47ce,0xb8,0xc6,0xec,0x81,0x68,0xf4,0x37,0xe5); +DEFINE_GUID(IID_ID3D12GraphicsCommandList,0x5b160d0f,0xac1b,0x4185,0x8b,0xa8,0xb3,0xae,0x42,0xa5,0xa4,0x55); +DEFINE_GUID(IID_ID3D12GraphicsCommandList1,0x553103fb,0x1fe7,0x4557,0xbb,0x38,0x94,0x6d,0x7d,0x0e,0x7c,0xa7); +DEFINE_GUID(IID_ID3D12GraphicsCommandList2,0x38C3E585,0xFF17,0x412C,0x91,0x50,0x4F,0xC6,0xF9,0xD7,0x2A,0x28); +DEFINE_GUID(IID_ID3D12CommandQueue,0x0ec870a6,0x5d7e,0x4c22,0x8c,0xfc,0x5b,0xaa,0xe0,0x76,0x16,0xed); +DEFINE_GUID(IID_ID3D12Device,0x189819f1,0x1db6,0x4b57,0xbe,0x54,0x18,0x21,0x33,0x9b,0x85,0xf7); +DEFINE_GUID(IID_ID3D12PipelineLibrary,0xc64226a8,0x9201,0x46af,0xb4,0xcc,0x53,0xfb,0x9f,0xf7,0x41,0x4f); +DEFINE_GUID(IID_ID3D12PipelineLibrary1,0x80eabf42,0x2568,0x4e5e,0xbd,0x82,0xc3,0x7f,0x86,0x96,0x1d,0xc3); +DEFINE_GUID(IID_ID3D12Device1,0x77acce80,0x638e,0x4e65,0x88,0x95,0xc1,0xf2,0x33,0x86,0x86,0x3e); +DEFINE_GUID(IID_ID3D12Device2,0x30baa41e,0xb15b,0x475c,0xa0,0xbb,0x1a,0xf5,0xc5,0xb6,0x43,0x28); +DEFINE_GUID(IID_ID3D12Device3,0x81dadc15,0x2bad,0x4392,0x93,0xc5,0x10,0x13,0x45,0xc4,0xaa,0x98); +DEFINE_GUID(IID_ID3D12ProtectedSession,0xA1533D18,0x0AC1,0x4084,0x85,0xB9,0x89,0xA9,0x61,0x16,0x80,0x6B); +DEFINE_GUID(IID_ID3D12ProtectedResourceSession,0x6CD696F4,0xF289,0x40CC,0x80,0x91,0x5A,0x6C,0x0A,0x09,0x9C,0x3D); +DEFINE_GUID(IID_ID3D12Device4,0xe865df17,0xa9ee,0x46f9,0xa4,0x63,0x30,0x98,0x31,0x5a,0xa2,0xe5); +DEFINE_GUID(IID_ID3D12LifetimeOwner,0xe667af9f,0xcd56,0x4f46,0x83,0xce,0x03,0x2e,0x59,0x5d,0x70,0xa8); +DEFINE_GUID(IID_ID3D12SwapChainAssistant,0xf1df64b6,0x57fd,0x49cd,0x88,0x07,0xc0,0xeb,0x88,0xb4,0x5c,0x8f); +DEFINE_GUID(IID_ID3D12LifetimeTracker,0x3fd03d36,0x4eb1,0x424a,0xa5,0x82,0x49,0x4e,0xcb,0x8b,0xa8,0x13); +DEFINE_GUID(IID_ID3D12StateObject,0x47016943,0xfca8,0x4594,0x93,0xea,0xaf,0x25,0x8b,0x55,0x34,0x6d); +DEFINE_GUID(IID_ID3D12StateObjectProperties,0xde5fa827,0x9bf9,0x4f26,0x89,0xff,0xd7,0xf5,0x6f,0xde,0x38,0x60); +DEFINE_GUID(IID_ID3D12Device5,0x8b4f173b,0x2fea,0x4b80,0x8f,0x58,0x43,0x07,0x19,0x1a,0xb9,0x5d); +DEFINE_GUID(IID_ID3D12DeviceRemovedExtendedDataSettings,0x82BC481C,0x6B9B,0x4030,0xAE,0xDB,0x7E,0xE3,0xD1,0xDF,0x1E,0x63); +DEFINE_GUID(IID_ID3D12DeviceRemovedExtendedData,0x98931D33,0x5AE8,0x4791,0xAA,0x3C,0x1A,0x73,0xA2,0x93,0x4E,0x71); +DEFINE_GUID(IID_ID3D12Device6,0xc70b221b,0x40e4,0x4a17,0x89,0xaf,0x02,0x5a,0x07,0x27,0xa6,0xdc); +DEFINE_GUID(IID_ID3D12Resource1,0x9D5E227A,0x4430,0x4161,0x88,0xB3,0x3E,0xCA,0x6B,0xB1,0x6E,0x19); +DEFINE_GUID(IID_ID3D12Heap1,0x572F7389,0x2168,0x49E3,0x96,0x93,0xD6,0xDF,0x58,0x71,0xBF,0x6D); +DEFINE_GUID(IID_ID3D12GraphicsCommandList3,0x6FDA83A7,0xB84C,0x4E38,0x9A,0xC8,0xC7,0xBD,0x22,0x01,0x6B,0x3D); +DEFINE_GUID(IID_ID3D12MetaCommand,0xDBB84C27,0x36CE,0x4FC9,0xB8,0x01,0xF0,0x48,0xC4,0x6A,0xC5,0x70); +DEFINE_GUID(IID_ID3D12GraphicsCommandList4,0x8754318e,0xd3a9,0x4541,0x98,0xcf,0x64,0x5b,0x50,0xdc,0x48,0x74); +DEFINE_GUID(IID_ID3D12Tools,0x7071e1f0,0xe84b,0x4b33,0x97,0x4f,0x12,0xfa,0x49,0xde,0x65,0xc5); +DEFINE_GUID(IID_ID3D12GraphicsCommandList5,0x55050859,0x4024,0x474c,0x87,0xf5,0x64,0x72,0xea,0xee,0x44,0xea); + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0045_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0045_v0_0_s_ifspec; + +/* Additional Prototypes for ALL interfaces */ + +/* end of Additional Prototypes */ + +#ifdef __cplusplus +} +#endif + +#endif + + diff --git a/src/decomp/pc/gfx/dxsdk/d3d12sdklayers.h b/src/decomp/pc/gfx/dxsdk/d3d12sdklayers.h new file mode 100644 index 0000000..cb4f9cd --- /dev/null +++ b/src/decomp/pc/gfx/dxsdk/d3d12sdklayers.h @@ -0,0 +1,3230 @@ +/*------------------------------------------------------------------------------------- + * + * Copyright (c) Microsoft Corporation + * + *-------------------------------------------------------------------------------------*/ + + +/* this ALWAYS GENERATED file contains the definitions for the interfaces */ + + + /* File created by MIDL compiler version 8.01.0622 */ + + + +/* verify that the version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCNDR_H_VERSION__ +#define __REQUIRED_RPCNDR_H_VERSION__ 500 +#endif + +/* verify that the version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCSAL_H_VERSION__ +#define __REQUIRED_RPCSAL_H_VERSION__ 100 +#endif + +#include "rpc.h" +#include "rpcndr.h" + +#ifndef __RPCNDR_H_VERSION__ +#error this stub requires an updated version of +#endif /* __RPCNDR_H_VERSION__ */ + +#ifndef COM_NO_WINDOWS_H +#include "windows.h" +#include "ole2.h" +#endif /*COM_NO_WINDOWS_H*/ + +#ifndef __d3d12sdklayers_h__ +#define __d3d12sdklayers_h__ + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#pragma once +#endif + +/* Forward Declarations */ + +#ifndef __ID3D12Debug_FWD_DEFINED__ +#define __ID3D12Debug_FWD_DEFINED__ +typedef interface ID3D12Debug ID3D12Debug; + +#endif /* __ID3D12Debug_FWD_DEFINED__ */ + + +#ifndef __ID3D12Debug1_FWD_DEFINED__ +#define __ID3D12Debug1_FWD_DEFINED__ +typedef interface ID3D12Debug1 ID3D12Debug1; + +#endif /* __ID3D12Debug1_FWD_DEFINED__ */ + + +#ifndef __ID3D12Debug2_FWD_DEFINED__ +#define __ID3D12Debug2_FWD_DEFINED__ +typedef interface ID3D12Debug2 ID3D12Debug2; + +#endif /* __ID3D12Debug2_FWD_DEFINED__ */ + + +#ifndef __ID3D12Debug3_FWD_DEFINED__ +#define __ID3D12Debug3_FWD_DEFINED__ +typedef interface ID3D12Debug3 ID3D12Debug3; + +#endif /* __ID3D12Debug3_FWD_DEFINED__ */ + + +#ifndef __ID3D12DebugDevice1_FWD_DEFINED__ +#define __ID3D12DebugDevice1_FWD_DEFINED__ +typedef interface ID3D12DebugDevice1 ID3D12DebugDevice1; + +#endif /* __ID3D12DebugDevice1_FWD_DEFINED__ */ + + +#ifndef __ID3D12DebugDevice_FWD_DEFINED__ +#define __ID3D12DebugDevice_FWD_DEFINED__ +typedef interface ID3D12DebugDevice ID3D12DebugDevice; + +#endif /* __ID3D12DebugDevice_FWD_DEFINED__ */ + + +#ifndef __ID3D12DebugDevice2_FWD_DEFINED__ +#define __ID3D12DebugDevice2_FWD_DEFINED__ +typedef interface ID3D12DebugDevice2 ID3D12DebugDevice2; + +#endif /* __ID3D12DebugDevice2_FWD_DEFINED__ */ + + +#ifndef __ID3D12DebugCommandQueue_FWD_DEFINED__ +#define __ID3D12DebugCommandQueue_FWD_DEFINED__ +typedef interface ID3D12DebugCommandQueue ID3D12DebugCommandQueue; + +#endif /* __ID3D12DebugCommandQueue_FWD_DEFINED__ */ + + +#ifndef __ID3D12DebugCommandList1_FWD_DEFINED__ +#define __ID3D12DebugCommandList1_FWD_DEFINED__ +typedef interface ID3D12DebugCommandList1 ID3D12DebugCommandList1; + +#endif /* __ID3D12DebugCommandList1_FWD_DEFINED__ */ + + +#ifndef __ID3D12DebugCommandList_FWD_DEFINED__ +#define __ID3D12DebugCommandList_FWD_DEFINED__ +typedef interface ID3D12DebugCommandList ID3D12DebugCommandList; + +#endif /* __ID3D12DebugCommandList_FWD_DEFINED__ */ + + +#ifndef __ID3D12DebugCommandList2_FWD_DEFINED__ +#define __ID3D12DebugCommandList2_FWD_DEFINED__ +typedef interface ID3D12DebugCommandList2 ID3D12DebugCommandList2; + +#endif /* __ID3D12DebugCommandList2_FWD_DEFINED__ */ + + +#ifndef __ID3D12SharingContract_FWD_DEFINED__ +#define __ID3D12SharingContract_FWD_DEFINED__ +typedef interface ID3D12SharingContract ID3D12SharingContract; + +#endif /* __ID3D12SharingContract_FWD_DEFINED__ */ + + +#ifndef __ID3D12InfoQueue_FWD_DEFINED__ +#define __ID3D12InfoQueue_FWD_DEFINED__ +typedef interface ID3D12InfoQueue ID3D12InfoQueue; + +#endif /* __ID3D12InfoQueue_FWD_DEFINED__ */ + + +/* header files for imported files */ +#include "oaidl.h" +#include "ocidl.h" +#include "d3d12.h" + +#ifdef __cplusplus +extern "C"{ +#endif + + +/* interface __MIDL_itf_d3d12sdklayers_0000_0000 */ +/* [local] */ + +#include +#pragma region App Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0000_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0000_v0_0_s_ifspec; + +#ifndef __ID3D12Debug_INTERFACE_DEFINED__ +#define __ID3D12Debug_INTERFACE_DEFINED__ + +/* interface ID3D12Debug */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12Debug; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("344488b7-6846-474b-b989-f027448245e0") + ID3D12Debug : public IUnknown + { + public: + virtual void STDMETHODCALLTYPE EnableDebugLayer( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12DebugVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12Debug * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12Debug * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12Debug * This); + + void ( STDMETHODCALLTYPE *EnableDebugLayer )( + ID3D12Debug * This); + + END_INTERFACE + } ID3D12DebugVtbl; + + interface ID3D12Debug + { + CONST_VTBL struct ID3D12DebugVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12Debug_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12Debug_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12Debug_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12Debug_EnableDebugLayer(This) \ + ( (This)->lpVtbl -> EnableDebugLayer(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12Debug_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12sdklayers_0000_0001 */ +/* [local] */ + +typedef +enum D3D12_GPU_BASED_VALIDATION_FLAGS + { + D3D12_GPU_BASED_VALIDATION_FLAGS_NONE = 0, + D3D12_GPU_BASED_VALIDATION_FLAGS_DISABLE_STATE_TRACKING = 0x1 + } D3D12_GPU_BASED_VALIDATION_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS(D3D12_GPU_BASED_VALIDATION_FLAGS) + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0001_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0001_v0_0_s_ifspec; + +#ifndef __ID3D12Debug1_INTERFACE_DEFINED__ +#define __ID3D12Debug1_INTERFACE_DEFINED__ + +/* interface ID3D12Debug1 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12Debug1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("affaa4ca-63fe-4d8e-b8ad-159000af4304") + ID3D12Debug1 : public IUnknown + { + public: + virtual void STDMETHODCALLTYPE EnableDebugLayer( void) = 0; + + virtual void STDMETHODCALLTYPE SetEnableGPUBasedValidation( + BOOL Enable) = 0; + + virtual void STDMETHODCALLTYPE SetEnableSynchronizedCommandQueueValidation( + BOOL Enable) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12Debug1Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12Debug1 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12Debug1 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12Debug1 * This); + + void ( STDMETHODCALLTYPE *EnableDebugLayer )( + ID3D12Debug1 * This); + + void ( STDMETHODCALLTYPE *SetEnableGPUBasedValidation )( + ID3D12Debug1 * This, + BOOL Enable); + + void ( STDMETHODCALLTYPE *SetEnableSynchronizedCommandQueueValidation )( + ID3D12Debug1 * This, + BOOL Enable); + + END_INTERFACE + } ID3D12Debug1Vtbl; + + interface ID3D12Debug1 + { + CONST_VTBL struct ID3D12Debug1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12Debug1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12Debug1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12Debug1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12Debug1_EnableDebugLayer(This) \ + ( (This)->lpVtbl -> EnableDebugLayer(This) ) + +#define ID3D12Debug1_SetEnableGPUBasedValidation(This,Enable) \ + ( (This)->lpVtbl -> SetEnableGPUBasedValidation(This,Enable) ) + +#define ID3D12Debug1_SetEnableSynchronizedCommandQueueValidation(This,Enable) \ + ( (This)->lpVtbl -> SetEnableSynchronizedCommandQueueValidation(This,Enable) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12Debug1_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12Debug2_INTERFACE_DEFINED__ +#define __ID3D12Debug2_INTERFACE_DEFINED__ + +/* interface ID3D12Debug2 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12Debug2; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("93a665c4-a3b2-4e5d-b692-a26ae14e3374") + ID3D12Debug2 : public IUnknown + { + public: + virtual void STDMETHODCALLTYPE SetGPUBasedValidationFlags( + D3D12_GPU_BASED_VALIDATION_FLAGS Flags) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12Debug2Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12Debug2 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12Debug2 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12Debug2 * This); + + void ( STDMETHODCALLTYPE *SetGPUBasedValidationFlags )( + ID3D12Debug2 * This, + D3D12_GPU_BASED_VALIDATION_FLAGS Flags); + + END_INTERFACE + } ID3D12Debug2Vtbl; + + interface ID3D12Debug2 + { + CONST_VTBL struct ID3D12Debug2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12Debug2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12Debug2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12Debug2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12Debug2_SetGPUBasedValidationFlags(This,Flags) \ + ( (This)->lpVtbl -> SetGPUBasedValidationFlags(This,Flags) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12Debug2_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12Debug3_INTERFACE_DEFINED__ +#define __ID3D12Debug3_INTERFACE_DEFINED__ + +/* interface ID3D12Debug3 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12Debug3; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("5cf4e58f-f671-4ff1-a542-3686e3d153d1") + ID3D12Debug3 : public ID3D12Debug + { + public: + virtual void STDMETHODCALLTYPE SetEnableGPUBasedValidation( + BOOL Enable) = 0; + + virtual void STDMETHODCALLTYPE SetEnableSynchronizedCommandQueueValidation( + BOOL Enable) = 0; + + virtual void STDMETHODCALLTYPE SetGPUBasedValidationFlags( + D3D12_GPU_BASED_VALIDATION_FLAGS Flags) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12Debug3Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12Debug3 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12Debug3 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12Debug3 * This); + + void ( STDMETHODCALLTYPE *EnableDebugLayer )( + ID3D12Debug3 * This); + + void ( STDMETHODCALLTYPE *SetEnableGPUBasedValidation )( + ID3D12Debug3 * This, + BOOL Enable); + + void ( STDMETHODCALLTYPE *SetEnableSynchronizedCommandQueueValidation )( + ID3D12Debug3 * This, + BOOL Enable); + + void ( STDMETHODCALLTYPE *SetGPUBasedValidationFlags )( + ID3D12Debug3 * This, + D3D12_GPU_BASED_VALIDATION_FLAGS Flags); + + END_INTERFACE + } ID3D12Debug3Vtbl; + + interface ID3D12Debug3 + { + CONST_VTBL struct ID3D12Debug3Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12Debug3_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12Debug3_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12Debug3_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12Debug3_EnableDebugLayer(This) \ + ( (This)->lpVtbl -> EnableDebugLayer(This) ) + + +#define ID3D12Debug3_SetEnableGPUBasedValidation(This,Enable) \ + ( (This)->lpVtbl -> SetEnableGPUBasedValidation(This,Enable) ) + +#define ID3D12Debug3_SetEnableSynchronizedCommandQueueValidation(This,Enable) \ + ( (This)->lpVtbl -> SetEnableSynchronizedCommandQueueValidation(This,Enable) ) + +#define ID3D12Debug3_SetGPUBasedValidationFlags(This,Flags) \ + ( (This)->lpVtbl -> SetGPUBasedValidationFlags(This,Flags) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12Debug3_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12sdklayers_0000_0004 */ +/* [local] */ + +typedef +enum D3D12_RLDO_FLAGS + { + D3D12_RLDO_NONE = 0, + D3D12_RLDO_SUMMARY = 0x1, + D3D12_RLDO_DETAIL = 0x2, + D3D12_RLDO_IGNORE_INTERNAL = 0x4 + } D3D12_RLDO_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS(D3D12_RLDO_FLAGS) +typedef +enum D3D12_DEBUG_DEVICE_PARAMETER_TYPE + { + D3D12_DEBUG_DEVICE_PARAMETER_FEATURE_FLAGS = 0, + D3D12_DEBUG_DEVICE_PARAMETER_GPU_BASED_VALIDATION_SETTINGS = ( D3D12_DEBUG_DEVICE_PARAMETER_FEATURE_FLAGS + 1 ) , + D3D12_DEBUG_DEVICE_PARAMETER_GPU_SLOWDOWN_PERFORMANCE_FACTOR = ( D3D12_DEBUG_DEVICE_PARAMETER_GPU_BASED_VALIDATION_SETTINGS + 1 ) + } D3D12_DEBUG_DEVICE_PARAMETER_TYPE; + +typedef +enum D3D12_DEBUG_FEATURE + { + D3D12_DEBUG_FEATURE_NONE = 0, + D3D12_DEBUG_FEATURE_ALLOW_BEHAVIOR_CHANGING_DEBUG_AIDS = 0x1, + D3D12_DEBUG_FEATURE_CONSERVATIVE_RESOURCE_STATE_TRACKING = 0x2, + D3D12_DEBUG_FEATURE_DISABLE_VIRTUALIZED_BUNDLES_VALIDATION = 0x4, + D3D12_DEBUG_FEATURE_EMULATE_WINDOWS7 = 0x8 + } D3D12_DEBUG_FEATURE; + +DEFINE_ENUM_FLAG_OPERATORS(D3D12_DEBUG_FEATURE) +typedef +enum D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE + { + D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_NONE = 0, + D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_STATE_TRACKING_ONLY = ( D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_NONE + 1 ) , + D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_UNGUARDED_VALIDATION = ( D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_STATE_TRACKING_ONLY + 1 ) , + D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_GUARDED_VALIDATION = ( D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_UNGUARDED_VALIDATION + 1 ) , + NUM_D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODES = ( D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_GUARDED_VALIDATION + 1 ) + } D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE; + +typedef +enum D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS + { + D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_NONE = 0, + D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_TRACKING_ONLY_SHADERS = 0x1, + D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_UNGUARDED_VALIDATION_SHADERS = 0x2, + D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_GUARDED_VALIDATION_SHADERS = 0x4, + D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS_VALID_MASK = 0x7 + } D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS(D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS) +typedef struct D3D12_DEBUG_DEVICE_GPU_BASED_VALIDATION_SETTINGS + { + UINT MaxMessagesPerCommandList; + D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE DefaultShaderPatchMode; + D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS PipelineStateCreateFlags; + } D3D12_DEBUG_DEVICE_GPU_BASED_VALIDATION_SETTINGS; + +typedef struct D3D12_DEBUG_DEVICE_GPU_SLOWDOWN_PERFORMANCE_FACTOR + { + FLOAT SlowdownFactor; + } D3D12_DEBUG_DEVICE_GPU_SLOWDOWN_PERFORMANCE_FACTOR; + + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0004_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0004_v0_0_s_ifspec; + +#ifndef __ID3D12DebugDevice1_INTERFACE_DEFINED__ +#define __ID3D12DebugDevice1_INTERFACE_DEFINED__ + +/* interface ID3D12DebugDevice1 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12DebugDevice1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("a9b71770-d099-4a65-a698-3dee10020f88") + ID3D12DebugDevice1 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetDebugParameter( + D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type, + _In_reads_bytes_(DataSize) const void *pData, + UINT DataSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDebugParameter( + D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type, + _Out_writes_bytes_(DataSize) void *pData, + UINT DataSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE ReportLiveDeviceObjects( + D3D12_RLDO_FLAGS Flags) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12DebugDevice1Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12DebugDevice1 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12DebugDevice1 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12DebugDevice1 * This); + + HRESULT ( STDMETHODCALLTYPE *SetDebugParameter )( + ID3D12DebugDevice1 * This, + D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type, + _In_reads_bytes_(DataSize) const void *pData, + UINT DataSize); + + HRESULT ( STDMETHODCALLTYPE *GetDebugParameter )( + ID3D12DebugDevice1 * This, + D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type, + _Out_writes_bytes_(DataSize) void *pData, + UINT DataSize); + + HRESULT ( STDMETHODCALLTYPE *ReportLiveDeviceObjects )( + ID3D12DebugDevice1 * This, + D3D12_RLDO_FLAGS Flags); + + END_INTERFACE + } ID3D12DebugDevice1Vtbl; + + interface ID3D12DebugDevice1 + { + CONST_VTBL struct ID3D12DebugDevice1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12DebugDevice1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12DebugDevice1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12DebugDevice1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12DebugDevice1_SetDebugParameter(This,Type,pData,DataSize) \ + ( (This)->lpVtbl -> SetDebugParameter(This,Type,pData,DataSize) ) + +#define ID3D12DebugDevice1_GetDebugParameter(This,Type,pData,DataSize) \ + ( (This)->lpVtbl -> GetDebugParameter(This,Type,pData,DataSize) ) + +#define ID3D12DebugDevice1_ReportLiveDeviceObjects(This,Flags) \ + ( (This)->lpVtbl -> ReportLiveDeviceObjects(This,Flags) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12DebugDevice1_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12DebugDevice_INTERFACE_DEFINED__ +#define __ID3D12DebugDevice_INTERFACE_DEFINED__ + +/* interface ID3D12DebugDevice */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12DebugDevice; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("3febd6dd-4973-4787-8194-e45f9e28923e") + ID3D12DebugDevice : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetFeatureMask( + D3D12_DEBUG_FEATURE Mask) = 0; + + virtual D3D12_DEBUG_FEATURE STDMETHODCALLTYPE GetFeatureMask( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE ReportLiveDeviceObjects( + D3D12_RLDO_FLAGS Flags) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12DebugDeviceVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12DebugDevice * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12DebugDevice * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12DebugDevice * This); + + HRESULT ( STDMETHODCALLTYPE *SetFeatureMask )( + ID3D12DebugDevice * This, + D3D12_DEBUG_FEATURE Mask); + + D3D12_DEBUG_FEATURE ( STDMETHODCALLTYPE *GetFeatureMask )( + ID3D12DebugDevice * This); + + HRESULT ( STDMETHODCALLTYPE *ReportLiveDeviceObjects )( + ID3D12DebugDevice * This, + D3D12_RLDO_FLAGS Flags); + + END_INTERFACE + } ID3D12DebugDeviceVtbl; + + interface ID3D12DebugDevice + { + CONST_VTBL struct ID3D12DebugDeviceVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12DebugDevice_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12DebugDevice_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12DebugDevice_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12DebugDevice_SetFeatureMask(This,Mask) \ + ( (This)->lpVtbl -> SetFeatureMask(This,Mask) ) + +#define ID3D12DebugDevice_GetFeatureMask(This) \ + ( (This)->lpVtbl -> GetFeatureMask(This) ) + +#define ID3D12DebugDevice_ReportLiveDeviceObjects(This,Flags) \ + ( (This)->lpVtbl -> ReportLiveDeviceObjects(This,Flags) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12DebugDevice_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12DebugDevice2_INTERFACE_DEFINED__ +#define __ID3D12DebugDevice2_INTERFACE_DEFINED__ + +/* interface ID3D12DebugDevice2 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12DebugDevice2; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("60eccbc1-378d-4df1-894c-f8ac5ce4d7dd") + ID3D12DebugDevice2 : public ID3D12DebugDevice + { + public: + virtual HRESULT STDMETHODCALLTYPE SetDebugParameter( + D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type, + _In_reads_bytes_(DataSize) const void *pData, + UINT DataSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDebugParameter( + D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type, + _Out_writes_bytes_(DataSize) void *pData, + UINT DataSize) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12DebugDevice2Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12DebugDevice2 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12DebugDevice2 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12DebugDevice2 * This); + + HRESULT ( STDMETHODCALLTYPE *SetFeatureMask )( + ID3D12DebugDevice2 * This, + D3D12_DEBUG_FEATURE Mask); + + D3D12_DEBUG_FEATURE ( STDMETHODCALLTYPE *GetFeatureMask )( + ID3D12DebugDevice2 * This); + + HRESULT ( STDMETHODCALLTYPE *ReportLiveDeviceObjects )( + ID3D12DebugDevice2 * This, + D3D12_RLDO_FLAGS Flags); + + HRESULT ( STDMETHODCALLTYPE *SetDebugParameter )( + ID3D12DebugDevice2 * This, + D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type, + _In_reads_bytes_(DataSize) const void *pData, + UINT DataSize); + + HRESULT ( STDMETHODCALLTYPE *GetDebugParameter )( + ID3D12DebugDevice2 * This, + D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type, + _Out_writes_bytes_(DataSize) void *pData, + UINT DataSize); + + END_INTERFACE + } ID3D12DebugDevice2Vtbl; + + interface ID3D12DebugDevice2 + { + CONST_VTBL struct ID3D12DebugDevice2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12DebugDevice2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12DebugDevice2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12DebugDevice2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12DebugDevice2_SetFeatureMask(This,Mask) \ + ( (This)->lpVtbl -> SetFeatureMask(This,Mask) ) + +#define ID3D12DebugDevice2_GetFeatureMask(This) \ + ( (This)->lpVtbl -> GetFeatureMask(This) ) + +#define ID3D12DebugDevice2_ReportLiveDeviceObjects(This,Flags) \ + ( (This)->lpVtbl -> ReportLiveDeviceObjects(This,Flags) ) + + +#define ID3D12DebugDevice2_SetDebugParameter(This,Type,pData,DataSize) \ + ( (This)->lpVtbl -> SetDebugParameter(This,Type,pData,DataSize) ) + +#define ID3D12DebugDevice2_GetDebugParameter(This,Type,pData,DataSize) \ + ( (This)->lpVtbl -> GetDebugParameter(This,Type,pData,DataSize) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12DebugDevice2_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12sdklayers_0000_0007 */ +/* [local] */ + +DEFINE_GUID(DXGI_DEBUG_D3D12, 0xcf59a98c, 0xa950, 0x4326, 0x91, 0xef, 0x9b, 0xba, 0xa1, 0x7b, 0xfd, 0x95); + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0007_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0007_v0_0_s_ifspec; + +#ifndef __ID3D12DebugCommandQueue_INTERFACE_DEFINED__ +#define __ID3D12DebugCommandQueue_INTERFACE_DEFINED__ + +/* interface ID3D12DebugCommandQueue */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12DebugCommandQueue; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("09e0bf36-54ac-484f-8847-4baeeab6053a") + ID3D12DebugCommandQueue : public IUnknown + { + public: + virtual BOOL STDMETHODCALLTYPE AssertResourceState( + _In_ ID3D12Resource *pResource, + UINT Subresource, + UINT State) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12DebugCommandQueueVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12DebugCommandQueue * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12DebugCommandQueue * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12DebugCommandQueue * This); + + BOOL ( STDMETHODCALLTYPE *AssertResourceState )( + ID3D12DebugCommandQueue * This, + _In_ ID3D12Resource *pResource, + UINT Subresource, + UINT State); + + END_INTERFACE + } ID3D12DebugCommandQueueVtbl; + + interface ID3D12DebugCommandQueue + { + CONST_VTBL struct ID3D12DebugCommandQueueVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12DebugCommandQueue_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12DebugCommandQueue_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12DebugCommandQueue_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12DebugCommandQueue_AssertResourceState(This,pResource,Subresource,State) \ + ( (This)->lpVtbl -> AssertResourceState(This,pResource,Subresource,State) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12DebugCommandQueue_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12sdklayers_0000_0008 */ +/* [local] */ + +typedef +enum D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE + { + D3D12_DEBUG_COMMAND_LIST_PARAMETER_GPU_BASED_VALIDATION_SETTINGS = 0 + } D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE; + +typedef struct D3D12_DEBUG_COMMAND_LIST_GPU_BASED_VALIDATION_SETTINGS + { + D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE ShaderPatchMode; + } D3D12_DEBUG_COMMAND_LIST_GPU_BASED_VALIDATION_SETTINGS; + + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0008_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0008_v0_0_s_ifspec; + +#ifndef __ID3D12DebugCommandList1_INTERFACE_DEFINED__ +#define __ID3D12DebugCommandList1_INTERFACE_DEFINED__ + +/* interface ID3D12DebugCommandList1 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12DebugCommandList1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("102ca951-311b-4b01-b11f-ecb83e061b37") + ID3D12DebugCommandList1 : public IUnknown + { + public: + virtual BOOL STDMETHODCALLTYPE AssertResourceState( + _In_ ID3D12Resource *pResource, + UINT Subresource, + UINT State) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetDebugParameter( + D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type, + _In_reads_bytes_(DataSize) const void *pData, + UINT DataSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDebugParameter( + D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type, + _Out_writes_bytes_(DataSize) void *pData, + UINT DataSize) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12DebugCommandList1Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12DebugCommandList1 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12DebugCommandList1 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12DebugCommandList1 * This); + + BOOL ( STDMETHODCALLTYPE *AssertResourceState )( + ID3D12DebugCommandList1 * This, + _In_ ID3D12Resource *pResource, + UINT Subresource, + UINT State); + + HRESULT ( STDMETHODCALLTYPE *SetDebugParameter )( + ID3D12DebugCommandList1 * This, + D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type, + _In_reads_bytes_(DataSize) const void *pData, + UINT DataSize); + + HRESULT ( STDMETHODCALLTYPE *GetDebugParameter )( + ID3D12DebugCommandList1 * This, + D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type, + _Out_writes_bytes_(DataSize) void *pData, + UINT DataSize); + + END_INTERFACE + } ID3D12DebugCommandList1Vtbl; + + interface ID3D12DebugCommandList1 + { + CONST_VTBL struct ID3D12DebugCommandList1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12DebugCommandList1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12DebugCommandList1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12DebugCommandList1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12DebugCommandList1_AssertResourceState(This,pResource,Subresource,State) \ + ( (This)->lpVtbl -> AssertResourceState(This,pResource,Subresource,State) ) + +#define ID3D12DebugCommandList1_SetDebugParameter(This,Type,pData,DataSize) \ + ( (This)->lpVtbl -> SetDebugParameter(This,Type,pData,DataSize) ) + +#define ID3D12DebugCommandList1_GetDebugParameter(This,Type,pData,DataSize) \ + ( (This)->lpVtbl -> GetDebugParameter(This,Type,pData,DataSize) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12DebugCommandList1_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12DebugCommandList_INTERFACE_DEFINED__ +#define __ID3D12DebugCommandList_INTERFACE_DEFINED__ + +/* interface ID3D12DebugCommandList */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12DebugCommandList; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("09e0bf36-54ac-484f-8847-4baeeab6053f") + ID3D12DebugCommandList : public IUnknown + { + public: + virtual BOOL STDMETHODCALLTYPE AssertResourceState( + _In_ ID3D12Resource *pResource, + UINT Subresource, + UINT State) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetFeatureMask( + D3D12_DEBUG_FEATURE Mask) = 0; + + virtual D3D12_DEBUG_FEATURE STDMETHODCALLTYPE GetFeatureMask( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12DebugCommandListVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12DebugCommandList * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12DebugCommandList * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12DebugCommandList * This); + + BOOL ( STDMETHODCALLTYPE *AssertResourceState )( + ID3D12DebugCommandList * This, + _In_ ID3D12Resource *pResource, + UINT Subresource, + UINT State); + + HRESULT ( STDMETHODCALLTYPE *SetFeatureMask )( + ID3D12DebugCommandList * This, + D3D12_DEBUG_FEATURE Mask); + + D3D12_DEBUG_FEATURE ( STDMETHODCALLTYPE *GetFeatureMask )( + ID3D12DebugCommandList * This); + + END_INTERFACE + } ID3D12DebugCommandListVtbl; + + interface ID3D12DebugCommandList + { + CONST_VTBL struct ID3D12DebugCommandListVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12DebugCommandList_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12DebugCommandList_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12DebugCommandList_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12DebugCommandList_AssertResourceState(This,pResource,Subresource,State) \ + ( (This)->lpVtbl -> AssertResourceState(This,pResource,Subresource,State) ) + +#define ID3D12DebugCommandList_SetFeatureMask(This,Mask) \ + ( (This)->lpVtbl -> SetFeatureMask(This,Mask) ) + +#define ID3D12DebugCommandList_GetFeatureMask(This) \ + ( (This)->lpVtbl -> GetFeatureMask(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12DebugCommandList_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12DebugCommandList2_INTERFACE_DEFINED__ +#define __ID3D12DebugCommandList2_INTERFACE_DEFINED__ + +/* interface ID3D12DebugCommandList2 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12DebugCommandList2; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("aeb575cf-4e06-48be-ba3b-c450fc96652e") + ID3D12DebugCommandList2 : public ID3D12DebugCommandList + { + public: + virtual HRESULT STDMETHODCALLTYPE SetDebugParameter( + D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type, + _In_reads_bytes_(DataSize) const void *pData, + UINT DataSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDebugParameter( + D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type, + _Out_writes_bytes_(DataSize) void *pData, + UINT DataSize) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12DebugCommandList2Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12DebugCommandList2 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12DebugCommandList2 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12DebugCommandList2 * This); + + BOOL ( STDMETHODCALLTYPE *AssertResourceState )( + ID3D12DebugCommandList2 * This, + _In_ ID3D12Resource *pResource, + UINT Subresource, + UINT State); + + HRESULT ( STDMETHODCALLTYPE *SetFeatureMask )( + ID3D12DebugCommandList2 * This, + D3D12_DEBUG_FEATURE Mask); + + D3D12_DEBUG_FEATURE ( STDMETHODCALLTYPE *GetFeatureMask )( + ID3D12DebugCommandList2 * This); + + HRESULT ( STDMETHODCALLTYPE *SetDebugParameter )( + ID3D12DebugCommandList2 * This, + D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type, + _In_reads_bytes_(DataSize) const void *pData, + UINT DataSize); + + HRESULT ( STDMETHODCALLTYPE *GetDebugParameter )( + ID3D12DebugCommandList2 * This, + D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type, + _Out_writes_bytes_(DataSize) void *pData, + UINT DataSize); + + END_INTERFACE + } ID3D12DebugCommandList2Vtbl; + + interface ID3D12DebugCommandList2 + { + CONST_VTBL struct ID3D12DebugCommandList2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12DebugCommandList2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12DebugCommandList2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12DebugCommandList2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12DebugCommandList2_AssertResourceState(This,pResource,Subresource,State) \ + ( (This)->lpVtbl -> AssertResourceState(This,pResource,Subresource,State) ) + +#define ID3D12DebugCommandList2_SetFeatureMask(This,Mask) \ + ( (This)->lpVtbl -> SetFeatureMask(This,Mask) ) + +#define ID3D12DebugCommandList2_GetFeatureMask(This) \ + ( (This)->lpVtbl -> GetFeatureMask(This) ) + + +#define ID3D12DebugCommandList2_SetDebugParameter(This,Type,pData,DataSize) \ + ( (This)->lpVtbl -> SetDebugParameter(This,Type,pData,DataSize) ) + +#define ID3D12DebugCommandList2_GetDebugParameter(This,Type,pData,DataSize) \ + ( (This)->lpVtbl -> GetDebugParameter(This,Type,pData,DataSize) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12DebugCommandList2_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12SharingContract_INTERFACE_DEFINED__ +#define __ID3D12SharingContract_INTERFACE_DEFINED__ + +/* interface ID3D12SharingContract */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12SharingContract; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("0adf7d52-929c-4e61-addb-ffed30de66ef") + ID3D12SharingContract : public IUnknown + { + public: + virtual void STDMETHODCALLTYPE Present( + _In_ ID3D12Resource *pResource, + UINT Subresource, + _In_ HWND window) = 0; + + virtual void STDMETHODCALLTYPE SharedFenceSignal( + _In_ ID3D12Fence *pFence, + UINT64 FenceValue) = 0; + + virtual void STDMETHODCALLTYPE BeginCapturableWork( + _In_ REFGUID guid) = 0; + + virtual void STDMETHODCALLTYPE EndCapturableWork( + _In_ REFGUID guid) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12SharingContractVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12SharingContract * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12SharingContract * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12SharingContract * This); + + void ( STDMETHODCALLTYPE *Present )( + ID3D12SharingContract * This, + _In_ ID3D12Resource *pResource, + UINT Subresource, + _In_ HWND window); + + void ( STDMETHODCALLTYPE *SharedFenceSignal )( + ID3D12SharingContract * This, + _In_ ID3D12Fence *pFence, + UINT64 FenceValue); + + void ( STDMETHODCALLTYPE *BeginCapturableWork )( + ID3D12SharingContract * This, + _In_ REFGUID guid); + + void ( STDMETHODCALLTYPE *EndCapturableWork )( + ID3D12SharingContract * This, + _In_ REFGUID guid); + + END_INTERFACE + } ID3D12SharingContractVtbl; + + interface ID3D12SharingContract + { + CONST_VTBL struct ID3D12SharingContractVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12SharingContract_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12SharingContract_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12SharingContract_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12SharingContract_Present(This,pResource,Subresource,window) \ + ( (This)->lpVtbl -> Present(This,pResource,Subresource,window) ) + +#define ID3D12SharingContract_SharedFenceSignal(This,pFence,FenceValue) \ + ( (This)->lpVtbl -> SharedFenceSignal(This,pFence,FenceValue) ) + +#define ID3D12SharingContract_BeginCapturableWork(This,guid) \ + ( (This)->lpVtbl -> BeginCapturableWork(This,guid) ) + +#define ID3D12SharingContract_EndCapturableWork(This,guid) \ + ( (This)->lpVtbl -> EndCapturableWork(This,guid) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12SharingContract_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12sdklayers_0000_0012 */ +/* [local] */ + +typedef +enum D3D12_MESSAGE_CATEGORY + { + D3D12_MESSAGE_CATEGORY_APPLICATION_DEFINED = 0, + D3D12_MESSAGE_CATEGORY_MISCELLANEOUS = ( D3D12_MESSAGE_CATEGORY_APPLICATION_DEFINED + 1 ) , + D3D12_MESSAGE_CATEGORY_INITIALIZATION = ( D3D12_MESSAGE_CATEGORY_MISCELLANEOUS + 1 ) , + D3D12_MESSAGE_CATEGORY_CLEANUP = ( D3D12_MESSAGE_CATEGORY_INITIALIZATION + 1 ) , + D3D12_MESSAGE_CATEGORY_COMPILATION = ( D3D12_MESSAGE_CATEGORY_CLEANUP + 1 ) , + D3D12_MESSAGE_CATEGORY_STATE_CREATION = ( D3D12_MESSAGE_CATEGORY_COMPILATION + 1 ) , + D3D12_MESSAGE_CATEGORY_STATE_SETTING = ( D3D12_MESSAGE_CATEGORY_STATE_CREATION + 1 ) , + D3D12_MESSAGE_CATEGORY_STATE_GETTING = ( D3D12_MESSAGE_CATEGORY_STATE_SETTING + 1 ) , + D3D12_MESSAGE_CATEGORY_RESOURCE_MANIPULATION = ( D3D12_MESSAGE_CATEGORY_STATE_GETTING + 1 ) , + D3D12_MESSAGE_CATEGORY_EXECUTION = ( D3D12_MESSAGE_CATEGORY_RESOURCE_MANIPULATION + 1 ) , + D3D12_MESSAGE_CATEGORY_SHADER = ( D3D12_MESSAGE_CATEGORY_EXECUTION + 1 ) + } D3D12_MESSAGE_CATEGORY; + +typedef +enum D3D12_MESSAGE_SEVERITY + { + D3D12_MESSAGE_SEVERITY_CORRUPTION = 0, + D3D12_MESSAGE_SEVERITY_ERROR = ( D3D12_MESSAGE_SEVERITY_CORRUPTION + 1 ) , + D3D12_MESSAGE_SEVERITY_WARNING = ( D3D12_MESSAGE_SEVERITY_ERROR + 1 ) , + D3D12_MESSAGE_SEVERITY_INFO = ( D3D12_MESSAGE_SEVERITY_WARNING + 1 ) , + D3D12_MESSAGE_SEVERITY_MESSAGE = ( D3D12_MESSAGE_SEVERITY_INFO + 1 ) + } D3D12_MESSAGE_SEVERITY; + +typedef +enum D3D12_MESSAGE_ID + { + D3D12_MESSAGE_ID_UNKNOWN = 0, + D3D12_MESSAGE_ID_STRING_FROM_APPLICATION = ( D3D12_MESSAGE_ID_UNKNOWN + 1 ) , + D3D12_MESSAGE_ID_CORRUPTED_THIS = ( D3D12_MESSAGE_ID_STRING_FROM_APPLICATION + 1 ) , + D3D12_MESSAGE_ID_CORRUPTED_PARAMETER1 = ( D3D12_MESSAGE_ID_CORRUPTED_THIS + 1 ) , + D3D12_MESSAGE_ID_CORRUPTED_PARAMETER2 = ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER1 + 1 ) , + D3D12_MESSAGE_ID_CORRUPTED_PARAMETER3 = ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER2 + 1 ) , + D3D12_MESSAGE_ID_CORRUPTED_PARAMETER4 = ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER3 + 1 ) , + D3D12_MESSAGE_ID_CORRUPTED_PARAMETER5 = ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER4 + 1 ) , + D3D12_MESSAGE_ID_CORRUPTED_PARAMETER6 = ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER5 + 1 ) , + D3D12_MESSAGE_ID_CORRUPTED_PARAMETER7 = ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER6 + 1 ) , + D3D12_MESSAGE_ID_CORRUPTED_PARAMETER8 = ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER7 + 1 ) , + D3D12_MESSAGE_ID_CORRUPTED_PARAMETER9 = ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER8 + 1 ) , + D3D12_MESSAGE_ID_CORRUPTED_PARAMETER10 = ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER9 + 1 ) , + D3D12_MESSAGE_ID_CORRUPTED_PARAMETER11 = ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER10 + 1 ) , + D3D12_MESSAGE_ID_CORRUPTED_PARAMETER12 = ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER11 + 1 ) , + D3D12_MESSAGE_ID_CORRUPTED_PARAMETER13 = ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER12 + 1 ) , + D3D12_MESSAGE_ID_CORRUPTED_PARAMETER14 = ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER13 + 1 ) , + D3D12_MESSAGE_ID_CORRUPTED_PARAMETER15 = ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER14 + 1 ) , + D3D12_MESSAGE_ID_CORRUPTED_MULTITHREADING = ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER15 + 1 ) , + D3D12_MESSAGE_ID_MESSAGE_REPORTING_OUTOFMEMORY = ( D3D12_MESSAGE_ID_CORRUPTED_MULTITHREADING + 1 ) , + D3D12_MESSAGE_ID_GETPRIVATEDATA_MOREDATA = ( D3D12_MESSAGE_ID_MESSAGE_REPORTING_OUTOFMEMORY + 1 ) , + D3D12_MESSAGE_ID_SETPRIVATEDATA_INVALIDFREEDATA = ( D3D12_MESSAGE_ID_GETPRIVATEDATA_MOREDATA + 1 ) , + D3D12_MESSAGE_ID_SETPRIVATEDATA_INVALIDIUNKNOWN = ( D3D12_MESSAGE_ID_SETPRIVATEDATA_INVALIDFREEDATA + 1 ) , + D3D12_MESSAGE_ID_SETPRIVATEDATA_INVALIDFLAGS = ( D3D12_MESSAGE_ID_SETPRIVATEDATA_INVALIDIUNKNOWN + 1 ) , + D3D12_MESSAGE_ID_SETPRIVATEDATA_CHANGINGPARAMS = ( D3D12_MESSAGE_ID_SETPRIVATEDATA_INVALIDFLAGS + 1 ) , + D3D12_MESSAGE_ID_SETPRIVATEDATA_OUTOFMEMORY = ( D3D12_MESSAGE_ID_SETPRIVATEDATA_CHANGINGPARAMS + 1 ) , + D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_UNRECOGNIZEDFORMAT = ( D3D12_MESSAGE_ID_SETPRIVATEDATA_OUTOFMEMORY + 1 ) , + D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDESC = ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_UNRECOGNIZEDFORMAT + 1 ) , + D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDFORMAT = ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDESC + 1 ) , + D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDVIDEOPLANESLICE = ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDFORMAT + 1 ) , + D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDPLANESLICE = ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDVIDEOPLANESLICE + 1 ) , + D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDIMENSIONS = ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDPLANESLICE + 1 ) , + D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDRESOURCE = ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDIMENSIONS + 1 ) , + D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDARG_RETURN = ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDRESOURCE + 1 ) , + D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_OUTOFMEMORY_RETURN = ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDARG_RETURN + 1 ) , + D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_UNRECOGNIZEDFORMAT = ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_OUTOFMEMORY_RETURN + 1 ) , + D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_UNSUPPORTEDFORMAT = ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_UNRECOGNIZEDFORMAT + 1 ) , + D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDESC = ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_UNSUPPORTEDFORMAT + 1 ) , + D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDFORMAT = ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDESC + 1 ) , + D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDVIDEOPLANESLICE = ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDFORMAT + 1 ) , + D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDPLANESLICE = ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDVIDEOPLANESLICE + 1 ) , + D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDIMENSIONS = ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDPLANESLICE + 1 ) , + D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDRESOURCE = ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDIMENSIONS + 1 ) , + D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDARG_RETURN = ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDRESOURCE + 1 ) , + D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_OUTOFMEMORY_RETURN = ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDARG_RETURN + 1 ) , + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_UNRECOGNIZEDFORMAT = ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_OUTOFMEMORY_RETURN + 1 ) , + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDESC = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_UNRECOGNIZEDFORMAT + 1 ) , + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDFORMAT = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDESC + 1 ) , + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDIMENSIONS = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDFORMAT + 1 ) , + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDRESOURCE = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDIMENSIONS + 1 ) , + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDARG_RETURN = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDRESOURCE + 1 ) , + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_OUTOFMEMORY_RETURN = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDARG_RETURN + 1 ) , + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_OUTOFMEMORY = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_OUTOFMEMORY_RETURN + 1 ) , + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TOOMANYELEMENTS = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_OUTOFMEMORY + 1 ) , + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDFORMAT = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TOOMANYELEMENTS + 1 ) , + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INCOMPATIBLEFORMAT = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDFORMAT + 1 ) , + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOT = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INCOMPATIBLEFORMAT + 1 ) , + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDINPUTSLOTCLASS = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOT + 1 ) , + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_STEPRATESLOTCLASSMISMATCH = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDINPUTSLOTCLASS + 1 ) , + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOTCLASSCHANGE = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_STEPRATESLOTCLASSMISMATCH + 1 ) , + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSTEPRATECHANGE = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOTCLASSCHANGE + 1 ) , + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDALIGNMENT = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSTEPRATECHANGE + 1 ) , + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_DUPLICATESEMANTIC = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDALIGNMENT + 1 ) , + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_UNPARSEABLEINPUTSIGNATURE = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_DUPLICATESEMANTIC + 1 ) , + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_NULLSEMANTIC = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_UNPARSEABLEINPUTSIGNATURE + 1 ) , + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_MISSINGELEMENT = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_NULLSEMANTIC + 1 ) , + D3D12_MESSAGE_ID_CREATEVERTEXSHADER_OUTOFMEMORY = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_MISSINGELEMENT + 1 ) , + D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERBYTECODE = ( D3D12_MESSAGE_ID_CREATEVERTEXSHADER_OUTOFMEMORY + 1 ) , + D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERTYPE = ( D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERBYTECODE + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_OUTOFMEMORY = ( D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERTYPE + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERBYTECODE = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_OUTOFMEMORY + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERTYPE = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERBYTECODE + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTOFMEMORY = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERTYPE + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERBYTECODE = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTOFMEMORY + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERTYPE = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERBYTECODE + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMENTRIES = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERTYPE + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSTREAMSTRIDEUNUSED = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMENTRIES + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDDECL = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSTREAMSTRIDEUNUSED + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_EXPECTEDDECL = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDDECL + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSLOT0EXPECTED = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_EXPECTEDDECL + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSLOT = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSLOT0EXPECTED + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_ONLYONEELEMENTPERSLOT = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSLOT + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDCOMPONENTCOUNT = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_ONLYONEELEMENTPERSLOT + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTARTCOMPONENTANDCOMPONENTCOUNT = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDCOMPONENTCOUNT + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDGAPDEFINITION = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTARTCOMPONENTANDCOMPONENTCOUNT + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_REPEATEDOUTPUT = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDGAPDEFINITION + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSTREAMSTRIDE = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_REPEATEDOUTPUT + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGSEMANTIC = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSTREAMSTRIDE + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MASKMISMATCH = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGSEMANTIC + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_CANTHAVEONLYGAPS = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MASKMISMATCH + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DECLTOOCOMPLEX = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_CANTHAVEONLYGAPS + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGOUTPUTSIGNATURE = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DECLTOOCOMPLEX + 1 ) , + D3D12_MESSAGE_ID_CREATEPIXELSHADER_OUTOFMEMORY = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGOUTPUTSIGNATURE + 1 ) , + D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERBYTECODE = ( D3D12_MESSAGE_ID_CREATEPIXELSHADER_OUTOFMEMORY + 1 ) , + D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERTYPE = ( D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERBYTECODE + 1 ) , + D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDFILLMODE = ( D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERTYPE + 1 ) , + D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDCULLMODE = ( D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDFILLMODE + 1 ) , + D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDDEPTHBIASCLAMP = ( D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDCULLMODE + 1 ) , + D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDSLOPESCALEDDEPTHBIAS = ( D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDDEPTHBIASCLAMP + 1 ) , + D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_NULLDESC = ( D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDSLOPESCALEDDEPTHBIAS + 1 ) , + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHWRITEMASK = ( D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_NULLDESC + 1 ) , + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHFUNC = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHWRITEMASK + 1 ) , + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFAILOP = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHFUNC + 1 ) , + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILZFAILOP = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFAILOP + 1 ) , + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILPASSOP = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILZFAILOP + 1 ) , + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFUNC = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILPASSOP + 1 ) , + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFAILOP = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFUNC + 1 ) , + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILZFAILOP = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFAILOP + 1 ) , + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILPASSOP = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILZFAILOP + 1 ) , + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFUNC = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILPASSOP + 1 ) , + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_NULLDESC = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFUNC + 1 ) , + D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLEND = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_NULLDESC + 1 ) , + D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLEND = ( D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLEND + 1 ) , + D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOP = ( D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLEND + 1 ) , + D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLENDALPHA = ( D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOP + 1 ) , + D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLENDALPHA = ( D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLENDALPHA + 1 ) , + D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOPALPHA = ( D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLENDALPHA + 1 ) , + D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDRENDERTARGETWRITEMASK = ( D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOPALPHA + 1 ) , + D3D12_MESSAGE_ID_CREATEBLENDSTATE_NULLDESC = ( D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDRENDERTARGETWRITEMASK + 1 ) , + D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDFILTER = ( D3D12_MESSAGE_ID_CREATEBLENDSTATE_NULLDESC + 1 ) , + D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSU = ( D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDFILTER + 1 ) , + D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSV = ( D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSU + 1 ) , + D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSW = ( D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSV + 1 ) , + D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMIPLODBIAS = ( D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSW + 1 ) , + D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMAXANISOTROPY = ( D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMIPLODBIAS + 1 ) , + D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDCOMPARISONFUNC = ( D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMAXANISOTROPY + 1 ) , + D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMINLOD = ( D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDCOMPARISONFUNC + 1 ) , + D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMAXLOD = ( D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMINLOD + 1 ) , + D3D12_MESSAGE_ID_CREATESAMPLERSTATE_NULLDESC = ( D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMAXLOD + 1 ) , + D3D12_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNRECOGNIZED = ( D3D12_MESSAGE_ID_CREATESAMPLERSTATE_NULLDESC + 1 ) , + D3D12_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNDEFINED = ( D3D12_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNRECOGNIZED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_RSSETVIEWPORTS_INVALIDVIEWPORT = ( D3D12_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNDEFINED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_RSSETSCISSORRECTS_INVALIDSCISSOR = ( D3D12_MESSAGE_ID_DEVICE_RSSETVIEWPORTS_INVALIDVIEWPORT + 1 ) , + D3D12_MESSAGE_ID_CLEARRENDERTARGETVIEW_DENORMFLUSH = ( D3D12_MESSAGE_ID_DEVICE_RSSETSCISSORRECTS_INVALIDSCISSOR + 1 ) , + D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_DENORMFLUSH = ( D3D12_MESSAGE_ID_CLEARRENDERTARGETVIEW_DENORMFLUSH + 1 ) , + D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_INVALID = ( D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_DENORMFLUSH + 1 ) , + D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDSOURCE = ( D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_INVALID + 1 ) , + D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDDESTINATIONSTATE = ( D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDSOURCE + 1 ) , + D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDSOURCESTATE = ( D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDDESTINATIONSTATE + 1 ) , + D3D12_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONSUBRESOURCE = ( D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDSOURCESTATE + 1 ) , + D3D12_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONBOX = ( D3D12_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONSUBRESOURCE + 1 ) , + D3D12_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONSTATE = ( D3D12_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONBOX + 1 ) , + D3D12_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_DESTINATION_INVALID = ( D3D12_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONSTATE + 1 ) , + D3D12_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_DESTINATION_SUBRESOURCE_INVALID = ( D3D12_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_DESTINATION_INVALID + 1 ) , + D3D12_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_SOURCE_INVALID = ( D3D12_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_DESTINATION_SUBRESOURCE_INVALID + 1 ) , + D3D12_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_SOURCE_SUBRESOURCE_INVALID = ( D3D12_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_SOURCE_INVALID + 1 ) , + D3D12_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_FORMAT_INVALID = ( D3D12_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_SOURCE_SUBRESOURCE_INVALID + 1 ) , + D3D12_MESSAGE_ID_BUFFER_MAP_INVALIDMAPTYPE = ( D3D12_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_FORMAT_INVALID + 1 ) , + D3D12_MESSAGE_ID_BUFFER_MAP_INVALIDFLAGS = ( D3D12_MESSAGE_ID_BUFFER_MAP_INVALIDMAPTYPE + 1 ) , + D3D12_MESSAGE_ID_BUFFER_MAP_ALREADYMAPPED = ( D3D12_MESSAGE_ID_BUFFER_MAP_INVALIDFLAGS + 1 ) , + D3D12_MESSAGE_ID_BUFFER_MAP_DEVICEREMOVED_RETURN = ( D3D12_MESSAGE_ID_BUFFER_MAP_ALREADYMAPPED + 1 ) , + D3D12_MESSAGE_ID_BUFFER_UNMAP_NOTMAPPED = ( D3D12_MESSAGE_ID_BUFFER_MAP_DEVICEREMOVED_RETURN + 1 ) , + D3D12_MESSAGE_ID_TEXTURE1D_MAP_INVALIDMAPTYPE = ( D3D12_MESSAGE_ID_BUFFER_UNMAP_NOTMAPPED + 1 ) , + D3D12_MESSAGE_ID_TEXTURE1D_MAP_INVALIDSUBRESOURCE = ( D3D12_MESSAGE_ID_TEXTURE1D_MAP_INVALIDMAPTYPE + 1 ) , + D3D12_MESSAGE_ID_TEXTURE1D_MAP_INVALIDFLAGS = ( D3D12_MESSAGE_ID_TEXTURE1D_MAP_INVALIDSUBRESOURCE + 1 ) , + D3D12_MESSAGE_ID_TEXTURE1D_MAP_ALREADYMAPPED = ( D3D12_MESSAGE_ID_TEXTURE1D_MAP_INVALIDFLAGS + 1 ) , + D3D12_MESSAGE_ID_TEXTURE1D_MAP_DEVICEREMOVED_RETURN = ( D3D12_MESSAGE_ID_TEXTURE1D_MAP_ALREADYMAPPED + 1 ) , + D3D12_MESSAGE_ID_TEXTURE1D_UNMAP_INVALIDSUBRESOURCE = ( D3D12_MESSAGE_ID_TEXTURE1D_MAP_DEVICEREMOVED_RETURN + 1 ) , + D3D12_MESSAGE_ID_TEXTURE1D_UNMAP_NOTMAPPED = ( D3D12_MESSAGE_ID_TEXTURE1D_UNMAP_INVALIDSUBRESOURCE + 1 ) , + D3D12_MESSAGE_ID_TEXTURE2D_MAP_INVALIDMAPTYPE = ( D3D12_MESSAGE_ID_TEXTURE1D_UNMAP_NOTMAPPED + 1 ) , + D3D12_MESSAGE_ID_TEXTURE2D_MAP_INVALIDSUBRESOURCE = ( D3D12_MESSAGE_ID_TEXTURE2D_MAP_INVALIDMAPTYPE + 1 ) , + D3D12_MESSAGE_ID_TEXTURE2D_MAP_INVALIDFLAGS = ( D3D12_MESSAGE_ID_TEXTURE2D_MAP_INVALIDSUBRESOURCE + 1 ) , + D3D12_MESSAGE_ID_TEXTURE2D_MAP_ALREADYMAPPED = ( D3D12_MESSAGE_ID_TEXTURE2D_MAP_INVALIDFLAGS + 1 ) , + D3D12_MESSAGE_ID_TEXTURE2D_MAP_DEVICEREMOVED_RETURN = ( D3D12_MESSAGE_ID_TEXTURE2D_MAP_ALREADYMAPPED + 1 ) , + D3D12_MESSAGE_ID_TEXTURE2D_UNMAP_INVALIDSUBRESOURCE = ( D3D12_MESSAGE_ID_TEXTURE2D_MAP_DEVICEREMOVED_RETURN + 1 ) , + D3D12_MESSAGE_ID_TEXTURE2D_UNMAP_NOTMAPPED = ( D3D12_MESSAGE_ID_TEXTURE2D_UNMAP_INVALIDSUBRESOURCE + 1 ) , + D3D12_MESSAGE_ID_TEXTURE3D_MAP_INVALIDMAPTYPE = ( D3D12_MESSAGE_ID_TEXTURE2D_UNMAP_NOTMAPPED + 1 ) , + D3D12_MESSAGE_ID_TEXTURE3D_MAP_INVALIDSUBRESOURCE = ( D3D12_MESSAGE_ID_TEXTURE3D_MAP_INVALIDMAPTYPE + 1 ) , + D3D12_MESSAGE_ID_TEXTURE3D_MAP_INVALIDFLAGS = ( D3D12_MESSAGE_ID_TEXTURE3D_MAP_INVALIDSUBRESOURCE + 1 ) , + D3D12_MESSAGE_ID_TEXTURE3D_MAP_ALREADYMAPPED = ( D3D12_MESSAGE_ID_TEXTURE3D_MAP_INVALIDFLAGS + 1 ) , + D3D12_MESSAGE_ID_TEXTURE3D_MAP_DEVICEREMOVED_RETURN = ( D3D12_MESSAGE_ID_TEXTURE3D_MAP_ALREADYMAPPED + 1 ) , + D3D12_MESSAGE_ID_TEXTURE3D_UNMAP_INVALIDSUBRESOURCE = ( D3D12_MESSAGE_ID_TEXTURE3D_MAP_DEVICEREMOVED_RETURN + 1 ) , + D3D12_MESSAGE_ID_TEXTURE3D_UNMAP_NOTMAPPED = ( D3D12_MESSAGE_ID_TEXTURE3D_UNMAP_INVALIDSUBRESOURCE + 1 ) , + D3D12_MESSAGE_ID_CHECKFORMATSUPPORT_FORMAT_DEPRECATED = ( D3D12_MESSAGE_ID_TEXTURE3D_UNMAP_NOTMAPPED + 1 ) , + D3D12_MESSAGE_ID_CHECKMULTISAMPLEQUALITYLEVELS_FORMAT_DEPRECATED = ( D3D12_MESSAGE_ID_CHECKFORMATSUPPORT_FORMAT_DEPRECATED + 1 ) , + D3D12_MESSAGE_ID_SETEXCEPTIONMODE_UNRECOGNIZEDFLAGS = ( D3D12_MESSAGE_ID_CHECKMULTISAMPLEQUALITYLEVELS_FORMAT_DEPRECATED + 1 ) , + D3D12_MESSAGE_ID_SETEXCEPTIONMODE_INVALIDARG_RETURN = ( D3D12_MESSAGE_ID_SETEXCEPTIONMODE_UNRECOGNIZEDFLAGS + 1 ) , + D3D12_MESSAGE_ID_SETEXCEPTIONMODE_DEVICEREMOVED_RETURN = ( D3D12_MESSAGE_ID_SETEXCEPTIONMODE_INVALIDARG_RETURN + 1 ) , + D3D12_MESSAGE_ID_REF_SIMULATING_INFINITELY_FAST_HARDWARE = ( D3D12_MESSAGE_ID_SETEXCEPTIONMODE_DEVICEREMOVED_RETURN + 1 ) , + D3D12_MESSAGE_ID_REF_THREADING_MODE = ( D3D12_MESSAGE_ID_REF_SIMULATING_INFINITELY_FAST_HARDWARE + 1 ) , + D3D12_MESSAGE_ID_REF_UMDRIVER_EXCEPTION = ( D3D12_MESSAGE_ID_REF_THREADING_MODE + 1 ) , + D3D12_MESSAGE_ID_REF_KMDRIVER_EXCEPTION = ( D3D12_MESSAGE_ID_REF_UMDRIVER_EXCEPTION + 1 ) , + D3D12_MESSAGE_ID_REF_HARDWARE_EXCEPTION = ( D3D12_MESSAGE_ID_REF_KMDRIVER_EXCEPTION + 1 ) , + D3D12_MESSAGE_ID_REF_ACCESSING_INDEXABLE_TEMP_OUT_OF_RANGE = ( D3D12_MESSAGE_ID_REF_HARDWARE_EXCEPTION + 1 ) , + D3D12_MESSAGE_ID_REF_PROBLEM_PARSING_SHADER = ( D3D12_MESSAGE_ID_REF_ACCESSING_INDEXABLE_TEMP_OUT_OF_RANGE + 1 ) , + D3D12_MESSAGE_ID_REF_OUT_OF_MEMORY = ( D3D12_MESSAGE_ID_REF_PROBLEM_PARSING_SHADER + 1 ) , + D3D12_MESSAGE_ID_REF_INFO = ( D3D12_MESSAGE_ID_REF_OUT_OF_MEMORY + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DRAW_VERTEXPOS_OVERFLOW = ( D3D12_MESSAGE_ID_REF_INFO + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DRAWINDEXED_INDEXPOS_OVERFLOW = ( D3D12_MESSAGE_ID_DEVICE_DRAW_VERTEXPOS_OVERFLOW + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DRAWINSTANCED_VERTEXPOS_OVERFLOW = ( D3D12_MESSAGE_ID_DEVICE_DRAWINDEXED_INDEXPOS_OVERFLOW + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DRAWINSTANCED_INSTANCEPOS_OVERFLOW = ( D3D12_MESSAGE_ID_DEVICE_DRAWINSTANCED_VERTEXPOS_OVERFLOW + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DRAWINDEXEDINSTANCED_INSTANCEPOS_OVERFLOW = ( D3D12_MESSAGE_ID_DEVICE_DRAWINSTANCED_INSTANCEPOS_OVERFLOW + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DRAWINDEXEDINSTANCED_INDEXPOS_OVERFLOW = ( D3D12_MESSAGE_ID_DEVICE_DRAWINDEXEDINSTANCED_INSTANCEPOS_OVERFLOW + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DRAW_VERTEX_SHADER_NOT_SET = ( D3D12_MESSAGE_ID_DEVICE_DRAWINDEXEDINSTANCED_INDEXPOS_OVERFLOW + 1 ) , + D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_SEMANTICNAME_NOT_FOUND = ( D3D12_MESSAGE_ID_DEVICE_DRAW_VERTEX_SHADER_NOT_SET + 1 ) , + D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_REGISTERINDEX = ( D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_SEMANTICNAME_NOT_FOUND + 1 ) , + D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_COMPONENTTYPE = ( D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_REGISTERINDEX + 1 ) , + D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_REGISTERMASK = ( D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_COMPONENTTYPE + 1 ) , + D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_SYSTEMVALUE = ( D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_REGISTERMASK + 1 ) , + D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_NEVERWRITTEN_ALWAYSREADS = ( D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_SYSTEMVALUE + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_ROOT_SIGNATURE_NOT_SET = ( D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_NEVERWRITTEN_ALWAYSREADS + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_ROOT_SIGNATURE_MISMATCH = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_ROOT_SIGNATURE_NOT_SET + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_NOT_SET = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_ROOT_SIGNATURE_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INPUTLAYOUT_NOT_SET = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_NOT_SET + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_CONSTANT_BUFFER_NOT_SET = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INPUTLAYOUT_NOT_SET + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_CONSTANT_BUFFER_TOO_SMALL = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_CONSTANT_BUFFER_NOT_SET + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_SAMPLER_NOT_SET = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_CONSTANT_BUFFER_TOO_SMALL + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_SHADERRESOURCEVIEW_NOT_SET = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_SAMPLER_NOT_SET + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VIEW_DIMENSION_MISMATCH = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_SHADERRESOURCEVIEW_NOT_SET + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_STRIDE_TOO_SMALL = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VIEW_DIMENSION_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_TOO_SMALL = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_STRIDE_TOO_SMALL + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_NOT_SET = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_TOO_SMALL + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_FORMAT_INVALID = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_NOT_SET + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_TOO_SMALL = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_FORMAT_INVALID + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_GS_INPUT_PRIMITIVE_MISMATCH = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_TOO_SMALL + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RESOURCE_RETURN_TYPE_MISMATCH = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_GS_INPUT_PRIMITIVE_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_POSITION_NOT_PRESENT = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RESOURCE_RETURN_TYPE_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_OUTPUT_STREAM_NOT_SET = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_POSITION_NOT_PRESENT + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_BOUND_RESOURCE_MAPPED = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_OUTPUT_STREAM_NOT_SET + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INVALID_PRIMITIVETOPOLOGY = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_BOUND_RESOURCE_MAPPED + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_OFFSET_UNALIGNED = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INVALID_PRIMITIVETOPOLOGY + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_STRIDE_UNALIGNED = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_OFFSET_UNALIGNED + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_OFFSET_UNALIGNED = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_STRIDE_UNALIGNED + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_OUTPUT_STREAM_OFFSET_UNALIGNED = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_OFFSET_UNALIGNED + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RESOURCE_FORMAT_LD_UNSUPPORTED = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_OUTPUT_STREAM_OFFSET_UNALIGNED + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RESOURCE_FORMAT_SAMPLE_UNSUPPORTED = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RESOURCE_FORMAT_LD_UNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RESOURCE_FORMAT_SAMPLE_C_UNSUPPORTED = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RESOURCE_FORMAT_SAMPLE_UNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RESOURCE_MULTISAMPLE_UNSUPPORTED = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RESOURCE_FORMAT_SAMPLE_C_UNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_SO_TARGETS_BOUND_WITHOUT_SOURCE = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RESOURCE_MULTISAMPLE_UNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_SO_STRIDE_LARGER_THAN_BUFFER = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_SO_TARGETS_BOUND_WITHOUT_SOURCE + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_OM_RENDER_TARGET_DOES_NOT_SUPPORT_BLENDING = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_SO_STRIDE_LARGER_THAN_BUFFER + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_OM_DUAL_SOURCE_BLENDING_CAN_ONLY_HAVE_RENDER_TARGET_0 = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_OM_RENDER_TARGET_DOES_NOT_SUPPORT_BLENDING + 1 ) , + D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_AT_FAULT = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_OM_DUAL_SOURCE_BLENDING_CAN_ONLY_HAVE_RENDER_TARGET_0 + 1 ) , + D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_POSSIBLY_AT_FAULT = ( D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_AT_FAULT + 1 ) , + D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_NOT_AT_FAULT = ( D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_POSSIBLY_AT_FAULT + 1 ) , + D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_INVALIDARG_RETURN = ( D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_NOT_AT_FAULT + 1 ) , + D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_OUTOFMEMORY_RETURN = ( D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_INVALIDARG_RETURN + 1 ) , + D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_BADINTERFACE_RETURN = ( D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_OUTOFMEMORY_RETURN + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DRAW_VIEWPORT_NOT_SET = ( D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_BADINTERFACE_RETURN + 1 ) , + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TRAILING_DIGIT_IN_SEMANTIC = ( D3D12_MESSAGE_ID_DEVICE_DRAW_VIEWPORT_NOT_SET + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_TRAILING_DIGIT_IN_SEMANTIC = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TRAILING_DIGIT_IN_SEMANTIC + 1 ) , + D3D12_MESSAGE_ID_DEVICE_RSSETVIEWPORTS_DENORMFLUSH = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_TRAILING_DIGIT_IN_SEMANTIC + 1 ) , + D3D12_MESSAGE_ID_OMSETRENDERTARGETS_INVALIDVIEW = ( D3D12_MESSAGE_ID_DEVICE_RSSETVIEWPORTS_DENORMFLUSH + 1 ) , + D3D12_MESSAGE_ID_DEVICE_SETTEXTFILTERSIZE_INVALIDDIMENSIONS = ( D3D12_MESSAGE_ID_OMSETRENDERTARGETS_INVALIDVIEW + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DRAW_SAMPLER_MISMATCH = ( D3D12_MESSAGE_ID_DEVICE_SETTEXTFILTERSIZE_INVALIDDIMENSIONS + 1 ) , + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TYPE_MISMATCH = ( D3D12_MESSAGE_ID_DEVICE_DRAW_SAMPLER_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_BLENDSTATE_GETDESC_LEGACY = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TYPE_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_SHADERRESOURCEVIEW_GETDESC_LEGACY = ( D3D12_MESSAGE_ID_BLENDSTATE_GETDESC_LEGACY + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DRAW_PS_OUTPUT_TYPE_MISMATCH = ( D3D12_MESSAGE_ID_SHADERRESOURCEVIEW_GETDESC_LEGACY + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_GATHER_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_DRAW_PS_OUTPUT_TYPE_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DRAW_INVALID_USE_OF_CENTER_MULTISAMPLE_PATTERN = ( D3D12_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_GATHER_UNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_STRIDE_TOO_LARGE = ( D3D12_MESSAGE_ID_DEVICE_DRAW_INVALID_USE_OF_CENTER_MULTISAMPLE_PATTERN + 1 ) , + D3D12_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_INVALIDRANGE = ( D3D12_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_STRIDE_TOO_LARGE + 1 ) , + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_EMPTY_LAYOUT = ( D3D12_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_INVALIDRANGE + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DRAW_RESOURCE_SAMPLE_COUNT_MISMATCH = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_EMPTY_LAYOUT + 1 ) , + D3D12_MESSAGE_ID_LIVE_OBJECT_SUMMARY = ( D3D12_MESSAGE_ID_DEVICE_DRAW_RESOURCE_SAMPLE_COUNT_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_LIVE_BUFFER = ( D3D12_MESSAGE_ID_LIVE_OBJECT_SUMMARY + 1 ) , + D3D12_MESSAGE_ID_LIVE_TEXTURE1D = ( D3D12_MESSAGE_ID_LIVE_BUFFER + 1 ) , + D3D12_MESSAGE_ID_LIVE_TEXTURE2D = ( D3D12_MESSAGE_ID_LIVE_TEXTURE1D + 1 ) , + D3D12_MESSAGE_ID_LIVE_TEXTURE3D = ( D3D12_MESSAGE_ID_LIVE_TEXTURE2D + 1 ) , + D3D12_MESSAGE_ID_LIVE_SHADERRESOURCEVIEW = ( D3D12_MESSAGE_ID_LIVE_TEXTURE3D + 1 ) , + D3D12_MESSAGE_ID_LIVE_RENDERTARGETVIEW = ( D3D12_MESSAGE_ID_LIVE_SHADERRESOURCEVIEW + 1 ) , + D3D12_MESSAGE_ID_LIVE_DEPTHSTENCILVIEW = ( D3D12_MESSAGE_ID_LIVE_RENDERTARGETVIEW + 1 ) , + D3D12_MESSAGE_ID_LIVE_VERTEXSHADER = ( D3D12_MESSAGE_ID_LIVE_DEPTHSTENCILVIEW + 1 ) , + D3D12_MESSAGE_ID_LIVE_GEOMETRYSHADER = ( D3D12_MESSAGE_ID_LIVE_VERTEXSHADER + 1 ) , + D3D12_MESSAGE_ID_LIVE_PIXELSHADER = ( D3D12_MESSAGE_ID_LIVE_GEOMETRYSHADER + 1 ) , + D3D12_MESSAGE_ID_LIVE_INPUTLAYOUT = ( D3D12_MESSAGE_ID_LIVE_PIXELSHADER + 1 ) , + D3D12_MESSAGE_ID_LIVE_SAMPLER = ( D3D12_MESSAGE_ID_LIVE_INPUTLAYOUT + 1 ) , + D3D12_MESSAGE_ID_LIVE_BLENDSTATE = ( D3D12_MESSAGE_ID_LIVE_SAMPLER + 1 ) , + D3D12_MESSAGE_ID_LIVE_DEPTHSTENCILSTATE = ( D3D12_MESSAGE_ID_LIVE_BLENDSTATE + 1 ) , + D3D12_MESSAGE_ID_LIVE_RASTERIZERSTATE = ( D3D12_MESSAGE_ID_LIVE_DEPTHSTENCILSTATE + 1 ) , + D3D12_MESSAGE_ID_LIVE_QUERY = ( D3D12_MESSAGE_ID_LIVE_RASTERIZERSTATE + 1 ) , + D3D12_MESSAGE_ID_LIVE_PREDICATE = ( D3D12_MESSAGE_ID_LIVE_QUERY + 1 ) , + D3D12_MESSAGE_ID_LIVE_COUNTER = ( D3D12_MESSAGE_ID_LIVE_PREDICATE + 1 ) , + D3D12_MESSAGE_ID_LIVE_DEVICE = ( D3D12_MESSAGE_ID_LIVE_COUNTER + 1 ) , + D3D12_MESSAGE_ID_LIVE_SWAPCHAIN = ( D3D12_MESSAGE_ID_LIVE_DEVICE + 1 ) , + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDFLAGS = ( D3D12_MESSAGE_ID_LIVE_SWAPCHAIN + 1 ) , + D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDCLASSLINKAGE = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDFLAGS + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDCLASSLINKAGE = ( D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDCLASSLINKAGE + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMSTREAMS = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDCLASSLINKAGE + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAMTORASTERIZER = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMSTREAMS + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDSTREAMS = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAMTORASTERIZER + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDCLASSLINKAGE = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDSTREAMS + 1 ) , + D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDCLASSLINKAGE = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDCLASSLINKAGE + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAM = ( D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDCLASSLINKAGE + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDENTRIES = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAM + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDSTRIDES = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDENTRIES + 1 ) , + D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMSTRIDES = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDSTRIDES + 1 ) , + D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDCALL = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMSTRIDES + 1 ) , + D3D12_MESSAGE_ID_CREATEHULLSHADER_OUTOFMEMORY = ( D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDCALL + 1 ) , + D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDSHADERBYTECODE = ( D3D12_MESSAGE_ID_CREATEHULLSHADER_OUTOFMEMORY + 1 ) , + D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDSHADERTYPE = ( D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDSHADERBYTECODE + 1 ) , + D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDCLASSLINKAGE = ( D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDSHADERTYPE + 1 ) , + D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDCALL = ( D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDCLASSLINKAGE + 1 ) , + D3D12_MESSAGE_ID_CREATEDOMAINSHADER_OUTOFMEMORY = ( D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDCALL + 1 ) , + D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDSHADERBYTECODE = ( D3D12_MESSAGE_ID_CREATEDOMAINSHADER_OUTOFMEMORY + 1 ) , + D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDSHADERTYPE = ( D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDSHADERBYTECODE + 1 ) , + D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDCLASSLINKAGE = ( D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDSHADERTYPE + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DRAW_HS_XOR_DS_MISMATCH = ( D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDCLASSLINKAGE + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DRAWINDIRECT_INVALID_ARG_BUFFER = ( D3D12_MESSAGE_ID_DEVICE_DRAW_HS_XOR_DS_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DRAWINDIRECT_OFFSET_UNALIGNED = ( D3D12_MESSAGE_ID_DEVICE_DRAWINDIRECT_INVALID_ARG_BUFFER + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DRAWINDIRECT_OFFSET_OVERFLOW = ( D3D12_MESSAGE_ID_DEVICE_DRAWINDIRECT_OFFSET_UNALIGNED + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_MAP_INVALIDMAPTYPE = ( D3D12_MESSAGE_ID_DEVICE_DRAWINDIRECT_OFFSET_OVERFLOW + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_MAP_INVALIDSUBRESOURCE = ( D3D12_MESSAGE_ID_RESOURCE_MAP_INVALIDMAPTYPE + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_MAP_INVALIDFLAGS = ( D3D12_MESSAGE_ID_RESOURCE_MAP_INVALIDSUBRESOURCE + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_MAP_ALREADYMAPPED = ( D3D12_MESSAGE_ID_RESOURCE_MAP_INVALIDFLAGS + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_MAP_DEVICEREMOVED_RETURN = ( D3D12_MESSAGE_ID_RESOURCE_MAP_ALREADYMAPPED + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_MAP_OUTOFMEMORY_RETURN = ( D3D12_MESSAGE_ID_RESOURCE_MAP_DEVICEREMOVED_RETURN + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_MAP_WITHOUT_INITIAL_DISCARD = ( D3D12_MESSAGE_ID_RESOURCE_MAP_OUTOFMEMORY_RETURN + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_UNMAP_INVALIDSUBRESOURCE = ( D3D12_MESSAGE_ID_RESOURCE_MAP_WITHOUT_INITIAL_DISCARD + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_UNMAP_NOTMAPPED = ( D3D12_MESSAGE_ID_RESOURCE_UNMAP_INVALIDSUBRESOURCE + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DRAW_RASTERIZING_CONTROL_POINTS = ( D3D12_MESSAGE_ID_RESOURCE_UNMAP_NOTMAPPED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_DRAW_RASTERIZING_CONTROL_POINTS + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DRAW_HS_DS_SIGNATURE_MISMATCH = ( D3D12_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DRAW_HULL_SHADER_INPUT_TOPOLOGY_MISMATCH = ( D3D12_MESSAGE_ID_DEVICE_DRAW_HS_DS_SIGNATURE_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DRAW_HS_DS_CONTROL_POINT_COUNT_MISMATCH = ( D3D12_MESSAGE_ID_DEVICE_DRAW_HULL_SHADER_INPUT_TOPOLOGY_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DRAW_HS_DS_TESSELLATOR_DOMAIN_MISMATCH = ( D3D12_MESSAGE_ID_DEVICE_DRAW_HS_DS_CONTROL_POINT_COUNT_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_UNRECOGNIZED_FEATURE = ( D3D12_MESSAGE_ID_DEVICE_DRAW_HS_DS_TESSELLATOR_DOMAIN_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_MISMATCHED_DATA_SIZE = ( D3D12_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_UNRECOGNIZED_FEATURE + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_INVALIDARG_RETURN = ( D3D12_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_MISMATCHED_DATA_SIZE + 1 ) , + D3D12_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDCALL = ( D3D12_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_INVALIDARG_RETURN + 1 ) , + D3D12_MESSAGE_ID_CREATECOMPUTESHADER_OUTOFMEMORY = ( D3D12_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDCALL + 1 ) , + D3D12_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDSHADERBYTECODE = ( D3D12_MESSAGE_ID_CREATECOMPUTESHADER_OUTOFMEMORY + 1 ) , + D3D12_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDCLASSLINKAGE = ( D3D12_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDSHADERBYTECODE + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CSSETSHADERRESOURCES_VIEWS_EMPTY = ( D3D12_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDCLASSLINKAGE + 1 ) , + D3D12_MESSAGE_ID_CSSETCONSTANTBUFFERS_INVALIDBUFFER = ( D3D12_MESSAGE_ID_DEVICE_CSSETSHADERRESOURCES_VIEWS_EMPTY + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CSSETCONSTANTBUFFERS_BUFFERS_EMPTY = ( D3D12_MESSAGE_ID_CSSETCONSTANTBUFFERS_INVALIDBUFFER + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CSSETSAMPLERS_SAMPLERS_EMPTY = ( D3D12_MESSAGE_ID_DEVICE_CSSETCONSTANTBUFFERS_BUFFERS_EMPTY + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CSGETSHADERRESOURCES_VIEWS_EMPTY = ( D3D12_MESSAGE_ID_DEVICE_CSSETSAMPLERS_SAMPLERS_EMPTY + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CSGETCONSTANTBUFFERS_BUFFERS_EMPTY = ( D3D12_MESSAGE_ID_DEVICE_CSGETSHADERRESOURCES_VIEWS_EMPTY + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CSGETSAMPLERS_SAMPLERS_EMPTY = ( D3D12_MESSAGE_ID_DEVICE_CSGETCONSTANTBUFFERS_BUFFERS_EMPTY + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_DOUBLEFLOATOPSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CSGETSAMPLERS_SAMPLERS_EMPTY + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_DOUBLEFLOATOPSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_DOUBLEFLOATOPSNOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_DOUBLEFLOATOPSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_DOUBLEFLOATOPSNOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_DOUBLEFLOATOPSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_DOUBLEFLOATOPSNOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DOUBLEFLOATOPSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_DOUBLEFLOATOPSNOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_DOUBLEFLOATOPSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DOUBLEFLOATOPSNOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_DOUBLEFLOATOPSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_DOUBLEFLOATOPSNOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_CREATEBUFFER_INVALIDSTRUCTURESTRIDE = ( D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_DOUBLEFLOATOPSNOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDFLAGS = ( D3D12_MESSAGE_ID_CREATEBUFFER_INVALIDSTRUCTURESTRIDE + 1 ) , + D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDRESOURCE = ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDFLAGS + 1 ) , + D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDDESC = ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDRESOURCE + 1 ) , + D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDFORMAT = ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDDESC + 1 ) , + D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDVIDEOPLANESLICE = ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDFORMAT + 1 ) , + D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDPLANESLICE = ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDVIDEOPLANESLICE + 1 ) , + D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDDIMENSIONS = ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDPLANESLICE + 1 ) , + D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_UNRECOGNIZEDFORMAT = ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDDIMENSIONS + 1 ) , + D3D12_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_OVERLAPPING_OLD_SLOTS = ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_UNRECOGNIZEDFORMAT + 1 ) , + D3D12_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_NO_OP = ( D3D12_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_OVERLAPPING_OLD_SLOTS + 1 ) , + D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDARG_RETURN = ( D3D12_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_NO_OP + 1 ) , + D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_OUTOFMEMORY_RETURN = ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDARG_RETURN + 1 ) , + D3D12_MESSAGE_ID_CLEARUNORDEREDACCESSVIEW_DENORMFLUSH = ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_OUTOFMEMORY_RETURN + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CSSETUNORDEREDACCESSS_VIEWS_EMPTY = ( D3D12_MESSAGE_ID_CLEARUNORDEREDACCESSVIEW_DENORMFLUSH + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CSGETUNORDEREDACCESSS_VIEWS_EMPTY = ( D3D12_MESSAGE_ID_DEVICE_CSSETUNORDEREDACCESSS_VIEWS_EMPTY + 1 ) , + D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDFLAGS = ( D3D12_MESSAGE_ID_DEVICE_CSGETUNORDEREDACCESSS_VIEWS_EMPTY + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_INVALID_ARG_BUFFER = ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDFLAGS + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_OFFSET_UNALIGNED = ( D3D12_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_INVALID_ARG_BUFFER + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_OFFSET_OVERFLOW = ( D3D12_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_OFFSET_UNALIGNED + 1 ) , + D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_DEPTH_READONLY = ( D3D12_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_OFFSET_OVERFLOW + 1 ) , + D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_STENCIL_READONLY = ( D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_DEPTH_READONLY + 1 ) , + D3D12_MESSAGE_ID_CHECKFEATURESUPPORT_FORMAT_DEPRECATED = ( D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_STENCIL_READONLY + 1 ) , + D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_RETURN_TYPE_MISMATCH = ( D3D12_MESSAGE_ID_CHECKFEATURESUPPORT_FORMAT_DEPRECATED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_NOT_SET = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_RETURN_TYPE_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DRAW_UNORDEREDACCESSVIEW_RENDERTARGETVIEW_OVERLAP = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_NOT_SET + 1 ) , + D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_DIMENSION_MISMATCH = ( D3D12_MESSAGE_ID_DEVICE_DRAW_UNORDEREDACCESSVIEW_RENDERTARGETVIEW_OVERLAP + 1 ) , + D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_APPEND_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_DIMENSION_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMICS_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_APPEND_UNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_STRUCTURE_STRIDE_MISMATCH = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMICS_UNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_BUFFER_TYPE_MISMATCH = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_STRUCTURE_STRIDE_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_RAW_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_BUFFER_TYPE_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_FORMAT_LD_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_RAW_UNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_FORMAT_STORE_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_FORMAT_LD_UNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_ADD_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_FORMAT_STORE_UNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_BITWISE_OPS_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_ADD_UNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_CMPSTORE_CMPEXCHANGE_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_BITWISE_OPS_UNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_EXCHANGE_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_CMPSTORE_CMPEXCHANGE_UNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_SIGNED_MINMAX_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_EXCHANGE_UNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_UNSIGNED_MINMAX_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_SIGNED_MINMAX_UNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DISPATCH_BOUND_RESOURCE_MAPPED = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_UNSIGNED_MINMAX_UNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DISPATCH_THREADGROUPCOUNT_OVERFLOW = ( D3D12_MESSAGE_ID_DEVICE_DISPATCH_BOUND_RESOURCE_MAPPED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DISPATCH_THREADGROUPCOUNT_ZERO = ( D3D12_MESSAGE_ID_DEVICE_DISPATCH_THREADGROUPCOUNT_OVERFLOW + 1 ) , + D3D12_MESSAGE_ID_DEVICE_SHADERRESOURCEVIEW_STRUCTURE_STRIDE_MISMATCH = ( D3D12_MESSAGE_ID_DEVICE_DISPATCH_THREADGROUPCOUNT_ZERO + 1 ) , + D3D12_MESSAGE_ID_DEVICE_SHADERRESOURCEVIEW_BUFFER_TYPE_MISMATCH = ( D3D12_MESSAGE_ID_DEVICE_SHADERRESOURCEVIEW_STRUCTURE_STRIDE_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_DEVICE_SHADERRESOURCEVIEW_RAW_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_SHADERRESOURCEVIEW_BUFFER_TYPE_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DISPATCH_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_SHADERRESOURCEVIEW_RAW_UNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_DISPATCH_UNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_COPYSTRUCTURECOUNT_INVALIDOFFSET = ( D3D12_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_UNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_COPYSTRUCTURECOUNT_LARGEOFFSET = ( D3D12_MESSAGE_ID_COPYSTRUCTURECOUNT_INVALIDOFFSET + 1 ) , + D3D12_MESSAGE_ID_COPYSTRUCTURECOUNT_INVALIDDESTINATIONSTATE = ( D3D12_MESSAGE_ID_COPYSTRUCTURECOUNT_LARGEOFFSET + 1 ) , + D3D12_MESSAGE_ID_COPYSTRUCTURECOUNT_INVALIDSOURCESTATE = ( D3D12_MESSAGE_ID_COPYSTRUCTURECOUNT_INVALIDDESTINATIONSTATE + 1 ) , + D3D12_MESSAGE_ID_CHECKFORMATSUPPORT_FORMAT_NOT_SUPPORTED = ( D3D12_MESSAGE_ID_COPYSTRUCTURECOUNT_INVALIDSOURCESTATE + 1 ) , + D3D12_MESSAGE_ID_CLEARUNORDEREDACCESSVIEWFLOAT_INVALIDFORMAT = ( D3D12_MESSAGE_ID_CHECKFORMATSUPPORT_FORMAT_NOT_SUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_COUNTER_UNSUPPORTED = ( D3D12_MESSAGE_ID_CLEARUNORDEREDACCESSVIEWFLOAT_INVALIDFORMAT + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DRAW_PIXEL_SHADER_WITHOUT_RTV_OR_DSV = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_COUNTER_UNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_SHADER_ABORT = ( D3D12_MESSAGE_ID_DEVICE_DRAW_PIXEL_SHADER_WITHOUT_RTV_OR_DSV + 1 ) , + D3D12_MESSAGE_ID_SHADER_MESSAGE = ( D3D12_MESSAGE_ID_SHADER_ABORT + 1 ) , + D3D12_MESSAGE_ID_SHADER_ERROR = ( D3D12_MESSAGE_ID_SHADER_MESSAGE + 1 ) , + D3D12_MESSAGE_ID_OFFERRESOURCES_INVALIDRESOURCE = ( D3D12_MESSAGE_ID_SHADER_ERROR + 1 ) , + D3D12_MESSAGE_ID_ENQUEUESETEVENT_INVALIDARG_RETURN = ( D3D12_MESSAGE_ID_OFFERRESOURCES_INVALIDRESOURCE + 1 ) , + D3D12_MESSAGE_ID_ENQUEUESETEVENT_OUTOFMEMORY_RETURN = ( D3D12_MESSAGE_ID_ENQUEUESETEVENT_INVALIDARG_RETURN + 1 ) , + D3D12_MESSAGE_ID_ENQUEUESETEVENT_ACCESSDENIED_RETURN = ( D3D12_MESSAGE_ID_ENQUEUESETEVENT_OUTOFMEMORY_RETURN + 1 ) , + D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDFORCEDSAMPLECOUNT = ( D3D12_MESSAGE_ID_ENQUEUESETEVENT_ACCESSDENIED_RETURN + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DRAW_INVALID_USE_OF_FORCED_SAMPLE_COUNT = ( D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDFORCEDSAMPLECOUNT + 1 ) , + D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDLOGICOPS = ( D3D12_MESSAGE_ID_DEVICE_DRAW_INVALID_USE_OF_FORCED_SAMPLE_COUNT + 1 ) , + D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDARRAYWITHDECODER = ( D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDLOGICOPS + 1 ) , + D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDARRAYWITHDECODER = ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDARRAYWITHDECODER + 1 ) , + D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDARRAYWITHDECODER = ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDARRAYWITHDECODER + 1 ) , + D3D12_MESSAGE_ID_DEVICE_LOCKEDOUT_INTERFACE = ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDARRAYWITHDECODER + 1 ) , + D3D12_MESSAGE_ID_OFFERRESOURCES_INVALIDPRIORITY = ( D3D12_MESSAGE_ID_DEVICE_LOCKEDOUT_INTERFACE + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_INVALIDVIEW = ( D3D12_MESSAGE_ID_OFFERRESOURCES_INVALIDPRIORITY + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_DOUBLEEXTENSIONSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_INVALIDVIEW + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_SHADEREXTENSIONSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_DOUBLEEXTENSIONSNOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_DOUBLEEXTENSIONSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_SHADEREXTENSIONSNOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_SHADEREXTENSIONSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_DOUBLEEXTENSIONSNOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_DOUBLEEXTENSIONSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_SHADEREXTENSIONSNOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_SHADEREXTENSIONSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_DOUBLEEXTENSIONSNOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_DOUBLEEXTENSIONSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_SHADEREXTENSIONSNOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_SHADEREXTENSIONSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_DOUBLEEXTENSIONSNOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DOUBLEEXTENSIONSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_SHADEREXTENSIONSNOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_SHADEREXTENSIONSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DOUBLEEXTENSIONSNOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_DOUBLEEXTENSIONSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_SHADEREXTENSIONSNOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_SHADEREXTENSIONSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_DOUBLEEXTENSIONSNOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_DOUBLEEXTENSIONSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_SHADEREXTENSIONSNOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_SHADEREXTENSIONSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_DOUBLEEXTENSIONSNOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_MINPRECISION = ( D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_SHADEREXTENSIONSNOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_UAVSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_MINPRECISION + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_UAVSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_UAVSNOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_UAVSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_UAVSNOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_UAVSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_UAVSNOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UAVSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_UAVSNOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_UAVSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UAVSNOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_UAVSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_UAVSNOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_INVALIDOFFSET = ( D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_UAVSNOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_TOOMANYVIEWS = ( D3D12_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_INVALIDOFFSET + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_NOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_TOOMANYVIEWS + 1 ) , + D3D12_MESSAGE_ID_SWAPDEVICECONTEXTSTATE_NOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_NOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_UPDATESUBRESOURCE_PREFERUPDATESUBRESOURCE1 = ( D3D12_MESSAGE_ID_SWAPDEVICECONTEXTSTATE_NOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_GETDC_INACCESSIBLE = ( D3D12_MESSAGE_ID_UPDATESUBRESOURCE_PREFERUPDATESUBRESOURCE1 + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_INVALIDRECT = ( D3D12_MESSAGE_ID_GETDC_INACCESSIBLE + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DRAW_SAMPLE_MASK_IGNORED_ON_FL9 = ( D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_INVALIDRECT + 1 ) , + D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE1_NOT_SUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_DRAW_SAMPLE_MASK_IGNORED_ON_FL9 + 1 ) , + D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_BY_NAME_NOT_SUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE1_NOT_SUPPORTED + 1 ) , + D3D12_MESSAGE_ID_ENQUEUESETEVENT_NOT_SUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_BY_NAME_NOT_SUPPORTED + 1 ) , + D3D12_MESSAGE_ID_OFFERRELEASE_NOT_SUPPORTED = ( D3D12_MESSAGE_ID_ENQUEUESETEVENT_NOT_SUPPORTED + 1 ) , + D3D12_MESSAGE_ID_OFFERRESOURCES_INACCESSIBLE = ( D3D12_MESSAGE_ID_OFFERRELEASE_NOT_SUPPORTED + 1 ) , + D3D12_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_INVALIDMSAA = ( D3D12_MESSAGE_ID_OFFERRESOURCES_INACCESSIBLE + 1 ) , + D3D12_MESSAGE_ID_CREATEVIDEOPROCESSOROUTPUTVIEW_INVALIDMSAA = ( D3D12_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_INVALIDMSAA + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_INVALIDSOURCERECT = ( D3D12_MESSAGE_ID_CREATEVIDEOPROCESSOROUTPUTVIEW_INVALIDMSAA + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_EMPTYRECT = ( D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_INVALIDSOURCERECT + 1 ) , + D3D12_MESSAGE_ID_UPDATESUBRESOURCE_EMPTYDESTBOX = ( D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_EMPTYRECT + 1 ) , + D3D12_MESSAGE_ID_COPYSUBRESOURCEREGION_EMPTYSOURCEBOX = ( D3D12_MESSAGE_ID_UPDATESUBRESOURCE_EMPTYDESTBOX + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DRAW_OM_RENDER_TARGET_DOES_NOT_SUPPORT_LOGIC_OPS = ( D3D12_MESSAGE_ID_COPYSUBRESOURCEREGION_EMPTYSOURCEBOX + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DRAW_DEPTHSTENCILVIEW_NOT_SET = ( D3D12_MESSAGE_ID_DEVICE_DRAW_OM_RENDER_TARGET_DOES_NOT_SUPPORT_LOGIC_OPS + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DRAW_RENDERTARGETVIEW_NOT_SET = ( D3D12_MESSAGE_ID_DEVICE_DRAW_DEPTHSTENCILVIEW_NOT_SET + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DRAW_RENDERTARGETVIEW_NOT_SET_DUE_TO_FLIP_PRESENT = ( D3D12_MESSAGE_ID_DEVICE_DRAW_RENDERTARGETVIEW_NOT_SET + 1 ) , + D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_NOT_SET_DUE_TO_FLIP_PRESENT = ( D3D12_MESSAGE_ID_DEVICE_DRAW_RENDERTARGETVIEW_NOT_SET_DUE_TO_FLIP_PRESENT + 1 ) , + D3D12_MESSAGE_ID_GETDATAFORNEWHARDWAREKEY_NULLPARAM = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_NOT_SET_DUE_TO_FLIP_PRESENT + 1 ) , + D3D12_MESSAGE_ID_CHECKCRYPTOSESSIONSTATUS_NULLPARAM = ( D3D12_MESSAGE_ID_GETDATAFORNEWHARDWAREKEY_NULLPARAM + 1 ) , + D3D12_MESSAGE_ID_SETEVENTONHARDWARECONTENTPROTECTIONTILT_NULLPARAM = ( D3D12_MESSAGE_ID_CHECKCRYPTOSESSIONSTATUS_NULLPARAM + 1 ) , + D3D12_MESSAGE_ID_GETVIDEODECODERCAPS_NULLPARAM = ( D3D12_MESSAGE_ID_SETEVENTONHARDWARECONTENTPROTECTIONTILT_NULLPARAM + 1 ) , + D3D12_MESSAGE_ID_GETVIDEODECODERCAPS_ZEROWIDTHHEIGHT = ( D3D12_MESSAGE_ID_GETVIDEODECODERCAPS_NULLPARAM + 1 ) , + D3D12_MESSAGE_ID_CHECKVIDEODECODERDOWNSAMPLING_NULLPARAM = ( D3D12_MESSAGE_ID_GETVIDEODECODERCAPS_ZEROWIDTHHEIGHT + 1 ) , + D3D12_MESSAGE_ID_CHECKVIDEODECODERDOWNSAMPLING_INVALIDCOLORSPACE = ( D3D12_MESSAGE_ID_CHECKVIDEODECODERDOWNSAMPLING_NULLPARAM + 1 ) , + D3D12_MESSAGE_ID_CHECKVIDEODECODERDOWNSAMPLING_ZEROWIDTHHEIGHT = ( D3D12_MESSAGE_ID_CHECKVIDEODECODERDOWNSAMPLING_INVALIDCOLORSPACE + 1 ) , + D3D12_MESSAGE_ID_VIDEODECODERENABLEDOWNSAMPLING_NULLPARAM = ( D3D12_MESSAGE_ID_CHECKVIDEODECODERDOWNSAMPLING_ZEROWIDTHHEIGHT + 1 ) , + D3D12_MESSAGE_ID_VIDEODECODERENABLEDOWNSAMPLING_UNSUPPORTED = ( D3D12_MESSAGE_ID_VIDEODECODERENABLEDOWNSAMPLING_NULLPARAM + 1 ) , + D3D12_MESSAGE_ID_VIDEODECODERUPDATEDOWNSAMPLING_NULLPARAM = ( D3D12_MESSAGE_ID_VIDEODECODERENABLEDOWNSAMPLING_UNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_VIDEODECODERUPDATEDOWNSAMPLING_UNSUPPORTED = ( D3D12_MESSAGE_ID_VIDEODECODERUPDATEDOWNSAMPLING_NULLPARAM + 1 ) , + D3D12_MESSAGE_ID_CHECKVIDEOPROCESSORFORMATCONVERSION_NULLPARAM = ( D3D12_MESSAGE_ID_VIDEODECODERUPDATEDOWNSAMPLING_UNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTCOLORSPACE1_NULLPARAM = ( D3D12_MESSAGE_ID_CHECKVIDEOPROCESSORFORMATCONVERSION_NULLPARAM + 1 ) , + D3D12_MESSAGE_ID_VIDEOPROCESSORGETOUTPUTCOLORSPACE1_NULLPARAM = ( D3D12_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTCOLORSPACE1_NULLPARAM + 1 ) , + D3D12_MESSAGE_ID_VIDEOPROCESSORSETSTREAMCOLORSPACE1_NULLPARAM = ( D3D12_MESSAGE_ID_VIDEOPROCESSORGETOUTPUTCOLORSPACE1_NULLPARAM + 1 ) , + D3D12_MESSAGE_ID_VIDEOPROCESSORSETSTREAMCOLORSPACE1_INVALIDSTREAM = ( D3D12_MESSAGE_ID_VIDEOPROCESSORSETSTREAMCOLORSPACE1_NULLPARAM + 1 ) , + D3D12_MESSAGE_ID_VIDEOPROCESSORSETSTREAMMIRROR_NULLPARAM = ( D3D12_MESSAGE_ID_VIDEOPROCESSORSETSTREAMCOLORSPACE1_INVALIDSTREAM + 1 ) , + D3D12_MESSAGE_ID_VIDEOPROCESSORSETSTREAMMIRROR_INVALIDSTREAM = ( D3D12_MESSAGE_ID_VIDEOPROCESSORSETSTREAMMIRROR_NULLPARAM + 1 ) , + D3D12_MESSAGE_ID_VIDEOPROCESSORSETSTREAMMIRROR_UNSUPPORTED = ( D3D12_MESSAGE_ID_VIDEOPROCESSORSETSTREAMMIRROR_INVALIDSTREAM + 1 ) , + D3D12_MESSAGE_ID_VIDEOPROCESSORGETSTREAMCOLORSPACE1_NULLPARAM = ( D3D12_MESSAGE_ID_VIDEOPROCESSORSETSTREAMMIRROR_UNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_VIDEOPROCESSORGETSTREAMMIRROR_NULLPARAM = ( D3D12_MESSAGE_ID_VIDEOPROCESSORGETSTREAMCOLORSPACE1_NULLPARAM + 1 ) , + D3D12_MESSAGE_ID_RECOMMENDVIDEODECODERDOWNSAMPLING_NULLPARAM = ( D3D12_MESSAGE_ID_VIDEOPROCESSORGETSTREAMMIRROR_NULLPARAM + 1 ) , + D3D12_MESSAGE_ID_RECOMMENDVIDEODECODERDOWNSAMPLING_INVALIDCOLORSPACE = ( D3D12_MESSAGE_ID_RECOMMENDVIDEODECODERDOWNSAMPLING_NULLPARAM + 1 ) , + D3D12_MESSAGE_ID_RECOMMENDVIDEODECODERDOWNSAMPLING_ZEROWIDTHHEIGHT = ( D3D12_MESSAGE_ID_RECOMMENDVIDEODECODERDOWNSAMPLING_INVALIDCOLORSPACE + 1 ) , + D3D12_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTSHADERUSAGE_NULLPARAM = ( D3D12_MESSAGE_ID_RECOMMENDVIDEODECODERDOWNSAMPLING_ZEROWIDTHHEIGHT + 1 ) , + D3D12_MESSAGE_ID_VIDEOPROCESSORGETOUTPUTSHADERUSAGE_NULLPARAM = ( D3D12_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTSHADERUSAGE_NULLPARAM + 1 ) , + D3D12_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_NULLPARAM = ( D3D12_MESSAGE_ID_VIDEOPROCESSORGETOUTPUTSHADERUSAGE_NULLPARAM + 1 ) , + D3D12_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_INVALIDSTREAMCOUNT = ( D3D12_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_NULLPARAM + 1 ) , + D3D12_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_TARGETRECT = ( D3D12_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_INVALIDSTREAMCOUNT + 1 ) , + D3D12_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_INVALIDSOURCERECT = ( D3D12_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_TARGETRECT + 1 ) , + D3D12_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_INVALIDDESTRECT = ( D3D12_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_INVALIDSOURCERECT + 1 ) , + D3D12_MESSAGE_ID_CREATEBUFFER_INVALIDUSAGE = ( D3D12_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_INVALIDDESTRECT + 1 ) , + D3D12_MESSAGE_ID_CREATETEXTURE1D_INVALIDUSAGE = ( D3D12_MESSAGE_ID_CREATEBUFFER_INVALIDUSAGE + 1 ) , + D3D12_MESSAGE_ID_CREATETEXTURE2D_INVALIDUSAGE = ( D3D12_MESSAGE_ID_CREATETEXTURE1D_INVALIDUSAGE + 1 ) , + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_LEVEL9_STEPRATE_NOT_1 = ( D3D12_MESSAGE_ID_CREATETEXTURE2D_INVALIDUSAGE + 1 ) , + D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_LEVEL9_INSTANCING_NOT_SUPPORTED = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_LEVEL9_STEPRATE_NOT_1 + 1 ) , + D3D12_MESSAGE_ID_UPDATETILEMAPPINGS_INVALID_PARAMETER = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_LEVEL9_INSTANCING_NOT_SUPPORTED + 1 ) , + D3D12_MESSAGE_ID_COPYTILEMAPPINGS_INVALID_PARAMETER = ( D3D12_MESSAGE_ID_UPDATETILEMAPPINGS_INVALID_PARAMETER + 1 ) , + D3D12_MESSAGE_ID_COPYTILES_INVALID_PARAMETER = ( D3D12_MESSAGE_ID_COPYTILEMAPPINGS_INVALID_PARAMETER + 1 ) , + D3D12_MESSAGE_ID_NULL_TILE_MAPPING_ACCESS_WARNING = ( D3D12_MESSAGE_ID_COPYTILES_INVALID_PARAMETER + 1 ) , + D3D12_MESSAGE_ID_NULL_TILE_MAPPING_ACCESS_ERROR = ( D3D12_MESSAGE_ID_NULL_TILE_MAPPING_ACCESS_WARNING + 1 ) , + D3D12_MESSAGE_ID_DIRTY_TILE_MAPPING_ACCESS = ( D3D12_MESSAGE_ID_NULL_TILE_MAPPING_ACCESS_ERROR + 1 ) , + D3D12_MESSAGE_ID_DUPLICATE_TILE_MAPPINGS_IN_COVERED_AREA = ( D3D12_MESSAGE_ID_DIRTY_TILE_MAPPING_ACCESS + 1 ) , + D3D12_MESSAGE_ID_TILE_MAPPINGS_IN_COVERED_AREA_DUPLICATED_OUTSIDE = ( D3D12_MESSAGE_ID_DUPLICATE_TILE_MAPPINGS_IN_COVERED_AREA + 1 ) , + D3D12_MESSAGE_ID_TILE_MAPPINGS_SHARED_BETWEEN_INCOMPATIBLE_RESOURCES = ( D3D12_MESSAGE_ID_TILE_MAPPINGS_IN_COVERED_AREA_DUPLICATED_OUTSIDE + 1 ) , + D3D12_MESSAGE_ID_TILE_MAPPINGS_SHARED_BETWEEN_INPUT_AND_OUTPUT = ( D3D12_MESSAGE_ID_TILE_MAPPINGS_SHARED_BETWEEN_INCOMPATIBLE_RESOURCES + 1 ) , + D3D12_MESSAGE_ID_CHECKMULTISAMPLEQUALITYLEVELS_INVALIDFLAGS = ( D3D12_MESSAGE_ID_TILE_MAPPINGS_SHARED_BETWEEN_INPUT_AND_OUTPUT + 1 ) , + D3D12_MESSAGE_ID_GETRESOURCETILING_NONTILED_RESOURCE = ( D3D12_MESSAGE_ID_CHECKMULTISAMPLEQUALITYLEVELS_INVALIDFLAGS + 1 ) , + D3D12_MESSAGE_ID_NEED_TO_CALL_TILEDRESOURCEBARRIER = ( D3D12_MESSAGE_ID_GETRESOURCETILING_NONTILED_RESOURCE + 1 ) , + D3D12_MESSAGE_ID_CREATEDEVICE_INVALIDARGS = ( D3D12_MESSAGE_ID_NEED_TO_CALL_TILEDRESOURCEBARRIER + 1 ) , + D3D12_MESSAGE_ID_CREATEDEVICE_WARNING = ( D3D12_MESSAGE_ID_CREATEDEVICE_INVALIDARGS + 1 ) , + D3D12_MESSAGE_ID_TILED_RESOURCE_TIER_1_BUFFER_TEXTURE_MISMATCH = ( D3D12_MESSAGE_ID_CREATEDEVICE_WARNING + 1 ) , + D3D12_MESSAGE_ID_CREATE_CRYPTOSESSION = ( D3D12_MESSAGE_ID_TILED_RESOURCE_TIER_1_BUFFER_TEXTURE_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_CREATE_AUTHENTICATEDCHANNEL = ( D3D12_MESSAGE_ID_CREATE_CRYPTOSESSION + 1 ) , + D3D12_MESSAGE_ID_LIVE_CRYPTOSESSION = ( D3D12_MESSAGE_ID_CREATE_AUTHENTICATEDCHANNEL + 1 ) , + D3D12_MESSAGE_ID_LIVE_AUTHENTICATEDCHANNEL = ( D3D12_MESSAGE_ID_LIVE_CRYPTOSESSION + 1 ) , + D3D12_MESSAGE_ID_DESTROY_CRYPTOSESSION = ( D3D12_MESSAGE_ID_LIVE_AUTHENTICATEDCHANNEL + 1 ) , + D3D12_MESSAGE_ID_DESTROY_AUTHENTICATEDCHANNEL = ( D3D12_MESSAGE_ID_DESTROY_CRYPTOSESSION + 1 ) , + D3D12_MESSAGE_ID_MAP_INVALID_SUBRESOURCE = ( D3D12_MESSAGE_ID_DESTROY_AUTHENTICATEDCHANNEL + 1 ) , + D3D12_MESSAGE_ID_MAP_INVALID_TYPE = ( D3D12_MESSAGE_ID_MAP_INVALID_SUBRESOURCE + 1 ) , + D3D12_MESSAGE_ID_MAP_UNSUPPORTED_TYPE = ( D3D12_MESSAGE_ID_MAP_INVALID_TYPE + 1 ) , + D3D12_MESSAGE_ID_UNMAP_INVALID_SUBRESOURCE = ( D3D12_MESSAGE_ID_MAP_UNSUPPORTED_TYPE + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_TYPE = ( D3D12_MESSAGE_ID_UNMAP_INVALID_SUBRESOURCE + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_BARRIER_NULL_POINTER = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_TYPE + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_SUBRESOURCE = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_NULL_POINTER + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_BARRIER_RESERVED_BITS = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_SUBRESOURCE + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISSING_BIND_FLAGS = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_RESERVED_BITS + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_MISC_FLAGS = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISSING_BIND_FLAGS + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_BARRIER_MATCHING_STATES = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_MISC_FLAGS + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMBINATION = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_MATCHING_STATES + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_BARRIER_BEFORE_AFTER_MISMATCH = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMBINATION + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_RESOURCE = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_BEFORE_AFTER_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_BARRIER_SAMPLE_COUNT = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_RESOURCE + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAGS = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_SAMPLE_COUNT + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMBINED_FLAGS = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAGS + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAGS_FOR_FORMAT = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMBINED_FLAGS + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_SPLIT_BARRIER = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAGS_FOR_FORMAT + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_BARRIER_UNMATCHED_END = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_SPLIT_BARRIER + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_BARRIER_UNMATCHED_BEGIN = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_UNMATCHED_END + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAG = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_UNMATCHED_BEGIN + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMMAND_LIST_TYPE = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAG + 1 ) , + D3D12_MESSAGE_ID_INVALID_SUBRESOURCE_STATE = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMMAND_LIST_TYPE + 1 ) , + D3D12_MESSAGE_ID_INEFFICIENT_PRESENT = ( D3D12_MESSAGE_ID_INVALID_SUBRESOURCE_STATE + 1 ) , + D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_CONTENTION = ( D3D12_MESSAGE_ID_INEFFICIENT_PRESENT + 1 ) , + D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_RESET = ( D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_CONTENTION + 1 ) , + D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_RESET_BUNDLE = ( D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_RESET + 1 ) , + D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_CANNOT_RESET = ( D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_RESET_BUNDLE + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_OPEN = ( D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_CANNOT_RESET + 1 ) , + D3D12_MESSAGE_ID_QUERY_STATE_MISMATCH = ( D3D12_MESSAGE_ID_COMMAND_LIST_OPEN + 1 ) , + D3D12_MESSAGE_ID_INVALID_BUNDLE_API = ( D3D12_MESSAGE_ID_QUERY_STATE_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_CLOSED = ( D3D12_MESSAGE_ID_INVALID_BUNDLE_API + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_CLOSED_WITH_INVALID_RESOURCE = ( D3D12_MESSAGE_ID_COMMAND_LIST_CLOSED + 1 ) , + D3D12_MESSAGE_ID_WRONG_COMMAND_ALLOCATOR_TYPE = ( D3D12_MESSAGE_ID_COMMAND_LIST_CLOSED_WITH_INVALID_RESOURCE + 1 ) , + D3D12_MESSAGE_ID_INVALID_INDIRECT_ARGUMENT_BUFFER = ( D3D12_MESSAGE_ID_WRONG_COMMAND_ALLOCATOR_TYPE + 1 ) , + D3D12_MESSAGE_ID_COMPUTE_AND_GRAPHICS_PIPELINE = ( D3D12_MESSAGE_ID_INVALID_INDIRECT_ARGUMENT_BUFFER + 1 ) , + D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_SYNC = ( D3D12_MESSAGE_ID_COMPUTE_AND_GRAPHICS_PIPELINE + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_SYNC = ( D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_SYNC + 1 ) , + D3D12_MESSAGE_ID_SET_DESCRIPTOR_HEAP_INVALID = ( D3D12_MESSAGE_ID_COMMAND_LIST_SYNC + 1 ) , + D3D12_MESSAGE_ID_CREATE_QUEUE_IMAGE_NOT_SUPPORTED = ( D3D12_MESSAGE_ID_SET_DESCRIPTOR_HEAP_INVALID + 1 ) , + D3D12_MESSAGE_ID_CREATE_COMMAND_ALLOCATOR_IMAGE_NOT_SUPPORTED = ( D3D12_MESSAGE_ID_CREATE_QUEUE_IMAGE_NOT_SUPPORTED + 1 ) , + D3D12_MESSAGE_ID_CREATE_COMMANDQUEUE = ( D3D12_MESSAGE_ID_CREATE_COMMAND_ALLOCATOR_IMAGE_NOT_SUPPORTED + 1 ) , + D3D12_MESSAGE_ID_CREATE_COMMANDALLOCATOR = ( D3D12_MESSAGE_ID_CREATE_COMMANDQUEUE + 1 ) , + D3D12_MESSAGE_ID_CREATE_PIPELINESTATE = ( D3D12_MESSAGE_ID_CREATE_COMMANDALLOCATOR + 1 ) , + D3D12_MESSAGE_ID_CREATE_COMMANDLIST12 = ( D3D12_MESSAGE_ID_CREATE_PIPELINESTATE + 1 ) , + D3D12_MESSAGE_ID_CREATE_IMAGECOMMANDLIST = ( D3D12_MESSAGE_ID_CREATE_COMMANDLIST12 + 1 ) , + D3D12_MESSAGE_ID_CREATE_RESOURCE = ( D3D12_MESSAGE_ID_CREATE_IMAGECOMMANDLIST + 1 ) , + D3D12_MESSAGE_ID_CREATE_DESCRIPTORHEAP = ( D3D12_MESSAGE_ID_CREATE_RESOURCE + 1 ) , + D3D12_MESSAGE_ID_CREATE_ROOTSIGNATURE = ( D3D12_MESSAGE_ID_CREATE_DESCRIPTORHEAP + 1 ) , + D3D12_MESSAGE_ID_CREATE_LIBRARY = ( D3D12_MESSAGE_ID_CREATE_ROOTSIGNATURE + 1 ) , + D3D12_MESSAGE_ID_CREATE_HEAP = ( D3D12_MESSAGE_ID_CREATE_LIBRARY + 1 ) , + D3D12_MESSAGE_ID_CREATE_MONITOREDFENCE = ( D3D12_MESSAGE_ID_CREATE_HEAP + 1 ) , + D3D12_MESSAGE_ID_CREATE_QUERYHEAP = ( D3D12_MESSAGE_ID_CREATE_MONITOREDFENCE + 1 ) , + D3D12_MESSAGE_ID_CREATE_COMMANDSIGNATURE = ( D3D12_MESSAGE_ID_CREATE_QUERYHEAP + 1 ) , + D3D12_MESSAGE_ID_LIVE_COMMANDQUEUE = ( D3D12_MESSAGE_ID_CREATE_COMMANDSIGNATURE + 1 ) , + D3D12_MESSAGE_ID_LIVE_COMMANDALLOCATOR = ( D3D12_MESSAGE_ID_LIVE_COMMANDQUEUE + 1 ) , + D3D12_MESSAGE_ID_LIVE_PIPELINESTATE = ( D3D12_MESSAGE_ID_LIVE_COMMANDALLOCATOR + 1 ) , + D3D12_MESSAGE_ID_LIVE_COMMANDLIST12 = ( D3D12_MESSAGE_ID_LIVE_PIPELINESTATE + 1 ) , + D3D12_MESSAGE_ID_LIVE_IMAGECOMMANDLIST = ( D3D12_MESSAGE_ID_LIVE_COMMANDLIST12 + 1 ) , + D3D12_MESSAGE_ID_LIVE_RESOURCE = ( D3D12_MESSAGE_ID_LIVE_IMAGECOMMANDLIST + 1 ) , + D3D12_MESSAGE_ID_LIVE_DESCRIPTORHEAP = ( D3D12_MESSAGE_ID_LIVE_RESOURCE + 1 ) , + D3D12_MESSAGE_ID_LIVE_ROOTSIGNATURE = ( D3D12_MESSAGE_ID_LIVE_DESCRIPTORHEAP + 1 ) , + D3D12_MESSAGE_ID_LIVE_LIBRARY = ( D3D12_MESSAGE_ID_LIVE_ROOTSIGNATURE + 1 ) , + D3D12_MESSAGE_ID_LIVE_HEAP = ( D3D12_MESSAGE_ID_LIVE_LIBRARY + 1 ) , + D3D12_MESSAGE_ID_LIVE_MONITOREDFENCE = ( D3D12_MESSAGE_ID_LIVE_HEAP + 1 ) , + D3D12_MESSAGE_ID_LIVE_QUERYHEAP = ( D3D12_MESSAGE_ID_LIVE_MONITOREDFENCE + 1 ) , + D3D12_MESSAGE_ID_LIVE_COMMANDSIGNATURE = ( D3D12_MESSAGE_ID_LIVE_QUERYHEAP + 1 ) , + D3D12_MESSAGE_ID_DESTROY_COMMANDQUEUE = ( D3D12_MESSAGE_ID_LIVE_COMMANDSIGNATURE + 1 ) , + D3D12_MESSAGE_ID_DESTROY_COMMANDALLOCATOR = ( D3D12_MESSAGE_ID_DESTROY_COMMANDQUEUE + 1 ) , + D3D12_MESSAGE_ID_DESTROY_PIPELINESTATE = ( D3D12_MESSAGE_ID_DESTROY_COMMANDALLOCATOR + 1 ) , + D3D12_MESSAGE_ID_DESTROY_COMMANDLIST12 = ( D3D12_MESSAGE_ID_DESTROY_PIPELINESTATE + 1 ) , + D3D12_MESSAGE_ID_DESTROY_IMAGECOMMANDLIST = ( D3D12_MESSAGE_ID_DESTROY_COMMANDLIST12 + 1 ) , + D3D12_MESSAGE_ID_DESTROY_RESOURCE = ( D3D12_MESSAGE_ID_DESTROY_IMAGECOMMANDLIST + 1 ) , + D3D12_MESSAGE_ID_DESTROY_DESCRIPTORHEAP = ( D3D12_MESSAGE_ID_DESTROY_RESOURCE + 1 ) , + D3D12_MESSAGE_ID_DESTROY_ROOTSIGNATURE = ( D3D12_MESSAGE_ID_DESTROY_DESCRIPTORHEAP + 1 ) , + D3D12_MESSAGE_ID_DESTROY_LIBRARY = ( D3D12_MESSAGE_ID_DESTROY_ROOTSIGNATURE + 1 ) , + D3D12_MESSAGE_ID_DESTROY_HEAP = ( D3D12_MESSAGE_ID_DESTROY_LIBRARY + 1 ) , + D3D12_MESSAGE_ID_DESTROY_MONITOREDFENCE = ( D3D12_MESSAGE_ID_DESTROY_HEAP + 1 ) , + D3D12_MESSAGE_ID_DESTROY_QUERYHEAP = ( D3D12_MESSAGE_ID_DESTROY_MONITOREDFENCE + 1 ) , + D3D12_MESSAGE_ID_DESTROY_COMMANDSIGNATURE = ( D3D12_MESSAGE_ID_DESTROY_QUERYHEAP + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDHEAPTYPE = ( D3D12_MESSAGE_ID_DESTROY_COMMANDSIGNATURE + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDIMENSIONS = ( D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDHEAPTYPE + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDMISCFLAGS = ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDIMENSIONS + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDMISCFLAGS = ( D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDMISCFLAGS + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCE_LARGEALLOCATION = ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDMISCFLAGS + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCE_SMALLALLOCATION = ( D3D12_MESSAGE_ID_CREATERESOURCE_LARGEALLOCATION + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDARG_RETURN = ( D3D12_MESSAGE_ID_CREATERESOURCE_SMALLALLOCATION + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCE_OUTOFMEMORY_RETURN = ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDARG_RETURN + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDESC = ( D3D12_MESSAGE_ID_CREATERESOURCE_OUTOFMEMORY_RETURN + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDINITIALSTATE = ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDESC + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_HAS_PENDING_INITIAL_DATA = ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDINITIALSTATE + 1 ) , + D3D12_MESSAGE_ID_POSSIBLY_INVALID_SUBRESOURCE_STATE = ( D3D12_MESSAGE_ID_RESOURCE_HAS_PENDING_INITIAL_DATA + 1 ) , + D3D12_MESSAGE_ID_INVALID_USE_OF_NON_RESIDENT_RESOURCE = ( D3D12_MESSAGE_ID_POSSIBLY_INVALID_SUBRESOURCE_STATE + 1 ) , + D3D12_MESSAGE_ID_POSSIBLE_INVALID_USE_OF_NON_RESIDENT_RESOURCE = ( D3D12_MESSAGE_ID_INVALID_USE_OF_NON_RESIDENT_RESOURCE + 1 ) , + D3D12_MESSAGE_ID_BUNDLE_PIPELINE_STATE_MISMATCH = ( D3D12_MESSAGE_ID_POSSIBLE_INVALID_USE_OF_NON_RESIDENT_RESOURCE + 1 ) , + D3D12_MESSAGE_ID_PRIMITIVE_TOPOLOGY_MISMATCH_PIPELINE_STATE = ( D3D12_MESSAGE_ID_BUNDLE_PIPELINE_STATE_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_RENDER_TARGET_NUMBER_MISMATCH_PIPELINE_STATE = ( D3D12_MESSAGE_ID_PRIMITIVE_TOPOLOGY_MISMATCH_PIPELINE_STATE + 1 ) , + D3D12_MESSAGE_ID_RENDER_TARGET_FORMAT_MISMATCH_PIPELINE_STATE = ( D3D12_MESSAGE_ID_RENDER_TARGET_NUMBER_MISMATCH_PIPELINE_STATE + 1 ) , + D3D12_MESSAGE_ID_RENDER_TARGET_SAMPLE_DESC_MISMATCH_PIPELINE_STATE = ( D3D12_MESSAGE_ID_RENDER_TARGET_FORMAT_MISMATCH_PIPELINE_STATE + 1 ) , + D3D12_MESSAGE_ID_DEPTH_STENCIL_FORMAT_MISMATCH_PIPELINE_STATE = ( D3D12_MESSAGE_ID_RENDER_TARGET_SAMPLE_DESC_MISMATCH_PIPELINE_STATE + 1 ) , + D3D12_MESSAGE_ID_DEPTH_STENCIL_SAMPLE_DESC_MISMATCH_PIPELINE_STATE = ( D3D12_MESSAGE_ID_DEPTH_STENCIL_FORMAT_MISMATCH_PIPELINE_STATE + 1 ) , + D3D12_MESSAGE_ID_RENDER_TARGET_NUMBER_MISMATCH_BUNDLE_PIPELINE_STATE = ( D3D12_MESSAGE_ID_DEPTH_STENCIL_SAMPLE_DESC_MISMATCH_PIPELINE_STATE + 1 ) , + D3D12_MESSAGE_ID_RENDER_TARGET_FORMAT_MISMATCH_BUNDLE_PIPELINE_STATE = ( D3D12_MESSAGE_ID_RENDER_TARGET_NUMBER_MISMATCH_BUNDLE_PIPELINE_STATE + 1 ) , + D3D12_MESSAGE_ID_RENDER_TARGET_SAMPLE_DESC_MISMATCH_BUNDLE_PIPELINE_STATE = ( D3D12_MESSAGE_ID_RENDER_TARGET_FORMAT_MISMATCH_BUNDLE_PIPELINE_STATE + 1 ) , + D3D12_MESSAGE_ID_DEPTH_STENCIL_FORMAT_MISMATCH_BUNDLE_PIPELINE_STATE = ( D3D12_MESSAGE_ID_RENDER_TARGET_SAMPLE_DESC_MISMATCH_BUNDLE_PIPELINE_STATE + 1 ) , + D3D12_MESSAGE_ID_DEPTH_STENCIL_SAMPLE_DESC_MISMATCH_BUNDLE_PIPELINE_STATE = ( D3D12_MESSAGE_ID_DEPTH_STENCIL_FORMAT_MISMATCH_BUNDLE_PIPELINE_STATE + 1 ) , + D3D12_MESSAGE_ID_CREATESHADER_INVALIDBYTECODE = ( D3D12_MESSAGE_ID_DEPTH_STENCIL_SAMPLE_DESC_MISMATCH_BUNDLE_PIPELINE_STATE + 1 ) , + D3D12_MESSAGE_ID_CREATEHEAP_NULLDESC = ( D3D12_MESSAGE_ID_CREATESHADER_INVALIDBYTECODE + 1 ) , + D3D12_MESSAGE_ID_CREATEHEAP_INVALIDSIZE = ( D3D12_MESSAGE_ID_CREATEHEAP_NULLDESC + 1 ) , + D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDHEAPTYPE = ( D3D12_MESSAGE_ID_CREATEHEAP_INVALIDSIZE + 1 ) , + D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDCPUPAGEPROPERTIES = ( D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDHEAPTYPE + 1 ) , + D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDMEMORYPOOL = ( D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDCPUPAGEPROPERTIES + 1 ) , + D3D12_MESSAGE_ID_CREATEHEAP_INVALIDPROPERTIES = ( D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDMEMORYPOOL + 1 ) , + D3D12_MESSAGE_ID_CREATEHEAP_INVALIDALIGNMENT = ( D3D12_MESSAGE_ID_CREATEHEAP_INVALIDPROPERTIES + 1 ) , + D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDMISCFLAGS = ( D3D12_MESSAGE_ID_CREATEHEAP_INVALIDALIGNMENT + 1 ) , + D3D12_MESSAGE_ID_CREATEHEAP_INVALIDMISCFLAGS = ( D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDMISCFLAGS + 1 ) , + D3D12_MESSAGE_ID_CREATEHEAP_INVALIDARG_RETURN = ( D3D12_MESSAGE_ID_CREATEHEAP_INVALIDMISCFLAGS + 1 ) , + D3D12_MESSAGE_ID_CREATEHEAP_OUTOFMEMORY_RETURN = ( D3D12_MESSAGE_ID_CREATEHEAP_INVALIDARG_RETURN + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLHEAPPROPERTIES = ( D3D12_MESSAGE_ID_CREATEHEAP_OUTOFMEMORY_RETURN + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDHEAPTYPE = ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLHEAPPROPERTIES + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDCPUPAGEPROPERTIES = ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDHEAPTYPE + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDMEMORYPOOL = ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDCPUPAGEPROPERTIES + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDHEAPPROPERTIES = ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDMEMORYPOOL + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDHEAPMISCFLAGS = ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDHEAPPROPERTIES + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDHEAPMISCFLAGS = ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDHEAPMISCFLAGS + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDARG_RETURN = ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDHEAPMISCFLAGS + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_OUTOFMEMORY_RETURN = ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDARG_RETURN + 1 ) , + D3D12_MESSAGE_ID_GETCUSTOMHEAPPROPERTIES_UNRECOGNIZEDHEAPTYPE = ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_OUTOFMEMORY_RETURN + 1 ) , + D3D12_MESSAGE_ID_GETCUSTOMHEAPPROPERTIES_INVALIDHEAPTYPE = ( D3D12_MESSAGE_ID_GETCUSTOMHEAPPROPERTIES_UNRECOGNIZEDHEAPTYPE + 1 ) , + D3D12_MESSAGE_ID_CREATE_DESCRIPTOR_HEAP_INVALID_DESC = ( D3D12_MESSAGE_ID_GETCUSTOMHEAPPROPERTIES_INVALIDHEAPTYPE + 1 ) , + D3D12_MESSAGE_ID_INVALID_DESCRIPTOR_HANDLE = ( D3D12_MESSAGE_ID_CREATE_DESCRIPTOR_HEAP_INVALID_DESC + 1 ) , + D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALID_CONSERVATIVERASTERMODE = ( D3D12_MESSAGE_ID_INVALID_DESCRIPTOR_HANDLE + 1 ) , + D3D12_MESSAGE_ID_DEVICE_DRAW_INVALID_SYSTEMVALUE = ( D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALID_CONSERVATIVERASTERMODE + 1 ) , + D3D12_MESSAGE_ID_CREATE_CONSTANT_BUFFER_VIEW_INVALID_RESOURCE = ( D3D12_MESSAGE_ID_DEVICE_DRAW_INVALID_SYSTEMVALUE + 1 ) , + D3D12_MESSAGE_ID_CREATE_CONSTANT_BUFFER_VIEW_INVALID_DESC = ( D3D12_MESSAGE_ID_CREATE_CONSTANT_BUFFER_VIEW_INVALID_RESOURCE + 1 ) , + D3D12_MESSAGE_ID_CREATE_CONSTANT_BUFFER_VIEW_LARGE_OFFSET = ( D3D12_MESSAGE_ID_CREATE_CONSTANT_BUFFER_VIEW_INVALID_DESC + 1 ) , + D3D12_MESSAGE_ID_CREATE_UNORDEREDACCESS_VIEW_INVALID_COUNTER_USAGE = ( D3D12_MESSAGE_ID_CREATE_CONSTANT_BUFFER_VIEW_LARGE_OFFSET + 1 ) , + D3D12_MESSAGE_ID_COPY_DESCRIPTORS_INVALID_RANGES = ( D3D12_MESSAGE_ID_CREATE_UNORDEREDACCESS_VIEW_INVALID_COUNTER_USAGE + 1 ) , + D3D12_MESSAGE_ID_COPY_DESCRIPTORS_WRITE_ONLY_DESCRIPTOR = ( D3D12_MESSAGE_ID_COPY_DESCRIPTORS_INVALID_RANGES + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RTV_FORMAT_NOT_UNKNOWN = ( D3D12_MESSAGE_ID_COPY_DESCRIPTORS_WRITE_ONLY_DESCRIPTOR + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_RENDER_TARGET_COUNT = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RTV_FORMAT_NOT_UNKNOWN + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_VERTEX_SHADER_NOT_SET = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_RENDER_TARGET_COUNT + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INPUTLAYOUT_NOT_SET = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_VERTEX_SHADER_NOT_SET + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_HS_DS_SIGNATURE_MISMATCH = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INPUTLAYOUT_NOT_SET + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_REGISTERINDEX = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_HS_DS_SIGNATURE_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_COMPONENTTYPE = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_REGISTERINDEX + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_REGISTERMASK = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_COMPONENTTYPE + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_SYSTEMVALUE = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_REGISTERMASK + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_NEVERWRITTEN_ALWAYSREADS = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_SYSTEMVALUE + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_MINPRECISION = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_NEVERWRITTEN_ALWAYSREADS + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_SEMANTICNAME_NOT_FOUND = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_MINPRECISION + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_XOR_DS_MISMATCH = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_SEMANTICNAME_NOT_FOUND + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HULL_SHADER_INPUT_TOPOLOGY_MISMATCH = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_XOR_DS_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_DS_CONTROL_POINT_COUNT_MISMATCH = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HULL_SHADER_INPUT_TOPOLOGY_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_DS_TESSELLATOR_DOMAIN_MISMATCH = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_DS_CONTROL_POINT_COUNT_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_USE_OF_CENTER_MULTISAMPLE_PATTERN = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_DS_TESSELLATOR_DOMAIN_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_USE_OF_FORCED_SAMPLE_COUNT = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_USE_OF_CENTER_MULTISAMPLE_PATTERN + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_PRIMITIVETOPOLOGY = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_USE_OF_FORCED_SAMPLE_COUNT + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_SYSTEMVALUE = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_PRIMITIVETOPOLOGY + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_DUAL_SOURCE_BLENDING_CAN_ONLY_HAVE_RENDER_TARGET_0 = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_SYSTEMVALUE + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_RENDER_TARGET_DOES_NOT_SUPPORT_BLENDING = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_DUAL_SOURCE_BLENDING_CAN_ONLY_HAVE_RENDER_TARGET_0 + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_OUTPUT_TYPE_MISMATCH = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_RENDER_TARGET_DOES_NOT_SUPPORT_BLENDING + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_RENDER_TARGET_DOES_NOT_SUPPORT_LOGIC_OPS = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_OUTPUT_TYPE_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RENDERTARGETVIEW_NOT_SET = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_RENDER_TARGET_DOES_NOT_SUPPORT_LOGIC_OPS + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_DEPTHSTENCILVIEW_NOT_SET = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RENDERTARGETVIEW_NOT_SET + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_GS_INPUT_PRIMITIVE_MISMATCH = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_DEPTHSTENCILVIEW_NOT_SET + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_POSITION_NOT_PRESENT = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_GS_INPUT_PRIMITIVE_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MISSING_ROOT_SIGNATURE_FLAGS = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_POSITION_NOT_PRESENT + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_INDEX_BUFFER_PROPERTIES = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MISSING_ROOT_SIGNATURE_FLAGS + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_SAMPLE_DESC = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_INDEX_BUFFER_PROPERTIES + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_ROOT_SIGNATURE_MISMATCH = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_SAMPLE_DESC + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_DS_ROOT_SIGNATURE_MISMATCH = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_ROOT_SIGNATURE_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_VS_ROOT_SIGNATURE_MISMATCH = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_DS_ROOT_SIGNATURE_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_GS_ROOT_SIGNATURE_MISMATCH = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_VS_ROOT_SIGNATURE_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_ROOT_SIGNATURE_MISMATCH = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_GS_ROOT_SIGNATURE_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MISSING_ROOT_SIGNATURE = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_ROOT_SIGNATURE_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_EXECUTE_BUNDLE_OPEN_BUNDLE = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MISSING_ROOT_SIGNATURE + 1 ) , + D3D12_MESSAGE_ID_EXECUTE_BUNDLE_DESCRIPTOR_HEAP_MISMATCH = ( D3D12_MESSAGE_ID_EXECUTE_BUNDLE_OPEN_BUNDLE + 1 ) , + D3D12_MESSAGE_ID_EXECUTE_BUNDLE_TYPE = ( D3D12_MESSAGE_ID_EXECUTE_BUNDLE_DESCRIPTOR_HEAP_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_DRAW_EMPTY_SCISSOR_RECTANGLE = ( D3D12_MESSAGE_ID_EXECUTE_BUNDLE_TYPE + 1 ) , + D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_BLOB_NOT_FOUND = ( D3D12_MESSAGE_ID_DRAW_EMPTY_SCISSOR_RECTANGLE + 1 ) , + D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_DESERIALIZE_FAILED = ( D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_BLOB_NOT_FOUND + 1 ) , + D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_INVALID_CONFIGURATION = ( D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_DESERIALIZE_FAILED + 1 ) , + D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_NOT_SUPPORTED_ON_DEVICE = ( D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_INVALID_CONFIGURATION + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLRESOURCEPROPERTIES = ( D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_NOT_SUPPORTED_ON_DEVICE + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLHEAP = ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLRESOURCEPROPERTIES + 1 ) , + D3D12_MESSAGE_ID_GETRESOURCEALLOCATIONINFO_INVALIDRDESCS = ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLHEAP + 1 ) , + D3D12_MESSAGE_ID_MAKERESIDENT_NULLOBJECTARRAY = ( D3D12_MESSAGE_ID_GETRESOURCEALLOCATIONINFO_INVALIDRDESCS + 1 ) , + D3D12_MESSAGE_ID_MAKERESIDENT_INVALIDOBJECT = ( D3D12_MESSAGE_ID_MAKERESIDENT_NULLOBJECTARRAY + 1 ) , + D3D12_MESSAGE_ID_EVICT_NULLOBJECTARRAY = ( D3D12_MESSAGE_ID_MAKERESIDENT_INVALIDOBJECT + 1 ) , + D3D12_MESSAGE_ID_EVICT_INVALIDOBJECT = ( D3D12_MESSAGE_ID_EVICT_NULLOBJECTARRAY + 1 ) , + D3D12_MESSAGE_ID_HEAPS_UNSUPPORTED = ( D3D12_MESSAGE_ID_EVICT_INVALIDOBJECT + 1 ) , + D3D12_MESSAGE_ID_SET_DESCRIPTOR_TABLE_INVALID = ( D3D12_MESSAGE_ID_HEAPS_UNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_SET_ROOT_CONSTANT_INVALID = ( D3D12_MESSAGE_ID_SET_DESCRIPTOR_TABLE_INVALID + 1 ) , + D3D12_MESSAGE_ID_SET_ROOT_CONSTANT_BUFFER_VIEW_INVALID = ( D3D12_MESSAGE_ID_SET_ROOT_CONSTANT_INVALID + 1 ) , + D3D12_MESSAGE_ID_SET_ROOT_SHADER_RESOURCE_VIEW_INVALID = ( D3D12_MESSAGE_ID_SET_ROOT_CONSTANT_BUFFER_VIEW_INVALID + 1 ) , + D3D12_MESSAGE_ID_SET_ROOT_UNORDERED_ACCESS_VIEW_INVALID = ( D3D12_MESSAGE_ID_SET_ROOT_SHADER_RESOURCE_VIEW_INVALID + 1 ) , + D3D12_MESSAGE_ID_SET_VERTEX_BUFFERS_INVALID_DESC = ( D3D12_MESSAGE_ID_SET_ROOT_UNORDERED_ACCESS_VIEW_INVALID + 1 ) , + D3D12_MESSAGE_ID_SET_VERTEX_BUFFERS_LARGE_OFFSET = ( D3D12_MESSAGE_ID_SET_VERTEX_BUFFERS_INVALID_DESC + 1 ) , + D3D12_MESSAGE_ID_SET_INDEX_BUFFER_INVALID_DESC = ( D3D12_MESSAGE_ID_SET_VERTEX_BUFFERS_LARGE_OFFSET + 1 ) , + D3D12_MESSAGE_ID_SET_INDEX_BUFFER_LARGE_OFFSET = ( D3D12_MESSAGE_ID_SET_INDEX_BUFFER_INVALID_DESC + 1 ) , + D3D12_MESSAGE_ID_SET_STREAM_OUTPUT_BUFFERS_INVALID_DESC = ( D3D12_MESSAGE_ID_SET_INDEX_BUFFER_LARGE_OFFSET + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDDIMENSIONALITY = ( D3D12_MESSAGE_ID_SET_STREAM_OUTPUT_BUFFERS_INVALID_DESC + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDLAYOUT = ( D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDDIMENSIONALITY + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDIMENSIONALITY = ( D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDLAYOUT + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDALIGNMENT = ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDIMENSIONALITY + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDMIPLEVELS = ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDALIGNMENT + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDSAMPLEDESC = ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDMIPLEVELS + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDLAYOUT = ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDSAMPLEDESC + 1 ) , + D3D12_MESSAGE_ID_SET_INDEX_BUFFER_INVALID = ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDLAYOUT + 1 ) , + D3D12_MESSAGE_ID_SET_VERTEX_BUFFERS_INVALID = ( D3D12_MESSAGE_ID_SET_INDEX_BUFFER_INVALID + 1 ) , + D3D12_MESSAGE_ID_SET_STREAM_OUTPUT_BUFFERS_INVALID = ( D3D12_MESSAGE_ID_SET_VERTEX_BUFFERS_INVALID + 1 ) , + D3D12_MESSAGE_ID_SET_RENDER_TARGETS_INVALID = ( D3D12_MESSAGE_ID_SET_STREAM_OUTPUT_BUFFERS_INVALID + 1 ) , + D3D12_MESSAGE_ID_CREATEQUERY_HEAP_INVALID_PARAMETERS = ( D3D12_MESSAGE_ID_SET_RENDER_TARGETS_INVALID + 1 ) , + D3D12_MESSAGE_ID_CREATEQUERY_HEAP_JPEG_NOT_SUPPORTED = ( D3D12_MESSAGE_ID_CREATEQUERY_HEAP_INVALID_PARAMETERS + 1 ) , + D3D12_MESSAGE_ID_BEGIN_END_QUERY_INVALID_PARAMETERS = ( D3D12_MESSAGE_ID_CREATEQUERY_HEAP_JPEG_NOT_SUPPORTED + 1 ) , + D3D12_MESSAGE_ID_CLOSE_COMMAND_LIST_OPEN_QUERY = ( D3D12_MESSAGE_ID_BEGIN_END_QUERY_INVALID_PARAMETERS + 1 ) , + D3D12_MESSAGE_ID_RESOLVE_QUERY_DATA_INVALID_PARAMETERS = ( D3D12_MESSAGE_ID_CLOSE_COMMAND_LIST_OPEN_QUERY + 1 ) , + D3D12_MESSAGE_ID_SET_PREDICATION_INVALID_PARAMETERS = ( D3D12_MESSAGE_ID_RESOLVE_QUERY_DATA_INVALID_PARAMETERS + 1 ) , + D3D12_MESSAGE_ID_TIMESTAMPS_NOT_SUPPORTED = ( D3D12_MESSAGE_ID_SET_PREDICATION_INVALID_PARAMETERS + 1 ) , + D3D12_MESSAGE_ID_UNSTABLE_POWER_STATE = ( D3D12_MESSAGE_ID_TIMESTAMPS_NOT_SUPPORTED + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDFORMAT = ( D3D12_MESSAGE_ID_UNSTABLE_POWER_STATE + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDFORMAT = ( D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDFORMAT + 1 ) , + D3D12_MESSAGE_ID_GETCOPYABLELAYOUT_INVALIDSUBRESOURCERANGE = ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDFORMAT + 1 ) , + D3D12_MESSAGE_ID_GETCOPYABLELAYOUT_INVALIDBASEOFFSET = ( D3D12_MESSAGE_ID_GETCOPYABLELAYOUT_INVALIDSUBRESOURCERANGE + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_HEAP = ( D3D12_MESSAGE_ID_GETCOPYABLELAYOUT_INVALIDBASEOFFSET + 1 ) , + D3D12_MESSAGE_ID_CREATE_SAMPLER_INVALID = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_HEAP + 1 ) , + D3D12_MESSAGE_ID_CREATECOMMANDSIGNATURE_INVALID = ( D3D12_MESSAGE_ID_CREATE_SAMPLER_INVALID + 1 ) , + D3D12_MESSAGE_ID_EXECUTE_INDIRECT_INVALID_PARAMETERS = ( D3D12_MESSAGE_ID_CREATECOMMANDSIGNATURE_INVALID + 1 ) , + D3D12_MESSAGE_ID_GETGPUVIRTUALADDRESS_INVALID_RESOURCE_DIMENSION = ( D3D12_MESSAGE_ID_EXECUTE_INDIRECT_INVALID_PARAMETERS + 1 ) , + D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDPLANEINDEX = ( D3D12_MESSAGE_ID_GETGPUVIRTUALADDRESS_INVALID_RESOURCE_DIMENSION + 4 ) , + D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDVIDEOPLANEINDEX = ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDPLANEINDEX + 1 ) , + D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_AMBIGUOUSVIDEOPLANEINDEX = ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDVIDEOPLANEINDEX + 1 ) , + D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDPLANEINDEX = ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_AMBIGUOUSVIDEOPLANEINDEX + 1 ) , + D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDVIDEOPLANEINDEX = ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDPLANEINDEX + 1 ) , + D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_AMBIGUOUSVIDEOPLANEINDEX = ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDVIDEOPLANEINDEX + 1 ) , + D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDPLANEINDEX = ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_AMBIGUOUSVIDEOPLANEINDEX + 1 ) , + D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDVIDEOPLANEINDEX = ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDPLANEINDEX + 1 ) , + D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_AMBIGUOUSVIDEOPLANEINDEX = ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDVIDEOPLANEINDEX + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_INVALIDSCANDATAOFFSET = ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_AMBIGUOUSVIDEOPLANEINDEX + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_NOTSUPPORTED = ( D3D12_MESSAGE_ID_JPEGDECODE_INVALIDSCANDATAOFFSET + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_DIMENSIONSTOOLARGE = ( D3D12_MESSAGE_ID_JPEGDECODE_NOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_INVALIDCOMPONENTS = ( D3D12_MESSAGE_ID_JPEGDECODE_DIMENSIONSTOOLARGE + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDCOMPONENTS = ( D3D12_MESSAGE_ID_JPEGDECODE_INVALIDCOMPONENTS + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_DESTINATIONNOT2D = ( D3D12_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDCOMPONENTS + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_TILEDRESOURCESUNSUPPORTED = ( D3D12_MESSAGE_ID_JPEGDECODE_DESTINATIONNOT2D + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_GUARDRECTSUNSUPPORTED = ( D3D12_MESSAGE_ID_JPEGDECODE_TILEDRESOURCESUNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_FORMATUNSUPPORTED = ( D3D12_MESSAGE_ID_JPEGDECODE_GUARDRECTSUNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_INVALIDSUBRESOURCE = ( D3D12_MESSAGE_ID_JPEGDECODE_FORMATUNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_INVALIDMIPLEVEL = ( D3D12_MESSAGE_ID_JPEGDECODE_INVALIDSUBRESOURCE + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_EMPTYDESTBOX = ( D3D12_MESSAGE_ID_JPEGDECODE_INVALIDMIPLEVEL + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_DESTBOXNOT2D = ( D3D12_MESSAGE_ID_JPEGDECODE_EMPTYDESTBOX + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_DESTBOXNOTSUB = ( D3D12_MESSAGE_ID_JPEGDECODE_DESTBOXNOT2D + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_DESTBOXESINTERSECT = ( D3D12_MESSAGE_ID_JPEGDECODE_DESTBOXNOTSUB + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_XSUBSAMPLEMISMATCH = ( D3D12_MESSAGE_ID_JPEGDECODE_DESTBOXESINTERSECT + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_YSUBSAMPLEMISMATCH = ( D3D12_MESSAGE_ID_JPEGDECODE_XSUBSAMPLEMISMATCH + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_XSUBSAMPLEODD = ( D3D12_MESSAGE_ID_JPEGDECODE_YSUBSAMPLEMISMATCH + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_YSUBSAMPLEODD = ( D3D12_MESSAGE_ID_JPEGDECODE_XSUBSAMPLEODD + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_UPSCALEUNSUPPORTED = ( D3D12_MESSAGE_ID_JPEGDECODE_YSUBSAMPLEODD + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_TIER4DOWNSCALETOLARGE = ( D3D12_MESSAGE_ID_JPEGDECODE_UPSCALEUNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_TIER3DOWNSCALEUNSUPPORTED = ( D3D12_MESSAGE_ID_JPEGDECODE_TIER4DOWNSCALETOLARGE + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_CHROMASIZEMISMATCH = ( D3D12_MESSAGE_ID_JPEGDECODE_TIER3DOWNSCALEUNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_LUMACHROMASIZEMISMATCH = ( D3D12_MESSAGE_ID_JPEGDECODE_CHROMASIZEMISMATCH + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_INVALIDNUMDESTINATIONS = ( D3D12_MESSAGE_ID_JPEGDECODE_LUMACHROMASIZEMISMATCH + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_SUBBOXUNSUPPORTED = ( D3D12_MESSAGE_ID_JPEGDECODE_INVALIDNUMDESTINATIONS + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_1DESTUNSUPPORTEDFORMAT = ( D3D12_MESSAGE_ID_JPEGDECODE_SUBBOXUNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_3DESTUNSUPPORTEDFORMAT = ( D3D12_MESSAGE_ID_JPEGDECODE_1DESTUNSUPPORTEDFORMAT + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_SCALEUNSUPPORTED = ( D3D12_MESSAGE_ID_JPEGDECODE_3DESTUNSUPPORTEDFORMAT + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_INVALIDSOURCESIZE = ( D3D12_MESSAGE_ID_JPEGDECODE_SCALEUNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_INVALIDCOPYFLAGS = ( D3D12_MESSAGE_ID_JPEGDECODE_INVALIDSOURCESIZE + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_HAZARD = ( D3D12_MESSAGE_ID_JPEGDECODE_INVALIDCOPYFLAGS + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDSRCBUFFERUSAGE = ( D3D12_MESSAGE_ID_JPEGDECODE_HAZARD + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDSRCBUFFERMISCFLAGS = ( D3D12_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDSRCBUFFERUSAGE + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDDSTTEXTUREUSAGE = ( D3D12_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDSRCBUFFERMISCFLAGS + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_BACKBUFFERNOTSUPPORTED = ( D3D12_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDDSTTEXTUREUSAGE + 1 ) , + D3D12_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDCOPYFLAGS = ( D3D12_MESSAGE_ID_JPEGDECODE_BACKBUFFERNOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_JPEGENCODE_NOTSUPPORTED = ( D3D12_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDCOPYFLAGS + 1 ) , + D3D12_MESSAGE_ID_JPEGENCODE_INVALIDSCANDATAOFFSET = ( D3D12_MESSAGE_ID_JPEGENCODE_NOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_JPEGENCODE_INVALIDCOMPONENTS = ( D3D12_MESSAGE_ID_JPEGENCODE_INVALIDSCANDATAOFFSET + 1 ) , + D3D12_MESSAGE_ID_JPEGENCODE_SOURCENOT2D = ( D3D12_MESSAGE_ID_JPEGENCODE_INVALIDCOMPONENTS + 1 ) , + D3D12_MESSAGE_ID_JPEGENCODE_TILEDRESOURCESUNSUPPORTED = ( D3D12_MESSAGE_ID_JPEGENCODE_SOURCENOT2D + 1 ) , + D3D12_MESSAGE_ID_JPEGENCODE_GUARDRECTSUNSUPPORTED = ( D3D12_MESSAGE_ID_JPEGENCODE_TILEDRESOURCESUNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_JPEGENCODE_XSUBSAMPLEMISMATCH = ( D3D12_MESSAGE_ID_JPEGENCODE_GUARDRECTSUNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_JPEGENCODE_YSUBSAMPLEMISMATCH = ( D3D12_MESSAGE_ID_JPEGENCODE_XSUBSAMPLEMISMATCH + 1 ) , + D3D12_MESSAGE_ID_JPEGENCODE_UNSUPPORTEDCOMPONENTS = ( D3D12_MESSAGE_ID_JPEGENCODE_YSUBSAMPLEMISMATCH + 1 ) , + D3D12_MESSAGE_ID_JPEGENCODE_FORMATUNSUPPORTED = ( D3D12_MESSAGE_ID_JPEGENCODE_UNSUPPORTEDCOMPONENTS + 1 ) , + D3D12_MESSAGE_ID_JPEGENCODE_INVALIDSUBRESOURCE = ( D3D12_MESSAGE_ID_JPEGENCODE_FORMATUNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_JPEGENCODE_INVALIDMIPLEVEL = ( D3D12_MESSAGE_ID_JPEGENCODE_INVALIDSUBRESOURCE + 1 ) , + D3D12_MESSAGE_ID_JPEGENCODE_DIMENSIONSTOOLARGE = ( D3D12_MESSAGE_ID_JPEGENCODE_INVALIDMIPLEVEL + 1 ) , + D3D12_MESSAGE_ID_JPEGENCODE_HAZARD = ( D3D12_MESSAGE_ID_JPEGENCODE_DIMENSIONSTOOLARGE + 1 ) , + D3D12_MESSAGE_ID_JPEGENCODE_UNSUPPORTEDDSTBUFFERUSAGE = ( D3D12_MESSAGE_ID_JPEGENCODE_HAZARD + 1 ) , + D3D12_MESSAGE_ID_JPEGENCODE_UNSUPPORTEDDSTBUFFERMISCFLAGS = ( D3D12_MESSAGE_ID_JPEGENCODE_UNSUPPORTEDDSTBUFFERUSAGE + 1 ) , + D3D12_MESSAGE_ID_JPEGENCODE_UNSUPPORTEDSRCTEXTUREUSAGE = ( D3D12_MESSAGE_ID_JPEGENCODE_UNSUPPORTEDDSTBUFFERMISCFLAGS + 1 ) , + D3D12_MESSAGE_ID_JPEGENCODE_BACKBUFFERNOTSUPPORTED = ( D3D12_MESSAGE_ID_JPEGENCODE_UNSUPPORTEDSRCTEXTUREUSAGE + 1 ) , + D3D12_MESSAGE_ID_CREATEQUERYORPREDICATE_UNSUPPORTEDCONTEXTTYPEFORQUERY = ( D3D12_MESSAGE_ID_JPEGENCODE_BACKBUFFERNOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_FLUSH1_INVALIDCONTEXTTYPE = ( D3D12_MESSAGE_ID_CREATEQUERYORPREDICATE_UNSUPPORTEDCONTEXTTYPEFORQUERY + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDCLEARVALUE = ( D3D12_MESSAGE_ID_FLUSH1_INVALIDCONTEXTTYPE + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDCLEARVALUEFORMAT = ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDCLEARVALUE + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDCLEARVALUEFORMAT = ( D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDCLEARVALUEFORMAT + 1 ) , + D3D12_MESSAGE_ID_CREATERESOURCE_CLEARVALUEDENORMFLUSH = ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDCLEARVALUEFORMAT + 1 ) , + D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_INVALIDDEPTH = ( D3D12_MESSAGE_ID_CREATERESOURCE_CLEARVALUEDENORMFLUSH + 1 ) , + D3D12_MESSAGE_ID_CLEARRENDERTARGETVIEW_MISMATCHINGCLEARVALUE = ( D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_INVALIDDEPTH + 1 ) , + D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_MISMATCHINGCLEARVALUE = ( D3D12_MESSAGE_ID_CLEARRENDERTARGETVIEW_MISMATCHINGCLEARVALUE + 1 ) , + D3D12_MESSAGE_ID_MAP_INVALIDHEAP = ( D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_MISMATCHINGCLEARVALUE + 1 ) , + D3D12_MESSAGE_ID_UNMAP_INVALIDHEAP = ( D3D12_MESSAGE_ID_MAP_INVALIDHEAP + 1 ) , + D3D12_MESSAGE_ID_MAP_INVALIDRESOURCE = ( D3D12_MESSAGE_ID_UNMAP_INVALIDHEAP + 1 ) , + D3D12_MESSAGE_ID_UNMAP_INVALIDRESOURCE = ( D3D12_MESSAGE_ID_MAP_INVALIDRESOURCE + 1 ) , + D3D12_MESSAGE_ID_MAP_INVALIDSUBRESOURCE = ( D3D12_MESSAGE_ID_UNMAP_INVALIDRESOURCE + 1 ) , + D3D12_MESSAGE_ID_UNMAP_INVALIDSUBRESOURCE = ( D3D12_MESSAGE_ID_MAP_INVALIDSUBRESOURCE + 1 ) , + D3D12_MESSAGE_ID_MAP_INVALIDRANGE = ( D3D12_MESSAGE_ID_UNMAP_INVALIDSUBRESOURCE + 1 ) , + D3D12_MESSAGE_ID_UNMAP_INVALIDRANGE = ( D3D12_MESSAGE_ID_MAP_INVALIDRANGE + 1 ) , + D3D12_MESSAGE_ID_MAP_NULLRANGE = ( D3D12_MESSAGE_ID_UNMAP_INVALIDRANGE + 1 ) , + D3D12_MESSAGE_ID_UNMAP_NULLRANGE = ( D3D12_MESSAGE_ID_MAP_NULLRANGE + 1 ) , + D3D12_MESSAGE_ID_MAP_INVALIDDATAPOINTER = ( D3D12_MESSAGE_ID_UNMAP_NULLRANGE + 1 ) , + D3D12_MESSAGE_ID_MAP_INVALIDARG_RETURN = ( D3D12_MESSAGE_ID_MAP_INVALIDDATAPOINTER + 1 ) , + D3D12_MESSAGE_ID_MAP_OUTOFMEMORY_RETURN = ( D3D12_MESSAGE_ID_MAP_INVALIDARG_RETURN + 1 ) , + D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_BUNDLENOTSUPPORTED = ( D3D12_MESSAGE_ID_MAP_OUTOFMEMORY_RETURN + 1 ) , + D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_COMMANDLISTMISMATCH = ( D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_BUNDLENOTSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_OPENCOMMANDLIST = ( D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_COMMANDLISTMISMATCH + 1 ) , + D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_FAILEDCOMMANDLIST = ( D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_OPENCOMMANDLIST + 1 ) , + D3D12_MESSAGE_ID_COPYBUFFERREGION_NULLDST = ( D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_FAILEDCOMMANDLIST + 1 ) , + D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDDSTRESOURCEDIMENSION = ( D3D12_MESSAGE_ID_COPYBUFFERREGION_NULLDST + 1 ) , + D3D12_MESSAGE_ID_COPYBUFFERREGION_DSTRANGEOUTOFBOUNDS = ( D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDDSTRESOURCEDIMENSION + 1 ) , + D3D12_MESSAGE_ID_COPYBUFFERREGION_NULLSRC = ( D3D12_MESSAGE_ID_COPYBUFFERREGION_DSTRANGEOUTOFBOUNDS + 1 ) , + D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDSRCRESOURCEDIMENSION = ( D3D12_MESSAGE_ID_COPYBUFFERREGION_NULLSRC + 1 ) , + D3D12_MESSAGE_ID_COPYBUFFERREGION_SRCRANGEOUTOFBOUNDS = ( D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDSRCRESOURCEDIMENSION + 1 ) , + D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDCOPYFLAGS = ( D3D12_MESSAGE_ID_COPYBUFFERREGION_SRCRANGEOUTOFBOUNDS + 1 ) , + D3D12_MESSAGE_ID_COPYTEXTUREREGION_NULLDST = ( D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDCOPYFLAGS + 1 ) , + D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDDSTTYPE = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_NULLDST + 1 ) , + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTRESOURCEDIMENSION = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDDSTTYPE + 1 ) , + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTRESOURCE = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTRESOURCEDIMENSION + 1 ) , + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTSUBRESOURCE = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTRESOURCE + 1 ) , + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTOFFSET = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTSUBRESOURCE + 1 ) , + D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDDSTFORMAT = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTOFFSET + 1 ) , + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTFORMAT = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDDSTFORMAT + 1 ) , + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTDIMENSIONS = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTFORMAT + 1 ) , + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTROWPITCH = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTDIMENSIONS + 1 ) , + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTPLACEMENT = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTROWPITCH + 1 ) , + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTDSPLACEDFOOTPRINTFORMAT = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTPLACEMENT + 1 ) , + D3D12_MESSAGE_ID_COPYTEXTUREREGION_DSTREGIONOUTOFBOUNDS = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTDSPLACEDFOOTPRINTFORMAT + 1 ) , + D3D12_MESSAGE_ID_COPYTEXTUREREGION_NULLSRC = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_DSTREGIONOUTOFBOUNDS + 1 ) , + D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDSRCTYPE = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_NULLSRC + 1 ) , + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCRESOURCEDIMENSION = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDSRCTYPE + 1 ) , + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCRESOURCE = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCRESOURCEDIMENSION + 1 ) , + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCSUBRESOURCE = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCRESOURCE + 1 ) , + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCOFFSET = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCSUBRESOURCE + 1 ) , + D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDSRCFORMAT = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCOFFSET + 1 ) , + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCFORMAT = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDSRCFORMAT + 1 ) , + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCDIMENSIONS = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCFORMAT + 1 ) , + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCROWPITCH = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCDIMENSIONS + 1 ) , + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCPLACEMENT = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCROWPITCH + 1 ) , + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCDSPLACEDFOOTPRINTFORMAT = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCPLACEMENT + 1 ) , + D3D12_MESSAGE_ID_COPYTEXTUREREGION_SRCREGIONOUTOFBOUNDS = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCDSPLACEDFOOTPRINTFORMAT + 1 ) , + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTCOORDINATES = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_SRCREGIONOUTOFBOUNDS + 1 ) , + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCBOX = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTCOORDINATES + 1 ) , + D3D12_MESSAGE_ID_COPYTEXTUREREGION_FORMATMISMATCH = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCBOX + 1 ) , + D3D12_MESSAGE_ID_COPYTEXTUREREGION_EMPTYBOX = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_FORMATMISMATCH + 1 ) , + D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDCOPYFLAGS = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_EMPTYBOX + 1 ) , + D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_SUBRESOURCE_INDEX = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDCOPYFLAGS + 1 ) , + D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_FORMAT = ( D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_SUBRESOURCE_INDEX + 1 ) , + D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_RESOURCE_MISMATCH = ( D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_FORMAT + 1 ) , + D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_SAMPLE_COUNT = ( D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_RESOURCE_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_INVALID_SHADER = ( D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_SAMPLE_COUNT + 1 ) , + D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_CS_ROOT_SIGNATURE_MISMATCH = ( D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_INVALID_SHADER + 1 ) , + D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_MISSING_ROOT_SIGNATURE = ( D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_CS_ROOT_SIGNATURE_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALIDCACHEDBLOB = ( D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_MISSING_ROOT_SIGNATURE + 1 ) , + D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBADAPTERMISMATCH = ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALIDCACHEDBLOB + 1 ) , + D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBDRIVERVERSIONMISMATCH = ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBADAPTERMISMATCH + 1 ) , + D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBDESCMISMATCH = ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBDRIVERVERSIONMISMATCH + 1 ) , + D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBIGNORED = ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBDESCMISMATCH + 1 ) , + D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDHEAP = ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBIGNORED + 1 ) , + D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDRESOURCE = ( D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDHEAP + 1 ) , + D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDBOX = ( D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDRESOURCE + 1 ) , + D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDSUBRESOURCE = ( D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDBOX + 1 ) , + D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_EMPTYBOX = ( D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDSUBRESOURCE + 1 ) , + D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDHEAP = ( D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_EMPTYBOX + 1 ) , + D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDRESOURCE = ( D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDHEAP + 1 ) , + D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDBOX = ( D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDRESOURCE + 1 ) , + D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDSUBRESOURCE = ( D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDBOX + 1 ) , + D3D12_MESSAGE_ID_READFROMSUBRESOURCE_EMPTYBOX = ( D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDSUBRESOURCE + 1 ) , + D3D12_MESSAGE_ID_TOO_MANY_NODES_SPECIFIED = ( D3D12_MESSAGE_ID_READFROMSUBRESOURCE_EMPTYBOX + 1 ) , + D3D12_MESSAGE_ID_INVALID_NODE_INDEX = ( D3D12_MESSAGE_ID_TOO_MANY_NODES_SPECIFIED + 1 ) , + D3D12_MESSAGE_ID_GETHEAPPROPERTIES_INVALIDRESOURCE = ( D3D12_MESSAGE_ID_INVALID_NODE_INDEX + 1 ) , + D3D12_MESSAGE_ID_NODE_MASK_MISMATCH = ( D3D12_MESSAGE_ID_GETHEAPPROPERTIES_INVALIDRESOURCE + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_OUTOFMEMORY = ( D3D12_MESSAGE_ID_NODE_MASK_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_MULTIPLE_SWAPCHAIN_BUFFER_REFERENCES = ( D3D12_MESSAGE_ID_COMMAND_LIST_OUTOFMEMORY + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_TOO_MANY_SWAPCHAIN_REFERENCES = ( D3D12_MESSAGE_ID_COMMAND_LIST_MULTIPLE_SWAPCHAIN_BUFFER_REFERENCES + 1 ) , + D3D12_MESSAGE_ID_COMMAND_QUEUE_TOO_MANY_SWAPCHAIN_REFERENCES = ( D3D12_MESSAGE_ID_COMMAND_LIST_TOO_MANY_SWAPCHAIN_REFERENCES + 1 ) , + D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_WRONGSWAPCHAINBUFFERREFERENCE = ( D3D12_MESSAGE_ID_COMMAND_QUEUE_TOO_MANY_SWAPCHAIN_REFERENCES + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_SETRENDERTARGETS_INVALIDNUMRENDERTARGETS = ( D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_WRONGSWAPCHAINBUFFERREFERENCE + 1 ) , + D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_TYPE = ( D3D12_MESSAGE_ID_COMMAND_LIST_SETRENDERTARGETS_INVALIDNUMRENDERTARGETS + 1 ) , + D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_FLAGS = ( D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_TYPE + 1 ) , + D3D12_MESSAGE_ID_CREATESHAREDRESOURCE_INVALIDFLAGS = ( D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_FLAGS + 1 ) , + D3D12_MESSAGE_ID_CREATESHAREDRESOURCE_INVALIDFORMAT = ( D3D12_MESSAGE_ID_CREATESHAREDRESOURCE_INVALIDFLAGS + 1 ) , + D3D12_MESSAGE_ID_CREATESHAREDHEAP_INVALIDFLAGS = ( D3D12_MESSAGE_ID_CREATESHAREDRESOURCE_INVALIDFORMAT + 1 ) , + D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_UNRECOGNIZEDPROPERTIES = ( D3D12_MESSAGE_ID_CREATESHAREDHEAP_INVALIDFLAGS + 1 ) , + D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_INVALIDSIZE = ( D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_UNRECOGNIZEDPROPERTIES + 1 ) , + D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_INVALIDOBJECT = ( D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_INVALIDSIZE + 1 ) , + D3D12_MESSAGE_ID_KEYEDMUTEX_INVALIDOBJECT = ( D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_INVALIDOBJECT + 1 ) , + D3D12_MESSAGE_ID_KEYEDMUTEX_INVALIDKEY = ( D3D12_MESSAGE_ID_KEYEDMUTEX_INVALIDOBJECT + 1 ) , + D3D12_MESSAGE_ID_KEYEDMUTEX_WRONGSTATE = ( D3D12_MESSAGE_ID_KEYEDMUTEX_INVALIDKEY + 1 ) , + D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_PRIORITY = ( D3D12_MESSAGE_ID_KEYEDMUTEX_WRONGSTATE + 1 ) , + D3D12_MESSAGE_ID_OBJECT_DELETED_WHILE_STILL_IN_USE = ( D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_PRIORITY + 1 ) , + D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALID_FLAGS = ( D3D12_MESSAGE_ID_OBJECT_DELETED_WHILE_STILL_IN_USE + 1 ) , + D3D12_MESSAGE_ID_HEAP_ADDRESS_RANGE_HAS_NO_RESOURCE = ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALID_FLAGS + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RENDER_TARGET_DELETED = ( D3D12_MESSAGE_ID_HEAP_ADDRESS_RANGE_HAS_NO_RESOURCE + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_ALL_RENDER_TARGETS_HAVE_UNKNOWN_FORMAT = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RENDER_TARGET_DELETED + 1 ) , + D3D12_MESSAGE_ID_HEAP_ADDRESS_RANGE_INTERSECTS_MULTIPLE_BUFFERS = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_ALL_RENDER_TARGETS_HAVE_UNKNOWN_FORMAT + 1 ) , + D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_GPU_WRITTEN_READBACK_RESOURCE_MAPPED = ( D3D12_MESSAGE_ID_HEAP_ADDRESS_RANGE_INTERSECTS_MULTIPLE_BUFFERS + 1 ) , + D3D12_MESSAGE_ID_UNMAP_RANGE_NOT_NEEDED = ( D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_GPU_WRITTEN_READBACK_RESOURCE_MAPPED + 1 ) , + D3D12_MESSAGE_ID_UNMAP_RANGE_NOT_EMPTY = ( D3D12_MESSAGE_ID_UNMAP_RANGE_NOT_NEEDED + 1 ) , + D3D12_MESSAGE_ID_MAP_INVALID_NULLRANGE = ( D3D12_MESSAGE_ID_UNMAP_RANGE_NOT_EMPTY + 1 ) , + D3D12_MESSAGE_ID_UNMAP_INVALID_NULLRANGE = ( D3D12_MESSAGE_ID_MAP_INVALID_NULLRANGE + 1 ) , + D3D12_MESSAGE_ID_NO_GRAPHICS_API_SUPPORT = ( D3D12_MESSAGE_ID_UNMAP_INVALID_NULLRANGE + 1 ) , + D3D12_MESSAGE_ID_NO_COMPUTE_API_SUPPORT = ( D3D12_MESSAGE_ID_NO_GRAPHICS_API_SUPPORT + 1 ) , + D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_RESOURCE_FLAGS_NOT_SUPPORTED = ( D3D12_MESSAGE_ID_NO_COMPUTE_API_SUPPORT + 1 ) , + D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_ROOT_ARGUMENT_UNINITIALIZED = ( D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_RESOURCE_FLAGS_NOT_SUPPORTED + 1 ) , + D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_HEAP_INDEX_OUT_OF_BOUNDS = ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_ROOT_ARGUMENT_UNINITIALIZED + 1 ) , + D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_TABLE_REGISTER_INDEX_OUT_OF_BOUNDS = ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_HEAP_INDEX_OUT_OF_BOUNDS + 1 ) , + D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_UNINITIALIZED = ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_TABLE_REGISTER_INDEX_OUT_OF_BOUNDS + 1 ) , + D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_TYPE_MISMATCH = ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_UNINITIALIZED + 1 ) , + D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_SRV_RESOURCE_DIMENSION_MISMATCH = ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_TYPE_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_UAV_RESOURCE_DIMENSION_MISMATCH = ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_SRV_RESOURCE_DIMENSION_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_INCOMPATIBLE_RESOURCE_STATE = ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_UAV_RESOURCE_DIMENSION_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_COPYRESOURCE_NULLDST = ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_INCOMPATIBLE_RESOURCE_STATE + 1 ) , + D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDDSTRESOURCE = ( D3D12_MESSAGE_ID_COPYRESOURCE_NULLDST + 1 ) , + D3D12_MESSAGE_ID_COPYRESOURCE_NULLSRC = ( D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDDSTRESOURCE + 1 ) , + D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDSRCRESOURCE = ( D3D12_MESSAGE_ID_COPYRESOURCE_NULLSRC + 1 ) , + D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_NULLDST = ( D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDSRCRESOURCE + 1 ) , + D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALIDDSTRESOURCE = ( D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_NULLDST + 1 ) , + D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_NULLSRC = ( D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALIDDSTRESOURCE + 1 ) , + D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALIDSRCRESOURCE = ( D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_NULLSRC + 1 ) , + D3D12_MESSAGE_ID_PIPELINE_STATE_TYPE_MISMATCH = ( D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALIDSRCRESOURCE + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DISPATCH_ROOT_SIGNATURE_NOT_SET = ( D3D12_MESSAGE_ID_PIPELINE_STATE_TYPE_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DISPATCH_ROOT_SIGNATURE_MISMATCH = ( D3D12_MESSAGE_ID_COMMAND_LIST_DISPATCH_ROOT_SIGNATURE_NOT_SET + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_BARRIER_ZERO_BARRIERS = ( D3D12_MESSAGE_ID_COMMAND_LIST_DISPATCH_ROOT_SIGNATURE_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_BEGIN_END_EVENT_MISMATCH = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_ZERO_BARRIERS + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_BARRIER_POSSIBLE_BEFORE_AFTER_MISMATCH = ( D3D12_MESSAGE_ID_BEGIN_END_EVENT_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_BEGIN_END = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_POSSIBLE_BEFORE_AFTER_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_INVALID_RESOURCE = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_BEGIN_END + 1 ) , + D3D12_MESSAGE_ID_USE_OF_ZERO_REFCOUNT_OBJECT = ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_INVALID_RESOURCE + 1 ) , + D3D12_MESSAGE_ID_OBJECT_EVICTED_WHILE_STILL_IN_USE = ( D3D12_MESSAGE_ID_USE_OF_ZERO_REFCOUNT_OBJECT + 1 ) , + D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_ROOT_DESCRIPTOR_ACCESS_OUT_OF_BOUNDS = ( D3D12_MESSAGE_ID_OBJECT_EVICTED_WHILE_STILL_IN_USE + 1 ) , + D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_INVALIDLIBRARYBLOB = ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_ROOT_DESCRIPTOR_ACCESS_OUT_OF_BOUNDS + 1 ) , + D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_DRIVERVERSIONMISMATCH = ( D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_INVALIDLIBRARYBLOB + 1 ) , + D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_ADAPTERVERSIONMISMATCH = ( D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_DRIVERVERSIONMISMATCH + 1 ) , + D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_UNSUPPORTED = ( D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_ADAPTERVERSIONMISMATCH + 1 ) , + D3D12_MESSAGE_ID_CREATE_PIPELINELIBRARY = ( D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_UNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_LIVE_PIPELINELIBRARY = ( D3D12_MESSAGE_ID_CREATE_PIPELINELIBRARY + 1 ) , + D3D12_MESSAGE_ID_DESTROY_PIPELINELIBRARY = ( D3D12_MESSAGE_ID_LIVE_PIPELINELIBRARY + 1 ) , + D3D12_MESSAGE_ID_STOREPIPELINE_NONAME = ( D3D12_MESSAGE_ID_DESTROY_PIPELINELIBRARY + 1 ) , + D3D12_MESSAGE_ID_STOREPIPELINE_DUPLICATENAME = ( D3D12_MESSAGE_ID_STOREPIPELINE_NONAME + 1 ) , + D3D12_MESSAGE_ID_LOADPIPELINE_NAMENOTFOUND = ( D3D12_MESSAGE_ID_STOREPIPELINE_DUPLICATENAME + 1 ) , + D3D12_MESSAGE_ID_LOADPIPELINE_INVALIDDESC = ( D3D12_MESSAGE_ID_LOADPIPELINE_NAMENOTFOUND + 1 ) , + D3D12_MESSAGE_ID_PIPELINELIBRARY_SERIALIZE_NOTENOUGHMEMORY = ( D3D12_MESSAGE_ID_LOADPIPELINE_INVALIDDESC + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_OUTPUT_RT_OUTPUT_MISMATCH = ( D3D12_MESSAGE_ID_PIPELINELIBRARY_SERIALIZE_NOTENOUGHMEMORY + 1 ) , + D3D12_MESSAGE_ID_SETEVENTONMULTIPLEFENCECOMPLETION_INVALIDFLAGS = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_OUTPUT_RT_OUTPUT_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_CREATE_QUEUE_VIDEO_NOT_SUPPORTED = ( D3D12_MESSAGE_ID_SETEVENTONMULTIPLEFENCECOMPLETION_INVALIDFLAGS + 1 ) , + D3D12_MESSAGE_ID_CREATE_COMMAND_ALLOCATOR_VIDEO_NOT_SUPPORTED = ( D3D12_MESSAGE_ID_CREATE_QUEUE_VIDEO_NOT_SUPPORTED + 1 ) , + D3D12_MESSAGE_ID_CREATEQUERY_HEAP_VIDEO_DECODE_STATISTICS_NOT_SUPPORTED = ( D3D12_MESSAGE_ID_CREATE_COMMAND_ALLOCATOR_VIDEO_NOT_SUPPORTED + 1 ) , + D3D12_MESSAGE_ID_CREATE_VIDEODECODECOMMANDLIST = ( D3D12_MESSAGE_ID_CREATEQUERY_HEAP_VIDEO_DECODE_STATISTICS_NOT_SUPPORTED + 1 ) , + D3D12_MESSAGE_ID_CREATE_VIDEODECODER = ( D3D12_MESSAGE_ID_CREATE_VIDEODECODECOMMANDLIST + 1 ) , + D3D12_MESSAGE_ID_CREATE_VIDEODECODESTREAM = ( D3D12_MESSAGE_ID_CREATE_VIDEODECODER + 1 ) , + D3D12_MESSAGE_ID_LIVE_VIDEODECODECOMMANDLIST = ( D3D12_MESSAGE_ID_CREATE_VIDEODECODESTREAM + 1 ) , + D3D12_MESSAGE_ID_LIVE_VIDEODECODER = ( D3D12_MESSAGE_ID_LIVE_VIDEODECODECOMMANDLIST + 1 ) , + D3D12_MESSAGE_ID_LIVE_VIDEODECODESTREAM = ( D3D12_MESSAGE_ID_LIVE_VIDEODECODER + 1 ) , + D3D12_MESSAGE_ID_DESTROY_VIDEODECODECOMMANDLIST = ( D3D12_MESSAGE_ID_LIVE_VIDEODECODESTREAM + 1 ) , + D3D12_MESSAGE_ID_DESTROY_VIDEODECODER = ( D3D12_MESSAGE_ID_DESTROY_VIDEODECODECOMMANDLIST + 1 ) , + D3D12_MESSAGE_ID_DESTROY_VIDEODECODESTREAM = ( D3D12_MESSAGE_ID_DESTROY_VIDEODECODER + 1 ) , + D3D12_MESSAGE_ID_DECODE_FRAME_INVALID_PARAMETERS = ( D3D12_MESSAGE_ID_DESTROY_VIDEODECODESTREAM + 1 ) , + D3D12_MESSAGE_ID_DEPRECATED_API = ( D3D12_MESSAGE_ID_DECODE_FRAME_INVALID_PARAMETERS + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_COMMAND_LIST_TYPE = ( D3D12_MESSAGE_ID_DEPRECATED_API + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_DESCRIPTOR_TABLE_NOT_SET = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_COMMAND_LIST_TYPE + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_CONSTANT_BUFFER_VIEW_NOT_SET = ( D3D12_MESSAGE_ID_COMMAND_LIST_DESCRIPTOR_TABLE_NOT_SET + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_SHADER_RESOURCE_VIEW_NOT_SET = ( D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_CONSTANT_BUFFER_VIEW_NOT_SET + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_UNORDERED_ACCESS_VIEW_NOT_SET = ( D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_SHADER_RESOURCE_VIEW_NOT_SET + 1 ) , + D3D12_MESSAGE_ID_DISCARD_INVALID_SUBRESOURCE_RANGE = ( D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_UNORDERED_ACCESS_VIEW_NOT_SET + 1 ) , + D3D12_MESSAGE_ID_DISCARD_ONE_SUBRESOURCE_FOR_MIPS_WITH_RECTS = ( D3D12_MESSAGE_ID_DISCARD_INVALID_SUBRESOURCE_RANGE + 1 ) , + D3D12_MESSAGE_ID_DISCARD_NO_RECTS_FOR_NON_TEXTURE2D = ( D3D12_MESSAGE_ID_DISCARD_ONE_SUBRESOURCE_FOR_MIPS_WITH_RECTS + 1 ) , + D3D12_MESSAGE_ID_COPY_ON_SAME_SUBRESOURCE = ( D3D12_MESSAGE_ID_DISCARD_NO_RECTS_FOR_NON_TEXTURE2D + 1 ) , + D3D12_MESSAGE_ID_SETRESIDENCYPRIORITY_INVALID_PAGEABLE = ( D3D12_MESSAGE_ID_COPY_ON_SAME_SUBRESOURCE + 1 ) , + D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_UNSUPPORTED = ( D3D12_MESSAGE_ID_SETRESIDENCYPRIORITY_INVALID_PAGEABLE + 1 ) , + D3D12_MESSAGE_ID_STATIC_DESCRIPTOR_INVALID_DESCRIPTOR_CHANGE = ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_UNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_DATA_STATIC_DESCRIPTOR_INVALID_DATA_CHANGE = ( D3D12_MESSAGE_ID_STATIC_DESCRIPTOR_INVALID_DESCRIPTOR_CHANGE + 1 ) , + D3D12_MESSAGE_ID_DATA_STATIC_WHILE_SET_AT_EXECUTE_DESCRIPTOR_INVALID_DATA_CHANGE = ( D3D12_MESSAGE_ID_DATA_STATIC_DESCRIPTOR_INVALID_DATA_CHANGE + 1 ) , + D3D12_MESSAGE_ID_EXECUTE_BUNDLE_STATIC_DESCRIPTOR_DATA_STATIC_NOT_SET = ( D3D12_MESSAGE_ID_DATA_STATIC_WHILE_SET_AT_EXECUTE_DESCRIPTOR_INVALID_DATA_CHANGE + 1 ) , + D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_RESOURCE_ACCESS_OUT_OF_BOUNDS = ( D3D12_MESSAGE_ID_EXECUTE_BUNDLE_STATIC_DESCRIPTOR_DATA_STATIC_NOT_SET + 1 ) , + D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_SAMPLER_MODE_MISMATCH = ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_RESOURCE_ACCESS_OUT_OF_BOUNDS + 1 ) , + D3D12_MESSAGE_ID_CREATE_FENCE_INVALID_FLAGS = ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_SAMPLER_MODE_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_RESOURCE_BARRIER_DUPLICATE_SUBRESOURCE_TRANSITIONS = ( D3D12_MESSAGE_ID_CREATE_FENCE_INVALID_FLAGS + 1 ) , + D3D12_MESSAGE_ID_SETRESIDENCYPRIORITY_INVALID_PRIORITY = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_DUPLICATE_SUBRESOURCE_TRANSITIONS + 1 ) , + D3D12_MESSAGE_ID_CREATE_PASS = ( D3D12_MESSAGE_ID_SETRESIDENCYPRIORITY_INVALID_PRIORITY + 1 ) , + D3D12_MESSAGE_ID_DESTROY_PASS = ( D3D12_MESSAGE_ID_CREATE_PASS + 1 ) , + D3D12_MESSAGE_ID_LIVE_PASS = ( D3D12_MESSAGE_ID_DESTROY_PASS + 1 ) , + D3D12_MESSAGE_ID_CREATE_DESCRIPTOR_HEAP_LARGE_NUM_DESCRIPTORS = ( D3D12_MESSAGE_ID_LIVE_PASS + 1 ) , + D3D12_MESSAGE_ID_BEGIN_EVENT = ( D3D12_MESSAGE_ID_CREATE_DESCRIPTOR_HEAP_LARGE_NUM_DESCRIPTORS + 1 ) , + D3D12_MESSAGE_ID_END_EVENT = ( D3D12_MESSAGE_ID_BEGIN_EVENT + 1 ) , + D3D12_MESSAGE_ID_CREATEDEVICE_DEBUG_LAYER_STARTUP_OPTIONS = ( D3D12_MESSAGE_ID_END_EVENT + 1 ) , + D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_DEPTHBOUNDSTEST_UNSUPPORTED = ( D3D12_MESSAGE_ID_CREATEDEVICE_DEBUG_LAYER_STARTUP_OPTIONS + 1 ) , + D3D12_MESSAGE_ID_CREATEPIPELINESTATE_DUPLICATE_SUBOBJECT = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_DEPTHBOUNDSTEST_UNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_CREATEPIPELINESTATE_UNKNOWN_SUBOBJECT = ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_DUPLICATE_SUBOBJECT + 1 ) , + D3D12_MESSAGE_ID_CREATEPIPELINESTATE_ZERO_SIZE_STREAM = ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_UNKNOWN_SUBOBJECT + 1 ) , + D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALID_STREAM = ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_ZERO_SIZE_STREAM + 1 ) , + D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CANNOT_DEDUCE_TYPE = ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALID_STREAM + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_STATIC_DESCRIPTOR_RESOURCE_DIMENSION_MISMATCH = ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CANNOT_DEDUCE_TYPE + 1 ) , + D3D12_MESSAGE_ID_CREATE_COMMAND_QUEUE_INSUFFICIENT_PRIVILEGE_FOR_GLOBAL_REALTIME = ( D3D12_MESSAGE_ID_COMMAND_LIST_STATIC_DESCRIPTOR_RESOURCE_DIMENSION_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_CREATE_COMMAND_QUEUE_INSUFFICIENT_HARDWARE_SUPPORT_FOR_GLOBAL_REALTIME = ( D3D12_MESSAGE_ID_CREATE_COMMAND_QUEUE_INSUFFICIENT_PRIVILEGE_FOR_GLOBAL_REALTIME + 1 ) , + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_ARCHITECTURE = ( D3D12_MESSAGE_ID_CREATE_COMMAND_QUEUE_INSUFFICIENT_HARDWARE_SUPPORT_FOR_GLOBAL_REALTIME + 1 ) , + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DST = ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_ARCHITECTURE + 1 ) , + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DST_RESOURCE_DIMENSION = ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DST + 1 ) , + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DST_RANGE_OUT_OF_BOUNDS = ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DST_RESOURCE_DIMENSION + 1 ) , + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_SRC = ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DST_RANGE_OUT_OF_BOUNDS + 1 ) , + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_SRC_RESOURCE_DIMENSION = ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_SRC + 1 ) , + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_SRC_RANGE_OUT_OF_BOUNDS = ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_SRC_RESOURCE_DIMENSION + 1 ) , + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_OFFSET_ALIGNMENT = ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_SRC_RANGE_OUT_OF_BOUNDS + 1 ) , + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DEPENDENT_RESOURCES = ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_OFFSET_ALIGNMENT + 1 ) , + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DEPENDENT_SUBRESOURCE_RANGES = ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DEPENDENT_RESOURCES + 1 ) , + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DEPENDENT_RESOURCE = ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DEPENDENT_SUBRESOURCE_RANGES + 1 ) , + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DEPENDENT_SUBRESOURCE_RANGE = ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DEPENDENT_RESOURCE + 1 ) , + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DEPENDENT_SUBRESOURCE_OUT_OF_BOUNDS = ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DEPENDENT_SUBRESOURCE_RANGE + 1 ) , + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DEPENDENT_RANGE_OUT_OF_BOUNDS = ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DEPENDENT_SUBRESOURCE_OUT_OF_BOUNDS + 1 ) , + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_ZERO_DEPENDENCIES = ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DEPENDENT_RANGE_OUT_OF_BOUNDS + 1 ) , + D3D12_MESSAGE_ID_DEVICE_CREATE_SHARED_HANDLE_INVALIDARG = ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_ZERO_DEPENDENCIES + 1 ) , + D3D12_MESSAGE_ID_DESCRIPTOR_HANDLE_WITH_INVALID_RESOURCE = ( D3D12_MESSAGE_ID_DEVICE_CREATE_SHARED_HANDLE_INVALIDARG + 1 ) , + D3D12_MESSAGE_ID_SETDEPTHBOUNDS_INVALIDARGS = ( D3D12_MESSAGE_ID_DESCRIPTOR_HANDLE_WITH_INVALID_RESOURCE + 1 ) , + D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_RESOURCE_STATE_IMPRECISE = ( D3D12_MESSAGE_ID_SETDEPTHBOUNDS_INVALIDARGS + 1 ) , + D3D12_MESSAGE_ID_COMMAND_LIST_PIPELINE_STATE_NOT_SET = ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_RESOURCE_STATE_IMPRECISE + 1 ) , + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_MODEL_MISMATCH = ( D3D12_MESSAGE_ID_COMMAND_LIST_PIPELINE_STATE_NOT_SET + 1 ) , + D3D12_MESSAGE_ID_OBJECT_ACCESSED_WHILE_STILL_IN_USE = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_MODEL_MISMATCH + 1 ) , + D3D12_MESSAGE_ID_PROGRAMMABLE_MSAA_UNSUPPORTED = ( D3D12_MESSAGE_ID_OBJECT_ACCESSED_WHILE_STILL_IN_USE + 1 ) , + D3D12_MESSAGE_ID_SETSAMPLEPOSITIONS_INVALIDARGS = ( D3D12_MESSAGE_ID_PROGRAMMABLE_MSAA_UNSUPPORTED + 1 ) , + D3D12_MESSAGE_ID_RESOLVESUBRESOURCEREGION_INVALID_RECT = ( D3D12_MESSAGE_ID_SETSAMPLEPOSITIONS_INVALIDARGS + 1 ) , + D3D12_MESSAGE_ID_CREATE_VIDEODECODECOMMANDQUEUE = ( D3D12_MESSAGE_ID_RESOLVESUBRESOURCEREGION_INVALID_RECT + 1 ) , + D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSCOMMANDLIST = ( D3D12_MESSAGE_ID_CREATE_VIDEODECODECOMMANDQUEUE + 1 ) , + D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSCOMMANDQUEUE = ( D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSCOMMANDLIST + 1 ) , + D3D12_MESSAGE_ID_LIVE_VIDEODECODECOMMANDQUEUE = ( D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSCOMMANDQUEUE + 1 ) , + D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSCOMMANDLIST = ( D3D12_MESSAGE_ID_LIVE_VIDEODECODECOMMANDQUEUE + 1 ) , + D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSCOMMANDQUEUE = ( D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSCOMMANDLIST + 1 ) , + D3D12_MESSAGE_ID_DESTROY_VIDEODECODECOMMANDQUEUE = ( D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSCOMMANDQUEUE + 1 ) , + D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSCOMMANDLIST = ( D3D12_MESSAGE_ID_DESTROY_VIDEODECODECOMMANDQUEUE + 1 ) , + D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSCOMMANDQUEUE = ( D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSCOMMANDLIST + 1 ) , + D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSOR = ( D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSCOMMANDQUEUE + 1 ) , + D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSSTREAM = ( D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSOR + 1 ) , + D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSOR = ( D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSSTREAM + 1 ) , + D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSSTREAM = ( D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSOR + 1 ) , + D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSOR = ( D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSSTREAM + 1 ) , + D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSSTREAM = ( D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSOR + 1 ) , + D3D12_MESSAGE_ID_PROCESS_FRAME_INVALID_PARAMETERS = ( D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSSTREAM + 1 ) , + D3D12_MESSAGE_ID_COPY_INVALIDLAYOUT = ( D3D12_MESSAGE_ID_PROCESS_FRAME_INVALID_PARAMETERS + 1 ) , + D3D12_MESSAGE_ID_CREATE_CRYPTO_SESSION = 1068, + D3D12_MESSAGE_ID_CREATE_CRYPTO_SESSION_POLICY = 1069, + D3D12_MESSAGE_ID_CREATE_PROTECTED_RESOURCE_SESSION = 1070, + D3D12_MESSAGE_ID_LIVE_CRYPTO_SESSION = 1071, + D3D12_MESSAGE_ID_LIVE_CRYPTO_SESSION_POLICY = 1072, + D3D12_MESSAGE_ID_LIVE_PROTECTED_RESOURCE_SESSION = 1073, + D3D12_MESSAGE_ID_DESTROY_CRYPTO_SESSION = 1074, + D3D12_MESSAGE_ID_DESTROY_CRYPTO_SESSION_POLICY = 1075, + D3D12_MESSAGE_ID_DESTROY_PROTECTED_RESOURCE_SESSION = 1076, + D3D12_MESSAGE_ID_PROTECTED_RESOURCE_SESSION_UNSUPPORTED = 1077, + D3D12_MESSAGE_ID_FENCE_INVALIDOPERATION = 1078, + D3D12_MESSAGE_ID_CREATEQUERY_HEAP_COPY_QUEUE_TIMESTAMPS_NOT_SUPPORTED = 1079, + D3D12_MESSAGE_ID_SAMPLEPOSITIONS_MISMATCH_DEFERRED = 1080, + D3D12_MESSAGE_ID_SAMPLEPOSITIONS_MISMATCH_RECORDTIME_ASSUMEDFROMFIRSTUSE = 1081, + D3D12_MESSAGE_ID_SAMPLEPOSITIONS_MISMATCH_RECORDTIME_ASSUMEDFROMCLEAR = 1082, + D3D12_MESSAGE_ID_CREATE_VIDEODECODERHEAP = 1083, + D3D12_MESSAGE_ID_LIVE_VIDEODECODERHEAP = 1084, + D3D12_MESSAGE_ID_DESTROY_VIDEODECODERHEAP = 1085, + D3D12_MESSAGE_ID_OPENEXISTINGHEAP_INVALIDARG_RETURN = 1086, + D3D12_MESSAGE_ID_OPENEXISTINGHEAP_OUTOFMEMORY_RETURN = 1087, + D3D12_MESSAGE_ID_OPENEXISTINGHEAP_INVALIDADDRESS = 1088, + D3D12_MESSAGE_ID_OPENEXISTINGHEAP_INVALIDHANDLE = 1089, + D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_INVALID_DEST = 1090, + D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_INVALID_MODE = 1091, + D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_INVALID_ALIGNMENT = 1092, + D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_NOT_SUPPORTED = 1093, + D3D12_MESSAGE_ID_SETVIEWINSTANCEMASK_INVALIDARGS = 1094, + D3D12_MESSAGE_ID_VIEW_INSTANCING_UNSUPPORTED = 1095, + D3D12_MESSAGE_ID_VIEW_INSTANCING_INVALIDARGS = 1096, + D3D12_MESSAGE_ID_COPYTEXTUREREGION_MISMATCH_DECODE_REFERENCE_ONLY_FLAG = 1097, + D3D12_MESSAGE_ID_COPYRESOURCE_MISMATCH_DECODE_REFERENCE_ONLY_FLAG = 1098, + D3D12_MESSAGE_ID_CREATE_VIDEO_DECODE_HEAP_CAPS_FAILURE = 1099, + D3D12_MESSAGE_ID_CREATE_VIDEO_DECODE_HEAP_CAPS_UNSUPPORTED = 1100, + D3D12_MESSAGE_ID_VIDEO_DECODE_SUPPORT_INVALID_INPUT = 1101, + D3D12_MESSAGE_ID_CREATE_VIDEO_DECODER_UNSUPPORTED = 1102, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_METADATA_ERROR = 1103, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_VIEW_INSTANCING_VERTEX_SIZE_EXCEEDED = 1104, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RUNTIME_INTERNAL_ERROR = 1105, + D3D12_MESSAGE_ID_NO_VIDEO_API_SUPPORT = 1106, + D3D12_MESSAGE_ID_VIDEO_PROCESS_SUPPORT_INVALID_INPUT = 1107, + D3D12_MESSAGE_ID_CREATE_VIDEO_PROCESSOR_CAPS_FAILURE = 1108, + D3D12_MESSAGE_ID_VIDEO_PROCESS_SUPPORT_UNSUPPORTED_FORMAT = 1109, + D3D12_MESSAGE_ID_VIDEO_DECODE_FRAME_INVALID_ARGUMENT = 1110, + D3D12_MESSAGE_ID_ENQUEUE_MAKE_RESIDENT_INVALID_FLAGS = 1111, + D3D12_MESSAGE_ID_OPENEXISTINGHEAP_UNSUPPORTED = 1112, + D3D12_MESSAGE_ID_VIDEO_PROCESS_FRAMES_INVALID_ARGUMENT = 1113, + D3D12_MESSAGE_ID_VIDEO_DECODE_SUPPORT_UNSUPPORTED = 1114, + D3D12_MESSAGE_ID_CREATE_COMMANDRECORDER = 1115, + D3D12_MESSAGE_ID_LIVE_COMMANDRECORDER = 1116, + D3D12_MESSAGE_ID_DESTROY_COMMANDRECORDER = 1117, + D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_VIDEO_NOT_SUPPORTED = 1118, + D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_INVALID_SUPPORT_FLAGS = 1119, + D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_INVALID_FLAGS = 1120, + D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_MORE_RECORDERS_THAN_LOGICAL_PROCESSORS = 1121, + D3D12_MESSAGE_ID_CREATE_COMMANDPOOL = 1122, + D3D12_MESSAGE_ID_LIVE_COMMANDPOOL = 1123, + D3D12_MESSAGE_ID_DESTROY_COMMANDPOOL = 1124, + D3D12_MESSAGE_ID_CREATE_COMMAND_POOL_INVALID_FLAGS = 1125, + D3D12_MESSAGE_ID_CREATE_COMMAND_LIST_VIDEO_NOT_SUPPORTED = 1126, + D3D12_MESSAGE_ID_COMMAND_RECORDER_SUPPORT_FLAGS_MISMATCH = 1127, + D3D12_MESSAGE_ID_COMMAND_RECORDER_CONTENTION = 1128, + D3D12_MESSAGE_ID_COMMAND_RECORDER_USAGE_WITH_CREATECOMMANDLIST_COMMAND_LIST = 1129, + D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_USAGE_WITH_CREATECOMMANDLIST1_COMMAND_LIST = 1130, + D3D12_MESSAGE_ID_CANNOT_EXECUTE_EMPTY_COMMAND_LIST = 1131, + D3D12_MESSAGE_ID_CANNOT_RESET_COMMAND_POOL_WITH_OPEN_COMMAND_LISTS = 1132, + D3D12_MESSAGE_ID_CANNOT_USE_COMMAND_RECORDER_WITHOUT_CURRENT_TARGET = 1133, + D3D12_MESSAGE_ID_CANNOT_CHANGE_COMMAND_RECORDER_TARGET_WHILE_RECORDING = 1134, + D3D12_MESSAGE_ID_COMMAND_POOL_SYNC = 1135, + D3D12_MESSAGE_ID_EVICT_UNDERFLOW = 1136, + D3D12_MESSAGE_ID_CREATE_META_COMMAND = 1137, + D3D12_MESSAGE_ID_LIVE_META_COMMAND = 1138, + D3D12_MESSAGE_ID_DESTROY_META_COMMAND = 1139, + D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALID_DST_RESOURCE = 1140, + D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALID_SRC_RESOURCE = 1141, + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DST_RESOURCE = 1142, + D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_SRC_RESOURCE = 1143, + D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_NULL_BUFFER = 1144, + D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_NULL_RESOURCE_DESC = 1145, + D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_UNSUPPORTED = 1146, + D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_BUFFER_DIMENSION = 1147, + D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_BUFFER_FLAGS = 1148, + D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_BUFFER_OFFSET = 1149, + D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_RESOURCE_DIMENSION = 1150, + D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_RESOURCE_FLAGS = 1151, + D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_OUTOFMEMORY_RETURN = 1152, + D3D12_MESSAGE_ID_CANNOT_CREATE_GRAPHICS_AND_VIDEO_COMMAND_RECORDER = 1153, + D3D12_MESSAGE_ID_UPDATETILEMAPPINGS_POSSIBLY_MISMATCHING_PROPERTIES = 1154, + D3D12_MESSAGE_ID_CREATE_COMMAND_LIST_INVALID_COMMAND_LIST_TYPE = 1155, + D3D12_MESSAGE_ID_CLEARUNORDEREDACCESSVIEW_INCOMPATIBLE_WITH_STRUCTURED_BUFFERS = 1156, + D3D12_MESSAGE_ID_COMPUTE_ONLY_DEVICE_OPERATION_UNSUPPORTED = 1157, + D3D12_MESSAGE_ID_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INVALID = 1158, + D3D12_MESSAGE_ID_EMIT_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_INVALID = 1159, + D3D12_MESSAGE_ID_COPY_RAYTRACING_ACCELERATION_STRUCTURE_INVALID = 1160, + D3D12_MESSAGE_ID_DISPATCH_RAYS_INVALID = 1161, + D3D12_MESSAGE_ID_GET_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO_INVALID = 1162, + D3D12_MESSAGE_ID_CREATE_LIFETIMETRACKER = 1163, + D3D12_MESSAGE_ID_LIVE_LIFETIMETRACKER = 1164, + D3D12_MESSAGE_ID_DESTROY_LIFETIMETRACKER = 1165, + D3D12_MESSAGE_ID_DESTROYOWNEDOBJECT_OBJECTNOTOWNED = 1166, + D3D12_MESSAGE_ID_CREATE_TRACKEDWORKLOAD = 1167, + D3D12_MESSAGE_ID_LIVE_TRACKEDWORKLOAD = 1168, + D3D12_MESSAGE_ID_DESTROY_TRACKEDWORKLOAD = 1169, + D3D12_MESSAGE_ID_RENDER_PASS_ERROR = 1170, + D3D12_MESSAGE_ID_META_COMMAND_ID_INVALID = 1171, + D3D12_MESSAGE_ID_META_COMMAND_UNSUPPORTED_PARAMS = 1172, + D3D12_MESSAGE_ID_META_COMMAND_FAILED_ENUMERATION = 1173, + D3D12_MESSAGE_ID_META_COMMAND_PARAMETER_SIZE_MISMATCH = 1174, + D3D12_MESSAGE_ID_UNINITIALIZED_META_COMMAND = 1175, + D3D12_MESSAGE_ID_META_COMMAND_INVALID_GPU_VIRTUAL_ADDRESS = 1176, + D3D12_MESSAGE_ID_CREATE_VIDEOENCODECOMMANDLIST = 1177, + D3D12_MESSAGE_ID_LIVE_VIDEOENCODECOMMANDLIST = 1178, + D3D12_MESSAGE_ID_DESTROY_VIDEOENCODECOMMANDLIST = 1179, + D3D12_MESSAGE_ID_CREATE_VIDEOENCODECOMMANDQUEUE = 1180, + D3D12_MESSAGE_ID_LIVE_VIDEOENCODECOMMANDQUEUE = 1181, + D3D12_MESSAGE_ID_DESTROY_VIDEOENCODECOMMANDQUEUE = 1182, + D3D12_MESSAGE_ID_CREATE_VIDEOMOTIONESTIMATOR = 1183, + D3D12_MESSAGE_ID_LIVE_VIDEOMOTIONESTIMATOR = 1184, + D3D12_MESSAGE_ID_DESTROY_VIDEOMOTIONESTIMATOR = 1185, + D3D12_MESSAGE_ID_CREATE_VIDEOMOTIONVECTORHEAP = 1186, + D3D12_MESSAGE_ID_LIVE_VIDEOMOTIONVECTORHEAP = 1187, + D3D12_MESSAGE_ID_DESTROY_VIDEOMOTIONVECTORHEAP = 1188, + D3D12_MESSAGE_ID_MULTIPLE_TRACKED_WORKLOADS = 1189, + D3D12_MESSAGE_ID_MULTIPLE_TRACKED_WORKLOAD_PAIRS = 1190, + D3D12_MESSAGE_ID_OUT_OF_ORDER_TRACKED_WORKLOAD_PAIR = 1191, + D3D12_MESSAGE_ID_CANNOT_ADD_TRACKED_WORKLOAD = 1192, + D3D12_MESSAGE_ID_INCOMPLETE_TRACKED_WORKLOAD_PAIR = 1193, + D3D12_MESSAGE_ID_CREATE_STATE_OBJECT_ERROR = 1194, + D3D12_MESSAGE_ID_GET_SHADER_IDENTIFIER_ERROR = 1195, + D3D12_MESSAGE_ID_GET_SHADER_STACK_SIZE_ERROR = 1196, + D3D12_MESSAGE_ID_GET_PIPELINE_STACK_SIZE_ERROR = 1197, + D3D12_MESSAGE_ID_SET_PIPELINE_STACK_SIZE_ERROR = 1198, + D3D12_MESSAGE_ID_GET_SHADER_IDENTIFIER_SIZE_INVALID = 1199, + D3D12_MESSAGE_ID_CHECK_DRIVER_MATCHING_IDENTIFIER_INVALID = 1200, + D3D12_MESSAGE_ID_CHECK_DRIVER_MATCHING_IDENTIFIER_DRIVER_REPORTED_ISSUE = 1201, + D3D12_MESSAGE_ID_RENDER_PASS_INVALID_RESOURCE_BARRIER = 1202, + D3D12_MESSAGE_ID_RENDER_PASS_DISALLOWED_API_CALLED = 1203, + D3D12_MESSAGE_ID_RENDER_PASS_CANNOT_NEST_RENDER_PASSES = 1204, + D3D12_MESSAGE_ID_RENDER_PASS_CANNOT_END_WITHOUT_BEGIN = 1205, + D3D12_MESSAGE_ID_RENDER_PASS_CANNOT_CLOSE_COMMAND_LIST = 1206, + D3D12_MESSAGE_ID_RENDER_PASS_GPU_WORK_WHILE_SUSPENDED = 1207, + D3D12_MESSAGE_ID_RENDER_PASS_MISMATCHING_SUSPEND_RESUME = 1208, + D3D12_MESSAGE_ID_RENDER_PASS_NO_PRIOR_SUSPEND_WITHIN_EXECUTECOMMANDLISTS = 1209, + D3D12_MESSAGE_ID_RENDER_PASS_NO_SUBSEQUENT_RESUME_WITHIN_EXECUTECOMMANDLISTS = 1210, + D3D12_MESSAGE_ID_TRACKED_WORKLOAD_COMMAND_QUEUE_MISMATCH = 1211, + D3D12_MESSAGE_ID_TRACKED_WORKLOAD_NOT_SUPPORTED = 1212, + D3D12_MESSAGE_ID_RENDER_PASS_MISMATCHING_NO_ACCESS = 1213, + D3D12_MESSAGE_ID_RENDER_PASS_UNSUPPORTED_RESOLVE = 1214, + D3D12_MESSAGE_ID_CLEARUNORDEREDACCESSVIEW_INVALID_RESOURCE_PTR = 1215, + D3D12_MESSAGE_ID_WINDOWS7_FENCE_OUTOFORDER_SIGNAL = 1216, + D3D12_MESSAGE_ID_WINDOWS7_FENCE_OUTOFORDER_WAIT = 1217, + D3D12_MESSAGE_ID_VIDEO_CREATE_MOTION_ESTIMATOR_INVALID_ARGUMENT = 1218, + D3D12_MESSAGE_ID_VIDEO_CREATE_MOTION_VECTOR_HEAP_INVALID_ARGUMENT = 1219, + D3D12_MESSAGE_ID_ESTIMATE_MOTION_INVALID_ARGUMENT = 1220, + D3D12_MESSAGE_ID_RESOLVE_MOTION_VECTOR_HEAP_INVALID_ARGUMENT = 1221, + D3D12_MESSAGE_ID_GETGPUVIRTUALADDRESS_INVALID_HEAP_TYPE = 1222, + D3D12_MESSAGE_ID_SET_BACKGROUND_PROCESSING_MODE_INVALID_ARGUMENT = 1223, + D3D12_MESSAGE_ID_CREATE_COMMAND_LIST_INVALID_COMMAND_LIST_TYPE_FOR_FEATURE_LEVEL = 1224, + D3D12_MESSAGE_ID_CREATE_VIDEOEXTENSIONCOMMAND = 1225, + D3D12_MESSAGE_ID_LIVE_VIDEOEXTENSIONCOMMAND = 1226, + D3D12_MESSAGE_ID_DESTROY_VIDEOEXTENSIONCOMMAND = 1227, + D3D12_MESSAGE_ID_INVALID_VIDEO_EXTENSION_COMMAND_ID = 1228, + D3D12_MESSAGE_ID_VIDEO_EXTENSION_COMMAND_INVALID_ARGUMENT = 1229, + D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_NOT_UNIQUE_IN_DXIL_LIBRARY = 1230, + D3D12_MESSAGE_ID_VARIABLE_SHADING_RATE_NOT_ALLOWED_WITH_TIR = 1231, + D3D12_MESSAGE_ID_GEOMETRY_SHADER_OUTPUTTING_BOTH_VIEWPORT_ARRAY_INDEX_AND_SHADING_RATE_NOT_SUPPORTED_ON_DEVICE = 1232, + D3D12_MESSAGE_ID_RSSETSHADING_RATE_INVALID_SHADING_RATE = 1233, + D3D12_MESSAGE_ID_RSSETSHADING_RATE_SHADING_RATE_NOT_PERMITTED_BY_CAP = 1234, + D3D12_MESSAGE_ID_RSSETSHADING_RATE_INVALID_COMBINER = 1235, + D3D12_MESSAGE_ID_RSSETSHADINGRATEIMAGE_REQUIRES_TIER_2 = 1236, + D3D12_MESSAGE_ID_RSSETSHADINGRATE_REQUIRES_TIER_1 = 1237, + D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_FORMAT = 1238, + D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_ARRAY_SIZE = 1239, + D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_MIP_LEVEL = 1240, + D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_SAMPLE_COUNT = 1241, + D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_SAMPLE_QUALITY = 1242, + D3D12_MESSAGE_ID_NON_RETAIL_SHADER_MODEL_WONT_VALIDATE = 1243, + D3D12_MESSAGE_ID_D3D12_MESSAGES_END = ( D3D12_MESSAGE_ID_NON_RETAIL_SHADER_MODEL_WONT_VALIDATE + 1 ) + } D3D12_MESSAGE_ID; + +static_assert(D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_UNSUPPORTED == 1000, "Publicly released SDK D3D12_MESSAGE_ID enum values must not be changed. New enum values must be added to the end of the list."); +static_assert(D3D12_MESSAGE_ID_COPY_INVALIDLAYOUT == 1067, "Publicly released SDK D3D12_MESSAGE_ID enum values must not be changed. New enum values must be added to the end of the list."); +typedef struct D3D12_MESSAGE + { + D3D12_MESSAGE_CATEGORY Category; + D3D12_MESSAGE_SEVERITY Severity; + D3D12_MESSAGE_ID ID; + _Field_size_(DescriptionByteLength) const char *pDescription; + SIZE_T DescriptionByteLength; + } D3D12_MESSAGE; + +typedef struct D3D12_INFO_QUEUE_FILTER_DESC + { + UINT NumCategories; + _Field_size_(NumCategories) D3D12_MESSAGE_CATEGORY *pCategoryList; + UINT NumSeverities; + _Field_size_(NumSeverities) D3D12_MESSAGE_SEVERITY *pSeverityList; + UINT NumIDs; + _Field_size_(NumIDs) D3D12_MESSAGE_ID *pIDList; + } D3D12_INFO_QUEUE_FILTER_DESC; + +typedef struct D3D12_INFO_QUEUE_FILTER + { + D3D12_INFO_QUEUE_FILTER_DESC AllowList; + D3D12_INFO_QUEUE_FILTER_DESC DenyList; + } D3D12_INFO_QUEUE_FILTER; + +#define D3D12_INFO_QUEUE_DEFAULT_MESSAGE_COUNT_LIMIT 1024 + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0012_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0012_v0_0_s_ifspec; + +#ifndef __ID3D12InfoQueue_INTERFACE_DEFINED__ +#define __ID3D12InfoQueue_INTERFACE_DEFINED__ + +/* interface ID3D12InfoQueue */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12InfoQueue; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("0742a90b-c387-483f-b946-30a7e4e61458") + ID3D12InfoQueue : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetMessageCountLimit( + _In_ UINT64 MessageCountLimit) = 0; + + virtual void STDMETHODCALLTYPE ClearStoredMessages( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMessage( + _In_ UINT64 MessageIndex, + _Out_writes_bytes_opt_(*pMessageByteLength) D3D12_MESSAGE *pMessage, + _Inout_ SIZE_T *pMessageByteLength) = 0; + + virtual UINT64 STDMETHODCALLTYPE GetNumMessagesAllowedByStorageFilter( void) = 0; + + virtual UINT64 STDMETHODCALLTYPE GetNumMessagesDeniedByStorageFilter( void) = 0; + + virtual UINT64 STDMETHODCALLTYPE GetNumStoredMessages( void) = 0; + + virtual UINT64 STDMETHODCALLTYPE GetNumStoredMessagesAllowedByRetrievalFilter( void) = 0; + + virtual UINT64 STDMETHODCALLTYPE GetNumMessagesDiscardedByMessageCountLimit( void) = 0; + + virtual UINT64 STDMETHODCALLTYPE GetMessageCountLimit( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddStorageFilterEntries( + _In_ D3D12_INFO_QUEUE_FILTER *pFilter) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStorageFilter( + _Out_writes_bytes_opt_(*pFilterByteLength) D3D12_INFO_QUEUE_FILTER *pFilter, + _Inout_ SIZE_T *pFilterByteLength) = 0; + + virtual void STDMETHODCALLTYPE ClearStorageFilter( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE PushEmptyStorageFilter( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE PushCopyOfStorageFilter( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE PushStorageFilter( + _In_ D3D12_INFO_QUEUE_FILTER *pFilter) = 0; + + virtual void STDMETHODCALLTYPE PopStorageFilter( void) = 0; + + virtual UINT STDMETHODCALLTYPE GetStorageFilterStackSize( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddRetrievalFilterEntries( + _In_ D3D12_INFO_QUEUE_FILTER *pFilter) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetRetrievalFilter( + _Out_writes_bytes_opt_(*pFilterByteLength) D3D12_INFO_QUEUE_FILTER *pFilter, + _Inout_ SIZE_T *pFilterByteLength) = 0; + + virtual void STDMETHODCALLTYPE ClearRetrievalFilter( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE PushEmptyRetrievalFilter( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE PushCopyOfRetrievalFilter( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE PushRetrievalFilter( + _In_ D3D12_INFO_QUEUE_FILTER *pFilter) = 0; + + virtual void STDMETHODCALLTYPE PopRetrievalFilter( void) = 0; + + virtual UINT STDMETHODCALLTYPE GetRetrievalFilterStackSize( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddMessage( + _In_ D3D12_MESSAGE_CATEGORY Category, + _In_ D3D12_MESSAGE_SEVERITY Severity, + _In_ D3D12_MESSAGE_ID ID, + _In_ LPCSTR pDescription) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddApplicationMessage( + _In_ D3D12_MESSAGE_SEVERITY Severity, + _In_ LPCSTR pDescription) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetBreakOnCategory( + _In_ D3D12_MESSAGE_CATEGORY Category, + _In_ BOOL bEnable) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetBreakOnSeverity( + _In_ D3D12_MESSAGE_SEVERITY Severity, + _In_ BOOL bEnable) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetBreakOnID( + _In_ D3D12_MESSAGE_ID ID, + _In_ BOOL bEnable) = 0; + + virtual BOOL STDMETHODCALLTYPE GetBreakOnCategory( + _In_ D3D12_MESSAGE_CATEGORY Category) = 0; + + virtual BOOL STDMETHODCALLTYPE GetBreakOnSeverity( + _In_ D3D12_MESSAGE_SEVERITY Severity) = 0; + + virtual BOOL STDMETHODCALLTYPE GetBreakOnID( + _In_ D3D12_MESSAGE_ID ID) = 0; + + virtual void STDMETHODCALLTYPE SetMuteDebugOutput( + _In_ BOOL bMute) = 0; + + virtual BOOL STDMETHODCALLTYPE GetMuteDebugOutput( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12InfoQueueVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12InfoQueue * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12InfoQueue * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12InfoQueue * This); + + HRESULT ( STDMETHODCALLTYPE *SetMessageCountLimit )( + ID3D12InfoQueue * This, + _In_ UINT64 MessageCountLimit); + + void ( STDMETHODCALLTYPE *ClearStoredMessages )( + ID3D12InfoQueue * This); + + HRESULT ( STDMETHODCALLTYPE *GetMessage )( + ID3D12InfoQueue * This, + _In_ UINT64 MessageIndex, + _Out_writes_bytes_opt_(*pMessageByteLength) D3D12_MESSAGE *pMessage, + _Inout_ SIZE_T *pMessageByteLength); + + UINT64 ( STDMETHODCALLTYPE *GetNumMessagesAllowedByStorageFilter )( + ID3D12InfoQueue * This); + + UINT64 ( STDMETHODCALLTYPE *GetNumMessagesDeniedByStorageFilter )( + ID3D12InfoQueue * This); + + UINT64 ( STDMETHODCALLTYPE *GetNumStoredMessages )( + ID3D12InfoQueue * This); + + UINT64 ( STDMETHODCALLTYPE *GetNumStoredMessagesAllowedByRetrievalFilter )( + ID3D12InfoQueue * This); + + UINT64 ( STDMETHODCALLTYPE *GetNumMessagesDiscardedByMessageCountLimit )( + ID3D12InfoQueue * This); + + UINT64 ( STDMETHODCALLTYPE *GetMessageCountLimit )( + ID3D12InfoQueue * This); + + HRESULT ( STDMETHODCALLTYPE *AddStorageFilterEntries )( + ID3D12InfoQueue * This, + _In_ D3D12_INFO_QUEUE_FILTER *pFilter); + + HRESULT ( STDMETHODCALLTYPE *GetStorageFilter )( + ID3D12InfoQueue * This, + _Out_writes_bytes_opt_(*pFilterByteLength) D3D12_INFO_QUEUE_FILTER *pFilter, + _Inout_ SIZE_T *pFilterByteLength); + + void ( STDMETHODCALLTYPE *ClearStorageFilter )( + ID3D12InfoQueue * This); + + HRESULT ( STDMETHODCALLTYPE *PushEmptyStorageFilter )( + ID3D12InfoQueue * This); + + HRESULT ( STDMETHODCALLTYPE *PushCopyOfStorageFilter )( + ID3D12InfoQueue * This); + + HRESULT ( STDMETHODCALLTYPE *PushStorageFilter )( + ID3D12InfoQueue * This, + _In_ D3D12_INFO_QUEUE_FILTER *pFilter); + + void ( STDMETHODCALLTYPE *PopStorageFilter )( + ID3D12InfoQueue * This); + + UINT ( STDMETHODCALLTYPE *GetStorageFilterStackSize )( + ID3D12InfoQueue * This); + + HRESULT ( STDMETHODCALLTYPE *AddRetrievalFilterEntries )( + ID3D12InfoQueue * This, + _In_ D3D12_INFO_QUEUE_FILTER *pFilter); + + HRESULT ( STDMETHODCALLTYPE *GetRetrievalFilter )( + ID3D12InfoQueue * This, + _Out_writes_bytes_opt_(*pFilterByteLength) D3D12_INFO_QUEUE_FILTER *pFilter, + _Inout_ SIZE_T *pFilterByteLength); + + void ( STDMETHODCALLTYPE *ClearRetrievalFilter )( + ID3D12InfoQueue * This); + + HRESULT ( STDMETHODCALLTYPE *PushEmptyRetrievalFilter )( + ID3D12InfoQueue * This); + + HRESULT ( STDMETHODCALLTYPE *PushCopyOfRetrievalFilter )( + ID3D12InfoQueue * This); + + HRESULT ( STDMETHODCALLTYPE *PushRetrievalFilter )( + ID3D12InfoQueue * This, + _In_ D3D12_INFO_QUEUE_FILTER *pFilter); + + void ( STDMETHODCALLTYPE *PopRetrievalFilter )( + ID3D12InfoQueue * This); + + UINT ( STDMETHODCALLTYPE *GetRetrievalFilterStackSize )( + ID3D12InfoQueue * This); + + HRESULT ( STDMETHODCALLTYPE *AddMessage )( + ID3D12InfoQueue * This, + _In_ D3D12_MESSAGE_CATEGORY Category, + _In_ D3D12_MESSAGE_SEVERITY Severity, + _In_ D3D12_MESSAGE_ID ID, + _In_ LPCSTR pDescription); + + HRESULT ( STDMETHODCALLTYPE *AddApplicationMessage )( + ID3D12InfoQueue * This, + _In_ D3D12_MESSAGE_SEVERITY Severity, + _In_ LPCSTR pDescription); + + HRESULT ( STDMETHODCALLTYPE *SetBreakOnCategory )( + ID3D12InfoQueue * This, + _In_ D3D12_MESSAGE_CATEGORY Category, + _In_ BOOL bEnable); + + HRESULT ( STDMETHODCALLTYPE *SetBreakOnSeverity )( + ID3D12InfoQueue * This, + _In_ D3D12_MESSAGE_SEVERITY Severity, + _In_ BOOL bEnable); + + HRESULT ( STDMETHODCALLTYPE *SetBreakOnID )( + ID3D12InfoQueue * This, + _In_ D3D12_MESSAGE_ID ID, + _In_ BOOL bEnable); + + BOOL ( STDMETHODCALLTYPE *GetBreakOnCategory )( + ID3D12InfoQueue * This, + _In_ D3D12_MESSAGE_CATEGORY Category); + + BOOL ( STDMETHODCALLTYPE *GetBreakOnSeverity )( + ID3D12InfoQueue * This, + _In_ D3D12_MESSAGE_SEVERITY Severity); + + BOOL ( STDMETHODCALLTYPE *GetBreakOnID )( + ID3D12InfoQueue * This, + _In_ D3D12_MESSAGE_ID ID); + + void ( STDMETHODCALLTYPE *SetMuteDebugOutput )( + ID3D12InfoQueue * This, + _In_ BOOL bMute); + + BOOL ( STDMETHODCALLTYPE *GetMuteDebugOutput )( + ID3D12InfoQueue * This); + + END_INTERFACE + } ID3D12InfoQueueVtbl; + + interface ID3D12InfoQueue + { + CONST_VTBL struct ID3D12InfoQueueVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12InfoQueue_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12InfoQueue_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12InfoQueue_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12InfoQueue_SetMessageCountLimit(This,MessageCountLimit) \ + ( (This)->lpVtbl -> SetMessageCountLimit(This,MessageCountLimit) ) + +#define ID3D12InfoQueue_ClearStoredMessages(This) \ + ( (This)->lpVtbl -> ClearStoredMessages(This) ) + +#define ID3D12InfoQueue_GetMessage(This,MessageIndex,pMessage,pMessageByteLength) \ + ( (This)->lpVtbl -> GetMessage(This,MessageIndex,pMessage,pMessageByteLength) ) + +#define ID3D12InfoQueue_GetNumMessagesAllowedByStorageFilter(This) \ + ( (This)->lpVtbl -> GetNumMessagesAllowedByStorageFilter(This) ) + +#define ID3D12InfoQueue_GetNumMessagesDeniedByStorageFilter(This) \ + ( (This)->lpVtbl -> GetNumMessagesDeniedByStorageFilter(This) ) + +#define ID3D12InfoQueue_GetNumStoredMessages(This) \ + ( (This)->lpVtbl -> GetNumStoredMessages(This) ) + +#define ID3D12InfoQueue_GetNumStoredMessagesAllowedByRetrievalFilter(This) \ + ( (This)->lpVtbl -> GetNumStoredMessagesAllowedByRetrievalFilter(This) ) + +#define ID3D12InfoQueue_GetNumMessagesDiscardedByMessageCountLimit(This) \ + ( (This)->lpVtbl -> GetNumMessagesDiscardedByMessageCountLimit(This) ) + +#define ID3D12InfoQueue_GetMessageCountLimit(This) \ + ( (This)->lpVtbl -> GetMessageCountLimit(This) ) + +#define ID3D12InfoQueue_AddStorageFilterEntries(This,pFilter) \ + ( (This)->lpVtbl -> AddStorageFilterEntries(This,pFilter) ) + +#define ID3D12InfoQueue_GetStorageFilter(This,pFilter,pFilterByteLength) \ + ( (This)->lpVtbl -> GetStorageFilter(This,pFilter,pFilterByteLength) ) + +#define ID3D12InfoQueue_ClearStorageFilter(This) \ + ( (This)->lpVtbl -> ClearStorageFilter(This) ) + +#define ID3D12InfoQueue_PushEmptyStorageFilter(This) \ + ( (This)->lpVtbl -> PushEmptyStorageFilter(This) ) + +#define ID3D12InfoQueue_PushCopyOfStorageFilter(This) \ + ( (This)->lpVtbl -> PushCopyOfStorageFilter(This) ) + +#define ID3D12InfoQueue_PushStorageFilter(This,pFilter) \ + ( (This)->lpVtbl -> PushStorageFilter(This,pFilter) ) + +#define ID3D12InfoQueue_PopStorageFilter(This) \ + ( (This)->lpVtbl -> PopStorageFilter(This) ) + +#define ID3D12InfoQueue_GetStorageFilterStackSize(This) \ + ( (This)->lpVtbl -> GetStorageFilterStackSize(This) ) + +#define ID3D12InfoQueue_AddRetrievalFilterEntries(This,pFilter) \ + ( (This)->lpVtbl -> AddRetrievalFilterEntries(This,pFilter) ) + +#define ID3D12InfoQueue_GetRetrievalFilter(This,pFilter,pFilterByteLength) \ + ( (This)->lpVtbl -> GetRetrievalFilter(This,pFilter,pFilterByteLength) ) + +#define ID3D12InfoQueue_ClearRetrievalFilter(This) \ + ( (This)->lpVtbl -> ClearRetrievalFilter(This) ) + +#define ID3D12InfoQueue_PushEmptyRetrievalFilter(This) \ + ( (This)->lpVtbl -> PushEmptyRetrievalFilter(This) ) + +#define ID3D12InfoQueue_PushCopyOfRetrievalFilter(This) \ + ( (This)->lpVtbl -> PushCopyOfRetrievalFilter(This) ) + +#define ID3D12InfoQueue_PushRetrievalFilter(This,pFilter) \ + ( (This)->lpVtbl -> PushRetrievalFilter(This,pFilter) ) + +#define ID3D12InfoQueue_PopRetrievalFilter(This) \ + ( (This)->lpVtbl -> PopRetrievalFilter(This) ) + +#define ID3D12InfoQueue_GetRetrievalFilterStackSize(This) \ + ( (This)->lpVtbl -> GetRetrievalFilterStackSize(This) ) + +#define ID3D12InfoQueue_AddMessage(This,Category,Severity,ID,pDescription) \ + ( (This)->lpVtbl -> AddMessage(This,Category,Severity,ID,pDescription) ) + +#define ID3D12InfoQueue_AddApplicationMessage(This,Severity,pDescription) \ + ( (This)->lpVtbl -> AddApplicationMessage(This,Severity,pDescription) ) + +#define ID3D12InfoQueue_SetBreakOnCategory(This,Category,bEnable) \ + ( (This)->lpVtbl -> SetBreakOnCategory(This,Category,bEnable) ) + +#define ID3D12InfoQueue_SetBreakOnSeverity(This,Severity,bEnable) \ + ( (This)->lpVtbl -> SetBreakOnSeverity(This,Severity,bEnable) ) + +#define ID3D12InfoQueue_SetBreakOnID(This,ID,bEnable) \ + ( (This)->lpVtbl -> SetBreakOnID(This,ID,bEnable) ) + +#define ID3D12InfoQueue_GetBreakOnCategory(This,Category) \ + ( (This)->lpVtbl -> GetBreakOnCategory(This,Category) ) + +#define ID3D12InfoQueue_GetBreakOnSeverity(This,Severity) \ + ( (This)->lpVtbl -> GetBreakOnSeverity(This,Severity) ) + +#define ID3D12InfoQueue_GetBreakOnID(This,ID) \ + ( (This)->lpVtbl -> GetBreakOnID(This,ID) ) + +#define ID3D12InfoQueue_SetMuteDebugOutput(This,bMute) \ + ( (This)->lpVtbl -> SetMuteDebugOutput(This,bMute) ) + +#define ID3D12InfoQueue_GetMuteDebugOutput(This) \ + ( (This)->lpVtbl -> GetMuteDebugOutput(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12InfoQueue_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12sdklayers_0000_0013 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */ +#pragma endregion +DEFINE_GUID(IID_ID3D12Debug,0x344488b7,0x6846,0x474b,0xb9,0x89,0xf0,0x27,0x44,0x82,0x45,0xe0); +DEFINE_GUID(IID_ID3D12Debug1,0xaffaa4ca,0x63fe,0x4d8e,0xb8,0xad,0x15,0x90,0x00,0xaf,0x43,0x04); +DEFINE_GUID(IID_ID3D12Debug2,0x93a665c4,0xa3b2,0x4e5d,0xb6,0x92,0xa2,0x6a,0xe1,0x4e,0x33,0x74); +DEFINE_GUID(IID_ID3D12Debug3,0x5cf4e58f,0xf671,0x4ff1,0xa5,0x42,0x36,0x86,0xe3,0xd1,0x53,0xd1); +DEFINE_GUID(IID_ID3D12DebugDevice1,0xa9b71770,0xd099,0x4a65,0xa6,0x98,0x3d,0xee,0x10,0x02,0x0f,0x88); +DEFINE_GUID(IID_ID3D12DebugDevice,0x3febd6dd,0x4973,0x4787,0x81,0x94,0xe4,0x5f,0x9e,0x28,0x92,0x3e); +DEFINE_GUID(IID_ID3D12DebugDevice2,0x60eccbc1,0x378d,0x4df1,0x89,0x4c,0xf8,0xac,0x5c,0xe4,0xd7,0xdd); +DEFINE_GUID(IID_ID3D12DebugCommandQueue,0x09e0bf36,0x54ac,0x484f,0x88,0x47,0x4b,0xae,0xea,0xb6,0x05,0x3a); +DEFINE_GUID(IID_ID3D12DebugCommandList1,0x102ca951,0x311b,0x4b01,0xb1,0x1f,0xec,0xb8,0x3e,0x06,0x1b,0x37); +DEFINE_GUID(IID_ID3D12DebugCommandList,0x09e0bf36,0x54ac,0x484f,0x88,0x47,0x4b,0xae,0xea,0xb6,0x05,0x3f); +DEFINE_GUID(IID_ID3D12DebugCommandList2,0xaeb575cf,0x4e06,0x48be,0xba,0x3b,0xc4,0x50,0xfc,0x96,0x65,0x2e); +DEFINE_GUID(IID_ID3D12SharingContract,0x0adf7d52,0x929c,0x4e61,0xad,0xdb,0xff,0xed,0x30,0xde,0x66,0xef); +DEFINE_GUID(IID_ID3D12InfoQueue,0x0742a90b,0xc387,0x483f,0xb9,0x46,0x30,0xa7,0xe4,0xe6,0x14,0x58); + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0013_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0013_v0_0_s_ifspec; + +/* Additional Prototypes for ALL interfaces */ + +/* end of Additional Prototypes */ + +#ifdef __cplusplus +} +#endif + +#endif + + diff --git a/src/decomp/pc/gfx/dxsdk/d3dcommon.h b/src/decomp/pc/gfx/dxsdk/d3dcommon.h new file mode 100644 index 0000000..2db8805 --- /dev/null +++ b/src/decomp/pc/gfx/dxsdk/d3dcommon.h @@ -0,0 +1,1009 @@ + + +/* this ALWAYS GENERATED file contains the definitions for the interfaces */ + + + /* File created by MIDL compiler version 8.01.0622 */ +/* @@MIDL_FILE_HEADING( ) */ + + + +/* verify that the version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCNDR_H_VERSION__ +#define __REQUIRED_RPCNDR_H_VERSION__ 500 +#endif + +/* verify that the version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCSAL_H_VERSION__ +#define __REQUIRED_RPCSAL_H_VERSION__ 100 +#endif + +#include "rpc.h" +#include "rpcndr.h" + +#ifndef __RPCNDR_H_VERSION__ +#error this stub requires an updated version of +#endif /* __RPCNDR_H_VERSION__ */ + +#ifndef COM_NO_WINDOWS_H +#include "windows.h" +#include "ole2.h" +#endif /*COM_NO_WINDOWS_H*/ + +#ifndef __d3dcommon_h__ +#define __d3dcommon_h__ + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#pragma once +#endif + +/* Forward Declarations */ + +#ifndef __ID3D10Blob_FWD_DEFINED__ +#define __ID3D10Blob_FWD_DEFINED__ +typedef interface ID3D10Blob ID3D10Blob; + +#endif /* __ID3D10Blob_FWD_DEFINED__ */ + + +#ifndef __ID3DDestructionNotifier_FWD_DEFINED__ +#define __ID3DDestructionNotifier_FWD_DEFINED__ +typedef interface ID3DDestructionNotifier ID3DDestructionNotifier; + +#endif /* __ID3DDestructionNotifier_FWD_DEFINED__ */ + + +/* header files for imported files */ +#include "oaidl.h" +#include "ocidl.h" + +#ifdef __cplusplus +extern "C"{ +#endif + + +/* interface __MIDL_itf_d3dcommon_0000_0000 */ +/* [local] */ + +typedef +enum D3D_DRIVER_TYPE + { + D3D_DRIVER_TYPE_UNKNOWN = 0, + D3D_DRIVER_TYPE_HARDWARE = ( D3D_DRIVER_TYPE_UNKNOWN + 1 ) , + D3D_DRIVER_TYPE_REFERENCE = ( D3D_DRIVER_TYPE_HARDWARE + 1 ) , + D3D_DRIVER_TYPE_NULL = ( D3D_DRIVER_TYPE_REFERENCE + 1 ) , + D3D_DRIVER_TYPE_SOFTWARE = ( D3D_DRIVER_TYPE_NULL + 1 ) , + D3D_DRIVER_TYPE_WARP = ( D3D_DRIVER_TYPE_SOFTWARE + 1 ) + } D3D_DRIVER_TYPE; + +typedef +enum D3D_FEATURE_LEVEL + { + D3D_FEATURE_LEVEL_1_0_CORE = 0x1000, + D3D_FEATURE_LEVEL_9_1 = 0x9100, + D3D_FEATURE_LEVEL_9_2 = 0x9200, + D3D_FEATURE_LEVEL_9_3 = 0x9300, + D3D_FEATURE_LEVEL_10_0 = 0xa000, + D3D_FEATURE_LEVEL_10_1 = 0xa100, + D3D_FEATURE_LEVEL_11_0 = 0xb000, + D3D_FEATURE_LEVEL_11_1 = 0xb100, + D3D_FEATURE_LEVEL_12_0 = 0xc000, + D3D_FEATURE_LEVEL_12_1 = 0xc100 + } D3D_FEATURE_LEVEL; + +#define D3D_FL9_1_REQ_TEXTURE1D_U_DIMENSION 2048 +#define D3D_FL9_3_REQ_TEXTURE1D_U_DIMENSION 4096 +#define D3D_FL9_1_REQ_TEXTURE2D_U_OR_V_DIMENSION 2048 +#define D3D_FL9_3_REQ_TEXTURE2D_U_OR_V_DIMENSION 4096 +#define D3D_FL9_1_REQ_TEXTURECUBE_DIMENSION 512 +#define D3D_FL9_3_REQ_TEXTURECUBE_DIMENSION 4096 +#define D3D_FL9_1_REQ_TEXTURE3D_U_V_OR_W_DIMENSION 256 +#define D3D_FL9_1_DEFAULT_MAX_ANISOTROPY 2 +#define D3D_FL9_1_IA_PRIMITIVE_MAX_COUNT 65535 +#define D3D_FL9_2_IA_PRIMITIVE_MAX_COUNT 1048575 +#define D3D_FL9_1_SIMULTANEOUS_RENDER_TARGET_COUNT 1 +#define D3D_FL9_3_SIMULTANEOUS_RENDER_TARGET_COUNT 4 +#define D3D_FL9_1_MAX_TEXTURE_REPEAT 128 +#define D3D_FL9_2_MAX_TEXTURE_REPEAT 2048 +#define D3D_FL9_3_MAX_TEXTURE_REPEAT 8192 +typedef +enum D3D_PRIMITIVE_TOPOLOGY + { + D3D_PRIMITIVE_TOPOLOGY_UNDEFINED = 0, + D3D_PRIMITIVE_TOPOLOGY_POINTLIST = 1, + D3D_PRIMITIVE_TOPOLOGY_LINELIST = 2, + D3D_PRIMITIVE_TOPOLOGY_LINESTRIP = 3, + D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST = 4, + D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP = 5, + D3D_PRIMITIVE_TOPOLOGY_LINELIST_ADJ = 10, + D3D_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ = 11, + D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ = 12, + D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ = 13, + D3D_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST = 33, + D3D_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST = 34, + D3D_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST = 35, + D3D_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST = 36, + D3D_PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST = 37, + D3D_PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST = 38, + D3D_PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST = 39, + D3D_PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST = 40, + D3D_PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST = 41, + D3D_PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST = 42, + D3D_PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST = 43, + D3D_PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST = 44, + D3D_PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST = 45, + D3D_PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST = 46, + D3D_PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST = 47, + D3D_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST = 48, + D3D_PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST = 49, + D3D_PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST = 50, + D3D_PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST = 51, + D3D_PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST = 52, + D3D_PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST = 53, + D3D_PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST = 54, + D3D_PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST = 55, + D3D_PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST = 56, + D3D_PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST = 57, + D3D_PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST = 58, + D3D_PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST = 59, + D3D_PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST = 60, + D3D_PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST = 61, + D3D_PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST = 62, + D3D_PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST = 63, + D3D_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST = 64, + D3D10_PRIMITIVE_TOPOLOGY_UNDEFINED = D3D_PRIMITIVE_TOPOLOGY_UNDEFINED, + D3D10_PRIMITIVE_TOPOLOGY_POINTLIST = D3D_PRIMITIVE_TOPOLOGY_POINTLIST, + D3D10_PRIMITIVE_TOPOLOGY_LINELIST = D3D_PRIMITIVE_TOPOLOGY_LINELIST, + D3D10_PRIMITIVE_TOPOLOGY_LINESTRIP = D3D_PRIMITIVE_TOPOLOGY_LINESTRIP, + D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST, + D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP = D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP, + D3D10_PRIMITIVE_TOPOLOGY_LINELIST_ADJ = D3D_PRIMITIVE_TOPOLOGY_LINELIST_ADJ, + D3D10_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ = D3D_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ, + D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ, + D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ = D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ, + D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED = D3D_PRIMITIVE_TOPOLOGY_UNDEFINED, + D3D11_PRIMITIVE_TOPOLOGY_POINTLIST = D3D_PRIMITIVE_TOPOLOGY_POINTLIST, + D3D11_PRIMITIVE_TOPOLOGY_LINELIST = D3D_PRIMITIVE_TOPOLOGY_LINELIST, + D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP = D3D_PRIMITIVE_TOPOLOGY_LINESTRIP, + D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST, + D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP = D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP, + D3D11_PRIMITIVE_TOPOLOGY_LINELIST_ADJ = D3D_PRIMITIVE_TOPOLOGY_LINELIST_ADJ, + D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ = D3D_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ, + D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ, + D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ = D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ, + D3D11_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST, + D3D11_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST + } D3D_PRIMITIVE_TOPOLOGY; + +typedef +enum D3D_PRIMITIVE + { + D3D_PRIMITIVE_UNDEFINED = 0, + D3D_PRIMITIVE_POINT = 1, + D3D_PRIMITIVE_LINE = 2, + D3D_PRIMITIVE_TRIANGLE = 3, + D3D_PRIMITIVE_LINE_ADJ = 6, + D3D_PRIMITIVE_TRIANGLE_ADJ = 7, + D3D_PRIMITIVE_1_CONTROL_POINT_PATCH = 8, + D3D_PRIMITIVE_2_CONTROL_POINT_PATCH = 9, + D3D_PRIMITIVE_3_CONTROL_POINT_PATCH = 10, + D3D_PRIMITIVE_4_CONTROL_POINT_PATCH = 11, + D3D_PRIMITIVE_5_CONTROL_POINT_PATCH = 12, + D3D_PRIMITIVE_6_CONTROL_POINT_PATCH = 13, + D3D_PRIMITIVE_7_CONTROL_POINT_PATCH = 14, + D3D_PRIMITIVE_8_CONTROL_POINT_PATCH = 15, + D3D_PRIMITIVE_9_CONTROL_POINT_PATCH = 16, + D3D_PRIMITIVE_10_CONTROL_POINT_PATCH = 17, + D3D_PRIMITIVE_11_CONTROL_POINT_PATCH = 18, + D3D_PRIMITIVE_12_CONTROL_POINT_PATCH = 19, + D3D_PRIMITIVE_13_CONTROL_POINT_PATCH = 20, + D3D_PRIMITIVE_14_CONTROL_POINT_PATCH = 21, + D3D_PRIMITIVE_15_CONTROL_POINT_PATCH = 22, + D3D_PRIMITIVE_16_CONTROL_POINT_PATCH = 23, + D3D_PRIMITIVE_17_CONTROL_POINT_PATCH = 24, + D3D_PRIMITIVE_18_CONTROL_POINT_PATCH = 25, + D3D_PRIMITIVE_19_CONTROL_POINT_PATCH = 26, + D3D_PRIMITIVE_20_CONTROL_POINT_PATCH = 27, + D3D_PRIMITIVE_21_CONTROL_POINT_PATCH = 28, + D3D_PRIMITIVE_22_CONTROL_POINT_PATCH = 29, + D3D_PRIMITIVE_23_CONTROL_POINT_PATCH = 30, + D3D_PRIMITIVE_24_CONTROL_POINT_PATCH = 31, + D3D_PRIMITIVE_25_CONTROL_POINT_PATCH = 32, + D3D_PRIMITIVE_26_CONTROL_POINT_PATCH = 33, + D3D_PRIMITIVE_27_CONTROL_POINT_PATCH = 34, + D3D_PRIMITIVE_28_CONTROL_POINT_PATCH = 35, + D3D_PRIMITIVE_29_CONTROL_POINT_PATCH = 36, + D3D_PRIMITIVE_30_CONTROL_POINT_PATCH = 37, + D3D_PRIMITIVE_31_CONTROL_POINT_PATCH = 38, + D3D_PRIMITIVE_32_CONTROL_POINT_PATCH = 39, + D3D10_PRIMITIVE_UNDEFINED = D3D_PRIMITIVE_UNDEFINED, + D3D10_PRIMITIVE_POINT = D3D_PRIMITIVE_POINT, + D3D10_PRIMITIVE_LINE = D3D_PRIMITIVE_LINE, + D3D10_PRIMITIVE_TRIANGLE = D3D_PRIMITIVE_TRIANGLE, + D3D10_PRIMITIVE_LINE_ADJ = D3D_PRIMITIVE_LINE_ADJ, + D3D10_PRIMITIVE_TRIANGLE_ADJ = D3D_PRIMITIVE_TRIANGLE_ADJ, + D3D11_PRIMITIVE_UNDEFINED = D3D_PRIMITIVE_UNDEFINED, + D3D11_PRIMITIVE_POINT = D3D_PRIMITIVE_POINT, + D3D11_PRIMITIVE_LINE = D3D_PRIMITIVE_LINE, + D3D11_PRIMITIVE_TRIANGLE = D3D_PRIMITIVE_TRIANGLE, + D3D11_PRIMITIVE_LINE_ADJ = D3D_PRIMITIVE_LINE_ADJ, + D3D11_PRIMITIVE_TRIANGLE_ADJ = D3D_PRIMITIVE_TRIANGLE_ADJ, + D3D11_PRIMITIVE_1_CONTROL_POINT_PATCH = D3D_PRIMITIVE_1_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_2_CONTROL_POINT_PATCH = D3D_PRIMITIVE_2_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_3_CONTROL_POINT_PATCH = D3D_PRIMITIVE_3_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_4_CONTROL_POINT_PATCH = D3D_PRIMITIVE_4_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_5_CONTROL_POINT_PATCH = D3D_PRIMITIVE_5_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_6_CONTROL_POINT_PATCH = D3D_PRIMITIVE_6_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_7_CONTROL_POINT_PATCH = D3D_PRIMITIVE_7_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_8_CONTROL_POINT_PATCH = D3D_PRIMITIVE_8_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_9_CONTROL_POINT_PATCH = D3D_PRIMITIVE_9_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_10_CONTROL_POINT_PATCH = D3D_PRIMITIVE_10_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_11_CONTROL_POINT_PATCH = D3D_PRIMITIVE_11_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_12_CONTROL_POINT_PATCH = D3D_PRIMITIVE_12_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_13_CONTROL_POINT_PATCH = D3D_PRIMITIVE_13_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_14_CONTROL_POINT_PATCH = D3D_PRIMITIVE_14_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_15_CONTROL_POINT_PATCH = D3D_PRIMITIVE_15_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_16_CONTROL_POINT_PATCH = D3D_PRIMITIVE_16_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_17_CONTROL_POINT_PATCH = D3D_PRIMITIVE_17_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_18_CONTROL_POINT_PATCH = D3D_PRIMITIVE_18_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_19_CONTROL_POINT_PATCH = D3D_PRIMITIVE_19_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_20_CONTROL_POINT_PATCH = D3D_PRIMITIVE_20_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_21_CONTROL_POINT_PATCH = D3D_PRIMITIVE_21_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_22_CONTROL_POINT_PATCH = D3D_PRIMITIVE_22_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_23_CONTROL_POINT_PATCH = D3D_PRIMITIVE_23_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_24_CONTROL_POINT_PATCH = D3D_PRIMITIVE_24_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_25_CONTROL_POINT_PATCH = D3D_PRIMITIVE_25_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_26_CONTROL_POINT_PATCH = D3D_PRIMITIVE_26_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_27_CONTROL_POINT_PATCH = D3D_PRIMITIVE_27_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_28_CONTROL_POINT_PATCH = D3D_PRIMITIVE_28_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_29_CONTROL_POINT_PATCH = D3D_PRIMITIVE_29_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_30_CONTROL_POINT_PATCH = D3D_PRIMITIVE_30_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_31_CONTROL_POINT_PATCH = D3D_PRIMITIVE_31_CONTROL_POINT_PATCH, + D3D11_PRIMITIVE_32_CONTROL_POINT_PATCH = D3D_PRIMITIVE_32_CONTROL_POINT_PATCH + } D3D_PRIMITIVE; + +typedef +enum D3D_SRV_DIMENSION + { + D3D_SRV_DIMENSION_UNKNOWN = 0, + D3D_SRV_DIMENSION_BUFFER = 1, + D3D_SRV_DIMENSION_TEXTURE1D = 2, + D3D_SRV_DIMENSION_TEXTURE1DARRAY = 3, + D3D_SRV_DIMENSION_TEXTURE2D = 4, + D3D_SRV_DIMENSION_TEXTURE2DARRAY = 5, + D3D_SRV_DIMENSION_TEXTURE2DMS = 6, + D3D_SRV_DIMENSION_TEXTURE2DMSARRAY = 7, + D3D_SRV_DIMENSION_TEXTURE3D = 8, + D3D_SRV_DIMENSION_TEXTURECUBE = 9, + D3D_SRV_DIMENSION_TEXTURECUBEARRAY = 10, + D3D_SRV_DIMENSION_BUFFEREX = 11, + D3D10_SRV_DIMENSION_UNKNOWN = D3D_SRV_DIMENSION_UNKNOWN, + D3D10_SRV_DIMENSION_BUFFER = D3D_SRV_DIMENSION_BUFFER, + D3D10_SRV_DIMENSION_TEXTURE1D = D3D_SRV_DIMENSION_TEXTURE1D, + D3D10_SRV_DIMENSION_TEXTURE1DARRAY = D3D_SRV_DIMENSION_TEXTURE1DARRAY, + D3D10_SRV_DIMENSION_TEXTURE2D = D3D_SRV_DIMENSION_TEXTURE2D, + D3D10_SRV_DIMENSION_TEXTURE2DARRAY = D3D_SRV_DIMENSION_TEXTURE2DARRAY, + D3D10_SRV_DIMENSION_TEXTURE2DMS = D3D_SRV_DIMENSION_TEXTURE2DMS, + D3D10_SRV_DIMENSION_TEXTURE2DMSARRAY = D3D_SRV_DIMENSION_TEXTURE2DMSARRAY, + D3D10_SRV_DIMENSION_TEXTURE3D = D3D_SRV_DIMENSION_TEXTURE3D, + D3D10_SRV_DIMENSION_TEXTURECUBE = D3D_SRV_DIMENSION_TEXTURECUBE, + D3D10_1_SRV_DIMENSION_UNKNOWN = D3D_SRV_DIMENSION_UNKNOWN, + D3D10_1_SRV_DIMENSION_BUFFER = D3D_SRV_DIMENSION_BUFFER, + D3D10_1_SRV_DIMENSION_TEXTURE1D = D3D_SRV_DIMENSION_TEXTURE1D, + D3D10_1_SRV_DIMENSION_TEXTURE1DARRAY = D3D_SRV_DIMENSION_TEXTURE1DARRAY, + D3D10_1_SRV_DIMENSION_TEXTURE2D = D3D_SRV_DIMENSION_TEXTURE2D, + D3D10_1_SRV_DIMENSION_TEXTURE2DARRAY = D3D_SRV_DIMENSION_TEXTURE2DARRAY, + D3D10_1_SRV_DIMENSION_TEXTURE2DMS = D3D_SRV_DIMENSION_TEXTURE2DMS, + D3D10_1_SRV_DIMENSION_TEXTURE2DMSARRAY = D3D_SRV_DIMENSION_TEXTURE2DMSARRAY, + D3D10_1_SRV_DIMENSION_TEXTURE3D = D3D_SRV_DIMENSION_TEXTURE3D, + D3D10_1_SRV_DIMENSION_TEXTURECUBE = D3D_SRV_DIMENSION_TEXTURECUBE, + D3D10_1_SRV_DIMENSION_TEXTURECUBEARRAY = D3D_SRV_DIMENSION_TEXTURECUBEARRAY, + D3D11_SRV_DIMENSION_UNKNOWN = D3D_SRV_DIMENSION_UNKNOWN, + D3D11_SRV_DIMENSION_BUFFER = D3D_SRV_DIMENSION_BUFFER, + D3D11_SRV_DIMENSION_TEXTURE1D = D3D_SRV_DIMENSION_TEXTURE1D, + D3D11_SRV_DIMENSION_TEXTURE1DARRAY = D3D_SRV_DIMENSION_TEXTURE1DARRAY, + D3D11_SRV_DIMENSION_TEXTURE2D = D3D_SRV_DIMENSION_TEXTURE2D, + D3D11_SRV_DIMENSION_TEXTURE2DARRAY = D3D_SRV_DIMENSION_TEXTURE2DARRAY, + D3D11_SRV_DIMENSION_TEXTURE2DMS = D3D_SRV_DIMENSION_TEXTURE2DMS, + D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY = D3D_SRV_DIMENSION_TEXTURE2DMSARRAY, + D3D11_SRV_DIMENSION_TEXTURE3D = D3D_SRV_DIMENSION_TEXTURE3D, + D3D11_SRV_DIMENSION_TEXTURECUBE = D3D_SRV_DIMENSION_TEXTURECUBE, + D3D11_SRV_DIMENSION_TEXTURECUBEARRAY = D3D_SRV_DIMENSION_TEXTURECUBEARRAY, + D3D11_SRV_DIMENSION_BUFFEREX = D3D_SRV_DIMENSION_BUFFEREX + } D3D_SRV_DIMENSION; + +typedef struct _D3D_SHADER_MACRO + { + LPCSTR Name; + LPCSTR Definition; + } D3D_SHADER_MACRO; + +typedef struct _D3D_SHADER_MACRO *LPD3D_SHADER_MACRO; + +DEFINE_GUID(IID_ID3D10Blob, 0x8ba5fb08, 0x5195, 0x40e2, 0xac, 0x58, 0xd, 0x98, 0x9c, 0x3a, 0x1, 0x2); + + +extern RPC_IF_HANDLE __MIDL_itf_d3dcommon_0000_0000_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3dcommon_0000_0000_v0_0_s_ifspec; + +#ifndef __ID3D10Blob_INTERFACE_DEFINED__ +#define __ID3D10Blob_INTERFACE_DEFINED__ + +/* interface ID3D10Blob */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D10Blob; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("8BA5FB08-5195-40e2-AC58-0D989C3A0102") + ID3D10Blob : public IUnknown + { + public: + virtual LPVOID STDMETHODCALLTYPE GetBufferPointer( void) = 0; + + virtual SIZE_T STDMETHODCALLTYPE GetBufferSize( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D10BlobVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D10Blob * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D10Blob * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D10Blob * This); + + LPVOID ( STDMETHODCALLTYPE *GetBufferPointer )( + ID3D10Blob * This); + + SIZE_T ( STDMETHODCALLTYPE *GetBufferSize )( + ID3D10Blob * This); + + END_INTERFACE + } ID3D10BlobVtbl; + + interface ID3D10Blob + { + CONST_VTBL struct ID3D10BlobVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D10Blob_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D10Blob_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D10Blob_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D10Blob_GetBufferPointer(This) \ + ( (This)->lpVtbl -> GetBufferPointer(This) ) + +#define ID3D10Blob_GetBufferSize(This) \ + ( (This)->lpVtbl -> GetBufferSize(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D10Blob_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3dcommon_0000_0001 */ +/* [local] */ + +typedef interface ID3D10Blob* LPD3D10BLOB; +typedef ID3D10Blob ID3DBlob; + +typedef ID3DBlob* LPD3DBLOB; +#define IID_ID3DBlob IID_ID3D10Blob +typedef void ( __stdcall *PFN_DESTRUCTION_CALLBACK )( + void *pData); + + + +extern RPC_IF_HANDLE __MIDL_itf_d3dcommon_0000_0001_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3dcommon_0000_0001_v0_0_s_ifspec; + +#ifndef __ID3DDestructionNotifier_INTERFACE_DEFINED__ +#define __ID3DDestructionNotifier_INTERFACE_DEFINED__ + +/* interface ID3DDestructionNotifier */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3DDestructionNotifier; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("a06eb39a-50da-425b-8c31-4eecd6c270f3") + ID3DDestructionNotifier : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE RegisterDestructionCallback( + /* [annotation] */ + _In_ PFN_DESTRUCTION_CALLBACK callbackFn, + /* [annotation] */ + _In_ void *pData, + /* [annotation] */ + _Out_ UINT *pCallbackID) = 0; + + virtual HRESULT STDMETHODCALLTYPE UnregisterDestructionCallback( + /* [annotation] */ + _In_ UINT callbackID) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3DDestructionNotifierVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3DDestructionNotifier * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3DDestructionNotifier * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + ID3DDestructionNotifier * This); + + HRESULT ( STDMETHODCALLTYPE *RegisterDestructionCallback )( + ID3DDestructionNotifier * This, + /* [annotation] */ + _In_ PFN_DESTRUCTION_CALLBACK callbackFn, + /* [annotation] */ + _In_ void *pData, + /* [annotation] */ + _Out_ UINT *pCallbackID); + + HRESULT ( STDMETHODCALLTYPE *UnregisterDestructionCallback )( + ID3DDestructionNotifier * This, + /* [annotation] */ + _In_ UINT callbackID); + + END_INTERFACE + } ID3DDestructionNotifierVtbl; + + interface ID3DDestructionNotifier + { + CONST_VTBL struct ID3DDestructionNotifierVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3DDestructionNotifier_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3DDestructionNotifier_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3DDestructionNotifier_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3DDestructionNotifier_RegisterDestructionCallback(This,callbackFn,pData,pCallbackID) \ + ( (This)->lpVtbl -> RegisterDestructionCallback(This,callbackFn,pData,pCallbackID) ) + +#define ID3DDestructionNotifier_UnregisterDestructionCallback(This,callbackID) \ + ( (This)->lpVtbl -> UnregisterDestructionCallback(This,callbackID) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3DDestructionNotifier_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3dcommon_0000_0002 */ +/* [local] */ + +typedef +enum _D3D_INCLUDE_TYPE + { + D3D_INCLUDE_LOCAL = 0, + D3D_INCLUDE_SYSTEM = ( D3D_INCLUDE_LOCAL + 1 ) , + D3D10_INCLUDE_LOCAL = D3D_INCLUDE_LOCAL, + D3D10_INCLUDE_SYSTEM = D3D_INCLUDE_SYSTEM, + D3D_INCLUDE_FORCE_DWORD = 0x7fffffff + } D3D_INCLUDE_TYPE; + +typedef interface ID3DInclude ID3DInclude; +#undef INTERFACE +#define INTERFACE ID3DInclude +DECLARE_INTERFACE(ID3DInclude) +{ + STDMETHOD(Open)(THIS_ D3D_INCLUDE_TYPE IncludeType, LPCSTR pFileName, LPCVOID pParentData, LPCVOID *ppData, UINT *pBytes) PURE; + STDMETHOD(Close)(THIS_ LPCVOID pData) PURE; +}; +typedef ID3DInclude* LPD3DINCLUDE; +typedef +enum _D3D_SHADER_VARIABLE_CLASS + { + D3D_SVC_SCALAR = 0, + D3D_SVC_VECTOR = ( D3D_SVC_SCALAR + 1 ) , + D3D_SVC_MATRIX_ROWS = ( D3D_SVC_VECTOR + 1 ) , + D3D_SVC_MATRIX_COLUMNS = ( D3D_SVC_MATRIX_ROWS + 1 ) , + D3D_SVC_OBJECT = ( D3D_SVC_MATRIX_COLUMNS + 1 ) , + D3D_SVC_STRUCT = ( D3D_SVC_OBJECT + 1 ) , + D3D_SVC_INTERFACE_CLASS = ( D3D_SVC_STRUCT + 1 ) , + D3D_SVC_INTERFACE_POINTER = ( D3D_SVC_INTERFACE_CLASS + 1 ) , + D3D10_SVC_SCALAR = D3D_SVC_SCALAR, + D3D10_SVC_VECTOR = D3D_SVC_VECTOR, + D3D10_SVC_MATRIX_ROWS = D3D_SVC_MATRIX_ROWS, + D3D10_SVC_MATRIX_COLUMNS = D3D_SVC_MATRIX_COLUMNS, + D3D10_SVC_OBJECT = D3D_SVC_OBJECT, + D3D10_SVC_STRUCT = D3D_SVC_STRUCT, + D3D11_SVC_INTERFACE_CLASS = D3D_SVC_INTERFACE_CLASS, + D3D11_SVC_INTERFACE_POINTER = D3D_SVC_INTERFACE_POINTER, + D3D_SVC_FORCE_DWORD = 0x7fffffff + } D3D_SHADER_VARIABLE_CLASS; + +typedef +enum _D3D_SHADER_VARIABLE_FLAGS + { + D3D_SVF_USERPACKED = 1, + D3D_SVF_USED = 2, + D3D_SVF_INTERFACE_POINTER = 4, + D3D_SVF_INTERFACE_PARAMETER = 8, + D3D10_SVF_USERPACKED = D3D_SVF_USERPACKED, + D3D10_SVF_USED = D3D_SVF_USED, + D3D11_SVF_INTERFACE_POINTER = D3D_SVF_INTERFACE_POINTER, + D3D11_SVF_INTERFACE_PARAMETER = D3D_SVF_INTERFACE_PARAMETER, + D3D_SVF_FORCE_DWORD = 0x7fffffff + } D3D_SHADER_VARIABLE_FLAGS; + +typedef +enum _D3D_SHADER_VARIABLE_TYPE + { + D3D_SVT_VOID = 0, + D3D_SVT_BOOL = 1, + D3D_SVT_INT = 2, + D3D_SVT_FLOAT = 3, + D3D_SVT_STRING = 4, + D3D_SVT_TEXTURE = 5, + D3D_SVT_TEXTURE1D = 6, + D3D_SVT_TEXTURE2D = 7, + D3D_SVT_TEXTURE3D = 8, + D3D_SVT_TEXTURECUBE = 9, + D3D_SVT_SAMPLER = 10, + D3D_SVT_SAMPLER1D = 11, + D3D_SVT_SAMPLER2D = 12, + D3D_SVT_SAMPLER3D = 13, + D3D_SVT_SAMPLERCUBE = 14, + D3D_SVT_PIXELSHADER = 15, + D3D_SVT_VERTEXSHADER = 16, + D3D_SVT_PIXELFRAGMENT = 17, + D3D_SVT_VERTEXFRAGMENT = 18, + D3D_SVT_UINT = 19, + D3D_SVT_UINT8 = 20, + D3D_SVT_GEOMETRYSHADER = 21, + D3D_SVT_RASTERIZER = 22, + D3D_SVT_DEPTHSTENCIL = 23, + D3D_SVT_BLEND = 24, + D3D_SVT_BUFFER = 25, + D3D_SVT_CBUFFER = 26, + D3D_SVT_TBUFFER = 27, + D3D_SVT_TEXTURE1DARRAY = 28, + D3D_SVT_TEXTURE2DARRAY = 29, + D3D_SVT_RENDERTARGETVIEW = 30, + D3D_SVT_DEPTHSTENCILVIEW = 31, + D3D_SVT_TEXTURE2DMS = 32, + D3D_SVT_TEXTURE2DMSARRAY = 33, + D3D_SVT_TEXTURECUBEARRAY = 34, + D3D_SVT_HULLSHADER = 35, + D3D_SVT_DOMAINSHADER = 36, + D3D_SVT_INTERFACE_POINTER = 37, + D3D_SVT_COMPUTESHADER = 38, + D3D_SVT_DOUBLE = 39, + D3D_SVT_RWTEXTURE1D = 40, + D3D_SVT_RWTEXTURE1DARRAY = 41, + D3D_SVT_RWTEXTURE2D = 42, + D3D_SVT_RWTEXTURE2DARRAY = 43, + D3D_SVT_RWTEXTURE3D = 44, + D3D_SVT_RWBUFFER = 45, + D3D_SVT_BYTEADDRESS_BUFFER = 46, + D3D_SVT_RWBYTEADDRESS_BUFFER = 47, + D3D_SVT_STRUCTURED_BUFFER = 48, + D3D_SVT_RWSTRUCTURED_BUFFER = 49, + D3D_SVT_APPEND_STRUCTURED_BUFFER = 50, + D3D_SVT_CONSUME_STRUCTURED_BUFFER = 51, + D3D_SVT_MIN8FLOAT = 52, + D3D_SVT_MIN10FLOAT = 53, + D3D_SVT_MIN16FLOAT = 54, + D3D_SVT_MIN12INT = 55, + D3D_SVT_MIN16INT = 56, + D3D_SVT_MIN16UINT = 57, + D3D10_SVT_VOID = D3D_SVT_VOID, + D3D10_SVT_BOOL = D3D_SVT_BOOL, + D3D10_SVT_INT = D3D_SVT_INT, + D3D10_SVT_FLOAT = D3D_SVT_FLOAT, + D3D10_SVT_STRING = D3D_SVT_STRING, + D3D10_SVT_TEXTURE = D3D_SVT_TEXTURE, + D3D10_SVT_TEXTURE1D = D3D_SVT_TEXTURE1D, + D3D10_SVT_TEXTURE2D = D3D_SVT_TEXTURE2D, + D3D10_SVT_TEXTURE3D = D3D_SVT_TEXTURE3D, + D3D10_SVT_TEXTURECUBE = D3D_SVT_TEXTURECUBE, + D3D10_SVT_SAMPLER = D3D_SVT_SAMPLER, + D3D10_SVT_SAMPLER1D = D3D_SVT_SAMPLER1D, + D3D10_SVT_SAMPLER2D = D3D_SVT_SAMPLER2D, + D3D10_SVT_SAMPLER3D = D3D_SVT_SAMPLER3D, + D3D10_SVT_SAMPLERCUBE = D3D_SVT_SAMPLERCUBE, + D3D10_SVT_PIXELSHADER = D3D_SVT_PIXELSHADER, + D3D10_SVT_VERTEXSHADER = D3D_SVT_VERTEXSHADER, + D3D10_SVT_PIXELFRAGMENT = D3D_SVT_PIXELFRAGMENT, + D3D10_SVT_VERTEXFRAGMENT = D3D_SVT_VERTEXFRAGMENT, + D3D10_SVT_UINT = D3D_SVT_UINT, + D3D10_SVT_UINT8 = D3D_SVT_UINT8, + D3D10_SVT_GEOMETRYSHADER = D3D_SVT_GEOMETRYSHADER, + D3D10_SVT_RASTERIZER = D3D_SVT_RASTERIZER, + D3D10_SVT_DEPTHSTENCIL = D3D_SVT_DEPTHSTENCIL, + D3D10_SVT_BLEND = D3D_SVT_BLEND, + D3D10_SVT_BUFFER = D3D_SVT_BUFFER, + D3D10_SVT_CBUFFER = D3D_SVT_CBUFFER, + D3D10_SVT_TBUFFER = D3D_SVT_TBUFFER, + D3D10_SVT_TEXTURE1DARRAY = D3D_SVT_TEXTURE1DARRAY, + D3D10_SVT_TEXTURE2DARRAY = D3D_SVT_TEXTURE2DARRAY, + D3D10_SVT_RENDERTARGETVIEW = D3D_SVT_RENDERTARGETVIEW, + D3D10_SVT_DEPTHSTENCILVIEW = D3D_SVT_DEPTHSTENCILVIEW, + D3D10_SVT_TEXTURE2DMS = D3D_SVT_TEXTURE2DMS, + D3D10_SVT_TEXTURE2DMSARRAY = D3D_SVT_TEXTURE2DMSARRAY, + D3D10_SVT_TEXTURECUBEARRAY = D3D_SVT_TEXTURECUBEARRAY, + D3D11_SVT_HULLSHADER = D3D_SVT_HULLSHADER, + D3D11_SVT_DOMAINSHADER = D3D_SVT_DOMAINSHADER, + D3D11_SVT_INTERFACE_POINTER = D3D_SVT_INTERFACE_POINTER, + D3D11_SVT_COMPUTESHADER = D3D_SVT_COMPUTESHADER, + D3D11_SVT_DOUBLE = D3D_SVT_DOUBLE, + D3D11_SVT_RWTEXTURE1D = D3D_SVT_RWTEXTURE1D, + D3D11_SVT_RWTEXTURE1DARRAY = D3D_SVT_RWTEXTURE1DARRAY, + D3D11_SVT_RWTEXTURE2D = D3D_SVT_RWTEXTURE2D, + D3D11_SVT_RWTEXTURE2DARRAY = D3D_SVT_RWTEXTURE2DARRAY, + D3D11_SVT_RWTEXTURE3D = D3D_SVT_RWTEXTURE3D, + D3D11_SVT_RWBUFFER = D3D_SVT_RWBUFFER, + D3D11_SVT_BYTEADDRESS_BUFFER = D3D_SVT_BYTEADDRESS_BUFFER, + D3D11_SVT_RWBYTEADDRESS_BUFFER = D3D_SVT_RWBYTEADDRESS_BUFFER, + D3D11_SVT_STRUCTURED_BUFFER = D3D_SVT_STRUCTURED_BUFFER, + D3D11_SVT_RWSTRUCTURED_BUFFER = D3D_SVT_RWSTRUCTURED_BUFFER, + D3D11_SVT_APPEND_STRUCTURED_BUFFER = D3D_SVT_APPEND_STRUCTURED_BUFFER, + D3D11_SVT_CONSUME_STRUCTURED_BUFFER = D3D_SVT_CONSUME_STRUCTURED_BUFFER, + D3D_SVT_FORCE_DWORD = 0x7fffffff + } D3D_SHADER_VARIABLE_TYPE; + +typedef +enum _D3D_SHADER_INPUT_FLAGS + { + D3D_SIF_USERPACKED = 0x1, + D3D_SIF_COMPARISON_SAMPLER = 0x2, + D3D_SIF_TEXTURE_COMPONENT_0 = 0x4, + D3D_SIF_TEXTURE_COMPONENT_1 = 0x8, + D3D_SIF_TEXTURE_COMPONENTS = 0xc, + D3D_SIF_UNUSED = 0x10, + D3D10_SIF_USERPACKED = D3D_SIF_USERPACKED, + D3D10_SIF_COMPARISON_SAMPLER = D3D_SIF_COMPARISON_SAMPLER, + D3D10_SIF_TEXTURE_COMPONENT_0 = D3D_SIF_TEXTURE_COMPONENT_0, + D3D10_SIF_TEXTURE_COMPONENT_1 = D3D_SIF_TEXTURE_COMPONENT_1, + D3D10_SIF_TEXTURE_COMPONENTS = D3D_SIF_TEXTURE_COMPONENTS, + D3D_SIF_FORCE_DWORD = 0x7fffffff + } D3D_SHADER_INPUT_FLAGS; + +typedef +enum _D3D_SHADER_INPUT_TYPE + { + D3D_SIT_CBUFFER = 0, + D3D_SIT_TBUFFER = ( D3D_SIT_CBUFFER + 1 ) , + D3D_SIT_TEXTURE = ( D3D_SIT_TBUFFER + 1 ) , + D3D_SIT_SAMPLER = ( D3D_SIT_TEXTURE + 1 ) , + D3D_SIT_UAV_RWTYPED = ( D3D_SIT_SAMPLER + 1 ) , + D3D_SIT_STRUCTURED = ( D3D_SIT_UAV_RWTYPED + 1 ) , + D3D_SIT_UAV_RWSTRUCTURED = ( D3D_SIT_STRUCTURED + 1 ) , + D3D_SIT_BYTEADDRESS = ( D3D_SIT_UAV_RWSTRUCTURED + 1 ) , + D3D_SIT_UAV_RWBYTEADDRESS = ( D3D_SIT_BYTEADDRESS + 1 ) , + D3D_SIT_UAV_APPEND_STRUCTURED = ( D3D_SIT_UAV_RWBYTEADDRESS + 1 ) , + D3D_SIT_UAV_CONSUME_STRUCTURED = ( D3D_SIT_UAV_APPEND_STRUCTURED + 1 ) , + D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER = ( D3D_SIT_UAV_CONSUME_STRUCTURED + 1 ) , + D3D10_SIT_CBUFFER = D3D_SIT_CBUFFER, + D3D10_SIT_TBUFFER = D3D_SIT_TBUFFER, + D3D10_SIT_TEXTURE = D3D_SIT_TEXTURE, + D3D10_SIT_SAMPLER = D3D_SIT_SAMPLER, + D3D11_SIT_UAV_RWTYPED = D3D_SIT_UAV_RWTYPED, + D3D11_SIT_STRUCTURED = D3D_SIT_STRUCTURED, + D3D11_SIT_UAV_RWSTRUCTURED = D3D_SIT_UAV_RWSTRUCTURED, + D3D11_SIT_BYTEADDRESS = D3D_SIT_BYTEADDRESS, + D3D11_SIT_UAV_RWBYTEADDRESS = D3D_SIT_UAV_RWBYTEADDRESS, + D3D11_SIT_UAV_APPEND_STRUCTURED = D3D_SIT_UAV_APPEND_STRUCTURED, + D3D11_SIT_UAV_CONSUME_STRUCTURED = D3D_SIT_UAV_CONSUME_STRUCTURED, + D3D11_SIT_UAV_RWSTRUCTURED_WITH_COUNTER = D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER + } D3D_SHADER_INPUT_TYPE; + +typedef +enum _D3D_SHADER_CBUFFER_FLAGS + { + D3D_CBF_USERPACKED = 1, + D3D10_CBF_USERPACKED = D3D_CBF_USERPACKED, + D3D_CBF_FORCE_DWORD = 0x7fffffff + } D3D_SHADER_CBUFFER_FLAGS; + +typedef +enum _D3D_CBUFFER_TYPE + { + D3D_CT_CBUFFER = 0, + D3D_CT_TBUFFER = ( D3D_CT_CBUFFER + 1 ) , + D3D_CT_INTERFACE_POINTERS = ( D3D_CT_TBUFFER + 1 ) , + D3D_CT_RESOURCE_BIND_INFO = ( D3D_CT_INTERFACE_POINTERS + 1 ) , + D3D10_CT_CBUFFER = D3D_CT_CBUFFER, + D3D10_CT_TBUFFER = D3D_CT_TBUFFER, + D3D11_CT_CBUFFER = D3D_CT_CBUFFER, + D3D11_CT_TBUFFER = D3D_CT_TBUFFER, + D3D11_CT_INTERFACE_POINTERS = D3D_CT_INTERFACE_POINTERS, + D3D11_CT_RESOURCE_BIND_INFO = D3D_CT_RESOURCE_BIND_INFO + } D3D_CBUFFER_TYPE; + +typedef +enum D3D_NAME + { + D3D_NAME_UNDEFINED = 0, + D3D_NAME_POSITION = 1, + D3D_NAME_CLIP_DISTANCE = 2, + D3D_NAME_CULL_DISTANCE = 3, + D3D_NAME_RENDER_TARGET_ARRAY_INDEX = 4, + D3D_NAME_VIEWPORT_ARRAY_INDEX = 5, + D3D_NAME_VERTEX_ID = 6, + D3D_NAME_PRIMITIVE_ID = 7, + D3D_NAME_INSTANCE_ID = 8, + D3D_NAME_IS_FRONT_FACE = 9, + D3D_NAME_SAMPLE_INDEX = 10, + D3D_NAME_FINAL_QUAD_EDGE_TESSFACTOR = 11, + D3D_NAME_FINAL_QUAD_INSIDE_TESSFACTOR = 12, + D3D_NAME_FINAL_TRI_EDGE_TESSFACTOR = 13, + D3D_NAME_FINAL_TRI_INSIDE_TESSFACTOR = 14, + D3D_NAME_FINAL_LINE_DETAIL_TESSFACTOR = 15, + D3D_NAME_FINAL_LINE_DENSITY_TESSFACTOR = 16, + D3D_NAME_BARYCENTRICS = 23, + D3D_NAME_SHADINGRATE = 24, + D3D_NAME_TARGET = 64, + D3D_NAME_DEPTH = 65, + D3D_NAME_COVERAGE = 66, + D3D_NAME_DEPTH_GREATER_EQUAL = 67, + D3D_NAME_DEPTH_LESS_EQUAL = 68, + D3D_NAME_STENCIL_REF = 69, + D3D_NAME_INNER_COVERAGE = 70, + D3D10_NAME_UNDEFINED = D3D_NAME_UNDEFINED, + D3D10_NAME_POSITION = D3D_NAME_POSITION, + D3D10_NAME_CLIP_DISTANCE = D3D_NAME_CLIP_DISTANCE, + D3D10_NAME_CULL_DISTANCE = D3D_NAME_CULL_DISTANCE, + D3D10_NAME_RENDER_TARGET_ARRAY_INDEX = D3D_NAME_RENDER_TARGET_ARRAY_INDEX, + D3D10_NAME_VIEWPORT_ARRAY_INDEX = D3D_NAME_VIEWPORT_ARRAY_INDEX, + D3D10_NAME_VERTEX_ID = D3D_NAME_VERTEX_ID, + D3D10_NAME_PRIMITIVE_ID = D3D_NAME_PRIMITIVE_ID, + D3D10_NAME_INSTANCE_ID = D3D_NAME_INSTANCE_ID, + D3D10_NAME_IS_FRONT_FACE = D3D_NAME_IS_FRONT_FACE, + D3D10_NAME_SAMPLE_INDEX = D3D_NAME_SAMPLE_INDEX, + D3D10_NAME_TARGET = D3D_NAME_TARGET, + D3D10_NAME_DEPTH = D3D_NAME_DEPTH, + D3D10_NAME_COVERAGE = D3D_NAME_COVERAGE, + D3D11_NAME_FINAL_QUAD_EDGE_TESSFACTOR = D3D_NAME_FINAL_QUAD_EDGE_TESSFACTOR, + D3D11_NAME_FINAL_QUAD_INSIDE_TESSFACTOR = D3D_NAME_FINAL_QUAD_INSIDE_TESSFACTOR, + D3D11_NAME_FINAL_TRI_EDGE_TESSFACTOR = D3D_NAME_FINAL_TRI_EDGE_TESSFACTOR, + D3D11_NAME_FINAL_TRI_INSIDE_TESSFACTOR = D3D_NAME_FINAL_TRI_INSIDE_TESSFACTOR, + D3D11_NAME_FINAL_LINE_DETAIL_TESSFACTOR = D3D_NAME_FINAL_LINE_DETAIL_TESSFACTOR, + D3D11_NAME_FINAL_LINE_DENSITY_TESSFACTOR = D3D_NAME_FINAL_LINE_DENSITY_TESSFACTOR, + D3D11_NAME_DEPTH_GREATER_EQUAL = D3D_NAME_DEPTH_GREATER_EQUAL, + D3D11_NAME_DEPTH_LESS_EQUAL = D3D_NAME_DEPTH_LESS_EQUAL, + D3D11_NAME_STENCIL_REF = D3D_NAME_STENCIL_REF, + D3D11_NAME_INNER_COVERAGE = D3D_NAME_INNER_COVERAGE, + D3D12_NAME_BARYCENTRICS = D3D_NAME_BARYCENTRICS, + D3D12_NAME_SHADINGRATE = D3D_NAME_SHADINGRATE + } D3D_NAME; + +typedef +enum D3D_RESOURCE_RETURN_TYPE + { + D3D_RETURN_TYPE_UNORM = 1, + D3D_RETURN_TYPE_SNORM = 2, + D3D_RETURN_TYPE_SINT = 3, + D3D_RETURN_TYPE_UINT = 4, + D3D_RETURN_TYPE_FLOAT = 5, + D3D_RETURN_TYPE_MIXED = 6, + D3D_RETURN_TYPE_DOUBLE = 7, + D3D_RETURN_TYPE_CONTINUED = 8, + D3D10_RETURN_TYPE_UNORM = D3D_RETURN_TYPE_UNORM, + D3D10_RETURN_TYPE_SNORM = D3D_RETURN_TYPE_SNORM, + D3D10_RETURN_TYPE_SINT = D3D_RETURN_TYPE_SINT, + D3D10_RETURN_TYPE_UINT = D3D_RETURN_TYPE_UINT, + D3D10_RETURN_TYPE_FLOAT = D3D_RETURN_TYPE_FLOAT, + D3D10_RETURN_TYPE_MIXED = D3D_RETURN_TYPE_MIXED, + D3D11_RETURN_TYPE_UNORM = D3D_RETURN_TYPE_UNORM, + D3D11_RETURN_TYPE_SNORM = D3D_RETURN_TYPE_SNORM, + D3D11_RETURN_TYPE_SINT = D3D_RETURN_TYPE_SINT, + D3D11_RETURN_TYPE_UINT = D3D_RETURN_TYPE_UINT, + D3D11_RETURN_TYPE_FLOAT = D3D_RETURN_TYPE_FLOAT, + D3D11_RETURN_TYPE_MIXED = D3D_RETURN_TYPE_MIXED, + D3D11_RETURN_TYPE_DOUBLE = D3D_RETURN_TYPE_DOUBLE, + D3D11_RETURN_TYPE_CONTINUED = D3D_RETURN_TYPE_CONTINUED + } D3D_RESOURCE_RETURN_TYPE; + +typedef +enum D3D_REGISTER_COMPONENT_TYPE + { + D3D_REGISTER_COMPONENT_UNKNOWN = 0, + D3D_REGISTER_COMPONENT_UINT32 = 1, + D3D_REGISTER_COMPONENT_SINT32 = 2, + D3D_REGISTER_COMPONENT_FLOAT32 = 3, + D3D10_REGISTER_COMPONENT_UNKNOWN = D3D_REGISTER_COMPONENT_UNKNOWN, + D3D10_REGISTER_COMPONENT_UINT32 = D3D_REGISTER_COMPONENT_UINT32, + D3D10_REGISTER_COMPONENT_SINT32 = D3D_REGISTER_COMPONENT_SINT32, + D3D10_REGISTER_COMPONENT_FLOAT32 = D3D_REGISTER_COMPONENT_FLOAT32 + } D3D_REGISTER_COMPONENT_TYPE; + +typedef +enum D3D_TESSELLATOR_DOMAIN + { + D3D_TESSELLATOR_DOMAIN_UNDEFINED = 0, + D3D_TESSELLATOR_DOMAIN_ISOLINE = 1, + D3D_TESSELLATOR_DOMAIN_TRI = 2, + D3D_TESSELLATOR_DOMAIN_QUAD = 3, + D3D11_TESSELLATOR_DOMAIN_UNDEFINED = D3D_TESSELLATOR_DOMAIN_UNDEFINED, + D3D11_TESSELLATOR_DOMAIN_ISOLINE = D3D_TESSELLATOR_DOMAIN_ISOLINE, + D3D11_TESSELLATOR_DOMAIN_TRI = D3D_TESSELLATOR_DOMAIN_TRI, + D3D11_TESSELLATOR_DOMAIN_QUAD = D3D_TESSELLATOR_DOMAIN_QUAD + } D3D_TESSELLATOR_DOMAIN; + +typedef +enum D3D_TESSELLATOR_PARTITIONING + { + D3D_TESSELLATOR_PARTITIONING_UNDEFINED = 0, + D3D_TESSELLATOR_PARTITIONING_INTEGER = 1, + D3D_TESSELLATOR_PARTITIONING_POW2 = 2, + D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD = 3, + D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN = 4, + D3D11_TESSELLATOR_PARTITIONING_UNDEFINED = D3D_TESSELLATOR_PARTITIONING_UNDEFINED, + D3D11_TESSELLATOR_PARTITIONING_INTEGER = D3D_TESSELLATOR_PARTITIONING_INTEGER, + D3D11_TESSELLATOR_PARTITIONING_POW2 = D3D_TESSELLATOR_PARTITIONING_POW2, + D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD = D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD, + D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN = D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN + } D3D_TESSELLATOR_PARTITIONING; + +typedef +enum D3D_TESSELLATOR_OUTPUT_PRIMITIVE + { + D3D_TESSELLATOR_OUTPUT_UNDEFINED = 0, + D3D_TESSELLATOR_OUTPUT_POINT = 1, + D3D_TESSELLATOR_OUTPUT_LINE = 2, + D3D_TESSELLATOR_OUTPUT_TRIANGLE_CW = 3, + D3D_TESSELLATOR_OUTPUT_TRIANGLE_CCW = 4, + D3D11_TESSELLATOR_OUTPUT_UNDEFINED = D3D_TESSELLATOR_OUTPUT_UNDEFINED, + D3D11_TESSELLATOR_OUTPUT_POINT = D3D_TESSELLATOR_OUTPUT_POINT, + D3D11_TESSELLATOR_OUTPUT_LINE = D3D_TESSELLATOR_OUTPUT_LINE, + D3D11_TESSELLATOR_OUTPUT_TRIANGLE_CW = D3D_TESSELLATOR_OUTPUT_TRIANGLE_CW, + D3D11_TESSELLATOR_OUTPUT_TRIANGLE_CCW = D3D_TESSELLATOR_OUTPUT_TRIANGLE_CCW + } D3D_TESSELLATOR_OUTPUT_PRIMITIVE; + +typedef +enum D3D_MIN_PRECISION + { + D3D_MIN_PRECISION_DEFAULT = 0, + D3D_MIN_PRECISION_FLOAT_16 = 1, + D3D_MIN_PRECISION_FLOAT_2_8 = 2, + D3D_MIN_PRECISION_RESERVED = 3, + D3D_MIN_PRECISION_SINT_16 = 4, + D3D_MIN_PRECISION_UINT_16 = 5, + D3D_MIN_PRECISION_ANY_16 = 0xf0, + D3D_MIN_PRECISION_ANY_10 = 0xf1 + } D3D_MIN_PRECISION; + +typedef +enum D3D_INTERPOLATION_MODE + { + D3D_INTERPOLATION_UNDEFINED = 0, + D3D_INTERPOLATION_CONSTANT = 1, + D3D_INTERPOLATION_LINEAR = 2, + D3D_INTERPOLATION_LINEAR_CENTROID = 3, + D3D_INTERPOLATION_LINEAR_NOPERSPECTIVE = 4, + D3D_INTERPOLATION_LINEAR_NOPERSPECTIVE_CENTROID = 5, + D3D_INTERPOLATION_LINEAR_SAMPLE = 6, + D3D_INTERPOLATION_LINEAR_NOPERSPECTIVE_SAMPLE = 7 + } D3D_INTERPOLATION_MODE; + +typedef +enum _D3D_PARAMETER_FLAGS + { + D3D_PF_NONE = 0, + D3D_PF_IN = 0x1, + D3D_PF_OUT = 0x2, + D3D_PF_FORCE_DWORD = 0x7fffffff + } D3D_PARAMETER_FLAGS; + +DEFINE_GUID(WKPDID_D3DDebugObjectName,0x429b8c22,0x9188,0x4b0c,0x87,0x42,0xac,0xb0,0xbf,0x85,0xc2,0x00); +DEFINE_GUID(WKPDID_D3DDebugObjectNameW,0x4cca5fd8,0x921f,0x42c8,0x85,0x66,0x70,0xca,0xf2,0xa9,0xb7,0x41); +DEFINE_GUID(WKPDID_CommentStringW,0xd0149dc0,0x90e8,0x4ec8,0x81, 0x44, 0xe9, 0x00, 0xad, 0x26, 0x6b, 0xb2); +#define D3D_SET_OBJECT_NAME_N_A(pObject, Chars, pName) (pObject)->SetPrivateData(WKPDID_D3DDebugObjectName, Chars, pName) +#define D3D_SET_OBJECT_NAME_A(pObject, pName) D3D_SET_OBJECT_NAME_N_A(pObject, lstrlenA(pName), pName) +#define D3D_SET_OBJECT_NAME_N_W(pObject, Chars, pName) (pObject)->SetPrivateData(WKPDID_D3DDebugObjectNameW, Chars*2, pName) +#define D3D_SET_OBJECT_NAME_W(pObject, pName) D3D_SET_OBJECT_NAME_N_W(pObject, wcslen(pName), pName) +#define D3D_COMPONENT_MASK_X 1 +#define D3D_COMPONENT_MASK_Y 2 +#define D3D_COMPONENT_MASK_Z 4 +#define D3D_COMPONENT_MASK_W 8 +DEFINE_GUID(D3D_TEXTURE_LAYOUT_ROW_MAJOR,0xb5dc234f,0x72bb,0x4bec,0x97,0x05,0x8c,0xf2,0x58,0xdf,0x6b,0x6c); +DEFINE_GUID(D3D_TEXTURE_LAYOUT_64KB_STANDARD_SWIZZLE,0x4c0f29e3,0x3f5f,0x4d35,0x84,0xc9,0xbc,0x09,0x83,0xb6,0x2c,0x28); + + +extern RPC_IF_HANDLE __MIDL_itf_d3dcommon_0000_0002_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3dcommon_0000_0002_v0_0_s_ifspec; + +/* Additional Prototypes for ALL interfaces */ + +/* end of Additional Prototypes */ + +#ifdef __cplusplus +} +#endif + +#endif + + diff --git a/src/decomp/pc/gfx/dxsdk/d3dx12.h b/src/decomp/pc/gfx/dxsdk/d3dx12.h new file mode 100644 index 0000000..3aafbd2 --- /dev/null +++ b/src/decomp/pc/gfx/dxsdk/d3dx12.h @@ -0,0 +1,3440 @@ +//********************************************************* +// +// Copyright (c) Microsoft. All rights reserved. +// This code is licensed under the MIT License (MIT). +// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF +// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY +// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR +// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT. +// +//********************************************************* + +#ifndef __D3DX12_H__ +#define __D3DX12_H__ + +#include "d3d12.h" + +#if defined( __cplusplus ) + +struct CD3DX12_DEFAULT {}; +extern const DECLSPEC_SELECTANY CD3DX12_DEFAULT D3D12_DEFAULT; + +//------------------------------------------------------------------------------------------------ +inline bool operator==( const D3D12_VIEWPORT& l, const D3D12_VIEWPORT& r ) +{ + return l.TopLeftX == r.TopLeftX && l.TopLeftY == r.TopLeftY && l.Width == r.Width && + l.Height == r.Height && l.MinDepth == r.MinDepth && l.MaxDepth == r.MaxDepth; +} + +//------------------------------------------------------------------------------------------------ +inline bool operator!=( const D3D12_VIEWPORT& l, const D3D12_VIEWPORT& r ) +{ return !( l == r ); } + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_RECT : public D3D12_RECT +{ + CD3DX12_RECT() = default; + explicit CD3DX12_RECT( const D3D12_RECT& o ) : + D3D12_RECT( o ) + {} + explicit CD3DX12_RECT( + LONG Left, + LONG Top, + LONG Right, + LONG Bottom ) + { + left = Left; + top = Top; + right = Right; + bottom = Bottom; + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_VIEWPORT : public D3D12_VIEWPORT +{ + CD3DX12_VIEWPORT() = default; + explicit CD3DX12_VIEWPORT( const D3D12_VIEWPORT& o ) : + D3D12_VIEWPORT( o ) + {} + explicit CD3DX12_VIEWPORT( + FLOAT topLeftX, + FLOAT topLeftY, + FLOAT width, + FLOAT height, + FLOAT minDepth = D3D12_MIN_DEPTH, + FLOAT maxDepth = D3D12_MAX_DEPTH ) + { + TopLeftX = topLeftX; + TopLeftY = topLeftY; + Width = width; + Height = height; + MinDepth = minDepth; + MaxDepth = maxDepth; + } + explicit CD3DX12_VIEWPORT( + _In_ ID3D12Resource* pResource, + UINT mipSlice = 0, + FLOAT topLeftX = 0.0f, + FLOAT topLeftY = 0.0f, + FLOAT minDepth = D3D12_MIN_DEPTH, + FLOAT maxDepth = D3D12_MAX_DEPTH ) + { + auto Desc = pResource->GetDesc(); + const UINT64 SubresourceWidth = Desc.Width >> mipSlice; + const UINT64 SubresourceHeight = Desc.Height >> mipSlice; + switch (Desc.Dimension) + { + case D3D12_RESOURCE_DIMENSION_BUFFER: + TopLeftX = topLeftX; + TopLeftY = 0.0f; + Width = Desc.Width - topLeftX; + Height = 1.0f; + break; + case D3D12_RESOURCE_DIMENSION_TEXTURE1D: + TopLeftX = topLeftX; + TopLeftY = 0.0f; + Width = (SubresourceWidth ? SubresourceWidth : 1.0f) - topLeftX; + Height = 1.0f; + break; + case D3D12_RESOURCE_DIMENSION_TEXTURE2D: + case D3D12_RESOURCE_DIMENSION_TEXTURE3D: + TopLeftX = topLeftX; + TopLeftY = topLeftY; + Width = (SubresourceWidth ? SubresourceWidth : 1.0f) - topLeftX; + Height = (SubresourceHeight ? SubresourceHeight: 1.0f) - topLeftY; + break; + default: break; + } + + MinDepth = minDepth; + MaxDepth = maxDepth; + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_BOX : public D3D12_BOX +{ + CD3DX12_BOX() = default; + explicit CD3DX12_BOX( const D3D12_BOX& o ) : + D3D12_BOX( o ) + {} + explicit CD3DX12_BOX( + LONG Left, + LONG Right ) + { + left = static_cast(Left); + top = 0; + front = 0; + right = static_cast(Right); + bottom = 1; + back = 1; + } + explicit CD3DX12_BOX( + LONG Left, + LONG Top, + LONG Right, + LONG Bottom ) + { + left = static_cast(Left); + top = static_cast(Top); + front = 0; + right = static_cast(Right); + bottom = static_cast(Bottom); + back = 1; + } + explicit CD3DX12_BOX( + LONG Left, + LONG Top, + LONG Front, + LONG Right, + LONG Bottom, + LONG Back ) + { + left = static_cast(Left); + top = static_cast(Top); + front = static_cast(Front); + right = static_cast(Right); + bottom = static_cast(Bottom); + back = static_cast(Back); + } +}; +inline bool operator==( const D3D12_BOX& l, const D3D12_BOX& r ) +{ + return l.left == r.left && l.top == r.top && l.front == r.front && + l.right == r.right && l.bottom == r.bottom && l.back == r.back; +} +inline bool operator!=( const D3D12_BOX& l, const D3D12_BOX& r ) +{ return !( l == r ); } + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_DEPTH_STENCIL_DESC : public D3D12_DEPTH_STENCIL_DESC +{ + CD3DX12_DEPTH_STENCIL_DESC() = default; + explicit CD3DX12_DEPTH_STENCIL_DESC( const D3D12_DEPTH_STENCIL_DESC& o ) : + D3D12_DEPTH_STENCIL_DESC( o ) + {} + explicit CD3DX12_DEPTH_STENCIL_DESC( CD3DX12_DEFAULT ) + { + DepthEnable = TRUE; + DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL; + DepthFunc = D3D12_COMPARISON_FUNC_LESS; + StencilEnable = FALSE; + StencilReadMask = D3D12_DEFAULT_STENCIL_READ_MASK; + StencilWriteMask = D3D12_DEFAULT_STENCIL_WRITE_MASK; + const D3D12_DEPTH_STENCILOP_DESC defaultStencilOp = + { D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_COMPARISON_FUNC_ALWAYS }; + FrontFace = defaultStencilOp; + BackFace = defaultStencilOp; + } + explicit CD3DX12_DEPTH_STENCIL_DESC( + BOOL depthEnable, + D3D12_DEPTH_WRITE_MASK depthWriteMask, + D3D12_COMPARISON_FUNC depthFunc, + BOOL stencilEnable, + UINT8 stencilReadMask, + UINT8 stencilWriteMask, + D3D12_STENCIL_OP frontStencilFailOp, + D3D12_STENCIL_OP frontStencilDepthFailOp, + D3D12_STENCIL_OP frontStencilPassOp, + D3D12_COMPARISON_FUNC frontStencilFunc, + D3D12_STENCIL_OP backStencilFailOp, + D3D12_STENCIL_OP backStencilDepthFailOp, + D3D12_STENCIL_OP backStencilPassOp, + D3D12_COMPARISON_FUNC backStencilFunc ) + { + DepthEnable = depthEnable; + DepthWriteMask = depthWriteMask; + DepthFunc = depthFunc; + StencilEnable = stencilEnable; + StencilReadMask = stencilReadMask; + StencilWriteMask = stencilWriteMask; + FrontFace.StencilFailOp = frontStencilFailOp; + FrontFace.StencilDepthFailOp = frontStencilDepthFailOp; + FrontFace.StencilPassOp = frontStencilPassOp; + FrontFace.StencilFunc = frontStencilFunc; + BackFace.StencilFailOp = backStencilFailOp; + BackFace.StencilDepthFailOp = backStencilDepthFailOp; + BackFace.StencilPassOp = backStencilPassOp; + BackFace.StencilFunc = backStencilFunc; + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_DEPTH_STENCIL_DESC1 : public D3D12_DEPTH_STENCIL_DESC1 +{ + CD3DX12_DEPTH_STENCIL_DESC1() = default; + explicit CD3DX12_DEPTH_STENCIL_DESC1( const D3D12_DEPTH_STENCIL_DESC1& o ) : + D3D12_DEPTH_STENCIL_DESC1( o ) + {} + explicit CD3DX12_DEPTH_STENCIL_DESC1( const D3D12_DEPTH_STENCIL_DESC& o ) + { + DepthEnable = o.DepthEnable; + DepthWriteMask = o.DepthWriteMask; + DepthFunc = o.DepthFunc; + StencilEnable = o.StencilEnable; + StencilReadMask = o.StencilReadMask; + StencilWriteMask = o.StencilWriteMask; + FrontFace.StencilFailOp = o.FrontFace.StencilFailOp; + FrontFace.StencilDepthFailOp = o.FrontFace.StencilDepthFailOp; + FrontFace.StencilPassOp = o.FrontFace.StencilPassOp; + FrontFace.StencilFunc = o.FrontFace.StencilFunc; + BackFace.StencilFailOp = o.BackFace.StencilFailOp; + BackFace.StencilDepthFailOp = o.BackFace.StencilDepthFailOp; + BackFace.StencilPassOp = o.BackFace.StencilPassOp; + BackFace.StencilFunc = o.BackFace.StencilFunc; + DepthBoundsTestEnable = FALSE; + } + explicit CD3DX12_DEPTH_STENCIL_DESC1( CD3DX12_DEFAULT ) + { + DepthEnable = TRUE; + DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL; + DepthFunc = D3D12_COMPARISON_FUNC_LESS; + StencilEnable = FALSE; + StencilReadMask = D3D12_DEFAULT_STENCIL_READ_MASK; + StencilWriteMask = D3D12_DEFAULT_STENCIL_WRITE_MASK; + const D3D12_DEPTH_STENCILOP_DESC defaultStencilOp = + { D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_COMPARISON_FUNC_ALWAYS }; + FrontFace = defaultStencilOp; + BackFace = defaultStencilOp; + DepthBoundsTestEnable = FALSE; + } + explicit CD3DX12_DEPTH_STENCIL_DESC1( + BOOL depthEnable, + D3D12_DEPTH_WRITE_MASK depthWriteMask, + D3D12_COMPARISON_FUNC depthFunc, + BOOL stencilEnable, + UINT8 stencilReadMask, + UINT8 stencilWriteMask, + D3D12_STENCIL_OP frontStencilFailOp, + D3D12_STENCIL_OP frontStencilDepthFailOp, + D3D12_STENCIL_OP frontStencilPassOp, + D3D12_COMPARISON_FUNC frontStencilFunc, + D3D12_STENCIL_OP backStencilFailOp, + D3D12_STENCIL_OP backStencilDepthFailOp, + D3D12_STENCIL_OP backStencilPassOp, + D3D12_COMPARISON_FUNC backStencilFunc, + BOOL depthBoundsTestEnable ) + { + DepthEnable = depthEnable; + DepthWriteMask = depthWriteMask; + DepthFunc = depthFunc; + StencilEnable = stencilEnable; + StencilReadMask = stencilReadMask; + StencilWriteMask = stencilWriteMask; + FrontFace.StencilFailOp = frontStencilFailOp; + FrontFace.StencilDepthFailOp = frontStencilDepthFailOp; + FrontFace.StencilPassOp = frontStencilPassOp; + FrontFace.StencilFunc = frontStencilFunc; + BackFace.StencilFailOp = backStencilFailOp; + BackFace.StencilDepthFailOp = backStencilDepthFailOp; + BackFace.StencilPassOp = backStencilPassOp; + BackFace.StencilFunc = backStencilFunc; + DepthBoundsTestEnable = depthBoundsTestEnable; + } + operator D3D12_DEPTH_STENCIL_DESC() const + { + D3D12_DEPTH_STENCIL_DESC D; + D.DepthEnable = DepthEnable; + D.DepthWriteMask = DepthWriteMask; + D.DepthFunc = DepthFunc; + D.StencilEnable = StencilEnable; + D.StencilReadMask = StencilReadMask; + D.StencilWriteMask = StencilWriteMask; + D.FrontFace.StencilFailOp = FrontFace.StencilFailOp; + D.FrontFace.StencilDepthFailOp = FrontFace.StencilDepthFailOp; + D.FrontFace.StencilPassOp = FrontFace.StencilPassOp; + D.FrontFace.StencilFunc = FrontFace.StencilFunc; + D.BackFace.StencilFailOp = BackFace.StencilFailOp; + D.BackFace.StencilDepthFailOp = BackFace.StencilDepthFailOp; + D.BackFace.StencilPassOp = BackFace.StencilPassOp; + D.BackFace.StencilFunc = BackFace.StencilFunc; + return D; + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_BLEND_DESC : public D3D12_BLEND_DESC +{ + CD3DX12_BLEND_DESC() = default; + explicit CD3DX12_BLEND_DESC( const D3D12_BLEND_DESC& o ) : + D3D12_BLEND_DESC( o ) + {} + explicit CD3DX12_BLEND_DESC( CD3DX12_DEFAULT ) + { + AlphaToCoverageEnable = FALSE; + IndependentBlendEnable = FALSE; + const D3D12_RENDER_TARGET_BLEND_DESC defaultRenderTargetBlendDesc = + { + FALSE,FALSE, + D3D12_BLEND_ONE, D3D12_BLEND_ZERO, D3D12_BLEND_OP_ADD, + D3D12_BLEND_ONE, D3D12_BLEND_ZERO, D3D12_BLEND_OP_ADD, + D3D12_LOGIC_OP_NOOP, + D3D12_COLOR_WRITE_ENABLE_ALL, + }; + for (UINT i = 0; i < D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i) + RenderTarget[ i ] = defaultRenderTargetBlendDesc; + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_RASTERIZER_DESC : public D3D12_RASTERIZER_DESC +{ + CD3DX12_RASTERIZER_DESC() = default; + explicit CD3DX12_RASTERIZER_DESC( const D3D12_RASTERIZER_DESC& o ) : + D3D12_RASTERIZER_DESC( o ) + {} + explicit CD3DX12_RASTERIZER_DESC( CD3DX12_DEFAULT ) + { + FillMode = D3D12_FILL_MODE_SOLID; + CullMode = D3D12_CULL_MODE_BACK; + FrontCounterClockwise = FALSE; + DepthBias = D3D12_DEFAULT_DEPTH_BIAS; + DepthBiasClamp = D3D12_DEFAULT_DEPTH_BIAS_CLAMP; + SlopeScaledDepthBias = D3D12_DEFAULT_SLOPE_SCALED_DEPTH_BIAS; + DepthClipEnable = TRUE; + MultisampleEnable = FALSE; + AntialiasedLineEnable = FALSE; + ForcedSampleCount = 0; + ConservativeRaster = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF; + } + explicit CD3DX12_RASTERIZER_DESC( + D3D12_FILL_MODE fillMode, + D3D12_CULL_MODE cullMode, + BOOL frontCounterClockwise, + INT depthBias, + FLOAT depthBiasClamp, + FLOAT slopeScaledDepthBias, + BOOL depthClipEnable, + BOOL multisampleEnable, + BOOL antialiasedLineEnable, + UINT forcedSampleCount, + D3D12_CONSERVATIVE_RASTERIZATION_MODE conservativeRaster) + { + FillMode = fillMode; + CullMode = cullMode; + FrontCounterClockwise = frontCounterClockwise; + DepthBias = depthBias; + DepthBiasClamp = depthBiasClamp; + SlopeScaledDepthBias = slopeScaledDepthBias; + DepthClipEnable = depthClipEnable; + MultisampleEnable = multisampleEnable; + AntialiasedLineEnable = antialiasedLineEnable; + ForcedSampleCount = forcedSampleCount; + ConservativeRaster = conservativeRaster; + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_RESOURCE_ALLOCATION_INFO : public D3D12_RESOURCE_ALLOCATION_INFO +{ + CD3DX12_RESOURCE_ALLOCATION_INFO() = default; + explicit CD3DX12_RESOURCE_ALLOCATION_INFO( const D3D12_RESOURCE_ALLOCATION_INFO& o ) : + D3D12_RESOURCE_ALLOCATION_INFO( o ) + {} + CD3DX12_RESOURCE_ALLOCATION_INFO( + UINT64 size, + UINT64 alignment ) + { + SizeInBytes = size; + Alignment = alignment; + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_HEAP_PROPERTIES : public D3D12_HEAP_PROPERTIES +{ + CD3DX12_HEAP_PROPERTIES() = default; + explicit CD3DX12_HEAP_PROPERTIES(const D3D12_HEAP_PROPERTIES &o) : + D3D12_HEAP_PROPERTIES(o) + {} + CD3DX12_HEAP_PROPERTIES( + D3D12_CPU_PAGE_PROPERTY cpuPageProperty, + D3D12_MEMORY_POOL memoryPoolPreference, + UINT creationNodeMask = 1, + UINT nodeMask = 1 ) + { + Type = D3D12_HEAP_TYPE_CUSTOM; + CPUPageProperty = cpuPageProperty; + MemoryPoolPreference = memoryPoolPreference; + CreationNodeMask = creationNodeMask; + VisibleNodeMask = nodeMask; + } + explicit CD3DX12_HEAP_PROPERTIES( + D3D12_HEAP_TYPE type, + UINT creationNodeMask = 1, + UINT nodeMask = 1 ) + { + Type = type; + CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN; + MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN; + CreationNodeMask = creationNodeMask; + VisibleNodeMask = nodeMask; + } + bool IsCPUAccessible() const + { + return Type == D3D12_HEAP_TYPE_UPLOAD || Type == D3D12_HEAP_TYPE_READBACK || (Type == D3D12_HEAP_TYPE_CUSTOM && + (CPUPageProperty == D3D12_CPU_PAGE_PROPERTY_WRITE_COMBINE || CPUPageProperty == D3D12_CPU_PAGE_PROPERTY_WRITE_BACK)); + } +}; +inline bool operator==( const D3D12_HEAP_PROPERTIES& l, const D3D12_HEAP_PROPERTIES& r ) +{ + return l.Type == r.Type && l.CPUPageProperty == r.CPUPageProperty && + l.MemoryPoolPreference == r.MemoryPoolPreference && + l.CreationNodeMask == r.CreationNodeMask && + l.VisibleNodeMask == r.VisibleNodeMask; +} +inline bool operator!=( const D3D12_HEAP_PROPERTIES& l, const D3D12_HEAP_PROPERTIES& r ) +{ return !( l == r ); } + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_HEAP_DESC : public D3D12_HEAP_DESC +{ + CD3DX12_HEAP_DESC() = default; + explicit CD3DX12_HEAP_DESC(const D3D12_HEAP_DESC &o) : + D3D12_HEAP_DESC(o) + {} + CD3DX12_HEAP_DESC( + UINT64 size, + D3D12_HEAP_PROPERTIES properties, + UINT64 alignment = 0, + D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) + { + SizeInBytes = size; + Properties = properties; + Alignment = alignment; + Flags = flags; + } + CD3DX12_HEAP_DESC( + UINT64 size, + D3D12_HEAP_TYPE type, + UINT64 alignment = 0, + D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) + { + SizeInBytes = size; + Properties = CD3DX12_HEAP_PROPERTIES( type ); + Alignment = alignment; + Flags = flags; + } + CD3DX12_HEAP_DESC( + UINT64 size, + D3D12_CPU_PAGE_PROPERTY cpuPageProperty, + D3D12_MEMORY_POOL memoryPoolPreference, + UINT64 alignment = 0, + D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) + { + SizeInBytes = size; + Properties = CD3DX12_HEAP_PROPERTIES( cpuPageProperty, memoryPoolPreference ); + Alignment = alignment; + Flags = flags; + } + CD3DX12_HEAP_DESC( + const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo, + D3D12_HEAP_PROPERTIES properties, + D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) + { + SizeInBytes = resAllocInfo.SizeInBytes; + Properties = properties; + Alignment = resAllocInfo.Alignment; + Flags = flags; + } + CD3DX12_HEAP_DESC( + const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo, + D3D12_HEAP_TYPE type, + D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) + { + SizeInBytes = resAllocInfo.SizeInBytes; + Properties = CD3DX12_HEAP_PROPERTIES( type ); + Alignment = resAllocInfo.Alignment; + Flags = flags; + } + CD3DX12_HEAP_DESC( + const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo, + D3D12_CPU_PAGE_PROPERTY cpuPageProperty, + D3D12_MEMORY_POOL memoryPoolPreference, + D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) + { + SizeInBytes = resAllocInfo.SizeInBytes; + Properties = CD3DX12_HEAP_PROPERTIES( cpuPageProperty, memoryPoolPreference ); + Alignment = resAllocInfo.Alignment; + Flags = flags; + } + bool IsCPUAccessible() const + { return static_cast< const CD3DX12_HEAP_PROPERTIES* >( &Properties )->IsCPUAccessible(); } +}; +inline bool operator==( const D3D12_HEAP_DESC& l, const D3D12_HEAP_DESC& r ) +{ + return l.SizeInBytes == r.SizeInBytes && + l.Properties == r.Properties && + l.Alignment == r.Alignment && + l.Flags == r.Flags; +} +inline bool operator!=( const D3D12_HEAP_DESC& l, const D3D12_HEAP_DESC& r ) +{ return !( l == r ); } + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_CLEAR_VALUE : public D3D12_CLEAR_VALUE +{ + CD3DX12_CLEAR_VALUE() = default; + explicit CD3DX12_CLEAR_VALUE(const D3D12_CLEAR_VALUE &o) : + D3D12_CLEAR_VALUE(o) + {} + CD3DX12_CLEAR_VALUE( + DXGI_FORMAT format, + const FLOAT color[4] ) + { + Format = format; + memcpy( Color, color, sizeof( Color ) ); + } + CD3DX12_CLEAR_VALUE( + DXGI_FORMAT format, + FLOAT depth, + UINT8 stencil ) + { + Format = format; + memset( &Color, 0, sizeof( Color ) ); + /* Use memcpy to preserve NAN values */ + memcpy( &DepthStencil.Depth, &depth, sizeof( depth ) ); + DepthStencil.Stencil = stencil; + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_RANGE : public D3D12_RANGE +{ + CD3DX12_RANGE() = default; + explicit CD3DX12_RANGE(const D3D12_RANGE &o) : + D3D12_RANGE(o) + {} + CD3DX12_RANGE( + SIZE_T begin, + SIZE_T end ) + { + Begin = begin; + End = end; + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_RANGE_UINT64 : public D3D12_RANGE_UINT64 +{ + CD3DX12_RANGE_UINT64() = default; + explicit CD3DX12_RANGE_UINT64(const D3D12_RANGE_UINT64 &o) : + D3D12_RANGE_UINT64(o) + {} + CD3DX12_RANGE_UINT64( + UINT64 begin, + UINT64 end ) + { + Begin = begin; + End = end; + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_SUBRESOURCE_RANGE_UINT64 : public D3D12_SUBRESOURCE_RANGE_UINT64 +{ + CD3DX12_SUBRESOURCE_RANGE_UINT64() = default; + explicit CD3DX12_SUBRESOURCE_RANGE_UINT64(const D3D12_SUBRESOURCE_RANGE_UINT64 &o) : + D3D12_SUBRESOURCE_RANGE_UINT64(o) + {} + CD3DX12_SUBRESOURCE_RANGE_UINT64( + UINT subresource, + const D3D12_RANGE_UINT64& range ) + { + Subresource = subresource; + Range = range; + } + CD3DX12_SUBRESOURCE_RANGE_UINT64( + UINT subresource, + UINT64 begin, + UINT64 end ) + { + Subresource = subresource; + Range.Begin = begin; + Range.End = end; + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_SHADER_BYTECODE : public D3D12_SHADER_BYTECODE +{ + CD3DX12_SHADER_BYTECODE() = default; + explicit CD3DX12_SHADER_BYTECODE(const D3D12_SHADER_BYTECODE &o) : + D3D12_SHADER_BYTECODE(o) + {} + CD3DX12_SHADER_BYTECODE( + _In_ ID3DBlob* pShaderBlob ) + { + pShaderBytecode = pShaderBlob->GetBufferPointer(); + BytecodeLength = pShaderBlob->GetBufferSize(); + } + CD3DX12_SHADER_BYTECODE( + const void* _pShaderBytecode, + SIZE_T bytecodeLength ) + { + pShaderBytecode = _pShaderBytecode; + BytecodeLength = bytecodeLength; + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_TILED_RESOURCE_COORDINATE : public D3D12_TILED_RESOURCE_COORDINATE +{ + CD3DX12_TILED_RESOURCE_COORDINATE() = default; + explicit CD3DX12_TILED_RESOURCE_COORDINATE(const D3D12_TILED_RESOURCE_COORDINATE &o) : + D3D12_TILED_RESOURCE_COORDINATE(o) + {} + CD3DX12_TILED_RESOURCE_COORDINATE( + UINT x, + UINT y, + UINT z, + UINT subresource ) + { + X = x; + Y = y; + Z = z; + Subresource = subresource; + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_TILE_REGION_SIZE : public D3D12_TILE_REGION_SIZE +{ + CD3DX12_TILE_REGION_SIZE() = default; + explicit CD3DX12_TILE_REGION_SIZE(const D3D12_TILE_REGION_SIZE &o) : + D3D12_TILE_REGION_SIZE(o) + {} + CD3DX12_TILE_REGION_SIZE( + UINT numTiles, + BOOL useBox, + UINT width, + UINT16 height, + UINT16 depth ) + { + NumTiles = numTiles; + UseBox = useBox; + Width = width; + Height = height; + Depth = depth; + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_SUBRESOURCE_TILING : public D3D12_SUBRESOURCE_TILING +{ + CD3DX12_SUBRESOURCE_TILING() = default; + explicit CD3DX12_SUBRESOURCE_TILING(const D3D12_SUBRESOURCE_TILING &o) : + D3D12_SUBRESOURCE_TILING(o) + {} + CD3DX12_SUBRESOURCE_TILING( + UINT widthInTiles, + UINT16 heightInTiles, + UINT16 depthInTiles, + UINT startTileIndexInOverallResource ) + { + WidthInTiles = widthInTiles; + HeightInTiles = heightInTiles; + DepthInTiles = depthInTiles; + StartTileIndexInOverallResource = startTileIndexInOverallResource; + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_TILE_SHAPE : public D3D12_TILE_SHAPE +{ + CD3DX12_TILE_SHAPE() = default; + explicit CD3DX12_TILE_SHAPE(const D3D12_TILE_SHAPE &o) : + D3D12_TILE_SHAPE(o) + {} + CD3DX12_TILE_SHAPE( + UINT widthInTexels, + UINT heightInTexels, + UINT depthInTexels ) + { + WidthInTexels = widthInTexels; + HeightInTexels = heightInTexels; + DepthInTexels = depthInTexels; + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_RESOURCE_BARRIER : public D3D12_RESOURCE_BARRIER +{ + CD3DX12_RESOURCE_BARRIER() = default; + explicit CD3DX12_RESOURCE_BARRIER(const D3D12_RESOURCE_BARRIER &o) : + D3D12_RESOURCE_BARRIER(o) + {} + static inline CD3DX12_RESOURCE_BARRIER Transition( + _In_ ID3D12Resource* pResource, + D3D12_RESOURCE_STATES stateBefore, + D3D12_RESOURCE_STATES stateAfter, + UINT subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES, + D3D12_RESOURCE_BARRIER_FLAGS flags = D3D12_RESOURCE_BARRIER_FLAG_NONE) + { + CD3DX12_RESOURCE_BARRIER result = {}; + D3D12_RESOURCE_BARRIER &barrier = result; + result.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION; + result.Flags = flags; + barrier.Transition.pResource = pResource; + barrier.Transition.StateBefore = stateBefore; + barrier.Transition.StateAfter = stateAfter; + barrier.Transition.Subresource = subresource; + return result; + } + static inline CD3DX12_RESOURCE_BARRIER Aliasing( + _In_ ID3D12Resource* pResourceBefore, + _In_ ID3D12Resource* pResourceAfter) + { + CD3DX12_RESOURCE_BARRIER result = {}; + D3D12_RESOURCE_BARRIER &barrier = result; + result.Type = D3D12_RESOURCE_BARRIER_TYPE_ALIASING; + barrier.Aliasing.pResourceBefore = pResourceBefore; + barrier.Aliasing.pResourceAfter = pResourceAfter; + return result; + } + static inline CD3DX12_RESOURCE_BARRIER UAV( + _In_ ID3D12Resource* pResource) + { + CD3DX12_RESOURCE_BARRIER result = {}; + D3D12_RESOURCE_BARRIER &barrier = result; + result.Type = D3D12_RESOURCE_BARRIER_TYPE_UAV; + barrier.UAV.pResource = pResource; + return result; + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_PACKED_MIP_INFO : public D3D12_PACKED_MIP_INFO +{ + CD3DX12_PACKED_MIP_INFO() = default; + explicit CD3DX12_PACKED_MIP_INFO(const D3D12_PACKED_MIP_INFO &o) : + D3D12_PACKED_MIP_INFO(o) + {} + CD3DX12_PACKED_MIP_INFO( + UINT8 numStandardMips, + UINT8 numPackedMips, + UINT numTilesForPackedMips, + UINT startTileIndexInOverallResource ) + { + NumStandardMips = numStandardMips; + NumPackedMips = numPackedMips; + NumTilesForPackedMips = numTilesForPackedMips; + StartTileIndexInOverallResource = startTileIndexInOverallResource; + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_SUBRESOURCE_FOOTPRINT : public D3D12_SUBRESOURCE_FOOTPRINT +{ + CD3DX12_SUBRESOURCE_FOOTPRINT() = default; + explicit CD3DX12_SUBRESOURCE_FOOTPRINT(const D3D12_SUBRESOURCE_FOOTPRINT &o) : + D3D12_SUBRESOURCE_FOOTPRINT(o) + {} + CD3DX12_SUBRESOURCE_FOOTPRINT( + DXGI_FORMAT format, + UINT width, + UINT height, + UINT depth, + UINT rowPitch ) + { + Format = format; + Width = width; + Height = height; + Depth = depth; + RowPitch = rowPitch; + } + explicit CD3DX12_SUBRESOURCE_FOOTPRINT( + const D3D12_RESOURCE_DESC& resDesc, + UINT rowPitch ) + { + Format = resDesc.Format; + Width = UINT( resDesc.Width ); + Height = resDesc.Height; + Depth = (resDesc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? resDesc.DepthOrArraySize : 1); + RowPitch = rowPitch; + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_TEXTURE_COPY_LOCATION : public D3D12_TEXTURE_COPY_LOCATION +{ + CD3DX12_TEXTURE_COPY_LOCATION() = default; + explicit CD3DX12_TEXTURE_COPY_LOCATION(const D3D12_TEXTURE_COPY_LOCATION &o) : + D3D12_TEXTURE_COPY_LOCATION(o) + {} + CD3DX12_TEXTURE_COPY_LOCATION(_In_ ID3D12Resource* pRes) + { + pResource = pRes; + Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX; + PlacedFootprint = {}; + } + CD3DX12_TEXTURE_COPY_LOCATION(_In_ ID3D12Resource* pRes, D3D12_PLACED_SUBRESOURCE_FOOTPRINT const& Footprint) + { + pResource = pRes; + Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT; + PlacedFootprint = Footprint; + } + CD3DX12_TEXTURE_COPY_LOCATION(_In_ ID3D12Resource* pRes, UINT Sub) + { + pResource = pRes; + Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX; + PlacedFootprint = {}; + SubresourceIndex = Sub; + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_DESCRIPTOR_RANGE : public D3D12_DESCRIPTOR_RANGE +{ + CD3DX12_DESCRIPTOR_RANGE() = default; + explicit CD3DX12_DESCRIPTOR_RANGE(const D3D12_DESCRIPTOR_RANGE &o) : + D3D12_DESCRIPTOR_RANGE(o) + {} + CD3DX12_DESCRIPTOR_RANGE( + D3D12_DESCRIPTOR_RANGE_TYPE rangeType, + UINT numDescriptors, + UINT baseShaderRegister, + UINT registerSpace = 0, + UINT offsetInDescriptorsFromTableStart = + D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) + { + Init(rangeType, numDescriptors, baseShaderRegister, registerSpace, offsetInDescriptorsFromTableStart); + } + + inline void Init( + D3D12_DESCRIPTOR_RANGE_TYPE rangeType, + UINT numDescriptors, + UINT baseShaderRegister, + UINT registerSpace = 0, + UINT offsetInDescriptorsFromTableStart = + D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) + { + Init(*this, rangeType, numDescriptors, baseShaderRegister, registerSpace, offsetInDescriptorsFromTableStart); + } + + static inline void Init( + _Out_ D3D12_DESCRIPTOR_RANGE &range, + D3D12_DESCRIPTOR_RANGE_TYPE rangeType, + UINT numDescriptors, + UINT baseShaderRegister, + UINT registerSpace = 0, + UINT offsetInDescriptorsFromTableStart = + D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) + { + range.RangeType = rangeType; + range.NumDescriptors = numDescriptors; + range.BaseShaderRegister = baseShaderRegister; + range.RegisterSpace = registerSpace; + range.OffsetInDescriptorsFromTableStart = offsetInDescriptorsFromTableStart; + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_ROOT_DESCRIPTOR_TABLE : public D3D12_ROOT_DESCRIPTOR_TABLE +{ + CD3DX12_ROOT_DESCRIPTOR_TABLE() = default; + explicit CD3DX12_ROOT_DESCRIPTOR_TABLE(const D3D12_ROOT_DESCRIPTOR_TABLE &o) : + D3D12_ROOT_DESCRIPTOR_TABLE(o) + {} + CD3DX12_ROOT_DESCRIPTOR_TABLE( + UINT numDescriptorRanges, + _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* _pDescriptorRanges) + { + Init(numDescriptorRanges, _pDescriptorRanges); + } + + inline void Init( + UINT numDescriptorRanges, + _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* _pDescriptorRanges) + { + Init(*this, numDescriptorRanges, _pDescriptorRanges); + } + + static inline void Init( + _Out_ D3D12_ROOT_DESCRIPTOR_TABLE &rootDescriptorTable, + UINT numDescriptorRanges, + _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* _pDescriptorRanges) + { + rootDescriptorTable.NumDescriptorRanges = numDescriptorRanges; + rootDescriptorTable.pDescriptorRanges = _pDescriptorRanges; + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_ROOT_CONSTANTS : public D3D12_ROOT_CONSTANTS +{ + CD3DX12_ROOT_CONSTANTS() = default; + explicit CD3DX12_ROOT_CONSTANTS(const D3D12_ROOT_CONSTANTS &o) : + D3D12_ROOT_CONSTANTS(o) + {} + CD3DX12_ROOT_CONSTANTS( + UINT num32BitValues, + UINT shaderRegister, + UINT registerSpace = 0) + { + Init(num32BitValues, shaderRegister, registerSpace); + } + + inline void Init( + UINT num32BitValues, + UINT shaderRegister, + UINT registerSpace = 0) + { + Init(*this, num32BitValues, shaderRegister, registerSpace); + } + + static inline void Init( + _Out_ D3D12_ROOT_CONSTANTS &rootConstants, + UINT num32BitValues, + UINT shaderRegister, + UINT registerSpace = 0) + { + rootConstants.Num32BitValues = num32BitValues; + rootConstants.ShaderRegister = shaderRegister; + rootConstants.RegisterSpace = registerSpace; + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_ROOT_DESCRIPTOR : public D3D12_ROOT_DESCRIPTOR +{ + CD3DX12_ROOT_DESCRIPTOR() = default; + explicit CD3DX12_ROOT_DESCRIPTOR(const D3D12_ROOT_DESCRIPTOR &o) : + D3D12_ROOT_DESCRIPTOR(o) + {} + CD3DX12_ROOT_DESCRIPTOR( + UINT shaderRegister, + UINT registerSpace = 0) + { + Init(shaderRegister, registerSpace); + } + + inline void Init( + UINT shaderRegister, + UINT registerSpace = 0) + { + Init(*this, shaderRegister, registerSpace); + } + + static inline void Init(_Out_ D3D12_ROOT_DESCRIPTOR &table, UINT shaderRegister, UINT registerSpace = 0) + { + table.ShaderRegister = shaderRegister; + table.RegisterSpace = registerSpace; + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_ROOT_PARAMETER : public D3D12_ROOT_PARAMETER +{ + CD3DX12_ROOT_PARAMETER() = default; + explicit CD3DX12_ROOT_PARAMETER(const D3D12_ROOT_PARAMETER &o) : + D3D12_ROOT_PARAMETER(o) + {} + + static inline void InitAsDescriptorTable( + _Out_ D3D12_ROOT_PARAMETER &rootParam, + UINT numDescriptorRanges, + _In_reads_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* pDescriptorRanges, + D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) + { + rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE; + rootParam.ShaderVisibility = visibility; + CD3DX12_ROOT_DESCRIPTOR_TABLE::Init(rootParam.DescriptorTable, numDescriptorRanges, pDescriptorRanges); + } + + static inline void InitAsConstants( + _Out_ D3D12_ROOT_PARAMETER &rootParam, + UINT num32BitValues, + UINT shaderRegister, + UINT registerSpace = 0, + D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) + { + rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS; + rootParam.ShaderVisibility = visibility; + CD3DX12_ROOT_CONSTANTS::Init(rootParam.Constants, num32BitValues, shaderRegister, registerSpace); + } + + static inline void InitAsConstantBufferView( + _Out_ D3D12_ROOT_PARAMETER &rootParam, + UINT shaderRegister, + UINT registerSpace = 0, + D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) + { + rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV; + rootParam.ShaderVisibility = visibility; + CD3DX12_ROOT_DESCRIPTOR::Init(rootParam.Descriptor, shaderRegister, registerSpace); + } + + static inline void InitAsShaderResourceView( + _Out_ D3D12_ROOT_PARAMETER &rootParam, + UINT shaderRegister, + UINT registerSpace = 0, + D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) + { + rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_SRV; + rootParam.ShaderVisibility = visibility; + CD3DX12_ROOT_DESCRIPTOR::Init(rootParam.Descriptor, shaderRegister, registerSpace); + } + + static inline void InitAsUnorderedAccessView( + _Out_ D3D12_ROOT_PARAMETER &rootParam, + UINT shaderRegister, + UINT registerSpace = 0, + D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) + { + rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_UAV; + rootParam.ShaderVisibility = visibility; + CD3DX12_ROOT_DESCRIPTOR::Init(rootParam.Descriptor, shaderRegister, registerSpace); + } + + inline void InitAsDescriptorTable( + UINT numDescriptorRanges, + _In_reads_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* pDescriptorRanges, + D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) + { + InitAsDescriptorTable(*this, numDescriptorRanges, pDescriptorRanges, visibility); + } + + inline void InitAsConstants( + UINT num32BitValues, + UINT shaderRegister, + UINT registerSpace = 0, + D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) + { + InitAsConstants(*this, num32BitValues, shaderRegister, registerSpace, visibility); + } + + inline void InitAsConstantBufferView( + UINT shaderRegister, + UINT registerSpace = 0, + D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) + { + InitAsConstantBufferView(*this, shaderRegister, registerSpace, visibility); + } + + inline void InitAsShaderResourceView( + UINT shaderRegister, + UINT registerSpace = 0, + D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) + { + InitAsShaderResourceView(*this, shaderRegister, registerSpace, visibility); + } + + inline void InitAsUnorderedAccessView( + UINT shaderRegister, + UINT registerSpace = 0, + D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) + { + InitAsUnorderedAccessView(*this, shaderRegister, registerSpace, visibility); + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_STATIC_SAMPLER_DESC : public D3D12_STATIC_SAMPLER_DESC +{ + CD3DX12_STATIC_SAMPLER_DESC() = default; + explicit CD3DX12_STATIC_SAMPLER_DESC(const D3D12_STATIC_SAMPLER_DESC &o) : + D3D12_STATIC_SAMPLER_DESC(o) + {} + CD3DX12_STATIC_SAMPLER_DESC( + UINT shaderRegister, + D3D12_FILTER filter = D3D12_FILTER_ANISOTROPIC, + D3D12_TEXTURE_ADDRESS_MODE addressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP, + D3D12_TEXTURE_ADDRESS_MODE addressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP, + D3D12_TEXTURE_ADDRESS_MODE addressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP, + FLOAT mipLODBias = 0, + UINT maxAnisotropy = 16, + D3D12_COMPARISON_FUNC comparisonFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL, + D3D12_STATIC_BORDER_COLOR borderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE, + FLOAT minLOD = 0.f, + FLOAT maxLOD = D3D12_FLOAT32_MAX, + D3D12_SHADER_VISIBILITY shaderVisibility = D3D12_SHADER_VISIBILITY_ALL, + UINT registerSpace = 0) + { + Init( + shaderRegister, + filter, + addressU, + addressV, + addressW, + mipLODBias, + maxAnisotropy, + comparisonFunc, + borderColor, + minLOD, + maxLOD, + shaderVisibility, + registerSpace); + } + + static inline void Init( + _Out_ D3D12_STATIC_SAMPLER_DESC &samplerDesc, + UINT shaderRegister, + D3D12_FILTER filter = D3D12_FILTER_ANISOTROPIC, + D3D12_TEXTURE_ADDRESS_MODE addressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP, + D3D12_TEXTURE_ADDRESS_MODE addressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP, + D3D12_TEXTURE_ADDRESS_MODE addressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP, + FLOAT mipLODBias = 0, + UINT maxAnisotropy = 16, + D3D12_COMPARISON_FUNC comparisonFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL, + D3D12_STATIC_BORDER_COLOR borderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE, + FLOAT minLOD = 0.f, + FLOAT maxLOD = D3D12_FLOAT32_MAX, + D3D12_SHADER_VISIBILITY shaderVisibility = D3D12_SHADER_VISIBILITY_ALL, + UINT registerSpace = 0) + { + samplerDesc.ShaderRegister = shaderRegister; + samplerDesc.Filter = filter; + samplerDesc.AddressU = addressU; + samplerDesc.AddressV = addressV; + samplerDesc.AddressW = addressW; + samplerDesc.MipLODBias = mipLODBias; + samplerDesc.MaxAnisotropy = maxAnisotropy; + samplerDesc.ComparisonFunc = comparisonFunc; + samplerDesc.BorderColor = borderColor; + samplerDesc.MinLOD = minLOD; + samplerDesc.MaxLOD = maxLOD; + samplerDesc.ShaderVisibility = shaderVisibility; + samplerDesc.RegisterSpace = registerSpace; + } + inline void Init( + UINT shaderRegister, + D3D12_FILTER filter = D3D12_FILTER_ANISOTROPIC, + D3D12_TEXTURE_ADDRESS_MODE addressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP, + D3D12_TEXTURE_ADDRESS_MODE addressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP, + D3D12_TEXTURE_ADDRESS_MODE addressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP, + FLOAT mipLODBias = 0, + UINT maxAnisotropy = 16, + D3D12_COMPARISON_FUNC comparisonFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL, + D3D12_STATIC_BORDER_COLOR borderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE, + FLOAT minLOD = 0.f, + FLOAT maxLOD = D3D12_FLOAT32_MAX, + D3D12_SHADER_VISIBILITY shaderVisibility = D3D12_SHADER_VISIBILITY_ALL, + UINT registerSpace = 0) + { + Init( + *this, + shaderRegister, + filter, + addressU, + addressV, + addressW, + mipLODBias, + maxAnisotropy, + comparisonFunc, + borderColor, + minLOD, + maxLOD, + shaderVisibility, + registerSpace); + } + +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_ROOT_SIGNATURE_DESC : public D3D12_ROOT_SIGNATURE_DESC +{ + CD3DX12_ROOT_SIGNATURE_DESC() = default; + explicit CD3DX12_ROOT_SIGNATURE_DESC(const D3D12_ROOT_SIGNATURE_DESC &o) : + D3D12_ROOT_SIGNATURE_DESC(o) + {} + CD3DX12_ROOT_SIGNATURE_DESC( + UINT numParameters, + _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters, + UINT numStaticSamplers = 0, + _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr, + D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) + { + Init(numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags); + } + CD3DX12_ROOT_SIGNATURE_DESC(CD3DX12_DEFAULT) + { + Init(0, nullptr, 0, nullptr, D3D12_ROOT_SIGNATURE_FLAG_NONE); + } + + inline void Init( + UINT numParameters, + _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters, + UINT numStaticSamplers = 0, + _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr, + D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) + { + Init(*this, numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags); + } + + static inline void Init( + _Out_ D3D12_ROOT_SIGNATURE_DESC &desc, + UINT numParameters, + _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters, + UINT numStaticSamplers = 0, + _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr, + D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) + { + desc.NumParameters = numParameters; + desc.pParameters = _pParameters; + desc.NumStaticSamplers = numStaticSamplers; + desc.pStaticSamplers = _pStaticSamplers; + desc.Flags = flags; + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_DESCRIPTOR_RANGE1 : public D3D12_DESCRIPTOR_RANGE1 +{ + CD3DX12_DESCRIPTOR_RANGE1() = default; + explicit CD3DX12_DESCRIPTOR_RANGE1(const D3D12_DESCRIPTOR_RANGE1 &o) : + D3D12_DESCRIPTOR_RANGE1(o) + {} + CD3DX12_DESCRIPTOR_RANGE1( + D3D12_DESCRIPTOR_RANGE_TYPE rangeType, + UINT numDescriptors, + UINT baseShaderRegister, + UINT registerSpace = 0, + D3D12_DESCRIPTOR_RANGE_FLAGS flags = D3D12_DESCRIPTOR_RANGE_FLAG_NONE, + UINT offsetInDescriptorsFromTableStart = + D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) + { + Init(rangeType, numDescriptors, baseShaderRegister, registerSpace, flags, offsetInDescriptorsFromTableStart); + } + + inline void Init( + D3D12_DESCRIPTOR_RANGE_TYPE rangeType, + UINT numDescriptors, + UINT baseShaderRegister, + UINT registerSpace = 0, + D3D12_DESCRIPTOR_RANGE_FLAGS flags = D3D12_DESCRIPTOR_RANGE_FLAG_NONE, + UINT offsetInDescriptorsFromTableStart = + D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) + { + Init(*this, rangeType, numDescriptors, baseShaderRegister, registerSpace, flags, offsetInDescriptorsFromTableStart); + } + + static inline void Init( + _Out_ D3D12_DESCRIPTOR_RANGE1 &range, + D3D12_DESCRIPTOR_RANGE_TYPE rangeType, + UINT numDescriptors, + UINT baseShaderRegister, + UINT registerSpace = 0, + D3D12_DESCRIPTOR_RANGE_FLAGS flags = D3D12_DESCRIPTOR_RANGE_FLAG_NONE, + UINT offsetInDescriptorsFromTableStart = + D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) + { + range.RangeType = rangeType; + range.NumDescriptors = numDescriptors; + range.BaseShaderRegister = baseShaderRegister; + range.RegisterSpace = registerSpace; + range.Flags = flags; + range.OffsetInDescriptorsFromTableStart = offsetInDescriptorsFromTableStart; + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_ROOT_DESCRIPTOR_TABLE1 : public D3D12_ROOT_DESCRIPTOR_TABLE1 +{ + CD3DX12_ROOT_DESCRIPTOR_TABLE1() = default; + explicit CD3DX12_ROOT_DESCRIPTOR_TABLE1(const D3D12_ROOT_DESCRIPTOR_TABLE1 &o) : + D3D12_ROOT_DESCRIPTOR_TABLE1(o) + {} + CD3DX12_ROOT_DESCRIPTOR_TABLE1( + UINT numDescriptorRanges, + _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1* _pDescriptorRanges) + { + Init(numDescriptorRanges, _pDescriptorRanges); + } + + inline void Init( + UINT numDescriptorRanges, + _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1* _pDescriptorRanges) + { + Init(*this, numDescriptorRanges, _pDescriptorRanges); + } + + static inline void Init( + _Out_ D3D12_ROOT_DESCRIPTOR_TABLE1 &rootDescriptorTable, + UINT numDescriptorRanges, + _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1* _pDescriptorRanges) + { + rootDescriptorTable.NumDescriptorRanges = numDescriptorRanges; + rootDescriptorTable.pDescriptorRanges = _pDescriptorRanges; + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_ROOT_DESCRIPTOR1 : public D3D12_ROOT_DESCRIPTOR1 +{ + CD3DX12_ROOT_DESCRIPTOR1() = default; + explicit CD3DX12_ROOT_DESCRIPTOR1(const D3D12_ROOT_DESCRIPTOR1 &o) : + D3D12_ROOT_DESCRIPTOR1(o) + {} + CD3DX12_ROOT_DESCRIPTOR1( + UINT shaderRegister, + UINT registerSpace = 0, + D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE) + { + Init(shaderRegister, registerSpace, flags); + } + + inline void Init( + UINT shaderRegister, + UINT registerSpace = 0, + D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE) + { + Init(*this, shaderRegister, registerSpace, flags); + } + + static inline void Init( + _Out_ D3D12_ROOT_DESCRIPTOR1 &table, + UINT shaderRegister, + UINT registerSpace = 0, + D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE) + { + table.ShaderRegister = shaderRegister; + table.RegisterSpace = registerSpace; + table.Flags = flags; + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_ROOT_PARAMETER1 : public D3D12_ROOT_PARAMETER1 +{ + CD3DX12_ROOT_PARAMETER1() = default; + explicit CD3DX12_ROOT_PARAMETER1(const D3D12_ROOT_PARAMETER1 &o) : + D3D12_ROOT_PARAMETER1(o) + {} + + static inline void InitAsDescriptorTable( + _Out_ D3D12_ROOT_PARAMETER1 &rootParam, + UINT numDescriptorRanges, + _In_reads_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1* pDescriptorRanges, + D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) + { + rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE; + rootParam.ShaderVisibility = visibility; + CD3DX12_ROOT_DESCRIPTOR_TABLE1::Init(rootParam.DescriptorTable, numDescriptorRanges, pDescriptorRanges); + } + + static inline void InitAsConstants( + _Out_ D3D12_ROOT_PARAMETER1 &rootParam, + UINT num32BitValues, + UINT shaderRegister, + UINT registerSpace = 0, + D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) + { + rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS; + rootParam.ShaderVisibility = visibility; + CD3DX12_ROOT_CONSTANTS::Init(rootParam.Constants, num32BitValues, shaderRegister, registerSpace); + } + + static inline void InitAsConstantBufferView( + _Out_ D3D12_ROOT_PARAMETER1 &rootParam, + UINT shaderRegister, + UINT registerSpace = 0, + D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE, + D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) + { + rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV; + rootParam.ShaderVisibility = visibility; + CD3DX12_ROOT_DESCRIPTOR1::Init(rootParam.Descriptor, shaderRegister, registerSpace, flags); + } + + static inline void InitAsShaderResourceView( + _Out_ D3D12_ROOT_PARAMETER1 &rootParam, + UINT shaderRegister, + UINT registerSpace = 0, + D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE, + D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) + { + rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_SRV; + rootParam.ShaderVisibility = visibility; + CD3DX12_ROOT_DESCRIPTOR1::Init(rootParam.Descriptor, shaderRegister, registerSpace, flags); + } + + static inline void InitAsUnorderedAccessView( + _Out_ D3D12_ROOT_PARAMETER1 &rootParam, + UINT shaderRegister, + UINT registerSpace = 0, + D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE, + D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) + { + rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_UAV; + rootParam.ShaderVisibility = visibility; + CD3DX12_ROOT_DESCRIPTOR1::Init(rootParam.Descriptor, shaderRegister, registerSpace, flags); + } + + inline void InitAsDescriptorTable( + UINT numDescriptorRanges, + _In_reads_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1* pDescriptorRanges, + D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) + { + InitAsDescriptorTable(*this, numDescriptorRanges, pDescriptorRanges, visibility); + } + + inline void InitAsConstants( + UINT num32BitValues, + UINT shaderRegister, + UINT registerSpace = 0, + D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) + { + InitAsConstants(*this, num32BitValues, shaderRegister, registerSpace, visibility); + } + + inline void InitAsConstantBufferView( + UINT shaderRegister, + UINT registerSpace = 0, + D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE, + D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) + { + InitAsConstantBufferView(*this, shaderRegister, registerSpace, flags, visibility); + } + + inline void InitAsShaderResourceView( + UINT shaderRegister, + UINT registerSpace = 0, + D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE, + D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) + { + InitAsShaderResourceView(*this, shaderRegister, registerSpace, flags, visibility); + } + + inline void InitAsUnorderedAccessView( + UINT shaderRegister, + UINT registerSpace = 0, + D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE, + D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) + { + InitAsUnorderedAccessView(*this, shaderRegister, registerSpace, flags, visibility); + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC : public D3D12_VERSIONED_ROOT_SIGNATURE_DESC +{ + CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC() = default; + explicit CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(const D3D12_VERSIONED_ROOT_SIGNATURE_DESC &o) : + D3D12_VERSIONED_ROOT_SIGNATURE_DESC(o) + {} + explicit CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(const D3D12_ROOT_SIGNATURE_DESC &o) + { + Version = D3D_ROOT_SIGNATURE_VERSION_1_0; + Desc_1_0 = o; + } + explicit CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(const D3D12_ROOT_SIGNATURE_DESC1 &o) + { + Version = D3D_ROOT_SIGNATURE_VERSION_1_1; + Desc_1_1 = o; + } + CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC( + UINT numParameters, + _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters, + UINT numStaticSamplers = 0, + _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr, + D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) + { + Init_1_0(numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags); + } + CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC( + UINT numParameters, + _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER1* _pParameters, + UINT numStaticSamplers = 0, + _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr, + D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) + { + Init_1_1(numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags); + } + CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(CD3DX12_DEFAULT) + { + Init_1_1(0, nullptr, 0, nullptr, D3D12_ROOT_SIGNATURE_FLAG_NONE); + } + + inline void Init_1_0( + UINT numParameters, + _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters, + UINT numStaticSamplers = 0, + _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr, + D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) + { + Init_1_0(*this, numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags); + } + + static inline void Init_1_0( + _Out_ D3D12_VERSIONED_ROOT_SIGNATURE_DESC &desc, + UINT numParameters, + _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters, + UINT numStaticSamplers = 0, + _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr, + D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) + { + desc.Version = D3D_ROOT_SIGNATURE_VERSION_1_0; + desc.Desc_1_0.NumParameters = numParameters; + desc.Desc_1_0.pParameters = _pParameters; + desc.Desc_1_0.NumStaticSamplers = numStaticSamplers; + desc.Desc_1_0.pStaticSamplers = _pStaticSamplers; + desc.Desc_1_0.Flags = flags; + } + + inline void Init_1_1( + UINT numParameters, + _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER1* _pParameters, + UINT numStaticSamplers = 0, + _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr, + D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) + { + Init_1_1(*this, numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags); + } + + static inline void Init_1_1( + _Out_ D3D12_VERSIONED_ROOT_SIGNATURE_DESC &desc, + UINT numParameters, + _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER1* _pParameters, + UINT numStaticSamplers = 0, + _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr, + D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) + { + desc.Version = D3D_ROOT_SIGNATURE_VERSION_1_1; + desc.Desc_1_1.NumParameters = numParameters; + desc.Desc_1_1.pParameters = _pParameters; + desc.Desc_1_1.NumStaticSamplers = numStaticSamplers; + desc.Desc_1_1.pStaticSamplers = _pStaticSamplers; + desc.Desc_1_1.Flags = flags; + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_CPU_DESCRIPTOR_HANDLE : public D3D12_CPU_DESCRIPTOR_HANDLE +{ + CD3DX12_CPU_DESCRIPTOR_HANDLE() = default; + explicit CD3DX12_CPU_DESCRIPTOR_HANDLE(const D3D12_CPU_DESCRIPTOR_HANDLE &o) : + D3D12_CPU_DESCRIPTOR_HANDLE(o) + {} + CD3DX12_CPU_DESCRIPTOR_HANDLE(CD3DX12_DEFAULT) { ptr = 0; } + CD3DX12_CPU_DESCRIPTOR_HANDLE(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &other, INT offsetScaledByIncrementSize) + { + InitOffsetted(other, offsetScaledByIncrementSize); + } + CD3DX12_CPU_DESCRIPTOR_HANDLE(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &other, INT offsetInDescriptors, UINT descriptorIncrementSize) + { + InitOffsetted(other, offsetInDescriptors, descriptorIncrementSize); + } + CD3DX12_CPU_DESCRIPTOR_HANDLE& Offset(INT offsetInDescriptors, UINT descriptorIncrementSize) + { + ptr = SIZE_T(INT64(ptr) + INT64(offsetInDescriptors) * INT64(descriptorIncrementSize)); + return *this; + } + CD3DX12_CPU_DESCRIPTOR_HANDLE& Offset(INT offsetScaledByIncrementSize) + { + ptr = SIZE_T(INT64(ptr) + INT64(offsetScaledByIncrementSize)); + return *this; + } + bool operator==(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE& other) const + { + return (ptr == other.ptr); + } + bool operator!=(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE& other) const + { + return (ptr != other.ptr); + } + CD3DX12_CPU_DESCRIPTOR_HANDLE &operator=(const D3D12_CPU_DESCRIPTOR_HANDLE &other) + { + ptr = other.ptr; + return *this; + } + + inline void InitOffsetted(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base, INT offsetScaledByIncrementSize) + { + InitOffsetted(*this, base, offsetScaledByIncrementSize); + } + + inline void InitOffsetted(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base, INT offsetInDescriptors, UINT descriptorIncrementSize) + { + InitOffsetted(*this, base, offsetInDescriptors, descriptorIncrementSize); + } + + static inline void InitOffsetted(_Out_ D3D12_CPU_DESCRIPTOR_HANDLE &handle, _In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base, INT offsetScaledByIncrementSize) + { + handle.ptr = SIZE_T(INT64(base.ptr) + INT64(offsetScaledByIncrementSize)); + } + + static inline void InitOffsetted(_Out_ D3D12_CPU_DESCRIPTOR_HANDLE &handle, _In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base, INT offsetInDescriptors, UINT descriptorIncrementSize) + { + handle.ptr = SIZE_T(INT64(base.ptr) + INT64(offsetInDescriptors) * INT64(descriptorIncrementSize)); + } +}; + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_GPU_DESCRIPTOR_HANDLE : public D3D12_GPU_DESCRIPTOR_HANDLE +{ + CD3DX12_GPU_DESCRIPTOR_HANDLE() = default; + explicit CD3DX12_GPU_DESCRIPTOR_HANDLE(const D3D12_GPU_DESCRIPTOR_HANDLE &o) : + D3D12_GPU_DESCRIPTOR_HANDLE(o) + {} + CD3DX12_GPU_DESCRIPTOR_HANDLE(CD3DX12_DEFAULT) { ptr = 0; } + CD3DX12_GPU_DESCRIPTOR_HANDLE(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &other, INT offsetScaledByIncrementSize) + { + InitOffsetted(other, offsetScaledByIncrementSize); + } + CD3DX12_GPU_DESCRIPTOR_HANDLE(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &other, INT offsetInDescriptors, UINT descriptorIncrementSize) + { + InitOffsetted(other, offsetInDescriptors, descriptorIncrementSize); + } + CD3DX12_GPU_DESCRIPTOR_HANDLE& Offset(INT offsetInDescriptors, UINT descriptorIncrementSize) + { + ptr = UINT64(INT64(ptr) + INT64(offsetInDescriptors) * INT64(descriptorIncrementSize)); + return *this; + } + CD3DX12_GPU_DESCRIPTOR_HANDLE& Offset(INT offsetScaledByIncrementSize) + { + ptr = UINT64(INT64(ptr) + INT64(offsetScaledByIncrementSize)); + return *this; + } + inline bool operator==(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE& other) const + { + return (ptr == other.ptr); + } + inline bool operator!=(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE& other) const + { + return (ptr != other.ptr); + } + CD3DX12_GPU_DESCRIPTOR_HANDLE &operator=(const D3D12_GPU_DESCRIPTOR_HANDLE &other) + { + ptr = other.ptr; + return *this; + } + + inline void InitOffsetted(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base, INT offsetScaledByIncrementSize) + { + InitOffsetted(*this, base, offsetScaledByIncrementSize); + } + + inline void InitOffsetted(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base, INT offsetInDescriptors, UINT descriptorIncrementSize) + { + InitOffsetted(*this, base, offsetInDescriptors, descriptorIncrementSize); + } + + static inline void InitOffsetted(_Out_ D3D12_GPU_DESCRIPTOR_HANDLE &handle, _In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base, INT offsetScaledByIncrementSize) + { + handle.ptr = UINT64(INT64(base.ptr) + INT64(offsetScaledByIncrementSize)); + } + + static inline void InitOffsetted(_Out_ D3D12_GPU_DESCRIPTOR_HANDLE &handle, _In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base, INT offsetInDescriptors, UINT descriptorIncrementSize) + { + handle.ptr = UINT64(INT64(base.ptr) + INT64(offsetInDescriptors) * INT64(descriptorIncrementSize)); + } +}; + +//------------------------------------------------------------------------------------------------ +inline UINT D3D12CalcSubresource( UINT MipSlice, UINT ArraySlice, UINT PlaneSlice, UINT MipLevels, UINT ArraySize ) +{ + return MipSlice + ArraySlice * MipLevels + PlaneSlice * MipLevels * ArraySize; +} + +//------------------------------------------------------------------------------------------------ +template +inline void D3D12DecomposeSubresource( UINT Subresource, UINT MipLevels, UINT ArraySize, _Out_ T& MipSlice, _Out_ U& ArraySlice, _Out_ V& PlaneSlice ) +{ + MipSlice = static_cast(Subresource % MipLevels); + ArraySlice = static_cast((Subresource / MipLevels) % ArraySize); + PlaneSlice = static_cast(Subresource / (MipLevels * ArraySize)); +} + +//------------------------------------------------------------------------------------------------ +inline UINT8 D3D12GetFormatPlaneCount( + _In_ ID3D12Device* pDevice, + DXGI_FORMAT Format + ) +{ + D3D12_FEATURE_DATA_FORMAT_INFO formatInfo = { Format, 0 }; + if (FAILED(pDevice->CheckFeatureSupport(D3D12_FEATURE_FORMAT_INFO, &formatInfo, sizeof(formatInfo)))) + { + return 0; + } + return formatInfo.PlaneCount; +} + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_RESOURCE_DESC : public D3D12_RESOURCE_DESC +{ + CD3DX12_RESOURCE_DESC() = default; + explicit CD3DX12_RESOURCE_DESC( const D3D12_RESOURCE_DESC& o ) : + D3D12_RESOURCE_DESC( o ) + {} + CD3DX12_RESOURCE_DESC( + D3D12_RESOURCE_DIMENSION dimension, + UINT64 alignment, + UINT64 width, + UINT height, + UINT16 depthOrArraySize, + UINT16 mipLevels, + DXGI_FORMAT format, + UINT sampleCount, + UINT sampleQuality, + D3D12_TEXTURE_LAYOUT layout, + D3D12_RESOURCE_FLAGS flags ) + { + Dimension = dimension; + Alignment = alignment; + Width = width; + Height = height; + DepthOrArraySize = depthOrArraySize; + MipLevels = mipLevels; + Format = format; + SampleDesc.Count = sampleCount; + SampleDesc.Quality = sampleQuality; + Layout = layout; + Flags = flags; + } + static inline CD3DX12_RESOURCE_DESC Buffer( + const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo, + D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE ) + { + return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_BUFFER, resAllocInfo.Alignment, resAllocInfo.SizeInBytes, + 1, 1, 1, DXGI_FORMAT_UNKNOWN, 1, 0, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, flags ); + } + static inline CD3DX12_RESOURCE_DESC Buffer( + UINT64 width, + D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE, + UINT64 alignment = 0 ) + { + return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_BUFFER, alignment, width, 1, 1, 1, + DXGI_FORMAT_UNKNOWN, 1, 0, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, flags ); + } + static inline CD3DX12_RESOURCE_DESC Tex1D( + DXGI_FORMAT format, + UINT64 width, + UINT16 arraySize = 1, + UINT16 mipLevels = 0, + D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE, + D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN, + UINT64 alignment = 0 ) + { + return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_TEXTURE1D, alignment, width, 1, arraySize, + mipLevels, format, 1, 0, layout, flags ); + } + static inline CD3DX12_RESOURCE_DESC Tex2D( + DXGI_FORMAT format, + UINT64 width, + UINT height, + UINT16 arraySize = 1, + UINT16 mipLevels = 0, + UINT sampleCount = 1, + UINT sampleQuality = 0, + D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE, + D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN, + UINT64 alignment = 0 ) + { + return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_TEXTURE2D, alignment, width, height, arraySize, + mipLevels, format, sampleCount, sampleQuality, layout, flags ); + } + static inline CD3DX12_RESOURCE_DESC Tex3D( + DXGI_FORMAT format, + UINT64 width, + UINT height, + UINT16 depth, + UINT16 mipLevels = 0, + D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE, + D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN, + UINT64 alignment = 0 ) + { + return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_TEXTURE3D, alignment, width, height, depth, + mipLevels, format, 1, 0, layout, flags ); + } + inline UINT16 Depth() const + { return (Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? DepthOrArraySize : 1); } + inline UINT16 ArraySize() const + { return (Dimension != D3D12_RESOURCE_DIMENSION_TEXTURE3D ? DepthOrArraySize : 1); } + inline UINT8 PlaneCount(_In_ ID3D12Device* pDevice) const + { return D3D12GetFormatPlaneCount(pDevice, Format); } + inline UINT Subresources(_In_ ID3D12Device* pDevice) const + { return MipLevels * ArraySize() * PlaneCount(pDevice); } + inline UINT CalcSubresource(UINT MipSlice, UINT ArraySlice, UINT PlaneSlice) + { return D3D12CalcSubresource(MipSlice, ArraySlice, PlaneSlice, MipLevels, ArraySize()); } +}; +inline bool operator==( const D3D12_RESOURCE_DESC& l, const D3D12_RESOURCE_DESC& r ) +{ + return l.Dimension == r.Dimension && + l.Alignment == r.Alignment && + l.Width == r.Width && + l.Height == r.Height && + l.DepthOrArraySize == r.DepthOrArraySize && + l.MipLevels == r.MipLevels && + l.Format == r.Format && + l.SampleDesc.Count == r.SampleDesc.Count && + l.SampleDesc.Quality == r.SampleDesc.Quality && + l.Layout == r.Layout && + l.Flags == r.Flags; +} +inline bool operator!=( const D3D12_RESOURCE_DESC& l, const D3D12_RESOURCE_DESC& r ) +{ return !( l == r ); } + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_VIEW_INSTANCING_DESC : public D3D12_VIEW_INSTANCING_DESC +{ + CD3DX12_VIEW_INSTANCING_DESC() = default; + explicit CD3DX12_VIEW_INSTANCING_DESC( const D3D12_VIEW_INSTANCING_DESC& o ) : + D3D12_VIEW_INSTANCING_DESC( o ) + {} + explicit CD3DX12_VIEW_INSTANCING_DESC( CD3DX12_DEFAULT ) + { + ViewInstanceCount = 0; + pViewInstanceLocations = nullptr; + Flags = D3D12_VIEW_INSTANCING_FLAG_NONE; + } + explicit CD3DX12_VIEW_INSTANCING_DESC( + UINT InViewInstanceCount, + const D3D12_VIEW_INSTANCE_LOCATION* InViewInstanceLocations, + D3D12_VIEW_INSTANCING_FLAGS InFlags) + { + ViewInstanceCount = InViewInstanceCount; + pViewInstanceLocations = InViewInstanceLocations; + Flags = InFlags; + } +}; + +//------------------------------------------------------------------------------------------------ +// Row-by-row memcpy +inline void MemcpySubresource( + _In_ const D3D12_MEMCPY_DEST* pDest, + _In_ const D3D12_SUBRESOURCE_DATA* pSrc, + SIZE_T RowSizeInBytes, + UINT NumRows, + UINT NumSlices) +{ + for (UINT z = 0; z < NumSlices; ++z) + { + auto pDestSlice = reinterpret_cast(pDest->pData) + pDest->SlicePitch * z; + auto pSrcSlice = reinterpret_cast(pSrc->pData) + pSrc->SlicePitch * LONG_PTR(z); + for (UINT y = 0; y < NumRows; ++y) + { + memcpy(pDestSlice + pDest->RowPitch * y, + pSrcSlice + pSrc->RowPitch * LONG_PTR(y), + RowSizeInBytes); + } + } +} + +//------------------------------------------------------------------------------------------------ +// Returns required size of a buffer to be used for data upload +inline UINT64 GetRequiredIntermediateSize( + _In_ ID3D12Resource* pDestinationResource, + _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, + _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources) +{ + auto Desc = pDestinationResource->GetDesc(); + UINT64 RequiredSize = 0; + + ID3D12Device* pDevice = nullptr; + pDestinationResource->GetDevice(IID_ID3D12Device, reinterpret_cast(&pDevice)); + pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources, 0, nullptr, nullptr, nullptr, &RequiredSize); + pDevice->Release(); + + return RequiredSize; +} + +//------------------------------------------------------------------------------------------------ +// All arrays must be populated (e.g. by calling GetCopyableFootprints) +inline UINT64 UpdateSubresources( + _In_ ID3D12GraphicsCommandList* pCmdList, + _In_ ID3D12Resource* pDestinationResource, + _In_ ID3D12Resource* pIntermediate, + _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, + _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, + UINT64 RequiredSize, + _In_reads_(NumSubresources) const D3D12_PLACED_SUBRESOURCE_FOOTPRINT* pLayouts, + _In_reads_(NumSubresources) const UINT* pNumRows, + _In_reads_(NumSubresources) const UINT64* pRowSizesInBytes, + _In_reads_(NumSubresources) const D3D12_SUBRESOURCE_DATA* pSrcData) +{ + // Minor validation + auto IntermediateDesc = pIntermediate->GetDesc(); + auto DestinationDesc = pDestinationResource->GetDesc(); + if (IntermediateDesc.Dimension != D3D12_RESOURCE_DIMENSION_BUFFER || + IntermediateDesc.Width < RequiredSize + pLayouts[0].Offset || + RequiredSize > SIZE_T(-1) || + (DestinationDesc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER && + (FirstSubresource != 0 || NumSubresources != 1))) + { + return 0; + } + + BYTE* pData; + HRESULT hr = pIntermediate->Map(0, nullptr, reinterpret_cast(&pData)); + if (FAILED(hr)) + { + return 0; + } + + for (UINT i = 0; i < NumSubresources; ++i) + { + if (pRowSizesInBytes[i] > SIZE_T(-1)) return 0; + D3D12_MEMCPY_DEST DestData = { pData + pLayouts[i].Offset, pLayouts[i].Footprint.RowPitch, SIZE_T(pLayouts[i].Footprint.RowPitch) * SIZE_T(pNumRows[i]) }; + MemcpySubresource(&DestData, &pSrcData[i], static_cast(pRowSizesInBytes[i]), pNumRows[i], pLayouts[i].Footprint.Depth); + } + pIntermediate->Unmap(0, nullptr); + + if (DestinationDesc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER) + { + pCmdList->CopyBufferRegion( + pDestinationResource, 0, pIntermediate, pLayouts[0].Offset, pLayouts[0].Footprint.Width); + } + else + { + for (UINT i = 0; i < NumSubresources; ++i) + { + CD3DX12_TEXTURE_COPY_LOCATION Dst(pDestinationResource, i + FirstSubresource); + CD3DX12_TEXTURE_COPY_LOCATION Src(pIntermediate, pLayouts[i]); + pCmdList->CopyTextureRegion(&Dst, 0, 0, 0, &Src, nullptr); + } + } + return RequiredSize; +} + +//------------------------------------------------------------------------------------------------ +// Heap-allocating UpdateSubresources implementation +inline UINT64 UpdateSubresources( + _In_ ID3D12GraphicsCommandList* pCmdList, + _In_ ID3D12Resource* pDestinationResource, + _In_ ID3D12Resource* pIntermediate, + UINT64 IntermediateOffset, + _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, + _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, + _In_reads_(NumSubresources) D3D12_SUBRESOURCE_DATA* pSrcData) +{ + UINT64 RequiredSize = 0; + UINT64 MemToAlloc = static_cast(sizeof(D3D12_PLACED_SUBRESOURCE_FOOTPRINT) + sizeof(UINT) + sizeof(UINT64)) * NumSubresources; + if (MemToAlloc > SIZE_MAX) + { + return 0; + } + void* pMem = HeapAlloc(GetProcessHeap(), 0, static_cast(MemToAlloc)); + if (pMem == nullptr) + { + return 0; + } + auto pLayouts = reinterpret_cast(pMem); + UINT64* pRowSizesInBytes = reinterpret_cast(pLayouts + NumSubresources); + UINT* pNumRows = reinterpret_cast(pRowSizesInBytes + NumSubresources); + + auto Desc = pDestinationResource->GetDesc(); + ID3D12Device* pDevice = nullptr; + pDestinationResource->GetDevice(IID_ID3D12Device, reinterpret_cast(&pDevice)); + pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources, IntermediateOffset, pLayouts, pNumRows, pRowSizesInBytes, &RequiredSize); + pDevice->Release(); + + UINT64 Result = UpdateSubresources(pCmdList, pDestinationResource, pIntermediate, FirstSubresource, NumSubresources, RequiredSize, pLayouts, pNumRows, pRowSizesInBytes, pSrcData); + HeapFree(GetProcessHeap(), 0, pMem); + return Result; +} + +//------------------------------------------------------------------------------------------------ +// Stack-allocating UpdateSubresources implementation +template +inline UINT64 UpdateSubresources( + _In_ ID3D12GraphicsCommandList* pCmdList, + _In_ ID3D12Resource* pDestinationResource, + _In_ ID3D12Resource* pIntermediate, + UINT64 IntermediateOffset, + _In_range_(0, MaxSubresources) UINT FirstSubresource, + _In_range_(1, MaxSubresources - FirstSubresource) UINT NumSubresources, + _In_reads_(NumSubresources) D3D12_SUBRESOURCE_DATA* pSrcData) +{ + UINT64 RequiredSize = 0; + D3D12_PLACED_SUBRESOURCE_FOOTPRINT Layouts[MaxSubresources]; + UINT NumRows[MaxSubresources]; + UINT64 RowSizesInBytes[MaxSubresources]; + + auto Desc = pDestinationResource->GetDesc(); + ID3D12Device* pDevice = nullptr; + pDestinationResource->GetDevice(IID_ID3D12Device, reinterpret_cast(&pDevice)); + pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources, IntermediateOffset, Layouts, NumRows, RowSizesInBytes, &RequiredSize); + pDevice->Release(); + + return UpdateSubresources(pCmdList, pDestinationResource, pIntermediate, FirstSubresource, NumSubresources, RequiredSize, Layouts, NumRows, RowSizesInBytes, pSrcData); +} + +//------------------------------------------------------------------------------------------------ +inline bool D3D12IsLayoutOpaque( D3D12_TEXTURE_LAYOUT Layout ) +{ return Layout == D3D12_TEXTURE_LAYOUT_UNKNOWN || Layout == D3D12_TEXTURE_LAYOUT_64KB_UNDEFINED_SWIZZLE; } + +//------------------------------------------------------------------------------------------------ +template +inline ID3D12CommandList * const * CommandListCast(t_CommandListType * const * pp) +{ + // This cast is useful for passing strongly typed command list pointers into + // ExecuteCommandLists. + // This cast is valid as long as the const-ness is respected. D3D12 APIs do + // respect the const-ness of their arguments. + return reinterpret_cast(pp); +} + +//------------------------------------------------------------------------------------------------ +// D3D12 exports a new method for serializing root signatures in the Windows 10 Anniversary Update. +// To help enable root signature 1.1 features when they are available and not require maintaining +// two code paths for building root signatures, this helper method reconstructs a 1.0 signature when +// 1.1 is not supported. +inline HRESULT D3DX12SerializeVersionedRootSignature( + _In_ const D3D12_VERSIONED_ROOT_SIGNATURE_DESC* pRootSignatureDesc, + D3D_ROOT_SIGNATURE_VERSION MaxVersion, + _Outptr_ ID3DBlob** ppBlob, + _Always_(_Outptr_opt_result_maybenull_) ID3DBlob** ppErrorBlob) +{ + if (ppErrorBlob != nullptr) + { + *ppErrorBlob = nullptr; + } + + switch (MaxVersion) + { + case D3D_ROOT_SIGNATURE_VERSION_1_0: + switch (pRootSignatureDesc->Version) + { + case D3D_ROOT_SIGNATURE_VERSION_1_0: + return D3D12SerializeRootSignature(&pRootSignatureDesc->Desc_1_0, D3D_ROOT_SIGNATURE_VERSION_1, ppBlob, ppErrorBlob); + + case D3D_ROOT_SIGNATURE_VERSION_1_1: + { + HRESULT hr = S_OK; + const D3D12_ROOT_SIGNATURE_DESC1& desc_1_1 = pRootSignatureDesc->Desc_1_1; + + const SIZE_T ParametersSize = sizeof(D3D12_ROOT_PARAMETER) * desc_1_1.NumParameters; + void* pParameters = (ParametersSize > 0) ? HeapAlloc(GetProcessHeap(), 0, ParametersSize) : nullptr; + if (ParametersSize > 0 && pParameters == nullptr) + { + hr = E_OUTOFMEMORY; + } + auto pParameters_1_0 = reinterpret_cast(pParameters); + + if (SUCCEEDED(hr)) + { + for (UINT n = 0; n < desc_1_1.NumParameters; n++) + { + __analysis_assume(ParametersSize == sizeof(D3D12_ROOT_PARAMETER) * desc_1_1.NumParameters); + pParameters_1_0[n].ParameterType = desc_1_1.pParameters[n].ParameterType; + pParameters_1_0[n].ShaderVisibility = desc_1_1.pParameters[n].ShaderVisibility; + + switch (desc_1_1.pParameters[n].ParameterType) + { + case D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS: + pParameters_1_0[n].Constants.Num32BitValues = desc_1_1.pParameters[n].Constants.Num32BitValues; + pParameters_1_0[n].Constants.RegisterSpace = desc_1_1.pParameters[n].Constants.RegisterSpace; + pParameters_1_0[n].Constants.ShaderRegister = desc_1_1.pParameters[n].Constants.ShaderRegister; + break; + + case D3D12_ROOT_PARAMETER_TYPE_CBV: + case D3D12_ROOT_PARAMETER_TYPE_SRV: + case D3D12_ROOT_PARAMETER_TYPE_UAV: + pParameters_1_0[n].Descriptor.RegisterSpace = desc_1_1.pParameters[n].Descriptor.RegisterSpace; + pParameters_1_0[n].Descriptor.ShaderRegister = desc_1_1.pParameters[n].Descriptor.ShaderRegister; + break; + + case D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE: + const D3D12_ROOT_DESCRIPTOR_TABLE1& table_1_1 = desc_1_1.pParameters[n].DescriptorTable; + + const SIZE_T DescriptorRangesSize = sizeof(D3D12_DESCRIPTOR_RANGE) * table_1_1.NumDescriptorRanges; + void* pDescriptorRanges = (DescriptorRangesSize > 0 && SUCCEEDED(hr)) ? HeapAlloc(GetProcessHeap(), 0, DescriptorRangesSize) : nullptr; + if (DescriptorRangesSize > 0 && pDescriptorRanges == nullptr) + { + hr = E_OUTOFMEMORY; + } + auto pDescriptorRanges_1_0 = reinterpret_cast(pDescriptorRanges); + + if (SUCCEEDED(hr)) + { + for (UINT x = 0; x < table_1_1.NumDescriptorRanges; x++) + { + __analysis_assume(DescriptorRangesSize == sizeof(D3D12_DESCRIPTOR_RANGE) * table_1_1.NumDescriptorRanges); + pDescriptorRanges_1_0[x].BaseShaderRegister = table_1_1.pDescriptorRanges[x].BaseShaderRegister; + pDescriptorRanges_1_0[x].NumDescriptors = table_1_1.pDescriptorRanges[x].NumDescriptors; + pDescriptorRanges_1_0[x].OffsetInDescriptorsFromTableStart = table_1_1.pDescriptorRanges[x].OffsetInDescriptorsFromTableStart; + pDescriptorRanges_1_0[x].RangeType = table_1_1.pDescriptorRanges[x].RangeType; + pDescriptorRanges_1_0[x].RegisterSpace = table_1_1.pDescriptorRanges[x].RegisterSpace; + } + } + + D3D12_ROOT_DESCRIPTOR_TABLE& table_1_0 = pParameters_1_0[n].DescriptorTable; + table_1_0.NumDescriptorRanges = table_1_1.NumDescriptorRanges; + table_1_0.pDescriptorRanges = pDescriptorRanges_1_0; + } + } + } + + if (SUCCEEDED(hr)) + { + CD3DX12_ROOT_SIGNATURE_DESC desc_1_0(desc_1_1.NumParameters, pParameters_1_0, desc_1_1.NumStaticSamplers, desc_1_1.pStaticSamplers, desc_1_1.Flags); + hr = D3D12SerializeRootSignature(&desc_1_0, D3D_ROOT_SIGNATURE_VERSION_1, ppBlob, ppErrorBlob); + } + + if (pParameters) + { + for (UINT n = 0; n < desc_1_1.NumParameters; n++) + { + if (desc_1_1.pParameters[n].ParameterType == D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE) + { + HeapFree(GetProcessHeap(), 0, reinterpret_cast(const_cast(pParameters_1_0[n].DescriptorTable.pDescriptorRanges))); + } + } + HeapFree(GetProcessHeap(), 0, pParameters); + } + return hr; + } + } + break; + + case D3D_ROOT_SIGNATURE_VERSION_1_1: + return D3D12SerializeVersionedRootSignature(pRootSignatureDesc, ppBlob, ppErrorBlob); + } + + return E_INVALIDARG; +} + +//------------------------------------------------------------------------------------------------ +struct CD3DX12_RT_FORMAT_ARRAY : public D3D12_RT_FORMAT_ARRAY +{ + CD3DX12_RT_FORMAT_ARRAY() = default; + explicit CD3DX12_RT_FORMAT_ARRAY(const D3D12_RT_FORMAT_ARRAY& o) + : D3D12_RT_FORMAT_ARRAY(o) + {} + explicit CD3DX12_RT_FORMAT_ARRAY(_In_reads_(NumFormats) const DXGI_FORMAT* pFormats, UINT NumFormats) + { + NumRenderTargets = NumFormats; + memcpy(RTFormats, pFormats, sizeof(RTFormats)); + // assumes ARRAY_SIZE(pFormats) == ARRAY_SIZE(RTFormats) + } +}; + +//------------------------------------------------------------------------------------------------ +// Pipeline State Stream Helpers +//------------------------------------------------------------------------------------------------ + +//------------------------------------------------------------------------------------------------ +// Stream Subobjects, i.e. elements of a stream + +struct DefaultSampleMask { operator UINT() { return UINT_MAX; } }; +struct DefaultSampleDesc { operator DXGI_SAMPLE_DESC() { return DXGI_SAMPLE_DESC{1, 0}; } }; + +#pragma warning(push) +#pragma warning(disable : 4324) +template +class alignas(void*) CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT +{ +private: + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE _Type; + InnerStructType _Inner; +public: + CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT() noexcept : _Type(Type), _Inner(DefaultArg()) {} + CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT(InnerStructType const& i) : _Type(Type), _Inner(i) {} + CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT& operator=(InnerStructType const& i) { _Inner = i; return *this; } + operator InnerStructType const&() const { return _Inner; } + operator InnerStructType&() { return _Inner; } + InnerStructType* operator&() { return &_Inner; } + InnerStructType const* operator&() const { return &_Inner; } +}; +#pragma warning(pop) +typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_PIPELINE_STATE_FLAGS, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_FLAGS> CD3DX12_PIPELINE_STATE_STREAM_FLAGS; +typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< UINT, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_NODE_MASK> CD3DX12_PIPELINE_STATE_STREAM_NODE_MASK; +typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< ID3D12RootSignature*, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_ROOT_SIGNATURE> CD3DX12_PIPELINE_STATE_STREAM_ROOT_SIGNATURE; +typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_INPUT_LAYOUT_DESC, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_INPUT_LAYOUT> CD3DX12_PIPELINE_STATE_STREAM_INPUT_LAYOUT; +typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_INDEX_BUFFER_STRIP_CUT_VALUE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_IB_STRIP_CUT_VALUE> CD3DX12_PIPELINE_STATE_STREAM_IB_STRIP_CUT_VALUE; +typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_PRIMITIVE_TOPOLOGY_TYPE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PRIMITIVE_TOPOLOGY> CD3DX12_PIPELINE_STATE_STREAM_PRIMITIVE_TOPOLOGY; +typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VS> CD3DX12_PIPELINE_STATE_STREAM_VS; +typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_GS> CD3DX12_PIPELINE_STATE_STREAM_GS; +typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_STREAM_OUTPUT_DESC, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_STREAM_OUTPUT> CD3DX12_PIPELINE_STATE_STREAM_STREAM_OUTPUT; +typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_HS> CD3DX12_PIPELINE_STATE_STREAM_HS; +typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DS> CD3DX12_PIPELINE_STATE_STREAM_DS; +typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PS> CD3DX12_PIPELINE_STATE_STREAM_PS; +typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CS> CD3DX12_PIPELINE_STATE_STREAM_CS; +typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< CD3DX12_BLEND_DESC, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_BLEND, CD3DX12_DEFAULT> CD3DX12_PIPELINE_STATE_STREAM_BLEND_DESC; +typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< CD3DX12_DEPTH_STENCIL_DESC, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL, CD3DX12_DEFAULT> CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL; +typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< CD3DX12_DEPTH_STENCIL_DESC1, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1, CD3DX12_DEFAULT> CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL1; +typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< DXGI_FORMAT, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL_FORMAT> CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL_FORMAT; +typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< CD3DX12_RASTERIZER_DESC, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RASTERIZER, CD3DX12_DEFAULT> CD3DX12_PIPELINE_STATE_STREAM_RASTERIZER; +typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_RT_FORMAT_ARRAY, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RENDER_TARGET_FORMATS> CD3DX12_PIPELINE_STATE_STREAM_RENDER_TARGET_FORMATS; +typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< DXGI_SAMPLE_DESC, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_DESC, DefaultSampleDesc> CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_DESC; +typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< UINT, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_MASK, DefaultSampleMask> CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_MASK; +typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_CACHED_PIPELINE_STATE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CACHED_PSO> CD3DX12_PIPELINE_STATE_STREAM_CACHED_PSO; +typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< CD3DX12_VIEW_INSTANCING_DESC, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VIEW_INSTANCING, CD3DX12_DEFAULT> CD3DX12_PIPELINE_STATE_STREAM_VIEW_INSTANCING; + +//------------------------------------------------------------------------------------------------ +// Stream Parser Helpers + +struct ID3DX12PipelineParserCallbacks +{ + // Subobject Callbacks + virtual void FlagsCb(D3D12_PIPELINE_STATE_FLAGS) {} + virtual void NodeMaskCb(UINT) {} + virtual void RootSignatureCb(ID3D12RootSignature*) {} + virtual void InputLayoutCb(const D3D12_INPUT_LAYOUT_DESC&) {} + virtual void IBStripCutValueCb(D3D12_INDEX_BUFFER_STRIP_CUT_VALUE) {} + virtual void PrimitiveTopologyTypeCb(D3D12_PRIMITIVE_TOPOLOGY_TYPE) {} + virtual void VSCb(const D3D12_SHADER_BYTECODE&) {} + virtual void GSCb(const D3D12_SHADER_BYTECODE&) {} + virtual void StreamOutputCb(const D3D12_STREAM_OUTPUT_DESC&) {} + virtual void HSCb(const D3D12_SHADER_BYTECODE&) {} + virtual void DSCb(const D3D12_SHADER_BYTECODE&) {} + virtual void PSCb(const D3D12_SHADER_BYTECODE&) {} + virtual void CSCb(const D3D12_SHADER_BYTECODE&) {} + virtual void BlendStateCb(const D3D12_BLEND_DESC&) {} + virtual void DepthStencilStateCb(const D3D12_DEPTH_STENCIL_DESC&) {} + virtual void DepthStencilState1Cb(const D3D12_DEPTH_STENCIL_DESC1&) {} + virtual void DSVFormatCb(DXGI_FORMAT) {} + virtual void RasterizerStateCb(const D3D12_RASTERIZER_DESC&) {} + virtual void RTVFormatsCb(const D3D12_RT_FORMAT_ARRAY&) {} + virtual void SampleDescCb(const DXGI_SAMPLE_DESC&) {} + virtual void SampleMaskCb(UINT) {} + virtual void ViewInstancingCb(const D3D12_VIEW_INSTANCING_DESC&) {} + virtual void CachedPSOCb(const D3D12_CACHED_PIPELINE_STATE&) {} + + // Error Callbacks + virtual void ErrorBadInputParameter(UINT /*ParameterIndex*/) {} + virtual void ErrorDuplicateSubobject(D3D12_PIPELINE_STATE_SUBOBJECT_TYPE /*DuplicateType*/) {} + virtual void ErrorUnknownSubobject(UINT /*UnknownTypeValue*/) {} + + virtual ~ID3DX12PipelineParserCallbacks() = default; +}; + +// CD3DX12_PIPELINE_STATE_STREAM1 Works on RS3+ (where there is a new view instancing subobject). +// Use CD3DX12_PIPELINE_STATE_STREAM for RS2+ support. +struct CD3DX12_PIPELINE_STATE_STREAM1 +{ + CD3DX12_PIPELINE_STATE_STREAM1() = default; + CD3DX12_PIPELINE_STATE_STREAM1(const D3D12_GRAPHICS_PIPELINE_STATE_DESC& Desc) + : Flags(Desc.Flags) + , NodeMask(Desc.NodeMask) + , pRootSignature(Desc.pRootSignature) + , InputLayout(Desc.InputLayout) + , IBStripCutValue(Desc.IBStripCutValue) + , PrimitiveTopologyType(Desc.PrimitiveTopologyType) + , VS(Desc.VS) + , GS(Desc.GS) + , StreamOutput(Desc.StreamOutput) + , HS(Desc.HS) + , DS(Desc.DS) + , PS(Desc.PS) + , BlendState(CD3DX12_BLEND_DESC(Desc.BlendState)) + , DepthStencilState(CD3DX12_DEPTH_STENCIL_DESC1(Desc.DepthStencilState)) + , DSVFormat(Desc.DSVFormat) + , RasterizerState(CD3DX12_RASTERIZER_DESC(Desc.RasterizerState)) + , RTVFormats(CD3DX12_RT_FORMAT_ARRAY(Desc.RTVFormats, Desc.NumRenderTargets)) + , SampleDesc(Desc.SampleDesc) + , SampleMask(Desc.SampleMask) + , CachedPSO(Desc.CachedPSO) + , ViewInstancingDesc(CD3DX12_VIEW_INSTANCING_DESC(CD3DX12_DEFAULT())) + {} + CD3DX12_PIPELINE_STATE_STREAM1(const D3D12_COMPUTE_PIPELINE_STATE_DESC& Desc) + : Flags(Desc.Flags) + , NodeMask(Desc.NodeMask) + , pRootSignature(Desc.pRootSignature) + , CS(CD3DX12_SHADER_BYTECODE(Desc.CS)) + , CachedPSO(Desc.CachedPSO) + { + static_cast(DepthStencilState).DepthEnable = false; + } + CD3DX12_PIPELINE_STATE_STREAM_FLAGS Flags; + CD3DX12_PIPELINE_STATE_STREAM_NODE_MASK NodeMask; + CD3DX12_PIPELINE_STATE_STREAM_ROOT_SIGNATURE pRootSignature; + CD3DX12_PIPELINE_STATE_STREAM_INPUT_LAYOUT InputLayout; + CD3DX12_PIPELINE_STATE_STREAM_IB_STRIP_CUT_VALUE IBStripCutValue; + CD3DX12_PIPELINE_STATE_STREAM_PRIMITIVE_TOPOLOGY PrimitiveTopologyType; + CD3DX12_PIPELINE_STATE_STREAM_VS VS; + CD3DX12_PIPELINE_STATE_STREAM_GS GS; + CD3DX12_PIPELINE_STATE_STREAM_STREAM_OUTPUT StreamOutput; + CD3DX12_PIPELINE_STATE_STREAM_HS HS; + CD3DX12_PIPELINE_STATE_STREAM_DS DS; + CD3DX12_PIPELINE_STATE_STREAM_PS PS; + CD3DX12_PIPELINE_STATE_STREAM_CS CS; + CD3DX12_PIPELINE_STATE_STREAM_BLEND_DESC BlendState; + CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL1 DepthStencilState; + CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL_FORMAT DSVFormat; + CD3DX12_PIPELINE_STATE_STREAM_RASTERIZER RasterizerState; + CD3DX12_PIPELINE_STATE_STREAM_RENDER_TARGET_FORMATS RTVFormats; + CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_DESC SampleDesc; + CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_MASK SampleMask; + CD3DX12_PIPELINE_STATE_STREAM_CACHED_PSO CachedPSO; + CD3DX12_PIPELINE_STATE_STREAM_VIEW_INSTANCING ViewInstancingDesc; + D3D12_GRAPHICS_PIPELINE_STATE_DESC GraphicsDescV0() const + { + D3D12_GRAPHICS_PIPELINE_STATE_DESC D; + D.Flags = this->Flags; + D.NodeMask = this->NodeMask; + D.pRootSignature = this->pRootSignature; + D.InputLayout = this->InputLayout; + D.IBStripCutValue = this->IBStripCutValue; + D.PrimitiveTopologyType = this->PrimitiveTopologyType; + D.VS = this->VS; + D.GS = this->GS; + D.StreamOutput = this->StreamOutput; + D.HS = this->HS; + D.DS = this->DS; + D.PS = this->PS; + D.BlendState = this->BlendState; + D.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC1(D3D12_DEPTH_STENCIL_DESC1(this->DepthStencilState)); + D.DSVFormat = this->DSVFormat; + D.RasterizerState = this->RasterizerState; + D.NumRenderTargets = D3D12_RT_FORMAT_ARRAY(this->RTVFormats).NumRenderTargets; + memcpy(D.RTVFormats, D3D12_RT_FORMAT_ARRAY(this->RTVFormats).RTFormats, sizeof(D.RTVFormats)); + D.SampleDesc = this->SampleDesc; + D.SampleMask = this->SampleMask; + D.CachedPSO = this->CachedPSO; + return D; + } + D3D12_COMPUTE_PIPELINE_STATE_DESC ComputeDescV0() const + { + D3D12_COMPUTE_PIPELINE_STATE_DESC D; + D.Flags = this->Flags; + D.NodeMask = this->NodeMask; + D.pRootSignature = this->pRootSignature; + D.CS = this->CS; + D.CachedPSO = this->CachedPSO; + return D; + } +}; + +// CD3DX12_PIPELINE_STATE_STREAM works on RS2+ but does not support new subobject(s) added in RS3+. +// See CD3DX12_PIPELINE_STATE_STREAM1 for instance. +struct CD3DX12_PIPELINE_STATE_STREAM +{ + CD3DX12_PIPELINE_STATE_STREAM() = default; + CD3DX12_PIPELINE_STATE_STREAM(const D3D12_GRAPHICS_PIPELINE_STATE_DESC& Desc) + : Flags(Desc.Flags) + , NodeMask(Desc.NodeMask) + , pRootSignature(Desc.pRootSignature) + , InputLayout(Desc.InputLayout) + , IBStripCutValue(Desc.IBStripCutValue) + , PrimitiveTopologyType(Desc.PrimitiveTopologyType) + , VS(Desc.VS) + , GS(Desc.GS) + , StreamOutput(Desc.StreamOutput) + , HS(Desc.HS) + , DS(Desc.DS) + , PS(Desc.PS) + , BlendState(CD3DX12_BLEND_DESC(Desc.BlendState)) + , DepthStencilState(CD3DX12_DEPTH_STENCIL_DESC1(Desc.DepthStencilState)) + , DSVFormat(Desc.DSVFormat) + , RasterizerState(CD3DX12_RASTERIZER_DESC(Desc.RasterizerState)) + , RTVFormats(CD3DX12_RT_FORMAT_ARRAY(Desc.RTVFormats, Desc.NumRenderTargets)) + , SampleDesc(Desc.SampleDesc) + , SampleMask(Desc.SampleMask) + , CachedPSO(Desc.CachedPSO) + {} + CD3DX12_PIPELINE_STATE_STREAM(const D3D12_COMPUTE_PIPELINE_STATE_DESC& Desc) + : Flags(Desc.Flags) + , NodeMask(Desc.NodeMask) + , pRootSignature(Desc.pRootSignature) + , CS(CD3DX12_SHADER_BYTECODE(Desc.CS)) + , CachedPSO(Desc.CachedPSO) + {} + CD3DX12_PIPELINE_STATE_STREAM_FLAGS Flags; + CD3DX12_PIPELINE_STATE_STREAM_NODE_MASK NodeMask; + CD3DX12_PIPELINE_STATE_STREAM_ROOT_SIGNATURE pRootSignature; + CD3DX12_PIPELINE_STATE_STREAM_INPUT_LAYOUT InputLayout; + CD3DX12_PIPELINE_STATE_STREAM_IB_STRIP_CUT_VALUE IBStripCutValue; + CD3DX12_PIPELINE_STATE_STREAM_PRIMITIVE_TOPOLOGY PrimitiveTopologyType; + CD3DX12_PIPELINE_STATE_STREAM_VS VS; + CD3DX12_PIPELINE_STATE_STREAM_GS GS; + CD3DX12_PIPELINE_STATE_STREAM_STREAM_OUTPUT StreamOutput; + CD3DX12_PIPELINE_STATE_STREAM_HS HS; + CD3DX12_PIPELINE_STATE_STREAM_DS DS; + CD3DX12_PIPELINE_STATE_STREAM_PS PS; + CD3DX12_PIPELINE_STATE_STREAM_CS CS; + CD3DX12_PIPELINE_STATE_STREAM_BLEND_DESC BlendState; + CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL1 DepthStencilState; + CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL_FORMAT DSVFormat; + CD3DX12_PIPELINE_STATE_STREAM_RASTERIZER RasterizerState; + CD3DX12_PIPELINE_STATE_STREAM_RENDER_TARGET_FORMATS RTVFormats; + CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_DESC SampleDesc; + CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_MASK SampleMask; + CD3DX12_PIPELINE_STATE_STREAM_CACHED_PSO CachedPSO; + D3D12_GRAPHICS_PIPELINE_STATE_DESC GraphicsDescV0() const + { + D3D12_GRAPHICS_PIPELINE_STATE_DESC D; + D.Flags = this->Flags; + D.NodeMask = this->NodeMask; + D.pRootSignature = this->pRootSignature; + D.InputLayout = this->InputLayout; + D.IBStripCutValue = this->IBStripCutValue; + D.PrimitiveTopologyType = this->PrimitiveTopologyType; + D.VS = this->VS; + D.GS = this->GS; + D.StreamOutput = this->StreamOutput; + D.HS = this->HS; + D.DS = this->DS; + D.PS = this->PS; + D.BlendState = this->BlendState; + D.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC1(D3D12_DEPTH_STENCIL_DESC1(this->DepthStencilState)); + D.DSVFormat = this->DSVFormat; + D.RasterizerState = this->RasterizerState; + D.NumRenderTargets = D3D12_RT_FORMAT_ARRAY(this->RTVFormats).NumRenderTargets; + memcpy(D.RTVFormats, D3D12_RT_FORMAT_ARRAY(this->RTVFormats).RTFormats, sizeof(D.RTVFormats)); + D.SampleDesc = this->SampleDesc; + D.SampleMask = this->SampleMask; + D.CachedPSO = this->CachedPSO; + return D; + } + D3D12_COMPUTE_PIPELINE_STATE_DESC ComputeDescV0() const + { + D3D12_COMPUTE_PIPELINE_STATE_DESC D; + D.Flags = this->Flags; + D.NodeMask = this->NodeMask; + D.pRootSignature = this->pRootSignature; + D.CS = this->CS; + D.CachedPSO = this->CachedPSO; + return D; + } +}; + +struct CD3DX12_PIPELINE_STATE_STREAM_PARSE_HELPER : public ID3DX12PipelineParserCallbacks +{ + CD3DX12_PIPELINE_STATE_STREAM1 PipelineStream; + CD3DX12_PIPELINE_STATE_STREAM_PARSE_HELPER() noexcept + : SeenDSS(false) + { + // Adjust defaults to account for absent members. + PipelineStream.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE; + + // Depth disabled if no DSV format specified. + static_cast(PipelineStream.DepthStencilState).DepthEnable = false; + } + + // ID3DX12PipelineParserCallbacks + void FlagsCb(D3D12_PIPELINE_STATE_FLAGS Flags) override {PipelineStream.Flags = Flags;} + void NodeMaskCb(UINT NodeMask) override {PipelineStream.NodeMask = NodeMask;} + void RootSignatureCb(ID3D12RootSignature* pRootSignature) override {PipelineStream.pRootSignature = pRootSignature;} + void InputLayoutCb(const D3D12_INPUT_LAYOUT_DESC& InputLayout) override {PipelineStream.InputLayout = InputLayout;} + void IBStripCutValueCb(D3D12_INDEX_BUFFER_STRIP_CUT_VALUE IBStripCutValue) override {PipelineStream.IBStripCutValue = IBStripCutValue;} + void PrimitiveTopologyTypeCb(D3D12_PRIMITIVE_TOPOLOGY_TYPE PrimitiveTopologyType) override {PipelineStream.PrimitiveTopologyType = PrimitiveTopologyType;} + void VSCb(const D3D12_SHADER_BYTECODE& VS) override {PipelineStream.VS = VS;} + void GSCb(const D3D12_SHADER_BYTECODE& GS) override {PipelineStream.GS = GS;} + void StreamOutputCb(const D3D12_STREAM_OUTPUT_DESC& StreamOutput) override {PipelineStream.StreamOutput = StreamOutput;} + void HSCb(const D3D12_SHADER_BYTECODE& HS) override {PipelineStream.HS = HS;} + void DSCb(const D3D12_SHADER_BYTECODE& DS) override {PipelineStream.DS = DS;} + void PSCb(const D3D12_SHADER_BYTECODE& PS) override {PipelineStream.PS = PS;} + void CSCb(const D3D12_SHADER_BYTECODE& CS) override {PipelineStream.CS = CS;} + void BlendStateCb(const D3D12_BLEND_DESC& BlendState) override {PipelineStream.BlendState = CD3DX12_BLEND_DESC(BlendState);} + void DepthStencilStateCb(const D3D12_DEPTH_STENCIL_DESC& DepthStencilState) override + { + PipelineStream.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC1(DepthStencilState); + SeenDSS = true; + } + void DepthStencilState1Cb(const D3D12_DEPTH_STENCIL_DESC1& DepthStencilState) override + { + PipelineStream.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC1(DepthStencilState); + SeenDSS = true; + } + void DSVFormatCb(DXGI_FORMAT DSVFormat) override + { + PipelineStream.DSVFormat = DSVFormat; + if (!SeenDSS && DSVFormat != DXGI_FORMAT_UNKNOWN) + { + // Re-enable depth for the default state. + static_cast(PipelineStream.DepthStencilState).DepthEnable = true; + } + } + void RasterizerStateCb(const D3D12_RASTERIZER_DESC& RasterizerState) override {PipelineStream.RasterizerState = CD3DX12_RASTERIZER_DESC(RasterizerState);} + void RTVFormatsCb(const D3D12_RT_FORMAT_ARRAY& RTVFormats) override {PipelineStream.RTVFormats = RTVFormats;} + void SampleDescCb(const DXGI_SAMPLE_DESC& SampleDesc) override {PipelineStream.SampleDesc = SampleDesc;} + void SampleMaskCb(UINT SampleMask) override {PipelineStream.SampleMask = SampleMask;} + void ViewInstancingCb(const D3D12_VIEW_INSTANCING_DESC& ViewInstancingDesc) override {PipelineStream.ViewInstancingDesc = CD3DX12_VIEW_INSTANCING_DESC(ViewInstancingDesc);} + void CachedPSOCb(const D3D12_CACHED_PIPELINE_STATE& CachedPSO) override {PipelineStream.CachedPSO = CachedPSO;} + +private: + bool SeenDSS; +}; + +inline D3D12_PIPELINE_STATE_SUBOBJECT_TYPE D3DX12GetBaseSubobjectType(D3D12_PIPELINE_STATE_SUBOBJECT_TYPE SubobjectType) +{ + switch (SubobjectType) + { + case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1: + return D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL; + default: + return SubobjectType; + } +} + +inline HRESULT D3DX12ParsePipelineStream(const D3D12_PIPELINE_STATE_STREAM_DESC& Desc, ID3DX12PipelineParserCallbacks* pCallbacks) +{ + if (pCallbacks == nullptr) + { + return E_INVALIDARG; + } + + if (Desc.SizeInBytes == 0 || Desc.pPipelineStateSubobjectStream == nullptr) + { + pCallbacks->ErrorBadInputParameter(1); // first parameter issue + return E_INVALIDARG; + } + + bool SubobjectSeen[D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MAX_VALID] = {}; + for (SIZE_T CurOffset = 0, SizeOfSubobject = 0; CurOffset < Desc.SizeInBytes; CurOffset += SizeOfSubobject) + { + BYTE* pStream = static_cast(Desc.pPipelineStateSubobjectStream)+CurOffset; + auto SubobjectType = *reinterpret_cast(pStream); + if (SubobjectType < 0 || SubobjectType >= D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MAX_VALID) + { + pCallbacks->ErrorUnknownSubobject(SubobjectType); + return E_INVALIDARG; + } + if (SubobjectSeen[D3DX12GetBaseSubobjectType(SubobjectType)]) + { + pCallbacks->ErrorDuplicateSubobject(SubobjectType); + return E_INVALIDARG; // disallow subobject duplicates in a stream + } + SubobjectSeen[SubobjectType] = true; + switch (SubobjectType) + { + case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_ROOT_SIGNATURE: + pCallbacks->RootSignatureCb(*reinterpret_cast(pStream)); + SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::pRootSignature); + break; + case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VS: + pCallbacks->VSCb(*reinterpret_cast(pStream)); + SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::VS); + break; + case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PS: + pCallbacks->PSCb(*reinterpret_cast(pStream)); + SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::PS); + break; + case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DS: + pCallbacks->DSCb(*reinterpret_cast(pStream)); + SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::DS); + break; + case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_HS: + pCallbacks->HSCb(*reinterpret_cast(pStream)); + SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::HS); + break; + case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_GS: + pCallbacks->GSCb(*reinterpret_cast(pStream)); + SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::GS); + break; + case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CS: + pCallbacks->CSCb(*reinterpret_cast(pStream)); + SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::CS); + break; + case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_STREAM_OUTPUT: + pCallbacks->StreamOutputCb(*reinterpret_cast(pStream)); + SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::StreamOutput); + break; + case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_BLEND: + pCallbacks->BlendStateCb(*reinterpret_cast(pStream)); + SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::BlendState); + break; + case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_MASK: + pCallbacks->SampleMaskCb(*reinterpret_cast(pStream)); + SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::SampleMask); + break; + case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RASTERIZER: + pCallbacks->RasterizerStateCb(*reinterpret_cast(pStream)); + SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::RasterizerState); + break; + case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL: + pCallbacks->DepthStencilStateCb(*reinterpret_cast(pStream)); + SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL); + break; + case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1: + pCallbacks->DepthStencilState1Cb(*reinterpret_cast(pStream)); + SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::DepthStencilState); + break; + case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_INPUT_LAYOUT: + pCallbacks->InputLayoutCb(*reinterpret_cast(pStream)); + SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::InputLayout); + break; + case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_IB_STRIP_CUT_VALUE: + pCallbacks->IBStripCutValueCb(*reinterpret_cast(pStream)); + SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::IBStripCutValue); + break; + case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PRIMITIVE_TOPOLOGY: + pCallbacks->PrimitiveTopologyTypeCb(*reinterpret_cast(pStream)); + SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::PrimitiveTopologyType); + break; + case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RENDER_TARGET_FORMATS: + pCallbacks->RTVFormatsCb(*reinterpret_cast(pStream)); + SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::RTVFormats); + break; + case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL_FORMAT: + pCallbacks->DSVFormatCb(*reinterpret_cast(pStream)); + SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::DSVFormat); + break; + case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_DESC: + pCallbacks->SampleDescCb(*reinterpret_cast(pStream)); + SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::SampleDesc); + break; + case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_NODE_MASK: + pCallbacks->NodeMaskCb(*reinterpret_cast(pStream)); + SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::NodeMask); + break; + case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CACHED_PSO: + pCallbacks->CachedPSOCb(*reinterpret_cast(pStream)); + SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::CachedPSO); + break; + case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_FLAGS: + pCallbacks->FlagsCb(*reinterpret_cast(pStream)); + SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::Flags); + break; + case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VIEW_INSTANCING: + pCallbacks->ViewInstancingCb(*reinterpret_cast(pStream)); + SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM1::ViewInstancingDesc); + break; + default: + pCallbacks->ErrorUnknownSubobject(SubobjectType); + return E_INVALIDARG; + break; + } + } + + return S_OK; +} + +//------------------------------------------------------------------------------------------------ +inline bool operator==( const D3D12_CLEAR_VALUE &a, const D3D12_CLEAR_VALUE &b) +{ + if (a.Format != b.Format) return false; + if (a.Format == DXGI_FORMAT_D24_UNORM_S8_UINT + || a.Format == DXGI_FORMAT_D16_UNORM + || a.Format == DXGI_FORMAT_D32_FLOAT + || a.Format == DXGI_FORMAT_D32_FLOAT_S8X24_UINT) + { + return (a.DepthStencil.Depth == b.DepthStencil.Depth) && + (a.DepthStencil.Stencil == b.DepthStencil.Stencil); + } else { + return (a.Color[0] == b.Color[0]) && + (a.Color[1] == b.Color[1]) && + (a.Color[2] == b.Color[2]) && + (a.Color[3] == b.Color[3]); + } +} +inline bool operator==( const D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS &a, const D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS &b) +{ + return a.ClearValue == b.ClearValue; +} +inline bool operator==( const D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS &a, const D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS &b) +{ + if (a.pSrcResource != b.pSrcResource) return false; + if (a.pDstResource != b.pDstResource) return false; + if (a.SubresourceCount != b.SubresourceCount) return false; + if (a.Format != b.Format) return false; + if (a.ResolveMode != b.ResolveMode) return false; + if (a.PreserveResolveSource != b.PreserveResolveSource) return false; + return true; +} +inline bool operator==( const D3D12_RENDER_PASS_BEGINNING_ACCESS &a, const D3D12_RENDER_PASS_BEGINNING_ACCESS &b) +{ + if (a.Type != b.Type) return false; + if (a.Type == D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR && !(a.Clear == b.Clear)) return false; + return true; +} +inline bool operator==( const D3D12_RENDER_PASS_ENDING_ACCESS &a, const D3D12_RENDER_PASS_ENDING_ACCESS &b) +{ + if (a.Type != b.Type) return false; + if (a.Type == D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_RESOLVE && !(a.Resolve == b.Resolve)) return false; + return true; +} +inline bool operator==( const D3D12_RENDER_PASS_RENDER_TARGET_DESC &a, const D3D12_RENDER_PASS_RENDER_TARGET_DESC &b) +{ + if (a.cpuDescriptor.ptr != b.cpuDescriptor.ptr) return false; + if (!(a.BeginningAccess == b.BeginningAccess)) return false; + if (!(a.EndingAccess == b.EndingAccess)) return false; + return true; +} +inline bool operator==( const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC &a, const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC &b) +{ + if (a.cpuDescriptor.ptr != b.cpuDescriptor.ptr) return false; + if (!(a.DepthBeginningAccess == b.DepthBeginningAccess)) return false; + if (!(a.StencilBeginningAccess == b.StencilBeginningAccess)) return false; + if (!(a.DepthEndingAccess == b.DepthEndingAccess)) return false; + if (!(a.StencilEndingAccess == b.StencilEndingAccess)) return false; + return true; +} + + +#ifndef D3DX12_NO_STATE_OBJECT_HELPERS + +//================================================================================================ +// D3DX12 State Object Creation Helpers +// +// Helper classes for creating new style state objects out of an arbitrary set of subobjects. +// Uses STL +// +// Start by instantiating CD3DX12_STATE_OBJECT_DESC (see it's public methods). +// One of its methods is CreateSubobject(), which has a comment showing a couple of options for +// defining subobjects using the helper classes for each subobject (CD3DX12_DXIL_LIBRARY_SUBOBJECT +// etc.). The subobject helpers each have methods specific to the subobject for configuring it's +// contents. +// +//================================================================================================ +#include +#include +#include +#include +#include + +//------------------------------------------------------------------------------------------------ +class CD3DX12_STATE_OBJECT_DESC +{ +public: + CD3DX12_STATE_OBJECT_DESC() + { + Init(D3D12_STATE_OBJECT_TYPE_COLLECTION); + } + CD3DX12_STATE_OBJECT_DESC(D3D12_STATE_OBJECT_TYPE Type) + { + Init(Type); + } + void SetStateObjectType(D3D12_STATE_OBJECT_TYPE Type) { m_Desc.Type = Type; } + operator const D3D12_STATE_OBJECT_DESC&() + { + // Do final preparation work + m_RepointedAssociations.clear(); + m_SubobjectArray.clear(); + m_SubobjectArray.reserve(m_Desc.NumSubobjects); + // Flatten subobjects into an array (each flattened subobject still has a + // member that's a pointer to it's desc that's not flattened) + for (auto Iter = m_SubobjectList.begin(); + Iter != m_SubobjectList.end(); Iter++) + { + m_SubobjectArray.push_back(*Iter); + // Store new location in array so we can redirect pointers contained in subobjects + Iter->pSubobjectArrayLocation = &m_SubobjectArray.back(); + } + // For subobjects with pointer fields, create a new copy of those subobject definitions + // with fixed pointers + for (UINT i = 0; i < m_Desc.NumSubobjects; i++) + { + if (m_SubobjectArray[i].Type == D3D12_STATE_SUBOBJECT_TYPE_SUBOBJECT_TO_EXPORTS_ASSOCIATION) + { + auto pOriginalSubobjectAssociation = + reinterpret_cast(m_SubobjectArray[i].pDesc); + D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION Repointed = *pOriginalSubobjectAssociation; + auto pWrapper = + static_cast(pOriginalSubobjectAssociation->pSubobjectToAssociate); + Repointed.pSubobjectToAssociate = pWrapper->pSubobjectArrayLocation; + m_RepointedAssociations.push_back(Repointed); + m_SubobjectArray[i].pDesc = &m_RepointedAssociations.back(); + } + } + // Below: using ugly way to get pointer in case .data() is not defined + m_Desc.pSubobjects = m_Desc.NumSubobjects ? &m_SubobjectArray[0] : nullptr; + return m_Desc; + } + operator const D3D12_STATE_OBJECT_DESC*() + { + // Cast calls the above final preparation work + return &static_cast(*this); + } + + // CreateSubobject creates a sububject helper (e.g. CD3DX12_HIT_GROUP_SUBOBJECT) + // whose lifetime is owned by this class. + // e.g. + // + // CD3DX12_STATE_OBJECT_DESC Collection1(D3D12_STATE_OBJECT_TYPE_COLLECTION); + // auto Lib0 = Collection1.CreateSubobject(); + // Lib0->SetDXILLibrary(&pMyAppDxilLibs[0]); + // Lib0->DefineExport(L"rayGenShader0"); // in practice these export listings might be + // // data/engine driven + // etc. + // + // Alternatively, users can instantiate sububject helpers explicitly, such as via local + // variables instead, passing the state object desc that should point to it into the helper + // constructor (or call mySubobjectHelper.AddToStateObject(Collection1)). + // In this alternative scenario, the user must keep the subobject alive as long as the state + // object it is associated with is alive, else it's pointer references will be stale. + // e.g. + // + // CD3DX12_STATE_OBJECT_DESC RaytracingState2(D3D12_STATE_OBJECT_TYPE_RAYTRACING_PIPELINE); + // CD3DX12_DXIL_LIBRARY_SUBOBJECT LibA(RaytracingState2); + // LibA.SetDXILLibrary(&pMyAppDxilLibs[4]); // not manually specifying exports + // // - meaning all exports in the libraries + // // are exported + // etc. + + template + T* CreateSubobject() + { + T* pSubobject = new T(*this); + m_OwnedSubobjectHelpers.emplace_back(pSubobject); + return pSubobject; + } + +private: + D3D12_STATE_SUBOBJECT* TrackSubobject(D3D12_STATE_SUBOBJECT_TYPE Type, void* pDesc) + { + SUBOBJECT_WRAPPER Subobject; + Subobject.pSubobjectArrayLocation = nullptr; + Subobject.Type = Type; + Subobject.pDesc = pDesc; + m_SubobjectList.push_back(Subobject); + m_Desc.NumSubobjects++; + return &m_SubobjectList.back(); + } + void Init(D3D12_STATE_OBJECT_TYPE Type) + { + SetStateObjectType(Type); + m_Desc.pSubobjects = nullptr; + m_Desc.NumSubobjects = 0; + m_SubobjectList.clear(); + m_SubobjectArray.clear(); + m_RepointedAssociations.clear(); + } + typedef struct SUBOBJECT_WRAPPER : public D3D12_STATE_SUBOBJECT + { + D3D12_STATE_SUBOBJECT* pSubobjectArrayLocation; // new location when flattened into array + // for repointing pointers in subobjects + } SUBOBJECT_WRAPPER; + D3D12_STATE_OBJECT_DESC m_Desc; + std::list m_SubobjectList; // Pointers to list nodes handed out so + // these can be edited live + std::vector m_SubobjectArray; // Built at the end, copying list contents + + std::list + m_RepointedAssociations; // subobject type that contains pointers to other subobjects, + // repointed to flattened array + + class StringContainer + { + public: + LPCWSTR LocalCopy(LPCWSTR string, bool bSingleString = false) + { + if (string) + { + if (bSingleString) + { + m_Strings.clear(); + m_Strings.push_back(string); + } + else + { + m_Strings.push_back(string); + } + return m_Strings.back().c_str(); + } + else + { + return nullptr; + } + } + void clear() { m_Strings.clear(); } + private: + std::list m_Strings; + }; + + class SUBOBJECT_HELPER_BASE + { + public: + SUBOBJECT_HELPER_BASE() { Init(); } + virtual ~SUBOBJECT_HELPER_BASE() {} + virtual D3D12_STATE_SUBOBJECT_TYPE Type() const = 0; + void AddToStateObject(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject) + { + m_pSubobject = ContainingStateObject.TrackSubobject(Type(), Data()); + } + protected: + virtual void* Data() = 0; + void Init() { m_pSubobject = nullptr; } + D3D12_STATE_SUBOBJECT* m_pSubobject; + }; + +#if(__cplusplus >= 201103L) + std::list> m_OwnedSubobjectHelpers; +#else + class OWNED_HELPER + { + public: + OWNED_HELPER(const SUBOBJECT_HELPER_BASE* pHelper) { m_pHelper = pHelper; } + ~OWNED_HELPER() { delete m_pHelper; } + const SUBOBJECT_HELPER_BASE* m_pHelper; + }; + + std::list m_OwnedSubobjectHelpers; +#endif + + friend class CD3DX12_DXIL_LIBRARY_SUBOBJECT; + friend class CD3DX12_EXISTING_COLLECTION_SUBOBJECT; + friend class CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT; + friend class CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION; + friend class CD3DX12_HIT_GROUP_SUBOBJECT; + friend class CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT; + friend class CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT; + friend class CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT; + friend class CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT; + friend class CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT; + friend class CD3DX12_NODE_MASK_SUBOBJECT; +}; + +//------------------------------------------------------------------------------------------------ +class CD3DX12_DXIL_LIBRARY_SUBOBJECT + : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE +{ +public: + CD3DX12_DXIL_LIBRARY_SUBOBJECT() + { + Init(); + } + CD3DX12_DXIL_LIBRARY_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject) + { + Init(); + AddToStateObject(ContainingStateObject); + } + void SetDXILLibrary(D3D12_SHADER_BYTECODE*pCode) + { + static const D3D12_SHADER_BYTECODE Default = {}; + m_Desc.DXILLibrary = pCode ? *pCode : Default; + } + void DefineExport( + LPCWSTR Name, + LPCWSTR ExportToRename = nullptr, + D3D12_EXPORT_FLAGS Flags = D3D12_EXPORT_FLAG_NONE) + { + D3D12_EXPORT_DESC Export; + Export.Name = m_Strings.LocalCopy(Name); + Export.ExportToRename = m_Strings.LocalCopy(ExportToRename); + Export.Flags = Flags; + m_Exports.push_back(Export); + m_Desc.pExports = &m_Exports[0]; // using ugly way to get pointer in case .data() is not defined + m_Desc.NumExports = static_cast(m_Exports.size()); + } + template + void DefineExports(LPCWSTR(&Exports)[N]) + { + for (UINT i = 0; i < N; i++) + { + DefineExport(Exports[i]); + } + } + void DefineExports(LPCWSTR* Exports, UINT N) + { + for (UINT i = 0; i < N; i++) + { + DefineExport(Exports[i]); + } + } + D3D12_STATE_SUBOBJECT_TYPE Type() const + { + return D3D12_STATE_SUBOBJECT_TYPE_DXIL_LIBRARY; + } + operator const D3D12_STATE_SUBOBJECT&() const { return *m_pSubobject; } + operator const D3D12_DXIL_LIBRARY_DESC&() const { return m_Desc; } +private: + void Init() + { + SUBOBJECT_HELPER_BASE::Init(); + m_Desc = {}; + m_Strings.clear(); + m_Exports.clear(); + } + void* Data() { return &m_Desc; } + D3D12_DXIL_LIBRARY_DESC m_Desc; + CD3DX12_STATE_OBJECT_DESC::StringContainer m_Strings; + std::vector m_Exports; +}; + +//------------------------------------------------------------------------------------------------ +class CD3DX12_EXISTING_COLLECTION_SUBOBJECT + : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE +{ +public: + CD3DX12_EXISTING_COLLECTION_SUBOBJECT() + { + Init(); + } + CD3DX12_EXISTING_COLLECTION_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject) + { + Init(); + AddToStateObject(ContainingStateObject); + } + void SetExistingCollection(ID3D12StateObject*pExistingCollection) + { + m_Desc.pExistingCollection = pExistingCollection; + m_CollectionRef = pExistingCollection; + } + void DefineExport( + LPCWSTR Name, + LPCWSTR ExportToRename = nullptr, + D3D12_EXPORT_FLAGS Flags = D3D12_EXPORT_FLAG_NONE) + { + D3D12_EXPORT_DESC Export; + Export.Name = m_Strings.LocalCopy(Name); + Export.ExportToRename = m_Strings.LocalCopy(ExportToRename); + Export.Flags = Flags; + m_Exports.push_back(Export); + m_Desc.pExports = &m_Exports[0]; // using ugly way to get pointer in case .data() is not defined + m_Desc.NumExports = static_cast(m_Exports.size()); + } + template + void DefineExports(LPCWSTR(&Exports)[N]) + { + for (UINT i = 0; i < N; i++) + { + DefineExport(Exports[i]); + } + } + void DefineExports(LPCWSTR* Exports, UINT N) + { + for (UINT i = 0; i < N; i++) + { + DefineExport(Exports[i]); + } + } + D3D12_STATE_SUBOBJECT_TYPE Type() const + { + return D3D12_STATE_SUBOBJECT_TYPE_EXISTING_COLLECTION; + } + operator const D3D12_STATE_SUBOBJECT&() const { return *m_pSubobject; } + operator const D3D12_EXISTING_COLLECTION_DESC&() const { return m_Desc; } +private: + void Init() + { + SUBOBJECT_HELPER_BASE::Init(); + m_Desc = {}; + m_CollectionRef = nullptr; + m_Strings.clear(); + m_Exports.clear(); + } + void* Data() { return &m_Desc; } + D3D12_EXISTING_COLLECTION_DESC m_Desc; + Microsoft::WRL::ComPtr m_CollectionRef; + CD3DX12_STATE_OBJECT_DESC::StringContainer m_Strings; + std::vector m_Exports; +}; + +//------------------------------------------------------------------------------------------------ +class CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT + : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE +{ +public: + CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT() + { + Init(); + } + CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject) + { + Init(); + AddToStateObject(ContainingStateObject); + } + void SetSubobjectToAssociate(const D3D12_STATE_SUBOBJECT& SubobjectToAssociate) + { + m_Desc.pSubobjectToAssociate = &SubobjectToAssociate; + } + void AddExport(LPCWSTR Export) + { + m_Desc.NumExports++; + m_Exports.push_back(m_Strings.LocalCopy(Export)); + m_Desc.pExports = &m_Exports[0]; // using ugly way to get pointer in case .data() is not defined + } + template + void AddExports(LPCWSTR (&Exports)[N]) + { + for (UINT i = 0; i < N; i++) + { + AddExport(Exports[i]); + } + } + void AddExports(LPCWSTR* Exports, UINT N) + { + for (UINT i = 0; i < N; i++) + { + AddExport(Exports[i]); + } + } + D3D12_STATE_SUBOBJECT_TYPE Type() const + { + return D3D12_STATE_SUBOBJECT_TYPE_SUBOBJECT_TO_EXPORTS_ASSOCIATION; + } + operator const D3D12_STATE_SUBOBJECT&() const { return *m_pSubobject; } + operator const D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION&() const { return m_Desc; } +private: + void Init() + { + SUBOBJECT_HELPER_BASE::Init(); + m_Desc = {}; + m_Strings.clear(); + m_Exports.clear(); + } + void* Data() { return &m_Desc; } + D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION m_Desc; + CD3DX12_STATE_OBJECT_DESC::StringContainer m_Strings; + std::vector m_Exports; +}; + +//------------------------------------------------------------------------------------------------ +class CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION + : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE +{ +public: + CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION() + { + Init(); + } + CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject) + { + Init(); + AddToStateObject(ContainingStateObject); + } + void SetSubobjectNameToAssociate(LPCWSTR SubobjectToAssociate) + { + m_Desc.SubobjectToAssociate = m_SubobjectName.LocalCopy(SubobjectToAssociate, true); + } + void AddExport(LPCWSTR Export) + { + m_Desc.NumExports++; + m_Exports.push_back(m_Strings.LocalCopy(Export)); + m_Desc.pExports = &m_Exports[0]; // using ugly way to get pointer in case .data() is not defined + } + template + void AddExports(LPCWSTR (&Exports)[N]) + { + for (UINT i = 0; i < N; i++) + { + AddExport(Exports[i]); + } + } + void AddExports(LPCWSTR* Exports, UINT N) + { + for (UINT i = 0; i < N; i++) + { + AddExport(Exports[i]); + } + } + D3D12_STATE_SUBOBJECT_TYPE Type() const + { + return D3D12_STATE_SUBOBJECT_TYPE_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION; + } + operator const D3D12_STATE_SUBOBJECT&() const { return *m_pSubobject; } + operator const D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION&() const { return m_Desc; } +private: + void Init() + { + SUBOBJECT_HELPER_BASE::Init(); + m_Desc = {}; + m_Strings.clear(); + m_SubobjectName.clear(); + m_Exports.clear(); + } + void* Data() { return &m_Desc; } + D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION m_Desc; + CD3DX12_STATE_OBJECT_DESC::StringContainer m_Strings; + CD3DX12_STATE_OBJECT_DESC::StringContainer m_SubobjectName; + std::vector m_Exports; +}; + +//------------------------------------------------------------------------------------------------ +class CD3DX12_HIT_GROUP_SUBOBJECT + : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE +{ +public: + CD3DX12_HIT_GROUP_SUBOBJECT() + { + Init(); + } + CD3DX12_HIT_GROUP_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject) + { + Init(); + AddToStateObject(ContainingStateObject); + } + void SetHitGroupExport(LPCWSTR exportName) + { + m_Desc.HitGroupExport = m_Strings[0].LocalCopy(exportName, true); + } + void SetHitGroupType(D3D12_HIT_GROUP_TYPE Type) { m_Desc.Type = Type; } + void SetAnyHitShaderImport(LPCWSTR importName) + { + m_Desc.AnyHitShaderImport = m_Strings[1].LocalCopy(importName, true); + } + void SetClosestHitShaderImport(LPCWSTR importName) + { + m_Desc.ClosestHitShaderImport = m_Strings[2].LocalCopy(importName, true); + } + void SetIntersectionShaderImport(LPCWSTR importName) + { + m_Desc.IntersectionShaderImport = m_Strings[3].LocalCopy(importName, true); + } + D3D12_STATE_SUBOBJECT_TYPE Type() const + { + return D3D12_STATE_SUBOBJECT_TYPE_HIT_GROUP; + } + operator const D3D12_STATE_SUBOBJECT&() const { return *m_pSubobject; } + operator const D3D12_HIT_GROUP_DESC&() const { return m_Desc; } +private: + void Init() + { + SUBOBJECT_HELPER_BASE::Init(); + m_Desc = {}; + for (UINT i = 0; i < m_NumStrings; i++) + { + m_Strings[i].clear(); + } + } + void* Data() { return &m_Desc; } + D3D12_HIT_GROUP_DESC m_Desc; + static const UINT m_NumStrings = 4; + CD3DX12_STATE_OBJECT_DESC::StringContainer + m_Strings[m_NumStrings]; // one string for every entrypoint name +}; + +//------------------------------------------------------------------------------------------------ +class CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT + : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE +{ +public: + CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT() + { + Init(); + } + CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject) + { + Init(); + AddToStateObject(ContainingStateObject); + } + void Config(UINT MaxPayloadSizeInBytes, UINT MaxAttributeSizeInBytes) + { + m_Desc.MaxPayloadSizeInBytes = MaxPayloadSizeInBytes; + m_Desc.MaxAttributeSizeInBytes = MaxAttributeSizeInBytes; + } + D3D12_STATE_SUBOBJECT_TYPE Type() const + { + return D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_SHADER_CONFIG; + } + operator const D3D12_STATE_SUBOBJECT&() const { return *m_pSubobject; } + operator const D3D12_RAYTRACING_SHADER_CONFIG&() const { return m_Desc; } +private: + void Init() + { + SUBOBJECT_HELPER_BASE::Init(); + m_Desc = {}; + } + void* Data() { return &m_Desc; } + D3D12_RAYTRACING_SHADER_CONFIG m_Desc; +}; + +//------------------------------------------------------------------------------------------------ +class CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT + : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE +{ +public: + CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT() + { + Init(); + } + CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject) + { + Init(); + AddToStateObject(ContainingStateObject); + } + void Config(UINT MaxTraceRecursionDepth) + { + m_Desc.MaxTraceRecursionDepth = MaxTraceRecursionDepth; + } + D3D12_STATE_SUBOBJECT_TYPE Type() const + { + return D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG; + } + operator const D3D12_STATE_SUBOBJECT&() const { return *m_pSubobject; } + operator const D3D12_RAYTRACING_PIPELINE_CONFIG&() const { return m_Desc; } +private: + void Init() + { + SUBOBJECT_HELPER_BASE::Init(); + m_Desc = {}; + } + void* Data() { return &m_Desc; } + D3D12_RAYTRACING_PIPELINE_CONFIG m_Desc; +}; + +//------------------------------------------------------------------------------------------------ +class CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT + : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE +{ +public: + CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT() + { + Init(); + } + CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject) + { + Init(); + AddToStateObject(ContainingStateObject); + } + void SetRootSignature(ID3D12RootSignature* pRootSig) + { + m_pRootSig = pRootSig; + } + D3D12_STATE_SUBOBJECT_TYPE Type() const + { + return D3D12_STATE_SUBOBJECT_TYPE_GLOBAL_ROOT_SIGNATURE; + } + operator const D3D12_STATE_SUBOBJECT&() const { return *m_pSubobject; } + operator ID3D12RootSignature*() const { return m_pRootSig.Get(); } +private: + void Init() + { + SUBOBJECT_HELPER_BASE::Init(); + m_pRootSig = nullptr; + } + void* Data() { return m_pRootSig.GetAddressOf(); } + Microsoft::WRL::ComPtr m_pRootSig; +}; + +//------------------------------------------------------------------------------------------------ +class CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT + : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE +{ +public: + CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT() + { + Init(); + } + CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject) + { + Init(); + AddToStateObject(ContainingStateObject); + } + void SetRootSignature(ID3D12RootSignature* pRootSig) + { + m_pRootSig = pRootSig; + } + D3D12_STATE_SUBOBJECT_TYPE Type() const + { + return D3D12_STATE_SUBOBJECT_TYPE_LOCAL_ROOT_SIGNATURE; + } + operator const D3D12_STATE_SUBOBJECT&() const { return *m_pSubobject; } + operator ID3D12RootSignature*() const { return m_pRootSig.Get(); } +private: + void Init() + { + SUBOBJECT_HELPER_BASE::Init(); + m_pRootSig = nullptr; + } + void* Data() { return m_pRootSig.GetAddressOf(); } + Microsoft::WRL::ComPtr m_pRootSig; +}; + +//------------------------------------------------------------------------------------------------ +class CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT + : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE +{ +public: + CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT() + { + Init(); + } + CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject) + { + Init(); + AddToStateObject(ContainingStateObject); + } + void SetFlags(D3D12_STATE_OBJECT_FLAGS Flags) + { + m_Desc.Flags = Flags; + } + D3D12_STATE_SUBOBJECT_TYPE Type() const + { + return D3D12_STATE_SUBOBJECT_TYPE_STATE_OBJECT_CONFIG; + } + operator const D3D12_STATE_SUBOBJECT&() const { return *m_pSubobject; } + operator const D3D12_STATE_OBJECT_CONFIG&() const { return m_Desc; } +private: + void Init() + { + SUBOBJECT_HELPER_BASE::Init(); + m_Desc = {}; + } + void* Data() { return &m_Desc; } + D3D12_STATE_OBJECT_CONFIG m_Desc; +}; + +//------------------------------------------------------------------------------------------------ +class CD3DX12_NODE_MASK_SUBOBJECT + : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE +{ +public: + CD3DX12_NODE_MASK_SUBOBJECT() + { + Init(); + } + CD3DX12_NODE_MASK_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject) + { + Init(); + AddToStateObject(ContainingStateObject); + } + void SetNodeMask(UINT NodeMask) + { + m_Desc.NodeMask = NodeMask; + } + D3D12_STATE_SUBOBJECT_TYPE Type() const + { + return D3D12_STATE_SUBOBJECT_TYPE_NODE_MASK; + } + operator const D3D12_STATE_SUBOBJECT&() const { return *m_pSubobject; } + operator const D3D12_NODE_MASK&() const { return m_Desc; } +private: + void Init() + { + SUBOBJECT_HELPER_BASE::Init(); + m_Desc = {}; + } + void* Data() { return &m_Desc; } + D3D12_NODE_MASK m_Desc; +}; + +#endif // #ifndef D3DX12_NO_STATE_OBJECT_HELPERS + +#endif // defined( __cplusplus ) + +#endif //__D3DX12_H__ diff --git a/src/decomp/pc/gfx/gfx_cc.c b/src/decomp/pc/gfx/gfx_cc.c new file mode 100644 index 0000000..d43f54b --- /dev/null +++ b/src/decomp/pc/gfx/gfx_cc.c @@ -0,0 +1,41 @@ +#include "gfx_cc.h" + +void gfx_cc_get_features(uint32_t shader_id, struct CCFeatures *cc_features) { + for (int i = 0; i < 4; i++) { + cc_features->c[0][i] = (shader_id >> (i * 3)) & 7; + cc_features->c[1][i] = (shader_id >> (12 + i * 3)) & 7; + } + + cc_features->opt_alpha = (shader_id & SHADER_OPT_ALPHA) != 0; + cc_features->opt_fog = (shader_id & SHADER_OPT_FOG) != 0; + cc_features->opt_texture_edge = (shader_id & SHADER_OPT_TEXTURE_EDGE) != 0; + cc_features->opt_noise = (shader_id & SHADER_OPT_NOISE) != 0; + + cc_features->used_textures[0] = false; + cc_features->used_textures[1] = false; + cc_features->num_inputs = 0; + + for (int i = 0; i < 2; i++) { + for (int j = 0; j < 4; j++) { + if (cc_features->c[i][j] >= SHADER_INPUT_1 && cc_features->c[i][j] <= SHADER_INPUT_4) { + if (cc_features->c[i][j] > cc_features->num_inputs) { + cc_features->num_inputs = cc_features->c[i][j]; + } + } + if (cc_features->c[i][j] == SHADER_TEXEL0 || cc_features->c[i][j] == SHADER_TEXEL0A) { + cc_features->used_textures[0] = true; + } + if (cc_features->c[i][j] == SHADER_TEXEL1) { + cc_features->used_textures[1] = true; + } + } + } + + cc_features->do_single[0] = cc_features->c[0][2] == 0; + cc_features->do_single[1] = cc_features->c[1][2] == 0; + cc_features->do_multiply[0] = cc_features->c[0][1] == 0 && cc_features->c[0][3] == 0; + cc_features->do_multiply[1] = cc_features->c[1][1] == 0 && cc_features->c[1][3] == 0; + cc_features->do_mix[0] = cc_features->c[0][1] == cc_features->c[0][3]; + cc_features->do_mix[1] = cc_features->c[1][1] == cc_features->c[1][3]; + cc_features->color_alpha_same = (shader_id & 0xfff) == ((shader_id >> 12) & 0xfff); +} diff --git a/src/decomp/pc/gfx/gfx_cc.h b/src/decomp/pc/gfx/gfx_cc.h new file mode 100644 index 0000000..2840b83 --- /dev/null +++ b/src/decomp/pc/gfx/gfx_cc.h @@ -0,0 +1,58 @@ +#ifndef GFX_CC_H +#define GFX_CC_H + +#include +#include + +enum { + CC_0, + CC_TEXEL0, + CC_TEXEL1, + CC_PRIM, + CC_SHADE, + CC_ENV, + CC_TEXEL0A, + CC_LOD +}; + +enum { + SHADER_0, + SHADER_INPUT_1, + SHADER_INPUT_2, + SHADER_INPUT_3, + SHADER_INPUT_4, + SHADER_TEXEL0, + SHADER_TEXEL0A, + SHADER_TEXEL1 +}; + +#define SHADER_OPT_ALPHA (1 << 24) +#define SHADER_OPT_FOG (1 << 25) +#define SHADER_OPT_TEXTURE_EDGE (1 << 26) +#define SHADER_OPT_NOISE (1 << 27) + +struct CCFeatures { + uint8_t c[2][4]; + bool opt_alpha; + bool opt_fog; + bool opt_texture_edge; + bool opt_noise; + bool used_textures[2]; + int num_inputs; + bool do_single[2]; + bool do_multiply[2]; + bool do_mix[2]; + bool color_alpha_same; +}; + +#ifdef __cplusplus +extern "C" { +#endif + +void gfx_cc_get_features(uint32_t shader_id, struct CCFeatures *cc_features); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/decomp/pc/gfx/gfx_direct3d11.cpp b/src/decomp/pc/gfx/gfx_direct3d11.cpp new file mode 100644 index 0000000..e5ee445 --- /dev/null +++ b/src/decomp/pc/gfx/gfx_direct3d11.cpp @@ -0,0 +1,731 @@ +#ifdef ENABLE_DX11 + +#include +#include +#include + +#include +#include +#include + +#include +#include +#include + +#ifndef _LANGUAGE_C +#define _LANGUAGE_C +#endif +#include + +#include "gfx_cc.h" +#include "gfx_window_manager_api.h" +#include "gfx_rendering_api.h" +#include "gfx_direct3d_common.h" + +#define DECLARE_GFX_DXGI_FUNCTIONS +#include "gfx_dxgi.h" + +#include "gfx_screen_config.h" + +#define THREE_POINT_FILTERING 0 +#define DEBUG_D3D 0 + +using namespace Microsoft::WRL; // For ComPtr + +namespace { + +struct PerFrameCB { + uint32_t noise_frame; + float noise_scale_x; + float noise_scale_y; + uint32_t padding; +}; + +struct PerDrawCB { + struct Texture { + uint32_t width; + uint32_t height; + uint32_t linear_filtering; + uint32_t padding; + } textures[2]; +}; + +struct TextureData { + ComPtr resource_view; + ComPtr sampler_state; + uint32_t width; + uint32_t height; + bool linear_filtering; +}; + +struct ShaderProgramD3D11 { + ComPtr vertex_shader; + ComPtr pixel_shader; + ComPtr input_layout; + ComPtr blend_state; + + uint32_t shader_id; + uint8_t num_inputs; + uint8_t num_floats; + bool used_textures[2]; +}; + +static struct { + HMODULE d3d11_module; + PFN_D3D11_CREATE_DEVICE D3D11CreateDevice; + + HMODULE d3dcompiler_module; + pD3DCompile D3DCompile; + + D3D_FEATURE_LEVEL feature_level; + + ComPtr device; + ComPtr swap_chain; + ComPtr context; + ComPtr backbuffer_view; + ComPtr depth_stencil_view; + ComPtr rasterizer_state; + ComPtr depth_stencil_state; + ComPtr vertex_buffer; + ComPtr per_frame_cb; + ComPtr per_draw_cb; + +#if DEBUG_D3D + ComPtr debug; +#endif + + DXGI_SAMPLE_DESC sample_description; + + PerFrameCB per_frame_cb_data; + PerDrawCB per_draw_cb_data; + + struct ShaderProgramD3D11 shader_program_pool[64]; + uint8_t shader_program_pool_size; + + std::vector textures; + int current_tile; + uint32_t current_texture_ids[2]; + + // Current state + + struct ShaderProgramD3D11 *shader_program; + + uint32_t current_width, current_height; + + int8_t depth_test; + int8_t depth_mask; + int8_t zmode_decal; + + // Previous states (to prevent setting states needlessly) + + struct ShaderProgramD3D11 *last_shader_program = nullptr; + uint32_t last_vertex_buffer_stride = 0; + ComPtr last_blend_state = nullptr; + ComPtr last_resource_views[2] = { nullptr, nullptr }; + ComPtr last_sampler_states[2] = { nullptr, nullptr }; + int8_t last_depth_test = -1; + int8_t last_depth_mask = -1; + int8_t last_zmode_decal = -1; + D3D_PRIMITIVE_TOPOLOGY last_primitive_topology = D3D_PRIMITIVE_TOPOLOGY_UNDEFINED; +} d3d; + +static LARGE_INTEGER last_time, accumulated_time, frequency; + +static void create_render_target_views(bool is_resize) { + DXGI_SWAP_CHAIN_DESC1 desc1; + + if (is_resize) { + // Release previous stuff (if any) + + d3d.backbuffer_view.Reset(); + d3d.depth_stencil_view.Reset(); + + // Resize swap chain buffers + + ThrowIfFailed(d3d.swap_chain->GetDesc1(&desc1)); + ThrowIfFailed(d3d.swap_chain->ResizeBuffers(0, 0, 0, DXGI_FORMAT_UNKNOWN, desc1.Flags), + gfx_dxgi_get_h_wnd(), "Failed to resize IDXGISwapChain buffers."); + } + + // Get new size + + ThrowIfFailed(d3d.swap_chain->GetDesc1(&desc1)); + + // Create back buffer + + ComPtr backbuffer_texture; + ThrowIfFailed(d3d.swap_chain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID *) backbuffer_texture.GetAddressOf()), + gfx_dxgi_get_h_wnd(), "Failed to get backbuffer from IDXGISwapChain."); + + ThrowIfFailed(d3d.device->CreateRenderTargetView(backbuffer_texture.Get(), nullptr, d3d.backbuffer_view.GetAddressOf()), + gfx_dxgi_get_h_wnd(), "Failed to create render target view."); + + // Create depth buffer + + D3D11_TEXTURE2D_DESC depth_stencil_texture_desc; + ZeroMemory(&depth_stencil_texture_desc, sizeof(D3D11_TEXTURE2D_DESC)); + + depth_stencil_texture_desc.Width = desc1.Width; + depth_stencil_texture_desc.Height = desc1.Height; + depth_stencil_texture_desc.MipLevels = 1; + depth_stencil_texture_desc.ArraySize = 1; + depth_stencil_texture_desc.Format = d3d.feature_level >= D3D_FEATURE_LEVEL_10_0 ? + DXGI_FORMAT_D32_FLOAT : DXGI_FORMAT_D24_UNORM_S8_UINT; + depth_stencil_texture_desc.SampleDesc = d3d.sample_description; + depth_stencil_texture_desc.Usage = D3D11_USAGE_DEFAULT; + depth_stencil_texture_desc.BindFlags = D3D11_BIND_DEPTH_STENCIL; + depth_stencil_texture_desc.CPUAccessFlags = 0; + depth_stencil_texture_desc.MiscFlags = 0; + + ComPtr depth_stencil_texture; + ThrowIfFailed(d3d.device->CreateTexture2D(&depth_stencil_texture_desc, nullptr, depth_stencil_texture.GetAddressOf())); + ThrowIfFailed(d3d.device->CreateDepthStencilView(depth_stencil_texture.Get(), nullptr, d3d.depth_stencil_view.GetAddressOf())); + + // Save resolution + + d3d.current_width = desc1.Width; + d3d.current_height = desc1.Height; +} + +static void gfx_d3d11_init(void) { + // Load d3d11.dll + d3d.d3d11_module = LoadLibraryW(L"d3d11.dll"); + if (d3d.d3d11_module == nullptr) { + ThrowIfFailed(HRESULT_FROM_WIN32(GetLastError()), gfx_dxgi_get_h_wnd(), "d3d11.dll could not be loaded"); + } + d3d.D3D11CreateDevice = (PFN_D3D11_CREATE_DEVICE)GetProcAddress(d3d.d3d11_module, "D3D11CreateDevice"); + + // Load D3DCompiler_47.dll or D3DCompiler_43.dll + d3d.d3dcompiler_module = LoadLibraryW(L"D3DCompiler_47.dll"); + if (d3d.d3dcompiler_module == nullptr) { + d3d.d3dcompiler_module = LoadLibraryW(L"D3DCompiler_43.dll"); + if (d3d.d3dcompiler_module == nullptr) { + ThrowIfFailed(HRESULT_FROM_WIN32(GetLastError()), gfx_dxgi_get_h_wnd(), "D3DCompiler_47.dll or D3DCompiler_43.dll could not be loaded"); + } + } + d3d.D3DCompile = (pD3DCompile)GetProcAddress(d3d.d3dcompiler_module, "D3DCompile"); + + // Create D3D11 device + + gfx_dxgi_create_factory_and_device(DEBUG_D3D, 11, [](IDXGIAdapter1 *adapter, bool test_only) { +#if DEBUG_D3D + UINT device_creation_flags = D3D11_CREATE_DEVICE_DEBUG; +#else + UINT device_creation_flags = 0; +#endif + D3D_FEATURE_LEVEL FeatureLevels[] = { + D3D_FEATURE_LEVEL_11_0, + D3D_FEATURE_LEVEL_10_1, + D3D_FEATURE_LEVEL_10_0, + D3D_FEATURE_LEVEL_9_3, + D3D_FEATURE_LEVEL_9_2, + D3D_FEATURE_LEVEL_9_1 + }; + + HRESULT res = d3d.D3D11CreateDevice( + adapter, + D3D_DRIVER_TYPE_UNKNOWN, // since we use a specific adapter + nullptr, + device_creation_flags, + FeatureLevels, + ARRAYSIZE(FeatureLevels), + D3D11_SDK_VERSION, + test_only ? nullptr : d3d.device.GetAddressOf(), + &d3d.feature_level, + test_only ? nullptr : d3d.context.GetAddressOf()); + + if (test_only) { + return SUCCEEDED(res); + } else { + ThrowIfFailed(res, gfx_dxgi_get_h_wnd(), "Failed to create D3D11 device."); + return true; + } + }); + + // Sample description to be used in back buffer and depth buffer + + d3d.sample_description.Count = 1; + d3d.sample_description.Quality = 0; + + // Create the swap chain + d3d.swap_chain = gfx_dxgi_create_swap_chain(d3d.device.Get()); + + // Create D3D Debug device if in debug mode + +#if DEBUG_D3D + ThrowIfFailed(d3d.device->QueryInterface(__uuidof(ID3D11Debug), (void **) d3d.debug.GetAddressOf()), + gfx_dxgi_get_h_wnd(), "Failed to get ID3D11Debug device."); +#endif + + // Create views + + create_render_target_views(false); + + // Create main vertex buffer + + D3D11_BUFFER_DESC vertex_buffer_desc; + ZeroMemory(&vertex_buffer_desc, sizeof(D3D11_BUFFER_DESC)); + + vertex_buffer_desc.Usage = D3D11_USAGE_DYNAMIC; + vertex_buffer_desc.ByteWidth = 256 * 26 * 3 * sizeof(float); // Same as buf_vbo size in gfx_pc + vertex_buffer_desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; + vertex_buffer_desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + vertex_buffer_desc.MiscFlags = 0; + + ThrowIfFailed(d3d.device->CreateBuffer(&vertex_buffer_desc, nullptr, d3d.vertex_buffer.GetAddressOf()), + gfx_dxgi_get_h_wnd(), "Failed to create vertex buffer."); + + // Create per-frame constant buffer + + D3D11_BUFFER_DESC constant_buffer_desc; + ZeroMemory(&constant_buffer_desc, sizeof(D3D11_BUFFER_DESC)); + + constant_buffer_desc.Usage = D3D11_USAGE_DYNAMIC; + constant_buffer_desc.ByteWidth = sizeof(PerFrameCB); + constant_buffer_desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; + constant_buffer_desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + constant_buffer_desc.MiscFlags = 0; + + ThrowIfFailed(d3d.device->CreateBuffer(&constant_buffer_desc, nullptr, d3d.per_frame_cb.GetAddressOf()), + gfx_dxgi_get_h_wnd(), "Failed to create per-frame constant buffer."); + + d3d.context->PSSetConstantBuffers(0, 1, d3d.per_frame_cb.GetAddressOf()); + + // Create per-draw constant buffer + + constant_buffer_desc.Usage = D3D11_USAGE_DYNAMIC; + constant_buffer_desc.ByteWidth = sizeof(PerDrawCB); + constant_buffer_desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; + constant_buffer_desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + constant_buffer_desc.MiscFlags = 0; + + ThrowIfFailed(d3d.device->CreateBuffer(&constant_buffer_desc, nullptr, d3d.per_draw_cb.GetAddressOf()), + gfx_dxgi_get_h_wnd(), "Failed to create per-draw constant buffer."); + + d3d.context->PSSetConstantBuffers(1, 1, d3d.per_draw_cb.GetAddressOf()); +} + + +static bool gfx_d3d11_z_is_from_0_to_1(void) { + return true; +} + +static void gfx_d3d11_unload_shader(struct ShaderProgram *old_prg) { +} + +static void gfx_d3d11_load_shader(struct ShaderProgram *new_prg) { + d3d.shader_program = (struct ShaderProgramD3D11 *)new_prg; +} + +static struct ShaderProgram *gfx_d3d11_create_and_load_new_shader(uint32_t shader_id) { + CCFeatures cc_features; + gfx_cc_get_features(shader_id, &cc_features); + + char buf[4096]; + size_t len, num_floats; + + gfx_direct3d_common_build_shader(buf, len, num_floats, cc_features, false, THREE_POINT_FILTERING); + + ComPtr vs, ps; + ComPtr error_blob; + +#if DEBUG_D3D + UINT compile_flags = D3DCOMPILE_DEBUG; +#else + UINT compile_flags = D3DCOMPILE_OPTIMIZATION_LEVEL2; +#endif + + HRESULT hr = d3d.D3DCompile(buf, len, nullptr, nullptr, nullptr, "VSMain", "vs_4_0_level_9_1", compile_flags, 0, vs.GetAddressOf(), error_blob.GetAddressOf()); + + if (FAILED(hr)) { + MessageBox(gfx_dxgi_get_h_wnd(), (char *) error_blob->GetBufferPointer(), "Error", MB_OK | MB_ICONERROR); + throw hr; + } + + hr = d3d.D3DCompile(buf, len, nullptr, nullptr, nullptr, "PSMain", "ps_4_0_level_9_1", compile_flags, 0, ps.GetAddressOf(), error_blob.GetAddressOf()); + + if (FAILED(hr)) { + MessageBox(gfx_dxgi_get_h_wnd(), (char *) error_blob->GetBufferPointer(), "Error", MB_OK | MB_ICONERROR); + throw hr; + } + + struct ShaderProgramD3D11 *prg = &d3d.shader_program_pool[d3d.shader_program_pool_size++]; + + ThrowIfFailed(d3d.device->CreateVertexShader(vs->GetBufferPointer(), vs->GetBufferSize(), nullptr, prg->vertex_shader.GetAddressOf())); + ThrowIfFailed(d3d.device->CreatePixelShader(ps->GetBufferPointer(), ps->GetBufferSize(), nullptr, prg->pixel_shader.GetAddressOf())); + + // Input Layout + + D3D11_INPUT_ELEMENT_DESC ied[7]; + uint8_t ied_index = 0; + ied[ied_index++] = { "POSITION", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }; + if (cc_features.used_textures[0] || cc_features.used_textures[1]) { + ied[ied_index++] = { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }; + } + if (cc_features.opt_fog) { + ied[ied_index++] = { "FOG", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }; + } + for (unsigned int i = 0; i < cc_features.num_inputs; i++) { + DXGI_FORMAT format = cc_features.opt_alpha ? DXGI_FORMAT_R32G32B32A32_FLOAT : DXGI_FORMAT_R32G32B32_FLOAT; + ied[ied_index++] = { "INPUT", i, format, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }; + } + + ThrowIfFailed(d3d.device->CreateInputLayout(ied, ied_index, vs->GetBufferPointer(), vs->GetBufferSize(), prg->input_layout.GetAddressOf())); + + // Blend state + + D3D11_BLEND_DESC blend_desc; + ZeroMemory(&blend_desc, sizeof(D3D11_BLEND_DESC)); + + if (cc_features.opt_alpha) { + blend_desc.RenderTarget[0].BlendEnable = true; + blend_desc.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA; + blend_desc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA; + blend_desc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD; + blend_desc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE; + blend_desc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO; + blend_desc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD; + blend_desc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL; + } else { + blend_desc.RenderTarget[0].BlendEnable = false; + blend_desc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL; + } + + ThrowIfFailed(d3d.device->CreateBlendState(&blend_desc, prg->blend_state.GetAddressOf())); + + // Save some values + + prg->shader_id = shader_id; + prg->num_inputs = cc_features.num_inputs; + prg->num_floats = num_floats; + prg->used_textures[0] = cc_features.used_textures[0]; + prg->used_textures[1] = cc_features.used_textures[1]; + + return (struct ShaderProgram *)(d3d.shader_program = prg); +} + +static struct ShaderProgram *gfx_d3d11_lookup_shader(uint32_t shader_id) { + for (size_t i = 0; i < d3d.shader_program_pool_size; i++) { + if (d3d.shader_program_pool[i].shader_id == shader_id) { + return (struct ShaderProgram *)&d3d.shader_program_pool[i]; + } + } + return nullptr; +} + +static void gfx_d3d11_shader_get_info(struct ShaderProgram *prg, uint8_t *num_inputs, bool used_textures[2]) { + struct ShaderProgramD3D11 *p = (struct ShaderProgramD3D11 *)prg; + + *num_inputs = p->num_inputs; + used_textures[0] = p->used_textures[0]; + used_textures[1] = p->used_textures[1]; +} + +static uint32_t gfx_d3d11_new_texture(void) { + d3d.textures.resize(d3d.textures.size() + 1); + return (uint32_t)(d3d.textures.size() - 1); +} + +static void gfx_d3d11_select_texture(int tile, uint32_t texture_id) { + d3d.current_tile = tile; + d3d.current_texture_ids[tile] = texture_id; +} + +static D3D11_TEXTURE_ADDRESS_MODE gfx_cm_to_d3d11(uint32_t val) { + if (val & G_TX_CLAMP) { + return D3D11_TEXTURE_ADDRESS_CLAMP; + } + return (val & G_TX_MIRROR) ? D3D11_TEXTURE_ADDRESS_MIRROR : D3D11_TEXTURE_ADDRESS_WRAP; +} + +static void gfx_d3d11_upload_texture(const uint8_t *rgba32_buf, int width, int height) { + // Create texture + + D3D11_TEXTURE2D_DESC texture_desc; + ZeroMemory(&texture_desc, sizeof(D3D11_TEXTURE2D_DESC)); + + texture_desc.Width = width; + texture_desc.Height = height; + texture_desc.Usage = D3D11_USAGE_IMMUTABLE; + texture_desc.BindFlags = D3D11_BIND_SHADER_RESOURCE; + texture_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; + texture_desc.CPUAccessFlags = 0; + texture_desc.MiscFlags = 0; // D3D11_RESOURCE_MISC_GENERATE_MIPS ? + texture_desc.ArraySize = 1; + texture_desc.MipLevels = 1; + texture_desc.SampleDesc.Count = 1; + texture_desc.SampleDesc.Quality = 0; + + D3D11_SUBRESOURCE_DATA resource_data; + resource_data.pSysMem = rgba32_buf; + resource_data.SysMemPitch = width * 4; + resource_data.SysMemSlicePitch = resource_data.SysMemPitch * height; + + ComPtr texture; + ThrowIfFailed(d3d.device->CreateTexture2D(&texture_desc, &resource_data, texture.GetAddressOf())); + + // Create shader resource view from texture + + D3D11_SHADER_RESOURCE_VIEW_DESC resource_view_desc; + ZeroMemory(&resource_view_desc, sizeof(D3D11_SHADER_RESOURCE_VIEW_DESC)); + + resource_view_desc.Format = texture_desc.Format; + resource_view_desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; + resource_view_desc.Texture2D.MostDetailedMip = 0; + resource_view_desc.Texture2D.MipLevels = -1; + + TextureData *texture_data = &d3d.textures[d3d.current_texture_ids[d3d.current_tile]]; + texture_data->width = width; + texture_data->height = height; + + if (texture_data->resource_view.Get() != nullptr) { + // Free the previous texture in this slot + texture_data->resource_view.Reset(); + } + + ThrowIfFailed(d3d.device->CreateShaderResourceView(texture.Get(), &resource_view_desc, texture_data->resource_view.GetAddressOf())); +} + +static void gfx_d3d11_set_sampler_parameters(int tile, bool linear_filter, uint32_t cms, uint32_t cmt) { + D3D11_SAMPLER_DESC sampler_desc; + ZeroMemory(&sampler_desc, sizeof(D3D11_SAMPLER_DESC)); + +#if THREE_POINT_FILTERING + sampler_desc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT; +#else + sampler_desc.Filter = linear_filter ? D3D11_FILTER_MIN_MAG_MIP_LINEAR : D3D11_FILTER_MIN_MAG_MIP_POINT; +#endif + sampler_desc.AddressU = gfx_cm_to_d3d11(cms); + sampler_desc.AddressV = gfx_cm_to_d3d11(cmt); + sampler_desc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP; + sampler_desc.MinLOD = 0; + sampler_desc.MaxLOD = D3D11_FLOAT32_MAX; + + TextureData *texture_data = &d3d.textures[d3d.current_texture_ids[tile]]; + texture_data->linear_filtering = linear_filter; + + // This function is called twice per texture, the first one only to set default values. + // Maybe that could be skipped? Anyway, make sure to release the first default sampler + // state before setting the actual one. + texture_data->sampler_state.Reset(); + + ThrowIfFailed(d3d.device->CreateSamplerState(&sampler_desc, texture_data->sampler_state.GetAddressOf())); +} + +static void gfx_d3d11_set_depth_test(bool depth_test) { + d3d.depth_test = depth_test; +} + +static void gfx_d3d11_set_depth_mask(bool depth_mask) { + d3d.depth_mask = depth_mask; +} + +static void gfx_d3d11_set_zmode_decal(bool zmode_decal) { + d3d.zmode_decal = zmode_decal; +} + +static void gfx_d3d11_set_viewport(int x, int y, int width, int height) { + D3D11_VIEWPORT viewport; + viewport.TopLeftX = x; + viewport.TopLeftY = d3d.current_height - y - height; + viewport.Width = width; + viewport.Height = height; + viewport.MinDepth = 0.0f; + viewport.MaxDepth = 1.0f; + + d3d.context->RSSetViewports(1, &viewport); +} + +static void gfx_d3d11_set_scissor(int x, int y, int width, int height) { + D3D11_RECT rect; + rect.left = x; + rect.top = d3d.current_height - y - height; + rect.right = x + width; + rect.bottom = d3d.current_height - y; + + d3d.context->RSSetScissorRects(1, &rect); +} + +static void gfx_d3d11_set_use_alpha(bool use_alpha) { + // Already part of the pipeline state from shader info +} + +static void gfx_d3d11_draw_triangles(float buf_vbo[], size_t buf_vbo_len, size_t buf_vbo_num_tris) { + + if (d3d.last_depth_test != d3d.depth_test || d3d.last_depth_mask != d3d.depth_mask) { + d3d.last_depth_test = d3d.depth_test; + d3d.last_depth_mask = d3d.depth_mask; + + d3d.depth_stencil_state.Reset(); + + D3D11_DEPTH_STENCIL_DESC depth_stencil_desc; + ZeroMemory(&depth_stencil_desc, sizeof(D3D11_DEPTH_STENCIL_DESC)); + + depth_stencil_desc.DepthEnable = d3d.depth_test; + depth_stencil_desc.DepthWriteMask = d3d.depth_mask ? D3D11_DEPTH_WRITE_MASK_ALL : D3D11_DEPTH_WRITE_MASK_ZERO; + depth_stencil_desc.DepthFunc = D3D11_COMPARISON_LESS_EQUAL; + depth_stencil_desc.StencilEnable = false; + + ThrowIfFailed(d3d.device->CreateDepthStencilState(&depth_stencil_desc, d3d.depth_stencil_state.GetAddressOf())); + d3d.context->OMSetDepthStencilState(d3d.depth_stencil_state.Get(), 0); + } + + if (d3d.last_zmode_decal != d3d.zmode_decal) { + d3d.last_zmode_decal = d3d.zmode_decal; + + d3d.rasterizer_state.Reset(); + + D3D11_RASTERIZER_DESC rasterizer_desc; + ZeroMemory(&rasterizer_desc, sizeof(D3D11_RASTERIZER_DESC)); + + rasterizer_desc.FillMode = D3D11_FILL_SOLID; + rasterizer_desc.CullMode = D3D11_CULL_NONE; + rasterizer_desc.FrontCounterClockwise = true; + rasterizer_desc.DepthBias = 0; + rasterizer_desc.SlopeScaledDepthBias = d3d.zmode_decal ? -2.0f : 0.0f; + rasterizer_desc.DepthBiasClamp = 0.0f; + rasterizer_desc.DepthClipEnable = true; + rasterizer_desc.ScissorEnable = true; + rasterizer_desc.MultisampleEnable = false; + rasterizer_desc.AntialiasedLineEnable = false; + + ThrowIfFailed(d3d.device->CreateRasterizerState(&rasterizer_desc, d3d.rasterizer_state.GetAddressOf())); + d3d.context->RSSetState(d3d.rasterizer_state.Get()); + } + + bool textures_changed = false; + + for (int i = 0; i < 2; i++) { + if (d3d.shader_program->used_textures[i]) { + if (d3d.last_resource_views[i].Get() != d3d.textures[d3d.current_texture_ids[i]].resource_view.Get()) { + d3d.last_resource_views[i] = d3d.textures[d3d.current_texture_ids[i]].resource_view.Get(); + d3d.context->PSSetShaderResources(i, 1, d3d.textures[d3d.current_texture_ids[i]].resource_view.GetAddressOf()); + +#if THREE_POINT_FILTERING + d3d.per_draw_cb_data.textures[i].width = d3d.textures[d3d.current_texture_ids[i]].width; + d3d.per_draw_cb_data.textures[i].height = d3d.textures[d3d.current_texture_ids[i]].height; + d3d.per_draw_cb_data.textures[i].linear_filtering = d3d.textures[d3d.current_texture_ids[i]].linear_filtering; + textures_changed = true; +#endif + + if (d3d.last_sampler_states[i].Get() != d3d.textures[d3d.current_texture_ids[i]].sampler_state.Get()) { + d3d.last_sampler_states[i] = d3d.textures[d3d.current_texture_ids[i]].sampler_state.Get(); + d3d.context->PSSetSamplers(i, 1, d3d.textures[d3d.current_texture_ids[i]].sampler_state.GetAddressOf()); + } + } + } + } + + // Set per-draw constant buffer + + if (textures_changed) { + D3D11_MAPPED_SUBRESOURCE ms; + ZeroMemory(&ms, sizeof(D3D11_MAPPED_SUBRESOURCE)); + d3d.context->Map(d3d.per_draw_cb.Get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &ms); + memcpy(ms.pData, &d3d.per_draw_cb_data, sizeof(PerDrawCB)); + d3d.context->Unmap(d3d.per_draw_cb.Get(), 0); + } + + // Set vertex buffer data + + D3D11_MAPPED_SUBRESOURCE ms; + ZeroMemory(&ms, sizeof(D3D11_MAPPED_SUBRESOURCE)); + d3d.context->Map(d3d.vertex_buffer.Get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &ms); + memcpy(ms.pData, buf_vbo, buf_vbo_len * sizeof(float)); + d3d.context->Unmap(d3d.vertex_buffer.Get(), 0); + + uint32_t stride = d3d.shader_program->num_floats * sizeof(float); + uint32_t offset = 0; + + if (d3d.last_vertex_buffer_stride != stride) { + d3d.last_vertex_buffer_stride = stride; + d3d.context->IASetVertexBuffers(0, 1, d3d.vertex_buffer.GetAddressOf(), &stride, &offset); + } + + if (d3d.last_shader_program != d3d.shader_program) { + d3d.last_shader_program = d3d.shader_program; + d3d.context->IASetInputLayout(d3d.shader_program->input_layout.Get()); + d3d.context->VSSetShader(d3d.shader_program->vertex_shader.Get(), 0, 0); + d3d.context->PSSetShader(d3d.shader_program->pixel_shader.Get(), 0, 0); + + if (d3d.last_blend_state.Get() != d3d.shader_program->blend_state.Get()) { + d3d.last_blend_state = d3d.shader_program->blend_state.Get(); + d3d.context->OMSetBlendState(d3d.shader_program->blend_state.Get(), 0, 0xFFFFFFFF); + } + } + + if (d3d.last_primitive_topology != D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST) { + d3d.last_primitive_topology = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST; + d3d.context->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST); + } + + d3d.context->Draw(buf_vbo_num_tris * 3, 0); +} + +static void gfx_d3d11_on_resize(void) { + create_render_target_views(true); +} + +static void gfx_d3d11_start_frame(void) { + // Set render targets + + d3d.context->OMSetRenderTargets(1, d3d.backbuffer_view.GetAddressOf(), d3d.depth_stencil_view.Get()); + + // Clear render targets + + const float clearColor[] = { 0.0f, 0.0f, 0.0f, 1.0f }; + d3d.context->ClearRenderTargetView(d3d.backbuffer_view.Get(), clearColor); + d3d.context->ClearDepthStencilView(d3d.depth_stencil_view.Get(), D3D11_CLEAR_DEPTH, 1.0f, 0); + + // Set per-frame constant buffer + + d3d.per_frame_cb_data.noise_frame++; + if (d3d.per_frame_cb_data.noise_frame > 150) { + // No high values, as noise starts to look ugly + d3d.per_frame_cb_data.noise_frame = 0; + } + float aspect_ratio = (float) d3d.current_width / (float) d3d.current_height; + d3d.per_frame_cb_data.noise_scale_x = 120 * aspect_ratio; // 120 = N64 height resolution (240) / 2 + d3d.per_frame_cb_data.noise_scale_y = 120; + + D3D11_MAPPED_SUBRESOURCE ms; + ZeroMemory(&ms, sizeof(D3D11_MAPPED_SUBRESOURCE)); + d3d.context->Map(d3d.per_frame_cb.Get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &ms); + memcpy(ms.pData, &d3d.per_frame_cb_data, sizeof(PerFrameCB)); + d3d.context->Unmap(d3d.per_frame_cb.Get(), 0); +} + +static void gfx_d3d11_end_frame(void) { +} + +static void gfx_d3d11_finish_render(void) { +} + +} // namespace + +struct GfxRenderingAPI gfx_direct3d11_api = { + gfx_d3d11_z_is_from_0_to_1, + gfx_d3d11_unload_shader, + gfx_d3d11_load_shader, + gfx_d3d11_create_and_load_new_shader, + gfx_d3d11_lookup_shader, + gfx_d3d11_shader_get_info, + gfx_d3d11_new_texture, + gfx_d3d11_select_texture, + gfx_d3d11_upload_texture, + gfx_d3d11_set_sampler_parameters, + gfx_d3d11_set_depth_test, + gfx_d3d11_set_depth_mask, + gfx_d3d11_set_zmode_decal, + gfx_d3d11_set_viewport, + gfx_d3d11_set_scissor, + gfx_d3d11_set_use_alpha, + gfx_d3d11_draw_triangles, + gfx_d3d11_init, + gfx_d3d11_on_resize, + gfx_d3d11_start_frame, + gfx_d3d11_end_frame, + gfx_d3d11_finish_render +}; + +#endif diff --git a/src/decomp/pc/gfx/gfx_direct3d11.h b/src/decomp/pc/gfx/gfx_direct3d11.h new file mode 100644 index 0000000..67f6406 --- /dev/null +++ b/src/decomp/pc/gfx/gfx_direct3d11.h @@ -0,0 +1,12 @@ +#ifdef ENABLE_DX11 + +#ifndef GFX_DIRECT3D11_H +#define GFX_DIRECT3D11_H + +#include "gfx_rendering_api.h" + +extern struct GfxRenderingAPI gfx_direct3d11_api; + +#endif + +#endif diff --git a/src/decomp/pc/gfx/gfx_direct3d12.cpp b/src/decomp/pc/gfx/gfx_direct3d12.cpp new file mode 100644 index 0000000..91eb47b --- /dev/null +++ b/src/decomp/pc/gfx/gfx_direct3d12.cpp @@ -0,0 +1,966 @@ +#ifdef ENABLE_DX12 + +#include +#include +#include +#include + +#include +#include +#include + +#include +#include + +// This is needed when compiling with MinGW, used in d3d12.h +#define __in_ecount_opt(size) + +#include +#include +#include "dxsdk/d3d12.h" +#include + +#include "gfx_direct3d12_guids.h" + +#include "dxsdk/d3dx12.h" + +#ifndef _LANGUAGE_C +#define _LANGUAGE_C +#endif +#include + +#define DECLARE_GFX_DXGI_FUNCTIONS +#include "gfx_dxgi.h" + +#include "gfx_cc.h" +#include "gfx_window_manager_api.h" +#include "gfx_rendering_api.h" +#include "gfx_direct3d_common.h" + +#include "gfx_screen_config.h" + +#define DEBUG_D3D 0 + +using namespace Microsoft::WRL; // For ComPtr + +namespace { + +struct ShaderProgramD3D12 { + uint32_t shader_id; + uint8_t num_inputs; + bool used_textures[2]; + uint8_t num_floats; + uint8_t num_attribs; + + ComPtr vertex_shader; + ComPtr pixel_shader; + ComPtr root_signature; +}; + +struct PipelineDesc { + uint32_t shader_id; + bool depth_test; + bool depth_mask; + bool zmode_decal; + bool _padding; + + bool operator==(const PipelineDesc& o) const { + return memcmp(this, &o, sizeof(*this)) == 0; + } + + bool operator<(const PipelineDesc& o) const { + return memcmp(this, &o, sizeof(*this)) < 0; + } +}; + +struct TextureHeap { + ComPtr heap; + std::vector free_list; +}; + +struct TextureData { + ComPtr resource; + struct TextureHeap *heap; + uint8_t heap_offset; + + uint64_t last_frame_counter; + uint32_t descriptor_index; + int sampler_parameters; +}; + +struct NoiseCB { + uint32_t noise_frame; + float noise_scale_x; + float noise_scale_y; + uint32_t padding; +}; + +static struct { + HMODULE d3d12_module; + PFN_D3D12_CREATE_DEVICE D3D12CreateDevice; + PFN_D3D12_GET_DEBUG_INTERFACE D3D12GetDebugInterface; + + HMODULE d3dcompiler_module; + pD3DCompile D3DCompile; + + struct ShaderProgramD3D12 shader_program_pool[64]; + uint8_t shader_program_pool_size; + + uint32_t current_width, current_height; + + ComPtr device; + ComPtr command_queue; + ComPtr copy_command_queue; + ComPtr swap_chain; + ComPtr rtv_heap; + UINT rtv_descriptor_size; + ComPtr render_targets[2]; + ComPtr command_allocator; + ComPtr copy_command_allocator; + ComPtr command_list; + ComPtr copy_command_list; + ComPtr dsv_heap; + ComPtr depth_stencil_buffer; + ComPtr srv_heap; + UINT srv_descriptor_size; + ComPtr sampler_heap; + UINT sampler_descriptor_size; + + std::map, std::list> texture_heaps; + + std::map>> upload_heaps; + std::vector>> upload_heaps_in_flight; + ComPtr copy_fence; + uint64_t copy_fence_value; + + std::vector textures; + int current_tile; + uint32_t current_texture_ids[2]; + uint32_t srv_pos; + + int frame_index; + ComPtr fence; + HANDLE fence_event; + + uint64_t frame_counter; + + ComPtr noise_cb; + void *mapped_noise_cb_address; + struct NoiseCB noise_cb_data; + + ComPtr vertex_buffer; + void *mapped_vbuf_address; + int vbuf_pos; + + std::vector> resources_to_clean_at_end_of_frame; + std::vector> texture_heap_allocations_to_reclaim_at_end_of_frame; + + std::map> pipeline_states; + bool must_reload_pipeline; + + // Current state: + ID3D12PipelineState *pipeline_state; + struct ShaderProgramD3D12 *shader_program; + bool depth_test; + bool depth_mask; + bool zmode_decal; + + CD3DX12_VIEWPORT viewport; + CD3DX12_RECT scissor; +} d3d; + +static int texture_uploads = 0; +static int max_texture_uploads; + +static D3D12_CPU_DESCRIPTOR_HANDLE get_cpu_descriptor_handle(ComPtr& heap) { +#ifdef __MINGW32__ + // We would like to do this: + // D3D12_CPU_DESCRIPTOR_HANDLE handle = heap->GetCPUDescriptorHandleForHeapStart(); + // but MinGW64 doesn't follow the calling conventions of VC++ for some reason. + // Per MS documentation "User-defined types can be returned by value from global functions and static member functions"... + // "Otherwise, the caller assumes the responsibility of allocating memory and passing a pointer for the return value as the first argument". + // The method here is a non-static member function, and hence we need to pass the address to the return value as a parameter. + // MinGW32 has the same issue. + auto fn = heap->GetCPUDescriptorHandleForHeapStart; + void (STDMETHODCALLTYPE ID3D12DescriptorHeap::*fun)(D3D12_CPU_DESCRIPTOR_HANDLE *out) = (void (STDMETHODCALLTYPE ID3D12DescriptorHeap::*)(D3D12_CPU_DESCRIPTOR_HANDLE *out))fn; + D3D12_CPU_DESCRIPTOR_HANDLE handle; + (heap.Get()->*fun)(&handle); + return handle; +#else + return heap->GetCPUDescriptorHandleForHeapStart(); +#endif +} + +static D3D12_GPU_DESCRIPTOR_HANDLE get_gpu_descriptor_handle(ComPtr& heap) { +#ifdef __MINGW32__ + // See get_cpu_descriptor_handle + auto fn = heap->GetGPUDescriptorHandleForHeapStart; + void (STDMETHODCALLTYPE ID3D12DescriptorHeap::*fun)(D3D12_GPU_DESCRIPTOR_HANDLE *out) = (void (STDMETHODCALLTYPE ID3D12DescriptorHeap::*)(D3D12_GPU_DESCRIPTOR_HANDLE *out))fn; + D3D12_GPU_DESCRIPTOR_HANDLE handle; + (heap.Get()->*fun)(&handle); + return handle; +#else + return heap->GetGPUDescriptorHandleForHeapStart(); +#endif +} + +static D3D12_RESOURCE_ALLOCATION_INFO get_resource_allocation_info(const D3D12_RESOURCE_DESC *resource_desc) { +#ifdef __MINGW32__ + // See get_cpu_descriptor_handle + auto fn = d3d.device->GetResourceAllocationInfo; + void (STDMETHODCALLTYPE ID3D12Device::*fun)(D3D12_RESOURCE_ALLOCATION_INFO *out, UINT visibleMask, UINT numResourceDescs, const D3D12_RESOURCE_DESC *pResourceDescs) = + (void (STDMETHODCALLTYPE ID3D12Device::*)(D3D12_RESOURCE_ALLOCATION_INFO *out, UINT visibleMask, UINT numResourceDescs, const D3D12_RESOURCE_DESC *pResourceDescs))fn; + D3D12_RESOURCE_ALLOCATION_INFO out; + (d3d.device.Get()->*fun)(&out, 0, 1, resource_desc); + return out; +#else + return d3d.device->GetResourceAllocationInfo(0, 1, resource_desc); +#endif +} + +static bool gfx_direct3d12_z_is_from_0_to_1(void) { + return true; +} + +static void gfx_direct3d12_unload_shader(struct ShaderProgram *old_prg) { +} + +static void gfx_direct3d12_load_shader(struct ShaderProgram *new_prg) { + d3d.shader_program = (struct ShaderProgramD3D12 *)new_prg; + d3d.must_reload_pipeline = true; +} + +static struct ShaderProgram *gfx_direct3d12_create_and_load_new_shader(uint32_t shader_id) { + /*static FILE *fp; + if (!fp) { + fp = fopen("shaders.txt", "w"); + } + fprintf(fp, "0x%08x\n", shader_id); + fflush(fp);*/ + + struct ShaderProgramD3D12 *prg = &d3d.shader_program_pool[d3d.shader_program_pool_size++]; + + CCFeatures cc_features; + gfx_cc_get_features(shader_id, &cc_features); + + char buf[2048]; + size_t len, num_floats; + + gfx_direct3d_common_build_shader(buf, len, num_floats, cc_features, true, false); + + //fwrite(buf, 1, len, stdout); + + ThrowIfFailed(d3d.D3DCompile(buf, len, nullptr, nullptr, nullptr, "VSMain", "vs_5_1", D3DCOMPILE_OPTIMIZATION_LEVEL3, 0, &prg->vertex_shader, nullptr)); + ThrowIfFailed(d3d.D3DCompile(buf, len, nullptr, nullptr, nullptr, "PSMain", "ps_5_1", D3DCOMPILE_OPTIMIZATION_LEVEL3, 0, &prg->pixel_shader, nullptr)); + + ThrowIfFailed(d3d.device->CreateRootSignature(0, prg->pixel_shader->GetBufferPointer(), prg->pixel_shader->GetBufferSize(), IID_PPV_ARGS(&prg->root_signature))); + + prg->shader_id = shader_id; + prg->num_inputs = cc_features.num_inputs; + prg->used_textures[0] = cc_features.used_textures[0]; + prg->used_textures[1] = cc_features.used_textures[1]; + prg->num_floats = num_floats; + //prg->num_attribs = cnt; + + d3d.must_reload_pipeline = true; + return (struct ShaderProgram *)(d3d.shader_program = prg); +} + +static struct ShaderProgram *gfx_direct3d12_lookup_shader(uint32_t shader_id) { + for (size_t i = 0; i < d3d.shader_program_pool_size; i++) { + if (d3d.shader_program_pool[i].shader_id == shader_id) { + return (struct ShaderProgram *)&d3d.shader_program_pool[i]; + } + } + return nullptr; +} + +static void gfx_direct3d12_shader_get_info(struct ShaderProgram *prg, uint8_t *num_inputs, bool used_textures[2]) { + struct ShaderProgramD3D12 *p = (struct ShaderProgramD3D12 *)prg; + + *num_inputs = p->num_inputs; + used_textures[0] = p->used_textures[0]; + used_textures[1] = p->used_textures[1]; +} + +static uint32_t gfx_direct3d12_new_texture(void) { + d3d.textures.resize(d3d.textures.size() + 1); + return (uint32_t)(d3d.textures.size() - 1); +} + +static void gfx_direct3d12_select_texture(int tile, uint32_t texture_id) { + d3d.current_tile = tile; + d3d.current_texture_ids[tile] = texture_id; +} + +static void gfx_direct3d12_upload_texture(const uint8_t *rgba32_buf, int width, int height) { + texture_uploads++; + + ComPtr texture_resource; + + // Describe and create a Texture2D. + D3D12_RESOURCE_DESC texture_desc = {}; + texture_desc.MipLevels = 1; + texture_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; + texture_desc.Width = width; + texture_desc.Height = height; + texture_desc.Flags = D3D12_RESOURCE_FLAG_NONE; + texture_desc.DepthOrArraySize = 1; + texture_desc.SampleDesc.Count = 1; + texture_desc.SampleDesc.Quality = 0; + texture_desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D; + texture_desc.Alignment = ((width + 31) / 32) * ((height + 31) / 32) > 16 ? 0 : D3D12_SMALL_RESOURCE_PLACEMENT_ALIGNMENT; + + D3D12_RESOURCE_ALLOCATION_INFO alloc_info = get_resource_allocation_info(&texture_desc); + + std::list& heaps = d3d.texture_heaps[std::pair(alloc_info.SizeInBytes, alloc_info.Alignment)]; + + struct TextureHeap *found_heap = nullptr; + for (struct TextureHeap& heap : heaps) { + if (!heap.free_list.empty()) { + found_heap = &heap; + } + } + if (found_heap == nullptr) { + heaps.resize(heaps.size() + 1); + found_heap = &heaps.back(); + + // In case of HD textures, make sure too much memory isn't wasted + int textures_per_heap = 524288 / alloc_info.SizeInBytes; + if (textures_per_heap < 1) { + textures_per_heap = 1; + } else if (textures_per_heap > 64) { + textures_per_heap = 64; + } + + D3D12_HEAP_DESC heap_desc = {}; + heap_desc.SizeInBytes = alloc_info.SizeInBytes * textures_per_heap; + if (alloc_info.Alignment == D3D12_SMALL_RESOURCE_PLACEMENT_ALIGNMENT) { + heap_desc.Alignment = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT; + } else { + heap_desc.Alignment = alloc_info.Alignment; + } + heap_desc.Properties.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN; + heap_desc.Properties.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN; + heap_desc.Properties.Type = D3D12_HEAP_TYPE_DEFAULT; + heap_desc.Flags = D3D12_HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES; + ThrowIfFailed(d3d.device->CreateHeap(&heap_desc, IID_PPV_ARGS(&found_heap->heap))); + for (int i = 0; i < textures_per_heap; i++) { + found_heap->free_list.push_back(i); + } + } + + uint8_t heap_offset = found_heap->free_list.back(); + found_heap->free_list.pop_back(); + ThrowIfFailed(d3d.device->CreatePlacedResource(found_heap->heap.Get(), heap_offset * alloc_info.SizeInBytes, &texture_desc, D3D12_RESOURCE_STATE_COPY_DEST, nullptr, IID_PPV_ARGS(&texture_resource))); + + D3D12_PLACED_SUBRESOURCE_FOOTPRINT layout; + UINT num_rows; + UINT64 row_size_in_bytes; + UINT64 upload_buffer_size; + d3d.device->GetCopyableFootprints(&texture_desc, 0, 1, 0, &layout, &num_rows, &row_size_in_bytes, &upload_buffer_size); + + std::vector>& upload_heaps = d3d.upload_heaps[upload_buffer_size]; + ComPtr upload_heap; + if (upload_heaps.empty()) { + CD3DX12_HEAP_PROPERTIES hp(D3D12_HEAP_TYPE_UPLOAD); + CD3DX12_RESOURCE_DESC rdb = CD3DX12_RESOURCE_DESC::Buffer(upload_buffer_size); + ThrowIfFailed(d3d.device->CreateCommittedResource( + &hp, + D3D12_HEAP_FLAG_NONE, + &rdb, + D3D12_RESOURCE_STATE_GENERIC_READ, + nullptr, + IID_PPV_ARGS(&upload_heap))); + } else { + upload_heap = upload_heaps.back(); + upload_heaps.pop_back(); + } + + { + D3D12_SUBRESOURCE_DATA texture_data = {}; + texture_data.pData = rgba32_buf; + texture_data.RowPitch = width * 4; // RGBA + texture_data.SlicePitch = texture_data.RowPitch * height; + + void *data; + upload_heap->Map(0, nullptr, &data); + D3D12_MEMCPY_DEST dest_data = { (uint8_t *)data + layout.Offset, layout.Footprint.RowPitch, SIZE_T(layout.Footprint.RowPitch) * SIZE_T(num_rows) }; + MemcpySubresource(&dest_data, &texture_data, static_cast(row_size_in_bytes), num_rows, layout.Footprint.Depth); + upload_heap->Unmap(0, nullptr); + + CD3DX12_TEXTURE_COPY_LOCATION dst(texture_resource.Get(), 0); + CD3DX12_TEXTURE_COPY_LOCATION src(upload_heap.Get(), layout); + d3d.copy_command_list->CopyTextureRegion(&dst, 0, 0, 0, &src, nullptr); + } + + CD3DX12_RESOURCE_BARRIER barrier = CD3DX12_RESOURCE_BARRIER::Transition(texture_resource.Get(), D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE); + d3d.command_list->ResourceBarrier(1, &barrier); + + d3d.upload_heaps_in_flight.push_back(std::make_pair((size_t)upload_buffer_size, std::move(upload_heap))); + + struct TextureData& td = d3d.textures[d3d.current_texture_ids[d3d.current_tile]]; + if (td.resource.Get() != nullptr) { + d3d.resources_to_clean_at_end_of_frame.push_back(std::move(td.resource)); + d3d.texture_heap_allocations_to_reclaim_at_end_of_frame.push_back(std::make_pair(td.heap, td.heap_offset)); + td.last_frame_counter = 0; + } + td.resource = std::move(texture_resource); + td.heap = found_heap; + td.heap_offset = heap_offset; +} + +static int gfx_cm_to_index(uint32_t val) { + if (val & G_TX_CLAMP) { + return 2; + } + return (val & G_TX_MIRROR) ? 1 : 0; +} + +static void gfx_direct3d12_set_sampler_parameters(int tile, bool linear_filter, uint32_t cms, uint32_t cmt) { + d3d.textures[d3d.current_texture_ids[tile]].sampler_parameters = linear_filter * 9 + gfx_cm_to_index(cms) * 3 + gfx_cm_to_index(cmt); +} + +static void gfx_direct3d12_set_depth_test(bool depth_test) { + d3d.depth_test = depth_test; + d3d.must_reload_pipeline = true; +} + +static void gfx_direct3d12_set_depth_mask(bool z_upd) { + d3d.depth_mask = z_upd; + d3d.must_reload_pipeline = true; +} + +static void gfx_direct3d12_set_zmode_decal(bool zmode_decal) { + d3d.zmode_decal = zmode_decal; + d3d.must_reload_pipeline = true; +} + +static void gfx_direct3d12_set_viewport(int x, int y, int width, int height) { + d3d.viewport = CD3DX12_VIEWPORT(x, d3d.current_height - y - height, width, height); +} + +static void gfx_direct3d12_set_scissor(int x, int y, int width, int height) { + d3d.scissor = CD3DX12_RECT(x, d3d.current_height - y - height, x + width, d3d.current_height - y); +} + +static void gfx_direct3d12_set_use_alpha(bool use_alpha) { + // Already part of the pipeline state from shader info +} + +static void gfx_direct3d12_draw_triangles(float buf_vbo[], size_t buf_vbo_len, size_t buf_vbo_num_tris) { + struct ShaderProgramD3D12 *prg = d3d.shader_program; + + if (d3d.must_reload_pipeline) { + ComPtr& pipeline_state = d3d.pipeline_states[PipelineDesc{ + prg->shader_id, + d3d.depth_test, + d3d.depth_mask, + d3d.zmode_decal, + 0 + }]; + if (pipeline_state.Get() == nullptr) { + D3D12_INPUT_ELEMENT_DESC ied[7] = { + {"POSITION", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 } + }; + uint32_t ied_pos = 1; + if (prg->used_textures[0] || prg->used_textures[1]) { + ied[ied_pos++] = D3D12_INPUT_ELEMENT_DESC{"TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0}; + } + if (prg->shader_id & SHADER_OPT_FOG) { + ied[ied_pos++] = D3D12_INPUT_ELEMENT_DESC{"FOG", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0}; + } + for (int i = 0; i < prg->num_inputs; i++) { + DXGI_FORMAT format = (prg->shader_id & SHADER_OPT_ALPHA) ? DXGI_FORMAT_R32G32B32A32_FLOAT : DXGI_FORMAT_R32G32B32_FLOAT; + ied[ied_pos++] = D3D12_INPUT_ELEMENT_DESC{"INPUT", (UINT)i, format, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0}; + } + + D3D12_GRAPHICS_PIPELINE_STATE_DESC desc = {}; + desc.InputLayout = { ied, ied_pos }; + desc.pRootSignature = prg->root_signature.Get(); + desc.VS = CD3DX12_SHADER_BYTECODE(prg->vertex_shader.Get()); + desc.PS = CD3DX12_SHADER_BYTECODE(prg->pixel_shader.Get()); + desc.RasterizerState = CD3DX12_RASTERIZER_DESC(D3D12_DEFAULT); + if (d3d.zmode_decal) { + desc.RasterizerState.SlopeScaledDepthBias = -2.0f; + } + desc.RasterizerState.CullMode = D3D12_CULL_MODE_NONE; + if (prg->shader_id & SHADER_OPT_ALPHA) { + D3D12_BLEND_DESC bd = {}; + bd.AlphaToCoverageEnable = FALSE; + bd.IndependentBlendEnable = FALSE; + static const D3D12_RENDER_TARGET_BLEND_DESC default_rtbd = { + TRUE, FALSE, + D3D12_BLEND_SRC_ALPHA, D3D12_BLEND_INV_SRC_ALPHA, D3D12_BLEND_OP_ADD, + D3D12_BLEND_ONE, D3D12_BLEND_INV_SRC_ALPHA, D3D12_BLEND_OP_ADD, + D3D12_LOGIC_OP_NOOP, + D3D12_COLOR_WRITE_ENABLE_ALL + }; + for (UINT i = 0; i < D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT; i++) { + bd.RenderTarget[i] = default_rtbd; + } + desc.BlendState = bd; + } else { + desc.BlendState = CD3DX12_BLEND_DESC(D3D12_DEFAULT); + } + desc.DepthStencilState.DepthEnable = d3d.depth_test; + desc.DepthStencilState.DepthWriteMask = d3d.depth_mask ? D3D12_DEPTH_WRITE_MASK_ALL : D3D12_DEPTH_WRITE_MASK_ZERO; + desc.DepthStencilState.DepthFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL; + desc.DSVFormat = d3d.depth_test ? DXGI_FORMAT_D32_FLOAT : DXGI_FORMAT_UNKNOWN; + desc.SampleMask = UINT_MAX; + desc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE; + desc.NumRenderTargets = 1; + desc.RTVFormats[0] = DXGI_FORMAT_R8G8B8A8_UNORM; + desc.SampleDesc.Count = 1; + ThrowIfFailed(d3d.device->CreateGraphicsPipelineState(&desc, IID_PPV_ARGS(&pipeline_state))); + } + d3d.pipeline_state = pipeline_state.Get(); + d3d.must_reload_pipeline = false; + } + + d3d.command_list->SetGraphicsRootSignature(prg->root_signature.Get()); + d3d.command_list->SetPipelineState(d3d.pipeline_state); + + ID3D12DescriptorHeap *heaps[] = { d3d.srv_heap.Get(), d3d.sampler_heap.Get() }; + d3d.command_list->SetDescriptorHeaps(2, heaps); + + int root_param_index = 0; + + if ((prg->shader_id & (SHADER_OPT_ALPHA | SHADER_OPT_NOISE)) == (SHADER_OPT_ALPHA | SHADER_OPT_NOISE)) { + d3d.command_list->SetGraphicsRootConstantBufferView(root_param_index++, d3d.noise_cb->GetGPUVirtualAddress()); + } + + for (int i = 0; i < 2; i++) { + if (prg->used_textures[i]) { + struct TextureData& td = d3d.textures[d3d.current_texture_ids[i]]; + if (td.last_frame_counter != d3d.frame_counter) { + td.descriptor_index = d3d.srv_pos; + td.last_frame_counter = d3d.frame_counter; + + D3D12_SHADER_RESOURCE_VIEW_DESC srv_desc = {}; + srv_desc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING; + srv_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; + srv_desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D; + srv_desc.Texture2D.MipLevels = 1; + + CD3DX12_CPU_DESCRIPTOR_HANDLE srv_handle(get_cpu_descriptor_handle(d3d.srv_heap), d3d.srv_pos++, d3d.srv_descriptor_size); + d3d.device->CreateShaderResourceView(td.resource.Get(), &srv_desc, srv_handle); + } + + CD3DX12_GPU_DESCRIPTOR_HANDLE srv_gpu_handle(get_gpu_descriptor_handle(d3d.srv_heap), td.descriptor_index, d3d.srv_descriptor_size); + d3d.command_list->SetGraphicsRootDescriptorTable(root_param_index++, srv_gpu_handle); + + CD3DX12_GPU_DESCRIPTOR_HANDLE sampler_gpu_handle(get_gpu_descriptor_handle(d3d.sampler_heap), td.sampler_parameters, d3d.sampler_descriptor_size); + d3d.command_list->SetGraphicsRootDescriptorTable(root_param_index++, sampler_gpu_handle); + } + } + + CD3DX12_CPU_DESCRIPTOR_HANDLE rtv_handle(get_cpu_descriptor_handle(d3d.rtv_heap), d3d.frame_index, d3d.rtv_descriptor_size); + D3D12_CPU_DESCRIPTOR_HANDLE dsv_handle = get_cpu_descriptor_handle(d3d.dsv_heap); + d3d.command_list->OMSetRenderTargets(1, &rtv_handle, FALSE, &dsv_handle); + + d3d.command_list->RSSetViewports(1, &d3d.viewport); + d3d.command_list->RSSetScissorRects(1, &d3d.scissor); + + int current_pos = d3d.vbuf_pos; + memcpy((uint8_t *)d3d.mapped_vbuf_address + current_pos, buf_vbo, buf_vbo_len * sizeof(float)); + d3d.vbuf_pos += buf_vbo_len * sizeof(float); + static int maxpos; + if (d3d.vbuf_pos > maxpos) { + maxpos = d3d.vbuf_pos; + //printf("NEW MAXPOS: %d\n", maxpos); + } + + D3D12_VERTEX_BUFFER_VIEW vertex_buffer_view; + vertex_buffer_view.BufferLocation = d3d.vertex_buffer->GetGPUVirtualAddress() + current_pos; + vertex_buffer_view.StrideInBytes = buf_vbo_len / (3 * buf_vbo_num_tris) * sizeof(float); + vertex_buffer_view.SizeInBytes = buf_vbo_len * sizeof(float); + + d3d.command_list->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST); + d3d.command_list->IASetVertexBuffers(0, 1, &vertex_buffer_view); + d3d.command_list->DrawInstanced(3 * buf_vbo_num_tris, 1, 0, 0); +} + +static void gfx_direct3d12_start_frame(void) { + ++d3d.frame_counter; + d3d.srv_pos = 0; + texture_uploads = 0; + ThrowIfFailed(d3d.command_allocator->Reset()); + ThrowIfFailed(d3d.command_list->Reset(d3d.command_allocator.Get(), nullptr)); + + CD3DX12_RESOURCE_BARRIER barrier = CD3DX12_RESOURCE_BARRIER::Transition( + d3d.render_targets[d3d.frame_index].Get(), + D3D12_RESOURCE_STATE_PRESENT, + D3D12_RESOURCE_STATE_RENDER_TARGET); + d3d.command_list->ResourceBarrier(1, &barrier); + + CD3DX12_CPU_DESCRIPTOR_HANDLE rtv_handle(get_cpu_descriptor_handle(d3d.rtv_heap), d3d.frame_index, d3d.rtv_descriptor_size); + D3D12_CPU_DESCRIPTOR_HANDLE dsv_handle = get_cpu_descriptor_handle(d3d.dsv_heap); + d3d.command_list->OMSetRenderTargets(1, &rtv_handle, FALSE, &dsv_handle); + + static unsigned char c; + const float clear_color[] = { 0.0f, 0.0f, 0.0f, 1.0f }; + d3d.command_list->ClearRenderTargetView(rtv_handle, clear_color, 0, nullptr); + d3d.command_list->ClearDepthStencilView(dsv_handle, D3D12_CLEAR_FLAG_DEPTH, 1.0f, 0, 0, nullptr); + + d3d.noise_cb_data.noise_frame++; + if (d3d.noise_cb_data.noise_frame > 150) { + // No high values, as noise starts to look ugly + d3d.noise_cb_data.noise_frame = 0; + } + float aspect_ratio = (float) d3d.current_width / (float) d3d.current_height; + d3d.noise_cb_data.noise_scale_x = 120 * aspect_ratio; // 120 = N64 height resolution (240) / 2 + d3d.noise_cb_data.noise_scale_y = 120; + memcpy(d3d.mapped_noise_cb_address, &d3d.noise_cb_data, sizeof(struct NoiseCB)); + + d3d.vbuf_pos = 0; +} + +static void create_render_target_views(void) { + D3D12_CPU_DESCRIPTOR_HANDLE rtv_handle = get_cpu_descriptor_handle(d3d.rtv_heap); + for (UINT i = 0; i < 2; i++) { + ThrowIfFailed(d3d.swap_chain->GetBuffer(i, IID_ID3D12Resource, (void **)&d3d.render_targets[i])); + d3d.device->CreateRenderTargetView(d3d.render_targets[i].Get(), nullptr, rtv_handle); + rtv_handle.ptr += d3d.rtv_descriptor_size; + } +} + +static void create_depth_buffer(void) { + DXGI_SWAP_CHAIN_DESC1 desc1; + ThrowIfFailed(d3d.swap_chain->GetDesc1(&desc1)); + UINT width = desc1.Width; + UINT height = desc1.Height; + + d3d.current_width = width; + d3d.current_height = height; + + D3D12_DEPTH_STENCIL_VIEW_DESC dsv_desc = {}; + dsv_desc.Format = DXGI_FORMAT_D32_FLOAT; + dsv_desc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE2D; + dsv_desc.Flags = D3D12_DSV_FLAG_NONE; + + D3D12_CLEAR_VALUE depth_optimized_cv = {}; + depth_optimized_cv.Format = DXGI_FORMAT_D32_FLOAT; + depth_optimized_cv.DepthStencil.Depth = 1.0f; + + D3D12_HEAP_PROPERTIES hp = {}; + hp.Type = D3D12_HEAP_TYPE_DEFAULT; + hp.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN; + hp.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN; + hp.CreationNodeMask = 1; + hp.VisibleNodeMask = 1; + + D3D12_RESOURCE_DESC rd = {}; + rd.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D; + rd.Alignment = 0; + rd.Width = width; + rd.Height = height; + rd.DepthOrArraySize = 1; + rd.MipLevels = 0; + rd.Format = DXGI_FORMAT_D32_FLOAT; + rd.SampleDesc.Count = 1; + rd.SampleDesc.Quality = 0; + rd.Flags = D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL; + rd.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN; + ThrowIfFailed(d3d.device->CreateCommittedResource(&hp, D3D12_HEAP_FLAG_NONE, &rd, D3D12_RESOURCE_STATE_DEPTH_WRITE, &depth_optimized_cv, IID_PPV_ARGS(&d3d.depth_stencil_buffer))); + + d3d.device->CreateDepthStencilView(d3d.depth_stencil_buffer.Get(), &dsv_desc, get_cpu_descriptor_handle(d3d.dsv_heap)); +} + +static void gfx_direct3d12_on_resize(void) { + if (d3d.render_targets[0].Get() != nullptr) { + d3d.render_targets[0].Reset(); + d3d.render_targets[1].Reset(); + ThrowIfFailed(d3d.swap_chain->ResizeBuffers(0, 0, 0, DXGI_FORMAT_UNKNOWN, DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT)); + d3d.frame_index = d3d.swap_chain->GetCurrentBackBufferIndex(); + create_render_target_views(); + create_depth_buffer(); + } +} + +static void gfx_direct3d12_init(void ) { + // Load d3d12.dll + d3d.d3d12_module = LoadLibraryW(L"d3d12.dll"); + if (d3d.d3d12_module == nullptr) { + ThrowIfFailed(HRESULT_FROM_WIN32(GetLastError()), gfx_dxgi_get_h_wnd(), "d3d12.dll could not be loaded"); + } + d3d.D3D12CreateDevice = (PFN_D3D12_CREATE_DEVICE)GetProcAddress(d3d.d3d12_module, "D3D12CreateDevice"); +#if DEBUG_D3D + d3d.D3D12GetDebugInterface = (PFN_D3D12_GET_DEBUG_INTERFACE)GetProcAddress(d3d.d3d12_module, "D3D12GetDebugInterface"); +#endif + + // Load D3DCompiler_47.dll + d3d.d3dcompiler_module = LoadLibraryW(L"D3DCompiler_47.dll"); + if (d3d.d3dcompiler_module == nullptr) { + ThrowIfFailed(HRESULT_FROM_WIN32(GetLastError()), gfx_dxgi_get_h_wnd(), "D3DCompiler_47.dll could not be loaded"); + } + d3d.D3DCompile = (pD3DCompile)GetProcAddress(d3d.d3dcompiler_module, "D3DCompile"); + + // Create device + { + UINT debug_flags = 0; +#if DEBUG_D3D + ComPtr debug_controller; + if (SUCCEEDED(d3d.D3D12GetDebugInterface(IID_PPV_ARGS(&debug_controller)))) { + debug_controller->EnableDebugLayer(); + debug_flags |= DXGI_CREATE_FACTORY_DEBUG; + } +#endif + + gfx_dxgi_create_factory_and_device(DEBUG_D3D, 12, [](IDXGIAdapter1 *adapter, bool test_only) { + HRESULT res = d3d.D3D12CreateDevice( + adapter, + D3D_FEATURE_LEVEL_11_0, + IID_ID3D12Device, + test_only ? nullptr : IID_PPV_ARGS_Helper(&d3d.device)); + + if (test_only) { + return SUCCEEDED(res); + } else { + ThrowIfFailed(res, gfx_dxgi_get_h_wnd(), "Failed to create D3D12 device."); + return true; + } + }); + } + + // Create command queues + { + D3D12_COMMAND_QUEUE_DESC queue_desc = {}; + queue_desc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE; + queue_desc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT; + ThrowIfFailed(d3d.device->CreateCommandQueue(&queue_desc, IID_PPV_ARGS(&d3d.command_queue))); + } + { + D3D12_COMMAND_QUEUE_DESC queue_desc = {}; + queue_desc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE; + queue_desc.Type = D3D12_COMMAND_LIST_TYPE_COPY; + ThrowIfFailed(d3d.device->CreateCommandQueue(&queue_desc, IID_PPV_ARGS(&d3d.copy_command_queue))); + } + + // Create swap chain + { + ComPtr swap_chain1 = gfx_dxgi_create_swap_chain(d3d.command_queue.Get()); + ThrowIfFailed(swap_chain1->QueryInterface(__uuidof(IDXGISwapChain3), &d3d.swap_chain)); + d3d.frame_index = d3d.swap_chain->GetCurrentBackBufferIndex(); + } + + // Create render target views + { + D3D12_DESCRIPTOR_HEAP_DESC rtv_heap_desc = {}; + rtv_heap_desc.NumDescriptors = 2; + rtv_heap_desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV; + rtv_heap_desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE; + ThrowIfFailed(d3d.device->CreateDescriptorHeap(&rtv_heap_desc, IID_PPV_ARGS(&d3d.rtv_heap))); + d3d.rtv_descriptor_size = d3d.device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV); + + create_render_target_views(); + } + + // Create Z-buffer + { + D3D12_DESCRIPTOR_HEAP_DESC dsv_heap_desc = {}; + dsv_heap_desc.NumDescriptors = 1; + dsv_heap_desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_DSV; + dsv_heap_desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE; + ThrowIfFailed(d3d.device->CreateDescriptorHeap(&dsv_heap_desc, IID_PPV_ARGS(&d3d.dsv_heap))); + + create_depth_buffer(); + } + + // Create SRV heap for texture descriptors + { + D3D12_DESCRIPTOR_HEAP_DESC srv_heap_desc = {}; + srv_heap_desc.NumDescriptors = 1024; // Max unique textures per frame + srv_heap_desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV; + srv_heap_desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE; + ThrowIfFailed(d3d.device->CreateDescriptorHeap(&srv_heap_desc, IID_PPV_ARGS(&d3d.srv_heap))); + d3d.srv_descriptor_size = d3d.device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); + } + + // Create sampler heap and descriptors + { + D3D12_DESCRIPTOR_HEAP_DESC sampler_heap_desc = {}; + sampler_heap_desc.NumDescriptors = 18; + sampler_heap_desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER; + sampler_heap_desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE; + ThrowIfFailed(d3d.device->CreateDescriptorHeap(&sampler_heap_desc, IID_PPV_ARGS(&d3d.sampler_heap))); + d3d.sampler_descriptor_size = d3d.device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER); + + static const D3D12_TEXTURE_ADDRESS_MODE address_modes[] = { + D3D12_TEXTURE_ADDRESS_MODE_WRAP, + D3D12_TEXTURE_ADDRESS_MODE_MIRROR, + D3D12_TEXTURE_ADDRESS_MODE_CLAMP + }; + + D3D12_CPU_DESCRIPTOR_HANDLE sampler_handle = get_cpu_descriptor_handle(d3d.sampler_heap); + int pos = 0; + for (int linear_filter = 0; linear_filter < 2; linear_filter++) { + for (int cms = 0; cms < 3; cms++) { + for (int cmt = 0; cmt < 3; cmt++) { + D3D12_SAMPLER_DESC sampler_desc = {}; + sampler_desc.Filter = linear_filter ? D3D12_FILTER_MIN_MAG_MIP_LINEAR : D3D12_FILTER_MIN_MAG_MIP_POINT; + sampler_desc.AddressU = address_modes[cms]; + sampler_desc.AddressV = address_modes[cmt]; + sampler_desc.AddressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP; + sampler_desc.MinLOD = 0; + sampler_desc.MaxLOD = D3D12_FLOAT32_MAX; + sampler_desc.MipLODBias = 0.0f; + sampler_desc.MaxAnisotropy = 1; + sampler_desc.ComparisonFunc = D3D12_COMPARISON_FUNC_NEVER; + d3d.device->CreateSampler(&sampler_desc, CD3DX12_CPU_DESCRIPTOR_HANDLE(sampler_handle, pos++, d3d.sampler_descriptor_size)); + } + } + } + } + + // Create constant buffer view for noise + { + /*D3D12_DESCRIPTOR_HEAP_DESC cbv_heap_desc = {}; + cbv_heap_desc.NumDescriptors = 1; + cbv_heap_desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV; + srv_heap_desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE; + ThrowIfFailed(d3d.device->CreateDescriptorHeap*/ + + CD3DX12_HEAP_PROPERTIES hp(D3D12_HEAP_TYPE_UPLOAD); + CD3DX12_RESOURCE_DESC rdb = CD3DX12_RESOURCE_DESC::Buffer(256); + ThrowIfFailed(d3d.device->CreateCommittedResource( + &hp, + D3D12_HEAP_FLAG_NONE, + &rdb, + D3D12_RESOURCE_STATE_GENERIC_READ, + nullptr, + IID_PPV_ARGS(&d3d.noise_cb))); + + CD3DX12_RANGE read_range(0, 0); // Read not possible from CPU + ThrowIfFailed(d3d.noise_cb->Map(0, &read_range, &d3d.mapped_noise_cb_address)); + } + + ThrowIfFailed(d3d.device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&d3d.command_allocator))); + ThrowIfFailed(d3d.device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_COPY, IID_PPV_ARGS(&d3d.copy_command_allocator))); + + ThrowIfFailed(d3d.device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, d3d.command_allocator.Get(), nullptr, IID_PPV_ARGS(&d3d.command_list))); + ThrowIfFailed(d3d.device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_COPY, d3d.copy_command_allocator.Get(), nullptr, IID_PPV_ARGS(&d3d.copy_command_list))); + + ThrowIfFailed(d3d.command_list->Close()); + + ThrowIfFailed(d3d.device->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&d3d.fence))); + d3d.fence_event = CreateEvent(nullptr, FALSE, FALSE, nullptr); + if (d3d.fence_event == nullptr) { + ThrowIfFailed(HRESULT_FROM_WIN32(GetLastError())); + } + + ThrowIfFailed(d3d.device->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&d3d.copy_fence))); + + { + // Create a buffer of 1 MB in size. With a 120 star speed run 192 kB seems to be max usage. + CD3DX12_HEAP_PROPERTIES hp(D3D12_HEAP_TYPE_UPLOAD); + CD3DX12_RESOURCE_DESC rdb = CD3DX12_RESOURCE_DESC::Buffer(256 * 1024 * sizeof(float)); + ThrowIfFailed(d3d.device->CreateCommittedResource( + &hp, + D3D12_HEAP_FLAG_NONE, + &rdb, + D3D12_RESOURCE_STATE_GENERIC_READ, + nullptr, + IID_PPV_ARGS(&d3d.vertex_buffer))); + + CD3DX12_RANGE read_range(0, 0); // Read not possible from CPU + ThrowIfFailed(d3d.vertex_buffer->Map(0, &read_range, &d3d.mapped_vbuf_address)); + } +} + +static void gfx_direct3d12_end_frame(void) { + if (max_texture_uploads < texture_uploads && texture_uploads != 38 && texture_uploads != 34 && texture_uploads != 29) { + max_texture_uploads = texture_uploads; + } + //printf("Texture uploads: %d %d\n", max_texture_uploads, texture_uploads); + texture_uploads = 0; + + ThrowIfFailed(d3d.copy_command_list->Close()); + { + ID3D12CommandList *lists[] = { d3d.copy_command_list.Get() }; + d3d.copy_command_queue->ExecuteCommandLists(1, lists); + d3d.copy_command_queue->Signal(d3d.copy_fence.Get(), ++d3d.copy_fence_value); + } + + CD3DX12_RESOURCE_BARRIER barrier = CD3DX12_RESOURCE_BARRIER::Transition( + d3d.render_targets[d3d.frame_index].Get(), + D3D12_RESOURCE_STATE_RENDER_TARGET, + D3D12_RESOURCE_STATE_PRESENT); + d3d.command_list->ResourceBarrier(1, &barrier); + + d3d.command_queue->Wait(d3d.copy_fence.Get(), d3d.copy_fence_value); + + ThrowIfFailed(d3d.command_list->Close()); + + { + ID3D12CommandList *lists[] = { d3d.command_list.Get() }; + d3d.command_queue->ExecuteCommandLists(1, lists); + } + + { + LARGE_INTEGER t0; + QueryPerformanceCounter(&t0); + //printf("Present: %llu %u\n", (unsigned long long)(t0.QuadPart - d3d.qpc_init), d3d.length_in_vsync_frames); + } +} + +static void gfx_direct3d12_finish_render(void) { + LARGE_INTEGER t0, t1, t2; + QueryPerformanceCounter(&t0); + + static UINT64 fence_value; + ThrowIfFailed(d3d.command_queue->Signal(d3d.fence.Get(), ++fence_value)); + if (d3d.fence->GetCompletedValue() < fence_value) { + ThrowIfFailed(d3d.fence->SetEventOnCompletion(fence_value, d3d.fence_event)); + WaitForSingleObject(d3d.fence_event, INFINITE); + } + QueryPerformanceCounter(&t1); + + d3d.resources_to_clean_at_end_of_frame.clear(); + for (std::pair>& heap : d3d.upload_heaps_in_flight) { + d3d.upload_heaps[heap.first].push_back(std::move(heap.second)); + } + d3d.upload_heaps_in_flight.clear(); + for (std::pair& item : d3d.texture_heap_allocations_to_reclaim_at_end_of_frame) { + item.first->free_list.push_back(item.second); + } + d3d.texture_heap_allocations_to_reclaim_at_end_of_frame.clear(); + + QueryPerformanceCounter(&t2); + + d3d.frame_index = d3d.swap_chain->GetCurrentBackBufferIndex(); + + ThrowIfFailed(d3d.copy_command_allocator->Reset()); + ThrowIfFailed(d3d.copy_command_list->Reset(d3d.copy_command_allocator.Get(), nullptr)); + + //printf("done %llu gpu:%d wait:%d freed:%llu frame:%u %u monitor:%u t:%llu\n", (unsigned long long)(t0.QuadPart - d3d.qpc_init), (int)(t1.QuadPart - t0.QuadPart), (int)(t2.QuadPart - t0.QuadPart), (unsigned long long)(t2.QuadPart - d3d.qpc_init), d3d.pending_frame_stats.rbegin()->first, stats.PresentCount, stats.SyncRefreshCount, (unsigned long long)(stats.SyncQPCTime.QuadPart - d3d.qpc_init)); +} + +} // namespace + +struct GfxRenderingAPI gfx_direct3d12_api = { + gfx_direct3d12_z_is_from_0_to_1, + gfx_direct3d12_unload_shader, + gfx_direct3d12_load_shader, + gfx_direct3d12_create_and_load_new_shader, + gfx_direct3d12_lookup_shader, + gfx_direct3d12_shader_get_info, + gfx_direct3d12_new_texture, + gfx_direct3d12_select_texture, + gfx_direct3d12_upload_texture, + gfx_direct3d12_set_sampler_parameters, + gfx_direct3d12_set_depth_test, + gfx_direct3d12_set_depth_mask, + gfx_direct3d12_set_zmode_decal, + gfx_direct3d12_set_viewport, + gfx_direct3d12_set_scissor, + gfx_direct3d12_set_use_alpha, + gfx_direct3d12_draw_triangles, + gfx_direct3d12_init, + gfx_direct3d12_on_resize, + gfx_direct3d12_start_frame, + gfx_direct3d12_end_frame, + gfx_direct3d12_finish_render +}; + +#endif diff --git a/src/decomp/pc/gfx/gfx_direct3d12.h b/src/decomp/pc/gfx/gfx_direct3d12.h new file mode 100644 index 0000000..9a29be4 --- /dev/null +++ b/src/decomp/pc/gfx/gfx_direct3d12.h @@ -0,0 +1,12 @@ +#ifdef ENABLE_DX12 + +#ifndef GFX_DIRECT3D12_H +#define GFX_DIRECT3D12_H + +#include "gfx_rendering_api.h" + +extern struct GfxRenderingAPI gfx_direct3d12_api; + +#endif + +#endif diff --git a/src/decomp/pc/gfx/gfx_direct3d12_guids.h b/src/decomp/pc/gfx/gfx_direct3d12_guids.h new file mode 100644 index 0000000..e18a018 --- /dev/null +++ b/src/decomp/pc/gfx/gfx_direct3d12_guids.h @@ -0,0 +1,62 @@ +#ifndef GFX_DIRECT3D12_GUIDS_H +#define GFX_DIRECT3D12_GUIDS_H + +#ifdef __MINGW32__ + +// This file is only needed due to missing MinGW-specific headers for d3d12.h. +// It will define IID_* symbols having the "selectany" attribute (assuming +// d3d12.h was earlier included), as well as make __uuidof(...) work. + +#define DEF_GUID(type,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) \ + __CRT_UUID_DECL(type,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) \ + const GUID IID_##type = __uuidof(type) + +DEF_GUID(ID3D12Object,0xc4fec28f,0x7966,0x4e95,0x9f,0x94,0xf4,0x31,0xcb,0x56,0xc3,0xb8); +DEF_GUID(ID3D12DeviceChild,0x905db94b,0xa00c,0x4140,0x9d,0xf5,0x2b,0x64,0xca,0x9e,0xa3,0x57); +DEF_GUID(ID3D12RootSignature,0xc54a6b66,0x72df,0x4ee8,0x8b,0xe5,0xa9,0x46,0xa1,0x42,0x92,0x14); +DEF_GUID(ID3D12RootSignatureDeserializer,0x34AB647B,0x3CC8,0x46AC,0x84,0x1B,0xC0,0x96,0x56,0x45,0xC0,0x46); +DEF_GUID(ID3D12VersionedRootSignatureDeserializer,0x7F91CE67,0x090C,0x4BB7,0xB7,0x8E,0xED,0x8F,0xF2,0xE3,0x1D,0xA0); +DEF_GUID(ID3D12Pageable,0x63ee58fb,0x1268,0x4835,0x86,0xda,0xf0,0x08,0xce,0x62,0xf0,0xd6); +DEF_GUID(ID3D12Heap,0x6b3b2502,0x6e51,0x45b3,0x90,0xee,0x98,0x84,0x26,0x5e,0x8d,0xf3); +DEF_GUID(ID3D12Resource,0x696442be,0xa72e,0x4059,0xbc,0x79,0x5b,0x5c,0x98,0x04,0x0f,0xad); +DEF_GUID(ID3D12CommandAllocator,0x6102dee4,0xaf59,0x4b09,0xb9,0x99,0xb4,0x4d,0x73,0xf0,0x9b,0x24); +DEF_GUID(ID3D12Fence,0x0a753dcf,0xc4d8,0x4b91,0xad,0xf6,0xbe,0x5a,0x60,0xd9,0x5a,0x76); +DEF_GUID(ID3D12Fence1,0x433685fe,0xe22b,0x4ca0,0xa8,0xdb,0xb5,0xb4,0xf4,0xdd,0x0e,0x4a); +DEF_GUID(ID3D12PipelineState,0x765a30f3,0xf624,0x4c6f,0xa8,0x28,0xac,0xe9,0x48,0x62,0x24,0x45); +DEF_GUID(ID3D12DescriptorHeap,0x8efb471d,0x616c,0x4f49,0x90,0xf7,0x12,0x7b,0xb7,0x63,0xfa,0x51); +DEF_GUID(ID3D12QueryHeap,0x0d9658ae,0xed45,0x469e,0xa6,0x1d,0x97,0x0e,0xc5,0x83,0xca,0xb4); +DEF_GUID(ID3D12CommandSignature,0xc36a797c,0xec80,0x4f0a,0x89,0x85,0xa7,0xb2,0x47,0x50,0x82,0xd1); +DEF_GUID(ID3D12CommandList,0x7116d91c,0xe7e4,0x47ce,0xb8,0xc6,0xec,0x81,0x68,0xf4,0x37,0xe5); +DEF_GUID(ID3D12GraphicsCommandList,0x5b160d0f,0xac1b,0x4185,0x8b,0xa8,0xb3,0xae,0x42,0xa5,0xa4,0x55); +DEF_GUID(ID3D12GraphicsCommandList1,0x553103fb,0x1fe7,0x4557,0xbb,0x38,0x94,0x6d,0x7d,0x0e,0x7c,0xa7); +DEF_GUID(ID3D12GraphicsCommandList2,0x38C3E585,0xFF17,0x412C,0x91,0x50,0x4F,0xC6,0xF9,0xD7,0x2A,0x28); +DEF_GUID(ID3D12CommandQueue,0x0ec870a6,0x5d7e,0x4c22,0x8c,0xfc,0x5b,0xaa,0xe0,0x76,0x16,0xed); +DEF_GUID(ID3D12Device,0x189819f1,0x1db6,0x4b57,0xbe,0x54,0x18,0x21,0x33,0x9b,0x85,0xf7); +DEF_GUID(ID3D12PipelineLibrary,0xc64226a8,0x9201,0x46af,0xb4,0xcc,0x53,0xfb,0x9f,0xf7,0x41,0x4f); +DEF_GUID(ID3D12PipelineLibrary1,0x80eabf42,0x2568,0x4e5e,0xbd,0x82,0xc3,0x7f,0x86,0x96,0x1d,0xc3); +DEF_GUID(ID3D12Device1,0x77acce80,0x638e,0x4e65,0x88,0x95,0xc1,0xf2,0x33,0x86,0x86,0x3e); +DEF_GUID(ID3D12Device2,0x30baa41e,0xb15b,0x475c,0xa0,0xbb,0x1a,0xf5,0xc5,0xb6,0x43,0x28); +DEF_GUID(ID3D12Device3,0x81dadc15,0x2bad,0x4392,0x93,0xc5,0x10,0x13,0x45,0xc4,0xaa,0x98); +DEF_GUID(ID3D12ProtectedSession,0xA1533D18,0x0AC1,0x4084,0x85,0xB9,0x89,0xA9,0x61,0x16,0x80,0x6B); +DEF_GUID(ID3D12ProtectedResourceSession,0x6CD696F4,0xF289,0x40CC,0x80,0x91,0x5A,0x6C,0x0A,0x09,0x9C,0x3D); +DEF_GUID(ID3D12Device4,0xe865df17,0xa9ee,0x46f9,0xa4,0x63,0x30,0x98,0x31,0x5a,0xa2,0xe5); +DEF_GUID(ID3D12LifetimeOwner,0xe667af9f,0xcd56,0x4f46,0x83,0xce,0x03,0x2e,0x59,0x5d,0x70,0xa8); +DEF_GUID(ID3D12SwapChainAssistant,0xf1df64b6,0x57fd,0x49cd,0x88,0x07,0xc0,0xeb,0x88,0xb4,0x5c,0x8f); +DEF_GUID(ID3D12LifetimeTracker,0x3fd03d36,0x4eb1,0x424a,0xa5,0x82,0x49,0x4e,0xcb,0x8b,0xa8,0x13); +DEF_GUID(ID3D12StateObject,0x47016943,0xfca8,0x4594,0x93,0xea,0xaf,0x25,0x8b,0x55,0x34,0x6d); +DEF_GUID(ID3D12StateObjectProperties,0xde5fa827,0x9bf9,0x4f26,0x89,0xff,0xd7,0xf5,0x6f,0xde,0x38,0x60); +DEF_GUID(ID3D12Device5,0x8b4f173b,0x2fea,0x4b80,0x8f,0x58,0x43,0x07,0x19,0x1a,0xb9,0x5d); +DEF_GUID(ID3D12DeviceRemovedExtendedDataSettings,0x82BC481C,0x6B9B,0x4030,0xAE,0xDB,0x7E,0xE3,0xD1,0xDF,0x1E,0x63); +DEF_GUID(ID3D12DeviceRemovedExtendedData,0x98931D33,0x5AE8,0x4791,0xAA,0x3C,0x1A,0x73,0xA2,0x93,0x4E,0x71); +DEF_GUID(ID3D12Device6,0xc70b221b,0x40e4,0x4a17,0x89,0xaf,0x02,0x5a,0x07,0x27,0xa6,0xdc); +DEF_GUID(ID3D12Resource1,0x9D5E227A,0x4430,0x4161,0x88,0xB3,0x3E,0xCA,0x6B,0xB1,0x6E,0x19); +DEF_GUID(ID3D12Heap1,0x572F7389,0x2168,0x49E3,0x96,0x93,0xD6,0xDF,0x58,0x71,0xBF,0x6D); +DEF_GUID(ID3D12GraphicsCommandList3,0x6FDA83A7,0xB84C,0x4E38,0x9A,0xC8,0xC7,0xBD,0x22,0x01,0x6B,0x3D); +DEF_GUID(ID3D12MetaCommand,0xDBB84C27,0x36CE,0x4FC9,0xB8,0x01,0xF0,0x48,0xC4,0x6A,0xC5,0x70); +DEF_GUID(ID3D12GraphicsCommandList4,0x8754318e,0xd3a9,0x4541,0x98,0xcf,0x64,0x5b,0x50,0xdc,0x48,0x74); +DEF_GUID(ID3D12Tools,0x7071e1f0,0xe84b,0x4b33,0x97,0x4f,0x12,0xfa,0x49,0xde,0x65,0xc5); +DEF_GUID(ID3D12GraphicsCommandList5,0x55050859,0x4024,0x474c,0x87,0xf5,0x64,0x72,0xea,0xee,0x44,0xea); + +#endif + +#endif diff --git a/src/decomp/pc/gfx/gfx_direct3d_common.cpp b/src/decomp/pc/gfx/gfx_direct3d_common.cpp new file mode 100644 index 0000000..32a7296 --- /dev/null +++ b/src/decomp/pc/gfx/gfx_direct3d_common.cpp @@ -0,0 +1,313 @@ +#if defined(ENABLE_DX11) || defined(ENABLE_DX12) + +#include + +#include "gfx_direct3d_common.h" +#include "gfx_cc.h" + +void get_cc_features(uint32_t shader_id, CCFeatures *cc_features) { + for (int i = 0; i < 4; i++) { + cc_features->c[0][i] = (shader_id >> (i * 3)) & 7; + cc_features->c[1][i] = (shader_id >> (12 + i * 3)) & 7; + } + + cc_features->opt_alpha = (shader_id & SHADER_OPT_ALPHA) != 0; + cc_features->opt_fog = (shader_id & SHADER_OPT_FOG) != 0; + cc_features->opt_texture_edge = (shader_id & SHADER_OPT_TEXTURE_EDGE) != 0; + cc_features->opt_noise = (shader_id & SHADER_OPT_NOISE) != 0; + + cc_features->used_textures[0] = false; + cc_features->used_textures[1] = false; + cc_features->num_inputs = 0; + + for (int i = 0; i < 2; i++) { + for (int j = 0; j < 4; j++) { + if (cc_features->c[i][j] >= SHADER_INPUT_1 && cc_features->c[i][j] <= SHADER_INPUT_4) { + if (cc_features->c[i][j] > cc_features->num_inputs) { + cc_features->num_inputs = cc_features->c[i][j]; + } + } + if (cc_features->c[i][j] == SHADER_TEXEL0 || cc_features->c[i][j] == SHADER_TEXEL0A) { + cc_features->used_textures[0] = true; + } + if (cc_features->c[i][j] == SHADER_TEXEL1) { + cc_features->used_textures[1] = true; + } + } + } + + cc_features->do_single[0] = cc_features->c[0][2] == 0; + cc_features->do_single[1] = cc_features->c[1][2] == 0; + cc_features->do_multiply[0] = cc_features->c[0][1] == 0 && cc_features->c[0][3] == 0; + cc_features->do_multiply[1] = cc_features->c[1][1] == 0 && cc_features->c[1][3] == 0; + cc_features->do_mix[0] = cc_features->c[0][1] == cc_features->c[0][3]; + cc_features->do_mix[1] = cc_features->c[1][1] == cc_features->c[1][3]; + cc_features->color_alpha_same = (shader_id & 0xfff) == ((shader_id >> 12) & 0xfff); +} + +static void append_str(char *buf, size_t *len, const char *str) { + while (*str != '\0') buf[(*len)++] = *str++; +} + +static void append_line(char *buf, size_t *len, const char *str) { + while (*str != '\0') buf[(*len)++] = *str++; + buf[(*len)++] = '\r'; + buf[(*len)++] = '\n'; +} + +static const char *shader_item_to_str(uint32_t item, bool with_alpha, bool only_alpha, bool inputs_have_alpha, bool hint_single_element) { + if (!only_alpha) { + switch (item) { + default: + case SHADER_0: + return with_alpha ? "float4(0.0, 0.0, 0.0, 0.0)" : "float3(0.0, 0.0, 0.0)"; + case SHADER_INPUT_1: + return with_alpha || !inputs_have_alpha ? "input.input1" : "input.input1.rgb"; + case SHADER_INPUT_2: + return with_alpha || !inputs_have_alpha ? "input.input2" : "input.input2.rgb"; + case SHADER_INPUT_3: + return with_alpha || !inputs_have_alpha ? "input.input3" : "input.input3.rgb"; + case SHADER_INPUT_4: + return with_alpha || !inputs_have_alpha ? "input.input4" : "input.input4.rgb"; + case SHADER_TEXEL0: + return with_alpha ? "texVal0" : "texVal0.rgb"; + case SHADER_TEXEL0A: + return hint_single_element ? "texVal0.a" : (with_alpha ? "float4(texVal0.a, texVal0.a, texVal0.a, texVal0.a)" : "float3(texVal0.a, texVal0.a, texVal0.a)"); + case SHADER_TEXEL1: + return with_alpha ? "texVal1" : "texVal1.rgb"; + } + } else { + switch (item) { + default: + case SHADER_0: + return "0.0"; + case SHADER_INPUT_1: + return "input.input1.a"; + case SHADER_INPUT_2: + return "input.input2.a"; + case SHADER_INPUT_3: + return "input.input3.a"; + case SHADER_INPUT_4: + return "input.input4.a"; + case SHADER_TEXEL0: + return "texVal0.a"; + case SHADER_TEXEL0A: + return "texVal0.a"; + case SHADER_TEXEL1: + return "texVal1.a"; + } + } +} + +static void append_formula(char *buf, size_t *len, const uint8_t c[2][4], bool do_single, bool do_multiply, bool do_mix, bool with_alpha, bool only_alpha, bool opt_alpha) { + if (do_single) { + append_str(buf, len, shader_item_to_str(c[only_alpha][3], with_alpha, only_alpha, opt_alpha, false)); + } else if (do_multiply) { + append_str(buf, len, shader_item_to_str(c[only_alpha][0], with_alpha, only_alpha, opt_alpha, false)); + append_str(buf, len, " * "); + append_str(buf, len, shader_item_to_str(c[only_alpha][2], with_alpha, only_alpha, opt_alpha, true)); + } else if (do_mix) { + append_str(buf, len, "lerp("); + append_str(buf, len, shader_item_to_str(c[only_alpha][1], with_alpha, only_alpha, opt_alpha, false)); + append_str(buf, len, ", "); + append_str(buf, len, shader_item_to_str(c[only_alpha][0], with_alpha, only_alpha, opt_alpha, false)); + append_str(buf, len, ", "); + append_str(buf, len, shader_item_to_str(c[only_alpha][2], with_alpha, only_alpha, opt_alpha, true)); + append_str(buf, len, ")"); + } else { + append_str(buf, len, "("); + append_str(buf, len, shader_item_to_str(c[only_alpha][0], with_alpha, only_alpha, opt_alpha, false)); + append_str(buf, len, " - "); + append_str(buf, len, shader_item_to_str(c[only_alpha][1], with_alpha, only_alpha, opt_alpha, false)); + append_str(buf, len, ") * "); + append_str(buf, len, shader_item_to_str(c[only_alpha][2], with_alpha, only_alpha, opt_alpha, true)); + append_str(buf, len, " + "); + append_str(buf, len, shader_item_to_str(c[only_alpha][3], with_alpha, only_alpha, opt_alpha, false)); + } +} + +void gfx_direct3d_common_build_shader(char buf[4096], size_t& len, size_t& num_floats, const CCFeatures& cc_features, bool include_root_signature, bool three_point_filtering) { + len = 0; + num_floats = 4; + + // Pixel shader input struct + + if (include_root_signature) { + append_str(buf, &len, "#define RS \"RootFlags(ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT | DENY_VERTEX_SHADER_ROOT_ACCESS)"); + if (cc_features.opt_alpha && cc_features.opt_noise) { + append_str(buf, &len, ",CBV(b0, visibility = SHADER_VISIBILITY_PIXEL)"); + } + if (cc_features.used_textures[0]) { + append_str(buf, &len, ",DescriptorTable(SRV(t0), visibility = SHADER_VISIBILITY_PIXEL)"); + append_str(buf, &len, ",DescriptorTable(Sampler(s0), visibility = SHADER_VISIBILITY_PIXEL)"); + } + if (cc_features.used_textures[1]) { + append_str(buf, &len, ",DescriptorTable(SRV(t1), visibility = SHADER_VISIBILITY_PIXEL)"); + append_str(buf, &len, ",DescriptorTable(Sampler(s1), visibility = SHADER_VISIBILITY_PIXEL)"); + } + append_line(buf, &len, "\""); + } + + append_line(buf, &len, "struct PSInput {"); + append_line(buf, &len, " float4 position : SV_POSITION;"); + if (cc_features.used_textures[0] || cc_features.used_textures[1]) { + append_line(buf, &len, " float2 uv : TEXCOORD;"); + num_floats += 2; + } + if (cc_features.opt_alpha && cc_features.opt_noise) { + append_line(buf, &len, " float4 screenPos : TEXCOORD1;"); + } + if (cc_features.opt_fog) { + append_line(buf, &len, " float4 fog : FOG;"); + num_floats += 4; + } + for (int i = 0; i < cc_features.num_inputs; i++) { + len += sprintf(buf + len, " float%d input%d : INPUT%d;\r\n", cc_features.opt_alpha ? 4 : 3, i + 1, i); + num_floats += cc_features.opt_alpha ? 4 : 3; + } + append_line(buf, &len, "};"); + + // Textures and samplers + + if (cc_features.used_textures[0]) { + append_line(buf, &len, "Texture2D g_texture0 : register(t0);"); + append_line(buf, &len, "SamplerState g_sampler0 : register(s0);"); + } + if (cc_features.used_textures[1]) { + append_line(buf, &len, "Texture2D g_texture1 : register(t1);"); + append_line(buf, &len, "SamplerState g_sampler1 : register(s1);"); + } + + // Constant buffer and random function + + if (cc_features.opt_alpha && cc_features.opt_noise) { + append_line(buf, &len, "cbuffer PerFrameCB : register(b0) {"); + append_line(buf, &len, " uint noise_frame;"); + append_line(buf, &len, " float2 noise_scale;"); + append_line(buf, &len, "}"); + + append_line(buf, &len, "float random(in float3 value) {"); + append_line(buf, &len, " float random = dot(value, float3(12.9898, 78.233, 37.719));"); + append_line(buf, &len, " return frac(sin(random) * 143758.5453);"); + append_line(buf, &len, "}"); + } + + // 3 point texture filtering + // Original author: ArthurCarvalho + // Based on GLSL implementation by twinaphex, mupen64plus-libretro project. + + if (three_point_filtering && (cc_features.used_textures[0] || cc_features.used_textures[1])) { + append_line(buf, &len, "cbuffer PerDrawCB : register(b1) {"); + append_line(buf, &len, " struct {"); + append_line(buf, &len, " uint width;"); + append_line(buf, &len, " uint height;"); + append_line(buf, &len, " bool linear_filtering;"); + append_line(buf, &len, " } textures[2];"); + append_line(buf, &len, "}"); + append_line(buf, &len, "#define TEX_OFFSET(tex, tSampler, texCoord, off, texSize) tex.Sample(tSampler, texCoord - off / texSize)"); + append_line(buf, &len, "float4 tex2D3PointFilter(in Texture2D tex, in SamplerState tSampler, in float2 texCoord, in float2 texSize) {"); + append_line(buf, &len, " float2 offset = frac(texCoord * texSize - float2(0.5, 0.5));"); + append_line(buf, &len, " offset -= step(1.0, offset.x + offset.y);"); + append_line(buf, &len, " float4 c0 = TEX_OFFSET(tex, tSampler, texCoord, offset, texSize);"); + append_line(buf, &len, " float4 c1 = TEX_OFFSET(tex, tSampler, texCoord, float2(offset.x - sign(offset.x), offset.y), texSize);"); + append_line(buf, &len, " float4 c2 = TEX_OFFSET(tex, tSampler, texCoord, float2(offset.x, offset.y - sign(offset.y)), texSize);"); + append_line(buf, &len, " return c0 + abs(offset.x)*(c1-c0) + abs(offset.y)*(c2-c0);"); + append_line(buf, &len, "}"); + } + + // Vertex shader + + append_str(buf, &len, "PSInput VSMain(float4 position : POSITION"); + if (cc_features.used_textures[0] || cc_features.used_textures[1]) { + append_str(buf, &len, ", float2 uv : TEXCOORD"); + } + if (cc_features.opt_fog) { + append_str(buf, &len, ", float4 fog : FOG"); + } + for (int i = 0; i < cc_features.num_inputs; i++) { + len += sprintf(buf + len, ", float%d input%d : INPUT%d", cc_features.opt_alpha ? 4 : 3, i + 1, i); + } + append_line(buf, &len, ") {"); + append_line(buf, &len, " PSInput result;"); + append_line(buf, &len, " result.position = position;"); + if (cc_features.opt_alpha && cc_features.opt_noise) { + append_line(buf, &len, " result.screenPos = position;"); + } + if (cc_features.used_textures[0] || cc_features.used_textures[1]) { + append_line(buf, &len, " result.uv = uv;"); + } + if (cc_features.opt_fog) { + append_line(buf, &len, " result.fog = fog;"); + } + for (int i = 0; i < cc_features.num_inputs; i++) { + len += sprintf(buf + len, " result.input%d = input%d;\r\n", i + 1, i + 1); + } + append_line(buf, &len, " return result;"); + append_line(buf, &len, "}"); + + // Pixel shader + if (include_root_signature) { + append_line(buf, &len, "[RootSignature(RS)]"); + } + append_line(buf, &len, "float4 PSMain(PSInput input) : SV_TARGET {"); + if (cc_features.used_textures[0]) { + if (three_point_filtering) { + append_line(buf, &len, " float4 texVal0;"); + append_line(buf, &len, " if (textures[0].linear_filtering)"); + append_line(buf, &len, " texVal0 = tex2D3PointFilter(g_texture0, g_sampler0, input.uv, float2(textures[0].width, textures[0].height));"); + append_line(buf, &len, " else"); + append_line(buf, &len, " texVal0 = g_texture0.Sample(g_sampler0, input.uv);"); + } else { + append_line(buf, &len, " float4 texVal0 = g_texture0.Sample(g_sampler0, input.uv);"); + } + } + if (cc_features.used_textures[1]) { + if (three_point_filtering) { + append_line(buf, &len, " float4 texVal1;"); + append_line(buf, &len, " if (textures[1].linear_filtering)"); + append_line(buf, &len, " texVal1 = tex2D3PointFilter(g_texture1, g_sampler1, input.uv, float2(textures[1].width, textures[1].height));"); + append_line(buf, &len, " else"); + append_line(buf, &len, " texVal1 = g_texture1.Sample(g_sampler1, input.uv);"); + } else { + append_line(buf, &len, " float4 texVal1 = g_texture1.Sample(g_sampler1, input.uv);"); + } + } + + append_str(buf, &len, cc_features.opt_alpha ? " float4 texel = " : " float3 texel = "); + if (!cc_features.color_alpha_same && cc_features.opt_alpha) { + append_str(buf, &len, "float4("); + append_formula(buf, &len, cc_features.c, cc_features.do_single[0], cc_features.do_multiply[0], cc_features.do_mix[0], false, false, true); + append_str(buf, &len, ", "); + append_formula(buf, &len, cc_features.c, cc_features.do_single[1], cc_features.do_multiply[1], cc_features.do_mix[1], true, true, true); + append_str(buf, &len, ")"); + } else { + append_formula(buf, &len, cc_features.c, cc_features.do_single[0], cc_features.do_multiply[0], cc_features.do_mix[0], cc_features.opt_alpha, false, cc_features.opt_alpha); + } + append_line(buf, &len, ";"); + + if (cc_features.opt_texture_edge && cc_features.opt_alpha) { + append_line(buf, &len, " if (texel.a > 0.3) texel.a = 1.0; else discard;"); + } + // TODO discard if alpha is 0? + if (cc_features.opt_fog) { + if (cc_features.opt_alpha) { + append_line(buf, &len, " texel = float4(lerp(texel.rgb, input.fog.rgb, input.fog.a), texel.a);"); + } else { + append_line(buf, &len, " texel = lerp(texel, input.fog.rgb, input.fog.a);"); + } + } + + if (cc_features.opt_alpha && cc_features.opt_noise) { + append_line(buf, &len, " float2 coords = (input.screenPos.xy / input.screenPos.w) * noise_scale;"); + append_line(buf, &len, " texel.a *= round(random(float3(floor(coords), noise_frame)));"); + } + + if (cc_features.opt_alpha) { + append_line(buf, &len, " return texel;"); + } else { + append_line(buf, &len, " return float4(texel, 1.0);"); + } + append_line(buf, &len, "}"); +} + +#endif diff --git a/src/decomp/pc/gfx/gfx_direct3d_common.h b/src/decomp/pc/gfx/gfx_direct3d_common.h new file mode 100644 index 0000000..5df83a3 --- /dev/null +++ b/src/decomp/pc/gfx/gfx_direct3d_common.h @@ -0,0 +1,14 @@ +#if defined(ENABLE_DX11) || defined(ENABLE_DX12) + +#ifndef GFX_DIRECT3D_COMMON_H +#define GFX_DIRECT3D_COMMON_H + +#include + +#include "gfx_cc.h" + +void gfx_direct3d_common_build_shader(char buf[4096], size_t& len, size_t& num_floats, const CCFeatures& cc_features, bool include_root_signature, bool three_point_filtering); + +#endif + +#endif diff --git a/src/decomp/pc/gfx/gfx_dummy.c b/src/decomp/pc/gfx/gfx_dummy.c new file mode 100644 index 0000000..c9c644a --- /dev/null +++ b/src/decomp/pc/gfx/gfx_dummy.c @@ -0,0 +1,192 @@ +#ifdef ENABLE_GFX_DUMMY +#include +#include + +#include "gfx_window_manager_api.h" +#include "gfx_rendering_api.h" + +static void gfx_dummy_wm_init(const char *game_name, bool start_in_fullscreen) { +} + +static void gfx_dummy_wm_set_keyboard_callbacks(bool (*on_key_down)(int scancode), bool (*on_key_up)(int scancode), void (*on_all_keys_up)(void)) { +} + +static void gfx_dummy_wm_set_fullscreen_changed_callback(void (*on_fullscreen_changed)(bool is_now_fullscreen)) { +} + +static void gfx_dummy_wm_set_fullscreen(bool enable) { +} + +static void gfx_dummy_wm_main_loop(void (*run_one_game_iter)(void)) { + while (1) { + run_one_game_iter(); + } +} + +static void gfx_dummy_wm_get_dimensions(uint32_t *width, uint32_t *height) { + *width = 320; + *height = 240; +} + +static void gfx_dummy_wm_handle_events(void) { +} + +static bool gfx_dummy_wm_start_frame(void) { + return true; +} + +static void gfx_dummy_wm_swap_buffers_begin(void) { +} + +static struct timespec gfx_dummy_wm_timediff(struct timespec t1, struct timespec t2) { + t1.tv_sec -= t2.tv_sec; + t1.tv_nsec -= t2.tv_nsec; + if (t1.tv_nsec < 0) { + t1.tv_nsec += 1000000000; + t1.tv_sec -= 1; + } + return t1; +} + +static struct timespec gfx_dummy_wm_timeadd(struct timespec t1, struct timespec t2) { + t1.tv_sec += t2.tv_sec; + t1.tv_nsec += t2.tv_nsec; + if (t1.tv_nsec > 1000000000) { + t1.tv_nsec -= 1000000000; + t1.tv_sec += 1; + } + return t1; +} + +static void gfx_dummy_wm_swap_buffers_end(void) { + static struct timespec prev; + struct timespec t; + clock_gettime(CLOCK_MONOTONIC, &t); + struct timespec diff = gfx_dummy_wm_timediff(t, prev); + if (diff.tv_sec == 0 && diff.tv_nsec < 1000000000 / 30) { + struct timespec add = {0, 1000000000 / 30}; + struct timespec next = gfx_dummy_wm_timeadd(prev, add); + while (clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &next, NULL) == EINTR) { + } + prev = next; + } else { + prev = t; + } +} + +static double gfx_dummy_wm_get_time(void) { + return 0.0; +} + +static bool gfx_dummy_renderer_z_is_from_0_to_1(void) { + return false; +} + +static void gfx_dummy_renderer_unload_shader(struct ShaderProgram *old_prg) { +} + +static void gfx_dummy_renderer_load_shader(struct ShaderProgram *new_prg) { +} + +static struct ShaderProgram *gfx_dummy_renderer_create_and_load_new_shader(uint32_t shader_id) { + return NULL; +} + +static struct ShaderProgram *gfx_dummy_renderer_lookup_shader(uint32_t shader_id) { + return NULL; +} + +static void gfx_dummy_renderer_shader_get_info(struct ShaderProgram *prg, uint8_t *num_inputs, bool used_textures[2]) { + *num_inputs = 0; + used_textures[0] = false; + used_textures[1] = false; +} + +static uint32_t gfx_dummy_renderer_new_texture(void) { + return 0; +} + +static void gfx_dummy_renderer_select_texture(int tile, uint32_t texture_id) { +} + +static void gfx_dummy_renderer_upload_texture(const uint8_t *rgba32_buf, int width, int height) { +} + +static void gfx_dummy_renderer_set_sampler_parameters(int tile, bool linear_filter, uint32_t cms, uint32_t cmt) { +} + +static void gfx_dummy_renderer_set_depth_test(bool depth_test) { +} + +static void gfx_dummy_renderer_set_depth_mask(bool z_upd) { +} + +static void gfx_dummy_renderer_set_zmode_decal(bool zmode_decal) { +} + +static void gfx_dummy_renderer_set_viewport(int x, int y, int width, int height) { +} + +static void gfx_dummy_renderer_set_scissor(int x, int y, int width, int height) { +} + +static void gfx_dummy_renderer_set_use_alpha(bool use_alpha) { +} + +static void gfx_dummy_renderer_draw_triangles(float buf_vbo[], size_t buf_vbo_len, size_t buf_vbo_num_tris) { +} + +static void gfx_dummy_renderer_init(void) { +} + +static void gfx_dummy_renderer_on_resize(void) { +} + +static void gfx_dummy_renderer_start_frame(void) { +} + +static void gfx_dummy_renderer_end_frame(void) { +} + +static void gfx_dummy_renderer_finish_render(void) { +} + +struct GfxWindowManagerAPI gfx_dummy_wm_api = { + gfx_dummy_wm_init, + gfx_dummy_wm_set_keyboard_callbacks, + gfx_dummy_wm_set_fullscreen_changed_callback, + gfx_dummy_wm_set_fullscreen, + gfx_dummy_wm_main_loop, + gfx_dummy_wm_get_dimensions, + gfx_dummy_wm_handle_events, + gfx_dummy_wm_start_frame, + gfx_dummy_wm_swap_buffers_begin, + gfx_dummy_wm_swap_buffers_end, + gfx_dummy_wm_get_time +}; + +struct GfxRenderingAPI gfx_dummy_renderer_api = { + gfx_dummy_renderer_z_is_from_0_to_1, + gfx_dummy_renderer_unload_shader, + gfx_dummy_renderer_load_shader, + gfx_dummy_renderer_create_and_load_new_shader, + gfx_dummy_renderer_lookup_shader, + gfx_dummy_renderer_shader_get_info, + gfx_dummy_renderer_new_texture, + gfx_dummy_renderer_select_texture, + gfx_dummy_renderer_upload_texture, + gfx_dummy_renderer_set_sampler_parameters, + gfx_dummy_renderer_set_depth_test, + gfx_dummy_renderer_set_depth_mask, + gfx_dummy_renderer_set_zmode_decal, + gfx_dummy_renderer_set_viewport, + gfx_dummy_renderer_set_scissor, + gfx_dummy_renderer_set_use_alpha, + gfx_dummy_renderer_draw_triangles, + gfx_dummy_renderer_init, + gfx_dummy_renderer_on_resize, + gfx_dummy_renderer_start_frame, + gfx_dummy_renderer_end_frame, + gfx_dummy_renderer_finish_render +}; +#endif diff --git a/src/decomp/pc/gfx/gfx_dummy.h b/src/decomp/pc/gfx/gfx_dummy.h new file mode 100644 index 0000000..de12c71 --- /dev/null +++ b/src/decomp/pc/gfx/gfx_dummy.h @@ -0,0 +1,14 @@ +#ifdef ENABLE_GFX_DUMMY + +#ifndef GFX_DUMMY_H +#define GFX_DUMMY_H + +#include "gfx_rendering_api.h" +#include "gfx_window_manager_api.h" + +extern struct GfxRenderingAPI gfx_dummy_renderer_api; +extern struct GfxWindowManagerAPI gfx_dummy_wm_api; + +#endif + +#endif diff --git a/src/decomp/pc/gfx/gfx_dxgi.cpp b/src/decomp/pc/gfx/gfx_dxgi.cpp new file mode 100644 index 0000000..02cdd81 --- /dev/null +++ b/src/decomp/pc/gfx/gfx_dxgi.cpp @@ -0,0 +1,614 @@ +#if defined(ENABLE_DX11) || defined(ENABLE_DX12) + +#include +#include + +#include +#include +#include + +#include +#include +#include +#include + +#include + + +#ifndef _LANGUAGE_C +#define _LANGUAGE_C +#endif +#include + +#include "gfx_window_manager_api.h" +#include "gfx_rendering_api.h" +#include "gfx_direct3d_common.h" +#include "gfx_screen_config.h" +#include "gfx_pc.h" + +#define DECLARE_GFX_DXGI_FUNCTIONS +#include "gfx_dxgi.h" + +#define WINCLASS_NAME L"N64GAME" +#define GFX_API_NAME "DirectX" + +#ifdef VERSION_EU +#define FRAME_INTERVAL_US_NUMERATOR 40000 +#define FRAME_INTERVAL_US_DENOMINATOR 1 +#else +#define FRAME_INTERVAL_US_NUMERATOR 100000 +#define FRAME_INTERVAL_US_DENOMINATOR 3 +#endif + +using namespace Microsoft::WRL; // For ComPtr + +static struct { + HWND h_wnd; + bool showing_error; + uint32_t current_width, current_height; + std::string game_name; + + HMODULE dxgi_module; + HRESULT (__stdcall *CreateDXGIFactory1)(REFIID riid, void **factory); + HRESULT (__stdcall *CreateDXGIFactory2)(UINT flags, REFIID iid, void **factory); + + bool process_dpi_awareness_done; + + RECT last_window_rect; + bool is_full_screen, last_maximized_state; + + ComPtr factory; + ComPtr swap_chain; + HANDLE waitable_object; + uint64_t qpc_init, qpc_freq; + uint64_t frame_timestamp; // in units of 1/FRAME_INTERVAL_US_DENOMINATOR microseconds + std::map frame_stats; + std::set> pending_frame_stats; + bool dropped_frame; + bool sync_interval_means_frames_to_wait; + UINT length_in_vsync_frames; + + void (*on_fullscreen_changed)(bool is_now_fullscreen); + void (*run_one_game_iter)(void); + bool (*on_key_down)(int scancode); + bool (*on_key_up)(int scancode); + void (*on_all_keys_up)(void); +} dxgi; + +static void load_dxgi_library(void) { + dxgi.dxgi_module = LoadLibraryW(L"dxgi.dll"); + *(FARPROC *)&dxgi.CreateDXGIFactory1 = GetProcAddress(dxgi.dxgi_module, "CreateDXGIFactory1"); + *(FARPROC *)&dxgi.CreateDXGIFactory2 = GetProcAddress(dxgi.dxgi_module, "CreateDXGIFactory2"); +} + +template +static void run_as_dpi_aware(Fun f) { + // Make sure Windows 8.1 or newer doesn't upscale/downscale the rendered images. + // This is an issue on Windows 8.1 and newer where moving around the window + // between different monitors having different scaling settings will + // by default result in the DirectX image will also be scaled accordingly. + // The resulting scale factor is the curent monitor's scale factor divided by + // the initial monitor's scale factor. Setting per-monitor aware disables scaling. + + // On Windows 10 1607 and later, that is solved by setting the awarenenss per window, + // which is done by using SetThreadDpiAwarenessContext before and after creating + // any window. When the message handler runs, the corresponding context also applies. + + // From windef.h, missing in MinGW. + DECLARE_HANDLE(DPI_AWARENESS_CONTEXT); + #define DPI_AWARENESS_CONTEXT_UNAWARE ((DPI_AWARENESS_CONTEXT)-1) + #define DPI_AWARENESS_CONTEXT_SYSTEM_AWARE ((DPI_AWARENESS_CONTEXT)-2) + #define DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE ((DPI_AWARENESS_CONTEXT)-3) + #define DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2 ((DPI_AWARENESS_CONTEXT)-4) + #define DPI_AWARENESS_CONTEXT_UNAWARE_GDISCALED ((DPI_AWARENESS_CONTEXT)-5) + + DPI_AWARENESS_CONTEXT (WINAPI *SetThreadDpiAwarenessContext)(DPI_AWARENESS_CONTEXT dpiContext); + *(FARPROC *)&SetThreadDpiAwarenessContext = GetProcAddress(GetModuleHandleW(L"user32.dll"), "SetThreadDpiAwarenessContext"); + DPI_AWARENESS_CONTEXT old_awareness_context; + if (SetThreadDpiAwarenessContext != nullptr) { + old_awareness_context = SetThreadDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2); + } else { + // Solution for Windows 8.1 and newer, but before Windows 10 1607. + // SetProcessDpiAwareness must be called before any drawing related API is called. + if (!dxgi.process_dpi_awareness_done) { + HMODULE shcore_module = LoadLibraryW(L"SHCore.dll"); + if (shcore_module != nullptr) { + HRESULT (WINAPI *SetProcessDpiAwareness)(PROCESS_DPI_AWARENESS value); + *(FARPROC *)&SetProcessDpiAwareness = GetProcAddress(shcore_module, "SetProcessDpiAwareness"); + if (SetProcessDpiAwareness != nullptr) { + SetProcessDpiAwareness(PROCESS_PER_MONITOR_DPI_AWARE); + // Ignore result, will fail if already called or manifest already specifies dpi awareness. + } + FreeLibrary(shcore_module); + } + dxgi.process_dpi_awareness_done = true; + } + } + + f(); + + // Restore the old context + if (SetThreadDpiAwarenessContext != nullptr && old_awareness_context != nullptr) { + SetThreadDpiAwarenessContext(old_awareness_context); + } +} + +static void toggle_borderless_window_full_screen(bool enable, bool call_callback) { + // Windows 7 + flip mode + waitable object can't go to exclusive fullscreen, + // so do borderless instead. If DWM is enabled, this means we get one monitor + // sync interval of latency extra. On Win 10 however (maybe Win 8 too), due to + // "fullscreen optimizations" the latency is eliminated. + + if (enable == dxgi.is_full_screen) { + return; + } + + if (!enable) { + RECT r = dxgi.last_window_rect; + + // Set in window mode with the last saved position and size + SetWindowLongPtr(dxgi.h_wnd, GWL_STYLE, WS_VISIBLE | WS_OVERLAPPEDWINDOW); + + if (dxgi.last_maximized_state) { + SetWindowPos(dxgi.h_wnd, NULL, 0, 0, 0, 0, SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOSIZE); + ShowWindow(dxgi.h_wnd, SW_MAXIMIZE); + } else { + SetWindowPos(dxgi.h_wnd, NULL, r.left, r.top, r.right - r.left, r.bottom - r.top, SWP_FRAMECHANGED); + ShowWindow(dxgi.h_wnd, SW_RESTORE); + } + + ShowCursor(TRUE); + + dxgi.is_full_screen = false; + } else { + // Save if window is maximized or not + WINDOWPLACEMENT window_placement; + window_placement.length = sizeof(WINDOWPLACEMENT); + GetWindowPlacement(dxgi.h_wnd, &window_placement); + dxgi.last_maximized_state = window_placement.showCmd == SW_SHOWMAXIMIZED; + + // Save window position and size if the window is not maximized + GetWindowRect(dxgi.h_wnd, &dxgi.last_window_rect); + + // Get in which monitor the window is + HMONITOR h_monitor = MonitorFromWindow(dxgi.h_wnd, MONITOR_DEFAULTTONEAREST); + + // Get info from that monitor + MONITORINFOEX monitor_info; + monitor_info.cbSize = sizeof(MONITORINFOEX); + GetMonitorInfo(h_monitor, &monitor_info); + RECT r = monitor_info.rcMonitor; + + // Set borderless full screen to that monitor + SetWindowLongPtr(dxgi.h_wnd, GWL_STYLE, WS_VISIBLE | WS_POPUP); + SetWindowPos(dxgi.h_wnd, HWND_TOP, r.left, r.top, r.right - r.left, r.bottom - r.top, SWP_FRAMECHANGED); + + ShowCursor(FALSE); + + dxgi.is_full_screen = true; + } + + if (dxgi.on_fullscreen_changed != nullptr && call_callback) { + dxgi.on_fullscreen_changed(enable); + } +} + +static void gfx_dxgi_on_resize(void) { + if (dxgi.swap_chain.Get() != nullptr) { + gfx_get_current_rendering_api()->on_resize(); + + DXGI_SWAP_CHAIN_DESC1 desc1; + ThrowIfFailed(dxgi.swap_chain->GetDesc1(&desc1)); + dxgi.current_width = desc1.Width; + dxgi.current_height = desc1.Height; + } +} + +static void onkeydown(WPARAM w_param, LPARAM l_param) { + int key = ((l_param >> 16) & 0x1ff); + if (dxgi.on_key_down != nullptr) { + dxgi.on_key_down(key); + } +} +static void onkeyup(WPARAM w_param, LPARAM l_param) { + int key = ((l_param >> 16) & 0x1ff); + if (dxgi.on_key_up != nullptr) { + dxgi.on_key_up(key); + } +} + +static LRESULT CALLBACK gfx_dxgi_wnd_proc(HWND h_wnd, UINT message, WPARAM w_param, LPARAM l_param) { + switch (message) { + case WM_SIZE: + gfx_dxgi_on_resize(); + break; + case WM_DESTROY: + exit(0); + case WM_PAINT: + if (dxgi.showing_error) { + return DefWindowProcW(h_wnd, message, w_param, l_param); + } else { + if (dxgi.run_one_game_iter != nullptr) { + dxgi.run_one_game_iter(); + } + } + break; + case WM_ACTIVATEAPP: + if (dxgi.on_all_keys_up != nullptr) { + dxgi.on_all_keys_up(); + } + break; + case WM_KEYDOWN: + onkeydown(w_param, l_param); + break; + case WM_KEYUP: + onkeyup(w_param, l_param); + break; + case WM_SYSKEYDOWN: + if ((w_param == VK_RETURN) && ((l_param & 1 << 30) == 0)) { + toggle_borderless_window_full_screen(!dxgi.is_full_screen, true); + break; + } else { + return DefWindowProcW(h_wnd, message, w_param, l_param); + } + default: + return DefWindowProcW(h_wnd, message, w_param, l_param); + } + return 0; +} + +static void gfx_dxgi_init(const char *game_name, bool start_in_fullscreen) { + LARGE_INTEGER qpc_init, qpc_freq; + QueryPerformanceCounter(&qpc_init); + QueryPerformanceFrequency(&qpc_freq); + dxgi.qpc_init = qpc_init.QuadPart; + dxgi.qpc_freq = qpc_freq.QuadPart; + + // Prepare window title + + char title[512]; + wchar_t w_title[512]; + int len = sprintf(title, "%s (%s)", game_name, GFX_API_NAME); + mbstowcs(w_title, title, len + 1); + dxgi.game_name = game_name; + + // Create window + WNDCLASSEXW wcex; + + wcex.cbSize = sizeof(WNDCLASSEX); + + wcex.style = CS_HREDRAW | CS_VREDRAW; + wcex.lpfnWndProc = gfx_dxgi_wnd_proc; + wcex.cbClsExtra = 0; + wcex.cbWndExtra = 0; + wcex.hInstance = nullptr; + wcex.hIcon = nullptr; + wcex.hCursor = LoadCursor(nullptr, IDC_ARROW); + wcex.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH); + wcex.lpszMenuName = nullptr; + wcex.lpszClassName = WINCLASS_NAME; + wcex.hIconSm = nullptr; + + ATOM winclass = RegisterClassExW(&wcex); + + + run_as_dpi_aware([&] () { + // We need to be dpi aware when calculating the size + RECT wr = {0, 0, DESIRED_SCREEN_WIDTH, DESIRED_SCREEN_HEIGHT}; + AdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, FALSE); + + dxgi.h_wnd = CreateWindowW(WINCLASS_NAME, w_title, WS_OVERLAPPEDWINDOW, + CW_USEDEFAULT, 0, wr.right - wr.left, wr.bottom - wr.top, nullptr, nullptr, nullptr, nullptr); + }); + + load_dxgi_library(); + + ShowWindow(dxgi.h_wnd, SW_SHOW); + UpdateWindow(dxgi.h_wnd); + + if (start_in_fullscreen) { + toggle_borderless_window_full_screen(true, false); + } +} + +static void gfx_dxgi_set_fullscreen_changed_callback(void (*on_fullscreen_changed)(bool is_now_fullscreen)) { + dxgi.on_fullscreen_changed = on_fullscreen_changed; +} + +static void gfx_dxgi_set_fullscreen(bool enable) { + toggle_borderless_window_full_screen(enable, true); +} + +static void gfx_dxgi_set_keyboard_callbacks(bool (*on_key_down)(int scancode), bool (*on_key_up)(int scancode), void (*on_all_keys_up)(void)) { + dxgi.on_key_down = on_key_down; + dxgi.on_key_up = on_key_up; + dxgi.on_all_keys_up = on_all_keys_up; +} + +static void gfx_dxgi_main_loop(void (*run_one_game_iter)(void)) { + dxgi.run_one_game_iter = run_one_game_iter; + + MSG msg; + while (GetMessage(&msg, nullptr, 0, 0)) { + TranslateMessage(&msg); + DispatchMessage(&msg); + } +} + +static void gfx_dxgi_get_dimensions(uint32_t *width, uint32_t *height) { + *width = dxgi.current_width; + *height = dxgi.current_height; +} + +static void gfx_dxgi_handle_events(void) { + /*MSG msg; + while (PeekMessageW(&msg, nullptr, 0, 0, PM_REMOVE)) { + TranslateMessage(&msg); + DispatchMessage(&msg); + }*/ +} + +static uint64_t qpc_to_us(uint64_t qpc) { + return qpc / dxgi.qpc_freq * 1000000 + qpc % dxgi.qpc_freq * 1000000 / dxgi.qpc_freq; +} + +static bool gfx_dxgi_start_frame(void) { + DXGI_FRAME_STATISTICS stats; + if (dxgi.swap_chain->GetFrameStatistics(&stats) == S_OK && (stats.SyncRefreshCount != 0 || stats.SyncQPCTime.QuadPart != 0ULL)) { + { + LARGE_INTEGER t0; + QueryPerformanceCounter(&t0); + //printf("Get frame stats: %llu\n", (unsigned long long)(t0.QuadPart - dxgi.qpc_init)); + } + //printf("stats: %u %u %u %u %u %.6f\n", dxgi.pending_frame_stats.rbegin()->first, dxgi.pending_frame_stats.rbegin()->second, stats.PresentCount, stats.PresentRefreshCount, stats.SyncRefreshCount, (double)(stats.SyncQPCTime.QuadPart - dxgi.qpc_init) / dxgi.qpc_freq); + if (dxgi.frame_stats.empty() || dxgi.frame_stats.rbegin()->second.PresentCount != stats.PresentCount) { + dxgi.frame_stats.insert(std::make_pair(stats.PresentCount, stats)); + } + if (dxgi.frame_stats.size() > 3) { + dxgi.frame_stats.erase(dxgi.frame_stats.begin()); + } + } + if (!dxgi.frame_stats.empty()) { + while (!dxgi.pending_frame_stats.empty() && dxgi.pending_frame_stats.begin()->first < dxgi.frame_stats.rbegin()->first) { + dxgi.pending_frame_stats.erase(dxgi.pending_frame_stats.begin()); + } + } + while (dxgi.pending_frame_stats.size() > 15) { + // Just make sure the list doesn't grow too large if GetFrameStatistics fails. + dxgi.pending_frame_stats.erase(dxgi.pending_frame_stats.begin()); + } + + dxgi.frame_timestamp += FRAME_INTERVAL_US_NUMERATOR; + + if (dxgi.frame_stats.size() >= 2) { + DXGI_FRAME_STATISTICS *first = &dxgi.frame_stats.begin()->second; + DXGI_FRAME_STATISTICS *last = &dxgi.frame_stats.rbegin()->second; + uint64_t sync_qpc_diff = last->SyncQPCTime.QuadPart - first->SyncQPCTime.QuadPart; + UINT sync_vsync_diff = last->SyncRefreshCount - first->SyncRefreshCount; + UINT present_vsync_diff = last->PresentRefreshCount - first->PresentRefreshCount; + UINT present_diff = last->PresentCount - first->PresentCount; + + if (sync_vsync_diff == 0) { + sync_vsync_diff = 1; + } + + double estimated_vsync_interval = (double)sync_qpc_diff / (double)sync_vsync_diff; + uint64_t estimated_vsync_interval_us = qpc_to_us(estimated_vsync_interval); + //printf("Estimated vsync_interval: %d\n", (int)estimated_vsync_interval_us); + if (estimated_vsync_interval_us < 2 || estimated_vsync_interval_us > 1000000) { + // Unreasonable, maybe a monitor change + estimated_vsync_interval_us = 16666; + estimated_vsync_interval = estimated_vsync_interval_us * dxgi.qpc_freq / 1000000; + } + + UINT queued_vsyncs = 0; + bool is_first = true; + for (const std::pair& p : dxgi.pending_frame_stats) { + if (is_first && dxgi.sync_interval_means_frames_to_wait) { + is_first = false; + continue; + } + queued_vsyncs += p.second; + } + + uint64_t last_frame_present_end_qpc = (last->SyncQPCTime.QuadPart - dxgi.qpc_init) + estimated_vsync_interval * queued_vsyncs; + uint64_t last_end_us = qpc_to_us(last_frame_present_end_qpc); + + double vsyncs_to_wait = (double)(int64_t)(dxgi.frame_timestamp / FRAME_INTERVAL_US_DENOMINATOR - last_end_us) / estimated_vsync_interval_us; + //printf("ts: %llu, last_end_us: %llu, Init v: %f\n", dxgi.frame_timestamp / 3, last_end_us, vsyncs_to_wait); + + if (vsyncs_to_wait <= 0) { + // Too late + + if ((int64_t)(dxgi.frame_timestamp / FRAME_INTERVAL_US_DENOMINATOR - last_end_us) < -66666) { + // The application must have been paused or similar + vsyncs_to_wait = round(((double)FRAME_INTERVAL_US_NUMERATOR / FRAME_INTERVAL_US_DENOMINATOR) / estimated_vsync_interval_us); + if (vsyncs_to_wait < 1) { + vsyncs_to_wait = 1; + } + dxgi.frame_timestamp = FRAME_INTERVAL_US_DENOMINATOR * (last_end_us + vsyncs_to_wait * estimated_vsync_interval_us); + } else { + // Drop frame + //printf("Dropping frame\n"); + dxgi.dropped_frame = true; + return false; + } + } + if (floor(vsyncs_to_wait) != vsyncs_to_wait) { + uint64_t left = last_end_us + floor(vsyncs_to_wait) * estimated_vsync_interval_us; + uint64_t right = last_end_us + ceil(vsyncs_to_wait) * estimated_vsync_interval_us; + uint64_t adjusted_desired_time = dxgi.frame_timestamp / FRAME_INTERVAL_US_DENOMINATOR + (last_end_us + (FRAME_INTERVAL_US_NUMERATOR / FRAME_INTERVAL_US_DENOMINATOR) > dxgi.frame_timestamp / FRAME_INTERVAL_US_DENOMINATOR ? 2000 : -2000); + int64_t diff_left = adjusted_desired_time - left; + int64_t diff_right = right - adjusted_desired_time; + if (diff_left < 0) { + diff_left = -diff_left; + } + if (diff_right < 0) { + diff_right = -diff_right; + } + if (diff_left < diff_right) { + vsyncs_to_wait = floor(vsyncs_to_wait); + } else { + vsyncs_to_wait = ceil(vsyncs_to_wait); + } + if (vsyncs_to_wait == 0) { + //printf("vsyncs_to_wait became 0 so dropping frame\n"); + dxgi.dropped_frame = true; + return false; + } + } + //printf("v: %d\n", (int)vsyncs_to_wait); + if (vsyncs_to_wait > 4) { + // Invalid, so change to 4 + vsyncs_to_wait = 4; + } + dxgi.length_in_vsync_frames = vsyncs_to_wait; + } else { + dxgi.length_in_vsync_frames = 2; + } + + return true; +} + +static void gfx_dxgi_swap_buffers_begin(void) { + //dxgi.length_in_vsync_frames = 1; + ThrowIfFailed(dxgi.swap_chain->Present(dxgi.length_in_vsync_frames, 0)); + UINT this_present_id; + if (dxgi.swap_chain->GetLastPresentCount(&this_present_id) == S_OK) { + dxgi.pending_frame_stats.insert(std::make_pair(this_present_id, dxgi.length_in_vsync_frames)); + } + dxgi.dropped_frame = false; +} + +static void gfx_dxgi_swap_buffers_end(void) { + LARGE_INTEGER t0, t1, t2; + QueryPerformanceCounter(&t0); + QueryPerformanceCounter(&t1); + + if (!dxgi.dropped_frame) { + if (dxgi.waitable_object != nullptr) { + WaitForSingleObject(dxgi.waitable_object, INFINITE); + } + // else TODO: maybe sleep until some estimated time the frame will be shown to reduce lag + } + + DXGI_FRAME_STATISTICS stats; + dxgi.swap_chain->GetFrameStatistics(&stats); + + QueryPerformanceCounter(&t2); + + dxgi.sync_interval_means_frames_to_wait = dxgi.pending_frame_stats.rbegin()->first == stats.PresentCount; + + //printf("done %llu gpu:%d wait:%d freed:%llu frame:%u %u monitor:%u t:%llu\n", (unsigned long long)(t0.QuadPart - dxgi.qpc_init), (int)(t1.QuadPart - t0.QuadPart), (int)(t2.QuadPart - t0.QuadPart), (unsigned long long)(t2.QuadPart - dxgi.qpc_init), dxgi.pending_frame_stats.rbegin()->first, stats.PresentCount, stats.SyncRefreshCount, (unsigned long long)(stats.SyncQPCTime.QuadPart - dxgi.qpc_init)); +} + +static double gfx_dxgi_get_time(void) { + LARGE_INTEGER t; + QueryPerformanceCounter(&t); + return (double)(t.QuadPart - dxgi.qpc_init) / dxgi.qpc_freq; +} + +void gfx_dxgi_create_factory_and_device(bool debug, int d3d_version, bool (*create_device_fn)(IDXGIAdapter1 *adapter, bool test_only)) { + if (dxgi.CreateDXGIFactory2 != nullptr) { + ThrowIfFailed(dxgi.CreateDXGIFactory2(debug ? DXGI_CREATE_FACTORY_DEBUG : 0, __uuidof(IDXGIFactory2), &dxgi.factory)); + } else { + ThrowIfFailed(dxgi.CreateDXGIFactory1(__uuidof(IDXGIFactory2), &dxgi.factory)); + } + + ComPtr adapter; + for (UINT i = 0; dxgi.factory->EnumAdapters1(i, &adapter) != DXGI_ERROR_NOT_FOUND; i++) { + DXGI_ADAPTER_DESC1 desc; + adapter->GetDesc1(&desc); + if (desc.Flags & 2/*DXGI_ADAPTER_FLAG_SOFTWARE*/) { // declaration missing in mingw headers + continue; + } + if (create_device_fn(adapter.Get(), true)) { + break; + } + } + create_device_fn(adapter.Get(), false); + + char title[512]; + wchar_t w_title[512]; + int len = sprintf(title, "%s (Direct3D %d)", dxgi.game_name.c_str(), d3d_version); + mbstowcs(w_title, title, len + 1); + SetWindowTextW(dxgi.h_wnd, w_title); +} + +ComPtr gfx_dxgi_create_swap_chain(IUnknown *device) { + bool win8 = IsWindows8OrGreater(); // DXGI_SCALING_NONE is only supported on Win8 and beyond + bool dxgi_13 = dxgi.CreateDXGIFactory2 != nullptr; // DXGI 1.3 introduced waitable object + + DXGI_SWAP_CHAIN_DESC1 swap_chain_desc = {}; + swap_chain_desc.BufferCount = 2; + swap_chain_desc.Width = 0; + swap_chain_desc.Height = 0; + swap_chain_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; + swap_chain_desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; + swap_chain_desc.Scaling = win8 ? DXGI_SCALING_NONE : DXGI_SCALING_STRETCH; + swap_chain_desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; // Apparently this was backported to Win 7 Platform Update + swap_chain_desc.Flags = dxgi_13 ? DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT : 0; + swap_chain_desc.SampleDesc.Count = 1; + + run_as_dpi_aware([&] () { + // When setting size for the buffers, the values that DXGI puts into the desc (that can later be retrieved by GetDesc1) + // have been divided by the current scaling factor. By making this call dpi aware, no division will be performed. + // The same goes for IDXGISwapChain::ResizeBuffers(), however that function is currently only called from the message handler. + ThrowIfFailed(dxgi.factory->CreateSwapChainForHwnd(device, dxgi.h_wnd, &swap_chain_desc, nullptr, nullptr, &dxgi.swap_chain)); + }); + ThrowIfFailed(dxgi.factory->MakeWindowAssociation(dxgi.h_wnd, DXGI_MWA_NO_ALT_ENTER)); + + ComPtr swap_chain2; + if (dxgi.swap_chain->QueryInterface(__uuidof(IDXGISwapChain2), &swap_chain2) == S_OK) { + ThrowIfFailed(swap_chain2->SetMaximumFrameLatency(1)); + dxgi.waitable_object = swap_chain2->GetFrameLatencyWaitableObject(); + WaitForSingleObject(dxgi.waitable_object, INFINITE); + } else { + ComPtr device1; + ThrowIfFailed(device->QueryInterface(IID_PPV_ARGS(&device1))); + ThrowIfFailed(device1->SetMaximumFrameLatency(1)); + } + + ThrowIfFailed(dxgi.swap_chain->GetDesc1(&swap_chain_desc)); + dxgi.current_width = swap_chain_desc.Width; + dxgi.current_height = swap_chain_desc.Height; + + return dxgi.swap_chain; +} + +HWND gfx_dxgi_get_h_wnd(void) { + return dxgi.h_wnd; +} + +void ThrowIfFailed(HRESULT res) { + if (FAILED(res)) { + fprintf(stderr, "Error: 0x%08X\n", res); + throw res; + } +} + +void ThrowIfFailed(HRESULT res, HWND h_wnd, const char *message) { + if (FAILED(res)) { + char full_message[256]; + sprintf(full_message, "%s\n\nHRESULT: 0x%08X", message, res); + dxgi.showing_error = true; + MessageBox(h_wnd, full_message, "Error", MB_OK | MB_ICONERROR); + throw res; + } +} + +struct GfxWindowManagerAPI gfx_dxgi_api = { + gfx_dxgi_init, + gfx_dxgi_set_keyboard_callbacks, + gfx_dxgi_set_fullscreen_changed_callback, + gfx_dxgi_set_fullscreen, + gfx_dxgi_main_loop, + gfx_dxgi_get_dimensions, + gfx_dxgi_handle_events, + gfx_dxgi_start_frame, + gfx_dxgi_swap_buffers_begin, + gfx_dxgi_swap_buffers_end, + gfx_dxgi_get_time, +}; + +#endif diff --git a/src/decomp/pc/gfx/gfx_dxgi.h b/src/decomp/pc/gfx/gfx_dxgi.h new file mode 100644 index 0000000..d590daa --- /dev/null +++ b/src/decomp/pc/gfx/gfx_dxgi.h @@ -0,0 +1,16 @@ +#ifndef GFX_DXGI_H +#define GFX_DXGI_H + +#include "gfx_rendering_api.h" + +#ifdef DECLARE_GFX_DXGI_FUNCTIONS +void gfx_dxgi_create_factory_and_device(bool debug, int d3d_version, bool (*create_device_fn)(IDXGIAdapter1 *adapter, bool test_only)); +Microsoft::WRL::ComPtr gfx_dxgi_create_swap_chain(IUnknown *device); +HWND gfx_dxgi_get_h_wnd(void); +void ThrowIfFailed(HRESULT res); +void ThrowIfFailed(HRESULT res, HWND h_wnd, const char *message); +#endif + +extern struct GfxWindowManagerAPI gfx_dxgi_api; + +#endif diff --git a/src/decomp/pc/gfx/gfx_glx.c b/src/decomp/pc/gfx/gfx_glx.c new file mode 100644 index 0000000..9d2743e --- /dev/null +++ b/src/decomp/pc/gfx/gfx_glx.c @@ -0,0 +1,620 @@ +#include "../compat.h" + +#if defined(__linux__) || defined(__BSD__) +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "gfx_window_manager_api.h" +#include "gfx_screen_config.h" + +#define GFX_API_NAME "GLX - OpenGL" + +#ifdef VERSION_EU +#define FRAME_INTERVAL_US_NUMERATOR 40000 +#define FRAME_INTERVAL_US_DENOMINATOR 1 +#else +#define FRAME_INTERVAL_US_NUMERATOR 100000 +#define FRAME_INTERVAL_US_DENOMINATOR 3 +#endif + +const struct { + const char *name; + int scancode; +} keymap_name_to_scancode[] = { + {"ESC", 0x01}, + {"AE01", 0x02 }, + {"AE02", 0x03 }, + {"AE03", 0x04 }, + {"AE04", 0x05 }, + {"AE05", 0x06 }, + {"AE06", 0x07 }, + {"AE07", 0x08 }, + {"AE08", 0x09 }, + {"AE09", 0x0a }, + {"AE10", 0x0b }, + {"AE11", 0x0c }, + {"AE12", 0x0d }, + {"BKSP", 0x0e }, + {"TAB", 0x0f }, + {"AD01", 0x10 }, + {"AD02", 0x11 }, + {"AD03", 0x12 }, + {"AD04", 0x13 }, + {"AD05", 0x14 }, + {"AD06", 0x15 }, + {"AD07", 0x16 }, + {"AD08", 0x17 }, + {"AD09", 0x18 }, + {"AD10", 0x19 }, + {"AD11", 0x1a }, + {"AD12", 0x1b }, + {"RTRN", 0x1c }, + {"LCTL", 0x1d }, + {"AC01", 0x1e }, + {"AC02", 0x1f }, + {"AC03", 0x20 }, + {"AC04", 0x21 }, + {"AC05", 0x22 }, + {"AC06", 0x23 }, + {"AC07", 0x24 }, + {"AC08", 0x25 }, + {"AC09", 0x26 }, + {"AC10", 0x27 }, + {"AC11", 0x28 }, + {"TLDE", 0x29 }, + {"LFSH", 0x2a }, + {"BKSL", 0x2b }, + {"AB01", 0x2c }, + {"AB02", 0x2d }, + {"AB03", 0x2e }, + {"AB04", 0x2f }, + {"AB05", 0x30 }, + {"AB06", 0x31 }, + {"AB07", 0x32 }, + {"AB08", 0x33 }, + {"AB09", 0x34 }, + {"AB10", 0x35 }, + {"RTSH", 0x36 }, + {"KPMU", 0x37 }, + {"LALT", 0x38 }, + {"SPCE", 0x39 }, + {"CAPS", 0x3a }, + {"FK01", 0x3b }, + {"FK02", 0x3c }, + {"FK03", 0x3d }, + {"FK04", 0x3e }, + {"FK05", 0x3f }, + {"FK06", 0x40 }, + {"FK07", 0x41 }, + {"FK08", 0x42 }, + {"FK09", 0x43 }, + {"FK10", 0x44 }, + {"NMLK", 0x45 }, + {"SCLK", 0x46 }, + {"KP7", 0x47 }, + {"KP8", 0x48 }, + {"KP9", 0x49 }, + {"KPSU", 0x4a }, + {"KP4", 0x4b }, + {"KP5", 0x4c }, + {"KP6", 0x4d }, + {"KPAD", 0x4e }, + {"KP1", 0x4f }, + {"KP2", 0x50 }, + {"KP3", 0x51 }, + {"KP0", 0x52 }, + {"KPDL", 0x53 }, + {"LVL3", 0x54 }, // correct? + {"", 0x55 }, // not mapped? + {"LSGT", 0x56 }, + {"FK11", 0x57 }, + {"FK12", 0x58 }, + {"AB11", 0x59 }, + {"KATA", 0 }, + {"HIRA", 0 }, + {"HENK", 0 }, + {"HKTG", 0 }, + {"MUHE", 0 }, + {"JPCM", 0 }, + {"KPEN", 0x11c }, + {"RCTL", 0x11d }, + {"KPDV", 0x135 }, + {"PRSC", 0x54 }, // ? + {"RALT", 0x138 }, + {"LNFD", 0 }, + {"HOME", 0x147 }, + {"UP", 0x148 }, + {"PGUP", 0x149 }, + {"LEFT", 0x14b }, + {"RGHT", 0x14d }, + {"END", 0x14f }, + {"DOWN", 0x150 }, + {"PGDN", 0x151 }, + {"INS", 0x152 }, + {"DELE", 0x153 }, + {"PAUS", 0x21d }, + {"LWIN", 0x15b }, + {"RWIN", 0x15c }, + {"COMP", 0x15d }, +}; + +static struct { + Display *dpy; + Window root; + Window win; + + Atom atom_wm_state; + Atom atom_wm_state_fullscreen; + + bool is_fullscreen; + void (*on_fullscreen_changed)(bool is_now_fullscreen); + + int keymap[256]; + bool (*on_key_down)(int scancode); + bool (*on_key_up)(int scancode); + void (*on_all_keys_up)(void); + + PFNGLXGETSYNCVALUESOMLPROC glXGetSyncValuesOML; + PFNGLXSWAPBUFFERSMSCOMLPROC glXSwapBuffersMscOML; + PFNGLXWAITFORSBCOMLPROC glXWaitForSbcOML; + + PFNGLXSWAPINTERVALEXTPROC glXSwapIntervalEXT; + PFNGLXSWAPINTERVALSGIPROC glXSwapIntervalSGI; + + PFNGLXGETVIDEOSYNCSGIPROC glXGetVideoSyncSGI; + PFNGLXWAITVIDEOSYNCSGIPROC glXWaitVideoSyncSGI; + + bool has_oml_sync_control; + uint64_t ust0; + int64_t last_msc; + uint64_t wanted_ust; // multiplied by FRAME_INTERVAL_US_DENOMINATOR + uint64_t vsync_interval; + uint64_t last_ust; + int64_t target_msc; + bool dropped_frame; + + bool has_sgi_video_sync; + uint64_t last_sync_counter; + int64_t this_msc; + int64_t this_ust; +} glx; + +static int64_t get_time(void) { + struct timespec ts; + clock_gettime(CLOCK_MONOTONIC, &ts); + return (int64_t)ts.tv_sec * 1000000 + ts.tv_nsec / 1000; +} + +static int64_t adjust_sync_counter(uint32_t counter) { + uint32_t hi = glx.last_sync_counter >> 32; + uint32_t lo = (uint32_t)glx.last_sync_counter; + if (lo >= 0x80000000U && counter < 0x80000000U) { + // Wrapped + ++hi; + } + glx.last_sync_counter = ((uint64_t)hi << 32) | counter; + return glx.last_sync_counter; +} + +static int64_t glXWaitVideoSyncSGI_wrapper(void) { + unsigned int counter = 0; + glx.glXWaitVideoSyncSGI(1, 0, &counter); + return adjust_sync_counter(counter); +} + +static int64_t glXGetVideoSyncSGI_wrapper(void) { + unsigned int counter = 0; + glx.glXGetVideoSyncSGI(&counter); + return adjust_sync_counter(counter); +} + +static void init_keymap(void) { + XkbDescPtr desc = XkbGetMap(glx.dpy, 0, XkbUseCoreKbd); + XkbGetNames(glx.dpy, XkbKeyNamesMask, desc); + + for (int i = desc->min_key_code; i <= desc->max_key_code && i < 256; i++) { + char name[XkbKeyNameLength + 1]; + memcpy(name, desc->names->keys[i].name, XkbKeyNameLength); + name[XkbKeyNameLength] = '\0'; + for (size_t j = 0; j < sizeof(keymap_name_to_scancode) / sizeof(keymap_name_to_scancode[0]); j++) { + if (strcmp(keymap_name_to_scancode[j].name, name) == 0) { + glx.keymap[i] = keymap_name_to_scancode[j].scancode; + break; + } + } + } + + XkbFreeNames(desc, XkbKeyNamesMask, True); + XkbFreeKeyboard(desc, 0, True); +} + +static void gfx_glx_hide_mouse(bool hide) { + // Removes distracting mouse cursor during fullscreen play + if (hide) { + Cursor hideCursor; + Pixmap bitmapNoData; + XColor black; + static char noData[] = { 0,0,0,0,0,0,0,0 }; + black.red = black.green = black.blue = 0; + + bitmapNoData = XCreateBitmapFromData(glx.dpy, glx.win, noData, 8, 8); + hideCursor = XCreatePixmapCursor(glx.dpy, bitmapNoData, bitmapNoData, + &black, &black, 0, 0); + XDefineCursor(glx.dpy, glx.win, hideCursor); + XSync(glx.dpy, False); + XFreeCursor(glx.dpy, hideCursor); + XFreePixmap(glx.dpy, bitmapNoData); + } else { + XUndefineCursor(glx.dpy, glx.win); + XSync(glx.dpy, False); + } + +} + +static void gfx_glx_set_fullscreen_state(bool on, bool call_callback) { + if (glx.is_fullscreen == on) { + return; + } + glx.is_fullscreen = on; + + XEvent xev; + xev.xany.type = ClientMessage; + xev.xclient.message_type = glx.atom_wm_state; + xev.xclient.format = 32; + xev.xclient.window = glx.win; + xev.xclient.data.l[0] = on; + xev.xclient.data.l[1] = glx.atom_wm_state_fullscreen; + xev.xclient.data.l[2] = 0; + xev.xclient.data.l[3] = 0; + XSendEvent(glx.dpy, glx.root, 0, SubstructureNotifyMask | SubstructureRedirectMask, &xev); + gfx_glx_hide_mouse(on); + + if (glx.on_fullscreen_changed != NULL && call_callback) { + glx.on_fullscreen_changed(on); + } +} + +static bool gfx_glx_check_extension(const char *extensions, const char *extension) { + size_t len = strlen(extension); + const char *pos = extensions; + while ((pos = strstr(pos, extension)) != NULL) { + if ((pos[len] == ' ' || pos[len] == '\0') && (pos == extensions || pos[-1] == ' ')) { + return true; + } + if (pos[len] == '\0') { + break; + } + pos += len + 1; + } + return false; +} + +static void gfx_glx_init(const char *game_name, bool start_in_fullscreen) { + // On NVIDIA proprietary driver, make the driver queue up to two frames on glXSwapBuffers, + // which means that glXSwapBuffers should be non-blocking, + // if we are sure to wait at least one vsync interval between calls. + setenv("__GL_MaxFramesAllowed", "2", true); + + glx.dpy = XOpenDisplay(NULL); + if (glx.dpy == NULL) { + fprintf(stderr, "Cannot connect to X server\n"); + exit(1); + } + int screen = DefaultScreen(glx.dpy); + glx.root = RootWindow(glx.dpy, screen); + + GLint att[] = { GLX_RGBA, GLX_DEPTH_SIZE, 24, GLX_DOUBLEBUFFER, None }; + XVisualInfo *vi = glXChooseVisual(glx.dpy, 0, att); + if (vi == NULL) { + fprintf(stderr, "No appropriate GLX visual found\n"); + exit(1); + } + Colormap cmap = XCreateColormap(glx.dpy, glx.root, vi->visual, AllocNone); + XSetWindowAttributes swa; + swa.colormap = cmap; + swa.event_mask = ExposureMask | KeyPressMask | KeyReleaseMask | FocusChangeMask; + glx.win = XCreateWindow(glx.dpy, glx.root, 0, 0, DESIRED_SCREEN_WIDTH, DESIRED_SCREEN_HEIGHT, 0, vi->depth, InputOutput, vi->visual, CWColormap | CWEventMask, &swa); + + glx.atom_wm_state = XInternAtom(glx.dpy, "_NET_WM_STATE", False); + glx.atom_wm_state_fullscreen = XInternAtom(glx.dpy, "_NET_WM_STATE_FULLSCREEN", False); + XMapWindow(glx.dpy, glx.win); + + if (start_in_fullscreen) { + gfx_glx_set_fullscreen_state(true, false); + } + + char title[512]; + int len = sprintf(title, "%s (%s)", game_name, GFX_API_NAME); + + XStoreName(glx.dpy, glx.win, title); + GLXContext glc = glXCreateContext(glx.dpy, vi, NULL, GL_TRUE); + glXMakeCurrent(glx.dpy, glx.win, glc); + + init_keymap(); + + const char *extensions = glXQueryExtensionsString(glx.dpy, screen); + + if (gfx_glx_check_extension(extensions, "GLX_OML_sync_control")) { + glx.glXGetSyncValuesOML = (PFNGLXGETSYNCVALUESOMLPROC)glXGetProcAddressARB((const GLubyte *)"glXGetSyncValuesOML"); + glx.glXSwapBuffersMscOML = (PFNGLXSWAPBUFFERSMSCOMLPROC)glXGetProcAddressARB((const GLubyte *)"glXSwapBuffersMscOML"); + glx.glXWaitForSbcOML = (PFNGLXWAITFORSBCOMLPROC)glXGetProcAddressARB((const GLubyte *)"glXWaitForSbcOML"); + } + if (gfx_glx_check_extension(extensions, "GLX_EXT_swap_control")) { + glx.glXSwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)glXGetProcAddressARB((const GLubyte *)"glXSwapIntervalEXT"); + } + if (gfx_glx_check_extension(extensions, "GLX_SGI_swap_control")) { + glx.glXSwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC)glXGetProcAddressARB((const GLubyte *)"glXSwapIntervalSGI"); + } + if (gfx_glx_check_extension(extensions, "GLX_SGI_video_sync")) { + glx.glXGetVideoSyncSGI = (PFNGLXGETVIDEOSYNCSGIPROC)glXGetProcAddressARB((const GLubyte *)"glXGetVideoSyncSGI"); + glx.glXWaitVideoSyncSGI = (PFNGLXWAITVIDEOSYNCSGIPROC)glXGetProcAddressARB((const GLubyte *)"glXWaitVideoSyncSGI"); + } + + int64_t ust, msc, sbc; + if (glx.glXGetSyncValuesOML != NULL && glx.glXGetSyncValuesOML(glx.dpy, glx.win, &ust, &msc, &sbc)) { + glx.has_oml_sync_control = true; + glx.ust0 = (uint64_t)ust; + } else { + glx.ust0 = get_time(); + if (glx.glXSwapIntervalEXT != NULL) { + glx.glXSwapIntervalEXT(glx.dpy, glx.win, 1); + } else if (glx.glXSwapIntervalSGI != NULL) { + glx.glXSwapIntervalSGI(1); + } + if (glx.glXGetVideoSyncSGI != NULL) { + // Try if it really works + unsigned int count; + if (glx.glXGetVideoSyncSGI(&count) == 0) { + glx.last_sync_counter = count; + glx.has_sgi_video_sync = true; + } + } + } + glx.vsync_interval = 16666; +} + +static void gfx_glx_set_fullscreen_changed_callback(void (*on_fullscreen_changed)(bool is_now_fullscreen)) { + glx.on_fullscreen_changed = on_fullscreen_changed; +} + +static void gfx_glx_set_fullscreen(bool enable) { + gfx_glx_set_fullscreen_state(enable, true); +} + +static void gfx_glx_set_keyboard_callbacks(bool (*on_key_down)(int scancode), bool (*on_key_up)(int scancode), void (*on_all_keys_up)(void)) { + glx.on_key_down = on_key_down; + glx.on_key_up = on_key_up; + glx.on_all_keys_up = on_all_keys_up; +} + +static void gfx_glx_main_loop(void (*run_one_game_iter)(void)) { + while (1) { + run_one_game_iter(); + } +} + +static void gfx_glx_get_dimensions(uint32_t *width, uint32_t *height) { + XWindowAttributes attributes; + XGetWindowAttributes(glx.dpy, glx.win, &attributes); + *width = attributes.width; + *height = attributes.height; +} + +static void gfx_glx_handle_events(void) { + Atom wm_delete_window = XInternAtom(glx.dpy, "WM_DELETE_WINDOW", 0); + XSetWMProtocols(glx.dpy, glx.win, & wm_delete_window, 1); + while (XPending(glx.dpy)) { + XEvent xev; + XNextEvent(glx.dpy, &xev); + if (xev.type == FocusOut) { + if (glx.on_all_keys_up != NULL) { + glx.on_all_keys_up(); + } + } + if (xev.type == KeyPress || xev.type == KeyRelease) { + if (xev.xkey.keycode < 256) { + int scancode = glx.keymap[xev.xkey.keycode]; + if (scancode != 0) { + if (xev.type == KeyPress) { + if (scancode == 0x44) { // F10 + gfx_glx_set_fullscreen_state(!glx.is_fullscreen, true); + } + if (glx.on_key_down != NULL) { + glx.on_key_down(scancode); + } + } else { + if (glx.on_key_up != NULL) { + glx.on_key_up(scancode); + } + } + } + } + } + if (xev.type == ClientMessage) { + if (xev.xclient.data.l[0] == wm_delete_window) { + exit(0); + } + } + } +} + +static bool gfx_glx_start_frame(void) { + return true; +} + +static void gfx_glx_swap_buffers_begin(void) { + glx.wanted_ust += FRAME_INTERVAL_US_NUMERATOR; // advance 1/30 seconds on JP/US or 1/25 seconds on EU + + if (!glx.has_oml_sync_control && !glx.has_sgi_video_sync) { + glFlush(); + + uint64_t target = glx.wanted_ust / FRAME_INTERVAL_US_DENOMINATOR; + uint64_t now; + while (target > (now = (uint64_t)get_time() - glx.ust0)) { + struct timespec ts = {(target - now) / 1000000, ((target - now) % 1000000) * 1000}; + if (nanosleep(&ts, NULL) == 0) { + break; + } + } + + if (target + 2 * FRAME_INTERVAL_US_NUMERATOR / FRAME_INTERVAL_US_DENOMINATOR < now) { + if (target + 32 * FRAME_INTERVAL_US_NUMERATOR / FRAME_INTERVAL_US_DENOMINATOR >= now) { + printf("Dropping frame\n"); + glx.dropped_frame = true; + return; + } else { + // Reset timer since we are way out of sync + glx.wanted_ust = now * FRAME_INTERVAL_US_DENOMINATOR; + } + } + glXSwapBuffers(glx.dpy, glx.win); + glx.dropped_frame = false; + + return; + } + + double vsyncs_to_wait = (int64_t)(glx.wanted_ust / FRAME_INTERVAL_US_DENOMINATOR - glx.last_ust) / (double)glx.vsync_interval; + if (vsyncs_to_wait <= 0) { + printf("Dropping frame\n"); + // Drop frame + glx.dropped_frame = true; + return; + } + if (floor(vsyncs_to_wait) != vsyncs_to_wait) { + uint64_t left_ust = glx.last_ust + floor(vsyncs_to_wait) * glx.vsync_interval; + uint64_t right_ust = glx.last_ust + ceil(vsyncs_to_wait) * glx.vsync_interval; + uint64_t adjusted_wanted_ust = glx.wanted_ust / FRAME_INTERVAL_US_DENOMINATOR + (glx.last_ust + FRAME_INTERVAL_US_NUMERATOR / FRAME_INTERVAL_US_DENOMINATOR > glx.wanted_ust / FRAME_INTERVAL_US_DENOMINATOR ? 2000 : -2000); + int64_t diff_left = adjusted_wanted_ust - left_ust; + int64_t diff_right = right_ust - adjusted_wanted_ust; + if (diff_left < 0) { + diff_left = -diff_left; + } + if (diff_right < 0) { + diff_right = -diff_right; + } + if (diff_left < diff_right) { + vsyncs_to_wait = floor(vsyncs_to_wait); + } else { + vsyncs_to_wait = ceil(vsyncs_to_wait); + } + if (vsyncs_to_wait <= -4) { + printf("vsyncs_to_wait became -4 or less so dropping frame\n"); + glx.dropped_frame = true; + return; + } else if (vsyncs_to_wait < 1) { + vsyncs_to_wait = 1; + } + } + glx.dropped_frame = false; + //printf("Vsyncs to wait: %d, diff: %d\n", (int)vsyncs_to_wait, (int)(glx.last_ust + (int64_t)vsyncs_to_wait * glx.vsync_interval - glx.wanted_ust / 3)); + if (vsyncs_to_wait > 30) { + // Unreasonable, so change to 2 + vsyncs_to_wait = 2; + } + glx.target_msc = glx.last_msc + vsyncs_to_wait; + + if (glx.has_oml_sync_control) { + glx.glXSwapBuffersMscOML(glx.dpy, glx.win, glx.target_msc, 0, 0); + } else if (glx.has_sgi_video_sync) { + glFlush(); // Try to submit pending work. Don't use glFinish since that busy loops on NVIDIA proprietary driver. + + //uint64_t counter0; + uint64_t counter1, counter2; + + //uint64_t before_wait = get_time(); + + counter1 = glXGetVideoSyncSGI_wrapper(); + //counter0 = counter1; + //int waits = 0; + while (counter1 < (uint64_t)glx.target_msc - 1) { + counter1 = glXWaitVideoSyncSGI_wrapper(); + //++waits; + } + + //uint64_t before = get_time(); + glXSwapBuffers(glx.dpy, glx.win); + + + counter2 = glXGetVideoSyncSGI_wrapper(); + while (counter2 < (uint64_t)glx.target_msc) { + counter2 = glXWaitVideoSyncSGI_wrapper(); + } + uint64_t after = get_time(); + + //printf("%.3f %.3f %.3f\t%.3f\t%u %d %.2f %u %d\n", before_wait * 0.000060, before * 0.000060, after * 0.000060, (after - before) * 0.000060, counter0, counter2 - counter0, vsyncs_to_wait, (unsigned int)glx.target_msc, waits); + glx.this_msc = counter2; + glx.this_ust = after; + } +} + +static void gfx_glx_swap_buffers_end(void) { + if (glx.dropped_frame || (!glx.has_oml_sync_control && !glx.has_sgi_video_sync)) { + return; + } + + int64_t ust, msc, sbc; + if (glx.has_oml_sync_control) { + if (!glx.glXWaitForSbcOML(glx.dpy, glx.win, 0, &ust, &msc, &sbc)) { + // X connection broke or something? + glx.last_ust += (glx.target_msc - glx.last_msc) * glx.vsync_interval; + glx.last_msc = glx.target_msc; + return; + } + } else { + ust = glx.this_ust; + msc = glx.this_msc; + } + uint64_t this_ust = ust - glx.ust0; + uint64_t vsyncs_passed = msc - glx.last_msc; + bool bad_vsync_interval = false; + if (glx.last_ust != 0 && vsyncs_passed != 0) { + uint64_t new_vsync_interval = (this_ust - glx.last_ust) / vsyncs_passed; + if (new_vsync_interval <= 500000) { + // Should be less than 0.5 seconds to be trusted + glx.vsync_interval = new_vsync_interval; + } else { + bad_vsync_interval = true; + } + //printf("glx.vsync_interval: %d\n", (int)glx.vsync_interval); + } + glx.last_ust = this_ust; + glx.last_msc = msc; + if (msc != glx.target_msc) { + printf("Frame too late by %d vsyncs\n", (int)(msc - glx.target_msc)); + } + if (msc - glx.target_msc >= 8 || bad_vsync_interval) { + // Frame arrived way too late, so reset timer from here + printf("Reseting timer\n"); + glx.wanted_ust = this_ust * FRAME_INTERVAL_US_DENOMINATOR; + } +} + +static double gfx_glx_get_time(void) { + return 0.0; +} + +struct GfxWindowManagerAPI gfx_glx = { + gfx_glx_init, + gfx_glx_set_keyboard_callbacks, + gfx_glx_set_fullscreen_changed_callback, + gfx_glx_set_fullscreen, + gfx_glx_main_loop, + gfx_glx_get_dimensions, + gfx_glx_handle_events, + gfx_glx_start_frame, + gfx_glx_swap_buffers_begin, + gfx_glx_swap_buffers_end, + gfx_glx_get_time +}; + +#endif diff --git a/src/decomp/pc/gfx/gfx_glx.h b/src/decomp/pc/gfx/gfx_glx.h new file mode 100644 index 0000000..1ca4109 --- /dev/null +++ b/src/decomp/pc/gfx/gfx_glx.h @@ -0,0 +1,8 @@ +#ifndef GFX_GLX_H +#define GFX_GLX_H + +#include "gfx_window_manager_api.h" + +extern struct GfxWindowManagerAPI gfx_glx; + +#endif diff --git a/src/decomp/pc/gfx/gfx_opengl.c b/src/decomp/pc/gfx/gfx_opengl.c new file mode 100644 index 0000000..7bc9745 --- /dev/null +++ b/src/decomp/pc/gfx/gfx_opengl.c @@ -0,0 +1,531 @@ +#ifdef ENABLE_OPENGL + +#include +#include + +#ifndef _LANGUAGE_C +#define _LANGUAGE_C +#endif +#include + +#ifdef __MINGW32__ +#define FOR_WINDOWS 1 +#else +#define FOR_WINDOWS 0 +#endif + +#if FOR_WINDOWS +#include +#include "SDL.h" +#define GL_GLEXT_PROTOTYPES 1 +#include "SDL_opengl.h" +#else +#include +#define GL_GLEXT_PROTOTYPES 1 +#include +#endif + +#include "gfx_cc.h" +#include "gfx_rendering_api.h" + +struct ShaderProgram { + uint32_t shader_id; + GLuint opengl_program_id; + uint8_t num_inputs; + bool used_textures[2]; + uint8_t num_floats; + GLint attrib_locations[7]; + uint8_t attrib_sizes[7]; + uint8_t num_attribs; + bool used_noise; + GLint frame_count_location; + GLint window_height_location; +}; + +static struct ShaderProgram shader_program_pool[64]; +static uint8_t shader_program_pool_size; +static GLuint opengl_vbo; + +static uint32_t frame_count; +static uint32_t current_height; + +static bool gfx_opengl_z_is_from_0_to_1(void) { + return false; +} + +static void gfx_opengl_vertex_array_set_attribs(struct ShaderProgram *prg) { + size_t num_floats = prg->num_floats; + size_t pos = 0; + + for (int i = 0; i < prg->num_attribs; i++) { + glEnableVertexAttribArray(prg->attrib_locations[i]); + glVertexAttribPointer(prg->attrib_locations[i], prg->attrib_sizes[i], GL_FLOAT, GL_FALSE, num_floats * sizeof(float), (void *) (pos * sizeof(float))); + pos += prg->attrib_sizes[i]; + } +} + +static void gfx_opengl_set_uniforms(struct ShaderProgram *prg) { + if (prg->used_noise) { + glUniform1i(prg->frame_count_location, frame_count); + glUniform1i(prg->window_height_location, current_height); + } +} + +static void gfx_opengl_unload_shader(struct ShaderProgram *old_prg) { + if (old_prg != NULL) { + for (int i = 0; i < old_prg->num_attribs; i++) { + glDisableVertexAttribArray(old_prg->attrib_locations[i]); + } + } +} + +static void gfx_opengl_load_shader(struct ShaderProgram *new_prg) { + glUseProgram(new_prg->opengl_program_id); + gfx_opengl_vertex_array_set_attribs(new_prg); + gfx_opengl_set_uniforms(new_prg); +} + +static void append_str(char *buf, size_t *len, const char *str) { + while (*str != '\0') buf[(*len)++] = *str++; +} + +static void append_line(char *buf, size_t *len, const char *str) { + while (*str != '\0') buf[(*len)++] = *str++; + buf[(*len)++] = '\n'; +} + +static const char *shader_item_to_str(uint32_t item, bool with_alpha, bool only_alpha, bool inputs_have_alpha, bool hint_single_element) { + if (!only_alpha) { + switch (item) { + case SHADER_0: + return with_alpha ? "vec4(0.0, 0.0, 0.0, 0.0)" : "vec3(0.0, 0.0, 0.0)"; + case SHADER_INPUT_1: + return with_alpha || !inputs_have_alpha ? "vInput1" : "vInput1.rgb"; + case SHADER_INPUT_2: + return with_alpha || !inputs_have_alpha ? "vInput2" : "vInput2.rgb"; + case SHADER_INPUT_3: + return with_alpha || !inputs_have_alpha ? "vInput3" : "vInput3.rgb"; + case SHADER_INPUT_4: + return with_alpha || !inputs_have_alpha ? "vInput4" : "vInput4.rgb"; + case SHADER_TEXEL0: + return with_alpha ? "texVal0" : "texVal0.rgb"; + case SHADER_TEXEL0A: + return hint_single_element ? "texVal0.a" : + (with_alpha ? "vec4(texVal0.a, texVal0.a, texVal0.a, texVal0.a)" : "vec3(texVal0.a, texVal0.a, texVal0.a)"); + case SHADER_TEXEL1: + return with_alpha ? "texVal1" : "texVal1.rgb"; + } + } else { + switch (item) { + case SHADER_0: + return "0.0"; + case SHADER_INPUT_1: + return "vInput1.a"; + case SHADER_INPUT_2: + return "vInput2.a"; + case SHADER_INPUT_3: + return "vInput3.a"; + case SHADER_INPUT_4: + return "vInput4.a"; + case SHADER_TEXEL0: + return "texVal0.a"; + case SHADER_TEXEL0A: + return "texVal0.a"; + case SHADER_TEXEL1: + return "texVal1.a"; + } + } +} + +static void append_formula(char *buf, size_t *len, uint8_t c[2][4], bool do_single, bool do_multiply, bool do_mix, bool with_alpha, bool only_alpha, bool opt_alpha) { + if (do_single) { + append_str(buf, len, shader_item_to_str(c[only_alpha][3], with_alpha, only_alpha, opt_alpha, false)); + } else if (do_multiply) { + append_str(buf, len, shader_item_to_str(c[only_alpha][0], with_alpha, only_alpha, opt_alpha, false)); + append_str(buf, len, " * "); + append_str(buf, len, shader_item_to_str(c[only_alpha][2], with_alpha, only_alpha, opt_alpha, true)); + } else if (do_mix) { + append_str(buf, len, "mix("); + append_str(buf, len, shader_item_to_str(c[only_alpha][1], with_alpha, only_alpha, opt_alpha, false)); + append_str(buf, len, ", "); + append_str(buf, len, shader_item_to_str(c[only_alpha][0], with_alpha, only_alpha, opt_alpha, false)); + append_str(buf, len, ", "); + append_str(buf, len, shader_item_to_str(c[only_alpha][2], with_alpha, only_alpha, opt_alpha, true)); + append_str(buf, len, ")"); + } else { + append_str(buf, len, "("); + append_str(buf, len, shader_item_to_str(c[only_alpha][0], with_alpha, only_alpha, opt_alpha, false)); + append_str(buf, len, " - "); + append_str(buf, len, shader_item_to_str(c[only_alpha][1], with_alpha, only_alpha, opt_alpha, false)); + append_str(buf, len, ") * "); + append_str(buf, len, shader_item_to_str(c[only_alpha][2], with_alpha, only_alpha, opt_alpha, true)); + append_str(buf, len, " + "); + append_str(buf, len, shader_item_to_str(c[only_alpha][3], with_alpha, only_alpha, opt_alpha, false)); + } +} + +static struct ShaderProgram *gfx_opengl_create_and_load_new_shader(uint32_t shader_id) { + struct CCFeatures cc_features; + gfx_cc_get_features(shader_id, &cc_features); + + char vs_buf[1024]; + char fs_buf[1024]; + size_t vs_len = 0; + size_t fs_len = 0; + size_t num_floats = 4; + + // Vertex shader + append_line(vs_buf, &vs_len, "#version 110"); + append_line(vs_buf, &vs_len, "attribute vec4 aVtxPos;"); + if (cc_features.used_textures[0] || cc_features.used_textures[1]) { + append_line(vs_buf, &vs_len, "attribute vec2 aTexCoord;"); + append_line(vs_buf, &vs_len, "varying vec2 vTexCoord;"); + num_floats += 2; + } + if (cc_features.opt_fog) { + append_line(vs_buf, &vs_len, "attribute vec4 aFog;"); + append_line(vs_buf, &vs_len, "varying vec4 vFog;"); + num_floats += 4; + } + for (int i = 0; i < cc_features.num_inputs; i++) { + vs_len += sprintf(vs_buf + vs_len, "attribute vec%d aInput%d;\n", cc_features.opt_alpha ? 4 : 3, i + 1); + vs_len += sprintf(vs_buf + vs_len, "varying vec%d vInput%d;\n", cc_features.opt_alpha ? 4 : 3, i + 1); + num_floats += cc_features.opt_alpha ? 4 : 3; + } + append_line(vs_buf, &vs_len, "void main() {"); + if (cc_features.used_textures[0] || cc_features.used_textures[1]) { + append_line(vs_buf, &vs_len, "vTexCoord = aTexCoord;"); + } + if (cc_features.opt_fog) { + append_line(vs_buf, &vs_len, "vFog = aFog;"); + } + for (int i = 0; i < cc_features.num_inputs; i++) { + vs_len += sprintf(vs_buf + vs_len, "vInput%d = aInput%d;\n", i + 1, i + 1); + } + append_line(vs_buf, &vs_len, "gl_Position = aVtxPos;"); + append_line(vs_buf, &vs_len, "}"); + + // Fragment shader + append_line(fs_buf, &fs_len, "#version 110"); + //append_line(fs_buf, &fs_len, "precision mediump float;"); + if (cc_features.used_textures[0] || cc_features.used_textures[1]) { + append_line(fs_buf, &fs_len, "varying vec2 vTexCoord;"); + } + if (cc_features.opt_fog) { + append_line(fs_buf, &fs_len, "varying vec4 vFog;"); + } + for (int i = 0; i < cc_features.num_inputs; i++) { + fs_len += sprintf(fs_buf + fs_len, "varying vec%d vInput%d;\n", cc_features.opt_alpha ? 4 : 3, i + 1); + } + if (cc_features.used_textures[0]) { + append_line(fs_buf, &fs_len, "uniform sampler2D uTex0;"); + } + if (cc_features.used_textures[1]) { + append_line(fs_buf, &fs_len, "uniform sampler2D uTex1;"); + } + + if (cc_features.opt_alpha && cc_features.opt_noise) { + append_line(fs_buf, &fs_len, "uniform int frame_count;"); + append_line(fs_buf, &fs_len, "uniform int window_height;"); + + append_line(fs_buf, &fs_len, "float random(in vec3 value) {"); + append_line(fs_buf, &fs_len, " float random = dot(sin(value), vec3(12.9898, 78.233, 37.719));"); + append_line(fs_buf, &fs_len, " return fract(sin(random) * 143758.5453);"); + append_line(fs_buf, &fs_len, "}"); + } + + append_line(fs_buf, &fs_len, "void main() {"); + + if (cc_features.used_textures[0]) { + append_line(fs_buf, &fs_len, "vec4 texVal0 = texture2D(uTex0, vTexCoord);"); + } + if (cc_features.used_textures[1]) { + append_line(fs_buf, &fs_len, "vec4 texVal1 = texture2D(uTex1, vTexCoord);"); + } + + append_str(fs_buf, &fs_len, cc_features.opt_alpha ? "vec4 texel = " : "vec3 texel = "); + if (!cc_features.color_alpha_same && cc_features.opt_alpha) { + append_str(fs_buf, &fs_len, "vec4("); + append_formula(fs_buf, &fs_len, cc_features.c, cc_features.do_single[0], cc_features.do_multiply[0], cc_features.do_mix[0], false, false, true); + append_str(fs_buf, &fs_len, ", "); + append_formula(fs_buf, &fs_len, cc_features.c, cc_features.do_single[1], cc_features.do_multiply[1], cc_features.do_mix[1], true, true, true); + append_str(fs_buf, &fs_len, ")"); + } else { + append_formula(fs_buf, &fs_len, cc_features.c, cc_features.do_single[0], cc_features.do_multiply[0], cc_features.do_mix[0], cc_features.opt_alpha, false, cc_features.opt_alpha); + } + append_line(fs_buf, &fs_len, ";"); + + if (cc_features.opt_texture_edge && cc_features.opt_alpha) { + append_line(fs_buf, &fs_len, "if (texel.a > 0.3) texel.a = 1.0; else discard;"); + } + // TODO discard if alpha is 0? + if (cc_features.opt_fog) { + if (cc_features.opt_alpha) { + append_line(fs_buf, &fs_len, "texel = vec4(mix(texel.rgb, vFog.rgb, vFog.a), texel.a);"); + } else { + append_line(fs_buf, &fs_len, "texel = mix(texel, vFog.rgb, vFog.a);"); + } + } + + if (cc_features.opt_alpha && cc_features.opt_noise) { + append_line(fs_buf, &fs_len, "texel.a *= floor(random(vec3(floor(gl_FragCoord.xy * (240.0 / float(window_height))), float(frame_count))) + 0.5);"); + } + + if (cc_features.opt_alpha) { + append_line(fs_buf, &fs_len, "gl_FragColor = texel;"); + } else { + append_line(fs_buf, &fs_len, "gl_FragColor = vec4(texel, 1.0);"); + } + append_line(fs_buf, &fs_len, "}"); + + vs_buf[vs_len] = '\0'; + fs_buf[fs_len] = '\0'; + + /*puts("Vertex shader:"); + puts(vs_buf); + puts("Fragment shader:"); + puts(fs_buf); + puts("End");*/ + + const GLchar *sources[2] = { vs_buf, fs_buf }; + const GLint lengths[2] = { vs_len, fs_len }; + GLint success; + + GLuint vertex_shader = glCreateShader(GL_VERTEX_SHADER); + glShaderSource(vertex_shader, 1, &sources[0], &lengths[0]); + glCompileShader(vertex_shader); + glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &success); + if (!success) { + GLint max_length = 0; + glGetShaderiv(vertex_shader, GL_INFO_LOG_LENGTH, &max_length); + char error_log[1024]; + fprintf(stderr, "Vertex shader compilation failed\n"); + glGetShaderInfoLog(vertex_shader, max_length, &max_length, &error_log[0]); + fprintf(stderr, "%s\n", &error_log[0]); + abort(); + } + + GLuint fragment_shader = glCreateShader(GL_FRAGMENT_SHADER); + glShaderSource(fragment_shader, 1, &sources[1], &lengths[1]); + glCompileShader(fragment_shader); + glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &success); + if (!success) { + GLint max_length = 0; + glGetShaderiv(fragment_shader, GL_INFO_LOG_LENGTH, &max_length); + char error_log[1024]; + fprintf(stderr, "Fragment shader compilation failed\n"); + glGetShaderInfoLog(fragment_shader, max_length, &max_length, &error_log[0]); + fprintf(stderr, "%s\n", &error_log[0]); + abort(); + } + + GLuint shader_program = glCreateProgram(); + glAttachShader(shader_program, vertex_shader); + glAttachShader(shader_program, fragment_shader); + glLinkProgram(shader_program); + + size_t cnt = 0; + + struct ShaderProgram *prg = &shader_program_pool[shader_program_pool_size++]; + prg->attrib_locations[cnt] = glGetAttribLocation(shader_program, "aVtxPos"); + prg->attrib_sizes[cnt] = 4; + ++cnt; + + if (cc_features.used_textures[0] || cc_features.used_textures[1]) { + prg->attrib_locations[cnt] = glGetAttribLocation(shader_program, "aTexCoord"); + prg->attrib_sizes[cnt] = 2; + ++cnt; + } + + if (cc_features.opt_fog) { + prg->attrib_locations[cnt] = glGetAttribLocation(shader_program, "aFog"); + prg->attrib_sizes[cnt] = 4; + ++cnt; + } + + for (int i = 0; i < cc_features.num_inputs; i++) { + char name[16]; + sprintf(name, "aInput%d", i + 1); + prg->attrib_locations[cnt] = glGetAttribLocation(shader_program, name); + prg->attrib_sizes[cnt] = cc_features.opt_alpha ? 4 : 3; + ++cnt; + } + + prg->shader_id = shader_id; + prg->opengl_program_id = shader_program; + prg->num_inputs = cc_features.num_inputs; + prg->used_textures[0] = cc_features.used_textures[0]; + prg->used_textures[1] = cc_features.used_textures[1]; + prg->num_floats = num_floats; + prg->num_attribs = cnt; + + gfx_opengl_load_shader(prg); + + if (cc_features.used_textures[0]) { + GLint sampler_location = glGetUniformLocation(shader_program, "uTex0"); + glUniform1i(sampler_location, 0); + } + if (cc_features.used_textures[1]) { + GLint sampler_location = glGetUniformLocation(shader_program, "uTex1"); + glUniform1i(sampler_location, 1); + } + + if (cc_features.opt_alpha && cc_features.opt_noise) { + prg->frame_count_location = glGetUniformLocation(shader_program, "frame_count"); + prg->window_height_location = glGetUniformLocation(shader_program, "window_height"); + prg->used_noise = true; + } else { + prg->used_noise = false; + } + + return prg; +} + +static struct ShaderProgram *gfx_opengl_lookup_shader(uint32_t shader_id) { + for (size_t i = 0; i < shader_program_pool_size; i++) { + if (shader_program_pool[i].shader_id == shader_id) { + return &shader_program_pool[i]; + } + } + return NULL; +} + +static void gfx_opengl_shader_get_info(struct ShaderProgram *prg, uint8_t *num_inputs, bool used_textures[2]) { + *num_inputs = prg->num_inputs; + used_textures[0] = prg->used_textures[0]; + used_textures[1] = prg->used_textures[1]; +} + +static GLuint gfx_opengl_new_texture(void) { + GLuint ret; + glGenTextures(1, &ret); + return ret; +} + +static void gfx_opengl_select_texture(int tile, GLuint texture_id) { + glActiveTexture(GL_TEXTURE0 + tile); + glBindTexture(GL_TEXTURE_2D, texture_id); +} + +static void gfx_opengl_upload_texture(const uint8_t *rgba32_buf, int width, int height) { + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, rgba32_buf); +} + +static uint32_t gfx_cm_to_opengl(uint32_t val) { + if (val & G_TX_CLAMP) { + return GL_CLAMP_TO_EDGE; + } + return (val & G_TX_MIRROR) ? GL_MIRRORED_REPEAT : GL_REPEAT; +} + +static void gfx_opengl_set_sampler_parameters(int tile, bool linear_filter, uint32_t cms, uint32_t cmt) { + glActiveTexture(GL_TEXTURE0 + tile); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, linear_filter ? GL_LINEAR : GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, linear_filter ? GL_LINEAR : GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, gfx_cm_to_opengl(cms)); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, gfx_cm_to_opengl(cmt)); +} + +static void gfx_opengl_set_depth_test(bool depth_test) { + if (depth_test) { + glEnable(GL_DEPTH_TEST); + } else { + glDisable(GL_DEPTH_TEST); + } +} + +static void gfx_opengl_set_depth_mask(bool z_upd) { + glDepthMask(z_upd ? GL_TRUE : GL_FALSE); +} + +static void gfx_opengl_set_zmode_decal(bool zmode_decal) { + if (zmode_decal) { + glPolygonOffset(-2, -2); + glEnable(GL_POLYGON_OFFSET_FILL); + } else { + glPolygonOffset(0, 0); + glDisable(GL_POLYGON_OFFSET_FILL); + } +} + +static void gfx_opengl_set_viewport(int x, int y, int width, int height) { + glViewport(x, y, width, height); + current_height = height; +} + +static void gfx_opengl_set_scissor(int x, int y, int width, int height) { + glScissor(x, y, width, height); +} + +static void gfx_opengl_set_use_alpha(bool use_alpha) { + if (use_alpha) { + glEnable(GL_BLEND); + } else { + glDisable(GL_BLEND); + } +} + +static void gfx_opengl_draw_triangles(float buf_vbo[], size_t buf_vbo_len, size_t buf_vbo_num_tris) { + //printf("flushing %d tris\n", buf_vbo_num_tris); + glBufferData(GL_ARRAY_BUFFER, sizeof(float) * buf_vbo_len, buf_vbo, GL_STREAM_DRAW); + glDrawArrays(GL_TRIANGLES, 0, 3 * buf_vbo_num_tris); +} + +static void gfx_opengl_init(void) { +#if FOR_WINDOWS + glewInit(); +#endif + + glGenBuffers(1, &opengl_vbo); + + glBindBuffer(GL_ARRAY_BUFFER, opengl_vbo); + + glDepthFunc(GL_LEQUAL); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); +} + +static void gfx_opengl_on_resize(void) { +} + +static void gfx_opengl_start_frame(void) { + frame_count++; + + glDisable(GL_SCISSOR_TEST); + glDepthMask(GL_TRUE); // Must be set to clear Z-buffer + glClearColor(0.0f, 0.0f, 0.0f, 1.0f); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + glEnable(GL_SCISSOR_TEST); +} + +static void gfx_opengl_end_frame(void) { +} + +static void gfx_opengl_finish_render(void) { +} + +struct GfxRenderingAPI gfx_opengl_api = { + gfx_opengl_z_is_from_0_to_1, + gfx_opengl_unload_shader, + gfx_opengl_load_shader, + gfx_opengl_create_and_load_new_shader, + gfx_opengl_lookup_shader, + gfx_opengl_shader_get_info, + gfx_opengl_new_texture, + gfx_opengl_select_texture, + gfx_opengl_upload_texture, + gfx_opengl_set_sampler_parameters, + gfx_opengl_set_depth_test, + gfx_opengl_set_depth_mask, + gfx_opengl_set_zmode_decal, + gfx_opengl_set_viewport, + gfx_opengl_set_scissor, + gfx_opengl_set_use_alpha, + gfx_opengl_draw_triangles, + gfx_opengl_init, + gfx_opengl_on_resize, + gfx_opengl_start_frame, + gfx_opengl_end_frame, + gfx_opengl_finish_render +}; + +#endif diff --git a/src/decomp/pc/gfx/gfx_opengl.h b/src/decomp/pc/gfx/gfx_opengl.h new file mode 100644 index 0000000..95be897 --- /dev/null +++ b/src/decomp/pc/gfx/gfx_opengl.h @@ -0,0 +1,8 @@ +#ifndef GFX_OPENGL_H +#define GFX_OPENGL_H + +#include "gfx_rendering_api.h" + +extern struct GfxRenderingAPI gfx_opengl_api; + +#endif diff --git a/src/decomp/pc/gfx/gfx_pc.c b/src/decomp/pc/gfx/gfx_pc.c new file mode 100644 index 0000000..15d7b94 --- /dev/null +++ b/src/decomp/pc/gfx/gfx_pc.c @@ -0,0 +1,1691 @@ +#include +#include +#include +#include +#include +#include + +#ifndef _LANGUAGE_C +#define _LANGUAGE_C +#endif +#include + +#include "gfx_pc.h" +#include "gfx_cc.h" +#include "gfx_window_manager_api.h" +#include "gfx_rendering_api.h" +#include "gfx_screen_config.h" + +#define SUPPORT_CHECK(x) assert(x) + +// SCALE_M_N: upscale/downscale M-bit integer to N-bit +#define SCALE_5_8(VAL_) (((VAL_) * 0xFF) / 0x1F) +#define SCALE_8_5(VAL_) ((((VAL_) + 4) * 0x1F) / 0xFF) +#define SCALE_4_8(VAL_) ((VAL_) * 0x11) +#define SCALE_8_4(VAL_) ((VAL_) / 0x11) +#define SCALE_3_8(VAL_) ((VAL_) * 0x24) +#define SCALE_8_3(VAL_) ((VAL_) / 0x24) + +#define SCREEN_WIDTH 320 +#define SCREEN_HEIGHT 240 +#define HALF_SCREEN_WIDTH (SCREEN_WIDTH / 2) +#define HALF_SCREEN_HEIGHT (SCREEN_HEIGHT / 2) + +#define RATIO_X (gfx_current_dimensions.width / (2.0f * HALF_SCREEN_WIDTH)) +#define RATIO_Y (gfx_current_dimensions.height / (2.0f * HALF_SCREEN_HEIGHT)) + +#define MAX_BUFFERED 256 +#define MAX_LIGHTS 2 +#define MAX_VERTICES 64 + +struct RGBA { + uint8_t r, g, b, a; +}; + +struct XYWidthHeight { + uint16_t x, y, width, height; +}; + +struct LoadedVertex { + float x, y, z, w; + float u, v; + struct RGBA color; + uint8_t clip_rej; +}; + +struct TextureHashmapNode { + struct TextureHashmapNode *next; + + const uint8_t *texture_addr; + uint8_t fmt, siz; + + uint32_t texture_id; + uint8_t cms, cmt; + bool linear_filter; +}; +static struct { + struct TextureHashmapNode *hashmap[1024]; + struct TextureHashmapNode pool[512]; + uint32_t pool_pos; +} gfx_texture_cache; + +struct ColorCombiner { + uint32_t cc_id; + struct ShaderProgram *prg; + uint8_t shader_input_mapping[2][4]; +}; + +static struct ColorCombiner color_combiner_pool[64]; +static uint8_t color_combiner_pool_size; + +static struct RSP { + float modelview_matrix_stack[11][4][4]; + uint8_t modelview_matrix_stack_size; + + float MP_matrix[4][4]; + float P_matrix[4][4]; + + Light_t current_lights[MAX_LIGHTS + 1]; + float current_lights_coeffs[MAX_LIGHTS][3]; + float current_lookat_coeffs[2][3]; // lookat_x, lookat_y + uint8_t current_num_lights; // includes ambient light + bool lights_changed; + + uint32_t geometry_mode; + int16_t fog_mul, fog_offset; + + struct { + // U0.16 + uint16_t s, t; + } texture_scaling_factor; + + struct LoadedVertex loaded_vertices[MAX_VERTICES + 4]; + + uint8_t saved_opcode; + uint8_t saved_tile; + uint16_t saved_uls, saved_ult; + int32_t saved_lrx, saved_lry, saved_ulx, saved_uly; +} rsp; + +static struct RDP { + const uint8_t *palette; + struct { + const uint8_t *addr; + uint8_t siz; + uint8_t tile_number; + } texture_to_load; + struct { + const uint8_t *addr; + uint32_t size_bytes; + } loaded_texture[2]; + struct { + uint8_t fmt; + uint8_t siz; + uint8_t cms, cmt; + uint16_t uls, ult, lrs, lrt; // U10.2 + uint32_t line_size_bytes; + } texture_tile; + bool textures_changed[2]; + + uint32_t other_mode_l, other_mode_h; + uint32_t combine_mode; + + struct RGBA env_color, prim_color, fog_color, fill_color; + struct XYWidthHeight viewport, scissor; + bool viewport_or_scissor_changed; + void *z_buf_address; + void *color_image_address; +} rdp; + +static struct RenderingState { + bool depth_test; + bool depth_mask; + bool decal_mode; + bool alpha_blend; + struct XYWidthHeight viewport, scissor; + struct ShaderProgram *shader_program; + struct TextureHashmapNode *textures[2]; +} rendering_state; + +struct GfxDimensions gfx_current_dimensions; + +static bool dropped_frame; + +static float buf_vbo[MAX_BUFFERED * (26 * 3)]; // 3 vertices in a triangle and 26 floats per vtx +static size_t buf_vbo_len; +static size_t buf_vbo_num_tris; + +static struct GfxWindowManagerAPI *gfx_wapi; +static struct GfxRenderingAPI *gfx_rapi; + +#include +static unsigned long get_time(void) { + struct timespec ts; + clock_gettime(CLOCK_MONOTONIC, &ts); + return (unsigned long)ts.tv_sec * 1000000 + ts.tv_nsec / 1000; +} + +static void gfx_flush(void) { + if (buf_vbo_len > 0) { + int num = buf_vbo_num_tris; + unsigned long t0 = get_time(); + gfx_rapi->draw_triangles(buf_vbo, buf_vbo_len, buf_vbo_num_tris); + buf_vbo_len = 0; + buf_vbo_num_tris = 0; + unsigned long t1 = get_time(); + /*if (t1 - t0 > 1000) { + printf("f: %d %d\n", num, (int)(t1 - t0)); + }*/ + } +} + +static struct ShaderProgram *gfx_lookup_or_create_shader_program(uint32_t shader_id) { + struct ShaderProgram *prg = gfx_rapi->lookup_shader(shader_id); + if (prg == NULL) { + gfx_rapi->unload_shader(rendering_state.shader_program); + prg = gfx_rapi->create_and_load_new_shader(shader_id); + rendering_state.shader_program = prg; + } + return prg; +} + +static void gfx_generate_cc(struct ColorCombiner *comb, uint32_t cc_id) { + uint8_t c[2][4]; + uint32_t shader_id = (cc_id >> 24) << 24; + uint8_t shader_input_mapping[2][4] = {{0}}; + for (int i = 0; i < 4; i++) { + c[0][i] = (cc_id >> (i * 3)) & 7; + c[1][i] = (cc_id >> (12 + i * 3)) & 7; + } + for (int i = 0; i < 2; i++) { + if (c[i][0] == c[i][1] || c[i][2] == CC_0) { + c[i][0] = c[i][1] = c[i][2] = 0; + } + uint8_t input_number[8] = {0}; + int next_input_number = SHADER_INPUT_1; + for (int j = 0; j < 4; j++) { + int val = 0; + switch (c[i][j]) { + case CC_0: + break; + case CC_TEXEL0: + val = SHADER_TEXEL0; + break; + case CC_TEXEL1: + val = SHADER_TEXEL1; + break; + case CC_TEXEL0A: + val = SHADER_TEXEL0A; + break; + case CC_PRIM: + case CC_SHADE: + case CC_ENV: + case CC_LOD: + if (input_number[c[i][j]] == 0) { + shader_input_mapping[i][next_input_number - 1] = c[i][j]; + input_number[c[i][j]] = next_input_number++; + } + val = input_number[c[i][j]]; + break; + } + shader_id |= val << (i * 12 + j * 3); + } + } + comb->cc_id = cc_id; + comb->prg = gfx_lookup_or_create_shader_program(shader_id); + memcpy(comb->shader_input_mapping, shader_input_mapping, sizeof(shader_input_mapping)); +} + +static struct ColorCombiner *gfx_lookup_or_create_color_combiner(uint32_t cc_id) { + static struct ColorCombiner *prev_combiner; + if (prev_combiner != NULL && prev_combiner->cc_id == cc_id) { + return prev_combiner; + } + + for (size_t i = 0; i < color_combiner_pool_size; i++) { + if (color_combiner_pool[i].cc_id == cc_id) { + return prev_combiner = &color_combiner_pool[i]; + } + } + gfx_flush(); + struct ColorCombiner *comb = &color_combiner_pool[color_combiner_pool_size++]; + gfx_generate_cc(comb, cc_id); + return prev_combiner = comb; +} + +static bool gfx_texture_cache_lookup(int tile, struct TextureHashmapNode **n, const uint8_t *orig_addr, uint32_t fmt, uint32_t siz) { + size_t hash = (uintptr_t)orig_addr; + hash = (hash >> 5) & 0x3ff; + struct TextureHashmapNode **node = &gfx_texture_cache.hashmap[hash]; + while (*node != NULL && *node - gfx_texture_cache.pool < (int)gfx_texture_cache.pool_pos) { + if ((*node)->texture_addr == orig_addr && (*node)->fmt == fmt && (*node)->siz == siz) { + gfx_rapi->select_texture(tile, (*node)->texture_id); + *n = *node; + return true; + } + node = &(*node)->next; + } + if (gfx_texture_cache.pool_pos == sizeof(gfx_texture_cache.pool) / sizeof(struct TextureHashmapNode)) { + // Pool is full. We just invalidate everything and start over. + gfx_texture_cache.pool_pos = 0; + node = &gfx_texture_cache.hashmap[hash]; + //puts("Clearing texture cache"); + } + *node = &gfx_texture_cache.pool[gfx_texture_cache.pool_pos++]; + if ((*node)->texture_addr == NULL) { + (*node)->texture_id = gfx_rapi->new_texture(); + } + gfx_rapi->select_texture(tile, (*node)->texture_id); + gfx_rapi->set_sampler_parameters(tile, false, 0, 0); + (*node)->cms = 0; + (*node)->cmt = 0; + (*node)->linear_filter = false; + (*node)->next = NULL; + (*node)->texture_addr = orig_addr; + (*node)->fmt = fmt; + (*node)->siz = siz; + *n = *node; + return false; +} + +static void import_texture_rgba16(int tile) { + uint8_t rgba32_buf[8192]; + + for (uint32_t i = 0; i < rdp.loaded_texture[tile].size_bytes / 2; i++) { + uint16_t col16 = (rdp.loaded_texture[tile].addr[2 * i] << 8) | rdp.loaded_texture[tile].addr[2 * i + 1]; + uint8_t a = col16 & 1; + uint8_t r = col16 >> 11; + uint8_t g = (col16 >> 6) & 0x1f; + uint8_t b = (col16 >> 1) & 0x1f; + rgba32_buf[4*i + 0] = SCALE_5_8(r); + rgba32_buf[4*i + 1] = SCALE_5_8(g); + rgba32_buf[4*i + 2] = SCALE_5_8(b); + rgba32_buf[4*i + 3] = a ? 255 : 0; + } + + uint32_t width = rdp.texture_tile.line_size_bytes / 2; + uint32_t height = rdp.loaded_texture[tile].size_bytes / rdp.texture_tile.line_size_bytes; + + gfx_rapi->upload_texture(rgba32_buf, width, height); +} + +static void import_texture_rgba32(int tile) { + uint32_t width = rdp.texture_tile.line_size_bytes / 2; + uint32_t height = (rdp.loaded_texture[tile].size_bytes / 2) / rdp.texture_tile.line_size_bytes; + gfx_rapi->upload_texture(rdp.loaded_texture[tile].addr, width, height); +} + +static void import_texture_ia4(int tile) { + uint8_t rgba32_buf[32768]; + + for (uint32_t i = 0; i < rdp.loaded_texture[tile].size_bytes * 2; i++) { + uint8_t byte = rdp.loaded_texture[tile].addr[i / 2]; + uint8_t part = (byte >> (4 - (i % 2) * 4)) & 0xf; + uint8_t intensity = part >> 1; + uint8_t alpha = part & 1; + uint8_t r = intensity; + uint8_t g = intensity; + uint8_t b = intensity; + rgba32_buf[4*i + 0] = SCALE_3_8(r); + rgba32_buf[4*i + 1] = SCALE_3_8(g); + rgba32_buf[4*i + 2] = SCALE_3_8(b); + rgba32_buf[4*i + 3] = alpha ? 255 : 0; + } + + uint32_t width = rdp.texture_tile.line_size_bytes * 2; + uint32_t height = rdp.loaded_texture[tile].size_bytes / rdp.texture_tile.line_size_bytes; + + gfx_rapi->upload_texture(rgba32_buf, width, height); +} + +static void import_texture_ia8(int tile) { + uint8_t rgba32_buf[16384]; + + for (uint32_t i = 0; i < rdp.loaded_texture[tile].size_bytes; i++) { + uint8_t intensity = rdp.loaded_texture[tile].addr[i] >> 4; + uint8_t alpha = rdp.loaded_texture[tile].addr[i] & 0xf; + uint8_t r = intensity; + uint8_t g = intensity; + uint8_t b = intensity; + rgba32_buf[4*i + 0] = SCALE_4_8(r); + rgba32_buf[4*i + 1] = SCALE_4_8(g); + rgba32_buf[4*i + 2] = SCALE_4_8(b); + rgba32_buf[4*i + 3] = SCALE_4_8(alpha); + } + + uint32_t width = rdp.texture_tile.line_size_bytes; + uint32_t height = rdp.loaded_texture[tile].size_bytes / rdp.texture_tile.line_size_bytes; + + gfx_rapi->upload_texture(rgba32_buf, width, height); +} + +static void import_texture_ia16(int tile) { + uint8_t rgba32_buf[8192]; + + for (uint32_t i = 0; i < rdp.loaded_texture[tile].size_bytes / 2; i++) { + uint8_t intensity = rdp.loaded_texture[tile].addr[2 * i]; + uint8_t alpha = rdp.loaded_texture[tile].addr[2 * i + 1]; + uint8_t r = intensity; + uint8_t g = intensity; + uint8_t b = intensity; + rgba32_buf[4*i + 0] = r; + rgba32_buf[4*i + 1] = g; + rgba32_buf[4*i + 2] = b; + rgba32_buf[4*i + 3] = alpha; + } + + uint32_t width = rdp.texture_tile.line_size_bytes / 2; + uint32_t height = rdp.loaded_texture[tile].size_bytes / rdp.texture_tile.line_size_bytes; + + gfx_rapi->upload_texture(rgba32_buf, width, height); +} + +static void import_texture_i4(int tile) { + uint8_t rgba32_buf[32768]; + + for (uint32_t i = 0; i < rdp.loaded_texture[tile].size_bytes * 2; i++) { + uint8_t byte = rdp.loaded_texture[tile].addr[i / 2]; + uint8_t part = (byte >> (4 - (i % 2) * 4)) & 0xf; + uint8_t intensity = part; + uint8_t r = intensity; + uint8_t g = intensity; + uint8_t b = intensity; + rgba32_buf[4*i + 0] = SCALE_4_8(r); + rgba32_buf[4*i + 1] = SCALE_4_8(g); + rgba32_buf[4*i + 2] = SCALE_4_8(b); + rgba32_buf[4*i + 3] = 255; + } + + uint32_t width = rdp.texture_tile.line_size_bytes * 2; + uint32_t height = rdp.loaded_texture[tile].size_bytes / rdp.texture_tile.line_size_bytes; + + gfx_rapi->upload_texture(rgba32_buf, width, height); +} + +static void import_texture_i8(int tile) { + uint8_t rgba32_buf[16384]; + + for (uint32_t i = 0; i < rdp.loaded_texture[tile].size_bytes; i++) { + uint8_t intensity = rdp.loaded_texture[tile].addr[i]; + uint8_t r = intensity; + uint8_t g = intensity; + uint8_t b = intensity; + rgba32_buf[4*i + 0] = r; + rgba32_buf[4*i + 1] = g; + rgba32_buf[4*i + 2] = b; + rgba32_buf[4*i + 3] = 255; + } + + uint32_t width = rdp.texture_tile.line_size_bytes; + uint32_t height = rdp.loaded_texture[tile].size_bytes / rdp.texture_tile.line_size_bytes; + + gfx_rapi->upload_texture(rgba32_buf, width, height); +} + + +static void import_texture_ci4(int tile) { + uint8_t rgba32_buf[32768]; + + for (uint32_t i = 0; i < rdp.loaded_texture[tile].size_bytes * 2; i++) { + uint8_t byte = rdp.loaded_texture[tile].addr[i / 2]; + uint8_t idx = (byte >> (4 - (i % 2) * 4)) & 0xf; + uint16_t col16 = (rdp.palette[idx * 2] << 8) | rdp.palette[idx * 2 + 1]; // Big endian load + uint8_t a = col16 & 1; + uint8_t r = col16 >> 11; + uint8_t g = (col16 >> 6) & 0x1f; + uint8_t b = (col16 >> 1) & 0x1f; + rgba32_buf[4*i + 0] = SCALE_5_8(r); + rgba32_buf[4*i + 1] = SCALE_5_8(g); + rgba32_buf[4*i + 2] = SCALE_5_8(b); + rgba32_buf[4*i + 3] = a ? 255 : 0; + } + + uint32_t width = rdp.texture_tile.line_size_bytes * 2; + uint32_t height = rdp.loaded_texture[tile].size_bytes / rdp.texture_tile.line_size_bytes; + + gfx_rapi->upload_texture(rgba32_buf, width, height); +} + +static void import_texture_ci8(int tile) { + uint8_t rgba32_buf[16384]; + + for (uint32_t i = 0; i < rdp.loaded_texture[tile].size_bytes; i++) { + uint8_t idx = rdp.loaded_texture[tile].addr[i]; + uint16_t col16 = (rdp.palette[idx * 2] << 8) | rdp.palette[idx * 2 + 1]; // Big endian load + uint8_t a = col16 & 1; + uint8_t r = col16 >> 11; + uint8_t g = (col16 >> 6) & 0x1f; + uint8_t b = (col16 >> 1) & 0x1f; + rgba32_buf[4*i + 0] = SCALE_5_8(r); + rgba32_buf[4*i + 1] = SCALE_5_8(g); + rgba32_buf[4*i + 2] = SCALE_5_8(b); + rgba32_buf[4*i + 3] = a ? 255 : 0; + } + + uint32_t width = rdp.texture_tile.line_size_bytes; + uint32_t height = rdp.loaded_texture[tile].size_bytes / rdp.texture_tile.line_size_bytes; + + gfx_rapi->upload_texture(rgba32_buf, width, height); +} + +static void import_texture(int tile) { + uint8_t fmt = rdp.texture_tile.fmt; + uint8_t siz = rdp.texture_tile.siz; + + if (gfx_texture_cache_lookup(tile, &rendering_state.textures[tile], rdp.loaded_texture[tile].addr, fmt, siz)) { + return; + } + + int t0 = get_time(); + if (fmt == G_IM_FMT_RGBA) { + if (siz == G_IM_SIZ_16b) { + import_texture_rgba16(tile); + } else if (siz == G_IM_SIZ_32b) { + import_texture_rgba32(tile); + } else { + abort(); + } + } else if (fmt == G_IM_FMT_IA) { + if (siz == G_IM_SIZ_4b) { + import_texture_ia4(tile); + } else if (siz == G_IM_SIZ_8b) { + import_texture_ia8(tile); + } else if (siz == G_IM_SIZ_16b) { + import_texture_ia16(tile); + } else { + abort(); + } + } else if (fmt == G_IM_FMT_CI) { + if (siz == G_IM_SIZ_4b) { + import_texture_ci4(tile); + } else if (siz == G_IM_SIZ_8b) { + import_texture_ci8(tile); + } else { + abort(); + } + } else if (fmt == G_IM_FMT_I) { + if (siz == G_IM_SIZ_4b) { + import_texture_i4(tile); + } else if (siz == G_IM_SIZ_8b) { + import_texture_i8(tile); + } else { + abort(); + } + } else { + abort(); + } + int t1 = get_time(); + //printf("Time diff: %d\n", t1 - t0); +} + +static void gfx_normalize_vector(float v[3]) { + float s = sqrtf(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]); + v[0] /= s; + v[1] /= s; + v[2] /= s; +} + +static void gfx_transposed_matrix_mul(float res[3], const float a[3], const float b[4][4]) { + res[0] = a[0] * b[0][0] + a[1] * b[0][1] + a[2] * b[0][2]; + res[1] = a[0] * b[1][0] + a[1] * b[1][1] + a[2] * b[1][2]; + res[2] = a[0] * b[2][0] + a[1] * b[2][1] + a[2] * b[2][2]; +} + +static void calculate_normal_dir(const Light_t *light, float coeffs[3]) { + float light_dir[3] = { + light->dir[0] / 127.0f, + light->dir[1] / 127.0f, + light->dir[2] / 127.0f + }; + gfx_transposed_matrix_mul(coeffs, light_dir, rsp.modelview_matrix_stack[rsp.modelview_matrix_stack_size - 1]); + gfx_normalize_vector(coeffs); +} + +static void gfx_matrix_mul(float res[4][4], const float a[4][4], const float b[4][4]) { + float tmp[4][4]; + for (int i = 0; i < 4; i++) { + for (int j = 0; j < 4; j++) { + tmp[i][j] = a[i][0] * b[0][j] + + a[i][1] * b[1][j] + + a[i][2] * b[2][j] + + a[i][3] * b[3][j]; + } + } + memcpy(res, tmp, sizeof(tmp)); +} + +static void gfx_sp_matrix(uint8_t parameters, const int32_t *addr) { + float matrix[4][4]; +#ifndef GBI_FLOATS + // Original GBI where fixed point matrices are used + for (int i = 0; i < 4; i++) { + for (int j = 0; j < 4; j += 2) { + int32_t int_part = addr[i * 2 + j / 2]; + uint32_t frac_part = addr[8 + i * 2 + j / 2]; + matrix[i][j] = (int32_t)((int_part & 0xffff0000) | (frac_part >> 16)) / 65536.0f; + matrix[i][j + 1] = (int32_t)((int_part << 16) | (frac_part & 0xffff)) / 65536.0f; + } + } +#else + // For a modified GBI where fixed point values are replaced with floats + memcpy(matrix, addr, sizeof(matrix)); +#endif + + if (parameters & G_MTX_PROJECTION) { + if (parameters & G_MTX_LOAD) { + memcpy(rsp.P_matrix, matrix, sizeof(matrix)); + } else { + gfx_matrix_mul(rsp.P_matrix, matrix, rsp.P_matrix); + } + } else { // G_MTX_MODELVIEW + if ((parameters & G_MTX_PUSH) && rsp.modelview_matrix_stack_size < 11) { + ++rsp.modelview_matrix_stack_size; + memcpy(rsp.modelview_matrix_stack[rsp.modelview_matrix_stack_size - 1], rsp.modelview_matrix_stack[rsp.modelview_matrix_stack_size - 2], sizeof(matrix)); + } + if (parameters & G_MTX_LOAD) { + memcpy(rsp.modelview_matrix_stack[rsp.modelview_matrix_stack_size - 1], matrix, sizeof(matrix)); + } else { + gfx_matrix_mul(rsp.modelview_matrix_stack[rsp.modelview_matrix_stack_size - 1], matrix, rsp.modelview_matrix_stack[rsp.modelview_matrix_stack_size - 1]); + } + rsp.lights_changed = 1; + } + gfx_matrix_mul(rsp.MP_matrix, rsp.modelview_matrix_stack[rsp.modelview_matrix_stack_size - 1], rsp.P_matrix); +} + +static void gfx_sp_pop_matrix(uint32_t count) { + while (count--) { + if (rsp.modelview_matrix_stack_size > 0) { + --rsp.modelview_matrix_stack_size; + if (rsp.modelview_matrix_stack_size > 0) { + gfx_matrix_mul(rsp.MP_matrix, rsp.modelview_matrix_stack[rsp.modelview_matrix_stack_size - 1], rsp.P_matrix); + } + } + } +} + +static float gfx_adjust_x_for_aspect_ratio(float x) { + return x * (4.0f / 3.0f) / ((float)gfx_current_dimensions.width / (float)gfx_current_dimensions.height); +} + +static void gfx_sp_vertex(size_t n_vertices, size_t dest_index, const Vtx *vertices) { + for (size_t i = 0; i < n_vertices; i++, dest_index++) { + const Vtx_t *v = &vertices[i].v; + const Vtx_tn *vn = &vertices[i].n; + struct LoadedVertex *d = &rsp.loaded_vertices[dest_index]; + + float x = v->ob[0] * rsp.MP_matrix[0][0] + v->ob[1] * rsp.MP_matrix[1][0] + v->ob[2] * rsp.MP_matrix[2][0] + rsp.MP_matrix[3][0]; + float y = v->ob[0] * rsp.MP_matrix[0][1] + v->ob[1] * rsp.MP_matrix[1][1] + v->ob[2] * rsp.MP_matrix[2][1] + rsp.MP_matrix[3][1]; + float z = v->ob[0] * rsp.MP_matrix[0][2] + v->ob[1] * rsp.MP_matrix[1][2] + v->ob[2] * rsp.MP_matrix[2][2] + rsp.MP_matrix[3][2]; + float w = v->ob[0] * rsp.MP_matrix[0][3] + v->ob[1] * rsp.MP_matrix[1][3] + v->ob[2] * rsp.MP_matrix[2][3] + rsp.MP_matrix[3][3]; + + x = gfx_adjust_x_for_aspect_ratio(x); + + short U = v->tc[0] * rsp.texture_scaling_factor.s >> 16; + short V = v->tc[1] * rsp.texture_scaling_factor.t >> 16; + + if (rsp.geometry_mode & G_LIGHTING) { + if (rsp.lights_changed) { + for (int i = 0; i < rsp.current_num_lights - 1; i++) { + calculate_normal_dir(&rsp.current_lights[i], rsp.current_lights_coeffs[i]); + } + static const Light_t lookat_x = {{0, 0, 0}, 0, {0, 0, 0}, 0, {127, 0, 0}, 0}; + static const Light_t lookat_y = {{0, 0, 0}, 0, {0, 0, 0}, 0, {0, 127, 0}, 0}; + calculate_normal_dir(&lookat_x, rsp.current_lookat_coeffs[0]); + calculate_normal_dir(&lookat_y, rsp.current_lookat_coeffs[1]); + rsp.lights_changed = false; + } + + int r = rsp.current_lights[rsp.current_num_lights - 1].col[0]; + int g = rsp.current_lights[rsp.current_num_lights - 1].col[1]; + int b = rsp.current_lights[rsp.current_num_lights - 1].col[2]; + + for (int i = 0; i < rsp.current_num_lights - 1; i++) { + float intensity = 0; + intensity += vn->n[0] * rsp.current_lights_coeffs[i][0]; + intensity += vn->n[1] * rsp.current_lights_coeffs[i][1]; + intensity += vn->n[2] * rsp.current_lights_coeffs[i][2]; + intensity /= 127.0f; + if (intensity > 0.0f) { + r += intensity * rsp.current_lights[i].col[0]; + g += intensity * rsp.current_lights[i].col[1]; + b += intensity * rsp.current_lights[i].col[2]; + } + } + + d->color.r = r > 255 ? 255 : r; + d->color.g = g > 255 ? 255 : g; + d->color.b = b > 255 ? 255 : b; + + if (rsp.geometry_mode & G_TEXTURE_GEN) { + float dotx = 0, doty = 0; + dotx += vn->n[0] * rsp.current_lookat_coeffs[0][0]; + dotx += vn->n[1] * rsp.current_lookat_coeffs[0][1]; + dotx += vn->n[2] * rsp.current_lookat_coeffs[0][2]; + doty += vn->n[0] * rsp.current_lookat_coeffs[1][0]; + doty += vn->n[1] * rsp.current_lookat_coeffs[1][1]; + doty += vn->n[2] * rsp.current_lookat_coeffs[1][2]; + + U = (int32_t)((dotx / 127.0f + 1.0f) / 4.0f * rsp.texture_scaling_factor.s); + V = (int32_t)((doty / 127.0f + 1.0f) / 4.0f * rsp.texture_scaling_factor.t); + } + } else { + d->color.r = v->cn[0]; + d->color.g = v->cn[1]; + d->color.b = v->cn[2]; + } + + d->u = U; + d->v = V; + + // trivial clip rejection + d->clip_rej = 0; + if (x < -w) d->clip_rej |= 1; + if (x > w) d->clip_rej |= 2; + if (y < -w) d->clip_rej |= 4; + if (y > w) d->clip_rej |= 8; + if (z < -w) d->clip_rej |= 16; + if (z > w) d->clip_rej |= 32; + + d->x = x; + d->y = y; + d->z = z; + d->w = w; + + if (rsp.geometry_mode & G_FOG) { + if (fabsf(w) < 0.001f) { + // To avoid division by zero + w = 0.001f; + } + + float winv = 1.0f / w; + if (winv < 0.0f) { + winv = 32767.0f; + } + + float fog_z = z * winv * rsp.fog_mul + rsp.fog_offset; + if (fog_z < 0) fog_z = 0; + if (fog_z > 255) fog_z = 255; + d->color.a = fog_z; // Use alpha variable to store fog factor + } else { + d->color.a = v->cn[3]; + } + } +} + +static void gfx_sp_tri1(uint8_t vtx1_idx, uint8_t vtx2_idx, uint8_t vtx3_idx) { + struct LoadedVertex *v1 = &rsp.loaded_vertices[vtx1_idx]; + struct LoadedVertex *v2 = &rsp.loaded_vertices[vtx2_idx]; + struct LoadedVertex *v3 = &rsp.loaded_vertices[vtx3_idx]; + struct LoadedVertex *v_arr[3] = {v1, v2, v3}; + + //if (rand()%2) return; + + if (v1->clip_rej & v2->clip_rej & v3->clip_rej) { + // The whole triangle lies outside the visible area + return; + } + + if ((rsp.geometry_mode & G_CULL_BOTH) != 0) { + float dx1 = v1->x / (v1->w) - v2->x / (v2->w); + float dy1 = v1->y / (v1->w) - v2->y / (v2->w); + float dx2 = v3->x / (v3->w) - v2->x / (v2->w); + float dy2 = v3->y / (v3->w) - v2->y / (v2->w); + float cross = dx1 * dy2 - dy1 * dx2; + + if ((v1->w < 0) ^ (v2->w < 0) ^ (v3->w < 0)) { + // If one vertex lies behind the eye, negating cross will give the correct result. + // If all vertices lie behind the eye, the triangle will be rejected anyway. + cross = -cross; + } + + switch (rsp.geometry_mode & G_CULL_BOTH) { + case G_CULL_FRONT: + if (cross <= 0) return; + break; + case G_CULL_BACK: + if (cross >= 0) return; + break; + case G_CULL_BOTH: + // Why is this even an option? + return; + } + } + + bool depth_test = (rsp.geometry_mode & G_ZBUFFER) == G_ZBUFFER; + if (depth_test != rendering_state.depth_test) { + gfx_flush(); + gfx_rapi->set_depth_test(depth_test); + rendering_state.depth_test = depth_test; + } + + bool z_upd = (rdp.other_mode_l & Z_UPD) == Z_UPD; + if (z_upd != rendering_state.depth_mask) { + gfx_flush(); + gfx_rapi->set_depth_mask(z_upd); + rendering_state.depth_mask = z_upd; + } + + bool zmode_decal = (rdp.other_mode_l & ZMODE_DEC) == ZMODE_DEC; + if (zmode_decal != rendering_state.decal_mode) { + gfx_flush(); + gfx_rapi->set_zmode_decal(zmode_decal); + rendering_state.decal_mode = zmode_decal; + } + + if (rdp.viewport_or_scissor_changed) { + if (memcmp(&rdp.viewport, &rendering_state.viewport, sizeof(rdp.viewport)) != 0) { + gfx_flush(); + gfx_rapi->set_viewport(rdp.viewport.x, rdp.viewport.y, rdp.viewport.width, rdp.viewport.height); + rendering_state.viewport = rdp.viewport; + } + if (memcmp(&rdp.scissor, &rendering_state.scissor, sizeof(rdp.scissor)) != 0) { + gfx_flush(); + gfx_rapi->set_scissor(rdp.scissor.x, rdp.scissor.y, rdp.scissor.width, rdp.scissor.height); + rendering_state.scissor = rdp.scissor; + } + rdp.viewport_or_scissor_changed = false; + } + + uint32_t cc_id = rdp.combine_mode; + + bool use_alpha = (rdp.other_mode_l & (G_BL_A_MEM << 18)) == 0; + bool use_fog = (rdp.other_mode_l >> 30) == G_BL_CLR_FOG; + bool texture_edge = (rdp.other_mode_l & CVG_X_ALPHA) == CVG_X_ALPHA; + bool use_noise = (rdp.other_mode_l & G_AC_DITHER) == G_AC_DITHER; + + if (texture_edge) { + use_alpha = true; + } + + if (use_alpha) cc_id |= SHADER_OPT_ALPHA; + if (use_fog) cc_id |= SHADER_OPT_FOG; + if (texture_edge) cc_id |= SHADER_OPT_TEXTURE_EDGE; + if (use_noise) cc_id |= SHADER_OPT_NOISE; + + if (!use_alpha) { + cc_id &= ~0xfff000; + } + + struct ColorCombiner *comb = gfx_lookup_or_create_color_combiner(cc_id); + struct ShaderProgram *prg = comb->prg; + if (prg != rendering_state.shader_program) { + gfx_flush(); + gfx_rapi->unload_shader(rendering_state.shader_program); + gfx_rapi->load_shader(prg); + rendering_state.shader_program = prg; + } + if (use_alpha != rendering_state.alpha_blend) { + gfx_flush(); + gfx_rapi->set_use_alpha(use_alpha); + rendering_state.alpha_blend = use_alpha; + } + uint8_t num_inputs; + bool used_textures[2]; + gfx_rapi->shader_get_info(prg, &num_inputs, used_textures); + + for (int i = 0; i < 2; i++) { + if (used_textures[i]) { + if (rdp.textures_changed[i]) { + gfx_flush(); + import_texture(i); + rdp.textures_changed[i] = false; + } + bool linear_filter = (rdp.other_mode_h & (3U << G_MDSFT_TEXTFILT)) != G_TF_POINT; + if (linear_filter != rendering_state.textures[i]->linear_filter || rdp.texture_tile.cms != rendering_state.textures[i]->cms || rdp.texture_tile.cmt != rendering_state.textures[i]->cmt) { + gfx_flush(); + gfx_rapi->set_sampler_parameters(i, linear_filter, rdp.texture_tile.cms, rdp.texture_tile.cmt); + rendering_state.textures[i]->linear_filter = linear_filter; + rendering_state.textures[i]->cms = rdp.texture_tile.cms; + rendering_state.textures[i]->cmt = rdp.texture_tile.cmt; + } + } + } + + bool use_texture = used_textures[0] || used_textures[1]; + uint32_t tex_width = (rdp.texture_tile.lrs - rdp.texture_tile.uls + 4) / 4; + uint32_t tex_height = (rdp.texture_tile.lrt - rdp.texture_tile.ult + 4) / 4; + + bool z_is_from_0_to_1 = gfx_rapi->z_is_from_0_to_1(); + + for (int i = 0; i < 3; i++) { + float z = v_arr[i]->z, w = v_arr[i]->w; + if (z_is_from_0_to_1) { + z = (z + w) / 2.0f; + } + buf_vbo[buf_vbo_len++] = v_arr[i]->x; + buf_vbo[buf_vbo_len++] = v_arr[i]->y; + buf_vbo[buf_vbo_len++] = z; + buf_vbo[buf_vbo_len++] = w; + + if (use_texture) { + float u = (v_arr[i]->u - rdp.texture_tile.uls * 8) / 32.0f; + float v = (v_arr[i]->v - rdp.texture_tile.ult * 8) / 32.0f; + if ((rdp.other_mode_h & (3U << G_MDSFT_TEXTFILT)) != G_TF_POINT) { + // Linear filter adds 0.5f to the coordinates + u += 0.5f; + v += 0.5f; + } + buf_vbo[buf_vbo_len++] = u / tex_width; + buf_vbo[buf_vbo_len++] = v / tex_height; + } + + if (use_fog) { + buf_vbo[buf_vbo_len++] = rdp.fog_color.r / 255.0f; + buf_vbo[buf_vbo_len++] = rdp.fog_color.g / 255.0f; + buf_vbo[buf_vbo_len++] = rdp.fog_color.b / 255.0f; + buf_vbo[buf_vbo_len++] = v_arr[i]->color.a / 255.0f; // fog factor (not alpha) + } + + for (int j = 0; j < num_inputs; j++) { + struct RGBA *color; + struct RGBA tmp; + for (int k = 0; k < 1 + (use_alpha ? 1 : 0); k++) { + switch (comb->shader_input_mapping[k][j]) { + case CC_PRIM: + color = &rdp.prim_color; + break; + case CC_SHADE: + color = &v_arr[i]->color; + break; + case CC_ENV: + color = &rdp.env_color; + break; + case CC_LOD: + { + float distance_frac = (v1->w - 3000.0f) / 3000.0f; + if (distance_frac < 0.0f) distance_frac = 0.0f; + if (distance_frac > 1.0f) distance_frac = 1.0f; + tmp.r = tmp.g = tmp.b = tmp.a = distance_frac * 255.0f; + color = &tmp; + break; + } + default: + memset(&tmp, 0, sizeof(tmp)); + color = &tmp; + break; + } + if (k == 0) { + buf_vbo[buf_vbo_len++] = color->r / 255.0f; + buf_vbo[buf_vbo_len++] = color->g / 255.0f; + buf_vbo[buf_vbo_len++] = color->b / 255.0f; + } else { + if (use_fog && color == &v_arr[i]->color) { + // Shade alpha is 100% for fog + buf_vbo[buf_vbo_len++] = 1.0f; + } else { + buf_vbo[buf_vbo_len++] = color->a / 255.0f; + } + } + } + } + /*struct RGBA *color = &v_arr[i]->color; + buf_vbo[buf_vbo_len++] = color->r / 255.0f; + buf_vbo[buf_vbo_len++] = color->g / 255.0f; + buf_vbo[buf_vbo_len++] = color->b / 255.0f; + buf_vbo[buf_vbo_len++] = color->a / 255.0f;*/ + } + if (++buf_vbo_num_tris == MAX_BUFFERED) { + gfx_flush(); + } +} + +static void gfx_sp_geometry_mode(uint32_t clear, uint32_t set) { + rsp.geometry_mode &= ~clear; + rsp.geometry_mode |= set; +} + +static void gfx_calc_and_set_viewport(const Vp_t *viewport) { + // 2 bits fraction + float width = 2.0f * viewport->vscale[0] / 4.0f; + float height = 2.0f * viewport->vscale[1] / 4.0f; + float x = (viewport->vtrans[0] / 4.0f) - width / 2.0f; + float y = SCREEN_HEIGHT - ((viewport->vtrans[1] / 4.0f) + height / 2.0f); + + width *= RATIO_X; + height *= RATIO_Y; + x *= RATIO_X; + y *= RATIO_Y; + + rdp.viewport.x = x; + rdp.viewport.y = y; + rdp.viewport.width = width; + rdp.viewport.height = height; + + rdp.viewport_or_scissor_changed = true; +} + +static void gfx_sp_movemem(uint8_t index, uint8_t offset, const void* data) { + switch (index) { + case G_MV_VIEWPORT: + gfx_calc_and_set_viewport((const Vp_t *) data); + break; +#if 0 + case G_MV_LOOKATY: + case G_MV_LOOKATX: + memcpy(rsp.current_lookat + (index - G_MV_LOOKATY) / 2, data, sizeof(Light_t)); + //rsp.lights_changed = 1; + break; +#endif +#ifdef F3DEX_GBI_2 + case G_MV_LIGHT: { + int lightidx = offset / 24 - 2; + if (lightidx >= 0 && lightidx <= MAX_LIGHTS) { // skip lookat + // NOTE: reads out of bounds if it is an ambient light + memcpy(rsp.current_lights + lightidx, data, sizeof(Light_t)); + } + break; + } +#else + case G_MV_L0: + case G_MV_L1: + case G_MV_L2: + // NOTE: reads out of bounds if it is an ambient light + memcpy(rsp.current_lights + (index - G_MV_L0) / 2, data, sizeof(Light_t)); + break; +#endif + } +} + +static void gfx_sp_moveword(uint8_t index, uint16_t offset, uint32_t data) { + switch (index) { + case G_MW_NUMLIGHT: +#ifdef F3DEX_GBI_2 + rsp.current_num_lights = data / 24 + 1; // add ambient light +#else + // Ambient light is included + // The 31th bit is a flag that lights should be recalculated + rsp.current_num_lights = (data - 0x80000000U) / 32; +#endif + rsp.lights_changed = 1; + break; + case G_MW_FOG: + rsp.fog_mul = (int16_t)(data >> 16); + rsp.fog_offset = (int16_t)data; + break; + } +} + +static void gfx_sp_texture(uint16_t sc, uint16_t tc, uint8_t level, uint8_t tile, uint8_t on) { + rsp.texture_scaling_factor.s = sc; + rsp.texture_scaling_factor.t = tc; +} + +static void gfx_dp_set_scissor(uint32_t mode, uint32_t ulx, uint32_t uly, uint32_t lrx, uint32_t lry) { + float x = ulx / 4.0f * RATIO_X; + float y = (SCREEN_HEIGHT - lry / 4.0f) * RATIO_Y; + float width = (lrx - ulx) / 4.0f * RATIO_X; + float height = (lry - uly) / 4.0f * RATIO_Y; + + rdp.scissor.x = x; + rdp.scissor.y = y; + rdp.scissor.width = width; + rdp.scissor.height = height; + + rdp.viewport_or_scissor_changed = true; +} + +static void gfx_dp_set_texture_image(uint32_t format, uint32_t size, uint32_t width, const void* addr) { + rdp.texture_to_load.addr = addr; + rdp.texture_to_load.siz = size; +} + +static void gfx_dp_set_tile(uint8_t fmt, uint32_t siz, uint32_t line, uint32_t tmem, uint8_t tile, uint32_t palette, uint32_t cmt, uint32_t maskt, uint32_t shiftt, uint32_t cms, uint32_t masks, uint32_t shifts) { + if (tile == G_TX_RENDERTILE) { + SUPPORT_CHECK(palette == 0); // palette should set upper 4 bits of color index in 4b mode + rdp.texture_tile.fmt = fmt; + rdp.texture_tile.siz = siz; + rdp.texture_tile.cms = cms; + rdp.texture_tile.cmt = cmt; + rdp.texture_tile.line_size_bytes = line * 8; + rdp.textures_changed[0] = true; + rdp.textures_changed[1] = true; + } + + if (tile == G_TX_LOADTILE) { + rdp.texture_to_load.tile_number = tmem / 256; + } +} + +static void gfx_dp_set_tile_size(uint8_t tile, uint16_t uls, uint16_t ult, uint16_t lrs, uint16_t lrt) { + if (tile == G_TX_RENDERTILE) { + rdp.texture_tile.uls = uls; + rdp.texture_tile.ult = ult; + rdp.texture_tile.lrs = lrs; + rdp.texture_tile.lrt = lrt; + rdp.textures_changed[0] = true; + rdp.textures_changed[1] = true; + } +} + +static void gfx_dp_load_tlut(uint8_t tile, uint32_t high_index) { + SUPPORT_CHECK(tile == G_TX_LOADTILE); + SUPPORT_CHECK(rdp.texture_to_load.siz == G_IM_SIZ_16b); + rdp.palette = rdp.texture_to_load.addr; +} + +static void gfx_dp_load_block(uint8_t tile, uint32_t uls, uint32_t ult, uint32_t lrs, uint32_t dxt) { + if (tile == 1) return; + SUPPORT_CHECK(tile == G_TX_LOADTILE); + SUPPORT_CHECK(uls == 0); + SUPPORT_CHECK(ult == 0); + + // The lrs field rather seems to be number of pixels to load + uint32_t word_size_shift; + switch (rdp.texture_to_load.siz) { + case G_IM_SIZ_4b: + word_size_shift = 0; // Or -1? It's unused in SM64 anyway. + break; + case G_IM_SIZ_8b: + word_size_shift = 0; + break; + case G_IM_SIZ_16b: + word_size_shift = 1; + break; + case G_IM_SIZ_32b: + word_size_shift = 2; + break; + } + uint32_t size_bytes = (lrs + 1) << word_size_shift; + rdp.loaded_texture[rdp.texture_to_load.tile_number].size_bytes = size_bytes; + assert(size_bytes <= 4096 && "bug: too big texture"); + rdp.loaded_texture[rdp.texture_to_load.tile_number].addr = rdp.texture_to_load.addr; + + rdp.textures_changed[rdp.texture_to_load.tile_number] = true; +} + +static void gfx_dp_load_tile(uint8_t tile, uint32_t uls, uint32_t ult, uint32_t lrs, uint32_t lrt) { + if (tile == 1) return; + SUPPORT_CHECK(tile == G_TX_LOADTILE); + SUPPORT_CHECK(uls == 0); + SUPPORT_CHECK(ult == 0); + + uint32_t word_size_shift; + switch (rdp.texture_to_load.siz) { + case G_IM_SIZ_4b: + word_size_shift = 0; + break; + case G_IM_SIZ_8b: + word_size_shift = 0; + break; + case G_IM_SIZ_16b: + word_size_shift = 1; + break; + case G_IM_SIZ_32b: + word_size_shift = 2; + break; + } + + uint32_t size_bytes = (((lrs >> G_TEXTURE_IMAGE_FRAC) + 1) * ((lrt >> G_TEXTURE_IMAGE_FRAC) + 1)) << word_size_shift; + rdp.loaded_texture[rdp.texture_to_load.tile_number].size_bytes = size_bytes; + + assert(size_bytes <= 4096 && "bug: too big texture"); + rdp.loaded_texture[rdp.texture_to_load.tile_number].addr = rdp.texture_to_load.addr; + rdp.texture_tile.uls = uls; + rdp.texture_tile.ult = ult; + rdp.texture_tile.lrs = lrs; + rdp.texture_tile.lrt = lrt; + + rdp.textures_changed[rdp.texture_to_load.tile_number] = true; +} + + +static uint8_t color_comb_component(uint32_t v) { + switch (v) { + case G_CCMUX_TEXEL0: + return CC_TEXEL0; + case G_CCMUX_TEXEL1: + return CC_TEXEL1; + case G_CCMUX_PRIMITIVE: + return CC_PRIM; + case G_CCMUX_SHADE: + return CC_SHADE; + case G_CCMUX_ENVIRONMENT: + return CC_ENV; + case G_CCMUX_TEXEL0_ALPHA: + return CC_TEXEL0A; + case G_CCMUX_LOD_FRACTION: + return CC_LOD; + default: + return CC_0; + } +} + +static inline uint32_t color_comb(uint32_t a, uint32_t b, uint32_t c, uint32_t d) { + return color_comb_component(a) | + (color_comb_component(b) << 3) | + (color_comb_component(c) << 6) | + (color_comb_component(d) << 9); +} + +static void gfx_dp_set_combine_mode(uint32_t rgb, uint32_t alpha) { + rdp.combine_mode = rgb | (alpha << 12); +} + +static void gfx_dp_set_env_color(uint8_t r, uint8_t g, uint8_t b, uint8_t a) { + rdp.env_color.r = r; + rdp.env_color.g = g; + rdp.env_color.b = b; + rdp.env_color.a = a; +} + +static void gfx_dp_set_prim_color(uint8_t r, uint8_t g, uint8_t b, uint8_t a) { + rdp.prim_color.r = r; + rdp.prim_color.g = g; + rdp.prim_color.b = b; + rdp.prim_color.a = a; +} + +static void gfx_dp_set_fog_color(uint8_t r, uint8_t g, uint8_t b, uint8_t a) { + rdp.fog_color.r = r; + rdp.fog_color.g = g; + rdp.fog_color.b = b; + rdp.fog_color.a = a; +} + +static void gfx_dp_set_fill_color(uint32_t packed_color) { + uint16_t col16 = (uint16_t)packed_color; + uint32_t r = col16 >> 11; + uint32_t g = (col16 >> 6) & 0x1f; + uint32_t b = (col16 >> 1) & 0x1f; + uint32_t a = col16 & 1; + rdp.fill_color.r = SCALE_5_8(r); + rdp.fill_color.g = SCALE_5_8(g); + rdp.fill_color.b = SCALE_5_8(b); + rdp.fill_color.a = a * 255; +} + +static void gfx_draw_rectangle(int32_t ulx, int32_t uly, int32_t lrx, int32_t lry) { + uint32_t saved_other_mode_h = rdp.other_mode_h; + uint32_t cycle_type = (rdp.other_mode_h & (3U << G_MDSFT_CYCLETYPE)); + + if (cycle_type == G_CYC_COPY) { + rdp.other_mode_h = (rdp.other_mode_h & ~(3U << G_MDSFT_TEXTFILT)) | G_TF_POINT; + } + + // U10.2 coordinates + float ulxf = ulx; + float ulyf = uly; + float lrxf = lrx; + float lryf = lry; + + ulxf = ulxf / (4.0f * HALF_SCREEN_WIDTH) - 1.0f; + ulyf = -(ulyf / (4.0f * HALF_SCREEN_HEIGHT)) + 1.0f; + lrxf = lrxf / (4.0f * HALF_SCREEN_WIDTH) - 1.0f; + lryf = -(lryf / (4.0f * HALF_SCREEN_HEIGHT)) + 1.0f; + + ulxf = gfx_adjust_x_for_aspect_ratio(ulxf); + lrxf = gfx_adjust_x_for_aspect_ratio(lrxf); + + struct LoadedVertex* ul = &rsp.loaded_vertices[MAX_VERTICES + 0]; + struct LoadedVertex* ll = &rsp.loaded_vertices[MAX_VERTICES + 1]; + struct LoadedVertex* lr = &rsp.loaded_vertices[MAX_VERTICES + 2]; + struct LoadedVertex* ur = &rsp.loaded_vertices[MAX_VERTICES + 3]; + + ul->x = ulxf; + ul->y = ulyf; + ul->z = -1.0f; + ul->w = 1.0f; + + ll->x = ulxf; + ll->y = lryf; + ll->z = -1.0f; + ll->w = 1.0f; + + lr->x = lrxf; + lr->y = lryf; + lr->z = -1.0f; + lr->w = 1.0f; + + ur->x = lrxf; + ur->y = ulyf; + ur->z = -1.0f; + ur->w = 1.0f; + + // The coordinates for texture rectangle shall bypass the viewport setting + struct XYWidthHeight default_viewport = {0, 0, gfx_current_dimensions.width, gfx_current_dimensions.height}; + struct XYWidthHeight viewport_saved = rdp.viewport; + uint32_t geometry_mode_saved = rsp.geometry_mode; + + rdp.viewport = default_viewport; + rdp.viewport_or_scissor_changed = true; + rsp.geometry_mode = 0; + + gfx_sp_tri1(MAX_VERTICES + 0, MAX_VERTICES + 1, MAX_VERTICES + 3); + gfx_sp_tri1(MAX_VERTICES + 1, MAX_VERTICES + 2, MAX_VERTICES + 3); + + rsp.geometry_mode = geometry_mode_saved; + rdp.viewport = viewport_saved; + rdp.viewport_or_scissor_changed = true; + + if (cycle_type == G_CYC_COPY) { + rdp.other_mode_h = saved_other_mode_h; + } +} + +static void gfx_dp_texture_rectangle(int32_t ulx, int32_t uly, int32_t lrx, int32_t lry, uint8_t tile, int16_t uls, int16_t ult, int16_t dsdx, int16_t dtdy, bool flip) { + uint32_t saved_combine_mode = rdp.combine_mode; + if ((rdp.other_mode_h & (3U << G_MDSFT_CYCLETYPE)) == G_CYC_COPY) { + // Per RDP Command Summary Set Tile's shift s and this dsdx should be set to 4 texels + // Divide by 4 to get 1 instead + dsdx >>= 2; + + // Color combiner is turned off in copy mode + gfx_dp_set_combine_mode(color_comb(0, 0, 0, G_CCMUX_TEXEL0), color_comb(0, 0, 0, G_ACMUX_TEXEL0)); + + // Per documentation one extra pixel is added in this modes to each edge + lrx += 1 << 2; + lry += 1 << 2; + } + + // uls and ult are S10.5 + // dsdx and dtdy are S5.10 + // lrx, lry, ulx, uly are U10.2 + // lrs, lrt are S10.5 + if (flip) { + dsdx = -dsdx; + dtdy = -dtdy; + } + int16_t width = !flip ? lrx - ulx : lry - uly; + int16_t height = !flip ? lry - uly : lrx - ulx; + float lrs = ((uls << 7) + dsdx * width) >> 7; + float lrt = ((ult << 7) + dtdy * height) >> 7; + + struct LoadedVertex* ul = &rsp.loaded_vertices[MAX_VERTICES + 0]; + struct LoadedVertex* ll = &rsp.loaded_vertices[MAX_VERTICES + 1]; + struct LoadedVertex* lr = &rsp.loaded_vertices[MAX_VERTICES + 2]; + struct LoadedVertex* ur = &rsp.loaded_vertices[MAX_VERTICES + 3]; + ul->u = uls; + ul->v = ult; + lr->u = lrs; + lr->v = lrt; + if (!flip) { + ll->u = uls; + ll->v = lrt; + ur->u = lrs; + ur->v = ult; + } else { + ll->u = lrs; + ll->v = ult; + ur->u = uls; + ur->v = lrt; + } + + gfx_draw_rectangle(ulx, uly, lrx, lry); + rdp.combine_mode = saved_combine_mode; +} + +static void gfx_dp_fill_rectangle(int32_t ulx, int32_t uly, int32_t lrx, int32_t lry) { + if (rdp.color_image_address == rdp.z_buf_address) { + // Don't clear Z buffer here since we already did it with glClear + return; + } + uint32_t mode = (rdp.other_mode_h & (3U << G_MDSFT_CYCLETYPE)); + + if (mode == G_CYC_COPY || mode == G_CYC_FILL) { + // Per documentation one extra pixel is added in this modes to each edge + lrx += 1 << 2; + lry += 1 << 2; + } + + for (int i = MAX_VERTICES; i < MAX_VERTICES + 4; i++) { + struct LoadedVertex* v = &rsp.loaded_vertices[i]; + v->color = rdp.fill_color; + } + + uint32_t saved_combine_mode = rdp.combine_mode; + gfx_dp_set_combine_mode(color_comb(0, 0, 0, G_CCMUX_SHADE), color_comb(0, 0, 0, G_ACMUX_SHADE)); + gfx_draw_rectangle(ulx, uly, lrx, lry); + rdp.combine_mode = saved_combine_mode; +} + +static void gfx_dp_set_z_image(void *z_buf_address) { + rdp.z_buf_address = z_buf_address; +} + +static void gfx_dp_set_color_image(uint32_t format, uint32_t size, uint32_t width, void* address) { + rdp.color_image_address = address; +} + +static void gfx_sp_set_other_mode(uint32_t shift, uint32_t num_bits, uint64_t mode) { + uint64_t mask = (((uint64_t)1 << num_bits) - 1) << shift; + uint64_t om = rdp.other_mode_l | ((uint64_t)rdp.other_mode_h << 32); + om = (om & ~mask) | mode; + rdp.other_mode_l = (uint32_t)om; + rdp.other_mode_h = (uint32_t)(om >> 32); +} + +static inline void *seg_addr(uintptr_t w1) { + return (void *) w1; +} + +#define C0(pos, width) ((cmd->words.w0 >> (pos)) & ((1U << width) - 1)) +#define C1(pos, width) ((cmd->words.w1 >> (pos)) & ((1U << width) - 1)) + +static void gfx_run_dl(Gfx* cmd) { + int dummy = 0; + for (;;) { + uint32_t opcode = cmd->words.w0 >> 24; + + switch (opcode) { + // RSP commands: + case G_MTX: +#ifdef F3DEX_GBI_2 + gfx_sp_matrix(C0(0, 8) ^ G_MTX_PUSH, (const int32_t *) seg_addr(cmd->words.w1)); +#else + gfx_sp_matrix(C0(16, 8), (const int32_t *) seg_addr(cmd->words.w1)); +#endif + break; + case (uint8_t)G_POPMTX: +#ifdef F3DEX_GBI_2 + gfx_sp_pop_matrix(cmd->words.w1 / 64); +#else + gfx_sp_pop_matrix(1); +#endif + break; + case G_MOVEMEM: +#ifdef F3DEX_GBI_2 + gfx_sp_movemem(C0(0, 8), C0(8, 8) * 8, seg_addr(cmd->words.w1)); +#else + gfx_sp_movemem(C0(16, 8), 0, seg_addr(cmd->words.w1)); +#endif + break; + case (uint8_t)G_MOVEWORD: +#ifdef F3DEX_GBI_2 + gfx_sp_moveword(C0(16, 8), C0(0, 16), cmd->words.w1); +#else + gfx_sp_moveword(C0(0, 8), C0(8, 16), cmd->words.w1); +#endif + break; + case (uint8_t)G_TEXTURE: +#ifdef F3DEX_GBI_2 + gfx_sp_texture(C1(16, 16), C1(0, 16), C0(11, 3), C0(8, 3), C0(1, 7)); +#else + gfx_sp_texture(C1(16, 16), C1(0, 16), C0(11, 3), C0(8, 3), C0(0, 8)); +#endif + break; + case G_VTX: +#ifdef F3DEX_GBI_2 + gfx_sp_vertex(C0(12, 8), C0(1, 7) - C0(12, 8), seg_addr(cmd->words.w1)); +#elif defined(F3DEX_GBI) || defined(F3DLP_GBI) + gfx_sp_vertex(C0(10, 6), C0(16, 8) / 2, seg_addr(cmd->words.w1)); +#else + gfx_sp_vertex((C0(0, 16)) / sizeof(Vtx), C0(16, 4), seg_addr(cmd->words.w1)); +#endif + break; + case G_DL: + if (C0(16, 1) == 0) { + // Push return address + gfx_run_dl((Gfx *)seg_addr(cmd->words.w1)); + } else { + cmd = (Gfx *)seg_addr(cmd->words.w1); + --cmd; // increase after break + } + break; + case (uint8_t)G_ENDDL: + return; +#ifdef F3DEX_GBI_2 + case G_GEOMETRYMODE: + gfx_sp_geometry_mode(~C0(0, 24), cmd->words.w1); + break; +#else + case (uint8_t)G_SETGEOMETRYMODE: + gfx_sp_geometry_mode(0, cmd->words.w1); + break; + case (uint8_t)G_CLEARGEOMETRYMODE: + gfx_sp_geometry_mode(cmd->words.w1, 0); + break; +#endif + case (uint8_t)G_TRI1: +#ifdef F3DEX_GBI_2 + gfx_sp_tri1(C0(16, 8) / 2, C0(8, 8) / 2, C0(0, 8) / 2); +#elif defined(F3DEX_GBI) || defined(F3DLP_GBI) + gfx_sp_tri1(C1(16, 8) / 2, C1(8, 8) / 2, C1(0, 8) / 2); +#else + gfx_sp_tri1(C1(16, 8) / 10, C1(8, 8) / 10, C1(0, 8) / 10); +#endif + break; +#if defined(F3DEX_GBI) || defined(F3DLP_GBI) + case (uint8_t)G_TRI2: + gfx_sp_tri1(C0(16, 8) / 2, C0(8, 8) / 2, C0(0, 8) / 2); + gfx_sp_tri1(C1(16, 8) / 2, C1(8, 8) / 2, C1(0, 8) / 2); + break; +#endif + case (uint8_t)G_SETOTHERMODE_L: +#ifdef F3DEX_GBI_2 + gfx_sp_set_other_mode(31 - C0(8, 8) - C0(0, 8), C0(0, 8) + 1, cmd->words.w1); +#else + gfx_sp_set_other_mode(C0(8, 8), C0(0, 8), cmd->words.w1); +#endif + break; + case (uint8_t)G_SETOTHERMODE_H: +#ifdef F3DEX_GBI_2 + gfx_sp_set_other_mode(63 - C0(8, 8) - C0(0, 8), C0(0, 8) + 1, (uint64_t) cmd->words.w1 << 32); +#else + gfx_sp_set_other_mode(C0(8, 8) + 32, C0(0, 8), (uint64_t) cmd->words.w1 << 32); +#endif + break; +#ifdef F3D_OLD + case (uint8_t)G_RDPHALF_2: +#else + case (uint8_t)G_RDPHALF_1: +#endif + switch (rsp.saved_opcode) { + case G_TEXRECT: + case G_TEXRECTFLIP: +#ifdef F3DEX_GBI_2E + rsp.saved_ulx = (int32_t)(C0(0, 24) << 8) >> 8; +#endif + rsp.saved_uls = (uint16_t)C1(16, 16); + rsp.saved_ult = (uint16_t)C1(0, 16); + break; +#ifdef F3DEX_GBI_2E + case G_FILLRECT: + { + int32_t ulx = (int32_t)(C0(0, 24) << 8) >> 8; + int32_t uly = (int32_t)(C1(0, 24) << 8) >> 8; + gfx_dp_fill_rectangle(ulx, uly, rsp.saved_lrx, rsp.saved_lry); + rsp.saved_opcode = G_NOOP; + break; + } +#endif + } + break; +#ifdef F3D_OLD + case (uint8_t)G_RDPHALF_CONT: +#else + case (uint8_t)G_RDPHALF_2: +#endif + switch (rsp.saved_opcode) { + case G_TEXRECT: + case G_TEXRECTFLIP: + { + uint8_t tile = rsp.saved_tile; + int32_t ulx = rsp.saved_ulx, lrx = rsp.saved_lrx, lry = rsp.saved_lry; + uint16_t uls = rsp.saved_uls, ult = rsp.saved_ult; +#ifdef F3DEX_GBI_2E + int32_t uly = (int32_t)(C0(0, 24) << 8) >> 8; +#else + int32_t uly = rsp.saved_uly; +#endif + uint16_t dsdx = (uint16_t)C1(16, 16); + uint16_t dtdy = (uint16_t)C1(0, 16); + gfx_dp_texture_rectangle(ulx, uly, lrx, lry, tile, uls, ult, dsdx, dtdy, rsp.saved_opcode == G_TEXRECTFLIP); + rsp.saved_opcode = G_NOOP; + break; + } + } + + // RDP Commands: + case G_SETTIMG: + gfx_dp_set_texture_image(C0(21, 3), C0(19, 2), C0(0, 10), seg_addr(cmd->words.w1)); + break; + case G_LOADBLOCK: + gfx_dp_load_block(C1(24, 3), C0(12, 12), C0(0, 12), C1(12, 12), C1(0, 12)); + break; + case G_LOADTILE: + gfx_dp_load_tile(C1(24, 3), C0(12, 12), C0(0, 12), C1(12, 12), C1(0, 12)); + break; + case G_SETTILE: + gfx_dp_set_tile(C0(21, 3), C0(19, 2), C0(9, 9), C0(0, 9), C1(24, 3), C1(20, 4), C1(18, 2), C1(14, 4), C1(10, 4), C1(8, 2), C1(4, 4), C1(0, 4)); + break; + case G_SETTILESIZE: + gfx_dp_set_tile_size(C1(24, 3), C0(12, 12), C0(0, 12), C1(12, 12), C1(0, 12)); + break; + case G_LOADTLUT: + gfx_dp_load_tlut(C1(24, 3), C1(14, 10)); + break; + case G_SETENVCOLOR: + gfx_dp_set_env_color(C1(24, 8), C1(16, 8), C1(8, 8), C1(0, 8)); + break; + case G_SETPRIMCOLOR: + gfx_dp_set_prim_color(C1(24, 8), C1(16, 8), C1(8, 8), C1(0, 8)); + break; + case G_SETFOGCOLOR: + gfx_dp_set_fog_color(C1(24, 8), C1(16, 8), C1(8, 8), C1(0, 8)); + break; + case G_SETFILLCOLOR: + gfx_dp_set_fill_color(cmd->words.w1); + break; + case G_SETCOMBINE: + gfx_dp_set_combine_mode( + color_comb(C0(20, 4), C1(28, 4), C0(15, 5), C1(15, 3)), + color_comb(C0(12, 3), C1(12, 3), C0(9, 3), C1(9, 3))); + /*color_comb(C0(5, 4), C1(24, 4), C0(0, 5), C1(6, 3)), + color_comb(C1(21, 3), C1(3, 3), C1(18, 3), C1(0, 3)));*/ + break; + // G_SETPRIMCOLOR, G_CCMUX_PRIMITIVE, G_ACMUX_PRIMITIVE, is used by Goddard + // G_CCMUX_TEXEL1, LOD_FRACTION is used in Bowser room 1 + case G_TEXRECT: + case G_TEXRECTFLIP: + { + rsp.saved_opcode = opcode; +#ifdef F3DEX_GBI_2E + rsp.saved_lrx = (int32_t)(C0(0, 24) << 8) >> 8; + rsp.saved_lry = (int32_t)(C1(0, 24) << 8) >> 8; + rsp.saved_tile = (int32_t)C1(24, 3); +#else + rsp.saved_lrx = C0(12, 12); + rsp.saved_lry = C0(0, 12); + rsp.saved_tile = C1(24, 3); + rsp.saved_ulx = C1(12, 12); + rsp.saved_uly = C1(0, 12); +#endif + break; + } + case G_FILLRECT: +#ifdef F3DEX_GBI_2E + { + rsp.saved_opcode = G_FILLRECT; + rsp.saved_lrx = (int32_t)(C0(0, 24) << 8) >> 8; + rsp.saved_lry = (int32_t)(C1(0, 24) << 8) >> 8; + break; + } +#else + gfx_dp_fill_rectangle(C1(12, 12), C1(0, 12), C0(12, 12), C0(0, 12)); + break; +#endif + case G_SETSCISSOR: + gfx_dp_set_scissor(C1(24, 2), C0(12, 12), C0(0, 12), C1(12, 12), C1(0, 12)); + break; + case G_SETZIMG: + gfx_dp_set_z_image(seg_addr(cmd->words.w1)); + break; + case G_SETCIMG: + gfx_dp_set_color_image(C0(21, 3), C0(19, 2), C0(0, 11), seg_addr(cmd->words.w1)); + break; + } + ++cmd; + } +} + +static void gfx_sp_reset() { + rsp.modelview_matrix_stack_size = 1; + rsp.current_num_lights = 2; + rsp.lights_changed = true; +} + +void gfx_get_dimensions(uint32_t *width, uint32_t *height) { + gfx_wapi->get_dimensions(width, height); +} + +void gfx_init(struct GfxWindowManagerAPI *wapi, struct GfxRenderingAPI *rapi, const char *game_name, bool start_in_fullscreen) { + gfx_wapi = wapi; + gfx_rapi = rapi; + gfx_wapi->init(game_name, start_in_fullscreen); + gfx_rapi->init(); + + // Used in the 120 star TAS + static uint32_t precomp_shaders[] = { + 0x01200200, + 0x00000045, + 0x00000200, + 0x01200a00, + 0x00000a00, + 0x01a00045, + 0x00000551, + 0x01045045, + 0x05a00a00, + 0x01200045, + 0x05045045, + 0x01045a00, + 0x01a00a00, + 0x0000038d, + 0x01081081, + 0x0120038d, + 0x03200045, + 0x03200a00, + 0x01a00a6f, + 0x01141045, + 0x07a00a00, + 0x05200200, + 0x03200200, + 0x09200200, + 0x0920038d, + 0x09200045 + }; + for (size_t i = 0; i < sizeof(precomp_shaders) / sizeof(uint32_t); i++) { + gfx_lookup_or_create_shader_program(precomp_shaders[i]); + } +} + +struct GfxRenderingAPI *gfx_get_current_rendering_api(void) { + return gfx_rapi; +} + +void gfx_start_frame(void) { + gfx_wapi->handle_events(); + gfx_wapi->get_dimensions(&gfx_current_dimensions.width, &gfx_current_dimensions.height); + if (gfx_current_dimensions.height == 0) { + // Avoid division by zero + gfx_current_dimensions.height = 1; + } + gfx_current_dimensions.aspect_ratio = (float)gfx_current_dimensions.width / (float)gfx_current_dimensions.height; +} + +void gfx_run(Gfx *commands) { + gfx_sp_reset(); + + //puts("New frame"); + + if (!gfx_wapi->start_frame()) { + dropped_frame = true; + return; + } + dropped_frame = false; + + double t0 = gfx_wapi->get_time(); + gfx_rapi->start_frame(); + gfx_run_dl(commands); + gfx_flush(); + double t1 = gfx_wapi->get_time(); + //printf("Process %f %f\n", t1, t1 - t0); + gfx_rapi->end_frame(); + gfx_wapi->swap_buffers_begin(); +} + +void gfx_end_frame(void) { + if (!dropped_frame) { + gfx_rapi->finish_render(); + gfx_wapi->swap_buffers_end(); + } +} diff --git a/src/decomp/pc/gfx/gfx_pc.h b/src/decomp/pc/gfx/gfx_pc.h new file mode 100644 index 0000000..0ad4a30 --- /dev/null +++ b/src/decomp/pc/gfx/gfx_pc.h @@ -0,0 +1,30 @@ +#ifndef GFX_PC_H +#define GFX_PC_H + +#include + +struct GfxRenderingAPI; +struct GfxWindowManagerAPI; + +struct GfxDimensions { + uint32_t width, height; + float aspect_ratio; +}; + +extern struct GfxDimensions gfx_current_dimensions; + +#ifdef __cplusplus +extern "C" { +#endif + +void gfx_init(struct GfxWindowManagerAPI *wapi, struct GfxRenderingAPI *rapi, const char *game_name, bool start_in_fullscreen); +struct GfxRenderingAPI *gfx_get_current_rendering_api(void); +void gfx_start_frame(void); +void gfx_run(Gfx *commands); +void gfx_end_frame(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/decomp/pc/gfx/gfx_rendering_api.h b/src/decomp/pc/gfx/gfx_rendering_api.h new file mode 100644 index 0000000..ed6f1c4 --- /dev/null +++ b/src/decomp/pc/gfx/gfx_rendering_api.h @@ -0,0 +1,35 @@ +#ifndef GFX_RENDERING_API_H +#define GFX_RENDERING_API_H + +#include +#include +#include + +struct ShaderProgram; + +struct GfxRenderingAPI { + bool (*z_is_from_0_to_1)(void); + void (*unload_shader)(struct ShaderProgram *old_prg); + void (*load_shader)(struct ShaderProgram *new_prg); + struct ShaderProgram *(*create_and_load_new_shader)(uint32_t shader_id); + struct ShaderProgram *(*lookup_shader)(uint32_t shader_id); + void (*shader_get_info)(struct ShaderProgram *prg, uint8_t *num_inputs, bool used_textures[2]); + uint32_t (*new_texture)(void); + void (*select_texture)(int tile, uint32_t texture_id); + void (*upload_texture)(const uint8_t *rgba32_buf, int width, int height); + void (*set_sampler_parameters)(int sampler, bool linear_filter, uint32_t cms, uint32_t cmt); + void (*set_depth_test)(bool depth_test); + void (*set_depth_mask)(bool z_upd); + void (*set_zmode_decal)(bool zmode_decal); + void (*set_viewport)(int x, int y, int width, int height); + void (*set_scissor)(int x, int y, int width, int height); + void (*set_use_alpha)(bool use_alpha); + void (*draw_triangles)(float buf_vbo[], size_t buf_vbo_len, size_t buf_vbo_num_tris); + void (*init)(void); + void (*on_resize)(void); + void (*start_frame)(void); + void (*end_frame)(void); + void (*finish_render)(void); +}; + +#endif diff --git a/src/decomp/pc/gfx/gfx_screen_config.h b/src/decomp/pc/gfx/gfx_screen_config.h new file mode 100644 index 0000000..5b933f8 --- /dev/null +++ b/src/decomp/pc/gfx/gfx_screen_config.h @@ -0,0 +1,7 @@ +#ifndef GFX_SCREEN_CONFIG_H +#define GFX_SCREEN_CONFIG_H + +#define DESIRED_SCREEN_WIDTH 640 +#define DESIRED_SCREEN_HEIGHT 480 + +#endif diff --git a/src/decomp/pc/gfx/gfx_sdl.h b/src/decomp/pc/gfx/gfx_sdl.h new file mode 100644 index 0000000..458eccb --- /dev/null +++ b/src/decomp/pc/gfx/gfx_sdl.h @@ -0,0 +1,8 @@ +#ifndef GFX_SDL_H +#define GFX_SDL_H + +#include "gfx_window_manager_api.h" + +extern struct GfxWindowManagerAPI gfx_sdl; + +#endif diff --git a/src/decomp/pc/gfx/gfx_sdl2.c b/src/decomp/pc/gfx/gfx_sdl2.c new file mode 100644 index 0000000..4fd5c43 --- /dev/null +++ b/src/decomp/pc/gfx/gfx_sdl2.c @@ -0,0 +1,315 @@ +#include "../compat.h" + +#if !defined(__linux__) && !defined(__BSD__) && defined(ENABLE_OPENGL) + +#ifdef __MINGW32__ +#define FOR_WINDOWS 1 +#else +#define FOR_WINDOWS 0 +#endif + +#if FOR_WINDOWS +#include +#include "SDL.h" +#define GL_GLEXT_PROTOTYPES 1 +#include "SDL_opengl.h" +#else +#include +#define GL_GLEXT_PROTOTYPES 1 +#include +#endif + +#include "gfx_window_manager_api.h" +#include "gfx_screen_config.h" + +#define GFX_API_NAME "SDL2 - OpenGL" + +static SDL_Window *wnd; +static int inverted_scancode_table[512]; +static int vsync_enabled = 0; +static unsigned int window_width = DESIRED_SCREEN_WIDTH; +static unsigned int window_height = DESIRED_SCREEN_HEIGHT; +static bool fullscreen_state; +static void (*on_fullscreen_changed_callback)(bool is_now_fullscreen); +static bool (*on_key_down_callback)(int scancode); +static bool (*on_key_up_callback)(int scancode); +static void (*on_all_keys_up_callback)(void); + +const SDL_Scancode windows_scancode_table[] = +{ + /* 0 1 2 3 4 5 6 7 */ + /* 8 9 A B C D E F */ + SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_ESCAPE, SDL_SCANCODE_1, SDL_SCANCODE_2, SDL_SCANCODE_3, SDL_SCANCODE_4, SDL_SCANCODE_5, SDL_SCANCODE_6, /* 0 */ + SDL_SCANCODE_7, SDL_SCANCODE_8, SDL_SCANCODE_9, SDL_SCANCODE_0, SDL_SCANCODE_MINUS, SDL_SCANCODE_EQUALS, SDL_SCANCODE_BACKSPACE, SDL_SCANCODE_TAB, /* 0 */ + + SDL_SCANCODE_Q, SDL_SCANCODE_W, SDL_SCANCODE_E, SDL_SCANCODE_R, SDL_SCANCODE_T, SDL_SCANCODE_Y, SDL_SCANCODE_U, SDL_SCANCODE_I, /* 1 */ + SDL_SCANCODE_O, SDL_SCANCODE_P, SDL_SCANCODE_LEFTBRACKET, SDL_SCANCODE_RIGHTBRACKET, SDL_SCANCODE_RETURN, SDL_SCANCODE_LCTRL, SDL_SCANCODE_A, SDL_SCANCODE_S, /* 1 */ + + SDL_SCANCODE_D, SDL_SCANCODE_F, SDL_SCANCODE_G, SDL_SCANCODE_H, SDL_SCANCODE_J, SDL_SCANCODE_K, SDL_SCANCODE_L, SDL_SCANCODE_SEMICOLON, /* 2 */ + SDL_SCANCODE_APOSTROPHE, SDL_SCANCODE_GRAVE, SDL_SCANCODE_LSHIFT, SDL_SCANCODE_BACKSLASH, SDL_SCANCODE_Z, SDL_SCANCODE_X, SDL_SCANCODE_C, SDL_SCANCODE_V, /* 2 */ + + SDL_SCANCODE_B, SDL_SCANCODE_N, SDL_SCANCODE_M, SDL_SCANCODE_COMMA, SDL_SCANCODE_PERIOD, SDL_SCANCODE_SLASH, SDL_SCANCODE_RSHIFT, SDL_SCANCODE_PRINTSCREEN,/* 3 */ + SDL_SCANCODE_LALT, SDL_SCANCODE_SPACE, SDL_SCANCODE_CAPSLOCK, SDL_SCANCODE_F1, SDL_SCANCODE_F2, SDL_SCANCODE_F3, SDL_SCANCODE_F4, SDL_SCANCODE_F5, /* 3 */ + + SDL_SCANCODE_F6, SDL_SCANCODE_F7, SDL_SCANCODE_F8, SDL_SCANCODE_F9, SDL_SCANCODE_F10, SDL_SCANCODE_NUMLOCKCLEAR, SDL_SCANCODE_SCROLLLOCK, SDL_SCANCODE_HOME, /* 4 */ + SDL_SCANCODE_UP, SDL_SCANCODE_PAGEUP, SDL_SCANCODE_KP_MINUS, SDL_SCANCODE_LEFT, SDL_SCANCODE_KP_5, SDL_SCANCODE_RIGHT, SDL_SCANCODE_KP_PLUS, SDL_SCANCODE_END, /* 4 */ + + SDL_SCANCODE_DOWN, SDL_SCANCODE_PAGEDOWN, SDL_SCANCODE_INSERT, SDL_SCANCODE_DELETE, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_NONUSBACKSLASH,SDL_SCANCODE_F11, /* 5 */ + SDL_SCANCODE_F12, SDL_SCANCODE_PAUSE, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_LGUI, SDL_SCANCODE_RGUI, SDL_SCANCODE_APPLICATION, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, /* 5 */ + + SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_F13, SDL_SCANCODE_F14, SDL_SCANCODE_F15, SDL_SCANCODE_F16, /* 6 */ + SDL_SCANCODE_F17, SDL_SCANCODE_F18, SDL_SCANCODE_F19, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, /* 6 */ + + SDL_SCANCODE_INTERNATIONAL2, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_INTERNATIONAL1, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, /* 7 */ + SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_INTERNATIONAL4, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_INTERNATIONAL5, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_INTERNATIONAL3, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN /* 7 */ +}; + +const SDL_Scancode scancode_rmapping_extended[][2] = { + {SDL_SCANCODE_KP_ENTER, SDL_SCANCODE_RETURN}, + {SDL_SCANCODE_RALT, SDL_SCANCODE_LALT}, + {SDL_SCANCODE_RCTRL, SDL_SCANCODE_LCTRL}, + {SDL_SCANCODE_KP_DIVIDE, SDL_SCANCODE_SLASH}, + //{SDL_SCANCODE_KP_PLUS, SDL_SCANCODE_CAPSLOCK} +}; + +const SDL_Scancode scancode_rmapping_nonextended[][2] = { + {SDL_SCANCODE_KP_7, SDL_SCANCODE_HOME}, + {SDL_SCANCODE_KP_8, SDL_SCANCODE_UP}, + {SDL_SCANCODE_KP_9, SDL_SCANCODE_PAGEUP}, + {SDL_SCANCODE_KP_4, SDL_SCANCODE_LEFT}, + {SDL_SCANCODE_KP_6, SDL_SCANCODE_RIGHT}, + {SDL_SCANCODE_KP_1, SDL_SCANCODE_END}, + {SDL_SCANCODE_KP_2, SDL_SCANCODE_DOWN}, + {SDL_SCANCODE_KP_3, SDL_SCANCODE_PAGEDOWN}, + {SDL_SCANCODE_KP_0, SDL_SCANCODE_INSERT}, + {SDL_SCANCODE_KP_PERIOD, SDL_SCANCODE_DELETE}, + {SDL_SCANCODE_KP_MULTIPLY, SDL_SCANCODE_PRINTSCREEN} +}; + +static void set_fullscreen(bool on, bool call_callback) { + if (fullscreen_state == on) { + return; + } + fullscreen_state = on; + + if (on) { + SDL_DisplayMode mode; + SDL_GetDesktopDisplayMode(0, &mode); + window_width = mode.w; + window_height = mode.h; + } else { + window_width = DESIRED_SCREEN_WIDTH; + window_height = DESIRED_SCREEN_HEIGHT; + } + SDL_SetWindowSize(wnd, window_width, window_height); + SDL_SetWindowFullscreen(wnd, on ? SDL_WINDOW_FULLSCREEN : 0); + + if (on_fullscreen_changed_callback != NULL && call_callback) { + on_fullscreen_changed_callback(on); + } +} + +int test_vsync(void) { + // Even if SDL_GL_SetSwapInterval succeeds, it doesn't mean that VSync actually works. + // A 60 Hz monitor should have a swap interval of 16.67 milliseconds. + // Try to detect the length of a vsync by swapping buffers some times. + // Since the graphics card may enqueue a fixed number of frames, + // first send in four dummy frames to hopefully fill the queue. + // This method will fail if the refresh rate is changed, which, in + // combination with that we can't control the queue size (i.e. lag) + // is a reason this generic SDL2 backend should only be used as last resort. + Uint32 start; + Uint32 end; + + SDL_GL_SwapWindow(wnd); + SDL_GL_SwapWindow(wnd); + SDL_GL_SwapWindow(wnd); + SDL_GL_SwapWindow(wnd); + SDL_GL_SwapWindow(wnd); + SDL_GL_SwapWindow(wnd); + SDL_GL_SwapWindow(wnd); + SDL_GL_SwapWindow(wnd); + start = SDL_GetTicks(); + SDL_GL_SwapWindow(wnd); + SDL_GL_SwapWindow(wnd); + SDL_GL_SwapWindow(wnd); + SDL_GL_SwapWindow(wnd); + end = SDL_GetTicks(); + + float average = 4.0 * 1000.0 / (end - start); + + vsync_enabled = 1; + if (average > 27 && average < 33) { + SDL_GL_SetSwapInterval(1); + } else if (average > 57 && average < 63) { + SDL_GL_SetSwapInterval(2); + } else if (average > 86 && average < 94) { + SDL_GL_SetSwapInterval(3); + } else if (average > 115 && average < 125) { + SDL_GL_SetSwapInterval(4); + } else { + vsync_enabled = 0; + } +} + +static void gfx_sdl_init(const char *game_name, bool start_in_fullscreen) { + SDL_Init(SDL_INIT_VIDEO); + + SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24); + SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); + + //SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1); + //SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4); + + char title[512]; + int len = sprintf(title, "%s (%s)", game_name, GFX_API_NAME); + + wnd = SDL_CreateWindow(title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, + window_width, window_height, SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE); + + if (start_in_fullscreen) { + set_fullscreen(true, false); + } + + SDL_GL_CreateContext(wnd); + + SDL_GL_SetSwapInterval(1); + test_vsync(); + if (!vsync_enabled) + puts("Warning: VSync is not enabled or not working. Falling back to timer for synchronization"); + + for (size_t i = 0; i < sizeof(windows_scancode_table) / sizeof(SDL_Scancode); i++) { + inverted_scancode_table[windows_scancode_table[i]] = i; + } + + for (size_t i = 0; i < sizeof(scancode_rmapping_extended) / sizeof(scancode_rmapping_extended[0]); i++) { + inverted_scancode_table[scancode_rmapping_extended[i][0]] = inverted_scancode_table[scancode_rmapping_extended[i][1]] + 0x100; + } + + for (size_t i = 0; i < sizeof(scancode_rmapping_nonextended) / sizeof(scancode_rmapping_nonextended[0]); i++) { + inverted_scancode_table[scancode_rmapping_extended[i][0]] = inverted_scancode_table[scancode_rmapping_extended[i][1]]; + inverted_scancode_table[scancode_rmapping_extended[i][1]] += 0x100; + } +} + +static void gfx_sdl_set_fullscreen_changed_callback(void (*on_fullscreen_changed)(bool is_now_fullscreen)) { + on_fullscreen_changed_callback = on_fullscreen_changed; +} + +static void gfx_sdl_set_fullscreen(bool enable) { + set_fullscreen(enable, true); +} + +static void gfx_sdl_set_keyboard_callbacks(bool (*on_key_down)(int scancode), bool (*on_key_up)(int scancode), void (*on_all_keys_up)(void)) { + on_key_down_callback = on_key_down; + on_key_up_callback = on_key_up; + on_all_keys_up_callback = on_all_keys_up; +} + +static void gfx_sdl_main_loop(void (*run_one_game_iter)(void)) { + while (1) { + run_one_game_iter(); + } +} + +static void gfx_sdl_get_dimensions(uint32_t *width, uint32_t *height) { + *width = window_width; + *height = window_height; +} + +static int translate_scancode(int scancode) { + if (scancode < 512) { + return inverted_scancode_table[scancode]; + } else { + return 0; + } +} + +static void gfx_sdl_onkeydown(int scancode) { + int key = translate_scancode(scancode); + if (on_key_down_callback != NULL) { + on_key_down_callback(key); + } +} + +static void gfx_sdl_onkeyup(int scancode) { + int key = translate_scancode(scancode); + if (on_key_up_callback != NULL) { + on_key_up_callback(key); + } +} + +static void gfx_sdl_handle_events(void) { + SDL_Event event; + while (SDL_PollEvent(&event)) { + switch (event.type) { +#ifndef TARGET_WEB + // Scancodes are broken in Emscripten SDL2: https://bugzilla.libsdl.org/show_bug.cgi?id=3259 + case SDL_KEYDOWN: + if (event.key.keysym.sym == SDLK_F10) { + set_fullscreen(!fullscreen_state, true); + break; + } + gfx_sdl_onkeydown(event.key.keysym.scancode); + break; + case SDL_KEYUP: + gfx_sdl_onkeyup(event.key.keysym.scancode); + break; +#endif + case SDL_WINDOWEVENT: + if (event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED) { + window_width = event.window.data1; + window_height = event.window.data2; + } + break; + case SDL_QUIT: + exit(0); + } + } +} + +static bool gfx_sdl_start_frame(void) { + return true; +} + +static void sync_framerate_with_timer(void) { + // Number of milliseconds a frame should take (30 fps) + const Uint32 FRAME_TIME = 1000 / 30; + static Uint32 last_time; + Uint32 elapsed = SDL_GetTicks() - last_time; + + if (elapsed < FRAME_TIME) + SDL_Delay(FRAME_TIME - elapsed); + last_time += FRAME_TIME; +} + +static void gfx_sdl_swap_buffers_begin(void) { + if (!vsync_enabled) { + sync_framerate_with_timer(); + } + + SDL_GL_SwapWindow(wnd); +} + +static void gfx_sdl_swap_buffers_end(void) { +} + +static double gfx_sdl_get_time(void) { + return 0.0; +} + +struct GfxWindowManagerAPI gfx_sdl = { + gfx_sdl_init, + gfx_sdl_set_keyboard_callbacks, + gfx_sdl_set_fullscreen_changed_callback, + gfx_sdl_set_fullscreen, + gfx_sdl_main_loop, + gfx_sdl_get_dimensions, + gfx_sdl_handle_events, + gfx_sdl_start_frame, + gfx_sdl_swap_buffers_begin, + gfx_sdl_swap_buffers_end, + gfx_sdl_get_time +}; + +#endif diff --git a/src/decomp/pc/gfx/gfx_window_manager_api.h b/src/decomp/pc/gfx/gfx_window_manager_api.h new file mode 100644 index 0000000..6ba4a2d --- /dev/null +++ b/src/decomp/pc/gfx/gfx_window_manager_api.h @@ -0,0 +1,21 @@ +#ifndef GFX_WINDOW_MANAGER_API_H +#define GFX_WINDOW_MANAGER_API_H + +#include +#include + +struct GfxWindowManagerAPI { + void (*init)(const char *game_name, bool start_in_fullscreen); + void (*set_keyboard_callbacks)(bool (*on_key_down)(int scancode), bool (*on_key_up)(int scancode), void (*on_all_keys_up)(void)); + void (*set_fullscreen_changed_callback)(void (*on_fullscreen_changed)(bool is_now_fullscreen)); + void (*set_fullscreen)(bool enable); + void (*main_loop)(void (*run_one_game_iter)(void)); + void (*get_dimensions)(uint32_t *width, uint32_t *height); + void (*handle_events)(void); + bool (*start_frame)(void); + void (*swap_buffers_begin)(void); + void (*swap_buffers_end)(void); + double (*get_time)(void); // For debug +}; + +#endif diff --git a/src/decomp/pc/libaudio_internal.h b/src/decomp/pc/libaudio_internal.h new file mode 100644 index 0000000..ea63322 --- /dev/null +++ b/src/decomp/pc/libaudio_internal.h @@ -0,0 +1,127 @@ +#ifndef _LIBAUDIO_INTERNAL_H_ +#define _LIBAUDIO_INTERNAL_H_ +#include +#define AL_BANK_VERSION 0x4231 /* 'B1' */ + +typedef u8 ALPan; +typedef s32 ALMicroTime; + +/* Possible wavetable types */ +enum +{ + AL_ADPCM_WAVE = 0, + AL_RAW16_WAVE +}; + +typedef struct +{ + u32 start; + u32 end; + u32 count; +} ALRawLoop; + +typedef struct +{ + u32 start; + u32 end; + u32 count; + ADPCM_STATE state; +} ALADPCMloop; + +typedef struct +{ + s32 order; + s32 npredictors; + s16 book[1]; // variable size, 8-byte aligned +} ALADPCMBook; + +typedef struct +{ + ALMicroTime attackTime; + ALMicroTime decayTime; + ALMicroTime releaseTime; + u8 attackVolume; + u8 decayVolume; +} ALEnvelope; + +typedef struct +{ + u8 velocityMin; + u8 velocityMax; + u8 keyMin; + u8 keyMax; + u8 keyBase; + s8 detune; +} ALKeyMap; + +typedef struct +{ + ALADPCMloop *loop; + ALADPCMBook *book; +} ALADPCMWaveInfo; + +typedef struct +{ + ALRawLoop *loop; +} ALRAWWaveInfo; + +typedef struct ALWaveTable_s +{ + u8 *base; /* ptr to start of wave data */ + s32 len; /* length of data in bytes */ + u8 type; /* compression type */ + u8 flags; /* offset/address flags */ + union { + ALADPCMWaveInfo adpcmWave; + ALRAWWaveInfo rawWave; + } waveInfo; +} ALWaveTable; + +typedef struct ALSound_s +{ + ALEnvelope *envelope; + ALKeyMap *keyMap; + ALWaveTable *wavetable; /* offset to wavetable struct */ + ALPan samplePan; + u8 sampleVolume; + u8 flags; +} ALSound; + +typedef struct +{ + u8 volume; /* overall volume for this instrument */ + ALPan pan; /* 0 = hard left, 127 = hard right */ + u8 priority; /* voice priority for this instrument */ + u8 flags; + u8 tremType; /* the type of tremelo osc. to use */ + u8 tremRate; /* the rate of the tremelo osc. */ + u8 tremDepth; /* the depth of the tremelo osc */ + u8 tremDelay; /* the delay for the tremelo osc */ + u8 vibType; /* the type of tremelo osc. to use */ + u8 vibRate; /* the rate of the tremelo osc. */ + u8 vibDepth; /* the depth of the tremelo osc */ + u8 vibDelay; /* the delay for the tremelo osc */ + s16 bendRange; /* pitch bend range in cents */ + s16 soundCount; /* number of sounds in this array */ + ALSound *soundArray[1]; +} ALInstrument; + +typedef struct ALBank_s +{ + s16 instCount; /* number of programs in this bank */ + u8 flags; + u8 pad; + s32 sampleRate; /* e.g. 44100, 22050, etc... */ + ALInstrument *percussion; /* default percussion for GM */ + ALInstrument *instArray[1]; /* ARRAY of instruments */ +} ALBank; + +typedef struct +{ /* Note: sizeof won't be correct */ + s16 revision; /* format revision of this file */ + s16 bankCount; /* number of banks */ + ALBank *bankArray[1]; /* ARRAY of bank offsets */ +} ALBankFile; + +void alBnkfNew(ALBankFile *f, u8 *table); +#endif diff --git a/src/decomp/pc/libultra_internal.h b/src/decomp/pc/libultra_internal.h new file mode 100644 index 0000000..5639c6a --- /dev/null +++ b/src/decomp/pc/libultra_internal.h @@ -0,0 +1,99 @@ +#ifndef _LIBULTRA_INTERNAL_H_ +#define _LIBULTRA_INTERNAL_H_ +#include + +/* + * This define is needed because the original definitions in __osDequeueThread.c are declared + * seperately instead of part of a single struct, however some code alises over this memory + * assuming a unified structure. To fix this, we declare the full type here and then alias the + * symbol names to the correct members in AVOID_UB. + */ +#ifdef AVOID_UB +typedef struct OSThread_ListHead_s +{ + /*0x00*/ struct OSThread_s *next; + /*0x04*/ OSPri priority; + /*0x08*/ struct OSThread_s *queue; + /*0x0C*/ struct OSThread_s *tlnext; + /*0x10*/ struct OSThread_s *unk10; + /*0x14*/ u32 unk14; +} OSThread_ListHead; + +// Now fix the symbols to the new one. +extern OSThread_ListHead D_80334890_fix; + +#define D_80334890 D_80334890_fix.next +#define D_80334894 D_80334890_fix.priority +#define D_80334898 D_80334890_fix.queue +#define D_8033489C D_80334890_fix.tlnext +#define D_803348A0 D_80334890_fix.unk10 + +// Fix for the EEPROM array. +extern u32 D_80365E00[16]; + +// alias the last array element correctly +#define D_80365E3C D_80365E00[15] +#else +// Original OSThread_ListHead definitions +extern OSThread *D_80334890; +extern u32 D_80334894; +extern OSThread *D_80334898; +extern OSThread *D_8033489C; +extern OSThread *D_803348A0; + +// Original EEPROM definitions +extern u32 D_80365E00[15]; +extern u32 D_80365E3C; +#endif + +typedef struct { + u32 initialized; // probably something like initialized? + OSThread *mgrThread; + OSMesgQueue *cmdQueue; + OSMesgQueue *eventQueue; + OSMesgQueue *accessQueue; + s32 (*dma_func)(s32, u32, void *, size_t); +#if defined(VERSION_EU) || defined(VERSION_SH) + s32 (*edma_func)(OSPiHandle*, s32, u32, void *, size_t); +#else + u64 force_align; +#endif +} OSMgrArgs; + +s32 __osDisableInt(void); +void __osRestoreInt(s32); +void __osEnqueueAndYield(OSThread **); +void __osDequeueThread(OSThread **, OSThread *); +void __osEnqueueThread(OSThread **, OSThread *); +OSThread *__osPopThread(OSThread **); +s32 __osSiRawStartDma(s32, void *); +void __osSiCreateAccessQueue(void); +void __osSiGetAccess(void); +void __osSiRelAccess(void); +u32 __osProbeTLB(void *); +void __osPiCreateAccessQueue(void); +void __osPiGetAccess(void); +void __osSetSR(u32); +u32 __osGetSR(void); +void __osSetFpcCsr(u32); +s32 __osSiRawReadIo(void *, u32 *); +s32 __osSiRawWriteIo(void *, u32); +s32 osPiRawReadIo(u32 a0, u32 *a1); +void __osSpSetStatus(u32); +u32 __osSpGetStatus(void); +s32 __osSpSetPc(void *); +s32 __osSpDeviceBusy(void); +s32 __osSiDeviceBusy(void); +s32 __osSpRawStartDma(u32 dir, void *sp_ptr, void *dram_ptr, size_t size); +void __osViInit(void); +OSViContext *__osViGetCurrentContext(void); +OSViContext *__osViGetCurrentContext2(void); +void __osViSwapContext(void); +void __osSetTimerIntr(u64); +u64 __osInsertTimer(OSTimer *); +void __osSetCompare(u32); +s32 __osAiDeviceBusy(void); +void __osDispatchThread(void); +u32 __osGetCause(void); +s32 __osAtomicDec(u32 *); +#endif diff --git a/src/decomp/pc/mixer.c b/src/decomp/pc/mixer.c new file mode 100644 index 0000000..62d2cbb --- /dev/null +++ b/src/decomp/pc/mixer.c @@ -0,0 +1,1185 @@ +#include +#include +#include +#include + +#include "mixer.h" + +#ifdef __SSE4_1__ +#include +#define HAS_SSE41 1 +#define HAS_NEON 0 +#elif __ARM_NEON +#include +#define HAS_SSE41 0 +#define HAS_NEON 1 +#else +#define HAS_SSE41 0 +#define HAS_NEON 0 +#endif + +#pragma GCC optimize ("unroll-loops") + +#if HAS_SSE41 +#define LOADLH(l, h) _mm_castpd_si128(_mm_loadh_pd(_mm_load_sd((const double *)(l)), (const double *)(h))) +#endif + +#define ROUND_UP_64(v) (((v) + 63) & ~63) +#define ROUND_UP_32(v) (((v) + 31) & ~31) +#define ROUND_UP_16(v) (((v) + 15) & ~15) +#define ROUND_UP_8(v) (((v) + 7) & ~7) +#define ROUND_DOWN_16(v) ((v) & ~0xf) + +#ifdef NEW_AUDIO_UCODE +#define BUF_SIZE 2880 +#define BUF_U8(a) (rspa.buf.as_u8 + ((a) - 0x450)) +#define BUF_S16(a) (rspa.buf.as_s16 + ((a) - 0x450) / sizeof(int16_t)) +#else +#define BUF_SIZE 2512 +#define BUF_U8(a) (rspa.buf.as_u8 + (a)) +#define BUF_S16(a) (rspa.buf.as_s16 + (a) / sizeof(int16_t)) +#endif + +static struct { + uint16_t in; + uint16_t out; + uint16_t nbytes; + +#ifdef NEW_AUDIO_UCODE + uint16_t vol[2]; + uint16_t rate[2]; + uint16_t vol_wet; + uint16_t rate_wet; +#else + int16_t vol[2]; + + uint16_t dry_right; + uint16_t wet_left; + uint16_t wet_right; + + int16_t target[2]; + int32_t rate[2]; + + int16_t vol_dry; + int16_t vol_wet; +#endif + + ADPCM_STATE *adpcm_loop_state; + + int16_t adpcm_table[8][2][8]; + +#ifdef NEW_AUDIO_UCODE + uint16_t filter_count; + int16_t filter[8]; +#endif + + union { + int16_t as_s16[BUF_SIZE / sizeof(int16_t)]; + uint8_t as_u8[BUF_SIZE]; + } buf; +} rspa; + +static int16_t resample_table[64][4] = { + {0x0c39, 0x66ad, 0x0d46, 0xffdf}, {0x0b39, 0x6696, 0x0e5f, 0xffd8}, + {0x0a44, 0x6669, 0x0f83, 0xffd0}, {0x095a, 0x6626, 0x10b4, 0xffc8}, + {0x087d, 0x65cd, 0x11f0, 0xffbf}, {0x07ab, 0x655e, 0x1338, 0xffb6}, + {0x06e4, 0x64d9, 0x148c, 0xffac}, {0x0628, 0x643f, 0x15eb, 0xffa1}, + {0x0577, 0x638f, 0x1756, 0xff96}, {0x04d1, 0x62cb, 0x18cb, 0xff8a}, + {0x0435, 0x61f3, 0x1a4c, 0xff7e}, {0x03a4, 0x6106, 0x1bd7, 0xff71}, + {0x031c, 0x6007, 0x1d6c, 0xff64}, {0x029f, 0x5ef5, 0x1f0b, 0xff56}, + {0x022a, 0x5dd0, 0x20b3, 0xff48}, {0x01be, 0x5c9a, 0x2264, 0xff3a}, + {0x015b, 0x5b53, 0x241e, 0xff2c}, {0x0101, 0x59fc, 0x25e0, 0xff1e}, + {0x00ae, 0x5896, 0x27a9, 0xff10}, {0x0063, 0x5720, 0x297a, 0xff02}, + {0x001f, 0x559d, 0x2b50, 0xfef4}, {0xffe2, 0x540d, 0x2d2c, 0xfee8}, + {0xffac, 0x5270, 0x2f0d, 0xfedb}, {0xff7c, 0x50c7, 0x30f3, 0xfed0}, + {0xff53, 0x4f14, 0x32dc, 0xfec6}, {0xff2e, 0x4d57, 0x34c8, 0xfebd}, + {0xff0f, 0x4b91, 0x36b6, 0xfeb6}, {0xfef5, 0x49c2, 0x38a5, 0xfeb0}, + {0xfedf, 0x47ed, 0x3a95, 0xfeac}, {0xfece, 0x4611, 0x3c85, 0xfeab}, + {0xfec0, 0x4430, 0x3e74, 0xfeac}, {0xfeb6, 0x424a, 0x4060, 0xfeaf}, + {0xfeaf, 0x4060, 0x424a, 0xfeb6}, {0xfeac, 0x3e74, 0x4430, 0xfec0}, + {0xfeab, 0x3c85, 0x4611, 0xfece}, {0xfeac, 0x3a95, 0x47ed, 0xfedf}, + {0xfeb0, 0x38a5, 0x49c2, 0xfef5}, {0xfeb6, 0x36b6, 0x4b91, 0xff0f}, + {0xfebd, 0x34c8, 0x4d57, 0xff2e}, {0xfec6, 0x32dc, 0x4f14, 0xff53}, + {0xfed0, 0x30f3, 0x50c7, 0xff7c}, {0xfedb, 0x2f0d, 0x5270, 0xffac}, + {0xfee8, 0x2d2c, 0x540d, 0xffe2}, {0xfef4, 0x2b50, 0x559d, 0x001f}, + {0xff02, 0x297a, 0x5720, 0x0063}, {0xff10, 0x27a9, 0x5896, 0x00ae}, + {0xff1e, 0x25e0, 0x59fc, 0x0101}, {0xff2c, 0x241e, 0x5b53, 0x015b}, + {0xff3a, 0x2264, 0x5c9a, 0x01be}, {0xff48, 0x20b3, 0x5dd0, 0x022a}, + {0xff56, 0x1f0b, 0x5ef5, 0x029f}, {0xff64, 0x1d6c, 0x6007, 0x031c}, + {0xff71, 0x1bd7, 0x6106, 0x03a4}, {0xff7e, 0x1a4c, 0x61f3, 0x0435}, + {0xff8a, 0x18cb, 0x62cb, 0x04d1}, {0xff96, 0x1756, 0x638f, 0x0577}, + {0xffa1, 0x15eb, 0x643f, 0x0628}, {0xffac, 0x148c, 0x64d9, 0x06e4}, + {0xffb6, 0x1338, 0x655e, 0x07ab}, {0xffbf, 0x11f0, 0x65cd, 0x087d}, + {0xffc8, 0x10b4, 0x6626, 0x095a}, {0xffd0, 0x0f83, 0x6669, 0x0a44}, + {0xffd8, 0x0e5f, 0x6696, 0x0b39}, {0xffdf, 0x0d46, 0x66ad, 0x0c39} +}; + +static inline int16_t clamp16(int32_t v) { + if (v < -0x8000) { + return -0x8000; + } else if (v > 0x7fff) { + return 0x7fff; + } + return (int16_t)v; +} + +static inline int32_t clamp32(int64_t v) { + if (v < -0x7fffffff - 1) { + return -0x7fffffff - 1; + } else if (v > 0x7fffffff) { + return 0x7fffffff; + } + return (int32_t)v; +} + +void aClearBufferImpl(uint16_t addr, int nbytes) { + nbytes = ROUND_UP_16(nbytes); + memset(BUF_U8(addr), 0, nbytes); +} + +#ifdef NEW_AUDIO_UCODE +void aLoadBufferImpl(const void *source_addr, uint16_t dest_addr, uint16_t nbytes) { + memcpy(BUF_U8(dest_addr), source_addr, ROUND_DOWN_16(nbytes)); +} + +void aSaveBufferImpl(uint16_t source_addr, int16_t *dest_addr, uint16_t nbytes) { + memcpy(dest_addr, BUF_S16(source_addr), ROUND_DOWN_16(nbytes)); +} +#else +void aLoadBufferImpl(const void *source_addr) { + memcpy(BUF_U8(rspa.in), source_addr, ROUND_UP_8(rspa.nbytes)); +} + +void aSaveBufferImpl(int16_t *dest_addr) { + memcpy(dest_addr, BUF_S16(rspa.out), ROUND_UP_8(rspa.nbytes)); +} +#endif + +void aLoadADPCMImpl(int num_entries_times_16, const int16_t *book_source_addr) { + memcpy(rspa.adpcm_table, book_source_addr, num_entries_times_16); +} + +void aSetBufferImpl(uint8_t flags, uint16_t in, uint16_t out, uint16_t nbytes) { +#ifndef NEW_AUDIO_UCODE + if (flags & A_AUX) { + rspa.dry_right = in; + rspa.wet_left = out; + rspa.wet_right = nbytes; + return; + } +#endif + rspa.in = in; + rspa.out = out; + rspa.nbytes = nbytes; +} + +#ifndef NEW_AUDIO_UCODE +void aSetVolumeImpl(uint8_t flags, int16_t v, int16_t t, int16_t r) { + if (flags & A_AUX) { + rspa.vol_dry = v; + rspa.vol_wet = r; + } else if (flags & A_VOL) { + if (flags & A_LEFT) { + rspa.vol[0] = v; + } else { + rspa.vol[1] = v; + } + } else { + if (flags & A_LEFT) { + rspa.target[0] = v; + rspa.rate[0] = (int32_t)((uint16_t)t << 16 | ((uint16_t)r)); + } else { + rspa.target[1] = v; + rspa.rate[1] = (int32_t)((uint16_t)t << 16 | ((uint16_t)r)); + } + } +} +#endif + +#ifdef NEW_AUDIO_UCODE +void aInterleaveImpl(uint16_t dest, uint16_t left, uint16_t right, uint16_t c) { + int count = ROUND_UP_8(c) / sizeof(int16_t) / 4; + int16_t *l = BUF_S16(left); + int16_t *r = BUF_S16(right); + int16_t *d = BUF_S16(dest); + while (count > 0) { + int16_t l0 = *l++; + int16_t l1 = *l++; + int16_t l2 = *l++; + int16_t l3 = *l++; + int16_t r0 = *r++; + int16_t r1 = *r++; + int16_t r2 = *r++; + int16_t r3 = *r++; + *d++ = l0; + *d++ = r0; + *d++ = l1; + *d++ = r1; + *d++ = l2; + *d++ = r2; + *d++ = l3; + *d++ = r3; + --count; + } +} +#else +void aInterleaveImpl(uint16_t left, uint16_t right) { + int count = ROUND_UP_16(rspa.nbytes) / sizeof(int16_t) / 8; + int16_t *l = BUF_S16(left); + int16_t *r = BUF_S16(right); + int16_t *d = BUF_S16(rspa.out); + while (count > 0) { + int16_t l0 = *l++; + int16_t l1 = *l++; + int16_t l2 = *l++; + int16_t l3 = *l++; + int16_t l4 = *l++; + int16_t l5 = *l++; + int16_t l6 = *l++; + int16_t l7 = *l++; + int16_t r0 = *r++; + int16_t r1 = *r++; + int16_t r2 = *r++; + int16_t r3 = *r++; + int16_t r4 = *r++; + int16_t r5 = *r++; + int16_t r6 = *r++; + int16_t r7 = *r++; + *d++ = l0; + *d++ = r0; + *d++ = l1; + *d++ = r1; + *d++ = l2; + *d++ = r2; + *d++ = l3; + *d++ = r3; + *d++ = l4; + *d++ = r4; + *d++ = l5; + *d++ = r5; + *d++ = l6; + *d++ = r6; + *d++ = l7; + *d++ = r7; + --count; + } +} +#endif + +void aDMEMMoveImpl(uint16_t in_addr, uint16_t out_addr, int nbytes) { + nbytes = ROUND_UP_16(nbytes); + memmove(BUF_U8(out_addr), BUF_U8(in_addr), nbytes); +} + +void aSetLoopImpl(ADPCM_STATE *adpcm_loop_state) { + rspa.adpcm_loop_state = adpcm_loop_state; +} + +void aADPCMdecImpl(uint8_t flags, ADPCM_STATE state) { +#if HAS_SSE41 + const __m128i tblrev = _mm_setr_epi8(12, 13, 10, 11, 8, 9, 6, 7, 4, 5, 2, 3, 0, 1, -1, -1); + const __m128i pos0 = _mm_set_epi8(3, -1, 3, -1, 2, -1, 2, -1, 1, -1, 1, -1, 0, -1, 0, -1); + const __m128i pos1 = _mm_set_epi8(7, -1, 7, -1, 6, -1, 6, -1, 5, -1, 5, -1, 4, -1, 4, -1); + const __m128i mult = _mm_set_epi16(0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01); + const __m128i mask = _mm_set1_epi16((int16_t)0xf000); +#elif HAS_NEON + static const int8_t pos0_data[] = {-1, 0, -1, 0, -1, 1, -1, 1, -1, 2, -1, 2, -1, 3, -1, 3}; + static const int8_t pos1_data[] = {-1, 4, -1, 4, -1, 5, -1, 5, -1, 6, -1, 6, -1, 7, -1, 7}; + static const int16_t mult_data[] = {0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10}; + static const int16_t table_prefix_data[] = {0, 0, 0, 0, 0, 0, 0, 1 << 11}; + const int8x16_t pos0 = vld1q_s8(pos0_data); + const int8x16_t pos1 = vld1q_s8(pos1_data); + const int16x8_t mult = vld1q_s16(mult_data); + const int16x8_t mask = vdupq_n_s16((int16_t)0xf000); + const int16x8_t table_prefix = vld1q_s16(table_prefix_data); +#endif + uint8_t *in = BUF_U8(rspa.in); + int16_t *out = BUF_S16(rspa.out); + int nbytes = ROUND_UP_32(rspa.nbytes); + if (flags & A_INIT) { + memset(out, 0, 16 * sizeof(int16_t)); + } else if (flags & A_LOOP) { + memcpy(out, rspa.adpcm_loop_state, 16 * sizeof(int16_t)); + } else { + memcpy(out, state, 16 * sizeof(int16_t)); + } + out += 16; +#if HAS_SSE41 + __m128i prev_interleaved = _mm_set1_epi32((uint16_t)out[-2] | ((uint16_t)out[-1] << 16)); + //__m128i prev_interleaved = _mm_shuffle_epi32(_mm_loadu_si32(out - 2), 0); // GCC misses this? +#elif HAS_NEON + int16x8_t result = vld1q_s16(out - 8); +#endif + while (nbytes > 0) { + int shift = *in >> 4; // should be in 0..12 + int table_index = *in++ & 0xf; // should be in 0..7 + int16_t (*tbl)[8] = rspa.adpcm_table[table_index]; + int i; +#if HAS_SSE41 + // The _mm_loadu_si64 instruction was added in GCC 9, and results in the same + // asm as the following instructions, so better be compatible with old GCC. + //__m128i inv = _mm_loadu_si64(in); + uint64_t v; memcpy(&v, in, 8); + __m128i inv = _mm_set_epi64x(0, v); + __m128i invec[2] = {_mm_shuffle_epi8(inv, pos0), _mm_shuffle_epi8(inv, pos1)}; + __m128i tblvec0 = _mm_loadu_si128((const __m128i *)tbl[0]); + __m128i tblvec1 = _mm_loadu_si128((const __m128i *)(tbl[1])); + __m128i tbllo = _mm_unpacklo_epi16(tblvec0, tblvec1); + __m128i tblhi = _mm_unpackhi_epi16(tblvec0, tblvec1); + __m128i shiftcount = _mm_set_epi64x(0, 12 - shift); // _mm_cvtsi64_si128 does not exist on 32-bit x86 + __m128i tblvec1_rev[8]; + + tblvec1_rev[0] = _mm_insert_epi16(_mm_shuffle_epi8(tblvec1, tblrev), 1 << 11, 7); + tblvec1_rev[1] = _mm_bsrli_si128(tblvec1_rev[0], 2); + tblvec1_rev[2] = _mm_bsrli_si128(tblvec1_rev[0], 4); + tblvec1_rev[3] = _mm_bsrli_si128(tblvec1_rev[0], 6); + tblvec1_rev[4] = _mm_bsrli_si128(tblvec1_rev[0], 8); + tblvec1_rev[5] = _mm_bsrli_si128(tblvec1_rev[0], 10); + tblvec1_rev[6] = _mm_bsrli_si128(tblvec1_rev[0], 12); + tblvec1_rev[7] = _mm_bsrli_si128(tblvec1_rev[0], 14); + in += 8; + for (i = 0; i < 2; i++) { + __m128i acc0 = _mm_madd_epi16(prev_interleaved, tbllo); + __m128i acc1 = _mm_madd_epi16(prev_interleaved, tblhi); + __m128i muls[8]; + __m128i result; + invec[i] = _mm_sra_epi16(_mm_and_si128(_mm_mullo_epi16(invec[i], mult), mask), shiftcount); + + muls[7] = _mm_madd_epi16(tblvec1_rev[0], invec[i]); + muls[6] = _mm_madd_epi16(tblvec1_rev[1], invec[i]); + muls[5] = _mm_madd_epi16(tblvec1_rev[2], invec[i]); + muls[4] = _mm_madd_epi16(tblvec1_rev[3], invec[i]); + muls[3] = _mm_madd_epi16(tblvec1_rev[4], invec[i]); + muls[2] = _mm_madd_epi16(tblvec1_rev[5], invec[i]); + muls[1] = _mm_madd_epi16(tblvec1_rev[6], invec[i]); + muls[0] = _mm_madd_epi16(tblvec1_rev[7], invec[i]); + + acc0 = _mm_add_epi32(acc0, _mm_hadd_epi32(_mm_hadd_epi32(muls[0], muls[1]), _mm_hadd_epi32(muls[2], muls[3]))); + acc1 = _mm_add_epi32(acc1, _mm_hadd_epi32(_mm_hadd_epi32(muls[4], muls[5]), _mm_hadd_epi32(muls[6], muls[7]))); + + acc0 = _mm_srai_epi32(acc0, 11); + acc1 = _mm_srai_epi32(acc1, 11); + + result = _mm_packs_epi32(acc0, acc1); + _mm_storeu_si128((__m128i *)out, result); + out += 8; + + prev_interleaved = _mm_shuffle_epi32(result, _MM_SHUFFLE(3, 3, 3, 3)); + } +#elif HAS_NEON + int8x8_t inv = vld1_s8((int8_t *)in); + int16x8_t tblvec[2] = {vld1q_s16(tbl[0]), vld1q_s16(tbl[1])}; + int16x8_t invec[2] = {vreinterpretq_s16_s8(vcombine_s8(vtbl1_s8(inv, vget_low_s8(pos0)), + vtbl1_s8(inv, vget_high_s8(pos0)))), + vreinterpretq_s16_s8(vcombine_s8(vtbl1_s8(inv, vget_low_s8(pos1)), + vtbl1_s8(inv, vget_high_s8(pos1))))}; + int16x8_t shiftcount = vdupq_n_s16(shift - 12); // negative means right shift + int16x8_t tblvec1[8]; + + in += 8; + tblvec1[0] = vextq_s16(table_prefix, tblvec[1], 7); + invec[0] = vmulq_s16(invec[0], mult); + tblvec1[1] = vextq_s16(table_prefix, tblvec[1], 6); + invec[1] = vmulq_s16(invec[1], mult); + tblvec1[2] = vextq_s16(table_prefix, tblvec[1], 5); + tblvec1[3] = vextq_s16(table_prefix, tblvec[1], 4); + invec[0] = vandq_s16(invec[0], mask); + tblvec1[4] = vextq_s16(table_prefix, tblvec[1], 3); + invec[1] = vandq_s16(invec[1], mask); + tblvec1[5] = vextq_s16(table_prefix, tblvec[1], 2); + tblvec1[6] = vextq_s16(table_prefix, tblvec[1], 1); + invec[0] = vqshlq_s16(invec[0], shiftcount); + invec[1] = vqshlq_s16(invec[1], shiftcount); + tblvec1[7] = table_prefix; + for (i = 0; i < 2; i++) { + int32x4_t acc0; + int32x4_t acc1; + + acc1 = vmull_lane_s16(vget_high_s16(tblvec[0]), vget_high_s16(result), 2); + acc1 = vmlal_lane_s16(acc1, vget_high_s16(tblvec[1]), vget_high_s16(result), 3); + acc0 = vmull_lane_s16(vget_low_s16(tblvec[0]), vget_high_s16(result), 2); + acc0 = vmlal_lane_s16(acc0, vget_low_s16(tblvec[1]), vget_high_s16(result), 3); + + acc0 = vmlal_lane_s16(acc0, vget_low_s16(tblvec1[0]), vget_low_s16(invec[i]), 0); + acc0 = vmlal_lane_s16(acc0, vget_low_s16(tblvec1[1]), vget_low_s16(invec[i]), 1); + acc0 = vmlal_lane_s16(acc0, vget_low_s16(tblvec1[2]), vget_low_s16(invec[i]), 2); + acc0 = vmlal_lane_s16(acc0, vget_low_s16(tblvec1[3]), vget_low_s16(invec[i]), 3); + + acc1 = vmlal_lane_s16(acc1, vget_high_s16(tblvec1[0]), vget_low_s16(invec[i]), 0); + acc1 = vmlal_lane_s16(acc1, vget_high_s16(tblvec1[1]), vget_low_s16(invec[i]), 1); + acc1 = vmlal_lane_s16(acc1, vget_high_s16(tblvec1[2]), vget_low_s16(invec[i]), 2); + acc1 = vmlal_lane_s16(acc1, vget_high_s16(tblvec1[3]), vget_low_s16(invec[i]), 3); + acc1 = vmlal_lane_s16(acc1, vget_high_s16(tblvec1[4]), vget_high_s16(invec[i]), 0); + acc1 = vmlal_lane_s16(acc1, vget_high_s16(tblvec1[5]), vget_high_s16(invec[i]), 1); + acc1 = vmlal_lane_s16(acc1, vget_high_s16(tblvec1[6]), vget_high_s16(invec[i]), 2); + acc1 = vmlal_lane_s16(acc1, vget_high_s16(tblvec1[7]), vget_high_s16(invec[i]), 3); + + result = vcombine_s16(vqshrn_n_s32(acc0, 11), vqshrn_n_s32(acc1, 11)); + vst1q_s16(out, result); + out += 8; + } +#else + for (i = 0; i < 2; i++) { + int16_t ins[8]; + int16_t prev1 = out[-1]; + int16_t prev2 = out[-2]; + int j, k; + for (j = 0; j < 4; j++) { + ins[j * 2] = (((*in >> 4) << 28) >> 28) << shift; + ins[j * 2 + 1] = (((*in++ & 0xf) << 28) >> 28) << shift; + } + for (j = 0; j < 8; j++) { + int32_t acc = tbl[0][j] * prev2 + tbl[1][j] * prev1 + (ins[j] << 11); + for (k = 0; k < j; k++) { + acc += tbl[1][((j - k) - 1)] * ins[k]; + } + acc >>= 11; + *out++ = clamp16(acc); + } + } +#endif + nbytes -= 16 * sizeof(int16_t); + } + memcpy(state, out - 16, 16 * sizeof(int16_t)); +} + +void aResampleImpl(uint8_t flags, uint16_t pitch, RESAMPLE_STATE state) { + int16_t tmp[16]; + int16_t *in_initial = BUF_S16(rspa.in); + int16_t *in = in_initial; + int16_t *out = BUF_S16(rspa.out); + int nbytes = ROUND_UP_16(rspa.nbytes); + uint32_t pitch_accumulator; + int i; +#if !HAS_SSE41 && !HAS_NEON + int16_t *tbl; + int32_t sample; +#endif + if (flags & A_INIT) { + memset(tmp, 0, 5 * sizeof(int16_t)); + } else { + memcpy(tmp, state, 16 * sizeof(int16_t)); + } + if (flags & 2) { + memcpy(in - 8, tmp + 8, 8 * sizeof(int16_t)); + in -= tmp[5] / sizeof(int16_t); + } + in -= 4; + pitch_accumulator = (uint16_t)tmp[4]; + memcpy(in, tmp, 4 * sizeof(int16_t)); + +#if HAS_SSE41 + __m128i multiples = _mm_setr_epi16(0, 2, 4, 6, 8, 10, 12, 14); + __m128i pitchvec = _mm_set1_epi16((int16_t)pitch); + __m128i pitchvec_8_steps = _mm_set1_epi32((pitch << 1) * 8); + __m128i pitchacclo_vec = _mm_set1_epi32((uint16_t)pitch_accumulator); + __m128i pl = _mm_mullo_epi16(multiples, pitchvec); + __m128i ph = _mm_mulhi_epu16(multiples, pitchvec); + __m128i acc_a = _mm_add_epi32(_mm_unpacklo_epi16(pl, ph), pitchacclo_vec); + __m128i acc_b = _mm_add_epi32(_mm_unpackhi_epi16(pl, ph), pitchacclo_vec); + + do { + __m128i tbl_positions = _mm_srli_epi16(_mm_packus_epi32( + _mm_and_si128(acc_a, _mm_set1_epi32(0xffff)), + _mm_and_si128(acc_b, _mm_set1_epi32(0xffff))), 10); + + __m128i in_positions = _mm_packus_epi32(_mm_srli_epi32(acc_a, 16), _mm_srli_epi32(acc_b, 16)); + __m128i tbl_entries[4]; + __m128i samples[4]; + + /*for (i = 0; i < 4; i++) { + tbl_entries[i] = _mm_castpd_si128(_mm_loadh_pd(_mm_load_sd( + (const double *)resample_table[_mm_extract_epi16(tbl_positions, 2 * i)]), + (const double *)resample_table[_mm_extract_epi16(tbl_positions, 2 * i + 1)])); + samples[i] = _mm_castpd_si128(_mm_loadh_pd(_mm_load_sd( + (const double *)&in[_mm_extract_epi16(in_positions, 2 * i)]), + (const double *)&in[_mm_extract_epi16(in_positions, 2 * i + 1)])); + samples[i] = _mm_mulhrs_epi16(samples[i], tbl_entries[i]); + }*/ + tbl_entries[0] = LOADLH(resample_table[_mm_extract_epi16(tbl_positions, 0)], resample_table[_mm_extract_epi16(tbl_positions, 1)]); + tbl_entries[1] = LOADLH(resample_table[_mm_extract_epi16(tbl_positions, 2)], resample_table[_mm_extract_epi16(tbl_positions, 3)]); + tbl_entries[2] = LOADLH(resample_table[_mm_extract_epi16(tbl_positions, 4)], resample_table[_mm_extract_epi16(tbl_positions, 5)]); + tbl_entries[3] = LOADLH(resample_table[_mm_extract_epi16(tbl_positions, 6)], resample_table[_mm_extract_epi16(tbl_positions, 7)]); + samples[0] = LOADLH(&in[_mm_extract_epi16(in_positions, 0)], &in[_mm_extract_epi16(in_positions, 1)]); + samples[1] = LOADLH(&in[_mm_extract_epi16(in_positions, 2)], &in[_mm_extract_epi16(in_positions, 3)]); + samples[2] = LOADLH(&in[_mm_extract_epi16(in_positions, 4)], &in[_mm_extract_epi16(in_positions, 5)]); + samples[3] = LOADLH(&in[_mm_extract_epi16(in_positions, 6)], &in[_mm_extract_epi16(in_positions, 7)]); + samples[0] = _mm_mulhrs_epi16(samples[0], tbl_entries[0]); + samples[1] = _mm_mulhrs_epi16(samples[1], tbl_entries[1]); + samples[2] = _mm_mulhrs_epi16(samples[2], tbl_entries[2]); + samples[3] = _mm_mulhrs_epi16(samples[3], tbl_entries[3]); + + _mm_storeu_si128((__m128i *)out, _mm_hadds_epi16(_mm_hadds_epi16(samples[0], samples[1]), _mm_hadds_epi16(samples[2], samples[3]))); + + acc_a = _mm_add_epi32(acc_a, pitchvec_8_steps); + acc_b = _mm_add_epi32(acc_b, pitchvec_8_steps); + out += 8; + nbytes -= 8 * sizeof(int16_t); + } while (nbytes > 0); + in += (uint16_t)_mm_extract_epi16(acc_a, 1); + pitch_accumulator = (uint16_t)_mm_extract_epi16(acc_a, 0); +#elif HAS_NEON + static const uint16_t multiples_data[8] = {0, 2, 4, 6, 8, 10, 12, 14}; + uint16x8_t multiples = vld1q_u16(multiples_data); + uint32x4_t pitchvec_8_steps = vdupq_n_u32((pitch << 1) * 8); + uint32x4_t pitchacclo_vec = vdupq_n_u32((uint16_t)pitch_accumulator); + uint32x4_t acc_a = vmlal_n_u16(pitchacclo_vec, vget_low_u16(multiples), pitch); + uint32x4_t acc_b = vmlal_n_u16(pitchacclo_vec, vget_high_u16(multiples), pitch); + + do { + uint16x8x2_t unzipped = vuzpq_u16(vreinterpretq_u16_u32(acc_a), vreinterpretq_u16_u32(acc_b)); + uint16x8_t tbl_positions = vshrq_n_u16(unzipped.val[0], 10); + uint16x8_t in_positions = unzipped.val[1]; + int16x8_t tbl_entries[4]; + int16x8_t samples[4]; + int16x8x2_t unzipped1; + int16x8x2_t unzipped2; + + tbl_entries[0] = vcombine_s16(vld1_s16(resample_table[vgetq_lane_u16(tbl_positions, 0)]), vld1_s16(resample_table[vgetq_lane_u16(tbl_positions, 1)])); + tbl_entries[1] = vcombine_s16(vld1_s16(resample_table[vgetq_lane_u16(tbl_positions, 2)]), vld1_s16(resample_table[vgetq_lane_u16(tbl_positions, 3)])); + tbl_entries[2] = vcombine_s16(vld1_s16(resample_table[vgetq_lane_u16(tbl_positions, 4)]), vld1_s16(resample_table[vgetq_lane_u16(tbl_positions, 5)])); + tbl_entries[3] = vcombine_s16(vld1_s16(resample_table[vgetq_lane_u16(tbl_positions, 6)]), vld1_s16(resample_table[vgetq_lane_u16(tbl_positions, 7)])); + samples[0] = vcombine_s16(vld1_s16(&in[vgetq_lane_u16(in_positions, 0)]), vld1_s16(&in[vgetq_lane_u16(in_positions, 1)])); + samples[1] = vcombine_s16(vld1_s16(&in[vgetq_lane_u16(in_positions, 2)]), vld1_s16(&in[vgetq_lane_u16(in_positions, 3)])); + samples[2] = vcombine_s16(vld1_s16(&in[vgetq_lane_u16(in_positions, 4)]), vld1_s16(&in[vgetq_lane_u16(in_positions, 5)])); + samples[3] = vcombine_s16(vld1_s16(&in[vgetq_lane_u16(in_positions, 6)]), vld1_s16(&in[vgetq_lane_u16(in_positions, 7)])); + samples[0] = vqrdmulhq_s16(samples[0], tbl_entries[0]); + samples[1] = vqrdmulhq_s16(samples[1], tbl_entries[1]); + samples[2] = vqrdmulhq_s16(samples[2], tbl_entries[2]); + samples[3] = vqrdmulhq_s16(samples[3], tbl_entries[3]); + + unzipped1 = vuzpq_s16(samples[0], samples[1]); + unzipped2 = vuzpq_s16(samples[2], samples[3]); + samples[0] = vqaddq_s16(unzipped1.val[0], unzipped1.val[1]); + samples[1] = vqaddq_s16(unzipped2.val[0], unzipped2.val[1]); + unzipped1 = vuzpq_s16(samples[0], samples[1]); + samples[0] = vqaddq_s16(unzipped1.val[0], unzipped1.val[1]); + + vst1q_s16(out, samples[0]); + + acc_a = vaddq_u32(acc_a, pitchvec_8_steps); + acc_b = vaddq_u32(acc_b, pitchvec_8_steps); + out += 8; + nbytes -= 8 * sizeof(int16_t); + } while (nbytes > 0); + in += vgetq_lane_u16(vreinterpretq_u16_u32(acc_a), 1); + pitch_accumulator = vgetq_lane_u16(vreinterpretq_u16_u32(acc_a), 0); +#else + do { + for (i = 0; i < 8; i++) { + tbl = resample_table[pitch_accumulator * 64 >> 16]; + sample = ((in[0] * tbl[0] + 0x4000) >> 15) + + ((in[1] * tbl[1] + 0x4000) >> 15) + + ((in[2] * tbl[2] + 0x4000) >> 15) + + ((in[3] * tbl[3] + 0x4000) >> 15); + *out++ = clamp16(sample); + + pitch_accumulator += (pitch << 1); + in += pitch_accumulator >> 16; + pitch_accumulator %= 0x10000; + } + nbytes -= 8 * sizeof(int16_t); + } while (nbytes > 0); +#endif + + state[4] = (int16_t)pitch_accumulator; + memcpy(state, in, 4 * sizeof(int16_t)); + i = (in - in_initial + 4) & 7; + in -= i; + if (i != 0) { + i = -8 - i; + } + state[5] = i; + memcpy(state + 8, in, 8 * sizeof(int16_t)); +} + +#ifdef NEW_AUDIO_UCODE +void aEnvSetup1Impl(uint8_t initial_vol_wet, uint16_t rate_wet, uint16_t rate_left, uint16_t rate_right) { + rspa.vol_wet = (uint16_t)(initial_vol_wet << 8); + rspa.rate_wet = rate_wet; + rspa.rate[0] = rate_left; + rspa.rate[1] = rate_right; +} + +void aEnvSetup2Impl(uint16_t initial_vol_left, uint16_t initial_vol_right) { + rspa.vol[0] = initial_vol_left; + rspa.vol[1] = initial_vol_right; +} + +void aEnvMixerImpl(uint16_t in_addr, uint16_t n_samples, bool swap_reverb, + bool neg_left, bool neg_right, + uint16_t dry_left_addr, uint16_t dry_right_addr, + uint16_t wet_left_addr, uint16_t wet_right_addr) +{ + int16_t *in = BUF_S16(in_addr); + int16_t *dry[2] = {BUF_S16(dry_left_addr), BUF_S16(dry_right_addr)}; + int16_t *wet[2] = {BUF_S16(wet_left_addr), BUF_S16(wet_right_addr)}; + int16_t negs[2] = {neg_left ? -1 : 0, neg_right ? -1 : 0}; + int swapped[2] = {swap_reverb ? 1 : 0, swap_reverb ? 0 : 1}; + int n = ROUND_UP_16(n_samples); + + uint16_t vols[2] = {rspa.vol[0], rspa.vol[1]}; + uint16_t rates[2] = {rspa.rate[0], rspa.rate[1]}; + uint16_t vol_wet = rspa.vol_wet; + uint16_t rate_wet = rspa.rate_wet; + + do { + for (int i = 0; i < 8; i++) { + int16_t samples[2] = {*in, *in}; in++; + for (int j = 0; j < 2; j++) { + samples[j] = (samples[j] * vols[j] >> 16) ^ negs[j]; + *dry[j] = clamp16(*dry[j] + samples[j]); dry[j]++; + *wet[j] = clamp16(*wet[j] + (samples[swapped[j]] * vol_wet >> 16)); wet[j]++; + } + } + vols[0] += rates[0]; + vols[1] += rates[1]; + vol_wet += rate_wet; + + n -= 8; + } while (n > 0); +} +#else +void aEnvMixerImpl(uint8_t flags, ENVMIX_STATE state) { + int16_t *in = BUF_S16(rspa.in); + int16_t *dry[2] = {BUF_S16(rspa.out), BUF_S16(rspa.dry_right)}; + int16_t *wet[2] = {BUF_S16(rspa.wet_left), BUF_S16(rspa.wet_right)}; + int nbytes = ROUND_UP_16(rspa.nbytes); + +#if HAS_SSE41 + __m128 vols[2][2]; + __m128i dry_factor; + __m128i wet_factor; + __m128 target[2]; + __m128 rate[2]; + __m128i in_loaded; + __m128i vol_s16; + bool increasing[2]; + + int c; + + if (flags & A_INIT) { + float vol_init[2] = {rspa.vol[0], rspa.vol[1]}; + float rate_float[2] = {(float)rspa.rate[0] * (1.0f / 65536.0f), (float)rspa.rate[1] * (1.0f / 65536.0f)}; + float step_diff[2] = {vol_init[0] * (rate_float[0] - 1.0f), vol_init[1] * (rate_float[1] - 1.0f)}; + + for (c = 0; c < 2; c++) { + vols[c][0] = _mm_add_ps( + _mm_set_ps1(vol_init[c]), + _mm_mul_ps(_mm_set1_ps(step_diff[c]), _mm_setr_ps(1.0f / 8.0f, 2.0f / 8.0f, 3.0f / 8.0f, 4.0f / 8.0f))); + vols[c][1] = _mm_add_ps( + _mm_set_ps1(vol_init[c]), + _mm_mul_ps(_mm_set1_ps(step_diff[c]), _mm_setr_ps(5.0f / 8.0f, 6.0f / 8.0f, 7.0f / 8.0f, 8.0f / 8.0f))); + + increasing[c] = rate_float[c] >= 1.0f; + target[c] = _mm_set1_ps(rspa.target[c]); + rate[c] = _mm_set1_ps(rate_float[c]); + } + + dry_factor = _mm_set1_epi16(rspa.vol_dry); + wet_factor = _mm_set1_epi16(rspa.vol_wet); + + memcpy(state + 32, &rate_float[0], 4); + memcpy(state + 34, &rate_float[1], 4); + state[36] = rspa.target[0]; + state[37] = rspa.target[1]; + state[38] = rspa.vol_dry; + state[39] = rspa.vol_wet; + } else { + float floats[2]; + vols[0][0] = _mm_loadu_ps((const float *)state); + vols[0][1] = _mm_loadu_ps((const float *)(state + 8)); + vols[1][0] = _mm_loadu_ps((const float *)(state + 16)); + vols[1][1] = _mm_loadu_ps((const float *)(state + 24)); + memcpy(floats, state + 32, 8); + rate[0] = _mm_set1_ps(floats[0]); + rate[1] = _mm_set1_ps(floats[1]); + increasing[0] = floats[0] >= 1.0f; + increasing[1] = floats[1] >= 1.0f; + target[0] = _mm_set1_ps(state[36]); + target[1] = _mm_set1_ps(state[37]); + dry_factor = _mm_set1_epi16(state[38]); + wet_factor = _mm_set1_epi16(state[39]); + } + do { + in_loaded = _mm_loadu_si128((const __m128i *)in); + in += 8; + for (c = 0; c < 2; c++) { + if (increasing[c]) { + vols[c][0] = _mm_min_ps(vols[c][0], target[c]); + vols[c][1] = _mm_min_ps(vols[c][1], target[c]); + } else { + vols[c][0] = _mm_max_ps(vols[c][0], target[c]); + vols[c][1] = _mm_max_ps(vols[c][1], target[c]); + } + + vol_s16 = _mm_packs_epi32(_mm_cvtps_epi32(vols[c][0]), _mm_cvtps_epi32(vols[c][1])); + _mm_storeu_si128((__m128i *)dry[c], + _mm_adds_epi16( + _mm_loadu_si128((const __m128i *)dry[c]), + _mm_mulhrs_epi16(in_loaded, _mm_mulhrs_epi16(vol_s16, dry_factor)))); + dry[c] += 8; + + if (flags & A_AUX) { + _mm_storeu_si128((__m128i *)wet[c], + _mm_adds_epi16( + _mm_loadu_si128((const __m128i *)wet[c]), + _mm_mulhrs_epi16(in_loaded, _mm_mulhrs_epi16(vol_s16, wet_factor)))); + wet[c] += 8; + } + + vols[c][0] = _mm_mul_ps(vols[c][0], rate[c]); + vols[c][1] = _mm_mul_ps(vols[c][1], rate[c]); + } + + nbytes -= 8 * sizeof(int16_t); + } while (nbytes > 0); + + _mm_storeu_ps((float *)state, vols[0][0]); + _mm_storeu_ps((float *)(state + 8), vols[0][1]); + _mm_storeu_ps((float *)(state + 16), vols[1][0]); + _mm_storeu_ps((float *)(state + 24), vols[1][1]); +#elif HAS_NEON + float32x4_t vols[2][2]; + int16_t dry_factor; + int16_t wet_factor; + float32x4_t target[2]; + float rate[2]; + int16x8_t in_loaded; + int16x8_t vol_s16; + bool increasing[2]; + + int c; + + if (flags & A_INIT) { + float vol_init[2] = {rspa.vol[0], rspa.vol[1]}; + float rate_float[2] = {(float)rspa.rate[0] * (1.0f / 65536.0f), (float)rspa.rate[1] * (1.0f / 65536.0f)}; + float step_diff[2] = {vol_init[0] * (rate_float[0] - 1.0f), vol_init[1] * (rate_float[1] - 1.0f)}; + static const float step_dividers_data[2][4] = {{1.0f / 8.0f, 2.0f / 8.0f, 3.0f / 8.0f, 4.0f / 8.0f}, + {5.0f / 8.0f, 6.0f / 8.0f, 7.0f / 8.0f, 8.0f / 8.0f}}; + float32x4_t step_dividers[2] = {vld1q_f32(step_dividers_data[0]), vld1q_f32(step_dividers_data[1])}; + + for (c = 0; c < 2; c++) { + vols[c][0] = vaddq_f32(vdupq_n_f32(vol_init[c]), vmulq_n_f32(step_dividers[0], step_diff[c])); + vols[c][1] = vaddq_f32(vdupq_n_f32(vol_init[c]), vmulq_n_f32(step_dividers[1], step_diff[c])); + increasing[c] = rate_float[c] >= 1.0f; + target[c] = vdupq_n_f32(rspa.target[c]); + rate[c] = rate_float[c]; + } + + dry_factor = rspa.vol_dry; + wet_factor = rspa.vol_wet; + + memcpy(state + 32, &rate_float[0], 4); + memcpy(state + 34, &rate_float[1], 4); + state[36] = rspa.target[0]; + state[37] = rspa.target[1]; + state[38] = rspa.vol_dry; + state[39] = rspa.vol_wet; + } else { + vols[0][0] = vreinterpretq_f32_s16(vld1q_s16(state)); + vols[0][1] = vreinterpretq_f32_s16(vld1q_s16(state + 8)); + vols[1][0] = vreinterpretq_f32_s16(vld1q_s16(state + 16)); + vols[1][1] = vreinterpretq_f32_s16(vld1q_s16(state + 24)); + memcpy(&rate[0], state + 32, 4); + memcpy(&rate[1], state + 34, 4); + increasing[0] = rate[0] >= 1.0f; + increasing[1] = rate[1] >= 1.0f; + target[0] = vdupq_n_f32(state[36]); + target[1] = vdupq_n_f32(state[37]); + dry_factor = state[38]; + wet_factor = state[39]; + } + + do { + in_loaded = vld1q_s16(in); + in += 8; + for (c = 0; c < 2; c++) { + if (increasing[c]) { + vols[c][0] = vminq_f32(vols[c][0], target[c]); + vols[c][1] = vminq_f32(vols[c][1], target[c]); + } else { + vols[c][0] = vmaxq_f32(vols[c][0], target[c]); + vols[c][1] = vmaxq_f32(vols[c][1], target[c]); + } + + vol_s16 = vcombine_s16(vqmovn_s32(vcvtq_s32_f32(vols[c][0])), vqmovn_s32(vcvtq_s32_f32(vols[c][1]))); + vst1q_s16(dry[c], vqaddq_s16(vld1q_s16(dry[c]), vqrdmulhq_s16(in_loaded, vqrdmulhq_n_s16(vol_s16, dry_factor)))); + dry[c] += 8; + if (flags & A_AUX) { + vst1q_s16(wet[c], vqaddq_s16(vld1q_s16(wet[c]), vqrdmulhq_s16(in_loaded, vqrdmulhq_n_s16(vol_s16, wet_factor)))); + wet[c] += 8; + } + vols[c][0] = vmulq_n_f32(vols[c][0], rate[c]); + vols[c][1] = vmulq_n_f32(vols[c][1], rate[c]); + } + + nbytes -= 8 * sizeof(int16_t); + } while (nbytes > 0); + + vst1q_s16(state, vreinterpretq_s16_f32(vols[0][0])); + vst1q_s16(state + 8, vreinterpretq_s16_f32(vols[0][1])); + vst1q_s16(state + 16, vreinterpretq_s16_f32(vols[1][0])); + vst1q_s16(state + 24, vreinterpretq_s16_f32(vols[1][1])); +#else + int16_t target[2]; + int32_t rate[2]; + int16_t vol_dry, vol_wet; + + int32_t step_diff[2]; + int32_t vols[2][8]; + + int c, i; + + if (flags & A_INIT) { + target[0] = rspa.target[0]; + target[1] = rspa.target[1]; + rate[0] = rspa.rate[0]; + rate[1] = rspa.rate[1]; + vol_dry = rspa.vol_dry; + vol_wet = rspa.vol_wet; + step_diff[0] = rspa.vol[0] * (rate[0] - 0x10000) / 8; + step_diff[1] = rspa.vol[0] * (rate[1] - 0x10000) / 8; + + for (i = 0; i < 8; i++) { + vols[0][i] = clamp32((int64_t)(rspa.vol[0] << 16) + step_diff[0] * (i + 1)); + vols[1][i] = clamp32((int64_t)(rspa.vol[1] << 16) + step_diff[1] * (i + 1)); + } + } else { + memcpy(vols[0], state, 32); + memcpy(vols[1], state + 16, 32); + target[0] = state[32]; + target[1] = state[35]; + rate[0] = (state[33] << 16) | (uint16_t)state[34]; + rate[1] = (state[36] << 16) | (uint16_t)state[37]; + vol_dry = state[38]; + vol_wet = state[39]; + } + + do { + for (c = 0; c < 2; c++) { + for (i = 0; i < 8; i++) { + if ((rate[c] >> 16) > 0) { + // Increasing volume + if ((vols[c][i] >> 16) > target[c]) { + vols[c][i] = target[c] << 16; + } + } else { + // Decreasing volume + if ((vols[c][i] >> 16) < target[c]) { + vols[c][i] = target[c] << 16; + } + } + dry[c][i] = clamp16((dry[c][i] * 0x7fff + in[i] * (((vols[c][i] >> 16) * vol_dry + 0x4000) >> 15) + 0x4000) >> 15); + if (flags & A_AUX) { + wet[c][i] = clamp16((wet[c][i] * 0x7fff + in[i] * (((vols[c][i] >> 16) * vol_wet + 0x4000) >> 15) + 0x4000) >> 15); + } + vols[c][i] = clamp32((int64_t)vols[c][i] * rate[c] >> 16); + } + + dry[c] += 8; + if (flags & A_AUX) { + wet[c] += 8; + } + } + + nbytes -= 16; + in += 8; + } while (nbytes > 0); + + memcpy(state, vols[0], 32); + memcpy(state + 16, vols[1], 32); + state[32] = target[0]; + state[35] = target[1]; + state[33] = (int16_t)(rate[0] >> 16); + state[34] = (int16_t)rate[0]; + state[36] = (int16_t)(rate[1] >> 16); + state[37] = (int16_t)rate[1]; + state[38] = vol_dry; + state[39] = vol_wet; +#endif +} +#endif + +#ifdef NEW_AUDIO_UCODE +void aMixImpl(int16_t gain, uint16_t in_addr, uint16_t out_addr, uint16_t count) { + int nbytes = ROUND_UP_32(ROUND_DOWN_16(count)); +#else +void aMixImpl(int16_t gain, uint16_t in_addr, uint16_t out_addr) { + int nbytes = ROUND_UP_32(rspa.nbytes); +#endif + int16_t *in = BUF_S16(in_addr); + int16_t *out = BUF_S16(out_addr); +#if HAS_SSE41 + __m128i gain_vec = _mm_set1_epi16(gain); +#elif !HAS_NEON + int i; + int32_t sample; +#endif + +#if !HAS_NEON + if (gain == -0x8000) { + while (nbytes > 0) { +#if HAS_SSE41 + __m128i out1, out2, in1, in2; + out1 = _mm_loadu_si128((const __m128i *)out); + out2 = _mm_loadu_si128((const __m128i *)(out + 8)); + in1 = _mm_loadu_si128((const __m128i *)in); + in2 = _mm_loadu_si128((const __m128i *)(in + 8)); + + out1 = _mm_subs_epi16(out1, in1); + out2 = _mm_subs_epi16(out2, in2); + + _mm_storeu_si128((__m128i *)out, out1); + _mm_storeu_si128((__m128i *)(out + 8), out2); + + out += 16; + in += 16; +#else + for (i = 0; i < 16; i++) { + sample = *out - *in++; + *out++ = clamp16(sample); + } +#endif + + nbytes -= 16 * sizeof(int16_t); + } + } +#endif + + while (nbytes > 0) { +#if HAS_SSE41 + __m128i out1, out2, in1, in2; + out1 = _mm_loadu_si128((const __m128i *)out); + out2 = _mm_loadu_si128((const __m128i *)(out + 8)); + in1 = _mm_loadu_si128((const __m128i *)in); + in2 = _mm_loadu_si128((const __m128i *)(in + 8)); + + out1 = _mm_adds_epi16(out1, _mm_mulhrs_epi16(in1, gain_vec)); + out2 = _mm_adds_epi16(out2, _mm_mulhrs_epi16(in2, gain_vec)); + + _mm_storeu_si128((__m128i *)out, out1); + _mm_storeu_si128((__m128i *)(out + 8), out2); + + out += 16; + in += 16; +#elif HAS_NEON + int16x8_t out1, out2, in1, in2; + out1 = vld1q_s16(out); + out2 = vld1q_s16(out + 8); + in1 = vld1q_s16(in); + in2 = vld1q_s16(in + 8); + + out1 = vqaddq_s16(out1, vqrdmulhq_n_s16(in1, gain)); + out2 = vqaddq_s16(out2, vqrdmulhq_n_s16(in2, gain)); + + vst1q_s16(out, out1); + vst1q_s16(out + 8, out2); + + out += 16; + in += 16; +#else + for (i = 0; i < 16; i++) { + sample = ((*out * 0x7fff + *in++ * gain) + 0x4000) >> 15; + *out++ = clamp16(sample); + } +#endif + + nbytes -= 16 * sizeof(int16_t); + } +} + +#ifdef NEW_AUDIO_UCODE +void aS8DecImpl(uint8_t flags, ADPCM_STATE state) { + uint8_t *in = BUF_U8(rspa.in); + int16_t *out = BUF_S16(rspa.out); + int nbytes = ROUND_UP_32(rspa.nbytes); + if (flags & A_INIT) { + memset(out, 0, 16 * sizeof(int16_t)); + } else if (flags & A_LOOP) { + memcpy(out, rspa.adpcm_loop_state, 16 * sizeof(int16_t)); + } else { + memcpy(out, state, 16 * sizeof(int16_t)); + } + out += 16; + + while (nbytes > 0) { + *out++ = (int16_t)(*in++ << 8); + *out++ = (int16_t)(*in++ << 8); + *out++ = (int16_t)(*in++ << 8); + *out++ = (int16_t)(*in++ << 8); + *out++ = (int16_t)(*in++ << 8); + *out++ = (int16_t)(*in++ << 8); + *out++ = (int16_t)(*in++ << 8); + *out++ = (int16_t)(*in++ << 8); + *out++ = (int16_t)(*in++ << 8); + *out++ = (int16_t)(*in++ << 8); + *out++ = (int16_t)(*in++ << 8); + *out++ = (int16_t)(*in++ << 8); + *out++ = (int16_t)(*in++ << 8); + *out++ = (int16_t)(*in++ << 8); + *out++ = (int16_t)(*in++ << 8); + *out++ = (int16_t)(*in++ << 8); + + nbytes -= 16 * sizeof(int16_t); + } + + memcpy(state, out - 16, 16 * sizeof(int16_t)); +} + +void aAddMixerImpl(uint16_t in_addr, uint16_t out_addr, uint16_t count) { + int16_t *in = BUF_S16(in_addr); + int16_t *out = BUF_S16(out_addr); + int nbytes = ROUND_UP_64(ROUND_DOWN_16(count)); + + do { + *out = clamp16(*out + *in++); out++; + *out = clamp16(*out + *in++); out++; + *out = clamp16(*out + *in++); out++; + *out = clamp16(*out + *in++); out++; + *out = clamp16(*out + *in++); out++; + *out = clamp16(*out + *in++); out++; + *out = clamp16(*out + *in++); out++; + *out = clamp16(*out + *in++); out++; + *out = clamp16(*out + *in++); out++; + *out = clamp16(*out + *in++); out++; + *out = clamp16(*out + *in++); out++; + *out = clamp16(*out + *in++); out++; + *out = clamp16(*out + *in++); out++; + *out = clamp16(*out + *in++); out++; + *out = clamp16(*out + *in++); out++; + *out = clamp16(*out + *in++); out++; + + nbytes -= 16 * sizeof(int16_t); + } while (nbytes > 0); +} + +void aDuplicateImpl(uint16_t in_addr, uint16_t out_addr, uint16_t count) { + uint8_t *in = BUF_U8(in_addr); + uint8_t *out = BUF_U8(out_addr); + + uint8_t tmp[128]; + memcpy(tmp, in, 128); + do { + memcpy(out, tmp, 128); + out += 128; + } while (count-- > 0); +} + +void aDMEMMove2Impl(uint8_t t, uint16_t in_addr, uint16_t out_addr, uint16_t count) { + uint8_t *in = BUF_U8(in_addr); + uint8_t *out = BUF_U8(out_addr); + int nbytes = ROUND_UP_32(count); + + do { + memmove(out, in, nbytes); + in += nbytes; + out += nbytes; + } while (t-- > 0); +} + +void aResampleZohImpl(uint16_t pitch, uint16_t start_fract) { + int16_t *in = BUF_S16(rspa.in); + int16_t *out = BUF_S16(rspa.out); + int nbytes = ROUND_UP_8(rspa.nbytes); + uint32_t pos = start_fract; + uint32_t pitch_add = pitch << 2; + + do { + *out++ = in[pos >> 17]; pos += pitch_add; + *out++ = in[pos >> 17]; pos += pitch_add; + *out++ = in[pos >> 17]; pos += pitch_add; + *out++ = in[pos >> 17]; pos += pitch_add; + + nbytes -= 4 * sizeof(int16_t); + } while (nbytes > 0); +} + +void aDownsampleHalfImpl(uint16_t n_samples, uint16_t in_addr, uint16_t out_addr) { + int16_t *in = BUF_S16(in_addr); + int16_t *out = BUF_S16(out_addr); + int n = ROUND_UP_8(n_samples); + + do { + *out++ = *in++; in++; + *out++ = *in++; in++; + *out++ = *in++; in++; + *out++ = *in++; in++; + *out++ = *in++; in++; + *out++ = *in++; in++; + *out++ = *in++; in++; + *out++ = *in++; in++; + + n -= 8; + } while (n > 0); +} + +void aFilterImpl(uint8_t flags, uint16_t count_or_buf, int16_t state_or_filter[8]) { + if (flags > A_INIT) { + rspa.filter_count = ROUND_UP_16(count_or_buf); + memcpy(rspa.filter, state_or_filter, sizeof(rspa.filter)); + } else { + int16_t tmp[16]; + int count = rspa.filter_count; + int16_t *buf = BUF_S16(count_or_buf); + + if (flags == A_INIT) { + memset(tmp, 0, 8 * sizeof(int16_t)); + } else { + memcpy(tmp, state_or_filter, 8 * sizeof(int16_t)); + } + + do { + memcpy(tmp + 8, buf, 8 * sizeof(int16_t)); + for (int i = 0; i < 8; i++) { + int64_t sample = 0x4000; // round term + int16_t in = tmp[8 + i]; + for (int j = 1; j <= 8; j++) { + sample += in * tmp[8 + i - j]; + } + buf[i] = clamp16((int32_t)(sample >> 15)); + } + memcpy(tmp, tmp + 8, 8 * sizeof(int16_t)); + + buf += 8; + count -= 8 * sizeof(int16_t); + } while (count > 0); + + memcpy(state_or_filter, tmp, 8 * sizeof(int16_t)); + } +} + +void aHiLoGainImpl(uint8_t g, uint16_t count, uint16_t addr) { + int16_t *samples = BUF_S16(addr); + int nbytes = ROUND_UP_32(count); + + do { + *samples = clamp16((*samples * g) >> 4); samples++; + *samples = clamp16((*samples * g) >> 4); samples++; + *samples = clamp16((*samples * g) >> 4); samples++; + *samples = clamp16((*samples * g) >> 4); samples++; + *samples = clamp16((*samples * g) >> 4); samples++; + *samples = clamp16((*samples * g) >> 4); samples++; + *samples = clamp16((*samples * g) >> 4); samples++; + *samples = clamp16((*samples * g) >> 4); samples++; + + nbytes -= 8; + } while (nbytes > 0); +} + +void aUnknown25Impl(uint8_t f, uint16_t count, uint16_t out_addr, uint16_t in_addr) { + int nbytes = ROUND_UP_64(count); + int16_t *in = BUF_S16(in_addr + f); + int16_t *out = BUF_S16(out_addr); + int16_t tbl[32]; + + memcpy(tbl, in, 32 * sizeof(int16_t)); + do { + for (int i = 0; i < 32; i++) { + out[i] = clamp16(out[i] * tbl[i]); + } + out += 32; + nbytes -= 32 * sizeof(int16_t); + } while (nbytes > 0); +} +#endif diff --git a/src/decomp/pc/mixer.h b/src/decomp/pc/mixer.h new file mode 100644 index 0000000..5debc7f --- /dev/null +++ b/src/decomp/pc/mixer.h @@ -0,0 +1,117 @@ +#ifndef MIXER_H +#define MIXER_H + +#include +#include +#include + +#ifdef VERSION_SH +#define NEW_AUDIO_UCODE +#endif + +#undef aSegment +#undef aClearBuffer +#undef aSetBuffer +#undef aLoadBuffer +#undef aSaveBuffer +#undef aDMEMMove +#undef aMix +#undef aEnvMixer +#undef aResample +#undef aInterleave +#undef aSetVolume +#undef aSetVolume32 +#undef aSetLoop +#undef aLoadADPCM +#undef aADPCMdec +#undef aS8Dec +#undef aAddMixer +#undef aDuplicate +#undef aDMEMMove2 +#undef aResampleZoh +#undef aDownsampleHalf +#undef aEnvSetup1 +#undef aEnvSetup2 +#undef aFilter +#undef aHiLoGain +#undef aUnknown25 + +void aClearBufferImpl(uint16_t addr, int nbytes); +void aLoadADPCMImpl(int num_entries_times_16, const int16_t *book_source_addr); +void aSetBufferImpl(uint8_t flags, uint16_t in, uint16_t out, uint16_t nbytes); +void aDMEMMoveImpl(uint16_t in_addr, uint16_t out_addr, int nbytes); +void aSetLoopImpl(ADPCM_STATE *adpcm_loop_state); +void aADPCMdecImpl(uint8_t flags, ADPCM_STATE state); +void aResampleImpl(uint8_t flags, uint16_t pitch, RESAMPLE_STATE state); + +#ifndef NEW_AUDIO_UCODE +void aSetVolumeImpl(uint8_t flags, int16_t v, int16_t t, int16_t r); +void aLoadBufferImpl(const void *source_addr); +void aSaveBufferImpl(int16_t *dest_addr); +void aInterleaveImpl(uint16_t left, uint16_t right); +void aMixImpl(int16_t gain, uint16_t in_addr, uint16_t out_addr); +void aEnvMixerImpl(uint8_t flags, ENVMIX_STATE state); +#else +void aLoadBufferImpl(const void *source_addr, uint16_t dest_addr, uint16_t nbytes); +void aSaveBufferImpl(uint16_t source_addr, int16_t *dest_addr, uint16_t nbytes); +void aInterleaveImpl(uint16_t dest, uint16_t left, uint16_t right, uint16_t c); +void aMixImpl(int16_t gain, uint16_t in_addr, uint16_t out_addr, uint16_t count); +void aEnvSetup1Impl(uint8_t initial_vol_wet, uint16_t rate_wet, uint16_t rate_left, uint16_t rate_right); +void aEnvSetup2Impl(uint16_t initial_vol_left, uint16_t initial_vol_right); +void aEnvMixerImpl(uint16_t in_addr, uint16_t n_samples, bool swap_reverb, + bool neg_left, bool neg_right, + uint16_t dry_left_addr, uint16_t dry_right_addr, + uint16_t wet_left_addr, uint16_t wet_right_addr); +void aS8DecImpl(uint8_t flags, ADPCM_STATE state); +void aAddMixerImpl(uint16_t in_addr, uint16_t out_addr, uint16_t count); +void aDuplicateImpl(uint16_t in_addr, uint16_t out_addr, uint16_t count); +void aDMEMMove2Impl(uint8_t t, uint16_t in_addr, uint16_t out_addr, uint16_t count); +void aResampleZohImpl(uint16_t pitch, uint16_t start_fract); +void aDownsampleHalfImpl(uint16_t n_samples, uint16_t in_addr, uint16_t out_addr); +void aFilterImpl(uint8_t flags, uint16_t count_or_buf, int16_t state_or_filter[8]); +void aHiLoGainImpl(uint8_t g, uint16_t count, uint16_t addr); +void aUnknown25Impl(uint8_t f, uint16_t count, uint16_t out_addr, uint16_t in_addr); +#endif + +#define aSegment(pkt, s, b) do { } while(0) +#define aClearBuffer(pkt, d, c) aClearBufferImpl(d, c) +#define aLoadADPCM(pkt, c, d) aLoadADPCMImpl(c, d) +#define aSetBuffer(pkt, f, i, o, c) aSetBufferImpl(f, i, o, c) +#define aDMEMMove(pkt, i, o, c) aDMEMMoveImpl(i, o, c) +#define aSetLoop(pkt, a) aSetLoopImpl(a) +#define aADPCMdec(pkt, f, s) aADPCMdecImpl(f, s) +#define aResample(pkt, f, p, s) aResampleImpl(f, p, s) + +#ifndef NEW_AUDIO_UCODE +#define aSetVolume(pkt, f, v, t, r) aSetVolumeImpl(f, v, t, r) +#define aSetVolume32(pkt, f, v, tr) aSetVolume(pkt, f, v, (int16_t)((tr) >> 16), (int16_t)(tr)) +#define aLoadBuffer(pkt, s) aLoadBufferImpl(s) +#define aSaveBuffer(pkt, s) aSaveBufferImpl(s) +#define aInterleave(pkt, l, r) aInterleaveImpl(l, r) +#define aMix(pkt, f, g, i, o) aMixImpl(g, i, o) +#define aEnvMixer(pkt, f, s) aEnvMixerImpl(f, s) +#else +#define aLoadBuffer(pkt, s, d, c) aLoadBufferImpl(s, d, c) +#define aSaveBuffer(pkt, s, d, c) aSaveBufferImpl(s, d, c) +#define aInterleave(pkt, o, l, r, c) aInterleaveImpl(o, l, r, c) +#define aMix(pkt, g, i, o, c) aMixImpl(g, i, o, c) +#define aEnvSetup1(pkt, initialVolReverb, rampReverb, rampLeft, rampRight) \ + aEnvSetup1Impl(initialVolReverb, rampReverb, rampLeft, rampRight) +#define aEnvSetup2(pkt, initialVolLeft, initialVolRight) \ + aEnvSetup2Impl(initialVolLeft, initialVolRight) +#define aEnvMixer(pkt, inBuf, nSamples, swapReverb, negLeft, negRight, \ + dryLeft, dryRight, wetLeft, wetRight) \ + aEnvMixerImpl(inBuf, nSamples, swapReverb, negLeft, negRight, \ + dryLeft, dryRight, wetLeft, wetRight) +#define aS8Dec(pkt, f, s) aS8DecImpl(f, s) +#define aAddMixer(pkt, s, d, c) aAddMixerImpl(s, d, c) +#define aDuplicate(pkt, s, d, c) aDuplicateImpl(s, d, c) +#define aDMEMMove2(pkt, t, i, o, c) aDMEMMove2Impl(t, i, o, c) +#define aResampleZoh(pkt, pitch, startFract) aResampleZohImpl(pitch, startFract) +#define aDownsampleHalf(pkt, nSamples, i, o) aDownsampleHalfImpl(nSamples, i, o) +#define aFilter(pkt, f, countOrBuf, addr) aFilterImpl(f, countOrBuf, addr) +#define aHiLoGain(pkt, g, buflen, i) aHiLoGainImpl(g, buflen, i) +#define aUnknown25(pkt, f, c, o, i) aUnknown25Impl(f, c, o, i) +#endif + +#endif diff --git a/src/decomp/pc/ultra_reimplementation.c b/src/decomp/pc/ultra_reimplementation.c new file mode 100644 index 0000000..4957cce --- /dev/null +++ b/src/decomp/pc/ultra_reimplementation.c @@ -0,0 +1,216 @@ +#include +#include +#include "libultra_internal.h" +#include + +#ifdef TARGET_WEB +#include +#endif + +extern OSMgrArgs piMgrArgs; + +u64 osClockRate = 62500000; + +s32 osPiStartDma(UNUSED OSIoMesg *mb, UNUSED s32 priority, UNUSED s32 direction, + uintptr_t devAddr, void *vAddr, size_t nbytes, + UNUSED OSMesgQueue *mq) { + memcpy(vAddr, (const void *) devAddr, nbytes); + return 0; +} + +void osCreateMesgQueue(OSMesgQueue *mq, OSMesg *msgBuf, s32 count) { + mq->validCount = 0; + mq->first = 0; + mq->msgCount = count; + mq->msg = msgBuf; + return; +} + +void osSetEventMesg(UNUSED OSEvent e, UNUSED OSMesgQueue *mq, UNUSED OSMesg msg) { +} +s32 osJamMesg(UNUSED OSMesgQueue *mq, UNUSED OSMesg msg, UNUSED s32 flag) { + return 0; +} +s32 osSendMesg(UNUSED OSMesgQueue *mq, UNUSED OSMesg msg, UNUSED s32 flag) { +#if defined(VERSION_EU) || defined(VERSION_SH) + s32 index; + if (mq->validCount >= mq->msgCount) { + return -1; + } + index = (mq->first + mq->validCount) % mq->msgCount; + mq->msg[index] = msg; + mq->validCount++; +#endif + return 0; +} +s32 osRecvMesg(UNUSED OSMesgQueue *mq, UNUSED OSMesg *msg, UNUSED s32 flag) { +#if defined(VERSION_EU) || defined(VERSION_SH) + if (mq->validCount == 0) { + return -1; + } + if (msg != NULL) { + *msg = *(mq->first + mq->msg); + } + mq->first = (mq->first + 1) % mq->msgCount; + mq->validCount--; +#endif + return 0; +} + +uintptr_t osVirtualToPhysical(void *addr) { + return (uintptr_t) addr; +} + +void osCreateViManager(UNUSED OSPri pri) { +} +void osViSetMode(UNUSED OSViMode *mode) { +} +void osViSetEvent(UNUSED OSMesgQueue *mq, UNUSED OSMesg msg, UNUSED u32 retraceCount) { +} +void osViBlack(UNUSED u8 active) { +} +void osViSetSpecialFeatures(UNUSED u32 func) { +} +void osViSwapBuffer(UNUSED void *vaddr) { +} + +OSTime osGetTime(void) { + return 0; +} + +void osWritebackDCacheAll(void) { +} + +void osWritebackDCache(UNUSED void *a, UNUSED size_t b) { +} + +void osInvalDCache(UNUSED void *a, UNUSED size_t b) { +} + +u32 osGetCount(void) { + static u32 counter; + return counter++; +} + +s32 osAiSetFrequency(u32 freq) { + u32 a1; + s32 a2; + u32 D_8033491C; + +#ifdef VERSION_EU + D_8033491C = 0x02E6025C; +#else + D_8033491C = 0x02E6D354; +#endif + + a1 = D_8033491C / (float) freq + .5f; + + if (a1 < 0x84) { + return -1; + } + + a2 = (a1 / 66) & 0xff; + if (a2 > 16) { + a2 = 16; + } + + return D_8033491C / (s32) a1; +} + +s32 osEepromProbe(UNUSED OSMesgQueue *mq) { + return 1; +} + +s32 osEepromLongRead(UNUSED OSMesgQueue *mq, u8 address, u8 *buffer, int nbytes) { + u8 content[512]; + s32 ret = -1; + +#ifdef TARGET_WEB + if (EM_ASM_INT({ + var s = localStorage.sm64_save_file; + if (s && s.length === 684) { + try { + var binary = atob(s); + if (binary.length === 512) { + for (var i = 0; i < 512; i++) { + HEAPU8[$0 + i] = binary.charCodeAt(i); + } + return 1; + } + } catch (e) { + } + } + return 0; + }, content)) { + memcpy(buffer, content + address * 8, nbytes); + ret = 0; + } +#else + FILE *fp = fopen("sm64_save_file.bin", "rb"); + if (fp == NULL) { + return -1; + } + if (fread(content, 1, 512, fp) == 512) { + memcpy(buffer, content + address * 8, nbytes); + ret = 0; + } + fclose(fp); +#endif + return ret; +} + +s32 osEepromLongWrite(UNUSED OSMesgQueue *mq, u8 address, u8 *buffer, int nbytes) { + u8 content[512] = {0}; + if (address != 0 || nbytes != 512) { + osEepromLongRead(mq, 0, content, 512); + } + memcpy(content + address * 8, buffer, nbytes); + +#ifdef TARGET_WEB + EM_ASM({ + var str = ""; + for (var i = 0; i < 512; i++) { + str += String.fromCharCode(HEAPU8[$0 + i]); + } + localStorage.sm64_save_file = btoa(str); + }, content); + s32 ret = 0; +#else + FILE* fp = fopen("sm64_save_file.bin", "wb"); + if (fp == NULL) { + return -1; + } + s32 ret = fwrite(content, 1, 512, fp) == 512 ? 0 : -1; + fclose(fp); +#endif + return ret; +} + +s32 gNumVblanks; + +s32 osMotorInit(UNUSED OSMesgQueue *mq, UNUSED void *pfs, UNUSED int channel) { + return 0; +} + +s32 osMotorStart(UNUSED void *pfs) { + return 0; +} + +s32 osMotorStop(UNUSED void *pfs) { + return 0; +} + +OSPiHandle *osCartRomInit(void) { + static OSPiHandle handle; + return &handle; +} + +OSPiHandle *osDriveRomInit(void) { + static OSPiHandle handle; + return &handle; +} + +s32 osEPiStartDma(UNUSED OSPiHandle *pihandle, OSIoMesg *mb, UNUSED s32 direction) { + memcpy(mb->dramAddr, (const void *) mb->devAddr, mb->size); + osSendMesg(mb->hdr.retQueue, mb, OS_MESG_NOBLOCK); +} diff --git a/src/libsm64.c b/src/libsm64.c index 003837a..30218af 100644 --- a/src/libsm64.c +++ b/src/libsm64.c @@ -29,6 +29,7 @@ #include "load_surfaces.h" #include "gfx_adapter.h" #include "load_anim_data.h" +#include "load_audio_data.h" #include "load_tex_data.h" #include "obj_pool.h" @@ -134,6 +135,10 @@ SM64_LIB_FN void sm64_global_terminate( void ) memory_terminate(); } +SM64_LIB_FN struct AudioBanks sm64_asset_load_audio_banks( void ) { + return load_audio_banks(); +} + SM64_LIB_FN void sm64_static_surfaces_load( const struct SM64Surface *surfaceArray, uint32_t numSurfaces ) { surfaces_load_static( surfaceArray, numSurfaces ); diff --git a/src/libsm64.h b/src/libsm64.h index 2a10146..de887db 100644 --- a/src/libsm64.h +++ b/src/libsm64.h @@ -80,6 +80,8 @@ extern SM64_LIB_FN void sm64_register_play_sound_function( SM64PlaySoundFunction extern SM64_LIB_FN void sm64_global_init( uint8_t *rom, uint8_t *outTexture ); extern SM64_LIB_FN void sm64_global_terminate( void ); +extern SM64_LIB_FN struct AudioBanks sm64_asset_load_audio_banks( void ); + extern SM64_LIB_FN void sm64_static_surfaces_load( const struct SM64Surface *surfaceArray, uint32_t numSurfaces ); extern SM64_LIB_FN int32_t sm64_mario_create( float x, float y, float z ); diff --git a/src/load_audio_data.c b/src/load_audio_data.c new file mode 100644 index 0000000..c293de5 --- /dev/null +++ b/src/load_audio_data.c @@ -0,0 +1,16 @@ +#include "load_audio_data.h" + +#include "decomp/audio/load.h" + +extern struct AudioBanks load_audio_banks() { + int numBanks = 10; + for (int i = 0; i < 10; ++i) { + bank_load_immediate(i, 2); + } + + struct AudioBanks audioBanks; + audioBanks.numCtlEntries = numBanks; + audioBanks.ctlEntries = gCtlEntries; + + return audioBanks; +} \ No newline at end of file diff --git a/src/load_audio_data.h b/src/load_audio_data.h new file mode 100644 index 0000000..96d75a3 --- /dev/null +++ b/src/load_audio_data.h @@ -0,0 +1,8 @@ +#pragma once + +struct AudioBanks { + int numCtlEntries; + struct CtlEntry * ctlEntries; +}; + +extern struct AudioBanks load_audio_banks(); \ No newline at end of file From 13fab60dd874e61c85c8b20a4cd7a065ff025f3e Mon Sep 17 00:00:00 2001 From: MeltyPlayer Date: Mon, 24 Oct 2022 02:05:59 -0500 Subject: [PATCH 04/16] Introduced the ability to parse audio tables from the ROM! --- src/decomp/audio/load.c | 6 +- src/decomp/audio/load_dat.c | 6 +- src/decomp/audio/load_dat.h | 11 +- src/decomp/tools/convTypes.h | 96 +++++++++ src/decomp/tools/convUtils.c | 394 +++++++++++++++++++++++++++++++++++ src/decomp/tools/convUtils.h | 25 +++ src/libsm64.c | 4 +- src/libsm64.h | 2 +- src/load_audio_data.c | 18 +- src/load_audio_data.h | 4 +- 10 files changed, 551 insertions(+), 15 deletions(-) create mode 100644 src/decomp/tools/convTypes.h create mode 100644 src/decomp/tools/convUtils.c create mode 100644 src/decomp/tools/convUtils.h diff --git a/src/decomp/audio/load.c b/src/decomp/audio/load.c index 1aa3053..58a2ba3 100644 --- a/src/decomp/audio/load.c +++ b/src/decomp/audio/load.c @@ -99,9 +99,9 @@ s8 gAudioUpdatesPerFrame; extern u64 gAudioGlobalsStartMarker; extern u64 gAudioGlobalsEndMarker; -extern u8* gSoundDataADSR; // sound_data.ctl -extern u8* gSoundDataRaw; // sound_data.tbl -extern u8* gMusicData; // sequences.s +extern struct seqFile *gSoundDataADSR; // sound_data.ctl +extern struct seqFile *gSoundDataRaw; // sound_data.tbl +extern struct seqFile *gMusicData; // sequences.s extern u8* gBankSetsData; // bank_sets.s ALSeqFile *get_audio_file_header(s32 arg0); diff --git a/src/decomp/audio/load_dat.c b/src/decomp/audio/load_dat.c index 8181b93..9c99214 100644 --- a/src/decomp/audio/load_dat.c +++ b/src/decomp/audio/load_dat.c @@ -1,10 +1,10 @@ #include "load_dat.h" -unsigned char* gSoundDataADSR; +struct seqFile *gSoundDataADSR; -unsigned char* gSoundDataRaw; +struct seqFile *gSoundDataRaw; -unsigned char* gMusicData; +struct seqFile *gMusicData; #ifndef VERSION_SH unsigned char* gBankSetsData; diff --git a/src/decomp/audio/load_dat.h b/src/decomp/audio/load_dat.h index 8d3adda..e563902 100644 --- a/src/decomp/audio/load_dat.h +++ b/src/decomp/audio/load_dat.h @@ -1,11 +1,14 @@ #pragma once -extern unsigned char* gSoundDataADSR; +#include "../tools/convTypes.h" +#include -extern unsigned char* gSoundDataRaw; +extern struct seqFile *gSoundDataADSR; -extern unsigned char* gMusicData; +extern struct seqFile *gSoundDataRaw; + +extern struct seqFile *gMusicData; #ifndef VERSION_SH -extern unsigned char* gBankSetsData; +extern unsigned char *gBankSetsData; #endif \ No newline at end of file diff --git a/src/decomp/tools/convTypes.h b/src/decomp/tools/convTypes.h new file mode 100644 index 0000000..cec8151 --- /dev/null +++ b/src/decomp/tools/convTypes.h @@ -0,0 +1,96 @@ +#pragma once + +#include + +#define TYPE_CTL 1 +#define TYPE_TBL 2 +#define TYPE_SEQ 3 + +struct CLoop +{ + unsigned int start; + unsigned int end; + int count; + unsigned int pad; + short state[1]; +}; + + +struct CBook +{ + int order; // must be 2 + int npredictors; // must be 2 + short table[32]; // 8 * order * npredictors +}; + +struct CSample{ + unsigned int zero; + uintptr_t addr; + struct CLoop* loop; // must not be null + struct CBook* book; // must not be null + unsigned int sample_size; +}; + +struct CSound{ + struct CSample* sample_addr; + float tuning; +}; + +struct delay_arg{ + unsigned short delay; + unsigned short arg; +}; + +struct CEnvelope{ + struct delay_arg delay_args[1]; // array of [(delay,arg)] +}; + +struct CDrum{ + unsigned char release_rate; + unsigned char pan; + unsigned char loaded; + unsigned char pad; + struct CSound snd; + struct CEnvelope* env_addr; +}; + +struct CInstrument{ + unsigned char loaded; + unsigned char normal_range_lo; + unsigned char normal_range_hi; + unsigned char release_rate; + struct CEnvelope* env_addr; + struct CSound sound_lo; + struct CSound sound_med; + struct CSound sound_hi; +}; + +struct TBL{ + unsigned char* data; +}; + +struct SEQ{ + unsigned char* data; +}; + +struct CTL +{ + unsigned int numInstruments; + unsigned int numDrums; + unsigned int shared; + unsigned int iso_date; + struct CDrum** drum_pointers; + struct CInstrument* instrument_pointers[1]; +}; + +struct seqObject{ + uintptr_t offset __attribute__((aligned (8))); + unsigned int len __attribute__((aligned (8))); +}; + +struct seqFile{ + unsigned short revision; + unsigned short seqCount; + unsigned int pad; + struct seqObject seqArray[1]; +} __attribute__((aligned (16))); \ No newline at end of file diff --git a/src/decomp/tools/convUtils.c b/src/decomp/tools/convUtils.c new file mode 100644 index 0000000..bf4d3b6 --- /dev/null +++ b/src/decomp/tools/convUtils.c @@ -0,0 +1,394 @@ +#pragma once +#include "convUtils.h" + +#include "utils.h" +#include +#include +#include "convUtils.h" +#include "convTypes.h" +#include "../../debug_print.h" + +/** + * This code is based on the only documentation that exists (that I know of) for the SM64 CTL/TBL format + * as well as dylanpdx's audio extraction implementation. + * https://github.com/n64decomp/sm64/blob/1372ae1bb7cbedc03df366393188f4f05dcfc422/tools/disassemble_sound.py + * https://github.com/n64decomp/sm64/blob/1372ae1bb7cbedc03df366393188f4f05dcfc422/tools/assemble_sound.py + * https://github.com/Retro64Mod/libsm64-retro64 + */ + +#define ALIGN16(val) (((val) + 0xF) & ~0xF) + +unsigned char* gCtlSeqs; + +struct seqFile* parse_seqfile(unsigned char* seq){ /* Read SeqFile data */ + DEBUG_PRINT("parse_seqfile()"); + + short revision = read_u16_be(seq); + short bankCount = read_u16_be(seq + 2); + DEBUG_PRINT("- bankCount: %d", bankCount); + + unsigned int size = sizeof(struct seqFile) + (bankCount-1) * sizeof(struct seqObject); + DEBUG_PRINT("- seqFile size: %d", sizeof(struct seqFile)); + DEBUG_PRINT("- actual size: %d", size); + + struct seqFile* seqFile = (struct seqFile*)calloc(size, 1); + seqFile->revision = revision; + seqFile->seqCount = bankCount; + for (int i = 0; i < bankCount; i++){ // read bank offsets and sizes + seqFile->seqArray[i].offset = (uintptr_t)read_u32_be(seq + 4 + i * 8); + seqFile->seqArray[i].len = read_u32_be((seq + 4 + i * 8 + 4)); + } + + if (revision == TYPE_CTL){ + DEBUG_PRINT("- found ctl!"); + // CTL file, contains instrument and drum data, this is really the only one that needs to be parsed, the rest only needs a header change + gCtlSeqs = (unsigned char*)calloc(0x20B40, 1); // We only really need 0x20AD0 bytes but still + uintptr_t pos = (uintptr_t)gCtlSeqs; + for (int i = 0; i < bankCount; i++){ + uintptr_t start = pos; + struct CTL* ptr = parse_ctl_data(seq+(seqFile->seqArray[i].offset), &pos); + seqFile->seqArray[i].offset = ptr; + seqFile->seqArray[i].len = (unsigned int)(pos - start); + } + }else if (revision == TYPE_TBL){ + DEBUG_PRINT("- found tbl!"); + // TBL file, contains raw audio data + for (int i = 0; i < bankCount; i++){ + seqFile->seqArray[i].offset = seq+(seqFile->seqArray[i].offset); + } + }else if (revision == TYPE_SEQ){ + DEBUG_PRINT("- found seq!"); + // SEQ file, contains music files (*.m64) + for (int i = 0; i < bankCount; i++){ + seqFile->seqArray[i].offset = seq+(seqFile->seqArray[i].offset); + } + } + + DEBUG_PRINT("- returning seq: %p", seqFile); + + return seqFile; +} + +void ctl_free(){ + free(gCtlSeqs); +} + +void snd_ptrs_to_offsets(struct CSound* snd, uintptr_t ctlData){ + struct CSample* smp = snd->sample_addr; + if((uintptr_t)(smp->loop) > ctlData) + smp->loop = (struct CLoop*)((uintptr_t)(smp->loop) - ctlData); + if((uintptr_t)(smp->book) > ctlData) + smp->book = (struct CBook*)((uintptr_t)(smp->book) - ctlData); + snd->sample_addr = (struct CSample*)((uintptr_t)(snd->sample_addr) - ctlData); +} + +void ptrs_to_offsets(struct seqFile* ctl){ + DEBUG_PRINT("ptrs_to_offsets()"); + + DEBUG_PRINT("- checking if type is not ctl..."); + DEBUG_PRINT("%p", ctl); + if (ctl->revision != TYPE_CTL){ + DEBUG_PRINT("Sequence file is not a CTL file\n"); + return; + } + + DEBUG_PRINT("- looping through ctl"); + DEBUG_PRINT("seq count: %d", ctl->seqCount); + for (int i = 0; i < ctl->seqCount; i++){ + DEBUG_PRINT("- for seq"); + struct CTL* ptr = (struct CTL*)ctl->seqArray[i].offset; + uintptr_t ctlData = (uintptr_t)ptr + 0x10; + // find all samples in the CTL file + DEBUG_PRINT("- finding samples"); + for (int j = 0; j < ptr->numInstruments; j++){ + struct CInstrument* inst = ptr->instrument_pointers[j]; + if (inst==0x0) + continue; // null instrument. + inst->env_addr = (struct CEnvelope*)((uintptr_t)inst->env_addr - ctlData); + if (inst->sound_hi.sample_addr!=0x0){ + snd_ptrs_to_offsets(&(inst->sound_hi), ctlData); + } + if (inst->sound_med.sample_addr!=0x0){ + snd_ptrs_to_offsets(&(inst->sound_med), ctlData); + } + if (inst->sound_lo.sample_addr!=0x0){ + snd_ptrs_to_offsets(&(inst->sound_lo), ctlData); + } + ptr->instrument_pointers[j] = (struct CInstrument*)((uintptr_t)(inst) - ctlData); + } + DEBUG_PRINT("- finding drums"); + if(ptr->numDrums != 0){ + for (int j = 0; j < ptr->numDrums; j++){ + struct CDrum* drum = ptr->drum_pointers[j]; + if (drum==0x0) + continue; // null drum. + drum->env_addr = (struct CEnvelope*)((uintptr_t)drum->env_addr - ctlData); + if (drum->snd.sample_addr!=0x0){ + snd_ptrs_to_offsets(&(drum->snd), ctlData); + } + ptr->drum_pointers[j] = (struct CDrum*)((uintptr_t)(drum) - ctlData); + } + ptr->drum_pointers = (struct CDrum**)((uintptr_t)(ptr->drum_pointers) - ctlData); + } + } +} + +struct CLoop* parse_loop(unsigned char* loop, uintptr_t* pos){ + uint32_t count = read_u32_be(loop + 8); // variable is signed, but the data is being read as unsigned. + unsigned int size = sizeof(struct CLoop) - 4; + if(count != 0){ + size = sizeof(struct CLoop) - 4 + sizeof(short) * 16; + } + struct CLoop* loop_ptr = (struct CLoop*)(*pos); + *pos += size; + *pos = ALIGN16(*pos); + + loop_ptr->start = read_u32_be(loop); + loop_ptr->end = read_u32_be(loop + 4); + loop_ptr->count = count; + loop_ptr->pad = read_u32_be(loop + 12); + + if (loop_ptr->count!=0){ + for (int i = 0;i<16;i++){ + loop_ptr->state[i]=read_u16_be(loop + 16 + i*2); + } + } + + return loop_ptr; +} + +struct CBook* parse_book(unsigned char* book, uintptr_t* pos){ + struct CBook* book_ptr = (struct CBook*)(*pos); + *pos += sizeof(struct CBook); + *pos = ALIGN16(*pos); + book_ptr->order = read_u32_be(book); + book_ptr->npredictors = read_u32_be(book + 4); // both are signed + unsigned char* table_data = book+8; + for (int i = 0; i < 8 * book_ptr->order * book_ptr->npredictors; i ++){ + book_ptr->table[i] = read_u16_be(table_data + i * 2); + } + return book_ptr; +} + +struct CSample* parse_sample(unsigned char* sample,unsigned char* ctl, uintptr_t* pos){ + struct CSample* samp = (struct CSample*)(*pos); + *pos += sizeof(struct CSample); + *pos = ALIGN16(*pos); + samp->zero=read_u32_be(sample); + samp->addr=read_u32_be(sample+4); + samp->loop=read_u32_be(sample+8);// loop address + samp->book=read_u32_be(sample+12);// book address + samp->sample_size=read_u32_be(sample+16); + + samp->book=parse_book(ctl+((uintptr_t)samp->book), pos); + samp->loop=parse_loop(ctl+((uintptr_t)samp->loop), pos); + return samp; +} + +struct CSound* parse_sound(unsigned char* sound,unsigned char* ctl, uintptr_t* pos, uintptr_t sndPos, struct SampleList* samples){ + struct CSound* snd = (struct CSound*)(sndPos); + snd->sample_addr=read_u32_be(sound); + snd->tuning = (float)read_f32_be(sound+4); + // if sample_addr is 0 then the sound is null + if (snd->sample_addr!=0){ + int smpIndex = -1; + for(int i = 0; i < samples->count; i++){ + if(samples->orig_addrs[i] == (uintptr_t)(snd->sample_addr)){ + smpIndex = i; + break; + } + } + if(smpIndex < 0){ + samples->orig_addrs[samples->count] = (uintptr_t)(snd->sample_addr); + snd->sample_addr = parse_sample(ctl+((uintptr_t)snd->sample_addr),ctl, pos); + samples->addrs[samples->count] = snd->sample_addr; + samples->count++; + } else { + snd->sample_addr = samples->addrs[smpIndex]; + } + } + return snd; +} + +struct CDrum* parse_drum(unsigned char* drum,unsigned char* ctl, uintptr_t* pos, struct SampleList* samples){ /* Read Drum data */ + struct CDrum* drumData = malloc(sizeof(struct CDrum)); + drumData->release_rate = drum[0]; + drumData->pan = drum[1]; + drumData->loaded = drum[2]; + drumData->pad = drum[3]; + drumData->snd=*parse_sound(drum+4,ctl, pos, &drumData->snd, samples); + drumData->env_addr=read_u32_be(drum+12); + return drumData; +} + +struct CEnvelope* parse_envelope(unsigned char* env, uintptr_t* pos, int* size){ + int count = 0; + while(1){ + unsigned short delay = read_u16_le(env + count * 4); + unsigned short arg = read_u16_le(env + count * 4 + 2); + unsigned short delayC = (-delay); + count++; + if ((1 <= delayC && delayC <= 3) || delay == 0) + break; + } + *size = sizeof(struct CEnvelope) + sizeof(struct delay_arg) * (count-1); + struct CEnvelope* envData = malloc(*size); + for (int i = 0; i < count; i++){ + envData->delay_args[i].delay = read_u16_le(env + i * 4); + envData->delay_args[i].arg = read_u16_le(env + i * 4 + 2); + } + return envData; +} + +struct CInstrument* parse_instrument(unsigned char* instrument,unsigned char* ctl, uintptr_t* pos, struct SampleList* samples){ + struct CInstrument* inst = malloc(sizeof(struct CInstrument)); + inst->loaded = instrument[0]; + inst->normal_range_lo = instrument[1]; + inst->normal_range_hi = instrument[2]; + inst->release_rate = instrument[3]; + inst->env_addr=read_u32_be(instrument+4); + inst->sound_lo=*parse_sound(instrument+8,ctl, pos, &(inst->sound_lo), samples); + inst->sound_med=*parse_sound(instrument+16,ctl, pos, &(inst->sound_med), samples); + inst->sound_hi=*parse_sound(instrument+24,ctl, pos, &(inst->sound_hi), samples); + + return inst; +} + +struct TBL* parse_tbl_data(unsigned char* tbl){ + struct TBL* tblData = malloc(sizeof(struct TBL)); + tblData->data = tbl; + return tblData; +} + +struct SEQ* parse_seq_data(unsigned char* seq){ + struct SEQ* seqData = malloc(sizeof(struct SEQ)); + seqData->data = seq; + return seqData; +} + +struct CTL* parse_ctl_data(unsigned char* ctlData, uintptr_t* pos){ + int instruments=read_u32_be(ctlData); + unsigned int size = sizeof(struct CTL) + sizeof(struct CInstrument*) * (instruments-1); + struct CTL* ctl = (struct CTL*)(*pos); + *pos += size; + *pos = ALIGN16(*pos); + #pragma region Parse CTL header + ctl->numInstruments = read_u32_be(ctlData); + ctl->numDrums = read_u32_be(ctlData + 4); + ctl->shared = read_u32_be(ctlData + 8); + ctl->iso_date = read_u32_be(ctlData + 12); + #pragma endregion + struct SampleList samples = {0}; + struct EnvelopeMeta envData[128] = {0}; + int envCount = 0; + samples.count = 0; + // header parsed, now read data + if(ctl->numDrums != 0) { + ctl->drum_pointers= (struct CDrum**)(*pos); + size = sizeof(struct CDrum*) * ctl->numDrums; + *pos += size; + *pos = ALIGN16(*pos); + int drumTablePtr = read_u32_be(ctlData + 16); + for (int i = 0; i < ctl->numDrums; i++){ + uint32_t data = read_u32_be(ctlData + drumTablePtr+16 + i * 4); + + struct CDrum* d = parse_drum(ctlData+data+16,ctlData+16, pos, &samples); + bool used = 0; + for(int j = 0; j < envCount; j++){ + if(envData[j].orig == (uintptr_t)d->env_addr){ + used = 1; + break; + } + } + if(used == 0){ + int size = 0; + unsigned char* addr = ctlData+((uintptr_t)d->env_addr)+16; + envData[envCount].orig = (uintptr_t)(d->env_addr); + envData[envCount].addr = parse_envelope(addr, pos, &size); + envData[envCount].size = size; + envCount++; + } + ctl->drum_pointers[i] = d; + } + *pos = ALIGN16(*pos); + } else { + ctl->drum_pointers= NULL; + } + // parse instrument data + int instTablePtr = 4; + for (int i = 0; i < ctl->numInstruments; i++){ + uint32_t data = read_u32_be(ctlData + 16 + instTablePtr + i * 4); + if (data == 0) + continue; + struct CInstrument* inst = parse_instrument(ctlData+16+data,ctlData+16, pos, &samples); + bool used = 0; + for(int j = 0; j < envCount; j++){ + if(envData[j].orig == (uintptr_t)inst->env_addr){ + used = 1; + break; + } + } + if(used == 0){ + int size = 0; + unsigned char* addr = ctlData+((uintptr_t)inst->env_addr)+16; + envData[envCount].orig = (uintptr_t)(inst->env_addr); + envData[envCount].addr = parse_envelope(addr, pos, &size); + envData[envCount].size = size; + envCount++; + } + ctl->instrument_pointers[i] = inst; + } + *pos = ALIGN16(*pos); + + // Copy envelopes to ctl + for (int i = 0; i < envCount; i++){ + struct CEnvelope* env = envData[i].addr; + memcpy((uint8_t*)(*pos), env, envData[i].size); + for (int j = 0; j < ctl->numInstruments; j++){ + struct CInstrument* inst = ctl->instrument_pointers[j]; + if (inst == 0x0) + continue; + if((uintptr_t)(inst->env_addr) == envData[i].orig){ + inst->env_addr = (struct CEnvelope*)(*pos); + } + } + for (int j = 0; j < ctl->numDrums; j++){ + struct CDrum* drum = ctl->drum_pointers[j]; + if (drum == 0x0) + continue; + if((uintptr_t)(drum->env_addr) == envData[i].orig){ + drum->env_addr = (struct CEnvelope*)(*pos); + } + } + free(env); + *pos += envData[i].size; + } + *pos = ALIGN16(*pos); + + // Copy instruments to ctl + for (int i = 0; i < ctl->numInstruments; i++){ + struct CInstrument* inst = ctl->instrument_pointers[i]; + if (inst == 0x0) + continue; + memcpy((uint8_t*)(*pos), inst, sizeof(struct CInstrument)); + free(inst); + ctl->instrument_pointers[i] = (struct CInstrument*)(*pos); + *pos += sizeof(struct CInstrument); + } + *pos = ALIGN16(*pos); + + // Copy drums to ctl + for (int i = 0; i < ctl->numDrums; i++){ + struct CDrum* drum = ctl->drum_pointers[i]; + if (drum == 0x0) + continue; + memcpy((uint8_t*)(*pos), drum, sizeof(struct CDrum)); + free(drum); + ctl->drum_pointers[i] = (struct CDrum*)(*pos); + *pos += sizeof(struct CDrum); + } + *pos = ALIGN16(*pos); + // + + return ctl; +} \ No newline at end of file diff --git a/src/decomp/tools/convUtils.h b/src/decomp/tools/convUtils.h new file mode 100644 index 0000000..4f82584 --- /dev/null +++ b/src/decomp/tools/convUtils.h @@ -0,0 +1,25 @@ +#pragma once +#include "../pc/libaudio_internal.h" + +#define read_u16_le(p) ((uint8_t*)p)[1] * 0x100u + ((uint8_t*)p)[0] + +struct EnvelopeMeta { + uintptr_t orig; + struct CEnvelope* addr; + int size; +}; + +struct SampleList { + int count; + uintptr_t orig_addrs[256]; + struct CSample* addrs[256]; +}; + +struct seqFile* parse_seqfile(unsigned char* seq); +struct CTL* parse_ctl_data(unsigned char* ctlData, uintptr_t* pos); +struct TBL* parse_tbl_data(unsigned char* tbl); +struct SEQ* parse_seq_data(unsigned char* seq); +void ptrs_to_offsets(struct seqFile* ctl); +void ctl_free(); +#define INITIAL_GFX_ALLOC 10 +#define INITIAL_GEO_ALLOC 10 \ No newline at end of file diff --git a/src/libsm64.c b/src/libsm64.c index 30218af..dd8c15d 100644 --- a/src/libsm64.c +++ b/src/libsm64.c @@ -135,8 +135,8 @@ SM64_LIB_FN void sm64_global_terminate( void ) memory_terminate(); } -SM64_LIB_FN struct AudioBanks sm64_asset_load_audio_banks( void ) { - return load_audio_banks(); +SM64_LIB_FN struct AudioBanks sm64_asset_load_audio_banks( uint8_t *rom ) { + return load_audio_banks( rom ); } SM64_LIB_FN void sm64_static_surfaces_load( const struct SM64Surface *surfaceArray, uint32_t numSurfaces ) diff --git a/src/libsm64.h b/src/libsm64.h index de887db..53ac004 100644 --- a/src/libsm64.h +++ b/src/libsm64.h @@ -80,7 +80,7 @@ extern SM64_LIB_FN void sm64_register_play_sound_function( SM64PlaySoundFunction extern SM64_LIB_FN void sm64_global_init( uint8_t *rom, uint8_t *outTexture ); extern SM64_LIB_FN void sm64_global_terminate( void ); -extern SM64_LIB_FN struct AudioBanks sm64_asset_load_audio_banks( void ); +extern SM64_LIB_FN struct AudioBanks sm64_asset_load_audio_banks( uint8_t *rom ); extern SM64_LIB_FN void sm64_static_surfaces_load( const struct SM64Surface *surfaceArray, uint32_t numSurfaces ); diff --git a/src/load_audio_data.c b/src/load_audio_data.c index c293de5..efa500c 100644 --- a/src/load_audio_data.c +++ b/src/load_audio_data.c @@ -1,8 +1,24 @@ #include "load_audio_data.h" +#include "decomp/tools/convUtils.h" #include "decomp/audio/load.h" +#include "decomp/audio/load_dat.h" -extern struct AudioBanks load_audio_banks() { +extern struct AudioBanks load_audio_banks( uint8_t *rom ) { + uint8_t *rom2 = malloc(0x800000); + + memcpy(rom2, rom, 0x800000); + rom = rom2; + gSoundDataADSR = parse_seqfile(rom+0x57B720); //ctl + gSoundDataRaw = parse_seqfile(rom+0x593560); //tbl + gMusicData = parse_seqfile(rom+0x7B0860); + gBankSetsData = rom+0x7CC621; + memmove(gBankSetsData+0x45,gBankSetsData+0x45-1,0x5B); + gBankSetsData[0x45]=0x00; + ptrs_to_offsets(gSoundDataADSR); + + audio_init(); + int numBanks = 10; for (int i = 0; i < 10; ++i) { bank_load_immediate(i, 2); diff --git a/src/load_audio_data.h b/src/load_audio_data.h index 96d75a3..90b99c8 100644 --- a/src/load_audio_data.h +++ b/src/load_audio_data.h @@ -1,8 +1,10 @@ #pragma once +#include + struct AudioBanks { int numCtlEntries; struct CtlEntry * ctlEntries; }; -extern struct AudioBanks load_audio_banks(); \ No newline at end of file +extern struct AudioBanks load_audio_banks( uint8_t *rom ); \ No newline at end of file From ecb592468287dd1708f3e549b5e612f17bff9bfd Mon Sep 17 00:00:00 2001 From: MeltyPlayer Date: Mon, 24 Oct 2022 02:52:10 -0500 Subject: [PATCH 05/16] Deleted unused pc/gfx and audio directories. --- src/decomp/pc/audio/audio_alsa.c | 170 - src/decomp/pc/audio/audio_alsa.h | 13 - src/decomp/pc/audio/audio_api.h | 15 - src/decomp/pc/audio/audio_null.c | 24 - src/decomp/pc/audio/audio_null.h | 8 - src/decomp/pc/audio/audio_pulse.c | 206 - src/decomp/pc/audio/audio_pulse.h | 13 - src/decomp/pc/audio/audio_wasapi.cpp | 219 - src/decomp/pc/audio/audio_wasapi.h | 12 - src/decomp/pc/gfx/LICENSE.txt | 19 - src/decomp/pc/gfx/README.md | 33 - src/decomp/pc/gfx/dxsdk/d3d12.h | 17258 ------------------- src/decomp/pc/gfx/dxsdk/d3d12sdklayers.h | 3230 ---- src/decomp/pc/gfx/dxsdk/d3dcommon.h | 1009 -- src/decomp/pc/gfx/dxsdk/d3dx12.h | 3440 ---- src/decomp/pc/gfx/gfx_cc.c | 41 - src/decomp/pc/gfx/gfx_cc.h | 58 - src/decomp/pc/gfx/gfx_direct3d11.cpp | 731 - src/decomp/pc/gfx/gfx_direct3d11.h | 12 - src/decomp/pc/gfx/gfx_direct3d12.cpp | 966 -- src/decomp/pc/gfx/gfx_direct3d12.h | 12 - src/decomp/pc/gfx/gfx_direct3d12_guids.h | 62 - src/decomp/pc/gfx/gfx_direct3d_common.cpp | 313 - src/decomp/pc/gfx/gfx_direct3d_common.h | 14 - src/decomp/pc/gfx/gfx_dummy.c | 192 - src/decomp/pc/gfx/gfx_dummy.h | 14 - src/decomp/pc/gfx/gfx_dxgi.cpp | 614 - src/decomp/pc/gfx/gfx_dxgi.h | 16 - src/decomp/pc/gfx/gfx_glx.c | 620 - src/decomp/pc/gfx/gfx_glx.h | 8 - src/decomp/pc/gfx/gfx_opengl.c | 531 - src/decomp/pc/gfx/gfx_opengl.h | 8 - src/decomp/pc/gfx/gfx_pc.c | 1691 -- src/decomp/pc/gfx/gfx_pc.h | 30 - src/decomp/pc/gfx/gfx_rendering_api.h | 35 - src/decomp/pc/gfx/gfx_screen_config.h | 7 - src/decomp/pc/gfx/gfx_sdl.h | 8 - src/decomp/pc/gfx/gfx_sdl2.c | 315 - src/decomp/pc/gfx/gfx_window_manager_api.h | 21 - 39 files changed, 31988 deletions(-) delete mode 100644 src/decomp/pc/audio/audio_alsa.c delete mode 100644 src/decomp/pc/audio/audio_alsa.h delete mode 100644 src/decomp/pc/audio/audio_api.h delete mode 100644 src/decomp/pc/audio/audio_null.c delete mode 100644 src/decomp/pc/audio/audio_null.h delete mode 100644 src/decomp/pc/audio/audio_pulse.c delete mode 100644 src/decomp/pc/audio/audio_pulse.h delete mode 100644 src/decomp/pc/audio/audio_wasapi.cpp delete mode 100644 src/decomp/pc/audio/audio_wasapi.h delete mode 100644 src/decomp/pc/gfx/LICENSE.txt delete mode 100644 src/decomp/pc/gfx/README.md delete mode 100644 src/decomp/pc/gfx/dxsdk/d3d12.h delete mode 100644 src/decomp/pc/gfx/dxsdk/d3d12sdklayers.h delete mode 100644 src/decomp/pc/gfx/dxsdk/d3dcommon.h delete mode 100644 src/decomp/pc/gfx/dxsdk/d3dx12.h delete mode 100644 src/decomp/pc/gfx/gfx_cc.c delete mode 100644 src/decomp/pc/gfx/gfx_cc.h delete mode 100644 src/decomp/pc/gfx/gfx_direct3d11.cpp delete mode 100644 src/decomp/pc/gfx/gfx_direct3d11.h delete mode 100644 src/decomp/pc/gfx/gfx_direct3d12.cpp delete mode 100644 src/decomp/pc/gfx/gfx_direct3d12.h delete mode 100644 src/decomp/pc/gfx/gfx_direct3d12_guids.h delete mode 100644 src/decomp/pc/gfx/gfx_direct3d_common.cpp delete mode 100644 src/decomp/pc/gfx/gfx_direct3d_common.h delete mode 100644 src/decomp/pc/gfx/gfx_dummy.c delete mode 100644 src/decomp/pc/gfx/gfx_dummy.h delete mode 100644 src/decomp/pc/gfx/gfx_dxgi.cpp delete mode 100644 src/decomp/pc/gfx/gfx_dxgi.h delete mode 100644 src/decomp/pc/gfx/gfx_glx.c delete mode 100644 src/decomp/pc/gfx/gfx_glx.h delete mode 100644 src/decomp/pc/gfx/gfx_opengl.c delete mode 100644 src/decomp/pc/gfx/gfx_opengl.h delete mode 100644 src/decomp/pc/gfx/gfx_pc.c delete mode 100644 src/decomp/pc/gfx/gfx_pc.h delete mode 100644 src/decomp/pc/gfx/gfx_rendering_api.h delete mode 100644 src/decomp/pc/gfx/gfx_screen_config.h delete mode 100644 src/decomp/pc/gfx/gfx_sdl.h delete mode 100644 src/decomp/pc/gfx/gfx_sdl2.c delete mode 100644 src/decomp/pc/gfx/gfx_window_manager_api.h diff --git a/src/decomp/pc/audio/audio_alsa.c b/src/decomp/pc/audio/audio_alsa.c deleted file mode 100644 index 7884130..0000000 --- a/src/decomp/pc/audio/audio_alsa.c +++ /dev/null @@ -1,170 +0,0 @@ -#include "../compat.h" - -#if (defined(__linux__) || defined(__BSD__)) && !defined(TARGET_WEB) -/* - Simple sound playback using ALSA API and libasound. - Dependencies: libasound, alsa - Build-Dependencies: liasound-dev - Compile: gcc -lasound -o play sound_playback.c - Usage: ./play < - Examples: - ./play 44100 2 5 < /dev/urandom - ./play 22050 1 8 < /path/to/file.wav - - Copyright (C) 2009 Alessandro Ghedini - -------------------------------------------------------------- - "THE BEER-WARE LICENSE" (Revision 42): - Alessandro Ghedini wrote this file. As long as you retain this - notice you can do whatever you want with this stuff. If we - meet some day, and you think this stuff is worth it, you can - buy me a beer in return. - -------------------------------------------------------------- -*/ - -#include -#include -#include -#include -#include -#include - -#include - -#include -#include - -#include "audio_api.h" - -#define PCM_DEVICE "default" -static snd_pcm_t *pcm_handle; -static unsigned long int alsa_buffer_size; - -static unsigned long get_time(void) { - struct timespec ts; - clock_gettime(CLOCK_MONOTONIC, &ts); - return (unsigned long)ts.tv_sec * 1000000 + ts.tv_nsec / 1000; -} - -static bool audio_alsa_init(void) { - int pcm; - unsigned int tmp; - unsigned int rate, channels; - snd_pcm_hw_params_t *params; - snd_pcm_uframes_t frames; - - rate = 32000; - channels = 2; - - /* Open the PCM device in playback mode */ - if ((pcm = snd_pcm_open(&pcm_handle, PCM_DEVICE, - SND_PCM_STREAM_PLAYBACK, 0)) < 0) { - printf("ERROR: Can't open \"%s\" PCM device. %s\n", - PCM_DEVICE, snd_strerror(pcm)); - return false; - } - - /* Allocate parameters object and fill it with default values*/ - snd_pcm_hw_params_alloca(¶ms); - - snd_pcm_hw_params_any(pcm_handle, params); - - /* Set parameters */ - if ((pcm = snd_pcm_hw_params_set_access(pcm_handle, params, - SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) - printf("ERROR: Can't set interleaved mode. %s\n", snd_strerror(pcm)); - - if ((pcm = snd_pcm_hw_params_set_format(pcm_handle, params, - SND_PCM_FORMAT_S16_LE)) < 0) - printf("ERROR: Can't set format. %s\n", snd_strerror(pcm)); - - if ((pcm = snd_pcm_hw_params_set_channels(pcm_handle, params, channels)) < 0) - printf("ERROR: Can't set channels number. %s\n", snd_strerror(pcm)); - - if ((pcm = snd_pcm_hw_params_set_rate_near(pcm_handle, params, &rate, 0)) < 0) - printf("ERROR: Can't set rate. %s\n", snd_strerror(pcm)); - - alsa_buffer_size = 1600 + 528 + 544; // five audio buffers from the game - if ((pcm = snd_pcm_hw_params_set_buffer_size_near(pcm_handle, params, &alsa_buffer_size)) < 0) - printf("ERROR: Can't set buffer size. %s\n", snd_strerror(pcm)); - - /* Write parameters */ - if ((pcm = snd_pcm_hw_params(pcm_handle, params)) < 0) - printf("ERROR: Can't set harware parameters. %s\n", snd_strerror(pcm)); - - /* Resume information */ - printf("PCM name: '%s'\n", snd_pcm_name(pcm_handle)); - - printf("PCM state: %s\n", snd_pcm_state_name(snd_pcm_state(pcm_handle))); - - snd_pcm_hw_params_get_channels(params, &tmp); - printf("channels: %i ", tmp); - - if (tmp == 1) - printf("(mono)\n"); - else if (tmp == 2) - printf("(stereo)\n"); - - snd_pcm_hw_params_get_rate(params, &tmp, 0); - printf("rate: %d bps\n", tmp); - - snd_pcm_hw_params_get_buffer_size(params, &alsa_buffer_size); - printf("buffer size: %lu\n", alsa_buffer_size); - - /* Allocate buffer to hold single period */ - snd_pcm_hw_params_get_period_size(params, &frames, 0); - printf("frames: %lu\n", frames); - - snd_pcm_hw_params_get_period_time(params, &tmp, NULL); - printf("time: %d\n", tmp); - - return true; -} - -static int audio_alsa_buffered(void) { - if (!pcm_handle) { - return 0; - } - snd_pcm_sframes_t ret = snd_pcm_avail(pcm_handle); - if (ret < 0) { - return 0; - } - ret = alsa_buffer_size - ret; - return ret < 0 ? 0 : ret; -} - -static int audio_alsa_get_desired_buffered(void) { - return 1100; -} - -static void audio_alsa_play(const uint8_t* buff, size_t len) { - if (!pcm_handle) { - audio_alsa_init(); - } - //unsigned long t1 = get_time(); - int frames = len / 4; - int pcm; - if ((pcm = snd_pcm_writei(pcm_handle, buff, frames)) == -EPIPE) { - printf("XRUN.\n"); - snd_pcm_prepare(pcm_handle); - // Add some silence to avoid another XRUN - char buf[1100 * 4 + len]; - memset(buf, 0, 1100 * 4); - memcpy(buf + 1100 * 4, buff, len); - if ((pcm = snd_pcm_writei(pcm_handle, buf, 1100 + frames)) < 0) { - printf("Failed again %d\n", pcm); - } - } else if (pcm < 0) { - printf("ERROR. Can't write to PCM device. %s\n", snd_strerror(pcm)); - return; - } - //fprintf(stderr, "%u ", get_time() - t1); -} - -struct AudioAPI audio_alsa = { - audio_alsa_init, - audio_alsa_buffered, - audio_alsa_get_desired_buffered, - audio_alsa_play -}; - -#endif diff --git a/src/decomp/pc/audio/audio_alsa.h b/src/decomp/pc/audio/audio_alsa.h deleted file mode 100644 index 199d9cf..0000000 --- a/src/decomp/pc/audio/audio_alsa.h +++ /dev/null @@ -1,13 +0,0 @@ -#ifndef AUDIO_ALSA_H -#define AUDIO_ALSA_H - -#include "../compat.h" - -#if defined(__linux__) || defined(__BSD__) -extern struct AudioAPI audio_alsa; -#define HAVE_ALSA 1 -#else -#define HAVE_ALSA 0 -#endif - -#endif diff --git a/src/decomp/pc/audio/audio_api.h b/src/decomp/pc/audio/audio_api.h deleted file mode 100644 index 26794dd..0000000 --- a/src/decomp/pc/audio/audio_api.h +++ /dev/null @@ -1,15 +0,0 @@ -#ifndef AUDIO_API_H -#define AUDIO_API_H - -#include -#include -#include - -struct AudioAPI { - bool (*init)(void); - int (*buffered)(void); - int (*get_desired_buffered)(void); - void (*play)(const uint8_t *buf, size_t len); -}; - -#endif diff --git a/src/decomp/pc/audio/audio_null.c b/src/decomp/pc/audio/audio_null.c deleted file mode 100644 index aa87add..0000000 --- a/src/decomp/pc/audio/audio_null.c +++ /dev/null @@ -1,24 +0,0 @@ -#include -#include "audio_api.h" - -static bool audio_null_init(void) { - return true; -} - -static int audio_null_buffered(void) { - return 0; -} - -static int audio_null_get_desired_buffered(void) { - return 0; -} - -static void audio_null_play(UNUSED const uint8_t *buf, UNUSED size_t len) { -} - -struct AudioAPI audio_null = { - audio_null_init, - audio_null_buffered, - audio_null_get_desired_buffered, - audio_null_play -}; diff --git a/src/decomp/pc/audio/audio_null.h b/src/decomp/pc/audio/audio_null.h deleted file mode 100644 index 59748bc..0000000 --- a/src/decomp/pc/audio/audio_null.h +++ /dev/null @@ -1,8 +0,0 @@ -#ifndef AUDIO_NULL_H -#define AUDIO_NULL_H - -#include "audio_api.h" - -extern struct AudioAPI audio_null; - -#endif diff --git a/src/decomp/pc/audio/audio_pulse.c b/src/decomp/pc/audio/audio_pulse.c deleted file mode 100644 index 385cb5e..0000000 --- a/src/decomp/pc/audio/audio_pulse.c +++ /dev/null @@ -1,206 +0,0 @@ -#include "../compat.h" - -#if defined(__linux__) || defined(__BSD__) - -#include -#include -#include - -#include "macros.h" -#include "audio_api.h" - -static struct { - pa_mainloop *mainloop; - pa_context *context; - pa_stream *stream; - pa_buffer_attr attr; - bool write_complete; -} pas; - -static void pas_context_state_cb(pa_context *c, void *userdata) { - switch (pa_context_get_state(c)) { - case PA_CONTEXT_READY: - case PA_CONTEXT_TERMINATED: - case PA_CONTEXT_FAILED: - *((bool *)userdata) = true; - break; - default: - break; - } -} - -static void pas_stream_state_cb(pa_stream *s, void *userdata) { - switch (pa_stream_get_state(s)) { - case PA_STREAM_READY: - case PA_STREAM_FAILED: - case PA_STREAM_TERMINATED: - *((bool *)userdata) = true; - break; - default: - break; - } -} - -static void pas_stream_write_cb(UNUSED pa_stream *s, UNUSED size_t length, UNUSED void *userdata) { - //size_t ws = pa_stream_writable_size(pas.stream); - //printf("write cb: %d %d\n", (int)length, (int)ws); -} - -static bool audio_pulse_init(void) { - // Create mainloop - pas.mainloop = pa_mainloop_new(); - if (pas.mainloop == NULL) { - return false; - } - - // Create context and connect - pas.context = pa_context_new(pa_mainloop_get_api(pas.mainloop), "Super Mario 64"); - if (pas.context == NULL) { - goto fail; - } - - bool done = false; - pa_context_set_state_callback(pas.context, pas_context_state_cb, &done); - - if (pa_context_connect(pas.context, NULL, 0, NULL) < 0) { - goto fail; - } - - while (!done) { - pa_mainloop_iterate(pas.mainloop, true, NULL); - } - pa_context_set_state_callback(pas.context, NULL, NULL); - if (pa_context_get_state(pas.context) != PA_CONTEXT_READY) { - goto fail; - } - - // Create stream - pa_sample_spec ss; - ss.format = PA_SAMPLE_S16LE; - ss.rate = 32000; - ss.channels = 2; - - pa_buffer_attr attr; - attr.maxlength = (1600 + 544 + 528 + 1600) * 4; - attr.tlength = (528*2 + 544) * 4; - attr.prebuf = 1500 * 4; - attr.minreq = 161 * 4; - attr.fragsize = (uint32_t)-1; - - pas.stream = pa_stream_new(pas.context, "mario", &ss, NULL); - if (pas.stream == NULL) { - goto fail; - } - - done = false; - pa_stream_set_state_callback(pas.stream, pas_stream_state_cb, &done); - pa_stream_set_write_callback(pas.stream, pas_stream_write_cb, NULL); - if (pa_stream_connect_playback(pas.stream, NULL, &attr, PA_STREAM_ADJUST_LATENCY, NULL, NULL) < 0) { - goto fail; - } - - while (!done) { - pa_mainloop_iterate(pas.mainloop, true, NULL); - } - pa_stream_set_state_callback(pas.stream, NULL, NULL); - if (pa_stream_get_state(pas.stream) != PA_STREAM_READY) { - goto fail; - } - - const pa_buffer_attr *applied_attr = pa_stream_get_buffer_attr(pas.stream); - printf("maxlength: %u\ntlength: %u\nprebuf: %u\nminreq: %u\nfragsize: %u\n", - applied_attr->maxlength, applied_attr->tlength, applied_attr->prebuf, applied_attr->minreq, applied_attr->fragsize); - pas.attr = *applied_attr; - - return true; - -fail: - if (pas.stream != NULL) { - pa_stream_unref(pas.stream); - pas.stream = NULL; - } - if (pas.context != NULL) { - pa_context_disconnect(pas.context); - pa_context_unref(pas.context); - pas.context = NULL; - } - if (pas.mainloop != NULL) { - pa_mainloop_free(pas.mainloop); - pas.mainloop = NULL; - } - return false; -} - -static void pas_update_complete(UNUSED pa_stream *stream, UNUSED int success, void *userdata) { - *(bool *)userdata = true; -} - -static void pas_update(void) { - bool done = false; - pa_stream_update_timing_info(pas.stream, pas_update_complete, &done); - while (!done) { - pa_mainloop_iterate(pas.mainloop, true, NULL); - } -} - -static void pas_write_complete(UNUSED void *p) { - pas.write_complete = true; -} - -static int audio_pulse_buffered(void) { - if (pas.stream == NULL) { - return 0; - } - pas_update(); - const pa_timing_info *info = pa_stream_get_timing_info(pas.stream); - if (info == NULL) { - printf("pa_stream_get_timing_info failed, state is %d\n", pa_stream_get_state(pas.stream)); - } - /*int diff = info->write_index - info->read_index + (int)(info->sink_usec * 0.128); - pa_usec_t usec; - pa_stream_get_time(pas.stream, &usec); - int32_t t = info->timestamp.tv_sec * 1000000 + info->timestamp.tv_usec - (usec - info->transport_usec); - static int t0; - if (t0 == 0) t0 = t;*/ - - /*int r = pa_mainloop_iterate(pas.mainloop, false, NULL); - size_t ws = pa_stream_writable_size(pas.stream); - printf("Writable: %d (%d) %d %d %d %d %llu %d\n", (int)ws, r, (int)(info->write_index - info->read_index), diff, (int)info->sink_usec, (int)info->transport_usec, (unsigned long long)usec, t - t0);*/ - //return (pas.attr.tlength - ws) / 4; - return (info->write_index - info->read_index) / 4; -} - -static int audio_pulse_get_desired_buffered(void) { - return 1100; -} - -static void audio_pulse_play(const uint8_t *buf, size_t len) { - if (pas.stream == NULL) { - if (!audio_pulse_init()) { - return; - } - } - //size_t ws = pa_stream_writable_size(pas.stream); - size_t ws = pas.attr.maxlength - audio_pulse_buffered() * 4; - if (ws < len) { - //printf("Warning: can't write everything: %d vs %d\n", (int)len, (int)ws); - len = ws; - } - if (pa_stream_write(pas.stream, buf, len, pas_write_complete, 0LL, PA_SEEK_RELATIVE) < 0) { - printf("pa_stream_write failed\n"); - return; - } - while (!pas.write_complete) { - pa_mainloop_iterate(pas.mainloop, true, NULL); - } - pas.write_complete = false; -} - -struct AudioAPI audio_pulse = { - audio_pulse_init, - audio_pulse_buffered, - audio_pulse_get_desired_buffered, - audio_pulse_play -}; - -#endif diff --git a/src/decomp/pc/audio/audio_pulse.h b/src/decomp/pc/audio/audio_pulse.h deleted file mode 100644 index c4d7e4b..0000000 --- a/src/decomp/pc/audio/audio_pulse.h +++ /dev/null @@ -1,13 +0,0 @@ -#ifndef AUDIO_PULSE_H -#define AUDIO_PULSE_H - -#include "../compat.h" - -#if defined(__linux__) || defined(__BSD__) -extern struct AudioAPI audio_pulse; -#define HAVE_PULSE_AUDIO 1 -#else -#define HAVE_PULSE_AUDIO 0 -#endif - -#endif diff --git a/src/decomp/pc/audio/audio_wasapi.cpp b/src/decomp/pc/audio/audio_wasapi.cpp deleted file mode 100644 index 427d66a..0000000 --- a/src/decomp/pc/audio/audio_wasapi.cpp +++ /dev/null @@ -1,219 +0,0 @@ -#if defined(_WIN32) || defined(_WIN64) - -#include -#include - -#include -#include -#include -#include -#include - -#include "audio_api.h" - -#include "../../../debug_print.h" - -// These constants are currently missing from the MinGW headers. -#ifndef AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM -# define AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM 0x80000000 -#endif -#ifndef AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY -# define AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY 0x08000000 -#endif - -using namespace Microsoft::WRL; - -const CLSID CLSID_MMDeviceEnumerator = __uuidof(MMDeviceEnumerator); -const IID IID_IMMDeviceEnumerator = __uuidof(IMMDeviceEnumerator); -const IID IID_IAudioClient = __uuidof(IAudioClient); -const IID IID_IAudioRenderClient = __uuidof(IAudioRenderClient); - -static ComPtr immdev_enumerator; - -static struct WasapiState { - ComPtr device; - ComPtr client; - ComPtr rclient; - UINT32 buffer_frame_count; - bool initialized; - bool started; -} wasapi; - -static class NotificationClient : public IMMNotificationClient { - LONG refcount; -public: - NotificationClient() : refcount(1) { - } - - virtual HRESULT STDMETHODCALLTYPE OnDeviceStateChanged(LPCWSTR pwstrDeviceId, DWORD dwNewState) { - return S_OK; - } - - virtual HRESULT STDMETHODCALLTYPE OnDeviceAdded(LPCWSTR pwstrDeviceId) { - return S_OK; - } - - virtual HRESULT STDMETHODCALLTYPE OnDeviceRemoved(LPCWSTR pwstrDeviceId) { - return S_OK; - } - - virtual HRESULT STDMETHODCALLTYPE OnDefaultDeviceChanged(EDataFlow flow, ERole role, LPCWSTR pwstrDefaultDeviceId) { - if (flow == eRender && role == eConsole) { - // This callback runs on a separate thread, - // but it's not important how fast this write takes effect. - wasapi.initialized = false; - } - return S_OK; - } - - virtual HRESULT STDMETHODCALLTYPE OnPropertyValueChanged(LPCWSTR pwstrDeviceId, const PROPERTYKEY key) { - return S_OK; - } - - virtual ULONG STDMETHODCALLTYPE AddRef() { - return InterlockedIncrement(&refcount); - } - - virtual ULONG STDMETHODCALLTYPE Release() { - ULONG rc = InterlockedDecrement(&refcount); - if (rc == 0) { - delete this; - } - return rc; - } - - virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, VOID **ppvInterface) { - if (riid == __uuidof(IUnknown)) { - AddRef(); - *ppvInterface = (IUnknown *)this; - } else if (riid == __uuidof(IMMNotificationClient)) { - AddRef(); - *ppvInterface = (IMMNotificationClient *)this; - } else { - *ppvInterface = nullptr; - return E_NOINTERFACE; - } - return S_OK; - } -} notification_client; - -static void ThrowIfFailed(HRESULT res) { - if (FAILED(res)) { - throw res; - } -} - -bool audio_wasapi_init(void) { - CoInitialize(NULL); - //DEBUG_PRINT("audio init!!!"); - try { - ThrowIfFailed(CoCreateInstance(CLSID_MMDeviceEnumerator, nullptr, CLSCTX_ALL, IID_PPV_ARGS(&immdev_enumerator))); - } catch (HRESULT res) { - //DEBUG_PRINT("audio init fail!!! %d", res); - return false; - } - - ThrowIfFailed(immdev_enumerator->RegisterEndpointNotificationCallback(new NotificationClient())); - //DEBUG_PRINT("audio init OK!!!"); - return true; -} - -static bool audio_wasapi_setup_stream(void) { - //DEBUG_PRINT("audio audio_wasapi_setup_stream!!!"); - wasapi = WasapiState(); - - try { - ThrowIfFailed(immdev_enumerator->GetDefaultAudioEndpoint(eRender, eConsole, &wasapi.device)); - ThrowIfFailed(wasapi.device->Activate(IID_IAudioClient, CLSCTX_ALL, nullptr, IID_PPV_ARGS_Helper(&wasapi.client))); - - WAVEFORMATEX desired; - desired.wFormatTag = WAVE_FORMAT_PCM; - desired.nChannels = 2; - desired.nSamplesPerSec = 32000; - desired.nAvgBytesPerSec = 32000 * 2 * 2; - desired.nBlockAlign = 4; - desired.wBitsPerSample = 16; - desired.cbSize = 0; - - ThrowIfFailed(wasapi.client->Initialize(AUDCLNT_SHAREMODE_SHARED, AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM | AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY, 2000000, 0, &desired, nullptr)); - - ThrowIfFailed(wasapi.client->GetBufferSize(&wasapi.buffer_frame_count)); - ThrowIfFailed(wasapi.client->GetService(IID_PPV_ARGS(&wasapi.rclient))); - - wasapi.started = false; - wasapi.initialized = true; - } catch (HRESULT res) { - wasapi = WasapiState(); - return false; - } - - return true; -} - -static int audio_wasapi_buffered(void) { - //DEBUG_PRINT("audio audio_wasapi_buffered!!!"); - if (!wasapi.initialized) { - if (!audio_wasapi_setup_stream()) { - return 0; - } - } - try { - UINT32 padding; - ThrowIfFailed(wasapi.client->GetCurrentPadding(&padding)); - return padding; - } catch (HRESULT res) { - wasapi = WasapiState(); - return 0; - } -} - -static int audio_wasapi_get_desired_buffered(void) { - //DEBUG_PRINT("audio audio_wasapi_get_desired_buffered!!!"); - return 1100; -} - -//#include -static void audio_wasapi_play(const uint8_t *buf, size_t len) { - //DEBUG_PRINT("audio audio_wasapi_play!!!"); - if (!wasapi.initialized) { - if (!audio_wasapi_setup_stream()) { - return; - } - } - try { - UINT32 frames = len / 4; - - UINT32 padding; - ThrowIfFailed(wasapi.client->GetCurrentPadding(&padding)); - if(padding >= 5400) - return; - //printf("%u %u\n", frames, padding); - - UINT32 available = wasapi.buffer_frame_count - padding; - if (available < frames) { - frames = available; - - } - - BYTE *data; - ThrowIfFailed(wasapi.rclient->GetBuffer(frames, &data)); - memcpy(data, buf, frames * 4); - ThrowIfFailed(wasapi.rclient->ReleaseBuffer(frames, 0)); - - if (!wasapi.started && padding + frames > 1500) { - wasapi.started = true; - ThrowIfFailed(wasapi.client->Start()); - } - } catch (HRESULT res) { - wasapi = WasapiState(); - } -} - -struct AudioAPI audio_wasapi = { - audio_wasapi_init, - audio_wasapi_buffered, - audio_wasapi_get_desired_buffered, - audio_wasapi_play -}; - -#endif diff --git a/src/decomp/pc/audio/audio_wasapi.h b/src/decomp/pc/audio/audio_wasapi.h deleted file mode 100644 index b0aab11..0000000 --- a/src/decomp/pc/audio/audio_wasapi.h +++ /dev/null @@ -1,12 +0,0 @@ -#ifndef AUDIO_WASAPI_H -#define AUDIO_WASAPI_H - -#if defined(_WIN32) || defined(_WIN64) -#include "audio_api.h" -extern struct AudioAPI audio_wasapi; -#define HAVE_WASAPI 1 -#else -#define HAVE_WASAPI 0 -#endif - -#endif diff --git a/src/decomp/pc/gfx/LICENSE.txt b/src/decomp/pc/gfx/LICENSE.txt deleted file mode 100644 index 5a1a079..0000000 --- a/src/decomp/pc/gfx/LICENSE.txt +++ /dev/null @@ -1,19 +0,0 @@ -Copyright (c) 2020 Emill, MaikelChan - -Redistribution and use in source forms, with or without modification, -are permitted provided that the following conditions are met: - -1. Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. -2. Redistributions in binary form are not allowed. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR -ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND -ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/src/decomp/pc/gfx/README.md b/src/decomp/pc/gfx/README.md deleted file mode 100644 index 3f36b1c..0000000 --- a/src/decomp/pc/gfx/README.md +++ /dev/null @@ -1,33 +0,0 @@ -# Nintendo 64 Fast3D renderer - -Implementation of a Fast3D renderer for games built originally for the Nintendo 64 platform. - -For rendering OpenGL, Direct3D 11 and Direct3D 12 are supported. - -Supported windowing systems are GLX (used on Linux), DXGI (used on Windows) and SDL (generic). - -# Usage - -See `gfx_pc.h`. You will also need a copy of `PR/gbi.h`, found in libultra. - -First call `gfx_init(struct GfxWindowManagerAPI *wapi, struct GfxRenderingAPI *rapi, const char *game_name, bool start_in_fullscreen)` and supply the desired backends at program start. - -Some callbacks can be set on `wapi`. See `gfx_window_manager_api.h` for more info. - -Each game main loop iteration should look like this: - -```C -gfx_start_frame(); // Handles input events such as keyboard and window events -// perform game logic here -gfx_run(cmds); // submit display list and render a frame -// do more expensive work here, such as play audio -gfx_end_frame(); // this just waits until the frame is shown on the screen (vsync), to provide correct game timing -``` - -When you are ready to start the main loop, call `wapi->main_loop(one_iteration_func)`. - -For the best experience, please change the Vtx and Mtx structures to use floats instead of fixed point arithmetic (`GBI_FLOATS`). - -# License - -See LICENSE.txt. Redistributions are allowed only in source form, not in binary form. diff --git a/src/decomp/pc/gfx/dxsdk/d3d12.h b/src/decomp/pc/gfx/dxsdk/d3d12.h deleted file mode 100644 index 06e98dc..0000000 --- a/src/decomp/pc/gfx/dxsdk/d3d12.h +++ /dev/null @@ -1,17258 +0,0 @@ -/*------------------------------------------------------------------------------------- - * - * Copyright (c) Microsoft Corporation - * - *-------------------------------------------------------------------------------------*/ - - -/* this ALWAYS GENERATED file contains the definitions for the interfaces */ - - - /* File created by MIDL compiler version 8.01.0622 */ - - - -/* verify that the version is high enough to compile this file*/ -#ifndef __REQUIRED_RPCNDR_H_VERSION__ -#define __REQUIRED_RPCNDR_H_VERSION__ 500 -#endif - -/* verify that the version is high enough to compile this file*/ -#ifndef __REQUIRED_RPCSAL_H_VERSION__ -#define __REQUIRED_RPCSAL_H_VERSION__ 100 -#endif - -#include "rpc.h" -#include "rpcndr.h" - -#ifndef __RPCNDR_H_VERSION__ -#error this stub requires an updated version of -#endif /* __RPCNDR_H_VERSION__ */ - -#ifndef COM_NO_WINDOWS_H -#include "windows.h" -#include "ole2.h" -#endif /*COM_NO_WINDOWS_H*/ - -#ifndef __d3d12_h__ -#define __d3d12_h__ - -#if defined(_MSC_VER) && (_MSC_VER >= 1020) -#pragma once -#endif - -/* Forward Declarations */ - -#ifndef __ID3D12Object_FWD_DEFINED__ -#define __ID3D12Object_FWD_DEFINED__ -typedef interface ID3D12Object ID3D12Object; - -#endif /* __ID3D12Object_FWD_DEFINED__ */ - - -#ifndef __ID3D12DeviceChild_FWD_DEFINED__ -#define __ID3D12DeviceChild_FWD_DEFINED__ -typedef interface ID3D12DeviceChild ID3D12DeviceChild; - -#endif /* __ID3D12DeviceChild_FWD_DEFINED__ */ - - -#ifndef __ID3D12RootSignature_FWD_DEFINED__ -#define __ID3D12RootSignature_FWD_DEFINED__ -typedef interface ID3D12RootSignature ID3D12RootSignature; - -#endif /* __ID3D12RootSignature_FWD_DEFINED__ */ - - -#ifndef __ID3D12RootSignatureDeserializer_FWD_DEFINED__ -#define __ID3D12RootSignatureDeserializer_FWD_DEFINED__ -typedef interface ID3D12RootSignatureDeserializer ID3D12RootSignatureDeserializer; - -#endif /* __ID3D12RootSignatureDeserializer_FWD_DEFINED__ */ - - -#ifndef __ID3D12VersionedRootSignatureDeserializer_FWD_DEFINED__ -#define __ID3D12VersionedRootSignatureDeserializer_FWD_DEFINED__ -typedef interface ID3D12VersionedRootSignatureDeserializer ID3D12VersionedRootSignatureDeserializer; - -#endif /* __ID3D12VersionedRootSignatureDeserializer_FWD_DEFINED__ */ - - -#ifndef __ID3D12Pageable_FWD_DEFINED__ -#define __ID3D12Pageable_FWD_DEFINED__ -typedef interface ID3D12Pageable ID3D12Pageable; - -#endif /* __ID3D12Pageable_FWD_DEFINED__ */ - - -#ifndef __ID3D12Heap_FWD_DEFINED__ -#define __ID3D12Heap_FWD_DEFINED__ -typedef interface ID3D12Heap ID3D12Heap; - -#endif /* __ID3D12Heap_FWD_DEFINED__ */ - - -#ifndef __ID3D12Resource_FWD_DEFINED__ -#define __ID3D12Resource_FWD_DEFINED__ -typedef interface ID3D12Resource ID3D12Resource; - -#endif /* __ID3D12Resource_FWD_DEFINED__ */ - - -#ifndef __ID3D12CommandAllocator_FWD_DEFINED__ -#define __ID3D12CommandAllocator_FWD_DEFINED__ -typedef interface ID3D12CommandAllocator ID3D12CommandAllocator; - -#endif /* __ID3D12CommandAllocator_FWD_DEFINED__ */ - - -#ifndef __ID3D12Fence_FWD_DEFINED__ -#define __ID3D12Fence_FWD_DEFINED__ -typedef interface ID3D12Fence ID3D12Fence; - -#endif /* __ID3D12Fence_FWD_DEFINED__ */ - - -#ifndef __ID3D12Fence1_FWD_DEFINED__ -#define __ID3D12Fence1_FWD_DEFINED__ -typedef interface ID3D12Fence1 ID3D12Fence1; - -#endif /* __ID3D12Fence1_FWD_DEFINED__ */ - - -#ifndef __ID3D12PipelineState_FWD_DEFINED__ -#define __ID3D12PipelineState_FWD_DEFINED__ -typedef interface ID3D12PipelineState ID3D12PipelineState; - -#endif /* __ID3D12PipelineState_FWD_DEFINED__ */ - - -#ifndef __ID3D12DescriptorHeap_FWD_DEFINED__ -#define __ID3D12DescriptorHeap_FWD_DEFINED__ -typedef interface ID3D12DescriptorHeap ID3D12DescriptorHeap; - -#endif /* __ID3D12DescriptorHeap_FWD_DEFINED__ */ - - -#ifndef __ID3D12QueryHeap_FWD_DEFINED__ -#define __ID3D12QueryHeap_FWD_DEFINED__ -typedef interface ID3D12QueryHeap ID3D12QueryHeap; - -#endif /* __ID3D12QueryHeap_FWD_DEFINED__ */ - - -#ifndef __ID3D12CommandSignature_FWD_DEFINED__ -#define __ID3D12CommandSignature_FWD_DEFINED__ -typedef interface ID3D12CommandSignature ID3D12CommandSignature; - -#endif /* __ID3D12CommandSignature_FWD_DEFINED__ */ - - -#ifndef __ID3D12CommandList_FWD_DEFINED__ -#define __ID3D12CommandList_FWD_DEFINED__ -typedef interface ID3D12CommandList ID3D12CommandList; - -#endif /* __ID3D12CommandList_FWD_DEFINED__ */ - - -#ifndef __ID3D12GraphicsCommandList_FWD_DEFINED__ -#define __ID3D12GraphicsCommandList_FWD_DEFINED__ -typedef interface ID3D12GraphicsCommandList ID3D12GraphicsCommandList; - -#endif /* __ID3D12GraphicsCommandList_FWD_DEFINED__ */ - - -#ifndef __ID3D12GraphicsCommandList1_FWD_DEFINED__ -#define __ID3D12GraphicsCommandList1_FWD_DEFINED__ -typedef interface ID3D12GraphicsCommandList1 ID3D12GraphicsCommandList1; - -#endif /* __ID3D12GraphicsCommandList1_FWD_DEFINED__ */ - - -#ifndef __ID3D12GraphicsCommandList2_FWD_DEFINED__ -#define __ID3D12GraphicsCommandList2_FWD_DEFINED__ -typedef interface ID3D12GraphicsCommandList2 ID3D12GraphicsCommandList2; - -#endif /* __ID3D12GraphicsCommandList2_FWD_DEFINED__ */ - - -#ifndef __ID3D12CommandQueue_FWD_DEFINED__ -#define __ID3D12CommandQueue_FWD_DEFINED__ -typedef interface ID3D12CommandQueue ID3D12CommandQueue; - -#endif /* __ID3D12CommandQueue_FWD_DEFINED__ */ - - -#ifndef __ID3D12Device_FWD_DEFINED__ -#define __ID3D12Device_FWD_DEFINED__ -typedef interface ID3D12Device ID3D12Device; - -#endif /* __ID3D12Device_FWD_DEFINED__ */ - - -#ifndef __ID3D12PipelineLibrary_FWD_DEFINED__ -#define __ID3D12PipelineLibrary_FWD_DEFINED__ -typedef interface ID3D12PipelineLibrary ID3D12PipelineLibrary; - -#endif /* __ID3D12PipelineLibrary_FWD_DEFINED__ */ - - -#ifndef __ID3D12PipelineLibrary1_FWD_DEFINED__ -#define __ID3D12PipelineLibrary1_FWD_DEFINED__ -typedef interface ID3D12PipelineLibrary1 ID3D12PipelineLibrary1; - -#endif /* __ID3D12PipelineLibrary1_FWD_DEFINED__ */ - - -#ifndef __ID3D12Device1_FWD_DEFINED__ -#define __ID3D12Device1_FWD_DEFINED__ -typedef interface ID3D12Device1 ID3D12Device1; - -#endif /* __ID3D12Device1_FWD_DEFINED__ */ - - -#ifndef __ID3D12Device2_FWD_DEFINED__ -#define __ID3D12Device2_FWD_DEFINED__ -typedef interface ID3D12Device2 ID3D12Device2; - -#endif /* __ID3D12Device2_FWD_DEFINED__ */ - - -#ifndef __ID3D12Device3_FWD_DEFINED__ -#define __ID3D12Device3_FWD_DEFINED__ -typedef interface ID3D12Device3 ID3D12Device3; - -#endif /* __ID3D12Device3_FWD_DEFINED__ */ - - -#ifndef __ID3D12ProtectedSession_FWD_DEFINED__ -#define __ID3D12ProtectedSession_FWD_DEFINED__ -typedef interface ID3D12ProtectedSession ID3D12ProtectedSession; - -#endif /* __ID3D12ProtectedSession_FWD_DEFINED__ */ - - -#ifndef __ID3D12ProtectedResourceSession_FWD_DEFINED__ -#define __ID3D12ProtectedResourceSession_FWD_DEFINED__ -typedef interface ID3D12ProtectedResourceSession ID3D12ProtectedResourceSession; - -#endif /* __ID3D12ProtectedResourceSession_FWD_DEFINED__ */ - - -#ifndef __ID3D12Device4_FWD_DEFINED__ -#define __ID3D12Device4_FWD_DEFINED__ -typedef interface ID3D12Device4 ID3D12Device4; - -#endif /* __ID3D12Device4_FWD_DEFINED__ */ - - -#ifndef __ID3D12LifetimeOwner_FWD_DEFINED__ -#define __ID3D12LifetimeOwner_FWD_DEFINED__ -typedef interface ID3D12LifetimeOwner ID3D12LifetimeOwner; - -#endif /* __ID3D12LifetimeOwner_FWD_DEFINED__ */ - - -#ifndef __ID3D12SwapChainAssistant_FWD_DEFINED__ -#define __ID3D12SwapChainAssistant_FWD_DEFINED__ -typedef interface ID3D12SwapChainAssistant ID3D12SwapChainAssistant; - -#endif /* __ID3D12SwapChainAssistant_FWD_DEFINED__ */ - - -#ifndef __ID3D12LifetimeTracker_FWD_DEFINED__ -#define __ID3D12LifetimeTracker_FWD_DEFINED__ -typedef interface ID3D12LifetimeTracker ID3D12LifetimeTracker; - -#endif /* __ID3D12LifetimeTracker_FWD_DEFINED__ */ - - -#ifndef __ID3D12StateObject_FWD_DEFINED__ -#define __ID3D12StateObject_FWD_DEFINED__ -typedef interface ID3D12StateObject ID3D12StateObject; - -#endif /* __ID3D12StateObject_FWD_DEFINED__ */ - - -#ifndef __ID3D12StateObjectProperties_FWD_DEFINED__ -#define __ID3D12StateObjectProperties_FWD_DEFINED__ -typedef interface ID3D12StateObjectProperties ID3D12StateObjectProperties; - -#endif /* __ID3D12StateObjectProperties_FWD_DEFINED__ */ - - -#ifndef __ID3D12Device5_FWD_DEFINED__ -#define __ID3D12Device5_FWD_DEFINED__ -typedef interface ID3D12Device5 ID3D12Device5; - -#endif /* __ID3D12Device5_FWD_DEFINED__ */ - - -#ifndef __ID3D12DeviceRemovedExtendedDataSettings_FWD_DEFINED__ -#define __ID3D12DeviceRemovedExtendedDataSettings_FWD_DEFINED__ -typedef interface ID3D12DeviceRemovedExtendedDataSettings ID3D12DeviceRemovedExtendedDataSettings; - -#endif /* __ID3D12DeviceRemovedExtendedDataSettings_FWD_DEFINED__ */ - - -#ifndef __ID3D12DeviceRemovedExtendedData_FWD_DEFINED__ -#define __ID3D12DeviceRemovedExtendedData_FWD_DEFINED__ -typedef interface ID3D12DeviceRemovedExtendedData ID3D12DeviceRemovedExtendedData; - -#endif /* __ID3D12DeviceRemovedExtendedData_FWD_DEFINED__ */ - - -#ifndef __ID3D12Device6_FWD_DEFINED__ -#define __ID3D12Device6_FWD_DEFINED__ -typedef interface ID3D12Device6 ID3D12Device6; - -#endif /* __ID3D12Device6_FWD_DEFINED__ */ - - -#ifndef __ID3D12Resource1_FWD_DEFINED__ -#define __ID3D12Resource1_FWD_DEFINED__ -typedef interface ID3D12Resource1 ID3D12Resource1; - -#endif /* __ID3D12Resource1_FWD_DEFINED__ */ - - -#ifndef __ID3D12Heap1_FWD_DEFINED__ -#define __ID3D12Heap1_FWD_DEFINED__ -typedef interface ID3D12Heap1 ID3D12Heap1; - -#endif /* __ID3D12Heap1_FWD_DEFINED__ */ - - -#ifndef __ID3D12GraphicsCommandList3_FWD_DEFINED__ -#define __ID3D12GraphicsCommandList3_FWD_DEFINED__ -typedef interface ID3D12GraphicsCommandList3 ID3D12GraphicsCommandList3; - -#endif /* __ID3D12GraphicsCommandList3_FWD_DEFINED__ */ - - -#ifndef __ID3D12MetaCommand_FWD_DEFINED__ -#define __ID3D12MetaCommand_FWD_DEFINED__ -typedef interface ID3D12MetaCommand ID3D12MetaCommand; - -#endif /* __ID3D12MetaCommand_FWD_DEFINED__ */ - - -#ifndef __ID3D12GraphicsCommandList4_FWD_DEFINED__ -#define __ID3D12GraphicsCommandList4_FWD_DEFINED__ -typedef interface ID3D12GraphicsCommandList4 ID3D12GraphicsCommandList4; - -#endif /* __ID3D12GraphicsCommandList4_FWD_DEFINED__ */ - - -#ifndef __ID3D12Tools_FWD_DEFINED__ -#define __ID3D12Tools_FWD_DEFINED__ -typedef interface ID3D12Tools ID3D12Tools; - -#endif /* __ID3D12Tools_FWD_DEFINED__ */ - - -#ifndef __ID3D12GraphicsCommandList5_FWD_DEFINED__ -#define __ID3D12GraphicsCommandList5_FWD_DEFINED__ -typedef interface ID3D12GraphicsCommandList5 ID3D12GraphicsCommandList5; - -#endif /* __ID3D12GraphicsCommandList5_FWD_DEFINED__ */ - - -/* header files for imported files */ -#include "oaidl.h" -#include "ocidl.h" -#include "dxgicommon.h" -#include "dxgiformat.h" -#include "d3dcommon.h" - -#ifdef __cplusplus -extern "C"{ -#endif - - -/* interface __MIDL_itf_d3d12_0000_0000 */ -/* [local] */ - -#include -#pragma region App Family -#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) -#ifndef _D3D12_CONSTANTS -#define _D3D12_CONSTANTS -#define D3D12_16BIT_INDEX_STRIP_CUT_VALUE ( 0xffff ) - -#define D3D12_32BIT_INDEX_STRIP_CUT_VALUE ( 0xffffffff ) - -#define D3D12_8BIT_INDEX_STRIP_CUT_VALUE ( 0xff ) - -#define D3D12_APPEND_ALIGNED_ELEMENT ( 0xffffffff ) - -#define D3D12_ARRAY_AXIS_ADDRESS_RANGE_BIT_COUNT ( 9 ) - -#define D3D12_CLIP_OR_CULL_DISTANCE_COUNT ( 8 ) - -#define D3D12_CLIP_OR_CULL_DISTANCE_ELEMENT_COUNT ( 2 ) - -#define D3D12_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT ( 14 ) - -#define D3D12_COMMONSHADER_CONSTANT_BUFFER_COMPONENTS ( 4 ) - -#define D3D12_COMMONSHADER_CONSTANT_BUFFER_COMPONENT_BIT_COUNT ( 32 ) - -#define D3D12_COMMONSHADER_CONSTANT_BUFFER_HW_SLOT_COUNT ( 15 ) - -#define D3D12_COMMONSHADER_CONSTANT_BUFFER_PARTIAL_UPDATE_EXTENTS_BYTE_ALIGNMENT ( 16 ) - -#define D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COMPONENTS ( 4 ) - -#define D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COUNT ( 15 ) - -#define D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READS_PER_INST ( 1 ) - -#define D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READ_PORTS ( 1 ) - -#define D3D12_COMMONSHADER_FLOWCONTROL_NESTING_LIMIT ( 64 ) - -#define D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COMPONENTS ( 4 ) - -#define D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COUNT ( 1 ) - -#define D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READS_PER_INST ( 1 ) - -#define D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READ_PORTS ( 1 ) - -#define D3D12_COMMONSHADER_IMMEDIATE_VALUE_COMPONENT_BIT_COUNT ( 32 ) - -#define D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_COMPONENTS ( 1 ) - -#define D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_COUNT ( 128 ) - -#define D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_READS_PER_INST ( 1 ) - -#define D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_READ_PORTS ( 1 ) - -#define D3D12_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT ( 128 ) - -#define D3D12_COMMONSHADER_SAMPLER_REGISTER_COMPONENTS ( 1 ) - -#define D3D12_COMMONSHADER_SAMPLER_REGISTER_COUNT ( 16 ) - -#define D3D12_COMMONSHADER_SAMPLER_REGISTER_READS_PER_INST ( 1 ) - -#define D3D12_COMMONSHADER_SAMPLER_REGISTER_READ_PORTS ( 1 ) - -#define D3D12_COMMONSHADER_SAMPLER_SLOT_COUNT ( 16 ) - -#define D3D12_COMMONSHADER_SUBROUTINE_NESTING_LIMIT ( 32 ) - -#define D3D12_COMMONSHADER_TEMP_REGISTER_COMPONENTS ( 4 ) - -#define D3D12_COMMONSHADER_TEMP_REGISTER_COMPONENT_BIT_COUNT ( 32 ) - -#define D3D12_COMMONSHADER_TEMP_REGISTER_COUNT ( 4096 ) - -#define D3D12_COMMONSHADER_TEMP_REGISTER_READS_PER_INST ( 3 ) - -#define D3D12_COMMONSHADER_TEMP_REGISTER_READ_PORTS ( 3 ) - -#define D3D12_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MAX ( 10 ) - -#define D3D12_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MIN ( -10 ) - -#define D3D12_COMMONSHADER_TEXEL_OFFSET_MAX_NEGATIVE ( -8 ) - -#define D3D12_COMMONSHADER_TEXEL_OFFSET_MAX_POSITIVE ( 7 ) - -#define D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT ( 256 ) - -#define D3D12_CS_4_X_BUCKET00_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 256 ) - -#define D3D12_CS_4_X_BUCKET00_MAX_NUM_THREADS_PER_GROUP ( 64 ) - -#define D3D12_CS_4_X_BUCKET01_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 240 ) - -#define D3D12_CS_4_X_BUCKET01_MAX_NUM_THREADS_PER_GROUP ( 68 ) - -#define D3D12_CS_4_X_BUCKET02_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 224 ) - -#define D3D12_CS_4_X_BUCKET02_MAX_NUM_THREADS_PER_GROUP ( 72 ) - -#define D3D12_CS_4_X_BUCKET03_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 208 ) - -#define D3D12_CS_4_X_BUCKET03_MAX_NUM_THREADS_PER_GROUP ( 76 ) - -#define D3D12_CS_4_X_BUCKET04_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 192 ) - -#define D3D12_CS_4_X_BUCKET04_MAX_NUM_THREADS_PER_GROUP ( 84 ) - -#define D3D12_CS_4_X_BUCKET05_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 176 ) - -#define D3D12_CS_4_X_BUCKET05_MAX_NUM_THREADS_PER_GROUP ( 92 ) - -#define D3D12_CS_4_X_BUCKET06_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 160 ) - -#define D3D12_CS_4_X_BUCKET06_MAX_NUM_THREADS_PER_GROUP ( 100 ) - -#define D3D12_CS_4_X_BUCKET07_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 144 ) - -#define D3D12_CS_4_X_BUCKET07_MAX_NUM_THREADS_PER_GROUP ( 112 ) - -#define D3D12_CS_4_X_BUCKET08_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 128 ) - -#define D3D12_CS_4_X_BUCKET08_MAX_NUM_THREADS_PER_GROUP ( 128 ) - -#define D3D12_CS_4_X_BUCKET09_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 112 ) - -#define D3D12_CS_4_X_BUCKET09_MAX_NUM_THREADS_PER_GROUP ( 144 ) - -#define D3D12_CS_4_X_BUCKET10_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 96 ) - -#define D3D12_CS_4_X_BUCKET10_MAX_NUM_THREADS_PER_GROUP ( 168 ) - -#define D3D12_CS_4_X_BUCKET11_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 80 ) - -#define D3D12_CS_4_X_BUCKET11_MAX_NUM_THREADS_PER_GROUP ( 204 ) - -#define D3D12_CS_4_X_BUCKET12_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 64 ) - -#define D3D12_CS_4_X_BUCKET12_MAX_NUM_THREADS_PER_GROUP ( 256 ) - -#define D3D12_CS_4_X_BUCKET13_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 48 ) - -#define D3D12_CS_4_X_BUCKET13_MAX_NUM_THREADS_PER_GROUP ( 340 ) - -#define D3D12_CS_4_X_BUCKET14_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 32 ) - -#define D3D12_CS_4_X_BUCKET14_MAX_NUM_THREADS_PER_GROUP ( 512 ) - -#define D3D12_CS_4_X_BUCKET15_MAX_BYTES_TGSM_WRITABLE_PER_THREAD ( 16 ) - -#define D3D12_CS_4_X_BUCKET15_MAX_NUM_THREADS_PER_GROUP ( 768 ) - -#define D3D12_CS_4_X_DISPATCH_MAX_THREAD_GROUPS_IN_Z_DIMENSION ( 1 ) - -#define D3D12_CS_4_X_RAW_UAV_BYTE_ALIGNMENT ( 256 ) - -#define D3D12_CS_4_X_THREAD_GROUP_MAX_THREADS_PER_GROUP ( 768 ) - -#define D3D12_CS_4_X_THREAD_GROUP_MAX_X ( 768 ) - -#define D3D12_CS_4_X_THREAD_GROUP_MAX_Y ( 768 ) - -#define D3D12_CS_4_X_UAV_REGISTER_COUNT ( 1 ) - -#define D3D12_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION ( 65535 ) - -#define D3D12_CS_TGSM_REGISTER_COUNT ( 8192 ) - -#define D3D12_CS_TGSM_REGISTER_READS_PER_INST ( 1 ) - -#define D3D12_CS_TGSM_RESOURCE_REGISTER_COMPONENTS ( 1 ) - -#define D3D12_CS_TGSM_RESOURCE_REGISTER_READ_PORTS ( 1 ) - -#define D3D12_CS_THREADGROUPID_REGISTER_COMPONENTS ( 3 ) - -#define D3D12_CS_THREADGROUPID_REGISTER_COUNT ( 1 ) - -#define D3D12_CS_THREADIDINGROUPFLATTENED_REGISTER_COMPONENTS ( 1 ) - -#define D3D12_CS_THREADIDINGROUPFLATTENED_REGISTER_COUNT ( 1 ) - -#define D3D12_CS_THREADIDINGROUP_REGISTER_COMPONENTS ( 3 ) - -#define D3D12_CS_THREADIDINGROUP_REGISTER_COUNT ( 1 ) - -#define D3D12_CS_THREADID_REGISTER_COMPONENTS ( 3 ) - -#define D3D12_CS_THREADID_REGISTER_COUNT ( 1 ) - -#define D3D12_CS_THREAD_GROUP_MAX_THREADS_PER_GROUP ( 1024 ) - -#define D3D12_CS_THREAD_GROUP_MAX_X ( 1024 ) - -#define D3D12_CS_THREAD_GROUP_MAX_Y ( 1024 ) - -#define D3D12_CS_THREAD_GROUP_MAX_Z ( 64 ) - -#define D3D12_CS_THREAD_GROUP_MIN_X ( 1 ) - -#define D3D12_CS_THREAD_GROUP_MIN_Y ( 1 ) - -#define D3D12_CS_THREAD_GROUP_MIN_Z ( 1 ) - -#define D3D12_CS_THREAD_LOCAL_TEMP_REGISTER_POOL ( 16384 ) - -#define D3D12_DEFAULT_BLEND_FACTOR_ALPHA ( 1.0f ) -#define D3D12_DEFAULT_BLEND_FACTOR_BLUE ( 1.0f ) -#define D3D12_DEFAULT_BLEND_FACTOR_GREEN ( 1.0f ) -#define D3D12_DEFAULT_BLEND_FACTOR_RED ( 1.0f ) -#define D3D12_DEFAULT_BORDER_COLOR_COMPONENT ( 0.0f ) -#define D3D12_DEFAULT_DEPTH_BIAS ( 0 ) - -#define D3D12_DEFAULT_DEPTH_BIAS_CLAMP ( 0.0f ) -#define D3D12_DEFAULT_MAX_ANISOTROPY ( 16 ) - -#define D3D12_DEFAULT_MIP_LOD_BIAS ( 0.0f ) -#define D3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENT ( 4194304 ) - -#define D3D12_DEFAULT_RENDER_TARGET_ARRAY_INDEX ( 0 ) - -#define D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT ( 65536 ) - -#define D3D12_DEFAULT_SAMPLE_MASK ( 0xffffffff ) - -#define D3D12_DEFAULT_SCISSOR_ENDX ( 0 ) - -#define D3D12_DEFAULT_SCISSOR_ENDY ( 0 ) - -#define D3D12_DEFAULT_SCISSOR_STARTX ( 0 ) - -#define D3D12_DEFAULT_SCISSOR_STARTY ( 0 ) - -#define D3D12_DEFAULT_SLOPE_SCALED_DEPTH_BIAS ( 0.0f ) -#define D3D12_DEFAULT_STENCIL_READ_MASK ( 0xff ) - -#define D3D12_DEFAULT_STENCIL_REFERENCE ( 0 ) - -#define D3D12_DEFAULT_STENCIL_WRITE_MASK ( 0xff ) - -#define D3D12_DEFAULT_VIEWPORT_AND_SCISSORRECT_INDEX ( 0 ) - -#define D3D12_DEFAULT_VIEWPORT_HEIGHT ( 0 ) - -#define D3D12_DEFAULT_VIEWPORT_MAX_DEPTH ( 0.0f ) -#define D3D12_DEFAULT_VIEWPORT_MIN_DEPTH ( 0.0f ) -#define D3D12_DEFAULT_VIEWPORT_TOPLEFTX ( 0 ) - -#define D3D12_DEFAULT_VIEWPORT_TOPLEFTY ( 0 ) - -#define D3D12_DEFAULT_VIEWPORT_WIDTH ( 0 ) - -#define D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND ( 0xffffffff ) - -#define D3D12_DRIVER_RESERVED_REGISTER_SPACE_VALUES_END ( 0xfffffff7 ) - -#define D3D12_DRIVER_RESERVED_REGISTER_SPACE_VALUES_START ( 0xfffffff0 ) - -#define D3D12_DS_INPUT_CONTROL_POINTS_MAX_TOTAL_SCALARS ( 3968 ) - -#define D3D12_DS_INPUT_CONTROL_POINT_REGISTER_COMPONENTS ( 4 ) - -#define D3D12_DS_INPUT_CONTROL_POINT_REGISTER_COMPONENT_BIT_COUNT ( 32 ) - -#define D3D12_DS_INPUT_CONTROL_POINT_REGISTER_COUNT ( 32 ) - -#define D3D12_DS_INPUT_CONTROL_POINT_REGISTER_READS_PER_INST ( 2 ) - -#define D3D12_DS_INPUT_CONTROL_POINT_REGISTER_READ_PORTS ( 1 ) - -#define D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_COMPONENTS ( 3 ) - -#define D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_COMPONENT_BIT_COUNT ( 32 ) - -#define D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_COUNT ( 1 ) - -#define D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_READS_PER_INST ( 2 ) - -#define D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_READ_PORTS ( 1 ) - -#define D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_COMPONENTS ( 4 ) - -#define D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_COMPONENT_BIT_COUNT ( 32 ) - -#define D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_COUNT ( 32 ) - -#define D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_READS_PER_INST ( 2 ) - -#define D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_READ_PORTS ( 1 ) - -#define D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENTS ( 1 ) - -#define D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENT_BIT_COUNT ( 32 ) - -#define D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_COUNT ( 1 ) - -#define D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_READS_PER_INST ( 2 ) - -#define D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_READ_PORTS ( 1 ) - -#define D3D12_DS_OUTPUT_REGISTER_COMPONENTS ( 4 ) - -#define D3D12_DS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT ( 32 ) - -#define D3D12_DS_OUTPUT_REGISTER_COUNT ( 32 ) - -#define D3D12_FLOAT16_FUSED_TOLERANCE_IN_ULP ( 0.6 ) -#define D3D12_FLOAT32_MAX ( 3.402823466e+38f ) -#define D3D12_FLOAT32_TO_INTEGER_TOLERANCE_IN_ULP ( 0.6f ) -#define D3D12_FLOAT_TO_SRGB_EXPONENT_DENOMINATOR ( 2.4f ) -#define D3D12_FLOAT_TO_SRGB_EXPONENT_NUMERATOR ( 1.0f ) -#define D3D12_FLOAT_TO_SRGB_OFFSET ( 0.055f ) -#define D3D12_FLOAT_TO_SRGB_SCALE_1 ( 12.92f ) -#define D3D12_FLOAT_TO_SRGB_SCALE_2 ( 1.055f ) -#define D3D12_FLOAT_TO_SRGB_THRESHOLD ( 0.0031308f ) -#define D3D12_FTOI_INSTRUCTION_MAX_INPUT ( 2147483647.999f ) -#define D3D12_FTOI_INSTRUCTION_MIN_INPUT ( -2147483648.999f ) -#define D3D12_FTOU_INSTRUCTION_MAX_INPUT ( 4294967295.999f ) -#define D3D12_FTOU_INSTRUCTION_MIN_INPUT ( 0.0f ) -#define D3D12_GS_INPUT_INSTANCE_ID_READS_PER_INST ( 2 ) - -#define D3D12_GS_INPUT_INSTANCE_ID_READ_PORTS ( 1 ) - -#define D3D12_GS_INPUT_INSTANCE_ID_REGISTER_COMPONENTS ( 1 ) - -#define D3D12_GS_INPUT_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNT ( 32 ) - -#define D3D12_GS_INPUT_INSTANCE_ID_REGISTER_COUNT ( 1 ) - -#define D3D12_GS_INPUT_PRIM_CONST_REGISTER_COMPONENTS ( 1 ) - -#define D3D12_GS_INPUT_PRIM_CONST_REGISTER_COMPONENT_BIT_COUNT ( 32 ) - -#define D3D12_GS_INPUT_PRIM_CONST_REGISTER_COUNT ( 1 ) - -#define D3D12_GS_INPUT_PRIM_CONST_REGISTER_READS_PER_INST ( 2 ) - -#define D3D12_GS_INPUT_PRIM_CONST_REGISTER_READ_PORTS ( 1 ) - -#define D3D12_GS_INPUT_REGISTER_COMPONENTS ( 4 ) - -#define D3D12_GS_INPUT_REGISTER_COMPONENT_BIT_COUNT ( 32 ) - -#define D3D12_GS_INPUT_REGISTER_COUNT ( 32 ) - -#define D3D12_GS_INPUT_REGISTER_READS_PER_INST ( 2 ) - -#define D3D12_GS_INPUT_REGISTER_READ_PORTS ( 1 ) - -#define D3D12_GS_INPUT_REGISTER_VERTICES ( 32 ) - -#define D3D12_GS_MAX_INSTANCE_COUNT ( 32 ) - -#define D3D12_GS_MAX_OUTPUT_VERTEX_COUNT_ACROSS_INSTANCES ( 1024 ) - -#define D3D12_GS_OUTPUT_ELEMENTS ( 32 ) - -#define D3D12_GS_OUTPUT_REGISTER_COMPONENTS ( 4 ) - -#define D3D12_GS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT ( 32 ) - -#define D3D12_GS_OUTPUT_REGISTER_COUNT ( 32 ) - -#define D3D12_HS_CONTROL_POINT_PHASE_INPUT_REGISTER_COUNT ( 32 ) - -#define D3D12_HS_CONTROL_POINT_PHASE_OUTPUT_REGISTER_COUNT ( 32 ) - -#define D3D12_HS_CONTROL_POINT_REGISTER_COMPONENTS ( 4 ) - -#define D3D12_HS_CONTROL_POINT_REGISTER_COMPONENT_BIT_COUNT ( 32 ) - -#define D3D12_HS_CONTROL_POINT_REGISTER_READS_PER_INST ( 2 ) - -#define D3D12_HS_CONTROL_POINT_REGISTER_READ_PORTS ( 1 ) - -#define D3D12_HS_FORK_PHASE_INSTANCE_COUNT_UPPER_BOUND ( 0xffffffff ) - -#define D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COMPONENTS ( 1 ) - -#define D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNT ( 32 ) - -#define D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COUNT ( 1 ) - -#define D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_READS_PER_INST ( 2 ) - -#define D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_READ_PORTS ( 1 ) - -#define D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COMPONENTS ( 1 ) - -#define D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNT ( 32 ) - -#define D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COUNT ( 1 ) - -#define D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_READS_PER_INST ( 2 ) - -#define D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_READ_PORTS ( 1 ) - -#define D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENTS ( 1 ) - -#define D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENT_BIT_COUNT ( 32 ) - -#define D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_COUNT ( 1 ) - -#define D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_READS_PER_INST ( 2 ) - -#define D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_READ_PORTS ( 1 ) - -#define D3D12_HS_JOIN_PHASE_INSTANCE_COUNT_UPPER_BOUND ( 0xffffffff ) - -#define D3D12_HS_MAXTESSFACTOR_LOWER_BOUND ( 1.0f ) -#define D3D12_HS_MAXTESSFACTOR_UPPER_BOUND ( 64.0f ) -#define D3D12_HS_OUTPUT_CONTROL_POINTS_MAX_TOTAL_SCALARS ( 3968 ) - -#define D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COMPONENTS ( 1 ) - -#define D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COMPONENT_BIT_COUNT ( 32 ) - -#define D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COUNT ( 1 ) - -#define D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_READS_PER_INST ( 2 ) - -#define D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_READ_PORTS ( 1 ) - -#define D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COMPONENTS ( 4 ) - -#define D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COMPONENT_BIT_COUNT ( 32 ) - -#define D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COUNT ( 32 ) - -#define D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_READS_PER_INST ( 2 ) - -#define D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_READ_PORTS ( 1 ) - -#define D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_SCALAR_COMPONENTS ( 128 ) - -#define D3D12_IA_DEFAULT_INDEX_BUFFER_OFFSET_IN_BYTES ( 0 ) - -#define D3D12_IA_DEFAULT_PRIMITIVE_TOPOLOGY ( 0 ) - -#define D3D12_IA_DEFAULT_VERTEX_BUFFER_OFFSET_IN_BYTES ( 0 ) - -#define D3D12_IA_INDEX_INPUT_RESOURCE_SLOT_COUNT ( 1 ) - -#define D3D12_IA_INSTANCE_ID_BIT_COUNT ( 32 ) - -#define D3D12_IA_INTEGER_ARITHMETIC_BIT_COUNT ( 32 ) - -#define D3D12_IA_PATCH_MAX_CONTROL_POINT_COUNT ( 32 ) - -#define D3D12_IA_PRIMITIVE_ID_BIT_COUNT ( 32 ) - -#define D3D12_IA_VERTEX_ID_BIT_COUNT ( 32 ) - -#define D3D12_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT ( 32 ) - -#define D3D12_IA_VERTEX_INPUT_STRUCTURE_ELEMENTS_COMPONENTS ( 128 ) - -#define D3D12_IA_VERTEX_INPUT_STRUCTURE_ELEMENT_COUNT ( 32 ) - -#define D3D12_INTEGER_DIVIDE_BY_ZERO_QUOTIENT ( 0xffffffff ) - -#define D3D12_INTEGER_DIVIDE_BY_ZERO_REMAINDER ( 0xffffffff ) - -#define D3D12_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL ( 0xffffffff ) - -#define D3D12_KEEP_UNORDERED_ACCESS_VIEWS ( 0xffffffff ) - -#define D3D12_LINEAR_GAMMA ( 1.0f ) -#define D3D12_MAJOR_VERSION ( 12 ) - -#define D3D12_MAX_BORDER_COLOR_COMPONENT ( 1.0f ) -#define D3D12_MAX_DEPTH ( 1.0f ) -#define D3D12_MAX_LIVE_STATIC_SAMPLERS ( 2032 ) - -#define D3D12_MAX_MAXANISOTROPY ( 16 ) - -#define D3D12_MAX_MULTISAMPLE_SAMPLE_COUNT ( 32 ) - -#define D3D12_MAX_POSITION_VALUE ( 3.402823466e+34f ) -#define D3D12_MAX_ROOT_COST ( 64 ) - -#define D3D12_MAX_SHADER_VISIBLE_DESCRIPTOR_HEAP_SIZE_TIER_1 ( 1000000 ) - -#define D3D12_MAX_SHADER_VISIBLE_DESCRIPTOR_HEAP_SIZE_TIER_2 ( 1000000 ) - -#define D3D12_MAX_SHADER_VISIBLE_SAMPLER_HEAP_SIZE ( 2048 ) - -#define D3D12_MAX_TEXTURE_DIMENSION_2_TO_EXP ( 17 ) - -#define D3D12_MAX_VIEW_INSTANCE_COUNT ( 4 ) - -#define D3D12_MINOR_VERSION ( 0 ) - -#define D3D12_MIN_BORDER_COLOR_COMPONENT ( 0.0f ) -#define D3D12_MIN_DEPTH ( 0.0f ) -#define D3D12_MIN_MAXANISOTROPY ( 0 ) - -#define D3D12_MIP_LOD_BIAS_MAX ( 15.99f ) -#define D3D12_MIP_LOD_BIAS_MIN ( -16.0f ) -#define D3D12_MIP_LOD_FRACTIONAL_BIT_COUNT ( 8 ) - -#define D3D12_MIP_LOD_RANGE_BIT_COUNT ( 8 ) - -#define D3D12_MULTISAMPLE_ANTIALIAS_LINE_WIDTH ( 1.4f ) -#define D3D12_NONSAMPLE_FETCH_OUT_OF_RANGE_ACCESS_RESULT ( 0 ) - -#define D3D12_OS_RESERVED_REGISTER_SPACE_VALUES_END ( 0xffffffff ) - -#define D3D12_OS_RESERVED_REGISTER_SPACE_VALUES_START ( 0xfffffff8 ) - -#define D3D12_PACKED_TILE ( 0xffffffff ) - -#define D3D12_PIXEL_ADDRESS_RANGE_BIT_COUNT ( 15 ) - -#define D3D12_PRE_SCISSOR_PIXEL_ADDRESS_RANGE_BIT_COUNT ( 16 ) - -#define D3D12_PS_CS_UAV_REGISTER_COMPONENTS ( 1 ) - -#define D3D12_PS_CS_UAV_REGISTER_COUNT ( 8 ) - -#define D3D12_PS_CS_UAV_REGISTER_READS_PER_INST ( 1 ) - -#define D3D12_PS_CS_UAV_REGISTER_READ_PORTS ( 1 ) - -#define D3D12_PS_FRONTFACING_DEFAULT_VALUE ( 0xffffffff ) - -#define D3D12_PS_FRONTFACING_FALSE_VALUE ( 0 ) - -#define D3D12_PS_FRONTFACING_TRUE_VALUE ( 0xffffffff ) - -#define D3D12_PS_INPUT_REGISTER_COMPONENTS ( 4 ) - -#define D3D12_PS_INPUT_REGISTER_COMPONENT_BIT_COUNT ( 32 ) - -#define D3D12_PS_INPUT_REGISTER_COUNT ( 32 ) - -#define D3D12_PS_INPUT_REGISTER_READS_PER_INST ( 2 ) - -#define D3D12_PS_INPUT_REGISTER_READ_PORTS ( 1 ) - -#define D3D12_PS_LEGACY_PIXEL_CENTER_FRACTIONAL_COMPONENT ( 0.0f ) -#define D3D12_PS_OUTPUT_DEPTH_REGISTER_COMPONENTS ( 1 ) - -#define D3D12_PS_OUTPUT_DEPTH_REGISTER_COMPONENT_BIT_COUNT ( 32 ) - -#define D3D12_PS_OUTPUT_DEPTH_REGISTER_COUNT ( 1 ) - -#define D3D12_PS_OUTPUT_MASK_REGISTER_COMPONENTS ( 1 ) - -#define D3D12_PS_OUTPUT_MASK_REGISTER_COMPONENT_BIT_COUNT ( 32 ) - -#define D3D12_PS_OUTPUT_MASK_REGISTER_COUNT ( 1 ) - -#define D3D12_PS_OUTPUT_REGISTER_COMPONENTS ( 4 ) - -#define D3D12_PS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT ( 32 ) - -#define D3D12_PS_OUTPUT_REGISTER_COUNT ( 8 ) - -#define D3D12_PS_PIXEL_CENTER_FRACTIONAL_COMPONENT ( 0.5f ) -#define D3D12_RAW_UAV_SRV_BYTE_ALIGNMENT ( 16 ) - -#define D3D12_RAYTRACING_AABB_BYTE_ALIGNMENT ( 8 ) - -#define D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BYTE_ALIGNMENT ( 256 ) - -#define D3D12_RAYTRACING_INSTANCE_DESCS_BYTE_ALIGNMENT ( 16 ) - -#define D3D12_RAYTRACING_MAX_ATTRIBUTE_SIZE_IN_BYTES ( 32 ) - -#define D3D12_RAYTRACING_MAX_DECLARABLE_TRACE_RECURSION_DEPTH ( 31 ) - -#define D3D12_RAYTRACING_MAX_GEOMETRIES_PER_BOTTOM_LEVEL_ACCELERATION_STRUCTURE ( 16777216 ) - -#define D3D12_RAYTRACING_MAX_INSTANCES_PER_TOP_LEVEL_ACCELERATION_STRUCTURE ( 16777216 ) - -#define D3D12_RAYTRACING_MAX_PRIMITIVES_PER_BOTTOM_LEVEL_ACCELERATION_STRUCTURE ( 536870912 ) - -#define D3D12_RAYTRACING_MAX_RAY_GENERATION_SHADER_THREADS ( 1073741824 ) - -#define D3D12_RAYTRACING_MAX_SHADER_RECORD_STRIDE ( 4096 ) - -#define D3D12_RAYTRACING_SHADER_RECORD_BYTE_ALIGNMENT ( 32 ) - -#define D3D12_RAYTRACING_SHADER_TABLE_BYTE_ALIGNMENT ( 64 ) - -#define D3D12_RAYTRACING_TRANSFORM3X4_BYTE_ALIGNMENT ( 16 ) - -#define D3D12_REQ_BLEND_OBJECT_COUNT_PER_DEVICE ( 4096 ) - -#define D3D12_REQ_BUFFER_RESOURCE_TEXEL_COUNT_2_TO_EXP ( 27 ) - -#define D3D12_REQ_CONSTANT_BUFFER_ELEMENT_COUNT ( 4096 ) - -#define D3D12_REQ_DEPTH_STENCIL_OBJECT_COUNT_PER_DEVICE ( 4096 ) - -#define D3D12_REQ_DRAWINDEXED_INDEX_COUNT_2_TO_EXP ( 32 ) - -#define D3D12_REQ_DRAW_VERTEX_COUNT_2_TO_EXP ( 32 ) - -#define D3D12_REQ_FILTERING_HW_ADDRESSABLE_RESOURCE_DIMENSION ( 16384 ) - -#define D3D12_REQ_GS_INVOCATION_32BIT_OUTPUT_COMPONENT_LIMIT ( 1024 ) - -#define D3D12_REQ_IMMEDIATE_CONSTANT_BUFFER_ELEMENT_COUNT ( 4096 ) - -#define D3D12_REQ_MAXANISOTROPY ( 16 ) - -#define D3D12_REQ_MIP_LEVELS ( 15 ) - -#define D3D12_REQ_MULTI_ELEMENT_STRUCTURE_SIZE_IN_BYTES ( 2048 ) - -#define D3D12_REQ_RASTERIZER_OBJECT_COUNT_PER_DEVICE ( 4096 ) - -#define D3D12_REQ_RENDER_TO_BUFFER_WINDOW_WIDTH ( 16384 ) - -#define D3D12_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_A_TERM ( 128 ) - -#define D3D12_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_B_TERM ( 0.25f ) -#define D3D12_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_C_TERM ( 2048 ) - -#define D3D12_REQ_RESOURCE_VIEW_COUNT_PER_DEVICE_2_TO_EXP ( 20 ) - -#define D3D12_REQ_SAMPLER_OBJECT_COUNT_PER_DEVICE ( 4096 ) - -#define D3D12_REQ_SUBRESOURCES ( 30720 ) - -#define D3D12_REQ_TEXTURE1D_ARRAY_AXIS_DIMENSION ( 2048 ) - -#define D3D12_REQ_TEXTURE1D_U_DIMENSION ( 16384 ) - -#define D3D12_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION ( 2048 ) - -#define D3D12_REQ_TEXTURE2D_U_OR_V_DIMENSION ( 16384 ) - -#define D3D12_REQ_TEXTURE3D_U_V_OR_W_DIMENSION ( 2048 ) - -#define D3D12_REQ_TEXTURECUBE_DIMENSION ( 16384 ) - -#define D3D12_RESINFO_INSTRUCTION_MISSING_COMPONENT_RETVAL ( 0 ) - -#define D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES ( 0xffffffff ) - -#define D3D12_RS_SET_SHADING_RATE_COMBINER_COUNT ( 2 ) - -#define D3D12_SHADER_IDENTIFIER_SIZE_IN_BYTES ( 32 ) - -#define D3D12_SHADER_MAJOR_VERSION ( 5 ) - -#define D3D12_SHADER_MAX_INSTANCES ( 65535 ) - -#define D3D12_SHADER_MAX_INTERFACES ( 253 ) - -#define D3D12_SHADER_MAX_INTERFACE_CALL_SITES ( 4096 ) - -#define D3D12_SHADER_MAX_TYPES ( 65535 ) - -#define D3D12_SHADER_MINOR_VERSION ( 1 ) - -#define D3D12_SHIFT_INSTRUCTION_PAD_VALUE ( 0 ) - -#define D3D12_SHIFT_INSTRUCTION_SHIFT_VALUE_BIT_COUNT ( 5 ) - -#define D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT ( 8 ) - -#define D3D12_SMALL_MSAA_RESOURCE_PLACEMENT_ALIGNMENT ( 65536 ) - -#define D3D12_SMALL_RESOURCE_PLACEMENT_ALIGNMENT ( 4096 ) - -#define D3D12_SO_BUFFER_MAX_STRIDE_IN_BYTES ( 2048 ) - -#define D3D12_SO_BUFFER_MAX_WRITE_WINDOW_IN_BYTES ( 512 ) - -#define D3D12_SO_BUFFER_SLOT_COUNT ( 4 ) - -#define D3D12_SO_DDI_REGISTER_INDEX_DENOTING_GAP ( 0xffffffff ) - -#define D3D12_SO_NO_RASTERIZED_STREAM ( 0xffffffff ) - -#define D3D12_SO_OUTPUT_COMPONENT_COUNT ( 128 ) - -#define D3D12_SO_STREAM_COUNT ( 4 ) - -#define D3D12_SPEC_DATE_DAY ( 14 ) - -#define D3D12_SPEC_DATE_MONTH ( 11 ) - -#define D3D12_SPEC_DATE_YEAR ( 2014 ) - -#define D3D12_SPEC_VERSION ( 1.16 ) -#define D3D12_SRGB_GAMMA ( 2.2f ) -#define D3D12_SRGB_TO_FLOAT_DENOMINATOR_1 ( 12.92f ) -#define D3D12_SRGB_TO_FLOAT_DENOMINATOR_2 ( 1.055f ) -#define D3D12_SRGB_TO_FLOAT_EXPONENT ( 2.4f ) -#define D3D12_SRGB_TO_FLOAT_OFFSET ( 0.055f ) -#define D3D12_SRGB_TO_FLOAT_THRESHOLD ( 0.04045f ) -#define D3D12_SRGB_TO_FLOAT_TOLERANCE_IN_ULP ( 0.5f ) -#define D3D12_STANDARD_COMPONENT_BIT_COUNT ( 32 ) - -#define D3D12_STANDARD_COMPONENT_BIT_COUNT_DOUBLED ( 64 ) - -#define D3D12_STANDARD_MAXIMUM_ELEMENT_ALIGNMENT_BYTE_MULTIPLE ( 4 ) - -#define D3D12_STANDARD_PIXEL_COMPONENT_COUNT ( 128 ) - -#define D3D12_STANDARD_PIXEL_ELEMENT_COUNT ( 32 ) - -#define D3D12_STANDARD_VECTOR_SIZE ( 4 ) - -#define D3D12_STANDARD_VERTEX_ELEMENT_COUNT ( 32 ) - -#define D3D12_STANDARD_VERTEX_TOTAL_COMPONENT_COUNT ( 64 ) - -#define D3D12_SUBPIXEL_FRACTIONAL_BIT_COUNT ( 8 ) - -#define D3D12_SUBTEXEL_FRACTIONAL_BIT_COUNT ( 8 ) - -#define D3D12_SYSTEM_RESERVED_REGISTER_SPACE_VALUES_END ( 0xffffffff ) - -#define D3D12_SYSTEM_RESERVED_REGISTER_SPACE_VALUES_START ( 0xfffffff0 ) - -#define D3D12_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR ( 64 ) - -#define D3D12_TESSELLATOR_MAX_ISOLINE_DENSITY_TESSELLATION_FACTOR ( 64 ) - -#define D3D12_TESSELLATOR_MAX_ODD_TESSELLATION_FACTOR ( 63 ) - -#define D3D12_TESSELLATOR_MAX_TESSELLATION_FACTOR ( 64 ) - -#define D3D12_TESSELLATOR_MIN_EVEN_TESSELLATION_FACTOR ( 2 ) - -#define D3D12_TESSELLATOR_MIN_ISOLINE_DENSITY_TESSELLATION_FACTOR ( 1 ) - -#define D3D12_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR ( 1 ) - -#define D3D12_TEXEL_ADDRESS_RANGE_BIT_COUNT ( 16 ) - -#define D3D12_TEXTURE_DATA_PITCH_ALIGNMENT ( 256 ) - -#define D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT ( 512 ) - -#define D3D12_TILED_RESOURCE_TILE_SIZE_IN_BYTES ( 65536 ) - -#define D3D12_TRACKED_WORKLOAD_MAX_INSTANCES ( 32 ) - -#define D3D12_UAV_COUNTER_PLACEMENT_ALIGNMENT ( 4096 ) - -#define D3D12_UAV_SLOT_COUNT ( 64 ) - -#define D3D12_UNBOUND_MEMORY_ACCESS_RESULT ( 0 ) - -#define D3D12_VIDEO_DECODE_MAX_ARGUMENTS ( 10 ) - -#define D3D12_VIDEO_DECODE_MAX_HISTOGRAM_COMPONENTS ( 4 ) - -#define D3D12_VIDEO_DECODE_MIN_BITSTREAM_OFFSET_ALIGNMENT ( 256 ) - -#define D3D12_VIDEO_DECODE_MIN_HISTOGRAM_OFFSET_ALIGNMENT ( 256 ) - -#define D3D12_VIDEO_DECODE_STATUS_MACROBLOCKS_AFFECTED_UNKNOWN ( 0xffffffff ) - -#define D3D12_VIDEO_PROCESS_MAX_FILTERS ( 32 ) - -#define D3D12_VIDEO_PROCESS_STEREO_VIEWS ( 2 ) - -#define D3D12_VIEWPORT_AND_SCISSORRECT_MAX_INDEX ( 15 ) - -#define D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE ( 16 ) - -#define D3D12_VIEWPORT_BOUNDS_MAX ( 32767 ) - -#define D3D12_VIEWPORT_BOUNDS_MIN ( -32768 ) - -#define D3D12_VS_INPUT_REGISTER_COMPONENTS ( 4 ) - -#define D3D12_VS_INPUT_REGISTER_COMPONENT_BIT_COUNT ( 32 ) - -#define D3D12_VS_INPUT_REGISTER_COUNT ( 32 ) - -#define D3D12_VS_INPUT_REGISTER_READS_PER_INST ( 2 ) - -#define D3D12_VS_INPUT_REGISTER_READ_PORTS ( 1 ) - -#define D3D12_VS_OUTPUT_REGISTER_COMPONENTS ( 4 ) - -#define D3D12_VS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT ( 32 ) - -#define D3D12_VS_OUTPUT_REGISTER_COUNT ( 32 ) - -#define D3D12_WHQL_CONTEXT_COUNT_FOR_RESOURCE_LIMIT ( 10 ) - -#define D3D12_WHQL_DRAWINDEXED_INDEX_COUNT_2_TO_EXP ( 25 ) - -#define D3D12_WHQL_DRAW_VERTEX_COUNT_2_TO_EXP ( 25 ) - -#endif - -typedef UINT64 D3D12_GPU_VIRTUAL_ADDRESS; - -typedef -enum D3D12_COMMAND_LIST_TYPE - { - D3D12_COMMAND_LIST_TYPE_DIRECT = 0, - D3D12_COMMAND_LIST_TYPE_BUNDLE = 1, - D3D12_COMMAND_LIST_TYPE_COMPUTE = 2, - D3D12_COMMAND_LIST_TYPE_COPY = 3, - D3D12_COMMAND_LIST_TYPE_VIDEO_DECODE = 4, - D3D12_COMMAND_LIST_TYPE_VIDEO_PROCESS = 5, - D3D12_COMMAND_LIST_TYPE_VIDEO_ENCODE = 6 - } D3D12_COMMAND_LIST_TYPE; - -typedef -enum D3D12_COMMAND_QUEUE_FLAGS - { - D3D12_COMMAND_QUEUE_FLAG_NONE = 0, - D3D12_COMMAND_QUEUE_FLAG_DISABLE_GPU_TIMEOUT = 0x1 - } D3D12_COMMAND_QUEUE_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_QUEUE_FLAGS ); -typedef -enum D3D12_COMMAND_QUEUE_PRIORITY - { - D3D12_COMMAND_QUEUE_PRIORITY_NORMAL = 0, - D3D12_COMMAND_QUEUE_PRIORITY_HIGH = 100, - D3D12_COMMAND_QUEUE_PRIORITY_GLOBAL_REALTIME = 10000 - } D3D12_COMMAND_QUEUE_PRIORITY; - -typedef struct D3D12_COMMAND_QUEUE_DESC - { - D3D12_COMMAND_LIST_TYPE Type; - INT Priority; - D3D12_COMMAND_QUEUE_FLAGS Flags; - UINT NodeMask; - } D3D12_COMMAND_QUEUE_DESC; - -typedef -enum D3D12_PRIMITIVE_TOPOLOGY_TYPE - { - D3D12_PRIMITIVE_TOPOLOGY_TYPE_UNDEFINED = 0, - D3D12_PRIMITIVE_TOPOLOGY_TYPE_POINT = 1, - D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE = 2, - D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE = 3, - D3D12_PRIMITIVE_TOPOLOGY_TYPE_PATCH = 4 - } D3D12_PRIMITIVE_TOPOLOGY_TYPE; - -typedef -enum D3D12_INPUT_CLASSIFICATION - { - D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA = 0, - D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA = 1 - } D3D12_INPUT_CLASSIFICATION; - -typedef struct D3D12_INPUT_ELEMENT_DESC - { - LPCSTR SemanticName; - UINT SemanticIndex; - DXGI_FORMAT Format; - UINT InputSlot; - UINT AlignedByteOffset; - D3D12_INPUT_CLASSIFICATION InputSlotClass; - UINT InstanceDataStepRate; - } D3D12_INPUT_ELEMENT_DESC; - -typedef -enum D3D12_FILL_MODE - { - D3D12_FILL_MODE_WIREFRAME = 2, - D3D12_FILL_MODE_SOLID = 3 - } D3D12_FILL_MODE; - -typedef D3D_PRIMITIVE_TOPOLOGY D3D12_PRIMITIVE_TOPOLOGY; - -typedef D3D_PRIMITIVE D3D12_PRIMITIVE; - -typedef -enum D3D12_CULL_MODE - { - D3D12_CULL_MODE_NONE = 1, - D3D12_CULL_MODE_FRONT = 2, - D3D12_CULL_MODE_BACK = 3 - } D3D12_CULL_MODE; - -typedef struct D3D12_SO_DECLARATION_ENTRY - { - UINT Stream; - LPCSTR SemanticName; - UINT SemanticIndex; - BYTE StartComponent; - BYTE ComponentCount; - BYTE OutputSlot; - } D3D12_SO_DECLARATION_ENTRY; - -typedef struct D3D12_VIEWPORT - { - FLOAT TopLeftX; - FLOAT TopLeftY; - FLOAT Width; - FLOAT Height; - FLOAT MinDepth; - FLOAT MaxDepth; - } D3D12_VIEWPORT; - -typedef RECT D3D12_RECT; - -typedef struct D3D12_BOX - { - UINT left; - UINT top; - UINT front; - UINT right; - UINT bottom; - UINT back; - } D3D12_BOX; - -typedef -enum D3D12_COMPARISON_FUNC - { - D3D12_COMPARISON_FUNC_NEVER = 1, - D3D12_COMPARISON_FUNC_LESS = 2, - D3D12_COMPARISON_FUNC_EQUAL = 3, - D3D12_COMPARISON_FUNC_LESS_EQUAL = 4, - D3D12_COMPARISON_FUNC_GREATER = 5, - D3D12_COMPARISON_FUNC_NOT_EQUAL = 6, - D3D12_COMPARISON_FUNC_GREATER_EQUAL = 7, - D3D12_COMPARISON_FUNC_ALWAYS = 8 - } D3D12_COMPARISON_FUNC; - -typedef -enum D3D12_DEPTH_WRITE_MASK - { - D3D12_DEPTH_WRITE_MASK_ZERO = 0, - D3D12_DEPTH_WRITE_MASK_ALL = 1 - } D3D12_DEPTH_WRITE_MASK; - -typedef -enum D3D12_STENCIL_OP - { - D3D12_STENCIL_OP_KEEP = 1, - D3D12_STENCIL_OP_ZERO = 2, - D3D12_STENCIL_OP_REPLACE = 3, - D3D12_STENCIL_OP_INCR_SAT = 4, - D3D12_STENCIL_OP_DECR_SAT = 5, - D3D12_STENCIL_OP_INVERT = 6, - D3D12_STENCIL_OP_INCR = 7, - D3D12_STENCIL_OP_DECR = 8 - } D3D12_STENCIL_OP; - -typedef struct D3D12_DEPTH_STENCILOP_DESC - { - D3D12_STENCIL_OP StencilFailOp; - D3D12_STENCIL_OP StencilDepthFailOp; - D3D12_STENCIL_OP StencilPassOp; - D3D12_COMPARISON_FUNC StencilFunc; - } D3D12_DEPTH_STENCILOP_DESC; - -typedef struct D3D12_DEPTH_STENCIL_DESC - { - BOOL DepthEnable; - D3D12_DEPTH_WRITE_MASK DepthWriteMask; - D3D12_COMPARISON_FUNC DepthFunc; - BOOL StencilEnable; - UINT8 StencilReadMask; - UINT8 StencilWriteMask; - D3D12_DEPTH_STENCILOP_DESC FrontFace; - D3D12_DEPTH_STENCILOP_DESC BackFace; - } D3D12_DEPTH_STENCIL_DESC; - -typedef struct D3D12_DEPTH_STENCIL_DESC1 - { - BOOL DepthEnable; - D3D12_DEPTH_WRITE_MASK DepthWriteMask; - D3D12_COMPARISON_FUNC DepthFunc; - BOOL StencilEnable; - UINT8 StencilReadMask; - UINT8 StencilWriteMask; - D3D12_DEPTH_STENCILOP_DESC FrontFace; - D3D12_DEPTH_STENCILOP_DESC BackFace; - BOOL DepthBoundsTestEnable; - } D3D12_DEPTH_STENCIL_DESC1; - -typedef -enum D3D12_BLEND - { - D3D12_BLEND_ZERO = 1, - D3D12_BLEND_ONE = 2, - D3D12_BLEND_SRC_COLOR = 3, - D3D12_BLEND_INV_SRC_COLOR = 4, - D3D12_BLEND_SRC_ALPHA = 5, - D3D12_BLEND_INV_SRC_ALPHA = 6, - D3D12_BLEND_DEST_ALPHA = 7, - D3D12_BLEND_INV_DEST_ALPHA = 8, - D3D12_BLEND_DEST_COLOR = 9, - D3D12_BLEND_INV_DEST_COLOR = 10, - D3D12_BLEND_SRC_ALPHA_SAT = 11, - D3D12_BLEND_BLEND_FACTOR = 14, - D3D12_BLEND_INV_BLEND_FACTOR = 15, - D3D12_BLEND_SRC1_COLOR = 16, - D3D12_BLEND_INV_SRC1_COLOR = 17, - D3D12_BLEND_SRC1_ALPHA = 18, - D3D12_BLEND_INV_SRC1_ALPHA = 19 - } D3D12_BLEND; - -typedef -enum D3D12_BLEND_OP - { - D3D12_BLEND_OP_ADD = 1, - D3D12_BLEND_OP_SUBTRACT = 2, - D3D12_BLEND_OP_REV_SUBTRACT = 3, - D3D12_BLEND_OP_MIN = 4, - D3D12_BLEND_OP_MAX = 5 - } D3D12_BLEND_OP; - -typedef -enum D3D12_COLOR_WRITE_ENABLE - { - D3D12_COLOR_WRITE_ENABLE_RED = 1, - D3D12_COLOR_WRITE_ENABLE_GREEN = 2, - D3D12_COLOR_WRITE_ENABLE_BLUE = 4, - D3D12_COLOR_WRITE_ENABLE_ALPHA = 8, - D3D12_COLOR_WRITE_ENABLE_ALL = ( ( ( D3D12_COLOR_WRITE_ENABLE_RED | D3D12_COLOR_WRITE_ENABLE_GREEN ) | D3D12_COLOR_WRITE_ENABLE_BLUE ) | D3D12_COLOR_WRITE_ENABLE_ALPHA ) - } D3D12_COLOR_WRITE_ENABLE; - -typedef -enum D3D12_LOGIC_OP - { - D3D12_LOGIC_OP_CLEAR = 0, - D3D12_LOGIC_OP_SET = ( D3D12_LOGIC_OP_CLEAR + 1 ) , - D3D12_LOGIC_OP_COPY = ( D3D12_LOGIC_OP_SET + 1 ) , - D3D12_LOGIC_OP_COPY_INVERTED = ( D3D12_LOGIC_OP_COPY + 1 ) , - D3D12_LOGIC_OP_NOOP = ( D3D12_LOGIC_OP_COPY_INVERTED + 1 ) , - D3D12_LOGIC_OP_INVERT = ( D3D12_LOGIC_OP_NOOP + 1 ) , - D3D12_LOGIC_OP_AND = ( D3D12_LOGIC_OP_INVERT + 1 ) , - D3D12_LOGIC_OP_NAND = ( D3D12_LOGIC_OP_AND + 1 ) , - D3D12_LOGIC_OP_OR = ( D3D12_LOGIC_OP_NAND + 1 ) , - D3D12_LOGIC_OP_NOR = ( D3D12_LOGIC_OP_OR + 1 ) , - D3D12_LOGIC_OP_XOR = ( D3D12_LOGIC_OP_NOR + 1 ) , - D3D12_LOGIC_OP_EQUIV = ( D3D12_LOGIC_OP_XOR + 1 ) , - D3D12_LOGIC_OP_AND_REVERSE = ( D3D12_LOGIC_OP_EQUIV + 1 ) , - D3D12_LOGIC_OP_AND_INVERTED = ( D3D12_LOGIC_OP_AND_REVERSE + 1 ) , - D3D12_LOGIC_OP_OR_REVERSE = ( D3D12_LOGIC_OP_AND_INVERTED + 1 ) , - D3D12_LOGIC_OP_OR_INVERTED = ( D3D12_LOGIC_OP_OR_REVERSE + 1 ) - } D3D12_LOGIC_OP; - -typedef struct D3D12_RENDER_TARGET_BLEND_DESC - { - BOOL BlendEnable; - BOOL LogicOpEnable; - D3D12_BLEND SrcBlend; - D3D12_BLEND DestBlend; - D3D12_BLEND_OP BlendOp; - D3D12_BLEND SrcBlendAlpha; - D3D12_BLEND DestBlendAlpha; - D3D12_BLEND_OP BlendOpAlpha; - D3D12_LOGIC_OP LogicOp; - UINT8 RenderTargetWriteMask; - } D3D12_RENDER_TARGET_BLEND_DESC; - -typedef struct D3D12_BLEND_DESC - { - BOOL AlphaToCoverageEnable; - BOOL IndependentBlendEnable; - D3D12_RENDER_TARGET_BLEND_DESC RenderTarget[ 8 ]; - } D3D12_BLEND_DESC; - -/* Note, the array size for RenderTarget[] above is D3D12_SIMULTANEOUS_RENDERTARGET_COUNT. - IDL processing/generation of this header replaces the define; this comment is merely explaining what happened. */ -typedef -enum D3D12_CONSERVATIVE_RASTERIZATION_MODE - { - D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF = 0, - D3D12_CONSERVATIVE_RASTERIZATION_MODE_ON = 1 - } D3D12_CONSERVATIVE_RASTERIZATION_MODE; - -typedef struct D3D12_RASTERIZER_DESC - { - D3D12_FILL_MODE FillMode; - D3D12_CULL_MODE CullMode; - BOOL FrontCounterClockwise; - INT DepthBias; - FLOAT DepthBiasClamp; - FLOAT SlopeScaledDepthBias; - BOOL DepthClipEnable; - BOOL MultisampleEnable; - BOOL AntialiasedLineEnable; - UINT ForcedSampleCount; - D3D12_CONSERVATIVE_RASTERIZATION_MODE ConservativeRaster; - } D3D12_RASTERIZER_DESC; - - - -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0000_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0000_v0_0_s_ifspec; - -#ifndef __ID3D12Object_INTERFACE_DEFINED__ -#define __ID3D12Object_INTERFACE_DEFINED__ - -/* interface ID3D12Object */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12Object; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("c4fec28f-7966-4e95-9f94-f431cb56c3b8") - ID3D12Object : public IUnknown - { - public: - virtual HRESULT STDMETHODCALLTYPE GetPrivateData( - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData) = 0; - - virtual HRESULT STDMETHODCALLTYPE SetPrivateData( - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData) = 0; - - virtual HRESULT STDMETHODCALLTYPE SetPrivateDataInterface( - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData) = 0; - - virtual HRESULT STDMETHODCALLTYPE SetName( - _In_z_ LPCWSTR Name) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12ObjectVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12Object * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12Object * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12Object * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12Object * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12Object * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12Object * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12Object * This, - _In_z_ LPCWSTR Name); - - END_INTERFACE - } ID3D12ObjectVtbl; - - interface ID3D12Object - { - CONST_VTBL struct ID3D12ObjectVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12Object_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12Object_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12Object_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12Object_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12Object_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12Object_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12Object_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12Object_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12DeviceChild_INTERFACE_DEFINED__ -#define __ID3D12DeviceChild_INTERFACE_DEFINED__ - -/* interface ID3D12DeviceChild */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12DeviceChild; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("905db94b-a00c-4140-9df5-2b64ca9ea357") - ID3D12DeviceChild : public ID3D12Object - { - public: - virtual HRESULT STDMETHODCALLTYPE GetDevice( - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12DeviceChildVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12DeviceChild * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12DeviceChild * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12DeviceChild * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12DeviceChild * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12DeviceChild * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12DeviceChild * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12DeviceChild * This, - _In_z_ LPCWSTR Name); - - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12DeviceChild * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - END_INTERFACE - } ID3D12DeviceChildVtbl; - - interface ID3D12DeviceChild - { - CONST_VTBL struct ID3D12DeviceChildVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12DeviceChild_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12DeviceChild_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12DeviceChild_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12DeviceChild_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12DeviceChild_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12DeviceChild_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12DeviceChild_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12DeviceChild_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12DeviceChild_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12RootSignature_INTERFACE_DEFINED__ -#define __ID3D12RootSignature_INTERFACE_DEFINED__ - -/* interface ID3D12RootSignature */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12RootSignature; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("c54a6b66-72df-4ee8-8be5-a946a1429214") - ID3D12RootSignature : public ID3D12DeviceChild - { - public: - }; - - -#else /* C style interface */ - - typedef struct ID3D12RootSignatureVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12RootSignature * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12RootSignature * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12RootSignature * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12RootSignature * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12RootSignature * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12RootSignature * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12RootSignature * This, - _In_z_ LPCWSTR Name); - - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12RootSignature * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - END_INTERFACE - } ID3D12RootSignatureVtbl; - - interface ID3D12RootSignature - { - CONST_VTBL struct ID3D12RootSignatureVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12RootSignature_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12RootSignature_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12RootSignature_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12RootSignature_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12RootSignature_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12RootSignature_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12RootSignature_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12RootSignature_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12RootSignature_INTERFACE_DEFINED__ */ - - -/* interface __MIDL_itf_d3d12_0000_0001 */ -/* [local] */ - -typedef struct D3D12_SHADER_BYTECODE - { - _Field_size_bytes_full_(BytecodeLength) const void *pShaderBytecode; - SIZE_T BytecodeLength; - } D3D12_SHADER_BYTECODE; - -typedef struct D3D12_STREAM_OUTPUT_DESC - { - _Field_size_full_(NumEntries) const D3D12_SO_DECLARATION_ENTRY *pSODeclaration; - UINT NumEntries; - _Field_size_full_(NumStrides) const UINT *pBufferStrides; - UINT NumStrides; - UINT RasterizedStream; - } D3D12_STREAM_OUTPUT_DESC; - -typedef struct D3D12_INPUT_LAYOUT_DESC - { - _Field_size_full_(NumElements) const D3D12_INPUT_ELEMENT_DESC *pInputElementDescs; - UINT NumElements; - } D3D12_INPUT_LAYOUT_DESC; - -typedef -enum D3D12_INDEX_BUFFER_STRIP_CUT_VALUE - { - D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_DISABLED = 0, - D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_0xFFFF = 1, - D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_0xFFFFFFFF = 2 - } D3D12_INDEX_BUFFER_STRIP_CUT_VALUE; - -typedef struct D3D12_CACHED_PIPELINE_STATE - { - _Field_size_bytes_full_(CachedBlobSizeInBytes) const void *pCachedBlob; - SIZE_T CachedBlobSizeInBytes; - } D3D12_CACHED_PIPELINE_STATE; - -typedef -enum D3D12_PIPELINE_STATE_FLAGS - { - D3D12_PIPELINE_STATE_FLAG_NONE = 0, - D3D12_PIPELINE_STATE_FLAG_TOOL_DEBUG = 0x1 - } D3D12_PIPELINE_STATE_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_PIPELINE_STATE_FLAGS ); -typedef struct D3D12_GRAPHICS_PIPELINE_STATE_DESC - { - ID3D12RootSignature *pRootSignature; - D3D12_SHADER_BYTECODE VS; - D3D12_SHADER_BYTECODE PS; - D3D12_SHADER_BYTECODE DS; - D3D12_SHADER_BYTECODE HS; - D3D12_SHADER_BYTECODE GS; - D3D12_STREAM_OUTPUT_DESC StreamOutput; - D3D12_BLEND_DESC BlendState; - UINT SampleMask; - D3D12_RASTERIZER_DESC RasterizerState; - D3D12_DEPTH_STENCIL_DESC DepthStencilState; - D3D12_INPUT_LAYOUT_DESC InputLayout; - D3D12_INDEX_BUFFER_STRIP_CUT_VALUE IBStripCutValue; - D3D12_PRIMITIVE_TOPOLOGY_TYPE PrimitiveTopologyType; - UINT NumRenderTargets; - DXGI_FORMAT RTVFormats[ 8 ]; - DXGI_FORMAT DSVFormat; - DXGI_SAMPLE_DESC SampleDesc; - UINT NodeMask; - D3D12_CACHED_PIPELINE_STATE CachedPSO; - D3D12_PIPELINE_STATE_FLAGS Flags; - } D3D12_GRAPHICS_PIPELINE_STATE_DESC; - -typedef struct D3D12_COMPUTE_PIPELINE_STATE_DESC - { - ID3D12RootSignature *pRootSignature; - D3D12_SHADER_BYTECODE CS; - UINT NodeMask; - D3D12_CACHED_PIPELINE_STATE CachedPSO; - D3D12_PIPELINE_STATE_FLAGS Flags; - } D3D12_COMPUTE_PIPELINE_STATE_DESC; - -struct D3D12_RT_FORMAT_ARRAY - { - DXGI_FORMAT RTFormats[ 8 ]; - UINT NumRenderTargets; - } ; -typedef struct D3D12_PIPELINE_STATE_STREAM_DESC - { - _In_ SIZE_T SizeInBytes; - _In_reads_(_Inexpressible_("Dependent on size of subobjects")) void *pPipelineStateSubobjectStream; - } D3D12_PIPELINE_STATE_STREAM_DESC; - -typedef -enum D3D12_PIPELINE_STATE_SUBOBJECT_TYPE - { - D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_ROOT_SIGNATURE = 0, - D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VS = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_ROOT_SIGNATURE + 1 ) , - D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PS = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VS + 1 ) , - D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DS = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PS + 1 ) , - D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_HS = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DS + 1 ) , - D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_GS = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_HS + 1 ) , - D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CS = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_GS + 1 ) , - D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_STREAM_OUTPUT = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CS + 1 ) , - D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_BLEND = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_STREAM_OUTPUT + 1 ) , - D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_MASK = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_BLEND + 1 ) , - D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RASTERIZER = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_MASK + 1 ) , - D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RASTERIZER + 1 ) , - D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_INPUT_LAYOUT = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL + 1 ) , - D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_IB_STRIP_CUT_VALUE = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_INPUT_LAYOUT + 1 ) , - D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PRIMITIVE_TOPOLOGY = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_IB_STRIP_CUT_VALUE + 1 ) , - D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RENDER_TARGET_FORMATS = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PRIMITIVE_TOPOLOGY + 1 ) , - D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL_FORMAT = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RENDER_TARGET_FORMATS + 1 ) , - D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_DESC = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL_FORMAT + 1 ) , - D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_NODE_MASK = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_DESC + 1 ) , - D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CACHED_PSO = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_NODE_MASK + 1 ) , - D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_FLAGS = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CACHED_PSO + 1 ) , - D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1 = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_FLAGS + 1 ) , - D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VIEW_INSTANCING = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1 + 1 ) , - D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MAX_VALID = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VIEW_INSTANCING + 1 ) - } D3D12_PIPELINE_STATE_SUBOBJECT_TYPE; - -typedef -enum D3D12_FEATURE - { - D3D12_FEATURE_D3D12_OPTIONS = 0, - D3D12_FEATURE_ARCHITECTURE = 1, - D3D12_FEATURE_FEATURE_LEVELS = 2, - D3D12_FEATURE_FORMAT_SUPPORT = 3, - D3D12_FEATURE_MULTISAMPLE_QUALITY_LEVELS = 4, - D3D12_FEATURE_FORMAT_INFO = 5, - D3D12_FEATURE_GPU_VIRTUAL_ADDRESS_SUPPORT = 6, - D3D12_FEATURE_SHADER_MODEL = 7, - D3D12_FEATURE_D3D12_OPTIONS1 = 8, - D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_SUPPORT = 10, - D3D12_FEATURE_ROOT_SIGNATURE = 12, - D3D12_FEATURE_ARCHITECTURE1 = 16, - D3D12_FEATURE_D3D12_OPTIONS2 = 18, - D3D12_FEATURE_SHADER_CACHE = 19, - D3D12_FEATURE_COMMAND_QUEUE_PRIORITY = 20, - D3D12_FEATURE_D3D12_OPTIONS3 = 21, - D3D12_FEATURE_EXISTING_HEAPS = 22, - D3D12_FEATURE_D3D12_OPTIONS4 = 23, - D3D12_FEATURE_SERIALIZATION = 24, - D3D12_FEATURE_CROSS_NODE = 25, - D3D12_FEATURE_D3D12_OPTIONS5 = 27, - D3D12_FEATURE_D3D12_OPTIONS6 = 30, - D3D12_FEATURE_QUERY_META_COMMAND = 31 - } D3D12_FEATURE; - -typedef -enum D3D12_SHADER_MIN_PRECISION_SUPPORT - { - D3D12_SHADER_MIN_PRECISION_SUPPORT_NONE = 0, - D3D12_SHADER_MIN_PRECISION_SUPPORT_10_BIT = 0x1, - D3D12_SHADER_MIN_PRECISION_SUPPORT_16_BIT = 0x2 - } D3D12_SHADER_MIN_PRECISION_SUPPORT; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_SHADER_MIN_PRECISION_SUPPORT ); -typedef -enum D3D12_TILED_RESOURCES_TIER - { - D3D12_TILED_RESOURCES_TIER_NOT_SUPPORTED = 0, - D3D12_TILED_RESOURCES_TIER_1 = 1, - D3D12_TILED_RESOURCES_TIER_2 = 2, - D3D12_TILED_RESOURCES_TIER_3 = 3, - D3D12_TILED_RESOURCES_TIER_4 = 4 - } D3D12_TILED_RESOURCES_TIER; - -typedef -enum D3D12_RESOURCE_BINDING_TIER - { - D3D12_RESOURCE_BINDING_TIER_1 = 1, - D3D12_RESOURCE_BINDING_TIER_2 = 2, - D3D12_RESOURCE_BINDING_TIER_3 = 3 - } D3D12_RESOURCE_BINDING_TIER; - -typedef -enum D3D12_CONSERVATIVE_RASTERIZATION_TIER - { - D3D12_CONSERVATIVE_RASTERIZATION_TIER_NOT_SUPPORTED = 0, - D3D12_CONSERVATIVE_RASTERIZATION_TIER_1 = 1, - D3D12_CONSERVATIVE_RASTERIZATION_TIER_2 = 2, - D3D12_CONSERVATIVE_RASTERIZATION_TIER_3 = 3 - } D3D12_CONSERVATIVE_RASTERIZATION_TIER; - -typedef -enum D3D12_FORMAT_SUPPORT1 - { - D3D12_FORMAT_SUPPORT1_NONE = 0, - D3D12_FORMAT_SUPPORT1_BUFFER = 0x1, - D3D12_FORMAT_SUPPORT1_IA_VERTEX_BUFFER = 0x2, - D3D12_FORMAT_SUPPORT1_IA_INDEX_BUFFER = 0x4, - D3D12_FORMAT_SUPPORT1_SO_BUFFER = 0x8, - D3D12_FORMAT_SUPPORT1_TEXTURE1D = 0x10, - D3D12_FORMAT_SUPPORT1_TEXTURE2D = 0x20, - D3D12_FORMAT_SUPPORT1_TEXTURE3D = 0x40, - D3D12_FORMAT_SUPPORT1_TEXTURECUBE = 0x80, - D3D12_FORMAT_SUPPORT1_SHADER_LOAD = 0x100, - D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE = 0x200, - D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE_COMPARISON = 0x400, - D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE_MONO_TEXT = 0x800, - D3D12_FORMAT_SUPPORT1_MIP = 0x1000, - D3D12_FORMAT_SUPPORT1_RENDER_TARGET = 0x4000, - D3D12_FORMAT_SUPPORT1_BLENDABLE = 0x8000, - D3D12_FORMAT_SUPPORT1_DEPTH_STENCIL = 0x10000, - D3D12_FORMAT_SUPPORT1_MULTISAMPLE_RESOLVE = 0x40000, - D3D12_FORMAT_SUPPORT1_DISPLAY = 0x80000, - D3D12_FORMAT_SUPPORT1_CAST_WITHIN_BIT_LAYOUT = 0x100000, - D3D12_FORMAT_SUPPORT1_MULTISAMPLE_RENDERTARGET = 0x200000, - D3D12_FORMAT_SUPPORT1_MULTISAMPLE_LOAD = 0x400000, - D3D12_FORMAT_SUPPORT1_SHADER_GATHER = 0x800000, - D3D12_FORMAT_SUPPORT1_BACK_BUFFER_CAST = 0x1000000, - D3D12_FORMAT_SUPPORT1_TYPED_UNORDERED_ACCESS_VIEW = 0x2000000, - D3D12_FORMAT_SUPPORT1_SHADER_GATHER_COMPARISON = 0x4000000, - D3D12_FORMAT_SUPPORT1_DECODER_OUTPUT = 0x8000000, - D3D12_FORMAT_SUPPORT1_VIDEO_PROCESSOR_OUTPUT = 0x10000000, - D3D12_FORMAT_SUPPORT1_VIDEO_PROCESSOR_INPUT = 0x20000000, - D3D12_FORMAT_SUPPORT1_VIDEO_ENCODER = 0x40000000 - } D3D12_FORMAT_SUPPORT1; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_FORMAT_SUPPORT1 ); -typedef -enum D3D12_FORMAT_SUPPORT2 - { - D3D12_FORMAT_SUPPORT2_NONE = 0, - D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_ADD = 0x1, - D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_BITWISE_OPS = 0x2, - D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_COMPARE_STORE_OR_COMPARE_EXCHANGE = 0x4, - D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_EXCHANGE = 0x8, - D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_SIGNED_MIN_OR_MAX = 0x10, - D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_UNSIGNED_MIN_OR_MAX = 0x20, - D3D12_FORMAT_SUPPORT2_UAV_TYPED_LOAD = 0x40, - D3D12_FORMAT_SUPPORT2_UAV_TYPED_STORE = 0x80, - D3D12_FORMAT_SUPPORT2_OUTPUT_MERGER_LOGIC_OP = 0x100, - D3D12_FORMAT_SUPPORT2_TILED = 0x200, - D3D12_FORMAT_SUPPORT2_MULTIPLANE_OVERLAY = 0x4000 - } D3D12_FORMAT_SUPPORT2; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_FORMAT_SUPPORT2 ); -typedef -enum D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS - { - D3D12_MULTISAMPLE_QUALITY_LEVELS_FLAG_NONE = 0, - D3D12_MULTISAMPLE_QUALITY_LEVELS_FLAG_TILED_RESOURCE = 0x1 - } D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS ); -typedef -enum D3D12_CROSS_NODE_SHARING_TIER - { - D3D12_CROSS_NODE_SHARING_TIER_NOT_SUPPORTED = 0, - D3D12_CROSS_NODE_SHARING_TIER_1_EMULATED = 1, - D3D12_CROSS_NODE_SHARING_TIER_1 = 2, - D3D12_CROSS_NODE_SHARING_TIER_2 = 3, - D3D12_CROSS_NODE_SHARING_TIER_3 = 4 - } D3D12_CROSS_NODE_SHARING_TIER; - -typedef -enum D3D12_RESOURCE_HEAP_TIER - { - D3D12_RESOURCE_HEAP_TIER_1 = 1, - D3D12_RESOURCE_HEAP_TIER_2 = 2 - } D3D12_RESOURCE_HEAP_TIER; - -typedef -enum D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER - { - D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_NOT_SUPPORTED = 0, - D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_1 = 1, - D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_2 = 2 - } D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER; - -typedef -enum D3D12_VIEW_INSTANCING_TIER - { - D3D12_VIEW_INSTANCING_TIER_NOT_SUPPORTED = 0, - D3D12_VIEW_INSTANCING_TIER_1 = 1, - D3D12_VIEW_INSTANCING_TIER_2 = 2, - D3D12_VIEW_INSTANCING_TIER_3 = 3 - } D3D12_VIEW_INSTANCING_TIER; - -typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS - { - _Out_ BOOL DoublePrecisionFloatShaderOps; - _Out_ BOOL OutputMergerLogicOp; - _Out_ D3D12_SHADER_MIN_PRECISION_SUPPORT MinPrecisionSupport; - _Out_ D3D12_TILED_RESOURCES_TIER TiledResourcesTier; - _Out_ D3D12_RESOURCE_BINDING_TIER ResourceBindingTier; - _Out_ BOOL PSSpecifiedStencilRefSupported; - _Out_ BOOL TypedUAVLoadAdditionalFormats; - _Out_ BOOL ROVsSupported; - _Out_ D3D12_CONSERVATIVE_RASTERIZATION_TIER ConservativeRasterizationTier; - _Out_ UINT MaxGPUVirtualAddressBitsPerResource; - _Out_ BOOL StandardSwizzle64KBSupported; - _Out_ D3D12_CROSS_NODE_SHARING_TIER CrossNodeSharingTier; - _Out_ BOOL CrossAdapterRowMajorTextureSupported; - _Out_ BOOL VPAndRTArrayIndexFromAnyShaderFeedingRasterizerSupportedWithoutGSEmulation; - _Out_ D3D12_RESOURCE_HEAP_TIER ResourceHeapTier; - } D3D12_FEATURE_DATA_D3D12_OPTIONS; - -typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS1 - { - _Out_ BOOL WaveOps; - _Out_ UINT WaveLaneCountMin; - _Out_ UINT WaveLaneCountMax; - _Out_ UINT TotalLaneCount; - _Out_ BOOL ExpandedComputeResourceStates; - _Out_ BOOL Int64ShaderOps; - } D3D12_FEATURE_DATA_D3D12_OPTIONS1; - -typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS2 - { - _Out_ BOOL DepthBoundsTestSupported; - _Out_ D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER ProgrammableSamplePositionsTier; - } D3D12_FEATURE_DATA_D3D12_OPTIONS2; - -typedef -enum D3D_ROOT_SIGNATURE_VERSION - { - D3D_ROOT_SIGNATURE_VERSION_1 = 0x1, - D3D_ROOT_SIGNATURE_VERSION_1_0 = 0x1, - D3D_ROOT_SIGNATURE_VERSION_1_1 = 0x2 - } D3D_ROOT_SIGNATURE_VERSION; - -typedef struct D3D12_FEATURE_DATA_ROOT_SIGNATURE - { - _Inout_ D3D_ROOT_SIGNATURE_VERSION HighestVersion; - } D3D12_FEATURE_DATA_ROOT_SIGNATURE; - -typedef struct D3D12_FEATURE_DATA_ARCHITECTURE - { - _In_ UINT NodeIndex; - _Out_ BOOL TileBasedRenderer; - _Out_ BOOL UMA; - _Out_ BOOL CacheCoherentUMA; - } D3D12_FEATURE_DATA_ARCHITECTURE; - -typedef struct D3D12_FEATURE_DATA_ARCHITECTURE1 - { - _In_ UINT NodeIndex; - _Out_ BOOL TileBasedRenderer; - _Out_ BOOL UMA; - _Out_ BOOL CacheCoherentUMA; - _Out_ BOOL IsolatedMMU; - } D3D12_FEATURE_DATA_ARCHITECTURE1; - -typedef struct D3D12_FEATURE_DATA_FEATURE_LEVELS - { - _In_ UINT NumFeatureLevels; - _In_reads_(NumFeatureLevels) const D3D_FEATURE_LEVEL *pFeatureLevelsRequested; - _Out_ D3D_FEATURE_LEVEL MaxSupportedFeatureLevel; - } D3D12_FEATURE_DATA_FEATURE_LEVELS; - -typedef -enum D3D_SHADER_MODEL - { - D3D_SHADER_MODEL_5_1 = 0x51, - D3D_SHADER_MODEL_6_0 = 0x60, - D3D_SHADER_MODEL_6_1 = 0x61, - D3D_SHADER_MODEL_6_2 = 0x62, - D3D_SHADER_MODEL_6_3 = 0x63, - D3D_SHADER_MODEL_6_4 = 0x64, - D3D_SHADER_MODEL_6_5 = 0x65 - } D3D_SHADER_MODEL; - -typedef struct D3D12_FEATURE_DATA_SHADER_MODEL - { - _Inout_ D3D_SHADER_MODEL HighestShaderModel; - } D3D12_FEATURE_DATA_SHADER_MODEL; - -typedef struct D3D12_FEATURE_DATA_FORMAT_SUPPORT - { - _In_ DXGI_FORMAT Format; - _Out_ D3D12_FORMAT_SUPPORT1 Support1; - _Out_ D3D12_FORMAT_SUPPORT2 Support2; - } D3D12_FEATURE_DATA_FORMAT_SUPPORT; - -typedef struct D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS - { - _In_ DXGI_FORMAT Format; - _In_ UINT SampleCount; - _In_ D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS Flags; - _Out_ UINT NumQualityLevels; - } D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS; - -typedef struct D3D12_FEATURE_DATA_FORMAT_INFO - { - DXGI_FORMAT Format; - UINT8 PlaneCount; - } D3D12_FEATURE_DATA_FORMAT_INFO; - -typedef struct D3D12_FEATURE_DATA_GPU_VIRTUAL_ADDRESS_SUPPORT - { - UINT MaxGPUVirtualAddressBitsPerResource; - UINT MaxGPUVirtualAddressBitsPerProcess; - } D3D12_FEATURE_DATA_GPU_VIRTUAL_ADDRESS_SUPPORT; - -typedef -enum D3D12_SHADER_CACHE_SUPPORT_FLAGS - { - D3D12_SHADER_CACHE_SUPPORT_NONE = 0, - D3D12_SHADER_CACHE_SUPPORT_SINGLE_PSO = 0x1, - D3D12_SHADER_CACHE_SUPPORT_LIBRARY = 0x2, - D3D12_SHADER_CACHE_SUPPORT_AUTOMATIC_INPROC_CACHE = 0x4, - D3D12_SHADER_CACHE_SUPPORT_AUTOMATIC_DISK_CACHE = 0x8 - } D3D12_SHADER_CACHE_SUPPORT_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_SHADER_CACHE_SUPPORT_FLAGS ); -typedef struct D3D12_FEATURE_DATA_SHADER_CACHE - { - _Out_ D3D12_SHADER_CACHE_SUPPORT_FLAGS SupportFlags; - } D3D12_FEATURE_DATA_SHADER_CACHE; - -typedef struct D3D12_FEATURE_DATA_COMMAND_QUEUE_PRIORITY - { - _In_ D3D12_COMMAND_LIST_TYPE CommandListType; - _In_ UINT Priority; - _Out_ BOOL PriorityForTypeIsSupported; - } D3D12_FEATURE_DATA_COMMAND_QUEUE_PRIORITY; - -typedef -enum D3D12_COMMAND_LIST_SUPPORT_FLAGS - { - D3D12_COMMAND_LIST_SUPPORT_FLAG_NONE = 0, - D3D12_COMMAND_LIST_SUPPORT_FLAG_DIRECT = ( 1 << D3D12_COMMAND_LIST_TYPE_DIRECT ) , - D3D12_COMMAND_LIST_SUPPORT_FLAG_BUNDLE = ( 1 << D3D12_COMMAND_LIST_TYPE_BUNDLE ) , - D3D12_COMMAND_LIST_SUPPORT_FLAG_COMPUTE = ( 1 << D3D12_COMMAND_LIST_TYPE_COMPUTE ) , - D3D12_COMMAND_LIST_SUPPORT_FLAG_COPY = ( 1 << D3D12_COMMAND_LIST_TYPE_COPY ) , - D3D12_COMMAND_LIST_SUPPORT_FLAG_VIDEO_DECODE = ( 1 << D3D12_COMMAND_LIST_TYPE_VIDEO_DECODE ) , - D3D12_COMMAND_LIST_SUPPORT_FLAG_VIDEO_PROCESS = ( 1 << D3D12_COMMAND_LIST_TYPE_VIDEO_PROCESS ) , - D3D12_COMMAND_LIST_SUPPORT_FLAG_VIDEO_ENCODE = ( 1 << D3D12_COMMAND_LIST_TYPE_VIDEO_ENCODE ) - } D3D12_COMMAND_LIST_SUPPORT_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_LIST_SUPPORT_FLAGS ); -typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS3 - { - _Out_ BOOL CopyQueueTimestampQueriesSupported; - _Out_ BOOL CastingFullyTypedFormatSupported; - _Out_ D3D12_COMMAND_LIST_SUPPORT_FLAGS WriteBufferImmediateSupportFlags; - _Out_ D3D12_VIEW_INSTANCING_TIER ViewInstancingTier; - _Out_ BOOL BarycentricsSupported; - } D3D12_FEATURE_DATA_D3D12_OPTIONS3; - -typedef struct D3D12_FEATURE_DATA_EXISTING_HEAPS - { - _Out_ BOOL Supported; - } D3D12_FEATURE_DATA_EXISTING_HEAPS; - -typedef -enum D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER - { - D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_0 = 0, - D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_1 = ( D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_0 + 1 ) - } D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER; - -typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS4 - { - _Out_ BOOL MSAA64KBAlignedTextureSupported; - _Out_ D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER SharedResourceCompatibilityTier; - _Out_ BOOL Native16BitShaderOpsSupported; - } D3D12_FEATURE_DATA_D3D12_OPTIONS4; - -typedef -enum D3D12_HEAP_SERIALIZATION_TIER - { - D3D12_HEAP_SERIALIZATION_TIER_0 = 0, - D3D12_HEAP_SERIALIZATION_TIER_10 = 10 - } D3D12_HEAP_SERIALIZATION_TIER; - -typedef struct D3D12_FEATURE_DATA_SERIALIZATION - { - _In_ UINT NodeIndex; - _Out_ D3D12_HEAP_SERIALIZATION_TIER HeapSerializationTier; - } D3D12_FEATURE_DATA_SERIALIZATION; - -typedef struct D3D12_FEATURE_DATA_CROSS_NODE - { - D3D12_CROSS_NODE_SHARING_TIER SharingTier; - BOOL AtomicShaderInstructions; - } D3D12_FEATURE_DATA_CROSS_NODE; - -typedef -enum D3D12_RENDER_PASS_TIER - { - D3D12_RENDER_PASS_TIER_0 = 0, - D3D12_RENDER_PASS_TIER_1 = 1, - D3D12_RENDER_PASS_TIER_2 = 2 - } D3D12_RENDER_PASS_TIER; - -typedef -enum D3D12_RAYTRACING_TIER - { - D3D12_RAYTRACING_TIER_NOT_SUPPORTED = 0, - D3D12_RAYTRACING_TIER_1_0 = 10 - } D3D12_RAYTRACING_TIER; - -typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS5 - { - _Out_ BOOL SRVOnlyTiledResourceTier3; - _Out_ D3D12_RENDER_PASS_TIER RenderPassesTier; - _Out_ D3D12_RAYTRACING_TIER RaytracingTier; - } D3D12_FEATURE_DATA_D3D12_OPTIONS5; - -typedef -enum D3D12_VARIABLE_SHADING_RATE_TIER - { - D3D12_VARIABLE_SHADING_RATE_TIER_NOT_SUPPORTED = 0, - D3D12_VARIABLE_SHADING_RATE_TIER_1 = 1, - D3D12_VARIABLE_SHADING_RATE_TIER_2 = 2 - } D3D12_VARIABLE_SHADING_RATE_TIER; - -typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS6 - { - _Out_ BOOL AdditionalShadingRatesSupported; - _Out_ BOOL PerPrimitiveShadingRateSupportedWithViewportIndexing; - _Out_ D3D12_VARIABLE_SHADING_RATE_TIER VariableShadingRateTier; - _Out_ UINT ShadingRateImageTileSize; - _Out_ BOOL BackgroundProcessingSupported; - } D3D12_FEATURE_DATA_D3D12_OPTIONS6; - -typedef struct D3D12_FEATURE_DATA_QUERY_META_COMMAND - { - _In_ GUID CommandId; - _In_ UINT NodeMask; - _Field_size_bytes_full_opt_( QueryInputDataSizeInBytes ) const void *pQueryInputData; - _In_ SIZE_T QueryInputDataSizeInBytes; - _Field_size_bytes_full_( QueryOutputDataSizeInBytes ) void *pQueryOutputData; - _In_ SIZE_T QueryOutputDataSizeInBytes; - } D3D12_FEATURE_DATA_QUERY_META_COMMAND; - -typedef struct D3D12_RESOURCE_ALLOCATION_INFO - { - UINT64 SizeInBytes; - UINT64 Alignment; - } D3D12_RESOURCE_ALLOCATION_INFO; - -typedef struct D3D12_RESOURCE_ALLOCATION_INFO1 - { - UINT64 Offset; - UINT64 Alignment; - UINT64 SizeInBytes; - } D3D12_RESOURCE_ALLOCATION_INFO1; - -typedef -enum D3D12_HEAP_TYPE - { - D3D12_HEAP_TYPE_DEFAULT = 1, - D3D12_HEAP_TYPE_UPLOAD = 2, - D3D12_HEAP_TYPE_READBACK = 3, - D3D12_HEAP_TYPE_CUSTOM = 4 - } D3D12_HEAP_TYPE; - -typedef -enum D3D12_CPU_PAGE_PROPERTY - { - D3D12_CPU_PAGE_PROPERTY_UNKNOWN = 0, - D3D12_CPU_PAGE_PROPERTY_NOT_AVAILABLE = 1, - D3D12_CPU_PAGE_PROPERTY_WRITE_COMBINE = 2, - D3D12_CPU_PAGE_PROPERTY_WRITE_BACK = 3 - } D3D12_CPU_PAGE_PROPERTY; - -typedef -enum D3D12_MEMORY_POOL - { - D3D12_MEMORY_POOL_UNKNOWN = 0, - D3D12_MEMORY_POOL_L0 = 1, - D3D12_MEMORY_POOL_L1 = 2 - } D3D12_MEMORY_POOL; - -typedef struct D3D12_HEAP_PROPERTIES - { - D3D12_HEAP_TYPE Type; - D3D12_CPU_PAGE_PROPERTY CPUPageProperty; - D3D12_MEMORY_POOL MemoryPoolPreference; - UINT CreationNodeMask; - UINT VisibleNodeMask; - } D3D12_HEAP_PROPERTIES; - -typedef -enum D3D12_HEAP_FLAGS - { - D3D12_HEAP_FLAG_NONE = 0, - D3D12_HEAP_FLAG_SHARED = 0x1, - D3D12_HEAP_FLAG_DENY_BUFFERS = 0x4, - D3D12_HEAP_FLAG_ALLOW_DISPLAY = 0x8, - D3D12_HEAP_FLAG_SHARED_CROSS_ADAPTER = 0x20, - D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES = 0x40, - D3D12_HEAP_FLAG_DENY_NON_RT_DS_TEXTURES = 0x80, - D3D12_HEAP_FLAG_HARDWARE_PROTECTED = 0x100, - D3D12_HEAP_FLAG_ALLOW_WRITE_WATCH = 0x200, - D3D12_HEAP_FLAG_ALLOW_SHADER_ATOMICS = 0x400, - D3D12_HEAP_FLAG_ALLOW_ALL_BUFFERS_AND_TEXTURES = 0, - D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS = 0xc0, - D3D12_HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES = 0x44, - D3D12_HEAP_FLAG_ALLOW_ONLY_RT_DS_TEXTURES = 0x84 - } D3D12_HEAP_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_HEAP_FLAGS ); -typedef struct D3D12_HEAP_DESC - { - UINT64 SizeInBytes; - D3D12_HEAP_PROPERTIES Properties; - UINT64 Alignment; - D3D12_HEAP_FLAGS Flags; - } D3D12_HEAP_DESC; - -typedef -enum D3D12_RESOURCE_DIMENSION - { - D3D12_RESOURCE_DIMENSION_UNKNOWN = 0, - D3D12_RESOURCE_DIMENSION_BUFFER = 1, - D3D12_RESOURCE_DIMENSION_TEXTURE1D = 2, - D3D12_RESOURCE_DIMENSION_TEXTURE2D = 3, - D3D12_RESOURCE_DIMENSION_TEXTURE3D = 4 - } D3D12_RESOURCE_DIMENSION; - -typedef -enum D3D12_TEXTURE_LAYOUT - { - D3D12_TEXTURE_LAYOUT_UNKNOWN = 0, - D3D12_TEXTURE_LAYOUT_ROW_MAJOR = 1, - D3D12_TEXTURE_LAYOUT_64KB_UNDEFINED_SWIZZLE = 2, - D3D12_TEXTURE_LAYOUT_64KB_STANDARD_SWIZZLE = 3 - } D3D12_TEXTURE_LAYOUT; - -typedef -enum D3D12_RESOURCE_FLAGS - { - D3D12_RESOURCE_FLAG_NONE = 0, - D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET = 0x1, - D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL = 0x2, - D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS = 0x4, - D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE = 0x8, - D3D12_RESOURCE_FLAG_ALLOW_CROSS_ADAPTER = 0x10, - D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS = 0x20, - D3D12_RESOURCE_FLAG_VIDEO_DECODE_REFERENCE_ONLY = 0x40 - } D3D12_RESOURCE_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_RESOURCE_FLAGS ); -typedef struct D3D12_RESOURCE_DESC - { - D3D12_RESOURCE_DIMENSION Dimension; - UINT64 Alignment; - UINT64 Width; - UINT Height; - UINT16 DepthOrArraySize; - UINT16 MipLevels; - DXGI_FORMAT Format; - DXGI_SAMPLE_DESC SampleDesc; - D3D12_TEXTURE_LAYOUT Layout; - D3D12_RESOURCE_FLAGS Flags; - } D3D12_RESOURCE_DESC; - -typedef struct D3D12_DEPTH_STENCIL_VALUE - { - FLOAT Depth; - UINT8 Stencil; - } D3D12_DEPTH_STENCIL_VALUE; - -typedef struct D3D12_CLEAR_VALUE - { - DXGI_FORMAT Format; - union - { - FLOAT Color[ 4 ]; - D3D12_DEPTH_STENCIL_VALUE DepthStencil; - } ; - } D3D12_CLEAR_VALUE; - -typedef struct D3D12_RANGE - { - SIZE_T Begin; - SIZE_T End; - } D3D12_RANGE; - -typedef struct D3D12_RANGE_UINT64 - { - UINT64 Begin; - UINT64 End; - } D3D12_RANGE_UINT64; - -typedef struct D3D12_SUBRESOURCE_RANGE_UINT64 - { - UINT Subresource; - D3D12_RANGE_UINT64 Range; - } D3D12_SUBRESOURCE_RANGE_UINT64; - -typedef struct D3D12_SUBRESOURCE_INFO - { - UINT64 Offset; - UINT RowPitch; - UINT DepthPitch; - } D3D12_SUBRESOURCE_INFO; - -typedef struct D3D12_TILED_RESOURCE_COORDINATE - { - UINT X; - UINT Y; - UINT Z; - UINT Subresource; - } D3D12_TILED_RESOURCE_COORDINATE; - -typedef struct D3D12_TILE_REGION_SIZE - { - UINT NumTiles; - BOOL UseBox; - UINT Width; - UINT16 Height; - UINT16 Depth; - } D3D12_TILE_REGION_SIZE; - -typedef -enum D3D12_TILE_RANGE_FLAGS - { - D3D12_TILE_RANGE_FLAG_NONE = 0, - D3D12_TILE_RANGE_FLAG_NULL = 1, - D3D12_TILE_RANGE_FLAG_SKIP = 2, - D3D12_TILE_RANGE_FLAG_REUSE_SINGLE_TILE = 4 - } D3D12_TILE_RANGE_FLAGS; - -typedef struct D3D12_SUBRESOURCE_TILING - { - UINT WidthInTiles; - UINT16 HeightInTiles; - UINT16 DepthInTiles; - UINT StartTileIndexInOverallResource; - } D3D12_SUBRESOURCE_TILING; - -typedef struct D3D12_TILE_SHAPE - { - UINT WidthInTexels; - UINT HeightInTexels; - UINT DepthInTexels; - } D3D12_TILE_SHAPE; - -typedef struct D3D12_PACKED_MIP_INFO - { - UINT8 NumStandardMips; - UINT8 NumPackedMips; - UINT NumTilesForPackedMips; - UINT StartTileIndexInOverallResource; - } D3D12_PACKED_MIP_INFO; - -typedef -enum D3D12_TILE_MAPPING_FLAGS - { - D3D12_TILE_MAPPING_FLAG_NONE = 0, - D3D12_TILE_MAPPING_FLAG_NO_HAZARD = 0x1 - } D3D12_TILE_MAPPING_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_TILE_MAPPING_FLAGS ); -typedef -enum D3D12_TILE_COPY_FLAGS - { - D3D12_TILE_COPY_FLAG_NONE = 0, - D3D12_TILE_COPY_FLAG_NO_HAZARD = 0x1, - D3D12_TILE_COPY_FLAG_LINEAR_BUFFER_TO_SWIZZLED_TILED_RESOURCE = 0x2, - D3D12_TILE_COPY_FLAG_SWIZZLED_TILED_RESOURCE_TO_LINEAR_BUFFER = 0x4 - } D3D12_TILE_COPY_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_TILE_COPY_FLAGS ); -typedef -enum D3D12_RESOURCE_STATES - { - D3D12_RESOURCE_STATE_COMMON = 0, - D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER = 0x1, - D3D12_RESOURCE_STATE_INDEX_BUFFER = 0x2, - D3D12_RESOURCE_STATE_RENDER_TARGET = 0x4, - D3D12_RESOURCE_STATE_UNORDERED_ACCESS = 0x8, - D3D12_RESOURCE_STATE_DEPTH_WRITE = 0x10, - D3D12_RESOURCE_STATE_DEPTH_READ = 0x20, - D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE = 0x40, - D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE = 0x80, - D3D12_RESOURCE_STATE_STREAM_OUT = 0x100, - D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT = 0x200, - D3D12_RESOURCE_STATE_COPY_DEST = 0x400, - D3D12_RESOURCE_STATE_COPY_SOURCE = 0x800, - D3D12_RESOURCE_STATE_RESOLVE_DEST = 0x1000, - D3D12_RESOURCE_STATE_RESOLVE_SOURCE = 0x2000, - D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE = 0x400000, - D3D12_RESOURCE_STATE_SHADING_RATE_SOURCE = 0x1000000, - D3D12_RESOURCE_STATE_GENERIC_READ = ( ( ( ( ( 0x1 | 0x2 ) | 0x40 ) | 0x80 ) | 0x200 ) | 0x800 ) , - D3D12_RESOURCE_STATE_PRESENT = 0, - D3D12_RESOURCE_STATE_PREDICATION = 0x200, - D3D12_RESOURCE_STATE_VIDEO_DECODE_READ = 0x10000, - D3D12_RESOURCE_STATE_VIDEO_DECODE_WRITE = 0x20000, - D3D12_RESOURCE_STATE_VIDEO_PROCESS_READ = 0x40000, - D3D12_RESOURCE_STATE_VIDEO_PROCESS_WRITE = 0x80000, - D3D12_RESOURCE_STATE_VIDEO_ENCODE_READ = 0x200000, - D3D12_RESOURCE_STATE_VIDEO_ENCODE_WRITE = 0x800000 - } D3D12_RESOURCE_STATES; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_RESOURCE_STATES ); -typedef -enum D3D12_RESOURCE_BARRIER_TYPE - { - D3D12_RESOURCE_BARRIER_TYPE_TRANSITION = 0, - D3D12_RESOURCE_BARRIER_TYPE_ALIASING = ( D3D12_RESOURCE_BARRIER_TYPE_TRANSITION + 1 ) , - D3D12_RESOURCE_BARRIER_TYPE_UAV = ( D3D12_RESOURCE_BARRIER_TYPE_ALIASING + 1 ) - } D3D12_RESOURCE_BARRIER_TYPE; - - -typedef struct D3D12_RESOURCE_TRANSITION_BARRIER - { - ID3D12Resource *pResource; - UINT Subresource; - D3D12_RESOURCE_STATES StateBefore; - D3D12_RESOURCE_STATES StateAfter; - } D3D12_RESOURCE_TRANSITION_BARRIER; - -typedef struct D3D12_RESOURCE_ALIASING_BARRIER - { - ID3D12Resource *pResourceBefore; - ID3D12Resource *pResourceAfter; - } D3D12_RESOURCE_ALIASING_BARRIER; - -typedef struct D3D12_RESOURCE_UAV_BARRIER - { - ID3D12Resource *pResource; - } D3D12_RESOURCE_UAV_BARRIER; - -typedef -enum D3D12_RESOURCE_BARRIER_FLAGS - { - D3D12_RESOURCE_BARRIER_FLAG_NONE = 0, - D3D12_RESOURCE_BARRIER_FLAG_BEGIN_ONLY = 0x1, - D3D12_RESOURCE_BARRIER_FLAG_END_ONLY = 0x2 - } D3D12_RESOURCE_BARRIER_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_RESOURCE_BARRIER_FLAGS ); -typedef struct D3D12_RESOURCE_BARRIER - { - D3D12_RESOURCE_BARRIER_TYPE Type; - D3D12_RESOURCE_BARRIER_FLAGS Flags; - union - { - D3D12_RESOURCE_TRANSITION_BARRIER Transition; - D3D12_RESOURCE_ALIASING_BARRIER Aliasing; - D3D12_RESOURCE_UAV_BARRIER UAV; - } ; - } D3D12_RESOURCE_BARRIER; - -typedef struct D3D12_SUBRESOURCE_FOOTPRINT - { - DXGI_FORMAT Format; - UINT Width; - UINT Height; - UINT Depth; - UINT RowPitch; - } D3D12_SUBRESOURCE_FOOTPRINT; - -typedef struct D3D12_PLACED_SUBRESOURCE_FOOTPRINT - { - UINT64 Offset; - D3D12_SUBRESOURCE_FOOTPRINT Footprint; - } D3D12_PLACED_SUBRESOURCE_FOOTPRINT; - -typedef -enum D3D12_TEXTURE_COPY_TYPE - { - D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX = 0, - D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT = 1 - } D3D12_TEXTURE_COPY_TYPE; - -typedef struct D3D12_TEXTURE_COPY_LOCATION - { - ID3D12Resource *pResource; - D3D12_TEXTURE_COPY_TYPE Type; - union - { - D3D12_PLACED_SUBRESOURCE_FOOTPRINT PlacedFootprint; - UINT SubresourceIndex; - } ; - } D3D12_TEXTURE_COPY_LOCATION; - -typedef -enum D3D12_RESOLVE_MODE - { - D3D12_RESOLVE_MODE_DECOMPRESS = 0, - D3D12_RESOLVE_MODE_MIN = 1, - D3D12_RESOLVE_MODE_MAX = 2, - D3D12_RESOLVE_MODE_AVERAGE = 3 - } D3D12_RESOLVE_MODE; - -typedef struct D3D12_SAMPLE_POSITION - { - INT8 X; - INT8 Y; - } D3D12_SAMPLE_POSITION; - -typedef struct D3D12_VIEW_INSTANCE_LOCATION - { - UINT ViewportArrayIndex; - UINT RenderTargetArrayIndex; - } D3D12_VIEW_INSTANCE_LOCATION; - -typedef -enum D3D12_VIEW_INSTANCING_FLAGS - { - D3D12_VIEW_INSTANCING_FLAG_NONE = 0, - D3D12_VIEW_INSTANCING_FLAG_ENABLE_VIEW_INSTANCE_MASKING = 0x1 - } D3D12_VIEW_INSTANCING_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_VIEW_INSTANCING_FLAGS ); -typedef struct D3D12_VIEW_INSTANCING_DESC - { - UINT ViewInstanceCount; - _Field_size_full_(ViewInstanceCount) const D3D12_VIEW_INSTANCE_LOCATION *pViewInstanceLocations; - D3D12_VIEW_INSTANCING_FLAGS Flags; - } D3D12_VIEW_INSTANCING_DESC; - -typedef -enum D3D12_SHADER_COMPONENT_MAPPING - { - D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_0 = 0, - D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_1 = 1, - D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_2 = 2, - D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_3 = 3, - D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_0 = 4, - D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_1 = 5 - } D3D12_SHADER_COMPONENT_MAPPING; - -#define D3D12_SHADER_COMPONENT_MAPPING_MASK 0x7 -#define D3D12_SHADER_COMPONENT_MAPPING_SHIFT 3 -#define D3D12_SHADER_COMPONENT_MAPPING_ALWAYS_SET_BIT_AVOIDING_ZEROMEM_MISTAKES (1<<(D3D12_SHADER_COMPONENT_MAPPING_SHIFT*4)) -#define D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING(Src0,Src1,Src2,Src3) ((((Src0)&D3D12_SHADER_COMPONENT_MAPPING_MASK)| \ - (((Src1)&D3D12_SHADER_COMPONENT_MAPPING_MASK)<> (D3D12_SHADER_COMPONENT_MAPPING_SHIFT*ComponentToExtract) & D3D12_SHADER_COMPONENT_MAPPING_MASK)) -#define D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING(0,1,2,3) -typedef -enum D3D12_BUFFER_SRV_FLAGS - { - D3D12_BUFFER_SRV_FLAG_NONE = 0, - D3D12_BUFFER_SRV_FLAG_RAW = 0x1 - } D3D12_BUFFER_SRV_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_BUFFER_SRV_FLAGS ); -typedef struct D3D12_BUFFER_SRV - { - UINT64 FirstElement; - UINT NumElements; - UINT StructureByteStride; - D3D12_BUFFER_SRV_FLAGS Flags; - } D3D12_BUFFER_SRV; - -typedef struct D3D12_TEX1D_SRV - { - UINT MostDetailedMip; - UINT MipLevels; - FLOAT ResourceMinLODClamp; - } D3D12_TEX1D_SRV; - -typedef struct D3D12_TEX1D_ARRAY_SRV - { - UINT MostDetailedMip; - UINT MipLevels; - UINT FirstArraySlice; - UINT ArraySize; - FLOAT ResourceMinLODClamp; - } D3D12_TEX1D_ARRAY_SRV; - -typedef struct D3D12_TEX2D_SRV - { - UINT MostDetailedMip; - UINT MipLevels; - UINT PlaneSlice; - FLOAT ResourceMinLODClamp; - } D3D12_TEX2D_SRV; - -typedef struct D3D12_TEX2D_ARRAY_SRV - { - UINT MostDetailedMip; - UINT MipLevels; - UINT FirstArraySlice; - UINT ArraySize; - UINT PlaneSlice; - FLOAT ResourceMinLODClamp; - } D3D12_TEX2D_ARRAY_SRV; - -typedef struct D3D12_TEX3D_SRV - { - UINT MostDetailedMip; - UINT MipLevels; - FLOAT ResourceMinLODClamp; - } D3D12_TEX3D_SRV; - -typedef struct D3D12_TEXCUBE_SRV - { - UINT MostDetailedMip; - UINT MipLevels; - FLOAT ResourceMinLODClamp; - } D3D12_TEXCUBE_SRV; - -typedef struct D3D12_TEXCUBE_ARRAY_SRV - { - UINT MostDetailedMip; - UINT MipLevels; - UINT First2DArrayFace; - UINT NumCubes; - FLOAT ResourceMinLODClamp; - } D3D12_TEXCUBE_ARRAY_SRV; - -typedef struct D3D12_TEX2DMS_SRV - { - UINT UnusedField_NothingToDefine; - } D3D12_TEX2DMS_SRV; - -typedef struct D3D12_TEX2DMS_ARRAY_SRV - { - UINT FirstArraySlice; - UINT ArraySize; - } D3D12_TEX2DMS_ARRAY_SRV; - -typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_SRV - { - D3D12_GPU_VIRTUAL_ADDRESS Location; - } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_SRV; - -typedef -enum D3D12_SRV_DIMENSION - { - D3D12_SRV_DIMENSION_UNKNOWN = 0, - D3D12_SRV_DIMENSION_BUFFER = 1, - D3D12_SRV_DIMENSION_TEXTURE1D = 2, - D3D12_SRV_DIMENSION_TEXTURE1DARRAY = 3, - D3D12_SRV_DIMENSION_TEXTURE2D = 4, - D3D12_SRV_DIMENSION_TEXTURE2DARRAY = 5, - D3D12_SRV_DIMENSION_TEXTURE2DMS = 6, - D3D12_SRV_DIMENSION_TEXTURE2DMSARRAY = 7, - D3D12_SRV_DIMENSION_TEXTURE3D = 8, - D3D12_SRV_DIMENSION_TEXTURECUBE = 9, - D3D12_SRV_DIMENSION_TEXTURECUBEARRAY = 10, - D3D12_SRV_DIMENSION_RAYTRACING_ACCELERATION_STRUCTURE = 11 - } D3D12_SRV_DIMENSION; - -typedef struct D3D12_SHADER_RESOURCE_VIEW_DESC - { - DXGI_FORMAT Format; - D3D12_SRV_DIMENSION ViewDimension; - UINT Shader4ComponentMapping; - union - { - D3D12_BUFFER_SRV Buffer; - D3D12_TEX1D_SRV Texture1D; - D3D12_TEX1D_ARRAY_SRV Texture1DArray; - D3D12_TEX2D_SRV Texture2D; - D3D12_TEX2D_ARRAY_SRV Texture2DArray; - D3D12_TEX2DMS_SRV Texture2DMS; - D3D12_TEX2DMS_ARRAY_SRV Texture2DMSArray; - D3D12_TEX3D_SRV Texture3D; - D3D12_TEXCUBE_SRV TextureCube; - D3D12_TEXCUBE_ARRAY_SRV TextureCubeArray; - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_SRV RaytracingAccelerationStructure; - } ; - } D3D12_SHADER_RESOURCE_VIEW_DESC; - -typedef struct D3D12_CONSTANT_BUFFER_VIEW_DESC - { - D3D12_GPU_VIRTUAL_ADDRESS BufferLocation; - UINT SizeInBytes; - } D3D12_CONSTANT_BUFFER_VIEW_DESC; - -typedef -enum D3D12_FILTER - { - D3D12_FILTER_MIN_MAG_MIP_POINT = 0, - D3D12_FILTER_MIN_MAG_POINT_MIP_LINEAR = 0x1, - D3D12_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x4, - D3D12_FILTER_MIN_POINT_MAG_MIP_LINEAR = 0x5, - D3D12_FILTER_MIN_LINEAR_MAG_MIP_POINT = 0x10, - D3D12_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x11, - D3D12_FILTER_MIN_MAG_LINEAR_MIP_POINT = 0x14, - D3D12_FILTER_MIN_MAG_MIP_LINEAR = 0x15, - D3D12_FILTER_ANISOTROPIC = 0x55, - D3D12_FILTER_COMPARISON_MIN_MAG_MIP_POINT = 0x80, - D3D12_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR = 0x81, - D3D12_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x84, - D3D12_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR = 0x85, - D3D12_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT = 0x90, - D3D12_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x91, - D3D12_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT = 0x94, - D3D12_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR = 0x95, - D3D12_FILTER_COMPARISON_ANISOTROPIC = 0xd5, - D3D12_FILTER_MINIMUM_MIN_MAG_MIP_POINT = 0x100, - D3D12_FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR = 0x101, - D3D12_FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x104, - D3D12_FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR = 0x105, - D3D12_FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT = 0x110, - D3D12_FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x111, - D3D12_FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT = 0x114, - D3D12_FILTER_MINIMUM_MIN_MAG_MIP_LINEAR = 0x115, - D3D12_FILTER_MINIMUM_ANISOTROPIC = 0x155, - D3D12_FILTER_MAXIMUM_MIN_MAG_MIP_POINT = 0x180, - D3D12_FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR = 0x181, - D3D12_FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x184, - D3D12_FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR = 0x185, - D3D12_FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT = 0x190, - D3D12_FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x191, - D3D12_FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT = 0x194, - D3D12_FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR = 0x195, - D3D12_FILTER_MAXIMUM_ANISOTROPIC = 0x1d5 - } D3D12_FILTER; - -typedef -enum D3D12_FILTER_TYPE - { - D3D12_FILTER_TYPE_POINT = 0, - D3D12_FILTER_TYPE_LINEAR = 1 - } D3D12_FILTER_TYPE; - -typedef -enum D3D12_FILTER_REDUCTION_TYPE - { - D3D12_FILTER_REDUCTION_TYPE_STANDARD = 0, - D3D12_FILTER_REDUCTION_TYPE_COMPARISON = 1, - D3D12_FILTER_REDUCTION_TYPE_MINIMUM = 2, - D3D12_FILTER_REDUCTION_TYPE_MAXIMUM = 3 - } D3D12_FILTER_REDUCTION_TYPE; - -#define D3D12_FILTER_REDUCTION_TYPE_MASK ( 0x3 ) - -#define D3D12_FILTER_REDUCTION_TYPE_SHIFT ( 7 ) - -#define D3D12_FILTER_TYPE_MASK ( 0x3 ) - -#define D3D12_MIN_FILTER_SHIFT ( 4 ) - -#define D3D12_MAG_FILTER_SHIFT ( 2 ) - -#define D3D12_MIP_FILTER_SHIFT ( 0 ) - -#define D3D12_ANISOTROPIC_FILTERING_BIT ( 0x40 ) - -#define D3D12_ENCODE_BASIC_FILTER( min, mag, mip, reduction ) \ - ( ( D3D12_FILTER ) ( \ - ( ( ( min ) & D3D12_FILTER_TYPE_MASK ) << D3D12_MIN_FILTER_SHIFT ) | \ - ( ( ( mag ) & D3D12_FILTER_TYPE_MASK ) << D3D12_MAG_FILTER_SHIFT ) | \ - ( ( ( mip ) & D3D12_FILTER_TYPE_MASK ) << D3D12_MIP_FILTER_SHIFT ) | \ - ( ( ( reduction ) & D3D12_FILTER_REDUCTION_TYPE_MASK ) << D3D12_FILTER_REDUCTION_TYPE_SHIFT ) ) ) -#define D3D12_ENCODE_ANISOTROPIC_FILTER( reduction ) \ - ( ( D3D12_FILTER ) ( \ - D3D12_ANISOTROPIC_FILTERING_BIT | \ - D3D12_ENCODE_BASIC_FILTER( D3D12_FILTER_TYPE_LINEAR, \ - D3D12_FILTER_TYPE_LINEAR, \ - D3D12_FILTER_TYPE_LINEAR, \ - reduction ) ) ) -#define D3D12_DECODE_MIN_FILTER( D3D12Filter ) \ - ( ( D3D12_FILTER_TYPE ) \ - ( ( ( D3D12Filter ) >> D3D12_MIN_FILTER_SHIFT ) & D3D12_FILTER_TYPE_MASK ) ) -#define D3D12_DECODE_MAG_FILTER( D3D12Filter ) \ - ( ( D3D12_FILTER_TYPE ) \ - ( ( ( D3D12Filter ) >> D3D12_MAG_FILTER_SHIFT ) & D3D12_FILTER_TYPE_MASK ) ) -#define D3D12_DECODE_MIP_FILTER( D3D12Filter ) \ - ( ( D3D12_FILTER_TYPE ) \ - ( ( ( D3D12Filter ) >> D3D12_MIP_FILTER_SHIFT ) & D3D12_FILTER_TYPE_MASK ) ) -#define D3D12_DECODE_FILTER_REDUCTION( D3D12Filter ) \ - ( ( D3D12_FILTER_REDUCTION_TYPE ) \ - ( ( ( D3D12Filter ) >> D3D12_FILTER_REDUCTION_TYPE_SHIFT ) & D3D12_FILTER_REDUCTION_TYPE_MASK ) ) -#define D3D12_DECODE_IS_COMPARISON_FILTER( D3D12Filter ) \ - ( D3D12_DECODE_FILTER_REDUCTION( D3D12Filter ) == D3D12_FILTER_REDUCTION_TYPE_COMPARISON ) -#define D3D12_DECODE_IS_ANISOTROPIC_FILTER( D3D12Filter ) \ - ( ( ( D3D12Filter ) & D3D12_ANISOTROPIC_FILTERING_BIT ) && \ - ( D3D12_FILTER_TYPE_LINEAR == D3D12_DECODE_MIN_FILTER( D3D12Filter ) ) && \ - ( D3D12_FILTER_TYPE_LINEAR == D3D12_DECODE_MAG_FILTER( D3D12Filter ) ) && \ - ( D3D12_FILTER_TYPE_LINEAR == D3D12_DECODE_MIP_FILTER( D3D12Filter ) ) ) -typedef -enum D3D12_TEXTURE_ADDRESS_MODE - { - D3D12_TEXTURE_ADDRESS_MODE_WRAP = 1, - D3D12_TEXTURE_ADDRESS_MODE_MIRROR = 2, - D3D12_TEXTURE_ADDRESS_MODE_CLAMP = 3, - D3D12_TEXTURE_ADDRESS_MODE_BORDER = 4, - D3D12_TEXTURE_ADDRESS_MODE_MIRROR_ONCE = 5 - } D3D12_TEXTURE_ADDRESS_MODE; - -typedef struct D3D12_SAMPLER_DESC - { - D3D12_FILTER Filter; - D3D12_TEXTURE_ADDRESS_MODE AddressU; - D3D12_TEXTURE_ADDRESS_MODE AddressV; - D3D12_TEXTURE_ADDRESS_MODE AddressW; - FLOAT MipLODBias; - UINT MaxAnisotropy; - D3D12_COMPARISON_FUNC ComparisonFunc; - FLOAT BorderColor[ 4 ]; - FLOAT MinLOD; - FLOAT MaxLOD; - } D3D12_SAMPLER_DESC; - -typedef -enum D3D12_BUFFER_UAV_FLAGS - { - D3D12_BUFFER_UAV_FLAG_NONE = 0, - D3D12_BUFFER_UAV_FLAG_RAW = 0x1 - } D3D12_BUFFER_UAV_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_BUFFER_UAV_FLAGS ); -typedef struct D3D12_BUFFER_UAV - { - UINT64 FirstElement; - UINT NumElements; - UINT StructureByteStride; - UINT64 CounterOffsetInBytes; - D3D12_BUFFER_UAV_FLAGS Flags; - } D3D12_BUFFER_UAV; - -typedef struct D3D12_TEX1D_UAV - { - UINT MipSlice; - } D3D12_TEX1D_UAV; - -typedef struct D3D12_TEX1D_ARRAY_UAV - { - UINT MipSlice; - UINT FirstArraySlice; - UINT ArraySize; - } D3D12_TEX1D_ARRAY_UAV; - -typedef struct D3D12_TEX2D_UAV - { - UINT MipSlice; - UINT PlaneSlice; - } D3D12_TEX2D_UAV; - -typedef struct D3D12_TEX2D_ARRAY_UAV - { - UINT MipSlice; - UINT FirstArraySlice; - UINT ArraySize; - UINT PlaneSlice; - } D3D12_TEX2D_ARRAY_UAV; - -typedef struct D3D12_TEX3D_UAV - { - UINT MipSlice; - UINT FirstWSlice; - UINT WSize; - } D3D12_TEX3D_UAV; - -typedef -enum D3D12_UAV_DIMENSION - { - D3D12_UAV_DIMENSION_UNKNOWN = 0, - D3D12_UAV_DIMENSION_BUFFER = 1, - D3D12_UAV_DIMENSION_TEXTURE1D = 2, - D3D12_UAV_DIMENSION_TEXTURE1DARRAY = 3, - D3D12_UAV_DIMENSION_TEXTURE2D = 4, - D3D12_UAV_DIMENSION_TEXTURE2DARRAY = 5, - D3D12_UAV_DIMENSION_TEXTURE3D = 8 - } D3D12_UAV_DIMENSION; - -typedef struct D3D12_UNORDERED_ACCESS_VIEW_DESC - { - DXGI_FORMAT Format; - D3D12_UAV_DIMENSION ViewDimension; - union - { - D3D12_BUFFER_UAV Buffer; - D3D12_TEX1D_UAV Texture1D; - D3D12_TEX1D_ARRAY_UAV Texture1DArray; - D3D12_TEX2D_UAV Texture2D; - D3D12_TEX2D_ARRAY_UAV Texture2DArray; - D3D12_TEX3D_UAV Texture3D; - } ; - } D3D12_UNORDERED_ACCESS_VIEW_DESC; - -typedef struct D3D12_BUFFER_RTV - { - UINT64 FirstElement; - UINT NumElements; - } D3D12_BUFFER_RTV; - -typedef struct D3D12_TEX1D_RTV - { - UINT MipSlice; - } D3D12_TEX1D_RTV; - -typedef struct D3D12_TEX1D_ARRAY_RTV - { - UINT MipSlice; - UINT FirstArraySlice; - UINT ArraySize; - } D3D12_TEX1D_ARRAY_RTV; - -typedef struct D3D12_TEX2D_RTV - { - UINT MipSlice; - UINT PlaneSlice; - } D3D12_TEX2D_RTV; - -typedef struct D3D12_TEX2DMS_RTV - { - UINT UnusedField_NothingToDefine; - } D3D12_TEX2DMS_RTV; - -typedef struct D3D12_TEX2D_ARRAY_RTV - { - UINT MipSlice; - UINT FirstArraySlice; - UINT ArraySize; - UINT PlaneSlice; - } D3D12_TEX2D_ARRAY_RTV; - -typedef struct D3D12_TEX2DMS_ARRAY_RTV - { - UINT FirstArraySlice; - UINT ArraySize; - } D3D12_TEX2DMS_ARRAY_RTV; - -typedef struct D3D12_TEX3D_RTV - { - UINT MipSlice; - UINT FirstWSlice; - UINT WSize; - } D3D12_TEX3D_RTV; - -typedef -enum D3D12_RTV_DIMENSION - { - D3D12_RTV_DIMENSION_UNKNOWN = 0, - D3D12_RTV_DIMENSION_BUFFER = 1, - D3D12_RTV_DIMENSION_TEXTURE1D = 2, - D3D12_RTV_DIMENSION_TEXTURE1DARRAY = 3, - D3D12_RTV_DIMENSION_TEXTURE2D = 4, - D3D12_RTV_DIMENSION_TEXTURE2DARRAY = 5, - D3D12_RTV_DIMENSION_TEXTURE2DMS = 6, - D3D12_RTV_DIMENSION_TEXTURE2DMSARRAY = 7, - D3D12_RTV_DIMENSION_TEXTURE3D = 8 - } D3D12_RTV_DIMENSION; - -typedef struct D3D12_RENDER_TARGET_VIEW_DESC - { - DXGI_FORMAT Format; - D3D12_RTV_DIMENSION ViewDimension; - union - { - D3D12_BUFFER_RTV Buffer; - D3D12_TEX1D_RTV Texture1D; - D3D12_TEX1D_ARRAY_RTV Texture1DArray; - D3D12_TEX2D_RTV Texture2D; - D3D12_TEX2D_ARRAY_RTV Texture2DArray; - D3D12_TEX2DMS_RTV Texture2DMS; - D3D12_TEX2DMS_ARRAY_RTV Texture2DMSArray; - D3D12_TEX3D_RTV Texture3D; - } ; - } D3D12_RENDER_TARGET_VIEW_DESC; - -typedef struct D3D12_TEX1D_DSV - { - UINT MipSlice; - } D3D12_TEX1D_DSV; - -typedef struct D3D12_TEX1D_ARRAY_DSV - { - UINT MipSlice; - UINT FirstArraySlice; - UINT ArraySize; - } D3D12_TEX1D_ARRAY_DSV; - -typedef struct D3D12_TEX2D_DSV - { - UINT MipSlice; - } D3D12_TEX2D_DSV; - -typedef struct D3D12_TEX2D_ARRAY_DSV - { - UINT MipSlice; - UINT FirstArraySlice; - UINT ArraySize; - } D3D12_TEX2D_ARRAY_DSV; - -typedef struct D3D12_TEX2DMS_DSV - { - UINT UnusedField_NothingToDefine; - } D3D12_TEX2DMS_DSV; - -typedef struct D3D12_TEX2DMS_ARRAY_DSV - { - UINT FirstArraySlice; - UINT ArraySize; - } D3D12_TEX2DMS_ARRAY_DSV; - -typedef -enum D3D12_DSV_FLAGS - { - D3D12_DSV_FLAG_NONE = 0, - D3D12_DSV_FLAG_READ_ONLY_DEPTH = 0x1, - D3D12_DSV_FLAG_READ_ONLY_STENCIL = 0x2 - } D3D12_DSV_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_DSV_FLAGS ); -typedef -enum D3D12_DSV_DIMENSION - { - D3D12_DSV_DIMENSION_UNKNOWN = 0, - D3D12_DSV_DIMENSION_TEXTURE1D = 1, - D3D12_DSV_DIMENSION_TEXTURE1DARRAY = 2, - D3D12_DSV_DIMENSION_TEXTURE2D = 3, - D3D12_DSV_DIMENSION_TEXTURE2DARRAY = 4, - D3D12_DSV_DIMENSION_TEXTURE2DMS = 5, - D3D12_DSV_DIMENSION_TEXTURE2DMSARRAY = 6 - } D3D12_DSV_DIMENSION; - -typedef struct D3D12_DEPTH_STENCIL_VIEW_DESC - { - DXGI_FORMAT Format; - D3D12_DSV_DIMENSION ViewDimension; - D3D12_DSV_FLAGS Flags; - union - { - D3D12_TEX1D_DSV Texture1D; - D3D12_TEX1D_ARRAY_DSV Texture1DArray; - D3D12_TEX2D_DSV Texture2D; - D3D12_TEX2D_ARRAY_DSV Texture2DArray; - D3D12_TEX2DMS_DSV Texture2DMS; - D3D12_TEX2DMS_ARRAY_DSV Texture2DMSArray; - } ; - } D3D12_DEPTH_STENCIL_VIEW_DESC; - -typedef -enum D3D12_CLEAR_FLAGS - { - D3D12_CLEAR_FLAG_DEPTH = 0x1, - D3D12_CLEAR_FLAG_STENCIL = 0x2 - } D3D12_CLEAR_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_CLEAR_FLAGS ); -typedef -enum D3D12_FENCE_FLAGS - { - D3D12_FENCE_FLAG_NONE = 0, - D3D12_FENCE_FLAG_SHARED = 0x1, - D3D12_FENCE_FLAG_SHARED_CROSS_ADAPTER = 0x2, - D3D12_FENCE_FLAG_NON_MONITORED = 0x4 - } D3D12_FENCE_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_FENCE_FLAGS ); -typedef -enum D3D12_DESCRIPTOR_HEAP_TYPE - { - D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV = 0, - D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER = ( D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV + 1 ) , - D3D12_DESCRIPTOR_HEAP_TYPE_RTV = ( D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER + 1 ) , - D3D12_DESCRIPTOR_HEAP_TYPE_DSV = ( D3D12_DESCRIPTOR_HEAP_TYPE_RTV + 1 ) , - D3D12_DESCRIPTOR_HEAP_TYPE_NUM_TYPES = ( D3D12_DESCRIPTOR_HEAP_TYPE_DSV + 1 ) - } D3D12_DESCRIPTOR_HEAP_TYPE; - -typedef -enum D3D12_DESCRIPTOR_HEAP_FLAGS - { - D3D12_DESCRIPTOR_HEAP_FLAG_NONE = 0, - D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE = 0x1 - } D3D12_DESCRIPTOR_HEAP_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_DESCRIPTOR_HEAP_FLAGS ); -typedef struct D3D12_DESCRIPTOR_HEAP_DESC - { - D3D12_DESCRIPTOR_HEAP_TYPE Type; - UINT NumDescriptors; - D3D12_DESCRIPTOR_HEAP_FLAGS Flags; - UINT NodeMask; - } D3D12_DESCRIPTOR_HEAP_DESC; - -typedef -enum D3D12_DESCRIPTOR_RANGE_TYPE - { - D3D12_DESCRIPTOR_RANGE_TYPE_SRV = 0, - D3D12_DESCRIPTOR_RANGE_TYPE_UAV = ( D3D12_DESCRIPTOR_RANGE_TYPE_SRV + 1 ) , - D3D12_DESCRIPTOR_RANGE_TYPE_CBV = ( D3D12_DESCRIPTOR_RANGE_TYPE_UAV + 1 ) , - D3D12_DESCRIPTOR_RANGE_TYPE_SAMPLER = ( D3D12_DESCRIPTOR_RANGE_TYPE_CBV + 1 ) - } D3D12_DESCRIPTOR_RANGE_TYPE; - -typedef struct D3D12_DESCRIPTOR_RANGE - { - D3D12_DESCRIPTOR_RANGE_TYPE RangeType; - UINT NumDescriptors; - UINT BaseShaderRegister; - UINT RegisterSpace; - UINT OffsetInDescriptorsFromTableStart; - } D3D12_DESCRIPTOR_RANGE; - -typedef struct D3D12_ROOT_DESCRIPTOR_TABLE - { - UINT NumDescriptorRanges; - _Field_size_full_(NumDescriptorRanges) const D3D12_DESCRIPTOR_RANGE *pDescriptorRanges; - } D3D12_ROOT_DESCRIPTOR_TABLE; - -typedef struct D3D12_ROOT_CONSTANTS - { - UINT ShaderRegister; - UINT RegisterSpace; - UINT Num32BitValues; - } D3D12_ROOT_CONSTANTS; - -typedef struct D3D12_ROOT_DESCRIPTOR - { - UINT ShaderRegister; - UINT RegisterSpace; - } D3D12_ROOT_DESCRIPTOR; - -typedef -enum D3D12_SHADER_VISIBILITY - { - D3D12_SHADER_VISIBILITY_ALL = 0, - D3D12_SHADER_VISIBILITY_VERTEX = 1, - D3D12_SHADER_VISIBILITY_HULL = 2, - D3D12_SHADER_VISIBILITY_DOMAIN = 3, - D3D12_SHADER_VISIBILITY_GEOMETRY = 4, - D3D12_SHADER_VISIBILITY_PIXEL = 5 - } D3D12_SHADER_VISIBILITY; - -typedef -enum D3D12_ROOT_PARAMETER_TYPE - { - D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE = 0, - D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS = ( D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE + 1 ) , - D3D12_ROOT_PARAMETER_TYPE_CBV = ( D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS + 1 ) , - D3D12_ROOT_PARAMETER_TYPE_SRV = ( D3D12_ROOT_PARAMETER_TYPE_CBV + 1 ) , - D3D12_ROOT_PARAMETER_TYPE_UAV = ( D3D12_ROOT_PARAMETER_TYPE_SRV + 1 ) - } D3D12_ROOT_PARAMETER_TYPE; - -typedef struct D3D12_ROOT_PARAMETER - { - D3D12_ROOT_PARAMETER_TYPE ParameterType; - union - { - D3D12_ROOT_DESCRIPTOR_TABLE DescriptorTable; - D3D12_ROOT_CONSTANTS Constants; - D3D12_ROOT_DESCRIPTOR Descriptor; - } ; - D3D12_SHADER_VISIBILITY ShaderVisibility; - } D3D12_ROOT_PARAMETER; - -typedef -enum D3D12_ROOT_SIGNATURE_FLAGS - { - D3D12_ROOT_SIGNATURE_FLAG_NONE = 0, - D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT = 0x1, - D3D12_ROOT_SIGNATURE_FLAG_DENY_VERTEX_SHADER_ROOT_ACCESS = 0x2, - D3D12_ROOT_SIGNATURE_FLAG_DENY_HULL_SHADER_ROOT_ACCESS = 0x4, - D3D12_ROOT_SIGNATURE_FLAG_DENY_DOMAIN_SHADER_ROOT_ACCESS = 0x8, - D3D12_ROOT_SIGNATURE_FLAG_DENY_GEOMETRY_SHADER_ROOT_ACCESS = 0x10, - D3D12_ROOT_SIGNATURE_FLAG_DENY_PIXEL_SHADER_ROOT_ACCESS = 0x20, - D3D12_ROOT_SIGNATURE_FLAG_ALLOW_STREAM_OUTPUT = 0x40, - D3D12_ROOT_SIGNATURE_FLAG_LOCAL_ROOT_SIGNATURE = 0x80 - } D3D12_ROOT_SIGNATURE_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_ROOT_SIGNATURE_FLAGS ); -typedef -enum D3D12_STATIC_BORDER_COLOR - { - D3D12_STATIC_BORDER_COLOR_TRANSPARENT_BLACK = 0, - D3D12_STATIC_BORDER_COLOR_OPAQUE_BLACK = ( D3D12_STATIC_BORDER_COLOR_TRANSPARENT_BLACK + 1 ) , - D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE = ( D3D12_STATIC_BORDER_COLOR_OPAQUE_BLACK + 1 ) - } D3D12_STATIC_BORDER_COLOR; - -typedef struct D3D12_STATIC_SAMPLER_DESC - { - D3D12_FILTER Filter; - D3D12_TEXTURE_ADDRESS_MODE AddressU; - D3D12_TEXTURE_ADDRESS_MODE AddressV; - D3D12_TEXTURE_ADDRESS_MODE AddressW; - FLOAT MipLODBias; - UINT MaxAnisotropy; - D3D12_COMPARISON_FUNC ComparisonFunc; - D3D12_STATIC_BORDER_COLOR BorderColor; - FLOAT MinLOD; - FLOAT MaxLOD; - UINT ShaderRegister; - UINT RegisterSpace; - D3D12_SHADER_VISIBILITY ShaderVisibility; - } D3D12_STATIC_SAMPLER_DESC; - -typedef struct D3D12_ROOT_SIGNATURE_DESC - { - UINT NumParameters; - _Field_size_full_(NumParameters) const D3D12_ROOT_PARAMETER *pParameters; - UINT NumStaticSamplers; - _Field_size_full_(NumStaticSamplers) const D3D12_STATIC_SAMPLER_DESC *pStaticSamplers; - D3D12_ROOT_SIGNATURE_FLAGS Flags; - } D3D12_ROOT_SIGNATURE_DESC; - -typedef -enum D3D12_DESCRIPTOR_RANGE_FLAGS - { - D3D12_DESCRIPTOR_RANGE_FLAG_NONE = 0, - D3D12_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_VOLATILE = 0x1, - D3D12_DESCRIPTOR_RANGE_FLAG_DATA_VOLATILE = 0x2, - D3D12_DESCRIPTOR_RANGE_FLAG_DATA_STATIC_WHILE_SET_AT_EXECUTE = 0x4, - D3D12_DESCRIPTOR_RANGE_FLAG_DATA_STATIC = 0x8, - D3D12_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS = 0x10000 - } D3D12_DESCRIPTOR_RANGE_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_DESCRIPTOR_RANGE_FLAGS ); -typedef struct D3D12_DESCRIPTOR_RANGE1 - { - D3D12_DESCRIPTOR_RANGE_TYPE RangeType; - UINT NumDescriptors; - UINT BaseShaderRegister; - UINT RegisterSpace; - D3D12_DESCRIPTOR_RANGE_FLAGS Flags; - UINT OffsetInDescriptorsFromTableStart; - } D3D12_DESCRIPTOR_RANGE1; - -typedef struct D3D12_ROOT_DESCRIPTOR_TABLE1 - { - UINT NumDescriptorRanges; - _Field_size_full_(NumDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1 *pDescriptorRanges; - } D3D12_ROOT_DESCRIPTOR_TABLE1; - -typedef -enum D3D12_ROOT_DESCRIPTOR_FLAGS - { - D3D12_ROOT_DESCRIPTOR_FLAG_NONE = 0, - D3D12_ROOT_DESCRIPTOR_FLAG_DATA_VOLATILE = 0x2, - D3D12_ROOT_DESCRIPTOR_FLAG_DATA_STATIC_WHILE_SET_AT_EXECUTE = 0x4, - D3D12_ROOT_DESCRIPTOR_FLAG_DATA_STATIC = 0x8 - } D3D12_ROOT_DESCRIPTOR_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_ROOT_DESCRIPTOR_FLAGS ); -typedef struct D3D12_ROOT_DESCRIPTOR1 - { - UINT ShaderRegister; - UINT RegisterSpace; - D3D12_ROOT_DESCRIPTOR_FLAGS Flags; - } D3D12_ROOT_DESCRIPTOR1; - -typedef struct D3D12_ROOT_PARAMETER1 - { - D3D12_ROOT_PARAMETER_TYPE ParameterType; - union - { - D3D12_ROOT_DESCRIPTOR_TABLE1 DescriptorTable; - D3D12_ROOT_CONSTANTS Constants; - D3D12_ROOT_DESCRIPTOR1 Descriptor; - } ; - D3D12_SHADER_VISIBILITY ShaderVisibility; - } D3D12_ROOT_PARAMETER1; - -typedef struct D3D12_ROOT_SIGNATURE_DESC1 - { - UINT NumParameters; - _Field_size_full_(NumParameters) const D3D12_ROOT_PARAMETER1 *pParameters; - UINT NumStaticSamplers; - _Field_size_full_(NumStaticSamplers) const D3D12_STATIC_SAMPLER_DESC *pStaticSamplers; - D3D12_ROOT_SIGNATURE_FLAGS Flags; - } D3D12_ROOT_SIGNATURE_DESC1; - -typedef struct D3D12_VERSIONED_ROOT_SIGNATURE_DESC - { - D3D_ROOT_SIGNATURE_VERSION Version; - union - { - D3D12_ROOT_SIGNATURE_DESC Desc_1_0; - D3D12_ROOT_SIGNATURE_DESC1 Desc_1_1; - } ; - } D3D12_VERSIONED_ROOT_SIGNATURE_DESC; - - - -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0001_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0001_v0_0_s_ifspec; - -#ifndef __ID3D12RootSignatureDeserializer_INTERFACE_DEFINED__ -#define __ID3D12RootSignatureDeserializer_INTERFACE_DEFINED__ - -/* interface ID3D12RootSignatureDeserializer */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12RootSignatureDeserializer; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("34AB647B-3CC8-46AC-841B-C0965645C046") - ID3D12RootSignatureDeserializer : public IUnknown - { - public: - virtual const D3D12_ROOT_SIGNATURE_DESC *STDMETHODCALLTYPE GetRootSignatureDesc( void) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12RootSignatureDeserializerVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12RootSignatureDeserializer * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12RootSignatureDeserializer * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12RootSignatureDeserializer * This); - - const D3D12_ROOT_SIGNATURE_DESC *( STDMETHODCALLTYPE *GetRootSignatureDesc )( - ID3D12RootSignatureDeserializer * This); - - END_INTERFACE - } ID3D12RootSignatureDeserializerVtbl; - - interface ID3D12RootSignatureDeserializer - { - CONST_VTBL struct ID3D12RootSignatureDeserializerVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12RootSignatureDeserializer_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12RootSignatureDeserializer_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12RootSignatureDeserializer_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12RootSignatureDeserializer_GetRootSignatureDesc(This) \ - ( (This)->lpVtbl -> GetRootSignatureDesc(This) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12RootSignatureDeserializer_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12VersionedRootSignatureDeserializer_INTERFACE_DEFINED__ -#define __ID3D12VersionedRootSignatureDeserializer_INTERFACE_DEFINED__ - -/* interface ID3D12VersionedRootSignatureDeserializer */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12VersionedRootSignatureDeserializer; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("7F91CE67-090C-4BB7-B78E-ED8FF2E31DA0") - ID3D12VersionedRootSignatureDeserializer : public IUnknown - { - public: - virtual HRESULT STDMETHODCALLTYPE GetRootSignatureDescAtVersion( - D3D_ROOT_SIGNATURE_VERSION convertToVersion, - _Out_ const D3D12_VERSIONED_ROOT_SIGNATURE_DESC **ppDesc) = 0; - - virtual const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *STDMETHODCALLTYPE GetUnconvertedRootSignatureDesc( void) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12VersionedRootSignatureDeserializerVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12VersionedRootSignatureDeserializer * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12VersionedRootSignatureDeserializer * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12VersionedRootSignatureDeserializer * This); - - HRESULT ( STDMETHODCALLTYPE *GetRootSignatureDescAtVersion )( - ID3D12VersionedRootSignatureDeserializer * This, - D3D_ROOT_SIGNATURE_VERSION convertToVersion, - _Out_ const D3D12_VERSIONED_ROOT_SIGNATURE_DESC **ppDesc); - - const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *( STDMETHODCALLTYPE *GetUnconvertedRootSignatureDesc )( - ID3D12VersionedRootSignatureDeserializer * This); - - END_INTERFACE - } ID3D12VersionedRootSignatureDeserializerVtbl; - - interface ID3D12VersionedRootSignatureDeserializer - { - CONST_VTBL struct ID3D12VersionedRootSignatureDeserializerVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12VersionedRootSignatureDeserializer_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12VersionedRootSignatureDeserializer_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12VersionedRootSignatureDeserializer_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12VersionedRootSignatureDeserializer_GetRootSignatureDescAtVersion(This,convertToVersion,ppDesc) \ - ( (This)->lpVtbl -> GetRootSignatureDescAtVersion(This,convertToVersion,ppDesc) ) - -#define ID3D12VersionedRootSignatureDeserializer_GetUnconvertedRootSignatureDesc(This) \ - ( (This)->lpVtbl -> GetUnconvertedRootSignatureDesc(This) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12VersionedRootSignatureDeserializer_INTERFACE_DEFINED__ */ - - -/* interface __MIDL_itf_d3d12_0000_0003 */ -/* [local] */ - -typedef HRESULT (WINAPI* PFN_D3D12_SERIALIZE_ROOT_SIGNATURE)( - _In_ const D3D12_ROOT_SIGNATURE_DESC* pRootSignature, - _In_ D3D_ROOT_SIGNATURE_VERSION Version, - _Out_ ID3DBlob** ppBlob, - _Always_(_Outptr_opt_result_maybenull_) ID3DBlob** ppErrorBlob); - -HRESULT WINAPI D3D12SerializeRootSignature( - _In_ const D3D12_ROOT_SIGNATURE_DESC* pRootSignature, - _In_ D3D_ROOT_SIGNATURE_VERSION Version, - _Out_ ID3DBlob** ppBlob, - _Always_(_Outptr_opt_result_maybenull_) ID3DBlob** ppErrorBlob); - -typedef HRESULT (WINAPI* PFN_D3D12_CREATE_ROOT_SIGNATURE_DESERIALIZER)( - _In_reads_bytes_(SrcDataSizeInBytes) LPCVOID pSrcData, - _In_ SIZE_T SrcDataSizeInBytes, - _In_ REFIID pRootSignatureDeserializerInterface, - _Out_ void** ppRootSignatureDeserializer); - -HRESULT WINAPI D3D12CreateRootSignatureDeserializer( - _In_reads_bytes_(SrcDataSizeInBytes) LPCVOID pSrcData, - _In_ SIZE_T SrcDataSizeInBytes, - _In_ REFIID pRootSignatureDeserializerInterface, - _Out_ void** ppRootSignatureDeserializer); - -typedef HRESULT (WINAPI* PFN_D3D12_SERIALIZE_VERSIONED_ROOT_SIGNATURE)( - _In_ const D3D12_VERSIONED_ROOT_SIGNATURE_DESC* pRootSignature, - _Out_ ID3DBlob** ppBlob, - _Always_(_Outptr_opt_result_maybenull_) ID3DBlob** ppErrorBlob); - -HRESULT WINAPI D3D12SerializeVersionedRootSignature( - _In_ const D3D12_VERSIONED_ROOT_SIGNATURE_DESC* pRootSignature, - _Out_ ID3DBlob** ppBlob, - _Always_(_Outptr_opt_result_maybenull_) ID3DBlob** ppErrorBlob); - -typedef HRESULT (WINAPI* PFN_D3D12_CREATE_VERSIONED_ROOT_SIGNATURE_DESERIALIZER)( - _In_reads_bytes_(SrcDataSizeInBytes) LPCVOID pSrcData, - _In_ SIZE_T SrcDataSizeInBytes, - _In_ REFIID pRootSignatureDeserializerInterface, - _Out_ void** ppRootSignatureDeserializer); - -HRESULT WINAPI D3D12CreateVersionedRootSignatureDeserializer( - _In_reads_bytes_(SrcDataSizeInBytes) LPCVOID pSrcData, - _In_ SIZE_T SrcDataSizeInBytes, - _In_ REFIID pRootSignatureDeserializerInterface, - _Out_ void** ppRootSignatureDeserializer); - -typedef struct D3D12_CPU_DESCRIPTOR_HANDLE - { - SIZE_T ptr; - } D3D12_CPU_DESCRIPTOR_HANDLE; - -typedef struct D3D12_GPU_DESCRIPTOR_HANDLE - { - UINT64 ptr; - } D3D12_GPU_DESCRIPTOR_HANDLE; - -// If rects are supplied in D3D12_DISCARD_REGION, below, the resource -// must have 2D subresources with all specified subresources the same dimension. -typedef struct D3D12_DISCARD_REGION - { - UINT NumRects; - _In_reads_(NumRects) const D3D12_RECT *pRects; - UINT FirstSubresource; - UINT NumSubresources; - } D3D12_DISCARD_REGION; - -typedef -enum D3D12_QUERY_HEAP_TYPE - { - D3D12_QUERY_HEAP_TYPE_OCCLUSION = 0, - D3D12_QUERY_HEAP_TYPE_TIMESTAMP = 1, - D3D12_QUERY_HEAP_TYPE_PIPELINE_STATISTICS = 2, - D3D12_QUERY_HEAP_TYPE_SO_STATISTICS = 3, - D3D12_QUERY_HEAP_TYPE_VIDEO_DECODE_STATISTICS = 4, - D3D12_QUERY_HEAP_TYPE_COPY_QUEUE_TIMESTAMP = 5 - } D3D12_QUERY_HEAP_TYPE; - -typedef struct D3D12_QUERY_HEAP_DESC - { - D3D12_QUERY_HEAP_TYPE Type; - UINT Count; - UINT NodeMask; - } D3D12_QUERY_HEAP_DESC; - -typedef -enum D3D12_QUERY_TYPE - { - D3D12_QUERY_TYPE_OCCLUSION = 0, - D3D12_QUERY_TYPE_BINARY_OCCLUSION = 1, - D3D12_QUERY_TYPE_TIMESTAMP = 2, - D3D12_QUERY_TYPE_PIPELINE_STATISTICS = 3, - D3D12_QUERY_TYPE_SO_STATISTICS_STREAM0 = 4, - D3D12_QUERY_TYPE_SO_STATISTICS_STREAM1 = 5, - D3D12_QUERY_TYPE_SO_STATISTICS_STREAM2 = 6, - D3D12_QUERY_TYPE_SO_STATISTICS_STREAM3 = 7, - D3D12_QUERY_TYPE_VIDEO_DECODE_STATISTICS = 8 - } D3D12_QUERY_TYPE; - -typedef -enum D3D12_PREDICATION_OP - { - D3D12_PREDICATION_OP_EQUAL_ZERO = 0, - D3D12_PREDICATION_OP_NOT_EQUAL_ZERO = 1 - } D3D12_PREDICATION_OP; - -typedef struct D3D12_QUERY_DATA_PIPELINE_STATISTICS - { - UINT64 IAVertices; - UINT64 IAPrimitives; - UINT64 VSInvocations; - UINT64 GSInvocations; - UINT64 GSPrimitives; - UINT64 CInvocations; - UINT64 CPrimitives; - UINT64 PSInvocations; - UINT64 HSInvocations; - UINT64 DSInvocations; - UINT64 CSInvocations; - } D3D12_QUERY_DATA_PIPELINE_STATISTICS; - -typedef struct D3D12_QUERY_DATA_SO_STATISTICS - { - UINT64 NumPrimitivesWritten; - UINT64 PrimitivesStorageNeeded; - } D3D12_QUERY_DATA_SO_STATISTICS; - -typedef struct D3D12_STREAM_OUTPUT_BUFFER_VIEW - { - D3D12_GPU_VIRTUAL_ADDRESS BufferLocation; - UINT64 SizeInBytes; - D3D12_GPU_VIRTUAL_ADDRESS BufferFilledSizeLocation; - } D3D12_STREAM_OUTPUT_BUFFER_VIEW; - -typedef struct D3D12_DRAW_ARGUMENTS - { - UINT VertexCountPerInstance; - UINT InstanceCount; - UINT StartVertexLocation; - UINT StartInstanceLocation; - } D3D12_DRAW_ARGUMENTS; - -typedef struct D3D12_DRAW_INDEXED_ARGUMENTS - { - UINT IndexCountPerInstance; - UINT InstanceCount; - UINT StartIndexLocation; - INT BaseVertexLocation; - UINT StartInstanceLocation; - } D3D12_DRAW_INDEXED_ARGUMENTS; - -typedef struct D3D12_DISPATCH_ARGUMENTS - { - UINT ThreadGroupCountX; - UINT ThreadGroupCountY; - UINT ThreadGroupCountZ; - } D3D12_DISPATCH_ARGUMENTS; - -typedef struct D3D12_VERTEX_BUFFER_VIEW - { - D3D12_GPU_VIRTUAL_ADDRESS BufferLocation; - UINT SizeInBytes; - UINT StrideInBytes; - } D3D12_VERTEX_BUFFER_VIEW; - -typedef struct D3D12_INDEX_BUFFER_VIEW - { - D3D12_GPU_VIRTUAL_ADDRESS BufferLocation; - UINT SizeInBytes; - DXGI_FORMAT Format; - } D3D12_INDEX_BUFFER_VIEW; - -typedef -enum D3D12_INDIRECT_ARGUMENT_TYPE - { - D3D12_INDIRECT_ARGUMENT_TYPE_DRAW = 0, - D3D12_INDIRECT_ARGUMENT_TYPE_DRAW_INDEXED = ( D3D12_INDIRECT_ARGUMENT_TYPE_DRAW + 1 ) , - D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH = ( D3D12_INDIRECT_ARGUMENT_TYPE_DRAW_INDEXED + 1 ) , - D3D12_INDIRECT_ARGUMENT_TYPE_VERTEX_BUFFER_VIEW = ( D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH + 1 ) , - D3D12_INDIRECT_ARGUMENT_TYPE_INDEX_BUFFER_VIEW = ( D3D12_INDIRECT_ARGUMENT_TYPE_VERTEX_BUFFER_VIEW + 1 ) , - D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT = ( D3D12_INDIRECT_ARGUMENT_TYPE_INDEX_BUFFER_VIEW + 1 ) , - D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT_BUFFER_VIEW = ( D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT + 1 ) , - D3D12_INDIRECT_ARGUMENT_TYPE_SHADER_RESOURCE_VIEW = ( D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT_BUFFER_VIEW + 1 ) , - D3D12_INDIRECT_ARGUMENT_TYPE_UNORDERED_ACCESS_VIEW = ( D3D12_INDIRECT_ARGUMENT_TYPE_SHADER_RESOURCE_VIEW + 1 ) - } D3D12_INDIRECT_ARGUMENT_TYPE; - -typedef struct D3D12_INDIRECT_ARGUMENT_DESC - { - D3D12_INDIRECT_ARGUMENT_TYPE Type; - union - { - struct - { - UINT Slot; - } VertexBuffer; - struct - { - UINT RootParameterIndex; - UINT DestOffsetIn32BitValues; - UINT Num32BitValuesToSet; - } Constant; - struct - { - UINT RootParameterIndex; - } ConstantBufferView; - struct - { - UINT RootParameterIndex; - } ShaderResourceView; - struct - { - UINT RootParameterIndex; - } UnorderedAccessView; - } ; - } D3D12_INDIRECT_ARGUMENT_DESC; - -typedef struct D3D12_COMMAND_SIGNATURE_DESC - { - UINT ByteStride; - UINT NumArgumentDescs; - _Field_size_full_(NumArgumentDescs) const D3D12_INDIRECT_ARGUMENT_DESC *pArgumentDescs; - UINT NodeMask; - } D3D12_COMMAND_SIGNATURE_DESC; - - - - -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0003_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0003_v0_0_s_ifspec; - -#ifndef __ID3D12Pageable_INTERFACE_DEFINED__ -#define __ID3D12Pageable_INTERFACE_DEFINED__ - -/* interface ID3D12Pageable */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12Pageable; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("63ee58fb-1268-4835-86da-f008ce62f0d6") - ID3D12Pageable : public ID3D12DeviceChild - { - public: - }; - - -#else /* C style interface */ - - typedef struct ID3D12PageableVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12Pageable * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12Pageable * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12Pageable * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12Pageable * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12Pageable * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12Pageable * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12Pageable * This, - _In_z_ LPCWSTR Name); - - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12Pageable * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - END_INTERFACE - } ID3D12PageableVtbl; - - interface ID3D12Pageable - { - CONST_VTBL struct ID3D12PageableVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12Pageable_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12Pageable_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12Pageable_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12Pageable_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12Pageable_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12Pageable_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12Pageable_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12Pageable_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12Pageable_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12Heap_INTERFACE_DEFINED__ -#define __ID3D12Heap_INTERFACE_DEFINED__ - -/* interface ID3D12Heap */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12Heap; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("6b3b2502-6e51-45b3-90ee-9884265e8df3") - ID3D12Heap : public ID3D12Pageable - { - public: - virtual D3D12_HEAP_DESC STDMETHODCALLTYPE GetDesc( void) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12HeapVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12Heap * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12Heap * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12Heap * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12Heap * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12Heap * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12Heap * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12Heap * This, - _In_z_ LPCWSTR Name); - - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12Heap * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - D3D12_HEAP_DESC ( STDMETHODCALLTYPE *GetDesc )( - ID3D12Heap * This); - - END_INTERFACE - } ID3D12HeapVtbl; - - interface ID3D12Heap - { - CONST_VTBL struct ID3D12HeapVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12Heap_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12Heap_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12Heap_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12Heap_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12Heap_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12Heap_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12Heap_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12Heap_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - - - -#define ID3D12Heap_GetDesc(This) \ - ( (This)->lpVtbl -> GetDesc(This) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - - - - - -#endif /* __ID3D12Heap_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12Resource_INTERFACE_DEFINED__ -#define __ID3D12Resource_INTERFACE_DEFINED__ - -/* interface ID3D12Resource */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12Resource; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("696442be-a72e-4059-bc79-5b5c98040fad") - ID3D12Resource : public ID3D12Pageable - { - public: - virtual HRESULT STDMETHODCALLTYPE Map( - UINT Subresource, - _In_opt_ const D3D12_RANGE *pReadRange, - _Outptr_opt_result_bytebuffer_(_Inexpressible_("Dependent on resource")) void **ppData) = 0; - - virtual void STDMETHODCALLTYPE Unmap( - UINT Subresource, - _In_opt_ const D3D12_RANGE *pWrittenRange) = 0; - - virtual D3D12_RESOURCE_DESC STDMETHODCALLTYPE GetDesc( void) = 0; - - virtual D3D12_GPU_VIRTUAL_ADDRESS STDMETHODCALLTYPE GetGPUVirtualAddress( void) = 0; - - virtual HRESULT STDMETHODCALLTYPE WriteToSubresource( - UINT DstSubresource, - _In_opt_ const D3D12_BOX *pDstBox, - _In_ const void *pSrcData, - UINT SrcRowPitch, - UINT SrcDepthPitch) = 0; - - virtual HRESULT STDMETHODCALLTYPE ReadFromSubresource( - _Out_ void *pDstData, - UINT DstRowPitch, - UINT DstDepthPitch, - UINT SrcSubresource, - _In_opt_ const D3D12_BOX *pSrcBox) = 0; - - virtual HRESULT STDMETHODCALLTYPE GetHeapProperties( - _Out_opt_ D3D12_HEAP_PROPERTIES *pHeapProperties, - _Out_opt_ D3D12_HEAP_FLAGS *pHeapFlags) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12ResourceVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12Resource * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12Resource * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12Resource * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12Resource * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12Resource * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12Resource * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12Resource * This, - _In_z_ LPCWSTR Name); - - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12Resource * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - HRESULT ( STDMETHODCALLTYPE *Map )( - ID3D12Resource * This, - UINT Subresource, - _In_opt_ const D3D12_RANGE *pReadRange, - _Outptr_opt_result_bytebuffer_(_Inexpressible_("Dependent on resource")) void **ppData); - - void ( STDMETHODCALLTYPE *Unmap )( - ID3D12Resource * This, - UINT Subresource, - _In_opt_ const D3D12_RANGE *pWrittenRange); - - D3D12_RESOURCE_DESC ( STDMETHODCALLTYPE *GetDesc )( - ID3D12Resource * This); - - D3D12_GPU_VIRTUAL_ADDRESS ( STDMETHODCALLTYPE *GetGPUVirtualAddress )( - ID3D12Resource * This); - - HRESULT ( STDMETHODCALLTYPE *WriteToSubresource )( - ID3D12Resource * This, - UINT DstSubresource, - _In_opt_ const D3D12_BOX *pDstBox, - _In_ const void *pSrcData, - UINT SrcRowPitch, - UINT SrcDepthPitch); - - HRESULT ( STDMETHODCALLTYPE *ReadFromSubresource )( - ID3D12Resource * This, - _Out_ void *pDstData, - UINT DstRowPitch, - UINT DstDepthPitch, - UINT SrcSubresource, - _In_opt_ const D3D12_BOX *pSrcBox); - - HRESULT ( STDMETHODCALLTYPE *GetHeapProperties )( - ID3D12Resource * This, - _Out_opt_ D3D12_HEAP_PROPERTIES *pHeapProperties, - _Out_opt_ D3D12_HEAP_FLAGS *pHeapFlags); - - END_INTERFACE - } ID3D12ResourceVtbl; - - interface ID3D12Resource - { - CONST_VTBL struct ID3D12ResourceVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12Resource_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12Resource_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12Resource_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12Resource_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12Resource_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12Resource_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12Resource_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12Resource_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - - - -#define ID3D12Resource_Map(This,Subresource,pReadRange,ppData) \ - ( (This)->lpVtbl -> Map(This,Subresource,pReadRange,ppData) ) - -#define ID3D12Resource_Unmap(This,Subresource,pWrittenRange) \ - ( (This)->lpVtbl -> Unmap(This,Subresource,pWrittenRange) ) - -#define ID3D12Resource_GetDesc(This) \ - ( (This)->lpVtbl -> GetDesc(This) ) - -#define ID3D12Resource_GetGPUVirtualAddress(This) \ - ( (This)->lpVtbl -> GetGPUVirtualAddress(This) ) - -#define ID3D12Resource_WriteToSubresource(This,DstSubresource,pDstBox,pSrcData,SrcRowPitch,SrcDepthPitch) \ - ( (This)->lpVtbl -> WriteToSubresource(This,DstSubresource,pDstBox,pSrcData,SrcRowPitch,SrcDepthPitch) ) - -#define ID3D12Resource_ReadFromSubresource(This,pDstData,DstRowPitch,DstDepthPitch,SrcSubresource,pSrcBox) \ - ( (This)->lpVtbl -> ReadFromSubresource(This,pDstData,DstRowPitch,DstDepthPitch,SrcSubresource,pSrcBox) ) - -#define ID3D12Resource_GetHeapProperties(This,pHeapProperties,pHeapFlags) \ - ( (This)->lpVtbl -> GetHeapProperties(This,pHeapProperties,pHeapFlags) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - - - - - -#endif /* __ID3D12Resource_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12CommandAllocator_INTERFACE_DEFINED__ -#define __ID3D12CommandAllocator_INTERFACE_DEFINED__ - -/* interface ID3D12CommandAllocator */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12CommandAllocator; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("6102dee4-af59-4b09-b999-b44d73f09b24") - ID3D12CommandAllocator : public ID3D12Pageable - { - public: - virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12CommandAllocatorVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12CommandAllocator * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12CommandAllocator * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12CommandAllocator * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12CommandAllocator * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12CommandAllocator * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12CommandAllocator * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12CommandAllocator * This, - _In_z_ LPCWSTR Name); - - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12CommandAllocator * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - HRESULT ( STDMETHODCALLTYPE *Reset )( - ID3D12CommandAllocator * This); - - END_INTERFACE - } ID3D12CommandAllocatorVtbl; - - interface ID3D12CommandAllocator - { - CONST_VTBL struct ID3D12CommandAllocatorVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12CommandAllocator_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12CommandAllocator_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12CommandAllocator_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12CommandAllocator_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12CommandAllocator_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12CommandAllocator_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12CommandAllocator_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12CommandAllocator_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - - - -#define ID3D12CommandAllocator_Reset(This) \ - ( (This)->lpVtbl -> Reset(This) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12CommandAllocator_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12Fence_INTERFACE_DEFINED__ -#define __ID3D12Fence_INTERFACE_DEFINED__ - -/* interface ID3D12Fence */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12Fence; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("0a753dcf-c4d8-4b91-adf6-be5a60d95a76") - ID3D12Fence : public ID3D12Pageable - { - public: - virtual UINT64 STDMETHODCALLTYPE GetCompletedValue( void) = 0; - - virtual HRESULT STDMETHODCALLTYPE SetEventOnCompletion( - UINT64 Value, - HANDLE hEvent) = 0; - - virtual HRESULT STDMETHODCALLTYPE Signal( - UINT64 Value) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12FenceVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12Fence * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12Fence * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12Fence * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12Fence * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12Fence * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12Fence * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12Fence * This, - _In_z_ LPCWSTR Name); - - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12Fence * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - UINT64 ( STDMETHODCALLTYPE *GetCompletedValue )( - ID3D12Fence * This); - - HRESULT ( STDMETHODCALLTYPE *SetEventOnCompletion )( - ID3D12Fence * This, - UINT64 Value, - HANDLE hEvent); - - HRESULT ( STDMETHODCALLTYPE *Signal )( - ID3D12Fence * This, - UINT64 Value); - - END_INTERFACE - } ID3D12FenceVtbl; - - interface ID3D12Fence - { - CONST_VTBL struct ID3D12FenceVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12Fence_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12Fence_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12Fence_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12Fence_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12Fence_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12Fence_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12Fence_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12Fence_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - - - -#define ID3D12Fence_GetCompletedValue(This) \ - ( (This)->lpVtbl -> GetCompletedValue(This) ) - -#define ID3D12Fence_SetEventOnCompletion(This,Value,hEvent) \ - ( (This)->lpVtbl -> SetEventOnCompletion(This,Value,hEvent) ) - -#define ID3D12Fence_Signal(This,Value) \ - ( (This)->lpVtbl -> Signal(This,Value) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12Fence_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12Fence1_INTERFACE_DEFINED__ -#define __ID3D12Fence1_INTERFACE_DEFINED__ - -/* interface ID3D12Fence1 */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12Fence1; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("433685fe-e22b-4ca0-a8db-b5b4f4dd0e4a") - ID3D12Fence1 : public ID3D12Fence - { - public: - virtual D3D12_FENCE_FLAGS STDMETHODCALLTYPE GetCreationFlags( void) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12Fence1Vtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12Fence1 * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12Fence1 * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12Fence1 * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12Fence1 * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12Fence1 * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12Fence1 * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12Fence1 * This, - _In_z_ LPCWSTR Name); - - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12Fence1 * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - UINT64 ( STDMETHODCALLTYPE *GetCompletedValue )( - ID3D12Fence1 * This); - - HRESULT ( STDMETHODCALLTYPE *SetEventOnCompletion )( - ID3D12Fence1 * This, - UINT64 Value, - HANDLE hEvent); - - HRESULT ( STDMETHODCALLTYPE *Signal )( - ID3D12Fence1 * This, - UINT64 Value); - - D3D12_FENCE_FLAGS ( STDMETHODCALLTYPE *GetCreationFlags )( - ID3D12Fence1 * This); - - END_INTERFACE - } ID3D12Fence1Vtbl; - - interface ID3D12Fence1 - { - CONST_VTBL struct ID3D12Fence1Vtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12Fence1_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12Fence1_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12Fence1_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12Fence1_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12Fence1_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12Fence1_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12Fence1_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12Fence1_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - - - -#define ID3D12Fence1_GetCompletedValue(This) \ - ( (This)->lpVtbl -> GetCompletedValue(This) ) - -#define ID3D12Fence1_SetEventOnCompletion(This,Value,hEvent) \ - ( (This)->lpVtbl -> SetEventOnCompletion(This,Value,hEvent) ) - -#define ID3D12Fence1_Signal(This,Value) \ - ( (This)->lpVtbl -> Signal(This,Value) ) - - -#define ID3D12Fence1_GetCreationFlags(This) \ - ( (This)->lpVtbl -> GetCreationFlags(This) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12Fence1_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12PipelineState_INTERFACE_DEFINED__ -#define __ID3D12PipelineState_INTERFACE_DEFINED__ - -/* interface ID3D12PipelineState */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12PipelineState; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("765a30f3-f624-4c6f-a828-ace948622445") - ID3D12PipelineState : public ID3D12Pageable - { - public: - virtual HRESULT STDMETHODCALLTYPE GetCachedBlob( - _COM_Outptr_ ID3DBlob **ppBlob) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12PipelineStateVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12PipelineState * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12PipelineState * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12PipelineState * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12PipelineState * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12PipelineState * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12PipelineState * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12PipelineState * This, - _In_z_ LPCWSTR Name); - - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12PipelineState * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - HRESULT ( STDMETHODCALLTYPE *GetCachedBlob )( - ID3D12PipelineState * This, - _COM_Outptr_ ID3DBlob **ppBlob); - - END_INTERFACE - } ID3D12PipelineStateVtbl; - - interface ID3D12PipelineState - { - CONST_VTBL struct ID3D12PipelineStateVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12PipelineState_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12PipelineState_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12PipelineState_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12PipelineState_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12PipelineState_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12PipelineState_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12PipelineState_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12PipelineState_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - - - -#define ID3D12PipelineState_GetCachedBlob(This,ppBlob) \ - ( (This)->lpVtbl -> GetCachedBlob(This,ppBlob) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12PipelineState_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12DescriptorHeap_INTERFACE_DEFINED__ -#define __ID3D12DescriptorHeap_INTERFACE_DEFINED__ - -/* interface ID3D12DescriptorHeap */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12DescriptorHeap; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("8efb471d-616c-4f49-90f7-127bb763fa51") - ID3D12DescriptorHeap : public ID3D12Pageable - { - public: - virtual D3D12_DESCRIPTOR_HEAP_DESC STDMETHODCALLTYPE GetDesc( void) = 0; - - virtual D3D12_CPU_DESCRIPTOR_HANDLE STDMETHODCALLTYPE GetCPUDescriptorHandleForHeapStart( void) = 0; - - virtual D3D12_GPU_DESCRIPTOR_HANDLE STDMETHODCALLTYPE GetGPUDescriptorHandleForHeapStart( void) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12DescriptorHeapVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12DescriptorHeap * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12DescriptorHeap * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12DescriptorHeap * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12DescriptorHeap * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12DescriptorHeap * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12DescriptorHeap * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12DescriptorHeap * This, - _In_z_ LPCWSTR Name); - - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12DescriptorHeap * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - D3D12_DESCRIPTOR_HEAP_DESC ( STDMETHODCALLTYPE *GetDesc )( - ID3D12DescriptorHeap * This); - - D3D12_CPU_DESCRIPTOR_HANDLE ( STDMETHODCALLTYPE *GetCPUDescriptorHandleForHeapStart )( - ID3D12DescriptorHeap * This); - - D3D12_GPU_DESCRIPTOR_HANDLE ( STDMETHODCALLTYPE *GetGPUDescriptorHandleForHeapStart )( - ID3D12DescriptorHeap * This); - - END_INTERFACE - } ID3D12DescriptorHeapVtbl; - - interface ID3D12DescriptorHeap - { - CONST_VTBL struct ID3D12DescriptorHeapVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12DescriptorHeap_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12DescriptorHeap_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12DescriptorHeap_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12DescriptorHeap_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12DescriptorHeap_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12DescriptorHeap_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12DescriptorHeap_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12DescriptorHeap_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - - - -#define ID3D12DescriptorHeap_GetDesc(This) \ - ( (This)->lpVtbl -> GetDesc(This) ) - -#define ID3D12DescriptorHeap_GetCPUDescriptorHandleForHeapStart(This) \ - ( (This)->lpVtbl -> GetCPUDescriptorHandleForHeapStart(This) ) - -#define ID3D12DescriptorHeap_GetGPUDescriptorHandleForHeapStart(This) \ - ( (This)->lpVtbl -> GetGPUDescriptorHandleForHeapStart(This) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - - - - - - - - - - - - - -#endif /* __ID3D12DescriptorHeap_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12QueryHeap_INTERFACE_DEFINED__ -#define __ID3D12QueryHeap_INTERFACE_DEFINED__ - -/* interface ID3D12QueryHeap */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12QueryHeap; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("0d9658ae-ed45-469e-a61d-970ec583cab4") - ID3D12QueryHeap : public ID3D12Pageable - { - public: - }; - - -#else /* C style interface */ - - typedef struct ID3D12QueryHeapVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12QueryHeap * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12QueryHeap * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12QueryHeap * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12QueryHeap * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12QueryHeap * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12QueryHeap * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12QueryHeap * This, - _In_z_ LPCWSTR Name); - - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12QueryHeap * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - END_INTERFACE - } ID3D12QueryHeapVtbl; - - interface ID3D12QueryHeap - { - CONST_VTBL struct ID3D12QueryHeapVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12QueryHeap_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12QueryHeap_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12QueryHeap_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12QueryHeap_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12QueryHeap_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12QueryHeap_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12QueryHeap_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12QueryHeap_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - - - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12QueryHeap_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12CommandSignature_INTERFACE_DEFINED__ -#define __ID3D12CommandSignature_INTERFACE_DEFINED__ - -/* interface ID3D12CommandSignature */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12CommandSignature; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("c36a797c-ec80-4f0a-8985-a7b2475082d1") - ID3D12CommandSignature : public ID3D12Pageable - { - public: - }; - - -#else /* C style interface */ - - typedef struct ID3D12CommandSignatureVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12CommandSignature * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12CommandSignature * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12CommandSignature * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12CommandSignature * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12CommandSignature * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12CommandSignature * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12CommandSignature * This, - _In_z_ LPCWSTR Name); - - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12CommandSignature * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - END_INTERFACE - } ID3D12CommandSignatureVtbl; - - interface ID3D12CommandSignature - { - CONST_VTBL struct ID3D12CommandSignatureVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12CommandSignature_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12CommandSignature_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12CommandSignature_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12CommandSignature_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12CommandSignature_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12CommandSignature_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12CommandSignature_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12CommandSignature_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - - - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12CommandSignature_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12CommandList_INTERFACE_DEFINED__ -#define __ID3D12CommandList_INTERFACE_DEFINED__ - -/* interface ID3D12CommandList */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12CommandList; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("7116d91c-e7e4-47ce-b8c6-ec8168f437e5") - ID3D12CommandList : public ID3D12DeviceChild - { - public: - virtual D3D12_COMMAND_LIST_TYPE STDMETHODCALLTYPE GetType( void) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12CommandListVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12CommandList * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12CommandList * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12CommandList * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12CommandList * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12CommandList * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12CommandList * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12CommandList * This, - _In_z_ LPCWSTR Name); - - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12CommandList * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( - ID3D12CommandList * This); - - END_INTERFACE - } ID3D12CommandListVtbl; - - interface ID3D12CommandList - { - CONST_VTBL struct ID3D12CommandListVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12CommandList_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12CommandList_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12CommandList_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12CommandList_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12CommandList_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12CommandList_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12CommandList_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12CommandList_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - - -#define ID3D12CommandList_GetType(This) \ - ( (This)->lpVtbl -> GetType(This) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12CommandList_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12GraphicsCommandList_INTERFACE_DEFINED__ -#define __ID3D12GraphicsCommandList_INTERFACE_DEFINED__ - -/* interface ID3D12GraphicsCommandList */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12GraphicsCommandList; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("5b160d0f-ac1b-4185-8ba8-b3ae42a5a455") - ID3D12GraphicsCommandList : public ID3D12CommandList - { - public: - virtual HRESULT STDMETHODCALLTYPE Close( void) = 0; - - virtual HRESULT STDMETHODCALLTYPE Reset( - _In_ ID3D12CommandAllocator *pAllocator, - _In_opt_ ID3D12PipelineState *pInitialState) = 0; - - virtual void STDMETHODCALLTYPE ClearState( - _In_opt_ ID3D12PipelineState *pPipelineState) = 0; - - virtual void STDMETHODCALLTYPE DrawInstanced( - _In_ UINT VertexCountPerInstance, - _In_ UINT InstanceCount, - _In_ UINT StartVertexLocation, - _In_ UINT StartInstanceLocation) = 0; - - virtual void STDMETHODCALLTYPE DrawIndexedInstanced( - _In_ UINT IndexCountPerInstance, - _In_ UINT InstanceCount, - _In_ UINT StartIndexLocation, - _In_ INT BaseVertexLocation, - _In_ UINT StartInstanceLocation) = 0; - - virtual void STDMETHODCALLTYPE Dispatch( - _In_ UINT ThreadGroupCountX, - _In_ UINT ThreadGroupCountY, - _In_ UINT ThreadGroupCountZ) = 0; - - virtual void STDMETHODCALLTYPE CopyBufferRegion( - _In_ ID3D12Resource *pDstBuffer, - UINT64 DstOffset, - _In_ ID3D12Resource *pSrcBuffer, - UINT64 SrcOffset, - UINT64 NumBytes) = 0; - - virtual void STDMETHODCALLTYPE CopyTextureRegion( - _In_ const D3D12_TEXTURE_COPY_LOCATION *pDst, - UINT DstX, - UINT DstY, - UINT DstZ, - _In_ const D3D12_TEXTURE_COPY_LOCATION *pSrc, - _In_opt_ const D3D12_BOX *pSrcBox) = 0; - - virtual void STDMETHODCALLTYPE CopyResource( - _In_ ID3D12Resource *pDstResource, - _In_ ID3D12Resource *pSrcResource) = 0; - - virtual void STDMETHODCALLTYPE CopyTiles( - _In_ ID3D12Resource *pTiledResource, - _In_ const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate, - _In_ const D3D12_TILE_REGION_SIZE *pTileRegionSize, - _In_ ID3D12Resource *pBuffer, - UINT64 BufferStartOffsetInBytes, - D3D12_TILE_COPY_FLAGS Flags) = 0; - - virtual void STDMETHODCALLTYPE ResolveSubresource( - _In_ ID3D12Resource *pDstResource, - _In_ UINT DstSubresource, - _In_ ID3D12Resource *pSrcResource, - _In_ UINT SrcSubresource, - _In_ DXGI_FORMAT Format) = 0; - - virtual void STDMETHODCALLTYPE IASetPrimitiveTopology( - _In_ D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology) = 0; - - virtual void STDMETHODCALLTYPE RSSetViewports( - _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumViewports, - _In_reads_( NumViewports) const D3D12_VIEWPORT *pViewports) = 0; - - virtual void STDMETHODCALLTYPE RSSetScissorRects( - _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumRects, - _In_reads_( NumRects) const D3D12_RECT *pRects) = 0; - - virtual void STDMETHODCALLTYPE OMSetBlendFactor( - _In_reads_opt_(4) const FLOAT BlendFactor[ 4 ]) = 0; - - virtual void STDMETHODCALLTYPE OMSetStencilRef( - _In_ UINT StencilRef) = 0; - - virtual void STDMETHODCALLTYPE SetPipelineState( - _In_ ID3D12PipelineState *pPipelineState) = 0; - - virtual void STDMETHODCALLTYPE ResourceBarrier( - _In_ UINT NumBarriers, - _In_reads_(NumBarriers) const D3D12_RESOURCE_BARRIER *pBarriers) = 0; - - virtual void STDMETHODCALLTYPE ExecuteBundle( - _In_ ID3D12GraphicsCommandList *pCommandList) = 0; - - virtual void STDMETHODCALLTYPE SetDescriptorHeaps( - _In_ UINT NumDescriptorHeaps, - _In_reads_(NumDescriptorHeaps) ID3D12DescriptorHeap *const *ppDescriptorHeaps) = 0; - - virtual void STDMETHODCALLTYPE SetComputeRootSignature( - _In_opt_ ID3D12RootSignature *pRootSignature) = 0; - - virtual void STDMETHODCALLTYPE SetGraphicsRootSignature( - _In_opt_ ID3D12RootSignature *pRootSignature) = 0; - - virtual void STDMETHODCALLTYPE SetComputeRootDescriptorTable( - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor) = 0; - - virtual void STDMETHODCALLTYPE SetGraphicsRootDescriptorTable( - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor) = 0; - - virtual void STDMETHODCALLTYPE SetComputeRoot32BitConstant( - _In_ UINT RootParameterIndex, - _In_ UINT SrcData, - _In_ UINT DestOffsetIn32BitValues) = 0; - - virtual void STDMETHODCALLTYPE SetGraphicsRoot32BitConstant( - _In_ UINT RootParameterIndex, - _In_ UINT SrcData, - _In_ UINT DestOffsetIn32BitValues) = 0; - - virtual void STDMETHODCALLTYPE SetComputeRoot32BitConstants( - _In_ UINT RootParameterIndex, - _In_ UINT Num32BitValuesToSet, - _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, - _In_ UINT DestOffsetIn32BitValues) = 0; - - virtual void STDMETHODCALLTYPE SetGraphicsRoot32BitConstants( - _In_ UINT RootParameterIndex, - _In_ UINT Num32BitValuesToSet, - _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, - _In_ UINT DestOffsetIn32BitValues) = 0; - - virtual void STDMETHODCALLTYPE SetComputeRootConstantBufferView( - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation) = 0; - - virtual void STDMETHODCALLTYPE SetGraphicsRootConstantBufferView( - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation) = 0; - - virtual void STDMETHODCALLTYPE SetComputeRootShaderResourceView( - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation) = 0; - - virtual void STDMETHODCALLTYPE SetGraphicsRootShaderResourceView( - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation) = 0; - - virtual void STDMETHODCALLTYPE SetComputeRootUnorderedAccessView( - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation) = 0; - - virtual void STDMETHODCALLTYPE SetGraphicsRootUnorderedAccessView( - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation) = 0; - - virtual void STDMETHODCALLTYPE IASetIndexBuffer( - _In_opt_ const D3D12_INDEX_BUFFER_VIEW *pView) = 0; - - virtual void STDMETHODCALLTYPE IASetVertexBuffers( - _In_ UINT StartSlot, - _In_ UINT NumViews, - _In_reads_opt_(NumViews) const D3D12_VERTEX_BUFFER_VIEW *pViews) = 0; - - virtual void STDMETHODCALLTYPE SOSetTargets( - _In_ UINT StartSlot, - _In_ UINT NumViews, - _In_reads_opt_(NumViews) const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews) = 0; - - virtual void STDMETHODCALLTYPE OMSetRenderTargets( - _In_ UINT NumRenderTargetDescriptors, - _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors, - _In_ BOOL RTsSingleHandleToDescriptorRange, - _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pDepthStencilDescriptor) = 0; - - virtual void STDMETHODCALLTYPE ClearDepthStencilView( - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView, - _In_ D3D12_CLEAR_FLAGS ClearFlags, - _In_ FLOAT Depth, - _In_ UINT8 Stencil, - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects) = 0; - - virtual void STDMETHODCALLTYPE ClearRenderTargetView( - _In_ D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView, - _In_ const FLOAT ColorRGBA[ 4 ], - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects) = 0; - - virtual void STDMETHODCALLTYPE ClearUnorderedAccessViewUint( - _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, - _In_ ID3D12Resource *pResource, - _In_ const UINT Values[ 4 ], - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects) = 0; - - virtual void STDMETHODCALLTYPE ClearUnorderedAccessViewFloat( - _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, - _In_ ID3D12Resource *pResource, - _In_ const FLOAT Values[ 4 ], - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects) = 0; - - virtual void STDMETHODCALLTYPE DiscardResource( - _In_ ID3D12Resource *pResource, - _In_opt_ const D3D12_DISCARD_REGION *pRegion) = 0; - - virtual void STDMETHODCALLTYPE BeginQuery( - _In_ ID3D12QueryHeap *pQueryHeap, - _In_ D3D12_QUERY_TYPE Type, - _In_ UINT Index) = 0; - - virtual void STDMETHODCALLTYPE EndQuery( - _In_ ID3D12QueryHeap *pQueryHeap, - _In_ D3D12_QUERY_TYPE Type, - _In_ UINT Index) = 0; - - virtual void STDMETHODCALLTYPE ResolveQueryData( - _In_ ID3D12QueryHeap *pQueryHeap, - _In_ D3D12_QUERY_TYPE Type, - _In_ UINT StartIndex, - _In_ UINT NumQueries, - _In_ ID3D12Resource *pDestinationBuffer, - _In_ UINT64 AlignedDestinationBufferOffset) = 0; - - virtual void STDMETHODCALLTYPE SetPredication( - _In_opt_ ID3D12Resource *pBuffer, - _In_ UINT64 AlignedBufferOffset, - _In_ D3D12_PREDICATION_OP Operation) = 0; - - virtual void STDMETHODCALLTYPE SetMarker( - UINT Metadata, - _In_reads_bytes_opt_(Size) const void *pData, - UINT Size) = 0; - - virtual void STDMETHODCALLTYPE BeginEvent( - UINT Metadata, - _In_reads_bytes_opt_(Size) const void *pData, - UINT Size) = 0; - - virtual void STDMETHODCALLTYPE EndEvent( void) = 0; - - virtual void STDMETHODCALLTYPE ExecuteIndirect( - _In_ ID3D12CommandSignature *pCommandSignature, - _In_ UINT MaxCommandCount, - _In_ ID3D12Resource *pArgumentBuffer, - _In_ UINT64 ArgumentBufferOffset, - _In_opt_ ID3D12Resource *pCountBuffer, - _In_ UINT64 CountBufferOffset) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12GraphicsCommandListVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12GraphicsCommandList * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12GraphicsCommandList * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12GraphicsCommandList * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12GraphicsCommandList * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12GraphicsCommandList * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12GraphicsCommandList * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12GraphicsCommandList * This, - _In_z_ LPCWSTR Name); - - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12GraphicsCommandList * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( - ID3D12GraphicsCommandList * This); - - HRESULT ( STDMETHODCALLTYPE *Close )( - ID3D12GraphicsCommandList * This); - - HRESULT ( STDMETHODCALLTYPE *Reset )( - ID3D12GraphicsCommandList * This, - _In_ ID3D12CommandAllocator *pAllocator, - _In_opt_ ID3D12PipelineState *pInitialState); - - void ( STDMETHODCALLTYPE *ClearState )( - ID3D12GraphicsCommandList * This, - _In_opt_ ID3D12PipelineState *pPipelineState); - - void ( STDMETHODCALLTYPE *DrawInstanced )( - ID3D12GraphicsCommandList * This, - _In_ UINT VertexCountPerInstance, - _In_ UINT InstanceCount, - _In_ UINT StartVertexLocation, - _In_ UINT StartInstanceLocation); - - void ( STDMETHODCALLTYPE *DrawIndexedInstanced )( - ID3D12GraphicsCommandList * This, - _In_ UINT IndexCountPerInstance, - _In_ UINT InstanceCount, - _In_ UINT StartIndexLocation, - _In_ INT BaseVertexLocation, - _In_ UINT StartInstanceLocation); - - void ( STDMETHODCALLTYPE *Dispatch )( - ID3D12GraphicsCommandList * This, - _In_ UINT ThreadGroupCountX, - _In_ UINT ThreadGroupCountY, - _In_ UINT ThreadGroupCountZ); - - void ( STDMETHODCALLTYPE *CopyBufferRegion )( - ID3D12GraphicsCommandList * This, - _In_ ID3D12Resource *pDstBuffer, - UINT64 DstOffset, - _In_ ID3D12Resource *pSrcBuffer, - UINT64 SrcOffset, - UINT64 NumBytes); - - void ( STDMETHODCALLTYPE *CopyTextureRegion )( - ID3D12GraphicsCommandList * This, - _In_ const D3D12_TEXTURE_COPY_LOCATION *pDst, - UINT DstX, - UINT DstY, - UINT DstZ, - _In_ const D3D12_TEXTURE_COPY_LOCATION *pSrc, - _In_opt_ const D3D12_BOX *pSrcBox); - - void ( STDMETHODCALLTYPE *CopyResource )( - ID3D12GraphicsCommandList * This, - _In_ ID3D12Resource *pDstResource, - _In_ ID3D12Resource *pSrcResource); - - void ( STDMETHODCALLTYPE *CopyTiles )( - ID3D12GraphicsCommandList * This, - _In_ ID3D12Resource *pTiledResource, - _In_ const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate, - _In_ const D3D12_TILE_REGION_SIZE *pTileRegionSize, - _In_ ID3D12Resource *pBuffer, - UINT64 BufferStartOffsetInBytes, - D3D12_TILE_COPY_FLAGS Flags); - - void ( STDMETHODCALLTYPE *ResolveSubresource )( - ID3D12GraphicsCommandList * This, - _In_ ID3D12Resource *pDstResource, - _In_ UINT DstSubresource, - _In_ ID3D12Resource *pSrcResource, - _In_ UINT SrcSubresource, - _In_ DXGI_FORMAT Format); - - void ( STDMETHODCALLTYPE *IASetPrimitiveTopology )( - ID3D12GraphicsCommandList * This, - _In_ D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology); - - void ( STDMETHODCALLTYPE *RSSetViewports )( - ID3D12GraphicsCommandList * This, - _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumViewports, - _In_reads_( NumViewports) const D3D12_VIEWPORT *pViewports); - - void ( STDMETHODCALLTYPE *RSSetScissorRects )( - ID3D12GraphicsCommandList * This, - _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumRects, - _In_reads_( NumRects) const D3D12_RECT *pRects); - - void ( STDMETHODCALLTYPE *OMSetBlendFactor )( - ID3D12GraphicsCommandList * This, - _In_reads_opt_(4) const FLOAT BlendFactor[ 4 ]); - - void ( STDMETHODCALLTYPE *OMSetStencilRef )( - ID3D12GraphicsCommandList * This, - _In_ UINT StencilRef); - - void ( STDMETHODCALLTYPE *SetPipelineState )( - ID3D12GraphicsCommandList * This, - _In_ ID3D12PipelineState *pPipelineState); - - void ( STDMETHODCALLTYPE *ResourceBarrier )( - ID3D12GraphicsCommandList * This, - _In_ UINT NumBarriers, - _In_reads_(NumBarriers) const D3D12_RESOURCE_BARRIER *pBarriers); - - void ( STDMETHODCALLTYPE *ExecuteBundle )( - ID3D12GraphicsCommandList * This, - _In_ ID3D12GraphicsCommandList *pCommandList); - - void ( STDMETHODCALLTYPE *SetDescriptorHeaps )( - ID3D12GraphicsCommandList * This, - _In_ UINT NumDescriptorHeaps, - _In_reads_(NumDescriptorHeaps) ID3D12DescriptorHeap *const *ppDescriptorHeaps); - - void ( STDMETHODCALLTYPE *SetComputeRootSignature )( - ID3D12GraphicsCommandList * This, - _In_opt_ ID3D12RootSignature *pRootSignature); - - void ( STDMETHODCALLTYPE *SetGraphicsRootSignature )( - ID3D12GraphicsCommandList * This, - _In_opt_ ID3D12RootSignature *pRootSignature); - - void ( STDMETHODCALLTYPE *SetComputeRootDescriptorTable )( - ID3D12GraphicsCommandList * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); - - void ( STDMETHODCALLTYPE *SetGraphicsRootDescriptorTable )( - ID3D12GraphicsCommandList * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); - - void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstant )( - ID3D12GraphicsCommandList * This, - _In_ UINT RootParameterIndex, - _In_ UINT SrcData, - _In_ UINT DestOffsetIn32BitValues); - - void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstant )( - ID3D12GraphicsCommandList * This, - _In_ UINT RootParameterIndex, - _In_ UINT SrcData, - _In_ UINT DestOffsetIn32BitValues); - - void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstants )( - ID3D12GraphicsCommandList * This, - _In_ UINT RootParameterIndex, - _In_ UINT Num32BitValuesToSet, - _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, - _In_ UINT DestOffsetIn32BitValues); - - void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstants )( - ID3D12GraphicsCommandList * This, - _In_ UINT RootParameterIndex, - _In_ UINT Num32BitValuesToSet, - _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, - _In_ UINT DestOffsetIn32BitValues); - - void ( STDMETHODCALLTYPE *SetComputeRootConstantBufferView )( - ID3D12GraphicsCommandList * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *SetGraphicsRootConstantBufferView )( - ID3D12GraphicsCommandList * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *SetComputeRootShaderResourceView )( - ID3D12GraphicsCommandList * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *SetGraphicsRootShaderResourceView )( - ID3D12GraphicsCommandList * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *SetComputeRootUnorderedAccessView )( - ID3D12GraphicsCommandList * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *SetGraphicsRootUnorderedAccessView )( - ID3D12GraphicsCommandList * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *IASetIndexBuffer )( - ID3D12GraphicsCommandList * This, - _In_opt_ const D3D12_INDEX_BUFFER_VIEW *pView); - - void ( STDMETHODCALLTYPE *IASetVertexBuffers )( - ID3D12GraphicsCommandList * This, - _In_ UINT StartSlot, - _In_ UINT NumViews, - _In_reads_opt_(NumViews) const D3D12_VERTEX_BUFFER_VIEW *pViews); - - void ( STDMETHODCALLTYPE *SOSetTargets )( - ID3D12GraphicsCommandList * This, - _In_ UINT StartSlot, - _In_ UINT NumViews, - _In_reads_opt_(NumViews) const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews); - - void ( STDMETHODCALLTYPE *OMSetRenderTargets )( - ID3D12GraphicsCommandList * This, - _In_ UINT NumRenderTargetDescriptors, - _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors, - _In_ BOOL RTsSingleHandleToDescriptorRange, - _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pDepthStencilDescriptor); - - void ( STDMETHODCALLTYPE *ClearDepthStencilView )( - ID3D12GraphicsCommandList * This, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView, - _In_ D3D12_CLEAR_FLAGS ClearFlags, - _In_ FLOAT Depth, - _In_ UINT8 Stencil, - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); - - void ( STDMETHODCALLTYPE *ClearRenderTargetView )( - ID3D12GraphicsCommandList * This, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView, - _In_ const FLOAT ColorRGBA[ 4 ], - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); - - void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewUint )( - ID3D12GraphicsCommandList * This, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, - _In_ ID3D12Resource *pResource, - _In_ const UINT Values[ 4 ], - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); - - void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewFloat )( - ID3D12GraphicsCommandList * This, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, - _In_ ID3D12Resource *pResource, - _In_ const FLOAT Values[ 4 ], - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); - - void ( STDMETHODCALLTYPE *DiscardResource )( - ID3D12GraphicsCommandList * This, - _In_ ID3D12Resource *pResource, - _In_opt_ const D3D12_DISCARD_REGION *pRegion); - - void ( STDMETHODCALLTYPE *BeginQuery )( - ID3D12GraphicsCommandList * This, - _In_ ID3D12QueryHeap *pQueryHeap, - _In_ D3D12_QUERY_TYPE Type, - _In_ UINT Index); - - void ( STDMETHODCALLTYPE *EndQuery )( - ID3D12GraphicsCommandList * This, - _In_ ID3D12QueryHeap *pQueryHeap, - _In_ D3D12_QUERY_TYPE Type, - _In_ UINT Index); - - void ( STDMETHODCALLTYPE *ResolveQueryData )( - ID3D12GraphicsCommandList * This, - _In_ ID3D12QueryHeap *pQueryHeap, - _In_ D3D12_QUERY_TYPE Type, - _In_ UINT StartIndex, - _In_ UINT NumQueries, - _In_ ID3D12Resource *pDestinationBuffer, - _In_ UINT64 AlignedDestinationBufferOffset); - - void ( STDMETHODCALLTYPE *SetPredication )( - ID3D12GraphicsCommandList * This, - _In_opt_ ID3D12Resource *pBuffer, - _In_ UINT64 AlignedBufferOffset, - _In_ D3D12_PREDICATION_OP Operation); - - void ( STDMETHODCALLTYPE *SetMarker )( - ID3D12GraphicsCommandList * This, - UINT Metadata, - _In_reads_bytes_opt_(Size) const void *pData, - UINT Size); - - void ( STDMETHODCALLTYPE *BeginEvent )( - ID3D12GraphicsCommandList * This, - UINT Metadata, - _In_reads_bytes_opt_(Size) const void *pData, - UINT Size); - - void ( STDMETHODCALLTYPE *EndEvent )( - ID3D12GraphicsCommandList * This); - - void ( STDMETHODCALLTYPE *ExecuteIndirect )( - ID3D12GraphicsCommandList * This, - _In_ ID3D12CommandSignature *pCommandSignature, - _In_ UINT MaxCommandCount, - _In_ ID3D12Resource *pArgumentBuffer, - _In_ UINT64 ArgumentBufferOffset, - _In_opt_ ID3D12Resource *pCountBuffer, - _In_ UINT64 CountBufferOffset); - - END_INTERFACE - } ID3D12GraphicsCommandListVtbl; - - interface ID3D12GraphicsCommandList - { - CONST_VTBL struct ID3D12GraphicsCommandListVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12GraphicsCommandList_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12GraphicsCommandList_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12GraphicsCommandList_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12GraphicsCommandList_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12GraphicsCommandList_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12GraphicsCommandList_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12GraphicsCommandList_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12GraphicsCommandList_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - - -#define ID3D12GraphicsCommandList_GetType(This) \ - ( (This)->lpVtbl -> GetType(This) ) - - -#define ID3D12GraphicsCommandList_Close(This) \ - ( (This)->lpVtbl -> Close(This) ) - -#define ID3D12GraphicsCommandList_Reset(This,pAllocator,pInitialState) \ - ( (This)->lpVtbl -> Reset(This,pAllocator,pInitialState) ) - -#define ID3D12GraphicsCommandList_ClearState(This,pPipelineState) \ - ( (This)->lpVtbl -> ClearState(This,pPipelineState) ) - -#define ID3D12GraphicsCommandList_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) \ - ( (This)->lpVtbl -> DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) ) - -#define ID3D12GraphicsCommandList_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) \ - ( (This)->lpVtbl -> DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) ) - -#define ID3D12GraphicsCommandList_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ - ( (This)->lpVtbl -> Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) - -#define ID3D12GraphicsCommandList_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) \ - ( (This)->lpVtbl -> CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) ) - -#define ID3D12GraphicsCommandList_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) \ - ( (This)->lpVtbl -> CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) ) - -#define ID3D12GraphicsCommandList_CopyResource(This,pDstResource,pSrcResource) \ - ( (This)->lpVtbl -> CopyResource(This,pDstResource,pSrcResource) ) - -#define ID3D12GraphicsCommandList_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) \ - ( (This)->lpVtbl -> CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) ) - -#define ID3D12GraphicsCommandList_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) \ - ( (This)->lpVtbl -> ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) ) - -#define ID3D12GraphicsCommandList_IASetPrimitiveTopology(This,PrimitiveTopology) \ - ( (This)->lpVtbl -> IASetPrimitiveTopology(This,PrimitiveTopology) ) - -#define ID3D12GraphicsCommandList_RSSetViewports(This,NumViewports,pViewports) \ - ( (This)->lpVtbl -> RSSetViewports(This,NumViewports,pViewports) ) - -#define ID3D12GraphicsCommandList_RSSetScissorRects(This,NumRects,pRects) \ - ( (This)->lpVtbl -> RSSetScissorRects(This,NumRects,pRects) ) - -#define ID3D12GraphicsCommandList_OMSetBlendFactor(This,BlendFactor) \ - ( (This)->lpVtbl -> OMSetBlendFactor(This,BlendFactor) ) - -#define ID3D12GraphicsCommandList_OMSetStencilRef(This,StencilRef) \ - ( (This)->lpVtbl -> OMSetStencilRef(This,StencilRef) ) - -#define ID3D12GraphicsCommandList_SetPipelineState(This,pPipelineState) \ - ( (This)->lpVtbl -> SetPipelineState(This,pPipelineState) ) - -#define ID3D12GraphicsCommandList_ResourceBarrier(This,NumBarriers,pBarriers) \ - ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) - -#define ID3D12GraphicsCommandList_ExecuteBundle(This,pCommandList) \ - ( (This)->lpVtbl -> ExecuteBundle(This,pCommandList) ) - -#define ID3D12GraphicsCommandList_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) \ - ( (This)->lpVtbl -> SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) ) - -#define ID3D12GraphicsCommandList_SetComputeRootSignature(This,pRootSignature) \ - ( (This)->lpVtbl -> SetComputeRootSignature(This,pRootSignature) ) - -#define ID3D12GraphicsCommandList_SetGraphicsRootSignature(This,pRootSignature) \ - ( (This)->lpVtbl -> SetGraphicsRootSignature(This,pRootSignature) ) - -#define ID3D12GraphicsCommandList_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ - ( (This)->lpVtbl -> SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) - -#define ID3D12GraphicsCommandList_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ - ( (This)->lpVtbl -> SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) - -#define ID3D12GraphicsCommandList_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) - -#define ID3D12GraphicsCommandList_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) - -#define ID3D12GraphicsCommandList_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) - -#define ID3D12GraphicsCommandList_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) - -#define ID3D12GraphicsCommandList_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList_IASetIndexBuffer(This,pView) \ - ( (This)->lpVtbl -> IASetIndexBuffer(This,pView) ) - -#define ID3D12GraphicsCommandList_IASetVertexBuffers(This,StartSlot,NumViews,pViews) \ - ( (This)->lpVtbl -> IASetVertexBuffers(This,StartSlot,NumViews,pViews) ) - -#define ID3D12GraphicsCommandList_SOSetTargets(This,StartSlot,NumViews,pViews) \ - ( (This)->lpVtbl -> SOSetTargets(This,StartSlot,NumViews,pViews) ) - -#define ID3D12GraphicsCommandList_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) \ - ( (This)->lpVtbl -> OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) ) - -#define ID3D12GraphicsCommandList_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) ) - -#define ID3D12GraphicsCommandList_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) ) - -#define ID3D12GraphicsCommandList_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) - -#define ID3D12GraphicsCommandList_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) - -#define ID3D12GraphicsCommandList_DiscardResource(This,pResource,pRegion) \ - ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) - -#define ID3D12GraphicsCommandList_BeginQuery(This,pQueryHeap,Type,Index) \ - ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) - -#define ID3D12GraphicsCommandList_EndQuery(This,pQueryHeap,Type,Index) \ - ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) - -#define ID3D12GraphicsCommandList_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) \ - ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) - -#define ID3D12GraphicsCommandList_SetPredication(This,pBuffer,AlignedBufferOffset,Operation) \ - ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) - -#define ID3D12GraphicsCommandList_SetMarker(This,Metadata,pData,Size) \ - ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) - -#define ID3D12GraphicsCommandList_BeginEvent(This,Metadata,pData,Size) \ - ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) - -#define ID3D12GraphicsCommandList_EndEvent(This) \ - ( (This)->lpVtbl -> EndEvent(This) ) - -#define ID3D12GraphicsCommandList_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) \ - ( (This)->lpVtbl -> ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12GraphicsCommandList_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12GraphicsCommandList1_INTERFACE_DEFINED__ -#define __ID3D12GraphicsCommandList1_INTERFACE_DEFINED__ - -/* interface ID3D12GraphicsCommandList1 */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12GraphicsCommandList1; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("553103fb-1fe7-4557-bb38-946d7d0e7ca7") - ID3D12GraphicsCommandList1 : public ID3D12GraphicsCommandList - { - public: - virtual void STDMETHODCALLTYPE AtomicCopyBufferUINT( - _In_ ID3D12Resource *pDstBuffer, - UINT64 DstOffset, - _In_ ID3D12Resource *pSrcBuffer, - UINT64 SrcOffset, - UINT Dependencies, - _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, - _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges) = 0; - - virtual void STDMETHODCALLTYPE AtomicCopyBufferUINT64( - _In_ ID3D12Resource *pDstBuffer, - UINT64 DstOffset, - _In_ ID3D12Resource *pSrcBuffer, - UINT64 SrcOffset, - UINT Dependencies, - _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, - _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges) = 0; - - virtual void STDMETHODCALLTYPE OMSetDepthBounds( - _In_ FLOAT Min, - _In_ FLOAT Max) = 0; - - virtual void STDMETHODCALLTYPE SetSamplePositions( - _In_ UINT NumSamplesPerPixel, - _In_ UINT NumPixels, - _In_reads_(NumSamplesPerPixel*NumPixels) D3D12_SAMPLE_POSITION *pSamplePositions) = 0; - - virtual void STDMETHODCALLTYPE ResolveSubresourceRegion( - _In_ ID3D12Resource *pDstResource, - _In_ UINT DstSubresource, - _In_ UINT DstX, - _In_ UINT DstY, - _In_ ID3D12Resource *pSrcResource, - _In_ UINT SrcSubresource, - _In_opt_ D3D12_RECT *pSrcRect, - _In_ DXGI_FORMAT Format, - _In_ D3D12_RESOLVE_MODE ResolveMode) = 0; - - virtual void STDMETHODCALLTYPE SetViewInstanceMask( - _In_ UINT Mask) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12GraphicsCommandList1Vtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12GraphicsCommandList1 * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12GraphicsCommandList1 * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12GraphicsCommandList1 * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12GraphicsCommandList1 * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12GraphicsCommandList1 * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12GraphicsCommandList1 * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12GraphicsCommandList1 * This, - _In_z_ LPCWSTR Name); - - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12GraphicsCommandList1 * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( - ID3D12GraphicsCommandList1 * This); - - HRESULT ( STDMETHODCALLTYPE *Close )( - ID3D12GraphicsCommandList1 * This); - - HRESULT ( STDMETHODCALLTYPE *Reset )( - ID3D12GraphicsCommandList1 * This, - _In_ ID3D12CommandAllocator *pAllocator, - _In_opt_ ID3D12PipelineState *pInitialState); - - void ( STDMETHODCALLTYPE *ClearState )( - ID3D12GraphicsCommandList1 * This, - _In_opt_ ID3D12PipelineState *pPipelineState); - - void ( STDMETHODCALLTYPE *DrawInstanced )( - ID3D12GraphicsCommandList1 * This, - _In_ UINT VertexCountPerInstance, - _In_ UINT InstanceCount, - _In_ UINT StartVertexLocation, - _In_ UINT StartInstanceLocation); - - void ( STDMETHODCALLTYPE *DrawIndexedInstanced )( - ID3D12GraphicsCommandList1 * This, - _In_ UINT IndexCountPerInstance, - _In_ UINT InstanceCount, - _In_ UINT StartIndexLocation, - _In_ INT BaseVertexLocation, - _In_ UINT StartInstanceLocation); - - void ( STDMETHODCALLTYPE *Dispatch )( - ID3D12GraphicsCommandList1 * This, - _In_ UINT ThreadGroupCountX, - _In_ UINT ThreadGroupCountY, - _In_ UINT ThreadGroupCountZ); - - void ( STDMETHODCALLTYPE *CopyBufferRegion )( - ID3D12GraphicsCommandList1 * This, - _In_ ID3D12Resource *pDstBuffer, - UINT64 DstOffset, - _In_ ID3D12Resource *pSrcBuffer, - UINT64 SrcOffset, - UINT64 NumBytes); - - void ( STDMETHODCALLTYPE *CopyTextureRegion )( - ID3D12GraphicsCommandList1 * This, - _In_ const D3D12_TEXTURE_COPY_LOCATION *pDst, - UINT DstX, - UINT DstY, - UINT DstZ, - _In_ const D3D12_TEXTURE_COPY_LOCATION *pSrc, - _In_opt_ const D3D12_BOX *pSrcBox); - - void ( STDMETHODCALLTYPE *CopyResource )( - ID3D12GraphicsCommandList1 * This, - _In_ ID3D12Resource *pDstResource, - _In_ ID3D12Resource *pSrcResource); - - void ( STDMETHODCALLTYPE *CopyTiles )( - ID3D12GraphicsCommandList1 * This, - _In_ ID3D12Resource *pTiledResource, - _In_ const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate, - _In_ const D3D12_TILE_REGION_SIZE *pTileRegionSize, - _In_ ID3D12Resource *pBuffer, - UINT64 BufferStartOffsetInBytes, - D3D12_TILE_COPY_FLAGS Flags); - - void ( STDMETHODCALLTYPE *ResolveSubresource )( - ID3D12GraphicsCommandList1 * This, - _In_ ID3D12Resource *pDstResource, - _In_ UINT DstSubresource, - _In_ ID3D12Resource *pSrcResource, - _In_ UINT SrcSubresource, - _In_ DXGI_FORMAT Format); - - void ( STDMETHODCALLTYPE *IASetPrimitiveTopology )( - ID3D12GraphicsCommandList1 * This, - _In_ D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology); - - void ( STDMETHODCALLTYPE *RSSetViewports )( - ID3D12GraphicsCommandList1 * This, - _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumViewports, - _In_reads_( NumViewports) const D3D12_VIEWPORT *pViewports); - - void ( STDMETHODCALLTYPE *RSSetScissorRects )( - ID3D12GraphicsCommandList1 * This, - _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumRects, - _In_reads_( NumRects) const D3D12_RECT *pRects); - - void ( STDMETHODCALLTYPE *OMSetBlendFactor )( - ID3D12GraphicsCommandList1 * This, - _In_reads_opt_(4) const FLOAT BlendFactor[ 4 ]); - - void ( STDMETHODCALLTYPE *OMSetStencilRef )( - ID3D12GraphicsCommandList1 * This, - _In_ UINT StencilRef); - - void ( STDMETHODCALLTYPE *SetPipelineState )( - ID3D12GraphicsCommandList1 * This, - _In_ ID3D12PipelineState *pPipelineState); - - void ( STDMETHODCALLTYPE *ResourceBarrier )( - ID3D12GraphicsCommandList1 * This, - _In_ UINT NumBarriers, - _In_reads_(NumBarriers) const D3D12_RESOURCE_BARRIER *pBarriers); - - void ( STDMETHODCALLTYPE *ExecuteBundle )( - ID3D12GraphicsCommandList1 * This, - _In_ ID3D12GraphicsCommandList *pCommandList); - - void ( STDMETHODCALLTYPE *SetDescriptorHeaps )( - ID3D12GraphicsCommandList1 * This, - _In_ UINT NumDescriptorHeaps, - _In_reads_(NumDescriptorHeaps) ID3D12DescriptorHeap *const *ppDescriptorHeaps); - - void ( STDMETHODCALLTYPE *SetComputeRootSignature )( - ID3D12GraphicsCommandList1 * This, - _In_opt_ ID3D12RootSignature *pRootSignature); - - void ( STDMETHODCALLTYPE *SetGraphicsRootSignature )( - ID3D12GraphicsCommandList1 * This, - _In_opt_ ID3D12RootSignature *pRootSignature); - - void ( STDMETHODCALLTYPE *SetComputeRootDescriptorTable )( - ID3D12GraphicsCommandList1 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); - - void ( STDMETHODCALLTYPE *SetGraphicsRootDescriptorTable )( - ID3D12GraphicsCommandList1 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); - - void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstant )( - ID3D12GraphicsCommandList1 * This, - _In_ UINT RootParameterIndex, - _In_ UINT SrcData, - _In_ UINT DestOffsetIn32BitValues); - - void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstant )( - ID3D12GraphicsCommandList1 * This, - _In_ UINT RootParameterIndex, - _In_ UINT SrcData, - _In_ UINT DestOffsetIn32BitValues); - - void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstants )( - ID3D12GraphicsCommandList1 * This, - _In_ UINT RootParameterIndex, - _In_ UINT Num32BitValuesToSet, - _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, - _In_ UINT DestOffsetIn32BitValues); - - void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstants )( - ID3D12GraphicsCommandList1 * This, - _In_ UINT RootParameterIndex, - _In_ UINT Num32BitValuesToSet, - _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, - _In_ UINT DestOffsetIn32BitValues); - - void ( STDMETHODCALLTYPE *SetComputeRootConstantBufferView )( - ID3D12GraphicsCommandList1 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *SetGraphicsRootConstantBufferView )( - ID3D12GraphicsCommandList1 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *SetComputeRootShaderResourceView )( - ID3D12GraphicsCommandList1 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *SetGraphicsRootShaderResourceView )( - ID3D12GraphicsCommandList1 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *SetComputeRootUnorderedAccessView )( - ID3D12GraphicsCommandList1 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *SetGraphicsRootUnorderedAccessView )( - ID3D12GraphicsCommandList1 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *IASetIndexBuffer )( - ID3D12GraphicsCommandList1 * This, - _In_opt_ const D3D12_INDEX_BUFFER_VIEW *pView); - - void ( STDMETHODCALLTYPE *IASetVertexBuffers )( - ID3D12GraphicsCommandList1 * This, - _In_ UINT StartSlot, - _In_ UINT NumViews, - _In_reads_opt_(NumViews) const D3D12_VERTEX_BUFFER_VIEW *pViews); - - void ( STDMETHODCALLTYPE *SOSetTargets )( - ID3D12GraphicsCommandList1 * This, - _In_ UINT StartSlot, - _In_ UINT NumViews, - _In_reads_opt_(NumViews) const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews); - - void ( STDMETHODCALLTYPE *OMSetRenderTargets )( - ID3D12GraphicsCommandList1 * This, - _In_ UINT NumRenderTargetDescriptors, - _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors, - _In_ BOOL RTsSingleHandleToDescriptorRange, - _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pDepthStencilDescriptor); - - void ( STDMETHODCALLTYPE *ClearDepthStencilView )( - ID3D12GraphicsCommandList1 * This, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView, - _In_ D3D12_CLEAR_FLAGS ClearFlags, - _In_ FLOAT Depth, - _In_ UINT8 Stencil, - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); - - void ( STDMETHODCALLTYPE *ClearRenderTargetView )( - ID3D12GraphicsCommandList1 * This, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView, - _In_ const FLOAT ColorRGBA[ 4 ], - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); - - void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewUint )( - ID3D12GraphicsCommandList1 * This, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, - _In_ ID3D12Resource *pResource, - _In_ const UINT Values[ 4 ], - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); - - void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewFloat )( - ID3D12GraphicsCommandList1 * This, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, - _In_ ID3D12Resource *pResource, - _In_ const FLOAT Values[ 4 ], - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); - - void ( STDMETHODCALLTYPE *DiscardResource )( - ID3D12GraphicsCommandList1 * This, - _In_ ID3D12Resource *pResource, - _In_opt_ const D3D12_DISCARD_REGION *pRegion); - - void ( STDMETHODCALLTYPE *BeginQuery )( - ID3D12GraphicsCommandList1 * This, - _In_ ID3D12QueryHeap *pQueryHeap, - _In_ D3D12_QUERY_TYPE Type, - _In_ UINT Index); - - void ( STDMETHODCALLTYPE *EndQuery )( - ID3D12GraphicsCommandList1 * This, - _In_ ID3D12QueryHeap *pQueryHeap, - _In_ D3D12_QUERY_TYPE Type, - _In_ UINT Index); - - void ( STDMETHODCALLTYPE *ResolveQueryData )( - ID3D12GraphicsCommandList1 * This, - _In_ ID3D12QueryHeap *pQueryHeap, - _In_ D3D12_QUERY_TYPE Type, - _In_ UINT StartIndex, - _In_ UINT NumQueries, - _In_ ID3D12Resource *pDestinationBuffer, - _In_ UINT64 AlignedDestinationBufferOffset); - - void ( STDMETHODCALLTYPE *SetPredication )( - ID3D12GraphicsCommandList1 * This, - _In_opt_ ID3D12Resource *pBuffer, - _In_ UINT64 AlignedBufferOffset, - _In_ D3D12_PREDICATION_OP Operation); - - void ( STDMETHODCALLTYPE *SetMarker )( - ID3D12GraphicsCommandList1 * This, - UINT Metadata, - _In_reads_bytes_opt_(Size) const void *pData, - UINT Size); - - void ( STDMETHODCALLTYPE *BeginEvent )( - ID3D12GraphicsCommandList1 * This, - UINT Metadata, - _In_reads_bytes_opt_(Size) const void *pData, - UINT Size); - - void ( STDMETHODCALLTYPE *EndEvent )( - ID3D12GraphicsCommandList1 * This); - - void ( STDMETHODCALLTYPE *ExecuteIndirect )( - ID3D12GraphicsCommandList1 * This, - _In_ ID3D12CommandSignature *pCommandSignature, - _In_ UINT MaxCommandCount, - _In_ ID3D12Resource *pArgumentBuffer, - _In_ UINT64 ArgumentBufferOffset, - _In_opt_ ID3D12Resource *pCountBuffer, - _In_ UINT64 CountBufferOffset); - - void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT )( - ID3D12GraphicsCommandList1 * This, - _In_ ID3D12Resource *pDstBuffer, - UINT64 DstOffset, - _In_ ID3D12Resource *pSrcBuffer, - UINT64 SrcOffset, - UINT Dependencies, - _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, - _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); - - void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT64 )( - ID3D12GraphicsCommandList1 * This, - _In_ ID3D12Resource *pDstBuffer, - UINT64 DstOffset, - _In_ ID3D12Resource *pSrcBuffer, - UINT64 SrcOffset, - UINT Dependencies, - _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, - _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); - - void ( STDMETHODCALLTYPE *OMSetDepthBounds )( - ID3D12GraphicsCommandList1 * This, - _In_ FLOAT Min, - _In_ FLOAT Max); - - void ( STDMETHODCALLTYPE *SetSamplePositions )( - ID3D12GraphicsCommandList1 * This, - _In_ UINT NumSamplesPerPixel, - _In_ UINT NumPixels, - _In_reads_(NumSamplesPerPixel*NumPixels) D3D12_SAMPLE_POSITION *pSamplePositions); - - void ( STDMETHODCALLTYPE *ResolveSubresourceRegion )( - ID3D12GraphicsCommandList1 * This, - _In_ ID3D12Resource *pDstResource, - _In_ UINT DstSubresource, - _In_ UINT DstX, - _In_ UINT DstY, - _In_ ID3D12Resource *pSrcResource, - _In_ UINT SrcSubresource, - _In_opt_ D3D12_RECT *pSrcRect, - _In_ DXGI_FORMAT Format, - _In_ D3D12_RESOLVE_MODE ResolveMode); - - void ( STDMETHODCALLTYPE *SetViewInstanceMask )( - ID3D12GraphicsCommandList1 * This, - _In_ UINT Mask); - - END_INTERFACE - } ID3D12GraphicsCommandList1Vtbl; - - interface ID3D12GraphicsCommandList1 - { - CONST_VTBL struct ID3D12GraphicsCommandList1Vtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12GraphicsCommandList1_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12GraphicsCommandList1_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12GraphicsCommandList1_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12GraphicsCommandList1_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12GraphicsCommandList1_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12GraphicsCommandList1_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12GraphicsCommandList1_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12GraphicsCommandList1_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - - -#define ID3D12GraphicsCommandList1_GetType(This) \ - ( (This)->lpVtbl -> GetType(This) ) - - -#define ID3D12GraphicsCommandList1_Close(This) \ - ( (This)->lpVtbl -> Close(This) ) - -#define ID3D12GraphicsCommandList1_Reset(This,pAllocator,pInitialState) \ - ( (This)->lpVtbl -> Reset(This,pAllocator,pInitialState) ) - -#define ID3D12GraphicsCommandList1_ClearState(This,pPipelineState) \ - ( (This)->lpVtbl -> ClearState(This,pPipelineState) ) - -#define ID3D12GraphicsCommandList1_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) \ - ( (This)->lpVtbl -> DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) ) - -#define ID3D12GraphicsCommandList1_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) \ - ( (This)->lpVtbl -> DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) ) - -#define ID3D12GraphicsCommandList1_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ - ( (This)->lpVtbl -> Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) - -#define ID3D12GraphicsCommandList1_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) \ - ( (This)->lpVtbl -> CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) ) - -#define ID3D12GraphicsCommandList1_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) \ - ( (This)->lpVtbl -> CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) ) - -#define ID3D12GraphicsCommandList1_CopyResource(This,pDstResource,pSrcResource) \ - ( (This)->lpVtbl -> CopyResource(This,pDstResource,pSrcResource) ) - -#define ID3D12GraphicsCommandList1_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) \ - ( (This)->lpVtbl -> CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) ) - -#define ID3D12GraphicsCommandList1_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) \ - ( (This)->lpVtbl -> ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) ) - -#define ID3D12GraphicsCommandList1_IASetPrimitiveTopology(This,PrimitiveTopology) \ - ( (This)->lpVtbl -> IASetPrimitiveTopology(This,PrimitiveTopology) ) - -#define ID3D12GraphicsCommandList1_RSSetViewports(This,NumViewports,pViewports) \ - ( (This)->lpVtbl -> RSSetViewports(This,NumViewports,pViewports) ) - -#define ID3D12GraphicsCommandList1_RSSetScissorRects(This,NumRects,pRects) \ - ( (This)->lpVtbl -> RSSetScissorRects(This,NumRects,pRects) ) - -#define ID3D12GraphicsCommandList1_OMSetBlendFactor(This,BlendFactor) \ - ( (This)->lpVtbl -> OMSetBlendFactor(This,BlendFactor) ) - -#define ID3D12GraphicsCommandList1_OMSetStencilRef(This,StencilRef) \ - ( (This)->lpVtbl -> OMSetStencilRef(This,StencilRef) ) - -#define ID3D12GraphicsCommandList1_SetPipelineState(This,pPipelineState) \ - ( (This)->lpVtbl -> SetPipelineState(This,pPipelineState) ) - -#define ID3D12GraphicsCommandList1_ResourceBarrier(This,NumBarriers,pBarriers) \ - ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) - -#define ID3D12GraphicsCommandList1_ExecuteBundle(This,pCommandList) \ - ( (This)->lpVtbl -> ExecuteBundle(This,pCommandList) ) - -#define ID3D12GraphicsCommandList1_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) \ - ( (This)->lpVtbl -> SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) ) - -#define ID3D12GraphicsCommandList1_SetComputeRootSignature(This,pRootSignature) \ - ( (This)->lpVtbl -> SetComputeRootSignature(This,pRootSignature) ) - -#define ID3D12GraphicsCommandList1_SetGraphicsRootSignature(This,pRootSignature) \ - ( (This)->lpVtbl -> SetGraphicsRootSignature(This,pRootSignature) ) - -#define ID3D12GraphicsCommandList1_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ - ( (This)->lpVtbl -> SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) - -#define ID3D12GraphicsCommandList1_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ - ( (This)->lpVtbl -> SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) - -#define ID3D12GraphicsCommandList1_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) - -#define ID3D12GraphicsCommandList1_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) - -#define ID3D12GraphicsCommandList1_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) - -#define ID3D12GraphicsCommandList1_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) - -#define ID3D12GraphicsCommandList1_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList1_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList1_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList1_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList1_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList1_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList1_IASetIndexBuffer(This,pView) \ - ( (This)->lpVtbl -> IASetIndexBuffer(This,pView) ) - -#define ID3D12GraphicsCommandList1_IASetVertexBuffers(This,StartSlot,NumViews,pViews) \ - ( (This)->lpVtbl -> IASetVertexBuffers(This,StartSlot,NumViews,pViews) ) - -#define ID3D12GraphicsCommandList1_SOSetTargets(This,StartSlot,NumViews,pViews) \ - ( (This)->lpVtbl -> SOSetTargets(This,StartSlot,NumViews,pViews) ) - -#define ID3D12GraphicsCommandList1_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) \ - ( (This)->lpVtbl -> OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) ) - -#define ID3D12GraphicsCommandList1_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) ) - -#define ID3D12GraphicsCommandList1_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) ) - -#define ID3D12GraphicsCommandList1_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) - -#define ID3D12GraphicsCommandList1_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) - -#define ID3D12GraphicsCommandList1_DiscardResource(This,pResource,pRegion) \ - ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) - -#define ID3D12GraphicsCommandList1_BeginQuery(This,pQueryHeap,Type,Index) \ - ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) - -#define ID3D12GraphicsCommandList1_EndQuery(This,pQueryHeap,Type,Index) \ - ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) - -#define ID3D12GraphicsCommandList1_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) \ - ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) - -#define ID3D12GraphicsCommandList1_SetPredication(This,pBuffer,AlignedBufferOffset,Operation) \ - ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) - -#define ID3D12GraphicsCommandList1_SetMarker(This,Metadata,pData,Size) \ - ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) - -#define ID3D12GraphicsCommandList1_BeginEvent(This,Metadata,pData,Size) \ - ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) - -#define ID3D12GraphicsCommandList1_EndEvent(This) \ - ( (This)->lpVtbl -> EndEvent(This) ) - -#define ID3D12GraphicsCommandList1_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) \ - ( (This)->lpVtbl -> ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) ) - - -#define ID3D12GraphicsCommandList1_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ - ( (This)->lpVtbl -> AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) - -#define ID3D12GraphicsCommandList1_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ - ( (This)->lpVtbl -> AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) - -#define ID3D12GraphicsCommandList1_OMSetDepthBounds(This,Min,Max) \ - ( (This)->lpVtbl -> OMSetDepthBounds(This,Min,Max) ) - -#define ID3D12GraphicsCommandList1_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) \ - ( (This)->lpVtbl -> SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) ) - -#define ID3D12GraphicsCommandList1_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) \ - ( (This)->lpVtbl -> ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) ) - -#define ID3D12GraphicsCommandList1_SetViewInstanceMask(This,Mask) \ - ( (This)->lpVtbl -> SetViewInstanceMask(This,Mask) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12GraphicsCommandList1_INTERFACE_DEFINED__ */ - - -/* interface __MIDL_itf_d3d12_0000_0018 */ -/* [local] */ - -typedef struct D3D12_WRITEBUFFERIMMEDIATE_PARAMETER - { - D3D12_GPU_VIRTUAL_ADDRESS Dest; - UINT32 Value; - } D3D12_WRITEBUFFERIMMEDIATE_PARAMETER; - -typedef -enum D3D12_WRITEBUFFERIMMEDIATE_MODE - { - D3D12_WRITEBUFFERIMMEDIATE_MODE_DEFAULT = 0, - D3D12_WRITEBUFFERIMMEDIATE_MODE_MARKER_IN = 0x1, - D3D12_WRITEBUFFERIMMEDIATE_MODE_MARKER_OUT = 0x2 - } D3D12_WRITEBUFFERIMMEDIATE_MODE; - - - -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0018_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0018_v0_0_s_ifspec; - -#ifndef __ID3D12GraphicsCommandList2_INTERFACE_DEFINED__ -#define __ID3D12GraphicsCommandList2_INTERFACE_DEFINED__ - -/* interface ID3D12GraphicsCommandList2 */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12GraphicsCommandList2; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("38C3E585-FF17-412C-9150-4FC6F9D72A28") - ID3D12GraphicsCommandList2 : public ID3D12GraphicsCommandList1 - { - public: - virtual void STDMETHODCALLTYPE WriteBufferImmediate( - UINT Count, - _In_reads_(Count) const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams, - _In_reads_opt_(Count) const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12GraphicsCommandList2Vtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12GraphicsCommandList2 * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12GraphicsCommandList2 * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12GraphicsCommandList2 * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12GraphicsCommandList2 * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12GraphicsCommandList2 * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12GraphicsCommandList2 * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12GraphicsCommandList2 * This, - _In_z_ LPCWSTR Name); - - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12GraphicsCommandList2 * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( - ID3D12GraphicsCommandList2 * This); - - HRESULT ( STDMETHODCALLTYPE *Close )( - ID3D12GraphicsCommandList2 * This); - - HRESULT ( STDMETHODCALLTYPE *Reset )( - ID3D12GraphicsCommandList2 * This, - _In_ ID3D12CommandAllocator *pAllocator, - _In_opt_ ID3D12PipelineState *pInitialState); - - void ( STDMETHODCALLTYPE *ClearState )( - ID3D12GraphicsCommandList2 * This, - _In_opt_ ID3D12PipelineState *pPipelineState); - - void ( STDMETHODCALLTYPE *DrawInstanced )( - ID3D12GraphicsCommandList2 * This, - _In_ UINT VertexCountPerInstance, - _In_ UINT InstanceCount, - _In_ UINT StartVertexLocation, - _In_ UINT StartInstanceLocation); - - void ( STDMETHODCALLTYPE *DrawIndexedInstanced )( - ID3D12GraphicsCommandList2 * This, - _In_ UINT IndexCountPerInstance, - _In_ UINT InstanceCount, - _In_ UINT StartIndexLocation, - _In_ INT BaseVertexLocation, - _In_ UINT StartInstanceLocation); - - void ( STDMETHODCALLTYPE *Dispatch )( - ID3D12GraphicsCommandList2 * This, - _In_ UINT ThreadGroupCountX, - _In_ UINT ThreadGroupCountY, - _In_ UINT ThreadGroupCountZ); - - void ( STDMETHODCALLTYPE *CopyBufferRegion )( - ID3D12GraphicsCommandList2 * This, - _In_ ID3D12Resource *pDstBuffer, - UINT64 DstOffset, - _In_ ID3D12Resource *pSrcBuffer, - UINT64 SrcOffset, - UINT64 NumBytes); - - void ( STDMETHODCALLTYPE *CopyTextureRegion )( - ID3D12GraphicsCommandList2 * This, - _In_ const D3D12_TEXTURE_COPY_LOCATION *pDst, - UINT DstX, - UINT DstY, - UINT DstZ, - _In_ const D3D12_TEXTURE_COPY_LOCATION *pSrc, - _In_opt_ const D3D12_BOX *pSrcBox); - - void ( STDMETHODCALLTYPE *CopyResource )( - ID3D12GraphicsCommandList2 * This, - _In_ ID3D12Resource *pDstResource, - _In_ ID3D12Resource *pSrcResource); - - void ( STDMETHODCALLTYPE *CopyTiles )( - ID3D12GraphicsCommandList2 * This, - _In_ ID3D12Resource *pTiledResource, - _In_ const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate, - _In_ const D3D12_TILE_REGION_SIZE *pTileRegionSize, - _In_ ID3D12Resource *pBuffer, - UINT64 BufferStartOffsetInBytes, - D3D12_TILE_COPY_FLAGS Flags); - - void ( STDMETHODCALLTYPE *ResolveSubresource )( - ID3D12GraphicsCommandList2 * This, - _In_ ID3D12Resource *pDstResource, - _In_ UINT DstSubresource, - _In_ ID3D12Resource *pSrcResource, - _In_ UINT SrcSubresource, - _In_ DXGI_FORMAT Format); - - void ( STDMETHODCALLTYPE *IASetPrimitiveTopology )( - ID3D12GraphicsCommandList2 * This, - _In_ D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology); - - void ( STDMETHODCALLTYPE *RSSetViewports )( - ID3D12GraphicsCommandList2 * This, - _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumViewports, - _In_reads_( NumViewports) const D3D12_VIEWPORT *pViewports); - - void ( STDMETHODCALLTYPE *RSSetScissorRects )( - ID3D12GraphicsCommandList2 * This, - _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumRects, - _In_reads_( NumRects) const D3D12_RECT *pRects); - - void ( STDMETHODCALLTYPE *OMSetBlendFactor )( - ID3D12GraphicsCommandList2 * This, - _In_reads_opt_(4) const FLOAT BlendFactor[ 4 ]); - - void ( STDMETHODCALLTYPE *OMSetStencilRef )( - ID3D12GraphicsCommandList2 * This, - _In_ UINT StencilRef); - - void ( STDMETHODCALLTYPE *SetPipelineState )( - ID3D12GraphicsCommandList2 * This, - _In_ ID3D12PipelineState *pPipelineState); - - void ( STDMETHODCALLTYPE *ResourceBarrier )( - ID3D12GraphicsCommandList2 * This, - _In_ UINT NumBarriers, - _In_reads_(NumBarriers) const D3D12_RESOURCE_BARRIER *pBarriers); - - void ( STDMETHODCALLTYPE *ExecuteBundle )( - ID3D12GraphicsCommandList2 * This, - _In_ ID3D12GraphicsCommandList *pCommandList); - - void ( STDMETHODCALLTYPE *SetDescriptorHeaps )( - ID3D12GraphicsCommandList2 * This, - _In_ UINT NumDescriptorHeaps, - _In_reads_(NumDescriptorHeaps) ID3D12DescriptorHeap *const *ppDescriptorHeaps); - - void ( STDMETHODCALLTYPE *SetComputeRootSignature )( - ID3D12GraphicsCommandList2 * This, - _In_opt_ ID3D12RootSignature *pRootSignature); - - void ( STDMETHODCALLTYPE *SetGraphicsRootSignature )( - ID3D12GraphicsCommandList2 * This, - _In_opt_ ID3D12RootSignature *pRootSignature); - - void ( STDMETHODCALLTYPE *SetComputeRootDescriptorTable )( - ID3D12GraphicsCommandList2 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); - - void ( STDMETHODCALLTYPE *SetGraphicsRootDescriptorTable )( - ID3D12GraphicsCommandList2 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); - - void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstant )( - ID3D12GraphicsCommandList2 * This, - _In_ UINT RootParameterIndex, - _In_ UINT SrcData, - _In_ UINT DestOffsetIn32BitValues); - - void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstant )( - ID3D12GraphicsCommandList2 * This, - _In_ UINT RootParameterIndex, - _In_ UINT SrcData, - _In_ UINT DestOffsetIn32BitValues); - - void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstants )( - ID3D12GraphicsCommandList2 * This, - _In_ UINT RootParameterIndex, - _In_ UINT Num32BitValuesToSet, - _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, - _In_ UINT DestOffsetIn32BitValues); - - void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstants )( - ID3D12GraphicsCommandList2 * This, - _In_ UINT RootParameterIndex, - _In_ UINT Num32BitValuesToSet, - _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, - _In_ UINT DestOffsetIn32BitValues); - - void ( STDMETHODCALLTYPE *SetComputeRootConstantBufferView )( - ID3D12GraphicsCommandList2 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *SetGraphicsRootConstantBufferView )( - ID3D12GraphicsCommandList2 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *SetComputeRootShaderResourceView )( - ID3D12GraphicsCommandList2 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *SetGraphicsRootShaderResourceView )( - ID3D12GraphicsCommandList2 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *SetComputeRootUnorderedAccessView )( - ID3D12GraphicsCommandList2 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *SetGraphicsRootUnorderedAccessView )( - ID3D12GraphicsCommandList2 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *IASetIndexBuffer )( - ID3D12GraphicsCommandList2 * This, - _In_opt_ const D3D12_INDEX_BUFFER_VIEW *pView); - - void ( STDMETHODCALLTYPE *IASetVertexBuffers )( - ID3D12GraphicsCommandList2 * This, - _In_ UINT StartSlot, - _In_ UINT NumViews, - _In_reads_opt_(NumViews) const D3D12_VERTEX_BUFFER_VIEW *pViews); - - void ( STDMETHODCALLTYPE *SOSetTargets )( - ID3D12GraphicsCommandList2 * This, - _In_ UINT StartSlot, - _In_ UINT NumViews, - _In_reads_opt_(NumViews) const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews); - - void ( STDMETHODCALLTYPE *OMSetRenderTargets )( - ID3D12GraphicsCommandList2 * This, - _In_ UINT NumRenderTargetDescriptors, - _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors, - _In_ BOOL RTsSingleHandleToDescriptorRange, - _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pDepthStencilDescriptor); - - void ( STDMETHODCALLTYPE *ClearDepthStencilView )( - ID3D12GraphicsCommandList2 * This, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView, - _In_ D3D12_CLEAR_FLAGS ClearFlags, - _In_ FLOAT Depth, - _In_ UINT8 Stencil, - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); - - void ( STDMETHODCALLTYPE *ClearRenderTargetView )( - ID3D12GraphicsCommandList2 * This, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView, - _In_ const FLOAT ColorRGBA[ 4 ], - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); - - void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewUint )( - ID3D12GraphicsCommandList2 * This, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, - _In_ ID3D12Resource *pResource, - _In_ const UINT Values[ 4 ], - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); - - void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewFloat )( - ID3D12GraphicsCommandList2 * This, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, - _In_ ID3D12Resource *pResource, - _In_ const FLOAT Values[ 4 ], - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); - - void ( STDMETHODCALLTYPE *DiscardResource )( - ID3D12GraphicsCommandList2 * This, - _In_ ID3D12Resource *pResource, - _In_opt_ const D3D12_DISCARD_REGION *pRegion); - - void ( STDMETHODCALLTYPE *BeginQuery )( - ID3D12GraphicsCommandList2 * This, - _In_ ID3D12QueryHeap *pQueryHeap, - _In_ D3D12_QUERY_TYPE Type, - _In_ UINT Index); - - void ( STDMETHODCALLTYPE *EndQuery )( - ID3D12GraphicsCommandList2 * This, - _In_ ID3D12QueryHeap *pQueryHeap, - _In_ D3D12_QUERY_TYPE Type, - _In_ UINT Index); - - void ( STDMETHODCALLTYPE *ResolveQueryData )( - ID3D12GraphicsCommandList2 * This, - _In_ ID3D12QueryHeap *pQueryHeap, - _In_ D3D12_QUERY_TYPE Type, - _In_ UINT StartIndex, - _In_ UINT NumQueries, - _In_ ID3D12Resource *pDestinationBuffer, - _In_ UINT64 AlignedDestinationBufferOffset); - - void ( STDMETHODCALLTYPE *SetPredication )( - ID3D12GraphicsCommandList2 * This, - _In_opt_ ID3D12Resource *pBuffer, - _In_ UINT64 AlignedBufferOffset, - _In_ D3D12_PREDICATION_OP Operation); - - void ( STDMETHODCALLTYPE *SetMarker )( - ID3D12GraphicsCommandList2 * This, - UINT Metadata, - _In_reads_bytes_opt_(Size) const void *pData, - UINT Size); - - void ( STDMETHODCALLTYPE *BeginEvent )( - ID3D12GraphicsCommandList2 * This, - UINT Metadata, - _In_reads_bytes_opt_(Size) const void *pData, - UINT Size); - - void ( STDMETHODCALLTYPE *EndEvent )( - ID3D12GraphicsCommandList2 * This); - - void ( STDMETHODCALLTYPE *ExecuteIndirect )( - ID3D12GraphicsCommandList2 * This, - _In_ ID3D12CommandSignature *pCommandSignature, - _In_ UINT MaxCommandCount, - _In_ ID3D12Resource *pArgumentBuffer, - _In_ UINT64 ArgumentBufferOffset, - _In_opt_ ID3D12Resource *pCountBuffer, - _In_ UINT64 CountBufferOffset); - - void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT )( - ID3D12GraphicsCommandList2 * This, - _In_ ID3D12Resource *pDstBuffer, - UINT64 DstOffset, - _In_ ID3D12Resource *pSrcBuffer, - UINT64 SrcOffset, - UINT Dependencies, - _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, - _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); - - void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT64 )( - ID3D12GraphicsCommandList2 * This, - _In_ ID3D12Resource *pDstBuffer, - UINT64 DstOffset, - _In_ ID3D12Resource *pSrcBuffer, - UINT64 SrcOffset, - UINT Dependencies, - _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, - _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); - - void ( STDMETHODCALLTYPE *OMSetDepthBounds )( - ID3D12GraphicsCommandList2 * This, - _In_ FLOAT Min, - _In_ FLOAT Max); - - void ( STDMETHODCALLTYPE *SetSamplePositions )( - ID3D12GraphicsCommandList2 * This, - _In_ UINT NumSamplesPerPixel, - _In_ UINT NumPixels, - _In_reads_(NumSamplesPerPixel*NumPixels) D3D12_SAMPLE_POSITION *pSamplePositions); - - void ( STDMETHODCALLTYPE *ResolveSubresourceRegion )( - ID3D12GraphicsCommandList2 * This, - _In_ ID3D12Resource *pDstResource, - _In_ UINT DstSubresource, - _In_ UINT DstX, - _In_ UINT DstY, - _In_ ID3D12Resource *pSrcResource, - _In_ UINT SrcSubresource, - _In_opt_ D3D12_RECT *pSrcRect, - _In_ DXGI_FORMAT Format, - _In_ D3D12_RESOLVE_MODE ResolveMode); - - void ( STDMETHODCALLTYPE *SetViewInstanceMask )( - ID3D12GraphicsCommandList2 * This, - _In_ UINT Mask); - - void ( STDMETHODCALLTYPE *WriteBufferImmediate )( - ID3D12GraphicsCommandList2 * This, - UINT Count, - _In_reads_(Count) const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams, - _In_reads_opt_(Count) const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes); - - END_INTERFACE - } ID3D12GraphicsCommandList2Vtbl; - - interface ID3D12GraphicsCommandList2 - { - CONST_VTBL struct ID3D12GraphicsCommandList2Vtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12GraphicsCommandList2_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12GraphicsCommandList2_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12GraphicsCommandList2_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12GraphicsCommandList2_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12GraphicsCommandList2_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12GraphicsCommandList2_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12GraphicsCommandList2_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12GraphicsCommandList2_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - - -#define ID3D12GraphicsCommandList2_GetType(This) \ - ( (This)->lpVtbl -> GetType(This) ) - - -#define ID3D12GraphicsCommandList2_Close(This) \ - ( (This)->lpVtbl -> Close(This) ) - -#define ID3D12GraphicsCommandList2_Reset(This,pAllocator,pInitialState) \ - ( (This)->lpVtbl -> Reset(This,pAllocator,pInitialState) ) - -#define ID3D12GraphicsCommandList2_ClearState(This,pPipelineState) \ - ( (This)->lpVtbl -> ClearState(This,pPipelineState) ) - -#define ID3D12GraphicsCommandList2_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) \ - ( (This)->lpVtbl -> DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) ) - -#define ID3D12GraphicsCommandList2_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) \ - ( (This)->lpVtbl -> DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) ) - -#define ID3D12GraphicsCommandList2_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ - ( (This)->lpVtbl -> Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) - -#define ID3D12GraphicsCommandList2_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) \ - ( (This)->lpVtbl -> CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) ) - -#define ID3D12GraphicsCommandList2_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) \ - ( (This)->lpVtbl -> CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) ) - -#define ID3D12GraphicsCommandList2_CopyResource(This,pDstResource,pSrcResource) \ - ( (This)->lpVtbl -> CopyResource(This,pDstResource,pSrcResource) ) - -#define ID3D12GraphicsCommandList2_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) \ - ( (This)->lpVtbl -> CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) ) - -#define ID3D12GraphicsCommandList2_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) \ - ( (This)->lpVtbl -> ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) ) - -#define ID3D12GraphicsCommandList2_IASetPrimitiveTopology(This,PrimitiveTopology) \ - ( (This)->lpVtbl -> IASetPrimitiveTopology(This,PrimitiveTopology) ) - -#define ID3D12GraphicsCommandList2_RSSetViewports(This,NumViewports,pViewports) \ - ( (This)->lpVtbl -> RSSetViewports(This,NumViewports,pViewports) ) - -#define ID3D12GraphicsCommandList2_RSSetScissorRects(This,NumRects,pRects) \ - ( (This)->lpVtbl -> RSSetScissorRects(This,NumRects,pRects) ) - -#define ID3D12GraphicsCommandList2_OMSetBlendFactor(This,BlendFactor) \ - ( (This)->lpVtbl -> OMSetBlendFactor(This,BlendFactor) ) - -#define ID3D12GraphicsCommandList2_OMSetStencilRef(This,StencilRef) \ - ( (This)->lpVtbl -> OMSetStencilRef(This,StencilRef) ) - -#define ID3D12GraphicsCommandList2_SetPipelineState(This,pPipelineState) \ - ( (This)->lpVtbl -> SetPipelineState(This,pPipelineState) ) - -#define ID3D12GraphicsCommandList2_ResourceBarrier(This,NumBarriers,pBarriers) \ - ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) - -#define ID3D12GraphicsCommandList2_ExecuteBundle(This,pCommandList) \ - ( (This)->lpVtbl -> ExecuteBundle(This,pCommandList) ) - -#define ID3D12GraphicsCommandList2_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) \ - ( (This)->lpVtbl -> SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) ) - -#define ID3D12GraphicsCommandList2_SetComputeRootSignature(This,pRootSignature) \ - ( (This)->lpVtbl -> SetComputeRootSignature(This,pRootSignature) ) - -#define ID3D12GraphicsCommandList2_SetGraphicsRootSignature(This,pRootSignature) \ - ( (This)->lpVtbl -> SetGraphicsRootSignature(This,pRootSignature) ) - -#define ID3D12GraphicsCommandList2_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ - ( (This)->lpVtbl -> SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) - -#define ID3D12GraphicsCommandList2_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ - ( (This)->lpVtbl -> SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) - -#define ID3D12GraphicsCommandList2_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) - -#define ID3D12GraphicsCommandList2_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) - -#define ID3D12GraphicsCommandList2_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) - -#define ID3D12GraphicsCommandList2_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) - -#define ID3D12GraphicsCommandList2_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList2_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList2_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList2_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList2_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList2_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList2_IASetIndexBuffer(This,pView) \ - ( (This)->lpVtbl -> IASetIndexBuffer(This,pView) ) - -#define ID3D12GraphicsCommandList2_IASetVertexBuffers(This,StartSlot,NumViews,pViews) \ - ( (This)->lpVtbl -> IASetVertexBuffers(This,StartSlot,NumViews,pViews) ) - -#define ID3D12GraphicsCommandList2_SOSetTargets(This,StartSlot,NumViews,pViews) \ - ( (This)->lpVtbl -> SOSetTargets(This,StartSlot,NumViews,pViews) ) - -#define ID3D12GraphicsCommandList2_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) \ - ( (This)->lpVtbl -> OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) ) - -#define ID3D12GraphicsCommandList2_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) ) - -#define ID3D12GraphicsCommandList2_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) ) - -#define ID3D12GraphicsCommandList2_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) - -#define ID3D12GraphicsCommandList2_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) - -#define ID3D12GraphicsCommandList2_DiscardResource(This,pResource,pRegion) \ - ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) - -#define ID3D12GraphicsCommandList2_BeginQuery(This,pQueryHeap,Type,Index) \ - ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) - -#define ID3D12GraphicsCommandList2_EndQuery(This,pQueryHeap,Type,Index) \ - ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) - -#define ID3D12GraphicsCommandList2_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) \ - ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) - -#define ID3D12GraphicsCommandList2_SetPredication(This,pBuffer,AlignedBufferOffset,Operation) \ - ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) - -#define ID3D12GraphicsCommandList2_SetMarker(This,Metadata,pData,Size) \ - ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) - -#define ID3D12GraphicsCommandList2_BeginEvent(This,Metadata,pData,Size) \ - ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) - -#define ID3D12GraphicsCommandList2_EndEvent(This) \ - ( (This)->lpVtbl -> EndEvent(This) ) - -#define ID3D12GraphicsCommandList2_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) \ - ( (This)->lpVtbl -> ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) ) - - -#define ID3D12GraphicsCommandList2_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ - ( (This)->lpVtbl -> AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) - -#define ID3D12GraphicsCommandList2_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ - ( (This)->lpVtbl -> AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) - -#define ID3D12GraphicsCommandList2_OMSetDepthBounds(This,Min,Max) \ - ( (This)->lpVtbl -> OMSetDepthBounds(This,Min,Max) ) - -#define ID3D12GraphicsCommandList2_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) \ - ( (This)->lpVtbl -> SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) ) - -#define ID3D12GraphicsCommandList2_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) \ - ( (This)->lpVtbl -> ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) ) - -#define ID3D12GraphicsCommandList2_SetViewInstanceMask(This,Mask) \ - ( (This)->lpVtbl -> SetViewInstanceMask(This,Mask) ) - - -#define ID3D12GraphicsCommandList2_WriteBufferImmediate(This,Count,pParams,pModes) \ - ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12GraphicsCommandList2_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12CommandQueue_INTERFACE_DEFINED__ -#define __ID3D12CommandQueue_INTERFACE_DEFINED__ - -/* interface ID3D12CommandQueue */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12CommandQueue; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("0ec870a6-5d7e-4c22-8cfc-5baae07616ed") - ID3D12CommandQueue : public ID3D12Pageable - { - public: - virtual void STDMETHODCALLTYPE UpdateTileMappings( - _In_ ID3D12Resource *pResource, - UINT NumResourceRegions, - _In_reads_opt_(NumResourceRegions) const D3D12_TILED_RESOURCE_COORDINATE *pResourceRegionStartCoordinates, - _In_reads_opt_(NumResourceRegions) const D3D12_TILE_REGION_SIZE *pResourceRegionSizes, - _In_opt_ ID3D12Heap *pHeap, - UINT NumRanges, - _In_reads_opt_(NumRanges) const D3D12_TILE_RANGE_FLAGS *pRangeFlags, - _In_reads_opt_(NumRanges) const UINT *pHeapRangeStartOffsets, - _In_reads_opt_(NumRanges) const UINT *pRangeTileCounts, - D3D12_TILE_MAPPING_FLAGS Flags) = 0; - - virtual void STDMETHODCALLTYPE CopyTileMappings( - _In_ ID3D12Resource *pDstResource, - _In_ const D3D12_TILED_RESOURCE_COORDINATE *pDstRegionStartCoordinate, - _In_ ID3D12Resource *pSrcResource, - _In_ const D3D12_TILED_RESOURCE_COORDINATE *pSrcRegionStartCoordinate, - _In_ const D3D12_TILE_REGION_SIZE *pRegionSize, - D3D12_TILE_MAPPING_FLAGS Flags) = 0; - - virtual void STDMETHODCALLTYPE ExecuteCommandLists( - _In_ UINT NumCommandLists, - _In_reads_(NumCommandLists) ID3D12CommandList *const *ppCommandLists) = 0; - - virtual void STDMETHODCALLTYPE SetMarker( - UINT Metadata, - _In_reads_bytes_opt_(Size) const void *pData, - UINT Size) = 0; - - virtual void STDMETHODCALLTYPE BeginEvent( - UINT Metadata, - _In_reads_bytes_opt_(Size) const void *pData, - UINT Size) = 0; - - virtual void STDMETHODCALLTYPE EndEvent( void) = 0; - - virtual HRESULT STDMETHODCALLTYPE Signal( - ID3D12Fence *pFence, - UINT64 Value) = 0; - - virtual HRESULT STDMETHODCALLTYPE Wait( - ID3D12Fence *pFence, - UINT64 Value) = 0; - - virtual HRESULT STDMETHODCALLTYPE GetTimestampFrequency( - _Out_ UINT64 *pFrequency) = 0; - - virtual HRESULT STDMETHODCALLTYPE GetClockCalibration( - _Out_ UINT64 *pGpuTimestamp, - _Out_ UINT64 *pCpuTimestamp) = 0; - - virtual D3D12_COMMAND_QUEUE_DESC STDMETHODCALLTYPE GetDesc( void) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12CommandQueueVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12CommandQueue * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12CommandQueue * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12CommandQueue * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12CommandQueue * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12CommandQueue * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12CommandQueue * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12CommandQueue * This, - _In_z_ LPCWSTR Name); - - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12CommandQueue * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - void ( STDMETHODCALLTYPE *UpdateTileMappings )( - ID3D12CommandQueue * This, - _In_ ID3D12Resource *pResource, - UINT NumResourceRegions, - _In_reads_opt_(NumResourceRegions) const D3D12_TILED_RESOURCE_COORDINATE *pResourceRegionStartCoordinates, - _In_reads_opt_(NumResourceRegions) const D3D12_TILE_REGION_SIZE *pResourceRegionSizes, - _In_opt_ ID3D12Heap *pHeap, - UINT NumRanges, - _In_reads_opt_(NumRanges) const D3D12_TILE_RANGE_FLAGS *pRangeFlags, - _In_reads_opt_(NumRanges) const UINT *pHeapRangeStartOffsets, - _In_reads_opt_(NumRanges) const UINT *pRangeTileCounts, - D3D12_TILE_MAPPING_FLAGS Flags); - - void ( STDMETHODCALLTYPE *CopyTileMappings )( - ID3D12CommandQueue * This, - _In_ ID3D12Resource *pDstResource, - _In_ const D3D12_TILED_RESOURCE_COORDINATE *pDstRegionStartCoordinate, - _In_ ID3D12Resource *pSrcResource, - _In_ const D3D12_TILED_RESOURCE_COORDINATE *pSrcRegionStartCoordinate, - _In_ const D3D12_TILE_REGION_SIZE *pRegionSize, - D3D12_TILE_MAPPING_FLAGS Flags); - - void ( STDMETHODCALLTYPE *ExecuteCommandLists )( - ID3D12CommandQueue * This, - _In_ UINT NumCommandLists, - _In_reads_(NumCommandLists) ID3D12CommandList *const *ppCommandLists); - - void ( STDMETHODCALLTYPE *SetMarker )( - ID3D12CommandQueue * This, - UINT Metadata, - _In_reads_bytes_opt_(Size) const void *pData, - UINT Size); - - void ( STDMETHODCALLTYPE *BeginEvent )( - ID3D12CommandQueue * This, - UINT Metadata, - _In_reads_bytes_opt_(Size) const void *pData, - UINT Size); - - void ( STDMETHODCALLTYPE *EndEvent )( - ID3D12CommandQueue * This); - - HRESULT ( STDMETHODCALLTYPE *Signal )( - ID3D12CommandQueue * This, - ID3D12Fence *pFence, - UINT64 Value); - - HRESULT ( STDMETHODCALLTYPE *Wait )( - ID3D12CommandQueue * This, - ID3D12Fence *pFence, - UINT64 Value); - - HRESULT ( STDMETHODCALLTYPE *GetTimestampFrequency )( - ID3D12CommandQueue * This, - _Out_ UINT64 *pFrequency); - - HRESULT ( STDMETHODCALLTYPE *GetClockCalibration )( - ID3D12CommandQueue * This, - _Out_ UINT64 *pGpuTimestamp, - _Out_ UINT64 *pCpuTimestamp); - - D3D12_COMMAND_QUEUE_DESC ( STDMETHODCALLTYPE *GetDesc )( - ID3D12CommandQueue * This); - - END_INTERFACE - } ID3D12CommandQueueVtbl; - - interface ID3D12CommandQueue - { - CONST_VTBL struct ID3D12CommandQueueVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12CommandQueue_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12CommandQueue_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12CommandQueue_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12CommandQueue_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12CommandQueue_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12CommandQueue_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12CommandQueue_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12CommandQueue_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - - - -#define ID3D12CommandQueue_UpdateTileMappings(This,pResource,NumResourceRegions,pResourceRegionStartCoordinates,pResourceRegionSizes,pHeap,NumRanges,pRangeFlags,pHeapRangeStartOffsets,pRangeTileCounts,Flags) \ - ( (This)->lpVtbl -> UpdateTileMappings(This,pResource,NumResourceRegions,pResourceRegionStartCoordinates,pResourceRegionSizes,pHeap,NumRanges,pRangeFlags,pHeapRangeStartOffsets,pRangeTileCounts,Flags) ) - -#define ID3D12CommandQueue_CopyTileMappings(This,pDstResource,pDstRegionStartCoordinate,pSrcResource,pSrcRegionStartCoordinate,pRegionSize,Flags) \ - ( (This)->lpVtbl -> CopyTileMappings(This,pDstResource,pDstRegionStartCoordinate,pSrcResource,pSrcRegionStartCoordinate,pRegionSize,Flags) ) - -#define ID3D12CommandQueue_ExecuteCommandLists(This,NumCommandLists,ppCommandLists) \ - ( (This)->lpVtbl -> ExecuteCommandLists(This,NumCommandLists,ppCommandLists) ) - -#define ID3D12CommandQueue_SetMarker(This,Metadata,pData,Size) \ - ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) - -#define ID3D12CommandQueue_BeginEvent(This,Metadata,pData,Size) \ - ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) - -#define ID3D12CommandQueue_EndEvent(This) \ - ( (This)->lpVtbl -> EndEvent(This) ) - -#define ID3D12CommandQueue_Signal(This,pFence,Value) \ - ( (This)->lpVtbl -> Signal(This,pFence,Value) ) - -#define ID3D12CommandQueue_Wait(This,pFence,Value) \ - ( (This)->lpVtbl -> Wait(This,pFence,Value) ) - -#define ID3D12CommandQueue_GetTimestampFrequency(This,pFrequency) \ - ( (This)->lpVtbl -> GetTimestampFrequency(This,pFrequency) ) - -#define ID3D12CommandQueue_GetClockCalibration(This,pGpuTimestamp,pCpuTimestamp) \ - ( (This)->lpVtbl -> GetClockCalibration(This,pGpuTimestamp,pCpuTimestamp) ) - -#define ID3D12CommandQueue_GetDesc(This) \ - ( (This)->lpVtbl -> GetDesc(This) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - - - - - -#endif /* __ID3D12CommandQueue_INTERFACE_DEFINED__ */ - - -/* interface __MIDL_itf_d3d12_0000_0020 */ -/* [local] */ - -#ifdef __midl -#ifndef LUID_DEFINED -#define LUID_DEFINED 1 -typedef struct __LUID - { - DWORD LowPart; - LONG HighPart; - } LUID; - -typedef struct __LUID *PLUID; - -#endif -#endif - - -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0020_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0020_v0_0_s_ifspec; - -#ifndef __ID3D12Device_INTERFACE_DEFINED__ -#define __ID3D12Device_INTERFACE_DEFINED__ - -/* interface ID3D12Device */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12Device; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("189819f1-1db6-4b57-be54-1821339b85f7") - ID3D12Device : public ID3D12Object - { - public: - virtual UINT STDMETHODCALLTYPE GetNodeCount( void) = 0; - - virtual HRESULT STDMETHODCALLTYPE CreateCommandQueue( - _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppCommandQueue) = 0; - - virtual HRESULT STDMETHODCALLTYPE CreateCommandAllocator( - _In_ D3D12_COMMAND_LIST_TYPE type, - REFIID riid, - _COM_Outptr_ void **ppCommandAllocator) = 0; - - virtual HRESULT STDMETHODCALLTYPE CreateGraphicsPipelineState( - _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState) = 0; - - virtual HRESULT STDMETHODCALLTYPE CreateComputePipelineState( - _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState) = 0; - - virtual HRESULT STDMETHODCALLTYPE CreateCommandList( - _In_ UINT nodeMask, - _In_ D3D12_COMMAND_LIST_TYPE type, - _In_ ID3D12CommandAllocator *pCommandAllocator, - _In_opt_ ID3D12PipelineState *pInitialState, - REFIID riid, - _COM_Outptr_ void **ppCommandList) = 0; - - virtual HRESULT STDMETHODCALLTYPE CheckFeatureSupport( - D3D12_FEATURE Feature, - _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, - UINT FeatureSupportDataSize) = 0; - - virtual HRESULT STDMETHODCALLTYPE CreateDescriptorHeap( - _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, - REFIID riid, - _COM_Outptr_ void **ppvHeap) = 0; - - virtual UINT STDMETHODCALLTYPE GetDescriptorHandleIncrementSize( - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType) = 0; - - virtual HRESULT STDMETHODCALLTYPE CreateRootSignature( - _In_ UINT nodeMask, - _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, - _In_ SIZE_T blobLengthInBytes, - REFIID riid, - _COM_Outptr_ void **ppvRootSignature) = 0; - - virtual void STDMETHODCALLTYPE CreateConstantBufferView( - _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0; - - virtual void STDMETHODCALLTYPE CreateShaderResourceView( - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0; - - virtual void STDMETHODCALLTYPE CreateUnorderedAccessView( - _In_opt_ ID3D12Resource *pResource, - _In_opt_ ID3D12Resource *pCounterResource, - _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0; - - virtual void STDMETHODCALLTYPE CreateRenderTargetView( - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0; - - virtual void STDMETHODCALLTYPE CreateDepthStencilView( - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0; - - virtual void STDMETHODCALLTYPE CreateSampler( - _In_ const D3D12_SAMPLER_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0; - - virtual void STDMETHODCALLTYPE CopyDescriptors( - _In_ UINT NumDestDescriptorRanges, - _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts, - _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes, - _In_ UINT NumSrcDescriptorRanges, - _In_reads_(NumSrcDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts, - _In_reads_opt_(NumSrcDescriptorRanges) const UINT *pSrcDescriptorRangeSizes, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType) = 0; - - virtual void STDMETHODCALLTYPE CopyDescriptorsSimple( - _In_ UINT NumDescriptors, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType) = 0; - - virtual D3D12_RESOURCE_ALLOCATION_INFO STDMETHODCALLTYPE GetResourceAllocationInfo( - _In_ UINT visibleMask, - _In_ UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs) = 0; - - virtual D3D12_HEAP_PROPERTIES STDMETHODCALLTYPE GetCustomHeapProperties( - _In_ UINT nodeMask, - D3D12_HEAP_TYPE heapType) = 0; - - virtual HRESULT STDMETHODCALLTYPE CreateCommittedResource( - _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, - D3D12_HEAP_FLAGS HeapFlags, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialResourceState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riidResource, - _COM_Outptr_opt_ void **ppvResource) = 0; - - virtual HRESULT STDMETHODCALLTYPE CreateHeap( - _In_ const D3D12_HEAP_DESC *pDesc, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap) = 0; - - virtual HRESULT STDMETHODCALLTYPE CreatePlacedResource( - _In_ ID3D12Heap *pHeap, - UINT64 HeapOffset, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource) = 0; - - virtual HRESULT STDMETHODCALLTYPE CreateReservedResource( - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource) = 0; - - virtual HRESULT STDMETHODCALLTYPE CreateSharedHandle( - _In_ ID3D12DeviceChild *pObject, - _In_opt_ const SECURITY_ATTRIBUTES *pAttributes, - DWORD Access, - _In_opt_ LPCWSTR Name, - _Out_ HANDLE *pHandle) = 0; - - virtual HRESULT STDMETHODCALLTYPE OpenSharedHandle( - _In_ HANDLE NTHandle, - REFIID riid, - _COM_Outptr_opt_ void **ppvObj) = 0; - - virtual HRESULT STDMETHODCALLTYPE OpenSharedHandleByName( - _In_ LPCWSTR Name, - DWORD Access, - /* [annotation][out] */ - _Out_ HANDLE *pNTHandle) = 0; - - virtual HRESULT STDMETHODCALLTYPE MakeResident( - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects) = 0; - - virtual HRESULT STDMETHODCALLTYPE Evict( - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects) = 0; - - virtual HRESULT STDMETHODCALLTYPE CreateFence( - UINT64 InitialValue, - D3D12_FENCE_FLAGS Flags, - REFIID riid, - _COM_Outptr_ void **ppFence) = 0; - - virtual HRESULT STDMETHODCALLTYPE GetDeviceRemovedReason( void) = 0; - - virtual void STDMETHODCALLTYPE GetCopyableFootprints( - _In_ const D3D12_RESOURCE_DESC *pResourceDesc, - _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, - _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, - UINT64 BaseOffset, - _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, - _Out_writes_opt_(NumSubresources) UINT *pNumRows, - _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, - _Out_opt_ UINT64 *pTotalBytes) = 0; - - virtual HRESULT STDMETHODCALLTYPE CreateQueryHeap( - _In_ const D3D12_QUERY_HEAP_DESC *pDesc, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap) = 0; - - virtual HRESULT STDMETHODCALLTYPE SetStablePowerState( - BOOL Enable) = 0; - - virtual HRESULT STDMETHODCALLTYPE CreateCommandSignature( - _In_ const D3D12_COMMAND_SIGNATURE_DESC *pDesc, - _In_opt_ ID3D12RootSignature *pRootSignature, - REFIID riid, - _COM_Outptr_opt_ void **ppvCommandSignature) = 0; - - virtual void STDMETHODCALLTYPE GetResourceTiling( - _In_ ID3D12Resource *pTiledResource, - _Out_opt_ UINT *pNumTilesForEntireResource, - _Out_opt_ D3D12_PACKED_MIP_INFO *pPackedMipDesc, - _Out_opt_ D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips, - _Inout_opt_ UINT *pNumSubresourceTilings, - _In_ UINT FirstSubresourceTilingToGet, - _Out_writes_(*pNumSubresourceTilings) D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips) = 0; - - virtual LUID STDMETHODCALLTYPE GetAdapterLuid( void) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12DeviceVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12Device * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12Device * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12Device * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12Device * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12Device * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12Device * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12Device * This, - _In_z_ LPCWSTR Name); - - UINT ( STDMETHODCALLTYPE *GetNodeCount )( - ID3D12Device * This); - - HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( - ID3D12Device * This, - _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppCommandQueue); - - HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( - ID3D12Device * This, - _In_ D3D12_COMMAND_LIST_TYPE type, - REFIID riid, - _COM_Outptr_ void **ppCommandAllocator); - - HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( - ID3D12Device * This, - _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); - - HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( - ID3D12Device * This, - _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); - - HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( - ID3D12Device * This, - _In_ UINT nodeMask, - _In_ D3D12_COMMAND_LIST_TYPE type, - _In_ ID3D12CommandAllocator *pCommandAllocator, - _In_opt_ ID3D12PipelineState *pInitialState, - REFIID riid, - _COM_Outptr_ void **ppCommandList); - - HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( - ID3D12Device * This, - D3D12_FEATURE Feature, - _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, - UINT FeatureSupportDataSize); - - HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( - ID3D12Device * This, - _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, - REFIID riid, - _COM_Outptr_ void **ppvHeap); - - UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( - ID3D12Device * This, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType); - - HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( - ID3D12Device * This, - _In_ UINT nodeMask, - _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, - _In_ SIZE_T blobLengthInBytes, - REFIID riid, - _COM_Outptr_ void **ppvRootSignature); - - void ( STDMETHODCALLTYPE *CreateConstantBufferView )( - ID3D12Device * This, - _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateShaderResourceView )( - ID3D12Device * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( - ID3D12Device * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ ID3D12Resource *pCounterResource, - _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateRenderTargetView )( - ID3D12Device * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateDepthStencilView )( - ID3D12Device * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateSampler )( - ID3D12Device * This, - _In_ const D3D12_SAMPLER_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CopyDescriptors )( - ID3D12Device * This, - _In_ UINT NumDestDescriptorRanges, - _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts, - _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes, - _In_ UINT NumSrcDescriptorRanges, - _In_reads_(NumSrcDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts, - _In_reads_opt_(NumSrcDescriptorRanges) const UINT *pSrcDescriptorRangeSizes, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); - - void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( - ID3D12Device * This, - _In_ UINT NumDescriptors, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); - - D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( - ID3D12Device * This, - _In_ UINT visibleMask, - _In_ UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); - - D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( - ID3D12Device * This, - _In_ UINT nodeMask, - D3D12_HEAP_TYPE heapType); - - HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( - ID3D12Device * This, - _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, - D3D12_HEAP_FLAGS HeapFlags, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialResourceState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riidResource, - _COM_Outptr_opt_ void **ppvResource); - - HRESULT ( STDMETHODCALLTYPE *CreateHeap )( - ID3D12Device * This, - _In_ const D3D12_HEAP_DESC *pDesc, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap); - - HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( - ID3D12Device * This, - _In_ ID3D12Heap *pHeap, - UINT64 HeapOffset, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); - - HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( - ID3D12Device * This, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); - - HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( - ID3D12Device * This, - _In_ ID3D12DeviceChild *pObject, - _In_opt_ const SECURITY_ATTRIBUTES *pAttributes, - DWORD Access, - _In_opt_ LPCWSTR Name, - _Out_ HANDLE *pHandle); - - HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( - ID3D12Device * This, - _In_ HANDLE NTHandle, - REFIID riid, - _COM_Outptr_opt_ void **ppvObj); - - HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( - ID3D12Device * This, - _In_ LPCWSTR Name, - DWORD Access, - /* [annotation][out] */ - _Out_ HANDLE *pNTHandle); - - HRESULT ( STDMETHODCALLTYPE *MakeResident )( - ID3D12Device * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); - - HRESULT ( STDMETHODCALLTYPE *Evict )( - ID3D12Device * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); - - HRESULT ( STDMETHODCALLTYPE *CreateFence )( - ID3D12Device * This, - UINT64 InitialValue, - D3D12_FENCE_FLAGS Flags, - REFIID riid, - _COM_Outptr_ void **ppFence); - - HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( - ID3D12Device * This); - - void ( STDMETHODCALLTYPE *GetCopyableFootprints )( - ID3D12Device * This, - _In_ const D3D12_RESOURCE_DESC *pResourceDesc, - _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, - _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, - UINT64 BaseOffset, - _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, - _Out_writes_opt_(NumSubresources) UINT *pNumRows, - _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, - _Out_opt_ UINT64 *pTotalBytes); - - HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( - ID3D12Device * This, - _In_ const D3D12_QUERY_HEAP_DESC *pDesc, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap); - - HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( - ID3D12Device * This, - BOOL Enable); - - HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( - ID3D12Device * This, - _In_ const D3D12_COMMAND_SIGNATURE_DESC *pDesc, - _In_opt_ ID3D12RootSignature *pRootSignature, - REFIID riid, - _COM_Outptr_opt_ void **ppvCommandSignature); - - void ( STDMETHODCALLTYPE *GetResourceTiling )( - ID3D12Device * This, - _In_ ID3D12Resource *pTiledResource, - _Out_opt_ UINT *pNumTilesForEntireResource, - _Out_opt_ D3D12_PACKED_MIP_INFO *pPackedMipDesc, - _Out_opt_ D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips, - _Inout_opt_ UINT *pNumSubresourceTilings, - _In_ UINT FirstSubresourceTilingToGet, - _Out_writes_(*pNumSubresourceTilings) D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips); - - LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( - ID3D12Device * This); - - END_INTERFACE - } ID3D12DeviceVtbl; - - interface ID3D12Device - { - CONST_VTBL struct ID3D12DeviceVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12Device_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12Device_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12Device_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12Device_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12Device_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12Device_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12Device_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12Device_GetNodeCount(This) \ - ( (This)->lpVtbl -> GetNodeCount(This) ) - -#define ID3D12Device_CreateCommandQueue(This,pDesc,riid,ppCommandQueue) \ - ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) - -#define ID3D12Device_CreateCommandAllocator(This,type,riid,ppCommandAllocator) \ - ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) - -#define ID3D12Device_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) - -#define ID3D12Device_CreateComputePipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) - -#define ID3D12Device_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) \ - ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) - -#define ID3D12Device_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) \ - ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) - -#define ID3D12Device_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) - -#define ID3D12Device_GetDescriptorHandleIncrementSize(This,DescriptorHeapType) \ - ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) - -#define ID3D12Device_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) \ - ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) - -#define ID3D12Device_CreateConstantBufferView(This,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) - -#define ID3D12Device_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) - -#define ID3D12Device_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) - -#define ID3D12Device_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) - -#define ID3D12Device_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) - -#define ID3D12Device_CreateSampler(This,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) - -#define ID3D12Device_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) \ - ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) - -#define ID3D12Device_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) \ - ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) - -#define ID3D12Device_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) - -#define ID3D12Device_GetCustomHeapProperties(This,nodeMask,heapType) \ - ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) - -#define ID3D12Device_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) \ - ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) - -#define ID3D12Device_CreateHeap(This,pDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) - -#define ID3D12Device_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ - ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) - -#define ID3D12Device_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ - ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) - -#define ID3D12Device_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) \ - ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) - -#define ID3D12Device_OpenSharedHandle(This,NTHandle,riid,ppvObj) \ - ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) - -#define ID3D12Device_OpenSharedHandleByName(This,Name,Access,pNTHandle) \ - ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) - -#define ID3D12Device_MakeResident(This,NumObjects,ppObjects) \ - ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) - -#define ID3D12Device_Evict(This,NumObjects,ppObjects) \ - ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) - -#define ID3D12Device_CreateFence(This,InitialValue,Flags,riid,ppFence) \ - ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) - -#define ID3D12Device_GetDeviceRemovedReason(This) \ - ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) - -#define ID3D12Device_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ - ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) - -#define ID3D12Device_CreateQueryHeap(This,pDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) - -#define ID3D12Device_SetStablePowerState(This,Enable) \ - ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) - -#define ID3D12Device_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) \ - ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) - -#define ID3D12Device_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) \ - ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) - -#define ID3D12Device_GetAdapterLuid(This) \ - ( (This)->lpVtbl -> GetAdapterLuid(This) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - - - - - - - - - - - - - -#endif /* __ID3D12Device_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12PipelineLibrary_INTERFACE_DEFINED__ -#define __ID3D12PipelineLibrary_INTERFACE_DEFINED__ - -/* interface ID3D12PipelineLibrary */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12PipelineLibrary; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("c64226a8-9201-46af-b4cc-53fb9ff7414f") - ID3D12PipelineLibrary : public ID3D12DeviceChild - { - public: - virtual HRESULT STDMETHODCALLTYPE StorePipeline( - _In_opt_ LPCWSTR pName, - _In_ ID3D12PipelineState *pPipeline) = 0; - - virtual HRESULT STDMETHODCALLTYPE LoadGraphicsPipeline( - _In_ LPCWSTR pName, - _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState) = 0; - - virtual HRESULT STDMETHODCALLTYPE LoadComputePipeline( - _In_ LPCWSTR pName, - _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState) = 0; - - virtual SIZE_T STDMETHODCALLTYPE GetSerializedSize( void) = 0; - - virtual HRESULT STDMETHODCALLTYPE Serialize( - _Out_writes_(DataSizeInBytes) void *pData, - SIZE_T DataSizeInBytes) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12PipelineLibraryVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12PipelineLibrary * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12PipelineLibrary * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12PipelineLibrary * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12PipelineLibrary * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12PipelineLibrary * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12PipelineLibrary * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12PipelineLibrary * This, - _In_z_ LPCWSTR Name); - - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12PipelineLibrary * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - HRESULT ( STDMETHODCALLTYPE *StorePipeline )( - ID3D12PipelineLibrary * This, - _In_opt_ LPCWSTR pName, - _In_ ID3D12PipelineState *pPipeline); - - HRESULT ( STDMETHODCALLTYPE *LoadGraphicsPipeline )( - ID3D12PipelineLibrary * This, - _In_ LPCWSTR pName, - _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); - - HRESULT ( STDMETHODCALLTYPE *LoadComputePipeline )( - ID3D12PipelineLibrary * This, - _In_ LPCWSTR pName, - _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); - - SIZE_T ( STDMETHODCALLTYPE *GetSerializedSize )( - ID3D12PipelineLibrary * This); - - HRESULT ( STDMETHODCALLTYPE *Serialize )( - ID3D12PipelineLibrary * This, - _Out_writes_(DataSizeInBytes) void *pData, - SIZE_T DataSizeInBytes); - - END_INTERFACE - } ID3D12PipelineLibraryVtbl; - - interface ID3D12PipelineLibrary - { - CONST_VTBL struct ID3D12PipelineLibraryVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12PipelineLibrary_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12PipelineLibrary_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12PipelineLibrary_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12PipelineLibrary_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12PipelineLibrary_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12PipelineLibrary_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12PipelineLibrary_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12PipelineLibrary_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - - -#define ID3D12PipelineLibrary_StorePipeline(This,pName,pPipeline) \ - ( (This)->lpVtbl -> StorePipeline(This,pName,pPipeline) ) - -#define ID3D12PipelineLibrary_LoadGraphicsPipeline(This,pName,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> LoadGraphicsPipeline(This,pName,pDesc,riid,ppPipelineState) ) - -#define ID3D12PipelineLibrary_LoadComputePipeline(This,pName,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> LoadComputePipeline(This,pName,pDesc,riid,ppPipelineState) ) - -#define ID3D12PipelineLibrary_GetSerializedSize(This) \ - ( (This)->lpVtbl -> GetSerializedSize(This) ) - -#define ID3D12PipelineLibrary_Serialize(This,pData,DataSizeInBytes) \ - ( (This)->lpVtbl -> Serialize(This,pData,DataSizeInBytes) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12PipelineLibrary_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12PipelineLibrary1_INTERFACE_DEFINED__ -#define __ID3D12PipelineLibrary1_INTERFACE_DEFINED__ - -/* interface ID3D12PipelineLibrary1 */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12PipelineLibrary1; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("80eabf42-2568-4e5e-bd82-c37f86961dc3") - ID3D12PipelineLibrary1 : public ID3D12PipelineLibrary - { - public: - virtual HRESULT STDMETHODCALLTYPE LoadPipeline( - _In_ LPCWSTR pName, - _In_ const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12PipelineLibrary1Vtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12PipelineLibrary1 * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12PipelineLibrary1 * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12PipelineLibrary1 * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12PipelineLibrary1 * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12PipelineLibrary1 * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12PipelineLibrary1 * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12PipelineLibrary1 * This, - _In_z_ LPCWSTR Name); - - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12PipelineLibrary1 * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - HRESULT ( STDMETHODCALLTYPE *StorePipeline )( - ID3D12PipelineLibrary1 * This, - _In_opt_ LPCWSTR pName, - _In_ ID3D12PipelineState *pPipeline); - - HRESULT ( STDMETHODCALLTYPE *LoadGraphicsPipeline )( - ID3D12PipelineLibrary1 * This, - _In_ LPCWSTR pName, - _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); - - HRESULT ( STDMETHODCALLTYPE *LoadComputePipeline )( - ID3D12PipelineLibrary1 * This, - _In_ LPCWSTR pName, - _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); - - SIZE_T ( STDMETHODCALLTYPE *GetSerializedSize )( - ID3D12PipelineLibrary1 * This); - - HRESULT ( STDMETHODCALLTYPE *Serialize )( - ID3D12PipelineLibrary1 * This, - _Out_writes_(DataSizeInBytes) void *pData, - SIZE_T DataSizeInBytes); - - HRESULT ( STDMETHODCALLTYPE *LoadPipeline )( - ID3D12PipelineLibrary1 * This, - _In_ LPCWSTR pName, - _In_ const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); - - END_INTERFACE - } ID3D12PipelineLibrary1Vtbl; - - interface ID3D12PipelineLibrary1 - { - CONST_VTBL struct ID3D12PipelineLibrary1Vtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12PipelineLibrary1_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12PipelineLibrary1_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12PipelineLibrary1_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12PipelineLibrary1_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12PipelineLibrary1_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12PipelineLibrary1_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12PipelineLibrary1_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12PipelineLibrary1_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - - -#define ID3D12PipelineLibrary1_StorePipeline(This,pName,pPipeline) \ - ( (This)->lpVtbl -> StorePipeline(This,pName,pPipeline) ) - -#define ID3D12PipelineLibrary1_LoadGraphicsPipeline(This,pName,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> LoadGraphicsPipeline(This,pName,pDesc,riid,ppPipelineState) ) - -#define ID3D12PipelineLibrary1_LoadComputePipeline(This,pName,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> LoadComputePipeline(This,pName,pDesc,riid,ppPipelineState) ) - -#define ID3D12PipelineLibrary1_GetSerializedSize(This) \ - ( (This)->lpVtbl -> GetSerializedSize(This) ) - -#define ID3D12PipelineLibrary1_Serialize(This,pData,DataSizeInBytes) \ - ( (This)->lpVtbl -> Serialize(This,pData,DataSizeInBytes) ) - - -#define ID3D12PipelineLibrary1_LoadPipeline(This,pName,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> LoadPipeline(This,pName,pDesc,riid,ppPipelineState) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12PipelineLibrary1_INTERFACE_DEFINED__ */ - - -/* interface __MIDL_itf_d3d12_0000_0023 */ -/* [local] */ - -typedef -enum D3D12_MULTIPLE_FENCE_WAIT_FLAGS - { - D3D12_MULTIPLE_FENCE_WAIT_FLAG_NONE = 0, - D3D12_MULTIPLE_FENCE_WAIT_FLAG_ANY = 0x1, - D3D12_MULTIPLE_FENCE_WAIT_FLAG_ALL = 0 - } D3D12_MULTIPLE_FENCE_WAIT_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_MULTIPLE_FENCE_WAIT_FLAGS ); -typedef -enum D3D12_RESIDENCY_PRIORITY - { - D3D12_RESIDENCY_PRIORITY_MINIMUM = 0x28000000, - D3D12_RESIDENCY_PRIORITY_LOW = 0x50000000, - D3D12_RESIDENCY_PRIORITY_NORMAL = 0x78000000, - D3D12_RESIDENCY_PRIORITY_HIGH = 0xa0010000, - D3D12_RESIDENCY_PRIORITY_MAXIMUM = 0xc8000000 - } D3D12_RESIDENCY_PRIORITY; - - - -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0023_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0023_v0_0_s_ifspec; - -#ifndef __ID3D12Device1_INTERFACE_DEFINED__ -#define __ID3D12Device1_INTERFACE_DEFINED__ - -/* interface ID3D12Device1 */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12Device1; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("77acce80-638e-4e65-8895-c1f23386863e") - ID3D12Device1 : public ID3D12Device - { - public: - virtual HRESULT STDMETHODCALLTYPE CreatePipelineLibrary( - _In_reads_(BlobLength) const void *pLibraryBlob, - SIZE_T BlobLength, - REFIID riid, - _COM_Outptr_ void **ppPipelineLibrary) = 0; - - virtual HRESULT STDMETHODCALLTYPE SetEventOnMultipleFenceCompletion( - _In_reads_(NumFences) ID3D12Fence *const *ppFences, - _In_reads_(NumFences) const UINT64 *pFenceValues, - UINT NumFences, - D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags, - HANDLE hEvent) = 0; - - virtual HRESULT STDMETHODCALLTYPE SetResidencyPriority( - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, - _In_reads_(NumObjects) const D3D12_RESIDENCY_PRIORITY *pPriorities) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12Device1Vtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12Device1 * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12Device1 * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12Device1 * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12Device1 * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12Device1 * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12Device1 * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12Device1 * This, - _In_z_ LPCWSTR Name); - - UINT ( STDMETHODCALLTYPE *GetNodeCount )( - ID3D12Device1 * This); - - HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( - ID3D12Device1 * This, - _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppCommandQueue); - - HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( - ID3D12Device1 * This, - _In_ D3D12_COMMAND_LIST_TYPE type, - REFIID riid, - _COM_Outptr_ void **ppCommandAllocator); - - HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( - ID3D12Device1 * This, - _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); - - HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( - ID3D12Device1 * This, - _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); - - HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( - ID3D12Device1 * This, - _In_ UINT nodeMask, - _In_ D3D12_COMMAND_LIST_TYPE type, - _In_ ID3D12CommandAllocator *pCommandAllocator, - _In_opt_ ID3D12PipelineState *pInitialState, - REFIID riid, - _COM_Outptr_ void **ppCommandList); - - HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( - ID3D12Device1 * This, - D3D12_FEATURE Feature, - _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, - UINT FeatureSupportDataSize); - - HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( - ID3D12Device1 * This, - _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, - REFIID riid, - _COM_Outptr_ void **ppvHeap); - - UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( - ID3D12Device1 * This, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType); - - HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( - ID3D12Device1 * This, - _In_ UINT nodeMask, - _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, - _In_ SIZE_T blobLengthInBytes, - REFIID riid, - _COM_Outptr_ void **ppvRootSignature); - - void ( STDMETHODCALLTYPE *CreateConstantBufferView )( - ID3D12Device1 * This, - _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateShaderResourceView )( - ID3D12Device1 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( - ID3D12Device1 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ ID3D12Resource *pCounterResource, - _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateRenderTargetView )( - ID3D12Device1 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateDepthStencilView )( - ID3D12Device1 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateSampler )( - ID3D12Device1 * This, - _In_ const D3D12_SAMPLER_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CopyDescriptors )( - ID3D12Device1 * This, - _In_ UINT NumDestDescriptorRanges, - _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts, - _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes, - _In_ UINT NumSrcDescriptorRanges, - _In_reads_(NumSrcDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts, - _In_reads_opt_(NumSrcDescriptorRanges) const UINT *pSrcDescriptorRangeSizes, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); - - void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( - ID3D12Device1 * This, - _In_ UINT NumDescriptors, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); - - D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( - ID3D12Device1 * This, - _In_ UINT visibleMask, - _In_ UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); - - D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( - ID3D12Device1 * This, - _In_ UINT nodeMask, - D3D12_HEAP_TYPE heapType); - - HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( - ID3D12Device1 * This, - _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, - D3D12_HEAP_FLAGS HeapFlags, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialResourceState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riidResource, - _COM_Outptr_opt_ void **ppvResource); - - HRESULT ( STDMETHODCALLTYPE *CreateHeap )( - ID3D12Device1 * This, - _In_ const D3D12_HEAP_DESC *pDesc, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap); - - HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( - ID3D12Device1 * This, - _In_ ID3D12Heap *pHeap, - UINT64 HeapOffset, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); - - HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( - ID3D12Device1 * This, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); - - HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( - ID3D12Device1 * This, - _In_ ID3D12DeviceChild *pObject, - _In_opt_ const SECURITY_ATTRIBUTES *pAttributes, - DWORD Access, - _In_opt_ LPCWSTR Name, - _Out_ HANDLE *pHandle); - - HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( - ID3D12Device1 * This, - _In_ HANDLE NTHandle, - REFIID riid, - _COM_Outptr_opt_ void **ppvObj); - - HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( - ID3D12Device1 * This, - _In_ LPCWSTR Name, - DWORD Access, - /* [annotation][out] */ - _Out_ HANDLE *pNTHandle); - - HRESULT ( STDMETHODCALLTYPE *MakeResident )( - ID3D12Device1 * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); - - HRESULT ( STDMETHODCALLTYPE *Evict )( - ID3D12Device1 * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); - - HRESULT ( STDMETHODCALLTYPE *CreateFence )( - ID3D12Device1 * This, - UINT64 InitialValue, - D3D12_FENCE_FLAGS Flags, - REFIID riid, - _COM_Outptr_ void **ppFence); - - HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( - ID3D12Device1 * This); - - void ( STDMETHODCALLTYPE *GetCopyableFootprints )( - ID3D12Device1 * This, - _In_ const D3D12_RESOURCE_DESC *pResourceDesc, - _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, - _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, - UINT64 BaseOffset, - _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, - _Out_writes_opt_(NumSubresources) UINT *pNumRows, - _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, - _Out_opt_ UINT64 *pTotalBytes); - - HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( - ID3D12Device1 * This, - _In_ const D3D12_QUERY_HEAP_DESC *pDesc, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap); - - HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( - ID3D12Device1 * This, - BOOL Enable); - - HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( - ID3D12Device1 * This, - _In_ const D3D12_COMMAND_SIGNATURE_DESC *pDesc, - _In_opt_ ID3D12RootSignature *pRootSignature, - REFIID riid, - _COM_Outptr_opt_ void **ppvCommandSignature); - - void ( STDMETHODCALLTYPE *GetResourceTiling )( - ID3D12Device1 * This, - _In_ ID3D12Resource *pTiledResource, - _Out_opt_ UINT *pNumTilesForEntireResource, - _Out_opt_ D3D12_PACKED_MIP_INFO *pPackedMipDesc, - _Out_opt_ D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips, - _Inout_opt_ UINT *pNumSubresourceTilings, - _In_ UINT FirstSubresourceTilingToGet, - _Out_writes_(*pNumSubresourceTilings) D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips); - - LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( - ID3D12Device1 * This); - - HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( - ID3D12Device1 * This, - _In_reads_(BlobLength) const void *pLibraryBlob, - SIZE_T BlobLength, - REFIID riid, - _COM_Outptr_ void **ppPipelineLibrary); - - HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( - ID3D12Device1 * This, - _In_reads_(NumFences) ID3D12Fence *const *ppFences, - _In_reads_(NumFences) const UINT64 *pFenceValues, - UINT NumFences, - D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags, - HANDLE hEvent); - - HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( - ID3D12Device1 * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, - _In_reads_(NumObjects) const D3D12_RESIDENCY_PRIORITY *pPriorities); - - END_INTERFACE - } ID3D12Device1Vtbl; - - interface ID3D12Device1 - { - CONST_VTBL struct ID3D12Device1Vtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12Device1_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12Device1_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12Device1_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12Device1_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12Device1_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12Device1_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12Device1_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12Device1_GetNodeCount(This) \ - ( (This)->lpVtbl -> GetNodeCount(This) ) - -#define ID3D12Device1_CreateCommandQueue(This,pDesc,riid,ppCommandQueue) \ - ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) - -#define ID3D12Device1_CreateCommandAllocator(This,type,riid,ppCommandAllocator) \ - ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) - -#define ID3D12Device1_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) - -#define ID3D12Device1_CreateComputePipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) - -#define ID3D12Device1_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) \ - ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) - -#define ID3D12Device1_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) \ - ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) - -#define ID3D12Device1_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) - -#define ID3D12Device1_GetDescriptorHandleIncrementSize(This,DescriptorHeapType) \ - ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) - -#define ID3D12Device1_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) \ - ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) - -#define ID3D12Device1_CreateConstantBufferView(This,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) - -#define ID3D12Device1_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) - -#define ID3D12Device1_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) - -#define ID3D12Device1_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) - -#define ID3D12Device1_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) - -#define ID3D12Device1_CreateSampler(This,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) - -#define ID3D12Device1_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) \ - ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) - -#define ID3D12Device1_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) \ - ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) - -#define ID3D12Device1_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) - -#define ID3D12Device1_GetCustomHeapProperties(This,nodeMask,heapType) \ - ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) - -#define ID3D12Device1_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) \ - ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) - -#define ID3D12Device1_CreateHeap(This,pDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) - -#define ID3D12Device1_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ - ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) - -#define ID3D12Device1_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ - ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) - -#define ID3D12Device1_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) \ - ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) - -#define ID3D12Device1_OpenSharedHandle(This,NTHandle,riid,ppvObj) \ - ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) - -#define ID3D12Device1_OpenSharedHandleByName(This,Name,Access,pNTHandle) \ - ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) - -#define ID3D12Device1_MakeResident(This,NumObjects,ppObjects) \ - ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) - -#define ID3D12Device1_Evict(This,NumObjects,ppObjects) \ - ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) - -#define ID3D12Device1_CreateFence(This,InitialValue,Flags,riid,ppFence) \ - ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) - -#define ID3D12Device1_GetDeviceRemovedReason(This) \ - ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) - -#define ID3D12Device1_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ - ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) - -#define ID3D12Device1_CreateQueryHeap(This,pDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) - -#define ID3D12Device1_SetStablePowerState(This,Enable) \ - ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) - -#define ID3D12Device1_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) \ - ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) - -#define ID3D12Device1_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) \ - ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) - -#define ID3D12Device1_GetAdapterLuid(This) \ - ( (This)->lpVtbl -> GetAdapterLuid(This) ) - - -#define ID3D12Device1_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) \ - ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) - -#define ID3D12Device1_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) \ - ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) - -#define ID3D12Device1_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) \ - ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12Device1_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12Device2_INTERFACE_DEFINED__ -#define __ID3D12Device2_INTERFACE_DEFINED__ - -/* interface ID3D12Device2 */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12Device2; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("30baa41e-b15b-475c-a0bb-1af5c5b64328") - ID3D12Device2 : public ID3D12Device1 - { - public: - virtual HRESULT STDMETHODCALLTYPE CreatePipelineState( - const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12Device2Vtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12Device2 * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12Device2 * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12Device2 * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12Device2 * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12Device2 * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12Device2 * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12Device2 * This, - _In_z_ LPCWSTR Name); - - UINT ( STDMETHODCALLTYPE *GetNodeCount )( - ID3D12Device2 * This); - - HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( - ID3D12Device2 * This, - _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppCommandQueue); - - HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( - ID3D12Device2 * This, - _In_ D3D12_COMMAND_LIST_TYPE type, - REFIID riid, - _COM_Outptr_ void **ppCommandAllocator); - - HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( - ID3D12Device2 * This, - _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); - - HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( - ID3D12Device2 * This, - _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); - - HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( - ID3D12Device2 * This, - _In_ UINT nodeMask, - _In_ D3D12_COMMAND_LIST_TYPE type, - _In_ ID3D12CommandAllocator *pCommandAllocator, - _In_opt_ ID3D12PipelineState *pInitialState, - REFIID riid, - _COM_Outptr_ void **ppCommandList); - - HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( - ID3D12Device2 * This, - D3D12_FEATURE Feature, - _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, - UINT FeatureSupportDataSize); - - HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( - ID3D12Device2 * This, - _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, - REFIID riid, - _COM_Outptr_ void **ppvHeap); - - UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( - ID3D12Device2 * This, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType); - - HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( - ID3D12Device2 * This, - _In_ UINT nodeMask, - _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, - _In_ SIZE_T blobLengthInBytes, - REFIID riid, - _COM_Outptr_ void **ppvRootSignature); - - void ( STDMETHODCALLTYPE *CreateConstantBufferView )( - ID3D12Device2 * This, - _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateShaderResourceView )( - ID3D12Device2 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( - ID3D12Device2 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ ID3D12Resource *pCounterResource, - _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateRenderTargetView )( - ID3D12Device2 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateDepthStencilView )( - ID3D12Device2 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateSampler )( - ID3D12Device2 * This, - _In_ const D3D12_SAMPLER_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CopyDescriptors )( - ID3D12Device2 * This, - _In_ UINT NumDestDescriptorRanges, - _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts, - _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes, - _In_ UINT NumSrcDescriptorRanges, - _In_reads_(NumSrcDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts, - _In_reads_opt_(NumSrcDescriptorRanges) const UINT *pSrcDescriptorRangeSizes, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); - - void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( - ID3D12Device2 * This, - _In_ UINT NumDescriptors, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); - - D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( - ID3D12Device2 * This, - _In_ UINT visibleMask, - _In_ UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); - - D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( - ID3D12Device2 * This, - _In_ UINT nodeMask, - D3D12_HEAP_TYPE heapType); - - HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( - ID3D12Device2 * This, - _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, - D3D12_HEAP_FLAGS HeapFlags, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialResourceState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riidResource, - _COM_Outptr_opt_ void **ppvResource); - - HRESULT ( STDMETHODCALLTYPE *CreateHeap )( - ID3D12Device2 * This, - _In_ const D3D12_HEAP_DESC *pDesc, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap); - - HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( - ID3D12Device2 * This, - _In_ ID3D12Heap *pHeap, - UINT64 HeapOffset, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); - - HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( - ID3D12Device2 * This, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); - - HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( - ID3D12Device2 * This, - _In_ ID3D12DeviceChild *pObject, - _In_opt_ const SECURITY_ATTRIBUTES *pAttributes, - DWORD Access, - _In_opt_ LPCWSTR Name, - _Out_ HANDLE *pHandle); - - HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( - ID3D12Device2 * This, - _In_ HANDLE NTHandle, - REFIID riid, - _COM_Outptr_opt_ void **ppvObj); - - HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( - ID3D12Device2 * This, - _In_ LPCWSTR Name, - DWORD Access, - /* [annotation][out] */ - _Out_ HANDLE *pNTHandle); - - HRESULT ( STDMETHODCALLTYPE *MakeResident )( - ID3D12Device2 * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); - - HRESULT ( STDMETHODCALLTYPE *Evict )( - ID3D12Device2 * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); - - HRESULT ( STDMETHODCALLTYPE *CreateFence )( - ID3D12Device2 * This, - UINT64 InitialValue, - D3D12_FENCE_FLAGS Flags, - REFIID riid, - _COM_Outptr_ void **ppFence); - - HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( - ID3D12Device2 * This); - - void ( STDMETHODCALLTYPE *GetCopyableFootprints )( - ID3D12Device2 * This, - _In_ const D3D12_RESOURCE_DESC *pResourceDesc, - _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, - _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, - UINT64 BaseOffset, - _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, - _Out_writes_opt_(NumSubresources) UINT *pNumRows, - _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, - _Out_opt_ UINT64 *pTotalBytes); - - HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( - ID3D12Device2 * This, - _In_ const D3D12_QUERY_HEAP_DESC *pDesc, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap); - - HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( - ID3D12Device2 * This, - BOOL Enable); - - HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( - ID3D12Device2 * This, - _In_ const D3D12_COMMAND_SIGNATURE_DESC *pDesc, - _In_opt_ ID3D12RootSignature *pRootSignature, - REFIID riid, - _COM_Outptr_opt_ void **ppvCommandSignature); - - void ( STDMETHODCALLTYPE *GetResourceTiling )( - ID3D12Device2 * This, - _In_ ID3D12Resource *pTiledResource, - _Out_opt_ UINT *pNumTilesForEntireResource, - _Out_opt_ D3D12_PACKED_MIP_INFO *pPackedMipDesc, - _Out_opt_ D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips, - _Inout_opt_ UINT *pNumSubresourceTilings, - _In_ UINT FirstSubresourceTilingToGet, - _Out_writes_(*pNumSubresourceTilings) D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips); - - LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( - ID3D12Device2 * This); - - HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( - ID3D12Device2 * This, - _In_reads_(BlobLength) const void *pLibraryBlob, - SIZE_T BlobLength, - REFIID riid, - _COM_Outptr_ void **ppPipelineLibrary); - - HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( - ID3D12Device2 * This, - _In_reads_(NumFences) ID3D12Fence *const *ppFences, - _In_reads_(NumFences) const UINT64 *pFenceValues, - UINT NumFences, - D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags, - HANDLE hEvent); - - HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( - ID3D12Device2 * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, - _In_reads_(NumObjects) const D3D12_RESIDENCY_PRIORITY *pPriorities); - - HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( - ID3D12Device2 * This, - const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); - - END_INTERFACE - } ID3D12Device2Vtbl; - - interface ID3D12Device2 - { - CONST_VTBL struct ID3D12Device2Vtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12Device2_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12Device2_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12Device2_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12Device2_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12Device2_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12Device2_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12Device2_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12Device2_GetNodeCount(This) \ - ( (This)->lpVtbl -> GetNodeCount(This) ) - -#define ID3D12Device2_CreateCommandQueue(This,pDesc,riid,ppCommandQueue) \ - ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) - -#define ID3D12Device2_CreateCommandAllocator(This,type,riid,ppCommandAllocator) \ - ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) - -#define ID3D12Device2_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) - -#define ID3D12Device2_CreateComputePipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) - -#define ID3D12Device2_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) \ - ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) - -#define ID3D12Device2_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) \ - ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) - -#define ID3D12Device2_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) - -#define ID3D12Device2_GetDescriptorHandleIncrementSize(This,DescriptorHeapType) \ - ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) - -#define ID3D12Device2_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) \ - ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) - -#define ID3D12Device2_CreateConstantBufferView(This,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) - -#define ID3D12Device2_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) - -#define ID3D12Device2_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) - -#define ID3D12Device2_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) - -#define ID3D12Device2_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) - -#define ID3D12Device2_CreateSampler(This,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) - -#define ID3D12Device2_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) \ - ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) - -#define ID3D12Device2_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) \ - ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) - -#define ID3D12Device2_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) - -#define ID3D12Device2_GetCustomHeapProperties(This,nodeMask,heapType) \ - ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) - -#define ID3D12Device2_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) \ - ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) - -#define ID3D12Device2_CreateHeap(This,pDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) - -#define ID3D12Device2_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ - ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) - -#define ID3D12Device2_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ - ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) - -#define ID3D12Device2_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) \ - ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) - -#define ID3D12Device2_OpenSharedHandle(This,NTHandle,riid,ppvObj) \ - ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) - -#define ID3D12Device2_OpenSharedHandleByName(This,Name,Access,pNTHandle) \ - ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) - -#define ID3D12Device2_MakeResident(This,NumObjects,ppObjects) \ - ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) - -#define ID3D12Device2_Evict(This,NumObjects,ppObjects) \ - ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) - -#define ID3D12Device2_CreateFence(This,InitialValue,Flags,riid,ppFence) \ - ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) - -#define ID3D12Device2_GetDeviceRemovedReason(This) \ - ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) - -#define ID3D12Device2_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ - ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) - -#define ID3D12Device2_CreateQueryHeap(This,pDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) - -#define ID3D12Device2_SetStablePowerState(This,Enable) \ - ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) - -#define ID3D12Device2_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) \ - ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) - -#define ID3D12Device2_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) \ - ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) - -#define ID3D12Device2_GetAdapterLuid(This) \ - ( (This)->lpVtbl -> GetAdapterLuid(This) ) - - -#define ID3D12Device2_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) \ - ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) - -#define ID3D12Device2_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) \ - ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) - -#define ID3D12Device2_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) \ - ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) - - -#define ID3D12Device2_CreatePipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12Device2_INTERFACE_DEFINED__ */ - - -/* interface __MIDL_itf_d3d12_0000_0025 */ -/* [local] */ - -typedef -enum D3D12_RESIDENCY_FLAGS - { - D3D12_RESIDENCY_FLAG_NONE = 0, - D3D12_RESIDENCY_FLAG_DENY_OVERBUDGET = 0x1 - } D3D12_RESIDENCY_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_RESIDENCY_FLAGS ); - - -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0025_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0025_v0_0_s_ifspec; - -#ifndef __ID3D12Device3_INTERFACE_DEFINED__ -#define __ID3D12Device3_INTERFACE_DEFINED__ - -/* interface ID3D12Device3 */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12Device3; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("81dadc15-2bad-4392-93c5-101345c4aa98") - ID3D12Device3 : public ID3D12Device2 - { - public: - virtual HRESULT STDMETHODCALLTYPE OpenExistingHeapFromAddress( - _In_ const void *pAddress, - REFIID riid, - _COM_Outptr_ void **ppvHeap) = 0; - - virtual HRESULT STDMETHODCALLTYPE OpenExistingHeapFromFileMapping( - _In_ HANDLE hFileMapping, - REFIID riid, - _COM_Outptr_ void **ppvHeap) = 0; - - virtual HRESULT STDMETHODCALLTYPE EnqueueMakeResident( - D3D12_RESIDENCY_FLAGS Flags, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, - _In_ ID3D12Fence *pFenceToSignal, - UINT64 FenceValueToSignal) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12Device3Vtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12Device3 * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12Device3 * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12Device3 * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12Device3 * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12Device3 * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12Device3 * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12Device3 * This, - _In_z_ LPCWSTR Name); - - UINT ( STDMETHODCALLTYPE *GetNodeCount )( - ID3D12Device3 * This); - - HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( - ID3D12Device3 * This, - _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppCommandQueue); - - HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( - ID3D12Device3 * This, - _In_ D3D12_COMMAND_LIST_TYPE type, - REFIID riid, - _COM_Outptr_ void **ppCommandAllocator); - - HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( - ID3D12Device3 * This, - _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); - - HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( - ID3D12Device3 * This, - _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); - - HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( - ID3D12Device3 * This, - _In_ UINT nodeMask, - _In_ D3D12_COMMAND_LIST_TYPE type, - _In_ ID3D12CommandAllocator *pCommandAllocator, - _In_opt_ ID3D12PipelineState *pInitialState, - REFIID riid, - _COM_Outptr_ void **ppCommandList); - - HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( - ID3D12Device3 * This, - D3D12_FEATURE Feature, - _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, - UINT FeatureSupportDataSize); - - HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( - ID3D12Device3 * This, - _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, - REFIID riid, - _COM_Outptr_ void **ppvHeap); - - UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( - ID3D12Device3 * This, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType); - - HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( - ID3D12Device3 * This, - _In_ UINT nodeMask, - _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, - _In_ SIZE_T blobLengthInBytes, - REFIID riid, - _COM_Outptr_ void **ppvRootSignature); - - void ( STDMETHODCALLTYPE *CreateConstantBufferView )( - ID3D12Device3 * This, - _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateShaderResourceView )( - ID3D12Device3 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( - ID3D12Device3 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ ID3D12Resource *pCounterResource, - _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateRenderTargetView )( - ID3D12Device3 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateDepthStencilView )( - ID3D12Device3 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateSampler )( - ID3D12Device3 * This, - _In_ const D3D12_SAMPLER_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CopyDescriptors )( - ID3D12Device3 * This, - _In_ UINT NumDestDescriptorRanges, - _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts, - _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes, - _In_ UINT NumSrcDescriptorRanges, - _In_reads_(NumSrcDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts, - _In_reads_opt_(NumSrcDescriptorRanges) const UINT *pSrcDescriptorRangeSizes, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); - - void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( - ID3D12Device3 * This, - _In_ UINT NumDescriptors, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); - - D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( - ID3D12Device3 * This, - _In_ UINT visibleMask, - _In_ UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); - - D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( - ID3D12Device3 * This, - _In_ UINT nodeMask, - D3D12_HEAP_TYPE heapType); - - HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( - ID3D12Device3 * This, - _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, - D3D12_HEAP_FLAGS HeapFlags, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialResourceState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riidResource, - _COM_Outptr_opt_ void **ppvResource); - - HRESULT ( STDMETHODCALLTYPE *CreateHeap )( - ID3D12Device3 * This, - _In_ const D3D12_HEAP_DESC *pDesc, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap); - - HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( - ID3D12Device3 * This, - _In_ ID3D12Heap *pHeap, - UINT64 HeapOffset, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); - - HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( - ID3D12Device3 * This, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); - - HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( - ID3D12Device3 * This, - _In_ ID3D12DeviceChild *pObject, - _In_opt_ const SECURITY_ATTRIBUTES *pAttributes, - DWORD Access, - _In_opt_ LPCWSTR Name, - _Out_ HANDLE *pHandle); - - HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( - ID3D12Device3 * This, - _In_ HANDLE NTHandle, - REFIID riid, - _COM_Outptr_opt_ void **ppvObj); - - HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( - ID3D12Device3 * This, - _In_ LPCWSTR Name, - DWORD Access, - /* [annotation][out] */ - _Out_ HANDLE *pNTHandle); - - HRESULT ( STDMETHODCALLTYPE *MakeResident )( - ID3D12Device3 * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); - - HRESULT ( STDMETHODCALLTYPE *Evict )( - ID3D12Device3 * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); - - HRESULT ( STDMETHODCALLTYPE *CreateFence )( - ID3D12Device3 * This, - UINT64 InitialValue, - D3D12_FENCE_FLAGS Flags, - REFIID riid, - _COM_Outptr_ void **ppFence); - - HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( - ID3D12Device3 * This); - - void ( STDMETHODCALLTYPE *GetCopyableFootprints )( - ID3D12Device3 * This, - _In_ const D3D12_RESOURCE_DESC *pResourceDesc, - _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, - _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, - UINT64 BaseOffset, - _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, - _Out_writes_opt_(NumSubresources) UINT *pNumRows, - _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, - _Out_opt_ UINT64 *pTotalBytes); - - HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( - ID3D12Device3 * This, - _In_ const D3D12_QUERY_HEAP_DESC *pDesc, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap); - - HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( - ID3D12Device3 * This, - BOOL Enable); - - HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( - ID3D12Device3 * This, - _In_ const D3D12_COMMAND_SIGNATURE_DESC *pDesc, - _In_opt_ ID3D12RootSignature *pRootSignature, - REFIID riid, - _COM_Outptr_opt_ void **ppvCommandSignature); - - void ( STDMETHODCALLTYPE *GetResourceTiling )( - ID3D12Device3 * This, - _In_ ID3D12Resource *pTiledResource, - _Out_opt_ UINT *pNumTilesForEntireResource, - _Out_opt_ D3D12_PACKED_MIP_INFO *pPackedMipDesc, - _Out_opt_ D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips, - _Inout_opt_ UINT *pNumSubresourceTilings, - _In_ UINT FirstSubresourceTilingToGet, - _Out_writes_(*pNumSubresourceTilings) D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips); - - LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( - ID3D12Device3 * This); - - HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( - ID3D12Device3 * This, - _In_reads_(BlobLength) const void *pLibraryBlob, - SIZE_T BlobLength, - REFIID riid, - _COM_Outptr_ void **ppPipelineLibrary); - - HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( - ID3D12Device3 * This, - _In_reads_(NumFences) ID3D12Fence *const *ppFences, - _In_reads_(NumFences) const UINT64 *pFenceValues, - UINT NumFences, - D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags, - HANDLE hEvent); - - HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( - ID3D12Device3 * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, - _In_reads_(NumObjects) const D3D12_RESIDENCY_PRIORITY *pPriorities); - - HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( - ID3D12Device3 * This, - const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); - - HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress )( - ID3D12Device3 * This, - _In_ const void *pAddress, - REFIID riid, - _COM_Outptr_ void **ppvHeap); - - HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromFileMapping )( - ID3D12Device3 * This, - _In_ HANDLE hFileMapping, - REFIID riid, - _COM_Outptr_ void **ppvHeap); - - HRESULT ( STDMETHODCALLTYPE *EnqueueMakeResident )( - ID3D12Device3 * This, - D3D12_RESIDENCY_FLAGS Flags, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, - _In_ ID3D12Fence *pFenceToSignal, - UINT64 FenceValueToSignal); - - END_INTERFACE - } ID3D12Device3Vtbl; - - interface ID3D12Device3 - { - CONST_VTBL struct ID3D12Device3Vtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12Device3_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12Device3_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12Device3_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12Device3_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12Device3_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12Device3_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12Device3_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12Device3_GetNodeCount(This) \ - ( (This)->lpVtbl -> GetNodeCount(This) ) - -#define ID3D12Device3_CreateCommandQueue(This,pDesc,riid,ppCommandQueue) \ - ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) - -#define ID3D12Device3_CreateCommandAllocator(This,type,riid,ppCommandAllocator) \ - ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) - -#define ID3D12Device3_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) - -#define ID3D12Device3_CreateComputePipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) - -#define ID3D12Device3_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) \ - ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) - -#define ID3D12Device3_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) \ - ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) - -#define ID3D12Device3_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) - -#define ID3D12Device3_GetDescriptorHandleIncrementSize(This,DescriptorHeapType) \ - ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) - -#define ID3D12Device3_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) \ - ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) - -#define ID3D12Device3_CreateConstantBufferView(This,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) - -#define ID3D12Device3_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) - -#define ID3D12Device3_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) - -#define ID3D12Device3_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) - -#define ID3D12Device3_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) - -#define ID3D12Device3_CreateSampler(This,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) - -#define ID3D12Device3_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) \ - ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) - -#define ID3D12Device3_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) \ - ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) - -#define ID3D12Device3_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) - -#define ID3D12Device3_GetCustomHeapProperties(This,nodeMask,heapType) \ - ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) - -#define ID3D12Device3_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) \ - ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) - -#define ID3D12Device3_CreateHeap(This,pDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) - -#define ID3D12Device3_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ - ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) - -#define ID3D12Device3_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ - ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) - -#define ID3D12Device3_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) \ - ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) - -#define ID3D12Device3_OpenSharedHandle(This,NTHandle,riid,ppvObj) \ - ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) - -#define ID3D12Device3_OpenSharedHandleByName(This,Name,Access,pNTHandle) \ - ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) - -#define ID3D12Device3_MakeResident(This,NumObjects,ppObjects) \ - ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) - -#define ID3D12Device3_Evict(This,NumObjects,ppObjects) \ - ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) - -#define ID3D12Device3_CreateFence(This,InitialValue,Flags,riid,ppFence) \ - ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) - -#define ID3D12Device3_GetDeviceRemovedReason(This) \ - ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) - -#define ID3D12Device3_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ - ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) - -#define ID3D12Device3_CreateQueryHeap(This,pDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) - -#define ID3D12Device3_SetStablePowerState(This,Enable) \ - ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) - -#define ID3D12Device3_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) \ - ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) - -#define ID3D12Device3_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) \ - ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) - -#define ID3D12Device3_GetAdapterLuid(This) \ - ( (This)->lpVtbl -> GetAdapterLuid(This) ) - - -#define ID3D12Device3_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) \ - ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) - -#define ID3D12Device3_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) \ - ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) - -#define ID3D12Device3_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) \ - ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) - - -#define ID3D12Device3_CreatePipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) - - -#define ID3D12Device3_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) \ - ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) - -#define ID3D12Device3_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) \ - ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) - -#define ID3D12Device3_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) \ - ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12Device3_INTERFACE_DEFINED__ */ - - -/* interface __MIDL_itf_d3d12_0000_0026 */ -/* [local] */ - -typedef -enum D3D12_COMMAND_LIST_FLAGS - { - D3D12_COMMAND_LIST_FLAG_NONE = 0 - } D3D12_COMMAND_LIST_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_LIST_FLAGS ); -typedef -enum D3D12_COMMAND_POOL_FLAGS - { - D3D12_COMMAND_POOL_FLAG_NONE = 0 - } D3D12_COMMAND_POOL_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_POOL_FLAGS ); -typedef -enum D3D12_COMMAND_RECORDER_FLAGS - { - D3D12_COMMAND_RECORDER_FLAG_NONE = 0 - } D3D12_COMMAND_RECORDER_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_RECORDER_FLAGS ); -typedef -enum D3D12_PROTECTED_SESSION_STATUS - { - D3D12_PROTECTED_SESSION_STATUS_OK = 0, - D3D12_PROTECTED_SESSION_STATUS_INVALID = 1 - } D3D12_PROTECTED_SESSION_STATUS; - - - -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0026_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0026_v0_0_s_ifspec; - -#ifndef __ID3D12ProtectedSession_INTERFACE_DEFINED__ -#define __ID3D12ProtectedSession_INTERFACE_DEFINED__ - -/* interface ID3D12ProtectedSession */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12ProtectedSession; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("A1533D18-0AC1-4084-85B9-89A96116806B") - ID3D12ProtectedSession : public ID3D12DeviceChild - { - public: - virtual HRESULT STDMETHODCALLTYPE GetStatusFence( - REFIID riid, - _COM_Outptr_opt_ void **ppFence) = 0; - - virtual D3D12_PROTECTED_SESSION_STATUS STDMETHODCALLTYPE GetSessionStatus( void) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12ProtectedSessionVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12ProtectedSession * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12ProtectedSession * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12ProtectedSession * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12ProtectedSession * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12ProtectedSession * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12ProtectedSession * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12ProtectedSession * This, - _In_z_ LPCWSTR Name); - - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12ProtectedSession * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - HRESULT ( STDMETHODCALLTYPE *GetStatusFence )( - ID3D12ProtectedSession * This, - REFIID riid, - _COM_Outptr_opt_ void **ppFence); - - D3D12_PROTECTED_SESSION_STATUS ( STDMETHODCALLTYPE *GetSessionStatus )( - ID3D12ProtectedSession * This); - - END_INTERFACE - } ID3D12ProtectedSessionVtbl; - - interface ID3D12ProtectedSession - { - CONST_VTBL struct ID3D12ProtectedSessionVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12ProtectedSession_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12ProtectedSession_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12ProtectedSession_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12ProtectedSession_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12ProtectedSession_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12ProtectedSession_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12ProtectedSession_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12ProtectedSession_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - - -#define ID3D12ProtectedSession_GetStatusFence(This,riid,ppFence) \ - ( (This)->lpVtbl -> GetStatusFence(This,riid,ppFence) ) - -#define ID3D12ProtectedSession_GetSessionStatus(This) \ - ( (This)->lpVtbl -> GetSessionStatus(This) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12ProtectedSession_INTERFACE_DEFINED__ */ - - -/* interface __MIDL_itf_d3d12_0000_0027 */ -/* [local] */ - -typedef -enum D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS - { - D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_NONE = 0, - D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_SUPPORTED = 0x1 - } D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS ); -typedef struct D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_SUPPORT - { - UINT NodeIndex; - D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS Support; - } D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_SUPPORT; - -typedef -enum D3D12_PROTECTED_RESOURCE_SESSION_FLAGS - { - D3D12_PROTECTED_RESOURCE_SESSION_FLAG_NONE = 0 - } D3D12_PROTECTED_RESOURCE_SESSION_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_PROTECTED_RESOURCE_SESSION_FLAGS ); -typedef struct D3D12_PROTECTED_RESOURCE_SESSION_DESC - { - UINT NodeMask; - D3D12_PROTECTED_RESOURCE_SESSION_FLAGS Flags; - } D3D12_PROTECTED_RESOURCE_SESSION_DESC; - - - -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0027_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0027_v0_0_s_ifspec; - -#ifndef __ID3D12ProtectedResourceSession_INTERFACE_DEFINED__ -#define __ID3D12ProtectedResourceSession_INTERFACE_DEFINED__ - -/* interface ID3D12ProtectedResourceSession */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12ProtectedResourceSession; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("6CD696F4-F289-40CC-8091-5A6C0A099C3D") - ID3D12ProtectedResourceSession : public ID3D12ProtectedSession - { - public: - virtual D3D12_PROTECTED_RESOURCE_SESSION_DESC STDMETHODCALLTYPE GetDesc( void) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12ProtectedResourceSessionVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12ProtectedResourceSession * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12ProtectedResourceSession * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12ProtectedResourceSession * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12ProtectedResourceSession * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12ProtectedResourceSession * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12ProtectedResourceSession * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12ProtectedResourceSession * This, - _In_z_ LPCWSTR Name); - - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12ProtectedResourceSession * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - HRESULT ( STDMETHODCALLTYPE *GetStatusFence )( - ID3D12ProtectedResourceSession * This, - REFIID riid, - _COM_Outptr_opt_ void **ppFence); - - D3D12_PROTECTED_SESSION_STATUS ( STDMETHODCALLTYPE *GetSessionStatus )( - ID3D12ProtectedResourceSession * This); - - D3D12_PROTECTED_RESOURCE_SESSION_DESC ( STDMETHODCALLTYPE *GetDesc )( - ID3D12ProtectedResourceSession * This); - - END_INTERFACE - } ID3D12ProtectedResourceSessionVtbl; - - interface ID3D12ProtectedResourceSession - { - CONST_VTBL struct ID3D12ProtectedResourceSessionVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12ProtectedResourceSession_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12ProtectedResourceSession_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12ProtectedResourceSession_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12ProtectedResourceSession_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12ProtectedResourceSession_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12ProtectedResourceSession_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12ProtectedResourceSession_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12ProtectedResourceSession_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - - -#define ID3D12ProtectedResourceSession_GetStatusFence(This,riid,ppFence) \ - ( (This)->lpVtbl -> GetStatusFence(This,riid,ppFence) ) - -#define ID3D12ProtectedResourceSession_GetSessionStatus(This) \ - ( (This)->lpVtbl -> GetSessionStatus(This) ) - - -#define ID3D12ProtectedResourceSession_GetDesc(This) \ - ( (This)->lpVtbl -> GetDesc(This) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - - - - - -#endif /* __ID3D12ProtectedResourceSession_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12Device4_INTERFACE_DEFINED__ -#define __ID3D12Device4_INTERFACE_DEFINED__ - -/* interface ID3D12Device4 */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12Device4; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("e865df17-a9ee-46f9-a463-3098315aa2e5") - ID3D12Device4 : public ID3D12Device3 - { - public: - virtual HRESULT STDMETHODCALLTYPE CreateCommandList1( - _In_ UINT nodeMask, - _In_ D3D12_COMMAND_LIST_TYPE type, - _In_ D3D12_COMMAND_LIST_FLAGS flags, - REFIID riid, - _COM_Outptr_ void **ppCommandList) = 0; - - virtual HRESULT STDMETHODCALLTYPE CreateProtectedResourceSession( - _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC *pDesc, - _In_ REFIID riid, - _COM_Outptr_ void **ppSession) = 0; - - virtual HRESULT STDMETHODCALLTYPE CreateCommittedResource1( - _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, - D3D12_HEAP_FLAGS HeapFlags, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialResourceState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - REFIID riidResource, - _COM_Outptr_opt_ void **ppvResource) = 0; - - virtual HRESULT STDMETHODCALLTYPE CreateHeap1( - _In_ const D3D12_HEAP_DESC *pDesc, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap) = 0; - - virtual HRESULT STDMETHODCALLTYPE CreateReservedResource1( - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource) = 0; - - virtual D3D12_RESOURCE_ALLOCATION_INFO STDMETHODCALLTYPE GetResourceAllocationInfo1( - UINT visibleMask, - UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, - _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12Device4Vtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12Device4 * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12Device4 * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12Device4 * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12Device4 * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12Device4 * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12Device4 * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12Device4 * This, - _In_z_ LPCWSTR Name); - - UINT ( STDMETHODCALLTYPE *GetNodeCount )( - ID3D12Device4 * This); - - HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( - ID3D12Device4 * This, - _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppCommandQueue); - - HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( - ID3D12Device4 * This, - _In_ D3D12_COMMAND_LIST_TYPE type, - REFIID riid, - _COM_Outptr_ void **ppCommandAllocator); - - HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( - ID3D12Device4 * This, - _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); - - HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( - ID3D12Device4 * This, - _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); - - HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( - ID3D12Device4 * This, - _In_ UINT nodeMask, - _In_ D3D12_COMMAND_LIST_TYPE type, - _In_ ID3D12CommandAllocator *pCommandAllocator, - _In_opt_ ID3D12PipelineState *pInitialState, - REFIID riid, - _COM_Outptr_ void **ppCommandList); - - HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( - ID3D12Device4 * This, - D3D12_FEATURE Feature, - _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, - UINT FeatureSupportDataSize); - - HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( - ID3D12Device4 * This, - _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, - REFIID riid, - _COM_Outptr_ void **ppvHeap); - - UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( - ID3D12Device4 * This, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType); - - HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( - ID3D12Device4 * This, - _In_ UINT nodeMask, - _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, - _In_ SIZE_T blobLengthInBytes, - REFIID riid, - _COM_Outptr_ void **ppvRootSignature); - - void ( STDMETHODCALLTYPE *CreateConstantBufferView )( - ID3D12Device4 * This, - _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateShaderResourceView )( - ID3D12Device4 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( - ID3D12Device4 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ ID3D12Resource *pCounterResource, - _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateRenderTargetView )( - ID3D12Device4 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateDepthStencilView )( - ID3D12Device4 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateSampler )( - ID3D12Device4 * This, - _In_ const D3D12_SAMPLER_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CopyDescriptors )( - ID3D12Device4 * This, - _In_ UINT NumDestDescriptorRanges, - _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts, - _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes, - _In_ UINT NumSrcDescriptorRanges, - _In_reads_(NumSrcDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts, - _In_reads_opt_(NumSrcDescriptorRanges) const UINT *pSrcDescriptorRangeSizes, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); - - void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( - ID3D12Device4 * This, - _In_ UINT NumDescriptors, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); - - D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( - ID3D12Device4 * This, - _In_ UINT visibleMask, - _In_ UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); - - D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( - ID3D12Device4 * This, - _In_ UINT nodeMask, - D3D12_HEAP_TYPE heapType); - - HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( - ID3D12Device4 * This, - _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, - D3D12_HEAP_FLAGS HeapFlags, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialResourceState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riidResource, - _COM_Outptr_opt_ void **ppvResource); - - HRESULT ( STDMETHODCALLTYPE *CreateHeap )( - ID3D12Device4 * This, - _In_ const D3D12_HEAP_DESC *pDesc, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap); - - HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( - ID3D12Device4 * This, - _In_ ID3D12Heap *pHeap, - UINT64 HeapOffset, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); - - HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( - ID3D12Device4 * This, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); - - HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( - ID3D12Device4 * This, - _In_ ID3D12DeviceChild *pObject, - _In_opt_ const SECURITY_ATTRIBUTES *pAttributes, - DWORD Access, - _In_opt_ LPCWSTR Name, - _Out_ HANDLE *pHandle); - - HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( - ID3D12Device4 * This, - _In_ HANDLE NTHandle, - REFIID riid, - _COM_Outptr_opt_ void **ppvObj); - - HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( - ID3D12Device4 * This, - _In_ LPCWSTR Name, - DWORD Access, - /* [annotation][out] */ - _Out_ HANDLE *pNTHandle); - - HRESULT ( STDMETHODCALLTYPE *MakeResident )( - ID3D12Device4 * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); - - HRESULT ( STDMETHODCALLTYPE *Evict )( - ID3D12Device4 * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); - - HRESULT ( STDMETHODCALLTYPE *CreateFence )( - ID3D12Device4 * This, - UINT64 InitialValue, - D3D12_FENCE_FLAGS Flags, - REFIID riid, - _COM_Outptr_ void **ppFence); - - HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( - ID3D12Device4 * This); - - void ( STDMETHODCALLTYPE *GetCopyableFootprints )( - ID3D12Device4 * This, - _In_ const D3D12_RESOURCE_DESC *pResourceDesc, - _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, - _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, - UINT64 BaseOffset, - _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, - _Out_writes_opt_(NumSubresources) UINT *pNumRows, - _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, - _Out_opt_ UINT64 *pTotalBytes); - - HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( - ID3D12Device4 * This, - _In_ const D3D12_QUERY_HEAP_DESC *pDesc, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap); - - HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( - ID3D12Device4 * This, - BOOL Enable); - - HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( - ID3D12Device4 * This, - _In_ const D3D12_COMMAND_SIGNATURE_DESC *pDesc, - _In_opt_ ID3D12RootSignature *pRootSignature, - REFIID riid, - _COM_Outptr_opt_ void **ppvCommandSignature); - - void ( STDMETHODCALLTYPE *GetResourceTiling )( - ID3D12Device4 * This, - _In_ ID3D12Resource *pTiledResource, - _Out_opt_ UINT *pNumTilesForEntireResource, - _Out_opt_ D3D12_PACKED_MIP_INFO *pPackedMipDesc, - _Out_opt_ D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips, - _Inout_opt_ UINT *pNumSubresourceTilings, - _In_ UINT FirstSubresourceTilingToGet, - _Out_writes_(*pNumSubresourceTilings) D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips); - - LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( - ID3D12Device4 * This); - - HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( - ID3D12Device4 * This, - _In_reads_(BlobLength) const void *pLibraryBlob, - SIZE_T BlobLength, - REFIID riid, - _COM_Outptr_ void **ppPipelineLibrary); - - HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( - ID3D12Device4 * This, - _In_reads_(NumFences) ID3D12Fence *const *ppFences, - _In_reads_(NumFences) const UINT64 *pFenceValues, - UINT NumFences, - D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags, - HANDLE hEvent); - - HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( - ID3D12Device4 * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, - _In_reads_(NumObjects) const D3D12_RESIDENCY_PRIORITY *pPriorities); - - HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( - ID3D12Device4 * This, - const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); - - HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress )( - ID3D12Device4 * This, - _In_ const void *pAddress, - REFIID riid, - _COM_Outptr_ void **ppvHeap); - - HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromFileMapping )( - ID3D12Device4 * This, - _In_ HANDLE hFileMapping, - REFIID riid, - _COM_Outptr_ void **ppvHeap); - - HRESULT ( STDMETHODCALLTYPE *EnqueueMakeResident )( - ID3D12Device4 * This, - D3D12_RESIDENCY_FLAGS Flags, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, - _In_ ID3D12Fence *pFenceToSignal, - UINT64 FenceValueToSignal); - - HRESULT ( STDMETHODCALLTYPE *CreateCommandList1 )( - ID3D12Device4 * This, - _In_ UINT nodeMask, - _In_ D3D12_COMMAND_LIST_TYPE type, - _In_ D3D12_COMMAND_LIST_FLAGS flags, - REFIID riid, - _COM_Outptr_ void **ppCommandList); - - HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession )( - ID3D12Device4 * This, - _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC *pDesc, - _In_ REFIID riid, - _COM_Outptr_ void **ppSession); - - HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource1 )( - ID3D12Device4 * This, - _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, - D3D12_HEAP_FLAGS HeapFlags, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialResourceState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - REFIID riidResource, - _COM_Outptr_opt_ void **ppvResource); - - HRESULT ( STDMETHODCALLTYPE *CreateHeap1 )( - ID3D12Device4 * This, - _In_ const D3D12_HEAP_DESC *pDesc, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap); - - HRESULT ( STDMETHODCALLTYPE *CreateReservedResource1 )( - ID3D12Device4 * This, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); - - D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( - ID3D12Device4 * This, - UINT visibleMask, - UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, - _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); - - END_INTERFACE - } ID3D12Device4Vtbl; - - interface ID3D12Device4 - { - CONST_VTBL struct ID3D12Device4Vtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12Device4_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12Device4_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12Device4_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12Device4_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12Device4_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12Device4_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12Device4_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12Device4_GetNodeCount(This) \ - ( (This)->lpVtbl -> GetNodeCount(This) ) - -#define ID3D12Device4_CreateCommandQueue(This,pDesc,riid,ppCommandQueue) \ - ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) - -#define ID3D12Device4_CreateCommandAllocator(This,type,riid,ppCommandAllocator) \ - ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) - -#define ID3D12Device4_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) - -#define ID3D12Device4_CreateComputePipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) - -#define ID3D12Device4_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) \ - ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) - -#define ID3D12Device4_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) \ - ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) - -#define ID3D12Device4_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) - -#define ID3D12Device4_GetDescriptorHandleIncrementSize(This,DescriptorHeapType) \ - ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) - -#define ID3D12Device4_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) \ - ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) - -#define ID3D12Device4_CreateConstantBufferView(This,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) - -#define ID3D12Device4_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) - -#define ID3D12Device4_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) - -#define ID3D12Device4_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) - -#define ID3D12Device4_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) - -#define ID3D12Device4_CreateSampler(This,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) - -#define ID3D12Device4_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) \ - ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) - -#define ID3D12Device4_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) \ - ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) - -#define ID3D12Device4_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) - -#define ID3D12Device4_GetCustomHeapProperties(This,nodeMask,heapType) \ - ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) - -#define ID3D12Device4_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) \ - ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) - -#define ID3D12Device4_CreateHeap(This,pDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) - -#define ID3D12Device4_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ - ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) - -#define ID3D12Device4_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ - ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) - -#define ID3D12Device4_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) \ - ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) - -#define ID3D12Device4_OpenSharedHandle(This,NTHandle,riid,ppvObj) \ - ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) - -#define ID3D12Device4_OpenSharedHandleByName(This,Name,Access,pNTHandle) \ - ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) - -#define ID3D12Device4_MakeResident(This,NumObjects,ppObjects) \ - ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) - -#define ID3D12Device4_Evict(This,NumObjects,ppObjects) \ - ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) - -#define ID3D12Device4_CreateFence(This,InitialValue,Flags,riid,ppFence) \ - ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) - -#define ID3D12Device4_GetDeviceRemovedReason(This) \ - ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) - -#define ID3D12Device4_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ - ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) - -#define ID3D12Device4_CreateQueryHeap(This,pDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) - -#define ID3D12Device4_SetStablePowerState(This,Enable) \ - ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) - -#define ID3D12Device4_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) \ - ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) - -#define ID3D12Device4_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) \ - ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) - -#define ID3D12Device4_GetAdapterLuid(This) \ - ( (This)->lpVtbl -> GetAdapterLuid(This) ) - - -#define ID3D12Device4_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) \ - ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) - -#define ID3D12Device4_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) \ - ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) - -#define ID3D12Device4_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) \ - ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) - - -#define ID3D12Device4_CreatePipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) - - -#define ID3D12Device4_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) \ - ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) - -#define ID3D12Device4_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) \ - ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) - -#define ID3D12Device4_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) \ - ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) - - -#define ID3D12Device4_CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) \ - ( (This)->lpVtbl -> CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) ) - -#define ID3D12Device4_CreateProtectedResourceSession(This,pDesc,riid,ppSession) \ - ( (This)->lpVtbl -> CreateProtectedResourceSession(This,pDesc,riid,ppSession) ) - -#define ID3D12Device4_CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ - ( (This)->lpVtbl -> CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) - -#define ID3D12Device4_CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) ) - -#define ID3D12Device4_CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) \ - ( (This)->lpVtbl -> CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) ) - -#define ID3D12Device4_GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - - - - - -#endif /* __ID3D12Device4_INTERFACE_DEFINED__ */ - - -/* interface __MIDL_itf_d3d12_0000_0029 */ -/* [local] */ - -typedef -enum D3D12_LIFETIME_STATE - { - D3D12_LIFETIME_STATE_IN_USE = 0, - D3D12_LIFETIME_STATE_NOT_IN_USE = ( D3D12_LIFETIME_STATE_IN_USE + 1 ) - } D3D12_LIFETIME_STATE; - - - - -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0029_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0029_v0_0_s_ifspec; - -#ifndef __ID3D12LifetimeOwner_INTERFACE_DEFINED__ -#define __ID3D12LifetimeOwner_INTERFACE_DEFINED__ - -/* interface ID3D12LifetimeOwner */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12LifetimeOwner; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("e667af9f-cd56-4f46-83ce-032e595d70a8") - ID3D12LifetimeOwner : public IUnknown - { - public: - virtual void STDMETHODCALLTYPE LifetimeStateUpdated( - D3D12_LIFETIME_STATE NewState) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12LifetimeOwnerVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12LifetimeOwner * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12LifetimeOwner * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12LifetimeOwner * This); - - void ( STDMETHODCALLTYPE *LifetimeStateUpdated )( - ID3D12LifetimeOwner * This, - D3D12_LIFETIME_STATE NewState); - - END_INTERFACE - } ID3D12LifetimeOwnerVtbl; - - interface ID3D12LifetimeOwner - { - CONST_VTBL struct ID3D12LifetimeOwnerVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12LifetimeOwner_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12LifetimeOwner_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12LifetimeOwner_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12LifetimeOwner_LifetimeStateUpdated(This,NewState) \ - ( (This)->lpVtbl -> LifetimeStateUpdated(This,NewState) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12LifetimeOwner_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12SwapChainAssistant_INTERFACE_DEFINED__ -#define __ID3D12SwapChainAssistant_INTERFACE_DEFINED__ - -/* interface ID3D12SwapChainAssistant */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12SwapChainAssistant; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("f1df64b6-57fd-49cd-8807-c0eb88b45c8f") - ID3D12SwapChainAssistant : public IUnknown - { - public: - virtual LUID STDMETHODCALLTYPE GetLUID( void) = 0; - - virtual HRESULT STDMETHODCALLTYPE GetSwapChainObject( - REFIID riid, - _COM_Outptr_ void **ppv) = 0; - - virtual HRESULT STDMETHODCALLTYPE GetCurrentResourceAndCommandQueue( - REFIID riidResource, - _COM_Outptr_ void **ppvResource, - REFIID riidQueue, - _COM_Outptr_ void **ppvQueue) = 0; - - virtual HRESULT STDMETHODCALLTYPE InsertImplicitSync( void) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12SwapChainAssistantVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12SwapChainAssistant * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12SwapChainAssistant * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12SwapChainAssistant * This); - - LUID ( STDMETHODCALLTYPE *GetLUID )( - ID3D12SwapChainAssistant * This); - - HRESULT ( STDMETHODCALLTYPE *GetSwapChainObject )( - ID3D12SwapChainAssistant * This, - REFIID riid, - _COM_Outptr_ void **ppv); - - HRESULT ( STDMETHODCALLTYPE *GetCurrentResourceAndCommandQueue )( - ID3D12SwapChainAssistant * This, - REFIID riidResource, - _COM_Outptr_ void **ppvResource, - REFIID riidQueue, - _COM_Outptr_ void **ppvQueue); - - HRESULT ( STDMETHODCALLTYPE *InsertImplicitSync )( - ID3D12SwapChainAssistant * This); - - END_INTERFACE - } ID3D12SwapChainAssistantVtbl; - - interface ID3D12SwapChainAssistant - { - CONST_VTBL struct ID3D12SwapChainAssistantVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12SwapChainAssistant_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12SwapChainAssistant_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12SwapChainAssistant_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12SwapChainAssistant_GetLUID(This) \ - ( (This)->lpVtbl -> GetLUID(This) ) - -#define ID3D12SwapChainAssistant_GetSwapChainObject(This,riid,ppv) \ - ( (This)->lpVtbl -> GetSwapChainObject(This,riid,ppv) ) - -#define ID3D12SwapChainAssistant_GetCurrentResourceAndCommandQueue(This,riidResource,ppvResource,riidQueue,ppvQueue) \ - ( (This)->lpVtbl -> GetCurrentResourceAndCommandQueue(This,riidResource,ppvResource,riidQueue,ppvQueue) ) - -#define ID3D12SwapChainAssistant_InsertImplicitSync(This) \ - ( (This)->lpVtbl -> InsertImplicitSync(This) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - - - - - -#endif /* __ID3D12SwapChainAssistant_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12LifetimeTracker_INTERFACE_DEFINED__ -#define __ID3D12LifetimeTracker_INTERFACE_DEFINED__ - -/* interface ID3D12LifetimeTracker */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12LifetimeTracker; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("3fd03d36-4eb1-424a-a582-494ecb8ba813") - ID3D12LifetimeTracker : public ID3D12DeviceChild - { - public: - virtual HRESULT STDMETHODCALLTYPE DestroyOwnedObject( - _In_ ID3D12DeviceChild *pObject) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12LifetimeTrackerVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12LifetimeTracker * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12LifetimeTracker * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12LifetimeTracker * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12LifetimeTracker * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12LifetimeTracker * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12LifetimeTracker * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12LifetimeTracker * This, - _In_z_ LPCWSTR Name); - - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12LifetimeTracker * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - HRESULT ( STDMETHODCALLTYPE *DestroyOwnedObject )( - ID3D12LifetimeTracker * This, - _In_ ID3D12DeviceChild *pObject); - - END_INTERFACE - } ID3D12LifetimeTrackerVtbl; - - interface ID3D12LifetimeTracker - { - CONST_VTBL struct ID3D12LifetimeTrackerVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12LifetimeTracker_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12LifetimeTracker_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12LifetimeTracker_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12LifetimeTracker_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12LifetimeTracker_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12LifetimeTracker_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12LifetimeTracker_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12LifetimeTracker_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - - -#define ID3D12LifetimeTracker_DestroyOwnedObject(This,pObject) \ - ( (This)->lpVtbl -> DestroyOwnedObject(This,pObject) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12LifetimeTracker_INTERFACE_DEFINED__ */ - - -/* interface __MIDL_itf_d3d12_0000_0032 */ -/* [local] */ - -typedef -enum D3D12_META_COMMAND_PARAMETER_TYPE - { - D3D12_META_COMMAND_PARAMETER_TYPE_FLOAT = 0, - D3D12_META_COMMAND_PARAMETER_TYPE_UINT64 = 1, - D3D12_META_COMMAND_PARAMETER_TYPE_GPU_VIRTUAL_ADDRESS = 2, - D3D12_META_COMMAND_PARAMETER_TYPE_CPU_DESCRIPTOR_HANDLE_HEAP_TYPE_CBV_SRV_UAV = 3, - D3D12_META_COMMAND_PARAMETER_TYPE_GPU_DESCRIPTOR_HANDLE_HEAP_TYPE_CBV_SRV_UAV = 4 - } D3D12_META_COMMAND_PARAMETER_TYPE; - -typedef -enum D3D12_META_COMMAND_PARAMETER_FLAGS - { - D3D12_META_COMMAND_PARAMETER_FLAG_INPUT = 0x1, - D3D12_META_COMMAND_PARAMETER_FLAG_OUTPUT = 0x2 - } D3D12_META_COMMAND_PARAMETER_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_META_COMMAND_PARAMETER_FLAGS ); -typedef -enum D3D12_META_COMMAND_PARAMETER_STAGE - { - D3D12_META_COMMAND_PARAMETER_STAGE_CREATION = 0, - D3D12_META_COMMAND_PARAMETER_STAGE_INITIALIZATION = 1, - D3D12_META_COMMAND_PARAMETER_STAGE_EXECUTION = 2 - } D3D12_META_COMMAND_PARAMETER_STAGE; - -typedef struct D3D12_META_COMMAND_PARAMETER_DESC - { - LPCWSTR Name; - D3D12_META_COMMAND_PARAMETER_TYPE Type; - D3D12_META_COMMAND_PARAMETER_FLAGS Flags; - D3D12_RESOURCE_STATES RequiredResourceState; - UINT StructureOffset; - } D3D12_META_COMMAND_PARAMETER_DESC; - -typedef -enum D3D12_GRAPHICS_STATES - { - D3D12_GRAPHICS_STATE_NONE = 0, - D3D12_GRAPHICS_STATE_IA_VERTEX_BUFFERS = ( 1 << 0 ) , - D3D12_GRAPHICS_STATE_IA_INDEX_BUFFER = ( 1 << 1 ) , - D3D12_GRAPHICS_STATE_IA_PRIMITIVE_TOPOLOGY = ( 1 << 2 ) , - D3D12_GRAPHICS_STATE_DESCRIPTOR_HEAP = ( 1 << 3 ) , - D3D12_GRAPHICS_STATE_GRAPHICS_ROOT_SIGNATURE = ( 1 << 4 ) , - D3D12_GRAPHICS_STATE_COMPUTE_ROOT_SIGNATURE = ( 1 << 5 ) , - D3D12_GRAPHICS_STATE_RS_VIEWPORTS = ( 1 << 6 ) , - D3D12_GRAPHICS_STATE_RS_SCISSOR_RECTS = ( 1 << 7 ) , - D3D12_GRAPHICS_STATE_PREDICATION = ( 1 << 8 ) , - D3D12_GRAPHICS_STATE_OM_RENDER_TARGETS = ( 1 << 9 ) , - D3D12_GRAPHICS_STATE_OM_STENCIL_REF = ( 1 << 10 ) , - D3D12_GRAPHICS_STATE_OM_BLEND_FACTOR = ( 1 << 11 ) , - D3D12_GRAPHICS_STATE_PIPELINE_STATE = ( 1 << 12 ) , - D3D12_GRAPHICS_STATE_SO_TARGETS = ( 1 << 13 ) , - D3D12_GRAPHICS_STATE_OM_DEPTH_BOUNDS = ( 1 << 14 ) , - D3D12_GRAPHICS_STATE_SAMPLE_POSITIONS = ( 1 << 15 ) , - D3D12_GRAPHICS_STATE_VIEW_INSTANCE_MASK = ( 1 << 16 ) - } D3D12_GRAPHICS_STATES; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_GRAPHICS_STATES ); -typedef struct D3D12_META_COMMAND_DESC - { - GUID Id; - LPCWSTR Name; - D3D12_GRAPHICS_STATES InitializationDirtyState; - D3D12_GRAPHICS_STATES ExecutionDirtyState; - } D3D12_META_COMMAND_DESC; - - - -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0032_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0032_v0_0_s_ifspec; - -#ifndef __ID3D12StateObject_INTERFACE_DEFINED__ -#define __ID3D12StateObject_INTERFACE_DEFINED__ - -/* interface ID3D12StateObject */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12StateObject; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("47016943-fca8-4594-93ea-af258b55346d") - ID3D12StateObject : public ID3D12Pageable - { - public: - }; - - -#else /* C style interface */ - - typedef struct ID3D12StateObjectVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12StateObject * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12StateObject * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12StateObject * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12StateObject * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12StateObject * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12StateObject * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12StateObject * This, - _In_z_ LPCWSTR Name); - - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12StateObject * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - END_INTERFACE - } ID3D12StateObjectVtbl; - - interface ID3D12StateObject - { - CONST_VTBL struct ID3D12StateObjectVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12StateObject_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12StateObject_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12StateObject_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12StateObject_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12StateObject_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12StateObject_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12StateObject_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12StateObject_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - - - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12StateObject_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12StateObjectProperties_INTERFACE_DEFINED__ -#define __ID3D12StateObjectProperties_INTERFACE_DEFINED__ - -/* interface ID3D12StateObjectProperties */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12StateObjectProperties; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("de5fa827-9bf9-4f26-89ff-d7f56fde3860") - ID3D12StateObjectProperties : public IUnknown - { - public: - virtual void *STDMETHODCALLTYPE GetShaderIdentifier( - _In_ LPCWSTR pExportName) = 0; - - virtual UINT64 STDMETHODCALLTYPE GetShaderStackSize( - _In_ LPCWSTR pExportName) = 0; - - virtual UINT64 STDMETHODCALLTYPE GetPipelineStackSize( void) = 0; - - virtual void STDMETHODCALLTYPE SetPipelineStackSize( - UINT64 PipelineStackSizeInBytes) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12StateObjectPropertiesVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12StateObjectProperties * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12StateObjectProperties * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12StateObjectProperties * This); - - void *( STDMETHODCALLTYPE *GetShaderIdentifier )( - ID3D12StateObjectProperties * This, - _In_ LPCWSTR pExportName); - - UINT64 ( STDMETHODCALLTYPE *GetShaderStackSize )( - ID3D12StateObjectProperties * This, - _In_ LPCWSTR pExportName); - - UINT64 ( STDMETHODCALLTYPE *GetPipelineStackSize )( - ID3D12StateObjectProperties * This); - - void ( STDMETHODCALLTYPE *SetPipelineStackSize )( - ID3D12StateObjectProperties * This, - UINT64 PipelineStackSizeInBytes); - - END_INTERFACE - } ID3D12StateObjectPropertiesVtbl; - - interface ID3D12StateObjectProperties - { - CONST_VTBL struct ID3D12StateObjectPropertiesVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12StateObjectProperties_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12StateObjectProperties_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12StateObjectProperties_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12StateObjectProperties_GetShaderIdentifier(This,pExportName) \ - ( (This)->lpVtbl -> GetShaderIdentifier(This,pExportName) ) - -#define ID3D12StateObjectProperties_GetShaderStackSize(This,pExportName) \ - ( (This)->lpVtbl -> GetShaderStackSize(This,pExportName) ) - -#define ID3D12StateObjectProperties_GetPipelineStackSize(This) \ - ( (This)->lpVtbl -> GetPipelineStackSize(This) ) - -#define ID3D12StateObjectProperties_SetPipelineStackSize(This,PipelineStackSizeInBytes) \ - ( (This)->lpVtbl -> SetPipelineStackSize(This,PipelineStackSizeInBytes) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12StateObjectProperties_INTERFACE_DEFINED__ */ - - -/* interface __MIDL_itf_d3d12_0000_0034 */ -/* [local] */ - -typedef -enum D3D12_STATE_SUBOBJECT_TYPE - { - D3D12_STATE_SUBOBJECT_TYPE_STATE_OBJECT_CONFIG = 0, - D3D12_STATE_SUBOBJECT_TYPE_GLOBAL_ROOT_SIGNATURE = 1, - D3D12_STATE_SUBOBJECT_TYPE_LOCAL_ROOT_SIGNATURE = 2, - D3D12_STATE_SUBOBJECT_TYPE_NODE_MASK = 3, - D3D12_STATE_SUBOBJECT_TYPE_DXIL_LIBRARY = 5, - D3D12_STATE_SUBOBJECT_TYPE_EXISTING_COLLECTION = 6, - D3D12_STATE_SUBOBJECT_TYPE_SUBOBJECT_TO_EXPORTS_ASSOCIATION = 7, - D3D12_STATE_SUBOBJECT_TYPE_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION = 8, - D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_SHADER_CONFIG = 9, - D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG = 10, - D3D12_STATE_SUBOBJECT_TYPE_HIT_GROUP = 11, - D3D12_STATE_SUBOBJECT_TYPE_MAX_VALID = ( D3D12_STATE_SUBOBJECT_TYPE_HIT_GROUP + 1 ) - } D3D12_STATE_SUBOBJECT_TYPE; - -typedef struct D3D12_STATE_SUBOBJECT - { - D3D12_STATE_SUBOBJECT_TYPE Type; - const void *pDesc; - } D3D12_STATE_SUBOBJECT; - -typedef -enum D3D12_STATE_OBJECT_FLAGS - { - D3D12_STATE_OBJECT_FLAG_NONE = 0, - D3D12_STATE_OBJECT_FLAG_ALLOW_LOCAL_DEPENDENCIES_ON_EXTERNAL_DEFINITIONS = 0x1, - D3D12_STATE_OBJECT_FLAG_ALLOW_EXTERNAL_DEPENDENCIES_ON_LOCAL_DEFINITIONS = 0x2 - } D3D12_STATE_OBJECT_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_STATE_OBJECT_FLAGS ); -typedef struct D3D12_STATE_OBJECT_CONFIG - { - D3D12_STATE_OBJECT_FLAGS Flags; - } D3D12_STATE_OBJECT_CONFIG; - -typedef struct D3D12_GLOBAL_ROOT_SIGNATURE - { - ID3D12RootSignature *pGlobalRootSignature; - } D3D12_GLOBAL_ROOT_SIGNATURE; - -typedef struct D3D12_LOCAL_ROOT_SIGNATURE - { - ID3D12RootSignature *pLocalRootSignature; - } D3D12_LOCAL_ROOT_SIGNATURE; - -typedef struct D3D12_NODE_MASK - { - UINT NodeMask; - } D3D12_NODE_MASK; - -typedef -enum D3D12_EXPORT_FLAGS - { - D3D12_EXPORT_FLAG_NONE = 0 - } D3D12_EXPORT_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_EXPORT_FLAGS ); -typedef struct D3D12_EXPORT_DESC - { - LPCWSTR Name; - _In_opt_ LPCWSTR ExportToRename; - D3D12_EXPORT_FLAGS Flags; - } D3D12_EXPORT_DESC; - -typedef struct D3D12_DXIL_LIBRARY_DESC - { - D3D12_SHADER_BYTECODE DXILLibrary; - UINT NumExports; - _In_reads_(NumExports) D3D12_EXPORT_DESC *pExports; - } D3D12_DXIL_LIBRARY_DESC; - -typedef struct D3D12_EXISTING_COLLECTION_DESC - { - ID3D12StateObject *pExistingCollection; - UINT NumExports; - _In_reads_(NumExports) D3D12_EXPORT_DESC *pExports; - } D3D12_EXISTING_COLLECTION_DESC; - -typedef struct D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION - { - const D3D12_STATE_SUBOBJECT *pSubobjectToAssociate; - UINT NumExports; - _In_reads_(NumExports) LPCWSTR *pExports; - } D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION; - -typedef struct D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION - { - LPCWSTR SubobjectToAssociate; - UINT NumExports; - _In_reads_(NumExports) LPCWSTR *pExports; - } D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION; - -typedef -enum D3D12_HIT_GROUP_TYPE - { - D3D12_HIT_GROUP_TYPE_TRIANGLES = 0, - D3D12_HIT_GROUP_TYPE_PROCEDURAL_PRIMITIVE = 0x1 - } D3D12_HIT_GROUP_TYPE; - -typedef struct D3D12_HIT_GROUP_DESC - { - LPCWSTR HitGroupExport; - D3D12_HIT_GROUP_TYPE Type; - _In_opt_ LPCWSTR AnyHitShaderImport; - _In_opt_ LPCWSTR ClosestHitShaderImport; - _In_opt_ LPCWSTR IntersectionShaderImport; - } D3D12_HIT_GROUP_DESC; - -typedef struct D3D12_RAYTRACING_SHADER_CONFIG - { - UINT MaxPayloadSizeInBytes; - UINT MaxAttributeSizeInBytes; - } D3D12_RAYTRACING_SHADER_CONFIG; - -typedef struct D3D12_RAYTRACING_PIPELINE_CONFIG - { - UINT MaxTraceRecursionDepth; - } D3D12_RAYTRACING_PIPELINE_CONFIG; - -typedef -enum D3D12_STATE_OBJECT_TYPE - { - D3D12_STATE_OBJECT_TYPE_COLLECTION = 0, - D3D12_STATE_OBJECT_TYPE_RAYTRACING_PIPELINE = 3 - } D3D12_STATE_OBJECT_TYPE; - -typedef struct D3D12_STATE_OBJECT_DESC - { - D3D12_STATE_OBJECT_TYPE Type; - UINT NumSubobjects; - _In_reads_(NumSubobjects) const D3D12_STATE_SUBOBJECT *pSubobjects; - } D3D12_STATE_OBJECT_DESC; - -typedef -enum D3D12_RAYTRACING_GEOMETRY_FLAGS - { - D3D12_RAYTRACING_GEOMETRY_FLAG_NONE = 0, - D3D12_RAYTRACING_GEOMETRY_FLAG_OPAQUE = 0x1, - D3D12_RAYTRACING_GEOMETRY_FLAG_NO_DUPLICATE_ANYHIT_INVOCATION = 0x2 - } D3D12_RAYTRACING_GEOMETRY_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAYTRACING_GEOMETRY_FLAGS ); -typedef -enum D3D12_RAYTRACING_GEOMETRY_TYPE - { - D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES = 0, - D3D12_RAYTRACING_GEOMETRY_TYPE_PROCEDURAL_PRIMITIVE_AABBS = ( D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES + 1 ) - } D3D12_RAYTRACING_GEOMETRY_TYPE; - -typedef -enum D3D12_RAYTRACING_INSTANCE_FLAGS - { - D3D12_RAYTRACING_INSTANCE_FLAG_NONE = 0, - D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_CULL_DISABLE = 0x1, - D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_FRONT_COUNTERCLOCKWISE = 0x2, - D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_OPAQUE = 0x4, - D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_NON_OPAQUE = 0x8 - } D3D12_RAYTRACING_INSTANCE_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAYTRACING_INSTANCE_FLAGS ); -typedef struct D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE - { - D3D12_GPU_VIRTUAL_ADDRESS StartAddress; - UINT64 StrideInBytes; - } D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE; - -typedef struct D3D12_GPU_VIRTUAL_ADDRESS_RANGE - { - D3D12_GPU_VIRTUAL_ADDRESS StartAddress; - UINT64 SizeInBytes; - } D3D12_GPU_VIRTUAL_ADDRESS_RANGE; - -typedef struct D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE - { - D3D12_GPU_VIRTUAL_ADDRESS StartAddress; - UINT64 SizeInBytes; - UINT64 StrideInBytes; - } D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE; - -typedef struct D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC - { - D3D12_GPU_VIRTUAL_ADDRESS Transform3x4; - DXGI_FORMAT IndexFormat; - DXGI_FORMAT VertexFormat; - UINT IndexCount; - UINT VertexCount; - D3D12_GPU_VIRTUAL_ADDRESS IndexBuffer; - D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE VertexBuffer; - } D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC; - -typedef struct D3D12_RAYTRACING_AABB - { - FLOAT MinX; - FLOAT MinY; - FLOAT MinZ; - FLOAT MaxX; - FLOAT MaxY; - FLOAT MaxZ; - } D3D12_RAYTRACING_AABB; - -typedef struct D3D12_RAYTRACING_GEOMETRY_AABBS_DESC - { - UINT64 AABBCount; - D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE AABBs; - } D3D12_RAYTRACING_GEOMETRY_AABBS_DESC; - -typedef -enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS - { - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_NONE = 0, - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_UPDATE = 0x1, - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_COMPACTION = 0x2, - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_TRACE = 0x4, - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_BUILD = 0x8, - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_MINIMIZE_MEMORY = 0x10, - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PERFORM_UPDATE = 0x20 - } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS ); -typedef -enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE - { - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_CLONE = 0, - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_COMPACT = 0x1, - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_VISUALIZATION_DECODE_FOR_TOOLS = 0x2, - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_SERIALIZE = 0x3, - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_DESERIALIZE = 0x4 - } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE; - -typedef -enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE - { - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL = 0, - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL = 0x1 - } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE; - -typedef -enum D3D12_ELEMENTS_LAYOUT - { - D3D12_ELEMENTS_LAYOUT_ARRAY = 0, - D3D12_ELEMENTS_LAYOUT_ARRAY_OF_POINTERS = 0x1 - } D3D12_ELEMENTS_LAYOUT; - -typedef -enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE - { - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE = 0, - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION = 0x1, - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION = 0x2, - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE = 0x3 - } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE; - -typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC - { - D3D12_GPU_VIRTUAL_ADDRESS DestBuffer; - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE InfoType; - } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC; - -typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE_DESC - { - UINT64 CompactedSizeInBytes; - } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE_DESC; - -typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION_DESC - { - UINT64 DecodedSizeInBytes; - } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION_DESC; - -typedef struct D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER - { - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE Type; - UINT NumDescs; - } D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER; - -// Regarding D3D12_BUILD_RAY_TRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER above, -// depending on Type field, NumDescs above is followed by either: -// D3D12_RAY_TRACING_INSTANCE_DESC InstanceDescs[NumDescs] -// or D3D12_RAY_TRACING_GEOMETRY_DESC GeometryDescs[NumDescs]. -// There is 4 bytes of padding between GeometryDesc structs in the array so alignment is natural when viewed by CPU. - -typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION_DESC - { - UINT64 SerializedSizeInBytes; - UINT64 NumBottomLevelAccelerationStructurePointers; - } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION_DESC; - -typedef struct D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER - { - GUID DriverOpaqueGUID; - BYTE DriverOpaqueVersioningData[ 16 ]; - } D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER; - -typedef -enum D3D12_SERIALIZED_DATA_TYPE - { - D3D12_SERIALIZED_DATA_RAYTRACING_ACCELERATION_STRUCTURE = 0 - } D3D12_SERIALIZED_DATA_TYPE; - -typedef -enum D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS - { - D3D12_DRIVER_MATCHING_IDENTIFIER_COMPATIBLE_WITH_DEVICE = 0, - D3D12_DRIVER_MATCHING_IDENTIFIER_UNSUPPORTED_TYPE = 0x1, - D3D12_DRIVER_MATCHING_IDENTIFIER_UNRECOGNIZED = 0x2, - D3D12_DRIVER_MATCHING_IDENTIFIER_INCOMPATIBLE_VERSION = 0x3, - D3D12_DRIVER_MATCHING_IDENTIFIER_INCOMPATIBLE_TYPE = 0x4 - } D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS; - -typedef struct D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER - { - D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER DriverMatchingIdentifier; - UINT64 SerializedSizeInBytesIncludingHeader; - UINT64 DeserializedSizeInBytes; - UINT64 NumBottomLevelAccelerationStructurePointersAfterHeader; - } D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER; - -typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE_DESC - { - UINT64 CurrentSizeInBytes; - } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE_DESC; - -typedef struct D3D12_RAYTRACING_INSTANCE_DESC - { - FLOAT Transform[ 3 ][ 4 ]; - UINT InstanceID : 24; - UINT InstanceMask : 8; - UINT InstanceContributionToHitGroupIndex : 24; - UINT Flags : 8; - D3D12_GPU_VIRTUAL_ADDRESS AccelerationStructure; - } D3D12_RAYTRACING_INSTANCE_DESC; - -typedef struct D3D12_RAYTRACING_GEOMETRY_DESC - { - D3D12_RAYTRACING_GEOMETRY_TYPE Type; - D3D12_RAYTRACING_GEOMETRY_FLAGS Flags; - union - { - D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC Triangles; - D3D12_RAYTRACING_GEOMETRY_AABBS_DESC AABBs; - } ; - } D3D12_RAYTRACING_GEOMETRY_DESC; - -typedef struct D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS - { - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE Type; - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS Flags; - UINT NumDescs; - D3D12_ELEMENTS_LAYOUT DescsLayout; - union - { - D3D12_GPU_VIRTUAL_ADDRESS InstanceDescs; - const D3D12_RAYTRACING_GEOMETRY_DESC *pGeometryDescs; - const D3D12_RAYTRACING_GEOMETRY_DESC *const *ppGeometryDescs; - } ; - } D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS; - -typedef struct D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC - { - D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData; - D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS Inputs; - _In_opt_ D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData; - D3D12_GPU_VIRTUAL_ADDRESS ScratchAccelerationStructureData; - } D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC; - -typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO - { - UINT64 ResultDataMaxSizeInBytes; - UINT64 ScratchDataSizeInBytes; - UINT64 UpdateScratchDataSizeInBytes; - } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO; - -typedef -enum D3D12_RAY_FLAGS - { - D3D12_RAY_FLAG_NONE = 0, - D3D12_RAY_FLAG_FORCE_OPAQUE = 0x1, - D3D12_RAY_FLAG_FORCE_NON_OPAQUE = 0x2, - D3D12_RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH = 0x4, - D3D12_RAY_FLAG_SKIP_CLOSEST_HIT_SHADER = 0x8, - D3D12_RAY_FLAG_CULL_BACK_FACING_TRIANGLES = 0x10, - D3D12_RAY_FLAG_CULL_FRONT_FACING_TRIANGLES = 0x20, - D3D12_RAY_FLAG_CULL_OPAQUE = 0x40, - D3D12_RAY_FLAG_CULL_NON_OPAQUE = 0x80 - } D3D12_RAY_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAY_FLAGS ); -typedef -enum D3D12_HIT_KIND - { - D3D12_HIT_KIND_TRIANGLE_FRONT_FACE = 0xfe, - D3D12_HIT_KIND_TRIANGLE_BACK_FACE = 0xff - } D3D12_HIT_KIND; - - - -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0034_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0034_v0_0_s_ifspec; - -#ifndef __ID3D12Device5_INTERFACE_DEFINED__ -#define __ID3D12Device5_INTERFACE_DEFINED__ - -/* interface ID3D12Device5 */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12Device5; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("8b4f173b-2fea-4b80-8f58-4307191ab95d") - ID3D12Device5 : public ID3D12Device4 - { - public: - virtual HRESULT STDMETHODCALLTYPE CreateLifetimeTracker( - _In_ ID3D12LifetimeOwner *pOwner, - REFIID riid, - _COM_Outptr_ void **ppvTracker) = 0; - - virtual void STDMETHODCALLTYPE RemoveDevice( void) = 0; - - virtual HRESULT STDMETHODCALLTYPE EnumerateMetaCommands( - _Inout_ UINT *pNumMetaCommands, - _Out_writes_opt_(*pNumMetaCommands) D3D12_META_COMMAND_DESC *pDescs) = 0; - - virtual HRESULT STDMETHODCALLTYPE EnumerateMetaCommandParameters( - _In_ REFGUID CommandId, - _In_ D3D12_META_COMMAND_PARAMETER_STAGE Stage, - _Out_opt_ UINT *pTotalStructureSizeInBytes, - _Inout_ UINT *pParameterCount, - _Out_writes_opt_(*pParameterCount) D3D12_META_COMMAND_PARAMETER_DESC *pParameterDescs) = 0; - - virtual HRESULT STDMETHODCALLTYPE CreateMetaCommand( - _In_ REFGUID CommandId, - _In_ UINT NodeMask, - _In_reads_bytes_opt_(CreationParametersDataSizeInBytes) const void *pCreationParametersData, - _In_ SIZE_T CreationParametersDataSizeInBytes, - REFIID riid, - _COM_Outptr_ void **ppMetaCommand) = 0; - - virtual HRESULT STDMETHODCALLTYPE CreateStateObject( - const D3D12_STATE_OBJECT_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppStateObject) = 0; - - virtual void STDMETHODCALLTYPE GetRaytracingAccelerationStructurePrebuildInfo( - _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *pDesc, - _Out_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo) = 0; - - virtual D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS STDMETHODCALLTYPE CheckDriverMatchingIdentifier( - _In_ D3D12_SERIALIZED_DATA_TYPE SerializedDataType, - _In_ const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *pIdentifierToCheck) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12Device5Vtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12Device5 * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12Device5 * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12Device5 * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12Device5 * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12Device5 * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12Device5 * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12Device5 * This, - _In_z_ LPCWSTR Name); - - UINT ( STDMETHODCALLTYPE *GetNodeCount )( - ID3D12Device5 * This); - - HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( - ID3D12Device5 * This, - _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppCommandQueue); - - HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( - ID3D12Device5 * This, - _In_ D3D12_COMMAND_LIST_TYPE type, - REFIID riid, - _COM_Outptr_ void **ppCommandAllocator); - - HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( - ID3D12Device5 * This, - _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); - - HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( - ID3D12Device5 * This, - _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); - - HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( - ID3D12Device5 * This, - _In_ UINT nodeMask, - _In_ D3D12_COMMAND_LIST_TYPE type, - _In_ ID3D12CommandAllocator *pCommandAllocator, - _In_opt_ ID3D12PipelineState *pInitialState, - REFIID riid, - _COM_Outptr_ void **ppCommandList); - - HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( - ID3D12Device5 * This, - D3D12_FEATURE Feature, - _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, - UINT FeatureSupportDataSize); - - HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( - ID3D12Device5 * This, - _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, - REFIID riid, - _COM_Outptr_ void **ppvHeap); - - UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( - ID3D12Device5 * This, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType); - - HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( - ID3D12Device5 * This, - _In_ UINT nodeMask, - _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, - _In_ SIZE_T blobLengthInBytes, - REFIID riid, - _COM_Outptr_ void **ppvRootSignature); - - void ( STDMETHODCALLTYPE *CreateConstantBufferView )( - ID3D12Device5 * This, - _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateShaderResourceView )( - ID3D12Device5 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( - ID3D12Device5 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ ID3D12Resource *pCounterResource, - _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateRenderTargetView )( - ID3D12Device5 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateDepthStencilView )( - ID3D12Device5 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateSampler )( - ID3D12Device5 * This, - _In_ const D3D12_SAMPLER_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CopyDescriptors )( - ID3D12Device5 * This, - _In_ UINT NumDestDescriptorRanges, - _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts, - _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes, - _In_ UINT NumSrcDescriptorRanges, - _In_reads_(NumSrcDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts, - _In_reads_opt_(NumSrcDescriptorRanges) const UINT *pSrcDescriptorRangeSizes, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); - - void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( - ID3D12Device5 * This, - _In_ UINT NumDescriptors, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); - - D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( - ID3D12Device5 * This, - _In_ UINT visibleMask, - _In_ UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); - - D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( - ID3D12Device5 * This, - _In_ UINT nodeMask, - D3D12_HEAP_TYPE heapType); - - HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( - ID3D12Device5 * This, - _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, - D3D12_HEAP_FLAGS HeapFlags, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialResourceState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riidResource, - _COM_Outptr_opt_ void **ppvResource); - - HRESULT ( STDMETHODCALLTYPE *CreateHeap )( - ID3D12Device5 * This, - _In_ const D3D12_HEAP_DESC *pDesc, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap); - - HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( - ID3D12Device5 * This, - _In_ ID3D12Heap *pHeap, - UINT64 HeapOffset, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); - - HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( - ID3D12Device5 * This, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); - - HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( - ID3D12Device5 * This, - _In_ ID3D12DeviceChild *pObject, - _In_opt_ const SECURITY_ATTRIBUTES *pAttributes, - DWORD Access, - _In_opt_ LPCWSTR Name, - _Out_ HANDLE *pHandle); - - HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( - ID3D12Device5 * This, - _In_ HANDLE NTHandle, - REFIID riid, - _COM_Outptr_opt_ void **ppvObj); - - HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( - ID3D12Device5 * This, - _In_ LPCWSTR Name, - DWORD Access, - /* [annotation][out] */ - _Out_ HANDLE *pNTHandle); - - HRESULT ( STDMETHODCALLTYPE *MakeResident )( - ID3D12Device5 * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); - - HRESULT ( STDMETHODCALLTYPE *Evict )( - ID3D12Device5 * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); - - HRESULT ( STDMETHODCALLTYPE *CreateFence )( - ID3D12Device5 * This, - UINT64 InitialValue, - D3D12_FENCE_FLAGS Flags, - REFIID riid, - _COM_Outptr_ void **ppFence); - - HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( - ID3D12Device5 * This); - - void ( STDMETHODCALLTYPE *GetCopyableFootprints )( - ID3D12Device5 * This, - _In_ const D3D12_RESOURCE_DESC *pResourceDesc, - _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, - _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, - UINT64 BaseOffset, - _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, - _Out_writes_opt_(NumSubresources) UINT *pNumRows, - _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, - _Out_opt_ UINT64 *pTotalBytes); - - HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( - ID3D12Device5 * This, - _In_ const D3D12_QUERY_HEAP_DESC *pDesc, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap); - - HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( - ID3D12Device5 * This, - BOOL Enable); - - HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( - ID3D12Device5 * This, - _In_ const D3D12_COMMAND_SIGNATURE_DESC *pDesc, - _In_opt_ ID3D12RootSignature *pRootSignature, - REFIID riid, - _COM_Outptr_opt_ void **ppvCommandSignature); - - void ( STDMETHODCALLTYPE *GetResourceTiling )( - ID3D12Device5 * This, - _In_ ID3D12Resource *pTiledResource, - _Out_opt_ UINT *pNumTilesForEntireResource, - _Out_opt_ D3D12_PACKED_MIP_INFO *pPackedMipDesc, - _Out_opt_ D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips, - _Inout_opt_ UINT *pNumSubresourceTilings, - _In_ UINT FirstSubresourceTilingToGet, - _Out_writes_(*pNumSubresourceTilings) D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips); - - LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( - ID3D12Device5 * This); - - HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( - ID3D12Device5 * This, - _In_reads_(BlobLength) const void *pLibraryBlob, - SIZE_T BlobLength, - REFIID riid, - _COM_Outptr_ void **ppPipelineLibrary); - - HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( - ID3D12Device5 * This, - _In_reads_(NumFences) ID3D12Fence *const *ppFences, - _In_reads_(NumFences) const UINT64 *pFenceValues, - UINT NumFences, - D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags, - HANDLE hEvent); - - HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( - ID3D12Device5 * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, - _In_reads_(NumObjects) const D3D12_RESIDENCY_PRIORITY *pPriorities); - - HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( - ID3D12Device5 * This, - const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); - - HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress )( - ID3D12Device5 * This, - _In_ const void *pAddress, - REFIID riid, - _COM_Outptr_ void **ppvHeap); - - HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromFileMapping )( - ID3D12Device5 * This, - _In_ HANDLE hFileMapping, - REFIID riid, - _COM_Outptr_ void **ppvHeap); - - HRESULT ( STDMETHODCALLTYPE *EnqueueMakeResident )( - ID3D12Device5 * This, - D3D12_RESIDENCY_FLAGS Flags, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, - _In_ ID3D12Fence *pFenceToSignal, - UINT64 FenceValueToSignal); - - HRESULT ( STDMETHODCALLTYPE *CreateCommandList1 )( - ID3D12Device5 * This, - _In_ UINT nodeMask, - _In_ D3D12_COMMAND_LIST_TYPE type, - _In_ D3D12_COMMAND_LIST_FLAGS flags, - REFIID riid, - _COM_Outptr_ void **ppCommandList); - - HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession )( - ID3D12Device5 * This, - _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC *pDesc, - _In_ REFIID riid, - _COM_Outptr_ void **ppSession); - - HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource1 )( - ID3D12Device5 * This, - _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, - D3D12_HEAP_FLAGS HeapFlags, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialResourceState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - REFIID riidResource, - _COM_Outptr_opt_ void **ppvResource); - - HRESULT ( STDMETHODCALLTYPE *CreateHeap1 )( - ID3D12Device5 * This, - _In_ const D3D12_HEAP_DESC *pDesc, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap); - - HRESULT ( STDMETHODCALLTYPE *CreateReservedResource1 )( - ID3D12Device5 * This, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); - - D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( - ID3D12Device5 * This, - UINT visibleMask, - UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, - _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); - - HRESULT ( STDMETHODCALLTYPE *CreateLifetimeTracker )( - ID3D12Device5 * This, - _In_ ID3D12LifetimeOwner *pOwner, - REFIID riid, - _COM_Outptr_ void **ppvTracker); - - void ( STDMETHODCALLTYPE *RemoveDevice )( - ID3D12Device5 * This); - - HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommands )( - ID3D12Device5 * This, - _Inout_ UINT *pNumMetaCommands, - _Out_writes_opt_(*pNumMetaCommands) D3D12_META_COMMAND_DESC *pDescs); - - HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommandParameters )( - ID3D12Device5 * This, - _In_ REFGUID CommandId, - _In_ D3D12_META_COMMAND_PARAMETER_STAGE Stage, - _Out_opt_ UINT *pTotalStructureSizeInBytes, - _Inout_ UINT *pParameterCount, - _Out_writes_opt_(*pParameterCount) D3D12_META_COMMAND_PARAMETER_DESC *pParameterDescs); - - HRESULT ( STDMETHODCALLTYPE *CreateMetaCommand )( - ID3D12Device5 * This, - _In_ REFGUID CommandId, - _In_ UINT NodeMask, - _In_reads_bytes_opt_(CreationParametersDataSizeInBytes) const void *pCreationParametersData, - _In_ SIZE_T CreationParametersDataSizeInBytes, - REFIID riid, - _COM_Outptr_ void **ppMetaCommand); - - HRESULT ( STDMETHODCALLTYPE *CreateStateObject )( - ID3D12Device5 * This, - const D3D12_STATE_OBJECT_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppStateObject); - - void ( STDMETHODCALLTYPE *GetRaytracingAccelerationStructurePrebuildInfo )( - ID3D12Device5 * This, - _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *pDesc, - _Out_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo); - - D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS ( STDMETHODCALLTYPE *CheckDriverMatchingIdentifier )( - ID3D12Device5 * This, - _In_ D3D12_SERIALIZED_DATA_TYPE SerializedDataType, - _In_ const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *pIdentifierToCheck); - - END_INTERFACE - } ID3D12Device5Vtbl; - - interface ID3D12Device5 - { - CONST_VTBL struct ID3D12Device5Vtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12Device5_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12Device5_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12Device5_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12Device5_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12Device5_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12Device5_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12Device5_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12Device5_GetNodeCount(This) \ - ( (This)->lpVtbl -> GetNodeCount(This) ) - -#define ID3D12Device5_CreateCommandQueue(This,pDesc,riid,ppCommandQueue) \ - ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) - -#define ID3D12Device5_CreateCommandAllocator(This,type,riid,ppCommandAllocator) \ - ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) - -#define ID3D12Device5_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) - -#define ID3D12Device5_CreateComputePipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) - -#define ID3D12Device5_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) \ - ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) - -#define ID3D12Device5_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) \ - ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) - -#define ID3D12Device5_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) - -#define ID3D12Device5_GetDescriptorHandleIncrementSize(This,DescriptorHeapType) \ - ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) - -#define ID3D12Device5_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) \ - ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) - -#define ID3D12Device5_CreateConstantBufferView(This,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) - -#define ID3D12Device5_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) - -#define ID3D12Device5_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) - -#define ID3D12Device5_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) - -#define ID3D12Device5_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) - -#define ID3D12Device5_CreateSampler(This,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) - -#define ID3D12Device5_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) \ - ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) - -#define ID3D12Device5_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) \ - ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) - -#define ID3D12Device5_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) - -#define ID3D12Device5_GetCustomHeapProperties(This,nodeMask,heapType) \ - ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) - -#define ID3D12Device5_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) \ - ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) - -#define ID3D12Device5_CreateHeap(This,pDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) - -#define ID3D12Device5_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ - ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) - -#define ID3D12Device5_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ - ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) - -#define ID3D12Device5_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) \ - ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) - -#define ID3D12Device5_OpenSharedHandle(This,NTHandle,riid,ppvObj) \ - ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) - -#define ID3D12Device5_OpenSharedHandleByName(This,Name,Access,pNTHandle) \ - ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) - -#define ID3D12Device5_MakeResident(This,NumObjects,ppObjects) \ - ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) - -#define ID3D12Device5_Evict(This,NumObjects,ppObjects) \ - ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) - -#define ID3D12Device5_CreateFence(This,InitialValue,Flags,riid,ppFence) \ - ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) - -#define ID3D12Device5_GetDeviceRemovedReason(This) \ - ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) - -#define ID3D12Device5_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ - ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) - -#define ID3D12Device5_CreateQueryHeap(This,pDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) - -#define ID3D12Device5_SetStablePowerState(This,Enable) \ - ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) - -#define ID3D12Device5_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) \ - ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) - -#define ID3D12Device5_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) \ - ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) - -#define ID3D12Device5_GetAdapterLuid(This) \ - ( (This)->lpVtbl -> GetAdapterLuid(This) ) - - -#define ID3D12Device5_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) \ - ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) - -#define ID3D12Device5_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) \ - ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) - -#define ID3D12Device5_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) \ - ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) - - -#define ID3D12Device5_CreatePipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) - - -#define ID3D12Device5_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) \ - ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) - -#define ID3D12Device5_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) \ - ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) - -#define ID3D12Device5_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) \ - ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) - - -#define ID3D12Device5_CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) \ - ( (This)->lpVtbl -> CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) ) - -#define ID3D12Device5_CreateProtectedResourceSession(This,pDesc,riid,ppSession) \ - ( (This)->lpVtbl -> CreateProtectedResourceSession(This,pDesc,riid,ppSession) ) - -#define ID3D12Device5_CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ - ( (This)->lpVtbl -> CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) - -#define ID3D12Device5_CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) ) - -#define ID3D12Device5_CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) \ - ( (This)->lpVtbl -> CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) ) - -#define ID3D12Device5_GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) - - -#define ID3D12Device5_CreateLifetimeTracker(This,pOwner,riid,ppvTracker) \ - ( (This)->lpVtbl -> CreateLifetimeTracker(This,pOwner,riid,ppvTracker) ) - -#define ID3D12Device5_RemoveDevice(This) \ - ( (This)->lpVtbl -> RemoveDevice(This) ) - -#define ID3D12Device5_EnumerateMetaCommands(This,pNumMetaCommands,pDescs) \ - ( (This)->lpVtbl -> EnumerateMetaCommands(This,pNumMetaCommands,pDescs) ) - -#define ID3D12Device5_EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) \ - ( (This)->lpVtbl -> EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) ) - -#define ID3D12Device5_CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) \ - ( (This)->lpVtbl -> CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) ) - -#define ID3D12Device5_CreateStateObject(This,pDesc,riid,ppStateObject) \ - ( (This)->lpVtbl -> CreateStateObject(This,pDesc,riid,ppStateObject) ) - -#define ID3D12Device5_GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) \ - ( (This)->lpVtbl -> GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) ) - -#define ID3D12Device5_CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) \ - ( (This)->lpVtbl -> CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12Device5_INTERFACE_DEFINED__ */ - - -/* interface __MIDL_itf_d3d12_0000_0035 */ -/* [local] */ - -typedef -enum D3D12_AUTO_BREADCRUMB_OP - { - D3D12_AUTO_BREADCRUMB_OP_SETMARKER = 0, - D3D12_AUTO_BREADCRUMB_OP_BEGINEVENT = 1, - D3D12_AUTO_BREADCRUMB_OP_ENDEVENT = 2, - D3D12_AUTO_BREADCRUMB_OP_DRAWINSTANCED = 3, - D3D12_AUTO_BREADCRUMB_OP_DRAWINDEXEDINSTANCED = 4, - D3D12_AUTO_BREADCRUMB_OP_EXECUTEINDIRECT = 5, - D3D12_AUTO_BREADCRUMB_OP_DISPATCH = 6, - D3D12_AUTO_BREADCRUMB_OP_COPYBUFFERREGION = 7, - D3D12_AUTO_BREADCRUMB_OP_COPYTEXTUREREGION = 8, - D3D12_AUTO_BREADCRUMB_OP_COPYRESOURCE = 9, - D3D12_AUTO_BREADCRUMB_OP_COPYTILES = 10, - D3D12_AUTO_BREADCRUMB_OP_RESOLVESUBRESOURCE = 11, - D3D12_AUTO_BREADCRUMB_OP_CLEARRENDERTARGETVIEW = 12, - D3D12_AUTO_BREADCRUMB_OP_CLEARUNORDEREDACCESSVIEW = 13, - D3D12_AUTO_BREADCRUMB_OP_CLEARDEPTHSTENCILVIEW = 14, - D3D12_AUTO_BREADCRUMB_OP_RESOURCEBARRIER = 15, - D3D12_AUTO_BREADCRUMB_OP_EXECUTEBUNDLE = 16, - D3D12_AUTO_BREADCRUMB_OP_PRESENT = 17, - D3D12_AUTO_BREADCRUMB_OP_RESOLVEQUERYDATA = 18, - D3D12_AUTO_BREADCRUMB_OP_BEGINSUBMISSION = 19, - D3D12_AUTO_BREADCRUMB_OP_ENDSUBMISSION = 20, - D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME = 21, - D3D12_AUTO_BREADCRUMB_OP_PROCESSFRAMES = 22, - D3D12_AUTO_BREADCRUMB_OP_ATOMICCOPYBUFFERUINT = 23, - D3D12_AUTO_BREADCRUMB_OP_ATOMICCOPYBUFFERUINT64 = 24, - D3D12_AUTO_BREADCRUMB_OP_RESOLVESUBRESOURCEREGION = 25, - D3D12_AUTO_BREADCRUMB_OP_WRITEBUFFERIMMEDIATE = 26, - D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME1 = 27, - D3D12_AUTO_BREADCRUMB_OP_SETPROTECTEDRESOURCESESSION = 28, - D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME2 = 29, - D3D12_AUTO_BREADCRUMB_OP_PROCESSFRAMES1 = 30, - D3D12_AUTO_BREADCRUMB_OP_BUILDRAYTRACINGACCELERATIONSTRUCTURE = 31, - D3D12_AUTO_BREADCRUMB_OP_EMITRAYTRACINGACCELERATIONSTRUCTUREPOSTBUILDINFO = 32, - D3D12_AUTO_BREADCRUMB_OP_COPYRAYTRACINGACCELERATIONSTRUCTURE = 33, - D3D12_AUTO_BREADCRUMB_OP_DISPATCHRAYS = 34, - D3D12_AUTO_BREADCRUMB_OP_INITIALIZEMETACOMMAND = 35, - D3D12_AUTO_BREADCRUMB_OP_EXECUTEMETACOMMAND = 36, - D3D12_AUTO_BREADCRUMB_OP_ESTIMATEMOTION = 37, - D3D12_AUTO_BREADCRUMB_OP_RESOLVEMOTIONVECTORHEAP = 38, - D3D12_AUTO_BREADCRUMB_OP_SETPIPELINESTATE1 = 39, - D3D12_AUTO_BREADCRUMB_OP_INITIALIZEEXTENSIONCOMMAND = 40, - D3D12_AUTO_BREADCRUMB_OP_EXECUTEEXTENSIONCOMMAND = 41 - } D3D12_AUTO_BREADCRUMB_OP; - -typedef struct D3D12_AUTO_BREADCRUMB_NODE - { - const char *pCommandListDebugNameA; - const wchar_t *pCommandListDebugNameW; - const char *pCommandQueueDebugNameA; - const wchar_t *pCommandQueueDebugNameW; - ID3D12GraphicsCommandList *pCommandList; - ID3D12CommandQueue *pCommandQueue; - UINT32 BreadcrumbCount; - const UINT32 *pLastBreadcrumbValue; - const D3D12_AUTO_BREADCRUMB_OP *pCommandHistory; - const struct D3D12_AUTO_BREADCRUMB_NODE *pNext; - } D3D12_AUTO_BREADCRUMB_NODE; - -typedef -enum D3D12_DRED_VERSION - { - D3D12_DRED_VERSION_1_0 = 0x1, - D3D12_DRED_VERSION_1_1 = 0x2 - } D3D12_DRED_VERSION; - -typedef -enum D3D12_DRED_FLAGS - { - D3D12_DRED_FLAG_NONE = 0, - D3D12_DRED_FLAG_FORCE_ENABLE = 1, - D3D12_DRED_FLAG_DISABLE_AUTOBREADCRUMBS = 2 - } D3D12_DRED_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_DRED_FLAGS ); -typedef -enum D3D12_DRED_ENABLEMENT - { - D3D12_DRED_ENABLEMENT_SYSTEM_CONTROLLED = 0, - D3D12_DRED_ENABLEMENT_FORCED_OFF = 1, - D3D12_DRED_ENABLEMENT_FORCED_ON = 2 - } D3D12_DRED_ENABLEMENT; - -typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA - { - _In_ D3D12_DRED_FLAGS Flags; - _Out_ D3D12_AUTO_BREADCRUMB_NODE *pHeadAutoBreadcrumbNode; - } D3D12_DEVICE_REMOVED_EXTENDED_DATA; - -typedef -enum D3D12_DRED_ALLOCATION_TYPE - { - D3D12_DRED_ALLOCATION_TYPE_COMMAND_QUEUE = 19, - D3D12_DRED_ALLOCATION_TYPE_COMMAND_ALLOCATOR = 20, - D3D12_DRED_ALLOCATION_TYPE_PIPELINE_STATE = 21, - D3D12_DRED_ALLOCATION_TYPE_COMMAND_LIST = 22, - D3D12_DRED_ALLOCATION_TYPE_FENCE = 23, - D3D12_DRED_ALLOCATION_TYPE_DESCRIPTOR_HEAP = 24, - D3D12_DRED_ALLOCATION_TYPE_HEAP = 25, - D3D12_DRED_ALLOCATION_TYPE_QUERY_HEAP = 27, - D3D12_DRED_ALLOCATION_TYPE_COMMAND_SIGNATURE = 28, - D3D12_DRED_ALLOCATION_TYPE_PIPELINE_LIBRARY = 29, - D3D12_DRED_ALLOCATION_TYPE_VIDEO_DECODER = 30, - D3D12_DRED_ALLOCATION_TYPE_VIDEO_PROCESSOR = 32, - D3D12_DRED_ALLOCATION_TYPE_RESOURCE = 34, - D3D12_DRED_ALLOCATION_TYPE_PASS = 35, - D3D12_DRED_ALLOCATION_TYPE_CRYPTOSESSION = 36, - D3D12_DRED_ALLOCATION_TYPE_CRYPTOSESSIONPOLICY = 37, - D3D12_DRED_ALLOCATION_TYPE_PROTECTEDRESOURCESESSION = 38, - D3D12_DRED_ALLOCATION_TYPE_VIDEO_DECODER_HEAP = 39, - D3D12_DRED_ALLOCATION_TYPE_COMMAND_POOL = 40, - D3D12_DRED_ALLOCATION_TYPE_COMMAND_RECORDER = 41, - D3D12_DRED_ALLOCATION_TYPE_STATE_OBJECT = 42, - D3D12_DRED_ALLOCATION_TYPE_METACOMMAND = 43, - D3D12_DRED_ALLOCATION_TYPE_SCHEDULINGGROUP = 44, - D3D12_DRED_ALLOCATION_TYPE_VIDEO_MOTION_ESTIMATOR = 45, - D3D12_DRED_ALLOCATION_TYPE_VIDEO_MOTION_VECTOR_HEAP = 46, - D3D12_DRED_ALLOCATION_TYPE_VIDEO_EXTENSION_COMMAND = 47, - D3D12_DRED_ALLOCATION_TYPE_INVALID = 0xffffffff - } D3D12_DRED_ALLOCATION_TYPE; - -typedef struct D3D12_DRED_ALLOCATION_NODE - { - const char *ObjectNameA; - const wchar_t *ObjectNameW; - D3D12_DRED_ALLOCATION_TYPE AllocationType; - const struct D3D12_DRED_ALLOCATION_NODE *pNext; - } D3D12_DRED_ALLOCATION_NODE; - -typedef struct D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT - { - _Out_ const D3D12_AUTO_BREADCRUMB_NODE *pHeadAutoBreadcrumbNode; - } D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT; - -typedef struct D3D12_DRED_PAGE_FAULT_OUTPUT - { - D3D12_GPU_VIRTUAL_ADDRESS PageFaultVA; - _Out_ const D3D12_DRED_ALLOCATION_NODE *pHeadExistingAllocationNode; - _Out_ const D3D12_DRED_ALLOCATION_NODE *pHeadRecentFreedAllocationNode; - } D3D12_DRED_PAGE_FAULT_OUTPUT; - -typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA1 - { - HRESULT DeviceRemovedReason; - D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT AutoBreadcrumbsOutput; - D3D12_DRED_PAGE_FAULT_OUTPUT PageFaultOutput; - } D3D12_DEVICE_REMOVED_EXTENDED_DATA1; - -typedef struct D3D12_VERSIONED_DEVICE_REMOVED_EXTENDED_DATA - { - D3D12_DRED_VERSION Version; - union - { - D3D12_DEVICE_REMOVED_EXTENDED_DATA Dred_1_0; - D3D12_DEVICE_REMOVED_EXTENDED_DATA1 Dred_1_1; - } ; - } D3D12_VERSIONED_DEVICE_REMOVED_EXTENDED_DATA; - - - -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0035_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0035_v0_0_s_ifspec; - -#ifndef __ID3D12DeviceRemovedExtendedDataSettings_INTERFACE_DEFINED__ -#define __ID3D12DeviceRemovedExtendedDataSettings_INTERFACE_DEFINED__ - -/* interface ID3D12DeviceRemovedExtendedDataSettings */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12DeviceRemovedExtendedDataSettings; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("82BC481C-6B9B-4030-AEDB-7EE3D1DF1E63") - ID3D12DeviceRemovedExtendedDataSettings : public IUnknown - { - public: - virtual void STDMETHODCALLTYPE SetAutoBreadcrumbsEnablement( - D3D12_DRED_ENABLEMENT __MIDL__ID3D12DeviceRemovedExtendedDataSettings0000) = 0; - - virtual void STDMETHODCALLTYPE SetPageFaultEnablement( - D3D12_DRED_ENABLEMENT __MIDL__ID3D12DeviceRemovedExtendedDataSettings0001) = 0; - - virtual void STDMETHODCALLTYPE SetWatsonDumpEnablement( - D3D12_DRED_ENABLEMENT __MIDL__ID3D12DeviceRemovedExtendedDataSettings0002) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12DeviceRemovedExtendedDataSettingsVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12DeviceRemovedExtendedDataSettings * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12DeviceRemovedExtendedDataSettings * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12DeviceRemovedExtendedDataSettings * This); - - void ( STDMETHODCALLTYPE *SetAutoBreadcrumbsEnablement )( - ID3D12DeviceRemovedExtendedDataSettings * This, - D3D12_DRED_ENABLEMENT __MIDL__ID3D12DeviceRemovedExtendedDataSettings0000); - - void ( STDMETHODCALLTYPE *SetPageFaultEnablement )( - ID3D12DeviceRemovedExtendedDataSettings * This, - D3D12_DRED_ENABLEMENT __MIDL__ID3D12DeviceRemovedExtendedDataSettings0001); - - void ( STDMETHODCALLTYPE *SetWatsonDumpEnablement )( - ID3D12DeviceRemovedExtendedDataSettings * This, - D3D12_DRED_ENABLEMENT __MIDL__ID3D12DeviceRemovedExtendedDataSettings0002); - - END_INTERFACE - } ID3D12DeviceRemovedExtendedDataSettingsVtbl; - - interface ID3D12DeviceRemovedExtendedDataSettings - { - CONST_VTBL struct ID3D12DeviceRemovedExtendedDataSettingsVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12DeviceRemovedExtendedDataSettings_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12DeviceRemovedExtendedDataSettings_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12DeviceRemovedExtendedDataSettings_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12DeviceRemovedExtendedDataSettings_SetAutoBreadcrumbsEnablement(This,__MIDL__ID3D12DeviceRemovedExtendedDataSettings0000) \ - ( (This)->lpVtbl -> SetAutoBreadcrumbsEnablement(This,__MIDL__ID3D12DeviceRemovedExtendedDataSettings0000) ) - -#define ID3D12DeviceRemovedExtendedDataSettings_SetPageFaultEnablement(This,__MIDL__ID3D12DeviceRemovedExtendedDataSettings0001) \ - ( (This)->lpVtbl -> SetPageFaultEnablement(This,__MIDL__ID3D12DeviceRemovedExtendedDataSettings0001) ) - -#define ID3D12DeviceRemovedExtendedDataSettings_SetWatsonDumpEnablement(This,__MIDL__ID3D12DeviceRemovedExtendedDataSettings0002) \ - ( (This)->lpVtbl -> SetWatsonDumpEnablement(This,__MIDL__ID3D12DeviceRemovedExtendedDataSettings0002) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12DeviceRemovedExtendedDataSettings_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12DeviceRemovedExtendedData_INTERFACE_DEFINED__ -#define __ID3D12DeviceRemovedExtendedData_INTERFACE_DEFINED__ - -/* interface ID3D12DeviceRemovedExtendedData */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12DeviceRemovedExtendedData; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("98931D33-5AE8-4791-AA3C-1A73A2934E71") - ID3D12DeviceRemovedExtendedData : public IUnknown - { - public: - virtual HRESULT STDMETHODCALLTYPE GetAutoBreadcrumbsOutput( - D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT *pOutput) = 0; - - virtual HRESULT STDMETHODCALLTYPE GetPageFaultAllocationOutput( - D3D12_DRED_PAGE_FAULT_OUTPUT *pOutput) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12DeviceRemovedExtendedDataVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12DeviceRemovedExtendedData * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12DeviceRemovedExtendedData * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12DeviceRemovedExtendedData * This); - - HRESULT ( STDMETHODCALLTYPE *GetAutoBreadcrumbsOutput )( - ID3D12DeviceRemovedExtendedData * This, - D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT *pOutput); - - HRESULT ( STDMETHODCALLTYPE *GetPageFaultAllocationOutput )( - ID3D12DeviceRemovedExtendedData * This, - D3D12_DRED_PAGE_FAULT_OUTPUT *pOutput); - - END_INTERFACE - } ID3D12DeviceRemovedExtendedDataVtbl; - - interface ID3D12DeviceRemovedExtendedData - { - CONST_VTBL struct ID3D12DeviceRemovedExtendedDataVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12DeviceRemovedExtendedData_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12DeviceRemovedExtendedData_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12DeviceRemovedExtendedData_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12DeviceRemovedExtendedData_GetAutoBreadcrumbsOutput(This,pOutput) \ - ( (This)->lpVtbl -> GetAutoBreadcrumbsOutput(This,pOutput) ) - -#define ID3D12DeviceRemovedExtendedData_GetPageFaultAllocationOutput(This,pOutput) \ - ( (This)->lpVtbl -> GetPageFaultAllocationOutput(This,pOutput) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12DeviceRemovedExtendedData_INTERFACE_DEFINED__ */ - - -/* interface __MIDL_itf_d3d12_0000_0037 */ -/* [local] */ - -typedef -enum D3D12_BACKGROUND_PROCESSING_MODE - { - D3D12_BACKGROUND_PROCESSING_MODE_ALLOWED = 0, - D3D12_BACKGROUND_PROCESSING_MODE_ALLOW_INTRUSIVE_MEASUREMENTS = ( D3D12_BACKGROUND_PROCESSING_MODE_ALLOWED + 1 ) , - D3D12_BACKGROUND_PROCESSING_MODE_DISABLE_BACKGROUND_WORK = ( D3D12_BACKGROUND_PROCESSING_MODE_ALLOW_INTRUSIVE_MEASUREMENTS + 1 ) , - D3D12_BACKGROUND_PROCESSING_MODE_DISABLE_PROFILING_BY_SYSTEM = ( D3D12_BACKGROUND_PROCESSING_MODE_DISABLE_BACKGROUND_WORK + 1 ) - } D3D12_BACKGROUND_PROCESSING_MODE; - -typedef -enum D3D12_MEASUREMENTS_ACTION - { - D3D12_MEASUREMENTS_ACTION_KEEP_ALL = 0, - D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS = ( D3D12_MEASUREMENTS_ACTION_KEEP_ALL + 1 ) , - D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS_HIGH_PRIORITY = ( D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS + 1 ) , - D3D12_MEASUREMENTS_ACTION_DISCARD_PREVIOUS = ( D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS_HIGH_PRIORITY + 1 ) - } D3D12_MEASUREMENTS_ACTION; - - - -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0037_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0037_v0_0_s_ifspec; - -#ifndef __ID3D12Device6_INTERFACE_DEFINED__ -#define __ID3D12Device6_INTERFACE_DEFINED__ - -/* interface ID3D12Device6 */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12Device6; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("c70b221b-40e4-4a17-89af-025a0727a6dc") - ID3D12Device6 : public ID3D12Device5 - { - public: - virtual HRESULT STDMETHODCALLTYPE SetBackgroundProcessingMode( - D3D12_BACKGROUND_PROCESSING_MODE Mode, - D3D12_MEASUREMENTS_ACTION MeasurementsAction, - _In_opt_ HANDLE hEventToSignalUponCompletion, - _Out_opt_ BOOL *pbFurtherMeasurementsDesired) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12Device6Vtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12Device6 * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12Device6 * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12Device6 * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12Device6 * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12Device6 * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12Device6 * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12Device6 * This, - _In_z_ LPCWSTR Name); - - UINT ( STDMETHODCALLTYPE *GetNodeCount )( - ID3D12Device6 * This); - - HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( - ID3D12Device6 * This, - _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppCommandQueue); - - HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( - ID3D12Device6 * This, - _In_ D3D12_COMMAND_LIST_TYPE type, - REFIID riid, - _COM_Outptr_ void **ppCommandAllocator); - - HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( - ID3D12Device6 * This, - _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); - - HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( - ID3D12Device6 * This, - _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); - - HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( - ID3D12Device6 * This, - _In_ UINT nodeMask, - _In_ D3D12_COMMAND_LIST_TYPE type, - _In_ ID3D12CommandAllocator *pCommandAllocator, - _In_opt_ ID3D12PipelineState *pInitialState, - REFIID riid, - _COM_Outptr_ void **ppCommandList); - - HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( - ID3D12Device6 * This, - D3D12_FEATURE Feature, - _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, - UINT FeatureSupportDataSize); - - HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( - ID3D12Device6 * This, - _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, - REFIID riid, - _COM_Outptr_ void **ppvHeap); - - UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( - ID3D12Device6 * This, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType); - - HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( - ID3D12Device6 * This, - _In_ UINT nodeMask, - _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, - _In_ SIZE_T blobLengthInBytes, - REFIID riid, - _COM_Outptr_ void **ppvRootSignature); - - void ( STDMETHODCALLTYPE *CreateConstantBufferView )( - ID3D12Device6 * This, - _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateShaderResourceView )( - ID3D12Device6 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( - ID3D12Device6 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ ID3D12Resource *pCounterResource, - _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateRenderTargetView )( - ID3D12Device6 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateDepthStencilView )( - ID3D12Device6 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CreateSampler )( - ID3D12Device6 * This, - _In_ const D3D12_SAMPLER_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - void ( STDMETHODCALLTYPE *CopyDescriptors )( - ID3D12Device6 * This, - _In_ UINT NumDestDescriptorRanges, - _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts, - _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes, - _In_ UINT NumSrcDescriptorRanges, - _In_reads_(NumSrcDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts, - _In_reads_opt_(NumSrcDescriptorRanges) const UINT *pSrcDescriptorRangeSizes, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); - - void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( - ID3D12Device6 * This, - _In_ UINT NumDescriptors, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); - - D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( - ID3D12Device6 * This, - _In_ UINT visibleMask, - _In_ UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); - - D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( - ID3D12Device6 * This, - _In_ UINT nodeMask, - D3D12_HEAP_TYPE heapType); - - HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( - ID3D12Device6 * This, - _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, - D3D12_HEAP_FLAGS HeapFlags, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialResourceState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riidResource, - _COM_Outptr_opt_ void **ppvResource); - - HRESULT ( STDMETHODCALLTYPE *CreateHeap )( - ID3D12Device6 * This, - _In_ const D3D12_HEAP_DESC *pDesc, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap); - - HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( - ID3D12Device6 * This, - _In_ ID3D12Heap *pHeap, - UINT64 HeapOffset, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); - - HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( - ID3D12Device6 * This, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); - - HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( - ID3D12Device6 * This, - _In_ ID3D12DeviceChild *pObject, - _In_opt_ const SECURITY_ATTRIBUTES *pAttributes, - DWORD Access, - _In_opt_ LPCWSTR Name, - _Out_ HANDLE *pHandle); - - HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( - ID3D12Device6 * This, - _In_ HANDLE NTHandle, - REFIID riid, - _COM_Outptr_opt_ void **ppvObj); - - HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( - ID3D12Device6 * This, - _In_ LPCWSTR Name, - DWORD Access, - /* [annotation][out] */ - _Out_ HANDLE *pNTHandle); - - HRESULT ( STDMETHODCALLTYPE *MakeResident )( - ID3D12Device6 * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); - - HRESULT ( STDMETHODCALLTYPE *Evict )( - ID3D12Device6 * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); - - HRESULT ( STDMETHODCALLTYPE *CreateFence )( - ID3D12Device6 * This, - UINT64 InitialValue, - D3D12_FENCE_FLAGS Flags, - REFIID riid, - _COM_Outptr_ void **ppFence); - - HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( - ID3D12Device6 * This); - - void ( STDMETHODCALLTYPE *GetCopyableFootprints )( - ID3D12Device6 * This, - _In_ const D3D12_RESOURCE_DESC *pResourceDesc, - _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, - _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, - UINT64 BaseOffset, - _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, - _Out_writes_opt_(NumSubresources) UINT *pNumRows, - _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, - _Out_opt_ UINT64 *pTotalBytes); - - HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( - ID3D12Device6 * This, - _In_ const D3D12_QUERY_HEAP_DESC *pDesc, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap); - - HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( - ID3D12Device6 * This, - BOOL Enable); - - HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( - ID3D12Device6 * This, - _In_ const D3D12_COMMAND_SIGNATURE_DESC *pDesc, - _In_opt_ ID3D12RootSignature *pRootSignature, - REFIID riid, - _COM_Outptr_opt_ void **ppvCommandSignature); - - void ( STDMETHODCALLTYPE *GetResourceTiling )( - ID3D12Device6 * This, - _In_ ID3D12Resource *pTiledResource, - _Out_opt_ UINT *pNumTilesForEntireResource, - _Out_opt_ D3D12_PACKED_MIP_INFO *pPackedMipDesc, - _Out_opt_ D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips, - _Inout_opt_ UINT *pNumSubresourceTilings, - _In_ UINT FirstSubresourceTilingToGet, - _Out_writes_(*pNumSubresourceTilings) D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips); - - LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( - ID3D12Device6 * This); - - HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( - ID3D12Device6 * This, - _In_reads_(BlobLength) const void *pLibraryBlob, - SIZE_T BlobLength, - REFIID riid, - _COM_Outptr_ void **ppPipelineLibrary); - - HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( - ID3D12Device6 * This, - _In_reads_(NumFences) ID3D12Fence *const *ppFences, - _In_reads_(NumFences) const UINT64 *pFenceValues, - UINT NumFences, - D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags, - HANDLE hEvent); - - HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( - ID3D12Device6 * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, - _In_reads_(NumObjects) const D3D12_RESIDENCY_PRIORITY *pPriorities); - - HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( - ID3D12Device6 * This, - const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); - - HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress )( - ID3D12Device6 * This, - _In_ const void *pAddress, - REFIID riid, - _COM_Outptr_ void **ppvHeap); - - HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromFileMapping )( - ID3D12Device6 * This, - _In_ HANDLE hFileMapping, - REFIID riid, - _COM_Outptr_ void **ppvHeap); - - HRESULT ( STDMETHODCALLTYPE *EnqueueMakeResident )( - ID3D12Device6 * This, - D3D12_RESIDENCY_FLAGS Flags, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, - _In_ ID3D12Fence *pFenceToSignal, - UINT64 FenceValueToSignal); - - HRESULT ( STDMETHODCALLTYPE *CreateCommandList1 )( - ID3D12Device6 * This, - _In_ UINT nodeMask, - _In_ D3D12_COMMAND_LIST_TYPE type, - _In_ D3D12_COMMAND_LIST_FLAGS flags, - REFIID riid, - _COM_Outptr_ void **ppCommandList); - - HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession )( - ID3D12Device6 * This, - _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC *pDesc, - _In_ REFIID riid, - _COM_Outptr_ void **ppSession); - - HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource1 )( - ID3D12Device6 * This, - _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, - D3D12_HEAP_FLAGS HeapFlags, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialResourceState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - REFIID riidResource, - _COM_Outptr_opt_ void **ppvResource); - - HRESULT ( STDMETHODCALLTYPE *CreateHeap1 )( - ID3D12Device6 * This, - _In_ const D3D12_HEAP_DESC *pDesc, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap); - - HRESULT ( STDMETHODCALLTYPE *CreateReservedResource1 )( - ID3D12Device6 * This, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); - - D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( - ID3D12Device6 * This, - UINT visibleMask, - UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, - _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); - - HRESULT ( STDMETHODCALLTYPE *CreateLifetimeTracker )( - ID3D12Device6 * This, - _In_ ID3D12LifetimeOwner *pOwner, - REFIID riid, - _COM_Outptr_ void **ppvTracker); - - void ( STDMETHODCALLTYPE *RemoveDevice )( - ID3D12Device6 * This); - - HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommands )( - ID3D12Device6 * This, - _Inout_ UINT *pNumMetaCommands, - _Out_writes_opt_(*pNumMetaCommands) D3D12_META_COMMAND_DESC *pDescs); - - HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommandParameters )( - ID3D12Device6 * This, - _In_ REFGUID CommandId, - _In_ D3D12_META_COMMAND_PARAMETER_STAGE Stage, - _Out_opt_ UINT *pTotalStructureSizeInBytes, - _Inout_ UINT *pParameterCount, - _Out_writes_opt_(*pParameterCount) D3D12_META_COMMAND_PARAMETER_DESC *pParameterDescs); - - HRESULT ( STDMETHODCALLTYPE *CreateMetaCommand )( - ID3D12Device6 * This, - _In_ REFGUID CommandId, - _In_ UINT NodeMask, - _In_reads_bytes_opt_(CreationParametersDataSizeInBytes) const void *pCreationParametersData, - _In_ SIZE_T CreationParametersDataSizeInBytes, - REFIID riid, - _COM_Outptr_ void **ppMetaCommand); - - HRESULT ( STDMETHODCALLTYPE *CreateStateObject )( - ID3D12Device6 * This, - const D3D12_STATE_OBJECT_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppStateObject); - - void ( STDMETHODCALLTYPE *GetRaytracingAccelerationStructurePrebuildInfo )( - ID3D12Device6 * This, - _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *pDesc, - _Out_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo); - - D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS ( STDMETHODCALLTYPE *CheckDriverMatchingIdentifier )( - ID3D12Device6 * This, - _In_ D3D12_SERIALIZED_DATA_TYPE SerializedDataType, - _In_ const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *pIdentifierToCheck); - - HRESULT ( STDMETHODCALLTYPE *SetBackgroundProcessingMode )( - ID3D12Device6 * This, - D3D12_BACKGROUND_PROCESSING_MODE Mode, - D3D12_MEASUREMENTS_ACTION MeasurementsAction, - _In_opt_ HANDLE hEventToSignalUponCompletion, - _Out_opt_ BOOL *pbFurtherMeasurementsDesired); - - END_INTERFACE - } ID3D12Device6Vtbl; - - interface ID3D12Device6 - { - CONST_VTBL struct ID3D12Device6Vtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12Device6_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12Device6_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12Device6_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12Device6_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12Device6_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12Device6_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12Device6_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12Device6_GetNodeCount(This) \ - ( (This)->lpVtbl -> GetNodeCount(This) ) - -#define ID3D12Device6_CreateCommandQueue(This,pDesc,riid,ppCommandQueue) \ - ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) - -#define ID3D12Device6_CreateCommandAllocator(This,type,riid,ppCommandAllocator) \ - ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) - -#define ID3D12Device6_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) - -#define ID3D12Device6_CreateComputePipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) - -#define ID3D12Device6_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) \ - ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) - -#define ID3D12Device6_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) \ - ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) - -#define ID3D12Device6_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) - -#define ID3D12Device6_GetDescriptorHandleIncrementSize(This,DescriptorHeapType) \ - ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) - -#define ID3D12Device6_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) \ - ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) - -#define ID3D12Device6_CreateConstantBufferView(This,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) - -#define ID3D12Device6_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) - -#define ID3D12Device6_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) - -#define ID3D12Device6_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) - -#define ID3D12Device6_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) - -#define ID3D12Device6_CreateSampler(This,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) - -#define ID3D12Device6_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) \ - ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) - -#define ID3D12Device6_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) \ - ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) - -#define ID3D12Device6_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) - -#define ID3D12Device6_GetCustomHeapProperties(This,nodeMask,heapType) \ - ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) - -#define ID3D12Device6_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) \ - ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) - -#define ID3D12Device6_CreateHeap(This,pDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) - -#define ID3D12Device6_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ - ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) - -#define ID3D12Device6_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ - ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) - -#define ID3D12Device6_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) \ - ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) - -#define ID3D12Device6_OpenSharedHandle(This,NTHandle,riid,ppvObj) \ - ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) - -#define ID3D12Device6_OpenSharedHandleByName(This,Name,Access,pNTHandle) \ - ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) - -#define ID3D12Device6_MakeResident(This,NumObjects,ppObjects) \ - ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) - -#define ID3D12Device6_Evict(This,NumObjects,ppObjects) \ - ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) - -#define ID3D12Device6_CreateFence(This,InitialValue,Flags,riid,ppFence) \ - ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) - -#define ID3D12Device6_GetDeviceRemovedReason(This) \ - ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) - -#define ID3D12Device6_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ - ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) - -#define ID3D12Device6_CreateQueryHeap(This,pDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) - -#define ID3D12Device6_SetStablePowerState(This,Enable) \ - ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) - -#define ID3D12Device6_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) \ - ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) - -#define ID3D12Device6_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) \ - ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) - -#define ID3D12Device6_GetAdapterLuid(This) \ - ( (This)->lpVtbl -> GetAdapterLuid(This) ) - - -#define ID3D12Device6_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) \ - ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) - -#define ID3D12Device6_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) \ - ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) - -#define ID3D12Device6_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) \ - ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) - - -#define ID3D12Device6_CreatePipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) - - -#define ID3D12Device6_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) \ - ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) - -#define ID3D12Device6_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) \ - ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) - -#define ID3D12Device6_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) \ - ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) - - -#define ID3D12Device6_CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) \ - ( (This)->lpVtbl -> CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) ) - -#define ID3D12Device6_CreateProtectedResourceSession(This,pDesc,riid,ppSession) \ - ( (This)->lpVtbl -> CreateProtectedResourceSession(This,pDesc,riid,ppSession) ) - -#define ID3D12Device6_CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ - ( (This)->lpVtbl -> CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) - -#define ID3D12Device6_CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) ) - -#define ID3D12Device6_CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) \ - ( (This)->lpVtbl -> CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) ) - -#define ID3D12Device6_GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) - - -#define ID3D12Device6_CreateLifetimeTracker(This,pOwner,riid,ppvTracker) \ - ( (This)->lpVtbl -> CreateLifetimeTracker(This,pOwner,riid,ppvTracker) ) - -#define ID3D12Device6_RemoveDevice(This) \ - ( (This)->lpVtbl -> RemoveDevice(This) ) - -#define ID3D12Device6_EnumerateMetaCommands(This,pNumMetaCommands,pDescs) \ - ( (This)->lpVtbl -> EnumerateMetaCommands(This,pNumMetaCommands,pDescs) ) - -#define ID3D12Device6_EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) \ - ( (This)->lpVtbl -> EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) ) - -#define ID3D12Device6_CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) \ - ( (This)->lpVtbl -> CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) ) - -#define ID3D12Device6_CreateStateObject(This,pDesc,riid,ppStateObject) \ - ( (This)->lpVtbl -> CreateStateObject(This,pDesc,riid,ppStateObject) ) - -#define ID3D12Device6_GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) \ - ( (This)->lpVtbl -> GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) ) - -#define ID3D12Device6_CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) \ - ( (This)->lpVtbl -> CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) ) - - -#define ID3D12Device6_SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) \ - ( (This)->lpVtbl -> SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12Device6_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12Resource1_INTERFACE_DEFINED__ -#define __ID3D12Resource1_INTERFACE_DEFINED__ - -/* interface ID3D12Resource1 */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12Resource1; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("9D5E227A-4430-4161-88B3-3ECA6BB16E19") - ID3D12Resource1 : public ID3D12Resource - { - public: - virtual HRESULT STDMETHODCALLTYPE GetProtectedResourceSession( - REFIID riid, - _COM_Outptr_opt_ void **ppProtectedSession) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12Resource1Vtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12Resource1 * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12Resource1 * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12Resource1 * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12Resource1 * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12Resource1 * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12Resource1 * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12Resource1 * This, - _In_z_ LPCWSTR Name); - - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12Resource1 * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - HRESULT ( STDMETHODCALLTYPE *Map )( - ID3D12Resource1 * This, - UINT Subresource, - _In_opt_ const D3D12_RANGE *pReadRange, - _Outptr_opt_result_bytebuffer_(_Inexpressible_("Dependent on resource")) void **ppData); - - void ( STDMETHODCALLTYPE *Unmap )( - ID3D12Resource1 * This, - UINT Subresource, - _In_opt_ const D3D12_RANGE *pWrittenRange); - - D3D12_RESOURCE_DESC ( STDMETHODCALLTYPE *GetDesc )( - ID3D12Resource1 * This); - - D3D12_GPU_VIRTUAL_ADDRESS ( STDMETHODCALLTYPE *GetGPUVirtualAddress )( - ID3D12Resource1 * This); - - HRESULT ( STDMETHODCALLTYPE *WriteToSubresource )( - ID3D12Resource1 * This, - UINT DstSubresource, - _In_opt_ const D3D12_BOX *pDstBox, - _In_ const void *pSrcData, - UINT SrcRowPitch, - UINT SrcDepthPitch); - - HRESULT ( STDMETHODCALLTYPE *ReadFromSubresource )( - ID3D12Resource1 * This, - _Out_ void *pDstData, - UINT DstRowPitch, - UINT DstDepthPitch, - UINT SrcSubresource, - _In_opt_ const D3D12_BOX *pSrcBox); - - HRESULT ( STDMETHODCALLTYPE *GetHeapProperties )( - ID3D12Resource1 * This, - _Out_opt_ D3D12_HEAP_PROPERTIES *pHeapProperties, - _Out_opt_ D3D12_HEAP_FLAGS *pHeapFlags); - - HRESULT ( STDMETHODCALLTYPE *GetProtectedResourceSession )( - ID3D12Resource1 * This, - REFIID riid, - _COM_Outptr_opt_ void **ppProtectedSession); - - END_INTERFACE - } ID3D12Resource1Vtbl; - - interface ID3D12Resource1 - { - CONST_VTBL struct ID3D12Resource1Vtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12Resource1_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12Resource1_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12Resource1_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12Resource1_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12Resource1_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12Resource1_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12Resource1_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12Resource1_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - - - -#define ID3D12Resource1_Map(This,Subresource,pReadRange,ppData) \ - ( (This)->lpVtbl -> Map(This,Subresource,pReadRange,ppData) ) - -#define ID3D12Resource1_Unmap(This,Subresource,pWrittenRange) \ - ( (This)->lpVtbl -> Unmap(This,Subresource,pWrittenRange) ) - -#define ID3D12Resource1_GetDesc(This) \ - ( (This)->lpVtbl -> GetDesc(This) ) - -#define ID3D12Resource1_GetGPUVirtualAddress(This) \ - ( (This)->lpVtbl -> GetGPUVirtualAddress(This) ) - -#define ID3D12Resource1_WriteToSubresource(This,DstSubresource,pDstBox,pSrcData,SrcRowPitch,SrcDepthPitch) \ - ( (This)->lpVtbl -> WriteToSubresource(This,DstSubresource,pDstBox,pSrcData,SrcRowPitch,SrcDepthPitch) ) - -#define ID3D12Resource1_ReadFromSubresource(This,pDstData,DstRowPitch,DstDepthPitch,SrcSubresource,pSrcBox) \ - ( (This)->lpVtbl -> ReadFromSubresource(This,pDstData,DstRowPitch,DstDepthPitch,SrcSubresource,pSrcBox) ) - -#define ID3D12Resource1_GetHeapProperties(This,pHeapProperties,pHeapFlags) \ - ( (This)->lpVtbl -> GetHeapProperties(This,pHeapProperties,pHeapFlags) ) - - -#define ID3D12Resource1_GetProtectedResourceSession(This,riid,ppProtectedSession) \ - ( (This)->lpVtbl -> GetProtectedResourceSession(This,riid,ppProtectedSession) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12Resource1_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12Heap1_INTERFACE_DEFINED__ -#define __ID3D12Heap1_INTERFACE_DEFINED__ - -/* interface ID3D12Heap1 */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12Heap1; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("572F7389-2168-49E3-9693-D6DF5871BF6D") - ID3D12Heap1 : public ID3D12Heap - { - public: - virtual HRESULT STDMETHODCALLTYPE GetProtectedResourceSession( - REFIID riid, - _COM_Outptr_opt_ void **ppProtectedSession) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12Heap1Vtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12Heap1 * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12Heap1 * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12Heap1 * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12Heap1 * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12Heap1 * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12Heap1 * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12Heap1 * This, - _In_z_ LPCWSTR Name); - - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12Heap1 * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - D3D12_HEAP_DESC ( STDMETHODCALLTYPE *GetDesc )( - ID3D12Heap1 * This); - - HRESULT ( STDMETHODCALLTYPE *GetProtectedResourceSession )( - ID3D12Heap1 * This, - REFIID riid, - _COM_Outptr_opt_ void **ppProtectedSession); - - END_INTERFACE - } ID3D12Heap1Vtbl; - - interface ID3D12Heap1 - { - CONST_VTBL struct ID3D12Heap1Vtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12Heap1_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12Heap1_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12Heap1_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12Heap1_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12Heap1_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12Heap1_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12Heap1_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12Heap1_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - - - -#define ID3D12Heap1_GetDesc(This) \ - ( (This)->lpVtbl -> GetDesc(This) ) - - -#define ID3D12Heap1_GetProtectedResourceSession(This,riid,ppProtectedSession) \ - ( (This)->lpVtbl -> GetProtectedResourceSession(This,riid,ppProtectedSession) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12Heap1_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12GraphicsCommandList3_INTERFACE_DEFINED__ -#define __ID3D12GraphicsCommandList3_INTERFACE_DEFINED__ - -/* interface ID3D12GraphicsCommandList3 */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12GraphicsCommandList3; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("6FDA83A7-B84C-4E38-9AC8-C7BD22016B3D") - ID3D12GraphicsCommandList3 : public ID3D12GraphicsCommandList2 - { - public: - virtual void STDMETHODCALLTYPE SetProtectedResourceSession( - _In_opt_ ID3D12ProtectedResourceSession *pProtectedResourceSession) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12GraphicsCommandList3Vtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12GraphicsCommandList3 * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12GraphicsCommandList3 * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12GraphicsCommandList3 * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12GraphicsCommandList3 * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12GraphicsCommandList3 * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12GraphicsCommandList3 * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12GraphicsCommandList3 * This, - _In_z_ LPCWSTR Name); - - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12GraphicsCommandList3 * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( - ID3D12GraphicsCommandList3 * This); - - HRESULT ( STDMETHODCALLTYPE *Close )( - ID3D12GraphicsCommandList3 * This); - - HRESULT ( STDMETHODCALLTYPE *Reset )( - ID3D12GraphicsCommandList3 * This, - _In_ ID3D12CommandAllocator *pAllocator, - _In_opt_ ID3D12PipelineState *pInitialState); - - void ( STDMETHODCALLTYPE *ClearState )( - ID3D12GraphicsCommandList3 * This, - _In_opt_ ID3D12PipelineState *pPipelineState); - - void ( STDMETHODCALLTYPE *DrawInstanced )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT VertexCountPerInstance, - _In_ UINT InstanceCount, - _In_ UINT StartVertexLocation, - _In_ UINT StartInstanceLocation); - - void ( STDMETHODCALLTYPE *DrawIndexedInstanced )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT IndexCountPerInstance, - _In_ UINT InstanceCount, - _In_ UINT StartIndexLocation, - _In_ INT BaseVertexLocation, - _In_ UINT StartInstanceLocation); - - void ( STDMETHODCALLTYPE *Dispatch )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT ThreadGroupCountX, - _In_ UINT ThreadGroupCountY, - _In_ UINT ThreadGroupCountZ); - - void ( STDMETHODCALLTYPE *CopyBufferRegion )( - ID3D12GraphicsCommandList3 * This, - _In_ ID3D12Resource *pDstBuffer, - UINT64 DstOffset, - _In_ ID3D12Resource *pSrcBuffer, - UINT64 SrcOffset, - UINT64 NumBytes); - - void ( STDMETHODCALLTYPE *CopyTextureRegion )( - ID3D12GraphicsCommandList3 * This, - _In_ const D3D12_TEXTURE_COPY_LOCATION *pDst, - UINT DstX, - UINT DstY, - UINT DstZ, - _In_ const D3D12_TEXTURE_COPY_LOCATION *pSrc, - _In_opt_ const D3D12_BOX *pSrcBox); - - void ( STDMETHODCALLTYPE *CopyResource )( - ID3D12GraphicsCommandList3 * This, - _In_ ID3D12Resource *pDstResource, - _In_ ID3D12Resource *pSrcResource); - - void ( STDMETHODCALLTYPE *CopyTiles )( - ID3D12GraphicsCommandList3 * This, - _In_ ID3D12Resource *pTiledResource, - _In_ const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate, - _In_ const D3D12_TILE_REGION_SIZE *pTileRegionSize, - _In_ ID3D12Resource *pBuffer, - UINT64 BufferStartOffsetInBytes, - D3D12_TILE_COPY_FLAGS Flags); - - void ( STDMETHODCALLTYPE *ResolveSubresource )( - ID3D12GraphicsCommandList3 * This, - _In_ ID3D12Resource *pDstResource, - _In_ UINT DstSubresource, - _In_ ID3D12Resource *pSrcResource, - _In_ UINT SrcSubresource, - _In_ DXGI_FORMAT Format); - - void ( STDMETHODCALLTYPE *IASetPrimitiveTopology )( - ID3D12GraphicsCommandList3 * This, - _In_ D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology); - - void ( STDMETHODCALLTYPE *RSSetViewports )( - ID3D12GraphicsCommandList3 * This, - _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumViewports, - _In_reads_( NumViewports) const D3D12_VIEWPORT *pViewports); - - void ( STDMETHODCALLTYPE *RSSetScissorRects )( - ID3D12GraphicsCommandList3 * This, - _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumRects, - _In_reads_( NumRects) const D3D12_RECT *pRects); - - void ( STDMETHODCALLTYPE *OMSetBlendFactor )( - ID3D12GraphicsCommandList3 * This, - _In_reads_opt_(4) const FLOAT BlendFactor[ 4 ]); - - void ( STDMETHODCALLTYPE *OMSetStencilRef )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT StencilRef); - - void ( STDMETHODCALLTYPE *SetPipelineState )( - ID3D12GraphicsCommandList3 * This, - _In_ ID3D12PipelineState *pPipelineState); - - void ( STDMETHODCALLTYPE *ResourceBarrier )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT NumBarriers, - _In_reads_(NumBarriers) const D3D12_RESOURCE_BARRIER *pBarriers); - - void ( STDMETHODCALLTYPE *ExecuteBundle )( - ID3D12GraphicsCommandList3 * This, - _In_ ID3D12GraphicsCommandList *pCommandList); - - void ( STDMETHODCALLTYPE *SetDescriptorHeaps )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT NumDescriptorHeaps, - _In_reads_(NumDescriptorHeaps) ID3D12DescriptorHeap *const *ppDescriptorHeaps); - - void ( STDMETHODCALLTYPE *SetComputeRootSignature )( - ID3D12GraphicsCommandList3 * This, - _In_opt_ ID3D12RootSignature *pRootSignature); - - void ( STDMETHODCALLTYPE *SetGraphicsRootSignature )( - ID3D12GraphicsCommandList3 * This, - _In_opt_ ID3D12RootSignature *pRootSignature); - - void ( STDMETHODCALLTYPE *SetComputeRootDescriptorTable )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); - - void ( STDMETHODCALLTYPE *SetGraphicsRootDescriptorTable )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); - - void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstant )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT RootParameterIndex, - _In_ UINT SrcData, - _In_ UINT DestOffsetIn32BitValues); - - void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstant )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT RootParameterIndex, - _In_ UINT SrcData, - _In_ UINT DestOffsetIn32BitValues); - - void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstants )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT RootParameterIndex, - _In_ UINT Num32BitValuesToSet, - _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, - _In_ UINT DestOffsetIn32BitValues); - - void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstants )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT RootParameterIndex, - _In_ UINT Num32BitValuesToSet, - _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, - _In_ UINT DestOffsetIn32BitValues); - - void ( STDMETHODCALLTYPE *SetComputeRootConstantBufferView )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *SetGraphicsRootConstantBufferView )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *SetComputeRootShaderResourceView )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *SetGraphicsRootShaderResourceView )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *SetComputeRootUnorderedAccessView )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *SetGraphicsRootUnorderedAccessView )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *IASetIndexBuffer )( - ID3D12GraphicsCommandList3 * This, - _In_opt_ const D3D12_INDEX_BUFFER_VIEW *pView); - - void ( STDMETHODCALLTYPE *IASetVertexBuffers )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT StartSlot, - _In_ UINT NumViews, - _In_reads_opt_(NumViews) const D3D12_VERTEX_BUFFER_VIEW *pViews); - - void ( STDMETHODCALLTYPE *SOSetTargets )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT StartSlot, - _In_ UINT NumViews, - _In_reads_opt_(NumViews) const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews); - - void ( STDMETHODCALLTYPE *OMSetRenderTargets )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT NumRenderTargetDescriptors, - _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors, - _In_ BOOL RTsSingleHandleToDescriptorRange, - _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pDepthStencilDescriptor); - - void ( STDMETHODCALLTYPE *ClearDepthStencilView )( - ID3D12GraphicsCommandList3 * This, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView, - _In_ D3D12_CLEAR_FLAGS ClearFlags, - _In_ FLOAT Depth, - _In_ UINT8 Stencil, - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); - - void ( STDMETHODCALLTYPE *ClearRenderTargetView )( - ID3D12GraphicsCommandList3 * This, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView, - _In_ const FLOAT ColorRGBA[ 4 ], - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); - - void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewUint )( - ID3D12GraphicsCommandList3 * This, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, - _In_ ID3D12Resource *pResource, - _In_ const UINT Values[ 4 ], - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); - - void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewFloat )( - ID3D12GraphicsCommandList3 * This, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, - _In_ ID3D12Resource *pResource, - _In_ const FLOAT Values[ 4 ], - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); - - void ( STDMETHODCALLTYPE *DiscardResource )( - ID3D12GraphicsCommandList3 * This, - _In_ ID3D12Resource *pResource, - _In_opt_ const D3D12_DISCARD_REGION *pRegion); - - void ( STDMETHODCALLTYPE *BeginQuery )( - ID3D12GraphicsCommandList3 * This, - _In_ ID3D12QueryHeap *pQueryHeap, - _In_ D3D12_QUERY_TYPE Type, - _In_ UINT Index); - - void ( STDMETHODCALLTYPE *EndQuery )( - ID3D12GraphicsCommandList3 * This, - _In_ ID3D12QueryHeap *pQueryHeap, - _In_ D3D12_QUERY_TYPE Type, - _In_ UINT Index); - - void ( STDMETHODCALLTYPE *ResolveQueryData )( - ID3D12GraphicsCommandList3 * This, - _In_ ID3D12QueryHeap *pQueryHeap, - _In_ D3D12_QUERY_TYPE Type, - _In_ UINT StartIndex, - _In_ UINT NumQueries, - _In_ ID3D12Resource *pDestinationBuffer, - _In_ UINT64 AlignedDestinationBufferOffset); - - void ( STDMETHODCALLTYPE *SetPredication )( - ID3D12GraphicsCommandList3 * This, - _In_opt_ ID3D12Resource *pBuffer, - _In_ UINT64 AlignedBufferOffset, - _In_ D3D12_PREDICATION_OP Operation); - - void ( STDMETHODCALLTYPE *SetMarker )( - ID3D12GraphicsCommandList3 * This, - UINT Metadata, - _In_reads_bytes_opt_(Size) const void *pData, - UINT Size); - - void ( STDMETHODCALLTYPE *BeginEvent )( - ID3D12GraphicsCommandList3 * This, - UINT Metadata, - _In_reads_bytes_opt_(Size) const void *pData, - UINT Size); - - void ( STDMETHODCALLTYPE *EndEvent )( - ID3D12GraphicsCommandList3 * This); - - void ( STDMETHODCALLTYPE *ExecuteIndirect )( - ID3D12GraphicsCommandList3 * This, - _In_ ID3D12CommandSignature *pCommandSignature, - _In_ UINT MaxCommandCount, - _In_ ID3D12Resource *pArgumentBuffer, - _In_ UINT64 ArgumentBufferOffset, - _In_opt_ ID3D12Resource *pCountBuffer, - _In_ UINT64 CountBufferOffset); - - void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT )( - ID3D12GraphicsCommandList3 * This, - _In_ ID3D12Resource *pDstBuffer, - UINT64 DstOffset, - _In_ ID3D12Resource *pSrcBuffer, - UINT64 SrcOffset, - UINT Dependencies, - _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, - _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); - - void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT64 )( - ID3D12GraphicsCommandList3 * This, - _In_ ID3D12Resource *pDstBuffer, - UINT64 DstOffset, - _In_ ID3D12Resource *pSrcBuffer, - UINT64 SrcOffset, - UINT Dependencies, - _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, - _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); - - void ( STDMETHODCALLTYPE *OMSetDepthBounds )( - ID3D12GraphicsCommandList3 * This, - _In_ FLOAT Min, - _In_ FLOAT Max); - - void ( STDMETHODCALLTYPE *SetSamplePositions )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT NumSamplesPerPixel, - _In_ UINT NumPixels, - _In_reads_(NumSamplesPerPixel*NumPixels) D3D12_SAMPLE_POSITION *pSamplePositions); - - void ( STDMETHODCALLTYPE *ResolveSubresourceRegion )( - ID3D12GraphicsCommandList3 * This, - _In_ ID3D12Resource *pDstResource, - _In_ UINT DstSubresource, - _In_ UINT DstX, - _In_ UINT DstY, - _In_ ID3D12Resource *pSrcResource, - _In_ UINT SrcSubresource, - _In_opt_ D3D12_RECT *pSrcRect, - _In_ DXGI_FORMAT Format, - _In_ D3D12_RESOLVE_MODE ResolveMode); - - void ( STDMETHODCALLTYPE *SetViewInstanceMask )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT Mask); - - void ( STDMETHODCALLTYPE *WriteBufferImmediate )( - ID3D12GraphicsCommandList3 * This, - UINT Count, - _In_reads_(Count) const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams, - _In_reads_opt_(Count) const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes); - - void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( - ID3D12GraphicsCommandList3 * This, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedResourceSession); - - END_INTERFACE - } ID3D12GraphicsCommandList3Vtbl; - - interface ID3D12GraphicsCommandList3 - { - CONST_VTBL struct ID3D12GraphicsCommandList3Vtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12GraphicsCommandList3_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12GraphicsCommandList3_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12GraphicsCommandList3_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12GraphicsCommandList3_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12GraphicsCommandList3_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12GraphicsCommandList3_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12GraphicsCommandList3_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12GraphicsCommandList3_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - - -#define ID3D12GraphicsCommandList3_GetType(This) \ - ( (This)->lpVtbl -> GetType(This) ) - - -#define ID3D12GraphicsCommandList3_Close(This) \ - ( (This)->lpVtbl -> Close(This) ) - -#define ID3D12GraphicsCommandList3_Reset(This,pAllocator,pInitialState) \ - ( (This)->lpVtbl -> Reset(This,pAllocator,pInitialState) ) - -#define ID3D12GraphicsCommandList3_ClearState(This,pPipelineState) \ - ( (This)->lpVtbl -> ClearState(This,pPipelineState) ) - -#define ID3D12GraphicsCommandList3_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) \ - ( (This)->lpVtbl -> DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) ) - -#define ID3D12GraphicsCommandList3_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) \ - ( (This)->lpVtbl -> DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) ) - -#define ID3D12GraphicsCommandList3_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ - ( (This)->lpVtbl -> Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) - -#define ID3D12GraphicsCommandList3_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) \ - ( (This)->lpVtbl -> CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) ) - -#define ID3D12GraphicsCommandList3_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) \ - ( (This)->lpVtbl -> CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) ) - -#define ID3D12GraphicsCommandList3_CopyResource(This,pDstResource,pSrcResource) \ - ( (This)->lpVtbl -> CopyResource(This,pDstResource,pSrcResource) ) - -#define ID3D12GraphicsCommandList3_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) \ - ( (This)->lpVtbl -> CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) ) - -#define ID3D12GraphicsCommandList3_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) \ - ( (This)->lpVtbl -> ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) ) - -#define ID3D12GraphicsCommandList3_IASetPrimitiveTopology(This,PrimitiveTopology) \ - ( (This)->lpVtbl -> IASetPrimitiveTopology(This,PrimitiveTopology) ) - -#define ID3D12GraphicsCommandList3_RSSetViewports(This,NumViewports,pViewports) \ - ( (This)->lpVtbl -> RSSetViewports(This,NumViewports,pViewports) ) - -#define ID3D12GraphicsCommandList3_RSSetScissorRects(This,NumRects,pRects) \ - ( (This)->lpVtbl -> RSSetScissorRects(This,NumRects,pRects) ) - -#define ID3D12GraphicsCommandList3_OMSetBlendFactor(This,BlendFactor) \ - ( (This)->lpVtbl -> OMSetBlendFactor(This,BlendFactor) ) - -#define ID3D12GraphicsCommandList3_OMSetStencilRef(This,StencilRef) \ - ( (This)->lpVtbl -> OMSetStencilRef(This,StencilRef) ) - -#define ID3D12GraphicsCommandList3_SetPipelineState(This,pPipelineState) \ - ( (This)->lpVtbl -> SetPipelineState(This,pPipelineState) ) - -#define ID3D12GraphicsCommandList3_ResourceBarrier(This,NumBarriers,pBarriers) \ - ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) - -#define ID3D12GraphicsCommandList3_ExecuteBundle(This,pCommandList) \ - ( (This)->lpVtbl -> ExecuteBundle(This,pCommandList) ) - -#define ID3D12GraphicsCommandList3_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) \ - ( (This)->lpVtbl -> SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) ) - -#define ID3D12GraphicsCommandList3_SetComputeRootSignature(This,pRootSignature) \ - ( (This)->lpVtbl -> SetComputeRootSignature(This,pRootSignature) ) - -#define ID3D12GraphicsCommandList3_SetGraphicsRootSignature(This,pRootSignature) \ - ( (This)->lpVtbl -> SetGraphicsRootSignature(This,pRootSignature) ) - -#define ID3D12GraphicsCommandList3_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ - ( (This)->lpVtbl -> SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) - -#define ID3D12GraphicsCommandList3_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ - ( (This)->lpVtbl -> SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) - -#define ID3D12GraphicsCommandList3_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) - -#define ID3D12GraphicsCommandList3_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) - -#define ID3D12GraphicsCommandList3_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) - -#define ID3D12GraphicsCommandList3_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) - -#define ID3D12GraphicsCommandList3_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList3_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList3_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList3_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList3_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList3_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList3_IASetIndexBuffer(This,pView) \ - ( (This)->lpVtbl -> IASetIndexBuffer(This,pView) ) - -#define ID3D12GraphicsCommandList3_IASetVertexBuffers(This,StartSlot,NumViews,pViews) \ - ( (This)->lpVtbl -> IASetVertexBuffers(This,StartSlot,NumViews,pViews) ) - -#define ID3D12GraphicsCommandList3_SOSetTargets(This,StartSlot,NumViews,pViews) \ - ( (This)->lpVtbl -> SOSetTargets(This,StartSlot,NumViews,pViews) ) - -#define ID3D12GraphicsCommandList3_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) \ - ( (This)->lpVtbl -> OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) ) - -#define ID3D12GraphicsCommandList3_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) ) - -#define ID3D12GraphicsCommandList3_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) ) - -#define ID3D12GraphicsCommandList3_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) - -#define ID3D12GraphicsCommandList3_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) - -#define ID3D12GraphicsCommandList3_DiscardResource(This,pResource,pRegion) \ - ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) - -#define ID3D12GraphicsCommandList3_BeginQuery(This,pQueryHeap,Type,Index) \ - ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) - -#define ID3D12GraphicsCommandList3_EndQuery(This,pQueryHeap,Type,Index) \ - ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) - -#define ID3D12GraphicsCommandList3_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) \ - ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) - -#define ID3D12GraphicsCommandList3_SetPredication(This,pBuffer,AlignedBufferOffset,Operation) \ - ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) - -#define ID3D12GraphicsCommandList3_SetMarker(This,Metadata,pData,Size) \ - ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) - -#define ID3D12GraphicsCommandList3_BeginEvent(This,Metadata,pData,Size) \ - ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) - -#define ID3D12GraphicsCommandList3_EndEvent(This) \ - ( (This)->lpVtbl -> EndEvent(This) ) - -#define ID3D12GraphicsCommandList3_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) \ - ( (This)->lpVtbl -> ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) ) - - -#define ID3D12GraphicsCommandList3_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ - ( (This)->lpVtbl -> AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) - -#define ID3D12GraphicsCommandList3_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ - ( (This)->lpVtbl -> AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) - -#define ID3D12GraphicsCommandList3_OMSetDepthBounds(This,Min,Max) \ - ( (This)->lpVtbl -> OMSetDepthBounds(This,Min,Max) ) - -#define ID3D12GraphicsCommandList3_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) \ - ( (This)->lpVtbl -> SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) ) - -#define ID3D12GraphicsCommandList3_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) \ - ( (This)->lpVtbl -> ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) ) - -#define ID3D12GraphicsCommandList3_SetViewInstanceMask(This,Mask) \ - ( (This)->lpVtbl -> SetViewInstanceMask(This,Mask) ) - - -#define ID3D12GraphicsCommandList3_WriteBufferImmediate(This,Count,pParams,pModes) \ - ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) - - -#define ID3D12GraphicsCommandList3_SetProtectedResourceSession(This,pProtectedResourceSession) \ - ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12GraphicsCommandList3_INTERFACE_DEFINED__ */ - - -/* interface __MIDL_itf_d3d12_0000_0041 */ -/* [local] */ - -typedef -enum D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE - { - D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_DISCARD = 0, - D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE = ( D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_DISCARD + 1 ) , - D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR = ( D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE + 1 ) , - D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_NO_ACCESS = ( D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR + 1 ) - } D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE; - -typedef struct D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS - { - D3D12_CLEAR_VALUE ClearValue; - } D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS; - -typedef struct D3D12_RENDER_PASS_BEGINNING_ACCESS - { - D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE Type; - union - { - D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS Clear; - } ; - } D3D12_RENDER_PASS_BEGINNING_ACCESS; - -typedef -enum D3D12_RENDER_PASS_ENDING_ACCESS_TYPE - { - D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_DISCARD = 0, - D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE = ( D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_DISCARD + 1 ) , - D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_RESOLVE = ( D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE + 1 ) , - D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_NO_ACCESS = ( D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_RESOLVE + 1 ) - } D3D12_RENDER_PASS_ENDING_ACCESS_TYPE; - -typedef struct D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS - { - UINT SrcSubresource; - UINT DstSubresource; - UINT DstX; - UINT DstY; - D3D12_RECT SrcRect; - } D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS; - -typedef struct D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS - { - ID3D12Resource *pSrcResource; - ID3D12Resource *pDstResource; - UINT SubresourceCount; - _Field_size_full_(SubresourceCount) const D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS *pSubresourceParameters; - DXGI_FORMAT Format; - D3D12_RESOLVE_MODE ResolveMode; - BOOL PreserveResolveSource; - } D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS; - -typedef struct D3D12_RENDER_PASS_ENDING_ACCESS - { - D3D12_RENDER_PASS_ENDING_ACCESS_TYPE Type; - union - { - D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS Resolve; - } ; - } D3D12_RENDER_PASS_ENDING_ACCESS; - -typedef struct D3D12_RENDER_PASS_RENDER_TARGET_DESC - { - D3D12_CPU_DESCRIPTOR_HANDLE cpuDescriptor; - D3D12_RENDER_PASS_BEGINNING_ACCESS BeginningAccess; - D3D12_RENDER_PASS_ENDING_ACCESS EndingAccess; - } D3D12_RENDER_PASS_RENDER_TARGET_DESC; - -typedef struct D3D12_RENDER_PASS_DEPTH_STENCIL_DESC - { - D3D12_CPU_DESCRIPTOR_HANDLE cpuDescriptor; - D3D12_RENDER_PASS_BEGINNING_ACCESS DepthBeginningAccess; - D3D12_RENDER_PASS_BEGINNING_ACCESS StencilBeginningAccess; - D3D12_RENDER_PASS_ENDING_ACCESS DepthEndingAccess; - D3D12_RENDER_PASS_ENDING_ACCESS StencilEndingAccess; - } D3D12_RENDER_PASS_DEPTH_STENCIL_DESC; - -typedef -enum D3D12_RENDER_PASS_FLAGS - { - D3D12_RENDER_PASS_FLAG_NONE = 0, - D3D12_RENDER_PASS_FLAG_ALLOW_UAV_WRITES = 0x1, - D3D12_RENDER_PASS_FLAG_SUSPENDING_PASS = 0x2, - D3D12_RENDER_PASS_FLAG_RESUMING_PASS = 0x4 - } D3D12_RENDER_PASS_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_RENDER_PASS_FLAGS ); - - -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0041_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0041_v0_0_s_ifspec; - -#ifndef __ID3D12MetaCommand_INTERFACE_DEFINED__ -#define __ID3D12MetaCommand_INTERFACE_DEFINED__ - -/* interface ID3D12MetaCommand */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12MetaCommand; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("DBB84C27-36CE-4FC9-B801-F048C46AC570") - ID3D12MetaCommand : public ID3D12Pageable - { - public: - virtual UINT64 STDMETHODCALLTYPE GetRequiredParameterResourceSize( - _In_ D3D12_META_COMMAND_PARAMETER_STAGE Stage, - _In_ UINT ParameterIndex) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12MetaCommandVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12MetaCommand * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12MetaCommand * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12MetaCommand * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12MetaCommand * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12MetaCommand * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12MetaCommand * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12MetaCommand * This, - _In_z_ LPCWSTR Name); - - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12MetaCommand * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - UINT64 ( STDMETHODCALLTYPE *GetRequiredParameterResourceSize )( - ID3D12MetaCommand * This, - _In_ D3D12_META_COMMAND_PARAMETER_STAGE Stage, - _In_ UINT ParameterIndex); - - END_INTERFACE - } ID3D12MetaCommandVtbl; - - interface ID3D12MetaCommand - { - CONST_VTBL struct ID3D12MetaCommandVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12MetaCommand_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12MetaCommand_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12MetaCommand_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12MetaCommand_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12MetaCommand_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12MetaCommand_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12MetaCommand_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12MetaCommand_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - - - -#define ID3D12MetaCommand_GetRequiredParameterResourceSize(This,Stage,ParameterIndex) \ - ( (This)->lpVtbl -> GetRequiredParameterResourceSize(This,Stage,ParameterIndex) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12MetaCommand_INTERFACE_DEFINED__ */ - - -/* interface __MIDL_itf_d3d12_0000_0042 */ -/* [local] */ - -typedef struct D3D12_DISPATCH_RAYS_DESC - { - D3D12_GPU_VIRTUAL_ADDRESS_RANGE RayGenerationShaderRecord; - D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE MissShaderTable; - D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE HitGroupTable; - D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE CallableShaderTable; - UINT Width; - UINT Height; - UINT Depth; - } D3D12_DISPATCH_RAYS_DESC; - - - -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0042_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0042_v0_0_s_ifspec; - -#ifndef __ID3D12GraphicsCommandList4_INTERFACE_DEFINED__ -#define __ID3D12GraphicsCommandList4_INTERFACE_DEFINED__ - -/* interface ID3D12GraphicsCommandList4 */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12GraphicsCommandList4; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("8754318e-d3a9-4541-98cf-645b50dc4874") - ID3D12GraphicsCommandList4 : public ID3D12GraphicsCommandList3 - { - public: - virtual void STDMETHODCALLTYPE BeginRenderPass( - _In_ UINT NumRenderTargets, - _In_reads_opt_(NumRenderTargets) const D3D12_RENDER_PASS_RENDER_TARGET_DESC *pRenderTargets, - _In_opt_ const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *pDepthStencil, - D3D12_RENDER_PASS_FLAGS Flags) = 0; - - virtual void STDMETHODCALLTYPE EndRenderPass( void) = 0; - - virtual void STDMETHODCALLTYPE InitializeMetaCommand( - _In_ ID3D12MetaCommand *pMetaCommand, - _In_reads_bytes_opt_(InitializationParametersDataSizeInBytes) const void *pInitializationParametersData, - _In_ SIZE_T InitializationParametersDataSizeInBytes) = 0; - - virtual void STDMETHODCALLTYPE ExecuteMetaCommand( - _In_ ID3D12MetaCommand *pMetaCommand, - _In_reads_bytes_opt_(ExecutionParametersDataSizeInBytes) const void *pExecutionParametersData, - _In_ SIZE_T ExecutionParametersDataSizeInBytes) = 0; - - virtual void STDMETHODCALLTYPE BuildRaytracingAccelerationStructure( - _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC *pDesc, - _In_ UINT NumPostbuildInfoDescs, - _In_reads_opt_(NumPostbuildInfoDescs) const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pPostbuildInfoDescs) = 0; - - virtual void STDMETHODCALLTYPE EmitRaytracingAccelerationStructurePostbuildInfo( - _In_ const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pDesc, - _In_ UINT NumSourceAccelerationStructures, - _In_reads_( NumSourceAccelerationStructures ) const D3D12_GPU_VIRTUAL_ADDRESS *pSourceAccelerationStructureData) = 0; - - virtual void STDMETHODCALLTYPE CopyRaytracingAccelerationStructure( - _In_ D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData, - _In_ D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData, - _In_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE Mode) = 0; - - virtual void STDMETHODCALLTYPE SetPipelineState1( - _In_ ID3D12StateObject *pStateObject) = 0; - - virtual void STDMETHODCALLTYPE DispatchRays( - _In_ const D3D12_DISPATCH_RAYS_DESC *pDesc) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12GraphicsCommandList4Vtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12GraphicsCommandList4 * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12GraphicsCommandList4 * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12GraphicsCommandList4 * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12GraphicsCommandList4 * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12GraphicsCommandList4 * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12GraphicsCommandList4 * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12GraphicsCommandList4 * This, - _In_z_ LPCWSTR Name); - - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12GraphicsCommandList4 * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( - ID3D12GraphicsCommandList4 * This); - - HRESULT ( STDMETHODCALLTYPE *Close )( - ID3D12GraphicsCommandList4 * This); - - HRESULT ( STDMETHODCALLTYPE *Reset )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12CommandAllocator *pAllocator, - _In_opt_ ID3D12PipelineState *pInitialState); - - void ( STDMETHODCALLTYPE *ClearState )( - ID3D12GraphicsCommandList4 * This, - _In_opt_ ID3D12PipelineState *pPipelineState); - - void ( STDMETHODCALLTYPE *DrawInstanced )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT VertexCountPerInstance, - _In_ UINT InstanceCount, - _In_ UINT StartVertexLocation, - _In_ UINT StartInstanceLocation); - - void ( STDMETHODCALLTYPE *DrawIndexedInstanced )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT IndexCountPerInstance, - _In_ UINT InstanceCount, - _In_ UINT StartIndexLocation, - _In_ INT BaseVertexLocation, - _In_ UINT StartInstanceLocation); - - void ( STDMETHODCALLTYPE *Dispatch )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT ThreadGroupCountX, - _In_ UINT ThreadGroupCountY, - _In_ UINT ThreadGroupCountZ); - - void ( STDMETHODCALLTYPE *CopyBufferRegion )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12Resource *pDstBuffer, - UINT64 DstOffset, - _In_ ID3D12Resource *pSrcBuffer, - UINT64 SrcOffset, - UINT64 NumBytes); - - void ( STDMETHODCALLTYPE *CopyTextureRegion )( - ID3D12GraphicsCommandList4 * This, - _In_ const D3D12_TEXTURE_COPY_LOCATION *pDst, - UINT DstX, - UINT DstY, - UINT DstZ, - _In_ const D3D12_TEXTURE_COPY_LOCATION *pSrc, - _In_opt_ const D3D12_BOX *pSrcBox); - - void ( STDMETHODCALLTYPE *CopyResource )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12Resource *pDstResource, - _In_ ID3D12Resource *pSrcResource); - - void ( STDMETHODCALLTYPE *CopyTiles )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12Resource *pTiledResource, - _In_ const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate, - _In_ const D3D12_TILE_REGION_SIZE *pTileRegionSize, - _In_ ID3D12Resource *pBuffer, - UINT64 BufferStartOffsetInBytes, - D3D12_TILE_COPY_FLAGS Flags); - - void ( STDMETHODCALLTYPE *ResolveSubresource )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12Resource *pDstResource, - _In_ UINT DstSubresource, - _In_ ID3D12Resource *pSrcResource, - _In_ UINT SrcSubresource, - _In_ DXGI_FORMAT Format); - - void ( STDMETHODCALLTYPE *IASetPrimitiveTopology )( - ID3D12GraphicsCommandList4 * This, - _In_ D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology); - - void ( STDMETHODCALLTYPE *RSSetViewports )( - ID3D12GraphicsCommandList4 * This, - _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumViewports, - _In_reads_( NumViewports) const D3D12_VIEWPORT *pViewports); - - void ( STDMETHODCALLTYPE *RSSetScissorRects )( - ID3D12GraphicsCommandList4 * This, - _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumRects, - _In_reads_( NumRects) const D3D12_RECT *pRects); - - void ( STDMETHODCALLTYPE *OMSetBlendFactor )( - ID3D12GraphicsCommandList4 * This, - _In_reads_opt_(4) const FLOAT BlendFactor[ 4 ]); - - void ( STDMETHODCALLTYPE *OMSetStencilRef )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT StencilRef); - - void ( STDMETHODCALLTYPE *SetPipelineState )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12PipelineState *pPipelineState); - - void ( STDMETHODCALLTYPE *ResourceBarrier )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT NumBarriers, - _In_reads_(NumBarriers) const D3D12_RESOURCE_BARRIER *pBarriers); - - void ( STDMETHODCALLTYPE *ExecuteBundle )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12GraphicsCommandList *pCommandList); - - void ( STDMETHODCALLTYPE *SetDescriptorHeaps )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT NumDescriptorHeaps, - _In_reads_(NumDescriptorHeaps) ID3D12DescriptorHeap *const *ppDescriptorHeaps); - - void ( STDMETHODCALLTYPE *SetComputeRootSignature )( - ID3D12GraphicsCommandList4 * This, - _In_opt_ ID3D12RootSignature *pRootSignature); - - void ( STDMETHODCALLTYPE *SetGraphicsRootSignature )( - ID3D12GraphicsCommandList4 * This, - _In_opt_ ID3D12RootSignature *pRootSignature); - - void ( STDMETHODCALLTYPE *SetComputeRootDescriptorTable )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); - - void ( STDMETHODCALLTYPE *SetGraphicsRootDescriptorTable )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); - - void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstant )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT RootParameterIndex, - _In_ UINT SrcData, - _In_ UINT DestOffsetIn32BitValues); - - void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstant )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT RootParameterIndex, - _In_ UINT SrcData, - _In_ UINT DestOffsetIn32BitValues); - - void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstants )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT RootParameterIndex, - _In_ UINT Num32BitValuesToSet, - _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, - _In_ UINT DestOffsetIn32BitValues); - - void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstants )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT RootParameterIndex, - _In_ UINT Num32BitValuesToSet, - _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, - _In_ UINT DestOffsetIn32BitValues); - - void ( STDMETHODCALLTYPE *SetComputeRootConstantBufferView )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *SetGraphicsRootConstantBufferView )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *SetComputeRootShaderResourceView )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *SetGraphicsRootShaderResourceView )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *SetComputeRootUnorderedAccessView )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *SetGraphicsRootUnorderedAccessView )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *IASetIndexBuffer )( - ID3D12GraphicsCommandList4 * This, - _In_opt_ const D3D12_INDEX_BUFFER_VIEW *pView); - - void ( STDMETHODCALLTYPE *IASetVertexBuffers )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT StartSlot, - _In_ UINT NumViews, - _In_reads_opt_(NumViews) const D3D12_VERTEX_BUFFER_VIEW *pViews); - - void ( STDMETHODCALLTYPE *SOSetTargets )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT StartSlot, - _In_ UINT NumViews, - _In_reads_opt_(NumViews) const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews); - - void ( STDMETHODCALLTYPE *OMSetRenderTargets )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT NumRenderTargetDescriptors, - _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors, - _In_ BOOL RTsSingleHandleToDescriptorRange, - _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pDepthStencilDescriptor); - - void ( STDMETHODCALLTYPE *ClearDepthStencilView )( - ID3D12GraphicsCommandList4 * This, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView, - _In_ D3D12_CLEAR_FLAGS ClearFlags, - _In_ FLOAT Depth, - _In_ UINT8 Stencil, - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); - - void ( STDMETHODCALLTYPE *ClearRenderTargetView )( - ID3D12GraphicsCommandList4 * This, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView, - _In_ const FLOAT ColorRGBA[ 4 ], - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); - - void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewUint )( - ID3D12GraphicsCommandList4 * This, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, - _In_ ID3D12Resource *pResource, - _In_ const UINT Values[ 4 ], - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); - - void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewFloat )( - ID3D12GraphicsCommandList4 * This, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, - _In_ ID3D12Resource *pResource, - _In_ const FLOAT Values[ 4 ], - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); - - void ( STDMETHODCALLTYPE *DiscardResource )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12Resource *pResource, - _In_opt_ const D3D12_DISCARD_REGION *pRegion); - - void ( STDMETHODCALLTYPE *BeginQuery )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12QueryHeap *pQueryHeap, - _In_ D3D12_QUERY_TYPE Type, - _In_ UINT Index); - - void ( STDMETHODCALLTYPE *EndQuery )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12QueryHeap *pQueryHeap, - _In_ D3D12_QUERY_TYPE Type, - _In_ UINT Index); - - void ( STDMETHODCALLTYPE *ResolveQueryData )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12QueryHeap *pQueryHeap, - _In_ D3D12_QUERY_TYPE Type, - _In_ UINT StartIndex, - _In_ UINT NumQueries, - _In_ ID3D12Resource *pDestinationBuffer, - _In_ UINT64 AlignedDestinationBufferOffset); - - void ( STDMETHODCALLTYPE *SetPredication )( - ID3D12GraphicsCommandList4 * This, - _In_opt_ ID3D12Resource *pBuffer, - _In_ UINT64 AlignedBufferOffset, - _In_ D3D12_PREDICATION_OP Operation); - - void ( STDMETHODCALLTYPE *SetMarker )( - ID3D12GraphicsCommandList4 * This, - UINT Metadata, - _In_reads_bytes_opt_(Size) const void *pData, - UINT Size); - - void ( STDMETHODCALLTYPE *BeginEvent )( - ID3D12GraphicsCommandList4 * This, - UINT Metadata, - _In_reads_bytes_opt_(Size) const void *pData, - UINT Size); - - void ( STDMETHODCALLTYPE *EndEvent )( - ID3D12GraphicsCommandList4 * This); - - void ( STDMETHODCALLTYPE *ExecuteIndirect )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12CommandSignature *pCommandSignature, - _In_ UINT MaxCommandCount, - _In_ ID3D12Resource *pArgumentBuffer, - _In_ UINT64 ArgumentBufferOffset, - _In_opt_ ID3D12Resource *pCountBuffer, - _In_ UINT64 CountBufferOffset); - - void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12Resource *pDstBuffer, - UINT64 DstOffset, - _In_ ID3D12Resource *pSrcBuffer, - UINT64 SrcOffset, - UINT Dependencies, - _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, - _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); - - void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT64 )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12Resource *pDstBuffer, - UINT64 DstOffset, - _In_ ID3D12Resource *pSrcBuffer, - UINT64 SrcOffset, - UINT Dependencies, - _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, - _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); - - void ( STDMETHODCALLTYPE *OMSetDepthBounds )( - ID3D12GraphicsCommandList4 * This, - _In_ FLOAT Min, - _In_ FLOAT Max); - - void ( STDMETHODCALLTYPE *SetSamplePositions )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT NumSamplesPerPixel, - _In_ UINT NumPixels, - _In_reads_(NumSamplesPerPixel*NumPixels) D3D12_SAMPLE_POSITION *pSamplePositions); - - void ( STDMETHODCALLTYPE *ResolveSubresourceRegion )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12Resource *pDstResource, - _In_ UINT DstSubresource, - _In_ UINT DstX, - _In_ UINT DstY, - _In_ ID3D12Resource *pSrcResource, - _In_ UINT SrcSubresource, - _In_opt_ D3D12_RECT *pSrcRect, - _In_ DXGI_FORMAT Format, - _In_ D3D12_RESOLVE_MODE ResolveMode); - - void ( STDMETHODCALLTYPE *SetViewInstanceMask )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT Mask); - - void ( STDMETHODCALLTYPE *WriteBufferImmediate )( - ID3D12GraphicsCommandList4 * This, - UINT Count, - _In_reads_(Count) const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams, - _In_reads_opt_(Count) const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes); - - void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( - ID3D12GraphicsCommandList4 * This, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedResourceSession); - - void ( STDMETHODCALLTYPE *BeginRenderPass )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT NumRenderTargets, - _In_reads_opt_(NumRenderTargets) const D3D12_RENDER_PASS_RENDER_TARGET_DESC *pRenderTargets, - _In_opt_ const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *pDepthStencil, - D3D12_RENDER_PASS_FLAGS Flags); - - void ( STDMETHODCALLTYPE *EndRenderPass )( - ID3D12GraphicsCommandList4 * This); - - void ( STDMETHODCALLTYPE *InitializeMetaCommand )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12MetaCommand *pMetaCommand, - _In_reads_bytes_opt_(InitializationParametersDataSizeInBytes) const void *pInitializationParametersData, - _In_ SIZE_T InitializationParametersDataSizeInBytes); - - void ( STDMETHODCALLTYPE *ExecuteMetaCommand )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12MetaCommand *pMetaCommand, - _In_reads_bytes_opt_(ExecutionParametersDataSizeInBytes) const void *pExecutionParametersData, - _In_ SIZE_T ExecutionParametersDataSizeInBytes); - - void ( STDMETHODCALLTYPE *BuildRaytracingAccelerationStructure )( - ID3D12GraphicsCommandList4 * This, - _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC *pDesc, - _In_ UINT NumPostbuildInfoDescs, - _In_reads_opt_(NumPostbuildInfoDescs) const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pPostbuildInfoDescs); - - void ( STDMETHODCALLTYPE *EmitRaytracingAccelerationStructurePostbuildInfo )( - ID3D12GraphicsCommandList4 * This, - _In_ const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pDesc, - _In_ UINT NumSourceAccelerationStructures, - _In_reads_( NumSourceAccelerationStructures ) const D3D12_GPU_VIRTUAL_ADDRESS *pSourceAccelerationStructureData); - - void ( STDMETHODCALLTYPE *CopyRaytracingAccelerationStructure )( - ID3D12GraphicsCommandList4 * This, - _In_ D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData, - _In_ D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData, - _In_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE Mode); - - void ( STDMETHODCALLTYPE *SetPipelineState1 )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12StateObject *pStateObject); - - void ( STDMETHODCALLTYPE *DispatchRays )( - ID3D12GraphicsCommandList4 * This, - _In_ const D3D12_DISPATCH_RAYS_DESC *pDesc); - - END_INTERFACE - } ID3D12GraphicsCommandList4Vtbl; - - interface ID3D12GraphicsCommandList4 - { - CONST_VTBL struct ID3D12GraphicsCommandList4Vtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12GraphicsCommandList4_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12GraphicsCommandList4_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12GraphicsCommandList4_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12GraphicsCommandList4_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12GraphicsCommandList4_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12GraphicsCommandList4_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12GraphicsCommandList4_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12GraphicsCommandList4_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - - -#define ID3D12GraphicsCommandList4_GetType(This) \ - ( (This)->lpVtbl -> GetType(This) ) - - -#define ID3D12GraphicsCommandList4_Close(This) \ - ( (This)->lpVtbl -> Close(This) ) - -#define ID3D12GraphicsCommandList4_Reset(This,pAllocator,pInitialState) \ - ( (This)->lpVtbl -> Reset(This,pAllocator,pInitialState) ) - -#define ID3D12GraphicsCommandList4_ClearState(This,pPipelineState) \ - ( (This)->lpVtbl -> ClearState(This,pPipelineState) ) - -#define ID3D12GraphicsCommandList4_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) \ - ( (This)->lpVtbl -> DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) ) - -#define ID3D12GraphicsCommandList4_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) \ - ( (This)->lpVtbl -> DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) ) - -#define ID3D12GraphicsCommandList4_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ - ( (This)->lpVtbl -> Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) - -#define ID3D12GraphicsCommandList4_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) \ - ( (This)->lpVtbl -> CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) ) - -#define ID3D12GraphicsCommandList4_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) \ - ( (This)->lpVtbl -> CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) ) - -#define ID3D12GraphicsCommandList4_CopyResource(This,pDstResource,pSrcResource) \ - ( (This)->lpVtbl -> CopyResource(This,pDstResource,pSrcResource) ) - -#define ID3D12GraphicsCommandList4_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) \ - ( (This)->lpVtbl -> CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) ) - -#define ID3D12GraphicsCommandList4_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) \ - ( (This)->lpVtbl -> ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) ) - -#define ID3D12GraphicsCommandList4_IASetPrimitiveTopology(This,PrimitiveTopology) \ - ( (This)->lpVtbl -> IASetPrimitiveTopology(This,PrimitiveTopology) ) - -#define ID3D12GraphicsCommandList4_RSSetViewports(This,NumViewports,pViewports) \ - ( (This)->lpVtbl -> RSSetViewports(This,NumViewports,pViewports) ) - -#define ID3D12GraphicsCommandList4_RSSetScissorRects(This,NumRects,pRects) \ - ( (This)->lpVtbl -> RSSetScissorRects(This,NumRects,pRects) ) - -#define ID3D12GraphicsCommandList4_OMSetBlendFactor(This,BlendFactor) \ - ( (This)->lpVtbl -> OMSetBlendFactor(This,BlendFactor) ) - -#define ID3D12GraphicsCommandList4_OMSetStencilRef(This,StencilRef) \ - ( (This)->lpVtbl -> OMSetStencilRef(This,StencilRef) ) - -#define ID3D12GraphicsCommandList4_SetPipelineState(This,pPipelineState) \ - ( (This)->lpVtbl -> SetPipelineState(This,pPipelineState) ) - -#define ID3D12GraphicsCommandList4_ResourceBarrier(This,NumBarriers,pBarriers) \ - ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) - -#define ID3D12GraphicsCommandList4_ExecuteBundle(This,pCommandList) \ - ( (This)->lpVtbl -> ExecuteBundle(This,pCommandList) ) - -#define ID3D12GraphicsCommandList4_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) \ - ( (This)->lpVtbl -> SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) ) - -#define ID3D12GraphicsCommandList4_SetComputeRootSignature(This,pRootSignature) \ - ( (This)->lpVtbl -> SetComputeRootSignature(This,pRootSignature) ) - -#define ID3D12GraphicsCommandList4_SetGraphicsRootSignature(This,pRootSignature) \ - ( (This)->lpVtbl -> SetGraphicsRootSignature(This,pRootSignature) ) - -#define ID3D12GraphicsCommandList4_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ - ( (This)->lpVtbl -> SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) - -#define ID3D12GraphicsCommandList4_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ - ( (This)->lpVtbl -> SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) - -#define ID3D12GraphicsCommandList4_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) - -#define ID3D12GraphicsCommandList4_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) - -#define ID3D12GraphicsCommandList4_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) - -#define ID3D12GraphicsCommandList4_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) - -#define ID3D12GraphicsCommandList4_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList4_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList4_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList4_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList4_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList4_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList4_IASetIndexBuffer(This,pView) \ - ( (This)->lpVtbl -> IASetIndexBuffer(This,pView) ) - -#define ID3D12GraphicsCommandList4_IASetVertexBuffers(This,StartSlot,NumViews,pViews) \ - ( (This)->lpVtbl -> IASetVertexBuffers(This,StartSlot,NumViews,pViews) ) - -#define ID3D12GraphicsCommandList4_SOSetTargets(This,StartSlot,NumViews,pViews) \ - ( (This)->lpVtbl -> SOSetTargets(This,StartSlot,NumViews,pViews) ) - -#define ID3D12GraphicsCommandList4_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) \ - ( (This)->lpVtbl -> OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) ) - -#define ID3D12GraphicsCommandList4_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) ) - -#define ID3D12GraphicsCommandList4_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) ) - -#define ID3D12GraphicsCommandList4_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) - -#define ID3D12GraphicsCommandList4_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) - -#define ID3D12GraphicsCommandList4_DiscardResource(This,pResource,pRegion) \ - ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) - -#define ID3D12GraphicsCommandList4_BeginQuery(This,pQueryHeap,Type,Index) \ - ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) - -#define ID3D12GraphicsCommandList4_EndQuery(This,pQueryHeap,Type,Index) \ - ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) - -#define ID3D12GraphicsCommandList4_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) \ - ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) - -#define ID3D12GraphicsCommandList4_SetPredication(This,pBuffer,AlignedBufferOffset,Operation) \ - ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) - -#define ID3D12GraphicsCommandList4_SetMarker(This,Metadata,pData,Size) \ - ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) - -#define ID3D12GraphicsCommandList4_BeginEvent(This,Metadata,pData,Size) \ - ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) - -#define ID3D12GraphicsCommandList4_EndEvent(This) \ - ( (This)->lpVtbl -> EndEvent(This) ) - -#define ID3D12GraphicsCommandList4_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) \ - ( (This)->lpVtbl -> ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) ) - - -#define ID3D12GraphicsCommandList4_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ - ( (This)->lpVtbl -> AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) - -#define ID3D12GraphicsCommandList4_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ - ( (This)->lpVtbl -> AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) - -#define ID3D12GraphicsCommandList4_OMSetDepthBounds(This,Min,Max) \ - ( (This)->lpVtbl -> OMSetDepthBounds(This,Min,Max) ) - -#define ID3D12GraphicsCommandList4_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) \ - ( (This)->lpVtbl -> SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) ) - -#define ID3D12GraphicsCommandList4_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) \ - ( (This)->lpVtbl -> ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) ) - -#define ID3D12GraphicsCommandList4_SetViewInstanceMask(This,Mask) \ - ( (This)->lpVtbl -> SetViewInstanceMask(This,Mask) ) - - -#define ID3D12GraphicsCommandList4_WriteBufferImmediate(This,Count,pParams,pModes) \ - ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) - - -#define ID3D12GraphicsCommandList4_SetProtectedResourceSession(This,pProtectedResourceSession) \ - ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) - - -#define ID3D12GraphicsCommandList4_BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) \ - ( (This)->lpVtbl -> BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) ) - -#define ID3D12GraphicsCommandList4_EndRenderPass(This) \ - ( (This)->lpVtbl -> EndRenderPass(This) ) - -#define ID3D12GraphicsCommandList4_InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) \ - ( (This)->lpVtbl -> InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) ) - -#define ID3D12GraphicsCommandList4_ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) \ - ( (This)->lpVtbl -> ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) ) - -#define ID3D12GraphicsCommandList4_BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) \ - ( (This)->lpVtbl -> BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) ) - -#define ID3D12GraphicsCommandList4_EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) \ - ( (This)->lpVtbl -> EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) ) - -#define ID3D12GraphicsCommandList4_CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) \ - ( (This)->lpVtbl -> CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) ) - -#define ID3D12GraphicsCommandList4_SetPipelineState1(This,pStateObject) \ - ( (This)->lpVtbl -> SetPipelineState1(This,pStateObject) ) - -#define ID3D12GraphicsCommandList4_DispatchRays(This,pDesc) \ - ( (This)->lpVtbl -> DispatchRays(This,pDesc) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12GraphicsCommandList4_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12Tools_INTERFACE_DEFINED__ -#define __ID3D12Tools_INTERFACE_DEFINED__ - -/* interface ID3D12Tools */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12Tools; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("7071e1f0-e84b-4b33-974f-12fa49de65c5") - ID3D12Tools : public IUnknown - { - public: - virtual void STDMETHODCALLTYPE EnableShaderInstrumentation( - BOOL bEnable) = 0; - - virtual BOOL STDMETHODCALLTYPE ShaderInstrumentationEnabled( void) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12ToolsVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12Tools * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12Tools * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12Tools * This); - - void ( STDMETHODCALLTYPE *EnableShaderInstrumentation )( - ID3D12Tools * This, - BOOL bEnable); - - BOOL ( STDMETHODCALLTYPE *ShaderInstrumentationEnabled )( - ID3D12Tools * This); - - END_INTERFACE - } ID3D12ToolsVtbl; - - interface ID3D12Tools - { - CONST_VTBL struct ID3D12ToolsVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12Tools_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12Tools_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12Tools_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12Tools_EnableShaderInstrumentation(This,bEnable) \ - ( (This)->lpVtbl -> EnableShaderInstrumentation(This,bEnable) ) - -#define ID3D12Tools_ShaderInstrumentationEnabled(This) \ - ( (This)->lpVtbl -> ShaderInstrumentationEnabled(This) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12Tools_INTERFACE_DEFINED__ */ - - -/* interface __MIDL_itf_d3d12_0000_0044 */ -/* [local] */ - -typedef struct D3D12_SUBRESOURCE_DATA - { - const void *pData; - LONG_PTR RowPitch; - LONG_PTR SlicePitch; - } D3D12_SUBRESOURCE_DATA; - -typedef struct D3D12_MEMCPY_DEST - { - void *pData; - SIZE_T RowPitch; - SIZE_T SlicePitch; - } D3D12_MEMCPY_DEST; - -#if !defined( D3D12_IGNORE_SDK_LAYERS ) -#include "d3d12sdklayers.h" -#endif - -/////////////////////////////////////////////////////////////////////////// -// D3D12CreateDevice -// ------------------ -// -// pAdapter -// If NULL, D3D12CreateDevice will choose the primary adapter. -// If non-NULL, D3D12CreateDevice will use the provided adapter. -// MinimumFeatureLevel -// The minimum feature level required for successful device creation. -// riid -// The interface IID of the device to be returned. Expected: ID3D12Device. -// ppDevice -// Pointer to returned interface. May be NULL. -// -// Return Values -// Any of those documented for -// CreateDXGIFactory1 -// IDXGIFactory::EnumAdapters -// D3D12CreateDevice -// -/////////////////////////////////////////////////////////////////////////// -typedef HRESULT (WINAPI* PFN_D3D12_CREATE_DEVICE)( _In_opt_ IUnknown*, - D3D_FEATURE_LEVEL, - _In_ REFIID, _COM_Outptr_opt_ void** ); - -HRESULT WINAPI D3D12CreateDevice( - _In_opt_ IUnknown* pAdapter, - D3D_FEATURE_LEVEL MinimumFeatureLevel, - _In_ REFIID riid, // Expected: ID3D12Device - _COM_Outptr_opt_ void** ppDevice ); - - -typedef HRESULT (WINAPI* PFN_D3D12_GET_DEBUG_INTERFACE)( _In_ REFIID, _COM_Outptr_opt_ void** ); - -HRESULT WINAPI D3D12GetDebugInterface( _In_ REFIID riid, _COM_Outptr_opt_ void** ppvDebug ); - -// -------------------------------------------------------------------------------------------------------------------------------- -// D3D12EnableExperimentalFeatures -// -// Pass in a list of feature GUIDs to be enabled together. -// -// If a particular feature requires some configuration information on enablement, it will have -// a configuration struct that can be passed alongside the GUID. -// -// Some features might use an interface IID as the GUID. For these, once the feature is enabled via -// D3D12EnableExperimentalFeatures, D3D12GetDebugInterface can then be called with the IID to retrieve the interface -// for manipulating the feature. This allows for control that might not cleanly be expressed by just -// the configuration struct that D3D12EnableExperimentalFeatures provides. -// -// If this method is called and a change to existing feature enablement is made, -// all current D3D12 devices are set to DEVICE_REMOVED state, since under the covers there is really only one -// singleton device for a process. Removing the devices when configuration changes prevents -// mismatched expectations of how a device is supposed to work after it has been created from the app's point of view. -// -// The call returns E_NOINTERFACE if an unrecognized feature is passed in or Windows Developer mode is not on. -// The call returns E_INVALIDARG if the configuration of a feature is incorrect, the set of features passed -// in are known to be incompatible with each other, or other errors. -// Returns S_OK otherwise. -// -// -------------------------------------------------------------------------------------------------------------------------------- -HRESULT WINAPI D3D12EnableExperimentalFeatures( - UINT NumFeatures, - __in_ecount(NumFeatures) const IID* pIIDs, - __in_ecount_opt(NumFeatures) void* pConfigurationStructs, - __in_ecount_opt(NumFeatures) UINT* pConfigurationStructSizes); - -// -------------------------------------------------------------------------------------------------------------------------------- -// Experimental Feature: D3D12ExperimentalShaderModels -// -// Use with D3D12EnableExperimentalFeatures to enable experimental shader model support, -// meaning shader models that haven't been finalized for use in retail. -// -// Enabling D3D12ExperimentalShaderModels needs no configuration struct, pass NULL in the pConfigurationStructs array. -// -// -------------------------------------------------------------------------------------------------------------------------------- -static const UUID D3D12ExperimentalShaderModels = { /* 76f5573e-f13a-40f5-b297-81ce9e18933f */ - 0x76f5573e, - 0xf13a, - 0x40f5, - { 0xb2, 0x97, 0x81, 0xce, 0x9e, 0x18, 0x93, 0x3f } -}; -// -------------------------------------------------------------------------------------------------------------------------------- -// Experimental Feature: D3D12TiledResourceTier4 -// -// Use with D3D12EnableExperimentalFeatures to enable tiled resource tier 4 support, -// meaning texture tile data-inheritance is allowed. -// -// Enabling D3D12TiledResourceTier4 needs no configuration struct, pass NULL in the pConfigurationStructs array. -// -// -------------------------------------------------------------------------------------------------------------------------------- -static const UUID D3D12TiledResourceTier4 = { /* c9c4725f-a81a-4f56-8c5b-c51039d694fb */ - 0xc9c4725f, - 0xa81a, - 0x4f56, - { 0x8c, 0x5b, 0xc5, 0x10, 0x39, 0xd6, 0x94, 0xfb } -}; -// -------------------------------------------------------------------------------------------------------------------------------- -// Experimental Feature: D3D12MetaCommand -// -// Use with D3D12EnableExperimentalFeatures to enable the D3D12 Meta Command. -// -// Enabling D3D12MetaCommand needs no configuration struct, pass NULL in the pConfigurationStructs array. -// -// -------------------------------------------------------------------------------------------------------------------------------- -static const UUID D3D12MetaCommand = { /* C734C97E-8077-48C8-9FDC-D9D1DD31DD77 */ - 0xc734c97e, - 0x8077, - 0x48c8, - { 0x9f, 0xdc, 0xd9, 0xd1, 0xdd, 0x31, 0xdd, 0x77 } -}; -// -------------------------------------------------------------------------------------------------------------------------------- -// Experimental Feature: D3D12ComputeOnlyDevices -// -// Use with D3D12EnableExperimentalFeatures to enable compute only devices (D3D_FEATURE_LEVEL_1_0_CORE). -// -// Enabling D3D12ComputeOnlyDevices needs no configuration struct, pass NULL in the pConfigurationStructs array. -// -// -------------------------------------------------------------------------------------------------------------------------------- -static const UUID D3D12ComputeOnlyDevices = { /* 50f7ab08-4b6d-4e14-89a5-5d16cd272594 */ - 0x50f7ab08, - 0x4b6d, - 0x4e14, - {0x89, 0xa5, 0x5d, 0x16, 0xcd, 0x27, 0x25, 0x94} -}; -typedef -enum D3D12_AXIS_SHADING_RATE - { - D3D12_AXIS_SHADING_RATE_1X = 0, - D3D12_AXIS_SHADING_RATE_2X = 0x1, - D3D12_AXIS_SHADING_RATE_4X = 0x2 - } D3D12_AXIS_SHADING_RATE; - -#define D3D12_SHADING_RATE_X_AXIS_SHIFT 2 -#define D3D12_SHADING_RATE_VALID_MASK 3 -#define D3D12_MAKE_COARSE_SHADING_RATE(x,y) ((x) << D3D12_SHADING_RATE_X_AXIS_SHIFT | (y)) -#define D3D12_GET_COARSE_SHADING_RATE_X_AXIS(x) (((x) >> D3D12_SHADING_RATE_X_AXIS_SHIFT) & D3D12_SHADING_RATE_VALID_MASK) -#define D3D12_GET_COARSE_SHADING_RATE_Y_AXIS(y) ((y) & D3D12_SHADING_RATE_VALID_MASK) -typedef -enum D3D12_SHADING_RATE - { - D3D12_SHADING_RATE_1X1 = 0, - D3D12_SHADING_RATE_1X2 = 0x1, - D3D12_SHADING_RATE_2X1 = 0x4, - D3D12_SHADING_RATE_2X2 = 0x5, - D3D12_SHADING_RATE_2X4 = 0x6, - D3D12_SHADING_RATE_4X2 = 0x9, - D3D12_SHADING_RATE_4X4 = 0xa - } D3D12_SHADING_RATE; - -typedef -enum D3D12_SHADING_RATE_COMBINER - { - D3D12_SHADING_RATE_COMBINER_PASSTHROUGH = 0, - D3D12_SHADING_RATE_COMBINER_OVERRIDE = 1, - D3D12_SHADING_RATE_COMBINER_MIN = 2, - D3D12_SHADING_RATE_COMBINER_MAX = 3, - D3D12_SHADING_RATE_COMBINER_SUM = 4 - } D3D12_SHADING_RATE_COMBINER; - - - -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0044_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0044_v0_0_s_ifspec; - -#ifndef __ID3D12GraphicsCommandList5_INTERFACE_DEFINED__ -#define __ID3D12GraphicsCommandList5_INTERFACE_DEFINED__ - -/* interface ID3D12GraphicsCommandList5 */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12GraphicsCommandList5; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("55050859-4024-474c-87f5-6472eaee44ea") - ID3D12GraphicsCommandList5 : public ID3D12GraphicsCommandList4 - { - public: - virtual void STDMETHODCALLTYPE RSSetShadingRate( - _In_ D3D12_SHADING_RATE baseShadingRate, - _In_reads_opt_(D3D12_RS_SET_SHADING_RATE_COMBINER_COUNT) const D3D12_SHADING_RATE_COMBINER *combiners) = 0; - - virtual void STDMETHODCALLTYPE RSSetShadingRateImage( - _In_opt_ ID3D12Resource *shadingRateImage) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12GraphicsCommandList5Vtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12GraphicsCommandList5 * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12GraphicsCommandList5 * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12GraphicsCommandList5 * This); - - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12GraphicsCommandList5 * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12GraphicsCommandList5 * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12GraphicsCommandList5 * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12GraphicsCommandList5 * This, - _In_z_ LPCWSTR Name); - - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12GraphicsCommandList5 * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( - ID3D12GraphicsCommandList5 * This); - - HRESULT ( STDMETHODCALLTYPE *Close )( - ID3D12GraphicsCommandList5 * This); - - HRESULT ( STDMETHODCALLTYPE *Reset )( - ID3D12GraphicsCommandList5 * This, - _In_ ID3D12CommandAllocator *pAllocator, - _In_opt_ ID3D12PipelineState *pInitialState); - - void ( STDMETHODCALLTYPE *ClearState )( - ID3D12GraphicsCommandList5 * This, - _In_opt_ ID3D12PipelineState *pPipelineState); - - void ( STDMETHODCALLTYPE *DrawInstanced )( - ID3D12GraphicsCommandList5 * This, - _In_ UINT VertexCountPerInstance, - _In_ UINT InstanceCount, - _In_ UINT StartVertexLocation, - _In_ UINT StartInstanceLocation); - - void ( STDMETHODCALLTYPE *DrawIndexedInstanced )( - ID3D12GraphicsCommandList5 * This, - _In_ UINT IndexCountPerInstance, - _In_ UINT InstanceCount, - _In_ UINT StartIndexLocation, - _In_ INT BaseVertexLocation, - _In_ UINT StartInstanceLocation); - - void ( STDMETHODCALLTYPE *Dispatch )( - ID3D12GraphicsCommandList5 * This, - _In_ UINT ThreadGroupCountX, - _In_ UINT ThreadGroupCountY, - _In_ UINT ThreadGroupCountZ); - - void ( STDMETHODCALLTYPE *CopyBufferRegion )( - ID3D12GraphicsCommandList5 * This, - _In_ ID3D12Resource *pDstBuffer, - UINT64 DstOffset, - _In_ ID3D12Resource *pSrcBuffer, - UINT64 SrcOffset, - UINT64 NumBytes); - - void ( STDMETHODCALLTYPE *CopyTextureRegion )( - ID3D12GraphicsCommandList5 * This, - _In_ const D3D12_TEXTURE_COPY_LOCATION *pDst, - UINT DstX, - UINT DstY, - UINT DstZ, - _In_ const D3D12_TEXTURE_COPY_LOCATION *pSrc, - _In_opt_ const D3D12_BOX *pSrcBox); - - void ( STDMETHODCALLTYPE *CopyResource )( - ID3D12GraphicsCommandList5 * This, - _In_ ID3D12Resource *pDstResource, - _In_ ID3D12Resource *pSrcResource); - - void ( STDMETHODCALLTYPE *CopyTiles )( - ID3D12GraphicsCommandList5 * This, - _In_ ID3D12Resource *pTiledResource, - _In_ const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate, - _In_ const D3D12_TILE_REGION_SIZE *pTileRegionSize, - _In_ ID3D12Resource *pBuffer, - UINT64 BufferStartOffsetInBytes, - D3D12_TILE_COPY_FLAGS Flags); - - void ( STDMETHODCALLTYPE *ResolveSubresource )( - ID3D12GraphicsCommandList5 * This, - _In_ ID3D12Resource *pDstResource, - _In_ UINT DstSubresource, - _In_ ID3D12Resource *pSrcResource, - _In_ UINT SrcSubresource, - _In_ DXGI_FORMAT Format); - - void ( STDMETHODCALLTYPE *IASetPrimitiveTopology )( - ID3D12GraphicsCommandList5 * This, - _In_ D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology); - - void ( STDMETHODCALLTYPE *RSSetViewports )( - ID3D12GraphicsCommandList5 * This, - _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumViewports, - _In_reads_( NumViewports) const D3D12_VIEWPORT *pViewports); - - void ( STDMETHODCALLTYPE *RSSetScissorRects )( - ID3D12GraphicsCommandList5 * This, - _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumRects, - _In_reads_( NumRects) const D3D12_RECT *pRects); - - void ( STDMETHODCALLTYPE *OMSetBlendFactor )( - ID3D12GraphicsCommandList5 * This, - _In_reads_opt_(4) const FLOAT BlendFactor[ 4 ]); - - void ( STDMETHODCALLTYPE *OMSetStencilRef )( - ID3D12GraphicsCommandList5 * This, - _In_ UINT StencilRef); - - void ( STDMETHODCALLTYPE *SetPipelineState )( - ID3D12GraphicsCommandList5 * This, - _In_ ID3D12PipelineState *pPipelineState); - - void ( STDMETHODCALLTYPE *ResourceBarrier )( - ID3D12GraphicsCommandList5 * This, - _In_ UINT NumBarriers, - _In_reads_(NumBarriers) const D3D12_RESOURCE_BARRIER *pBarriers); - - void ( STDMETHODCALLTYPE *ExecuteBundle )( - ID3D12GraphicsCommandList5 * This, - _In_ ID3D12GraphicsCommandList *pCommandList); - - void ( STDMETHODCALLTYPE *SetDescriptorHeaps )( - ID3D12GraphicsCommandList5 * This, - _In_ UINT NumDescriptorHeaps, - _In_reads_(NumDescriptorHeaps) ID3D12DescriptorHeap *const *ppDescriptorHeaps); - - void ( STDMETHODCALLTYPE *SetComputeRootSignature )( - ID3D12GraphicsCommandList5 * This, - _In_opt_ ID3D12RootSignature *pRootSignature); - - void ( STDMETHODCALLTYPE *SetGraphicsRootSignature )( - ID3D12GraphicsCommandList5 * This, - _In_opt_ ID3D12RootSignature *pRootSignature); - - void ( STDMETHODCALLTYPE *SetComputeRootDescriptorTable )( - ID3D12GraphicsCommandList5 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); - - void ( STDMETHODCALLTYPE *SetGraphicsRootDescriptorTable )( - ID3D12GraphicsCommandList5 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); - - void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstant )( - ID3D12GraphicsCommandList5 * This, - _In_ UINT RootParameterIndex, - _In_ UINT SrcData, - _In_ UINT DestOffsetIn32BitValues); - - void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstant )( - ID3D12GraphicsCommandList5 * This, - _In_ UINT RootParameterIndex, - _In_ UINT SrcData, - _In_ UINT DestOffsetIn32BitValues); - - void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstants )( - ID3D12GraphicsCommandList5 * This, - _In_ UINT RootParameterIndex, - _In_ UINT Num32BitValuesToSet, - _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, - _In_ UINT DestOffsetIn32BitValues); - - void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstants )( - ID3D12GraphicsCommandList5 * This, - _In_ UINT RootParameterIndex, - _In_ UINT Num32BitValuesToSet, - _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, - _In_ UINT DestOffsetIn32BitValues); - - void ( STDMETHODCALLTYPE *SetComputeRootConstantBufferView )( - ID3D12GraphicsCommandList5 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *SetGraphicsRootConstantBufferView )( - ID3D12GraphicsCommandList5 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *SetComputeRootShaderResourceView )( - ID3D12GraphicsCommandList5 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *SetGraphicsRootShaderResourceView )( - ID3D12GraphicsCommandList5 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *SetComputeRootUnorderedAccessView )( - ID3D12GraphicsCommandList5 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *SetGraphicsRootUnorderedAccessView )( - ID3D12GraphicsCommandList5 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - - void ( STDMETHODCALLTYPE *IASetIndexBuffer )( - ID3D12GraphicsCommandList5 * This, - _In_opt_ const D3D12_INDEX_BUFFER_VIEW *pView); - - void ( STDMETHODCALLTYPE *IASetVertexBuffers )( - ID3D12GraphicsCommandList5 * This, - _In_ UINT StartSlot, - _In_ UINT NumViews, - _In_reads_opt_(NumViews) const D3D12_VERTEX_BUFFER_VIEW *pViews); - - void ( STDMETHODCALLTYPE *SOSetTargets )( - ID3D12GraphicsCommandList5 * This, - _In_ UINT StartSlot, - _In_ UINT NumViews, - _In_reads_opt_(NumViews) const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews); - - void ( STDMETHODCALLTYPE *OMSetRenderTargets )( - ID3D12GraphicsCommandList5 * This, - _In_ UINT NumRenderTargetDescriptors, - _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors, - _In_ BOOL RTsSingleHandleToDescriptorRange, - _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pDepthStencilDescriptor); - - void ( STDMETHODCALLTYPE *ClearDepthStencilView )( - ID3D12GraphicsCommandList5 * This, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView, - _In_ D3D12_CLEAR_FLAGS ClearFlags, - _In_ FLOAT Depth, - _In_ UINT8 Stencil, - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); - - void ( STDMETHODCALLTYPE *ClearRenderTargetView )( - ID3D12GraphicsCommandList5 * This, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView, - _In_ const FLOAT ColorRGBA[ 4 ], - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); - - void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewUint )( - ID3D12GraphicsCommandList5 * This, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, - _In_ ID3D12Resource *pResource, - _In_ const UINT Values[ 4 ], - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); - - void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewFloat )( - ID3D12GraphicsCommandList5 * This, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, - _In_ ID3D12Resource *pResource, - _In_ const FLOAT Values[ 4 ], - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); - - void ( STDMETHODCALLTYPE *DiscardResource )( - ID3D12GraphicsCommandList5 * This, - _In_ ID3D12Resource *pResource, - _In_opt_ const D3D12_DISCARD_REGION *pRegion); - - void ( STDMETHODCALLTYPE *BeginQuery )( - ID3D12GraphicsCommandList5 * This, - _In_ ID3D12QueryHeap *pQueryHeap, - _In_ D3D12_QUERY_TYPE Type, - _In_ UINT Index); - - void ( STDMETHODCALLTYPE *EndQuery )( - ID3D12GraphicsCommandList5 * This, - _In_ ID3D12QueryHeap *pQueryHeap, - _In_ D3D12_QUERY_TYPE Type, - _In_ UINT Index); - - void ( STDMETHODCALLTYPE *ResolveQueryData )( - ID3D12GraphicsCommandList5 * This, - _In_ ID3D12QueryHeap *pQueryHeap, - _In_ D3D12_QUERY_TYPE Type, - _In_ UINT StartIndex, - _In_ UINT NumQueries, - _In_ ID3D12Resource *pDestinationBuffer, - _In_ UINT64 AlignedDestinationBufferOffset); - - void ( STDMETHODCALLTYPE *SetPredication )( - ID3D12GraphicsCommandList5 * This, - _In_opt_ ID3D12Resource *pBuffer, - _In_ UINT64 AlignedBufferOffset, - _In_ D3D12_PREDICATION_OP Operation); - - void ( STDMETHODCALLTYPE *SetMarker )( - ID3D12GraphicsCommandList5 * This, - UINT Metadata, - _In_reads_bytes_opt_(Size) const void *pData, - UINT Size); - - void ( STDMETHODCALLTYPE *BeginEvent )( - ID3D12GraphicsCommandList5 * This, - UINT Metadata, - _In_reads_bytes_opt_(Size) const void *pData, - UINT Size); - - void ( STDMETHODCALLTYPE *EndEvent )( - ID3D12GraphicsCommandList5 * This); - - void ( STDMETHODCALLTYPE *ExecuteIndirect )( - ID3D12GraphicsCommandList5 * This, - _In_ ID3D12CommandSignature *pCommandSignature, - _In_ UINT MaxCommandCount, - _In_ ID3D12Resource *pArgumentBuffer, - _In_ UINT64 ArgumentBufferOffset, - _In_opt_ ID3D12Resource *pCountBuffer, - _In_ UINT64 CountBufferOffset); - - void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT )( - ID3D12GraphicsCommandList5 * This, - _In_ ID3D12Resource *pDstBuffer, - UINT64 DstOffset, - _In_ ID3D12Resource *pSrcBuffer, - UINT64 SrcOffset, - UINT Dependencies, - _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, - _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); - - void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT64 )( - ID3D12GraphicsCommandList5 * This, - _In_ ID3D12Resource *pDstBuffer, - UINT64 DstOffset, - _In_ ID3D12Resource *pSrcBuffer, - UINT64 SrcOffset, - UINT Dependencies, - _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, - _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); - - void ( STDMETHODCALLTYPE *OMSetDepthBounds )( - ID3D12GraphicsCommandList5 * This, - _In_ FLOAT Min, - _In_ FLOAT Max); - - void ( STDMETHODCALLTYPE *SetSamplePositions )( - ID3D12GraphicsCommandList5 * This, - _In_ UINT NumSamplesPerPixel, - _In_ UINT NumPixels, - _In_reads_(NumSamplesPerPixel*NumPixels) D3D12_SAMPLE_POSITION *pSamplePositions); - - void ( STDMETHODCALLTYPE *ResolveSubresourceRegion )( - ID3D12GraphicsCommandList5 * This, - _In_ ID3D12Resource *pDstResource, - _In_ UINT DstSubresource, - _In_ UINT DstX, - _In_ UINT DstY, - _In_ ID3D12Resource *pSrcResource, - _In_ UINT SrcSubresource, - _In_opt_ D3D12_RECT *pSrcRect, - _In_ DXGI_FORMAT Format, - _In_ D3D12_RESOLVE_MODE ResolveMode); - - void ( STDMETHODCALLTYPE *SetViewInstanceMask )( - ID3D12GraphicsCommandList5 * This, - _In_ UINT Mask); - - void ( STDMETHODCALLTYPE *WriteBufferImmediate )( - ID3D12GraphicsCommandList5 * This, - UINT Count, - _In_reads_(Count) const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams, - _In_reads_opt_(Count) const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes); - - void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( - ID3D12GraphicsCommandList5 * This, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedResourceSession); - - void ( STDMETHODCALLTYPE *BeginRenderPass )( - ID3D12GraphicsCommandList5 * This, - _In_ UINT NumRenderTargets, - _In_reads_opt_(NumRenderTargets) const D3D12_RENDER_PASS_RENDER_TARGET_DESC *pRenderTargets, - _In_opt_ const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *pDepthStencil, - D3D12_RENDER_PASS_FLAGS Flags); - - void ( STDMETHODCALLTYPE *EndRenderPass )( - ID3D12GraphicsCommandList5 * This); - - void ( STDMETHODCALLTYPE *InitializeMetaCommand )( - ID3D12GraphicsCommandList5 * This, - _In_ ID3D12MetaCommand *pMetaCommand, - _In_reads_bytes_opt_(InitializationParametersDataSizeInBytes) const void *pInitializationParametersData, - _In_ SIZE_T InitializationParametersDataSizeInBytes); - - void ( STDMETHODCALLTYPE *ExecuteMetaCommand )( - ID3D12GraphicsCommandList5 * This, - _In_ ID3D12MetaCommand *pMetaCommand, - _In_reads_bytes_opt_(ExecutionParametersDataSizeInBytes) const void *pExecutionParametersData, - _In_ SIZE_T ExecutionParametersDataSizeInBytes); - - void ( STDMETHODCALLTYPE *BuildRaytracingAccelerationStructure )( - ID3D12GraphicsCommandList5 * This, - _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC *pDesc, - _In_ UINT NumPostbuildInfoDescs, - _In_reads_opt_(NumPostbuildInfoDescs) const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pPostbuildInfoDescs); - - void ( STDMETHODCALLTYPE *EmitRaytracingAccelerationStructurePostbuildInfo )( - ID3D12GraphicsCommandList5 * This, - _In_ const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pDesc, - _In_ UINT NumSourceAccelerationStructures, - _In_reads_( NumSourceAccelerationStructures ) const D3D12_GPU_VIRTUAL_ADDRESS *pSourceAccelerationStructureData); - - void ( STDMETHODCALLTYPE *CopyRaytracingAccelerationStructure )( - ID3D12GraphicsCommandList5 * This, - _In_ D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData, - _In_ D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData, - _In_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE Mode); - - void ( STDMETHODCALLTYPE *SetPipelineState1 )( - ID3D12GraphicsCommandList5 * This, - _In_ ID3D12StateObject *pStateObject); - - void ( STDMETHODCALLTYPE *DispatchRays )( - ID3D12GraphicsCommandList5 * This, - _In_ const D3D12_DISPATCH_RAYS_DESC *pDesc); - - void ( STDMETHODCALLTYPE *RSSetShadingRate )( - ID3D12GraphicsCommandList5 * This, - _In_ D3D12_SHADING_RATE baseShadingRate, - _In_reads_opt_(D3D12_RS_SET_SHADING_RATE_COMBINER_COUNT) const D3D12_SHADING_RATE_COMBINER *combiners); - - void ( STDMETHODCALLTYPE *RSSetShadingRateImage )( - ID3D12GraphicsCommandList5 * This, - _In_opt_ ID3D12Resource *shadingRateImage); - - END_INTERFACE - } ID3D12GraphicsCommandList5Vtbl; - - interface ID3D12GraphicsCommandList5 - { - CONST_VTBL struct ID3D12GraphicsCommandList5Vtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12GraphicsCommandList5_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12GraphicsCommandList5_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12GraphicsCommandList5_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12GraphicsCommandList5_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12GraphicsCommandList5_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12GraphicsCommandList5_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12GraphicsCommandList5_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12GraphicsCommandList5_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - - -#define ID3D12GraphicsCommandList5_GetType(This) \ - ( (This)->lpVtbl -> GetType(This) ) - - -#define ID3D12GraphicsCommandList5_Close(This) \ - ( (This)->lpVtbl -> Close(This) ) - -#define ID3D12GraphicsCommandList5_Reset(This,pAllocator,pInitialState) \ - ( (This)->lpVtbl -> Reset(This,pAllocator,pInitialState) ) - -#define ID3D12GraphicsCommandList5_ClearState(This,pPipelineState) \ - ( (This)->lpVtbl -> ClearState(This,pPipelineState) ) - -#define ID3D12GraphicsCommandList5_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) \ - ( (This)->lpVtbl -> DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) ) - -#define ID3D12GraphicsCommandList5_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) \ - ( (This)->lpVtbl -> DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) ) - -#define ID3D12GraphicsCommandList5_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ - ( (This)->lpVtbl -> Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) - -#define ID3D12GraphicsCommandList5_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) \ - ( (This)->lpVtbl -> CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) ) - -#define ID3D12GraphicsCommandList5_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) \ - ( (This)->lpVtbl -> CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) ) - -#define ID3D12GraphicsCommandList5_CopyResource(This,pDstResource,pSrcResource) \ - ( (This)->lpVtbl -> CopyResource(This,pDstResource,pSrcResource) ) - -#define ID3D12GraphicsCommandList5_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) \ - ( (This)->lpVtbl -> CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) ) - -#define ID3D12GraphicsCommandList5_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) \ - ( (This)->lpVtbl -> ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) ) - -#define ID3D12GraphicsCommandList5_IASetPrimitiveTopology(This,PrimitiveTopology) \ - ( (This)->lpVtbl -> IASetPrimitiveTopology(This,PrimitiveTopology) ) - -#define ID3D12GraphicsCommandList5_RSSetViewports(This,NumViewports,pViewports) \ - ( (This)->lpVtbl -> RSSetViewports(This,NumViewports,pViewports) ) - -#define ID3D12GraphicsCommandList5_RSSetScissorRects(This,NumRects,pRects) \ - ( (This)->lpVtbl -> RSSetScissorRects(This,NumRects,pRects) ) - -#define ID3D12GraphicsCommandList5_OMSetBlendFactor(This,BlendFactor) \ - ( (This)->lpVtbl -> OMSetBlendFactor(This,BlendFactor) ) - -#define ID3D12GraphicsCommandList5_OMSetStencilRef(This,StencilRef) \ - ( (This)->lpVtbl -> OMSetStencilRef(This,StencilRef) ) - -#define ID3D12GraphicsCommandList5_SetPipelineState(This,pPipelineState) \ - ( (This)->lpVtbl -> SetPipelineState(This,pPipelineState) ) - -#define ID3D12GraphicsCommandList5_ResourceBarrier(This,NumBarriers,pBarriers) \ - ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) - -#define ID3D12GraphicsCommandList5_ExecuteBundle(This,pCommandList) \ - ( (This)->lpVtbl -> ExecuteBundle(This,pCommandList) ) - -#define ID3D12GraphicsCommandList5_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) \ - ( (This)->lpVtbl -> SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) ) - -#define ID3D12GraphicsCommandList5_SetComputeRootSignature(This,pRootSignature) \ - ( (This)->lpVtbl -> SetComputeRootSignature(This,pRootSignature) ) - -#define ID3D12GraphicsCommandList5_SetGraphicsRootSignature(This,pRootSignature) \ - ( (This)->lpVtbl -> SetGraphicsRootSignature(This,pRootSignature) ) - -#define ID3D12GraphicsCommandList5_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ - ( (This)->lpVtbl -> SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) - -#define ID3D12GraphicsCommandList5_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ - ( (This)->lpVtbl -> SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) - -#define ID3D12GraphicsCommandList5_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) - -#define ID3D12GraphicsCommandList5_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) - -#define ID3D12GraphicsCommandList5_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) - -#define ID3D12GraphicsCommandList5_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) - -#define ID3D12GraphicsCommandList5_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList5_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList5_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList5_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList5_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList5_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) - -#define ID3D12GraphicsCommandList5_IASetIndexBuffer(This,pView) \ - ( (This)->lpVtbl -> IASetIndexBuffer(This,pView) ) - -#define ID3D12GraphicsCommandList5_IASetVertexBuffers(This,StartSlot,NumViews,pViews) \ - ( (This)->lpVtbl -> IASetVertexBuffers(This,StartSlot,NumViews,pViews) ) - -#define ID3D12GraphicsCommandList5_SOSetTargets(This,StartSlot,NumViews,pViews) \ - ( (This)->lpVtbl -> SOSetTargets(This,StartSlot,NumViews,pViews) ) - -#define ID3D12GraphicsCommandList5_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) \ - ( (This)->lpVtbl -> OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) ) - -#define ID3D12GraphicsCommandList5_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) ) - -#define ID3D12GraphicsCommandList5_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) ) - -#define ID3D12GraphicsCommandList5_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) - -#define ID3D12GraphicsCommandList5_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) - -#define ID3D12GraphicsCommandList5_DiscardResource(This,pResource,pRegion) \ - ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) - -#define ID3D12GraphicsCommandList5_BeginQuery(This,pQueryHeap,Type,Index) \ - ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) - -#define ID3D12GraphicsCommandList5_EndQuery(This,pQueryHeap,Type,Index) \ - ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) - -#define ID3D12GraphicsCommandList5_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) \ - ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) - -#define ID3D12GraphicsCommandList5_SetPredication(This,pBuffer,AlignedBufferOffset,Operation) \ - ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) - -#define ID3D12GraphicsCommandList5_SetMarker(This,Metadata,pData,Size) \ - ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) - -#define ID3D12GraphicsCommandList5_BeginEvent(This,Metadata,pData,Size) \ - ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) - -#define ID3D12GraphicsCommandList5_EndEvent(This) \ - ( (This)->lpVtbl -> EndEvent(This) ) - -#define ID3D12GraphicsCommandList5_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) \ - ( (This)->lpVtbl -> ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) ) - - -#define ID3D12GraphicsCommandList5_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ - ( (This)->lpVtbl -> AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) - -#define ID3D12GraphicsCommandList5_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ - ( (This)->lpVtbl -> AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) - -#define ID3D12GraphicsCommandList5_OMSetDepthBounds(This,Min,Max) \ - ( (This)->lpVtbl -> OMSetDepthBounds(This,Min,Max) ) - -#define ID3D12GraphicsCommandList5_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) \ - ( (This)->lpVtbl -> SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) ) - -#define ID3D12GraphicsCommandList5_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) \ - ( (This)->lpVtbl -> ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) ) - -#define ID3D12GraphicsCommandList5_SetViewInstanceMask(This,Mask) \ - ( (This)->lpVtbl -> SetViewInstanceMask(This,Mask) ) - - -#define ID3D12GraphicsCommandList5_WriteBufferImmediate(This,Count,pParams,pModes) \ - ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) - - -#define ID3D12GraphicsCommandList5_SetProtectedResourceSession(This,pProtectedResourceSession) \ - ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) - - -#define ID3D12GraphicsCommandList5_BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) \ - ( (This)->lpVtbl -> BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) ) - -#define ID3D12GraphicsCommandList5_EndRenderPass(This) \ - ( (This)->lpVtbl -> EndRenderPass(This) ) - -#define ID3D12GraphicsCommandList5_InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) \ - ( (This)->lpVtbl -> InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) ) - -#define ID3D12GraphicsCommandList5_ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) \ - ( (This)->lpVtbl -> ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) ) - -#define ID3D12GraphicsCommandList5_BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) \ - ( (This)->lpVtbl -> BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) ) - -#define ID3D12GraphicsCommandList5_EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) \ - ( (This)->lpVtbl -> EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) ) - -#define ID3D12GraphicsCommandList5_CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) \ - ( (This)->lpVtbl -> CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) ) - -#define ID3D12GraphicsCommandList5_SetPipelineState1(This,pStateObject) \ - ( (This)->lpVtbl -> SetPipelineState1(This,pStateObject) ) - -#define ID3D12GraphicsCommandList5_DispatchRays(This,pDesc) \ - ( (This)->lpVtbl -> DispatchRays(This,pDesc) ) - - -#define ID3D12GraphicsCommandList5_RSSetShadingRate(This,baseShadingRate,combiners) \ - ( (This)->lpVtbl -> RSSetShadingRate(This,baseShadingRate,combiners) ) - -#define ID3D12GraphicsCommandList5_RSSetShadingRateImage(This,shadingRateImage) \ - ( (This)->lpVtbl -> RSSetShadingRateImage(This,shadingRateImage) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12GraphicsCommandList5_INTERFACE_DEFINED__ */ - - -/* interface __MIDL_itf_d3d12_0000_0045 */ -/* [local] */ - -#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */ -#pragma endregion -DEFINE_GUID(IID_ID3D12Object,0xc4fec28f,0x7966,0x4e95,0x9f,0x94,0xf4,0x31,0xcb,0x56,0xc3,0xb8); -DEFINE_GUID(IID_ID3D12DeviceChild,0x905db94b,0xa00c,0x4140,0x9d,0xf5,0x2b,0x64,0xca,0x9e,0xa3,0x57); -DEFINE_GUID(IID_ID3D12RootSignature,0xc54a6b66,0x72df,0x4ee8,0x8b,0xe5,0xa9,0x46,0xa1,0x42,0x92,0x14); -DEFINE_GUID(IID_ID3D12RootSignatureDeserializer,0x34AB647B,0x3CC8,0x46AC,0x84,0x1B,0xC0,0x96,0x56,0x45,0xC0,0x46); -DEFINE_GUID(IID_ID3D12VersionedRootSignatureDeserializer,0x7F91CE67,0x090C,0x4BB7,0xB7,0x8E,0xED,0x8F,0xF2,0xE3,0x1D,0xA0); -DEFINE_GUID(IID_ID3D12Pageable,0x63ee58fb,0x1268,0x4835,0x86,0xda,0xf0,0x08,0xce,0x62,0xf0,0xd6); -DEFINE_GUID(IID_ID3D12Heap,0x6b3b2502,0x6e51,0x45b3,0x90,0xee,0x98,0x84,0x26,0x5e,0x8d,0xf3); -DEFINE_GUID(IID_ID3D12Resource,0x696442be,0xa72e,0x4059,0xbc,0x79,0x5b,0x5c,0x98,0x04,0x0f,0xad); -DEFINE_GUID(IID_ID3D12CommandAllocator,0x6102dee4,0xaf59,0x4b09,0xb9,0x99,0xb4,0x4d,0x73,0xf0,0x9b,0x24); -DEFINE_GUID(IID_ID3D12Fence,0x0a753dcf,0xc4d8,0x4b91,0xad,0xf6,0xbe,0x5a,0x60,0xd9,0x5a,0x76); -DEFINE_GUID(IID_ID3D12Fence1,0x433685fe,0xe22b,0x4ca0,0xa8,0xdb,0xb5,0xb4,0xf4,0xdd,0x0e,0x4a); -DEFINE_GUID(IID_ID3D12PipelineState,0x765a30f3,0xf624,0x4c6f,0xa8,0x28,0xac,0xe9,0x48,0x62,0x24,0x45); -DEFINE_GUID(IID_ID3D12DescriptorHeap,0x8efb471d,0x616c,0x4f49,0x90,0xf7,0x12,0x7b,0xb7,0x63,0xfa,0x51); -DEFINE_GUID(IID_ID3D12QueryHeap,0x0d9658ae,0xed45,0x469e,0xa6,0x1d,0x97,0x0e,0xc5,0x83,0xca,0xb4); -DEFINE_GUID(IID_ID3D12CommandSignature,0xc36a797c,0xec80,0x4f0a,0x89,0x85,0xa7,0xb2,0x47,0x50,0x82,0xd1); -DEFINE_GUID(IID_ID3D12CommandList,0x7116d91c,0xe7e4,0x47ce,0xb8,0xc6,0xec,0x81,0x68,0xf4,0x37,0xe5); -DEFINE_GUID(IID_ID3D12GraphicsCommandList,0x5b160d0f,0xac1b,0x4185,0x8b,0xa8,0xb3,0xae,0x42,0xa5,0xa4,0x55); -DEFINE_GUID(IID_ID3D12GraphicsCommandList1,0x553103fb,0x1fe7,0x4557,0xbb,0x38,0x94,0x6d,0x7d,0x0e,0x7c,0xa7); -DEFINE_GUID(IID_ID3D12GraphicsCommandList2,0x38C3E585,0xFF17,0x412C,0x91,0x50,0x4F,0xC6,0xF9,0xD7,0x2A,0x28); -DEFINE_GUID(IID_ID3D12CommandQueue,0x0ec870a6,0x5d7e,0x4c22,0x8c,0xfc,0x5b,0xaa,0xe0,0x76,0x16,0xed); -DEFINE_GUID(IID_ID3D12Device,0x189819f1,0x1db6,0x4b57,0xbe,0x54,0x18,0x21,0x33,0x9b,0x85,0xf7); -DEFINE_GUID(IID_ID3D12PipelineLibrary,0xc64226a8,0x9201,0x46af,0xb4,0xcc,0x53,0xfb,0x9f,0xf7,0x41,0x4f); -DEFINE_GUID(IID_ID3D12PipelineLibrary1,0x80eabf42,0x2568,0x4e5e,0xbd,0x82,0xc3,0x7f,0x86,0x96,0x1d,0xc3); -DEFINE_GUID(IID_ID3D12Device1,0x77acce80,0x638e,0x4e65,0x88,0x95,0xc1,0xf2,0x33,0x86,0x86,0x3e); -DEFINE_GUID(IID_ID3D12Device2,0x30baa41e,0xb15b,0x475c,0xa0,0xbb,0x1a,0xf5,0xc5,0xb6,0x43,0x28); -DEFINE_GUID(IID_ID3D12Device3,0x81dadc15,0x2bad,0x4392,0x93,0xc5,0x10,0x13,0x45,0xc4,0xaa,0x98); -DEFINE_GUID(IID_ID3D12ProtectedSession,0xA1533D18,0x0AC1,0x4084,0x85,0xB9,0x89,0xA9,0x61,0x16,0x80,0x6B); -DEFINE_GUID(IID_ID3D12ProtectedResourceSession,0x6CD696F4,0xF289,0x40CC,0x80,0x91,0x5A,0x6C,0x0A,0x09,0x9C,0x3D); -DEFINE_GUID(IID_ID3D12Device4,0xe865df17,0xa9ee,0x46f9,0xa4,0x63,0x30,0x98,0x31,0x5a,0xa2,0xe5); -DEFINE_GUID(IID_ID3D12LifetimeOwner,0xe667af9f,0xcd56,0x4f46,0x83,0xce,0x03,0x2e,0x59,0x5d,0x70,0xa8); -DEFINE_GUID(IID_ID3D12SwapChainAssistant,0xf1df64b6,0x57fd,0x49cd,0x88,0x07,0xc0,0xeb,0x88,0xb4,0x5c,0x8f); -DEFINE_GUID(IID_ID3D12LifetimeTracker,0x3fd03d36,0x4eb1,0x424a,0xa5,0x82,0x49,0x4e,0xcb,0x8b,0xa8,0x13); -DEFINE_GUID(IID_ID3D12StateObject,0x47016943,0xfca8,0x4594,0x93,0xea,0xaf,0x25,0x8b,0x55,0x34,0x6d); -DEFINE_GUID(IID_ID3D12StateObjectProperties,0xde5fa827,0x9bf9,0x4f26,0x89,0xff,0xd7,0xf5,0x6f,0xde,0x38,0x60); -DEFINE_GUID(IID_ID3D12Device5,0x8b4f173b,0x2fea,0x4b80,0x8f,0x58,0x43,0x07,0x19,0x1a,0xb9,0x5d); -DEFINE_GUID(IID_ID3D12DeviceRemovedExtendedDataSettings,0x82BC481C,0x6B9B,0x4030,0xAE,0xDB,0x7E,0xE3,0xD1,0xDF,0x1E,0x63); -DEFINE_GUID(IID_ID3D12DeviceRemovedExtendedData,0x98931D33,0x5AE8,0x4791,0xAA,0x3C,0x1A,0x73,0xA2,0x93,0x4E,0x71); -DEFINE_GUID(IID_ID3D12Device6,0xc70b221b,0x40e4,0x4a17,0x89,0xaf,0x02,0x5a,0x07,0x27,0xa6,0xdc); -DEFINE_GUID(IID_ID3D12Resource1,0x9D5E227A,0x4430,0x4161,0x88,0xB3,0x3E,0xCA,0x6B,0xB1,0x6E,0x19); -DEFINE_GUID(IID_ID3D12Heap1,0x572F7389,0x2168,0x49E3,0x96,0x93,0xD6,0xDF,0x58,0x71,0xBF,0x6D); -DEFINE_GUID(IID_ID3D12GraphicsCommandList3,0x6FDA83A7,0xB84C,0x4E38,0x9A,0xC8,0xC7,0xBD,0x22,0x01,0x6B,0x3D); -DEFINE_GUID(IID_ID3D12MetaCommand,0xDBB84C27,0x36CE,0x4FC9,0xB8,0x01,0xF0,0x48,0xC4,0x6A,0xC5,0x70); -DEFINE_GUID(IID_ID3D12GraphicsCommandList4,0x8754318e,0xd3a9,0x4541,0x98,0xcf,0x64,0x5b,0x50,0xdc,0x48,0x74); -DEFINE_GUID(IID_ID3D12Tools,0x7071e1f0,0xe84b,0x4b33,0x97,0x4f,0x12,0xfa,0x49,0xde,0x65,0xc5); -DEFINE_GUID(IID_ID3D12GraphicsCommandList5,0x55050859,0x4024,0x474c,0x87,0xf5,0x64,0x72,0xea,0xee,0x44,0xea); - - -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0045_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0045_v0_0_s_ifspec; - -/* Additional Prototypes for ALL interfaces */ - -/* end of Additional Prototypes */ - -#ifdef __cplusplus -} -#endif - -#endif - - diff --git a/src/decomp/pc/gfx/dxsdk/d3d12sdklayers.h b/src/decomp/pc/gfx/dxsdk/d3d12sdklayers.h deleted file mode 100644 index cb4f9cd..0000000 --- a/src/decomp/pc/gfx/dxsdk/d3d12sdklayers.h +++ /dev/null @@ -1,3230 +0,0 @@ -/*------------------------------------------------------------------------------------- - * - * Copyright (c) Microsoft Corporation - * - *-------------------------------------------------------------------------------------*/ - - -/* this ALWAYS GENERATED file contains the definitions for the interfaces */ - - - /* File created by MIDL compiler version 8.01.0622 */ - - - -/* verify that the version is high enough to compile this file*/ -#ifndef __REQUIRED_RPCNDR_H_VERSION__ -#define __REQUIRED_RPCNDR_H_VERSION__ 500 -#endif - -/* verify that the version is high enough to compile this file*/ -#ifndef __REQUIRED_RPCSAL_H_VERSION__ -#define __REQUIRED_RPCSAL_H_VERSION__ 100 -#endif - -#include "rpc.h" -#include "rpcndr.h" - -#ifndef __RPCNDR_H_VERSION__ -#error this stub requires an updated version of -#endif /* __RPCNDR_H_VERSION__ */ - -#ifndef COM_NO_WINDOWS_H -#include "windows.h" -#include "ole2.h" -#endif /*COM_NO_WINDOWS_H*/ - -#ifndef __d3d12sdklayers_h__ -#define __d3d12sdklayers_h__ - -#if defined(_MSC_VER) && (_MSC_VER >= 1020) -#pragma once -#endif - -/* Forward Declarations */ - -#ifndef __ID3D12Debug_FWD_DEFINED__ -#define __ID3D12Debug_FWD_DEFINED__ -typedef interface ID3D12Debug ID3D12Debug; - -#endif /* __ID3D12Debug_FWD_DEFINED__ */ - - -#ifndef __ID3D12Debug1_FWD_DEFINED__ -#define __ID3D12Debug1_FWD_DEFINED__ -typedef interface ID3D12Debug1 ID3D12Debug1; - -#endif /* __ID3D12Debug1_FWD_DEFINED__ */ - - -#ifndef __ID3D12Debug2_FWD_DEFINED__ -#define __ID3D12Debug2_FWD_DEFINED__ -typedef interface ID3D12Debug2 ID3D12Debug2; - -#endif /* __ID3D12Debug2_FWD_DEFINED__ */ - - -#ifndef __ID3D12Debug3_FWD_DEFINED__ -#define __ID3D12Debug3_FWD_DEFINED__ -typedef interface ID3D12Debug3 ID3D12Debug3; - -#endif /* __ID3D12Debug3_FWD_DEFINED__ */ - - -#ifndef __ID3D12DebugDevice1_FWD_DEFINED__ -#define __ID3D12DebugDevice1_FWD_DEFINED__ -typedef interface ID3D12DebugDevice1 ID3D12DebugDevice1; - -#endif /* __ID3D12DebugDevice1_FWD_DEFINED__ */ - - -#ifndef __ID3D12DebugDevice_FWD_DEFINED__ -#define __ID3D12DebugDevice_FWD_DEFINED__ -typedef interface ID3D12DebugDevice ID3D12DebugDevice; - -#endif /* __ID3D12DebugDevice_FWD_DEFINED__ */ - - -#ifndef __ID3D12DebugDevice2_FWD_DEFINED__ -#define __ID3D12DebugDevice2_FWD_DEFINED__ -typedef interface ID3D12DebugDevice2 ID3D12DebugDevice2; - -#endif /* __ID3D12DebugDevice2_FWD_DEFINED__ */ - - -#ifndef __ID3D12DebugCommandQueue_FWD_DEFINED__ -#define __ID3D12DebugCommandQueue_FWD_DEFINED__ -typedef interface ID3D12DebugCommandQueue ID3D12DebugCommandQueue; - -#endif /* __ID3D12DebugCommandQueue_FWD_DEFINED__ */ - - -#ifndef __ID3D12DebugCommandList1_FWD_DEFINED__ -#define __ID3D12DebugCommandList1_FWD_DEFINED__ -typedef interface ID3D12DebugCommandList1 ID3D12DebugCommandList1; - -#endif /* __ID3D12DebugCommandList1_FWD_DEFINED__ */ - - -#ifndef __ID3D12DebugCommandList_FWD_DEFINED__ -#define __ID3D12DebugCommandList_FWD_DEFINED__ -typedef interface ID3D12DebugCommandList ID3D12DebugCommandList; - -#endif /* __ID3D12DebugCommandList_FWD_DEFINED__ */ - - -#ifndef __ID3D12DebugCommandList2_FWD_DEFINED__ -#define __ID3D12DebugCommandList2_FWD_DEFINED__ -typedef interface ID3D12DebugCommandList2 ID3D12DebugCommandList2; - -#endif /* __ID3D12DebugCommandList2_FWD_DEFINED__ */ - - -#ifndef __ID3D12SharingContract_FWD_DEFINED__ -#define __ID3D12SharingContract_FWD_DEFINED__ -typedef interface ID3D12SharingContract ID3D12SharingContract; - -#endif /* __ID3D12SharingContract_FWD_DEFINED__ */ - - -#ifndef __ID3D12InfoQueue_FWD_DEFINED__ -#define __ID3D12InfoQueue_FWD_DEFINED__ -typedef interface ID3D12InfoQueue ID3D12InfoQueue; - -#endif /* __ID3D12InfoQueue_FWD_DEFINED__ */ - - -/* header files for imported files */ -#include "oaidl.h" -#include "ocidl.h" -#include "d3d12.h" - -#ifdef __cplusplus -extern "C"{ -#endif - - -/* interface __MIDL_itf_d3d12sdklayers_0000_0000 */ -/* [local] */ - -#include -#pragma region App Family -#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) - - -extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0000_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0000_v0_0_s_ifspec; - -#ifndef __ID3D12Debug_INTERFACE_DEFINED__ -#define __ID3D12Debug_INTERFACE_DEFINED__ - -/* interface ID3D12Debug */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12Debug; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("344488b7-6846-474b-b989-f027448245e0") - ID3D12Debug : public IUnknown - { - public: - virtual void STDMETHODCALLTYPE EnableDebugLayer( void) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12DebugVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12Debug * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12Debug * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12Debug * This); - - void ( STDMETHODCALLTYPE *EnableDebugLayer )( - ID3D12Debug * This); - - END_INTERFACE - } ID3D12DebugVtbl; - - interface ID3D12Debug - { - CONST_VTBL struct ID3D12DebugVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12Debug_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12Debug_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12Debug_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12Debug_EnableDebugLayer(This) \ - ( (This)->lpVtbl -> EnableDebugLayer(This) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12Debug_INTERFACE_DEFINED__ */ - - -/* interface __MIDL_itf_d3d12sdklayers_0000_0001 */ -/* [local] */ - -typedef -enum D3D12_GPU_BASED_VALIDATION_FLAGS - { - D3D12_GPU_BASED_VALIDATION_FLAGS_NONE = 0, - D3D12_GPU_BASED_VALIDATION_FLAGS_DISABLE_STATE_TRACKING = 0x1 - } D3D12_GPU_BASED_VALIDATION_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS(D3D12_GPU_BASED_VALIDATION_FLAGS) - - -extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0001_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0001_v0_0_s_ifspec; - -#ifndef __ID3D12Debug1_INTERFACE_DEFINED__ -#define __ID3D12Debug1_INTERFACE_DEFINED__ - -/* interface ID3D12Debug1 */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12Debug1; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("affaa4ca-63fe-4d8e-b8ad-159000af4304") - ID3D12Debug1 : public IUnknown - { - public: - virtual void STDMETHODCALLTYPE EnableDebugLayer( void) = 0; - - virtual void STDMETHODCALLTYPE SetEnableGPUBasedValidation( - BOOL Enable) = 0; - - virtual void STDMETHODCALLTYPE SetEnableSynchronizedCommandQueueValidation( - BOOL Enable) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12Debug1Vtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12Debug1 * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12Debug1 * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12Debug1 * This); - - void ( STDMETHODCALLTYPE *EnableDebugLayer )( - ID3D12Debug1 * This); - - void ( STDMETHODCALLTYPE *SetEnableGPUBasedValidation )( - ID3D12Debug1 * This, - BOOL Enable); - - void ( STDMETHODCALLTYPE *SetEnableSynchronizedCommandQueueValidation )( - ID3D12Debug1 * This, - BOOL Enable); - - END_INTERFACE - } ID3D12Debug1Vtbl; - - interface ID3D12Debug1 - { - CONST_VTBL struct ID3D12Debug1Vtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12Debug1_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12Debug1_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12Debug1_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12Debug1_EnableDebugLayer(This) \ - ( (This)->lpVtbl -> EnableDebugLayer(This) ) - -#define ID3D12Debug1_SetEnableGPUBasedValidation(This,Enable) \ - ( (This)->lpVtbl -> SetEnableGPUBasedValidation(This,Enable) ) - -#define ID3D12Debug1_SetEnableSynchronizedCommandQueueValidation(This,Enable) \ - ( (This)->lpVtbl -> SetEnableSynchronizedCommandQueueValidation(This,Enable) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12Debug1_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12Debug2_INTERFACE_DEFINED__ -#define __ID3D12Debug2_INTERFACE_DEFINED__ - -/* interface ID3D12Debug2 */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12Debug2; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("93a665c4-a3b2-4e5d-b692-a26ae14e3374") - ID3D12Debug2 : public IUnknown - { - public: - virtual void STDMETHODCALLTYPE SetGPUBasedValidationFlags( - D3D12_GPU_BASED_VALIDATION_FLAGS Flags) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12Debug2Vtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12Debug2 * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12Debug2 * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12Debug2 * This); - - void ( STDMETHODCALLTYPE *SetGPUBasedValidationFlags )( - ID3D12Debug2 * This, - D3D12_GPU_BASED_VALIDATION_FLAGS Flags); - - END_INTERFACE - } ID3D12Debug2Vtbl; - - interface ID3D12Debug2 - { - CONST_VTBL struct ID3D12Debug2Vtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12Debug2_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12Debug2_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12Debug2_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12Debug2_SetGPUBasedValidationFlags(This,Flags) \ - ( (This)->lpVtbl -> SetGPUBasedValidationFlags(This,Flags) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12Debug2_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12Debug3_INTERFACE_DEFINED__ -#define __ID3D12Debug3_INTERFACE_DEFINED__ - -/* interface ID3D12Debug3 */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12Debug3; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("5cf4e58f-f671-4ff1-a542-3686e3d153d1") - ID3D12Debug3 : public ID3D12Debug - { - public: - virtual void STDMETHODCALLTYPE SetEnableGPUBasedValidation( - BOOL Enable) = 0; - - virtual void STDMETHODCALLTYPE SetEnableSynchronizedCommandQueueValidation( - BOOL Enable) = 0; - - virtual void STDMETHODCALLTYPE SetGPUBasedValidationFlags( - D3D12_GPU_BASED_VALIDATION_FLAGS Flags) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12Debug3Vtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12Debug3 * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12Debug3 * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12Debug3 * This); - - void ( STDMETHODCALLTYPE *EnableDebugLayer )( - ID3D12Debug3 * This); - - void ( STDMETHODCALLTYPE *SetEnableGPUBasedValidation )( - ID3D12Debug3 * This, - BOOL Enable); - - void ( STDMETHODCALLTYPE *SetEnableSynchronizedCommandQueueValidation )( - ID3D12Debug3 * This, - BOOL Enable); - - void ( STDMETHODCALLTYPE *SetGPUBasedValidationFlags )( - ID3D12Debug3 * This, - D3D12_GPU_BASED_VALIDATION_FLAGS Flags); - - END_INTERFACE - } ID3D12Debug3Vtbl; - - interface ID3D12Debug3 - { - CONST_VTBL struct ID3D12Debug3Vtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12Debug3_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12Debug3_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12Debug3_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12Debug3_EnableDebugLayer(This) \ - ( (This)->lpVtbl -> EnableDebugLayer(This) ) - - -#define ID3D12Debug3_SetEnableGPUBasedValidation(This,Enable) \ - ( (This)->lpVtbl -> SetEnableGPUBasedValidation(This,Enable) ) - -#define ID3D12Debug3_SetEnableSynchronizedCommandQueueValidation(This,Enable) \ - ( (This)->lpVtbl -> SetEnableSynchronizedCommandQueueValidation(This,Enable) ) - -#define ID3D12Debug3_SetGPUBasedValidationFlags(This,Flags) \ - ( (This)->lpVtbl -> SetGPUBasedValidationFlags(This,Flags) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12Debug3_INTERFACE_DEFINED__ */ - - -/* interface __MIDL_itf_d3d12sdklayers_0000_0004 */ -/* [local] */ - -typedef -enum D3D12_RLDO_FLAGS - { - D3D12_RLDO_NONE = 0, - D3D12_RLDO_SUMMARY = 0x1, - D3D12_RLDO_DETAIL = 0x2, - D3D12_RLDO_IGNORE_INTERNAL = 0x4 - } D3D12_RLDO_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS(D3D12_RLDO_FLAGS) -typedef -enum D3D12_DEBUG_DEVICE_PARAMETER_TYPE - { - D3D12_DEBUG_DEVICE_PARAMETER_FEATURE_FLAGS = 0, - D3D12_DEBUG_DEVICE_PARAMETER_GPU_BASED_VALIDATION_SETTINGS = ( D3D12_DEBUG_DEVICE_PARAMETER_FEATURE_FLAGS + 1 ) , - D3D12_DEBUG_DEVICE_PARAMETER_GPU_SLOWDOWN_PERFORMANCE_FACTOR = ( D3D12_DEBUG_DEVICE_PARAMETER_GPU_BASED_VALIDATION_SETTINGS + 1 ) - } D3D12_DEBUG_DEVICE_PARAMETER_TYPE; - -typedef -enum D3D12_DEBUG_FEATURE - { - D3D12_DEBUG_FEATURE_NONE = 0, - D3D12_DEBUG_FEATURE_ALLOW_BEHAVIOR_CHANGING_DEBUG_AIDS = 0x1, - D3D12_DEBUG_FEATURE_CONSERVATIVE_RESOURCE_STATE_TRACKING = 0x2, - D3D12_DEBUG_FEATURE_DISABLE_VIRTUALIZED_BUNDLES_VALIDATION = 0x4, - D3D12_DEBUG_FEATURE_EMULATE_WINDOWS7 = 0x8 - } D3D12_DEBUG_FEATURE; - -DEFINE_ENUM_FLAG_OPERATORS(D3D12_DEBUG_FEATURE) -typedef -enum D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE - { - D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_NONE = 0, - D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_STATE_TRACKING_ONLY = ( D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_NONE + 1 ) , - D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_UNGUARDED_VALIDATION = ( D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_STATE_TRACKING_ONLY + 1 ) , - D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_GUARDED_VALIDATION = ( D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_UNGUARDED_VALIDATION + 1 ) , - NUM_D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODES = ( D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_GUARDED_VALIDATION + 1 ) - } D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE; - -typedef -enum D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS - { - D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_NONE = 0, - D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_TRACKING_ONLY_SHADERS = 0x1, - D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_UNGUARDED_VALIDATION_SHADERS = 0x2, - D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_GUARDED_VALIDATION_SHADERS = 0x4, - D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS_VALID_MASK = 0x7 - } D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS(D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS) -typedef struct D3D12_DEBUG_DEVICE_GPU_BASED_VALIDATION_SETTINGS - { - UINT MaxMessagesPerCommandList; - D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE DefaultShaderPatchMode; - D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS PipelineStateCreateFlags; - } D3D12_DEBUG_DEVICE_GPU_BASED_VALIDATION_SETTINGS; - -typedef struct D3D12_DEBUG_DEVICE_GPU_SLOWDOWN_PERFORMANCE_FACTOR - { - FLOAT SlowdownFactor; - } D3D12_DEBUG_DEVICE_GPU_SLOWDOWN_PERFORMANCE_FACTOR; - - - -extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0004_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0004_v0_0_s_ifspec; - -#ifndef __ID3D12DebugDevice1_INTERFACE_DEFINED__ -#define __ID3D12DebugDevice1_INTERFACE_DEFINED__ - -/* interface ID3D12DebugDevice1 */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12DebugDevice1; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("a9b71770-d099-4a65-a698-3dee10020f88") - ID3D12DebugDevice1 : public IUnknown - { - public: - virtual HRESULT STDMETHODCALLTYPE SetDebugParameter( - D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type, - _In_reads_bytes_(DataSize) const void *pData, - UINT DataSize) = 0; - - virtual HRESULT STDMETHODCALLTYPE GetDebugParameter( - D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type, - _Out_writes_bytes_(DataSize) void *pData, - UINT DataSize) = 0; - - virtual HRESULT STDMETHODCALLTYPE ReportLiveDeviceObjects( - D3D12_RLDO_FLAGS Flags) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12DebugDevice1Vtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12DebugDevice1 * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12DebugDevice1 * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12DebugDevice1 * This); - - HRESULT ( STDMETHODCALLTYPE *SetDebugParameter )( - ID3D12DebugDevice1 * This, - D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type, - _In_reads_bytes_(DataSize) const void *pData, - UINT DataSize); - - HRESULT ( STDMETHODCALLTYPE *GetDebugParameter )( - ID3D12DebugDevice1 * This, - D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type, - _Out_writes_bytes_(DataSize) void *pData, - UINT DataSize); - - HRESULT ( STDMETHODCALLTYPE *ReportLiveDeviceObjects )( - ID3D12DebugDevice1 * This, - D3D12_RLDO_FLAGS Flags); - - END_INTERFACE - } ID3D12DebugDevice1Vtbl; - - interface ID3D12DebugDevice1 - { - CONST_VTBL struct ID3D12DebugDevice1Vtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12DebugDevice1_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12DebugDevice1_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12DebugDevice1_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12DebugDevice1_SetDebugParameter(This,Type,pData,DataSize) \ - ( (This)->lpVtbl -> SetDebugParameter(This,Type,pData,DataSize) ) - -#define ID3D12DebugDevice1_GetDebugParameter(This,Type,pData,DataSize) \ - ( (This)->lpVtbl -> GetDebugParameter(This,Type,pData,DataSize) ) - -#define ID3D12DebugDevice1_ReportLiveDeviceObjects(This,Flags) \ - ( (This)->lpVtbl -> ReportLiveDeviceObjects(This,Flags) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12DebugDevice1_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12DebugDevice_INTERFACE_DEFINED__ -#define __ID3D12DebugDevice_INTERFACE_DEFINED__ - -/* interface ID3D12DebugDevice */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12DebugDevice; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("3febd6dd-4973-4787-8194-e45f9e28923e") - ID3D12DebugDevice : public IUnknown - { - public: - virtual HRESULT STDMETHODCALLTYPE SetFeatureMask( - D3D12_DEBUG_FEATURE Mask) = 0; - - virtual D3D12_DEBUG_FEATURE STDMETHODCALLTYPE GetFeatureMask( void) = 0; - - virtual HRESULT STDMETHODCALLTYPE ReportLiveDeviceObjects( - D3D12_RLDO_FLAGS Flags) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12DebugDeviceVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12DebugDevice * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12DebugDevice * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12DebugDevice * This); - - HRESULT ( STDMETHODCALLTYPE *SetFeatureMask )( - ID3D12DebugDevice * This, - D3D12_DEBUG_FEATURE Mask); - - D3D12_DEBUG_FEATURE ( STDMETHODCALLTYPE *GetFeatureMask )( - ID3D12DebugDevice * This); - - HRESULT ( STDMETHODCALLTYPE *ReportLiveDeviceObjects )( - ID3D12DebugDevice * This, - D3D12_RLDO_FLAGS Flags); - - END_INTERFACE - } ID3D12DebugDeviceVtbl; - - interface ID3D12DebugDevice - { - CONST_VTBL struct ID3D12DebugDeviceVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12DebugDevice_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12DebugDevice_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12DebugDevice_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12DebugDevice_SetFeatureMask(This,Mask) \ - ( (This)->lpVtbl -> SetFeatureMask(This,Mask) ) - -#define ID3D12DebugDevice_GetFeatureMask(This) \ - ( (This)->lpVtbl -> GetFeatureMask(This) ) - -#define ID3D12DebugDevice_ReportLiveDeviceObjects(This,Flags) \ - ( (This)->lpVtbl -> ReportLiveDeviceObjects(This,Flags) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12DebugDevice_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12DebugDevice2_INTERFACE_DEFINED__ -#define __ID3D12DebugDevice2_INTERFACE_DEFINED__ - -/* interface ID3D12DebugDevice2 */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12DebugDevice2; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("60eccbc1-378d-4df1-894c-f8ac5ce4d7dd") - ID3D12DebugDevice2 : public ID3D12DebugDevice - { - public: - virtual HRESULT STDMETHODCALLTYPE SetDebugParameter( - D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type, - _In_reads_bytes_(DataSize) const void *pData, - UINT DataSize) = 0; - - virtual HRESULT STDMETHODCALLTYPE GetDebugParameter( - D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type, - _Out_writes_bytes_(DataSize) void *pData, - UINT DataSize) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12DebugDevice2Vtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12DebugDevice2 * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12DebugDevice2 * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12DebugDevice2 * This); - - HRESULT ( STDMETHODCALLTYPE *SetFeatureMask )( - ID3D12DebugDevice2 * This, - D3D12_DEBUG_FEATURE Mask); - - D3D12_DEBUG_FEATURE ( STDMETHODCALLTYPE *GetFeatureMask )( - ID3D12DebugDevice2 * This); - - HRESULT ( STDMETHODCALLTYPE *ReportLiveDeviceObjects )( - ID3D12DebugDevice2 * This, - D3D12_RLDO_FLAGS Flags); - - HRESULT ( STDMETHODCALLTYPE *SetDebugParameter )( - ID3D12DebugDevice2 * This, - D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type, - _In_reads_bytes_(DataSize) const void *pData, - UINT DataSize); - - HRESULT ( STDMETHODCALLTYPE *GetDebugParameter )( - ID3D12DebugDevice2 * This, - D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type, - _Out_writes_bytes_(DataSize) void *pData, - UINT DataSize); - - END_INTERFACE - } ID3D12DebugDevice2Vtbl; - - interface ID3D12DebugDevice2 - { - CONST_VTBL struct ID3D12DebugDevice2Vtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12DebugDevice2_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12DebugDevice2_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12DebugDevice2_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12DebugDevice2_SetFeatureMask(This,Mask) \ - ( (This)->lpVtbl -> SetFeatureMask(This,Mask) ) - -#define ID3D12DebugDevice2_GetFeatureMask(This) \ - ( (This)->lpVtbl -> GetFeatureMask(This) ) - -#define ID3D12DebugDevice2_ReportLiveDeviceObjects(This,Flags) \ - ( (This)->lpVtbl -> ReportLiveDeviceObjects(This,Flags) ) - - -#define ID3D12DebugDevice2_SetDebugParameter(This,Type,pData,DataSize) \ - ( (This)->lpVtbl -> SetDebugParameter(This,Type,pData,DataSize) ) - -#define ID3D12DebugDevice2_GetDebugParameter(This,Type,pData,DataSize) \ - ( (This)->lpVtbl -> GetDebugParameter(This,Type,pData,DataSize) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12DebugDevice2_INTERFACE_DEFINED__ */ - - -/* interface __MIDL_itf_d3d12sdklayers_0000_0007 */ -/* [local] */ - -DEFINE_GUID(DXGI_DEBUG_D3D12, 0xcf59a98c, 0xa950, 0x4326, 0x91, 0xef, 0x9b, 0xba, 0xa1, 0x7b, 0xfd, 0x95); - - -extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0007_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0007_v0_0_s_ifspec; - -#ifndef __ID3D12DebugCommandQueue_INTERFACE_DEFINED__ -#define __ID3D12DebugCommandQueue_INTERFACE_DEFINED__ - -/* interface ID3D12DebugCommandQueue */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12DebugCommandQueue; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("09e0bf36-54ac-484f-8847-4baeeab6053a") - ID3D12DebugCommandQueue : public IUnknown - { - public: - virtual BOOL STDMETHODCALLTYPE AssertResourceState( - _In_ ID3D12Resource *pResource, - UINT Subresource, - UINT State) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12DebugCommandQueueVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12DebugCommandQueue * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12DebugCommandQueue * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12DebugCommandQueue * This); - - BOOL ( STDMETHODCALLTYPE *AssertResourceState )( - ID3D12DebugCommandQueue * This, - _In_ ID3D12Resource *pResource, - UINT Subresource, - UINT State); - - END_INTERFACE - } ID3D12DebugCommandQueueVtbl; - - interface ID3D12DebugCommandQueue - { - CONST_VTBL struct ID3D12DebugCommandQueueVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12DebugCommandQueue_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12DebugCommandQueue_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12DebugCommandQueue_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12DebugCommandQueue_AssertResourceState(This,pResource,Subresource,State) \ - ( (This)->lpVtbl -> AssertResourceState(This,pResource,Subresource,State) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12DebugCommandQueue_INTERFACE_DEFINED__ */ - - -/* interface __MIDL_itf_d3d12sdklayers_0000_0008 */ -/* [local] */ - -typedef -enum D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE - { - D3D12_DEBUG_COMMAND_LIST_PARAMETER_GPU_BASED_VALIDATION_SETTINGS = 0 - } D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE; - -typedef struct D3D12_DEBUG_COMMAND_LIST_GPU_BASED_VALIDATION_SETTINGS - { - D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE ShaderPatchMode; - } D3D12_DEBUG_COMMAND_LIST_GPU_BASED_VALIDATION_SETTINGS; - - - -extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0008_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0008_v0_0_s_ifspec; - -#ifndef __ID3D12DebugCommandList1_INTERFACE_DEFINED__ -#define __ID3D12DebugCommandList1_INTERFACE_DEFINED__ - -/* interface ID3D12DebugCommandList1 */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12DebugCommandList1; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("102ca951-311b-4b01-b11f-ecb83e061b37") - ID3D12DebugCommandList1 : public IUnknown - { - public: - virtual BOOL STDMETHODCALLTYPE AssertResourceState( - _In_ ID3D12Resource *pResource, - UINT Subresource, - UINT State) = 0; - - virtual HRESULT STDMETHODCALLTYPE SetDebugParameter( - D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type, - _In_reads_bytes_(DataSize) const void *pData, - UINT DataSize) = 0; - - virtual HRESULT STDMETHODCALLTYPE GetDebugParameter( - D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type, - _Out_writes_bytes_(DataSize) void *pData, - UINT DataSize) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12DebugCommandList1Vtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12DebugCommandList1 * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12DebugCommandList1 * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12DebugCommandList1 * This); - - BOOL ( STDMETHODCALLTYPE *AssertResourceState )( - ID3D12DebugCommandList1 * This, - _In_ ID3D12Resource *pResource, - UINT Subresource, - UINT State); - - HRESULT ( STDMETHODCALLTYPE *SetDebugParameter )( - ID3D12DebugCommandList1 * This, - D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type, - _In_reads_bytes_(DataSize) const void *pData, - UINT DataSize); - - HRESULT ( STDMETHODCALLTYPE *GetDebugParameter )( - ID3D12DebugCommandList1 * This, - D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type, - _Out_writes_bytes_(DataSize) void *pData, - UINT DataSize); - - END_INTERFACE - } ID3D12DebugCommandList1Vtbl; - - interface ID3D12DebugCommandList1 - { - CONST_VTBL struct ID3D12DebugCommandList1Vtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12DebugCommandList1_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12DebugCommandList1_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12DebugCommandList1_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12DebugCommandList1_AssertResourceState(This,pResource,Subresource,State) \ - ( (This)->lpVtbl -> AssertResourceState(This,pResource,Subresource,State) ) - -#define ID3D12DebugCommandList1_SetDebugParameter(This,Type,pData,DataSize) \ - ( (This)->lpVtbl -> SetDebugParameter(This,Type,pData,DataSize) ) - -#define ID3D12DebugCommandList1_GetDebugParameter(This,Type,pData,DataSize) \ - ( (This)->lpVtbl -> GetDebugParameter(This,Type,pData,DataSize) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12DebugCommandList1_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12DebugCommandList_INTERFACE_DEFINED__ -#define __ID3D12DebugCommandList_INTERFACE_DEFINED__ - -/* interface ID3D12DebugCommandList */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12DebugCommandList; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("09e0bf36-54ac-484f-8847-4baeeab6053f") - ID3D12DebugCommandList : public IUnknown - { - public: - virtual BOOL STDMETHODCALLTYPE AssertResourceState( - _In_ ID3D12Resource *pResource, - UINT Subresource, - UINT State) = 0; - - virtual HRESULT STDMETHODCALLTYPE SetFeatureMask( - D3D12_DEBUG_FEATURE Mask) = 0; - - virtual D3D12_DEBUG_FEATURE STDMETHODCALLTYPE GetFeatureMask( void) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12DebugCommandListVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12DebugCommandList * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12DebugCommandList * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12DebugCommandList * This); - - BOOL ( STDMETHODCALLTYPE *AssertResourceState )( - ID3D12DebugCommandList * This, - _In_ ID3D12Resource *pResource, - UINT Subresource, - UINT State); - - HRESULT ( STDMETHODCALLTYPE *SetFeatureMask )( - ID3D12DebugCommandList * This, - D3D12_DEBUG_FEATURE Mask); - - D3D12_DEBUG_FEATURE ( STDMETHODCALLTYPE *GetFeatureMask )( - ID3D12DebugCommandList * This); - - END_INTERFACE - } ID3D12DebugCommandListVtbl; - - interface ID3D12DebugCommandList - { - CONST_VTBL struct ID3D12DebugCommandListVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12DebugCommandList_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12DebugCommandList_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12DebugCommandList_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12DebugCommandList_AssertResourceState(This,pResource,Subresource,State) \ - ( (This)->lpVtbl -> AssertResourceState(This,pResource,Subresource,State) ) - -#define ID3D12DebugCommandList_SetFeatureMask(This,Mask) \ - ( (This)->lpVtbl -> SetFeatureMask(This,Mask) ) - -#define ID3D12DebugCommandList_GetFeatureMask(This) \ - ( (This)->lpVtbl -> GetFeatureMask(This) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12DebugCommandList_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12DebugCommandList2_INTERFACE_DEFINED__ -#define __ID3D12DebugCommandList2_INTERFACE_DEFINED__ - -/* interface ID3D12DebugCommandList2 */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12DebugCommandList2; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("aeb575cf-4e06-48be-ba3b-c450fc96652e") - ID3D12DebugCommandList2 : public ID3D12DebugCommandList - { - public: - virtual HRESULT STDMETHODCALLTYPE SetDebugParameter( - D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type, - _In_reads_bytes_(DataSize) const void *pData, - UINT DataSize) = 0; - - virtual HRESULT STDMETHODCALLTYPE GetDebugParameter( - D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type, - _Out_writes_bytes_(DataSize) void *pData, - UINT DataSize) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12DebugCommandList2Vtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12DebugCommandList2 * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12DebugCommandList2 * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12DebugCommandList2 * This); - - BOOL ( STDMETHODCALLTYPE *AssertResourceState )( - ID3D12DebugCommandList2 * This, - _In_ ID3D12Resource *pResource, - UINT Subresource, - UINT State); - - HRESULT ( STDMETHODCALLTYPE *SetFeatureMask )( - ID3D12DebugCommandList2 * This, - D3D12_DEBUG_FEATURE Mask); - - D3D12_DEBUG_FEATURE ( STDMETHODCALLTYPE *GetFeatureMask )( - ID3D12DebugCommandList2 * This); - - HRESULT ( STDMETHODCALLTYPE *SetDebugParameter )( - ID3D12DebugCommandList2 * This, - D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type, - _In_reads_bytes_(DataSize) const void *pData, - UINT DataSize); - - HRESULT ( STDMETHODCALLTYPE *GetDebugParameter )( - ID3D12DebugCommandList2 * This, - D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type, - _Out_writes_bytes_(DataSize) void *pData, - UINT DataSize); - - END_INTERFACE - } ID3D12DebugCommandList2Vtbl; - - interface ID3D12DebugCommandList2 - { - CONST_VTBL struct ID3D12DebugCommandList2Vtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12DebugCommandList2_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12DebugCommandList2_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12DebugCommandList2_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12DebugCommandList2_AssertResourceState(This,pResource,Subresource,State) \ - ( (This)->lpVtbl -> AssertResourceState(This,pResource,Subresource,State) ) - -#define ID3D12DebugCommandList2_SetFeatureMask(This,Mask) \ - ( (This)->lpVtbl -> SetFeatureMask(This,Mask) ) - -#define ID3D12DebugCommandList2_GetFeatureMask(This) \ - ( (This)->lpVtbl -> GetFeatureMask(This) ) - - -#define ID3D12DebugCommandList2_SetDebugParameter(This,Type,pData,DataSize) \ - ( (This)->lpVtbl -> SetDebugParameter(This,Type,pData,DataSize) ) - -#define ID3D12DebugCommandList2_GetDebugParameter(This,Type,pData,DataSize) \ - ( (This)->lpVtbl -> GetDebugParameter(This,Type,pData,DataSize) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12DebugCommandList2_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12SharingContract_INTERFACE_DEFINED__ -#define __ID3D12SharingContract_INTERFACE_DEFINED__ - -/* interface ID3D12SharingContract */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12SharingContract; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("0adf7d52-929c-4e61-addb-ffed30de66ef") - ID3D12SharingContract : public IUnknown - { - public: - virtual void STDMETHODCALLTYPE Present( - _In_ ID3D12Resource *pResource, - UINT Subresource, - _In_ HWND window) = 0; - - virtual void STDMETHODCALLTYPE SharedFenceSignal( - _In_ ID3D12Fence *pFence, - UINT64 FenceValue) = 0; - - virtual void STDMETHODCALLTYPE BeginCapturableWork( - _In_ REFGUID guid) = 0; - - virtual void STDMETHODCALLTYPE EndCapturableWork( - _In_ REFGUID guid) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12SharingContractVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12SharingContract * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12SharingContract * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12SharingContract * This); - - void ( STDMETHODCALLTYPE *Present )( - ID3D12SharingContract * This, - _In_ ID3D12Resource *pResource, - UINT Subresource, - _In_ HWND window); - - void ( STDMETHODCALLTYPE *SharedFenceSignal )( - ID3D12SharingContract * This, - _In_ ID3D12Fence *pFence, - UINT64 FenceValue); - - void ( STDMETHODCALLTYPE *BeginCapturableWork )( - ID3D12SharingContract * This, - _In_ REFGUID guid); - - void ( STDMETHODCALLTYPE *EndCapturableWork )( - ID3D12SharingContract * This, - _In_ REFGUID guid); - - END_INTERFACE - } ID3D12SharingContractVtbl; - - interface ID3D12SharingContract - { - CONST_VTBL struct ID3D12SharingContractVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12SharingContract_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12SharingContract_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12SharingContract_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12SharingContract_Present(This,pResource,Subresource,window) \ - ( (This)->lpVtbl -> Present(This,pResource,Subresource,window) ) - -#define ID3D12SharingContract_SharedFenceSignal(This,pFence,FenceValue) \ - ( (This)->lpVtbl -> SharedFenceSignal(This,pFence,FenceValue) ) - -#define ID3D12SharingContract_BeginCapturableWork(This,guid) \ - ( (This)->lpVtbl -> BeginCapturableWork(This,guid) ) - -#define ID3D12SharingContract_EndCapturableWork(This,guid) \ - ( (This)->lpVtbl -> EndCapturableWork(This,guid) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12SharingContract_INTERFACE_DEFINED__ */ - - -/* interface __MIDL_itf_d3d12sdklayers_0000_0012 */ -/* [local] */ - -typedef -enum D3D12_MESSAGE_CATEGORY - { - D3D12_MESSAGE_CATEGORY_APPLICATION_DEFINED = 0, - D3D12_MESSAGE_CATEGORY_MISCELLANEOUS = ( D3D12_MESSAGE_CATEGORY_APPLICATION_DEFINED + 1 ) , - D3D12_MESSAGE_CATEGORY_INITIALIZATION = ( D3D12_MESSAGE_CATEGORY_MISCELLANEOUS + 1 ) , - D3D12_MESSAGE_CATEGORY_CLEANUP = ( D3D12_MESSAGE_CATEGORY_INITIALIZATION + 1 ) , - D3D12_MESSAGE_CATEGORY_COMPILATION = ( D3D12_MESSAGE_CATEGORY_CLEANUP + 1 ) , - D3D12_MESSAGE_CATEGORY_STATE_CREATION = ( D3D12_MESSAGE_CATEGORY_COMPILATION + 1 ) , - D3D12_MESSAGE_CATEGORY_STATE_SETTING = ( D3D12_MESSAGE_CATEGORY_STATE_CREATION + 1 ) , - D3D12_MESSAGE_CATEGORY_STATE_GETTING = ( D3D12_MESSAGE_CATEGORY_STATE_SETTING + 1 ) , - D3D12_MESSAGE_CATEGORY_RESOURCE_MANIPULATION = ( D3D12_MESSAGE_CATEGORY_STATE_GETTING + 1 ) , - D3D12_MESSAGE_CATEGORY_EXECUTION = ( D3D12_MESSAGE_CATEGORY_RESOURCE_MANIPULATION + 1 ) , - D3D12_MESSAGE_CATEGORY_SHADER = ( D3D12_MESSAGE_CATEGORY_EXECUTION + 1 ) - } D3D12_MESSAGE_CATEGORY; - -typedef -enum D3D12_MESSAGE_SEVERITY - { - D3D12_MESSAGE_SEVERITY_CORRUPTION = 0, - D3D12_MESSAGE_SEVERITY_ERROR = ( D3D12_MESSAGE_SEVERITY_CORRUPTION + 1 ) , - D3D12_MESSAGE_SEVERITY_WARNING = ( D3D12_MESSAGE_SEVERITY_ERROR + 1 ) , - D3D12_MESSAGE_SEVERITY_INFO = ( D3D12_MESSAGE_SEVERITY_WARNING + 1 ) , - D3D12_MESSAGE_SEVERITY_MESSAGE = ( D3D12_MESSAGE_SEVERITY_INFO + 1 ) - } D3D12_MESSAGE_SEVERITY; - -typedef -enum D3D12_MESSAGE_ID - { - D3D12_MESSAGE_ID_UNKNOWN = 0, - D3D12_MESSAGE_ID_STRING_FROM_APPLICATION = ( D3D12_MESSAGE_ID_UNKNOWN + 1 ) , - D3D12_MESSAGE_ID_CORRUPTED_THIS = ( D3D12_MESSAGE_ID_STRING_FROM_APPLICATION + 1 ) , - D3D12_MESSAGE_ID_CORRUPTED_PARAMETER1 = ( D3D12_MESSAGE_ID_CORRUPTED_THIS + 1 ) , - D3D12_MESSAGE_ID_CORRUPTED_PARAMETER2 = ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER1 + 1 ) , - D3D12_MESSAGE_ID_CORRUPTED_PARAMETER3 = ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER2 + 1 ) , - D3D12_MESSAGE_ID_CORRUPTED_PARAMETER4 = ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER3 + 1 ) , - D3D12_MESSAGE_ID_CORRUPTED_PARAMETER5 = ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER4 + 1 ) , - D3D12_MESSAGE_ID_CORRUPTED_PARAMETER6 = ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER5 + 1 ) , - D3D12_MESSAGE_ID_CORRUPTED_PARAMETER7 = ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER6 + 1 ) , - D3D12_MESSAGE_ID_CORRUPTED_PARAMETER8 = ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER7 + 1 ) , - D3D12_MESSAGE_ID_CORRUPTED_PARAMETER9 = ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER8 + 1 ) , - D3D12_MESSAGE_ID_CORRUPTED_PARAMETER10 = ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER9 + 1 ) , - D3D12_MESSAGE_ID_CORRUPTED_PARAMETER11 = ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER10 + 1 ) , - D3D12_MESSAGE_ID_CORRUPTED_PARAMETER12 = ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER11 + 1 ) , - D3D12_MESSAGE_ID_CORRUPTED_PARAMETER13 = ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER12 + 1 ) , - D3D12_MESSAGE_ID_CORRUPTED_PARAMETER14 = ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER13 + 1 ) , - D3D12_MESSAGE_ID_CORRUPTED_PARAMETER15 = ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER14 + 1 ) , - D3D12_MESSAGE_ID_CORRUPTED_MULTITHREADING = ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER15 + 1 ) , - D3D12_MESSAGE_ID_MESSAGE_REPORTING_OUTOFMEMORY = ( D3D12_MESSAGE_ID_CORRUPTED_MULTITHREADING + 1 ) , - D3D12_MESSAGE_ID_GETPRIVATEDATA_MOREDATA = ( D3D12_MESSAGE_ID_MESSAGE_REPORTING_OUTOFMEMORY + 1 ) , - D3D12_MESSAGE_ID_SETPRIVATEDATA_INVALIDFREEDATA = ( D3D12_MESSAGE_ID_GETPRIVATEDATA_MOREDATA + 1 ) , - D3D12_MESSAGE_ID_SETPRIVATEDATA_INVALIDIUNKNOWN = ( D3D12_MESSAGE_ID_SETPRIVATEDATA_INVALIDFREEDATA + 1 ) , - D3D12_MESSAGE_ID_SETPRIVATEDATA_INVALIDFLAGS = ( D3D12_MESSAGE_ID_SETPRIVATEDATA_INVALIDIUNKNOWN + 1 ) , - D3D12_MESSAGE_ID_SETPRIVATEDATA_CHANGINGPARAMS = ( D3D12_MESSAGE_ID_SETPRIVATEDATA_INVALIDFLAGS + 1 ) , - D3D12_MESSAGE_ID_SETPRIVATEDATA_OUTOFMEMORY = ( D3D12_MESSAGE_ID_SETPRIVATEDATA_CHANGINGPARAMS + 1 ) , - D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_UNRECOGNIZEDFORMAT = ( D3D12_MESSAGE_ID_SETPRIVATEDATA_OUTOFMEMORY + 1 ) , - D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDESC = ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_UNRECOGNIZEDFORMAT + 1 ) , - D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDFORMAT = ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDESC + 1 ) , - D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDVIDEOPLANESLICE = ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDFORMAT + 1 ) , - D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDPLANESLICE = ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDVIDEOPLANESLICE + 1 ) , - D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDIMENSIONS = ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDPLANESLICE + 1 ) , - D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDRESOURCE = ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDIMENSIONS + 1 ) , - D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDARG_RETURN = ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDRESOURCE + 1 ) , - D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_OUTOFMEMORY_RETURN = ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDARG_RETURN + 1 ) , - D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_UNRECOGNIZEDFORMAT = ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_OUTOFMEMORY_RETURN + 1 ) , - D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_UNSUPPORTEDFORMAT = ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_UNRECOGNIZEDFORMAT + 1 ) , - D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDESC = ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_UNSUPPORTEDFORMAT + 1 ) , - D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDFORMAT = ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDESC + 1 ) , - D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDVIDEOPLANESLICE = ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDFORMAT + 1 ) , - D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDPLANESLICE = ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDVIDEOPLANESLICE + 1 ) , - D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDIMENSIONS = ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDPLANESLICE + 1 ) , - D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDRESOURCE = ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDIMENSIONS + 1 ) , - D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDARG_RETURN = ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDRESOURCE + 1 ) , - D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_OUTOFMEMORY_RETURN = ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDARG_RETURN + 1 ) , - D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_UNRECOGNIZEDFORMAT = ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_OUTOFMEMORY_RETURN + 1 ) , - D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDESC = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_UNRECOGNIZEDFORMAT + 1 ) , - D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDFORMAT = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDESC + 1 ) , - D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDIMENSIONS = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDFORMAT + 1 ) , - D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDRESOURCE = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDIMENSIONS + 1 ) , - D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDARG_RETURN = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDRESOURCE + 1 ) , - D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_OUTOFMEMORY_RETURN = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDARG_RETURN + 1 ) , - D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_OUTOFMEMORY = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_OUTOFMEMORY_RETURN + 1 ) , - D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TOOMANYELEMENTS = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_OUTOFMEMORY + 1 ) , - D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDFORMAT = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TOOMANYELEMENTS + 1 ) , - D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INCOMPATIBLEFORMAT = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDFORMAT + 1 ) , - D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOT = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INCOMPATIBLEFORMAT + 1 ) , - D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDINPUTSLOTCLASS = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOT + 1 ) , - D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_STEPRATESLOTCLASSMISMATCH = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDINPUTSLOTCLASS + 1 ) , - D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOTCLASSCHANGE = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_STEPRATESLOTCLASSMISMATCH + 1 ) , - D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSTEPRATECHANGE = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOTCLASSCHANGE + 1 ) , - D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDALIGNMENT = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSTEPRATECHANGE + 1 ) , - D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_DUPLICATESEMANTIC = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDALIGNMENT + 1 ) , - D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_UNPARSEABLEINPUTSIGNATURE = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_DUPLICATESEMANTIC + 1 ) , - D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_NULLSEMANTIC = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_UNPARSEABLEINPUTSIGNATURE + 1 ) , - D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_MISSINGELEMENT = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_NULLSEMANTIC + 1 ) , - D3D12_MESSAGE_ID_CREATEVERTEXSHADER_OUTOFMEMORY = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_MISSINGELEMENT + 1 ) , - D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERBYTECODE = ( D3D12_MESSAGE_ID_CREATEVERTEXSHADER_OUTOFMEMORY + 1 ) , - D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERTYPE = ( D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERBYTECODE + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_OUTOFMEMORY = ( D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERTYPE + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERBYTECODE = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_OUTOFMEMORY + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERTYPE = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERBYTECODE + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTOFMEMORY = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERTYPE + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERBYTECODE = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTOFMEMORY + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERTYPE = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERBYTECODE + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMENTRIES = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERTYPE + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSTREAMSTRIDEUNUSED = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMENTRIES + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDDECL = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSTREAMSTRIDEUNUSED + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_EXPECTEDDECL = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDDECL + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSLOT0EXPECTED = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_EXPECTEDDECL + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSLOT = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSLOT0EXPECTED + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_ONLYONEELEMENTPERSLOT = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSLOT + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDCOMPONENTCOUNT = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_ONLYONEELEMENTPERSLOT + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTARTCOMPONENTANDCOMPONENTCOUNT = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDCOMPONENTCOUNT + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDGAPDEFINITION = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTARTCOMPONENTANDCOMPONENTCOUNT + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_REPEATEDOUTPUT = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDGAPDEFINITION + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSTREAMSTRIDE = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_REPEATEDOUTPUT + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGSEMANTIC = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSTREAMSTRIDE + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MASKMISMATCH = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGSEMANTIC + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_CANTHAVEONLYGAPS = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MASKMISMATCH + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DECLTOOCOMPLEX = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_CANTHAVEONLYGAPS + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGOUTPUTSIGNATURE = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DECLTOOCOMPLEX + 1 ) , - D3D12_MESSAGE_ID_CREATEPIXELSHADER_OUTOFMEMORY = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGOUTPUTSIGNATURE + 1 ) , - D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERBYTECODE = ( D3D12_MESSAGE_ID_CREATEPIXELSHADER_OUTOFMEMORY + 1 ) , - D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERTYPE = ( D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERBYTECODE + 1 ) , - D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDFILLMODE = ( D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERTYPE + 1 ) , - D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDCULLMODE = ( D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDFILLMODE + 1 ) , - D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDDEPTHBIASCLAMP = ( D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDCULLMODE + 1 ) , - D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDSLOPESCALEDDEPTHBIAS = ( D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDDEPTHBIASCLAMP + 1 ) , - D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_NULLDESC = ( D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDSLOPESCALEDDEPTHBIAS + 1 ) , - D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHWRITEMASK = ( D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_NULLDESC + 1 ) , - D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHFUNC = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHWRITEMASK + 1 ) , - D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFAILOP = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHFUNC + 1 ) , - D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILZFAILOP = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFAILOP + 1 ) , - D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILPASSOP = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILZFAILOP + 1 ) , - D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFUNC = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILPASSOP + 1 ) , - D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFAILOP = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFUNC + 1 ) , - D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILZFAILOP = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFAILOP + 1 ) , - D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILPASSOP = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILZFAILOP + 1 ) , - D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFUNC = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILPASSOP + 1 ) , - D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_NULLDESC = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFUNC + 1 ) , - D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLEND = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_NULLDESC + 1 ) , - D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLEND = ( D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLEND + 1 ) , - D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOP = ( D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLEND + 1 ) , - D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLENDALPHA = ( D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOP + 1 ) , - D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLENDALPHA = ( D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLENDALPHA + 1 ) , - D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOPALPHA = ( D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLENDALPHA + 1 ) , - D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDRENDERTARGETWRITEMASK = ( D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOPALPHA + 1 ) , - D3D12_MESSAGE_ID_CREATEBLENDSTATE_NULLDESC = ( D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDRENDERTARGETWRITEMASK + 1 ) , - D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDFILTER = ( D3D12_MESSAGE_ID_CREATEBLENDSTATE_NULLDESC + 1 ) , - D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSU = ( D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDFILTER + 1 ) , - D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSV = ( D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSU + 1 ) , - D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSW = ( D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSV + 1 ) , - D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMIPLODBIAS = ( D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSW + 1 ) , - D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMAXANISOTROPY = ( D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMIPLODBIAS + 1 ) , - D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDCOMPARISONFUNC = ( D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMAXANISOTROPY + 1 ) , - D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMINLOD = ( D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDCOMPARISONFUNC + 1 ) , - D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMAXLOD = ( D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMINLOD + 1 ) , - D3D12_MESSAGE_ID_CREATESAMPLERSTATE_NULLDESC = ( D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMAXLOD + 1 ) , - D3D12_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNRECOGNIZED = ( D3D12_MESSAGE_ID_CREATESAMPLERSTATE_NULLDESC + 1 ) , - D3D12_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNDEFINED = ( D3D12_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNRECOGNIZED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_RSSETVIEWPORTS_INVALIDVIEWPORT = ( D3D12_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNDEFINED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_RSSETSCISSORRECTS_INVALIDSCISSOR = ( D3D12_MESSAGE_ID_DEVICE_RSSETVIEWPORTS_INVALIDVIEWPORT + 1 ) , - D3D12_MESSAGE_ID_CLEARRENDERTARGETVIEW_DENORMFLUSH = ( D3D12_MESSAGE_ID_DEVICE_RSSETSCISSORRECTS_INVALIDSCISSOR + 1 ) , - D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_DENORMFLUSH = ( D3D12_MESSAGE_ID_CLEARRENDERTARGETVIEW_DENORMFLUSH + 1 ) , - D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_INVALID = ( D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_DENORMFLUSH + 1 ) , - D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDSOURCE = ( D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_INVALID + 1 ) , - D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDDESTINATIONSTATE = ( D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDSOURCE + 1 ) , - D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDSOURCESTATE = ( D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDDESTINATIONSTATE + 1 ) , - D3D12_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONSUBRESOURCE = ( D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDSOURCESTATE + 1 ) , - D3D12_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONBOX = ( D3D12_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONSUBRESOURCE + 1 ) , - D3D12_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONSTATE = ( D3D12_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONBOX + 1 ) , - D3D12_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_DESTINATION_INVALID = ( D3D12_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONSTATE + 1 ) , - D3D12_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_DESTINATION_SUBRESOURCE_INVALID = ( D3D12_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_DESTINATION_INVALID + 1 ) , - D3D12_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_SOURCE_INVALID = ( D3D12_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_DESTINATION_SUBRESOURCE_INVALID + 1 ) , - D3D12_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_SOURCE_SUBRESOURCE_INVALID = ( D3D12_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_SOURCE_INVALID + 1 ) , - D3D12_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_FORMAT_INVALID = ( D3D12_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_SOURCE_SUBRESOURCE_INVALID + 1 ) , - D3D12_MESSAGE_ID_BUFFER_MAP_INVALIDMAPTYPE = ( D3D12_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_FORMAT_INVALID + 1 ) , - D3D12_MESSAGE_ID_BUFFER_MAP_INVALIDFLAGS = ( D3D12_MESSAGE_ID_BUFFER_MAP_INVALIDMAPTYPE + 1 ) , - D3D12_MESSAGE_ID_BUFFER_MAP_ALREADYMAPPED = ( D3D12_MESSAGE_ID_BUFFER_MAP_INVALIDFLAGS + 1 ) , - D3D12_MESSAGE_ID_BUFFER_MAP_DEVICEREMOVED_RETURN = ( D3D12_MESSAGE_ID_BUFFER_MAP_ALREADYMAPPED + 1 ) , - D3D12_MESSAGE_ID_BUFFER_UNMAP_NOTMAPPED = ( D3D12_MESSAGE_ID_BUFFER_MAP_DEVICEREMOVED_RETURN + 1 ) , - D3D12_MESSAGE_ID_TEXTURE1D_MAP_INVALIDMAPTYPE = ( D3D12_MESSAGE_ID_BUFFER_UNMAP_NOTMAPPED + 1 ) , - D3D12_MESSAGE_ID_TEXTURE1D_MAP_INVALIDSUBRESOURCE = ( D3D12_MESSAGE_ID_TEXTURE1D_MAP_INVALIDMAPTYPE + 1 ) , - D3D12_MESSAGE_ID_TEXTURE1D_MAP_INVALIDFLAGS = ( D3D12_MESSAGE_ID_TEXTURE1D_MAP_INVALIDSUBRESOURCE + 1 ) , - D3D12_MESSAGE_ID_TEXTURE1D_MAP_ALREADYMAPPED = ( D3D12_MESSAGE_ID_TEXTURE1D_MAP_INVALIDFLAGS + 1 ) , - D3D12_MESSAGE_ID_TEXTURE1D_MAP_DEVICEREMOVED_RETURN = ( D3D12_MESSAGE_ID_TEXTURE1D_MAP_ALREADYMAPPED + 1 ) , - D3D12_MESSAGE_ID_TEXTURE1D_UNMAP_INVALIDSUBRESOURCE = ( D3D12_MESSAGE_ID_TEXTURE1D_MAP_DEVICEREMOVED_RETURN + 1 ) , - D3D12_MESSAGE_ID_TEXTURE1D_UNMAP_NOTMAPPED = ( D3D12_MESSAGE_ID_TEXTURE1D_UNMAP_INVALIDSUBRESOURCE + 1 ) , - D3D12_MESSAGE_ID_TEXTURE2D_MAP_INVALIDMAPTYPE = ( D3D12_MESSAGE_ID_TEXTURE1D_UNMAP_NOTMAPPED + 1 ) , - D3D12_MESSAGE_ID_TEXTURE2D_MAP_INVALIDSUBRESOURCE = ( D3D12_MESSAGE_ID_TEXTURE2D_MAP_INVALIDMAPTYPE + 1 ) , - D3D12_MESSAGE_ID_TEXTURE2D_MAP_INVALIDFLAGS = ( D3D12_MESSAGE_ID_TEXTURE2D_MAP_INVALIDSUBRESOURCE + 1 ) , - D3D12_MESSAGE_ID_TEXTURE2D_MAP_ALREADYMAPPED = ( D3D12_MESSAGE_ID_TEXTURE2D_MAP_INVALIDFLAGS + 1 ) , - D3D12_MESSAGE_ID_TEXTURE2D_MAP_DEVICEREMOVED_RETURN = ( D3D12_MESSAGE_ID_TEXTURE2D_MAP_ALREADYMAPPED + 1 ) , - D3D12_MESSAGE_ID_TEXTURE2D_UNMAP_INVALIDSUBRESOURCE = ( D3D12_MESSAGE_ID_TEXTURE2D_MAP_DEVICEREMOVED_RETURN + 1 ) , - D3D12_MESSAGE_ID_TEXTURE2D_UNMAP_NOTMAPPED = ( D3D12_MESSAGE_ID_TEXTURE2D_UNMAP_INVALIDSUBRESOURCE + 1 ) , - D3D12_MESSAGE_ID_TEXTURE3D_MAP_INVALIDMAPTYPE = ( D3D12_MESSAGE_ID_TEXTURE2D_UNMAP_NOTMAPPED + 1 ) , - D3D12_MESSAGE_ID_TEXTURE3D_MAP_INVALIDSUBRESOURCE = ( D3D12_MESSAGE_ID_TEXTURE3D_MAP_INVALIDMAPTYPE + 1 ) , - D3D12_MESSAGE_ID_TEXTURE3D_MAP_INVALIDFLAGS = ( D3D12_MESSAGE_ID_TEXTURE3D_MAP_INVALIDSUBRESOURCE + 1 ) , - D3D12_MESSAGE_ID_TEXTURE3D_MAP_ALREADYMAPPED = ( D3D12_MESSAGE_ID_TEXTURE3D_MAP_INVALIDFLAGS + 1 ) , - D3D12_MESSAGE_ID_TEXTURE3D_MAP_DEVICEREMOVED_RETURN = ( D3D12_MESSAGE_ID_TEXTURE3D_MAP_ALREADYMAPPED + 1 ) , - D3D12_MESSAGE_ID_TEXTURE3D_UNMAP_INVALIDSUBRESOURCE = ( D3D12_MESSAGE_ID_TEXTURE3D_MAP_DEVICEREMOVED_RETURN + 1 ) , - D3D12_MESSAGE_ID_TEXTURE3D_UNMAP_NOTMAPPED = ( D3D12_MESSAGE_ID_TEXTURE3D_UNMAP_INVALIDSUBRESOURCE + 1 ) , - D3D12_MESSAGE_ID_CHECKFORMATSUPPORT_FORMAT_DEPRECATED = ( D3D12_MESSAGE_ID_TEXTURE3D_UNMAP_NOTMAPPED + 1 ) , - D3D12_MESSAGE_ID_CHECKMULTISAMPLEQUALITYLEVELS_FORMAT_DEPRECATED = ( D3D12_MESSAGE_ID_CHECKFORMATSUPPORT_FORMAT_DEPRECATED + 1 ) , - D3D12_MESSAGE_ID_SETEXCEPTIONMODE_UNRECOGNIZEDFLAGS = ( D3D12_MESSAGE_ID_CHECKMULTISAMPLEQUALITYLEVELS_FORMAT_DEPRECATED + 1 ) , - D3D12_MESSAGE_ID_SETEXCEPTIONMODE_INVALIDARG_RETURN = ( D3D12_MESSAGE_ID_SETEXCEPTIONMODE_UNRECOGNIZEDFLAGS + 1 ) , - D3D12_MESSAGE_ID_SETEXCEPTIONMODE_DEVICEREMOVED_RETURN = ( D3D12_MESSAGE_ID_SETEXCEPTIONMODE_INVALIDARG_RETURN + 1 ) , - D3D12_MESSAGE_ID_REF_SIMULATING_INFINITELY_FAST_HARDWARE = ( D3D12_MESSAGE_ID_SETEXCEPTIONMODE_DEVICEREMOVED_RETURN + 1 ) , - D3D12_MESSAGE_ID_REF_THREADING_MODE = ( D3D12_MESSAGE_ID_REF_SIMULATING_INFINITELY_FAST_HARDWARE + 1 ) , - D3D12_MESSAGE_ID_REF_UMDRIVER_EXCEPTION = ( D3D12_MESSAGE_ID_REF_THREADING_MODE + 1 ) , - D3D12_MESSAGE_ID_REF_KMDRIVER_EXCEPTION = ( D3D12_MESSAGE_ID_REF_UMDRIVER_EXCEPTION + 1 ) , - D3D12_MESSAGE_ID_REF_HARDWARE_EXCEPTION = ( D3D12_MESSAGE_ID_REF_KMDRIVER_EXCEPTION + 1 ) , - D3D12_MESSAGE_ID_REF_ACCESSING_INDEXABLE_TEMP_OUT_OF_RANGE = ( D3D12_MESSAGE_ID_REF_HARDWARE_EXCEPTION + 1 ) , - D3D12_MESSAGE_ID_REF_PROBLEM_PARSING_SHADER = ( D3D12_MESSAGE_ID_REF_ACCESSING_INDEXABLE_TEMP_OUT_OF_RANGE + 1 ) , - D3D12_MESSAGE_ID_REF_OUT_OF_MEMORY = ( D3D12_MESSAGE_ID_REF_PROBLEM_PARSING_SHADER + 1 ) , - D3D12_MESSAGE_ID_REF_INFO = ( D3D12_MESSAGE_ID_REF_OUT_OF_MEMORY + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DRAW_VERTEXPOS_OVERFLOW = ( D3D12_MESSAGE_ID_REF_INFO + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DRAWINDEXED_INDEXPOS_OVERFLOW = ( D3D12_MESSAGE_ID_DEVICE_DRAW_VERTEXPOS_OVERFLOW + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DRAWINSTANCED_VERTEXPOS_OVERFLOW = ( D3D12_MESSAGE_ID_DEVICE_DRAWINDEXED_INDEXPOS_OVERFLOW + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DRAWINSTANCED_INSTANCEPOS_OVERFLOW = ( D3D12_MESSAGE_ID_DEVICE_DRAWINSTANCED_VERTEXPOS_OVERFLOW + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DRAWINDEXEDINSTANCED_INSTANCEPOS_OVERFLOW = ( D3D12_MESSAGE_ID_DEVICE_DRAWINSTANCED_INSTANCEPOS_OVERFLOW + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DRAWINDEXEDINSTANCED_INDEXPOS_OVERFLOW = ( D3D12_MESSAGE_ID_DEVICE_DRAWINDEXEDINSTANCED_INSTANCEPOS_OVERFLOW + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DRAW_VERTEX_SHADER_NOT_SET = ( D3D12_MESSAGE_ID_DEVICE_DRAWINDEXEDINSTANCED_INDEXPOS_OVERFLOW + 1 ) , - D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_SEMANTICNAME_NOT_FOUND = ( D3D12_MESSAGE_ID_DEVICE_DRAW_VERTEX_SHADER_NOT_SET + 1 ) , - D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_REGISTERINDEX = ( D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_SEMANTICNAME_NOT_FOUND + 1 ) , - D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_COMPONENTTYPE = ( D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_REGISTERINDEX + 1 ) , - D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_REGISTERMASK = ( D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_COMPONENTTYPE + 1 ) , - D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_SYSTEMVALUE = ( D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_REGISTERMASK + 1 ) , - D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_NEVERWRITTEN_ALWAYSREADS = ( D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_SYSTEMVALUE + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_ROOT_SIGNATURE_NOT_SET = ( D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_NEVERWRITTEN_ALWAYSREADS + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_ROOT_SIGNATURE_MISMATCH = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_ROOT_SIGNATURE_NOT_SET + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_NOT_SET = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_ROOT_SIGNATURE_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INPUTLAYOUT_NOT_SET = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_NOT_SET + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_CONSTANT_BUFFER_NOT_SET = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INPUTLAYOUT_NOT_SET + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_CONSTANT_BUFFER_TOO_SMALL = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_CONSTANT_BUFFER_NOT_SET + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_SAMPLER_NOT_SET = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_CONSTANT_BUFFER_TOO_SMALL + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_SHADERRESOURCEVIEW_NOT_SET = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_SAMPLER_NOT_SET + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VIEW_DIMENSION_MISMATCH = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_SHADERRESOURCEVIEW_NOT_SET + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_STRIDE_TOO_SMALL = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VIEW_DIMENSION_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_TOO_SMALL = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_STRIDE_TOO_SMALL + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_NOT_SET = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_TOO_SMALL + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_FORMAT_INVALID = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_NOT_SET + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_TOO_SMALL = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_FORMAT_INVALID + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_GS_INPUT_PRIMITIVE_MISMATCH = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_TOO_SMALL + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RESOURCE_RETURN_TYPE_MISMATCH = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_GS_INPUT_PRIMITIVE_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_POSITION_NOT_PRESENT = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RESOURCE_RETURN_TYPE_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_OUTPUT_STREAM_NOT_SET = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_POSITION_NOT_PRESENT + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_BOUND_RESOURCE_MAPPED = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_OUTPUT_STREAM_NOT_SET + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INVALID_PRIMITIVETOPOLOGY = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_BOUND_RESOURCE_MAPPED + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_OFFSET_UNALIGNED = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INVALID_PRIMITIVETOPOLOGY + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_STRIDE_UNALIGNED = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_OFFSET_UNALIGNED + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_OFFSET_UNALIGNED = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_STRIDE_UNALIGNED + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_OUTPUT_STREAM_OFFSET_UNALIGNED = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_OFFSET_UNALIGNED + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RESOURCE_FORMAT_LD_UNSUPPORTED = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_OUTPUT_STREAM_OFFSET_UNALIGNED + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RESOURCE_FORMAT_SAMPLE_UNSUPPORTED = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RESOURCE_FORMAT_LD_UNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RESOURCE_FORMAT_SAMPLE_C_UNSUPPORTED = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RESOURCE_FORMAT_SAMPLE_UNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RESOURCE_MULTISAMPLE_UNSUPPORTED = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RESOURCE_FORMAT_SAMPLE_C_UNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_SO_TARGETS_BOUND_WITHOUT_SOURCE = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RESOURCE_MULTISAMPLE_UNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_SO_STRIDE_LARGER_THAN_BUFFER = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_SO_TARGETS_BOUND_WITHOUT_SOURCE + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_OM_RENDER_TARGET_DOES_NOT_SUPPORT_BLENDING = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_SO_STRIDE_LARGER_THAN_BUFFER + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_OM_DUAL_SOURCE_BLENDING_CAN_ONLY_HAVE_RENDER_TARGET_0 = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_OM_RENDER_TARGET_DOES_NOT_SUPPORT_BLENDING + 1 ) , - D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_AT_FAULT = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_OM_DUAL_SOURCE_BLENDING_CAN_ONLY_HAVE_RENDER_TARGET_0 + 1 ) , - D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_POSSIBLY_AT_FAULT = ( D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_AT_FAULT + 1 ) , - D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_NOT_AT_FAULT = ( D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_POSSIBLY_AT_FAULT + 1 ) , - D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_INVALIDARG_RETURN = ( D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_NOT_AT_FAULT + 1 ) , - D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_OUTOFMEMORY_RETURN = ( D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_INVALIDARG_RETURN + 1 ) , - D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_BADINTERFACE_RETURN = ( D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_OUTOFMEMORY_RETURN + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DRAW_VIEWPORT_NOT_SET = ( D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_BADINTERFACE_RETURN + 1 ) , - D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TRAILING_DIGIT_IN_SEMANTIC = ( D3D12_MESSAGE_ID_DEVICE_DRAW_VIEWPORT_NOT_SET + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_TRAILING_DIGIT_IN_SEMANTIC = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TRAILING_DIGIT_IN_SEMANTIC + 1 ) , - D3D12_MESSAGE_ID_DEVICE_RSSETVIEWPORTS_DENORMFLUSH = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_TRAILING_DIGIT_IN_SEMANTIC + 1 ) , - D3D12_MESSAGE_ID_OMSETRENDERTARGETS_INVALIDVIEW = ( D3D12_MESSAGE_ID_DEVICE_RSSETVIEWPORTS_DENORMFLUSH + 1 ) , - D3D12_MESSAGE_ID_DEVICE_SETTEXTFILTERSIZE_INVALIDDIMENSIONS = ( D3D12_MESSAGE_ID_OMSETRENDERTARGETS_INVALIDVIEW + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DRAW_SAMPLER_MISMATCH = ( D3D12_MESSAGE_ID_DEVICE_SETTEXTFILTERSIZE_INVALIDDIMENSIONS + 1 ) , - D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TYPE_MISMATCH = ( D3D12_MESSAGE_ID_DEVICE_DRAW_SAMPLER_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_BLENDSTATE_GETDESC_LEGACY = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TYPE_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_SHADERRESOURCEVIEW_GETDESC_LEGACY = ( D3D12_MESSAGE_ID_BLENDSTATE_GETDESC_LEGACY + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DRAW_PS_OUTPUT_TYPE_MISMATCH = ( D3D12_MESSAGE_ID_SHADERRESOURCEVIEW_GETDESC_LEGACY + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_GATHER_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_DRAW_PS_OUTPUT_TYPE_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DRAW_INVALID_USE_OF_CENTER_MULTISAMPLE_PATTERN = ( D3D12_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_GATHER_UNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_STRIDE_TOO_LARGE = ( D3D12_MESSAGE_ID_DEVICE_DRAW_INVALID_USE_OF_CENTER_MULTISAMPLE_PATTERN + 1 ) , - D3D12_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_INVALIDRANGE = ( D3D12_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_STRIDE_TOO_LARGE + 1 ) , - D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_EMPTY_LAYOUT = ( D3D12_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_INVALIDRANGE + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DRAW_RESOURCE_SAMPLE_COUNT_MISMATCH = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_EMPTY_LAYOUT + 1 ) , - D3D12_MESSAGE_ID_LIVE_OBJECT_SUMMARY = ( D3D12_MESSAGE_ID_DEVICE_DRAW_RESOURCE_SAMPLE_COUNT_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_LIVE_BUFFER = ( D3D12_MESSAGE_ID_LIVE_OBJECT_SUMMARY + 1 ) , - D3D12_MESSAGE_ID_LIVE_TEXTURE1D = ( D3D12_MESSAGE_ID_LIVE_BUFFER + 1 ) , - D3D12_MESSAGE_ID_LIVE_TEXTURE2D = ( D3D12_MESSAGE_ID_LIVE_TEXTURE1D + 1 ) , - D3D12_MESSAGE_ID_LIVE_TEXTURE3D = ( D3D12_MESSAGE_ID_LIVE_TEXTURE2D + 1 ) , - D3D12_MESSAGE_ID_LIVE_SHADERRESOURCEVIEW = ( D3D12_MESSAGE_ID_LIVE_TEXTURE3D + 1 ) , - D3D12_MESSAGE_ID_LIVE_RENDERTARGETVIEW = ( D3D12_MESSAGE_ID_LIVE_SHADERRESOURCEVIEW + 1 ) , - D3D12_MESSAGE_ID_LIVE_DEPTHSTENCILVIEW = ( D3D12_MESSAGE_ID_LIVE_RENDERTARGETVIEW + 1 ) , - D3D12_MESSAGE_ID_LIVE_VERTEXSHADER = ( D3D12_MESSAGE_ID_LIVE_DEPTHSTENCILVIEW + 1 ) , - D3D12_MESSAGE_ID_LIVE_GEOMETRYSHADER = ( D3D12_MESSAGE_ID_LIVE_VERTEXSHADER + 1 ) , - D3D12_MESSAGE_ID_LIVE_PIXELSHADER = ( D3D12_MESSAGE_ID_LIVE_GEOMETRYSHADER + 1 ) , - D3D12_MESSAGE_ID_LIVE_INPUTLAYOUT = ( D3D12_MESSAGE_ID_LIVE_PIXELSHADER + 1 ) , - D3D12_MESSAGE_ID_LIVE_SAMPLER = ( D3D12_MESSAGE_ID_LIVE_INPUTLAYOUT + 1 ) , - D3D12_MESSAGE_ID_LIVE_BLENDSTATE = ( D3D12_MESSAGE_ID_LIVE_SAMPLER + 1 ) , - D3D12_MESSAGE_ID_LIVE_DEPTHSTENCILSTATE = ( D3D12_MESSAGE_ID_LIVE_BLENDSTATE + 1 ) , - D3D12_MESSAGE_ID_LIVE_RASTERIZERSTATE = ( D3D12_MESSAGE_ID_LIVE_DEPTHSTENCILSTATE + 1 ) , - D3D12_MESSAGE_ID_LIVE_QUERY = ( D3D12_MESSAGE_ID_LIVE_RASTERIZERSTATE + 1 ) , - D3D12_MESSAGE_ID_LIVE_PREDICATE = ( D3D12_MESSAGE_ID_LIVE_QUERY + 1 ) , - D3D12_MESSAGE_ID_LIVE_COUNTER = ( D3D12_MESSAGE_ID_LIVE_PREDICATE + 1 ) , - D3D12_MESSAGE_ID_LIVE_DEVICE = ( D3D12_MESSAGE_ID_LIVE_COUNTER + 1 ) , - D3D12_MESSAGE_ID_LIVE_SWAPCHAIN = ( D3D12_MESSAGE_ID_LIVE_DEVICE + 1 ) , - D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDFLAGS = ( D3D12_MESSAGE_ID_LIVE_SWAPCHAIN + 1 ) , - D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDCLASSLINKAGE = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDFLAGS + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDCLASSLINKAGE = ( D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDCLASSLINKAGE + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMSTREAMS = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDCLASSLINKAGE + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAMTORASTERIZER = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMSTREAMS + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDSTREAMS = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAMTORASTERIZER + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDCLASSLINKAGE = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDSTREAMS + 1 ) , - D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDCLASSLINKAGE = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDCLASSLINKAGE + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAM = ( D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDCLASSLINKAGE + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDENTRIES = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAM + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDSTRIDES = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDENTRIES + 1 ) , - D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMSTRIDES = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDSTRIDES + 1 ) , - D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDCALL = ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMSTRIDES + 1 ) , - D3D12_MESSAGE_ID_CREATEHULLSHADER_OUTOFMEMORY = ( D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDCALL + 1 ) , - D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDSHADERBYTECODE = ( D3D12_MESSAGE_ID_CREATEHULLSHADER_OUTOFMEMORY + 1 ) , - D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDSHADERTYPE = ( D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDSHADERBYTECODE + 1 ) , - D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDCLASSLINKAGE = ( D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDSHADERTYPE + 1 ) , - D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDCALL = ( D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDCLASSLINKAGE + 1 ) , - D3D12_MESSAGE_ID_CREATEDOMAINSHADER_OUTOFMEMORY = ( D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDCALL + 1 ) , - D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDSHADERBYTECODE = ( D3D12_MESSAGE_ID_CREATEDOMAINSHADER_OUTOFMEMORY + 1 ) , - D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDSHADERTYPE = ( D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDSHADERBYTECODE + 1 ) , - D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDCLASSLINKAGE = ( D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDSHADERTYPE + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DRAW_HS_XOR_DS_MISMATCH = ( D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDCLASSLINKAGE + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DRAWINDIRECT_INVALID_ARG_BUFFER = ( D3D12_MESSAGE_ID_DEVICE_DRAW_HS_XOR_DS_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DRAWINDIRECT_OFFSET_UNALIGNED = ( D3D12_MESSAGE_ID_DEVICE_DRAWINDIRECT_INVALID_ARG_BUFFER + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DRAWINDIRECT_OFFSET_OVERFLOW = ( D3D12_MESSAGE_ID_DEVICE_DRAWINDIRECT_OFFSET_UNALIGNED + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_MAP_INVALIDMAPTYPE = ( D3D12_MESSAGE_ID_DEVICE_DRAWINDIRECT_OFFSET_OVERFLOW + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_MAP_INVALIDSUBRESOURCE = ( D3D12_MESSAGE_ID_RESOURCE_MAP_INVALIDMAPTYPE + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_MAP_INVALIDFLAGS = ( D3D12_MESSAGE_ID_RESOURCE_MAP_INVALIDSUBRESOURCE + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_MAP_ALREADYMAPPED = ( D3D12_MESSAGE_ID_RESOURCE_MAP_INVALIDFLAGS + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_MAP_DEVICEREMOVED_RETURN = ( D3D12_MESSAGE_ID_RESOURCE_MAP_ALREADYMAPPED + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_MAP_OUTOFMEMORY_RETURN = ( D3D12_MESSAGE_ID_RESOURCE_MAP_DEVICEREMOVED_RETURN + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_MAP_WITHOUT_INITIAL_DISCARD = ( D3D12_MESSAGE_ID_RESOURCE_MAP_OUTOFMEMORY_RETURN + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_UNMAP_INVALIDSUBRESOURCE = ( D3D12_MESSAGE_ID_RESOURCE_MAP_WITHOUT_INITIAL_DISCARD + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_UNMAP_NOTMAPPED = ( D3D12_MESSAGE_ID_RESOURCE_UNMAP_INVALIDSUBRESOURCE + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DRAW_RASTERIZING_CONTROL_POINTS = ( D3D12_MESSAGE_ID_RESOURCE_UNMAP_NOTMAPPED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_DRAW_RASTERIZING_CONTROL_POINTS + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DRAW_HS_DS_SIGNATURE_MISMATCH = ( D3D12_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DRAW_HULL_SHADER_INPUT_TOPOLOGY_MISMATCH = ( D3D12_MESSAGE_ID_DEVICE_DRAW_HS_DS_SIGNATURE_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DRAW_HS_DS_CONTROL_POINT_COUNT_MISMATCH = ( D3D12_MESSAGE_ID_DEVICE_DRAW_HULL_SHADER_INPUT_TOPOLOGY_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DRAW_HS_DS_TESSELLATOR_DOMAIN_MISMATCH = ( D3D12_MESSAGE_ID_DEVICE_DRAW_HS_DS_CONTROL_POINT_COUNT_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_UNRECOGNIZED_FEATURE = ( D3D12_MESSAGE_ID_DEVICE_DRAW_HS_DS_TESSELLATOR_DOMAIN_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_MISMATCHED_DATA_SIZE = ( D3D12_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_UNRECOGNIZED_FEATURE + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_INVALIDARG_RETURN = ( D3D12_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_MISMATCHED_DATA_SIZE + 1 ) , - D3D12_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDCALL = ( D3D12_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_INVALIDARG_RETURN + 1 ) , - D3D12_MESSAGE_ID_CREATECOMPUTESHADER_OUTOFMEMORY = ( D3D12_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDCALL + 1 ) , - D3D12_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDSHADERBYTECODE = ( D3D12_MESSAGE_ID_CREATECOMPUTESHADER_OUTOFMEMORY + 1 ) , - D3D12_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDCLASSLINKAGE = ( D3D12_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDSHADERBYTECODE + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CSSETSHADERRESOURCES_VIEWS_EMPTY = ( D3D12_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDCLASSLINKAGE + 1 ) , - D3D12_MESSAGE_ID_CSSETCONSTANTBUFFERS_INVALIDBUFFER = ( D3D12_MESSAGE_ID_DEVICE_CSSETSHADERRESOURCES_VIEWS_EMPTY + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CSSETCONSTANTBUFFERS_BUFFERS_EMPTY = ( D3D12_MESSAGE_ID_CSSETCONSTANTBUFFERS_INVALIDBUFFER + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CSSETSAMPLERS_SAMPLERS_EMPTY = ( D3D12_MESSAGE_ID_DEVICE_CSSETCONSTANTBUFFERS_BUFFERS_EMPTY + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CSGETSHADERRESOURCES_VIEWS_EMPTY = ( D3D12_MESSAGE_ID_DEVICE_CSSETSAMPLERS_SAMPLERS_EMPTY + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CSGETCONSTANTBUFFERS_BUFFERS_EMPTY = ( D3D12_MESSAGE_ID_DEVICE_CSGETSHADERRESOURCES_VIEWS_EMPTY + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CSGETSAMPLERS_SAMPLERS_EMPTY = ( D3D12_MESSAGE_ID_DEVICE_CSGETCONSTANTBUFFERS_BUFFERS_EMPTY + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_DOUBLEFLOATOPSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CSGETSAMPLERS_SAMPLERS_EMPTY + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_DOUBLEFLOATOPSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_DOUBLEFLOATOPSNOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_DOUBLEFLOATOPSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_DOUBLEFLOATOPSNOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_DOUBLEFLOATOPSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_DOUBLEFLOATOPSNOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DOUBLEFLOATOPSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_DOUBLEFLOATOPSNOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_DOUBLEFLOATOPSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DOUBLEFLOATOPSNOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_DOUBLEFLOATOPSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_DOUBLEFLOATOPSNOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_CREATEBUFFER_INVALIDSTRUCTURESTRIDE = ( D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_DOUBLEFLOATOPSNOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDFLAGS = ( D3D12_MESSAGE_ID_CREATEBUFFER_INVALIDSTRUCTURESTRIDE + 1 ) , - D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDRESOURCE = ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDFLAGS + 1 ) , - D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDDESC = ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDRESOURCE + 1 ) , - D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDFORMAT = ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDDESC + 1 ) , - D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDVIDEOPLANESLICE = ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDFORMAT + 1 ) , - D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDPLANESLICE = ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDVIDEOPLANESLICE + 1 ) , - D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDDIMENSIONS = ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDPLANESLICE + 1 ) , - D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_UNRECOGNIZEDFORMAT = ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDDIMENSIONS + 1 ) , - D3D12_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_OVERLAPPING_OLD_SLOTS = ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_UNRECOGNIZEDFORMAT + 1 ) , - D3D12_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_NO_OP = ( D3D12_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_OVERLAPPING_OLD_SLOTS + 1 ) , - D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDARG_RETURN = ( D3D12_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_NO_OP + 1 ) , - D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_OUTOFMEMORY_RETURN = ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDARG_RETURN + 1 ) , - D3D12_MESSAGE_ID_CLEARUNORDEREDACCESSVIEW_DENORMFLUSH = ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_OUTOFMEMORY_RETURN + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CSSETUNORDEREDACCESSS_VIEWS_EMPTY = ( D3D12_MESSAGE_ID_CLEARUNORDEREDACCESSVIEW_DENORMFLUSH + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CSGETUNORDEREDACCESSS_VIEWS_EMPTY = ( D3D12_MESSAGE_ID_DEVICE_CSSETUNORDEREDACCESSS_VIEWS_EMPTY + 1 ) , - D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDFLAGS = ( D3D12_MESSAGE_ID_DEVICE_CSGETUNORDEREDACCESSS_VIEWS_EMPTY + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_INVALID_ARG_BUFFER = ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDFLAGS + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_OFFSET_UNALIGNED = ( D3D12_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_INVALID_ARG_BUFFER + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_OFFSET_OVERFLOW = ( D3D12_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_OFFSET_UNALIGNED + 1 ) , - D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_DEPTH_READONLY = ( D3D12_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_OFFSET_OVERFLOW + 1 ) , - D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_STENCIL_READONLY = ( D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_DEPTH_READONLY + 1 ) , - D3D12_MESSAGE_ID_CHECKFEATURESUPPORT_FORMAT_DEPRECATED = ( D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_STENCIL_READONLY + 1 ) , - D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_RETURN_TYPE_MISMATCH = ( D3D12_MESSAGE_ID_CHECKFEATURESUPPORT_FORMAT_DEPRECATED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_NOT_SET = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_RETURN_TYPE_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DRAW_UNORDEREDACCESSVIEW_RENDERTARGETVIEW_OVERLAP = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_NOT_SET + 1 ) , - D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_DIMENSION_MISMATCH = ( D3D12_MESSAGE_ID_DEVICE_DRAW_UNORDEREDACCESSVIEW_RENDERTARGETVIEW_OVERLAP + 1 ) , - D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_APPEND_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_DIMENSION_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMICS_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_APPEND_UNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_STRUCTURE_STRIDE_MISMATCH = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMICS_UNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_BUFFER_TYPE_MISMATCH = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_STRUCTURE_STRIDE_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_RAW_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_BUFFER_TYPE_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_FORMAT_LD_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_RAW_UNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_FORMAT_STORE_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_FORMAT_LD_UNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_ADD_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_FORMAT_STORE_UNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_BITWISE_OPS_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_ADD_UNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_CMPSTORE_CMPEXCHANGE_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_BITWISE_OPS_UNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_EXCHANGE_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_CMPSTORE_CMPEXCHANGE_UNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_SIGNED_MINMAX_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_EXCHANGE_UNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_UNSIGNED_MINMAX_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_SIGNED_MINMAX_UNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DISPATCH_BOUND_RESOURCE_MAPPED = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_UNSIGNED_MINMAX_UNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DISPATCH_THREADGROUPCOUNT_OVERFLOW = ( D3D12_MESSAGE_ID_DEVICE_DISPATCH_BOUND_RESOURCE_MAPPED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DISPATCH_THREADGROUPCOUNT_ZERO = ( D3D12_MESSAGE_ID_DEVICE_DISPATCH_THREADGROUPCOUNT_OVERFLOW + 1 ) , - D3D12_MESSAGE_ID_DEVICE_SHADERRESOURCEVIEW_STRUCTURE_STRIDE_MISMATCH = ( D3D12_MESSAGE_ID_DEVICE_DISPATCH_THREADGROUPCOUNT_ZERO + 1 ) , - D3D12_MESSAGE_ID_DEVICE_SHADERRESOURCEVIEW_BUFFER_TYPE_MISMATCH = ( D3D12_MESSAGE_ID_DEVICE_SHADERRESOURCEVIEW_STRUCTURE_STRIDE_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_DEVICE_SHADERRESOURCEVIEW_RAW_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_SHADERRESOURCEVIEW_BUFFER_TYPE_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DISPATCH_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_SHADERRESOURCEVIEW_RAW_UNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_UNSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_DISPATCH_UNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_COPYSTRUCTURECOUNT_INVALIDOFFSET = ( D3D12_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_UNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_COPYSTRUCTURECOUNT_LARGEOFFSET = ( D3D12_MESSAGE_ID_COPYSTRUCTURECOUNT_INVALIDOFFSET + 1 ) , - D3D12_MESSAGE_ID_COPYSTRUCTURECOUNT_INVALIDDESTINATIONSTATE = ( D3D12_MESSAGE_ID_COPYSTRUCTURECOUNT_LARGEOFFSET + 1 ) , - D3D12_MESSAGE_ID_COPYSTRUCTURECOUNT_INVALIDSOURCESTATE = ( D3D12_MESSAGE_ID_COPYSTRUCTURECOUNT_INVALIDDESTINATIONSTATE + 1 ) , - D3D12_MESSAGE_ID_CHECKFORMATSUPPORT_FORMAT_NOT_SUPPORTED = ( D3D12_MESSAGE_ID_COPYSTRUCTURECOUNT_INVALIDSOURCESTATE + 1 ) , - D3D12_MESSAGE_ID_CLEARUNORDEREDACCESSVIEWFLOAT_INVALIDFORMAT = ( D3D12_MESSAGE_ID_CHECKFORMATSUPPORT_FORMAT_NOT_SUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_COUNTER_UNSUPPORTED = ( D3D12_MESSAGE_ID_CLEARUNORDEREDACCESSVIEWFLOAT_INVALIDFORMAT + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DRAW_PIXEL_SHADER_WITHOUT_RTV_OR_DSV = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_COUNTER_UNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_SHADER_ABORT = ( D3D12_MESSAGE_ID_DEVICE_DRAW_PIXEL_SHADER_WITHOUT_RTV_OR_DSV + 1 ) , - D3D12_MESSAGE_ID_SHADER_MESSAGE = ( D3D12_MESSAGE_ID_SHADER_ABORT + 1 ) , - D3D12_MESSAGE_ID_SHADER_ERROR = ( D3D12_MESSAGE_ID_SHADER_MESSAGE + 1 ) , - D3D12_MESSAGE_ID_OFFERRESOURCES_INVALIDRESOURCE = ( D3D12_MESSAGE_ID_SHADER_ERROR + 1 ) , - D3D12_MESSAGE_ID_ENQUEUESETEVENT_INVALIDARG_RETURN = ( D3D12_MESSAGE_ID_OFFERRESOURCES_INVALIDRESOURCE + 1 ) , - D3D12_MESSAGE_ID_ENQUEUESETEVENT_OUTOFMEMORY_RETURN = ( D3D12_MESSAGE_ID_ENQUEUESETEVENT_INVALIDARG_RETURN + 1 ) , - D3D12_MESSAGE_ID_ENQUEUESETEVENT_ACCESSDENIED_RETURN = ( D3D12_MESSAGE_ID_ENQUEUESETEVENT_OUTOFMEMORY_RETURN + 1 ) , - D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDFORCEDSAMPLECOUNT = ( D3D12_MESSAGE_ID_ENQUEUESETEVENT_ACCESSDENIED_RETURN + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DRAW_INVALID_USE_OF_FORCED_SAMPLE_COUNT = ( D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDFORCEDSAMPLECOUNT + 1 ) , - D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDLOGICOPS = ( D3D12_MESSAGE_ID_DEVICE_DRAW_INVALID_USE_OF_FORCED_SAMPLE_COUNT + 1 ) , - D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDARRAYWITHDECODER = ( D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDLOGICOPS + 1 ) , - D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDARRAYWITHDECODER = ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDARRAYWITHDECODER + 1 ) , - D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDARRAYWITHDECODER = ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDARRAYWITHDECODER + 1 ) , - D3D12_MESSAGE_ID_DEVICE_LOCKEDOUT_INTERFACE = ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDARRAYWITHDECODER + 1 ) , - D3D12_MESSAGE_ID_OFFERRESOURCES_INVALIDPRIORITY = ( D3D12_MESSAGE_ID_DEVICE_LOCKEDOUT_INTERFACE + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_INVALIDVIEW = ( D3D12_MESSAGE_ID_OFFERRESOURCES_INVALIDPRIORITY + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_DOUBLEEXTENSIONSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_INVALIDVIEW + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_SHADEREXTENSIONSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_DOUBLEEXTENSIONSNOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_DOUBLEEXTENSIONSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_SHADEREXTENSIONSNOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_SHADEREXTENSIONSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_DOUBLEEXTENSIONSNOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_DOUBLEEXTENSIONSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_SHADEREXTENSIONSNOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_SHADEREXTENSIONSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_DOUBLEEXTENSIONSNOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_DOUBLEEXTENSIONSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_SHADEREXTENSIONSNOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_SHADEREXTENSIONSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_DOUBLEEXTENSIONSNOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DOUBLEEXTENSIONSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_SHADEREXTENSIONSNOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_SHADEREXTENSIONSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DOUBLEEXTENSIONSNOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_DOUBLEEXTENSIONSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_SHADEREXTENSIONSNOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_SHADEREXTENSIONSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_DOUBLEEXTENSIONSNOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_DOUBLEEXTENSIONSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_SHADEREXTENSIONSNOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_SHADEREXTENSIONSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_DOUBLEEXTENSIONSNOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_MINPRECISION = ( D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_SHADEREXTENSIONSNOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_UAVSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_MINPRECISION + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_UAVSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_UAVSNOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_UAVSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_UAVSNOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_UAVSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_UAVSNOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UAVSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_UAVSNOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_UAVSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UAVSNOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_UAVSNOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_UAVSNOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_INVALIDOFFSET = ( D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_UAVSNOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_TOOMANYVIEWS = ( D3D12_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_INVALIDOFFSET + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_NOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_TOOMANYVIEWS + 1 ) , - D3D12_MESSAGE_ID_SWAPDEVICECONTEXTSTATE_NOTSUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_NOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_UPDATESUBRESOURCE_PREFERUPDATESUBRESOURCE1 = ( D3D12_MESSAGE_ID_SWAPDEVICECONTEXTSTATE_NOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_GETDC_INACCESSIBLE = ( D3D12_MESSAGE_ID_UPDATESUBRESOURCE_PREFERUPDATESUBRESOURCE1 + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_INVALIDRECT = ( D3D12_MESSAGE_ID_GETDC_INACCESSIBLE + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DRAW_SAMPLE_MASK_IGNORED_ON_FL9 = ( D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_INVALIDRECT + 1 ) , - D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE1_NOT_SUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_DRAW_SAMPLE_MASK_IGNORED_ON_FL9 + 1 ) , - D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_BY_NAME_NOT_SUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE1_NOT_SUPPORTED + 1 ) , - D3D12_MESSAGE_ID_ENQUEUESETEVENT_NOT_SUPPORTED = ( D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_BY_NAME_NOT_SUPPORTED + 1 ) , - D3D12_MESSAGE_ID_OFFERRELEASE_NOT_SUPPORTED = ( D3D12_MESSAGE_ID_ENQUEUESETEVENT_NOT_SUPPORTED + 1 ) , - D3D12_MESSAGE_ID_OFFERRESOURCES_INACCESSIBLE = ( D3D12_MESSAGE_ID_OFFERRELEASE_NOT_SUPPORTED + 1 ) , - D3D12_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_INVALIDMSAA = ( D3D12_MESSAGE_ID_OFFERRESOURCES_INACCESSIBLE + 1 ) , - D3D12_MESSAGE_ID_CREATEVIDEOPROCESSOROUTPUTVIEW_INVALIDMSAA = ( D3D12_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_INVALIDMSAA + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_INVALIDSOURCERECT = ( D3D12_MESSAGE_ID_CREATEVIDEOPROCESSOROUTPUTVIEW_INVALIDMSAA + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_EMPTYRECT = ( D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_INVALIDSOURCERECT + 1 ) , - D3D12_MESSAGE_ID_UPDATESUBRESOURCE_EMPTYDESTBOX = ( D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_EMPTYRECT + 1 ) , - D3D12_MESSAGE_ID_COPYSUBRESOURCEREGION_EMPTYSOURCEBOX = ( D3D12_MESSAGE_ID_UPDATESUBRESOURCE_EMPTYDESTBOX + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DRAW_OM_RENDER_TARGET_DOES_NOT_SUPPORT_LOGIC_OPS = ( D3D12_MESSAGE_ID_COPYSUBRESOURCEREGION_EMPTYSOURCEBOX + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DRAW_DEPTHSTENCILVIEW_NOT_SET = ( D3D12_MESSAGE_ID_DEVICE_DRAW_OM_RENDER_TARGET_DOES_NOT_SUPPORT_LOGIC_OPS + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DRAW_RENDERTARGETVIEW_NOT_SET = ( D3D12_MESSAGE_ID_DEVICE_DRAW_DEPTHSTENCILVIEW_NOT_SET + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DRAW_RENDERTARGETVIEW_NOT_SET_DUE_TO_FLIP_PRESENT = ( D3D12_MESSAGE_ID_DEVICE_DRAW_RENDERTARGETVIEW_NOT_SET + 1 ) , - D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_NOT_SET_DUE_TO_FLIP_PRESENT = ( D3D12_MESSAGE_ID_DEVICE_DRAW_RENDERTARGETVIEW_NOT_SET_DUE_TO_FLIP_PRESENT + 1 ) , - D3D12_MESSAGE_ID_GETDATAFORNEWHARDWAREKEY_NULLPARAM = ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_NOT_SET_DUE_TO_FLIP_PRESENT + 1 ) , - D3D12_MESSAGE_ID_CHECKCRYPTOSESSIONSTATUS_NULLPARAM = ( D3D12_MESSAGE_ID_GETDATAFORNEWHARDWAREKEY_NULLPARAM + 1 ) , - D3D12_MESSAGE_ID_SETEVENTONHARDWARECONTENTPROTECTIONTILT_NULLPARAM = ( D3D12_MESSAGE_ID_CHECKCRYPTOSESSIONSTATUS_NULLPARAM + 1 ) , - D3D12_MESSAGE_ID_GETVIDEODECODERCAPS_NULLPARAM = ( D3D12_MESSAGE_ID_SETEVENTONHARDWARECONTENTPROTECTIONTILT_NULLPARAM + 1 ) , - D3D12_MESSAGE_ID_GETVIDEODECODERCAPS_ZEROWIDTHHEIGHT = ( D3D12_MESSAGE_ID_GETVIDEODECODERCAPS_NULLPARAM + 1 ) , - D3D12_MESSAGE_ID_CHECKVIDEODECODERDOWNSAMPLING_NULLPARAM = ( D3D12_MESSAGE_ID_GETVIDEODECODERCAPS_ZEROWIDTHHEIGHT + 1 ) , - D3D12_MESSAGE_ID_CHECKVIDEODECODERDOWNSAMPLING_INVALIDCOLORSPACE = ( D3D12_MESSAGE_ID_CHECKVIDEODECODERDOWNSAMPLING_NULLPARAM + 1 ) , - D3D12_MESSAGE_ID_CHECKVIDEODECODERDOWNSAMPLING_ZEROWIDTHHEIGHT = ( D3D12_MESSAGE_ID_CHECKVIDEODECODERDOWNSAMPLING_INVALIDCOLORSPACE + 1 ) , - D3D12_MESSAGE_ID_VIDEODECODERENABLEDOWNSAMPLING_NULLPARAM = ( D3D12_MESSAGE_ID_CHECKVIDEODECODERDOWNSAMPLING_ZEROWIDTHHEIGHT + 1 ) , - D3D12_MESSAGE_ID_VIDEODECODERENABLEDOWNSAMPLING_UNSUPPORTED = ( D3D12_MESSAGE_ID_VIDEODECODERENABLEDOWNSAMPLING_NULLPARAM + 1 ) , - D3D12_MESSAGE_ID_VIDEODECODERUPDATEDOWNSAMPLING_NULLPARAM = ( D3D12_MESSAGE_ID_VIDEODECODERENABLEDOWNSAMPLING_UNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_VIDEODECODERUPDATEDOWNSAMPLING_UNSUPPORTED = ( D3D12_MESSAGE_ID_VIDEODECODERUPDATEDOWNSAMPLING_NULLPARAM + 1 ) , - D3D12_MESSAGE_ID_CHECKVIDEOPROCESSORFORMATCONVERSION_NULLPARAM = ( D3D12_MESSAGE_ID_VIDEODECODERUPDATEDOWNSAMPLING_UNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTCOLORSPACE1_NULLPARAM = ( D3D12_MESSAGE_ID_CHECKVIDEOPROCESSORFORMATCONVERSION_NULLPARAM + 1 ) , - D3D12_MESSAGE_ID_VIDEOPROCESSORGETOUTPUTCOLORSPACE1_NULLPARAM = ( D3D12_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTCOLORSPACE1_NULLPARAM + 1 ) , - D3D12_MESSAGE_ID_VIDEOPROCESSORSETSTREAMCOLORSPACE1_NULLPARAM = ( D3D12_MESSAGE_ID_VIDEOPROCESSORGETOUTPUTCOLORSPACE1_NULLPARAM + 1 ) , - D3D12_MESSAGE_ID_VIDEOPROCESSORSETSTREAMCOLORSPACE1_INVALIDSTREAM = ( D3D12_MESSAGE_ID_VIDEOPROCESSORSETSTREAMCOLORSPACE1_NULLPARAM + 1 ) , - D3D12_MESSAGE_ID_VIDEOPROCESSORSETSTREAMMIRROR_NULLPARAM = ( D3D12_MESSAGE_ID_VIDEOPROCESSORSETSTREAMCOLORSPACE1_INVALIDSTREAM + 1 ) , - D3D12_MESSAGE_ID_VIDEOPROCESSORSETSTREAMMIRROR_INVALIDSTREAM = ( D3D12_MESSAGE_ID_VIDEOPROCESSORSETSTREAMMIRROR_NULLPARAM + 1 ) , - D3D12_MESSAGE_ID_VIDEOPROCESSORSETSTREAMMIRROR_UNSUPPORTED = ( D3D12_MESSAGE_ID_VIDEOPROCESSORSETSTREAMMIRROR_INVALIDSTREAM + 1 ) , - D3D12_MESSAGE_ID_VIDEOPROCESSORGETSTREAMCOLORSPACE1_NULLPARAM = ( D3D12_MESSAGE_ID_VIDEOPROCESSORSETSTREAMMIRROR_UNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_VIDEOPROCESSORGETSTREAMMIRROR_NULLPARAM = ( D3D12_MESSAGE_ID_VIDEOPROCESSORGETSTREAMCOLORSPACE1_NULLPARAM + 1 ) , - D3D12_MESSAGE_ID_RECOMMENDVIDEODECODERDOWNSAMPLING_NULLPARAM = ( D3D12_MESSAGE_ID_VIDEOPROCESSORGETSTREAMMIRROR_NULLPARAM + 1 ) , - D3D12_MESSAGE_ID_RECOMMENDVIDEODECODERDOWNSAMPLING_INVALIDCOLORSPACE = ( D3D12_MESSAGE_ID_RECOMMENDVIDEODECODERDOWNSAMPLING_NULLPARAM + 1 ) , - D3D12_MESSAGE_ID_RECOMMENDVIDEODECODERDOWNSAMPLING_ZEROWIDTHHEIGHT = ( D3D12_MESSAGE_ID_RECOMMENDVIDEODECODERDOWNSAMPLING_INVALIDCOLORSPACE + 1 ) , - D3D12_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTSHADERUSAGE_NULLPARAM = ( D3D12_MESSAGE_ID_RECOMMENDVIDEODECODERDOWNSAMPLING_ZEROWIDTHHEIGHT + 1 ) , - D3D12_MESSAGE_ID_VIDEOPROCESSORGETOUTPUTSHADERUSAGE_NULLPARAM = ( D3D12_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTSHADERUSAGE_NULLPARAM + 1 ) , - D3D12_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_NULLPARAM = ( D3D12_MESSAGE_ID_VIDEOPROCESSORGETOUTPUTSHADERUSAGE_NULLPARAM + 1 ) , - D3D12_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_INVALIDSTREAMCOUNT = ( D3D12_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_NULLPARAM + 1 ) , - D3D12_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_TARGETRECT = ( D3D12_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_INVALIDSTREAMCOUNT + 1 ) , - D3D12_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_INVALIDSOURCERECT = ( D3D12_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_TARGETRECT + 1 ) , - D3D12_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_INVALIDDESTRECT = ( D3D12_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_INVALIDSOURCERECT + 1 ) , - D3D12_MESSAGE_ID_CREATEBUFFER_INVALIDUSAGE = ( D3D12_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_INVALIDDESTRECT + 1 ) , - D3D12_MESSAGE_ID_CREATETEXTURE1D_INVALIDUSAGE = ( D3D12_MESSAGE_ID_CREATEBUFFER_INVALIDUSAGE + 1 ) , - D3D12_MESSAGE_ID_CREATETEXTURE2D_INVALIDUSAGE = ( D3D12_MESSAGE_ID_CREATETEXTURE1D_INVALIDUSAGE + 1 ) , - D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_LEVEL9_STEPRATE_NOT_1 = ( D3D12_MESSAGE_ID_CREATETEXTURE2D_INVALIDUSAGE + 1 ) , - D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_LEVEL9_INSTANCING_NOT_SUPPORTED = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_LEVEL9_STEPRATE_NOT_1 + 1 ) , - D3D12_MESSAGE_ID_UPDATETILEMAPPINGS_INVALID_PARAMETER = ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_LEVEL9_INSTANCING_NOT_SUPPORTED + 1 ) , - D3D12_MESSAGE_ID_COPYTILEMAPPINGS_INVALID_PARAMETER = ( D3D12_MESSAGE_ID_UPDATETILEMAPPINGS_INVALID_PARAMETER + 1 ) , - D3D12_MESSAGE_ID_COPYTILES_INVALID_PARAMETER = ( D3D12_MESSAGE_ID_COPYTILEMAPPINGS_INVALID_PARAMETER + 1 ) , - D3D12_MESSAGE_ID_NULL_TILE_MAPPING_ACCESS_WARNING = ( D3D12_MESSAGE_ID_COPYTILES_INVALID_PARAMETER + 1 ) , - D3D12_MESSAGE_ID_NULL_TILE_MAPPING_ACCESS_ERROR = ( D3D12_MESSAGE_ID_NULL_TILE_MAPPING_ACCESS_WARNING + 1 ) , - D3D12_MESSAGE_ID_DIRTY_TILE_MAPPING_ACCESS = ( D3D12_MESSAGE_ID_NULL_TILE_MAPPING_ACCESS_ERROR + 1 ) , - D3D12_MESSAGE_ID_DUPLICATE_TILE_MAPPINGS_IN_COVERED_AREA = ( D3D12_MESSAGE_ID_DIRTY_TILE_MAPPING_ACCESS + 1 ) , - D3D12_MESSAGE_ID_TILE_MAPPINGS_IN_COVERED_AREA_DUPLICATED_OUTSIDE = ( D3D12_MESSAGE_ID_DUPLICATE_TILE_MAPPINGS_IN_COVERED_AREA + 1 ) , - D3D12_MESSAGE_ID_TILE_MAPPINGS_SHARED_BETWEEN_INCOMPATIBLE_RESOURCES = ( D3D12_MESSAGE_ID_TILE_MAPPINGS_IN_COVERED_AREA_DUPLICATED_OUTSIDE + 1 ) , - D3D12_MESSAGE_ID_TILE_MAPPINGS_SHARED_BETWEEN_INPUT_AND_OUTPUT = ( D3D12_MESSAGE_ID_TILE_MAPPINGS_SHARED_BETWEEN_INCOMPATIBLE_RESOURCES + 1 ) , - D3D12_MESSAGE_ID_CHECKMULTISAMPLEQUALITYLEVELS_INVALIDFLAGS = ( D3D12_MESSAGE_ID_TILE_MAPPINGS_SHARED_BETWEEN_INPUT_AND_OUTPUT + 1 ) , - D3D12_MESSAGE_ID_GETRESOURCETILING_NONTILED_RESOURCE = ( D3D12_MESSAGE_ID_CHECKMULTISAMPLEQUALITYLEVELS_INVALIDFLAGS + 1 ) , - D3D12_MESSAGE_ID_NEED_TO_CALL_TILEDRESOURCEBARRIER = ( D3D12_MESSAGE_ID_GETRESOURCETILING_NONTILED_RESOURCE + 1 ) , - D3D12_MESSAGE_ID_CREATEDEVICE_INVALIDARGS = ( D3D12_MESSAGE_ID_NEED_TO_CALL_TILEDRESOURCEBARRIER + 1 ) , - D3D12_MESSAGE_ID_CREATEDEVICE_WARNING = ( D3D12_MESSAGE_ID_CREATEDEVICE_INVALIDARGS + 1 ) , - D3D12_MESSAGE_ID_TILED_RESOURCE_TIER_1_BUFFER_TEXTURE_MISMATCH = ( D3D12_MESSAGE_ID_CREATEDEVICE_WARNING + 1 ) , - D3D12_MESSAGE_ID_CREATE_CRYPTOSESSION = ( D3D12_MESSAGE_ID_TILED_RESOURCE_TIER_1_BUFFER_TEXTURE_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_CREATE_AUTHENTICATEDCHANNEL = ( D3D12_MESSAGE_ID_CREATE_CRYPTOSESSION + 1 ) , - D3D12_MESSAGE_ID_LIVE_CRYPTOSESSION = ( D3D12_MESSAGE_ID_CREATE_AUTHENTICATEDCHANNEL + 1 ) , - D3D12_MESSAGE_ID_LIVE_AUTHENTICATEDCHANNEL = ( D3D12_MESSAGE_ID_LIVE_CRYPTOSESSION + 1 ) , - D3D12_MESSAGE_ID_DESTROY_CRYPTOSESSION = ( D3D12_MESSAGE_ID_LIVE_AUTHENTICATEDCHANNEL + 1 ) , - D3D12_MESSAGE_ID_DESTROY_AUTHENTICATEDCHANNEL = ( D3D12_MESSAGE_ID_DESTROY_CRYPTOSESSION + 1 ) , - D3D12_MESSAGE_ID_MAP_INVALID_SUBRESOURCE = ( D3D12_MESSAGE_ID_DESTROY_AUTHENTICATEDCHANNEL + 1 ) , - D3D12_MESSAGE_ID_MAP_INVALID_TYPE = ( D3D12_MESSAGE_ID_MAP_INVALID_SUBRESOURCE + 1 ) , - D3D12_MESSAGE_ID_MAP_UNSUPPORTED_TYPE = ( D3D12_MESSAGE_ID_MAP_INVALID_TYPE + 1 ) , - D3D12_MESSAGE_ID_UNMAP_INVALID_SUBRESOURCE = ( D3D12_MESSAGE_ID_MAP_UNSUPPORTED_TYPE + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_TYPE = ( D3D12_MESSAGE_ID_UNMAP_INVALID_SUBRESOURCE + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_BARRIER_NULL_POINTER = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_TYPE + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_SUBRESOURCE = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_NULL_POINTER + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_BARRIER_RESERVED_BITS = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_SUBRESOURCE + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISSING_BIND_FLAGS = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_RESERVED_BITS + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_MISC_FLAGS = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISSING_BIND_FLAGS + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_BARRIER_MATCHING_STATES = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_MISC_FLAGS + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMBINATION = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_MATCHING_STATES + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_BARRIER_BEFORE_AFTER_MISMATCH = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMBINATION + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_RESOURCE = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_BEFORE_AFTER_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_BARRIER_SAMPLE_COUNT = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_RESOURCE + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAGS = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_SAMPLE_COUNT + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMBINED_FLAGS = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAGS + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAGS_FOR_FORMAT = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMBINED_FLAGS + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_SPLIT_BARRIER = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAGS_FOR_FORMAT + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_BARRIER_UNMATCHED_END = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_SPLIT_BARRIER + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_BARRIER_UNMATCHED_BEGIN = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_UNMATCHED_END + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAG = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_UNMATCHED_BEGIN + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMMAND_LIST_TYPE = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAG + 1 ) , - D3D12_MESSAGE_ID_INVALID_SUBRESOURCE_STATE = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMMAND_LIST_TYPE + 1 ) , - D3D12_MESSAGE_ID_INEFFICIENT_PRESENT = ( D3D12_MESSAGE_ID_INVALID_SUBRESOURCE_STATE + 1 ) , - D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_CONTENTION = ( D3D12_MESSAGE_ID_INEFFICIENT_PRESENT + 1 ) , - D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_RESET = ( D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_CONTENTION + 1 ) , - D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_RESET_BUNDLE = ( D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_RESET + 1 ) , - D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_CANNOT_RESET = ( D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_RESET_BUNDLE + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_OPEN = ( D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_CANNOT_RESET + 1 ) , - D3D12_MESSAGE_ID_QUERY_STATE_MISMATCH = ( D3D12_MESSAGE_ID_COMMAND_LIST_OPEN + 1 ) , - D3D12_MESSAGE_ID_INVALID_BUNDLE_API = ( D3D12_MESSAGE_ID_QUERY_STATE_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_CLOSED = ( D3D12_MESSAGE_ID_INVALID_BUNDLE_API + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_CLOSED_WITH_INVALID_RESOURCE = ( D3D12_MESSAGE_ID_COMMAND_LIST_CLOSED + 1 ) , - D3D12_MESSAGE_ID_WRONG_COMMAND_ALLOCATOR_TYPE = ( D3D12_MESSAGE_ID_COMMAND_LIST_CLOSED_WITH_INVALID_RESOURCE + 1 ) , - D3D12_MESSAGE_ID_INVALID_INDIRECT_ARGUMENT_BUFFER = ( D3D12_MESSAGE_ID_WRONG_COMMAND_ALLOCATOR_TYPE + 1 ) , - D3D12_MESSAGE_ID_COMPUTE_AND_GRAPHICS_PIPELINE = ( D3D12_MESSAGE_ID_INVALID_INDIRECT_ARGUMENT_BUFFER + 1 ) , - D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_SYNC = ( D3D12_MESSAGE_ID_COMPUTE_AND_GRAPHICS_PIPELINE + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_SYNC = ( D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_SYNC + 1 ) , - D3D12_MESSAGE_ID_SET_DESCRIPTOR_HEAP_INVALID = ( D3D12_MESSAGE_ID_COMMAND_LIST_SYNC + 1 ) , - D3D12_MESSAGE_ID_CREATE_QUEUE_IMAGE_NOT_SUPPORTED = ( D3D12_MESSAGE_ID_SET_DESCRIPTOR_HEAP_INVALID + 1 ) , - D3D12_MESSAGE_ID_CREATE_COMMAND_ALLOCATOR_IMAGE_NOT_SUPPORTED = ( D3D12_MESSAGE_ID_CREATE_QUEUE_IMAGE_NOT_SUPPORTED + 1 ) , - D3D12_MESSAGE_ID_CREATE_COMMANDQUEUE = ( D3D12_MESSAGE_ID_CREATE_COMMAND_ALLOCATOR_IMAGE_NOT_SUPPORTED + 1 ) , - D3D12_MESSAGE_ID_CREATE_COMMANDALLOCATOR = ( D3D12_MESSAGE_ID_CREATE_COMMANDQUEUE + 1 ) , - D3D12_MESSAGE_ID_CREATE_PIPELINESTATE = ( D3D12_MESSAGE_ID_CREATE_COMMANDALLOCATOR + 1 ) , - D3D12_MESSAGE_ID_CREATE_COMMANDLIST12 = ( D3D12_MESSAGE_ID_CREATE_PIPELINESTATE + 1 ) , - D3D12_MESSAGE_ID_CREATE_IMAGECOMMANDLIST = ( D3D12_MESSAGE_ID_CREATE_COMMANDLIST12 + 1 ) , - D3D12_MESSAGE_ID_CREATE_RESOURCE = ( D3D12_MESSAGE_ID_CREATE_IMAGECOMMANDLIST + 1 ) , - D3D12_MESSAGE_ID_CREATE_DESCRIPTORHEAP = ( D3D12_MESSAGE_ID_CREATE_RESOURCE + 1 ) , - D3D12_MESSAGE_ID_CREATE_ROOTSIGNATURE = ( D3D12_MESSAGE_ID_CREATE_DESCRIPTORHEAP + 1 ) , - D3D12_MESSAGE_ID_CREATE_LIBRARY = ( D3D12_MESSAGE_ID_CREATE_ROOTSIGNATURE + 1 ) , - D3D12_MESSAGE_ID_CREATE_HEAP = ( D3D12_MESSAGE_ID_CREATE_LIBRARY + 1 ) , - D3D12_MESSAGE_ID_CREATE_MONITOREDFENCE = ( D3D12_MESSAGE_ID_CREATE_HEAP + 1 ) , - D3D12_MESSAGE_ID_CREATE_QUERYHEAP = ( D3D12_MESSAGE_ID_CREATE_MONITOREDFENCE + 1 ) , - D3D12_MESSAGE_ID_CREATE_COMMANDSIGNATURE = ( D3D12_MESSAGE_ID_CREATE_QUERYHEAP + 1 ) , - D3D12_MESSAGE_ID_LIVE_COMMANDQUEUE = ( D3D12_MESSAGE_ID_CREATE_COMMANDSIGNATURE + 1 ) , - D3D12_MESSAGE_ID_LIVE_COMMANDALLOCATOR = ( D3D12_MESSAGE_ID_LIVE_COMMANDQUEUE + 1 ) , - D3D12_MESSAGE_ID_LIVE_PIPELINESTATE = ( D3D12_MESSAGE_ID_LIVE_COMMANDALLOCATOR + 1 ) , - D3D12_MESSAGE_ID_LIVE_COMMANDLIST12 = ( D3D12_MESSAGE_ID_LIVE_PIPELINESTATE + 1 ) , - D3D12_MESSAGE_ID_LIVE_IMAGECOMMANDLIST = ( D3D12_MESSAGE_ID_LIVE_COMMANDLIST12 + 1 ) , - D3D12_MESSAGE_ID_LIVE_RESOURCE = ( D3D12_MESSAGE_ID_LIVE_IMAGECOMMANDLIST + 1 ) , - D3D12_MESSAGE_ID_LIVE_DESCRIPTORHEAP = ( D3D12_MESSAGE_ID_LIVE_RESOURCE + 1 ) , - D3D12_MESSAGE_ID_LIVE_ROOTSIGNATURE = ( D3D12_MESSAGE_ID_LIVE_DESCRIPTORHEAP + 1 ) , - D3D12_MESSAGE_ID_LIVE_LIBRARY = ( D3D12_MESSAGE_ID_LIVE_ROOTSIGNATURE + 1 ) , - D3D12_MESSAGE_ID_LIVE_HEAP = ( D3D12_MESSAGE_ID_LIVE_LIBRARY + 1 ) , - D3D12_MESSAGE_ID_LIVE_MONITOREDFENCE = ( D3D12_MESSAGE_ID_LIVE_HEAP + 1 ) , - D3D12_MESSAGE_ID_LIVE_QUERYHEAP = ( D3D12_MESSAGE_ID_LIVE_MONITOREDFENCE + 1 ) , - D3D12_MESSAGE_ID_LIVE_COMMANDSIGNATURE = ( D3D12_MESSAGE_ID_LIVE_QUERYHEAP + 1 ) , - D3D12_MESSAGE_ID_DESTROY_COMMANDQUEUE = ( D3D12_MESSAGE_ID_LIVE_COMMANDSIGNATURE + 1 ) , - D3D12_MESSAGE_ID_DESTROY_COMMANDALLOCATOR = ( D3D12_MESSAGE_ID_DESTROY_COMMANDQUEUE + 1 ) , - D3D12_MESSAGE_ID_DESTROY_PIPELINESTATE = ( D3D12_MESSAGE_ID_DESTROY_COMMANDALLOCATOR + 1 ) , - D3D12_MESSAGE_ID_DESTROY_COMMANDLIST12 = ( D3D12_MESSAGE_ID_DESTROY_PIPELINESTATE + 1 ) , - D3D12_MESSAGE_ID_DESTROY_IMAGECOMMANDLIST = ( D3D12_MESSAGE_ID_DESTROY_COMMANDLIST12 + 1 ) , - D3D12_MESSAGE_ID_DESTROY_RESOURCE = ( D3D12_MESSAGE_ID_DESTROY_IMAGECOMMANDLIST + 1 ) , - D3D12_MESSAGE_ID_DESTROY_DESCRIPTORHEAP = ( D3D12_MESSAGE_ID_DESTROY_RESOURCE + 1 ) , - D3D12_MESSAGE_ID_DESTROY_ROOTSIGNATURE = ( D3D12_MESSAGE_ID_DESTROY_DESCRIPTORHEAP + 1 ) , - D3D12_MESSAGE_ID_DESTROY_LIBRARY = ( D3D12_MESSAGE_ID_DESTROY_ROOTSIGNATURE + 1 ) , - D3D12_MESSAGE_ID_DESTROY_HEAP = ( D3D12_MESSAGE_ID_DESTROY_LIBRARY + 1 ) , - D3D12_MESSAGE_ID_DESTROY_MONITOREDFENCE = ( D3D12_MESSAGE_ID_DESTROY_HEAP + 1 ) , - D3D12_MESSAGE_ID_DESTROY_QUERYHEAP = ( D3D12_MESSAGE_ID_DESTROY_MONITOREDFENCE + 1 ) , - D3D12_MESSAGE_ID_DESTROY_COMMANDSIGNATURE = ( D3D12_MESSAGE_ID_DESTROY_QUERYHEAP + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDHEAPTYPE = ( D3D12_MESSAGE_ID_DESTROY_COMMANDSIGNATURE + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDIMENSIONS = ( D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDHEAPTYPE + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDMISCFLAGS = ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDIMENSIONS + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDMISCFLAGS = ( D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDMISCFLAGS + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCE_LARGEALLOCATION = ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDMISCFLAGS + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCE_SMALLALLOCATION = ( D3D12_MESSAGE_ID_CREATERESOURCE_LARGEALLOCATION + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDARG_RETURN = ( D3D12_MESSAGE_ID_CREATERESOURCE_SMALLALLOCATION + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCE_OUTOFMEMORY_RETURN = ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDARG_RETURN + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDESC = ( D3D12_MESSAGE_ID_CREATERESOURCE_OUTOFMEMORY_RETURN + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDINITIALSTATE = ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDESC + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_HAS_PENDING_INITIAL_DATA = ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDINITIALSTATE + 1 ) , - D3D12_MESSAGE_ID_POSSIBLY_INVALID_SUBRESOURCE_STATE = ( D3D12_MESSAGE_ID_RESOURCE_HAS_PENDING_INITIAL_DATA + 1 ) , - D3D12_MESSAGE_ID_INVALID_USE_OF_NON_RESIDENT_RESOURCE = ( D3D12_MESSAGE_ID_POSSIBLY_INVALID_SUBRESOURCE_STATE + 1 ) , - D3D12_MESSAGE_ID_POSSIBLE_INVALID_USE_OF_NON_RESIDENT_RESOURCE = ( D3D12_MESSAGE_ID_INVALID_USE_OF_NON_RESIDENT_RESOURCE + 1 ) , - D3D12_MESSAGE_ID_BUNDLE_PIPELINE_STATE_MISMATCH = ( D3D12_MESSAGE_ID_POSSIBLE_INVALID_USE_OF_NON_RESIDENT_RESOURCE + 1 ) , - D3D12_MESSAGE_ID_PRIMITIVE_TOPOLOGY_MISMATCH_PIPELINE_STATE = ( D3D12_MESSAGE_ID_BUNDLE_PIPELINE_STATE_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_RENDER_TARGET_NUMBER_MISMATCH_PIPELINE_STATE = ( D3D12_MESSAGE_ID_PRIMITIVE_TOPOLOGY_MISMATCH_PIPELINE_STATE + 1 ) , - D3D12_MESSAGE_ID_RENDER_TARGET_FORMAT_MISMATCH_PIPELINE_STATE = ( D3D12_MESSAGE_ID_RENDER_TARGET_NUMBER_MISMATCH_PIPELINE_STATE + 1 ) , - D3D12_MESSAGE_ID_RENDER_TARGET_SAMPLE_DESC_MISMATCH_PIPELINE_STATE = ( D3D12_MESSAGE_ID_RENDER_TARGET_FORMAT_MISMATCH_PIPELINE_STATE + 1 ) , - D3D12_MESSAGE_ID_DEPTH_STENCIL_FORMAT_MISMATCH_PIPELINE_STATE = ( D3D12_MESSAGE_ID_RENDER_TARGET_SAMPLE_DESC_MISMATCH_PIPELINE_STATE + 1 ) , - D3D12_MESSAGE_ID_DEPTH_STENCIL_SAMPLE_DESC_MISMATCH_PIPELINE_STATE = ( D3D12_MESSAGE_ID_DEPTH_STENCIL_FORMAT_MISMATCH_PIPELINE_STATE + 1 ) , - D3D12_MESSAGE_ID_RENDER_TARGET_NUMBER_MISMATCH_BUNDLE_PIPELINE_STATE = ( D3D12_MESSAGE_ID_DEPTH_STENCIL_SAMPLE_DESC_MISMATCH_PIPELINE_STATE + 1 ) , - D3D12_MESSAGE_ID_RENDER_TARGET_FORMAT_MISMATCH_BUNDLE_PIPELINE_STATE = ( D3D12_MESSAGE_ID_RENDER_TARGET_NUMBER_MISMATCH_BUNDLE_PIPELINE_STATE + 1 ) , - D3D12_MESSAGE_ID_RENDER_TARGET_SAMPLE_DESC_MISMATCH_BUNDLE_PIPELINE_STATE = ( D3D12_MESSAGE_ID_RENDER_TARGET_FORMAT_MISMATCH_BUNDLE_PIPELINE_STATE + 1 ) , - D3D12_MESSAGE_ID_DEPTH_STENCIL_FORMAT_MISMATCH_BUNDLE_PIPELINE_STATE = ( D3D12_MESSAGE_ID_RENDER_TARGET_SAMPLE_DESC_MISMATCH_BUNDLE_PIPELINE_STATE + 1 ) , - D3D12_MESSAGE_ID_DEPTH_STENCIL_SAMPLE_DESC_MISMATCH_BUNDLE_PIPELINE_STATE = ( D3D12_MESSAGE_ID_DEPTH_STENCIL_FORMAT_MISMATCH_BUNDLE_PIPELINE_STATE + 1 ) , - D3D12_MESSAGE_ID_CREATESHADER_INVALIDBYTECODE = ( D3D12_MESSAGE_ID_DEPTH_STENCIL_SAMPLE_DESC_MISMATCH_BUNDLE_PIPELINE_STATE + 1 ) , - D3D12_MESSAGE_ID_CREATEHEAP_NULLDESC = ( D3D12_MESSAGE_ID_CREATESHADER_INVALIDBYTECODE + 1 ) , - D3D12_MESSAGE_ID_CREATEHEAP_INVALIDSIZE = ( D3D12_MESSAGE_ID_CREATEHEAP_NULLDESC + 1 ) , - D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDHEAPTYPE = ( D3D12_MESSAGE_ID_CREATEHEAP_INVALIDSIZE + 1 ) , - D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDCPUPAGEPROPERTIES = ( D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDHEAPTYPE + 1 ) , - D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDMEMORYPOOL = ( D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDCPUPAGEPROPERTIES + 1 ) , - D3D12_MESSAGE_ID_CREATEHEAP_INVALIDPROPERTIES = ( D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDMEMORYPOOL + 1 ) , - D3D12_MESSAGE_ID_CREATEHEAP_INVALIDALIGNMENT = ( D3D12_MESSAGE_ID_CREATEHEAP_INVALIDPROPERTIES + 1 ) , - D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDMISCFLAGS = ( D3D12_MESSAGE_ID_CREATEHEAP_INVALIDALIGNMENT + 1 ) , - D3D12_MESSAGE_ID_CREATEHEAP_INVALIDMISCFLAGS = ( D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDMISCFLAGS + 1 ) , - D3D12_MESSAGE_ID_CREATEHEAP_INVALIDARG_RETURN = ( D3D12_MESSAGE_ID_CREATEHEAP_INVALIDMISCFLAGS + 1 ) , - D3D12_MESSAGE_ID_CREATEHEAP_OUTOFMEMORY_RETURN = ( D3D12_MESSAGE_ID_CREATEHEAP_INVALIDARG_RETURN + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLHEAPPROPERTIES = ( D3D12_MESSAGE_ID_CREATEHEAP_OUTOFMEMORY_RETURN + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDHEAPTYPE = ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLHEAPPROPERTIES + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDCPUPAGEPROPERTIES = ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDHEAPTYPE + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDMEMORYPOOL = ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDCPUPAGEPROPERTIES + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDHEAPPROPERTIES = ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDMEMORYPOOL + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDHEAPMISCFLAGS = ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDHEAPPROPERTIES + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDHEAPMISCFLAGS = ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDHEAPMISCFLAGS + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDARG_RETURN = ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDHEAPMISCFLAGS + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_OUTOFMEMORY_RETURN = ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDARG_RETURN + 1 ) , - D3D12_MESSAGE_ID_GETCUSTOMHEAPPROPERTIES_UNRECOGNIZEDHEAPTYPE = ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_OUTOFMEMORY_RETURN + 1 ) , - D3D12_MESSAGE_ID_GETCUSTOMHEAPPROPERTIES_INVALIDHEAPTYPE = ( D3D12_MESSAGE_ID_GETCUSTOMHEAPPROPERTIES_UNRECOGNIZEDHEAPTYPE + 1 ) , - D3D12_MESSAGE_ID_CREATE_DESCRIPTOR_HEAP_INVALID_DESC = ( D3D12_MESSAGE_ID_GETCUSTOMHEAPPROPERTIES_INVALIDHEAPTYPE + 1 ) , - D3D12_MESSAGE_ID_INVALID_DESCRIPTOR_HANDLE = ( D3D12_MESSAGE_ID_CREATE_DESCRIPTOR_HEAP_INVALID_DESC + 1 ) , - D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALID_CONSERVATIVERASTERMODE = ( D3D12_MESSAGE_ID_INVALID_DESCRIPTOR_HANDLE + 1 ) , - D3D12_MESSAGE_ID_DEVICE_DRAW_INVALID_SYSTEMVALUE = ( D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALID_CONSERVATIVERASTERMODE + 1 ) , - D3D12_MESSAGE_ID_CREATE_CONSTANT_BUFFER_VIEW_INVALID_RESOURCE = ( D3D12_MESSAGE_ID_DEVICE_DRAW_INVALID_SYSTEMVALUE + 1 ) , - D3D12_MESSAGE_ID_CREATE_CONSTANT_BUFFER_VIEW_INVALID_DESC = ( D3D12_MESSAGE_ID_CREATE_CONSTANT_BUFFER_VIEW_INVALID_RESOURCE + 1 ) , - D3D12_MESSAGE_ID_CREATE_CONSTANT_BUFFER_VIEW_LARGE_OFFSET = ( D3D12_MESSAGE_ID_CREATE_CONSTANT_BUFFER_VIEW_INVALID_DESC + 1 ) , - D3D12_MESSAGE_ID_CREATE_UNORDEREDACCESS_VIEW_INVALID_COUNTER_USAGE = ( D3D12_MESSAGE_ID_CREATE_CONSTANT_BUFFER_VIEW_LARGE_OFFSET + 1 ) , - D3D12_MESSAGE_ID_COPY_DESCRIPTORS_INVALID_RANGES = ( D3D12_MESSAGE_ID_CREATE_UNORDEREDACCESS_VIEW_INVALID_COUNTER_USAGE + 1 ) , - D3D12_MESSAGE_ID_COPY_DESCRIPTORS_WRITE_ONLY_DESCRIPTOR = ( D3D12_MESSAGE_ID_COPY_DESCRIPTORS_INVALID_RANGES + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RTV_FORMAT_NOT_UNKNOWN = ( D3D12_MESSAGE_ID_COPY_DESCRIPTORS_WRITE_ONLY_DESCRIPTOR + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_RENDER_TARGET_COUNT = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RTV_FORMAT_NOT_UNKNOWN + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_VERTEX_SHADER_NOT_SET = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_RENDER_TARGET_COUNT + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INPUTLAYOUT_NOT_SET = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_VERTEX_SHADER_NOT_SET + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_HS_DS_SIGNATURE_MISMATCH = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INPUTLAYOUT_NOT_SET + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_REGISTERINDEX = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_HS_DS_SIGNATURE_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_COMPONENTTYPE = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_REGISTERINDEX + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_REGISTERMASK = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_COMPONENTTYPE + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_SYSTEMVALUE = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_REGISTERMASK + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_NEVERWRITTEN_ALWAYSREADS = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_SYSTEMVALUE + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_MINPRECISION = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_NEVERWRITTEN_ALWAYSREADS + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_SEMANTICNAME_NOT_FOUND = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_MINPRECISION + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_XOR_DS_MISMATCH = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_SEMANTICNAME_NOT_FOUND + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HULL_SHADER_INPUT_TOPOLOGY_MISMATCH = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_XOR_DS_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_DS_CONTROL_POINT_COUNT_MISMATCH = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HULL_SHADER_INPUT_TOPOLOGY_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_DS_TESSELLATOR_DOMAIN_MISMATCH = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_DS_CONTROL_POINT_COUNT_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_USE_OF_CENTER_MULTISAMPLE_PATTERN = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_DS_TESSELLATOR_DOMAIN_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_USE_OF_FORCED_SAMPLE_COUNT = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_USE_OF_CENTER_MULTISAMPLE_PATTERN + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_PRIMITIVETOPOLOGY = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_USE_OF_FORCED_SAMPLE_COUNT + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_SYSTEMVALUE = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_PRIMITIVETOPOLOGY + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_DUAL_SOURCE_BLENDING_CAN_ONLY_HAVE_RENDER_TARGET_0 = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_SYSTEMVALUE + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_RENDER_TARGET_DOES_NOT_SUPPORT_BLENDING = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_DUAL_SOURCE_BLENDING_CAN_ONLY_HAVE_RENDER_TARGET_0 + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_OUTPUT_TYPE_MISMATCH = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_RENDER_TARGET_DOES_NOT_SUPPORT_BLENDING + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_RENDER_TARGET_DOES_NOT_SUPPORT_LOGIC_OPS = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_OUTPUT_TYPE_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RENDERTARGETVIEW_NOT_SET = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_RENDER_TARGET_DOES_NOT_SUPPORT_LOGIC_OPS + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_DEPTHSTENCILVIEW_NOT_SET = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RENDERTARGETVIEW_NOT_SET + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_GS_INPUT_PRIMITIVE_MISMATCH = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_DEPTHSTENCILVIEW_NOT_SET + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_POSITION_NOT_PRESENT = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_GS_INPUT_PRIMITIVE_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MISSING_ROOT_SIGNATURE_FLAGS = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_POSITION_NOT_PRESENT + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_INDEX_BUFFER_PROPERTIES = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MISSING_ROOT_SIGNATURE_FLAGS + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_SAMPLE_DESC = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_INDEX_BUFFER_PROPERTIES + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_ROOT_SIGNATURE_MISMATCH = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_SAMPLE_DESC + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_DS_ROOT_SIGNATURE_MISMATCH = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_ROOT_SIGNATURE_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_VS_ROOT_SIGNATURE_MISMATCH = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_DS_ROOT_SIGNATURE_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_GS_ROOT_SIGNATURE_MISMATCH = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_VS_ROOT_SIGNATURE_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_ROOT_SIGNATURE_MISMATCH = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_GS_ROOT_SIGNATURE_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MISSING_ROOT_SIGNATURE = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_ROOT_SIGNATURE_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_EXECUTE_BUNDLE_OPEN_BUNDLE = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MISSING_ROOT_SIGNATURE + 1 ) , - D3D12_MESSAGE_ID_EXECUTE_BUNDLE_DESCRIPTOR_HEAP_MISMATCH = ( D3D12_MESSAGE_ID_EXECUTE_BUNDLE_OPEN_BUNDLE + 1 ) , - D3D12_MESSAGE_ID_EXECUTE_BUNDLE_TYPE = ( D3D12_MESSAGE_ID_EXECUTE_BUNDLE_DESCRIPTOR_HEAP_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_DRAW_EMPTY_SCISSOR_RECTANGLE = ( D3D12_MESSAGE_ID_EXECUTE_BUNDLE_TYPE + 1 ) , - D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_BLOB_NOT_FOUND = ( D3D12_MESSAGE_ID_DRAW_EMPTY_SCISSOR_RECTANGLE + 1 ) , - D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_DESERIALIZE_FAILED = ( D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_BLOB_NOT_FOUND + 1 ) , - D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_INVALID_CONFIGURATION = ( D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_DESERIALIZE_FAILED + 1 ) , - D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_NOT_SUPPORTED_ON_DEVICE = ( D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_INVALID_CONFIGURATION + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLRESOURCEPROPERTIES = ( D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_NOT_SUPPORTED_ON_DEVICE + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLHEAP = ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLRESOURCEPROPERTIES + 1 ) , - D3D12_MESSAGE_ID_GETRESOURCEALLOCATIONINFO_INVALIDRDESCS = ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLHEAP + 1 ) , - D3D12_MESSAGE_ID_MAKERESIDENT_NULLOBJECTARRAY = ( D3D12_MESSAGE_ID_GETRESOURCEALLOCATIONINFO_INVALIDRDESCS + 1 ) , - D3D12_MESSAGE_ID_MAKERESIDENT_INVALIDOBJECT = ( D3D12_MESSAGE_ID_MAKERESIDENT_NULLOBJECTARRAY + 1 ) , - D3D12_MESSAGE_ID_EVICT_NULLOBJECTARRAY = ( D3D12_MESSAGE_ID_MAKERESIDENT_INVALIDOBJECT + 1 ) , - D3D12_MESSAGE_ID_EVICT_INVALIDOBJECT = ( D3D12_MESSAGE_ID_EVICT_NULLOBJECTARRAY + 1 ) , - D3D12_MESSAGE_ID_HEAPS_UNSUPPORTED = ( D3D12_MESSAGE_ID_EVICT_INVALIDOBJECT + 1 ) , - D3D12_MESSAGE_ID_SET_DESCRIPTOR_TABLE_INVALID = ( D3D12_MESSAGE_ID_HEAPS_UNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_SET_ROOT_CONSTANT_INVALID = ( D3D12_MESSAGE_ID_SET_DESCRIPTOR_TABLE_INVALID + 1 ) , - D3D12_MESSAGE_ID_SET_ROOT_CONSTANT_BUFFER_VIEW_INVALID = ( D3D12_MESSAGE_ID_SET_ROOT_CONSTANT_INVALID + 1 ) , - D3D12_MESSAGE_ID_SET_ROOT_SHADER_RESOURCE_VIEW_INVALID = ( D3D12_MESSAGE_ID_SET_ROOT_CONSTANT_BUFFER_VIEW_INVALID + 1 ) , - D3D12_MESSAGE_ID_SET_ROOT_UNORDERED_ACCESS_VIEW_INVALID = ( D3D12_MESSAGE_ID_SET_ROOT_SHADER_RESOURCE_VIEW_INVALID + 1 ) , - D3D12_MESSAGE_ID_SET_VERTEX_BUFFERS_INVALID_DESC = ( D3D12_MESSAGE_ID_SET_ROOT_UNORDERED_ACCESS_VIEW_INVALID + 1 ) , - D3D12_MESSAGE_ID_SET_VERTEX_BUFFERS_LARGE_OFFSET = ( D3D12_MESSAGE_ID_SET_VERTEX_BUFFERS_INVALID_DESC + 1 ) , - D3D12_MESSAGE_ID_SET_INDEX_BUFFER_INVALID_DESC = ( D3D12_MESSAGE_ID_SET_VERTEX_BUFFERS_LARGE_OFFSET + 1 ) , - D3D12_MESSAGE_ID_SET_INDEX_BUFFER_LARGE_OFFSET = ( D3D12_MESSAGE_ID_SET_INDEX_BUFFER_INVALID_DESC + 1 ) , - D3D12_MESSAGE_ID_SET_STREAM_OUTPUT_BUFFERS_INVALID_DESC = ( D3D12_MESSAGE_ID_SET_INDEX_BUFFER_LARGE_OFFSET + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDDIMENSIONALITY = ( D3D12_MESSAGE_ID_SET_STREAM_OUTPUT_BUFFERS_INVALID_DESC + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDLAYOUT = ( D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDDIMENSIONALITY + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDIMENSIONALITY = ( D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDLAYOUT + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDALIGNMENT = ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDIMENSIONALITY + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDMIPLEVELS = ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDALIGNMENT + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDSAMPLEDESC = ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDMIPLEVELS + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDLAYOUT = ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDSAMPLEDESC + 1 ) , - D3D12_MESSAGE_ID_SET_INDEX_BUFFER_INVALID = ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDLAYOUT + 1 ) , - D3D12_MESSAGE_ID_SET_VERTEX_BUFFERS_INVALID = ( D3D12_MESSAGE_ID_SET_INDEX_BUFFER_INVALID + 1 ) , - D3D12_MESSAGE_ID_SET_STREAM_OUTPUT_BUFFERS_INVALID = ( D3D12_MESSAGE_ID_SET_VERTEX_BUFFERS_INVALID + 1 ) , - D3D12_MESSAGE_ID_SET_RENDER_TARGETS_INVALID = ( D3D12_MESSAGE_ID_SET_STREAM_OUTPUT_BUFFERS_INVALID + 1 ) , - D3D12_MESSAGE_ID_CREATEQUERY_HEAP_INVALID_PARAMETERS = ( D3D12_MESSAGE_ID_SET_RENDER_TARGETS_INVALID + 1 ) , - D3D12_MESSAGE_ID_CREATEQUERY_HEAP_JPEG_NOT_SUPPORTED = ( D3D12_MESSAGE_ID_CREATEQUERY_HEAP_INVALID_PARAMETERS + 1 ) , - D3D12_MESSAGE_ID_BEGIN_END_QUERY_INVALID_PARAMETERS = ( D3D12_MESSAGE_ID_CREATEQUERY_HEAP_JPEG_NOT_SUPPORTED + 1 ) , - D3D12_MESSAGE_ID_CLOSE_COMMAND_LIST_OPEN_QUERY = ( D3D12_MESSAGE_ID_BEGIN_END_QUERY_INVALID_PARAMETERS + 1 ) , - D3D12_MESSAGE_ID_RESOLVE_QUERY_DATA_INVALID_PARAMETERS = ( D3D12_MESSAGE_ID_CLOSE_COMMAND_LIST_OPEN_QUERY + 1 ) , - D3D12_MESSAGE_ID_SET_PREDICATION_INVALID_PARAMETERS = ( D3D12_MESSAGE_ID_RESOLVE_QUERY_DATA_INVALID_PARAMETERS + 1 ) , - D3D12_MESSAGE_ID_TIMESTAMPS_NOT_SUPPORTED = ( D3D12_MESSAGE_ID_SET_PREDICATION_INVALID_PARAMETERS + 1 ) , - D3D12_MESSAGE_ID_UNSTABLE_POWER_STATE = ( D3D12_MESSAGE_ID_TIMESTAMPS_NOT_SUPPORTED + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDFORMAT = ( D3D12_MESSAGE_ID_UNSTABLE_POWER_STATE + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDFORMAT = ( D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDFORMAT + 1 ) , - D3D12_MESSAGE_ID_GETCOPYABLELAYOUT_INVALIDSUBRESOURCERANGE = ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDFORMAT + 1 ) , - D3D12_MESSAGE_ID_GETCOPYABLELAYOUT_INVALIDBASEOFFSET = ( D3D12_MESSAGE_ID_GETCOPYABLELAYOUT_INVALIDSUBRESOURCERANGE + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_HEAP = ( D3D12_MESSAGE_ID_GETCOPYABLELAYOUT_INVALIDBASEOFFSET + 1 ) , - D3D12_MESSAGE_ID_CREATE_SAMPLER_INVALID = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_HEAP + 1 ) , - D3D12_MESSAGE_ID_CREATECOMMANDSIGNATURE_INVALID = ( D3D12_MESSAGE_ID_CREATE_SAMPLER_INVALID + 1 ) , - D3D12_MESSAGE_ID_EXECUTE_INDIRECT_INVALID_PARAMETERS = ( D3D12_MESSAGE_ID_CREATECOMMANDSIGNATURE_INVALID + 1 ) , - D3D12_MESSAGE_ID_GETGPUVIRTUALADDRESS_INVALID_RESOURCE_DIMENSION = ( D3D12_MESSAGE_ID_EXECUTE_INDIRECT_INVALID_PARAMETERS + 1 ) , - D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDPLANEINDEX = ( D3D12_MESSAGE_ID_GETGPUVIRTUALADDRESS_INVALID_RESOURCE_DIMENSION + 4 ) , - D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDVIDEOPLANEINDEX = ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDPLANEINDEX + 1 ) , - D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_AMBIGUOUSVIDEOPLANEINDEX = ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDVIDEOPLANEINDEX + 1 ) , - D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDPLANEINDEX = ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_AMBIGUOUSVIDEOPLANEINDEX + 1 ) , - D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDVIDEOPLANEINDEX = ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDPLANEINDEX + 1 ) , - D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_AMBIGUOUSVIDEOPLANEINDEX = ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDVIDEOPLANEINDEX + 1 ) , - D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDPLANEINDEX = ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_AMBIGUOUSVIDEOPLANEINDEX + 1 ) , - D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDVIDEOPLANEINDEX = ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDPLANEINDEX + 1 ) , - D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_AMBIGUOUSVIDEOPLANEINDEX = ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDVIDEOPLANEINDEX + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_INVALIDSCANDATAOFFSET = ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_AMBIGUOUSVIDEOPLANEINDEX + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_NOTSUPPORTED = ( D3D12_MESSAGE_ID_JPEGDECODE_INVALIDSCANDATAOFFSET + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_DIMENSIONSTOOLARGE = ( D3D12_MESSAGE_ID_JPEGDECODE_NOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_INVALIDCOMPONENTS = ( D3D12_MESSAGE_ID_JPEGDECODE_DIMENSIONSTOOLARGE + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDCOMPONENTS = ( D3D12_MESSAGE_ID_JPEGDECODE_INVALIDCOMPONENTS + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_DESTINATIONNOT2D = ( D3D12_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDCOMPONENTS + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_TILEDRESOURCESUNSUPPORTED = ( D3D12_MESSAGE_ID_JPEGDECODE_DESTINATIONNOT2D + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_GUARDRECTSUNSUPPORTED = ( D3D12_MESSAGE_ID_JPEGDECODE_TILEDRESOURCESUNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_FORMATUNSUPPORTED = ( D3D12_MESSAGE_ID_JPEGDECODE_GUARDRECTSUNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_INVALIDSUBRESOURCE = ( D3D12_MESSAGE_ID_JPEGDECODE_FORMATUNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_INVALIDMIPLEVEL = ( D3D12_MESSAGE_ID_JPEGDECODE_INVALIDSUBRESOURCE + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_EMPTYDESTBOX = ( D3D12_MESSAGE_ID_JPEGDECODE_INVALIDMIPLEVEL + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_DESTBOXNOT2D = ( D3D12_MESSAGE_ID_JPEGDECODE_EMPTYDESTBOX + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_DESTBOXNOTSUB = ( D3D12_MESSAGE_ID_JPEGDECODE_DESTBOXNOT2D + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_DESTBOXESINTERSECT = ( D3D12_MESSAGE_ID_JPEGDECODE_DESTBOXNOTSUB + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_XSUBSAMPLEMISMATCH = ( D3D12_MESSAGE_ID_JPEGDECODE_DESTBOXESINTERSECT + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_YSUBSAMPLEMISMATCH = ( D3D12_MESSAGE_ID_JPEGDECODE_XSUBSAMPLEMISMATCH + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_XSUBSAMPLEODD = ( D3D12_MESSAGE_ID_JPEGDECODE_YSUBSAMPLEMISMATCH + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_YSUBSAMPLEODD = ( D3D12_MESSAGE_ID_JPEGDECODE_XSUBSAMPLEODD + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_UPSCALEUNSUPPORTED = ( D3D12_MESSAGE_ID_JPEGDECODE_YSUBSAMPLEODD + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_TIER4DOWNSCALETOLARGE = ( D3D12_MESSAGE_ID_JPEGDECODE_UPSCALEUNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_TIER3DOWNSCALEUNSUPPORTED = ( D3D12_MESSAGE_ID_JPEGDECODE_TIER4DOWNSCALETOLARGE + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_CHROMASIZEMISMATCH = ( D3D12_MESSAGE_ID_JPEGDECODE_TIER3DOWNSCALEUNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_LUMACHROMASIZEMISMATCH = ( D3D12_MESSAGE_ID_JPEGDECODE_CHROMASIZEMISMATCH + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_INVALIDNUMDESTINATIONS = ( D3D12_MESSAGE_ID_JPEGDECODE_LUMACHROMASIZEMISMATCH + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_SUBBOXUNSUPPORTED = ( D3D12_MESSAGE_ID_JPEGDECODE_INVALIDNUMDESTINATIONS + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_1DESTUNSUPPORTEDFORMAT = ( D3D12_MESSAGE_ID_JPEGDECODE_SUBBOXUNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_3DESTUNSUPPORTEDFORMAT = ( D3D12_MESSAGE_ID_JPEGDECODE_1DESTUNSUPPORTEDFORMAT + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_SCALEUNSUPPORTED = ( D3D12_MESSAGE_ID_JPEGDECODE_3DESTUNSUPPORTEDFORMAT + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_INVALIDSOURCESIZE = ( D3D12_MESSAGE_ID_JPEGDECODE_SCALEUNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_INVALIDCOPYFLAGS = ( D3D12_MESSAGE_ID_JPEGDECODE_INVALIDSOURCESIZE + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_HAZARD = ( D3D12_MESSAGE_ID_JPEGDECODE_INVALIDCOPYFLAGS + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDSRCBUFFERUSAGE = ( D3D12_MESSAGE_ID_JPEGDECODE_HAZARD + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDSRCBUFFERMISCFLAGS = ( D3D12_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDSRCBUFFERUSAGE + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDDSTTEXTUREUSAGE = ( D3D12_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDSRCBUFFERMISCFLAGS + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_BACKBUFFERNOTSUPPORTED = ( D3D12_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDDSTTEXTUREUSAGE + 1 ) , - D3D12_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDCOPYFLAGS = ( D3D12_MESSAGE_ID_JPEGDECODE_BACKBUFFERNOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_JPEGENCODE_NOTSUPPORTED = ( D3D12_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDCOPYFLAGS + 1 ) , - D3D12_MESSAGE_ID_JPEGENCODE_INVALIDSCANDATAOFFSET = ( D3D12_MESSAGE_ID_JPEGENCODE_NOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_JPEGENCODE_INVALIDCOMPONENTS = ( D3D12_MESSAGE_ID_JPEGENCODE_INVALIDSCANDATAOFFSET + 1 ) , - D3D12_MESSAGE_ID_JPEGENCODE_SOURCENOT2D = ( D3D12_MESSAGE_ID_JPEGENCODE_INVALIDCOMPONENTS + 1 ) , - D3D12_MESSAGE_ID_JPEGENCODE_TILEDRESOURCESUNSUPPORTED = ( D3D12_MESSAGE_ID_JPEGENCODE_SOURCENOT2D + 1 ) , - D3D12_MESSAGE_ID_JPEGENCODE_GUARDRECTSUNSUPPORTED = ( D3D12_MESSAGE_ID_JPEGENCODE_TILEDRESOURCESUNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_JPEGENCODE_XSUBSAMPLEMISMATCH = ( D3D12_MESSAGE_ID_JPEGENCODE_GUARDRECTSUNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_JPEGENCODE_YSUBSAMPLEMISMATCH = ( D3D12_MESSAGE_ID_JPEGENCODE_XSUBSAMPLEMISMATCH + 1 ) , - D3D12_MESSAGE_ID_JPEGENCODE_UNSUPPORTEDCOMPONENTS = ( D3D12_MESSAGE_ID_JPEGENCODE_YSUBSAMPLEMISMATCH + 1 ) , - D3D12_MESSAGE_ID_JPEGENCODE_FORMATUNSUPPORTED = ( D3D12_MESSAGE_ID_JPEGENCODE_UNSUPPORTEDCOMPONENTS + 1 ) , - D3D12_MESSAGE_ID_JPEGENCODE_INVALIDSUBRESOURCE = ( D3D12_MESSAGE_ID_JPEGENCODE_FORMATUNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_JPEGENCODE_INVALIDMIPLEVEL = ( D3D12_MESSAGE_ID_JPEGENCODE_INVALIDSUBRESOURCE + 1 ) , - D3D12_MESSAGE_ID_JPEGENCODE_DIMENSIONSTOOLARGE = ( D3D12_MESSAGE_ID_JPEGENCODE_INVALIDMIPLEVEL + 1 ) , - D3D12_MESSAGE_ID_JPEGENCODE_HAZARD = ( D3D12_MESSAGE_ID_JPEGENCODE_DIMENSIONSTOOLARGE + 1 ) , - D3D12_MESSAGE_ID_JPEGENCODE_UNSUPPORTEDDSTBUFFERUSAGE = ( D3D12_MESSAGE_ID_JPEGENCODE_HAZARD + 1 ) , - D3D12_MESSAGE_ID_JPEGENCODE_UNSUPPORTEDDSTBUFFERMISCFLAGS = ( D3D12_MESSAGE_ID_JPEGENCODE_UNSUPPORTEDDSTBUFFERUSAGE + 1 ) , - D3D12_MESSAGE_ID_JPEGENCODE_UNSUPPORTEDSRCTEXTUREUSAGE = ( D3D12_MESSAGE_ID_JPEGENCODE_UNSUPPORTEDDSTBUFFERMISCFLAGS + 1 ) , - D3D12_MESSAGE_ID_JPEGENCODE_BACKBUFFERNOTSUPPORTED = ( D3D12_MESSAGE_ID_JPEGENCODE_UNSUPPORTEDSRCTEXTUREUSAGE + 1 ) , - D3D12_MESSAGE_ID_CREATEQUERYORPREDICATE_UNSUPPORTEDCONTEXTTYPEFORQUERY = ( D3D12_MESSAGE_ID_JPEGENCODE_BACKBUFFERNOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_FLUSH1_INVALIDCONTEXTTYPE = ( D3D12_MESSAGE_ID_CREATEQUERYORPREDICATE_UNSUPPORTEDCONTEXTTYPEFORQUERY + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDCLEARVALUE = ( D3D12_MESSAGE_ID_FLUSH1_INVALIDCONTEXTTYPE + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDCLEARVALUEFORMAT = ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDCLEARVALUE + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDCLEARVALUEFORMAT = ( D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDCLEARVALUEFORMAT + 1 ) , - D3D12_MESSAGE_ID_CREATERESOURCE_CLEARVALUEDENORMFLUSH = ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDCLEARVALUEFORMAT + 1 ) , - D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_INVALIDDEPTH = ( D3D12_MESSAGE_ID_CREATERESOURCE_CLEARVALUEDENORMFLUSH + 1 ) , - D3D12_MESSAGE_ID_CLEARRENDERTARGETVIEW_MISMATCHINGCLEARVALUE = ( D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_INVALIDDEPTH + 1 ) , - D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_MISMATCHINGCLEARVALUE = ( D3D12_MESSAGE_ID_CLEARRENDERTARGETVIEW_MISMATCHINGCLEARVALUE + 1 ) , - D3D12_MESSAGE_ID_MAP_INVALIDHEAP = ( D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_MISMATCHINGCLEARVALUE + 1 ) , - D3D12_MESSAGE_ID_UNMAP_INVALIDHEAP = ( D3D12_MESSAGE_ID_MAP_INVALIDHEAP + 1 ) , - D3D12_MESSAGE_ID_MAP_INVALIDRESOURCE = ( D3D12_MESSAGE_ID_UNMAP_INVALIDHEAP + 1 ) , - D3D12_MESSAGE_ID_UNMAP_INVALIDRESOURCE = ( D3D12_MESSAGE_ID_MAP_INVALIDRESOURCE + 1 ) , - D3D12_MESSAGE_ID_MAP_INVALIDSUBRESOURCE = ( D3D12_MESSAGE_ID_UNMAP_INVALIDRESOURCE + 1 ) , - D3D12_MESSAGE_ID_UNMAP_INVALIDSUBRESOURCE = ( D3D12_MESSAGE_ID_MAP_INVALIDSUBRESOURCE + 1 ) , - D3D12_MESSAGE_ID_MAP_INVALIDRANGE = ( D3D12_MESSAGE_ID_UNMAP_INVALIDSUBRESOURCE + 1 ) , - D3D12_MESSAGE_ID_UNMAP_INVALIDRANGE = ( D3D12_MESSAGE_ID_MAP_INVALIDRANGE + 1 ) , - D3D12_MESSAGE_ID_MAP_NULLRANGE = ( D3D12_MESSAGE_ID_UNMAP_INVALIDRANGE + 1 ) , - D3D12_MESSAGE_ID_UNMAP_NULLRANGE = ( D3D12_MESSAGE_ID_MAP_NULLRANGE + 1 ) , - D3D12_MESSAGE_ID_MAP_INVALIDDATAPOINTER = ( D3D12_MESSAGE_ID_UNMAP_NULLRANGE + 1 ) , - D3D12_MESSAGE_ID_MAP_INVALIDARG_RETURN = ( D3D12_MESSAGE_ID_MAP_INVALIDDATAPOINTER + 1 ) , - D3D12_MESSAGE_ID_MAP_OUTOFMEMORY_RETURN = ( D3D12_MESSAGE_ID_MAP_INVALIDARG_RETURN + 1 ) , - D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_BUNDLENOTSUPPORTED = ( D3D12_MESSAGE_ID_MAP_OUTOFMEMORY_RETURN + 1 ) , - D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_COMMANDLISTMISMATCH = ( D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_BUNDLENOTSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_OPENCOMMANDLIST = ( D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_COMMANDLISTMISMATCH + 1 ) , - D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_FAILEDCOMMANDLIST = ( D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_OPENCOMMANDLIST + 1 ) , - D3D12_MESSAGE_ID_COPYBUFFERREGION_NULLDST = ( D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_FAILEDCOMMANDLIST + 1 ) , - D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDDSTRESOURCEDIMENSION = ( D3D12_MESSAGE_ID_COPYBUFFERREGION_NULLDST + 1 ) , - D3D12_MESSAGE_ID_COPYBUFFERREGION_DSTRANGEOUTOFBOUNDS = ( D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDDSTRESOURCEDIMENSION + 1 ) , - D3D12_MESSAGE_ID_COPYBUFFERREGION_NULLSRC = ( D3D12_MESSAGE_ID_COPYBUFFERREGION_DSTRANGEOUTOFBOUNDS + 1 ) , - D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDSRCRESOURCEDIMENSION = ( D3D12_MESSAGE_ID_COPYBUFFERREGION_NULLSRC + 1 ) , - D3D12_MESSAGE_ID_COPYBUFFERREGION_SRCRANGEOUTOFBOUNDS = ( D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDSRCRESOURCEDIMENSION + 1 ) , - D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDCOPYFLAGS = ( D3D12_MESSAGE_ID_COPYBUFFERREGION_SRCRANGEOUTOFBOUNDS + 1 ) , - D3D12_MESSAGE_ID_COPYTEXTUREREGION_NULLDST = ( D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDCOPYFLAGS + 1 ) , - D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDDSTTYPE = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_NULLDST + 1 ) , - D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTRESOURCEDIMENSION = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDDSTTYPE + 1 ) , - D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTRESOURCE = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTRESOURCEDIMENSION + 1 ) , - D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTSUBRESOURCE = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTRESOURCE + 1 ) , - D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTOFFSET = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTSUBRESOURCE + 1 ) , - D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDDSTFORMAT = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTOFFSET + 1 ) , - D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTFORMAT = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDDSTFORMAT + 1 ) , - D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTDIMENSIONS = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTFORMAT + 1 ) , - D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTROWPITCH = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTDIMENSIONS + 1 ) , - D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTPLACEMENT = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTROWPITCH + 1 ) , - D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTDSPLACEDFOOTPRINTFORMAT = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTPLACEMENT + 1 ) , - D3D12_MESSAGE_ID_COPYTEXTUREREGION_DSTREGIONOUTOFBOUNDS = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTDSPLACEDFOOTPRINTFORMAT + 1 ) , - D3D12_MESSAGE_ID_COPYTEXTUREREGION_NULLSRC = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_DSTREGIONOUTOFBOUNDS + 1 ) , - D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDSRCTYPE = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_NULLSRC + 1 ) , - D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCRESOURCEDIMENSION = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDSRCTYPE + 1 ) , - D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCRESOURCE = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCRESOURCEDIMENSION + 1 ) , - D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCSUBRESOURCE = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCRESOURCE + 1 ) , - D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCOFFSET = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCSUBRESOURCE + 1 ) , - D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDSRCFORMAT = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCOFFSET + 1 ) , - D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCFORMAT = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDSRCFORMAT + 1 ) , - D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCDIMENSIONS = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCFORMAT + 1 ) , - D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCROWPITCH = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCDIMENSIONS + 1 ) , - D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCPLACEMENT = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCROWPITCH + 1 ) , - D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCDSPLACEDFOOTPRINTFORMAT = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCPLACEMENT + 1 ) , - D3D12_MESSAGE_ID_COPYTEXTUREREGION_SRCREGIONOUTOFBOUNDS = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCDSPLACEDFOOTPRINTFORMAT + 1 ) , - D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTCOORDINATES = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_SRCREGIONOUTOFBOUNDS + 1 ) , - D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCBOX = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTCOORDINATES + 1 ) , - D3D12_MESSAGE_ID_COPYTEXTUREREGION_FORMATMISMATCH = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCBOX + 1 ) , - D3D12_MESSAGE_ID_COPYTEXTUREREGION_EMPTYBOX = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_FORMATMISMATCH + 1 ) , - D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDCOPYFLAGS = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_EMPTYBOX + 1 ) , - D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_SUBRESOURCE_INDEX = ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDCOPYFLAGS + 1 ) , - D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_FORMAT = ( D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_SUBRESOURCE_INDEX + 1 ) , - D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_RESOURCE_MISMATCH = ( D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_FORMAT + 1 ) , - D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_SAMPLE_COUNT = ( D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_RESOURCE_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_INVALID_SHADER = ( D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_SAMPLE_COUNT + 1 ) , - D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_CS_ROOT_SIGNATURE_MISMATCH = ( D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_INVALID_SHADER + 1 ) , - D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_MISSING_ROOT_SIGNATURE = ( D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_CS_ROOT_SIGNATURE_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALIDCACHEDBLOB = ( D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_MISSING_ROOT_SIGNATURE + 1 ) , - D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBADAPTERMISMATCH = ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALIDCACHEDBLOB + 1 ) , - D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBDRIVERVERSIONMISMATCH = ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBADAPTERMISMATCH + 1 ) , - D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBDESCMISMATCH = ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBDRIVERVERSIONMISMATCH + 1 ) , - D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBIGNORED = ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBDESCMISMATCH + 1 ) , - D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDHEAP = ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBIGNORED + 1 ) , - D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDRESOURCE = ( D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDHEAP + 1 ) , - D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDBOX = ( D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDRESOURCE + 1 ) , - D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDSUBRESOURCE = ( D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDBOX + 1 ) , - D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_EMPTYBOX = ( D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDSUBRESOURCE + 1 ) , - D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDHEAP = ( D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_EMPTYBOX + 1 ) , - D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDRESOURCE = ( D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDHEAP + 1 ) , - D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDBOX = ( D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDRESOURCE + 1 ) , - D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDSUBRESOURCE = ( D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDBOX + 1 ) , - D3D12_MESSAGE_ID_READFROMSUBRESOURCE_EMPTYBOX = ( D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDSUBRESOURCE + 1 ) , - D3D12_MESSAGE_ID_TOO_MANY_NODES_SPECIFIED = ( D3D12_MESSAGE_ID_READFROMSUBRESOURCE_EMPTYBOX + 1 ) , - D3D12_MESSAGE_ID_INVALID_NODE_INDEX = ( D3D12_MESSAGE_ID_TOO_MANY_NODES_SPECIFIED + 1 ) , - D3D12_MESSAGE_ID_GETHEAPPROPERTIES_INVALIDRESOURCE = ( D3D12_MESSAGE_ID_INVALID_NODE_INDEX + 1 ) , - D3D12_MESSAGE_ID_NODE_MASK_MISMATCH = ( D3D12_MESSAGE_ID_GETHEAPPROPERTIES_INVALIDRESOURCE + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_OUTOFMEMORY = ( D3D12_MESSAGE_ID_NODE_MASK_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_MULTIPLE_SWAPCHAIN_BUFFER_REFERENCES = ( D3D12_MESSAGE_ID_COMMAND_LIST_OUTOFMEMORY + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_TOO_MANY_SWAPCHAIN_REFERENCES = ( D3D12_MESSAGE_ID_COMMAND_LIST_MULTIPLE_SWAPCHAIN_BUFFER_REFERENCES + 1 ) , - D3D12_MESSAGE_ID_COMMAND_QUEUE_TOO_MANY_SWAPCHAIN_REFERENCES = ( D3D12_MESSAGE_ID_COMMAND_LIST_TOO_MANY_SWAPCHAIN_REFERENCES + 1 ) , - D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_WRONGSWAPCHAINBUFFERREFERENCE = ( D3D12_MESSAGE_ID_COMMAND_QUEUE_TOO_MANY_SWAPCHAIN_REFERENCES + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_SETRENDERTARGETS_INVALIDNUMRENDERTARGETS = ( D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_WRONGSWAPCHAINBUFFERREFERENCE + 1 ) , - D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_TYPE = ( D3D12_MESSAGE_ID_COMMAND_LIST_SETRENDERTARGETS_INVALIDNUMRENDERTARGETS + 1 ) , - D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_FLAGS = ( D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_TYPE + 1 ) , - D3D12_MESSAGE_ID_CREATESHAREDRESOURCE_INVALIDFLAGS = ( D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_FLAGS + 1 ) , - D3D12_MESSAGE_ID_CREATESHAREDRESOURCE_INVALIDFORMAT = ( D3D12_MESSAGE_ID_CREATESHAREDRESOURCE_INVALIDFLAGS + 1 ) , - D3D12_MESSAGE_ID_CREATESHAREDHEAP_INVALIDFLAGS = ( D3D12_MESSAGE_ID_CREATESHAREDRESOURCE_INVALIDFORMAT + 1 ) , - D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_UNRECOGNIZEDPROPERTIES = ( D3D12_MESSAGE_ID_CREATESHAREDHEAP_INVALIDFLAGS + 1 ) , - D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_INVALIDSIZE = ( D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_UNRECOGNIZEDPROPERTIES + 1 ) , - D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_INVALIDOBJECT = ( D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_INVALIDSIZE + 1 ) , - D3D12_MESSAGE_ID_KEYEDMUTEX_INVALIDOBJECT = ( D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_INVALIDOBJECT + 1 ) , - D3D12_MESSAGE_ID_KEYEDMUTEX_INVALIDKEY = ( D3D12_MESSAGE_ID_KEYEDMUTEX_INVALIDOBJECT + 1 ) , - D3D12_MESSAGE_ID_KEYEDMUTEX_WRONGSTATE = ( D3D12_MESSAGE_ID_KEYEDMUTEX_INVALIDKEY + 1 ) , - D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_PRIORITY = ( D3D12_MESSAGE_ID_KEYEDMUTEX_WRONGSTATE + 1 ) , - D3D12_MESSAGE_ID_OBJECT_DELETED_WHILE_STILL_IN_USE = ( D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_PRIORITY + 1 ) , - D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALID_FLAGS = ( D3D12_MESSAGE_ID_OBJECT_DELETED_WHILE_STILL_IN_USE + 1 ) , - D3D12_MESSAGE_ID_HEAP_ADDRESS_RANGE_HAS_NO_RESOURCE = ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALID_FLAGS + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RENDER_TARGET_DELETED = ( D3D12_MESSAGE_ID_HEAP_ADDRESS_RANGE_HAS_NO_RESOURCE + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_ALL_RENDER_TARGETS_HAVE_UNKNOWN_FORMAT = ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RENDER_TARGET_DELETED + 1 ) , - D3D12_MESSAGE_ID_HEAP_ADDRESS_RANGE_INTERSECTS_MULTIPLE_BUFFERS = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_ALL_RENDER_TARGETS_HAVE_UNKNOWN_FORMAT + 1 ) , - D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_GPU_WRITTEN_READBACK_RESOURCE_MAPPED = ( D3D12_MESSAGE_ID_HEAP_ADDRESS_RANGE_INTERSECTS_MULTIPLE_BUFFERS + 1 ) , - D3D12_MESSAGE_ID_UNMAP_RANGE_NOT_NEEDED = ( D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_GPU_WRITTEN_READBACK_RESOURCE_MAPPED + 1 ) , - D3D12_MESSAGE_ID_UNMAP_RANGE_NOT_EMPTY = ( D3D12_MESSAGE_ID_UNMAP_RANGE_NOT_NEEDED + 1 ) , - D3D12_MESSAGE_ID_MAP_INVALID_NULLRANGE = ( D3D12_MESSAGE_ID_UNMAP_RANGE_NOT_EMPTY + 1 ) , - D3D12_MESSAGE_ID_UNMAP_INVALID_NULLRANGE = ( D3D12_MESSAGE_ID_MAP_INVALID_NULLRANGE + 1 ) , - D3D12_MESSAGE_ID_NO_GRAPHICS_API_SUPPORT = ( D3D12_MESSAGE_ID_UNMAP_INVALID_NULLRANGE + 1 ) , - D3D12_MESSAGE_ID_NO_COMPUTE_API_SUPPORT = ( D3D12_MESSAGE_ID_NO_GRAPHICS_API_SUPPORT + 1 ) , - D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_RESOURCE_FLAGS_NOT_SUPPORTED = ( D3D12_MESSAGE_ID_NO_COMPUTE_API_SUPPORT + 1 ) , - D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_ROOT_ARGUMENT_UNINITIALIZED = ( D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_RESOURCE_FLAGS_NOT_SUPPORTED + 1 ) , - D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_HEAP_INDEX_OUT_OF_BOUNDS = ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_ROOT_ARGUMENT_UNINITIALIZED + 1 ) , - D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_TABLE_REGISTER_INDEX_OUT_OF_BOUNDS = ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_HEAP_INDEX_OUT_OF_BOUNDS + 1 ) , - D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_UNINITIALIZED = ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_TABLE_REGISTER_INDEX_OUT_OF_BOUNDS + 1 ) , - D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_TYPE_MISMATCH = ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_UNINITIALIZED + 1 ) , - D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_SRV_RESOURCE_DIMENSION_MISMATCH = ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_TYPE_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_UAV_RESOURCE_DIMENSION_MISMATCH = ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_SRV_RESOURCE_DIMENSION_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_INCOMPATIBLE_RESOURCE_STATE = ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_UAV_RESOURCE_DIMENSION_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_COPYRESOURCE_NULLDST = ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_INCOMPATIBLE_RESOURCE_STATE + 1 ) , - D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDDSTRESOURCE = ( D3D12_MESSAGE_ID_COPYRESOURCE_NULLDST + 1 ) , - D3D12_MESSAGE_ID_COPYRESOURCE_NULLSRC = ( D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDDSTRESOURCE + 1 ) , - D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDSRCRESOURCE = ( D3D12_MESSAGE_ID_COPYRESOURCE_NULLSRC + 1 ) , - D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_NULLDST = ( D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDSRCRESOURCE + 1 ) , - D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALIDDSTRESOURCE = ( D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_NULLDST + 1 ) , - D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_NULLSRC = ( D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALIDDSTRESOURCE + 1 ) , - D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALIDSRCRESOURCE = ( D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_NULLSRC + 1 ) , - D3D12_MESSAGE_ID_PIPELINE_STATE_TYPE_MISMATCH = ( D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALIDSRCRESOURCE + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DISPATCH_ROOT_SIGNATURE_NOT_SET = ( D3D12_MESSAGE_ID_PIPELINE_STATE_TYPE_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DISPATCH_ROOT_SIGNATURE_MISMATCH = ( D3D12_MESSAGE_ID_COMMAND_LIST_DISPATCH_ROOT_SIGNATURE_NOT_SET + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_BARRIER_ZERO_BARRIERS = ( D3D12_MESSAGE_ID_COMMAND_LIST_DISPATCH_ROOT_SIGNATURE_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_BEGIN_END_EVENT_MISMATCH = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_ZERO_BARRIERS + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_BARRIER_POSSIBLE_BEFORE_AFTER_MISMATCH = ( D3D12_MESSAGE_ID_BEGIN_END_EVENT_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_BEGIN_END = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_POSSIBLE_BEFORE_AFTER_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_INVALID_RESOURCE = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_BEGIN_END + 1 ) , - D3D12_MESSAGE_ID_USE_OF_ZERO_REFCOUNT_OBJECT = ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_INVALID_RESOURCE + 1 ) , - D3D12_MESSAGE_ID_OBJECT_EVICTED_WHILE_STILL_IN_USE = ( D3D12_MESSAGE_ID_USE_OF_ZERO_REFCOUNT_OBJECT + 1 ) , - D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_ROOT_DESCRIPTOR_ACCESS_OUT_OF_BOUNDS = ( D3D12_MESSAGE_ID_OBJECT_EVICTED_WHILE_STILL_IN_USE + 1 ) , - D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_INVALIDLIBRARYBLOB = ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_ROOT_DESCRIPTOR_ACCESS_OUT_OF_BOUNDS + 1 ) , - D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_DRIVERVERSIONMISMATCH = ( D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_INVALIDLIBRARYBLOB + 1 ) , - D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_ADAPTERVERSIONMISMATCH = ( D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_DRIVERVERSIONMISMATCH + 1 ) , - D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_UNSUPPORTED = ( D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_ADAPTERVERSIONMISMATCH + 1 ) , - D3D12_MESSAGE_ID_CREATE_PIPELINELIBRARY = ( D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_UNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_LIVE_PIPELINELIBRARY = ( D3D12_MESSAGE_ID_CREATE_PIPELINELIBRARY + 1 ) , - D3D12_MESSAGE_ID_DESTROY_PIPELINELIBRARY = ( D3D12_MESSAGE_ID_LIVE_PIPELINELIBRARY + 1 ) , - D3D12_MESSAGE_ID_STOREPIPELINE_NONAME = ( D3D12_MESSAGE_ID_DESTROY_PIPELINELIBRARY + 1 ) , - D3D12_MESSAGE_ID_STOREPIPELINE_DUPLICATENAME = ( D3D12_MESSAGE_ID_STOREPIPELINE_NONAME + 1 ) , - D3D12_MESSAGE_ID_LOADPIPELINE_NAMENOTFOUND = ( D3D12_MESSAGE_ID_STOREPIPELINE_DUPLICATENAME + 1 ) , - D3D12_MESSAGE_ID_LOADPIPELINE_INVALIDDESC = ( D3D12_MESSAGE_ID_LOADPIPELINE_NAMENOTFOUND + 1 ) , - D3D12_MESSAGE_ID_PIPELINELIBRARY_SERIALIZE_NOTENOUGHMEMORY = ( D3D12_MESSAGE_ID_LOADPIPELINE_INVALIDDESC + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_OUTPUT_RT_OUTPUT_MISMATCH = ( D3D12_MESSAGE_ID_PIPELINELIBRARY_SERIALIZE_NOTENOUGHMEMORY + 1 ) , - D3D12_MESSAGE_ID_SETEVENTONMULTIPLEFENCECOMPLETION_INVALIDFLAGS = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_OUTPUT_RT_OUTPUT_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_CREATE_QUEUE_VIDEO_NOT_SUPPORTED = ( D3D12_MESSAGE_ID_SETEVENTONMULTIPLEFENCECOMPLETION_INVALIDFLAGS + 1 ) , - D3D12_MESSAGE_ID_CREATE_COMMAND_ALLOCATOR_VIDEO_NOT_SUPPORTED = ( D3D12_MESSAGE_ID_CREATE_QUEUE_VIDEO_NOT_SUPPORTED + 1 ) , - D3D12_MESSAGE_ID_CREATEQUERY_HEAP_VIDEO_DECODE_STATISTICS_NOT_SUPPORTED = ( D3D12_MESSAGE_ID_CREATE_COMMAND_ALLOCATOR_VIDEO_NOT_SUPPORTED + 1 ) , - D3D12_MESSAGE_ID_CREATE_VIDEODECODECOMMANDLIST = ( D3D12_MESSAGE_ID_CREATEQUERY_HEAP_VIDEO_DECODE_STATISTICS_NOT_SUPPORTED + 1 ) , - D3D12_MESSAGE_ID_CREATE_VIDEODECODER = ( D3D12_MESSAGE_ID_CREATE_VIDEODECODECOMMANDLIST + 1 ) , - D3D12_MESSAGE_ID_CREATE_VIDEODECODESTREAM = ( D3D12_MESSAGE_ID_CREATE_VIDEODECODER + 1 ) , - D3D12_MESSAGE_ID_LIVE_VIDEODECODECOMMANDLIST = ( D3D12_MESSAGE_ID_CREATE_VIDEODECODESTREAM + 1 ) , - D3D12_MESSAGE_ID_LIVE_VIDEODECODER = ( D3D12_MESSAGE_ID_LIVE_VIDEODECODECOMMANDLIST + 1 ) , - D3D12_MESSAGE_ID_LIVE_VIDEODECODESTREAM = ( D3D12_MESSAGE_ID_LIVE_VIDEODECODER + 1 ) , - D3D12_MESSAGE_ID_DESTROY_VIDEODECODECOMMANDLIST = ( D3D12_MESSAGE_ID_LIVE_VIDEODECODESTREAM + 1 ) , - D3D12_MESSAGE_ID_DESTROY_VIDEODECODER = ( D3D12_MESSAGE_ID_DESTROY_VIDEODECODECOMMANDLIST + 1 ) , - D3D12_MESSAGE_ID_DESTROY_VIDEODECODESTREAM = ( D3D12_MESSAGE_ID_DESTROY_VIDEODECODER + 1 ) , - D3D12_MESSAGE_ID_DECODE_FRAME_INVALID_PARAMETERS = ( D3D12_MESSAGE_ID_DESTROY_VIDEODECODESTREAM + 1 ) , - D3D12_MESSAGE_ID_DEPRECATED_API = ( D3D12_MESSAGE_ID_DECODE_FRAME_INVALID_PARAMETERS + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_COMMAND_LIST_TYPE = ( D3D12_MESSAGE_ID_DEPRECATED_API + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_DESCRIPTOR_TABLE_NOT_SET = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_COMMAND_LIST_TYPE + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_CONSTANT_BUFFER_VIEW_NOT_SET = ( D3D12_MESSAGE_ID_COMMAND_LIST_DESCRIPTOR_TABLE_NOT_SET + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_SHADER_RESOURCE_VIEW_NOT_SET = ( D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_CONSTANT_BUFFER_VIEW_NOT_SET + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_UNORDERED_ACCESS_VIEW_NOT_SET = ( D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_SHADER_RESOURCE_VIEW_NOT_SET + 1 ) , - D3D12_MESSAGE_ID_DISCARD_INVALID_SUBRESOURCE_RANGE = ( D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_UNORDERED_ACCESS_VIEW_NOT_SET + 1 ) , - D3D12_MESSAGE_ID_DISCARD_ONE_SUBRESOURCE_FOR_MIPS_WITH_RECTS = ( D3D12_MESSAGE_ID_DISCARD_INVALID_SUBRESOURCE_RANGE + 1 ) , - D3D12_MESSAGE_ID_DISCARD_NO_RECTS_FOR_NON_TEXTURE2D = ( D3D12_MESSAGE_ID_DISCARD_ONE_SUBRESOURCE_FOR_MIPS_WITH_RECTS + 1 ) , - D3D12_MESSAGE_ID_COPY_ON_SAME_SUBRESOURCE = ( D3D12_MESSAGE_ID_DISCARD_NO_RECTS_FOR_NON_TEXTURE2D + 1 ) , - D3D12_MESSAGE_ID_SETRESIDENCYPRIORITY_INVALID_PAGEABLE = ( D3D12_MESSAGE_ID_COPY_ON_SAME_SUBRESOURCE + 1 ) , - D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_UNSUPPORTED = ( D3D12_MESSAGE_ID_SETRESIDENCYPRIORITY_INVALID_PAGEABLE + 1 ) , - D3D12_MESSAGE_ID_STATIC_DESCRIPTOR_INVALID_DESCRIPTOR_CHANGE = ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_UNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_DATA_STATIC_DESCRIPTOR_INVALID_DATA_CHANGE = ( D3D12_MESSAGE_ID_STATIC_DESCRIPTOR_INVALID_DESCRIPTOR_CHANGE + 1 ) , - D3D12_MESSAGE_ID_DATA_STATIC_WHILE_SET_AT_EXECUTE_DESCRIPTOR_INVALID_DATA_CHANGE = ( D3D12_MESSAGE_ID_DATA_STATIC_DESCRIPTOR_INVALID_DATA_CHANGE + 1 ) , - D3D12_MESSAGE_ID_EXECUTE_BUNDLE_STATIC_DESCRIPTOR_DATA_STATIC_NOT_SET = ( D3D12_MESSAGE_ID_DATA_STATIC_WHILE_SET_AT_EXECUTE_DESCRIPTOR_INVALID_DATA_CHANGE + 1 ) , - D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_RESOURCE_ACCESS_OUT_OF_BOUNDS = ( D3D12_MESSAGE_ID_EXECUTE_BUNDLE_STATIC_DESCRIPTOR_DATA_STATIC_NOT_SET + 1 ) , - D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_SAMPLER_MODE_MISMATCH = ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_RESOURCE_ACCESS_OUT_OF_BOUNDS + 1 ) , - D3D12_MESSAGE_ID_CREATE_FENCE_INVALID_FLAGS = ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_SAMPLER_MODE_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_RESOURCE_BARRIER_DUPLICATE_SUBRESOURCE_TRANSITIONS = ( D3D12_MESSAGE_ID_CREATE_FENCE_INVALID_FLAGS + 1 ) , - D3D12_MESSAGE_ID_SETRESIDENCYPRIORITY_INVALID_PRIORITY = ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_DUPLICATE_SUBRESOURCE_TRANSITIONS + 1 ) , - D3D12_MESSAGE_ID_CREATE_PASS = ( D3D12_MESSAGE_ID_SETRESIDENCYPRIORITY_INVALID_PRIORITY + 1 ) , - D3D12_MESSAGE_ID_DESTROY_PASS = ( D3D12_MESSAGE_ID_CREATE_PASS + 1 ) , - D3D12_MESSAGE_ID_LIVE_PASS = ( D3D12_MESSAGE_ID_DESTROY_PASS + 1 ) , - D3D12_MESSAGE_ID_CREATE_DESCRIPTOR_HEAP_LARGE_NUM_DESCRIPTORS = ( D3D12_MESSAGE_ID_LIVE_PASS + 1 ) , - D3D12_MESSAGE_ID_BEGIN_EVENT = ( D3D12_MESSAGE_ID_CREATE_DESCRIPTOR_HEAP_LARGE_NUM_DESCRIPTORS + 1 ) , - D3D12_MESSAGE_ID_END_EVENT = ( D3D12_MESSAGE_ID_BEGIN_EVENT + 1 ) , - D3D12_MESSAGE_ID_CREATEDEVICE_DEBUG_LAYER_STARTUP_OPTIONS = ( D3D12_MESSAGE_ID_END_EVENT + 1 ) , - D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_DEPTHBOUNDSTEST_UNSUPPORTED = ( D3D12_MESSAGE_ID_CREATEDEVICE_DEBUG_LAYER_STARTUP_OPTIONS + 1 ) , - D3D12_MESSAGE_ID_CREATEPIPELINESTATE_DUPLICATE_SUBOBJECT = ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_DEPTHBOUNDSTEST_UNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_CREATEPIPELINESTATE_UNKNOWN_SUBOBJECT = ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_DUPLICATE_SUBOBJECT + 1 ) , - D3D12_MESSAGE_ID_CREATEPIPELINESTATE_ZERO_SIZE_STREAM = ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_UNKNOWN_SUBOBJECT + 1 ) , - D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALID_STREAM = ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_ZERO_SIZE_STREAM + 1 ) , - D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CANNOT_DEDUCE_TYPE = ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALID_STREAM + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_STATIC_DESCRIPTOR_RESOURCE_DIMENSION_MISMATCH = ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CANNOT_DEDUCE_TYPE + 1 ) , - D3D12_MESSAGE_ID_CREATE_COMMAND_QUEUE_INSUFFICIENT_PRIVILEGE_FOR_GLOBAL_REALTIME = ( D3D12_MESSAGE_ID_COMMAND_LIST_STATIC_DESCRIPTOR_RESOURCE_DIMENSION_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_CREATE_COMMAND_QUEUE_INSUFFICIENT_HARDWARE_SUPPORT_FOR_GLOBAL_REALTIME = ( D3D12_MESSAGE_ID_CREATE_COMMAND_QUEUE_INSUFFICIENT_PRIVILEGE_FOR_GLOBAL_REALTIME + 1 ) , - D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_ARCHITECTURE = ( D3D12_MESSAGE_ID_CREATE_COMMAND_QUEUE_INSUFFICIENT_HARDWARE_SUPPORT_FOR_GLOBAL_REALTIME + 1 ) , - D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DST = ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_ARCHITECTURE + 1 ) , - D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DST_RESOURCE_DIMENSION = ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DST + 1 ) , - D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DST_RANGE_OUT_OF_BOUNDS = ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DST_RESOURCE_DIMENSION + 1 ) , - D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_SRC = ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DST_RANGE_OUT_OF_BOUNDS + 1 ) , - D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_SRC_RESOURCE_DIMENSION = ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_SRC + 1 ) , - D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_SRC_RANGE_OUT_OF_BOUNDS = ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_SRC_RESOURCE_DIMENSION + 1 ) , - D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_OFFSET_ALIGNMENT = ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_SRC_RANGE_OUT_OF_BOUNDS + 1 ) , - D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DEPENDENT_RESOURCES = ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_OFFSET_ALIGNMENT + 1 ) , - D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DEPENDENT_SUBRESOURCE_RANGES = ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DEPENDENT_RESOURCES + 1 ) , - D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DEPENDENT_RESOURCE = ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DEPENDENT_SUBRESOURCE_RANGES + 1 ) , - D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DEPENDENT_SUBRESOURCE_RANGE = ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DEPENDENT_RESOURCE + 1 ) , - D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DEPENDENT_SUBRESOURCE_OUT_OF_BOUNDS = ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DEPENDENT_SUBRESOURCE_RANGE + 1 ) , - D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DEPENDENT_RANGE_OUT_OF_BOUNDS = ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DEPENDENT_SUBRESOURCE_OUT_OF_BOUNDS + 1 ) , - D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_ZERO_DEPENDENCIES = ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DEPENDENT_RANGE_OUT_OF_BOUNDS + 1 ) , - D3D12_MESSAGE_ID_DEVICE_CREATE_SHARED_HANDLE_INVALIDARG = ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_ZERO_DEPENDENCIES + 1 ) , - D3D12_MESSAGE_ID_DESCRIPTOR_HANDLE_WITH_INVALID_RESOURCE = ( D3D12_MESSAGE_ID_DEVICE_CREATE_SHARED_HANDLE_INVALIDARG + 1 ) , - D3D12_MESSAGE_ID_SETDEPTHBOUNDS_INVALIDARGS = ( D3D12_MESSAGE_ID_DESCRIPTOR_HANDLE_WITH_INVALID_RESOURCE + 1 ) , - D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_RESOURCE_STATE_IMPRECISE = ( D3D12_MESSAGE_ID_SETDEPTHBOUNDS_INVALIDARGS + 1 ) , - D3D12_MESSAGE_ID_COMMAND_LIST_PIPELINE_STATE_NOT_SET = ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_RESOURCE_STATE_IMPRECISE + 1 ) , - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_MODEL_MISMATCH = ( D3D12_MESSAGE_ID_COMMAND_LIST_PIPELINE_STATE_NOT_SET + 1 ) , - D3D12_MESSAGE_ID_OBJECT_ACCESSED_WHILE_STILL_IN_USE = ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_MODEL_MISMATCH + 1 ) , - D3D12_MESSAGE_ID_PROGRAMMABLE_MSAA_UNSUPPORTED = ( D3D12_MESSAGE_ID_OBJECT_ACCESSED_WHILE_STILL_IN_USE + 1 ) , - D3D12_MESSAGE_ID_SETSAMPLEPOSITIONS_INVALIDARGS = ( D3D12_MESSAGE_ID_PROGRAMMABLE_MSAA_UNSUPPORTED + 1 ) , - D3D12_MESSAGE_ID_RESOLVESUBRESOURCEREGION_INVALID_RECT = ( D3D12_MESSAGE_ID_SETSAMPLEPOSITIONS_INVALIDARGS + 1 ) , - D3D12_MESSAGE_ID_CREATE_VIDEODECODECOMMANDQUEUE = ( D3D12_MESSAGE_ID_RESOLVESUBRESOURCEREGION_INVALID_RECT + 1 ) , - D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSCOMMANDLIST = ( D3D12_MESSAGE_ID_CREATE_VIDEODECODECOMMANDQUEUE + 1 ) , - D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSCOMMANDQUEUE = ( D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSCOMMANDLIST + 1 ) , - D3D12_MESSAGE_ID_LIVE_VIDEODECODECOMMANDQUEUE = ( D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSCOMMANDQUEUE + 1 ) , - D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSCOMMANDLIST = ( D3D12_MESSAGE_ID_LIVE_VIDEODECODECOMMANDQUEUE + 1 ) , - D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSCOMMANDQUEUE = ( D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSCOMMANDLIST + 1 ) , - D3D12_MESSAGE_ID_DESTROY_VIDEODECODECOMMANDQUEUE = ( D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSCOMMANDQUEUE + 1 ) , - D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSCOMMANDLIST = ( D3D12_MESSAGE_ID_DESTROY_VIDEODECODECOMMANDQUEUE + 1 ) , - D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSCOMMANDQUEUE = ( D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSCOMMANDLIST + 1 ) , - D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSOR = ( D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSCOMMANDQUEUE + 1 ) , - D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSSTREAM = ( D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSOR + 1 ) , - D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSOR = ( D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSSTREAM + 1 ) , - D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSSTREAM = ( D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSOR + 1 ) , - D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSOR = ( D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSSTREAM + 1 ) , - D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSSTREAM = ( D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSOR + 1 ) , - D3D12_MESSAGE_ID_PROCESS_FRAME_INVALID_PARAMETERS = ( D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSSTREAM + 1 ) , - D3D12_MESSAGE_ID_COPY_INVALIDLAYOUT = ( D3D12_MESSAGE_ID_PROCESS_FRAME_INVALID_PARAMETERS + 1 ) , - D3D12_MESSAGE_ID_CREATE_CRYPTO_SESSION = 1068, - D3D12_MESSAGE_ID_CREATE_CRYPTO_SESSION_POLICY = 1069, - D3D12_MESSAGE_ID_CREATE_PROTECTED_RESOURCE_SESSION = 1070, - D3D12_MESSAGE_ID_LIVE_CRYPTO_SESSION = 1071, - D3D12_MESSAGE_ID_LIVE_CRYPTO_SESSION_POLICY = 1072, - D3D12_MESSAGE_ID_LIVE_PROTECTED_RESOURCE_SESSION = 1073, - D3D12_MESSAGE_ID_DESTROY_CRYPTO_SESSION = 1074, - D3D12_MESSAGE_ID_DESTROY_CRYPTO_SESSION_POLICY = 1075, - D3D12_MESSAGE_ID_DESTROY_PROTECTED_RESOURCE_SESSION = 1076, - D3D12_MESSAGE_ID_PROTECTED_RESOURCE_SESSION_UNSUPPORTED = 1077, - D3D12_MESSAGE_ID_FENCE_INVALIDOPERATION = 1078, - D3D12_MESSAGE_ID_CREATEQUERY_HEAP_COPY_QUEUE_TIMESTAMPS_NOT_SUPPORTED = 1079, - D3D12_MESSAGE_ID_SAMPLEPOSITIONS_MISMATCH_DEFERRED = 1080, - D3D12_MESSAGE_ID_SAMPLEPOSITIONS_MISMATCH_RECORDTIME_ASSUMEDFROMFIRSTUSE = 1081, - D3D12_MESSAGE_ID_SAMPLEPOSITIONS_MISMATCH_RECORDTIME_ASSUMEDFROMCLEAR = 1082, - D3D12_MESSAGE_ID_CREATE_VIDEODECODERHEAP = 1083, - D3D12_MESSAGE_ID_LIVE_VIDEODECODERHEAP = 1084, - D3D12_MESSAGE_ID_DESTROY_VIDEODECODERHEAP = 1085, - D3D12_MESSAGE_ID_OPENEXISTINGHEAP_INVALIDARG_RETURN = 1086, - D3D12_MESSAGE_ID_OPENEXISTINGHEAP_OUTOFMEMORY_RETURN = 1087, - D3D12_MESSAGE_ID_OPENEXISTINGHEAP_INVALIDADDRESS = 1088, - D3D12_MESSAGE_ID_OPENEXISTINGHEAP_INVALIDHANDLE = 1089, - D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_INVALID_DEST = 1090, - D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_INVALID_MODE = 1091, - D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_INVALID_ALIGNMENT = 1092, - D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_NOT_SUPPORTED = 1093, - D3D12_MESSAGE_ID_SETVIEWINSTANCEMASK_INVALIDARGS = 1094, - D3D12_MESSAGE_ID_VIEW_INSTANCING_UNSUPPORTED = 1095, - D3D12_MESSAGE_ID_VIEW_INSTANCING_INVALIDARGS = 1096, - D3D12_MESSAGE_ID_COPYTEXTUREREGION_MISMATCH_DECODE_REFERENCE_ONLY_FLAG = 1097, - D3D12_MESSAGE_ID_COPYRESOURCE_MISMATCH_DECODE_REFERENCE_ONLY_FLAG = 1098, - D3D12_MESSAGE_ID_CREATE_VIDEO_DECODE_HEAP_CAPS_FAILURE = 1099, - D3D12_MESSAGE_ID_CREATE_VIDEO_DECODE_HEAP_CAPS_UNSUPPORTED = 1100, - D3D12_MESSAGE_ID_VIDEO_DECODE_SUPPORT_INVALID_INPUT = 1101, - D3D12_MESSAGE_ID_CREATE_VIDEO_DECODER_UNSUPPORTED = 1102, - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_METADATA_ERROR = 1103, - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_VIEW_INSTANCING_VERTEX_SIZE_EXCEEDED = 1104, - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RUNTIME_INTERNAL_ERROR = 1105, - D3D12_MESSAGE_ID_NO_VIDEO_API_SUPPORT = 1106, - D3D12_MESSAGE_ID_VIDEO_PROCESS_SUPPORT_INVALID_INPUT = 1107, - D3D12_MESSAGE_ID_CREATE_VIDEO_PROCESSOR_CAPS_FAILURE = 1108, - D3D12_MESSAGE_ID_VIDEO_PROCESS_SUPPORT_UNSUPPORTED_FORMAT = 1109, - D3D12_MESSAGE_ID_VIDEO_DECODE_FRAME_INVALID_ARGUMENT = 1110, - D3D12_MESSAGE_ID_ENQUEUE_MAKE_RESIDENT_INVALID_FLAGS = 1111, - D3D12_MESSAGE_ID_OPENEXISTINGHEAP_UNSUPPORTED = 1112, - D3D12_MESSAGE_ID_VIDEO_PROCESS_FRAMES_INVALID_ARGUMENT = 1113, - D3D12_MESSAGE_ID_VIDEO_DECODE_SUPPORT_UNSUPPORTED = 1114, - D3D12_MESSAGE_ID_CREATE_COMMANDRECORDER = 1115, - D3D12_MESSAGE_ID_LIVE_COMMANDRECORDER = 1116, - D3D12_MESSAGE_ID_DESTROY_COMMANDRECORDER = 1117, - D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_VIDEO_NOT_SUPPORTED = 1118, - D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_INVALID_SUPPORT_FLAGS = 1119, - D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_INVALID_FLAGS = 1120, - D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_MORE_RECORDERS_THAN_LOGICAL_PROCESSORS = 1121, - D3D12_MESSAGE_ID_CREATE_COMMANDPOOL = 1122, - D3D12_MESSAGE_ID_LIVE_COMMANDPOOL = 1123, - D3D12_MESSAGE_ID_DESTROY_COMMANDPOOL = 1124, - D3D12_MESSAGE_ID_CREATE_COMMAND_POOL_INVALID_FLAGS = 1125, - D3D12_MESSAGE_ID_CREATE_COMMAND_LIST_VIDEO_NOT_SUPPORTED = 1126, - D3D12_MESSAGE_ID_COMMAND_RECORDER_SUPPORT_FLAGS_MISMATCH = 1127, - D3D12_MESSAGE_ID_COMMAND_RECORDER_CONTENTION = 1128, - D3D12_MESSAGE_ID_COMMAND_RECORDER_USAGE_WITH_CREATECOMMANDLIST_COMMAND_LIST = 1129, - D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_USAGE_WITH_CREATECOMMANDLIST1_COMMAND_LIST = 1130, - D3D12_MESSAGE_ID_CANNOT_EXECUTE_EMPTY_COMMAND_LIST = 1131, - D3D12_MESSAGE_ID_CANNOT_RESET_COMMAND_POOL_WITH_OPEN_COMMAND_LISTS = 1132, - D3D12_MESSAGE_ID_CANNOT_USE_COMMAND_RECORDER_WITHOUT_CURRENT_TARGET = 1133, - D3D12_MESSAGE_ID_CANNOT_CHANGE_COMMAND_RECORDER_TARGET_WHILE_RECORDING = 1134, - D3D12_MESSAGE_ID_COMMAND_POOL_SYNC = 1135, - D3D12_MESSAGE_ID_EVICT_UNDERFLOW = 1136, - D3D12_MESSAGE_ID_CREATE_META_COMMAND = 1137, - D3D12_MESSAGE_ID_LIVE_META_COMMAND = 1138, - D3D12_MESSAGE_ID_DESTROY_META_COMMAND = 1139, - D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALID_DST_RESOURCE = 1140, - D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALID_SRC_RESOURCE = 1141, - D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DST_RESOURCE = 1142, - D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_SRC_RESOURCE = 1143, - D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_NULL_BUFFER = 1144, - D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_NULL_RESOURCE_DESC = 1145, - D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_UNSUPPORTED = 1146, - D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_BUFFER_DIMENSION = 1147, - D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_BUFFER_FLAGS = 1148, - D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_BUFFER_OFFSET = 1149, - D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_RESOURCE_DIMENSION = 1150, - D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_RESOURCE_FLAGS = 1151, - D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_OUTOFMEMORY_RETURN = 1152, - D3D12_MESSAGE_ID_CANNOT_CREATE_GRAPHICS_AND_VIDEO_COMMAND_RECORDER = 1153, - D3D12_MESSAGE_ID_UPDATETILEMAPPINGS_POSSIBLY_MISMATCHING_PROPERTIES = 1154, - D3D12_MESSAGE_ID_CREATE_COMMAND_LIST_INVALID_COMMAND_LIST_TYPE = 1155, - D3D12_MESSAGE_ID_CLEARUNORDEREDACCESSVIEW_INCOMPATIBLE_WITH_STRUCTURED_BUFFERS = 1156, - D3D12_MESSAGE_ID_COMPUTE_ONLY_DEVICE_OPERATION_UNSUPPORTED = 1157, - D3D12_MESSAGE_ID_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INVALID = 1158, - D3D12_MESSAGE_ID_EMIT_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_INVALID = 1159, - D3D12_MESSAGE_ID_COPY_RAYTRACING_ACCELERATION_STRUCTURE_INVALID = 1160, - D3D12_MESSAGE_ID_DISPATCH_RAYS_INVALID = 1161, - D3D12_MESSAGE_ID_GET_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO_INVALID = 1162, - D3D12_MESSAGE_ID_CREATE_LIFETIMETRACKER = 1163, - D3D12_MESSAGE_ID_LIVE_LIFETIMETRACKER = 1164, - D3D12_MESSAGE_ID_DESTROY_LIFETIMETRACKER = 1165, - D3D12_MESSAGE_ID_DESTROYOWNEDOBJECT_OBJECTNOTOWNED = 1166, - D3D12_MESSAGE_ID_CREATE_TRACKEDWORKLOAD = 1167, - D3D12_MESSAGE_ID_LIVE_TRACKEDWORKLOAD = 1168, - D3D12_MESSAGE_ID_DESTROY_TRACKEDWORKLOAD = 1169, - D3D12_MESSAGE_ID_RENDER_PASS_ERROR = 1170, - D3D12_MESSAGE_ID_META_COMMAND_ID_INVALID = 1171, - D3D12_MESSAGE_ID_META_COMMAND_UNSUPPORTED_PARAMS = 1172, - D3D12_MESSAGE_ID_META_COMMAND_FAILED_ENUMERATION = 1173, - D3D12_MESSAGE_ID_META_COMMAND_PARAMETER_SIZE_MISMATCH = 1174, - D3D12_MESSAGE_ID_UNINITIALIZED_META_COMMAND = 1175, - D3D12_MESSAGE_ID_META_COMMAND_INVALID_GPU_VIRTUAL_ADDRESS = 1176, - D3D12_MESSAGE_ID_CREATE_VIDEOENCODECOMMANDLIST = 1177, - D3D12_MESSAGE_ID_LIVE_VIDEOENCODECOMMANDLIST = 1178, - D3D12_MESSAGE_ID_DESTROY_VIDEOENCODECOMMANDLIST = 1179, - D3D12_MESSAGE_ID_CREATE_VIDEOENCODECOMMANDQUEUE = 1180, - D3D12_MESSAGE_ID_LIVE_VIDEOENCODECOMMANDQUEUE = 1181, - D3D12_MESSAGE_ID_DESTROY_VIDEOENCODECOMMANDQUEUE = 1182, - D3D12_MESSAGE_ID_CREATE_VIDEOMOTIONESTIMATOR = 1183, - D3D12_MESSAGE_ID_LIVE_VIDEOMOTIONESTIMATOR = 1184, - D3D12_MESSAGE_ID_DESTROY_VIDEOMOTIONESTIMATOR = 1185, - D3D12_MESSAGE_ID_CREATE_VIDEOMOTIONVECTORHEAP = 1186, - D3D12_MESSAGE_ID_LIVE_VIDEOMOTIONVECTORHEAP = 1187, - D3D12_MESSAGE_ID_DESTROY_VIDEOMOTIONVECTORHEAP = 1188, - D3D12_MESSAGE_ID_MULTIPLE_TRACKED_WORKLOADS = 1189, - D3D12_MESSAGE_ID_MULTIPLE_TRACKED_WORKLOAD_PAIRS = 1190, - D3D12_MESSAGE_ID_OUT_OF_ORDER_TRACKED_WORKLOAD_PAIR = 1191, - D3D12_MESSAGE_ID_CANNOT_ADD_TRACKED_WORKLOAD = 1192, - D3D12_MESSAGE_ID_INCOMPLETE_TRACKED_WORKLOAD_PAIR = 1193, - D3D12_MESSAGE_ID_CREATE_STATE_OBJECT_ERROR = 1194, - D3D12_MESSAGE_ID_GET_SHADER_IDENTIFIER_ERROR = 1195, - D3D12_MESSAGE_ID_GET_SHADER_STACK_SIZE_ERROR = 1196, - D3D12_MESSAGE_ID_GET_PIPELINE_STACK_SIZE_ERROR = 1197, - D3D12_MESSAGE_ID_SET_PIPELINE_STACK_SIZE_ERROR = 1198, - D3D12_MESSAGE_ID_GET_SHADER_IDENTIFIER_SIZE_INVALID = 1199, - D3D12_MESSAGE_ID_CHECK_DRIVER_MATCHING_IDENTIFIER_INVALID = 1200, - D3D12_MESSAGE_ID_CHECK_DRIVER_MATCHING_IDENTIFIER_DRIVER_REPORTED_ISSUE = 1201, - D3D12_MESSAGE_ID_RENDER_PASS_INVALID_RESOURCE_BARRIER = 1202, - D3D12_MESSAGE_ID_RENDER_PASS_DISALLOWED_API_CALLED = 1203, - D3D12_MESSAGE_ID_RENDER_PASS_CANNOT_NEST_RENDER_PASSES = 1204, - D3D12_MESSAGE_ID_RENDER_PASS_CANNOT_END_WITHOUT_BEGIN = 1205, - D3D12_MESSAGE_ID_RENDER_PASS_CANNOT_CLOSE_COMMAND_LIST = 1206, - D3D12_MESSAGE_ID_RENDER_PASS_GPU_WORK_WHILE_SUSPENDED = 1207, - D3D12_MESSAGE_ID_RENDER_PASS_MISMATCHING_SUSPEND_RESUME = 1208, - D3D12_MESSAGE_ID_RENDER_PASS_NO_PRIOR_SUSPEND_WITHIN_EXECUTECOMMANDLISTS = 1209, - D3D12_MESSAGE_ID_RENDER_PASS_NO_SUBSEQUENT_RESUME_WITHIN_EXECUTECOMMANDLISTS = 1210, - D3D12_MESSAGE_ID_TRACKED_WORKLOAD_COMMAND_QUEUE_MISMATCH = 1211, - D3D12_MESSAGE_ID_TRACKED_WORKLOAD_NOT_SUPPORTED = 1212, - D3D12_MESSAGE_ID_RENDER_PASS_MISMATCHING_NO_ACCESS = 1213, - D3D12_MESSAGE_ID_RENDER_PASS_UNSUPPORTED_RESOLVE = 1214, - D3D12_MESSAGE_ID_CLEARUNORDEREDACCESSVIEW_INVALID_RESOURCE_PTR = 1215, - D3D12_MESSAGE_ID_WINDOWS7_FENCE_OUTOFORDER_SIGNAL = 1216, - D3D12_MESSAGE_ID_WINDOWS7_FENCE_OUTOFORDER_WAIT = 1217, - D3D12_MESSAGE_ID_VIDEO_CREATE_MOTION_ESTIMATOR_INVALID_ARGUMENT = 1218, - D3D12_MESSAGE_ID_VIDEO_CREATE_MOTION_VECTOR_HEAP_INVALID_ARGUMENT = 1219, - D3D12_MESSAGE_ID_ESTIMATE_MOTION_INVALID_ARGUMENT = 1220, - D3D12_MESSAGE_ID_RESOLVE_MOTION_VECTOR_HEAP_INVALID_ARGUMENT = 1221, - D3D12_MESSAGE_ID_GETGPUVIRTUALADDRESS_INVALID_HEAP_TYPE = 1222, - D3D12_MESSAGE_ID_SET_BACKGROUND_PROCESSING_MODE_INVALID_ARGUMENT = 1223, - D3D12_MESSAGE_ID_CREATE_COMMAND_LIST_INVALID_COMMAND_LIST_TYPE_FOR_FEATURE_LEVEL = 1224, - D3D12_MESSAGE_ID_CREATE_VIDEOEXTENSIONCOMMAND = 1225, - D3D12_MESSAGE_ID_LIVE_VIDEOEXTENSIONCOMMAND = 1226, - D3D12_MESSAGE_ID_DESTROY_VIDEOEXTENSIONCOMMAND = 1227, - D3D12_MESSAGE_ID_INVALID_VIDEO_EXTENSION_COMMAND_ID = 1228, - D3D12_MESSAGE_ID_VIDEO_EXTENSION_COMMAND_INVALID_ARGUMENT = 1229, - D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_NOT_UNIQUE_IN_DXIL_LIBRARY = 1230, - D3D12_MESSAGE_ID_VARIABLE_SHADING_RATE_NOT_ALLOWED_WITH_TIR = 1231, - D3D12_MESSAGE_ID_GEOMETRY_SHADER_OUTPUTTING_BOTH_VIEWPORT_ARRAY_INDEX_AND_SHADING_RATE_NOT_SUPPORTED_ON_DEVICE = 1232, - D3D12_MESSAGE_ID_RSSETSHADING_RATE_INVALID_SHADING_RATE = 1233, - D3D12_MESSAGE_ID_RSSETSHADING_RATE_SHADING_RATE_NOT_PERMITTED_BY_CAP = 1234, - D3D12_MESSAGE_ID_RSSETSHADING_RATE_INVALID_COMBINER = 1235, - D3D12_MESSAGE_ID_RSSETSHADINGRATEIMAGE_REQUIRES_TIER_2 = 1236, - D3D12_MESSAGE_ID_RSSETSHADINGRATE_REQUIRES_TIER_1 = 1237, - D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_FORMAT = 1238, - D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_ARRAY_SIZE = 1239, - D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_MIP_LEVEL = 1240, - D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_SAMPLE_COUNT = 1241, - D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_SAMPLE_QUALITY = 1242, - D3D12_MESSAGE_ID_NON_RETAIL_SHADER_MODEL_WONT_VALIDATE = 1243, - D3D12_MESSAGE_ID_D3D12_MESSAGES_END = ( D3D12_MESSAGE_ID_NON_RETAIL_SHADER_MODEL_WONT_VALIDATE + 1 ) - } D3D12_MESSAGE_ID; - -static_assert(D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_UNSUPPORTED == 1000, "Publicly released SDK D3D12_MESSAGE_ID enum values must not be changed. New enum values must be added to the end of the list."); -static_assert(D3D12_MESSAGE_ID_COPY_INVALIDLAYOUT == 1067, "Publicly released SDK D3D12_MESSAGE_ID enum values must not be changed. New enum values must be added to the end of the list."); -typedef struct D3D12_MESSAGE - { - D3D12_MESSAGE_CATEGORY Category; - D3D12_MESSAGE_SEVERITY Severity; - D3D12_MESSAGE_ID ID; - _Field_size_(DescriptionByteLength) const char *pDescription; - SIZE_T DescriptionByteLength; - } D3D12_MESSAGE; - -typedef struct D3D12_INFO_QUEUE_FILTER_DESC - { - UINT NumCategories; - _Field_size_(NumCategories) D3D12_MESSAGE_CATEGORY *pCategoryList; - UINT NumSeverities; - _Field_size_(NumSeverities) D3D12_MESSAGE_SEVERITY *pSeverityList; - UINT NumIDs; - _Field_size_(NumIDs) D3D12_MESSAGE_ID *pIDList; - } D3D12_INFO_QUEUE_FILTER_DESC; - -typedef struct D3D12_INFO_QUEUE_FILTER - { - D3D12_INFO_QUEUE_FILTER_DESC AllowList; - D3D12_INFO_QUEUE_FILTER_DESC DenyList; - } D3D12_INFO_QUEUE_FILTER; - -#define D3D12_INFO_QUEUE_DEFAULT_MESSAGE_COUNT_LIMIT 1024 - - -extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0012_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0012_v0_0_s_ifspec; - -#ifndef __ID3D12InfoQueue_INTERFACE_DEFINED__ -#define __ID3D12InfoQueue_INTERFACE_DEFINED__ - -/* interface ID3D12InfoQueue */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12InfoQueue; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("0742a90b-c387-483f-b946-30a7e4e61458") - ID3D12InfoQueue : public IUnknown - { - public: - virtual HRESULT STDMETHODCALLTYPE SetMessageCountLimit( - _In_ UINT64 MessageCountLimit) = 0; - - virtual void STDMETHODCALLTYPE ClearStoredMessages( void) = 0; - - virtual HRESULT STDMETHODCALLTYPE GetMessage( - _In_ UINT64 MessageIndex, - _Out_writes_bytes_opt_(*pMessageByteLength) D3D12_MESSAGE *pMessage, - _Inout_ SIZE_T *pMessageByteLength) = 0; - - virtual UINT64 STDMETHODCALLTYPE GetNumMessagesAllowedByStorageFilter( void) = 0; - - virtual UINT64 STDMETHODCALLTYPE GetNumMessagesDeniedByStorageFilter( void) = 0; - - virtual UINT64 STDMETHODCALLTYPE GetNumStoredMessages( void) = 0; - - virtual UINT64 STDMETHODCALLTYPE GetNumStoredMessagesAllowedByRetrievalFilter( void) = 0; - - virtual UINT64 STDMETHODCALLTYPE GetNumMessagesDiscardedByMessageCountLimit( void) = 0; - - virtual UINT64 STDMETHODCALLTYPE GetMessageCountLimit( void) = 0; - - virtual HRESULT STDMETHODCALLTYPE AddStorageFilterEntries( - _In_ D3D12_INFO_QUEUE_FILTER *pFilter) = 0; - - virtual HRESULT STDMETHODCALLTYPE GetStorageFilter( - _Out_writes_bytes_opt_(*pFilterByteLength) D3D12_INFO_QUEUE_FILTER *pFilter, - _Inout_ SIZE_T *pFilterByteLength) = 0; - - virtual void STDMETHODCALLTYPE ClearStorageFilter( void) = 0; - - virtual HRESULT STDMETHODCALLTYPE PushEmptyStorageFilter( void) = 0; - - virtual HRESULT STDMETHODCALLTYPE PushCopyOfStorageFilter( void) = 0; - - virtual HRESULT STDMETHODCALLTYPE PushStorageFilter( - _In_ D3D12_INFO_QUEUE_FILTER *pFilter) = 0; - - virtual void STDMETHODCALLTYPE PopStorageFilter( void) = 0; - - virtual UINT STDMETHODCALLTYPE GetStorageFilterStackSize( void) = 0; - - virtual HRESULT STDMETHODCALLTYPE AddRetrievalFilterEntries( - _In_ D3D12_INFO_QUEUE_FILTER *pFilter) = 0; - - virtual HRESULT STDMETHODCALLTYPE GetRetrievalFilter( - _Out_writes_bytes_opt_(*pFilterByteLength) D3D12_INFO_QUEUE_FILTER *pFilter, - _Inout_ SIZE_T *pFilterByteLength) = 0; - - virtual void STDMETHODCALLTYPE ClearRetrievalFilter( void) = 0; - - virtual HRESULT STDMETHODCALLTYPE PushEmptyRetrievalFilter( void) = 0; - - virtual HRESULT STDMETHODCALLTYPE PushCopyOfRetrievalFilter( void) = 0; - - virtual HRESULT STDMETHODCALLTYPE PushRetrievalFilter( - _In_ D3D12_INFO_QUEUE_FILTER *pFilter) = 0; - - virtual void STDMETHODCALLTYPE PopRetrievalFilter( void) = 0; - - virtual UINT STDMETHODCALLTYPE GetRetrievalFilterStackSize( void) = 0; - - virtual HRESULT STDMETHODCALLTYPE AddMessage( - _In_ D3D12_MESSAGE_CATEGORY Category, - _In_ D3D12_MESSAGE_SEVERITY Severity, - _In_ D3D12_MESSAGE_ID ID, - _In_ LPCSTR pDescription) = 0; - - virtual HRESULT STDMETHODCALLTYPE AddApplicationMessage( - _In_ D3D12_MESSAGE_SEVERITY Severity, - _In_ LPCSTR pDescription) = 0; - - virtual HRESULT STDMETHODCALLTYPE SetBreakOnCategory( - _In_ D3D12_MESSAGE_CATEGORY Category, - _In_ BOOL bEnable) = 0; - - virtual HRESULT STDMETHODCALLTYPE SetBreakOnSeverity( - _In_ D3D12_MESSAGE_SEVERITY Severity, - _In_ BOOL bEnable) = 0; - - virtual HRESULT STDMETHODCALLTYPE SetBreakOnID( - _In_ D3D12_MESSAGE_ID ID, - _In_ BOOL bEnable) = 0; - - virtual BOOL STDMETHODCALLTYPE GetBreakOnCategory( - _In_ D3D12_MESSAGE_CATEGORY Category) = 0; - - virtual BOOL STDMETHODCALLTYPE GetBreakOnSeverity( - _In_ D3D12_MESSAGE_SEVERITY Severity) = 0; - - virtual BOOL STDMETHODCALLTYPE GetBreakOnID( - _In_ D3D12_MESSAGE_ID ID) = 0; - - virtual void STDMETHODCALLTYPE SetMuteDebugOutput( - _In_ BOOL bMute) = 0; - - virtual BOOL STDMETHODCALLTYPE GetMuteDebugOutput( void) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D12InfoQueueVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12InfoQueue * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12InfoQueue * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12InfoQueue * This); - - HRESULT ( STDMETHODCALLTYPE *SetMessageCountLimit )( - ID3D12InfoQueue * This, - _In_ UINT64 MessageCountLimit); - - void ( STDMETHODCALLTYPE *ClearStoredMessages )( - ID3D12InfoQueue * This); - - HRESULT ( STDMETHODCALLTYPE *GetMessage )( - ID3D12InfoQueue * This, - _In_ UINT64 MessageIndex, - _Out_writes_bytes_opt_(*pMessageByteLength) D3D12_MESSAGE *pMessage, - _Inout_ SIZE_T *pMessageByteLength); - - UINT64 ( STDMETHODCALLTYPE *GetNumMessagesAllowedByStorageFilter )( - ID3D12InfoQueue * This); - - UINT64 ( STDMETHODCALLTYPE *GetNumMessagesDeniedByStorageFilter )( - ID3D12InfoQueue * This); - - UINT64 ( STDMETHODCALLTYPE *GetNumStoredMessages )( - ID3D12InfoQueue * This); - - UINT64 ( STDMETHODCALLTYPE *GetNumStoredMessagesAllowedByRetrievalFilter )( - ID3D12InfoQueue * This); - - UINT64 ( STDMETHODCALLTYPE *GetNumMessagesDiscardedByMessageCountLimit )( - ID3D12InfoQueue * This); - - UINT64 ( STDMETHODCALLTYPE *GetMessageCountLimit )( - ID3D12InfoQueue * This); - - HRESULT ( STDMETHODCALLTYPE *AddStorageFilterEntries )( - ID3D12InfoQueue * This, - _In_ D3D12_INFO_QUEUE_FILTER *pFilter); - - HRESULT ( STDMETHODCALLTYPE *GetStorageFilter )( - ID3D12InfoQueue * This, - _Out_writes_bytes_opt_(*pFilterByteLength) D3D12_INFO_QUEUE_FILTER *pFilter, - _Inout_ SIZE_T *pFilterByteLength); - - void ( STDMETHODCALLTYPE *ClearStorageFilter )( - ID3D12InfoQueue * This); - - HRESULT ( STDMETHODCALLTYPE *PushEmptyStorageFilter )( - ID3D12InfoQueue * This); - - HRESULT ( STDMETHODCALLTYPE *PushCopyOfStorageFilter )( - ID3D12InfoQueue * This); - - HRESULT ( STDMETHODCALLTYPE *PushStorageFilter )( - ID3D12InfoQueue * This, - _In_ D3D12_INFO_QUEUE_FILTER *pFilter); - - void ( STDMETHODCALLTYPE *PopStorageFilter )( - ID3D12InfoQueue * This); - - UINT ( STDMETHODCALLTYPE *GetStorageFilterStackSize )( - ID3D12InfoQueue * This); - - HRESULT ( STDMETHODCALLTYPE *AddRetrievalFilterEntries )( - ID3D12InfoQueue * This, - _In_ D3D12_INFO_QUEUE_FILTER *pFilter); - - HRESULT ( STDMETHODCALLTYPE *GetRetrievalFilter )( - ID3D12InfoQueue * This, - _Out_writes_bytes_opt_(*pFilterByteLength) D3D12_INFO_QUEUE_FILTER *pFilter, - _Inout_ SIZE_T *pFilterByteLength); - - void ( STDMETHODCALLTYPE *ClearRetrievalFilter )( - ID3D12InfoQueue * This); - - HRESULT ( STDMETHODCALLTYPE *PushEmptyRetrievalFilter )( - ID3D12InfoQueue * This); - - HRESULT ( STDMETHODCALLTYPE *PushCopyOfRetrievalFilter )( - ID3D12InfoQueue * This); - - HRESULT ( STDMETHODCALLTYPE *PushRetrievalFilter )( - ID3D12InfoQueue * This, - _In_ D3D12_INFO_QUEUE_FILTER *pFilter); - - void ( STDMETHODCALLTYPE *PopRetrievalFilter )( - ID3D12InfoQueue * This); - - UINT ( STDMETHODCALLTYPE *GetRetrievalFilterStackSize )( - ID3D12InfoQueue * This); - - HRESULT ( STDMETHODCALLTYPE *AddMessage )( - ID3D12InfoQueue * This, - _In_ D3D12_MESSAGE_CATEGORY Category, - _In_ D3D12_MESSAGE_SEVERITY Severity, - _In_ D3D12_MESSAGE_ID ID, - _In_ LPCSTR pDescription); - - HRESULT ( STDMETHODCALLTYPE *AddApplicationMessage )( - ID3D12InfoQueue * This, - _In_ D3D12_MESSAGE_SEVERITY Severity, - _In_ LPCSTR pDescription); - - HRESULT ( STDMETHODCALLTYPE *SetBreakOnCategory )( - ID3D12InfoQueue * This, - _In_ D3D12_MESSAGE_CATEGORY Category, - _In_ BOOL bEnable); - - HRESULT ( STDMETHODCALLTYPE *SetBreakOnSeverity )( - ID3D12InfoQueue * This, - _In_ D3D12_MESSAGE_SEVERITY Severity, - _In_ BOOL bEnable); - - HRESULT ( STDMETHODCALLTYPE *SetBreakOnID )( - ID3D12InfoQueue * This, - _In_ D3D12_MESSAGE_ID ID, - _In_ BOOL bEnable); - - BOOL ( STDMETHODCALLTYPE *GetBreakOnCategory )( - ID3D12InfoQueue * This, - _In_ D3D12_MESSAGE_CATEGORY Category); - - BOOL ( STDMETHODCALLTYPE *GetBreakOnSeverity )( - ID3D12InfoQueue * This, - _In_ D3D12_MESSAGE_SEVERITY Severity); - - BOOL ( STDMETHODCALLTYPE *GetBreakOnID )( - ID3D12InfoQueue * This, - _In_ D3D12_MESSAGE_ID ID); - - void ( STDMETHODCALLTYPE *SetMuteDebugOutput )( - ID3D12InfoQueue * This, - _In_ BOOL bMute); - - BOOL ( STDMETHODCALLTYPE *GetMuteDebugOutput )( - ID3D12InfoQueue * This); - - END_INTERFACE - } ID3D12InfoQueueVtbl; - - interface ID3D12InfoQueue - { - CONST_VTBL struct ID3D12InfoQueueVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12InfoQueue_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12InfoQueue_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12InfoQueue_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12InfoQueue_SetMessageCountLimit(This,MessageCountLimit) \ - ( (This)->lpVtbl -> SetMessageCountLimit(This,MessageCountLimit) ) - -#define ID3D12InfoQueue_ClearStoredMessages(This) \ - ( (This)->lpVtbl -> ClearStoredMessages(This) ) - -#define ID3D12InfoQueue_GetMessage(This,MessageIndex,pMessage,pMessageByteLength) \ - ( (This)->lpVtbl -> GetMessage(This,MessageIndex,pMessage,pMessageByteLength) ) - -#define ID3D12InfoQueue_GetNumMessagesAllowedByStorageFilter(This) \ - ( (This)->lpVtbl -> GetNumMessagesAllowedByStorageFilter(This) ) - -#define ID3D12InfoQueue_GetNumMessagesDeniedByStorageFilter(This) \ - ( (This)->lpVtbl -> GetNumMessagesDeniedByStorageFilter(This) ) - -#define ID3D12InfoQueue_GetNumStoredMessages(This) \ - ( (This)->lpVtbl -> GetNumStoredMessages(This) ) - -#define ID3D12InfoQueue_GetNumStoredMessagesAllowedByRetrievalFilter(This) \ - ( (This)->lpVtbl -> GetNumStoredMessagesAllowedByRetrievalFilter(This) ) - -#define ID3D12InfoQueue_GetNumMessagesDiscardedByMessageCountLimit(This) \ - ( (This)->lpVtbl -> GetNumMessagesDiscardedByMessageCountLimit(This) ) - -#define ID3D12InfoQueue_GetMessageCountLimit(This) \ - ( (This)->lpVtbl -> GetMessageCountLimit(This) ) - -#define ID3D12InfoQueue_AddStorageFilterEntries(This,pFilter) \ - ( (This)->lpVtbl -> AddStorageFilterEntries(This,pFilter) ) - -#define ID3D12InfoQueue_GetStorageFilter(This,pFilter,pFilterByteLength) \ - ( (This)->lpVtbl -> GetStorageFilter(This,pFilter,pFilterByteLength) ) - -#define ID3D12InfoQueue_ClearStorageFilter(This) \ - ( (This)->lpVtbl -> ClearStorageFilter(This) ) - -#define ID3D12InfoQueue_PushEmptyStorageFilter(This) \ - ( (This)->lpVtbl -> PushEmptyStorageFilter(This) ) - -#define ID3D12InfoQueue_PushCopyOfStorageFilter(This) \ - ( (This)->lpVtbl -> PushCopyOfStorageFilter(This) ) - -#define ID3D12InfoQueue_PushStorageFilter(This,pFilter) \ - ( (This)->lpVtbl -> PushStorageFilter(This,pFilter) ) - -#define ID3D12InfoQueue_PopStorageFilter(This) \ - ( (This)->lpVtbl -> PopStorageFilter(This) ) - -#define ID3D12InfoQueue_GetStorageFilterStackSize(This) \ - ( (This)->lpVtbl -> GetStorageFilterStackSize(This) ) - -#define ID3D12InfoQueue_AddRetrievalFilterEntries(This,pFilter) \ - ( (This)->lpVtbl -> AddRetrievalFilterEntries(This,pFilter) ) - -#define ID3D12InfoQueue_GetRetrievalFilter(This,pFilter,pFilterByteLength) \ - ( (This)->lpVtbl -> GetRetrievalFilter(This,pFilter,pFilterByteLength) ) - -#define ID3D12InfoQueue_ClearRetrievalFilter(This) \ - ( (This)->lpVtbl -> ClearRetrievalFilter(This) ) - -#define ID3D12InfoQueue_PushEmptyRetrievalFilter(This) \ - ( (This)->lpVtbl -> PushEmptyRetrievalFilter(This) ) - -#define ID3D12InfoQueue_PushCopyOfRetrievalFilter(This) \ - ( (This)->lpVtbl -> PushCopyOfRetrievalFilter(This) ) - -#define ID3D12InfoQueue_PushRetrievalFilter(This,pFilter) \ - ( (This)->lpVtbl -> PushRetrievalFilter(This,pFilter) ) - -#define ID3D12InfoQueue_PopRetrievalFilter(This) \ - ( (This)->lpVtbl -> PopRetrievalFilter(This) ) - -#define ID3D12InfoQueue_GetRetrievalFilterStackSize(This) \ - ( (This)->lpVtbl -> GetRetrievalFilterStackSize(This) ) - -#define ID3D12InfoQueue_AddMessage(This,Category,Severity,ID,pDescription) \ - ( (This)->lpVtbl -> AddMessage(This,Category,Severity,ID,pDescription) ) - -#define ID3D12InfoQueue_AddApplicationMessage(This,Severity,pDescription) \ - ( (This)->lpVtbl -> AddApplicationMessage(This,Severity,pDescription) ) - -#define ID3D12InfoQueue_SetBreakOnCategory(This,Category,bEnable) \ - ( (This)->lpVtbl -> SetBreakOnCategory(This,Category,bEnable) ) - -#define ID3D12InfoQueue_SetBreakOnSeverity(This,Severity,bEnable) \ - ( (This)->lpVtbl -> SetBreakOnSeverity(This,Severity,bEnable) ) - -#define ID3D12InfoQueue_SetBreakOnID(This,ID,bEnable) \ - ( (This)->lpVtbl -> SetBreakOnID(This,ID,bEnable) ) - -#define ID3D12InfoQueue_GetBreakOnCategory(This,Category) \ - ( (This)->lpVtbl -> GetBreakOnCategory(This,Category) ) - -#define ID3D12InfoQueue_GetBreakOnSeverity(This,Severity) \ - ( (This)->lpVtbl -> GetBreakOnSeverity(This,Severity) ) - -#define ID3D12InfoQueue_GetBreakOnID(This,ID) \ - ( (This)->lpVtbl -> GetBreakOnID(This,ID) ) - -#define ID3D12InfoQueue_SetMuteDebugOutput(This,bMute) \ - ( (This)->lpVtbl -> SetMuteDebugOutput(This,bMute) ) - -#define ID3D12InfoQueue_GetMuteDebugOutput(This) \ - ( (This)->lpVtbl -> GetMuteDebugOutput(This) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12InfoQueue_INTERFACE_DEFINED__ */ - - -/* interface __MIDL_itf_d3d12sdklayers_0000_0013 */ -/* [local] */ - -#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */ -#pragma endregion -DEFINE_GUID(IID_ID3D12Debug,0x344488b7,0x6846,0x474b,0xb9,0x89,0xf0,0x27,0x44,0x82,0x45,0xe0); -DEFINE_GUID(IID_ID3D12Debug1,0xaffaa4ca,0x63fe,0x4d8e,0xb8,0xad,0x15,0x90,0x00,0xaf,0x43,0x04); -DEFINE_GUID(IID_ID3D12Debug2,0x93a665c4,0xa3b2,0x4e5d,0xb6,0x92,0xa2,0x6a,0xe1,0x4e,0x33,0x74); -DEFINE_GUID(IID_ID3D12Debug3,0x5cf4e58f,0xf671,0x4ff1,0xa5,0x42,0x36,0x86,0xe3,0xd1,0x53,0xd1); -DEFINE_GUID(IID_ID3D12DebugDevice1,0xa9b71770,0xd099,0x4a65,0xa6,0x98,0x3d,0xee,0x10,0x02,0x0f,0x88); -DEFINE_GUID(IID_ID3D12DebugDevice,0x3febd6dd,0x4973,0x4787,0x81,0x94,0xe4,0x5f,0x9e,0x28,0x92,0x3e); -DEFINE_GUID(IID_ID3D12DebugDevice2,0x60eccbc1,0x378d,0x4df1,0x89,0x4c,0xf8,0xac,0x5c,0xe4,0xd7,0xdd); -DEFINE_GUID(IID_ID3D12DebugCommandQueue,0x09e0bf36,0x54ac,0x484f,0x88,0x47,0x4b,0xae,0xea,0xb6,0x05,0x3a); -DEFINE_GUID(IID_ID3D12DebugCommandList1,0x102ca951,0x311b,0x4b01,0xb1,0x1f,0xec,0xb8,0x3e,0x06,0x1b,0x37); -DEFINE_GUID(IID_ID3D12DebugCommandList,0x09e0bf36,0x54ac,0x484f,0x88,0x47,0x4b,0xae,0xea,0xb6,0x05,0x3f); -DEFINE_GUID(IID_ID3D12DebugCommandList2,0xaeb575cf,0x4e06,0x48be,0xba,0x3b,0xc4,0x50,0xfc,0x96,0x65,0x2e); -DEFINE_GUID(IID_ID3D12SharingContract,0x0adf7d52,0x929c,0x4e61,0xad,0xdb,0xff,0xed,0x30,0xde,0x66,0xef); -DEFINE_GUID(IID_ID3D12InfoQueue,0x0742a90b,0xc387,0x483f,0xb9,0x46,0x30,0xa7,0xe4,0xe6,0x14,0x58); - - -extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0013_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0013_v0_0_s_ifspec; - -/* Additional Prototypes for ALL interfaces */ - -/* end of Additional Prototypes */ - -#ifdef __cplusplus -} -#endif - -#endif - - diff --git a/src/decomp/pc/gfx/dxsdk/d3dcommon.h b/src/decomp/pc/gfx/dxsdk/d3dcommon.h deleted file mode 100644 index 2db8805..0000000 --- a/src/decomp/pc/gfx/dxsdk/d3dcommon.h +++ /dev/null @@ -1,1009 +0,0 @@ - - -/* this ALWAYS GENERATED file contains the definitions for the interfaces */ - - - /* File created by MIDL compiler version 8.01.0622 */ -/* @@MIDL_FILE_HEADING( ) */ - - - -/* verify that the version is high enough to compile this file*/ -#ifndef __REQUIRED_RPCNDR_H_VERSION__ -#define __REQUIRED_RPCNDR_H_VERSION__ 500 -#endif - -/* verify that the version is high enough to compile this file*/ -#ifndef __REQUIRED_RPCSAL_H_VERSION__ -#define __REQUIRED_RPCSAL_H_VERSION__ 100 -#endif - -#include "rpc.h" -#include "rpcndr.h" - -#ifndef __RPCNDR_H_VERSION__ -#error this stub requires an updated version of -#endif /* __RPCNDR_H_VERSION__ */ - -#ifndef COM_NO_WINDOWS_H -#include "windows.h" -#include "ole2.h" -#endif /*COM_NO_WINDOWS_H*/ - -#ifndef __d3dcommon_h__ -#define __d3dcommon_h__ - -#if defined(_MSC_VER) && (_MSC_VER >= 1020) -#pragma once -#endif - -/* Forward Declarations */ - -#ifndef __ID3D10Blob_FWD_DEFINED__ -#define __ID3D10Blob_FWD_DEFINED__ -typedef interface ID3D10Blob ID3D10Blob; - -#endif /* __ID3D10Blob_FWD_DEFINED__ */ - - -#ifndef __ID3DDestructionNotifier_FWD_DEFINED__ -#define __ID3DDestructionNotifier_FWD_DEFINED__ -typedef interface ID3DDestructionNotifier ID3DDestructionNotifier; - -#endif /* __ID3DDestructionNotifier_FWD_DEFINED__ */ - - -/* header files for imported files */ -#include "oaidl.h" -#include "ocidl.h" - -#ifdef __cplusplus -extern "C"{ -#endif - - -/* interface __MIDL_itf_d3dcommon_0000_0000 */ -/* [local] */ - -typedef -enum D3D_DRIVER_TYPE - { - D3D_DRIVER_TYPE_UNKNOWN = 0, - D3D_DRIVER_TYPE_HARDWARE = ( D3D_DRIVER_TYPE_UNKNOWN + 1 ) , - D3D_DRIVER_TYPE_REFERENCE = ( D3D_DRIVER_TYPE_HARDWARE + 1 ) , - D3D_DRIVER_TYPE_NULL = ( D3D_DRIVER_TYPE_REFERENCE + 1 ) , - D3D_DRIVER_TYPE_SOFTWARE = ( D3D_DRIVER_TYPE_NULL + 1 ) , - D3D_DRIVER_TYPE_WARP = ( D3D_DRIVER_TYPE_SOFTWARE + 1 ) - } D3D_DRIVER_TYPE; - -typedef -enum D3D_FEATURE_LEVEL - { - D3D_FEATURE_LEVEL_1_0_CORE = 0x1000, - D3D_FEATURE_LEVEL_9_1 = 0x9100, - D3D_FEATURE_LEVEL_9_2 = 0x9200, - D3D_FEATURE_LEVEL_9_3 = 0x9300, - D3D_FEATURE_LEVEL_10_0 = 0xa000, - D3D_FEATURE_LEVEL_10_1 = 0xa100, - D3D_FEATURE_LEVEL_11_0 = 0xb000, - D3D_FEATURE_LEVEL_11_1 = 0xb100, - D3D_FEATURE_LEVEL_12_0 = 0xc000, - D3D_FEATURE_LEVEL_12_1 = 0xc100 - } D3D_FEATURE_LEVEL; - -#define D3D_FL9_1_REQ_TEXTURE1D_U_DIMENSION 2048 -#define D3D_FL9_3_REQ_TEXTURE1D_U_DIMENSION 4096 -#define D3D_FL9_1_REQ_TEXTURE2D_U_OR_V_DIMENSION 2048 -#define D3D_FL9_3_REQ_TEXTURE2D_U_OR_V_DIMENSION 4096 -#define D3D_FL9_1_REQ_TEXTURECUBE_DIMENSION 512 -#define D3D_FL9_3_REQ_TEXTURECUBE_DIMENSION 4096 -#define D3D_FL9_1_REQ_TEXTURE3D_U_V_OR_W_DIMENSION 256 -#define D3D_FL9_1_DEFAULT_MAX_ANISOTROPY 2 -#define D3D_FL9_1_IA_PRIMITIVE_MAX_COUNT 65535 -#define D3D_FL9_2_IA_PRIMITIVE_MAX_COUNT 1048575 -#define D3D_FL9_1_SIMULTANEOUS_RENDER_TARGET_COUNT 1 -#define D3D_FL9_3_SIMULTANEOUS_RENDER_TARGET_COUNT 4 -#define D3D_FL9_1_MAX_TEXTURE_REPEAT 128 -#define D3D_FL9_2_MAX_TEXTURE_REPEAT 2048 -#define D3D_FL9_3_MAX_TEXTURE_REPEAT 8192 -typedef -enum D3D_PRIMITIVE_TOPOLOGY - { - D3D_PRIMITIVE_TOPOLOGY_UNDEFINED = 0, - D3D_PRIMITIVE_TOPOLOGY_POINTLIST = 1, - D3D_PRIMITIVE_TOPOLOGY_LINELIST = 2, - D3D_PRIMITIVE_TOPOLOGY_LINESTRIP = 3, - D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST = 4, - D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP = 5, - D3D_PRIMITIVE_TOPOLOGY_LINELIST_ADJ = 10, - D3D_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ = 11, - D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ = 12, - D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ = 13, - D3D_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST = 33, - D3D_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST = 34, - D3D_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST = 35, - D3D_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST = 36, - D3D_PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST = 37, - D3D_PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST = 38, - D3D_PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST = 39, - D3D_PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST = 40, - D3D_PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST = 41, - D3D_PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST = 42, - D3D_PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST = 43, - D3D_PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST = 44, - D3D_PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST = 45, - D3D_PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST = 46, - D3D_PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST = 47, - D3D_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST = 48, - D3D_PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST = 49, - D3D_PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST = 50, - D3D_PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST = 51, - D3D_PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST = 52, - D3D_PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST = 53, - D3D_PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST = 54, - D3D_PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST = 55, - D3D_PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST = 56, - D3D_PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST = 57, - D3D_PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST = 58, - D3D_PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST = 59, - D3D_PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST = 60, - D3D_PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST = 61, - D3D_PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST = 62, - D3D_PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST = 63, - D3D_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST = 64, - D3D10_PRIMITIVE_TOPOLOGY_UNDEFINED = D3D_PRIMITIVE_TOPOLOGY_UNDEFINED, - D3D10_PRIMITIVE_TOPOLOGY_POINTLIST = D3D_PRIMITIVE_TOPOLOGY_POINTLIST, - D3D10_PRIMITIVE_TOPOLOGY_LINELIST = D3D_PRIMITIVE_TOPOLOGY_LINELIST, - D3D10_PRIMITIVE_TOPOLOGY_LINESTRIP = D3D_PRIMITIVE_TOPOLOGY_LINESTRIP, - D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST, - D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP = D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP, - D3D10_PRIMITIVE_TOPOLOGY_LINELIST_ADJ = D3D_PRIMITIVE_TOPOLOGY_LINELIST_ADJ, - D3D10_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ = D3D_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ, - D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ, - D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ = D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ, - D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED = D3D_PRIMITIVE_TOPOLOGY_UNDEFINED, - D3D11_PRIMITIVE_TOPOLOGY_POINTLIST = D3D_PRIMITIVE_TOPOLOGY_POINTLIST, - D3D11_PRIMITIVE_TOPOLOGY_LINELIST = D3D_PRIMITIVE_TOPOLOGY_LINELIST, - D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP = D3D_PRIMITIVE_TOPOLOGY_LINESTRIP, - D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST, - D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP = D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP, - D3D11_PRIMITIVE_TOPOLOGY_LINELIST_ADJ = D3D_PRIMITIVE_TOPOLOGY_LINELIST_ADJ, - D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ = D3D_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ, - D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ, - D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ = D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ, - D3D11_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST, - D3D11_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST, - D3D11_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST, - D3D11_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST, - D3D11_PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST, - D3D11_PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST, - D3D11_PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST, - D3D11_PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST, - D3D11_PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST, - D3D11_PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST, - D3D11_PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST, - D3D11_PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST, - D3D11_PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST, - D3D11_PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST, - D3D11_PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST, - D3D11_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST, - D3D11_PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST, - D3D11_PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST, - D3D11_PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST, - D3D11_PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST, - D3D11_PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST, - D3D11_PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST, - D3D11_PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST, - D3D11_PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST, - D3D11_PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST, - D3D11_PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST, - D3D11_PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST, - D3D11_PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST, - D3D11_PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST, - D3D11_PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST, - D3D11_PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST, - D3D11_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST = D3D_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST - } D3D_PRIMITIVE_TOPOLOGY; - -typedef -enum D3D_PRIMITIVE - { - D3D_PRIMITIVE_UNDEFINED = 0, - D3D_PRIMITIVE_POINT = 1, - D3D_PRIMITIVE_LINE = 2, - D3D_PRIMITIVE_TRIANGLE = 3, - D3D_PRIMITIVE_LINE_ADJ = 6, - D3D_PRIMITIVE_TRIANGLE_ADJ = 7, - D3D_PRIMITIVE_1_CONTROL_POINT_PATCH = 8, - D3D_PRIMITIVE_2_CONTROL_POINT_PATCH = 9, - D3D_PRIMITIVE_3_CONTROL_POINT_PATCH = 10, - D3D_PRIMITIVE_4_CONTROL_POINT_PATCH = 11, - D3D_PRIMITIVE_5_CONTROL_POINT_PATCH = 12, - D3D_PRIMITIVE_6_CONTROL_POINT_PATCH = 13, - D3D_PRIMITIVE_7_CONTROL_POINT_PATCH = 14, - D3D_PRIMITIVE_8_CONTROL_POINT_PATCH = 15, - D3D_PRIMITIVE_9_CONTROL_POINT_PATCH = 16, - D3D_PRIMITIVE_10_CONTROL_POINT_PATCH = 17, - D3D_PRIMITIVE_11_CONTROL_POINT_PATCH = 18, - D3D_PRIMITIVE_12_CONTROL_POINT_PATCH = 19, - D3D_PRIMITIVE_13_CONTROL_POINT_PATCH = 20, - D3D_PRIMITIVE_14_CONTROL_POINT_PATCH = 21, - D3D_PRIMITIVE_15_CONTROL_POINT_PATCH = 22, - D3D_PRIMITIVE_16_CONTROL_POINT_PATCH = 23, - D3D_PRIMITIVE_17_CONTROL_POINT_PATCH = 24, - D3D_PRIMITIVE_18_CONTROL_POINT_PATCH = 25, - D3D_PRIMITIVE_19_CONTROL_POINT_PATCH = 26, - D3D_PRIMITIVE_20_CONTROL_POINT_PATCH = 27, - D3D_PRIMITIVE_21_CONTROL_POINT_PATCH = 28, - D3D_PRIMITIVE_22_CONTROL_POINT_PATCH = 29, - D3D_PRIMITIVE_23_CONTROL_POINT_PATCH = 30, - D3D_PRIMITIVE_24_CONTROL_POINT_PATCH = 31, - D3D_PRIMITIVE_25_CONTROL_POINT_PATCH = 32, - D3D_PRIMITIVE_26_CONTROL_POINT_PATCH = 33, - D3D_PRIMITIVE_27_CONTROL_POINT_PATCH = 34, - D3D_PRIMITIVE_28_CONTROL_POINT_PATCH = 35, - D3D_PRIMITIVE_29_CONTROL_POINT_PATCH = 36, - D3D_PRIMITIVE_30_CONTROL_POINT_PATCH = 37, - D3D_PRIMITIVE_31_CONTROL_POINT_PATCH = 38, - D3D_PRIMITIVE_32_CONTROL_POINT_PATCH = 39, - D3D10_PRIMITIVE_UNDEFINED = D3D_PRIMITIVE_UNDEFINED, - D3D10_PRIMITIVE_POINT = D3D_PRIMITIVE_POINT, - D3D10_PRIMITIVE_LINE = D3D_PRIMITIVE_LINE, - D3D10_PRIMITIVE_TRIANGLE = D3D_PRIMITIVE_TRIANGLE, - D3D10_PRIMITIVE_LINE_ADJ = D3D_PRIMITIVE_LINE_ADJ, - D3D10_PRIMITIVE_TRIANGLE_ADJ = D3D_PRIMITIVE_TRIANGLE_ADJ, - D3D11_PRIMITIVE_UNDEFINED = D3D_PRIMITIVE_UNDEFINED, - D3D11_PRIMITIVE_POINT = D3D_PRIMITIVE_POINT, - D3D11_PRIMITIVE_LINE = D3D_PRIMITIVE_LINE, - D3D11_PRIMITIVE_TRIANGLE = D3D_PRIMITIVE_TRIANGLE, - D3D11_PRIMITIVE_LINE_ADJ = D3D_PRIMITIVE_LINE_ADJ, - D3D11_PRIMITIVE_TRIANGLE_ADJ = D3D_PRIMITIVE_TRIANGLE_ADJ, - D3D11_PRIMITIVE_1_CONTROL_POINT_PATCH = D3D_PRIMITIVE_1_CONTROL_POINT_PATCH, - D3D11_PRIMITIVE_2_CONTROL_POINT_PATCH = D3D_PRIMITIVE_2_CONTROL_POINT_PATCH, - D3D11_PRIMITIVE_3_CONTROL_POINT_PATCH = D3D_PRIMITIVE_3_CONTROL_POINT_PATCH, - D3D11_PRIMITIVE_4_CONTROL_POINT_PATCH = D3D_PRIMITIVE_4_CONTROL_POINT_PATCH, - D3D11_PRIMITIVE_5_CONTROL_POINT_PATCH = D3D_PRIMITIVE_5_CONTROL_POINT_PATCH, - D3D11_PRIMITIVE_6_CONTROL_POINT_PATCH = D3D_PRIMITIVE_6_CONTROL_POINT_PATCH, - D3D11_PRIMITIVE_7_CONTROL_POINT_PATCH = D3D_PRIMITIVE_7_CONTROL_POINT_PATCH, - D3D11_PRIMITIVE_8_CONTROL_POINT_PATCH = D3D_PRIMITIVE_8_CONTROL_POINT_PATCH, - D3D11_PRIMITIVE_9_CONTROL_POINT_PATCH = D3D_PRIMITIVE_9_CONTROL_POINT_PATCH, - D3D11_PRIMITIVE_10_CONTROL_POINT_PATCH = D3D_PRIMITIVE_10_CONTROL_POINT_PATCH, - D3D11_PRIMITIVE_11_CONTROL_POINT_PATCH = D3D_PRIMITIVE_11_CONTROL_POINT_PATCH, - D3D11_PRIMITIVE_12_CONTROL_POINT_PATCH = D3D_PRIMITIVE_12_CONTROL_POINT_PATCH, - D3D11_PRIMITIVE_13_CONTROL_POINT_PATCH = D3D_PRIMITIVE_13_CONTROL_POINT_PATCH, - D3D11_PRIMITIVE_14_CONTROL_POINT_PATCH = D3D_PRIMITIVE_14_CONTROL_POINT_PATCH, - D3D11_PRIMITIVE_15_CONTROL_POINT_PATCH = D3D_PRIMITIVE_15_CONTROL_POINT_PATCH, - D3D11_PRIMITIVE_16_CONTROL_POINT_PATCH = D3D_PRIMITIVE_16_CONTROL_POINT_PATCH, - D3D11_PRIMITIVE_17_CONTROL_POINT_PATCH = D3D_PRIMITIVE_17_CONTROL_POINT_PATCH, - D3D11_PRIMITIVE_18_CONTROL_POINT_PATCH = D3D_PRIMITIVE_18_CONTROL_POINT_PATCH, - D3D11_PRIMITIVE_19_CONTROL_POINT_PATCH = D3D_PRIMITIVE_19_CONTROL_POINT_PATCH, - D3D11_PRIMITIVE_20_CONTROL_POINT_PATCH = D3D_PRIMITIVE_20_CONTROL_POINT_PATCH, - D3D11_PRIMITIVE_21_CONTROL_POINT_PATCH = D3D_PRIMITIVE_21_CONTROL_POINT_PATCH, - D3D11_PRIMITIVE_22_CONTROL_POINT_PATCH = D3D_PRIMITIVE_22_CONTROL_POINT_PATCH, - D3D11_PRIMITIVE_23_CONTROL_POINT_PATCH = D3D_PRIMITIVE_23_CONTROL_POINT_PATCH, - D3D11_PRIMITIVE_24_CONTROL_POINT_PATCH = D3D_PRIMITIVE_24_CONTROL_POINT_PATCH, - D3D11_PRIMITIVE_25_CONTROL_POINT_PATCH = D3D_PRIMITIVE_25_CONTROL_POINT_PATCH, - D3D11_PRIMITIVE_26_CONTROL_POINT_PATCH = D3D_PRIMITIVE_26_CONTROL_POINT_PATCH, - D3D11_PRIMITIVE_27_CONTROL_POINT_PATCH = D3D_PRIMITIVE_27_CONTROL_POINT_PATCH, - D3D11_PRIMITIVE_28_CONTROL_POINT_PATCH = D3D_PRIMITIVE_28_CONTROL_POINT_PATCH, - D3D11_PRIMITIVE_29_CONTROL_POINT_PATCH = D3D_PRIMITIVE_29_CONTROL_POINT_PATCH, - D3D11_PRIMITIVE_30_CONTROL_POINT_PATCH = D3D_PRIMITIVE_30_CONTROL_POINT_PATCH, - D3D11_PRIMITIVE_31_CONTROL_POINT_PATCH = D3D_PRIMITIVE_31_CONTROL_POINT_PATCH, - D3D11_PRIMITIVE_32_CONTROL_POINT_PATCH = D3D_PRIMITIVE_32_CONTROL_POINT_PATCH - } D3D_PRIMITIVE; - -typedef -enum D3D_SRV_DIMENSION - { - D3D_SRV_DIMENSION_UNKNOWN = 0, - D3D_SRV_DIMENSION_BUFFER = 1, - D3D_SRV_DIMENSION_TEXTURE1D = 2, - D3D_SRV_DIMENSION_TEXTURE1DARRAY = 3, - D3D_SRV_DIMENSION_TEXTURE2D = 4, - D3D_SRV_DIMENSION_TEXTURE2DARRAY = 5, - D3D_SRV_DIMENSION_TEXTURE2DMS = 6, - D3D_SRV_DIMENSION_TEXTURE2DMSARRAY = 7, - D3D_SRV_DIMENSION_TEXTURE3D = 8, - D3D_SRV_DIMENSION_TEXTURECUBE = 9, - D3D_SRV_DIMENSION_TEXTURECUBEARRAY = 10, - D3D_SRV_DIMENSION_BUFFEREX = 11, - D3D10_SRV_DIMENSION_UNKNOWN = D3D_SRV_DIMENSION_UNKNOWN, - D3D10_SRV_DIMENSION_BUFFER = D3D_SRV_DIMENSION_BUFFER, - D3D10_SRV_DIMENSION_TEXTURE1D = D3D_SRV_DIMENSION_TEXTURE1D, - D3D10_SRV_DIMENSION_TEXTURE1DARRAY = D3D_SRV_DIMENSION_TEXTURE1DARRAY, - D3D10_SRV_DIMENSION_TEXTURE2D = D3D_SRV_DIMENSION_TEXTURE2D, - D3D10_SRV_DIMENSION_TEXTURE2DARRAY = D3D_SRV_DIMENSION_TEXTURE2DARRAY, - D3D10_SRV_DIMENSION_TEXTURE2DMS = D3D_SRV_DIMENSION_TEXTURE2DMS, - D3D10_SRV_DIMENSION_TEXTURE2DMSARRAY = D3D_SRV_DIMENSION_TEXTURE2DMSARRAY, - D3D10_SRV_DIMENSION_TEXTURE3D = D3D_SRV_DIMENSION_TEXTURE3D, - D3D10_SRV_DIMENSION_TEXTURECUBE = D3D_SRV_DIMENSION_TEXTURECUBE, - D3D10_1_SRV_DIMENSION_UNKNOWN = D3D_SRV_DIMENSION_UNKNOWN, - D3D10_1_SRV_DIMENSION_BUFFER = D3D_SRV_DIMENSION_BUFFER, - D3D10_1_SRV_DIMENSION_TEXTURE1D = D3D_SRV_DIMENSION_TEXTURE1D, - D3D10_1_SRV_DIMENSION_TEXTURE1DARRAY = D3D_SRV_DIMENSION_TEXTURE1DARRAY, - D3D10_1_SRV_DIMENSION_TEXTURE2D = D3D_SRV_DIMENSION_TEXTURE2D, - D3D10_1_SRV_DIMENSION_TEXTURE2DARRAY = D3D_SRV_DIMENSION_TEXTURE2DARRAY, - D3D10_1_SRV_DIMENSION_TEXTURE2DMS = D3D_SRV_DIMENSION_TEXTURE2DMS, - D3D10_1_SRV_DIMENSION_TEXTURE2DMSARRAY = D3D_SRV_DIMENSION_TEXTURE2DMSARRAY, - D3D10_1_SRV_DIMENSION_TEXTURE3D = D3D_SRV_DIMENSION_TEXTURE3D, - D3D10_1_SRV_DIMENSION_TEXTURECUBE = D3D_SRV_DIMENSION_TEXTURECUBE, - D3D10_1_SRV_DIMENSION_TEXTURECUBEARRAY = D3D_SRV_DIMENSION_TEXTURECUBEARRAY, - D3D11_SRV_DIMENSION_UNKNOWN = D3D_SRV_DIMENSION_UNKNOWN, - D3D11_SRV_DIMENSION_BUFFER = D3D_SRV_DIMENSION_BUFFER, - D3D11_SRV_DIMENSION_TEXTURE1D = D3D_SRV_DIMENSION_TEXTURE1D, - D3D11_SRV_DIMENSION_TEXTURE1DARRAY = D3D_SRV_DIMENSION_TEXTURE1DARRAY, - D3D11_SRV_DIMENSION_TEXTURE2D = D3D_SRV_DIMENSION_TEXTURE2D, - D3D11_SRV_DIMENSION_TEXTURE2DARRAY = D3D_SRV_DIMENSION_TEXTURE2DARRAY, - D3D11_SRV_DIMENSION_TEXTURE2DMS = D3D_SRV_DIMENSION_TEXTURE2DMS, - D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY = D3D_SRV_DIMENSION_TEXTURE2DMSARRAY, - D3D11_SRV_DIMENSION_TEXTURE3D = D3D_SRV_DIMENSION_TEXTURE3D, - D3D11_SRV_DIMENSION_TEXTURECUBE = D3D_SRV_DIMENSION_TEXTURECUBE, - D3D11_SRV_DIMENSION_TEXTURECUBEARRAY = D3D_SRV_DIMENSION_TEXTURECUBEARRAY, - D3D11_SRV_DIMENSION_BUFFEREX = D3D_SRV_DIMENSION_BUFFEREX - } D3D_SRV_DIMENSION; - -typedef struct _D3D_SHADER_MACRO - { - LPCSTR Name; - LPCSTR Definition; - } D3D_SHADER_MACRO; - -typedef struct _D3D_SHADER_MACRO *LPD3D_SHADER_MACRO; - -DEFINE_GUID(IID_ID3D10Blob, 0x8ba5fb08, 0x5195, 0x40e2, 0xac, 0x58, 0xd, 0x98, 0x9c, 0x3a, 0x1, 0x2); - - -extern RPC_IF_HANDLE __MIDL_itf_d3dcommon_0000_0000_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3dcommon_0000_0000_v0_0_s_ifspec; - -#ifndef __ID3D10Blob_INTERFACE_DEFINED__ -#define __ID3D10Blob_INTERFACE_DEFINED__ - -/* interface ID3D10Blob */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D10Blob; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("8BA5FB08-5195-40e2-AC58-0D989C3A0102") - ID3D10Blob : public IUnknown - { - public: - virtual LPVOID STDMETHODCALLTYPE GetBufferPointer( void) = 0; - - virtual SIZE_T STDMETHODCALLTYPE GetBufferSize( void) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3D10BlobVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D10Blob * This, - /* [in] */ REFIID riid, - /* [annotation][iid_is][out] */ - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D10Blob * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D10Blob * This); - - LPVOID ( STDMETHODCALLTYPE *GetBufferPointer )( - ID3D10Blob * This); - - SIZE_T ( STDMETHODCALLTYPE *GetBufferSize )( - ID3D10Blob * This); - - END_INTERFACE - } ID3D10BlobVtbl; - - interface ID3D10Blob - { - CONST_VTBL struct ID3D10BlobVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D10Blob_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D10Blob_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D10Blob_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D10Blob_GetBufferPointer(This) \ - ( (This)->lpVtbl -> GetBufferPointer(This) ) - -#define ID3D10Blob_GetBufferSize(This) \ - ( (This)->lpVtbl -> GetBufferSize(This) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D10Blob_INTERFACE_DEFINED__ */ - - -/* interface __MIDL_itf_d3dcommon_0000_0001 */ -/* [local] */ - -typedef interface ID3D10Blob* LPD3D10BLOB; -typedef ID3D10Blob ID3DBlob; - -typedef ID3DBlob* LPD3DBLOB; -#define IID_ID3DBlob IID_ID3D10Blob -typedef void ( __stdcall *PFN_DESTRUCTION_CALLBACK )( - void *pData); - - - -extern RPC_IF_HANDLE __MIDL_itf_d3dcommon_0000_0001_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3dcommon_0000_0001_v0_0_s_ifspec; - -#ifndef __ID3DDestructionNotifier_INTERFACE_DEFINED__ -#define __ID3DDestructionNotifier_INTERFACE_DEFINED__ - -/* interface ID3DDestructionNotifier */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3DDestructionNotifier; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("a06eb39a-50da-425b-8c31-4eecd6c270f3") - ID3DDestructionNotifier : public IUnknown - { - public: - virtual HRESULT STDMETHODCALLTYPE RegisterDestructionCallback( - /* [annotation] */ - _In_ PFN_DESTRUCTION_CALLBACK callbackFn, - /* [annotation] */ - _In_ void *pData, - /* [annotation] */ - _Out_ UINT *pCallbackID) = 0; - - virtual HRESULT STDMETHODCALLTYPE UnregisterDestructionCallback( - /* [annotation] */ - _In_ UINT callbackID) = 0; - - }; - - -#else /* C style interface */ - - typedef struct ID3DDestructionNotifierVtbl - { - BEGIN_INTERFACE - - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3DDestructionNotifier * This, - /* [in] */ REFIID riid, - /* [annotation][iid_is][out] */ - _COM_Outptr_ void **ppvObject); - - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3DDestructionNotifier * This); - - ULONG ( STDMETHODCALLTYPE *Release )( - ID3DDestructionNotifier * This); - - HRESULT ( STDMETHODCALLTYPE *RegisterDestructionCallback )( - ID3DDestructionNotifier * This, - /* [annotation] */ - _In_ PFN_DESTRUCTION_CALLBACK callbackFn, - /* [annotation] */ - _In_ void *pData, - /* [annotation] */ - _Out_ UINT *pCallbackID); - - HRESULT ( STDMETHODCALLTYPE *UnregisterDestructionCallback )( - ID3DDestructionNotifier * This, - /* [annotation] */ - _In_ UINT callbackID); - - END_INTERFACE - } ID3DDestructionNotifierVtbl; - - interface ID3DDestructionNotifier - { - CONST_VTBL struct ID3DDestructionNotifierVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3DDestructionNotifier_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3DDestructionNotifier_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3DDestructionNotifier_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3DDestructionNotifier_RegisterDestructionCallback(This,callbackFn,pData,pCallbackID) \ - ( (This)->lpVtbl -> RegisterDestructionCallback(This,callbackFn,pData,pCallbackID) ) - -#define ID3DDestructionNotifier_UnregisterDestructionCallback(This,callbackID) \ - ( (This)->lpVtbl -> UnregisterDestructionCallback(This,callbackID) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3DDestructionNotifier_INTERFACE_DEFINED__ */ - - -/* interface __MIDL_itf_d3dcommon_0000_0002 */ -/* [local] */ - -typedef -enum _D3D_INCLUDE_TYPE - { - D3D_INCLUDE_LOCAL = 0, - D3D_INCLUDE_SYSTEM = ( D3D_INCLUDE_LOCAL + 1 ) , - D3D10_INCLUDE_LOCAL = D3D_INCLUDE_LOCAL, - D3D10_INCLUDE_SYSTEM = D3D_INCLUDE_SYSTEM, - D3D_INCLUDE_FORCE_DWORD = 0x7fffffff - } D3D_INCLUDE_TYPE; - -typedef interface ID3DInclude ID3DInclude; -#undef INTERFACE -#define INTERFACE ID3DInclude -DECLARE_INTERFACE(ID3DInclude) -{ - STDMETHOD(Open)(THIS_ D3D_INCLUDE_TYPE IncludeType, LPCSTR pFileName, LPCVOID pParentData, LPCVOID *ppData, UINT *pBytes) PURE; - STDMETHOD(Close)(THIS_ LPCVOID pData) PURE; -}; -typedef ID3DInclude* LPD3DINCLUDE; -typedef -enum _D3D_SHADER_VARIABLE_CLASS - { - D3D_SVC_SCALAR = 0, - D3D_SVC_VECTOR = ( D3D_SVC_SCALAR + 1 ) , - D3D_SVC_MATRIX_ROWS = ( D3D_SVC_VECTOR + 1 ) , - D3D_SVC_MATRIX_COLUMNS = ( D3D_SVC_MATRIX_ROWS + 1 ) , - D3D_SVC_OBJECT = ( D3D_SVC_MATRIX_COLUMNS + 1 ) , - D3D_SVC_STRUCT = ( D3D_SVC_OBJECT + 1 ) , - D3D_SVC_INTERFACE_CLASS = ( D3D_SVC_STRUCT + 1 ) , - D3D_SVC_INTERFACE_POINTER = ( D3D_SVC_INTERFACE_CLASS + 1 ) , - D3D10_SVC_SCALAR = D3D_SVC_SCALAR, - D3D10_SVC_VECTOR = D3D_SVC_VECTOR, - D3D10_SVC_MATRIX_ROWS = D3D_SVC_MATRIX_ROWS, - D3D10_SVC_MATRIX_COLUMNS = D3D_SVC_MATRIX_COLUMNS, - D3D10_SVC_OBJECT = D3D_SVC_OBJECT, - D3D10_SVC_STRUCT = D3D_SVC_STRUCT, - D3D11_SVC_INTERFACE_CLASS = D3D_SVC_INTERFACE_CLASS, - D3D11_SVC_INTERFACE_POINTER = D3D_SVC_INTERFACE_POINTER, - D3D_SVC_FORCE_DWORD = 0x7fffffff - } D3D_SHADER_VARIABLE_CLASS; - -typedef -enum _D3D_SHADER_VARIABLE_FLAGS - { - D3D_SVF_USERPACKED = 1, - D3D_SVF_USED = 2, - D3D_SVF_INTERFACE_POINTER = 4, - D3D_SVF_INTERFACE_PARAMETER = 8, - D3D10_SVF_USERPACKED = D3D_SVF_USERPACKED, - D3D10_SVF_USED = D3D_SVF_USED, - D3D11_SVF_INTERFACE_POINTER = D3D_SVF_INTERFACE_POINTER, - D3D11_SVF_INTERFACE_PARAMETER = D3D_SVF_INTERFACE_PARAMETER, - D3D_SVF_FORCE_DWORD = 0x7fffffff - } D3D_SHADER_VARIABLE_FLAGS; - -typedef -enum _D3D_SHADER_VARIABLE_TYPE - { - D3D_SVT_VOID = 0, - D3D_SVT_BOOL = 1, - D3D_SVT_INT = 2, - D3D_SVT_FLOAT = 3, - D3D_SVT_STRING = 4, - D3D_SVT_TEXTURE = 5, - D3D_SVT_TEXTURE1D = 6, - D3D_SVT_TEXTURE2D = 7, - D3D_SVT_TEXTURE3D = 8, - D3D_SVT_TEXTURECUBE = 9, - D3D_SVT_SAMPLER = 10, - D3D_SVT_SAMPLER1D = 11, - D3D_SVT_SAMPLER2D = 12, - D3D_SVT_SAMPLER3D = 13, - D3D_SVT_SAMPLERCUBE = 14, - D3D_SVT_PIXELSHADER = 15, - D3D_SVT_VERTEXSHADER = 16, - D3D_SVT_PIXELFRAGMENT = 17, - D3D_SVT_VERTEXFRAGMENT = 18, - D3D_SVT_UINT = 19, - D3D_SVT_UINT8 = 20, - D3D_SVT_GEOMETRYSHADER = 21, - D3D_SVT_RASTERIZER = 22, - D3D_SVT_DEPTHSTENCIL = 23, - D3D_SVT_BLEND = 24, - D3D_SVT_BUFFER = 25, - D3D_SVT_CBUFFER = 26, - D3D_SVT_TBUFFER = 27, - D3D_SVT_TEXTURE1DARRAY = 28, - D3D_SVT_TEXTURE2DARRAY = 29, - D3D_SVT_RENDERTARGETVIEW = 30, - D3D_SVT_DEPTHSTENCILVIEW = 31, - D3D_SVT_TEXTURE2DMS = 32, - D3D_SVT_TEXTURE2DMSARRAY = 33, - D3D_SVT_TEXTURECUBEARRAY = 34, - D3D_SVT_HULLSHADER = 35, - D3D_SVT_DOMAINSHADER = 36, - D3D_SVT_INTERFACE_POINTER = 37, - D3D_SVT_COMPUTESHADER = 38, - D3D_SVT_DOUBLE = 39, - D3D_SVT_RWTEXTURE1D = 40, - D3D_SVT_RWTEXTURE1DARRAY = 41, - D3D_SVT_RWTEXTURE2D = 42, - D3D_SVT_RWTEXTURE2DARRAY = 43, - D3D_SVT_RWTEXTURE3D = 44, - D3D_SVT_RWBUFFER = 45, - D3D_SVT_BYTEADDRESS_BUFFER = 46, - D3D_SVT_RWBYTEADDRESS_BUFFER = 47, - D3D_SVT_STRUCTURED_BUFFER = 48, - D3D_SVT_RWSTRUCTURED_BUFFER = 49, - D3D_SVT_APPEND_STRUCTURED_BUFFER = 50, - D3D_SVT_CONSUME_STRUCTURED_BUFFER = 51, - D3D_SVT_MIN8FLOAT = 52, - D3D_SVT_MIN10FLOAT = 53, - D3D_SVT_MIN16FLOAT = 54, - D3D_SVT_MIN12INT = 55, - D3D_SVT_MIN16INT = 56, - D3D_SVT_MIN16UINT = 57, - D3D10_SVT_VOID = D3D_SVT_VOID, - D3D10_SVT_BOOL = D3D_SVT_BOOL, - D3D10_SVT_INT = D3D_SVT_INT, - D3D10_SVT_FLOAT = D3D_SVT_FLOAT, - D3D10_SVT_STRING = D3D_SVT_STRING, - D3D10_SVT_TEXTURE = D3D_SVT_TEXTURE, - D3D10_SVT_TEXTURE1D = D3D_SVT_TEXTURE1D, - D3D10_SVT_TEXTURE2D = D3D_SVT_TEXTURE2D, - D3D10_SVT_TEXTURE3D = D3D_SVT_TEXTURE3D, - D3D10_SVT_TEXTURECUBE = D3D_SVT_TEXTURECUBE, - D3D10_SVT_SAMPLER = D3D_SVT_SAMPLER, - D3D10_SVT_SAMPLER1D = D3D_SVT_SAMPLER1D, - D3D10_SVT_SAMPLER2D = D3D_SVT_SAMPLER2D, - D3D10_SVT_SAMPLER3D = D3D_SVT_SAMPLER3D, - D3D10_SVT_SAMPLERCUBE = D3D_SVT_SAMPLERCUBE, - D3D10_SVT_PIXELSHADER = D3D_SVT_PIXELSHADER, - D3D10_SVT_VERTEXSHADER = D3D_SVT_VERTEXSHADER, - D3D10_SVT_PIXELFRAGMENT = D3D_SVT_PIXELFRAGMENT, - D3D10_SVT_VERTEXFRAGMENT = D3D_SVT_VERTEXFRAGMENT, - D3D10_SVT_UINT = D3D_SVT_UINT, - D3D10_SVT_UINT8 = D3D_SVT_UINT8, - D3D10_SVT_GEOMETRYSHADER = D3D_SVT_GEOMETRYSHADER, - D3D10_SVT_RASTERIZER = D3D_SVT_RASTERIZER, - D3D10_SVT_DEPTHSTENCIL = D3D_SVT_DEPTHSTENCIL, - D3D10_SVT_BLEND = D3D_SVT_BLEND, - D3D10_SVT_BUFFER = D3D_SVT_BUFFER, - D3D10_SVT_CBUFFER = D3D_SVT_CBUFFER, - D3D10_SVT_TBUFFER = D3D_SVT_TBUFFER, - D3D10_SVT_TEXTURE1DARRAY = D3D_SVT_TEXTURE1DARRAY, - D3D10_SVT_TEXTURE2DARRAY = D3D_SVT_TEXTURE2DARRAY, - D3D10_SVT_RENDERTARGETVIEW = D3D_SVT_RENDERTARGETVIEW, - D3D10_SVT_DEPTHSTENCILVIEW = D3D_SVT_DEPTHSTENCILVIEW, - D3D10_SVT_TEXTURE2DMS = D3D_SVT_TEXTURE2DMS, - D3D10_SVT_TEXTURE2DMSARRAY = D3D_SVT_TEXTURE2DMSARRAY, - D3D10_SVT_TEXTURECUBEARRAY = D3D_SVT_TEXTURECUBEARRAY, - D3D11_SVT_HULLSHADER = D3D_SVT_HULLSHADER, - D3D11_SVT_DOMAINSHADER = D3D_SVT_DOMAINSHADER, - D3D11_SVT_INTERFACE_POINTER = D3D_SVT_INTERFACE_POINTER, - D3D11_SVT_COMPUTESHADER = D3D_SVT_COMPUTESHADER, - D3D11_SVT_DOUBLE = D3D_SVT_DOUBLE, - D3D11_SVT_RWTEXTURE1D = D3D_SVT_RWTEXTURE1D, - D3D11_SVT_RWTEXTURE1DARRAY = D3D_SVT_RWTEXTURE1DARRAY, - D3D11_SVT_RWTEXTURE2D = D3D_SVT_RWTEXTURE2D, - D3D11_SVT_RWTEXTURE2DARRAY = D3D_SVT_RWTEXTURE2DARRAY, - D3D11_SVT_RWTEXTURE3D = D3D_SVT_RWTEXTURE3D, - D3D11_SVT_RWBUFFER = D3D_SVT_RWBUFFER, - D3D11_SVT_BYTEADDRESS_BUFFER = D3D_SVT_BYTEADDRESS_BUFFER, - D3D11_SVT_RWBYTEADDRESS_BUFFER = D3D_SVT_RWBYTEADDRESS_BUFFER, - D3D11_SVT_STRUCTURED_BUFFER = D3D_SVT_STRUCTURED_BUFFER, - D3D11_SVT_RWSTRUCTURED_BUFFER = D3D_SVT_RWSTRUCTURED_BUFFER, - D3D11_SVT_APPEND_STRUCTURED_BUFFER = D3D_SVT_APPEND_STRUCTURED_BUFFER, - D3D11_SVT_CONSUME_STRUCTURED_BUFFER = D3D_SVT_CONSUME_STRUCTURED_BUFFER, - D3D_SVT_FORCE_DWORD = 0x7fffffff - } D3D_SHADER_VARIABLE_TYPE; - -typedef -enum _D3D_SHADER_INPUT_FLAGS - { - D3D_SIF_USERPACKED = 0x1, - D3D_SIF_COMPARISON_SAMPLER = 0x2, - D3D_SIF_TEXTURE_COMPONENT_0 = 0x4, - D3D_SIF_TEXTURE_COMPONENT_1 = 0x8, - D3D_SIF_TEXTURE_COMPONENTS = 0xc, - D3D_SIF_UNUSED = 0x10, - D3D10_SIF_USERPACKED = D3D_SIF_USERPACKED, - D3D10_SIF_COMPARISON_SAMPLER = D3D_SIF_COMPARISON_SAMPLER, - D3D10_SIF_TEXTURE_COMPONENT_0 = D3D_SIF_TEXTURE_COMPONENT_0, - D3D10_SIF_TEXTURE_COMPONENT_1 = D3D_SIF_TEXTURE_COMPONENT_1, - D3D10_SIF_TEXTURE_COMPONENTS = D3D_SIF_TEXTURE_COMPONENTS, - D3D_SIF_FORCE_DWORD = 0x7fffffff - } D3D_SHADER_INPUT_FLAGS; - -typedef -enum _D3D_SHADER_INPUT_TYPE - { - D3D_SIT_CBUFFER = 0, - D3D_SIT_TBUFFER = ( D3D_SIT_CBUFFER + 1 ) , - D3D_SIT_TEXTURE = ( D3D_SIT_TBUFFER + 1 ) , - D3D_SIT_SAMPLER = ( D3D_SIT_TEXTURE + 1 ) , - D3D_SIT_UAV_RWTYPED = ( D3D_SIT_SAMPLER + 1 ) , - D3D_SIT_STRUCTURED = ( D3D_SIT_UAV_RWTYPED + 1 ) , - D3D_SIT_UAV_RWSTRUCTURED = ( D3D_SIT_STRUCTURED + 1 ) , - D3D_SIT_BYTEADDRESS = ( D3D_SIT_UAV_RWSTRUCTURED + 1 ) , - D3D_SIT_UAV_RWBYTEADDRESS = ( D3D_SIT_BYTEADDRESS + 1 ) , - D3D_SIT_UAV_APPEND_STRUCTURED = ( D3D_SIT_UAV_RWBYTEADDRESS + 1 ) , - D3D_SIT_UAV_CONSUME_STRUCTURED = ( D3D_SIT_UAV_APPEND_STRUCTURED + 1 ) , - D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER = ( D3D_SIT_UAV_CONSUME_STRUCTURED + 1 ) , - D3D10_SIT_CBUFFER = D3D_SIT_CBUFFER, - D3D10_SIT_TBUFFER = D3D_SIT_TBUFFER, - D3D10_SIT_TEXTURE = D3D_SIT_TEXTURE, - D3D10_SIT_SAMPLER = D3D_SIT_SAMPLER, - D3D11_SIT_UAV_RWTYPED = D3D_SIT_UAV_RWTYPED, - D3D11_SIT_STRUCTURED = D3D_SIT_STRUCTURED, - D3D11_SIT_UAV_RWSTRUCTURED = D3D_SIT_UAV_RWSTRUCTURED, - D3D11_SIT_BYTEADDRESS = D3D_SIT_BYTEADDRESS, - D3D11_SIT_UAV_RWBYTEADDRESS = D3D_SIT_UAV_RWBYTEADDRESS, - D3D11_SIT_UAV_APPEND_STRUCTURED = D3D_SIT_UAV_APPEND_STRUCTURED, - D3D11_SIT_UAV_CONSUME_STRUCTURED = D3D_SIT_UAV_CONSUME_STRUCTURED, - D3D11_SIT_UAV_RWSTRUCTURED_WITH_COUNTER = D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER - } D3D_SHADER_INPUT_TYPE; - -typedef -enum _D3D_SHADER_CBUFFER_FLAGS - { - D3D_CBF_USERPACKED = 1, - D3D10_CBF_USERPACKED = D3D_CBF_USERPACKED, - D3D_CBF_FORCE_DWORD = 0x7fffffff - } D3D_SHADER_CBUFFER_FLAGS; - -typedef -enum _D3D_CBUFFER_TYPE - { - D3D_CT_CBUFFER = 0, - D3D_CT_TBUFFER = ( D3D_CT_CBUFFER + 1 ) , - D3D_CT_INTERFACE_POINTERS = ( D3D_CT_TBUFFER + 1 ) , - D3D_CT_RESOURCE_BIND_INFO = ( D3D_CT_INTERFACE_POINTERS + 1 ) , - D3D10_CT_CBUFFER = D3D_CT_CBUFFER, - D3D10_CT_TBUFFER = D3D_CT_TBUFFER, - D3D11_CT_CBUFFER = D3D_CT_CBUFFER, - D3D11_CT_TBUFFER = D3D_CT_TBUFFER, - D3D11_CT_INTERFACE_POINTERS = D3D_CT_INTERFACE_POINTERS, - D3D11_CT_RESOURCE_BIND_INFO = D3D_CT_RESOURCE_BIND_INFO - } D3D_CBUFFER_TYPE; - -typedef -enum D3D_NAME - { - D3D_NAME_UNDEFINED = 0, - D3D_NAME_POSITION = 1, - D3D_NAME_CLIP_DISTANCE = 2, - D3D_NAME_CULL_DISTANCE = 3, - D3D_NAME_RENDER_TARGET_ARRAY_INDEX = 4, - D3D_NAME_VIEWPORT_ARRAY_INDEX = 5, - D3D_NAME_VERTEX_ID = 6, - D3D_NAME_PRIMITIVE_ID = 7, - D3D_NAME_INSTANCE_ID = 8, - D3D_NAME_IS_FRONT_FACE = 9, - D3D_NAME_SAMPLE_INDEX = 10, - D3D_NAME_FINAL_QUAD_EDGE_TESSFACTOR = 11, - D3D_NAME_FINAL_QUAD_INSIDE_TESSFACTOR = 12, - D3D_NAME_FINAL_TRI_EDGE_TESSFACTOR = 13, - D3D_NAME_FINAL_TRI_INSIDE_TESSFACTOR = 14, - D3D_NAME_FINAL_LINE_DETAIL_TESSFACTOR = 15, - D3D_NAME_FINAL_LINE_DENSITY_TESSFACTOR = 16, - D3D_NAME_BARYCENTRICS = 23, - D3D_NAME_SHADINGRATE = 24, - D3D_NAME_TARGET = 64, - D3D_NAME_DEPTH = 65, - D3D_NAME_COVERAGE = 66, - D3D_NAME_DEPTH_GREATER_EQUAL = 67, - D3D_NAME_DEPTH_LESS_EQUAL = 68, - D3D_NAME_STENCIL_REF = 69, - D3D_NAME_INNER_COVERAGE = 70, - D3D10_NAME_UNDEFINED = D3D_NAME_UNDEFINED, - D3D10_NAME_POSITION = D3D_NAME_POSITION, - D3D10_NAME_CLIP_DISTANCE = D3D_NAME_CLIP_DISTANCE, - D3D10_NAME_CULL_DISTANCE = D3D_NAME_CULL_DISTANCE, - D3D10_NAME_RENDER_TARGET_ARRAY_INDEX = D3D_NAME_RENDER_TARGET_ARRAY_INDEX, - D3D10_NAME_VIEWPORT_ARRAY_INDEX = D3D_NAME_VIEWPORT_ARRAY_INDEX, - D3D10_NAME_VERTEX_ID = D3D_NAME_VERTEX_ID, - D3D10_NAME_PRIMITIVE_ID = D3D_NAME_PRIMITIVE_ID, - D3D10_NAME_INSTANCE_ID = D3D_NAME_INSTANCE_ID, - D3D10_NAME_IS_FRONT_FACE = D3D_NAME_IS_FRONT_FACE, - D3D10_NAME_SAMPLE_INDEX = D3D_NAME_SAMPLE_INDEX, - D3D10_NAME_TARGET = D3D_NAME_TARGET, - D3D10_NAME_DEPTH = D3D_NAME_DEPTH, - D3D10_NAME_COVERAGE = D3D_NAME_COVERAGE, - D3D11_NAME_FINAL_QUAD_EDGE_TESSFACTOR = D3D_NAME_FINAL_QUAD_EDGE_TESSFACTOR, - D3D11_NAME_FINAL_QUAD_INSIDE_TESSFACTOR = D3D_NAME_FINAL_QUAD_INSIDE_TESSFACTOR, - D3D11_NAME_FINAL_TRI_EDGE_TESSFACTOR = D3D_NAME_FINAL_TRI_EDGE_TESSFACTOR, - D3D11_NAME_FINAL_TRI_INSIDE_TESSFACTOR = D3D_NAME_FINAL_TRI_INSIDE_TESSFACTOR, - D3D11_NAME_FINAL_LINE_DETAIL_TESSFACTOR = D3D_NAME_FINAL_LINE_DETAIL_TESSFACTOR, - D3D11_NAME_FINAL_LINE_DENSITY_TESSFACTOR = D3D_NAME_FINAL_LINE_DENSITY_TESSFACTOR, - D3D11_NAME_DEPTH_GREATER_EQUAL = D3D_NAME_DEPTH_GREATER_EQUAL, - D3D11_NAME_DEPTH_LESS_EQUAL = D3D_NAME_DEPTH_LESS_EQUAL, - D3D11_NAME_STENCIL_REF = D3D_NAME_STENCIL_REF, - D3D11_NAME_INNER_COVERAGE = D3D_NAME_INNER_COVERAGE, - D3D12_NAME_BARYCENTRICS = D3D_NAME_BARYCENTRICS, - D3D12_NAME_SHADINGRATE = D3D_NAME_SHADINGRATE - } D3D_NAME; - -typedef -enum D3D_RESOURCE_RETURN_TYPE - { - D3D_RETURN_TYPE_UNORM = 1, - D3D_RETURN_TYPE_SNORM = 2, - D3D_RETURN_TYPE_SINT = 3, - D3D_RETURN_TYPE_UINT = 4, - D3D_RETURN_TYPE_FLOAT = 5, - D3D_RETURN_TYPE_MIXED = 6, - D3D_RETURN_TYPE_DOUBLE = 7, - D3D_RETURN_TYPE_CONTINUED = 8, - D3D10_RETURN_TYPE_UNORM = D3D_RETURN_TYPE_UNORM, - D3D10_RETURN_TYPE_SNORM = D3D_RETURN_TYPE_SNORM, - D3D10_RETURN_TYPE_SINT = D3D_RETURN_TYPE_SINT, - D3D10_RETURN_TYPE_UINT = D3D_RETURN_TYPE_UINT, - D3D10_RETURN_TYPE_FLOAT = D3D_RETURN_TYPE_FLOAT, - D3D10_RETURN_TYPE_MIXED = D3D_RETURN_TYPE_MIXED, - D3D11_RETURN_TYPE_UNORM = D3D_RETURN_TYPE_UNORM, - D3D11_RETURN_TYPE_SNORM = D3D_RETURN_TYPE_SNORM, - D3D11_RETURN_TYPE_SINT = D3D_RETURN_TYPE_SINT, - D3D11_RETURN_TYPE_UINT = D3D_RETURN_TYPE_UINT, - D3D11_RETURN_TYPE_FLOAT = D3D_RETURN_TYPE_FLOAT, - D3D11_RETURN_TYPE_MIXED = D3D_RETURN_TYPE_MIXED, - D3D11_RETURN_TYPE_DOUBLE = D3D_RETURN_TYPE_DOUBLE, - D3D11_RETURN_TYPE_CONTINUED = D3D_RETURN_TYPE_CONTINUED - } D3D_RESOURCE_RETURN_TYPE; - -typedef -enum D3D_REGISTER_COMPONENT_TYPE - { - D3D_REGISTER_COMPONENT_UNKNOWN = 0, - D3D_REGISTER_COMPONENT_UINT32 = 1, - D3D_REGISTER_COMPONENT_SINT32 = 2, - D3D_REGISTER_COMPONENT_FLOAT32 = 3, - D3D10_REGISTER_COMPONENT_UNKNOWN = D3D_REGISTER_COMPONENT_UNKNOWN, - D3D10_REGISTER_COMPONENT_UINT32 = D3D_REGISTER_COMPONENT_UINT32, - D3D10_REGISTER_COMPONENT_SINT32 = D3D_REGISTER_COMPONENT_SINT32, - D3D10_REGISTER_COMPONENT_FLOAT32 = D3D_REGISTER_COMPONENT_FLOAT32 - } D3D_REGISTER_COMPONENT_TYPE; - -typedef -enum D3D_TESSELLATOR_DOMAIN - { - D3D_TESSELLATOR_DOMAIN_UNDEFINED = 0, - D3D_TESSELLATOR_DOMAIN_ISOLINE = 1, - D3D_TESSELLATOR_DOMAIN_TRI = 2, - D3D_TESSELLATOR_DOMAIN_QUAD = 3, - D3D11_TESSELLATOR_DOMAIN_UNDEFINED = D3D_TESSELLATOR_DOMAIN_UNDEFINED, - D3D11_TESSELLATOR_DOMAIN_ISOLINE = D3D_TESSELLATOR_DOMAIN_ISOLINE, - D3D11_TESSELLATOR_DOMAIN_TRI = D3D_TESSELLATOR_DOMAIN_TRI, - D3D11_TESSELLATOR_DOMAIN_QUAD = D3D_TESSELLATOR_DOMAIN_QUAD - } D3D_TESSELLATOR_DOMAIN; - -typedef -enum D3D_TESSELLATOR_PARTITIONING - { - D3D_TESSELLATOR_PARTITIONING_UNDEFINED = 0, - D3D_TESSELLATOR_PARTITIONING_INTEGER = 1, - D3D_TESSELLATOR_PARTITIONING_POW2 = 2, - D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD = 3, - D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN = 4, - D3D11_TESSELLATOR_PARTITIONING_UNDEFINED = D3D_TESSELLATOR_PARTITIONING_UNDEFINED, - D3D11_TESSELLATOR_PARTITIONING_INTEGER = D3D_TESSELLATOR_PARTITIONING_INTEGER, - D3D11_TESSELLATOR_PARTITIONING_POW2 = D3D_TESSELLATOR_PARTITIONING_POW2, - D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD = D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD, - D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN = D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN - } D3D_TESSELLATOR_PARTITIONING; - -typedef -enum D3D_TESSELLATOR_OUTPUT_PRIMITIVE - { - D3D_TESSELLATOR_OUTPUT_UNDEFINED = 0, - D3D_TESSELLATOR_OUTPUT_POINT = 1, - D3D_TESSELLATOR_OUTPUT_LINE = 2, - D3D_TESSELLATOR_OUTPUT_TRIANGLE_CW = 3, - D3D_TESSELLATOR_OUTPUT_TRIANGLE_CCW = 4, - D3D11_TESSELLATOR_OUTPUT_UNDEFINED = D3D_TESSELLATOR_OUTPUT_UNDEFINED, - D3D11_TESSELLATOR_OUTPUT_POINT = D3D_TESSELLATOR_OUTPUT_POINT, - D3D11_TESSELLATOR_OUTPUT_LINE = D3D_TESSELLATOR_OUTPUT_LINE, - D3D11_TESSELLATOR_OUTPUT_TRIANGLE_CW = D3D_TESSELLATOR_OUTPUT_TRIANGLE_CW, - D3D11_TESSELLATOR_OUTPUT_TRIANGLE_CCW = D3D_TESSELLATOR_OUTPUT_TRIANGLE_CCW - } D3D_TESSELLATOR_OUTPUT_PRIMITIVE; - -typedef -enum D3D_MIN_PRECISION - { - D3D_MIN_PRECISION_DEFAULT = 0, - D3D_MIN_PRECISION_FLOAT_16 = 1, - D3D_MIN_PRECISION_FLOAT_2_8 = 2, - D3D_MIN_PRECISION_RESERVED = 3, - D3D_MIN_PRECISION_SINT_16 = 4, - D3D_MIN_PRECISION_UINT_16 = 5, - D3D_MIN_PRECISION_ANY_16 = 0xf0, - D3D_MIN_PRECISION_ANY_10 = 0xf1 - } D3D_MIN_PRECISION; - -typedef -enum D3D_INTERPOLATION_MODE - { - D3D_INTERPOLATION_UNDEFINED = 0, - D3D_INTERPOLATION_CONSTANT = 1, - D3D_INTERPOLATION_LINEAR = 2, - D3D_INTERPOLATION_LINEAR_CENTROID = 3, - D3D_INTERPOLATION_LINEAR_NOPERSPECTIVE = 4, - D3D_INTERPOLATION_LINEAR_NOPERSPECTIVE_CENTROID = 5, - D3D_INTERPOLATION_LINEAR_SAMPLE = 6, - D3D_INTERPOLATION_LINEAR_NOPERSPECTIVE_SAMPLE = 7 - } D3D_INTERPOLATION_MODE; - -typedef -enum _D3D_PARAMETER_FLAGS - { - D3D_PF_NONE = 0, - D3D_PF_IN = 0x1, - D3D_PF_OUT = 0x2, - D3D_PF_FORCE_DWORD = 0x7fffffff - } D3D_PARAMETER_FLAGS; - -DEFINE_GUID(WKPDID_D3DDebugObjectName,0x429b8c22,0x9188,0x4b0c,0x87,0x42,0xac,0xb0,0xbf,0x85,0xc2,0x00); -DEFINE_GUID(WKPDID_D3DDebugObjectNameW,0x4cca5fd8,0x921f,0x42c8,0x85,0x66,0x70,0xca,0xf2,0xa9,0xb7,0x41); -DEFINE_GUID(WKPDID_CommentStringW,0xd0149dc0,0x90e8,0x4ec8,0x81, 0x44, 0xe9, 0x00, 0xad, 0x26, 0x6b, 0xb2); -#define D3D_SET_OBJECT_NAME_N_A(pObject, Chars, pName) (pObject)->SetPrivateData(WKPDID_D3DDebugObjectName, Chars, pName) -#define D3D_SET_OBJECT_NAME_A(pObject, pName) D3D_SET_OBJECT_NAME_N_A(pObject, lstrlenA(pName), pName) -#define D3D_SET_OBJECT_NAME_N_W(pObject, Chars, pName) (pObject)->SetPrivateData(WKPDID_D3DDebugObjectNameW, Chars*2, pName) -#define D3D_SET_OBJECT_NAME_W(pObject, pName) D3D_SET_OBJECT_NAME_N_W(pObject, wcslen(pName), pName) -#define D3D_COMPONENT_MASK_X 1 -#define D3D_COMPONENT_MASK_Y 2 -#define D3D_COMPONENT_MASK_Z 4 -#define D3D_COMPONENT_MASK_W 8 -DEFINE_GUID(D3D_TEXTURE_LAYOUT_ROW_MAJOR,0xb5dc234f,0x72bb,0x4bec,0x97,0x05,0x8c,0xf2,0x58,0xdf,0x6b,0x6c); -DEFINE_GUID(D3D_TEXTURE_LAYOUT_64KB_STANDARD_SWIZZLE,0x4c0f29e3,0x3f5f,0x4d35,0x84,0xc9,0xbc,0x09,0x83,0xb6,0x2c,0x28); - - -extern RPC_IF_HANDLE __MIDL_itf_d3dcommon_0000_0002_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3dcommon_0000_0002_v0_0_s_ifspec; - -/* Additional Prototypes for ALL interfaces */ - -/* end of Additional Prototypes */ - -#ifdef __cplusplus -} -#endif - -#endif - - diff --git a/src/decomp/pc/gfx/dxsdk/d3dx12.h b/src/decomp/pc/gfx/dxsdk/d3dx12.h deleted file mode 100644 index 3aafbd2..0000000 --- a/src/decomp/pc/gfx/dxsdk/d3dx12.h +++ /dev/null @@ -1,3440 +0,0 @@ -//********************************************************* -// -// Copyright (c) Microsoft. All rights reserved. -// This code is licensed under the MIT License (MIT). -// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF -// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY -// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR -// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT. -// -//********************************************************* - -#ifndef __D3DX12_H__ -#define __D3DX12_H__ - -#include "d3d12.h" - -#if defined( __cplusplus ) - -struct CD3DX12_DEFAULT {}; -extern const DECLSPEC_SELECTANY CD3DX12_DEFAULT D3D12_DEFAULT; - -//------------------------------------------------------------------------------------------------ -inline bool operator==( const D3D12_VIEWPORT& l, const D3D12_VIEWPORT& r ) -{ - return l.TopLeftX == r.TopLeftX && l.TopLeftY == r.TopLeftY && l.Width == r.Width && - l.Height == r.Height && l.MinDepth == r.MinDepth && l.MaxDepth == r.MaxDepth; -} - -//------------------------------------------------------------------------------------------------ -inline bool operator!=( const D3D12_VIEWPORT& l, const D3D12_VIEWPORT& r ) -{ return !( l == r ); } - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_RECT : public D3D12_RECT -{ - CD3DX12_RECT() = default; - explicit CD3DX12_RECT( const D3D12_RECT& o ) : - D3D12_RECT( o ) - {} - explicit CD3DX12_RECT( - LONG Left, - LONG Top, - LONG Right, - LONG Bottom ) - { - left = Left; - top = Top; - right = Right; - bottom = Bottom; - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_VIEWPORT : public D3D12_VIEWPORT -{ - CD3DX12_VIEWPORT() = default; - explicit CD3DX12_VIEWPORT( const D3D12_VIEWPORT& o ) : - D3D12_VIEWPORT( o ) - {} - explicit CD3DX12_VIEWPORT( - FLOAT topLeftX, - FLOAT topLeftY, - FLOAT width, - FLOAT height, - FLOAT minDepth = D3D12_MIN_DEPTH, - FLOAT maxDepth = D3D12_MAX_DEPTH ) - { - TopLeftX = topLeftX; - TopLeftY = topLeftY; - Width = width; - Height = height; - MinDepth = minDepth; - MaxDepth = maxDepth; - } - explicit CD3DX12_VIEWPORT( - _In_ ID3D12Resource* pResource, - UINT mipSlice = 0, - FLOAT topLeftX = 0.0f, - FLOAT topLeftY = 0.0f, - FLOAT minDepth = D3D12_MIN_DEPTH, - FLOAT maxDepth = D3D12_MAX_DEPTH ) - { - auto Desc = pResource->GetDesc(); - const UINT64 SubresourceWidth = Desc.Width >> mipSlice; - const UINT64 SubresourceHeight = Desc.Height >> mipSlice; - switch (Desc.Dimension) - { - case D3D12_RESOURCE_DIMENSION_BUFFER: - TopLeftX = topLeftX; - TopLeftY = 0.0f; - Width = Desc.Width - topLeftX; - Height = 1.0f; - break; - case D3D12_RESOURCE_DIMENSION_TEXTURE1D: - TopLeftX = topLeftX; - TopLeftY = 0.0f; - Width = (SubresourceWidth ? SubresourceWidth : 1.0f) - topLeftX; - Height = 1.0f; - break; - case D3D12_RESOURCE_DIMENSION_TEXTURE2D: - case D3D12_RESOURCE_DIMENSION_TEXTURE3D: - TopLeftX = topLeftX; - TopLeftY = topLeftY; - Width = (SubresourceWidth ? SubresourceWidth : 1.0f) - topLeftX; - Height = (SubresourceHeight ? SubresourceHeight: 1.0f) - topLeftY; - break; - default: break; - } - - MinDepth = minDepth; - MaxDepth = maxDepth; - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_BOX : public D3D12_BOX -{ - CD3DX12_BOX() = default; - explicit CD3DX12_BOX( const D3D12_BOX& o ) : - D3D12_BOX( o ) - {} - explicit CD3DX12_BOX( - LONG Left, - LONG Right ) - { - left = static_cast(Left); - top = 0; - front = 0; - right = static_cast(Right); - bottom = 1; - back = 1; - } - explicit CD3DX12_BOX( - LONG Left, - LONG Top, - LONG Right, - LONG Bottom ) - { - left = static_cast(Left); - top = static_cast(Top); - front = 0; - right = static_cast(Right); - bottom = static_cast(Bottom); - back = 1; - } - explicit CD3DX12_BOX( - LONG Left, - LONG Top, - LONG Front, - LONG Right, - LONG Bottom, - LONG Back ) - { - left = static_cast(Left); - top = static_cast(Top); - front = static_cast(Front); - right = static_cast(Right); - bottom = static_cast(Bottom); - back = static_cast(Back); - } -}; -inline bool operator==( const D3D12_BOX& l, const D3D12_BOX& r ) -{ - return l.left == r.left && l.top == r.top && l.front == r.front && - l.right == r.right && l.bottom == r.bottom && l.back == r.back; -} -inline bool operator!=( const D3D12_BOX& l, const D3D12_BOX& r ) -{ return !( l == r ); } - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_DEPTH_STENCIL_DESC : public D3D12_DEPTH_STENCIL_DESC -{ - CD3DX12_DEPTH_STENCIL_DESC() = default; - explicit CD3DX12_DEPTH_STENCIL_DESC( const D3D12_DEPTH_STENCIL_DESC& o ) : - D3D12_DEPTH_STENCIL_DESC( o ) - {} - explicit CD3DX12_DEPTH_STENCIL_DESC( CD3DX12_DEFAULT ) - { - DepthEnable = TRUE; - DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL; - DepthFunc = D3D12_COMPARISON_FUNC_LESS; - StencilEnable = FALSE; - StencilReadMask = D3D12_DEFAULT_STENCIL_READ_MASK; - StencilWriteMask = D3D12_DEFAULT_STENCIL_WRITE_MASK; - const D3D12_DEPTH_STENCILOP_DESC defaultStencilOp = - { D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_COMPARISON_FUNC_ALWAYS }; - FrontFace = defaultStencilOp; - BackFace = defaultStencilOp; - } - explicit CD3DX12_DEPTH_STENCIL_DESC( - BOOL depthEnable, - D3D12_DEPTH_WRITE_MASK depthWriteMask, - D3D12_COMPARISON_FUNC depthFunc, - BOOL stencilEnable, - UINT8 stencilReadMask, - UINT8 stencilWriteMask, - D3D12_STENCIL_OP frontStencilFailOp, - D3D12_STENCIL_OP frontStencilDepthFailOp, - D3D12_STENCIL_OP frontStencilPassOp, - D3D12_COMPARISON_FUNC frontStencilFunc, - D3D12_STENCIL_OP backStencilFailOp, - D3D12_STENCIL_OP backStencilDepthFailOp, - D3D12_STENCIL_OP backStencilPassOp, - D3D12_COMPARISON_FUNC backStencilFunc ) - { - DepthEnable = depthEnable; - DepthWriteMask = depthWriteMask; - DepthFunc = depthFunc; - StencilEnable = stencilEnable; - StencilReadMask = stencilReadMask; - StencilWriteMask = stencilWriteMask; - FrontFace.StencilFailOp = frontStencilFailOp; - FrontFace.StencilDepthFailOp = frontStencilDepthFailOp; - FrontFace.StencilPassOp = frontStencilPassOp; - FrontFace.StencilFunc = frontStencilFunc; - BackFace.StencilFailOp = backStencilFailOp; - BackFace.StencilDepthFailOp = backStencilDepthFailOp; - BackFace.StencilPassOp = backStencilPassOp; - BackFace.StencilFunc = backStencilFunc; - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_DEPTH_STENCIL_DESC1 : public D3D12_DEPTH_STENCIL_DESC1 -{ - CD3DX12_DEPTH_STENCIL_DESC1() = default; - explicit CD3DX12_DEPTH_STENCIL_DESC1( const D3D12_DEPTH_STENCIL_DESC1& o ) : - D3D12_DEPTH_STENCIL_DESC1( o ) - {} - explicit CD3DX12_DEPTH_STENCIL_DESC1( const D3D12_DEPTH_STENCIL_DESC& o ) - { - DepthEnable = o.DepthEnable; - DepthWriteMask = o.DepthWriteMask; - DepthFunc = o.DepthFunc; - StencilEnable = o.StencilEnable; - StencilReadMask = o.StencilReadMask; - StencilWriteMask = o.StencilWriteMask; - FrontFace.StencilFailOp = o.FrontFace.StencilFailOp; - FrontFace.StencilDepthFailOp = o.FrontFace.StencilDepthFailOp; - FrontFace.StencilPassOp = o.FrontFace.StencilPassOp; - FrontFace.StencilFunc = o.FrontFace.StencilFunc; - BackFace.StencilFailOp = o.BackFace.StencilFailOp; - BackFace.StencilDepthFailOp = o.BackFace.StencilDepthFailOp; - BackFace.StencilPassOp = o.BackFace.StencilPassOp; - BackFace.StencilFunc = o.BackFace.StencilFunc; - DepthBoundsTestEnable = FALSE; - } - explicit CD3DX12_DEPTH_STENCIL_DESC1( CD3DX12_DEFAULT ) - { - DepthEnable = TRUE; - DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL; - DepthFunc = D3D12_COMPARISON_FUNC_LESS; - StencilEnable = FALSE; - StencilReadMask = D3D12_DEFAULT_STENCIL_READ_MASK; - StencilWriteMask = D3D12_DEFAULT_STENCIL_WRITE_MASK; - const D3D12_DEPTH_STENCILOP_DESC defaultStencilOp = - { D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_STENCIL_OP_KEEP, D3D12_COMPARISON_FUNC_ALWAYS }; - FrontFace = defaultStencilOp; - BackFace = defaultStencilOp; - DepthBoundsTestEnable = FALSE; - } - explicit CD3DX12_DEPTH_STENCIL_DESC1( - BOOL depthEnable, - D3D12_DEPTH_WRITE_MASK depthWriteMask, - D3D12_COMPARISON_FUNC depthFunc, - BOOL stencilEnable, - UINT8 stencilReadMask, - UINT8 stencilWriteMask, - D3D12_STENCIL_OP frontStencilFailOp, - D3D12_STENCIL_OP frontStencilDepthFailOp, - D3D12_STENCIL_OP frontStencilPassOp, - D3D12_COMPARISON_FUNC frontStencilFunc, - D3D12_STENCIL_OP backStencilFailOp, - D3D12_STENCIL_OP backStencilDepthFailOp, - D3D12_STENCIL_OP backStencilPassOp, - D3D12_COMPARISON_FUNC backStencilFunc, - BOOL depthBoundsTestEnable ) - { - DepthEnable = depthEnable; - DepthWriteMask = depthWriteMask; - DepthFunc = depthFunc; - StencilEnable = stencilEnable; - StencilReadMask = stencilReadMask; - StencilWriteMask = stencilWriteMask; - FrontFace.StencilFailOp = frontStencilFailOp; - FrontFace.StencilDepthFailOp = frontStencilDepthFailOp; - FrontFace.StencilPassOp = frontStencilPassOp; - FrontFace.StencilFunc = frontStencilFunc; - BackFace.StencilFailOp = backStencilFailOp; - BackFace.StencilDepthFailOp = backStencilDepthFailOp; - BackFace.StencilPassOp = backStencilPassOp; - BackFace.StencilFunc = backStencilFunc; - DepthBoundsTestEnable = depthBoundsTestEnable; - } - operator D3D12_DEPTH_STENCIL_DESC() const - { - D3D12_DEPTH_STENCIL_DESC D; - D.DepthEnable = DepthEnable; - D.DepthWriteMask = DepthWriteMask; - D.DepthFunc = DepthFunc; - D.StencilEnable = StencilEnable; - D.StencilReadMask = StencilReadMask; - D.StencilWriteMask = StencilWriteMask; - D.FrontFace.StencilFailOp = FrontFace.StencilFailOp; - D.FrontFace.StencilDepthFailOp = FrontFace.StencilDepthFailOp; - D.FrontFace.StencilPassOp = FrontFace.StencilPassOp; - D.FrontFace.StencilFunc = FrontFace.StencilFunc; - D.BackFace.StencilFailOp = BackFace.StencilFailOp; - D.BackFace.StencilDepthFailOp = BackFace.StencilDepthFailOp; - D.BackFace.StencilPassOp = BackFace.StencilPassOp; - D.BackFace.StencilFunc = BackFace.StencilFunc; - return D; - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_BLEND_DESC : public D3D12_BLEND_DESC -{ - CD3DX12_BLEND_DESC() = default; - explicit CD3DX12_BLEND_DESC( const D3D12_BLEND_DESC& o ) : - D3D12_BLEND_DESC( o ) - {} - explicit CD3DX12_BLEND_DESC( CD3DX12_DEFAULT ) - { - AlphaToCoverageEnable = FALSE; - IndependentBlendEnable = FALSE; - const D3D12_RENDER_TARGET_BLEND_DESC defaultRenderTargetBlendDesc = - { - FALSE,FALSE, - D3D12_BLEND_ONE, D3D12_BLEND_ZERO, D3D12_BLEND_OP_ADD, - D3D12_BLEND_ONE, D3D12_BLEND_ZERO, D3D12_BLEND_OP_ADD, - D3D12_LOGIC_OP_NOOP, - D3D12_COLOR_WRITE_ENABLE_ALL, - }; - for (UINT i = 0; i < D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i) - RenderTarget[ i ] = defaultRenderTargetBlendDesc; - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_RASTERIZER_DESC : public D3D12_RASTERIZER_DESC -{ - CD3DX12_RASTERIZER_DESC() = default; - explicit CD3DX12_RASTERIZER_DESC( const D3D12_RASTERIZER_DESC& o ) : - D3D12_RASTERIZER_DESC( o ) - {} - explicit CD3DX12_RASTERIZER_DESC( CD3DX12_DEFAULT ) - { - FillMode = D3D12_FILL_MODE_SOLID; - CullMode = D3D12_CULL_MODE_BACK; - FrontCounterClockwise = FALSE; - DepthBias = D3D12_DEFAULT_DEPTH_BIAS; - DepthBiasClamp = D3D12_DEFAULT_DEPTH_BIAS_CLAMP; - SlopeScaledDepthBias = D3D12_DEFAULT_SLOPE_SCALED_DEPTH_BIAS; - DepthClipEnable = TRUE; - MultisampleEnable = FALSE; - AntialiasedLineEnable = FALSE; - ForcedSampleCount = 0; - ConservativeRaster = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF; - } - explicit CD3DX12_RASTERIZER_DESC( - D3D12_FILL_MODE fillMode, - D3D12_CULL_MODE cullMode, - BOOL frontCounterClockwise, - INT depthBias, - FLOAT depthBiasClamp, - FLOAT slopeScaledDepthBias, - BOOL depthClipEnable, - BOOL multisampleEnable, - BOOL antialiasedLineEnable, - UINT forcedSampleCount, - D3D12_CONSERVATIVE_RASTERIZATION_MODE conservativeRaster) - { - FillMode = fillMode; - CullMode = cullMode; - FrontCounterClockwise = frontCounterClockwise; - DepthBias = depthBias; - DepthBiasClamp = depthBiasClamp; - SlopeScaledDepthBias = slopeScaledDepthBias; - DepthClipEnable = depthClipEnable; - MultisampleEnable = multisampleEnable; - AntialiasedLineEnable = antialiasedLineEnable; - ForcedSampleCount = forcedSampleCount; - ConservativeRaster = conservativeRaster; - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_RESOURCE_ALLOCATION_INFO : public D3D12_RESOURCE_ALLOCATION_INFO -{ - CD3DX12_RESOURCE_ALLOCATION_INFO() = default; - explicit CD3DX12_RESOURCE_ALLOCATION_INFO( const D3D12_RESOURCE_ALLOCATION_INFO& o ) : - D3D12_RESOURCE_ALLOCATION_INFO( o ) - {} - CD3DX12_RESOURCE_ALLOCATION_INFO( - UINT64 size, - UINT64 alignment ) - { - SizeInBytes = size; - Alignment = alignment; - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_HEAP_PROPERTIES : public D3D12_HEAP_PROPERTIES -{ - CD3DX12_HEAP_PROPERTIES() = default; - explicit CD3DX12_HEAP_PROPERTIES(const D3D12_HEAP_PROPERTIES &o) : - D3D12_HEAP_PROPERTIES(o) - {} - CD3DX12_HEAP_PROPERTIES( - D3D12_CPU_PAGE_PROPERTY cpuPageProperty, - D3D12_MEMORY_POOL memoryPoolPreference, - UINT creationNodeMask = 1, - UINT nodeMask = 1 ) - { - Type = D3D12_HEAP_TYPE_CUSTOM; - CPUPageProperty = cpuPageProperty; - MemoryPoolPreference = memoryPoolPreference; - CreationNodeMask = creationNodeMask; - VisibleNodeMask = nodeMask; - } - explicit CD3DX12_HEAP_PROPERTIES( - D3D12_HEAP_TYPE type, - UINT creationNodeMask = 1, - UINT nodeMask = 1 ) - { - Type = type; - CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN; - MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN; - CreationNodeMask = creationNodeMask; - VisibleNodeMask = nodeMask; - } - bool IsCPUAccessible() const - { - return Type == D3D12_HEAP_TYPE_UPLOAD || Type == D3D12_HEAP_TYPE_READBACK || (Type == D3D12_HEAP_TYPE_CUSTOM && - (CPUPageProperty == D3D12_CPU_PAGE_PROPERTY_WRITE_COMBINE || CPUPageProperty == D3D12_CPU_PAGE_PROPERTY_WRITE_BACK)); - } -}; -inline bool operator==( const D3D12_HEAP_PROPERTIES& l, const D3D12_HEAP_PROPERTIES& r ) -{ - return l.Type == r.Type && l.CPUPageProperty == r.CPUPageProperty && - l.MemoryPoolPreference == r.MemoryPoolPreference && - l.CreationNodeMask == r.CreationNodeMask && - l.VisibleNodeMask == r.VisibleNodeMask; -} -inline bool operator!=( const D3D12_HEAP_PROPERTIES& l, const D3D12_HEAP_PROPERTIES& r ) -{ return !( l == r ); } - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_HEAP_DESC : public D3D12_HEAP_DESC -{ - CD3DX12_HEAP_DESC() = default; - explicit CD3DX12_HEAP_DESC(const D3D12_HEAP_DESC &o) : - D3D12_HEAP_DESC(o) - {} - CD3DX12_HEAP_DESC( - UINT64 size, - D3D12_HEAP_PROPERTIES properties, - UINT64 alignment = 0, - D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) - { - SizeInBytes = size; - Properties = properties; - Alignment = alignment; - Flags = flags; - } - CD3DX12_HEAP_DESC( - UINT64 size, - D3D12_HEAP_TYPE type, - UINT64 alignment = 0, - D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) - { - SizeInBytes = size; - Properties = CD3DX12_HEAP_PROPERTIES( type ); - Alignment = alignment; - Flags = flags; - } - CD3DX12_HEAP_DESC( - UINT64 size, - D3D12_CPU_PAGE_PROPERTY cpuPageProperty, - D3D12_MEMORY_POOL memoryPoolPreference, - UINT64 alignment = 0, - D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) - { - SizeInBytes = size; - Properties = CD3DX12_HEAP_PROPERTIES( cpuPageProperty, memoryPoolPreference ); - Alignment = alignment; - Flags = flags; - } - CD3DX12_HEAP_DESC( - const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo, - D3D12_HEAP_PROPERTIES properties, - D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) - { - SizeInBytes = resAllocInfo.SizeInBytes; - Properties = properties; - Alignment = resAllocInfo.Alignment; - Flags = flags; - } - CD3DX12_HEAP_DESC( - const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo, - D3D12_HEAP_TYPE type, - D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) - { - SizeInBytes = resAllocInfo.SizeInBytes; - Properties = CD3DX12_HEAP_PROPERTIES( type ); - Alignment = resAllocInfo.Alignment; - Flags = flags; - } - CD3DX12_HEAP_DESC( - const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo, - D3D12_CPU_PAGE_PROPERTY cpuPageProperty, - D3D12_MEMORY_POOL memoryPoolPreference, - D3D12_HEAP_FLAGS flags = D3D12_HEAP_FLAG_NONE ) - { - SizeInBytes = resAllocInfo.SizeInBytes; - Properties = CD3DX12_HEAP_PROPERTIES( cpuPageProperty, memoryPoolPreference ); - Alignment = resAllocInfo.Alignment; - Flags = flags; - } - bool IsCPUAccessible() const - { return static_cast< const CD3DX12_HEAP_PROPERTIES* >( &Properties )->IsCPUAccessible(); } -}; -inline bool operator==( const D3D12_HEAP_DESC& l, const D3D12_HEAP_DESC& r ) -{ - return l.SizeInBytes == r.SizeInBytes && - l.Properties == r.Properties && - l.Alignment == r.Alignment && - l.Flags == r.Flags; -} -inline bool operator!=( const D3D12_HEAP_DESC& l, const D3D12_HEAP_DESC& r ) -{ return !( l == r ); } - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_CLEAR_VALUE : public D3D12_CLEAR_VALUE -{ - CD3DX12_CLEAR_VALUE() = default; - explicit CD3DX12_CLEAR_VALUE(const D3D12_CLEAR_VALUE &o) : - D3D12_CLEAR_VALUE(o) - {} - CD3DX12_CLEAR_VALUE( - DXGI_FORMAT format, - const FLOAT color[4] ) - { - Format = format; - memcpy( Color, color, sizeof( Color ) ); - } - CD3DX12_CLEAR_VALUE( - DXGI_FORMAT format, - FLOAT depth, - UINT8 stencil ) - { - Format = format; - memset( &Color, 0, sizeof( Color ) ); - /* Use memcpy to preserve NAN values */ - memcpy( &DepthStencil.Depth, &depth, sizeof( depth ) ); - DepthStencil.Stencil = stencil; - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_RANGE : public D3D12_RANGE -{ - CD3DX12_RANGE() = default; - explicit CD3DX12_RANGE(const D3D12_RANGE &o) : - D3D12_RANGE(o) - {} - CD3DX12_RANGE( - SIZE_T begin, - SIZE_T end ) - { - Begin = begin; - End = end; - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_RANGE_UINT64 : public D3D12_RANGE_UINT64 -{ - CD3DX12_RANGE_UINT64() = default; - explicit CD3DX12_RANGE_UINT64(const D3D12_RANGE_UINT64 &o) : - D3D12_RANGE_UINT64(o) - {} - CD3DX12_RANGE_UINT64( - UINT64 begin, - UINT64 end ) - { - Begin = begin; - End = end; - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_SUBRESOURCE_RANGE_UINT64 : public D3D12_SUBRESOURCE_RANGE_UINT64 -{ - CD3DX12_SUBRESOURCE_RANGE_UINT64() = default; - explicit CD3DX12_SUBRESOURCE_RANGE_UINT64(const D3D12_SUBRESOURCE_RANGE_UINT64 &o) : - D3D12_SUBRESOURCE_RANGE_UINT64(o) - {} - CD3DX12_SUBRESOURCE_RANGE_UINT64( - UINT subresource, - const D3D12_RANGE_UINT64& range ) - { - Subresource = subresource; - Range = range; - } - CD3DX12_SUBRESOURCE_RANGE_UINT64( - UINT subresource, - UINT64 begin, - UINT64 end ) - { - Subresource = subresource; - Range.Begin = begin; - Range.End = end; - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_SHADER_BYTECODE : public D3D12_SHADER_BYTECODE -{ - CD3DX12_SHADER_BYTECODE() = default; - explicit CD3DX12_SHADER_BYTECODE(const D3D12_SHADER_BYTECODE &o) : - D3D12_SHADER_BYTECODE(o) - {} - CD3DX12_SHADER_BYTECODE( - _In_ ID3DBlob* pShaderBlob ) - { - pShaderBytecode = pShaderBlob->GetBufferPointer(); - BytecodeLength = pShaderBlob->GetBufferSize(); - } - CD3DX12_SHADER_BYTECODE( - const void* _pShaderBytecode, - SIZE_T bytecodeLength ) - { - pShaderBytecode = _pShaderBytecode; - BytecodeLength = bytecodeLength; - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_TILED_RESOURCE_COORDINATE : public D3D12_TILED_RESOURCE_COORDINATE -{ - CD3DX12_TILED_RESOURCE_COORDINATE() = default; - explicit CD3DX12_TILED_RESOURCE_COORDINATE(const D3D12_TILED_RESOURCE_COORDINATE &o) : - D3D12_TILED_RESOURCE_COORDINATE(o) - {} - CD3DX12_TILED_RESOURCE_COORDINATE( - UINT x, - UINT y, - UINT z, - UINT subresource ) - { - X = x; - Y = y; - Z = z; - Subresource = subresource; - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_TILE_REGION_SIZE : public D3D12_TILE_REGION_SIZE -{ - CD3DX12_TILE_REGION_SIZE() = default; - explicit CD3DX12_TILE_REGION_SIZE(const D3D12_TILE_REGION_SIZE &o) : - D3D12_TILE_REGION_SIZE(o) - {} - CD3DX12_TILE_REGION_SIZE( - UINT numTiles, - BOOL useBox, - UINT width, - UINT16 height, - UINT16 depth ) - { - NumTiles = numTiles; - UseBox = useBox; - Width = width; - Height = height; - Depth = depth; - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_SUBRESOURCE_TILING : public D3D12_SUBRESOURCE_TILING -{ - CD3DX12_SUBRESOURCE_TILING() = default; - explicit CD3DX12_SUBRESOURCE_TILING(const D3D12_SUBRESOURCE_TILING &o) : - D3D12_SUBRESOURCE_TILING(o) - {} - CD3DX12_SUBRESOURCE_TILING( - UINT widthInTiles, - UINT16 heightInTiles, - UINT16 depthInTiles, - UINT startTileIndexInOverallResource ) - { - WidthInTiles = widthInTiles; - HeightInTiles = heightInTiles; - DepthInTiles = depthInTiles; - StartTileIndexInOverallResource = startTileIndexInOverallResource; - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_TILE_SHAPE : public D3D12_TILE_SHAPE -{ - CD3DX12_TILE_SHAPE() = default; - explicit CD3DX12_TILE_SHAPE(const D3D12_TILE_SHAPE &o) : - D3D12_TILE_SHAPE(o) - {} - CD3DX12_TILE_SHAPE( - UINT widthInTexels, - UINT heightInTexels, - UINT depthInTexels ) - { - WidthInTexels = widthInTexels; - HeightInTexels = heightInTexels; - DepthInTexels = depthInTexels; - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_RESOURCE_BARRIER : public D3D12_RESOURCE_BARRIER -{ - CD3DX12_RESOURCE_BARRIER() = default; - explicit CD3DX12_RESOURCE_BARRIER(const D3D12_RESOURCE_BARRIER &o) : - D3D12_RESOURCE_BARRIER(o) - {} - static inline CD3DX12_RESOURCE_BARRIER Transition( - _In_ ID3D12Resource* pResource, - D3D12_RESOURCE_STATES stateBefore, - D3D12_RESOURCE_STATES stateAfter, - UINT subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES, - D3D12_RESOURCE_BARRIER_FLAGS flags = D3D12_RESOURCE_BARRIER_FLAG_NONE) - { - CD3DX12_RESOURCE_BARRIER result = {}; - D3D12_RESOURCE_BARRIER &barrier = result; - result.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION; - result.Flags = flags; - barrier.Transition.pResource = pResource; - barrier.Transition.StateBefore = stateBefore; - barrier.Transition.StateAfter = stateAfter; - barrier.Transition.Subresource = subresource; - return result; - } - static inline CD3DX12_RESOURCE_BARRIER Aliasing( - _In_ ID3D12Resource* pResourceBefore, - _In_ ID3D12Resource* pResourceAfter) - { - CD3DX12_RESOURCE_BARRIER result = {}; - D3D12_RESOURCE_BARRIER &barrier = result; - result.Type = D3D12_RESOURCE_BARRIER_TYPE_ALIASING; - barrier.Aliasing.pResourceBefore = pResourceBefore; - barrier.Aliasing.pResourceAfter = pResourceAfter; - return result; - } - static inline CD3DX12_RESOURCE_BARRIER UAV( - _In_ ID3D12Resource* pResource) - { - CD3DX12_RESOURCE_BARRIER result = {}; - D3D12_RESOURCE_BARRIER &barrier = result; - result.Type = D3D12_RESOURCE_BARRIER_TYPE_UAV; - barrier.UAV.pResource = pResource; - return result; - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_PACKED_MIP_INFO : public D3D12_PACKED_MIP_INFO -{ - CD3DX12_PACKED_MIP_INFO() = default; - explicit CD3DX12_PACKED_MIP_INFO(const D3D12_PACKED_MIP_INFO &o) : - D3D12_PACKED_MIP_INFO(o) - {} - CD3DX12_PACKED_MIP_INFO( - UINT8 numStandardMips, - UINT8 numPackedMips, - UINT numTilesForPackedMips, - UINT startTileIndexInOverallResource ) - { - NumStandardMips = numStandardMips; - NumPackedMips = numPackedMips; - NumTilesForPackedMips = numTilesForPackedMips; - StartTileIndexInOverallResource = startTileIndexInOverallResource; - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_SUBRESOURCE_FOOTPRINT : public D3D12_SUBRESOURCE_FOOTPRINT -{ - CD3DX12_SUBRESOURCE_FOOTPRINT() = default; - explicit CD3DX12_SUBRESOURCE_FOOTPRINT(const D3D12_SUBRESOURCE_FOOTPRINT &o) : - D3D12_SUBRESOURCE_FOOTPRINT(o) - {} - CD3DX12_SUBRESOURCE_FOOTPRINT( - DXGI_FORMAT format, - UINT width, - UINT height, - UINT depth, - UINT rowPitch ) - { - Format = format; - Width = width; - Height = height; - Depth = depth; - RowPitch = rowPitch; - } - explicit CD3DX12_SUBRESOURCE_FOOTPRINT( - const D3D12_RESOURCE_DESC& resDesc, - UINT rowPitch ) - { - Format = resDesc.Format; - Width = UINT( resDesc.Width ); - Height = resDesc.Height; - Depth = (resDesc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? resDesc.DepthOrArraySize : 1); - RowPitch = rowPitch; - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_TEXTURE_COPY_LOCATION : public D3D12_TEXTURE_COPY_LOCATION -{ - CD3DX12_TEXTURE_COPY_LOCATION() = default; - explicit CD3DX12_TEXTURE_COPY_LOCATION(const D3D12_TEXTURE_COPY_LOCATION &o) : - D3D12_TEXTURE_COPY_LOCATION(o) - {} - CD3DX12_TEXTURE_COPY_LOCATION(_In_ ID3D12Resource* pRes) - { - pResource = pRes; - Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX; - PlacedFootprint = {}; - } - CD3DX12_TEXTURE_COPY_LOCATION(_In_ ID3D12Resource* pRes, D3D12_PLACED_SUBRESOURCE_FOOTPRINT const& Footprint) - { - pResource = pRes; - Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT; - PlacedFootprint = Footprint; - } - CD3DX12_TEXTURE_COPY_LOCATION(_In_ ID3D12Resource* pRes, UINT Sub) - { - pResource = pRes; - Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX; - PlacedFootprint = {}; - SubresourceIndex = Sub; - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_DESCRIPTOR_RANGE : public D3D12_DESCRIPTOR_RANGE -{ - CD3DX12_DESCRIPTOR_RANGE() = default; - explicit CD3DX12_DESCRIPTOR_RANGE(const D3D12_DESCRIPTOR_RANGE &o) : - D3D12_DESCRIPTOR_RANGE(o) - {} - CD3DX12_DESCRIPTOR_RANGE( - D3D12_DESCRIPTOR_RANGE_TYPE rangeType, - UINT numDescriptors, - UINT baseShaderRegister, - UINT registerSpace = 0, - UINT offsetInDescriptorsFromTableStart = - D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) - { - Init(rangeType, numDescriptors, baseShaderRegister, registerSpace, offsetInDescriptorsFromTableStart); - } - - inline void Init( - D3D12_DESCRIPTOR_RANGE_TYPE rangeType, - UINT numDescriptors, - UINT baseShaderRegister, - UINT registerSpace = 0, - UINT offsetInDescriptorsFromTableStart = - D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) - { - Init(*this, rangeType, numDescriptors, baseShaderRegister, registerSpace, offsetInDescriptorsFromTableStart); - } - - static inline void Init( - _Out_ D3D12_DESCRIPTOR_RANGE &range, - D3D12_DESCRIPTOR_RANGE_TYPE rangeType, - UINT numDescriptors, - UINT baseShaderRegister, - UINT registerSpace = 0, - UINT offsetInDescriptorsFromTableStart = - D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) - { - range.RangeType = rangeType; - range.NumDescriptors = numDescriptors; - range.BaseShaderRegister = baseShaderRegister; - range.RegisterSpace = registerSpace; - range.OffsetInDescriptorsFromTableStart = offsetInDescriptorsFromTableStart; - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_ROOT_DESCRIPTOR_TABLE : public D3D12_ROOT_DESCRIPTOR_TABLE -{ - CD3DX12_ROOT_DESCRIPTOR_TABLE() = default; - explicit CD3DX12_ROOT_DESCRIPTOR_TABLE(const D3D12_ROOT_DESCRIPTOR_TABLE &o) : - D3D12_ROOT_DESCRIPTOR_TABLE(o) - {} - CD3DX12_ROOT_DESCRIPTOR_TABLE( - UINT numDescriptorRanges, - _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* _pDescriptorRanges) - { - Init(numDescriptorRanges, _pDescriptorRanges); - } - - inline void Init( - UINT numDescriptorRanges, - _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* _pDescriptorRanges) - { - Init(*this, numDescriptorRanges, _pDescriptorRanges); - } - - static inline void Init( - _Out_ D3D12_ROOT_DESCRIPTOR_TABLE &rootDescriptorTable, - UINT numDescriptorRanges, - _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* _pDescriptorRanges) - { - rootDescriptorTable.NumDescriptorRanges = numDescriptorRanges; - rootDescriptorTable.pDescriptorRanges = _pDescriptorRanges; - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_ROOT_CONSTANTS : public D3D12_ROOT_CONSTANTS -{ - CD3DX12_ROOT_CONSTANTS() = default; - explicit CD3DX12_ROOT_CONSTANTS(const D3D12_ROOT_CONSTANTS &o) : - D3D12_ROOT_CONSTANTS(o) - {} - CD3DX12_ROOT_CONSTANTS( - UINT num32BitValues, - UINT shaderRegister, - UINT registerSpace = 0) - { - Init(num32BitValues, shaderRegister, registerSpace); - } - - inline void Init( - UINT num32BitValues, - UINT shaderRegister, - UINT registerSpace = 0) - { - Init(*this, num32BitValues, shaderRegister, registerSpace); - } - - static inline void Init( - _Out_ D3D12_ROOT_CONSTANTS &rootConstants, - UINT num32BitValues, - UINT shaderRegister, - UINT registerSpace = 0) - { - rootConstants.Num32BitValues = num32BitValues; - rootConstants.ShaderRegister = shaderRegister; - rootConstants.RegisterSpace = registerSpace; - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_ROOT_DESCRIPTOR : public D3D12_ROOT_DESCRIPTOR -{ - CD3DX12_ROOT_DESCRIPTOR() = default; - explicit CD3DX12_ROOT_DESCRIPTOR(const D3D12_ROOT_DESCRIPTOR &o) : - D3D12_ROOT_DESCRIPTOR(o) - {} - CD3DX12_ROOT_DESCRIPTOR( - UINT shaderRegister, - UINT registerSpace = 0) - { - Init(shaderRegister, registerSpace); - } - - inline void Init( - UINT shaderRegister, - UINT registerSpace = 0) - { - Init(*this, shaderRegister, registerSpace); - } - - static inline void Init(_Out_ D3D12_ROOT_DESCRIPTOR &table, UINT shaderRegister, UINT registerSpace = 0) - { - table.ShaderRegister = shaderRegister; - table.RegisterSpace = registerSpace; - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_ROOT_PARAMETER : public D3D12_ROOT_PARAMETER -{ - CD3DX12_ROOT_PARAMETER() = default; - explicit CD3DX12_ROOT_PARAMETER(const D3D12_ROOT_PARAMETER &o) : - D3D12_ROOT_PARAMETER(o) - {} - - static inline void InitAsDescriptorTable( - _Out_ D3D12_ROOT_PARAMETER &rootParam, - UINT numDescriptorRanges, - _In_reads_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* pDescriptorRanges, - D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) - { - rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE; - rootParam.ShaderVisibility = visibility; - CD3DX12_ROOT_DESCRIPTOR_TABLE::Init(rootParam.DescriptorTable, numDescriptorRanges, pDescriptorRanges); - } - - static inline void InitAsConstants( - _Out_ D3D12_ROOT_PARAMETER &rootParam, - UINT num32BitValues, - UINT shaderRegister, - UINT registerSpace = 0, - D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) - { - rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS; - rootParam.ShaderVisibility = visibility; - CD3DX12_ROOT_CONSTANTS::Init(rootParam.Constants, num32BitValues, shaderRegister, registerSpace); - } - - static inline void InitAsConstantBufferView( - _Out_ D3D12_ROOT_PARAMETER &rootParam, - UINT shaderRegister, - UINT registerSpace = 0, - D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) - { - rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV; - rootParam.ShaderVisibility = visibility; - CD3DX12_ROOT_DESCRIPTOR::Init(rootParam.Descriptor, shaderRegister, registerSpace); - } - - static inline void InitAsShaderResourceView( - _Out_ D3D12_ROOT_PARAMETER &rootParam, - UINT shaderRegister, - UINT registerSpace = 0, - D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) - { - rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_SRV; - rootParam.ShaderVisibility = visibility; - CD3DX12_ROOT_DESCRIPTOR::Init(rootParam.Descriptor, shaderRegister, registerSpace); - } - - static inline void InitAsUnorderedAccessView( - _Out_ D3D12_ROOT_PARAMETER &rootParam, - UINT shaderRegister, - UINT registerSpace = 0, - D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) - { - rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_UAV; - rootParam.ShaderVisibility = visibility; - CD3DX12_ROOT_DESCRIPTOR::Init(rootParam.Descriptor, shaderRegister, registerSpace); - } - - inline void InitAsDescriptorTable( - UINT numDescriptorRanges, - _In_reads_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE* pDescriptorRanges, - D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) - { - InitAsDescriptorTable(*this, numDescriptorRanges, pDescriptorRanges, visibility); - } - - inline void InitAsConstants( - UINT num32BitValues, - UINT shaderRegister, - UINT registerSpace = 0, - D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) - { - InitAsConstants(*this, num32BitValues, shaderRegister, registerSpace, visibility); - } - - inline void InitAsConstantBufferView( - UINT shaderRegister, - UINT registerSpace = 0, - D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) - { - InitAsConstantBufferView(*this, shaderRegister, registerSpace, visibility); - } - - inline void InitAsShaderResourceView( - UINT shaderRegister, - UINT registerSpace = 0, - D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) - { - InitAsShaderResourceView(*this, shaderRegister, registerSpace, visibility); - } - - inline void InitAsUnorderedAccessView( - UINT shaderRegister, - UINT registerSpace = 0, - D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) - { - InitAsUnorderedAccessView(*this, shaderRegister, registerSpace, visibility); - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_STATIC_SAMPLER_DESC : public D3D12_STATIC_SAMPLER_DESC -{ - CD3DX12_STATIC_SAMPLER_DESC() = default; - explicit CD3DX12_STATIC_SAMPLER_DESC(const D3D12_STATIC_SAMPLER_DESC &o) : - D3D12_STATIC_SAMPLER_DESC(o) - {} - CD3DX12_STATIC_SAMPLER_DESC( - UINT shaderRegister, - D3D12_FILTER filter = D3D12_FILTER_ANISOTROPIC, - D3D12_TEXTURE_ADDRESS_MODE addressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP, - D3D12_TEXTURE_ADDRESS_MODE addressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP, - D3D12_TEXTURE_ADDRESS_MODE addressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP, - FLOAT mipLODBias = 0, - UINT maxAnisotropy = 16, - D3D12_COMPARISON_FUNC comparisonFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL, - D3D12_STATIC_BORDER_COLOR borderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE, - FLOAT minLOD = 0.f, - FLOAT maxLOD = D3D12_FLOAT32_MAX, - D3D12_SHADER_VISIBILITY shaderVisibility = D3D12_SHADER_VISIBILITY_ALL, - UINT registerSpace = 0) - { - Init( - shaderRegister, - filter, - addressU, - addressV, - addressW, - mipLODBias, - maxAnisotropy, - comparisonFunc, - borderColor, - minLOD, - maxLOD, - shaderVisibility, - registerSpace); - } - - static inline void Init( - _Out_ D3D12_STATIC_SAMPLER_DESC &samplerDesc, - UINT shaderRegister, - D3D12_FILTER filter = D3D12_FILTER_ANISOTROPIC, - D3D12_TEXTURE_ADDRESS_MODE addressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP, - D3D12_TEXTURE_ADDRESS_MODE addressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP, - D3D12_TEXTURE_ADDRESS_MODE addressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP, - FLOAT mipLODBias = 0, - UINT maxAnisotropy = 16, - D3D12_COMPARISON_FUNC comparisonFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL, - D3D12_STATIC_BORDER_COLOR borderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE, - FLOAT minLOD = 0.f, - FLOAT maxLOD = D3D12_FLOAT32_MAX, - D3D12_SHADER_VISIBILITY shaderVisibility = D3D12_SHADER_VISIBILITY_ALL, - UINT registerSpace = 0) - { - samplerDesc.ShaderRegister = shaderRegister; - samplerDesc.Filter = filter; - samplerDesc.AddressU = addressU; - samplerDesc.AddressV = addressV; - samplerDesc.AddressW = addressW; - samplerDesc.MipLODBias = mipLODBias; - samplerDesc.MaxAnisotropy = maxAnisotropy; - samplerDesc.ComparisonFunc = comparisonFunc; - samplerDesc.BorderColor = borderColor; - samplerDesc.MinLOD = minLOD; - samplerDesc.MaxLOD = maxLOD; - samplerDesc.ShaderVisibility = shaderVisibility; - samplerDesc.RegisterSpace = registerSpace; - } - inline void Init( - UINT shaderRegister, - D3D12_FILTER filter = D3D12_FILTER_ANISOTROPIC, - D3D12_TEXTURE_ADDRESS_MODE addressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP, - D3D12_TEXTURE_ADDRESS_MODE addressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP, - D3D12_TEXTURE_ADDRESS_MODE addressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP, - FLOAT mipLODBias = 0, - UINT maxAnisotropy = 16, - D3D12_COMPARISON_FUNC comparisonFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL, - D3D12_STATIC_BORDER_COLOR borderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE, - FLOAT minLOD = 0.f, - FLOAT maxLOD = D3D12_FLOAT32_MAX, - D3D12_SHADER_VISIBILITY shaderVisibility = D3D12_SHADER_VISIBILITY_ALL, - UINT registerSpace = 0) - { - Init( - *this, - shaderRegister, - filter, - addressU, - addressV, - addressW, - mipLODBias, - maxAnisotropy, - comparisonFunc, - borderColor, - minLOD, - maxLOD, - shaderVisibility, - registerSpace); - } - -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_ROOT_SIGNATURE_DESC : public D3D12_ROOT_SIGNATURE_DESC -{ - CD3DX12_ROOT_SIGNATURE_DESC() = default; - explicit CD3DX12_ROOT_SIGNATURE_DESC(const D3D12_ROOT_SIGNATURE_DESC &o) : - D3D12_ROOT_SIGNATURE_DESC(o) - {} - CD3DX12_ROOT_SIGNATURE_DESC( - UINT numParameters, - _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters, - UINT numStaticSamplers = 0, - _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr, - D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) - { - Init(numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags); - } - CD3DX12_ROOT_SIGNATURE_DESC(CD3DX12_DEFAULT) - { - Init(0, nullptr, 0, nullptr, D3D12_ROOT_SIGNATURE_FLAG_NONE); - } - - inline void Init( - UINT numParameters, - _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters, - UINT numStaticSamplers = 0, - _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr, - D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) - { - Init(*this, numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags); - } - - static inline void Init( - _Out_ D3D12_ROOT_SIGNATURE_DESC &desc, - UINT numParameters, - _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters, - UINT numStaticSamplers = 0, - _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr, - D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) - { - desc.NumParameters = numParameters; - desc.pParameters = _pParameters; - desc.NumStaticSamplers = numStaticSamplers; - desc.pStaticSamplers = _pStaticSamplers; - desc.Flags = flags; - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_DESCRIPTOR_RANGE1 : public D3D12_DESCRIPTOR_RANGE1 -{ - CD3DX12_DESCRIPTOR_RANGE1() = default; - explicit CD3DX12_DESCRIPTOR_RANGE1(const D3D12_DESCRIPTOR_RANGE1 &o) : - D3D12_DESCRIPTOR_RANGE1(o) - {} - CD3DX12_DESCRIPTOR_RANGE1( - D3D12_DESCRIPTOR_RANGE_TYPE rangeType, - UINT numDescriptors, - UINT baseShaderRegister, - UINT registerSpace = 0, - D3D12_DESCRIPTOR_RANGE_FLAGS flags = D3D12_DESCRIPTOR_RANGE_FLAG_NONE, - UINT offsetInDescriptorsFromTableStart = - D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) - { - Init(rangeType, numDescriptors, baseShaderRegister, registerSpace, flags, offsetInDescriptorsFromTableStart); - } - - inline void Init( - D3D12_DESCRIPTOR_RANGE_TYPE rangeType, - UINT numDescriptors, - UINT baseShaderRegister, - UINT registerSpace = 0, - D3D12_DESCRIPTOR_RANGE_FLAGS flags = D3D12_DESCRIPTOR_RANGE_FLAG_NONE, - UINT offsetInDescriptorsFromTableStart = - D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) - { - Init(*this, rangeType, numDescriptors, baseShaderRegister, registerSpace, flags, offsetInDescriptorsFromTableStart); - } - - static inline void Init( - _Out_ D3D12_DESCRIPTOR_RANGE1 &range, - D3D12_DESCRIPTOR_RANGE_TYPE rangeType, - UINT numDescriptors, - UINT baseShaderRegister, - UINT registerSpace = 0, - D3D12_DESCRIPTOR_RANGE_FLAGS flags = D3D12_DESCRIPTOR_RANGE_FLAG_NONE, - UINT offsetInDescriptorsFromTableStart = - D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND) - { - range.RangeType = rangeType; - range.NumDescriptors = numDescriptors; - range.BaseShaderRegister = baseShaderRegister; - range.RegisterSpace = registerSpace; - range.Flags = flags; - range.OffsetInDescriptorsFromTableStart = offsetInDescriptorsFromTableStart; - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_ROOT_DESCRIPTOR_TABLE1 : public D3D12_ROOT_DESCRIPTOR_TABLE1 -{ - CD3DX12_ROOT_DESCRIPTOR_TABLE1() = default; - explicit CD3DX12_ROOT_DESCRIPTOR_TABLE1(const D3D12_ROOT_DESCRIPTOR_TABLE1 &o) : - D3D12_ROOT_DESCRIPTOR_TABLE1(o) - {} - CD3DX12_ROOT_DESCRIPTOR_TABLE1( - UINT numDescriptorRanges, - _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1* _pDescriptorRanges) - { - Init(numDescriptorRanges, _pDescriptorRanges); - } - - inline void Init( - UINT numDescriptorRanges, - _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1* _pDescriptorRanges) - { - Init(*this, numDescriptorRanges, _pDescriptorRanges); - } - - static inline void Init( - _Out_ D3D12_ROOT_DESCRIPTOR_TABLE1 &rootDescriptorTable, - UINT numDescriptorRanges, - _In_reads_opt_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1* _pDescriptorRanges) - { - rootDescriptorTable.NumDescriptorRanges = numDescriptorRanges; - rootDescriptorTable.pDescriptorRanges = _pDescriptorRanges; - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_ROOT_DESCRIPTOR1 : public D3D12_ROOT_DESCRIPTOR1 -{ - CD3DX12_ROOT_DESCRIPTOR1() = default; - explicit CD3DX12_ROOT_DESCRIPTOR1(const D3D12_ROOT_DESCRIPTOR1 &o) : - D3D12_ROOT_DESCRIPTOR1(o) - {} - CD3DX12_ROOT_DESCRIPTOR1( - UINT shaderRegister, - UINT registerSpace = 0, - D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE) - { - Init(shaderRegister, registerSpace, flags); - } - - inline void Init( - UINT shaderRegister, - UINT registerSpace = 0, - D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE) - { - Init(*this, shaderRegister, registerSpace, flags); - } - - static inline void Init( - _Out_ D3D12_ROOT_DESCRIPTOR1 &table, - UINT shaderRegister, - UINT registerSpace = 0, - D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE) - { - table.ShaderRegister = shaderRegister; - table.RegisterSpace = registerSpace; - table.Flags = flags; - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_ROOT_PARAMETER1 : public D3D12_ROOT_PARAMETER1 -{ - CD3DX12_ROOT_PARAMETER1() = default; - explicit CD3DX12_ROOT_PARAMETER1(const D3D12_ROOT_PARAMETER1 &o) : - D3D12_ROOT_PARAMETER1(o) - {} - - static inline void InitAsDescriptorTable( - _Out_ D3D12_ROOT_PARAMETER1 &rootParam, - UINT numDescriptorRanges, - _In_reads_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1* pDescriptorRanges, - D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) - { - rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE; - rootParam.ShaderVisibility = visibility; - CD3DX12_ROOT_DESCRIPTOR_TABLE1::Init(rootParam.DescriptorTable, numDescriptorRanges, pDescriptorRanges); - } - - static inline void InitAsConstants( - _Out_ D3D12_ROOT_PARAMETER1 &rootParam, - UINT num32BitValues, - UINT shaderRegister, - UINT registerSpace = 0, - D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) - { - rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS; - rootParam.ShaderVisibility = visibility; - CD3DX12_ROOT_CONSTANTS::Init(rootParam.Constants, num32BitValues, shaderRegister, registerSpace); - } - - static inline void InitAsConstantBufferView( - _Out_ D3D12_ROOT_PARAMETER1 &rootParam, - UINT shaderRegister, - UINT registerSpace = 0, - D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE, - D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) - { - rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV; - rootParam.ShaderVisibility = visibility; - CD3DX12_ROOT_DESCRIPTOR1::Init(rootParam.Descriptor, shaderRegister, registerSpace, flags); - } - - static inline void InitAsShaderResourceView( - _Out_ D3D12_ROOT_PARAMETER1 &rootParam, - UINT shaderRegister, - UINT registerSpace = 0, - D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE, - D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) - { - rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_SRV; - rootParam.ShaderVisibility = visibility; - CD3DX12_ROOT_DESCRIPTOR1::Init(rootParam.Descriptor, shaderRegister, registerSpace, flags); - } - - static inline void InitAsUnorderedAccessView( - _Out_ D3D12_ROOT_PARAMETER1 &rootParam, - UINT shaderRegister, - UINT registerSpace = 0, - D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE, - D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) - { - rootParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_UAV; - rootParam.ShaderVisibility = visibility; - CD3DX12_ROOT_DESCRIPTOR1::Init(rootParam.Descriptor, shaderRegister, registerSpace, flags); - } - - inline void InitAsDescriptorTable( - UINT numDescriptorRanges, - _In_reads_(numDescriptorRanges) const D3D12_DESCRIPTOR_RANGE1* pDescriptorRanges, - D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) - { - InitAsDescriptorTable(*this, numDescriptorRanges, pDescriptorRanges, visibility); - } - - inline void InitAsConstants( - UINT num32BitValues, - UINT shaderRegister, - UINT registerSpace = 0, - D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) - { - InitAsConstants(*this, num32BitValues, shaderRegister, registerSpace, visibility); - } - - inline void InitAsConstantBufferView( - UINT shaderRegister, - UINT registerSpace = 0, - D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE, - D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) - { - InitAsConstantBufferView(*this, shaderRegister, registerSpace, flags, visibility); - } - - inline void InitAsShaderResourceView( - UINT shaderRegister, - UINT registerSpace = 0, - D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE, - D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) - { - InitAsShaderResourceView(*this, shaderRegister, registerSpace, flags, visibility); - } - - inline void InitAsUnorderedAccessView( - UINT shaderRegister, - UINT registerSpace = 0, - D3D12_ROOT_DESCRIPTOR_FLAGS flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE, - D3D12_SHADER_VISIBILITY visibility = D3D12_SHADER_VISIBILITY_ALL) - { - InitAsUnorderedAccessView(*this, shaderRegister, registerSpace, flags, visibility); - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC : public D3D12_VERSIONED_ROOT_SIGNATURE_DESC -{ - CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC() = default; - explicit CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(const D3D12_VERSIONED_ROOT_SIGNATURE_DESC &o) : - D3D12_VERSIONED_ROOT_SIGNATURE_DESC(o) - {} - explicit CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(const D3D12_ROOT_SIGNATURE_DESC &o) - { - Version = D3D_ROOT_SIGNATURE_VERSION_1_0; - Desc_1_0 = o; - } - explicit CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(const D3D12_ROOT_SIGNATURE_DESC1 &o) - { - Version = D3D_ROOT_SIGNATURE_VERSION_1_1; - Desc_1_1 = o; - } - CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC( - UINT numParameters, - _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters, - UINT numStaticSamplers = 0, - _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr, - D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) - { - Init_1_0(numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags); - } - CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC( - UINT numParameters, - _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER1* _pParameters, - UINT numStaticSamplers = 0, - _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr, - D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) - { - Init_1_1(numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags); - } - CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(CD3DX12_DEFAULT) - { - Init_1_1(0, nullptr, 0, nullptr, D3D12_ROOT_SIGNATURE_FLAG_NONE); - } - - inline void Init_1_0( - UINT numParameters, - _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters, - UINT numStaticSamplers = 0, - _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr, - D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) - { - Init_1_0(*this, numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags); - } - - static inline void Init_1_0( - _Out_ D3D12_VERSIONED_ROOT_SIGNATURE_DESC &desc, - UINT numParameters, - _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER* _pParameters, - UINT numStaticSamplers = 0, - _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr, - D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) - { - desc.Version = D3D_ROOT_SIGNATURE_VERSION_1_0; - desc.Desc_1_0.NumParameters = numParameters; - desc.Desc_1_0.pParameters = _pParameters; - desc.Desc_1_0.NumStaticSamplers = numStaticSamplers; - desc.Desc_1_0.pStaticSamplers = _pStaticSamplers; - desc.Desc_1_0.Flags = flags; - } - - inline void Init_1_1( - UINT numParameters, - _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER1* _pParameters, - UINT numStaticSamplers = 0, - _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr, - D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) - { - Init_1_1(*this, numParameters, _pParameters, numStaticSamplers, _pStaticSamplers, flags); - } - - static inline void Init_1_1( - _Out_ D3D12_VERSIONED_ROOT_SIGNATURE_DESC &desc, - UINT numParameters, - _In_reads_opt_(numParameters) const D3D12_ROOT_PARAMETER1* _pParameters, - UINT numStaticSamplers = 0, - _In_reads_opt_(numStaticSamplers) const D3D12_STATIC_SAMPLER_DESC* _pStaticSamplers = nullptr, - D3D12_ROOT_SIGNATURE_FLAGS flags = D3D12_ROOT_SIGNATURE_FLAG_NONE) - { - desc.Version = D3D_ROOT_SIGNATURE_VERSION_1_1; - desc.Desc_1_1.NumParameters = numParameters; - desc.Desc_1_1.pParameters = _pParameters; - desc.Desc_1_1.NumStaticSamplers = numStaticSamplers; - desc.Desc_1_1.pStaticSamplers = _pStaticSamplers; - desc.Desc_1_1.Flags = flags; - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_CPU_DESCRIPTOR_HANDLE : public D3D12_CPU_DESCRIPTOR_HANDLE -{ - CD3DX12_CPU_DESCRIPTOR_HANDLE() = default; - explicit CD3DX12_CPU_DESCRIPTOR_HANDLE(const D3D12_CPU_DESCRIPTOR_HANDLE &o) : - D3D12_CPU_DESCRIPTOR_HANDLE(o) - {} - CD3DX12_CPU_DESCRIPTOR_HANDLE(CD3DX12_DEFAULT) { ptr = 0; } - CD3DX12_CPU_DESCRIPTOR_HANDLE(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &other, INT offsetScaledByIncrementSize) - { - InitOffsetted(other, offsetScaledByIncrementSize); - } - CD3DX12_CPU_DESCRIPTOR_HANDLE(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &other, INT offsetInDescriptors, UINT descriptorIncrementSize) - { - InitOffsetted(other, offsetInDescriptors, descriptorIncrementSize); - } - CD3DX12_CPU_DESCRIPTOR_HANDLE& Offset(INT offsetInDescriptors, UINT descriptorIncrementSize) - { - ptr = SIZE_T(INT64(ptr) + INT64(offsetInDescriptors) * INT64(descriptorIncrementSize)); - return *this; - } - CD3DX12_CPU_DESCRIPTOR_HANDLE& Offset(INT offsetScaledByIncrementSize) - { - ptr = SIZE_T(INT64(ptr) + INT64(offsetScaledByIncrementSize)); - return *this; - } - bool operator==(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE& other) const - { - return (ptr == other.ptr); - } - bool operator!=(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE& other) const - { - return (ptr != other.ptr); - } - CD3DX12_CPU_DESCRIPTOR_HANDLE &operator=(const D3D12_CPU_DESCRIPTOR_HANDLE &other) - { - ptr = other.ptr; - return *this; - } - - inline void InitOffsetted(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base, INT offsetScaledByIncrementSize) - { - InitOffsetted(*this, base, offsetScaledByIncrementSize); - } - - inline void InitOffsetted(_In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base, INT offsetInDescriptors, UINT descriptorIncrementSize) - { - InitOffsetted(*this, base, offsetInDescriptors, descriptorIncrementSize); - } - - static inline void InitOffsetted(_Out_ D3D12_CPU_DESCRIPTOR_HANDLE &handle, _In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base, INT offsetScaledByIncrementSize) - { - handle.ptr = SIZE_T(INT64(base.ptr) + INT64(offsetScaledByIncrementSize)); - } - - static inline void InitOffsetted(_Out_ D3D12_CPU_DESCRIPTOR_HANDLE &handle, _In_ const D3D12_CPU_DESCRIPTOR_HANDLE &base, INT offsetInDescriptors, UINT descriptorIncrementSize) - { - handle.ptr = SIZE_T(INT64(base.ptr) + INT64(offsetInDescriptors) * INT64(descriptorIncrementSize)); - } -}; - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_GPU_DESCRIPTOR_HANDLE : public D3D12_GPU_DESCRIPTOR_HANDLE -{ - CD3DX12_GPU_DESCRIPTOR_HANDLE() = default; - explicit CD3DX12_GPU_DESCRIPTOR_HANDLE(const D3D12_GPU_DESCRIPTOR_HANDLE &o) : - D3D12_GPU_DESCRIPTOR_HANDLE(o) - {} - CD3DX12_GPU_DESCRIPTOR_HANDLE(CD3DX12_DEFAULT) { ptr = 0; } - CD3DX12_GPU_DESCRIPTOR_HANDLE(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &other, INT offsetScaledByIncrementSize) - { - InitOffsetted(other, offsetScaledByIncrementSize); - } - CD3DX12_GPU_DESCRIPTOR_HANDLE(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &other, INT offsetInDescriptors, UINT descriptorIncrementSize) - { - InitOffsetted(other, offsetInDescriptors, descriptorIncrementSize); - } - CD3DX12_GPU_DESCRIPTOR_HANDLE& Offset(INT offsetInDescriptors, UINT descriptorIncrementSize) - { - ptr = UINT64(INT64(ptr) + INT64(offsetInDescriptors) * INT64(descriptorIncrementSize)); - return *this; - } - CD3DX12_GPU_DESCRIPTOR_HANDLE& Offset(INT offsetScaledByIncrementSize) - { - ptr = UINT64(INT64(ptr) + INT64(offsetScaledByIncrementSize)); - return *this; - } - inline bool operator==(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE& other) const - { - return (ptr == other.ptr); - } - inline bool operator!=(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE& other) const - { - return (ptr != other.ptr); - } - CD3DX12_GPU_DESCRIPTOR_HANDLE &operator=(const D3D12_GPU_DESCRIPTOR_HANDLE &other) - { - ptr = other.ptr; - return *this; - } - - inline void InitOffsetted(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base, INT offsetScaledByIncrementSize) - { - InitOffsetted(*this, base, offsetScaledByIncrementSize); - } - - inline void InitOffsetted(_In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base, INT offsetInDescriptors, UINT descriptorIncrementSize) - { - InitOffsetted(*this, base, offsetInDescriptors, descriptorIncrementSize); - } - - static inline void InitOffsetted(_Out_ D3D12_GPU_DESCRIPTOR_HANDLE &handle, _In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base, INT offsetScaledByIncrementSize) - { - handle.ptr = UINT64(INT64(base.ptr) + INT64(offsetScaledByIncrementSize)); - } - - static inline void InitOffsetted(_Out_ D3D12_GPU_DESCRIPTOR_HANDLE &handle, _In_ const D3D12_GPU_DESCRIPTOR_HANDLE &base, INT offsetInDescriptors, UINT descriptorIncrementSize) - { - handle.ptr = UINT64(INT64(base.ptr) + INT64(offsetInDescriptors) * INT64(descriptorIncrementSize)); - } -}; - -//------------------------------------------------------------------------------------------------ -inline UINT D3D12CalcSubresource( UINT MipSlice, UINT ArraySlice, UINT PlaneSlice, UINT MipLevels, UINT ArraySize ) -{ - return MipSlice + ArraySlice * MipLevels + PlaneSlice * MipLevels * ArraySize; -} - -//------------------------------------------------------------------------------------------------ -template -inline void D3D12DecomposeSubresource( UINT Subresource, UINT MipLevels, UINT ArraySize, _Out_ T& MipSlice, _Out_ U& ArraySlice, _Out_ V& PlaneSlice ) -{ - MipSlice = static_cast(Subresource % MipLevels); - ArraySlice = static_cast((Subresource / MipLevels) % ArraySize); - PlaneSlice = static_cast(Subresource / (MipLevels * ArraySize)); -} - -//------------------------------------------------------------------------------------------------ -inline UINT8 D3D12GetFormatPlaneCount( - _In_ ID3D12Device* pDevice, - DXGI_FORMAT Format - ) -{ - D3D12_FEATURE_DATA_FORMAT_INFO formatInfo = { Format, 0 }; - if (FAILED(pDevice->CheckFeatureSupport(D3D12_FEATURE_FORMAT_INFO, &formatInfo, sizeof(formatInfo)))) - { - return 0; - } - return formatInfo.PlaneCount; -} - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_RESOURCE_DESC : public D3D12_RESOURCE_DESC -{ - CD3DX12_RESOURCE_DESC() = default; - explicit CD3DX12_RESOURCE_DESC( const D3D12_RESOURCE_DESC& o ) : - D3D12_RESOURCE_DESC( o ) - {} - CD3DX12_RESOURCE_DESC( - D3D12_RESOURCE_DIMENSION dimension, - UINT64 alignment, - UINT64 width, - UINT height, - UINT16 depthOrArraySize, - UINT16 mipLevels, - DXGI_FORMAT format, - UINT sampleCount, - UINT sampleQuality, - D3D12_TEXTURE_LAYOUT layout, - D3D12_RESOURCE_FLAGS flags ) - { - Dimension = dimension; - Alignment = alignment; - Width = width; - Height = height; - DepthOrArraySize = depthOrArraySize; - MipLevels = mipLevels; - Format = format; - SampleDesc.Count = sampleCount; - SampleDesc.Quality = sampleQuality; - Layout = layout; - Flags = flags; - } - static inline CD3DX12_RESOURCE_DESC Buffer( - const D3D12_RESOURCE_ALLOCATION_INFO& resAllocInfo, - D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE ) - { - return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_BUFFER, resAllocInfo.Alignment, resAllocInfo.SizeInBytes, - 1, 1, 1, DXGI_FORMAT_UNKNOWN, 1, 0, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, flags ); - } - static inline CD3DX12_RESOURCE_DESC Buffer( - UINT64 width, - D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE, - UINT64 alignment = 0 ) - { - return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_BUFFER, alignment, width, 1, 1, 1, - DXGI_FORMAT_UNKNOWN, 1, 0, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, flags ); - } - static inline CD3DX12_RESOURCE_DESC Tex1D( - DXGI_FORMAT format, - UINT64 width, - UINT16 arraySize = 1, - UINT16 mipLevels = 0, - D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE, - D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN, - UINT64 alignment = 0 ) - { - return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_TEXTURE1D, alignment, width, 1, arraySize, - mipLevels, format, 1, 0, layout, flags ); - } - static inline CD3DX12_RESOURCE_DESC Tex2D( - DXGI_FORMAT format, - UINT64 width, - UINT height, - UINT16 arraySize = 1, - UINT16 mipLevels = 0, - UINT sampleCount = 1, - UINT sampleQuality = 0, - D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE, - D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN, - UINT64 alignment = 0 ) - { - return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_TEXTURE2D, alignment, width, height, arraySize, - mipLevels, format, sampleCount, sampleQuality, layout, flags ); - } - static inline CD3DX12_RESOURCE_DESC Tex3D( - DXGI_FORMAT format, - UINT64 width, - UINT height, - UINT16 depth, - UINT16 mipLevels = 0, - D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE, - D3D12_TEXTURE_LAYOUT layout = D3D12_TEXTURE_LAYOUT_UNKNOWN, - UINT64 alignment = 0 ) - { - return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_TEXTURE3D, alignment, width, height, depth, - mipLevels, format, 1, 0, layout, flags ); - } - inline UINT16 Depth() const - { return (Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? DepthOrArraySize : 1); } - inline UINT16 ArraySize() const - { return (Dimension != D3D12_RESOURCE_DIMENSION_TEXTURE3D ? DepthOrArraySize : 1); } - inline UINT8 PlaneCount(_In_ ID3D12Device* pDevice) const - { return D3D12GetFormatPlaneCount(pDevice, Format); } - inline UINT Subresources(_In_ ID3D12Device* pDevice) const - { return MipLevels * ArraySize() * PlaneCount(pDevice); } - inline UINT CalcSubresource(UINT MipSlice, UINT ArraySlice, UINT PlaneSlice) - { return D3D12CalcSubresource(MipSlice, ArraySlice, PlaneSlice, MipLevels, ArraySize()); } -}; -inline bool operator==( const D3D12_RESOURCE_DESC& l, const D3D12_RESOURCE_DESC& r ) -{ - return l.Dimension == r.Dimension && - l.Alignment == r.Alignment && - l.Width == r.Width && - l.Height == r.Height && - l.DepthOrArraySize == r.DepthOrArraySize && - l.MipLevels == r.MipLevels && - l.Format == r.Format && - l.SampleDesc.Count == r.SampleDesc.Count && - l.SampleDesc.Quality == r.SampleDesc.Quality && - l.Layout == r.Layout && - l.Flags == r.Flags; -} -inline bool operator!=( const D3D12_RESOURCE_DESC& l, const D3D12_RESOURCE_DESC& r ) -{ return !( l == r ); } - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_VIEW_INSTANCING_DESC : public D3D12_VIEW_INSTANCING_DESC -{ - CD3DX12_VIEW_INSTANCING_DESC() = default; - explicit CD3DX12_VIEW_INSTANCING_DESC( const D3D12_VIEW_INSTANCING_DESC& o ) : - D3D12_VIEW_INSTANCING_DESC( o ) - {} - explicit CD3DX12_VIEW_INSTANCING_DESC( CD3DX12_DEFAULT ) - { - ViewInstanceCount = 0; - pViewInstanceLocations = nullptr; - Flags = D3D12_VIEW_INSTANCING_FLAG_NONE; - } - explicit CD3DX12_VIEW_INSTANCING_DESC( - UINT InViewInstanceCount, - const D3D12_VIEW_INSTANCE_LOCATION* InViewInstanceLocations, - D3D12_VIEW_INSTANCING_FLAGS InFlags) - { - ViewInstanceCount = InViewInstanceCount; - pViewInstanceLocations = InViewInstanceLocations; - Flags = InFlags; - } -}; - -//------------------------------------------------------------------------------------------------ -// Row-by-row memcpy -inline void MemcpySubresource( - _In_ const D3D12_MEMCPY_DEST* pDest, - _In_ const D3D12_SUBRESOURCE_DATA* pSrc, - SIZE_T RowSizeInBytes, - UINT NumRows, - UINT NumSlices) -{ - for (UINT z = 0; z < NumSlices; ++z) - { - auto pDestSlice = reinterpret_cast(pDest->pData) + pDest->SlicePitch * z; - auto pSrcSlice = reinterpret_cast(pSrc->pData) + pSrc->SlicePitch * LONG_PTR(z); - for (UINT y = 0; y < NumRows; ++y) - { - memcpy(pDestSlice + pDest->RowPitch * y, - pSrcSlice + pSrc->RowPitch * LONG_PTR(y), - RowSizeInBytes); - } - } -} - -//------------------------------------------------------------------------------------------------ -// Returns required size of a buffer to be used for data upload -inline UINT64 GetRequiredIntermediateSize( - _In_ ID3D12Resource* pDestinationResource, - _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, - _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources) -{ - auto Desc = pDestinationResource->GetDesc(); - UINT64 RequiredSize = 0; - - ID3D12Device* pDevice = nullptr; - pDestinationResource->GetDevice(IID_ID3D12Device, reinterpret_cast(&pDevice)); - pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources, 0, nullptr, nullptr, nullptr, &RequiredSize); - pDevice->Release(); - - return RequiredSize; -} - -//------------------------------------------------------------------------------------------------ -// All arrays must be populated (e.g. by calling GetCopyableFootprints) -inline UINT64 UpdateSubresources( - _In_ ID3D12GraphicsCommandList* pCmdList, - _In_ ID3D12Resource* pDestinationResource, - _In_ ID3D12Resource* pIntermediate, - _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, - _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, - UINT64 RequiredSize, - _In_reads_(NumSubresources) const D3D12_PLACED_SUBRESOURCE_FOOTPRINT* pLayouts, - _In_reads_(NumSubresources) const UINT* pNumRows, - _In_reads_(NumSubresources) const UINT64* pRowSizesInBytes, - _In_reads_(NumSubresources) const D3D12_SUBRESOURCE_DATA* pSrcData) -{ - // Minor validation - auto IntermediateDesc = pIntermediate->GetDesc(); - auto DestinationDesc = pDestinationResource->GetDesc(); - if (IntermediateDesc.Dimension != D3D12_RESOURCE_DIMENSION_BUFFER || - IntermediateDesc.Width < RequiredSize + pLayouts[0].Offset || - RequiredSize > SIZE_T(-1) || - (DestinationDesc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER && - (FirstSubresource != 0 || NumSubresources != 1))) - { - return 0; - } - - BYTE* pData; - HRESULT hr = pIntermediate->Map(0, nullptr, reinterpret_cast(&pData)); - if (FAILED(hr)) - { - return 0; - } - - for (UINT i = 0; i < NumSubresources; ++i) - { - if (pRowSizesInBytes[i] > SIZE_T(-1)) return 0; - D3D12_MEMCPY_DEST DestData = { pData + pLayouts[i].Offset, pLayouts[i].Footprint.RowPitch, SIZE_T(pLayouts[i].Footprint.RowPitch) * SIZE_T(pNumRows[i]) }; - MemcpySubresource(&DestData, &pSrcData[i], static_cast(pRowSizesInBytes[i]), pNumRows[i], pLayouts[i].Footprint.Depth); - } - pIntermediate->Unmap(0, nullptr); - - if (DestinationDesc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER) - { - pCmdList->CopyBufferRegion( - pDestinationResource, 0, pIntermediate, pLayouts[0].Offset, pLayouts[0].Footprint.Width); - } - else - { - for (UINT i = 0; i < NumSubresources; ++i) - { - CD3DX12_TEXTURE_COPY_LOCATION Dst(pDestinationResource, i + FirstSubresource); - CD3DX12_TEXTURE_COPY_LOCATION Src(pIntermediate, pLayouts[i]); - pCmdList->CopyTextureRegion(&Dst, 0, 0, 0, &Src, nullptr); - } - } - return RequiredSize; -} - -//------------------------------------------------------------------------------------------------ -// Heap-allocating UpdateSubresources implementation -inline UINT64 UpdateSubresources( - _In_ ID3D12GraphicsCommandList* pCmdList, - _In_ ID3D12Resource* pDestinationResource, - _In_ ID3D12Resource* pIntermediate, - UINT64 IntermediateOffset, - _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, - _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, - _In_reads_(NumSubresources) D3D12_SUBRESOURCE_DATA* pSrcData) -{ - UINT64 RequiredSize = 0; - UINT64 MemToAlloc = static_cast(sizeof(D3D12_PLACED_SUBRESOURCE_FOOTPRINT) + sizeof(UINT) + sizeof(UINT64)) * NumSubresources; - if (MemToAlloc > SIZE_MAX) - { - return 0; - } - void* pMem = HeapAlloc(GetProcessHeap(), 0, static_cast(MemToAlloc)); - if (pMem == nullptr) - { - return 0; - } - auto pLayouts = reinterpret_cast(pMem); - UINT64* pRowSizesInBytes = reinterpret_cast(pLayouts + NumSubresources); - UINT* pNumRows = reinterpret_cast(pRowSizesInBytes + NumSubresources); - - auto Desc = pDestinationResource->GetDesc(); - ID3D12Device* pDevice = nullptr; - pDestinationResource->GetDevice(IID_ID3D12Device, reinterpret_cast(&pDevice)); - pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources, IntermediateOffset, pLayouts, pNumRows, pRowSizesInBytes, &RequiredSize); - pDevice->Release(); - - UINT64 Result = UpdateSubresources(pCmdList, pDestinationResource, pIntermediate, FirstSubresource, NumSubresources, RequiredSize, pLayouts, pNumRows, pRowSizesInBytes, pSrcData); - HeapFree(GetProcessHeap(), 0, pMem); - return Result; -} - -//------------------------------------------------------------------------------------------------ -// Stack-allocating UpdateSubresources implementation -template -inline UINT64 UpdateSubresources( - _In_ ID3D12GraphicsCommandList* pCmdList, - _In_ ID3D12Resource* pDestinationResource, - _In_ ID3D12Resource* pIntermediate, - UINT64 IntermediateOffset, - _In_range_(0, MaxSubresources) UINT FirstSubresource, - _In_range_(1, MaxSubresources - FirstSubresource) UINT NumSubresources, - _In_reads_(NumSubresources) D3D12_SUBRESOURCE_DATA* pSrcData) -{ - UINT64 RequiredSize = 0; - D3D12_PLACED_SUBRESOURCE_FOOTPRINT Layouts[MaxSubresources]; - UINT NumRows[MaxSubresources]; - UINT64 RowSizesInBytes[MaxSubresources]; - - auto Desc = pDestinationResource->GetDesc(); - ID3D12Device* pDevice = nullptr; - pDestinationResource->GetDevice(IID_ID3D12Device, reinterpret_cast(&pDevice)); - pDevice->GetCopyableFootprints(&Desc, FirstSubresource, NumSubresources, IntermediateOffset, Layouts, NumRows, RowSizesInBytes, &RequiredSize); - pDevice->Release(); - - return UpdateSubresources(pCmdList, pDestinationResource, pIntermediate, FirstSubresource, NumSubresources, RequiredSize, Layouts, NumRows, RowSizesInBytes, pSrcData); -} - -//------------------------------------------------------------------------------------------------ -inline bool D3D12IsLayoutOpaque( D3D12_TEXTURE_LAYOUT Layout ) -{ return Layout == D3D12_TEXTURE_LAYOUT_UNKNOWN || Layout == D3D12_TEXTURE_LAYOUT_64KB_UNDEFINED_SWIZZLE; } - -//------------------------------------------------------------------------------------------------ -template -inline ID3D12CommandList * const * CommandListCast(t_CommandListType * const * pp) -{ - // This cast is useful for passing strongly typed command list pointers into - // ExecuteCommandLists. - // This cast is valid as long as the const-ness is respected. D3D12 APIs do - // respect the const-ness of their arguments. - return reinterpret_cast(pp); -} - -//------------------------------------------------------------------------------------------------ -// D3D12 exports a new method for serializing root signatures in the Windows 10 Anniversary Update. -// To help enable root signature 1.1 features when they are available and not require maintaining -// two code paths for building root signatures, this helper method reconstructs a 1.0 signature when -// 1.1 is not supported. -inline HRESULT D3DX12SerializeVersionedRootSignature( - _In_ const D3D12_VERSIONED_ROOT_SIGNATURE_DESC* pRootSignatureDesc, - D3D_ROOT_SIGNATURE_VERSION MaxVersion, - _Outptr_ ID3DBlob** ppBlob, - _Always_(_Outptr_opt_result_maybenull_) ID3DBlob** ppErrorBlob) -{ - if (ppErrorBlob != nullptr) - { - *ppErrorBlob = nullptr; - } - - switch (MaxVersion) - { - case D3D_ROOT_SIGNATURE_VERSION_1_0: - switch (pRootSignatureDesc->Version) - { - case D3D_ROOT_SIGNATURE_VERSION_1_0: - return D3D12SerializeRootSignature(&pRootSignatureDesc->Desc_1_0, D3D_ROOT_SIGNATURE_VERSION_1, ppBlob, ppErrorBlob); - - case D3D_ROOT_SIGNATURE_VERSION_1_1: - { - HRESULT hr = S_OK; - const D3D12_ROOT_SIGNATURE_DESC1& desc_1_1 = pRootSignatureDesc->Desc_1_1; - - const SIZE_T ParametersSize = sizeof(D3D12_ROOT_PARAMETER) * desc_1_1.NumParameters; - void* pParameters = (ParametersSize > 0) ? HeapAlloc(GetProcessHeap(), 0, ParametersSize) : nullptr; - if (ParametersSize > 0 && pParameters == nullptr) - { - hr = E_OUTOFMEMORY; - } - auto pParameters_1_0 = reinterpret_cast(pParameters); - - if (SUCCEEDED(hr)) - { - for (UINT n = 0; n < desc_1_1.NumParameters; n++) - { - __analysis_assume(ParametersSize == sizeof(D3D12_ROOT_PARAMETER) * desc_1_1.NumParameters); - pParameters_1_0[n].ParameterType = desc_1_1.pParameters[n].ParameterType; - pParameters_1_0[n].ShaderVisibility = desc_1_1.pParameters[n].ShaderVisibility; - - switch (desc_1_1.pParameters[n].ParameterType) - { - case D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS: - pParameters_1_0[n].Constants.Num32BitValues = desc_1_1.pParameters[n].Constants.Num32BitValues; - pParameters_1_0[n].Constants.RegisterSpace = desc_1_1.pParameters[n].Constants.RegisterSpace; - pParameters_1_0[n].Constants.ShaderRegister = desc_1_1.pParameters[n].Constants.ShaderRegister; - break; - - case D3D12_ROOT_PARAMETER_TYPE_CBV: - case D3D12_ROOT_PARAMETER_TYPE_SRV: - case D3D12_ROOT_PARAMETER_TYPE_UAV: - pParameters_1_0[n].Descriptor.RegisterSpace = desc_1_1.pParameters[n].Descriptor.RegisterSpace; - pParameters_1_0[n].Descriptor.ShaderRegister = desc_1_1.pParameters[n].Descriptor.ShaderRegister; - break; - - case D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE: - const D3D12_ROOT_DESCRIPTOR_TABLE1& table_1_1 = desc_1_1.pParameters[n].DescriptorTable; - - const SIZE_T DescriptorRangesSize = sizeof(D3D12_DESCRIPTOR_RANGE) * table_1_1.NumDescriptorRanges; - void* pDescriptorRanges = (DescriptorRangesSize > 0 && SUCCEEDED(hr)) ? HeapAlloc(GetProcessHeap(), 0, DescriptorRangesSize) : nullptr; - if (DescriptorRangesSize > 0 && pDescriptorRanges == nullptr) - { - hr = E_OUTOFMEMORY; - } - auto pDescriptorRanges_1_0 = reinterpret_cast(pDescriptorRanges); - - if (SUCCEEDED(hr)) - { - for (UINT x = 0; x < table_1_1.NumDescriptorRanges; x++) - { - __analysis_assume(DescriptorRangesSize == sizeof(D3D12_DESCRIPTOR_RANGE) * table_1_1.NumDescriptorRanges); - pDescriptorRanges_1_0[x].BaseShaderRegister = table_1_1.pDescriptorRanges[x].BaseShaderRegister; - pDescriptorRanges_1_0[x].NumDescriptors = table_1_1.pDescriptorRanges[x].NumDescriptors; - pDescriptorRanges_1_0[x].OffsetInDescriptorsFromTableStart = table_1_1.pDescriptorRanges[x].OffsetInDescriptorsFromTableStart; - pDescriptorRanges_1_0[x].RangeType = table_1_1.pDescriptorRanges[x].RangeType; - pDescriptorRanges_1_0[x].RegisterSpace = table_1_1.pDescriptorRanges[x].RegisterSpace; - } - } - - D3D12_ROOT_DESCRIPTOR_TABLE& table_1_0 = pParameters_1_0[n].DescriptorTable; - table_1_0.NumDescriptorRanges = table_1_1.NumDescriptorRanges; - table_1_0.pDescriptorRanges = pDescriptorRanges_1_0; - } - } - } - - if (SUCCEEDED(hr)) - { - CD3DX12_ROOT_SIGNATURE_DESC desc_1_0(desc_1_1.NumParameters, pParameters_1_0, desc_1_1.NumStaticSamplers, desc_1_1.pStaticSamplers, desc_1_1.Flags); - hr = D3D12SerializeRootSignature(&desc_1_0, D3D_ROOT_SIGNATURE_VERSION_1, ppBlob, ppErrorBlob); - } - - if (pParameters) - { - for (UINT n = 0; n < desc_1_1.NumParameters; n++) - { - if (desc_1_1.pParameters[n].ParameterType == D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE) - { - HeapFree(GetProcessHeap(), 0, reinterpret_cast(const_cast(pParameters_1_0[n].DescriptorTable.pDescriptorRanges))); - } - } - HeapFree(GetProcessHeap(), 0, pParameters); - } - return hr; - } - } - break; - - case D3D_ROOT_SIGNATURE_VERSION_1_1: - return D3D12SerializeVersionedRootSignature(pRootSignatureDesc, ppBlob, ppErrorBlob); - } - - return E_INVALIDARG; -} - -//------------------------------------------------------------------------------------------------ -struct CD3DX12_RT_FORMAT_ARRAY : public D3D12_RT_FORMAT_ARRAY -{ - CD3DX12_RT_FORMAT_ARRAY() = default; - explicit CD3DX12_RT_FORMAT_ARRAY(const D3D12_RT_FORMAT_ARRAY& o) - : D3D12_RT_FORMAT_ARRAY(o) - {} - explicit CD3DX12_RT_FORMAT_ARRAY(_In_reads_(NumFormats) const DXGI_FORMAT* pFormats, UINT NumFormats) - { - NumRenderTargets = NumFormats; - memcpy(RTFormats, pFormats, sizeof(RTFormats)); - // assumes ARRAY_SIZE(pFormats) == ARRAY_SIZE(RTFormats) - } -}; - -//------------------------------------------------------------------------------------------------ -// Pipeline State Stream Helpers -//------------------------------------------------------------------------------------------------ - -//------------------------------------------------------------------------------------------------ -// Stream Subobjects, i.e. elements of a stream - -struct DefaultSampleMask { operator UINT() { return UINT_MAX; } }; -struct DefaultSampleDesc { operator DXGI_SAMPLE_DESC() { return DXGI_SAMPLE_DESC{1, 0}; } }; - -#pragma warning(push) -#pragma warning(disable : 4324) -template -class alignas(void*) CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT -{ -private: - D3D12_PIPELINE_STATE_SUBOBJECT_TYPE _Type; - InnerStructType _Inner; -public: - CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT() noexcept : _Type(Type), _Inner(DefaultArg()) {} - CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT(InnerStructType const& i) : _Type(Type), _Inner(i) {} - CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT& operator=(InnerStructType const& i) { _Inner = i; return *this; } - operator InnerStructType const&() const { return _Inner; } - operator InnerStructType&() { return _Inner; } - InnerStructType* operator&() { return &_Inner; } - InnerStructType const* operator&() const { return &_Inner; } -}; -#pragma warning(pop) -typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_PIPELINE_STATE_FLAGS, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_FLAGS> CD3DX12_PIPELINE_STATE_STREAM_FLAGS; -typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< UINT, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_NODE_MASK> CD3DX12_PIPELINE_STATE_STREAM_NODE_MASK; -typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< ID3D12RootSignature*, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_ROOT_SIGNATURE> CD3DX12_PIPELINE_STATE_STREAM_ROOT_SIGNATURE; -typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_INPUT_LAYOUT_DESC, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_INPUT_LAYOUT> CD3DX12_PIPELINE_STATE_STREAM_INPUT_LAYOUT; -typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_INDEX_BUFFER_STRIP_CUT_VALUE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_IB_STRIP_CUT_VALUE> CD3DX12_PIPELINE_STATE_STREAM_IB_STRIP_CUT_VALUE; -typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_PRIMITIVE_TOPOLOGY_TYPE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PRIMITIVE_TOPOLOGY> CD3DX12_PIPELINE_STATE_STREAM_PRIMITIVE_TOPOLOGY; -typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VS> CD3DX12_PIPELINE_STATE_STREAM_VS; -typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_GS> CD3DX12_PIPELINE_STATE_STREAM_GS; -typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_STREAM_OUTPUT_DESC, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_STREAM_OUTPUT> CD3DX12_PIPELINE_STATE_STREAM_STREAM_OUTPUT; -typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_HS> CD3DX12_PIPELINE_STATE_STREAM_HS; -typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DS> CD3DX12_PIPELINE_STATE_STREAM_DS; -typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PS> CD3DX12_PIPELINE_STATE_STREAM_PS; -typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_SHADER_BYTECODE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CS> CD3DX12_PIPELINE_STATE_STREAM_CS; -typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< CD3DX12_BLEND_DESC, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_BLEND, CD3DX12_DEFAULT> CD3DX12_PIPELINE_STATE_STREAM_BLEND_DESC; -typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< CD3DX12_DEPTH_STENCIL_DESC, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL, CD3DX12_DEFAULT> CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL; -typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< CD3DX12_DEPTH_STENCIL_DESC1, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1, CD3DX12_DEFAULT> CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL1; -typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< DXGI_FORMAT, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL_FORMAT> CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL_FORMAT; -typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< CD3DX12_RASTERIZER_DESC, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RASTERIZER, CD3DX12_DEFAULT> CD3DX12_PIPELINE_STATE_STREAM_RASTERIZER; -typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_RT_FORMAT_ARRAY, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RENDER_TARGET_FORMATS> CD3DX12_PIPELINE_STATE_STREAM_RENDER_TARGET_FORMATS; -typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< DXGI_SAMPLE_DESC, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_DESC, DefaultSampleDesc> CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_DESC; -typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< UINT, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_MASK, DefaultSampleMask> CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_MASK; -typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< D3D12_CACHED_PIPELINE_STATE, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CACHED_PSO> CD3DX12_PIPELINE_STATE_STREAM_CACHED_PSO; -typedef CD3DX12_PIPELINE_STATE_STREAM_SUBOBJECT< CD3DX12_VIEW_INSTANCING_DESC, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VIEW_INSTANCING, CD3DX12_DEFAULT> CD3DX12_PIPELINE_STATE_STREAM_VIEW_INSTANCING; - -//------------------------------------------------------------------------------------------------ -// Stream Parser Helpers - -struct ID3DX12PipelineParserCallbacks -{ - // Subobject Callbacks - virtual void FlagsCb(D3D12_PIPELINE_STATE_FLAGS) {} - virtual void NodeMaskCb(UINT) {} - virtual void RootSignatureCb(ID3D12RootSignature*) {} - virtual void InputLayoutCb(const D3D12_INPUT_LAYOUT_DESC&) {} - virtual void IBStripCutValueCb(D3D12_INDEX_BUFFER_STRIP_CUT_VALUE) {} - virtual void PrimitiveTopologyTypeCb(D3D12_PRIMITIVE_TOPOLOGY_TYPE) {} - virtual void VSCb(const D3D12_SHADER_BYTECODE&) {} - virtual void GSCb(const D3D12_SHADER_BYTECODE&) {} - virtual void StreamOutputCb(const D3D12_STREAM_OUTPUT_DESC&) {} - virtual void HSCb(const D3D12_SHADER_BYTECODE&) {} - virtual void DSCb(const D3D12_SHADER_BYTECODE&) {} - virtual void PSCb(const D3D12_SHADER_BYTECODE&) {} - virtual void CSCb(const D3D12_SHADER_BYTECODE&) {} - virtual void BlendStateCb(const D3D12_BLEND_DESC&) {} - virtual void DepthStencilStateCb(const D3D12_DEPTH_STENCIL_DESC&) {} - virtual void DepthStencilState1Cb(const D3D12_DEPTH_STENCIL_DESC1&) {} - virtual void DSVFormatCb(DXGI_FORMAT) {} - virtual void RasterizerStateCb(const D3D12_RASTERIZER_DESC&) {} - virtual void RTVFormatsCb(const D3D12_RT_FORMAT_ARRAY&) {} - virtual void SampleDescCb(const DXGI_SAMPLE_DESC&) {} - virtual void SampleMaskCb(UINT) {} - virtual void ViewInstancingCb(const D3D12_VIEW_INSTANCING_DESC&) {} - virtual void CachedPSOCb(const D3D12_CACHED_PIPELINE_STATE&) {} - - // Error Callbacks - virtual void ErrorBadInputParameter(UINT /*ParameterIndex*/) {} - virtual void ErrorDuplicateSubobject(D3D12_PIPELINE_STATE_SUBOBJECT_TYPE /*DuplicateType*/) {} - virtual void ErrorUnknownSubobject(UINT /*UnknownTypeValue*/) {} - - virtual ~ID3DX12PipelineParserCallbacks() = default; -}; - -// CD3DX12_PIPELINE_STATE_STREAM1 Works on RS3+ (where there is a new view instancing subobject). -// Use CD3DX12_PIPELINE_STATE_STREAM for RS2+ support. -struct CD3DX12_PIPELINE_STATE_STREAM1 -{ - CD3DX12_PIPELINE_STATE_STREAM1() = default; - CD3DX12_PIPELINE_STATE_STREAM1(const D3D12_GRAPHICS_PIPELINE_STATE_DESC& Desc) - : Flags(Desc.Flags) - , NodeMask(Desc.NodeMask) - , pRootSignature(Desc.pRootSignature) - , InputLayout(Desc.InputLayout) - , IBStripCutValue(Desc.IBStripCutValue) - , PrimitiveTopologyType(Desc.PrimitiveTopologyType) - , VS(Desc.VS) - , GS(Desc.GS) - , StreamOutput(Desc.StreamOutput) - , HS(Desc.HS) - , DS(Desc.DS) - , PS(Desc.PS) - , BlendState(CD3DX12_BLEND_DESC(Desc.BlendState)) - , DepthStencilState(CD3DX12_DEPTH_STENCIL_DESC1(Desc.DepthStencilState)) - , DSVFormat(Desc.DSVFormat) - , RasterizerState(CD3DX12_RASTERIZER_DESC(Desc.RasterizerState)) - , RTVFormats(CD3DX12_RT_FORMAT_ARRAY(Desc.RTVFormats, Desc.NumRenderTargets)) - , SampleDesc(Desc.SampleDesc) - , SampleMask(Desc.SampleMask) - , CachedPSO(Desc.CachedPSO) - , ViewInstancingDesc(CD3DX12_VIEW_INSTANCING_DESC(CD3DX12_DEFAULT())) - {} - CD3DX12_PIPELINE_STATE_STREAM1(const D3D12_COMPUTE_PIPELINE_STATE_DESC& Desc) - : Flags(Desc.Flags) - , NodeMask(Desc.NodeMask) - , pRootSignature(Desc.pRootSignature) - , CS(CD3DX12_SHADER_BYTECODE(Desc.CS)) - , CachedPSO(Desc.CachedPSO) - { - static_cast(DepthStencilState).DepthEnable = false; - } - CD3DX12_PIPELINE_STATE_STREAM_FLAGS Flags; - CD3DX12_PIPELINE_STATE_STREAM_NODE_MASK NodeMask; - CD3DX12_PIPELINE_STATE_STREAM_ROOT_SIGNATURE pRootSignature; - CD3DX12_PIPELINE_STATE_STREAM_INPUT_LAYOUT InputLayout; - CD3DX12_PIPELINE_STATE_STREAM_IB_STRIP_CUT_VALUE IBStripCutValue; - CD3DX12_PIPELINE_STATE_STREAM_PRIMITIVE_TOPOLOGY PrimitiveTopologyType; - CD3DX12_PIPELINE_STATE_STREAM_VS VS; - CD3DX12_PIPELINE_STATE_STREAM_GS GS; - CD3DX12_PIPELINE_STATE_STREAM_STREAM_OUTPUT StreamOutput; - CD3DX12_PIPELINE_STATE_STREAM_HS HS; - CD3DX12_PIPELINE_STATE_STREAM_DS DS; - CD3DX12_PIPELINE_STATE_STREAM_PS PS; - CD3DX12_PIPELINE_STATE_STREAM_CS CS; - CD3DX12_PIPELINE_STATE_STREAM_BLEND_DESC BlendState; - CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL1 DepthStencilState; - CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL_FORMAT DSVFormat; - CD3DX12_PIPELINE_STATE_STREAM_RASTERIZER RasterizerState; - CD3DX12_PIPELINE_STATE_STREAM_RENDER_TARGET_FORMATS RTVFormats; - CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_DESC SampleDesc; - CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_MASK SampleMask; - CD3DX12_PIPELINE_STATE_STREAM_CACHED_PSO CachedPSO; - CD3DX12_PIPELINE_STATE_STREAM_VIEW_INSTANCING ViewInstancingDesc; - D3D12_GRAPHICS_PIPELINE_STATE_DESC GraphicsDescV0() const - { - D3D12_GRAPHICS_PIPELINE_STATE_DESC D; - D.Flags = this->Flags; - D.NodeMask = this->NodeMask; - D.pRootSignature = this->pRootSignature; - D.InputLayout = this->InputLayout; - D.IBStripCutValue = this->IBStripCutValue; - D.PrimitiveTopologyType = this->PrimitiveTopologyType; - D.VS = this->VS; - D.GS = this->GS; - D.StreamOutput = this->StreamOutput; - D.HS = this->HS; - D.DS = this->DS; - D.PS = this->PS; - D.BlendState = this->BlendState; - D.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC1(D3D12_DEPTH_STENCIL_DESC1(this->DepthStencilState)); - D.DSVFormat = this->DSVFormat; - D.RasterizerState = this->RasterizerState; - D.NumRenderTargets = D3D12_RT_FORMAT_ARRAY(this->RTVFormats).NumRenderTargets; - memcpy(D.RTVFormats, D3D12_RT_FORMAT_ARRAY(this->RTVFormats).RTFormats, sizeof(D.RTVFormats)); - D.SampleDesc = this->SampleDesc; - D.SampleMask = this->SampleMask; - D.CachedPSO = this->CachedPSO; - return D; - } - D3D12_COMPUTE_PIPELINE_STATE_DESC ComputeDescV0() const - { - D3D12_COMPUTE_PIPELINE_STATE_DESC D; - D.Flags = this->Flags; - D.NodeMask = this->NodeMask; - D.pRootSignature = this->pRootSignature; - D.CS = this->CS; - D.CachedPSO = this->CachedPSO; - return D; - } -}; - -// CD3DX12_PIPELINE_STATE_STREAM works on RS2+ but does not support new subobject(s) added in RS3+. -// See CD3DX12_PIPELINE_STATE_STREAM1 for instance. -struct CD3DX12_PIPELINE_STATE_STREAM -{ - CD3DX12_PIPELINE_STATE_STREAM() = default; - CD3DX12_PIPELINE_STATE_STREAM(const D3D12_GRAPHICS_PIPELINE_STATE_DESC& Desc) - : Flags(Desc.Flags) - , NodeMask(Desc.NodeMask) - , pRootSignature(Desc.pRootSignature) - , InputLayout(Desc.InputLayout) - , IBStripCutValue(Desc.IBStripCutValue) - , PrimitiveTopologyType(Desc.PrimitiveTopologyType) - , VS(Desc.VS) - , GS(Desc.GS) - , StreamOutput(Desc.StreamOutput) - , HS(Desc.HS) - , DS(Desc.DS) - , PS(Desc.PS) - , BlendState(CD3DX12_BLEND_DESC(Desc.BlendState)) - , DepthStencilState(CD3DX12_DEPTH_STENCIL_DESC1(Desc.DepthStencilState)) - , DSVFormat(Desc.DSVFormat) - , RasterizerState(CD3DX12_RASTERIZER_DESC(Desc.RasterizerState)) - , RTVFormats(CD3DX12_RT_FORMAT_ARRAY(Desc.RTVFormats, Desc.NumRenderTargets)) - , SampleDesc(Desc.SampleDesc) - , SampleMask(Desc.SampleMask) - , CachedPSO(Desc.CachedPSO) - {} - CD3DX12_PIPELINE_STATE_STREAM(const D3D12_COMPUTE_PIPELINE_STATE_DESC& Desc) - : Flags(Desc.Flags) - , NodeMask(Desc.NodeMask) - , pRootSignature(Desc.pRootSignature) - , CS(CD3DX12_SHADER_BYTECODE(Desc.CS)) - , CachedPSO(Desc.CachedPSO) - {} - CD3DX12_PIPELINE_STATE_STREAM_FLAGS Flags; - CD3DX12_PIPELINE_STATE_STREAM_NODE_MASK NodeMask; - CD3DX12_PIPELINE_STATE_STREAM_ROOT_SIGNATURE pRootSignature; - CD3DX12_PIPELINE_STATE_STREAM_INPUT_LAYOUT InputLayout; - CD3DX12_PIPELINE_STATE_STREAM_IB_STRIP_CUT_VALUE IBStripCutValue; - CD3DX12_PIPELINE_STATE_STREAM_PRIMITIVE_TOPOLOGY PrimitiveTopologyType; - CD3DX12_PIPELINE_STATE_STREAM_VS VS; - CD3DX12_PIPELINE_STATE_STREAM_GS GS; - CD3DX12_PIPELINE_STATE_STREAM_STREAM_OUTPUT StreamOutput; - CD3DX12_PIPELINE_STATE_STREAM_HS HS; - CD3DX12_PIPELINE_STATE_STREAM_DS DS; - CD3DX12_PIPELINE_STATE_STREAM_PS PS; - CD3DX12_PIPELINE_STATE_STREAM_CS CS; - CD3DX12_PIPELINE_STATE_STREAM_BLEND_DESC BlendState; - CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL1 DepthStencilState; - CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL_FORMAT DSVFormat; - CD3DX12_PIPELINE_STATE_STREAM_RASTERIZER RasterizerState; - CD3DX12_PIPELINE_STATE_STREAM_RENDER_TARGET_FORMATS RTVFormats; - CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_DESC SampleDesc; - CD3DX12_PIPELINE_STATE_STREAM_SAMPLE_MASK SampleMask; - CD3DX12_PIPELINE_STATE_STREAM_CACHED_PSO CachedPSO; - D3D12_GRAPHICS_PIPELINE_STATE_DESC GraphicsDescV0() const - { - D3D12_GRAPHICS_PIPELINE_STATE_DESC D; - D.Flags = this->Flags; - D.NodeMask = this->NodeMask; - D.pRootSignature = this->pRootSignature; - D.InputLayout = this->InputLayout; - D.IBStripCutValue = this->IBStripCutValue; - D.PrimitiveTopologyType = this->PrimitiveTopologyType; - D.VS = this->VS; - D.GS = this->GS; - D.StreamOutput = this->StreamOutput; - D.HS = this->HS; - D.DS = this->DS; - D.PS = this->PS; - D.BlendState = this->BlendState; - D.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC1(D3D12_DEPTH_STENCIL_DESC1(this->DepthStencilState)); - D.DSVFormat = this->DSVFormat; - D.RasterizerState = this->RasterizerState; - D.NumRenderTargets = D3D12_RT_FORMAT_ARRAY(this->RTVFormats).NumRenderTargets; - memcpy(D.RTVFormats, D3D12_RT_FORMAT_ARRAY(this->RTVFormats).RTFormats, sizeof(D.RTVFormats)); - D.SampleDesc = this->SampleDesc; - D.SampleMask = this->SampleMask; - D.CachedPSO = this->CachedPSO; - return D; - } - D3D12_COMPUTE_PIPELINE_STATE_DESC ComputeDescV0() const - { - D3D12_COMPUTE_PIPELINE_STATE_DESC D; - D.Flags = this->Flags; - D.NodeMask = this->NodeMask; - D.pRootSignature = this->pRootSignature; - D.CS = this->CS; - D.CachedPSO = this->CachedPSO; - return D; - } -}; - -struct CD3DX12_PIPELINE_STATE_STREAM_PARSE_HELPER : public ID3DX12PipelineParserCallbacks -{ - CD3DX12_PIPELINE_STATE_STREAM1 PipelineStream; - CD3DX12_PIPELINE_STATE_STREAM_PARSE_HELPER() noexcept - : SeenDSS(false) - { - // Adjust defaults to account for absent members. - PipelineStream.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE; - - // Depth disabled if no DSV format specified. - static_cast(PipelineStream.DepthStencilState).DepthEnable = false; - } - - // ID3DX12PipelineParserCallbacks - void FlagsCb(D3D12_PIPELINE_STATE_FLAGS Flags) override {PipelineStream.Flags = Flags;} - void NodeMaskCb(UINT NodeMask) override {PipelineStream.NodeMask = NodeMask;} - void RootSignatureCb(ID3D12RootSignature* pRootSignature) override {PipelineStream.pRootSignature = pRootSignature;} - void InputLayoutCb(const D3D12_INPUT_LAYOUT_DESC& InputLayout) override {PipelineStream.InputLayout = InputLayout;} - void IBStripCutValueCb(D3D12_INDEX_BUFFER_STRIP_CUT_VALUE IBStripCutValue) override {PipelineStream.IBStripCutValue = IBStripCutValue;} - void PrimitiveTopologyTypeCb(D3D12_PRIMITIVE_TOPOLOGY_TYPE PrimitiveTopologyType) override {PipelineStream.PrimitiveTopologyType = PrimitiveTopologyType;} - void VSCb(const D3D12_SHADER_BYTECODE& VS) override {PipelineStream.VS = VS;} - void GSCb(const D3D12_SHADER_BYTECODE& GS) override {PipelineStream.GS = GS;} - void StreamOutputCb(const D3D12_STREAM_OUTPUT_DESC& StreamOutput) override {PipelineStream.StreamOutput = StreamOutput;} - void HSCb(const D3D12_SHADER_BYTECODE& HS) override {PipelineStream.HS = HS;} - void DSCb(const D3D12_SHADER_BYTECODE& DS) override {PipelineStream.DS = DS;} - void PSCb(const D3D12_SHADER_BYTECODE& PS) override {PipelineStream.PS = PS;} - void CSCb(const D3D12_SHADER_BYTECODE& CS) override {PipelineStream.CS = CS;} - void BlendStateCb(const D3D12_BLEND_DESC& BlendState) override {PipelineStream.BlendState = CD3DX12_BLEND_DESC(BlendState);} - void DepthStencilStateCb(const D3D12_DEPTH_STENCIL_DESC& DepthStencilState) override - { - PipelineStream.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC1(DepthStencilState); - SeenDSS = true; - } - void DepthStencilState1Cb(const D3D12_DEPTH_STENCIL_DESC1& DepthStencilState) override - { - PipelineStream.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC1(DepthStencilState); - SeenDSS = true; - } - void DSVFormatCb(DXGI_FORMAT DSVFormat) override - { - PipelineStream.DSVFormat = DSVFormat; - if (!SeenDSS && DSVFormat != DXGI_FORMAT_UNKNOWN) - { - // Re-enable depth for the default state. - static_cast(PipelineStream.DepthStencilState).DepthEnable = true; - } - } - void RasterizerStateCb(const D3D12_RASTERIZER_DESC& RasterizerState) override {PipelineStream.RasterizerState = CD3DX12_RASTERIZER_DESC(RasterizerState);} - void RTVFormatsCb(const D3D12_RT_FORMAT_ARRAY& RTVFormats) override {PipelineStream.RTVFormats = RTVFormats;} - void SampleDescCb(const DXGI_SAMPLE_DESC& SampleDesc) override {PipelineStream.SampleDesc = SampleDesc;} - void SampleMaskCb(UINT SampleMask) override {PipelineStream.SampleMask = SampleMask;} - void ViewInstancingCb(const D3D12_VIEW_INSTANCING_DESC& ViewInstancingDesc) override {PipelineStream.ViewInstancingDesc = CD3DX12_VIEW_INSTANCING_DESC(ViewInstancingDesc);} - void CachedPSOCb(const D3D12_CACHED_PIPELINE_STATE& CachedPSO) override {PipelineStream.CachedPSO = CachedPSO;} - -private: - bool SeenDSS; -}; - -inline D3D12_PIPELINE_STATE_SUBOBJECT_TYPE D3DX12GetBaseSubobjectType(D3D12_PIPELINE_STATE_SUBOBJECT_TYPE SubobjectType) -{ - switch (SubobjectType) - { - case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1: - return D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL; - default: - return SubobjectType; - } -} - -inline HRESULT D3DX12ParsePipelineStream(const D3D12_PIPELINE_STATE_STREAM_DESC& Desc, ID3DX12PipelineParserCallbacks* pCallbacks) -{ - if (pCallbacks == nullptr) - { - return E_INVALIDARG; - } - - if (Desc.SizeInBytes == 0 || Desc.pPipelineStateSubobjectStream == nullptr) - { - pCallbacks->ErrorBadInputParameter(1); // first parameter issue - return E_INVALIDARG; - } - - bool SubobjectSeen[D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MAX_VALID] = {}; - for (SIZE_T CurOffset = 0, SizeOfSubobject = 0; CurOffset < Desc.SizeInBytes; CurOffset += SizeOfSubobject) - { - BYTE* pStream = static_cast(Desc.pPipelineStateSubobjectStream)+CurOffset; - auto SubobjectType = *reinterpret_cast(pStream); - if (SubobjectType < 0 || SubobjectType >= D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MAX_VALID) - { - pCallbacks->ErrorUnknownSubobject(SubobjectType); - return E_INVALIDARG; - } - if (SubobjectSeen[D3DX12GetBaseSubobjectType(SubobjectType)]) - { - pCallbacks->ErrorDuplicateSubobject(SubobjectType); - return E_INVALIDARG; // disallow subobject duplicates in a stream - } - SubobjectSeen[SubobjectType] = true; - switch (SubobjectType) - { - case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_ROOT_SIGNATURE: - pCallbacks->RootSignatureCb(*reinterpret_cast(pStream)); - SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::pRootSignature); - break; - case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VS: - pCallbacks->VSCb(*reinterpret_cast(pStream)); - SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::VS); - break; - case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PS: - pCallbacks->PSCb(*reinterpret_cast(pStream)); - SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::PS); - break; - case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DS: - pCallbacks->DSCb(*reinterpret_cast(pStream)); - SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::DS); - break; - case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_HS: - pCallbacks->HSCb(*reinterpret_cast(pStream)); - SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::HS); - break; - case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_GS: - pCallbacks->GSCb(*reinterpret_cast(pStream)); - SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::GS); - break; - case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CS: - pCallbacks->CSCb(*reinterpret_cast(pStream)); - SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::CS); - break; - case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_STREAM_OUTPUT: - pCallbacks->StreamOutputCb(*reinterpret_cast(pStream)); - SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::StreamOutput); - break; - case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_BLEND: - pCallbacks->BlendStateCb(*reinterpret_cast(pStream)); - SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::BlendState); - break; - case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_MASK: - pCallbacks->SampleMaskCb(*reinterpret_cast(pStream)); - SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::SampleMask); - break; - case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RASTERIZER: - pCallbacks->RasterizerStateCb(*reinterpret_cast(pStream)); - SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::RasterizerState); - break; - case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL: - pCallbacks->DepthStencilStateCb(*reinterpret_cast(pStream)); - SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM_DEPTH_STENCIL); - break; - case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1: - pCallbacks->DepthStencilState1Cb(*reinterpret_cast(pStream)); - SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::DepthStencilState); - break; - case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_INPUT_LAYOUT: - pCallbacks->InputLayoutCb(*reinterpret_cast(pStream)); - SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::InputLayout); - break; - case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_IB_STRIP_CUT_VALUE: - pCallbacks->IBStripCutValueCb(*reinterpret_cast(pStream)); - SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::IBStripCutValue); - break; - case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PRIMITIVE_TOPOLOGY: - pCallbacks->PrimitiveTopologyTypeCb(*reinterpret_cast(pStream)); - SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::PrimitiveTopologyType); - break; - case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RENDER_TARGET_FORMATS: - pCallbacks->RTVFormatsCb(*reinterpret_cast(pStream)); - SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::RTVFormats); - break; - case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL_FORMAT: - pCallbacks->DSVFormatCb(*reinterpret_cast(pStream)); - SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::DSVFormat); - break; - case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_DESC: - pCallbacks->SampleDescCb(*reinterpret_cast(pStream)); - SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::SampleDesc); - break; - case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_NODE_MASK: - pCallbacks->NodeMaskCb(*reinterpret_cast(pStream)); - SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::NodeMask); - break; - case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CACHED_PSO: - pCallbacks->CachedPSOCb(*reinterpret_cast(pStream)); - SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::CachedPSO); - break; - case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_FLAGS: - pCallbacks->FlagsCb(*reinterpret_cast(pStream)); - SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM::Flags); - break; - case D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VIEW_INSTANCING: - pCallbacks->ViewInstancingCb(*reinterpret_cast(pStream)); - SizeOfSubobject = sizeof(CD3DX12_PIPELINE_STATE_STREAM1::ViewInstancingDesc); - break; - default: - pCallbacks->ErrorUnknownSubobject(SubobjectType); - return E_INVALIDARG; - break; - } - } - - return S_OK; -} - -//------------------------------------------------------------------------------------------------ -inline bool operator==( const D3D12_CLEAR_VALUE &a, const D3D12_CLEAR_VALUE &b) -{ - if (a.Format != b.Format) return false; - if (a.Format == DXGI_FORMAT_D24_UNORM_S8_UINT - || a.Format == DXGI_FORMAT_D16_UNORM - || a.Format == DXGI_FORMAT_D32_FLOAT - || a.Format == DXGI_FORMAT_D32_FLOAT_S8X24_UINT) - { - return (a.DepthStencil.Depth == b.DepthStencil.Depth) && - (a.DepthStencil.Stencil == b.DepthStencil.Stencil); - } else { - return (a.Color[0] == b.Color[0]) && - (a.Color[1] == b.Color[1]) && - (a.Color[2] == b.Color[2]) && - (a.Color[3] == b.Color[3]); - } -} -inline bool operator==( const D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS &a, const D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS &b) -{ - return a.ClearValue == b.ClearValue; -} -inline bool operator==( const D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS &a, const D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS &b) -{ - if (a.pSrcResource != b.pSrcResource) return false; - if (a.pDstResource != b.pDstResource) return false; - if (a.SubresourceCount != b.SubresourceCount) return false; - if (a.Format != b.Format) return false; - if (a.ResolveMode != b.ResolveMode) return false; - if (a.PreserveResolveSource != b.PreserveResolveSource) return false; - return true; -} -inline bool operator==( const D3D12_RENDER_PASS_BEGINNING_ACCESS &a, const D3D12_RENDER_PASS_BEGINNING_ACCESS &b) -{ - if (a.Type != b.Type) return false; - if (a.Type == D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR && !(a.Clear == b.Clear)) return false; - return true; -} -inline bool operator==( const D3D12_RENDER_PASS_ENDING_ACCESS &a, const D3D12_RENDER_PASS_ENDING_ACCESS &b) -{ - if (a.Type != b.Type) return false; - if (a.Type == D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_RESOLVE && !(a.Resolve == b.Resolve)) return false; - return true; -} -inline bool operator==( const D3D12_RENDER_PASS_RENDER_TARGET_DESC &a, const D3D12_RENDER_PASS_RENDER_TARGET_DESC &b) -{ - if (a.cpuDescriptor.ptr != b.cpuDescriptor.ptr) return false; - if (!(a.BeginningAccess == b.BeginningAccess)) return false; - if (!(a.EndingAccess == b.EndingAccess)) return false; - return true; -} -inline bool operator==( const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC &a, const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC &b) -{ - if (a.cpuDescriptor.ptr != b.cpuDescriptor.ptr) return false; - if (!(a.DepthBeginningAccess == b.DepthBeginningAccess)) return false; - if (!(a.StencilBeginningAccess == b.StencilBeginningAccess)) return false; - if (!(a.DepthEndingAccess == b.DepthEndingAccess)) return false; - if (!(a.StencilEndingAccess == b.StencilEndingAccess)) return false; - return true; -} - - -#ifndef D3DX12_NO_STATE_OBJECT_HELPERS - -//================================================================================================ -// D3DX12 State Object Creation Helpers -// -// Helper classes for creating new style state objects out of an arbitrary set of subobjects. -// Uses STL -// -// Start by instantiating CD3DX12_STATE_OBJECT_DESC (see it's public methods). -// One of its methods is CreateSubobject(), which has a comment showing a couple of options for -// defining subobjects using the helper classes for each subobject (CD3DX12_DXIL_LIBRARY_SUBOBJECT -// etc.). The subobject helpers each have methods specific to the subobject for configuring it's -// contents. -// -//================================================================================================ -#include -#include -#include -#include -#include - -//------------------------------------------------------------------------------------------------ -class CD3DX12_STATE_OBJECT_DESC -{ -public: - CD3DX12_STATE_OBJECT_DESC() - { - Init(D3D12_STATE_OBJECT_TYPE_COLLECTION); - } - CD3DX12_STATE_OBJECT_DESC(D3D12_STATE_OBJECT_TYPE Type) - { - Init(Type); - } - void SetStateObjectType(D3D12_STATE_OBJECT_TYPE Type) { m_Desc.Type = Type; } - operator const D3D12_STATE_OBJECT_DESC&() - { - // Do final preparation work - m_RepointedAssociations.clear(); - m_SubobjectArray.clear(); - m_SubobjectArray.reserve(m_Desc.NumSubobjects); - // Flatten subobjects into an array (each flattened subobject still has a - // member that's a pointer to it's desc that's not flattened) - for (auto Iter = m_SubobjectList.begin(); - Iter != m_SubobjectList.end(); Iter++) - { - m_SubobjectArray.push_back(*Iter); - // Store new location in array so we can redirect pointers contained in subobjects - Iter->pSubobjectArrayLocation = &m_SubobjectArray.back(); - } - // For subobjects with pointer fields, create a new copy of those subobject definitions - // with fixed pointers - for (UINT i = 0; i < m_Desc.NumSubobjects; i++) - { - if (m_SubobjectArray[i].Type == D3D12_STATE_SUBOBJECT_TYPE_SUBOBJECT_TO_EXPORTS_ASSOCIATION) - { - auto pOriginalSubobjectAssociation = - reinterpret_cast(m_SubobjectArray[i].pDesc); - D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION Repointed = *pOriginalSubobjectAssociation; - auto pWrapper = - static_cast(pOriginalSubobjectAssociation->pSubobjectToAssociate); - Repointed.pSubobjectToAssociate = pWrapper->pSubobjectArrayLocation; - m_RepointedAssociations.push_back(Repointed); - m_SubobjectArray[i].pDesc = &m_RepointedAssociations.back(); - } - } - // Below: using ugly way to get pointer in case .data() is not defined - m_Desc.pSubobjects = m_Desc.NumSubobjects ? &m_SubobjectArray[0] : nullptr; - return m_Desc; - } - operator const D3D12_STATE_OBJECT_DESC*() - { - // Cast calls the above final preparation work - return &static_cast(*this); - } - - // CreateSubobject creates a sububject helper (e.g. CD3DX12_HIT_GROUP_SUBOBJECT) - // whose lifetime is owned by this class. - // e.g. - // - // CD3DX12_STATE_OBJECT_DESC Collection1(D3D12_STATE_OBJECT_TYPE_COLLECTION); - // auto Lib0 = Collection1.CreateSubobject(); - // Lib0->SetDXILLibrary(&pMyAppDxilLibs[0]); - // Lib0->DefineExport(L"rayGenShader0"); // in practice these export listings might be - // // data/engine driven - // etc. - // - // Alternatively, users can instantiate sububject helpers explicitly, such as via local - // variables instead, passing the state object desc that should point to it into the helper - // constructor (or call mySubobjectHelper.AddToStateObject(Collection1)). - // In this alternative scenario, the user must keep the subobject alive as long as the state - // object it is associated with is alive, else it's pointer references will be stale. - // e.g. - // - // CD3DX12_STATE_OBJECT_DESC RaytracingState2(D3D12_STATE_OBJECT_TYPE_RAYTRACING_PIPELINE); - // CD3DX12_DXIL_LIBRARY_SUBOBJECT LibA(RaytracingState2); - // LibA.SetDXILLibrary(&pMyAppDxilLibs[4]); // not manually specifying exports - // // - meaning all exports in the libraries - // // are exported - // etc. - - template - T* CreateSubobject() - { - T* pSubobject = new T(*this); - m_OwnedSubobjectHelpers.emplace_back(pSubobject); - return pSubobject; - } - -private: - D3D12_STATE_SUBOBJECT* TrackSubobject(D3D12_STATE_SUBOBJECT_TYPE Type, void* pDesc) - { - SUBOBJECT_WRAPPER Subobject; - Subobject.pSubobjectArrayLocation = nullptr; - Subobject.Type = Type; - Subobject.pDesc = pDesc; - m_SubobjectList.push_back(Subobject); - m_Desc.NumSubobjects++; - return &m_SubobjectList.back(); - } - void Init(D3D12_STATE_OBJECT_TYPE Type) - { - SetStateObjectType(Type); - m_Desc.pSubobjects = nullptr; - m_Desc.NumSubobjects = 0; - m_SubobjectList.clear(); - m_SubobjectArray.clear(); - m_RepointedAssociations.clear(); - } - typedef struct SUBOBJECT_WRAPPER : public D3D12_STATE_SUBOBJECT - { - D3D12_STATE_SUBOBJECT* pSubobjectArrayLocation; // new location when flattened into array - // for repointing pointers in subobjects - } SUBOBJECT_WRAPPER; - D3D12_STATE_OBJECT_DESC m_Desc; - std::list m_SubobjectList; // Pointers to list nodes handed out so - // these can be edited live - std::vector m_SubobjectArray; // Built at the end, copying list contents - - std::list - m_RepointedAssociations; // subobject type that contains pointers to other subobjects, - // repointed to flattened array - - class StringContainer - { - public: - LPCWSTR LocalCopy(LPCWSTR string, bool bSingleString = false) - { - if (string) - { - if (bSingleString) - { - m_Strings.clear(); - m_Strings.push_back(string); - } - else - { - m_Strings.push_back(string); - } - return m_Strings.back().c_str(); - } - else - { - return nullptr; - } - } - void clear() { m_Strings.clear(); } - private: - std::list m_Strings; - }; - - class SUBOBJECT_HELPER_BASE - { - public: - SUBOBJECT_HELPER_BASE() { Init(); } - virtual ~SUBOBJECT_HELPER_BASE() {} - virtual D3D12_STATE_SUBOBJECT_TYPE Type() const = 0; - void AddToStateObject(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject) - { - m_pSubobject = ContainingStateObject.TrackSubobject(Type(), Data()); - } - protected: - virtual void* Data() = 0; - void Init() { m_pSubobject = nullptr; } - D3D12_STATE_SUBOBJECT* m_pSubobject; - }; - -#if(__cplusplus >= 201103L) - std::list> m_OwnedSubobjectHelpers; -#else - class OWNED_HELPER - { - public: - OWNED_HELPER(const SUBOBJECT_HELPER_BASE* pHelper) { m_pHelper = pHelper; } - ~OWNED_HELPER() { delete m_pHelper; } - const SUBOBJECT_HELPER_BASE* m_pHelper; - }; - - std::list m_OwnedSubobjectHelpers; -#endif - - friend class CD3DX12_DXIL_LIBRARY_SUBOBJECT; - friend class CD3DX12_EXISTING_COLLECTION_SUBOBJECT; - friend class CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT; - friend class CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION; - friend class CD3DX12_HIT_GROUP_SUBOBJECT; - friend class CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT; - friend class CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT; - friend class CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT; - friend class CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT; - friend class CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT; - friend class CD3DX12_NODE_MASK_SUBOBJECT; -}; - -//------------------------------------------------------------------------------------------------ -class CD3DX12_DXIL_LIBRARY_SUBOBJECT - : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE -{ -public: - CD3DX12_DXIL_LIBRARY_SUBOBJECT() - { - Init(); - } - CD3DX12_DXIL_LIBRARY_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject) - { - Init(); - AddToStateObject(ContainingStateObject); - } - void SetDXILLibrary(D3D12_SHADER_BYTECODE*pCode) - { - static const D3D12_SHADER_BYTECODE Default = {}; - m_Desc.DXILLibrary = pCode ? *pCode : Default; - } - void DefineExport( - LPCWSTR Name, - LPCWSTR ExportToRename = nullptr, - D3D12_EXPORT_FLAGS Flags = D3D12_EXPORT_FLAG_NONE) - { - D3D12_EXPORT_DESC Export; - Export.Name = m_Strings.LocalCopy(Name); - Export.ExportToRename = m_Strings.LocalCopy(ExportToRename); - Export.Flags = Flags; - m_Exports.push_back(Export); - m_Desc.pExports = &m_Exports[0]; // using ugly way to get pointer in case .data() is not defined - m_Desc.NumExports = static_cast(m_Exports.size()); - } - template - void DefineExports(LPCWSTR(&Exports)[N]) - { - for (UINT i = 0; i < N; i++) - { - DefineExport(Exports[i]); - } - } - void DefineExports(LPCWSTR* Exports, UINT N) - { - for (UINT i = 0; i < N; i++) - { - DefineExport(Exports[i]); - } - } - D3D12_STATE_SUBOBJECT_TYPE Type() const - { - return D3D12_STATE_SUBOBJECT_TYPE_DXIL_LIBRARY; - } - operator const D3D12_STATE_SUBOBJECT&() const { return *m_pSubobject; } - operator const D3D12_DXIL_LIBRARY_DESC&() const { return m_Desc; } -private: - void Init() - { - SUBOBJECT_HELPER_BASE::Init(); - m_Desc = {}; - m_Strings.clear(); - m_Exports.clear(); - } - void* Data() { return &m_Desc; } - D3D12_DXIL_LIBRARY_DESC m_Desc; - CD3DX12_STATE_OBJECT_DESC::StringContainer m_Strings; - std::vector m_Exports; -}; - -//------------------------------------------------------------------------------------------------ -class CD3DX12_EXISTING_COLLECTION_SUBOBJECT - : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE -{ -public: - CD3DX12_EXISTING_COLLECTION_SUBOBJECT() - { - Init(); - } - CD3DX12_EXISTING_COLLECTION_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject) - { - Init(); - AddToStateObject(ContainingStateObject); - } - void SetExistingCollection(ID3D12StateObject*pExistingCollection) - { - m_Desc.pExistingCollection = pExistingCollection; - m_CollectionRef = pExistingCollection; - } - void DefineExport( - LPCWSTR Name, - LPCWSTR ExportToRename = nullptr, - D3D12_EXPORT_FLAGS Flags = D3D12_EXPORT_FLAG_NONE) - { - D3D12_EXPORT_DESC Export; - Export.Name = m_Strings.LocalCopy(Name); - Export.ExportToRename = m_Strings.LocalCopy(ExportToRename); - Export.Flags = Flags; - m_Exports.push_back(Export); - m_Desc.pExports = &m_Exports[0]; // using ugly way to get pointer in case .data() is not defined - m_Desc.NumExports = static_cast(m_Exports.size()); - } - template - void DefineExports(LPCWSTR(&Exports)[N]) - { - for (UINT i = 0; i < N; i++) - { - DefineExport(Exports[i]); - } - } - void DefineExports(LPCWSTR* Exports, UINT N) - { - for (UINT i = 0; i < N; i++) - { - DefineExport(Exports[i]); - } - } - D3D12_STATE_SUBOBJECT_TYPE Type() const - { - return D3D12_STATE_SUBOBJECT_TYPE_EXISTING_COLLECTION; - } - operator const D3D12_STATE_SUBOBJECT&() const { return *m_pSubobject; } - operator const D3D12_EXISTING_COLLECTION_DESC&() const { return m_Desc; } -private: - void Init() - { - SUBOBJECT_HELPER_BASE::Init(); - m_Desc = {}; - m_CollectionRef = nullptr; - m_Strings.clear(); - m_Exports.clear(); - } - void* Data() { return &m_Desc; } - D3D12_EXISTING_COLLECTION_DESC m_Desc; - Microsoft::WRL::ComPtr m_CollectionRef; - CD3DX12_STATE_OBJECT_DESC::StringContainer m_Strings; - std::vector m_Exports; -}; - -//------------------------------------------------------------------------------------------------ -class CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT - : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE -{ -public: - CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT() - { - Init(); - } - CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject) - { - Init(); - AddToStateObject(ContainingStateObject); - } - void SetSubobjectToAssociate(const D3D12_STATE_SUBOBJECT& SubobjectToAssociate) - { - m_Desc.pSubobjectToAssociate = &SubobjectToAssociate; - } - void AddExport(LPCWSTR Export) - { - m_Desc.NumExports++; - m_Exports.push_back(m_Strings.LocalCopy(Export)); - m_Desc.pExports = &m_Exports[0]; // using ugly way to get pointer in case .data() is not defined - } - template - void AddExports(LPCWSTR (&Exports)[N]) - { - for (UINT i = 0; i < N; i++) - { - AddExport(Exports[i]); - } - } - void AddExports(LPCWSTR* Exports, UINT N) - { - for (UINT i = 0; i < N; i++) - { - AddExport(Exports[i]); - } - } - D3D12_STATE_SUBOBJECT_TYPE Type() const - { - return D3D12_STATE_SUBOBJECT_TYPE_SUBOBJECT_TO_EXPORTS_ASSOCIATION; - } - operator const D3D12_STATE_SUBOBJECT&() const { return *m_pSubobject; } - operator const D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION&() const { return m_Desc; } -private: - void Init() - { - SUBOBJECT_HELPER_BASE::Init(); - m_Desc = {}; - m_Strings.clear(); - m_Exports.clear(); - } - void* Data() { return &m_Desc; } - D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION m_Desc; - CD3DX12_STATE_OBJECT_DESC::StringContainer m_Strings; - std::vector m_Exports; -}; - -//------------------------------------------------------------------------------------------------ -class CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION - : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE -{ -public: - CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION() - { - Init(); - } - CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject) - { - Init(); - AddToStateObject(ContainingStateObject); - } - void SetSubobjectNameToAssociate(LPCWSTR SubobjectToAssociate) - { - m_Desc.SubobjectToAssociate = m_SubobjectName.LocalCopy(SubobjectToAssociate, true); - } - void AddExport(LPCWSTR Export) - { - m_Desc.NumExports++; - m_Exports.push_back(m_Strings.LocalCopy(Export)); - m_Desc.pExports = &m_Exports[0]; // using ugly way to get pointer in case .data() is not defined - } - template - void AddExports(LPCWSTR (&Exports)[N]) - { - for (UINT i = 0; i < N; i++) - { - AddExport(Exports[i]); - } - } - void AddExports(LPCWSTR* Exports, UINT N) - { - for (UINT i = 0; i < N; i++) - { - AddExport(Exports[i]); - } - } - D3D12_STATE_SUBOBJECT_TYPE Type() const - { - return D3D12_STATE_SUBOBJECT_TYPE_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION; - } - operator const D3D12_STATE_SUBOBJECT&() const { return *m_pSubobject; } - operator const D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION&() const { return m_Desc; } -private: - void Init() - { - SUBOBJECT_HELPER_BASE::Init(); - m_Desc = {}; - m_Strings.clear(); - m_SubobjectName.clear(); - m_Exports.clear(); - } - void* Data() { return &m_Desc; } - D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION m_Desc; - CD3DX12_STATE_OBJECT_DESC::StringContainer m_Strings; - CD3DX12_STATE_OBJECT_DESC::StringContainer m_SubobjectName; - std::vector m_Exports; -}; - -//------------------------------------------------------------------------------------------------ -class CD3DX12_HIT_GROUP_SUBOBJECT - : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE -{ -public: - CD3DX12_HIT_GROUP_SUBOBJECT() - { - Init(); - } - CD3DX12_HIT_GROUP_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject) - { - Init(); - AddToStateObject(ContainingStateObject); - } - void SetHitGroupExport(LPCWSTR exportName) - { - m_Desc.HitGroupExport = m_Strings[0].LocalCopy(exportName, true); - } - void SetHitGroupType(D3D12_HIT_GROUP_TYPE Type) { m_Desc.Type = Type; } - void SetAnyHitShaderImport(LPCWSTR importName) - { - m_Desc.AnyHitShaderImport = m_Strings[1].LocalCopy(importName, true); - } - void SetClosestHitShaderImport(LPCWSTR importName) - { - m_Desc.ClosestHitShaderImport = m_Strings[2].LocalCopy(importName, true); - } - void SetIntersectionShaderImport(LPCWSTR importName) - { - m_Desc.IntersectionShaderImport = m_Strings[3].LocalCopy(importName, true); - } - D3D12_STATE_SUBOBJECT_TYPE Type() const - { - return D3D12_STATE_SUBOBJECT_TYPE_HIT_GROUP; - } - operator const D3D12_STATE_SUBOBJECT&() const { return *m_pSubobject; } - operator const D3D12_HIT_GROUP_DESC&() const { return m_Desc; } -private: - void Init() - { - SUBOBJECT_HELPER_BASE::Init(); - m_Desc = {}; - for (UINT i = 0; i < m_NumStrings; i++) - { - m_Strings[i].clear(); - } - } - void* Data() { return &m_Desc; } - D3D12_HIT_GROUP_DESC m_Desc; - static const UINT m_NumStrings = 4; - CD3DX12_STATE_OBJECT_DESC::StringContainer - m_Strings[m_NumStrings]; // one string for every entrypoint name -}; - -//------------------------------------------------------------------------------------------------ -class CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT - : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE -{ -public: - CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT() - { - Init(); - } - CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject) - { - Init(); - AddToStateObject(ContainingStateObject); - } - void Config(UINT MaxPayloadSizeInBytes, UINT MaxAttributeSizeInBytes) - { - m_Desc.MaxPayloadSizeInBytes = MaxPayloadSizeInBytes; - m_Desc.MaxAttributeSizeInBytes = MaxAttributeSizeInBytes; - } - D3D12_STATE_SUBOBJECT_TYPE Type() const - { - return D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_SHADER_CONFIG; - } - operator const D3D12_STATE_SUBOBJECT&() const { return *m_pSubobject; } - operator const D3D12_RAYTRACING_SHADER_CONFIG&() const { return m_Desc; } -private: - void Init() - { - SUBOBJECT_HELPER_BASE::Init(); - m_Desc = {}; - } - void* Data() { return &m_Desc; } - D3D12_RAYTRACING_SHADER_CONFIG m_Desc; -}; - -//------------------------------------------------------------------------------------------------ -class CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT - : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE -{ -public: - CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT() - { - Init(); - } - CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject) - { - Init(); - AddToStateObject(ContainingStateObject); - } - void Config(UINT MaxTraceRecursionDepth) - { - m_Desc.MaxTraceRecursionDepth = MaxTraceRecursionDepth; - } - D3D12_STATE_SUBOBJECT_TYPE Type() const - { - return D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG; - } - operator const D3D12_STATE_SUBOBJECT&() const { return *m_pSubobject; } - operator const D3D12_RAYTRACING_PIPELINE_CONFIG&() const { return m_Desc; } -private: - void Init() - { - SUBOBJECT_HELPER_BASE::Init(); - m_Desc = {}; - } - void* Data() { return &m_Desc; } - D3D12_RAYTRACING_PIPELINE_CONFIG m_Desc; -}; - -//------------------------------------------------------------------------------------------------ -class CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT - : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE -{ -public: - CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT() - { - Init(); - } - CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject) - { - Init(); - AddToStateObject(ContainingStateObject); - } - void SetRootSignature(ID3D12RootSignature* pRootSig) - { - m_pRootSig = pRootSig; - } - D3D12_STATE_SUBOBJECT_TYPE Type() const - { - return D3D12_STATE_SUBOBJECT_TYPE_GLOBAL_ROOT_SIGNATURE; - } - operator const D3D12_STATE_SUBOBJECT&() const { return *m_pSubobject; } - operator ID3D12RootSignature*() const { return m_pRootSig.Get(); } -private: - void Init() - { - SUBOBJECT_HELPER_BASE::Init(); - m_pRootSig = nullptr; - } - void* Data() { return m_pRootSig.GetAddressOf(); } - Microsoft::WRL::ComPtr m_pRootSig; -}; - -//------------------------------------------------------------------------------------------------ -class CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT - : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE -{ -public: - CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT() - { - Init(); - } - CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject) - { - Init(); - AddToStateObject(ContainingStateObject); - } - void SetRootSignature(ID3D12RootSignature* pRootSig) - { - m_pRootSig = pRootSig; - } - D3D12_STATE_SUBOBJECT_TYPE Type() const - { - return D3D12_STATE_SUBOBJECT_TYPE_LOCAL_ROOT_SIGNATURE; - } - operator const D3D12_STATE_SUBOBJECT&() const { return *m_pSubobject; } - operator ID3D12RootSignature*() const { return m_pRootSig.Get(); } -private: - void Init() - { - SUBOBJECT_HELPER_BASE::Init(); - m_pRootSig = nullptr; - } - void* Data() { return m_pRootSig.GetAddressOf(); } - Microsoft::WRL::ComPtr m_pRootSig; -}; - -//------------------------------------------------------------------------------------------------ -class CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT - : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE -{ -public: - CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT() - { - Init(); - } - CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject) - { - Init(); - AddToStateObject(ContainingStateObject); - } - void SetFlags(D3D12_STATE_OBJECT_FLAGS Flags) - { - m_Desc.Flags = Flags; - } - D3D12_STATE_SUBOBJECT_TYPE Type() const - { - return D3D12_STATE_SUBOBJECT_TYPE_STATE_OBJECT_CONFIG; - } - operator const D3D12_STATE_SUBOBJECT&() const { return *m_pSubobject; } - operator const D3D12_STATE_OBJECT_CONFIG&() const { return m_Desc; } -private: - void Init() - { - SUBOBJECT_HELPER_BASE::Init(); - m_Desc = {}; - } - void* Data() { return &m_Desc; } - D3D12_STATE_OBJECT_CONFIG m_Desc; -}; - -//------------------------------------------------------------------------------------------------ -class CD3DX12_NODE_MASK_SUBOBJECT - : public CD3DX12_STATE_OBJECT_DESC::SUBOBJECT_HELPER_BASE -{ -public: - CD3DX12_NODE_MASK_SUBOBJECT() - { - Init(); - } - CD3DX12_NODE_MASK_SUBOBJECT(CD3DX12_STATE_OBJECT_DESC& ContainingStateObject) - { - Init(); - AddToStateObject(ContainingStateObject); - } - void SetNodeMask(UINT NodeMask) - { - m_Desc.NodeMask = NodeMask; - } - D3D12_STATE_SUBOBJECT_TYPE Type() const - { - return D3D12_STATE_SUBOBJECT_TYPE_NODE_MASK; - } - operator const D3D12_STATE_SUBOBJECT&() const { return *m_pSubobject; } - operator const D3D12_NODE_MASK&() const { return m_Desc; } -private: - void Init() - { - SUBOBJECT_HELPER_BASE::Init(); - m_Desc = {}; - } - void* Data() { return &m_Desc; } - D3D12_NODE_MASK m_Desc; -}; - -#endif // #ifndef D3DX12_NO_STATE_OBJECT_HELPERS - -#endif // defined( __cplusplus ) - -#endif //__D3DX12_H__ diff --git a/src/decomp/pc/gfx/gfx_cc.c b/src/decomp/pc/gfx/gfx_cc.c deleted file mode 100644 index d43f54b..0000000 --- a/src/decomp/pc/gfx/gfx_cc.c +++ /dev/null @@ -1,41 +0,0 @@ -#include "gfx_cc.h" - -void gfx_cc_get_features(uint32_t shader_id, struct CCFeatures *cc_features) { - for (int i = 0; i < 4; i++) { - cc_features->c[0][i] = (shader_id >> (i * 3)) & 7; - cc_features->c[1][i] = (shader_id >> (12 + i * 3)) & 7; - } - - cc_features->opt_alpha = (shader_id & SHADER_OPT_ALPHA) != 0; - cc_features->opt_fog = (shader_id & SHADER_OPT_FOG) != 0; - cc_features->opt_texture_edge = (shader_id & SHADER_OPT_TEXTURE_EDGE) != 0; - cc_features->opt_noise = (shader_id & SHADER_OPT_NOISE) != 0; - - cc_features->used_textures[0] = false; - cc_features->used_textures[1] = false; - cc_features->num_inputs = 0; - - for (int i = 0; i < 2; i++) { - for (int j = 0; j < 4; j++) { - if (cc_features->c[i][j] >= SHADER_INPUT_1 && cc_features->c[i][j] <= SHADER_INPUT_4) { - if (cc_features->c[i][j] > cc_features->num_inputs) { - cc_features->num_inputs = cc_features->c[i][j]; - } - } - if (cc_features->c[i][j] == SHADER_TEXEL0 || cc_features->c[i][j] == SHADER_TEXEL0A) { - cc_features->used_textures[0] = true; - } - if (cc_features->c[i][j] == SHADER_TEXEL1) { - cc_features->used_textures[1] = true; - } - } - } - - cc_features->do_single[0] = cc_features->c[0][2] == 0; - cc_features->do_single[1] = cc_features->c[1][2] == 0; - cc_features->do_multiply[0] = cc_features->c[0][1] == 0 && cc_features->c[0][3] == 0; - cc_features->do_multiply[1] = cc_features->c[1][1] == 0 && cc_features->c[1][3] == 0; - cc_features->do_mix[0] = cc_features->c[0][1] == cc_features->c[0][3]; - cc_features->do_mix[1] = cc_features->c[1][1] == cc_features->c[1][3]; - cc_features->color_alpha_same = (shader_id & 0xfff) == ((shader_id >> 12) & 0xfff); -} diff --git a/src/decomp/pc/gfx/gfx_cc.h b/src/decomp/pc/gfx/gfx_cc.h deleted file mode 100644 index 2840b83..0000000 --- a/src/decomp/pc/gfx/gfx_cc.h +++ /dev/null @@ -1,58 +0,0 @@ -#ifndef GFX_CC_H -#define GFX_CC_H - -#include -#include - -enum { - CC_0, - CC_TEXEL0, - CC_TEXEL1, - CC_PRIM, - CC_SHADE, - CC_ENV, - CC_TEXEL0A, - CC_LOD -}; - -enum { - SHADER_0, - SHADER_INPUT_1, - SHADER_INPUT_2, - SHADER_INPUT_3, - SHADER_INPUT_4, - SHADER_TEXEL0, - SHADER_TEXEL0A, - SHADER_TEXEL1 -}; - -#define SHADER_OPT_ALPHA (1 << 24) -#define SHADER_OPT_FOG (1 << 25) -#define SHADER_OPT_TEXTURE_EDGE (1 << 26) -#define SHADER_OPT_NOISE (1 << 27) - -struct CCFeatures { - uint8_t c[2][4]; - bool opt_alpha; - bool opt_fog; - bool opt_texture_edge; - bool opt_noise; - bool used_textures[2]; - int num_inputs; - bool do_single[2]; - bool do_multiply[2]; - bool do_mix[2]; - bool color_alpha_same; -}; - -#ifdef __cplusplus -extern "C" { -#endif - -void gfx_cc_get_features(uint32_t shader_id, struct CCFeatures *cc_features); - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/src/decomp/pc/gfx/gfx_direct3d11.cpp b/src/decomp/pc/gfx/gfx_direct3d11.cpp deleted file mode 100644 index e5ee445..0000000 --- a/src/decomp/pc/gfx/gfx_direct3d11.cpp +++ /dev/null @@ -1,731 +0,0 @@ -#ifdef ENABLE_DX11 - -#include -#include -#include - -#include -#include -#include - -#include -#include -#include - -#ifndef _LANGUAGE_C -#define _LANGUAGE_C -#endif -#include - -#include "gfx_cc.h" -#include "gfx_window_manager_api.h" -#include "gfx_rendering_api.h" -#include "gfx_direct3d_common.h" - -#define DECLARE_GFX_DXGI_FUNCTIONS -#include "gfx_dxgi.h" - -#include "gfx_screen_config.h" - -#define THREE_POINT_FILTERING 0 -#define DEBUG_D3D 0 - -using namespace Microsoft::WRL; // For ComPtr - -namespace { - -struct PerFrameCB { - uint32_t noise_frame; - float noise_scale_x; - float noise_scale_y; - uint32_t padding; -}; - -struct PerDrawCB { - struct Texture { - uint32_t width; - uint32_t height; - uint32_t linear_filtering; - uint32_t padding; - } textures[2]; -}; - -struct TextureData { - ComPtr resource_view; - ComPtr sampler_state; - uint32_t width; - uint32_t height; - bool linear_filtering; -}; - -struct ShaderProgramD3D11 { - ComPtr vertex_shader; - ComPtr pixel_shader; - ComPtr input_layout; - ComPtr blend_state; - - uint32_t shader_id; - uint8_t num_inputs; - uint8_t num_floats; - bool used_textures[2]; -}; - -static struct { - HMODULE d3d11_module; - PFN_D3D11_CREATE_DEVICE D3D11CreateDevice; - - HMODULE d3dcompiler_module; - pD3DCompile D3DCompile; - - D3D_FEATURE_LEVEL feature_level; - - ComPtr device; - ComPtr swap_chain; - ComPtr context; - ComPtr backbuffer_view; - ComPtr depth_stencil_view; - ComPtr rasterizer_state; - ComPtr depth_stencil_state; - ComPtr vertex_buffer; - ComPtr per_frame_cb; - ComPtr per_draw_cb; - -#if DEBUG_D3D - ComPtr debug; -#endif - - DXGI_SAMPLE_DESC sample_description; - - PerFrameCB per_frame_cb_data; - PerDrawCB per_draw_cb_data; - - struct ShaderProgramD3D11 shader_program_pool[64]; - uint8_t shader_program_pool_size; - - std::vector textures; - int current_tile; - uint32_t current_texture_ids[2]; - - // Current state - - struct ShaderProgramD3D11 *shader_program; - - uint32_t current_width, current_height; - - int8_t depth_test; - int8_t depth_mask; - int8_t zmode_decal; - - // Previous states (to prevent setting states needlessly) - - struct ShaderProgramD3D11 *last_shader_program = nullptr; - uint32_t last_vertex_buffer_stride = 0; - ComPtr last_blend_state = nullptr; - ComPtr last_resource_views[2] = { nullptr, nullptr }; - ComPtr last_sampler_states[2] = { nullptr, nullptr }; - int8_t last_depth_test = -1; - int8_t last_depth_mask = -1; - int8_t last_zmode_decal = -1; - D3D_PRIMITIVE_TOPOLOGY last_primitive_topology = D3D_PRIMITIVE_TOPOLOGY_UNDEFINED; -} d3d; - -static LARGE_INTEGER last_time, accumulated_time, frequency; - -static void create_render_target_views(bool is_resize) { - DXGI_SWAP_CHAIN_DESC1 desc1; - - if (is_resize) { - // Release previous stuff (if any) - - d3d.backbuffer_view.Reset(); - d3d.depth_stencil_view.Reset(); - - // Resize swap chain buffers - - ThrowIfFailed(d3d.swap_chain->GetDesc1(&desc1)); - ThrowIfFailed(d3d.swap_chain->ResizeBuffers(0, 0, 0, DXGI_FORMAT_UNKNOWN, desc1.Flags), - gfx_dxgi_get_h_wnd(), "Failed to resize IDXGISwapChain buffers."); - } - - // Get new size - - ThrowIfFailed(d3d.swap_chain->GetDesc1(&desc1)); - - // Create back buffer - - ComPtr backbuffer_texture; - ThrowIfFailed(d3d.swap_chain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID *) backbuffer_texture.GetAddressOf()), - gfx_dxgi_get_h_wnd(), "Failed to get backbuffer from IDXGISwapChain."); - - ThrowIfFailed(d3d.device->CreateRenderTargetView(backbuffer_texture.Get(), nullptr, d3d.backbuffer_view.GetAddressOf()), - gfx_dxgi_get_h_wnd(), "Failed to create render target view."); - - // Create depth buffer - - D3D11_TEXTURE2D_DESC depth_stencil_texture_desc; - ZeroMemory(&depth_stencil_texture_desc, sizeof(D3D11_TEXTURE2D_DESC)); - - depth_stencil_texture_desc.Width = desc1.Width; - depth_stencil_texture_desc.Height = desc1.Height; - depth_stencil_texture_desc.MipLevels = 1; - depth_stencil_texture_desc.ArraySize = 1; - depth_stencil_texture_desc.Format = d3d.feature_level >= D3D_FEATURE_LEVEL_10_0 ? - DXGI_FORMAT_D32_FLOAT : DXGI_FORMAT_D24_UNORM_S8_UINT; - depth_stencil_texture_desc.SampleDesc = d3d.sample_description; - depth_stencil_texture_desc.Usage = D3D11_USAGE_DEFAULT; - depth_stencil_texture_desc.BindFlags = D3D11_BIND_DEPTH_STENCIL; - depth_stencil_texture_desc.CPUAccessFlags = 0; - depth_stencil_texture_desc.MiscFlags = 0; - - ComPtr depth_stencil_texture; - ThrowIfFailed(d3d.device->CreateTexture2D(&depth_stencil_texture_desc, nullptr, depth_stencil_texture.GetAddressOf())); - ThrowIfFailed(d3d.device->CreateDepthStencilView(depth_stencil_texture.Get(), nullptr, d3d.depth_stencil_view.GetAddressOf())); - - // Save resolution - - d3d.current_width = desc1.Width; - d3d.current_height = desc1.Height; -} - -static void gfx_d3d11_init(void) { - // Load d3d11.dll - d3d.d3d11_module = LoadLibraryW(L"d3d11.dll"); - if (d3d.d3d11_module == nullptr) { - ThrowIfFailed(HRESULT_FROM_WIN32(GetLastError()), gfx_dxgi_get_h_wnd(), "d3d11.dll could not be loaded"); - } - d3d.D3D11CreateDevice = (PFN_D3D11_CREATE_DEVICE)GetProcAddress(d3d.d3d11_module, "D3D11CreateDevice"); - - // Load D3DCompiler_47.dll or D3DCompiler_43.dll - d3d.d3dcompiler_module = LoadLibraryW(L"D3DCompiler_47.dll"); - if (d3d.d3dcompiler_module == nullptr) { - d3d.d3dcompiler_module = LoadLibraryW(L"D3DCompiler_43.dll"); - if (d3d.d3dcompiler_module == nullptr) { - ThrowIfFailed(HRESULT_FROM_WIN32(GetLastError()), gfx_dxgi_get_h_wnd(), "D3DCompiler_47.dll or D3DCompiler_43.dll could not be loaded"); - } - } - d3d.D3DCompile = (pD3DCompile)GetProcAddress(d3d.d3dcompiler_module, "D3DCompile"); - - // Create D3D11 device - - gfx_dxgi_create_factory_and_device(DEBUG_D3D, 11, [](IDXGIAdapter1 *adapter, bool test_only) { -#if DEBUG_D3D - UINT device_creation_flags = D3D11_CREATE_DEVICE_DEBUG; -#else - UINT device_creation_flags = 0; -#endif - D3D_FEATURE_LEVEL FeatureLevels[] = { - D3D_FEATURE_LEVEL_11_0, - D3D_FEATURE_LEVEL_10_1, - D3D_FEATURE_LEVEL_10_0, - D3D_FEATURE_LEVEL_9_3, - D3D_FEATURE_LEVEL_9_2, - D3D_FEATURE_LEVEL_9_1 - }; - - HRESULT res = d3d.D3D11CreateDevice( - adapter, - D3D_DRIVER_TYPE_UNKNOWN, // since we use a specific adapter - nullptr, - device_creation_flags, - FeatureLevels, - ARRAYSIZE(FeatureLevels), - D3D11_SDK_VERSION, - test_only ? nullptr : d3d.device.GetAddressOf(), - &d3d.feature_level, - test_only ? nullptr : d3d.context.GetAddressOf()); - - if (test_only) { - return SUCCEEDED(res); - } else { - ThrowIfFailed(res, gfx_dxgi_get_h_wnd(), "Failed to create D3D11 device."); - return true; - } - }); - - // Sample description to be used in back buffer and depth buffer - - d3d.sample_description.Count = 1; - d3d.sample_description.Quality = 0; - - // Create the swap chain - d3d.swap_chain = gfx_dxgi_create_swap_chain(d3d.device.Get()); - - // Create D3D Debug device if in debug mode - -#if DEBUG_D3D - ThrowIfFailed(d3d.device->QueryInterface(__uuidof(ID3D11Debug), (void **) d3d.debug.GetAddressOf()), - gfx_dxgi_get_h_wnd(), "Failed to get ID3D11Debug device."); -#endif - - // Create views - - create_render_target_views(false); - - // Create main vertex buffer - - D3D11_BUFFER_DESC vertex_buffer_desc; - ZeroMemory(&vertex_buffer_desc, sizeof(D3D11_BUFFER_DESC)); - - vertex_buffer_desc.Usage = D3D11_USAGE_DYNAMIC; - vertex_buffer_desc.ByteWidth = 256 * 26 * 3 * sizeof(float); // Same as buf_vbo size in gfx_pc - vertex_buffer_desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; - vertex_buffer_desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; - vertex_buffer_desc.MiscFlags = 0; - - ThrowIfFailed(d3d.device->CreateBuffer(&vertex_buffer_desc, nullptr, d3d.vertex_buffer.GetAddressOf()), - gfx_dxgi_get_h_wnd(), "Failed to create vertex buffer."); - - // Create per-frame constant buffer - - D3D11_BUFFER_DESC constant_buffer_desc; - ZeroMemory(&constant_buffer_desc, sizeof(D3D11_BUFFER_DESC)); - - constant_buffer_desc.Usage = D3D11_USAGE_DYNAMIC; - constant_buffer_desc.ByteWidth = sizeof(PerFrameCB); - constant_buffer_desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; - constant_buffer_desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; - constant_buffer_desc.MiscFlags = 0; - - ThrowIfFailed(d3d.device->CreateBuffer(&constant_buffer_desc, nullptr, d3d.per_frame_cb.GetAddressOf()), - gfx_dxgi_get_h_wnd(), "Failed to create per-frame constant buffer."); - - d3d.context->PSSetConstantBuffers(0, 1, d3d.per_frame_cb.GetAddressOf()); - - // Create per-draw constant buffer - - constant_buffer_desc.Usage = D3D11_USAGE_DYNAMIC; - constant_buffer_desc.ByteWidth = sizeof(PerDrawCB); - constant_buffer_desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; - constant_buffer_desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; - constant_buffer_desc.MiscFlags = 0; - - ThrowIfFailed(d3d.device->CreateBuffer(&constant_buffer_desc, nullptr, d3d.per_draw_cb.GetAddressOf()), - gfx_dxgi_get_h_wnd(), "Failed to create per-draw constant buffer."); - - d3d.context->PSSetConstantBuffers(1, 1, d3d.per_draw_cb.GetAddressOf()); -} - - -static bool gfx_d3d11_z_is_from_0_to_1(void) { - return true; -} - -static void gfx_d3d11_unload_shader(struct ShaderProgram *old_prg) { -} - -static void gfx_d3d11_load_shader(struct ShaderProgram *new_prg) { - d3d.shader_program = (struct ShaderProgramD3D11 *)new_prg; -} - -static struct ShaderProgram *gfx_d3d11_create_and_load_new_shader(uint32_t shader_id) { - CCFeatures cc_features; - gfx_cc_get_features(shader_id, &cc_features); - - char buf[4096]; - size_t len, num_floats; - - gfx_direct3d_common_build_shader(buf, len, num_floats, cc_features, false, THREE_POINT_FILTERING); - - ComPtr vs, ps; - ComPtr error_blob; - -#if DEBUG_D3D - UINT compile_flags = D3DCOMPILE_DEBUG; -#else - UINT compile_flags = D3DCOMPILE_OPTIMIZATION_LEVEL2; -#endif - - HRESULT hr = d3d.D3DCompile(buf, len, nullptr, nullptr, nullptr, "VSMain", "vs_4_0_level_9_1", compile_flags, 0, vs.GetAddressOf(), error_blob.GetAddressOf()); - - if (FAILED(hr)) { - MessageBox(gfx_dxgi_get_h_wnd(), (char *) error_blob->GetBufferPointer(), "Error", MB_OK | MB_ICONERROR); - throw hr; - } - - hr = d3d.D3DCompile(buf, len, nullptr, nullptr, nullptr, "PSMain", "ps_4_0_level_9_1", compile_flags, 0, ps.GetAddressOf(), error_blob.GetAddressOf()); - - if (FAILED(hr)) { - MessageBox(gfx_dxgi_get_h_wnd(), (char *) error_blob->GetBufferPointer(), "Error", MB_OK | MB_ICONERROR); - throw hr; - } - - struct ShaderProgramD3D11 *prg = &d3d.shader_program_pool[d3d.shader_program_pool_size++]; - - ThrowIfFailed(d3d.device->CreateVertexShader(vs->GetBufferPointer(), vs->GetBufferSize(), nullptr, prg->vertex_shader.GetAddressOf())); - ThrowIfFailed(d3d.device->CreatePixelShader(ps->GetBufferPointer(), ps->GetBufferSize(), nullptr, prg->pixel_shader.GetAddressOf())); - - // Input Layout - - D3D11_INPUT_ELEMENT_DESC ied[7]; - uint8_t ied_index = 0; - ied[ied_index++] = { "POSITION", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }; - if (cc_features.used_textures[0] || cc_features.used_textures[1]) { - ied[ied_index++] = { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }; - } - if (cc_features.opt_fog) { - ied[ied_index++] = { "FOG", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }; - } - for (unsigned int i = 0; i < cc_features.num_inputs; i++) { - DXGI_FORMAT format = cc_features.opt_alpha ? DXGI_FORMAT_R32G32B32A32_FLOAT : DXGI_FORMAT_R32G32B32_FLOAT; - ied[ied_index++] = { "INPUT", i, format, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }; - } - - ThrowIfFailed(d3d.device->CreateInputLayout(ied, ied_index, vs->GetBufferPointer(), vs->GetBufferSize(), prg->input_layout.GetAddressOf())); - - // Blend state - - D3D11_BLEND_DESC blend_desc; - ZeroMemory(&blend_desc, sizeof(D3D11_BLEND_DESC)); - - if (cc_features.opt_alpha) { - blend_desc.RenderTarget[0].BlendEnable = true; - blend_desc.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA; - blend_desc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA; - blend_desc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD; - blend_desc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE; - blend_desc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO; - blend_desc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD; - blend_desc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL; - } else { - blend_desc.RenderTarget[0].BlendEnable = false; - blend_desc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL; - } - - ThrowIfFailed(d3d.device->CreateBlendState(&blend_desc, prg->blend_state.GetAddressOf())); - - // Save some values - - prg->shader_id = shader_id; - prg->num_inputs = cc_features.num_inputs; - prg->num_floats = num_floats; - prg->used_textures[0] = cc_features.used_textures[0]; - prg->used_textures[1] = cc_features.used_textures[1]; - - return (struct ShaderProgram *)(d3d.shader_program = prg); -} - -static struct ShaderProgram *gfx_d3d11_lookup_shader(uint32_t shader_id) { - for (size_t i = 0; i < d3d.shader_program_pool_size; i++) { - if (d3d.shader_program_pool[i].shader_id == shader_id) { - return (struct ShaderProgram *)&d3d.shader_program_pool[i]; - } - } - return nullptr; -} - -static void gfx_d3d11_shader_get_info(struct ShaderProgram *prg, uint8_t *num_inputs, bool used_textures[2]) { - struct ShaderProgramD3D11 *p = (struct ShaderProgramD3D11 *)prg; - - *num_inputs = p->num_inputs; - used_textures[0] = p->used_textures[0]; - used_textures[1] = p->used_textures[1]; -} - -static uint32_t gfx_d3d11_new_texture(void) { - d3d.textures.resize(d3d.textures.size() + 1); - return (uint32_t)(d3d.textures.size() - 1); -} - -static void gfx_d3d11_select_texture(int tile, uint32_t texture_id) { - d3d.current_tile = tile; - d3d.current_texture_ids[tile] = texture_id; -} - -static D3D11_TEXTURE_ADDRESS_MODE gfx_cm_to_d3d11(uint32_t val) { - if (val & G_TX_CLAMP) { - return D3D11_TEXTURE_ADDRESS_CLAMP; - } - return (val & G_TX_MIRROR) ? D3D11_TEXTURE_ADDRESS_MIRROR : D3D11_TEXTURE_ADDRESS_WRAP; -} - -static void gfx_d3d11_upload_texture(const uint8_t *rgba32_buf, int width, int height) { - // Create texture - - D3D11_TEXTURE2D_DESC texture_desc; - ZeroMemory(&texture_desc, sizeof(D3D11_TEXTURE2D_DESC)); - - texture_desc.Width = width; - texture_desc.Height = height; - texture_desc.Usage = D3D11_USAGE_IMMUTABLE; - texture_desc.BindFlags = D3D11_BIND_SHADER_RESOURCE; - texture_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; - texture_desc.CPUAccessFlags = 0; - texture_desc.MiscFlags = 0; // D3D11_RESOURCE_MISC_GENERATE_MIPS ? - texture_desc.ArraySize = 1; - texture_desc.MipLevels = 1; - texture_desc.SampleDesc.Count = 1; - texture_desc.SampleDesc.Quality = 0; - - D3D11_SUBRESOURCE_DATA resource_data; - resource_data.pSysMem = rgba32_buf; - resource_data.SysMemPitch = width * 4; - resource_data.SysMemSlicePitch = resource_data.SysMemPitch * height; - - ComPtr texture; - ThrowIfFailed(d3d.device->CreateTexture2D(&texture_desc, &resource_data, texture.GetAddressOf())); - - // Create shader resource view from texture - - D3D11_SHADER_RESOURCE_VIEW_DESC resource_view_desc; - ZeroMemory(&resource_view_desc, sizeof(D3D11_SHADER_RESOURCE_VIEW_DESC)); - - resource_view_desc.Format = texture_desc.Format; - resource_view_desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; - resource_view_desc.Texture2D.MostDetailedMip = 0; - resource_view_desc.Texture2D.MipLevels = -1; - - TextureData *texture_data = &d3d.textures[d3d.current_texture_ids[d3d.current_tile]]; - texture_data->width = width; - texture_data->height = height; - - if (texture_data->resource_view.Get() != nullptr) { - // Free the previous texture in this slot - texture_data->resource_view.Reset(); - } - - ThrowIfFailed(d3d.device->CreateShaderResourceView(texture.Get(), &resource_view_desc, texture_data->resource_view.GetAddressOf())); -} - -static void gfx_d3d11_set_sampler_parameters(int tile, bool linear_filter, uint32_t cms, uint32_t cmt) { - D3D11_SAMPLER_DESC sampler_desc; - ZeroMemory(&sampler_desc, sizeof(D3D11_SAMPLER_DESC)); - -#if THREE_POINT_FILTERING - sampler_desc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT; -#else - sampler_desc.Filter = linear_filter ? D3D11_FILTER_MIN_MAG_MIP_LINEAR : D3D11_FILTER_MIN_MAG_MIP_POINT; -#endif - sampler_desc.AddressU = gfx_cm_to_d3d11(cms); - sampler_desc.AddressV = gfx_cm_to_d3d11(cmt); - sampler_desc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP; - sampler_desc.MinLOD = 0; - sampler_desc.MaxLOD = D3D11_FLOAT32_MAX; - - TextureData *texture_data = &d3d.textures[d3d.current_texture_ids[tile]]; - texture_data->linear_filtering = linear_filter; - - // This function is called twice per texture, the first one only to set default values. - // Maybe that could be skipped? Anyway, make sure to release the first default sampler - // state before setting the actual one. - texture_data->sampler_state.Reset(); - - ThrowIfFailed(d3d.device->CreateSamplerState(&sampler_desc, texture_data->sampler_state.GetAddressOf())); -} - -static void gfx_d3d11_set_depth_test(bool depth_test) { - d3d.depth_test = depth_test; -} - -static void gfx_d3d11_set_depth_mask(bool depth_mask) { - d3d.depth_mask = depth_mask; -} - -static void gfx_d3d11_set_zmode_decal(bool zmode_decal) { - d3d.zmode_decal = zmode_decal; -} - -static void gfx_d3d11_set_viewport(int x, int y, int width, int height) { - D3D11_VIEWPORT viewport; - viewport.TopLeftX = x; - viewport.TopLeftY = d3d.current_height - y - height; - viewport.Width = width; - viewport.Height = height; - viewport.MinDepth = 0.0f; - viewport.MaxDepth = 1.0f; - - d3d.context->RSSetViewports(1, &viewport); -} - -static void gfx_d3d11_set_scissor(int x, int y, int width, int height) { - D3D11_RECT rect; - rect.left = x; - rect.top = d3d.current_height - y - height; - rect.right = x + width; - rect.bottom = d3d.current_height - y; - - d3d.context->RSSetScissorRects(1, &rect); -} - -static void gfx_d3d11_set_use_alpha(bool use_alpha) { - // Already part of the pipeline state from shader info -} - -static void gfx_d3d11_draw_triangles(float buf_vbo[], size_t buf_vbo_len, size_t buf_vbo_num_tris) { - - if (d3d.last_depth_test != d3d.depth_test || d3d.last_depth_mask != d3d.depth_mask) { - d3d.last_depth_test = d3d.depth_test; - d3d.last_depth_mask = d3d.depth_mask; - - d3d.depth_stencil_state.Reset(); - - D3D11_DEPTH_STENCIL_DESC depth_stencil_desc; - ZeroMemory(&depth_stencil_desc, sizeof(D3D11_DEPTH_STENCIL_DESC)); - - depth_stencil_desc.DepthEnable = d3d.depth_test; - depth_stencil_desc.DepthWriteMask = d3d.depth_mask ? D3D11_DEPTH_WRITE_MASK_ALL : D3D11_DEPTH_WRITE_MASK_ZERO; - depth_stencil_desc.DepthFunc = D3D11_COMPARISON_LESS_EQUAL; - depth_stencil_desc.StencilEnable = false; - - ThrowIfFailed(d3d.device->CreateDepthStencilState(&depth_stencil_desc, d3d.depth_stencil_state.GetAddressOf())); - d3d.context->OMSetDepthStencilState(d3d.depth_stencil_state.Get(), 0); - } - - if (d3d.last_zmode_decal != d3d.zmode_decal) { - d3d.last_zmode_decal = d3d.zmode_decal; - - d3d.rasterizer_state.Reset(); - - D3D11_RASTERIZER_DESC rasterizer_desc; - ZeroMemory(&rasterizer_desc, sizeof(D3D11_RASTERIZER_DESC)); - - rasterizer_desc.FillMode = D3D11_FILL_SOLID; - rasterizer_desc.CullMode = D3D11_CULL_NONE; - rasterizer_desc.FrontCounterClockwise = true; - rasterizer_desc.DepthBias = 0; - rasterizer_desc.SlopeScaledDepthBias = d3d.zmode_decal ? -2.0f : 0.0f; - rasterizer_desc.DepthBiasClamp = 0.0f; - rasterizer_desc.DepthClipEnable = true; - rasterizer_desc.ScissorEnable = true; - rasterizer_desc.MultisampleEnable = false; - rasterizer_desc.AntialiasedLineEnable = false; - - ThrowIfFailed(d3d.device->CreateRasterizerState(&rasterizer_desc, d3d.rasterizer_state.GetAddressOf())); - d3d.context->RSSetState(d3d.rasterizer_state.Get()); - } - - bool textures_changed = false; - - for (int i = 0; i < 2; i++) { - if (d3d.shader_program->used_textures[i]) { - if (d3d.last_resource_views[i].Get() != d3d.textures[d3d.current_texture_ids[i]].resource_view.Get()) { - d3d.last_resource_views[i] = d3d.textures[d3d.current_texture_ids[i]].resource_view.Get(); - d3d.context->PSSetShaderResources(i, 1, d3d.textures[d3d.current_texture_ids[i]].resource_view.GetAddressOf()); - -#if THREE_POINT_FILTERING - d3d.per_draw_cb_data.textures[i].width = d3d.textures[d3d.current_texture_ids[i]].width; - d3d.per_draw_cb_data.textures[i].height = d3d.textures[d3d.current_texture_ids[i]].height; - d3d.per_draw_cb_data.textures[i].linear_filtering = d3d.textures[d3d.current_texture_ids[i]].linear_filtering; - textures_changed = true; -#endif - - if (d3d.last_sampler_states[i].Get() != d3d.textures[d3d.current_texture_ids[i]].sampler_state.Get()) { - d3d.last_sampler_states[i] = d3d.textures[d3d.current_texture_ids[i]].sampler_state.Get(); - d3d.context->PSSetSamplers(i, 1, d3d.textures[d3d.current_texture_ids[i]].sampler_state.GetAddressOf()); - } - } - } - } - - // Set per-draw constant buffer - - if (textures_changed) { - D3D11_MAPPED_SUBRESOURCE ms; - ZeroMemory(&ms, sizeof(D3D11_MAPPED_SUBRESOURCE)); - d3d.context->Map(d3d.per_draw_cb.Get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &ms); - memcpy(ms.pData, &d3d.per_draw_cb_data, sizeof(PerDrawCB)); - d3d.context->Unmap(d3d.per_draw_cb.Get(), 0); - } - - // Set vertex buffer data - - D3D11_MAPPED_SUBRESOURCE ms; - ZeroMemory(&ms, sizeof(D3D11_MAPPED_SUBRESOURCE)); - d3d.context->Map(d3d.vertex_buffer.Get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &ms); - memcpy(ms.pData, buf_vbo, buf_vbo_len * sizeof(float)); - d3d.context->Unmap(d3d.vertex_buffer.Get(), 0); - - uint32_t stride = d3d.shader_program->num_floats * sizeof(float); - uint32_t offset = 0; - - if (d3d.last_vertex_buffer_stride != stride) { - d3d.last_vertex_buffer_stride = stride; - d3d.context->IASetVertexBuffers(0, 1, d3d.vertex_buffer.GetAddressOf(), &stride, &offset); - } - - if (d3d.last_shader_program != d3d.shader_program) { - d3d.last_shader_program = d3d.shader_program; - d3d.context->IASetInputLayout(d3d.shader_program->input_layout.Get()); - d3d.context->VSSetShader(d3d.shader_program->vertex_shader.Get(), 0, 0); - d3d.context->PSSetShader(d3d.shader_program->pixel_shader.Get(), 0, 0); - - if (d3d.last_blend_state.Get() != d3d.shader_program->blend_state.Get()) { - d3d.last_blend_state = d3d.shader_program->blend_state.Get(); - d3d.context->OMSetBlendState(d3d.shader_program->blend_state.Get(), 0, 0xFFFFFFFF); - } - } - - if (d3d.last_primitive_topology != D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST) { - d3d.last_primitive_topology = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST; - d3d.context->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST); - } - - d3d.context->Draw(buf_vbo_num_tris * 3, 0); -} - -static void gfx_d3d11_on_resize(void) { - create_render_target_views(true); -} - -static void gfx_d3d11_start_frame(void) { - // Set render targets - - d3d.context->OMSetRenderTargets(1, d3d.backbuffer_view.GetAddressOf(), d3d.depth_stencil_view.Get()); - - // Clear render targets - - const float clearColor[] = { 0.0f, 0.0f, 0.0f, 1.0f }; - d3d.context->ClearRenderTargetView(d3d.backbuffer_view.Get(), clearColor); - d3d.context->ClearDepthStencilView(d3d.depth_stencil_view.Get(), D3D11_CLEAR_DEPTH, 1.0f, 0); - - // Set per-frame constant buffer - - d3d.per_frame_cb_data.noise_frame++; - if (d3d.per_frame_cb_data.noise_frame > 150) { - // No high values, as noise starts to look ugly - d3d.per_frame_cb_data.noise_frame = 0; - } - float aspect_ratio = (float) d3d.current_width / (float) d3d.current_height; - d3d.per_frame_cb_data.noise_scale_x = 120 * aspect_ratio; // 120 = N64 height resolution (240) / 2 - d3d.per_frame_cb_data.noise_scale_y = 120; - - D3D11_MAPPED_SUBRESOURCE ms; - ZeroMemory(&ms, sizeof(D3D11_MAPPED_SUBRESOURCE)); - d3d.context->Map(d3d.per_frame_cb.Get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &ms); - memcpy(ms.pData, &d3d.per_frame_cb_data, sizeof(PerFrameCB)); - d3d.context->Unmap(d3d.per_frame_cb.Get(), 0); -} - -static void gfx_d3d11_end_frame(void) { -} - -static void gfx_d3d11_finish_render(void) { -} - -} // namespace - -struct GfxRenderingAPI gfx_direct3d11_api = { - gfx_d3d11_z_is_from_0_to_1, - gfx_d3d11_unload_shader, - gfx_d3d11_load_shader, - gfx_d3d11_create_and_load_new_shader, - gfx_d3d11_lookup_shader, - gfx_d3d11_shader_get_info, - gfx_d3d11_new_texture, - gfx_d3d11_select_texture, - gfx_d3d11_upload_texture, - gfx_d3d11_set_sampler_parameters, - gfx_d3d11_set_depth_test, - gfx_d3d11_set_depth_mask, - gfx_d3d11_set_zmode_decal, - gfx_d3d11_set_viewport, - gfx_d3d11_set_scissor, - gfx_d3d11_set_use_alpha, - gfx_d3d11_draw_triangles, - gfx_d3d11_init, - gfx_d3d11_on_resize, - gfx_d3d11_start_frame, - gfx_d3d11_end_frame, - gfx_d3d11_finish_render -}; - -#endif diff --git a/src/decomp/pc/gfx/gfx_direct3d11.h b/src/decomp/pc/gfx/gfx_direct3d11.h deleted file mode 100644 index 67f6406..0000000 --- a/src/decomp/pc/gfx/gfx_direct3d11.h +++ /dev/null @@ -1,12 +0,0 @@ -#ifdef ENABLE_DX11 - -#ifndef GFX_DIRECT3D11_H -#define GFX_DIRECT3D11_H - -#include "gfx_rendering_api.h" - -extern struct GfxRenderingAPI gfx_direct3d11_api; - -#endif - -#endif diff --git a/src/decomp/pc/gfx/gfx_direct3d12.cpp b/src/decomp/pc/gfx/gfx_direct3d12.cpp deleted file mode 100644 index 91eb47b..0000000 --- a/src/decomp/pc/gfx/gfx_direct3d12.cpp +++ /dev/null @@ -1,966 +0,0 @@ -#ifdef ENABLE_DX12 - -#include -#include -#include -#include - -#include -#include -#include - -#include -#include - -// This is needed when compiling with MinGW, used in d3d12.h -#define __in_ecount_opt(size) - -#include -#include -#include "dxsdk/d3d12.h" -#include - -#include "gfx_direct3d12_guids.h" - -#include "dxsdk/d3dx12.h" - -#ifndef _LANGUAGE_C -#define _LANGUAGE_C -#endif -#include - -#define DECLARE_GFX_DXGI_FUNCTIONS -#include "gfx_dxgi.h" - -#include "gfx_cc.h" -#include "gfx_window_manager_api.h" -#include "gfx_rendering_api.h" -#include "gfx_direct3d_common.h" - -#include "gfx_screen_config.h" - -#define DEBUG_D3D 0 - -using namespace Microsoft::WRL; // For ComPtr - -namespace { - -struct ShaderProgramD3D12 { - uint32_t shader_id; - uint8_t num_inputs; - bool used_textures[2]; - uint8_t num_floats; - uint8_t num_attribs; - - ComPtr vertex_shader; - ComPtr pixel_shader; - ComPtr root_signature; -}; - -struct PipelineDesc { - uint32_t shader_id; - bool depth_test; - bool depth_mask; - bool zmode_decal; - bool _padding; - - bool operator==(const PipelineDesc& o) const { - return memcmp(this, &o, sizeof(*this)) == 0; - } - - bool operator<(const PipelineDesc& o) const { - return memcmp(this, &o, sizeof(*this)) < 0; - } -}; - -struct TextureHeap { - ComPtr heap; - std::vector free_list; -}; - -struct TextureData { - ComPtr resource; - struct TextureHeap *heap; - uint8_t heap_offset; - - uint64_t last_frame_counter; - uint32_t descriptor_index; - int sampler_parameters; -}; - -struct NoiseCB { - uint32_t noise_frame; - float noise_scale_x; - float noise_scale_y; - uint32_t padding; -}; - -static struct { - HMODULE d3d12_module; - PFN_D3D12_CREATE_DEVICE D3D12CreateDevice; - PFN_D3D12_GET_DEBUG_INTERFACE D3D12GetDebugInterface; - - HMODULE d3dcompiler_module; - pD3DCompile D3DCompile; - - struct ShaderProgramD3D12 shader_program_pool[64]; - uint8_t shader_program_pool_size; - - uint32_t current_width, current_height; - - ComPtr device; - ComPtr command_queue; - ComPtr copy_command_queue; - ComPtr swap_chain; - ComPtr rtv_heap; - UINT rtv_descriptor_size; - ComPtr render_targets[2]; - ComPtr command_allocator; - ComPtr copy_command_allocator; - ComPtr command_list; - ComPtr copy_command_list; - ComPtr dsv_heap; - ComPtr depth_stencil_buffer; - ComPtr srv_heap; - UINT srv_descriptor_size; - ComPtr sampler_heap; - UINT sampler_descriptor_size; - - std::map, std::list> texture_heaps; - - std::map>> upload_heaps; - std::vector>> upload_heaps_in_flight; - ComPtr copy_fence; - uint64_t copy_fence_value; - - std::vector textures; - int current_tile; - uint32_t current_texture_ids[2]; - uint32_t srv_pos; - - int frame_index; - ComPtr fence; - HANDLE fence_event; - - uint64_t frame_counter; - - ComPtr noise_cb; - void *mapped_noise_cb_address; - struct NoiseCB noise_cb_data; - - ComPtr vertex_buffer; - void *mapped_vbuf_address; - int vbuf_pos; - - std::vector> resources_to_clean_at_end_of_frame; - std::vector> texture_heap_allocations_to_reclaim_at_end_of_frame; - - std::map> pipeline_states; - bool must_reload_pipeline; - - // Current state: - ID3D12PipelineState *pipeline_state; - struct ShaderProgramD3D12 *shader_program; - bool depth_test; - bool depth_mask; - bool zmode_decal; - - CD3DX12_VIEWPORT viewport; - CD3DX12_RECT scissor; -} d3d; - -static int texture_uploads = 0; -static int max_texture_uploads; - -static D3D12_CPU_DESCRIPTOR_HANDLE get_cpu_descriptor_handle(ComPtr& heap) { -#ifdef __MINGW32__ - // We would like to do this: - // D3D12_CPU_DESCRIPTOR_HANDLE handle = heap->GetCPUDescriptorHandleForHeapStart(); - // but MinGW64 doesn't follow the calling conventions of VC++ for some reason. - // Per MS documentation "User-defined types can be returned by value from global functions and static member functions"... - // "Otherwise, the caller assumes the responsibility of allocating memory and passing a pointer for the return value as the first argument". - // The method here is a non-static member function, and hence we need to pass the address to the return value as a parameter. - // MinGW32 has the same issue. - auto fn = heap->GetCPUDescriptorHandleForHeapStart; - void (STDMETHODCALLTYPE ID3D12DescriptorHeap::*fun)(D3D12_CPU_DESCRIPTOR_HANDLE *out) = (void (STDMETHODCALLTYPE ID3D12DescriptorHeap::*)(D3D12_CPU_DESCRIPTOR_HANDLE *out))fn; - D3D12_CPU_DESCRIPTOR_HANDLE handle; - (heap.Get()->*fun)(&handle); - return handle; -#else - return heap->GetCPUDescriptorHandleForHeapStart(); -#endif -} - -static D3D12_GPU_DESCRIPTOR_HANDLE get_gpu_descriptor_handle(ComPtr& heap) { -#ifdef __MINGW32__ - // See get_cpu_descriptor_handle - auto fn = heap->GetGPUDescriptorHandleForHeapStart; - void (STDMETHODCALLTYPE ID3D12DescriptorHeap::*fun)(D3D12_GPU_DESCRIPTOR_HANDLE *out) = (void (STDMETHODCALLTYPE ID3D12DescriptorHeap::*)(D3D12_GPU_DESCRIPTOR_HANDLE *out))fn; - D3D12_GPU_DESCRIPTOR_HANDLE handle; - (heap.Get()->*fun)(&handle); - return handle; -#else - return heap->GetGPUDescriptorHandleForHeapStart(); -#endif -} - -static D3D12_RESOURCE_ALLOCATION_INFO get_resource_allocation_info(const D3D12_RESOURCE_DESC *resource_desc) { -#ifdef __MINGW32__ - // See get_cpu_descriptor_handle - auto fn = d3d.device->GetResourceAllocationInfo; - void (STDMETHODCALLTYPE ID3D12Device::*fun)(D3D12_RESOURCE_ALLOCATION_INFO *out, UINT visibleMask, UINT numResourceDescs, const D3D12_RESOURCE_DESC *pResourceDescs) = - (void (STDMETHODCALLTYPE ID3D12Device::*)(D3D12_RESOURCE_ALLOCATION_INFO *out, UINT visibleMask, UINT numResourceDescs, const D3D12_RESOURCE_DESC *pResourceDescs))fn; - D3D12_RESOURCE_ALLOCATION_INFO out; - (d3d.device.Get()->*fun)(&out, 0, 1, resource_desc); - return out; -#else - return d3d.device->GetResourceAllocationInfo(0, 1, resource_desc); -#endif -} - -static bool gfx_direct3d12_z_is_from_0_to_1(void) { - return true; -} - -static void gfx_direct3d12_unload_shader(struct ShaderProgram *old_prg) { -} - -static void gfx_direct3d12_load_shader(struct ShaderProgram *new_prg) { - d3d.shader_program = (struct ShaderProgramD3D12 *)new_prg; - d3d.must_reload_pipeline = true; -} - -static struct ShaderProgram *gfx_direct3d12_create_and_load_new_shader(uint32_t shader_id) { - /*static FILE *fp; - if (!fp) { - fp = fopen("shaders.txt", "w"); - } - fprintf(fp, "0x%08x\n", shader_id); - fflush(fp);*/ - - struct ShaderProgramD3D12 *prg = &d3d.shader_program_pool[d3d.shader_program_pool_size++]; - - CCFeatures cc_features; - gfx_cc_get_features(shader_id, &cc_features); - - char buf[2048]; - size_t len, num_floats; - - gfx_direct3d_common_build_shader(buf, len, num_floats, cc_features, true, false); - - //fwrite(buf, 1, len, stdout); - - ThrowIfFailed(d3d.D3DCompile(buf, len, nullptr, nullptr, nullptr, "VSMain", "vs_5_1", D3DCOMPILE_OPTIMIZATION_LEVEL3, 0, &prg->vertex_shader, nullptr)); - ThrowIfFailed(d3d.D3DCompile(buf, len, nullptr, nullptr, nullptr, "PSMain", "ps_5_1", D3DCOMPILE_OPTIMIZATION_LEVEL3, 0, &prg->pixel_shader, nullptr)); - - ThrowIfFailed(d3d.device->CreateRootSignature(0, prg->pixel_shader->GetBufferPointer(), prg->pixel_shader->GetBufferSize(), IID_PPV_ARGS(&prg->root_signature))); - - prg->shader_id = shader_id; - prg->num_inputs = cc_features.num_inputs; - prg->used_textures[0] = cc_features.used_textures[0]; - prg->used_textures[1] = cc_features.used_textures[1]; - prg->num_floats = num_floats; - //prg->num_attribs = cnt; - - d3d.must_reload_pipeline = true; - return (struct ShaderProgram *)(d3d.shader_program = prg); -} - -static struct ShaderProgram *gfx_direct3d12_lookup_shader(uint32_t shader_id) { - for (size_t i = 0; i < d3d.shader_program_pool_size; i++) { - if (d3d.shader_program_pool[i].shader_id == shader_id) { - return (struct ShaderProgram *)&d3d.shader_program_pool[i]; - } - } - return nullptr; -} - -static void gfx_direct3d12_shader_get_info(struct ShaderProgram *prg, uint8_t *num_inputs, bool used_textures[2]) { - struct ShaderProgramD3D12 *p = (struct ShaderProgramD3D12 *)prg; - - *num_inputs = p->num_inputs; - used_textures[0] = p->used_textures[0]; - used_textures[1] = p->used_textures[1]; -} - -static uint32_t gfx_direct3d12_new_texture(void) { - d3d.textures.resize(d3d.textures.size() + 1); - return (uint32_t)(d3d.textures.size() - 1); -} - -static void gfx_direct3d12_select_texture(int tile, uint32_t texture_id) { - d3d.current_tile = tile; - d3d.current_texture_ids[tile] = texture_id; -} - -static void gfx_direct3d12_upload_texture(const uint8_t *rgba32_buf, int width, int height) { - texture_uploads++; - - ComPtr texture_resource; - - // Describe and create a Texture2D. - D3D12_RESOURCE_DESC texture_desc = {}; - texture_desc.MipLevels = 1; - texture_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; - texture_desc.Width = width; - texture_desc.Height = height; - texture_desc.Flags = D3D12_RESOURCE_FLAG_NONE; - texture_desc.DepthOrArraySize = 1; - texture_desc.SampleDesc.Count = 1; - texture_desc.SampleDesc.Quality = 0; - texture_desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D; - texture_desc.Alignment = ((width + 31) / 32) * ((height + 31) / 32) > 16 ? 0 : D3D12_SMALL_RESOURCE_PLACEMENT_ALIGNMENT; - - D3D12_RESOURCE_ALLOCATION_INFO alloc_info = get_resource_allocation_info(&texture_desc); - - std::list& heaps = d3d.texture_heaps[std::pair(alloc_info.SizeInBytes, alloc_info.Alignment)]; - - struct TextureHeap *found_heap = nullptr; - for (struct TextureHeap& heap : heaps) { - if (!heap.free_list.empty()) { - found_heap = &heap; - } - } - if (found_heap == nullptr) { - heaps.resize(heaps.size() + 1); - found_heap = &heaps.back(); - - // In case of HD textures, make sure too much memory isn't wasted - int textures_per_heap = 524288 / alloc_info.SizeInBytes; - if (textures_per_heap < 1) { - textures_per_heap = 1; - } else if (textures_per_heap > 64) { - textures_per_heap = 64; - } - - D3D12_HEAP_DESC heap_desc = {}; - heap_desc.SizeInBytes = alloc_info.SizeInBytes * textures_per_heap; - if (alloc_info.Alignment == D3D12_SMALL_RESOURCE_PLACEMENT_ALIGNMENT) { - heap_desc.Alignment = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT; - } else { - heap_desc.Alignment = alloc_info.Alignment; - } - heap_desc.Properties.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN; - heap_desc.Properties.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN; - heap_desc.Properties.Type = D3D12_HEAP_TYPE_DEFAULT; - heap_desc.Flags = D3D12_HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES; - ThrowIfFailed(d3d.device->CreateHeap(&heap_desc, IID_PPV_ARGS(&found_heap->heap))); - for (int i = 0; i < textures_per_heap; i++) { - found_heap->free_list.push_back(i); - } - } - - uint8_t heap_offset = found_heap->free_list.back(); - found_heap->free_list.pop_back(); - ThrowIfFailed(d3d.device->CreatePlacedResource(found_heap->heap.Get(), heap_offset * alloc_info.SizeInBytes, &texture_desc, D3D12_RESOURCE_STATE_COPY_DEST, nullptr, IID_PPV_ARGS(&texture_resource))); - - D3D12_PLACED_SUBRESOURCE_FOOTPRINT layout; - UINT num_rows; - UINT64 row_size_in_bytes; - UINT64 upload_buffer_size; - d3d.device->GetCopyableFootprints(&texture_desc, 0, 1, 0, &layout, &num_rows, &row_size_in_bytes, &upload_buffer_size); - - std::vector>& upload_heaps = d3d.upload_heaps[upload_buffer_size]; - ComPtr upload_heap; - if (upload_heaps.empty()) { - CD3DX12_HEAP_PROPERTIES hp(D3D12_HEAP_TYPE_UPLOAD); - CD3DX12_RESOURCE_DESC rdb = CD3DX12_RESOURCE_DESC::Buffer(upload_buffer_size); - ThrowIfFailed(d3d.device->CreateCommittedResource( - &hp, - D3D12_HEAP_FLAG_NONE, - &rdb, - D3D12_RESOURCE_STATE_GENERIC_READ, - nullptr, - IID_PPV_ARGS(&upload_heap))); - } else { - upload_heap = upload_heaps.back(); - upload_heaps.pop_back(); - } - - { - D3D12_SUBRESOURCE_DATA texture_data = {}; - texture_data.pData = rgba32_buf; - texture_data.RowPitch = width * 4; // RGBA - texture_data.SlicePitch = texture_data.RowPitch * height; - - void *data; - upload_heap->Map(0, nullptr, &data); - D3D12_MEMCPY_DEST dest_data = { (uint8_t *)data + layout.Offset, layout.Footprint.RowPitch, SIZE_T(layout.Footprint.RowPitch) * SIZE_T(num_rows) }; - MemcpySubresource(&dest_data, &texture_data, static_cast(row_size_in_bytes), num_rows, layout.Footprint.Depth); - upload_heap->Unmap(0, nullptr); - - CD3DX12_TEXTURE_COPY_LOCATION dst(texture_resource.Get(), 0); - CD3DX12_TEXTURE_COPY_LOCATION src(upload_heap.Get(), layout); - d3d.copy_command_list->CopyTextureRegion(&dst, 0, 0, 0, &src, nullptr); - } - - CD3DX12_RESOURCE_BARRIER barrier = CD3DX12_RESOURCE_BARRIER::Transition(texture_resource.Get(), D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE); - d3d.command_list->ResourceBarrier(1, &barrier); - - d3d.upload_heaps_in_flight.push_back(std::make_pair((size_t)upload_buffer_size, std::move(upload_heap))); - - struct TextureData& td = d3d.textures[d3d.current_texture_ids[d3d.current_tile]]; - if (td.resource.Get() != nullptr) { - d3d.resources_to_clean_at_end_of_frame.push_back(std::move(td.resource)); - d3d.texture_heap_allocations_to_reclaim_at_end_of_frame.push_back(std::make_pair(td.heap, td.heap_offset)); - td.last_frame_counter = 0; - } - td.resource = std::move(texture_resource); - td.heap = found_heap; - td.heap_offset = heap_offset; -} - -static int gfx_cm_to_index(uint32_t val) { - if (val & G_TX_CLAMP) { - return 2; - } - return (val & G_TX_MIRROR) ? 1 : 0; -} - -static void gfx_direct3d12_set_sampler_parameters(int tile, bool linear_filter, uint32_t cms, uint32_t cmt) { - d3d.textures[d3d.current_texture_ids[tile]].sampler_parameters = linear_filter * 9 + gfx_cm_to_index(cms) * 3 + gfx_cm_to_index(cmt); -} - -static void gfx_direct3d12_set_depth_test(bool depth_test) { - d3d.depth_test = depth_test; - d3d.must_reload_pipeline = true; -} - -static void gfx_direct3d12_set_depth_mask(bool z_upd) { - d3d.depth_mask = z_upd; - d3d.must_reload_pipeline = true; -} - -static void gfx_direct3d12_set_zmode_decal(bool zmode_decal) { - d3d.zmode_decal = zmode_decal; - d3d.must_reload_pipeline = true; -} - -static void gfx_direct3d12_set_viewport(int x, int y, int width, int height) { - d3d.viewport = CD3DX12_VIEWPORT(x, d3d.current_height - y - height, width, height); -} - -static void gfx_direct3d12_set_scissor(int x, int y, int width, int height) { - d3d.scissor = CD3DX12_RECT(x, d3d.current_height - y - height, x + width, d3d.current_height - y); -} - -static void gfx_direct3d12_set_use_alpha(bool use_alpha) { - // Already part of the pipeline state from shader info -} - -static void gfx_direct3d12_draw_triangles(float buf_vbo[], size_t buf_vbo_len, size_t buf_vbo_num_tris) { - struct ShaderProgramD3D12 *prg = d3d.shader_program; - - if (d3d.must_reload_pipeline) { - ComPtr& pipeline_state = d3d.pipeline_states[PipelineDesc{ - prg->shader_id, - d3d.depth_test, - d3d.depth_mask, - d3d.zmode_decal, - 0 - }]; - if (pipeline_state.Get() == nullptr) { - D3D12_INPUT_ELEMENT_DESC ied[7] = { - {"POSITION", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 } - }; - uint32_t ied_pos = 1; - if (prg->used_textures[0] || prg->used_textures[1]) { - ied[ied_pos++] = D3D12_INPUT_ELEMENT_DESC{"TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0}; - } - if (prg->shader_id & SHADER_OPT_FOG) { - ied[ied_pos++] = D3D12_INPUT_ELEMENT_DESC{"FOG", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0}; - } - for (int i = 0; i < prg->num_inputs; i++) { - DXGI_FORMAT format = (prg->shader_id & SHADER_OPT_ALPHA) ? DXGI_FORMAT_R32G32B32A32_FLOAT : DXGI_FORMAT_R32G32B32_FLOAT; - ied[ied_pos++] = D3D12_INPUT_ELEMENT_DESC{"INPUT", (UINT)i, format, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0}; - } - - D3D12_GRAPHICS_PIPELINE_STATE_DESC desc = {}; - desc.InputLayout = { ied, ied_pos }; - desc.pRootSignature = prg->root_signature.Get(); - desc.VS = CD3DX12_SHADER_BYTECODE(prg->vertex_shader.Get()); - desc.PS = CD3DX12_SHADER_BYTECODE(prg->pixel_shader.Get()); - desc.RasterizerState = CD3DX12_RASTERIZER_DESC(D3D12_DEFAULT); - if (d3d.zmode_decal) { - desc.RasterizerState.SlopeScaledDepthBias = -2.0f; - } - desc.RasterizerState.CullMode = D3D12_CULL_MODE_NONE; - if (prg->shader_id & SHADER_OPT_ALPHA) { - D3D12_BLEND_DESC bd = {}; - bd.AlphaToCoverageEnable = FALSE; - bd.IndependentBlendEnable = FALSE; - static const D3D12_RENDER_TARGET_BLEND_DESC default_rtbd = { - TRUE, FALSE, - D3D12_BLEND_SRC_ALPHA, D3D12_BLEND_INV_SRC_ALPHA, D3D12_BLEND_OP_ADD, - D3D12_BLEND_ONE, D3D12_BLEND_INV_SRC_ALPHA, D3D12_BLEND_OP_ADD, - D3D12_LOGIC_OP_NOOP, - D3D12_COLOR_WRITE_ENABLE_ALL - }; - for (UINT i = 0; i < D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT; i++) { - bd.RenderTarget[i] = default_rtbd; - } - desc.BlendState = bd; - } else { - desc.BlendState = CD3DX12_BLEND_DESC(D3D12_DEFAULT); - } - desc.DepthStencilState.DepthEnable = d3d.depth_test; - desc.DepthStencilState.DepthWriteMask = d3d.depth_mask ? D3D12_DEPTH_WRITE_MASK_ALL : D3D12_DEPTH_WRITE_MASK_ZERO; - desc.DepthStencilState.DepthFunc = D3D12_COMPARISON_FUNC_LESS_EQUAL; - desc.DSVFormat = d3d.depth_test ? DXGI_FORMAT_D32_FLOAT : DXGI_FORMAT_UNKNOWN; - desc.SampleMask = UINT_MAX; - desc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE; - desc.NumRenderTargets = 1; - desc.RTVFormats[0] = DXGI_FORMAT_R8G8B8A8_UNORM; - desc.SampleDesc.Count = 1; - ThrowIfFailed(d3d.device->CreateGraphicsPipelineState(&desc, IID_PPV_ARGS(&pipeline_state))); - } - d3d.pipeline_state = pipeline_state.Get(); - d3d.must_reload_pipeline = false; - } - - d3d.command_list->SetGraphicsRootSignature(prg->root_signature.Get()); - d3d.command_list->SetPipelineState(d3d.pipeline_state); - - ID3D12DescriptorHeap *heaps[] = { d3d.srv_heap.Get(), d3d.sampler_heap.Get() }; - d3d.command_list->SetDescriptorHeaps(2, heaps); - - int root_param_index = 0; - - if ((prg->shader_id & (SHADER_OPT_ALPHA | SHADER_OPT_NOISE)) == (SHADER_OPT_ALPHA | SHADER_OPT_NOISE)) { - d3d.command_list->SetGraphicsRootConstantBufferView(root_param_index++, d3d.noise_cb->GetGPUVirtualAddress()); - } - - for (int i = 0; i < 2; i++) { - if (prg->used_textures[i]) { - struct TextureData& td = d3d.textures[d3d.current_texture_ids[i]]; - if (td.last_frame_counter != d3d.frame_counter) { - td.descriptor_index = d3d.srv_pos; - td.last_frame_counter = d3d.frame_counter; - - D3D12_SHADER_RESOURCE_VIEW_DESC srv_desc = {}; - srv_desc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING; - srv_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; - srv_desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D; - srv_desc.Texture2D.MipLevels = 1; - - CD3DX12_CPU_DESCRIPTOR_HANDLE srv_handle(get_cpu_descriptor_handle(d3d.srv_heap), d3d.srv_pos++, d3d.srv_descriptor_size); - d3d.device->CreateShaderResourceView(td.resource.Get(), &srv_desc, srv_handle); - } - - CD3DX12_GPU_DESCRIPTOR_HANDLE srv_gpu_handle(get_gpu_descriptor_handle(d3d.srv_heap), td.descriptor_index, d3d.srv_descriptor_size); - d3d.command_list->SetGraphicsRootDescriptorTable(root_param_index++, srv_gpu_handle); - - CD3DX12_GPU_DESCRIPTOR_HANDLE sampler_gpu_handle(get_gpu_descriptor_handle(d3d.sampler_heap), td.sampler_parameters, d3d.sampler_descriptor_size); - d3d.command_list->SetGraphicsRootDescriptorTable(root_param_index++, sampler_gpu_handle); - } - } - - CD3DX12_CPU_DESCRIPTOR_HANDLE rtv_handle(get_cpu_descriptor_handle(d3d.rtv_heap), d3d.frame_index, d3d.rtv_descriptor_size); - D3D12_CPU_DESCRIPTOR_HANDLE dsv_handle = get_cpu_descriptor_handle(d3d.dsv_heap); - d3d.command_list->OMSetRenderTargets(1, &rtv_handle, FALSE, &dsv_handle); - - d3d.command_list->RSSetViewports(1, &d3d.viewport); - d3d.command_list->RSSetScissorRects(1, &d3d.scissor); - - int current_pos = d3d.vbuf_pos; - memcpy((uint8_t *)d3d.mapped_vbuf_address + current_pos, buf_vbo, buf_vbo_len * sizeof(float)); - d3d.vbuf_pos += buf_vbo_len * sizeof(float); - static int maxpos; - if (d3d.vbuf_pos > maxpos) { - maxpos = d3d.vbuf_pos; - //printf("NEW MAXPOS: %d\n", maxpos); - } - - D3D12_VERTEX_BUFFER_VIEW vertex_buffer_view; - vertex_buffer_view.BufferLocation = d3d.vertex_buffer->GetGPUVirtualAddress() + current_pos; - vertex_buffer_view.StrideInBytes = buf_vbo_len / (3 * buf_vbo_num_tris) * sizeof(float); - vertex_buffer_view.SizeInBytes = buf_vbo_len * sizeof(float); - - d3d.command_list->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST); - d3d.command_list->IASetVertexBuffers(0, 1, &vertex_buffer_view); - d3d.command_list->DrawInstanced(3 * buf_vbo_num_tris, 1, 0, 0); -} - -static void gfx_direct3d12_start_frame(void) { - ++d3d.frame_counter; - d3d.srv_pos = 0; - texture_uploads = 0; - ThrowIfFailed(d3d.command_allocator->Reset()); - ThrowIfFailed(d3d.command_list->Reset(d3d.command_allocator.Get(), nullptr)); - - CD3DX12_RESOURCE_BARRIER barrier = CD3DX12_RESOURCE_BARRIER::Transition( - d3d.render_targets[d3d.frame_index].Get(), - D3D12_RESOURCE_STATE_PRESENT, - D3D12_RESOURCE_STATE_RENDER_TARGET); - d3d.command_list->ResourceBarrier(1, &barrier); - - CD3DX12_CPU_DESCRIPTOR_HANDLE rtv_handle(get_cpu_descriptor_handle(d3d.rtv_heap), d3d.frame_index, d3d.rtv_descriptor_size); - D3D12_CPU_DESCRIPTOR_HANDLE dsv_handle = get_cpu_descriptor_handle(d3d.dsv_heap); - d3d.command_list->OMSetRenderTargets(1, &rtv_handle, FALSE, &dsv_handle); - - static unsigned char c; - const float clear_color[] = { 0.0f, 0.0f, 0.0f, 1.0f }; - d3d.command_list->ClearRenderTargetView(rtv_handle, clear_color, 0, nullptr); - d3d.command_list->ClearDepthStencilView(dsv_handle, D3D12_CLEAR_FLAG_DEPTH, 1.0f, 0, 0, nullptr); - - d3d.noise_cb_data.noise_frame++; - if (d3d.noise_cb_data.noise_frame > 150) { - // No high values, as noise starts to look ugly - d3d.noise_cb_data.noise_frame = 0; - } - float aspect_ratio = (float) d3d.current_width / (float) d3d.current_height; - d3d.noise_cb_data.noise_scale_x = 120 * aspect_ratio; // 120 = N64 height resolution (240) / 2 - d3d.noise_cb_data.noise_scale_y = 120; - memcpy(d3d.mapped_noise_cb_address, &d3d.noise_cb_data, sizeof(struct NoiseCB)); - - d3d.vbuf_pos = 0; -} - -static void create_render_target_views(void) { - D3D12_CPU_DESCRIPTOR_HANDLE rtv_handle = get_cpu_descriptor_handle(d3d.rtv_heap); - for (UINT i = 0; i < 2; i++) { - ThrowIfFailed(d3d.swap_chain->GetBuffer(i, IID_ID3D12Resource, (void **)&d3d.render_targets[i])); - d3d.device->CreateRenderTargetView(d3d.render_targets[i].Get(), nullptr, rtv_handle); - rtv_handle.ptr += d3d.rtv_descriptor_size; - } -} - -static void create_depth_buffer(void) { - DXGI_SWAP_CHAIN_DESC1 desc1; - ThrowIfFailed(d3d.swap_chain->GetDesc1(&desc1)); - UINT width = desc1.Width; - UINT height = desc1.Height; - - d3d.current_width = width; - d3d.current_height = height; - - D3D12_DEPTH_STENCIL_VIEW_DESC dsv_desc = {}; - dsv_desc.Format = DXGI_FORMAT_D32_FLOAT; - dsv_desc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE2D; - dsv_desc.Flags = D3D12_DSV_FLAG_NONE; - - D3D12_CLEAR_VALUE depth_optimized_cv = {}; - depth_optimized_cv.Format = DXGI_FORMAT_D32_FLOAT; - depth_optimized_cv.DepthStencil.Depth = 1.0f; - - D3D12_HEAP_PROPERTIES hp = {}; - hp.Type = D3D12_HEAP_TYPE_DEFAULT; - hp.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN; - hp.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN; - hp.CreationNodeMask = 1; - hp.VisibleNodeMask = 1; - - D3D12_RESOURCE_DESC rd = {}; - rd.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D; - rd.Alignment = 0; - rd.Width = width; - rd.Height = height; - rd.DepthOrArraySize = 1; - rd.MipLevels = 0; - rd.Format = DXGI_FORMAT_D32_FLOAT; - rd.SampleDesc.Count = 1; - rd.SampleDesc.Quality = 0; - rd.Flags = D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL; - rd.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN; - ThrowIfFailed(d3d.device->CreateCommittedResource(&hp, D3D12_HEAP_FLAG_NONE, &rd, D3D12_RESOURCE_STATE_DEPTH_WRITE, &depth_optimized_cv, IID_PPV_ARGS(&d3d.depth_stencil_buffer))); - - d3d.device->CreateDepthStencilView(d3d.depth_stencil_buffer.Get(), &dsv_desc, get_cpu_descriptor_handle(d3d.dsv_heap)); -} - -static void gfx_direct3d12_on_resize(void) { - if (d3d.render_targets[0].Get() != nullptr) { - d3d.render_targets[0].Reset(); - d3d.render_targets[1].Reset(); - ThrowIfFailed(d3d.swap_chain->ResizeBuffers(0, 0, 0, DXGI_FORMAT_UNKNOWN, DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT)); - d3d.frame_index = d3d.swap_chain->GetCurrentBackBufferIndex(); - create_render_target_views(); - create_depth_buffer(); - } -} - -static void gfx_direct3d12_init(void ) { - // Load d3d12.dll - d3d.d3d12_module = LoadLibraryW(L"d3d12.dll"); - if (d3d.d3d12_module == nullptr) { - ThrowIfFailed(HRESULT_FROM_WIN32(GetLastError()), gfx_dxgi_get_h_wnd(), "d3d12.dll could not be loaded"); - } - d3d.D3D12CreateDevice = (PFN_D3D12_CREATE_DEVICE)GetProcAddress(d3d.d3d12_module, "D3D12CreateDevice"); -#if DEBUG_D3D - d3d.D3D12GetDebugInterface = (PFN_D3D12_GET_DEBUG_INTERFACE)GetProcAddress(d3d.d3d12_module, "D3D12GetDebugInterface"); -#endif - - // Load D3DCompiler_47.dll - d3d.d3dcompiler_module = LoadLibraryW(L"D3DCompiler_47.dll"); - if (d3d.d3dcompiler_module == nullptr) { - ThrowIfFailed(HRESULT_FROM_WIN32(GetLastError()), gfx_dxgi_get_h_wnd(), "D3DCompiler_47.dll could not be loaded"); - } - d3d.D3DCompile = (pD3DCompile)GetProcAddress(d3d.d3dcompiler_module, "D3DCompile"); - - // Create device - { - UINT debug_flags = 0; -#if DEBUG_D3D - ComPtr debug_controller; - if (SUCCEEDED(d3d.D3D12GetDebugInterface(IID_PPV_ARGS(&debug_controller)))) { - debug_controller->EnableDebugLayer(); - debug_flags |= DXGI_CREATE_FACTORY_DEBUG; - } -#endif - - gfx_dxgi_create_factory_and_device(DEBUG_D3D, 12, [](IDXGIAdapter1 *adapter, bool test_only) { - HRESULT res = d3d.D3D12CreateDevice( - adapter, - D3D_FEATURE_LEVEL_11_0, - IID_ID3D12Device, - test_only ? nullptr : IID_PPV_ARGS_Helper(&d3d.device)); - - if (test_only) { - return SUCCEEDED(res); - } else { - ThrowIfFailed(res, gfx_dxgi_get_h_wnd(), "Failed to create D3D12 device."); - return true; - } - }); - } - - // Create command queues - { - D3D12_COMMAND_QUEUE_DESC queue_desc = {}; - queue_desc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE; - queue_desc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT; - ThrowIfFailed(d3d.device->CreateCommandQueue(&queue_desc, IID_PPV_ARGS(&d3d.command_queue))); - } - { - D3D12_COMMAND_QUEUE_DESC queue_desc = {}; - queue_desc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE; - queue_desc.Type = D3D12_COMMAND_LIST_TYPE_COPY; - ThrowIfFailed(d3d.device->CreateCommandQueue(&queue_desc, IID_PPV_ARGS(&d3d.copy_command_queue))); - } - - // Create swap chain - { - ComPtr swap_chain1 = gfx_dxgi_create_swap_chain(d3d.command_queue.Get()); - ThrowIfFailed(swap_chain1->QueryInterface(__uuidof(IDXGISwapChain3), &d3d.swap_chain)); - d3d.frame_index = d3d.swap_chain->GetCurrentBackBufferIndex(); - } - - // Create render target views - { - D3D12_DESCRIPTOR_HEAP_DESC rtv_heap_desc = {}; - rtv_heap_desc.NumDescriptors = 2; - rtv_heap_desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV; - rtv_heap_desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE; - ThrowIfFailed(d3d.device->CreateDescriptorHeap(&rtv_heap_desc, IID_PPV_ARGS(&d3d.rtv_heap))); - d3d.rtv_descriptor_size = d3d.device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV); - - create_render_target_views(); - } - - // Create Z-buffer - { - D3D12_DESCRIPTOR_HEAP_DESC dsv_heap_desc = {}; - dsv_heap_desc.NumDescriptors = 1; - dsv_heap_desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_DSV; - dsv_heap_desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE; - ThrowIfFailed(d3d.device->CreateDescriptorHeap(&dsv_heap_desc, IID_PPV_ARGS(&d3d.dsv_heap))); - - create_depth_buffer(); - } - - // Create SRV heap for texture descriptors - { - D3D12_DESCRIPTOR_HEAP_DESC srv_heap_desc = {}; - srv_heap_desc.NumDescriptors = 1024; // Max unique textures per frame - srv_heap_desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV; - srv_heap_desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE; - ThrowIfFailed(d3d.device->CreateDescriptorHeap(&srv_heap_desc, IID_PPV_ARGS(&d3d.srv_heap))); - d3d.srv_descriptor_size = d3d.device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); - } - - // Create sampler heap and descriptors - { - D3D12_DESCRIPTOR_HEAP_DESC sampler_heap_desc = {}; - sampler_heap_desc.NumDescriptors = 18; - sampler_heap_desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER; - sampler_heap_desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE; - ThrowIfFailed(d3d.device->CreateDescriptorHeap(&sampler_heap_desc, IID_PPV_ARGS(&d3d.sampler_heap))); - d3d.sampler_descriptor_size = d3d.device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER); - - static const D3D12_TEXTURE_ADDRESS_MODE address_modes[] = { - D3D12_TEXTURE_ADDRESS_MODE_WRAP, - D3D12_TEXTURE_ADDRESS_MODE_MIRROR, - D3D12_TEXTURE_ADDRESS_MODE_CLAMP - }; - - D3D12_CPU_DESCRIPTOR_HANDLE sampler_handle = get_cpu_descriptor_handle(d3d.sampler_heap); - int pos = 0; - for (int linear_filter = 0; linear_filter < 2; linear_filter++) { - for (int cms = 0; cms < 3; cms++) { - for (int cmt = 0; cmt < 3; cmt++) { - D3D12_SAMPLER_DESC sampler_desc = {}; - sampler_desc.Filter = linear_filter ? D3D12_FILTER_MIN_MAG_MIP_LINEAR : D3D12_FILTER_MIN_MAG_MIP_POINT; - sampler_desc.AddressU = address_modes[cms]; - sampler_desc.AddressV = address_modes[cmt]; - sampler_desc.AddressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP; - sampler_desc.MinLOD = 0; - sampler_desc.MaxLOD = D3D12_FLOAT32_MAX; - sampler_desc.MipLODBias = 0.0f; - sampler_desc.MaxAnisotropy = 1; - sampler_desc.ComparisonFunc = D3D12_COMPARISON_FUNC_NEVER; - d3d.device->CreateSampler(&sampler_desc, CD3DX12_CPU_DESCRIPTOR_HANDLE(sampler_handle, pos++, d3d.sampler_descriptor_size)); - } - } - } - } - - // Create constant buffer view for noise - { - /*D3D12_DESCRIPTOR_HEAP_DESC cbv_heap_desc = {}; - cbv_heap_desc.NumDescriptors = 1; - cbv_heap_desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV; - srv_heap_desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE; - ThrowIfFailed(d3d.device->CreateDescriptorHeap*/ - - CD3DX12_HEAP_PROPERTIES hp(D3D12_HEAP_TYPE_UPLOAD); - CD3DX12_RESOURCE_DESC rdb = CD3DX12_RESOURCE_DESC::Buffer(256); - ThrowIfFailed(d3d.device->CreateCommittedResource( - &hp, - D3D12_HEAP_FLAG_NONE, - &rdb, - D3D12_RESOURCE_STATE_GENERIC_READ, - nullptr, - IID_PPV_ARGS(&d3d.noise_cb))); - - CD3DX12_RANGE read_range(0, 0); // Read not possible from CPU - ThrowIfFailed(d3d.noise_cb->Map(0, &read_range, &d3d.mapped_noise_cb_address)); - } - - ThrowIfFailed(d3d.device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&d3d.command_allocator))); - ThrowIfFailed(d3d.device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_COPY, IID_PPV_ARGS(&d3d.copy_command_allocator))); - - ThrowIfFailed(d3d.device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, d3d.command_allocator.Get(), nullptr, IID_PPV_ARGS(&d3d.command_list))); - ThrowIfFailed(d3d.device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_COPY, d3d.copy_command_allocator.Get(), nullptr, IID_PPV_ARGS(&d3d.copy_command_list))); - - ThrowIfFailed(d3d.command_list->Close()); - - ThrowIfFailed(d3d.device->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&d3d.fence))); - d3d.fence_event = CreateEvent(nullptr, FALSE, FALSE, nullptr); - if (d3d.fence_event == nullptr) { - ThrowIfFailed(HRESULT_FROM_WIN32(GetLastError())); - } - - ThrowIfFailed(d3d.device->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&d3d.copy_fence))); - - { - // Create a buffer of 1 MB in size. With a 120 star speed run 192 kB seems to be max usage. - CD3DX12_HEAP_PROPERTIES hp(D3D12_HEAP_TYPE_UPLOAD); - CD3DX12_RESOURCE_DESC rdb = CD3DX12_RESOURCE_DESC::Buffer(256 * 1024 * sizeof(float)); - ThrowIfFailed(d3d.device->CreateCommittedResource( - &hp, - D3D12_HEAP_FLAG_NONE, - &rdb, - D3D12_RESOURCE_STATE_GENERIC_READ, - nullptr, - IID_PPV_ARGS(&d3d.vertex_buffer))); - - CD3DX12_RANGE read_range(0, 0); // Read not possible from CPU - ThrowIfFailed(d3d.vertex_buffer->Map(0, &read_range, &d3d.mapped_vbuf_address)); - } -} - -static void gfx_direct3d12_end_frame(void) { - if (max_texture_uploads < texture_uploads && texture_uploads != 38 && texture_uploads != 34 && texture_uploads != 29) { - max_texture_uploads = texture_uploads; - } - //printf("Texture uploads: %d %d\n", max_texture_uploads, texture_uploads); - texture_uploads = 0; - - ThrowIfFailed(d3d.copy_command_list->Close()); - { - ID3D12CommandList *lists[] = { d3d.copy_command_list.Get() }; - d3d.copy_command_queue->ExecuteCommandLists(1, lists); - d3d.copy_command_queue->Signal(d3d.copy_fence.Get(), ++d3d.copy_fence_value); - } - - CD3DX12_RESOURCE_BARRIER barrier = CD3DX12_RESOURCE_BARRIER::Transition( - d3d.render_targets[d3d.frame_index].Get(), - D3D12_RESOURCE_STATE_RENDER_TARGET, - D3D12_RESOURCE_STATE_PRESENT); - d3d.command_list->ResourceBarrier(1, &barrier); - - d3d.command_queue->Wait(d3d.copy_fence.Get(), d3d.copy_fence_value); - - ThrowIfFailed(d3d.command_list->Close()); - - { - ID3D12CommandList *lists[] = { d3d.command_list.Get() }; - d3d.command_queue->ExecuteCommandLists(1, lists); - } - - { - LARGE_INTEGER t0; - QueryPerformanceCounter(&t0); - //printf("Present: %llu %u\n", (unsigned long long)(t0.QuadPart - d3d.qpc_init), d3d.length_in_vsync_frames); - } -} - -static void gfx_direct3d12_finish_render(void) { - LARGE_INTEGER t0, t1, t2; - QueryPerformanceCounter(&t0); - - static UINT64 fence_value; - ThrowIfFailed(d3d.command_queue->Signal(d3d.fence.Get(), ++fence_value)); - if (d3d.fence->GetCompletedValue() < fence_value) { - ThrowIfFailed(d3d.fence->SetEventOnCompletion(fence_value, d3d.fence_event)); - WaitForSingleObject(d3d.fence_event, INFINITE); - } - QueryPerformanceCounter(&t1); - - d3d.resources_to_clean_at_end_of_frame.clear(); - for (std::pair>& heap : d3d.upload_heaps_in_flight) { - d3d.upload_heaps[heap.first].push_back(std::move(heap.second)); - } - d3d.upload_heaps_in_flight.clear(); - for (std::pair& item : d3d.texture_heap_allocations_to_reclaim_at_end_of_frame) { - item.first->free_list.push_back(item.second); - } - d3d.texture_heap_allocations_to_reclaim_at_end_of_frame.clear(); - - QueryPerformanceCounter(&t2); - - d3d.frame_index = d3d.swap_chain->GetCurrentBackBufferIndex(); - - ThrowIfFailed(d3d.copy_command_allocator->Reset()); - ThrowIfFailed(d3d.copy_command_list->Reset(d3d.copy_command_allocator.Get(), nullptr)); - - //printf("done %llu gpu:%d wait:%d freed:%llu frame:%u %u monitor:%u t:%llu\n", (unsigned long long)(t0.QuadPart - d3d.qpc_init), (int)(t1.QuadPart - t0.QuadPart), (int)(t2.QuadPart - t0.QuadPart), (unsigned long long)(t2.QuadPart - d3d.qpc_init), d3d.pending_frame_stats.rbegin()->first, stats.PresentCount, stats.SyncRefreshCount, (unsigned long long)(stats.SyncQPCTime.QuadPart - d3d.qpc_init)); -} - -} // namespace - -struct GfxRenderingAPI gfx_direct3d12_api = { - gfx_direct3d12_z_is_from_0_to_1, - gfx_direct3d12_unload_shader, - gfx_direct3d12_load_shader, - gfx_direct3d12_create_and_load_new_shader, - gfx_direct3d12_lookup_shader, - gfx_direct3d12_shader_get_info, - gfx_direct3d12_new_texture, - gfx_direct3d12_select_texture, - gfx_direct3d12_upload_texture, - gfx_direct3d12_set_sampler_parameters, - gfx_direct3d12_set_depth_test, - gfx_direct3d12_set_depth_mask, - gfx_direct3d12_set_zmode_decal, - gfx_direct3d12_set_viewport, - gfx_direct3d12_set_scissor, - gfx_direct3d12_set_use_alpha, - gfx_direct3d12_draw_triangles, - gfx_direct3d12_init, - gfx_direct3d12_on_resize, - gfx_direct3d12_start_frame, - gfx_direct3d12_end_frame, - gfx_direct3d12_finish_render -}; - -#endif diff --git a/src/decomp/pc/gfx/gfx_direct3d12.h b/src/decomp/pc/gfx/gfx_direct3d12.h deleted file mode 100644 index 9a29be4..0000000 --- a/src/decomp/pc/gfx/gfx_direct3d12.h +++ /dev/null @@ -1,12 +0,0 @@ -#ifdef ENABLE_DX12 - -#ifndef GFX_DIRECT3D12_H -#define GFX_DIRECT3D12_H - -#include "gfx_rendering_api.h" - -extern struct GfxRenderingAPI gfx_direct3d12_api; - -#endif - -#endif diff --git a/src/decomp/pc/gfx/gfx_direct3d12_guids.h b/src/decomp/pc/gfx/gfx_direct3d12_guids.h deleted file mode 100644 index e18a018..0000000 --- a/src/decomp/pc/gfx/gfx_direct3d12_guids.h +++ /dev/null @@ -1,62 +0,0 @@ -#ifndef GFX_DIRECT3D12_GUIDS_H -#define GFX_DIRECT3D12_GUIDS_H - -#ifdef __MINGW32__ - -// This file is only needed due to missing MinGW-specific headers for d3d12.h. -// It will define IID_* symbols having the "selectany" attribute (assuming -// d3d12.h was earlier included), as well as make __uuidof(...) work. - -#define DEF_GUID(type,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) \ - __CRT_UUID_DECL(type,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) \ - const GUID IID_##type = __uuidof(type) - -DEF_GUID(ID3D12Object,0xc4fec28f,0x7966,0x4e95,0x9f,0x94,0xf4,0x31,0xcb,0x56,0xc3,0xb8); -DEF_GUID(ID3D12DeviceChild,0x905db94b,0xa00c,0x4140,0x9d,0xf5,0x2b,0x64,0xca,0x9e,0xa3,0x57); -DEF_GUID(ID3D12RootSignature,0xc54a6b66,0x72df,0x4ee8,0x8b,0xe5,0xa9,0x46,0xa1,0x42,0x92,0x14); -DEF_GUID(ID3D12RootSignatureDeserializer,0x34AB647B,0x3CC8,0x46AC,0x84,0x1B,0xC0,0x96,0x56,0x45,0xC0,0x46); -DEF_GUID(ID3D12VersionedRootSignatureDeserializer,0x7F91CE67,0x090C,0x4BB7,0xB7,0x8E,0xED,0x8F,0xF2,0xE3,0x1D,0xA0); -DEF_GUID(ID3D12Pageable,0x63ee58fb,0x1268,0x4835,0x86,0xda,0xf0,0x08,0xce,0x62,0xf0,0xd6); -DEF_GUID(ID3D12Heap,0x6b3b2502,0x6e51,0x45b3,0x90,0xee,0x98,0x84,0x26,0x5e,0x8d,0xf3); -DEF_GUID(ID3D12Resource,0x696442be,0xa72e,0x4059,0xbc,0x79,0x5b,0x5c,0x98,0x04,0x0f,0xad); -DEF_GUID(ID3D12CommandAllocator,0x6102dee4,0xaf59,0x4b09,0xb9,0x99,0xb4,0x4d,0x73,0xf0,0x9b,0x24); -DEF_GUID(ID3D12Fence,0x0a753dcf,0xc4d8,0x4b91,0xad,0xf6,0xbe,0x5a,0x60,0xd9,0x5a,0x76); -DEF_GUID(ID3D12Fence1,0x433685fe,0xe22b,0x4ca0,0xa8,0xdb,0xb5,0xb4,0xf4,0xdd,0x0e,0x4a); -DEF_GUID(ID3D12PipelineState,0x765a30f3,0xf624,0x4c6f,0xa8,0x28,0xac,0xe9,0x48,0x62,0x24,0x45); -DEF_GUID(ID3D12DescriptorHeap,0x8efb471d,0x616c,0x4f49,0x90,0xf7,0x12,0x7b,0xb7,0x63,0xfa,0x51); -DEF_GUID(ID3D12QueryHeap,0x0d9658ae,0xed45,0x469e,0xa6,0x1d,0x97,0x0e,0xc5,0x83,0xca,0xb4); -DEF_GUID(ID3D12CommandSignature,0xc36a797c,0xec80,0x4f0a,0x89,0x85,0xa7,0xb2,0x47,0x50,0x82,0xd1); -DEF_GUID(ID3D12CommandList,0x7116d91c,0xe7e4,0x47ce,0xb8,0xc6,0xec,0x81,0x68,0xf4,0x37,0xe5); -DEF_GUID(ID3D12GraphicsCommandList,0x5b160d0f,0xac1b,0x4185,0x8b,0xa8,0xb3,0xae,0x42,0xa5,0xa4,0x55); -DEF_GUID(ID3D12GraphicsCommandList1,0x553103fb,0x1fe7,0x4557,0xbb,0x38,0x94,0x6d,0x7d,0x0e,0x7c,0xa7); -DEF_GUID(ID3D12GraphicsCommandList2,0x38C3E585,0xFF17,0x412C,0x91,0x50,0x4F,0xC6,0xF9,0xD7,0x2A,0x28); -DEF_GUID(ID3D12CommandQueue,0x0ec870a6,0x5d7e,0x4c22,0x8c,0xfc,0x5b,0xaa,0xe0,0x76,0x16,0xed); -DEF_GUID(ID3D12Device,0x189819f1,0x1db6,0x4b57,0xbe,0x54,0x18,0x21,0x33,0x9b,0x85,0xf7); -DEF_GUID(ID3D12PipelineLibrary,0xc64226a8,0x9201,0x46af,0xb4,0xcc,0x53,0xfb,0x9f,0xf7,0x41,0x4f); -DEF_GUID(ID3D12PipelineLibrary1,0x80eabf42,0x2568,0x4e5e,0xbd,0x82,0xc3,0x7f,0x86,0x96,0x1d,0xc3); -DEF_GUID(ID3D12Device1,0x77acce80,0x638e,0x4e65,0x88,0x95,0xc1,0xf2,0x33,0x86,0x86,0x3e); -DEF_GUID(ID3D12Device2,0x30baa41e,0xb15b,0x475c,0xa0,0xbb,0x1a,0xf5,0xc5,0xb6,0x43,0x28); -DEF_GUID(ID3D12Device3,0x81dadc15,0x2bad,0x4392,0x93,0xc5,0x10,0x13,0x45,0xc4,0xaa,0x98); -DEF_GUID(ID3D12ProtectedSession,0xA1533D18,0x0AC1,0x4084,0x85,0xB9,0x89,0xA9,0x61,0x16,0x80,0x6B); -DEF_GUID(ID3D12ProtectedResourceSession,0x6CD696F4,0xF289,0x40CC,0x80,0x91,0x5A,0x6C,0x0A,0x09,0x9C,0x3D); -DEF_GUID(ID3D12Device4,0xe865df17,0xa9ee,0x46f9,0xa4,0x63,0x30,0x98,0x31,0x5a,0xa2,0xe5); -DEF_GUID(ID3D12LifetimeOwner,0xe667af9f,0xcd56,0x4f46,0x83,0xce,0x03,0x2e,0x59,0x5d,0x70,0xa8); -DEF_GUID(ID3D12SwapChainAssistant,0xf1df64b6,0x57fd,0x49cd,0x88,0x07,0xc0,0xeb,0x88,0xb4,0x5c,0x8f); -DEF_GUID(ID3D12LifetimeTracker,0x3fd03d36,0x4eb1,0x424a,0xa5,0x82,0x49,0x4e,0xcb,0x8b,0xa8,0x13); -DEF_GUID(ID3D12StateObject,0x47016943,0xfca8,0x4594,0x93,0xea,0xaf,0x25,0x8b,0x55,0x34,0x6d); -DEF_GUID(ID3D12StateObjectProperties,0xde5fa827,0x9bf9,0x4f26,0x89,0xff,0xd7,0xf5,0x6f,0xde,0x38,0x60); -DEF_GUID(ID3D12Device5,0x8b4f173b,0x2fea,0x4b80,0x8f,0x58,0x43,0x07,0x19,0x1a,0xb9,0x5d); -DEF_GUID(ID3D12DeviceRemovedExtendedDataSettings,0x82BC481C,0x6B9B,0x4030,0xAE,0xDB,0x7E,0xE3,0xD1,0xDF,0x1E,0x63); -DEF_GUID(ID3D12DeviceRemovedExtendedData,0x98931D33,0x5AE8,0x4791,0xAA,0x3C,0x1A,0x73,0xA2,0x93,0x4E,0x71); -DEF_GUID(ID3D12Device6,0xc70b221b,0x40e4,0x4a17,0x89,0xaf,0x02,0x5a,0x07,0x27,0xa6,0xdc); -DEF_GUID(ID3D12Resource1,0x9D5E227A,0x4430,0x4161,0x88,0xB3,0x3E,0xCA,0x6B,0xB1,0x6E,0x19); -DEF_GUID(ID3D12Heap1,0x572F7389,0x2168,0x49E3,0x96,0x93,0xD6,0xDF,0x58,0x71,0xBF,0x6D); -DEF_GUID(ID3D12GraphicsCommandList3,0x6FDA83A7,0xB84C,0x4E38,0x9A,0xC8,0xC7,0xBD,0x22,0x01,0x6B,0x3D); -DEF_GUID(ID3D12MetaCommand,0xDBB84C27,0x36CE,0x4FC9,0xB8,0x01,0xF0,0x48,0xC4,0x6A,0xC5,0x70); -DEF_GUID(ID3D12GraphicsCommandList4,0x8754318e,0xd3a9,0x4541,0x98,0xcf,0x64,0x5b,0x50,0xdc,0x48,0x74); -DEF_GUID(ID3D12Tools,0x7071e1f0,0xe84b,0x4b33,0x97,0x4f,0x12,0xfa,0x49,0xde,0x65,0xc5); -DEF_GUID(ID3D12GraphicsCommandList5,0x55050859,0x4024,0x474c,0x87,0xf5,0x64,0x72,0xea,0xee,0x44,0xea); - -#endif - -#endif diff --git a/src/decomp/pc/gfx/gfx_direct3d_common.cpp b/src/decomp/pc/gfx/gfx_direct3d_common.cpp deleted file mode 100644 index 32a7296..0000000 --- a/src/decomp/pc/gfx/gfx_direct3d_common.cpp +++ /dev/null @@ -1,313 +0,0 @@ -#if defined(ENABLE_DX11) || defined(ENABLE_DX12) - -#include - -#include "gfx_direct3d_common.h" -#include "gfx_cc.h" - -void get_cc_features(uint32_t shader_id, CCFeatures *cc_features) { - for (int i = 0; i < 4; i++) { - cc_features->c[0][i] = (shader_id >> (i * 3)) & 7; - cc_features->c[1][i] = (shader_id >> (12 + i * 3)) & 7; - } - - cc_features->opt_alpha = (shader_id & SHADER_OPT_ALPHA) != 0; - cc_features->opt_fog = (shader_id & SHADER_OPT_FOG) != 0; - cc_features->opt_texture_edge = (shader_id & SHADER_OPT_TEXTURE_EDGE) != 0; - cc_features->opt_noise = (shader_id & SHADER_OPT_NOISE) != 0; - - cc_features->used_textures[0] = false; - cc_features->used_textures[1] = false; - cc_features->num_inputs = 0; - - for (int i = 0; i < 2; i++) { - for (int j = 0; j < 4; j++) { - if (cc_features->c[i][j] >= SHADER_INPUT_1 && cc_features->c[i][j] <= SHADER_INPUT_4) { - if (cc_features->c[i][j] > cc_features->num_inputs) { - cc_features->num_inputs = cc_features->c[i][j]; - } - } - if (cc_features->c[i][j] == SHADER_TEXEL0 || cc_features->c[i][j] == SHADER_TEXEL0A) { - cc_features->used_textures[0] = true; - } - if (cc_features->c[i][j] == SHADER_TEXEL1) { - cc_features->used_textures[1] = true; - } - } - } - - cc_features->do_single[0] = cc_features->c[0][2] == 0; - cc_features->do_single[1] = cc_features->c[1][2] == 0; - cc_features->do_multiply[0] = cc_features->c[0][1] == 0 && cc_features->c[0][3] == 0; - cc_features->do_multiply[1] = cc_features->c[1][1] == 0 && cc_features->c[1][3] == 0; - cc_features->do_mix[0] = cc_features->c[0][1] == cc_features->c[0][3]; - cc_features->do_mix[1] = cc_features->c[1][1] == cc_features->c[1][3]; - cc_features->color_alpha_same = (shader_id & 0xfff) == ((shader_id >> 12) & 0xfff); -} - -static void append_str(char *buf, size_t *len, const char *str) { - while (*str != '\0') buf[(*len)++] = *str++; -} - -static void append_line(char *buf, size_t *len, const char *str) { - while (*str != '\0') buf[(*len)++] = *str++; - buf[(*len)++] = '\r'; - buf[(*len)++] = '\n'; -} - -static const char *shader_item_to_str(uint32_t item, bool with_alpha, bool only_alpha, bool inputs_have_alpha, bool hint_single_element) { - if (!only_alpha) { - switch (item) { - default: - case SHADER_0: - return with_alpha ? "float4(0.0, 0.0, 0.0, 0.0)" : "float3(0.0, 0.0, 0.0)"; - case SHADER_INPUT_1: - return with_alpha || !inputs_have_alpha ? "input.input1" : "input.input1.rgb"; - case SHADER_INPUT_2: - return with_alpha || !inputs_have_alpha ? "input.input2" : "input.input2.rgb"; - case SHADER_INPUT_3: - return with_alpha || !inputs_have_alpha ? "input.input3" : "input.input3.rgb"; - case SHADER_INPUT_4: - return with_alpha || !inputs_have_alpha ? "input.input4" : "input.input4.rgb"; - case SHADER_TEXEL0: - return with_alpha ? "texVal0" : "texVal0.rgb"; - case SHADER_TEXEL0A: - return hint_single_element ? "texVal0.a" : (with_alpha ? "float4(texVal0.a, texVal0.a, texVal0.a, texVal0.a)" : "float3(texVal0.a, texVal0.a, texVal0.a)"); - case SHADER_TEXEL1: - return with_alpha ? "texVal1" : "texVal1.rgb"; - } - } else { - switch (item) { - default: - case SHADER_0: - return "0.0"; - case SHADER_INPUT_1: - return "input.input1.a"; - case SHADER_INPUT_2: - return "input.input2.a"; - case SHADER_INPUT_3: - return "input.input3.a"; - case SHADER_INPUT_4: - return "input.input4.a"; - case SHADER_TEXEL0: - return "texVal0.a"; - case SHADER_TEXEL0A: - return "texVal0.a"; - case SHADER_TEXEL1: - return "texVal1.a"; - } - } -} - -static void append_formula(char *buf, size_t *len, const uint8_t c[2][4], bool do_single, bool do_multiply, bool do_mix, bool with_alpha, bool only_alpha, bool opt_alpha) { - if (do_single) { - append_str(buf, len, shader_item_to_str(c[only_alpha][3], with_alpha, only_alpha, opt_alpha, false)); - } else if (do_multiply) { - append_str(buf, len, shader_item_to_str(c[only_alpha][0], with_alpha, only_alpha, opt_alpha, false)); - append_str(buf, len, " * "); - append_str(buf, len, shader_item_to_str(c[only_alpha][2], with_alpha, only_alpha, opt_alpha, true)); - } else if (do_mix) { - append_str(buf, len, "lerp("); - append_str(buf, len, shader_item_to_str(c[only_alpha][1], with_alpha, only_alpha, opt_alpha, false)); - append_str(buf, len, ", "); - append_str(buf, len, shader_item_to_str(c[only_alpha][0], with_alpha, only_alpha, opt_alpha, false)); - append_str(buf, len, ", "); - append_str(buf, len, shader_item_to_str(c[only_alpha][2], with_alpha, only_alpha, opt_alpha, true)); - append_str(buf, len, ")"); - } else { - append_str(buf, len, "("); - append_str(buf, len, shader_item_to_str(c[only_alpha][0], with_alpha, only_alpha, opt_alpha, false)); - append_str(buf, len, " - "); - append_str(buf, len, shader_item_to_str(c[only_alpha][1], with_alpha, only_alpha, opt_alpha, false)); - append_str(buf, len, ") * "); - append_str(buf, len, shader_item_to_str(c[only_alpha][2], with_alpha, only_alpha, opt_alpha, true)); - append_str(buf, len, " + "); - append_str(buf, len, shader_item_to_str(c[only_alpha][3], with_alpha, only_alpha, opt_alpha, false)); - } -} - -void gfx_direct3d_common_build_shader(char buf[4096], size_t& len, size_t& num_floats, const CCFeatures& cc_features, bool include_root_signature, bool three_point_filtering) { - len = 0; - num_floats = 4; - - // Pixel shader input struct - - if (include_root_signature) { - append_str(buf, &len, "#define RS \"RootFlags(ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT | DENY_VERTEX_SHADER_ROOT_ACCESS)"); - if (cc_features.opt_alpha && cc_features.opt_noise) { - append_str(buf, &len, ",CBV(b0, visibility = SHADER_VISIBILITY_PIXEL)"); - } - if (cc_features.used_textures[0]) { - append_str(buf, &len, ",DescriptorTable(SRV(t0), visibility = SHADER_VISIBILITY_PIXEL)"); - append_str(buf, &len, ",DescriptorTable(Sampler(s0), visibility = SHADER_VISIBILITY_PIXEL)"); - } - if (cc_features.used_textures[1]) { - append_str(buf, &len, ",DescriptorTable(SRV(t1), visibility = SHADER_VISIBILITY_PIXEL)"); - append_str(buf, &len, ",DescriptorTable(Sampler(s1), visibility = SHADER_VISIBILITY_PIXEL)"); - } - append_line(buf, &len, "\""); - } - - append_line(buf, &len, "struct PSInput {"); - append_line(buf, &len, " float4 position : SV_POSITION;"); - if (cc_features.used_textures[0] || cc_features.used_textures[1]) { - append_line(buf, &len, " float2 uv : TEXCOORD;"); - num_floats += 2; - } - if (cc_features.opt_alpha && cc_features.opt_noise) { - append_line(buf, &len, " float4 screenPos : TEXCOORD1;"); - } - if (cc_features.opt_fog) { - append_line(buf, &len, " float4 fog : FOG;"); - num_floats += 4; - } - for (int i = 0; i < cc_features.num_inputs; i++) { - len += sprintf(buf + len, " float%d input%d : INPUT%d;\r\n", cc_features.opt_alpha ? 4 : 3, i + 1, i); - num_floats += cc_features.opt_alpha ? 4 : 3; - } - append_line(buf, &len, "};"); - - // Textures and samplers - - if (cc_features.used_textures[0]) { - append_line(buf, &len, "Texture2D g_texture0 : register(t0);"); - append_line(buf, &len, "SamplerState g_sampler0 : register(s0);"); - } - if (cc_features.used_textures[1]) { - append_line(buf, &len, "Texture2D g_texture1 : register(t1);"); - append_line(buf, &len, "SamplerState g_sampler1 : register(s1);"); - } - - // Constant buffer and random function - - if (cc_features.opt_alpha && cc_features.opt_noise) { - append_line(buf, &len, "cbuffer PerFrameCB : register(b0) {"); - append_line(buf, &len, " uint noise_frame;"); - append_line(buf, &len, " float2 noise_scale;"); - append_line(buf, &len, "}"); - - append_line(buf, &len, "float random(in float3 value) {"); - append_line(buf, &len, " float random = dot(value, float3(12.9898, 78.233, 37.719));"); - append_line(buf, &len, " return frac(sin(random) * 143758.5453);"); - append_line(buf, &len, "}"); - } - - // 3 point texture filtering - // Original author: ArthurCarvalho - // Based on GLSL implementation by twinaphex, mupen64plus-libretro project. - - if (three_point_filtering && (cc_features.used_textures[0] || cc_features.used_textures[1])) { - append_line(buf, &len, "cbuffer PerDrawCB : register(b1) {"); - append_line(buf, &len, " struct {"); - append_line(buf, &len, " uint width;"); - append_line(buf, &len, " uint height;"); - append_line(buf, &len, " bool linear_filtering;"); - append_line(buf, &len, " } textures[2];"); - append_line(buf, &len, "}"); - append_line(buf, &len, "#define TEX_OFFSET(tex, tSampler, texCoord, off, texSize) tex.Sample(tSampler, texCoord - off / texSize)"); - append_line(buf, &len, "float4 tex2D3PointFilter(in Texture2D tex, in SamplerState tSampler, in float2 texCoord, in float2 texSize) {"); - append_line(buf, &len, " float2 offset = frac(texCoord * texSize - float2(0.5, 0.5));"); - append_line(buf, &len, " offset -= step(1.0, offset.x + offset.y);"); - append_line(buf, &len, " float4 c0 = TEX_OFFSET(tex, tSampler, texCoord, offset, texSize);"); - append_line(buf, &len, " float4 c1 = TEX_OFFSET(tex, tSampler, texCoord, float2(offset.x - sign(offset.x), offset.y), texSize);"); - append_line(buf, &len, " float4 c2 = TEX_OFFSET(tex, tSampler, texCoord, float2(offset.x, offset.y - sign(offset.y)), texSize);"); - append_line(buf, &len, " return c0 + abs(offset.x)*(c1-c0) + abs(offset.y)*(c2-c0);"); - append_line(buf, &len, "}"); - } - - // Vertex shader - - append_str(buf, &len, "PSInput VSMain(float4 position : POSITION"); - if (cc_features.used_textures[0] || cc_features.used_textures[1]) { - append_str(buf, &len, ", float2 uv : TEXCOORD"); - } - if (cc_features.opt_fog) { - append_str(buf, &len, ", float4 fog : FOG"); - } - for (int i = 0; i < cc_features.num_inputs; i++) { - len += sprintf(buf + len, ", float%d input%d : INPUT%d", cc_features.opt_alpha ? 4 : 3, i + 1, i); - } - append_line(buf, &len, ") {"); - append_line(buf, &len, " PSInput result;"); - append_line(buf, &len, " result.position = position;"); - if (cc_features.opt_alpha && cc_features.opt_noise) { - append_line(buf, &len, " result.screenPos = position;"); - } - if (cc_features.used_textures[0] || cc_features.used_textures[1]) { - append_line(buf, &len, " result.uv = uv;"); - } - if (cc_features.opt_fog) { - append_line(buf, &len, " result.fog = fog;"); - } - for (int i = 0; i < cc_features.num_inputs; i++) { - len += sprintf(buf + len, " result.input%d = input%d;\r\n", i + 1, i + 1); - } - append_line(buf, &len, " return result;"); - append_line(buf, &len, "}"); - - // Pixel shader - if (include_root_signature) { - append_line(buf, &len, "[RootSignature(RS)]"); - } - append_line(buf, &len, "float4 PSMain(PSInput input) : SV_TARGET {"); - if (cc_features.used_textures[0]) { - if (three_point_filtering) { - append_line(buf, &len, " float4 texVal0;"); - append_line(buf, &len, " if (textures[0].linear_filtering)"); - append_line(buf, &len, " texVal0 = tex2D3PointFilter(g_texture0, g_sampler0, input.uv, float2(textures[0].width, textures[0].height));"); - append_line(buf, &len, " else"); - append_line(buf, &len, " texVal0 = g_texture0.Sample(g_sampler0, input.uv);"); - } else { - append_line(buf, &len, " float4 texVal0 = g_texture0.Sample(g_sampler0, input.uv);"); - } - } - if (cc_features.used_textures[1]) { - if (three_point_filtering) { - append_line(buf, &len, " float4 texVal1;"); - append_line(buf, &len, " if (textures[1].linear_filtering)"); - append_line(buf, &len, " texVal1 = tex2D3PointFilter(g_texture1, g_sampler1, input.uv, float2(textures[1].width, textures[1].height));"); - append_line(buf, &len, " else"); - append_line(buf, &len, " texVal1 = g_texture1.Sample(g_sampler1, input.uv);"); - } else { - append_line(buf, &len, " float4 texVal1 = g_texture1.Sample(g_sampler1, input.uv);"); - } - } - - append_str(buf, &len, cc_features.opt_alpha ? " float4 texel = " : " float3 texel = "); - if (!cc_features.color_alpha_same && cc_features.opt_alpha) { - append_str(buf, &len, "float4("); - append_formula(buf, &len, cc_features.c, cc_features.do_single[0], cc_features.do_multiply[0], cc_features.do_mix[0], false, false, true); - append_str(buf, &len, ", "); - append_formula(buf, &len, cc_features.c, cc_features.do_single[1], cc_features.do_multiply[1], cc_features.do_mix[1], true, true, true); - append_str(buf, &len, ")"); - } else { - append_formula(buf, &len, cc_features.c, cc_features.do_single[0], cc_features.do_multiply[0], cc_features.do_mix[0], cc_features.opt_alpha, false, cc_features.opt_alpha); - } - append_line(buf, &len, ";"); - - if (cc_features.opt_texture_edge && cc_features.opt_alpha) { - append_line(buf, &len, " if (texel.a > 0.3) texel.a = 1.0; else discard;"); - } - // TODO discard if alpha is 0? - if (cc_features.opt_fog) { - if (cc_features.opt_alpha) { - append_line(buf, &len, " texel = float4(lerp(texel.rgb, input.fog.rgb, input.fog.a), texel.a);"); - } else { - append_line(buf, &len, " texel = lerp(texel, input.fog.rgb, input.fog.a);"); - } - } - - if (cc_features.opt_alpha && cc_features.opt_noise) { - append_line(buf, &len, " float2 coords = (input.screenPos.xy / input.screenPos.w) * noise_scale;"); - append_line(buf, &len, " texel.a *= round(random(float3(floor(coords), noise_frame)));"); - } - - if (cc_features.opt_alpha) { - append_line(buf, &len, " return texel;"); - } else { - append_line(buf, &len, " return float4(texel, 1.0);"); - } - append_line(buf, &len, "}"); -} - -#endif diff --git a/src/decomp/pc/gfx/gfx_direct3d_common.h b/src/decomp/pc/gfx/gfx_direct3d_common.h deleted file mode 100644 index 5df83a3..0000000 --- a/src/decomp/pc/gfx/gfx_direct3d_common.h +++ /dev/null @@ -1,14 +0,0 @@ -#if defined(ENABLE_DX11) || defined(ENABLE_DX12) - -#ifndef GFX_DIRECT3D_COMMON_H -#define GFX_DIRECT3D_COMMON_H - -#include - -#include "gfx_cc.h" - -void gfx_direct3d_common_build_shader(char buf[4096], size_t& len, size_t& num_floats, const CCFeatures& cc_features, bool include_root_signature, bool three_point_filtering); - -#endif - -#endif diff --git a/src/decomp/pc/gfx/gfx_dummy.c b/src/decomp/pc/gfx/gfx_dummy.c deleted file mode 100644 index c9c644a..0000000 --- a/src/decomp/pc/gfx/gfx_dummy.c +++ /dev/null @@ -1,192 +0,0 @@ -#ifdef ENABLE_GFX_DUMMY -#include -#include - -#include "gfx_window_manager_api.h" -#include "gfx_rendering_api.h" - -static void gfx_dummy_wm_init(const char *game_name, bool start_in_fullscreen) { -} - -static void gfx_dummy_wm_set_keyboard_callbacks(bool (*on_key_down)(int scancode), bool (*on_key_up)(int scancode), void (*on_all_keys_up)(void)) { -} - -static void gfx_dummy_wm_set_fullscreen_changed_callback(void (*on_fullscreen_changed)(bool is_now_fullscreen)) { -} - -static void gfx_dummy_wm_set_fullscreen(bool enable) { -} - -static void gfx_dummy_wm_main_loop(void (*run_one_game_iter)(void)) { - while (1) { - run_one_game_iter(); - } -} - -static void gfx_dummy_wm_get_dimensions(uint32_t *width, uint32_t *height) { - *width = 320; - *height = 240; -} - -static void gfx_dummy_wm_handle_events(void) { -} - -static bool gfx_dummy_wm_start_frame(void) { - return true; -} - -static void gfx_dummy_wm_swap_buffers_begin(void) { -} - -static struct timespec gfx_dummy_wm_timediff(struct timespec t1, struct timespec t2) { - t1.tv_sec -= t2.tv_sec; - t1.tv_nsec -= t2.tv_nsec; - if (t1.tv_nsec < 0) { - t1.tv_nsec += 1000000000; - t1.tv_sec -= 1; - } - return t1; -} - -static struct timespec gfx_dummy_wm_timeadd(struct timespec t1, struct timespec t2) { - t1.tv_sec += t2.tv_sec; - t1.tv_nsec += t2.tv_nsec; - if (t1.tv_nsec > 1000000000) { - t1.tv_nsec -= 1000000000; - t1.tv_sec += 1; - } - return t1; -} - -static void gfx_dummy_wm_swap_buffers_end(void) { - static struct timespec prev; - struct timespec t; - clock_gettime(CLOCK_MONOTONIC, &t); - struct timespec diff = gfx_dummy_wm_timediff(t, prev); - if (diff.tv_sec == 0 && diff.tv_nsec < 1000000000 / 30) { - struct timespec add = {0, 1000000000 / 30}; - struct timespec next = gfx_dummy_wm_timeadd(prev, add); - while (clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &next, NULL) == EINTR) { - } - prev = next; - } else { - prev = t; - } -} - -static double gfx_dummy_wm_get_time(void) { - return 0.0; -} - -static bool gfx_dummy_renderer_z_is_from_0_to_1(void) { - return false; -} - -static void gfx_dummy_renderer_unload_shader(struct ShaderProgram *old_prg) { -} - -static void gfx_dummy_renderer_load_shader(struct ShaderProgram *new_prg) { -} - -static struct ShaderProgram *gfx_dummy_renderer_create_and_load_new_shader(uint32_t shader_id) { - return NULL; -} - -static struct ShaderProgram *gfx_dummy_renderer_lookup_shader(uint32_t shader_id) { - return NULL; -} - -static void gfx_dummy_renderer_shader_get_info(struct ShaderProgram *prg, uint8_t *num_inputs, bool used_textures[2]) { - *num_inputs = 0; - used_textures[0] = false; - used_textures[1] = false; -} - -static uint32_t gfx_dummy_renderer_new_texture(void) { - return 0; -} - -static void gfx_dummy_renderer_select_texture(int tile, uint32_t texture_id) { -} - -static void gfx_dummy_renderer_upload_texture(const uint8_t *rgba32_buf, int width, int height) { -} - -static void gfx_dummy_renderer_set_sampler_parameters(int tile, bool linear_filter, uint32_t cms, uint32_t cmt) { -} - -static void gfx_dummy_renderer_set_depth_test(bool depth_test) { -} - -static void gfx_dummy_renderer_set_depth_mask(bool z_upd) { -} - -static void gfx_dummy_renderer_set_zmode_decal(bool zmode_decal) { -} - -static void gfx_dummy_renderer_set_viewport(int x, int y, int width, int height) { -} - -static void gfx_dummy_renderer_set_scissor(int x, int y, int width, int height) { -} - -static void gfx_dummy_renderer_set_use_alpha(bool use_alpha) { -} - -static void gfx_dummy_renderer_draw_triangles(float buf_vbo[], size_t buf_vbo_len, size_t buf_vbo_num_tris) { -} - -static void gfx_dummy_renderer_init(void) { -} - -static void gfx_dummy_renderer_on_resize(void) { -} - -static void gfx_dummy_renderer_start_frame(void) { -} - -static void gfx_dummy_renderer_end_frame(void) { -} - -static void gfx_dummy_renderer_finish_render(void) { -} - -struct GfxWindowManagerAPI gfx_dummy_wm_api = { - gfx_dummy_wm_init, - gfx_dummy_wm_set_keyboard_callbacks, - gfx_dummy_wm_set_fullscreen_changed_callback, - gfx_dummy_wm_set_fullscreen, - gfx_dummy_wm_main_loop, - gfx_dummy_wm_get_dimensions, - gfx_dummy_wm_handle_events, - gfx_dummy_wm_start_frame, - gfx_dummy_wm_swap_buffers_begin, - gfx_dummy_wm_swap_buffers_end, - gfx_dummy_wm_get_time -}; - -struct GfxRenderingAPI gfx_dummy_renderer_api = { - gfx_dummy_renderer_z_is_from_0_to_1, - gfx_dummy_renderer_unload_shader, - gfx_dummy_renderer_load_shader, - gfx_dummy_renderer_create_and_load_new_shader, - gfx_dummy_renderer_lookup_shader, - gfx_dummy_renderer_shader_get_info, - gfx_dummy_renderer_new_texture, - gfx_dummy_renderer_select_texture, - gfx_dummy_renderer_upload_texture, - gfx_dummy_renderer_set_sampler_parameters, - gfx_dummy_renderer_set_depth_test, - gfx_dummy_renderer_set_depth_mask, - gfx_dummy_renderer_set_zmode_decal, - gfx_dummy_renderer_set_viewport, - gfx_dummy_renderer_set_scissor, - gfx_dummy_renderer_set_use_alpha, - gfx_dummy_renderer_draw_triangles, - gfx_dummy_renderer_init, - gfx_dummy_renderer_on_resize, - gfx_dummy_renderer_start_frame, - gfx_dummy_renderer_end_frame, - gfx_dummy_renderer_finish_render -}; -#endif diff --git a/src/decomp/pc/gfx/gfx_dummy.h b/src/decomp/pc/gfx/gfx_dummy.h deleted file mode 100644 index de12c71..0000000 --- a/src/decomp/pc/gfx/gfx_dummy.h +++ /dev/null @@ -1,14 +0,0 @@ -#ifdef ENABLE_GFX_DUMMY - -#ifndef GFX_DUMMY_H -#define GFX_DUMMY_H - -#include "gfx_rendering_api.h" -#include "gfx_window_manager_api.h" - -extern struct GfxRenderingAPI gfx_dummy_renderer_api; -extern struct GfxWindowManagerAPI gfx_dummy_wm_api; - -#endif - -#endif diff --git a/src/decomp/pc/gfx/gfx_dxgi.cpp b/src/decomp/pc/gfx/gfx_dxgi.cpp deleted file mode 100644 index 02cdd81..0000000 --- a/src/decomp/pc/gfx/gfx_dxgi.cpp +++ /dev/null @@ -1,614 +0,0 @@ -#if defined(ENABLE_DX11) || defined(ENABLE_DX12) - -#include -#include - -#include -#include -#include - -#include -#include -#include -#include - -#include - - -#ifndef _LANGUAGE_C -#define _LANGUAGE_C -#endif -#include - -#include "gfx_window_manager_api.h" -#include "gfx_rendering_api.h" -#include "gfx_direct3d_common.h" -#include "gfx_screen_config.h" -#include "gfx_pc.h" - -#define DECLARE_GFX_DXGI_FUNCTIONS -#include "gfx_dxgi.h" - -#define WINCLASS_NAME L"N64GAME" -#define GFX_API_NAME "DirectX" - -#ifdef VERSION_EU -#define FRAME_INTERVAL_US_NUMERATOR 40000 -#define FRAME_INTERVAL_US_DENOMINATOR 1 -#else -#define FRAME_INTERVAL_US_NUMERATOR 100000 -#define FRAME_INTERVAL_US_DENOMINATOR 3 -#endif - -using namespace Microsoft::WRL; // For ComPtr - -static struct { - HWND h_wnd; - bool showing_error; - uint32_t current_width, current_height; - std::string game_name; - - HMODULE dxgi_module; - HRESULT (__stdcall *CreateDXGIFactory1)(REFIID riid, void **factory); - HRESULT (__stdcall *CreateDXGIFactory2)(UINT flags, REFIID iid, void **factory); - - bool process_dpi_awareness_done; - - RECT last_window_rect; - bool is_full_screen, last_maximized_state; - - ComPtr factory; - ComPtr swap_chain; - HANDLE waitable_object; - uint64_t qpc_init, qpc_freq; - uint64_t frame_timestamp; // in units of 1/FRAME_INTERVAL_US_DENOMINATOR microseconds - std::map frame_stats; - std::set> pending_frame_stats; - bool dropped_frame; - bool sync_interval_means_frames_to_wait; - UINT length_in_vsync_frames; - - void (*on_fullscreen_changed)(bool is_now_fullscreen); - void (*run_one_game_iter)(void); - bool (*on_key_down)(int scancode); - bool (*on_key_up)(int scancode); - void (*on_all_keys_up)(void); -} dxgi; - -static void load_dxgi_library(void) { - dxgi.dxgi_module = LoadLibraryW(L"dxgi.dll"); - *(FARPROC *)&dxgi.CreateDXGIFactory1 = GetProcAddress(dxgi.dxgi_module, "CreateDXGIFactory1"); - *(FARPROC *)&dxgi.CreateDXGIFactory2 = GetProcAddress(dxgi.dxgi_module, "CreateDXGIFactory2"); -} - -template -static void run_as_dpi_aware(Fun f) { - // Make sure Windows 8.1 or newer doesn't upscale/downscale the rendered images. - // This is an issue on Windows 8.1 and newer where moving around the window - // between different monitors having different scaling settings will - // by default result in the DirectX image will also be scaled accordingly. - // The resulting scale factor is the curent monitor's scale factor divided by - // the initial monitor's scale factor. Setting per-monitor aware disables scaling. - - // On Windows 10 1607 and later, that is solved by setting the awarenenss per window, - // which is done by using SetThreadDpiAwarenessContext before and after creating - // any window. When the message handler runs, the corresponding context also applies. - - // From windef.h, missing in MinGW. - DECLARE_HANDLE(DPI_AWARENESS_CONTEXT); - #define DPI_AWARENESS_CONTEXT_UNAWARE ((DPI_AWARENESS_CONTEXT)-1) - #define DPI_AWARENESS_CONTEXT_SYSTEM_AWARE ((DPI_AWARENESS_CONTEXT)-2) - #define DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE ((DPI_AWARENESS_CONTEXT)-3) - #define DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2 ((DPI_AWARENESS_CONTEXT)-4) - #define DPI_AWARENESS_CONTEXT_UNAWARE_GDISCALED ((DPI_AWARENESS_CONTEXT)-5) - - DPI_AWARENESS_CONTEXT (WINAPI *SetThreadDpiAwarenessContext)(DPI_AWARENESS_CONTEXT dpiContext); - *(FARPROC *)&SetThreadDpiAwarenessContext = GetProcAddress(GetModuleHandleW(L"user32.dll"), "SetThreadDpiAwarenessContext"); - DPI_AWARENESS_CONTEXT old_awareness_context; - if (SetThreadDpiAwarenessContext != nullptr) { - old_awareness_context = SetThreadDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2); - } else { - // Solution for Windows 8.1 and newer, but before Windows 10 1607. - // SetProcessDpiAwareness must be called before any drawing related API is called. - if (!dxgi.process_dpi_awareness_done) { - HMODULE shcore_module = LoadLibraryW(L"SHCore.dll"); - if (shcore_module != nullptr) { - HRESULT (WINAPI *SetProcessDpiAwareness)(PROCESS_DPI_AWARENESS value); - *(FARPROC *)&SetProcessDpiAwareness = GetProcAddress(shcore_module, "SetProcessDpiAwareness"); - if (SetProcessDpiAwareness != nullptr) { - SetProcessDpiAwareness(PROCESS_PER_MONITOR_DPI_AWARE); - // Ignore result, will fail if already called or manifest already specifies dpi awareness. - } - FreeLibrary(shcore_module); - } - dxgi.process_dpi_awareness_done = true; - } - } - - f(); - - // Restore the old context - if (SetThreadDpiAwarenessContext != nullptr && old_awareness_context != nullptr) { - SetThreadDpiAwarenessContext(old_awareness_context); - } -} - -static void toggle_borderless_window_full_screen(bool enable, bool call_callback) { - // Windows 7 + flip mode + waitable object can't go to exclusive fullscreen, - // so do borderless instead. If DWM is enabled, this means we get one monitor - // sync interval of latency extra. On Win 10 however (maybe Win 8 too), due to - // "fullscreen optimizations" the latency is eliminated. - - if (enable == dxgi.is_full_screen) { - return; - } - - if (!enable) { - RECT r = dxgi.last_window_rect; - - // Set in window mode with the last saved position and size - SetWindowLongPtr(dxgi.h_wnd, GWL_STYLE, WS_VISIBLE | WS_OVERLAPPEDWINDOW); - - if (dxgi.last_maximized_state) { - SetWindowPos(dxgi.h_wnd, NULL, 0, 0, 0, 0, SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOSIZE); - ShowWindow(dxgi.h_wnd, SW_MAXIMIZE); - } else { - SetWindowPos(dxgi.h_wnd, NULL, r.left, r.top, r.right - r.left, r.bottom - r.top, SWP_FRAMECHANGED); - ShowWindow(dxgi.h_wnd, SW_RESTORE); - } - - ShowCursor(TRUE); - - dxgi.is_full_screen = false; - } else { - // Save if window is maximized or not - WINDOWPLACEMENT window_placement; - window_placement.length = sizeof(WINDOWPLACEMENT); - GetWindowPlacement(dxgi.h_wnd, &window_placement); - dxgi.last_maximized_state = window_placement.showCmd == SW_SHOWMAXIMIZED; - - // Save window position and size if the window is not maximized - GetWindowRect(dxgi.h_wnd, &dxgi.last_window_rect); - - // Get in which monitor the window is - HMONITOR h_monitor = MonitorFromWindow(dxgi.h_wnd, MONITOR_DEFAULTTONEAREST); - - // Get info from that monitor - MONITORINFOEX monitor_info; - monitor_info.cbSize = sizeof(MONITORINFOEX); - GetMonitorInfo(h_monitor, &monitor_info); - RECT r = monitor_info.rcMonitor; - - // Set borderless full screen to that monitor - SetWindowLongPtr(dxgi.h_wnd, GWL_STYLE, WS_VISIBLE | WS_POPUP); - SetWindowPos(dxgi.h_wnd, HWND_TOP, r.left, r.top, r.right - r.left, r.bottom - r.top, SWP_FRAMECHANGED); - - ShowCursor(FALSE); - - dxgi.is_full_screen = true; - } - - if (dxgi.on_fullscreen_changed != nullptr && call_callback) { - dxgi.on_fullscreen_changed(enable); - } -} - -static void gfx_dxgi_on_resize(void) { - if (dxgi.swap_chain.Get() != nullptr) { - gfx_get_current_rendering_api()->on_resize(); - - DXGI_SWAP_CHAIN_DESC1 desc1; - ThrowIfFailed(dxgi.swap_chain->GetDesc1(&desc1)); - dxgi.current_width = desc1.Width; - dxgi.current_height = desc1.Height; - } -} - -static void onkeydown(WPARAM w_param, LPARAM l_param) { - int key = ((l_param >> 16) & 0x1ff); - if (dxgi.on_key_down != nullptr) { - dxgi.on_key_down(key); - } -} -static void onkeyup(WPARAM w_param, LPARAM l_param) { - int key = ((l_param >> 16) & 0x1ff); - if (dxgi.on_key_up != nullptr) { - dxgi.on_key_up(key); - } -} - -static LRESULT CALLBACK gfx_dxgi_wnd_proc(HWND h_wnd, UINT message, WPARAM w_param, LPARAM l_param) { - switch (message) { - case WM_SIZE: - gfx_dxgi_on_resize(); - break; - case WM_DESTROY: - exit(0); - case WM_PAINT: - if (dxgi.showing_error) { - return DefWindowProcW(h_wnd, message, w_param, l_param); - } else { - if (dxgi.run_one_game_iter != nullptr) { - dxgi.run_one_game_iter(); - } - } - break; - case WM_ACTIVATEAPP: - if (dxgi.on_all_keys_up != nullptr) { - dxgi.on_all_keys_up(); - } - break; - case WM_KEYDOWN: - onkeydown(w_param, l_param); - break; - case WM_KEYUP: - onkeyup(w_param, l_param); - break; - case WM_SYSKEYDOWN: - if ((w_param == VK_RETURN) && ((l_param & 1 << 30) == 0)) { - toggle_borderless_window_full_screen(!dxgi.is_full_screen, true); - break; - } else { - return DefWindowProcW(h_wnd, message, w_param, l_param); - } - default: - return DefWindowProcW(h_wnd, message, w_param, l_param); - } - return 0; -} - -static void gfx_dxgi_init(const char *game_name, bool start_in_fullscreen) { - LARGE_INTEGER qpc_init, qpc_freq; - QueryPerformanceCounter(&qpc_init); - QueryPerformanceFrequency(&qpc_freq); - dxgi.qpc_init = qpc_init.QuadPart; - dxgi.qpc_freq = qpc_freq.QuadPart; - - // Prepare window title - - char title[512]; - wchar_t w_title[512]; - int len = sprintf(title, "%s (%s)", game_name, GFX_API_NAME); - mbstowcs(w_title, title, len + 1); - dxgi.game_name = game_name; - - // Create window - WNDCLASSEXW wcex; - - wcex.cbSize = sizeof(WNDCLASSEX); - - wcex.style = CS_HREDRAW | CS_VREDRAW; - wcex.lpfnWndProc = gfx_dxgi_wnd_proc; - wcex.cbClsExtra = 0; - wcex.cbWndExtra = 0; - wcex.hInstance = nullptr; - wcex.hIcon = nullptr; - wcex.hCursor = LoadCursor(nullptr, IDC_ARROW); - wcex.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH); - wcex.lpszMenuName = nullptr; - wcex.lpszClassName = WINCLASS_NAME; - wcex.hIconSm = nullptr; - - ATOM winclass = RegisterClassExW(&wcex); - - - run_as_dpi_aware([&] () { - // We need to be dpi aware when calculating the size - RECT wr = {0, 0, DESIRED_SCREEN_WIDTH, DESIRED_SCREEN_HEIGHT}; - AdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, FALSE); - - dxgi.h_wnd = CreateWindowW(WINCLASS_NAME, w_title, WS_OVERLAPPEDWINDOW, - CW_USEDEFAULT, 0, wr.right - wr.left, wr.bottom - wr.top, nullptr, nullptr, nullptr, nullptr); - }); - - load_dxgi_library(); - - ShowWindow(dxgi.h_wnd, SW_SHOW); - UpdateWindow(dxgi.h_wnd); - - if (start_in_fullscreen) { - toggle_borderless_window_full_screen(true, false); - } -} - -static void gfx_dxgi_set_fullscreen_changed_callback(void (*on_fullscreen_changed)(bool is_now_fullscreen)) { - dxgi.on_fullscreen_changed = on_fullscreen_changed; -} - -static void gfx_dxgi_set_fullscreen(bool enable) { - toggle_borderless_window_full_screen(enable, true); -} - -static void gfx_dxgi_set_keyboard_callbacks(bool (*on_key_down)(int scancode), bool (*on_key_up)(int scancode), void (*on_all_keys_up)(void)) { - dxgi.on_key_down = on_key_down; - dxgi.on_key_up = on_key_up; - dxgi.on_all_keys_up = on_all_keys_up; -} - -static void gfx_dxgi_main_loop(void (*run_one_game_iter)(void)) { - dxgi.run_one_game_iter = run_one_game_iter; - - MSG msg; - while (GetMessage(&msg, nullptr, 0, 0)) { - TranslateMessage(&msg); - DispatchMessage(&msg); - } -} - -static void gfx_dxgi_get_dimensions(uint32_t *width, uint32_t *height) { - *width = dxgi.current_width; - *height = dxgi.current_height; -} - -static void gfx_dxgi_handle_events(void) { - /*MSG msg; - while (PeekMessageW(&msg, nullptr, 0, 0, PM_REMOVE)) { - TranslateMessage(&msg); - DispatchMessage(&msg); - }*/ -} - -static uint64_t qpc_to_us(uint64_t qpc) { - return qpc / dxgi.qpc_freq * 1000000 + qpc % dxgi.qpc_freq * 1000000 / dxgi.qpc_freq; -} - -static bool gfx_dxgi_start_frame(void) { - DXGI_FRAME_STATISTICS stats; - if (dxgi.swap_chain->GetFrameStatistics(&stats) == S_OK && (stats.SyncRefreshCount != 0 || stats.SyncQPCTime.QuadPart != 0ULL)) { - { - LARGE_INTEGER t0; - QueryPerformanceCounter(&t0); - //printf("Get frame stats: %llu\n", (unsigned long long)(t0.QuadPart - dxgi.qpc_init)); - } - //printf("stats: %u %u %u %u %u %.6f\n", dxgi.pending_frame_stats.rbegin()->first, dxgi.pending_frame_stats.rbegin()->second, stats.PresentCount, stats.PresentRefreshCount, stats.SyncRefreshCount, (double)(stats.SyncQPCTime.QuadPart - dxgi.qpc_init) / dxgi.qpc_freq); - if (dxgi.frame_stats.empty() || dxgi.frame_stats.rbegin()->second.PresentCount != stats.PresentCount) { - dxgi.frame_stats.insert(std::make_pair(stats.PresentCount, stats)); - } - if (dxgi.frame_stats.size() > 3) { - dxgi.frame_stats.erase(dxgi.frame_stats.begin()); - } - } - if (!dxgi.frame_stats.empty()) { - while (!dxgi.pending_frame_stats.empty() && dxgi.pending_frame_stats.begin()->first < dxgi.frame_stats.rbegin()->first) { - dxgi.pending_frame_stats.erase(dxgi.pending_frame_stats.begin()); - } - } - while (dxgi.pending_frame_stats.size() > 15) { - // Just make sure the list doesn't grow too large if GetFrameStatistics fails. - dxgi.pending_frame_stats.erase(dxgi.pending_frame_stats.begin()); - } - - dxgi.frame_timestamp += FRAME_INTERVAL_US_NUMERATOR; - - if (dxgi.frame_stats.size() >= 2) { - DXGI_FRAME_STATISTICS *first = &dxgi.frame_stats.begin()->second; - DXGI_FRAME_STATISTICS *last = &dxgi.frame_stats.rbegin()->second; - uint64_t sync_qpc_diff = last->SyncQPCTime.QuadPart - first->SyncQPCTime.QuadPart; - UINT sync_vsync_diff = last->SyncRefreshCount - first->SyncRefreshCount; - UINT present_vsync_diff = last->PresentRefreshCount - first->PresentRefreshCount; - UINT present_diff = last->PresentCount - first->PresentCount; - - if (sync_vsync_diff == 0) { - sync_vsync_diff = 1; - } - - double estimated_vsync_interval = (double)sync_qpc_diff / (double)sync_vsync_diff; - uint64_t estimated_vsync_interval_us = qpc_to_us(estimated_vsync_interval); - //printf("Estimated vsync_interval: %d\n", (int)estimated_vsync_interval_us); - if (estimated_vsync_interval_us < 2 || estimated_vsync_interval_us > 1000000) { - // Unreasonable, maybe a monitor change - estimated_vsync_interval_us = 16666; - estimated_vsync_interval = estimated_vsync_interval_us * dxgi.qpc_freq / 1000000; - } - - UINT queued_vsyncs = 0; - bool is_first = true; - for (const std::pair& p : dxgi.pending_frame_stats) { - if (is_first && dxgi.sync_interval_means_frames_to_wait) { - is_first = false; - continue; - } - queued_vsyncs += p.second; - } - - uint64_t last_frame_present_end_qpc = (last->SyncQPCTime.QuadPart - dxgi.qpc_init) + estimated_vsync_interval * queued_vsyncs; - uint64_t last_end_us = qpc_to_us(last_frame_present_end_qpc); - - double vsyncs_to_wait = (double)(int64_t)(dxgi.frame_timestamp / FRAME_INTERVAL_US_DENOMINATOR - last_end_us) / estimated_vsync_interval_us; - //printf("ts: %llu, last_end_us: %llu, Init v: %f\n", dxgi.frame_timestamp / 3, last_end_us, vsyncs_to_wait); - - if (vsyncs_to_wait <= 0) { - // Too late - - if ((int64_t)(dxgi.frame_timestamp / FRAME_INTERVAL_US_DENOMINATOR - last_end_us) < -66666) { - // The application must have been paused or similar - vsyncs_to_wait = round(((double)FRAME_INTERVAL_US_NUMERATOR / FRAME_INTERVAL_US_DENOMINATOR) / estimated_vsync_interval_us); - if (vsyncs_to_wait < 1) { - vsyncs_to_wait = 1; - } - dxgi.frame_timestamp = FRAME_INTERVAL_US_DENOMINATOR * (last_end_us + vsyncs_to_wait * estimated_vsync_interval_us); - } else { - // Drop frame - //printf("Dropping frame\n"); - dxgi.dropped_frame = true; - return false; - } - } - if (floor(vsyncs_to_wait) != vsyncs_to_wait) { - uint64_t left = last_end_us + floor(vsyncs_to_wait) * estimated_vsync_interval_us; - uint64_t right = last_end_us + ceil(vsyncs_to_wait) * estimated_vsync_interval_us; - uint64_t adjusted_desired_time = dxgi.frame_timestamp / FRAME_INTERVAL_US_DENOMINATOR + (last_end_us + (FRAME_INTERVAL_US_NUMERATOR / FRAME_INTERVAL_US_DENOMINATOR) > dxgi.frame_timestamp / FRAME_INTERVAL_US_DENOMINATOR ? 2000 : -2000); - int64_t diff_left = adjusted_desired_time - left; - int64_t diff_right = right - adjusted_desired_time; - if (diff_left < 0) { - diff_left = -diff_left; - } - if (diff_right < 0) { - diff_right = -diff_right; - } - if (diff_left < diff_right) { - vsyncs_to_wait = floor(vsyncs_to_wait); - } else { - vsyncs_to_wait = ceil(vsyncs_to_wait); - } - if (vsyncs_to_wait == 0) { - //printf("vsyncs_to_wait became 0 so dropping frame\n"); - dxgi.dropped_frame = true; - return false; - } - } - //printf("v: %d\n", (int)vsyncs_to_wait); - if (vsyncs_to_wait > 4) { - // Invalid, so change to 4 - vsyncs_to_wait = 4; - } - dxgi.length_in_vsync_frames = vsyncs_to_wait; - } else { - dxgi.length_in_vsync_frames = 2; - } - - return true; -} - -static void gfx_dxgi_swap_buffers_begin(void) { - //dxgi.length_in_vsync_frames = 1; - ThrowIfFailed(dxgi.swap_chain->Present(dxgi.length_in_vsync_frames, 0)); - UINT this_present_id; - if (dxgi.swap_chain->GetLastPresentCount(&this_present_id) == S_OK) { - dxgi.pending_frame_stats.insert(std::make_pair(this_present_id, dxgi.length_in_vsync_frames)); - } - dxgi.dropped_frame = false; -} - -static void gfx_dxgi_swap_buffers_end(void) { - LARGE_INTEGER t0, t1, t2; - QueryPerformanceCounter(&t0); - QueryPerformanceCounter(&t1); - - if (!dxgi.dropped_frame) { - if (dxgi.waitable_object != nullptr) { - WaitForSingleObject(dxgi.waitable_object, INFINITE); - } - // else TODO: maybe sleep until some estimated time the frame will be shown to reduce lag - } - - DXGI_FRAME_STATISTICS stats; - dxgi.swap_chain->GetFrameStatistics(&stats); - - QueryPerformanceCounter(&t2); - - dxgi.sync_interval_means_frames_to_wait = dxgi.pending_frame_stats.rbegin()->first == stats.PresentCount; - - //printf("done %llu gpu:%d wait:%d freed:%llu frame:%u %u monitor:%u t:%llu\n", (unsigned long long)(t0.QuadPart - dxgi.qpc_init), (int)(t1.QuadPart - t0.QuadPart), (int)(t2.QuadPart - t0.QuadPart), (unsigned long long)(t2.QuadPart - dxgi.qpc_init), dxgi.pending_frame_stats.rbegin()->first, stats.PresentCount, stats.SyncRefreshCount, (unsigned long long)(stats.SyncQPCTime.QuadPart - dxgi.qpc_init)); -} - -static double gfx_dxgi_get_time(void) { - LARGE_INTEGER t; - QueryPerformanceCounter(&t); - return (double)(t.QuadPart - dxgi.qpc_init) / dxgi.qpc_freq; -} - -void gfx_dxgi_create_factory_and_device(bool debug, int d3d_version, bool (*create_device_fn)(IDXGIAdapter1 *adapter, bool test_only)) { - if (dxgi.CreateDXGIFactory2 != nullptr) { - ThrowIfFailed(dxgi.CreateDXGIFactory2(debug ? DXGI_CREATE_FACTORY_DEBUG : 0, __uuidof(IDXGIFactory2), &dxgi.factory)); - } else { - ThrowIfFailed(dxgi.CreateDXGIFactory1(__uuidof(IDXGIFactory2), &dxgi.factory)); - } - - ComPtr adapter; - for (UINT i = 0; dxgi.factory->EnumAdapters1(i, &adapter) != DXGI_ERROR_NOT_FOUND; i++) { - DXGI_ADAPTER_DESC1 desc; - adapter->GetDesc1(&desc); - if (desc.Flags & 2/*DXGI_ADAPTER_FLAG_SOFTWARE*/) { // declaration missing in mingw headers - continue; - } - if (create_device_fn(adapter.Get(), true)) { - break; - } - } - create_device_fn(adapter.Get(), false); - - char title[512]; - wchar_t w_title[512]; - int len = sprintf(title, "%s (Direct3D %d)", dxgi.game_name.c_str(), d3d_version); - mbstowcs(w_title, title, len + 1); - SetWindowTextW(dxgi.h_wnd, w_title); -} - -ComPtr gfx_dxgi_create_swap_chain(IUnknown *device) { - bool win8 = IsWindows8OrGreater(); // DXGI_SCALING_NONE is only supported on Win8 and beyond - bool dxgi_13 = dxgi.CreateDXGIFactory2 != nullptr; // DXGI 1.3 introduced waitable object - - DXGI_SWAP_CHAIN_DESC1 swap_chain_desc = {}; - swap_chain_desc.BufferCount = 2; - swap_chain_desc.Width = 0; - swap_chain_desc.Height = 0; - swap_chain_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; - swap_chain_desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; - swap_chain_desc.Scaling = win8 ? DXGI_SCALING_NONE : DXGI_SCALING_STRETCH; - swap_chain_desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; // Apparently this was backported to Win 7 Platform Update - swap_chain_desc.Flags = dxgi_13 ? DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT : 0; - swap_chain_desc.SampleDesc.Count = 1; - - run_as_dpi_aware([&] () { - // When setting size for the buffers, the values that DXGI puts into the desc (that can later be retrieved by GetDesc1) - // have been divided by the current scaling factor. By making this call dpi aware, no division will be performed. - // The same goes for IDXGISwapChain::ResizeBuffers(), however that function is currently only called from the message handler. - ThrowIfFailed(dxgi.factory->CreateSwapChainForHwnd(device, dxgi.h_wnd, &swap_chain_desc, nullptr, nullptr, &dxgi.swap_chain)); - }); - ThrowIfFailed(dxgi.factory->MakeWindowAssociation(dxgi.h_wnd, DXGI_MWA_NO_ALT_ENTER)); - - ComPtr swap_chain2; - if (dxgi.swap_chain->QueryInterface(__uuidof(IDXGISwapChain2), &swap_chain2) == S_OK) { - ThrowIfFailed(swap_chain2->SetMaximumFrameLatency(1)); - dxgi.waitable_object = swap_chain2->GetFrameLatencyWaitableObject(); - WaitForSingleObject(dxgi.waitable_object, INFINITE); - } else { - ComPtr device1; - ThrowIfFailed(device->QueryInterface(IID_PPV_ARGS(&device1))); - ThrowIfFailed(device1->SetMaximumFrameLatency(1)); - } - - ThrowIfFailed(dxgi.swap_chain->GetDesc1(&swap_chain_desc)); - dxgi.current_width = swap_chain_desc.Width; - dxgi.current_height = swap_chain_desc.Height; - - return dxgi.swap_chain; -} - -HWND gfx_dxgi_get_h_wnd(void) { - return dxgi.h_wnd; -} - -void ThrowIfFailed(HRESULT res) { - if (FAILED(res)) { - fprintf(stderr, "Error: 0x%08X\n", res); - throw res; - } -} - -void ThrowIfFailed(HRESULT res, HWND h_wnd, const char *message) { - if (FAILED(res)) { - char full_message[256]; - sprintf(full_message, "%s\n\nHRESULT: 0x%08X", message, res); - dxgi.showing_error = true; - MessageBox(h_wnd, full_message, "Error", MB_OK | MB_ICONERROR); - throw res; - } -} - -struct GfxWindowManagerAPI gfx_dxgi_api = { - gfx_dxgi_init, - gfx_dxgi_set_keyboard_callbacks, - gfx_dxgi_set_fullscreen_changed_callback, - gfx_dxgi_set_fullscreen, - gfx_dxgi_main_loop, - gfx_dxgi_get_dimensions, - gfx_dxgi_handle_events, - gfx_dxgi_start_frame, - gfx_dxgi_swap_buffers_begin, - gfx_dxgi_swap_buffers_end, - gfx_dxgi_get_time, -}; - -#endif diff --git a/src/decomp/pc/gfx/gfx_dxgi.h b/src/decomp/pc/gfx/gfx_dxgi.h deleted file mode 100644 index d590daa..0000000 --- a/src/decomp/pc/gfx/gfx_dxgi.h +++ /dev/null @@ -1,16 +0,0 @@ -#ifndef GFX_DXGI_H -#define GFX_DXGI_H - -#include "gfx_rendering_api.h" - -#ifdef DECLARE_GFX_DXGI_FUNCTIONS -void gfx_dxgi_create_factory_and_device(bool debug, int d3d_version, bool (*create_device_fn)(IDXGIAdapter1 *adapter, bool test_only)); -Microsoft::WRL::ComPtr gfx_dxgi_create_swap_chain(IUnknown *device); -HWND gfx_dxgi_get_h_wnd(void); -void ThrowIfFailed(HRESULT res); -void ThrowIfFailed(HRESULT res, HWND h_wnd, const char *message); -#endif - -extern struct GfxWindowManagerAPI gfx_dxgi_api; - -#endif diff --git a/src/decomp/pc/gfx/gfx_glx.c b/src/decomp/pc/gfx/gfx_glx.c deleted file mode 100644 index 9d2743e..0000000 --- a/src/decomp/pc/gfx/gfx_glx.c +++ /dev/null @@ -1,620 +0,0 @@ -#include "../compat.h" - -#if defined(__linux__) || defined(__BSD__) -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "gfx_window_manager_api.h" -#include "gfx_screen_config.h" - -#define GFX_API_NAME "GLX - OpenGL" - -#ifdef VERSION_EU -#define FRAME_INTERVAL_US_NUMERATOR 40000 -#define FRAME_INTERVAL_US_DENOMINATOR 1 -#else -#define FRAME_INTERVAL_US_NUMERATOR 100000 -#define FRAME_INTERVAL_US_DENOMINATOR 3 -#endif - -const struct { - const char *name; - int scancode; -} keymap_name_to_scancode[] = { - {"ESC", 0x01}, - {"AE01", 0x02 }, - {"AE02", 0x03 }, - {"AE03", 0x04 }, - {"AE04", 0x05 }, - {"AE05", 0x06 }, - {"AE06", 0x07 }, - {"AE07", 0x08 }, - {"AE08", 0x09 }, - {"AE09", 0x0a }, - {"AE10", 0x0b }, - {"AE11", 0x0c }, - {"AE12", 0x0d }, - {"BKSP", 0x0e }, - {"TAB", 0x0f }, - {"AD01", 0x10 }, - {"AD02", 0x11 }, - {"AD03", 0x12 }, - {"AD04", 0x13 }, - {"AD05", 0x14 }, - {"AD06", 0x15 }, - {"AD07", 0x16 }, - {"AD08", 0x17 }, - {"AD09", 0x18 }, - {"AD10", 0x19 }, - {"AD11", 0x1a }, - {"AD12", 0x1b }, - {"RTRN", 0x1c }, - {"LCTL", 0x1d }, - {"AC01", 0x1e }, - {"AC02", 0x1f }, - {"AC03", 0x20 }, - {"AC04", 0x21 }, - {"AC05", 0x22 }, - {"AC06", 0x23 }, - {"AC07", 0x24 }, - {"AC08", 0x25 }, - {"AC09", 0x26 }, - {"AC10", 0x27 }, - {"AC11", 0x28 }, - {"TLDE", 0x29 }, - {"LFSH", 0x2a }, - {"BKSL", 0x2b }, - {"AB01", 0x2c }, - {"AB02", 0x2d }, - {"AB03", 0x2e }, - {"AB04", 0x2f }, - {"AB05", 0x30 }, - {"AB06", 0x31 }, - {"AB07", 0x32 }, - {"AB08", 0x33 }, - {"AB09", 0x34 }, - {"AB10", 0x35 }, - {"RTSH", 0x36 }, - {"KPMU", 0x37 }, - {"LALT", 0x38 }, - {"SPCE", 0x39 }, - {"CAPS", 0x3a }, - {"FK01", 0x3b }, - {"FK02", 0x3c }, - {"FK03", 0x3d }, - {"FK04", 0x3e }, - {"FK05", 0x3f }, - {"FK06", 0x40 }, - {"FK07", 0x41 }, - {"FK08", 0x42 }, - {"FK09", 0x43 }, - {"FK10", 0x44 }, - {"NMLK", 0x45 }, - {"SCLK", 0x46 }, - {"KP7", 0x47 }, - {"KP8", 0x48 }, - {"KP9", 0x49 }, - {"KPSU", 0x4a }, - {"KP4", 0x4b }, - {"KP5", 0x4c }, - {"KP6", 0x4d }, - {"KPAD", 0x4e }, - {"KP1", 0x4f }, - {"KP2", 0x50 }, - {"KP3", 0x51 }, - {"KP0", 0x52 }, - {"KPDL", 0x53 }, - {"LVL3", 0x54 }, // correct? - {"", 0x55 }, // not mapped? - {"LSGT", 0x56 }, - {"FK11", 0x57 }, - {"FK12", 0x58 }, - {"AB11", 0x59 }, - {"KATA", 0 }, - {"HIRA", 0 }, - {"HENK", 0 }, - {"HKTG", 0 }, - {"MUHE", 0 }, - {"JPCM", 0 }, - {"KPEN", 0x11c }, - {"RCTL", 0x11d }, - {"KPDV", 0x135 }, - {"PRSC", 0x54 }, // ? - {"RALT", 0x138 }, - {"LNFD", 0 }, - {"HOME", 0x147 }, - {"UP", 0x148 }, - {"PGUP", 0x149 }, - {"LEFT", 0x14b }, - {"RGHT", 0x14d }, - {"END", 0x14f }, - {"DOWN", 0x150 }, - {"PGDN", 0x151 }, - {"INS", 0x152 }, - {"DELE", 0x153 }, - {"PAUS", 0x21d }, - {"LWIN", 0x15b }, - {"RWIN", 0x15c }, - {"COMP", 0x15d }, -}; - -static struct { - Display *dpy; - Window root; - Window win; - - Atom atom_wm_state; - Atom atom_wm_state_fullscreen; - - bool is_fullscreen; - void (*on_fullscreen_changed)(bool is_now_fullscreen); - - int keymap[256]; - bool (*on_key_down)(int scancode); - bool (*on_key_up)(int scancode); - void (*on_all_keys_up)(void); - - PFNGLXGETSYNCVALUESOMLPROC glXGetSyncValuesOML; - PFNGLXSWAPBUFFERSMSCOMLPROC glXSwapBuffersMscOML; - PFNGLXWAITFORSBCOMLPROC glXWaitForSbcOML; - - PFNGLXSWAPINTERVALEXTPROC glXSwapIntervalEXT; - PFNGLXSWAPINTERVALSGIPROC glXSwapIntervalSGI; - - PFNGLXGETVIDEOSYNCSGIPROC glXGetVideoSyncSGI; - PFNGLXWAITVIDEOSYNCSGIPROC glXWaitVideoSyncSGI; - - bool has_oml_sync_control; - uint64_t ust0; - int64_t last_msc; - uint64_t wanted_ust; // multiplied by FRAME_INTERVAL_US_DENOMINATOR - uint64_t vsync_interval; - uint64_t last_ust; - int64_t target_msc; - bool dropped_frame; - - bool has_sgi_video_sync; - uint64_t last_sync_counter; - int64_t this_msc; - int64_t this_ust; -} glx; - -static int64_t get_time(void) { - struct timespec ts; - clock_gettime(CLOCK_MONOTONIC, &ts); - return (int64_t)ts.tv_sec * 1000000 + ts.tv_nsec / 1000; -} - -static int64_t adjust_sync_counter(uint32_t counter) { - uint32_t hi = glx.last_sync_counter >> 32; - uint32_t lo = (uint32_t)glx.last_sync_counter; - if (lo >= 0x80000000U && counter < 0x80000000U) { - // Wrapped - ++hi; - } - glx.last_sync_counter = ((uint64_t)hi << 32) | counter; - return glx.last_sync_counter; -} - -static int64_t glXWaitVideoSyncSGI_wrapper(void) { - unsigned int counter = 0; - glx.glXWaitVideoSyncSGI(1, 0, &counter); - return adjust_sync_counter(counter); -} - -static int64_t glXGetVideoSyncSGI_wrapper(void) { - unsigned int counter = 0; - glx.glXGetVideoSyncSGI(&counter); - return adjust_sync_counter(counter); -} - -static void init_keymap(void) { - XkbDescPtr desc = XkbGetMap(glx.dpy, 0, XkbUseCoreKbd); - XkbGetNames(glx.dpy, XkbKeyNamesMask, desc); - - for (int i = desc->min_key_code; i <= desc->max_key_code && i < 256; i++) { - char name[XkbKeyNameLength + 1]; - memcpy(name, desc->names->keys[i].name, XkbKeyNameLength); - name[XkbKeyNameLength] = '\0'; - for (size_t j = 0; j < sizeof(keymap_name_to_scancode) / sizeof(keymap_name_to_scancode[0]); j++) { - if (strcmp(keymap_name_to_scancode[j].name, name) == 0) { - glx.keymap[i] = keymap_name_to_scancode[j].scancode; - break; - } - } - } - - XkbFreeNames(desc, XkbKeyNamesMask, True); - XkbFreeKeyboard(desc, 0, True); -} - -static void gfx_glx_hide_mouse(bool hide) { - // Removes distracting mouse cursor during fullscreen play - if (hide) { - Cursor hideCursor; - Pixmap bitmapNoData; - XColor black; - static char noData[] = { 0,0,0,0,0,0,0,0 }; - black.red = black.green = black.blue = 0; - - bitmapNoData = XCreateBitmapFromData(glx.dpy, glx.win, noData, 8, 8); - hideCursor = XCreatePixmapCursor(glx.dpy, bitmapNoData, bitmapNoData, - &black, &black, 0, 0); - XDefineCursor(glx.dpy, glx.win, hideCursor); - XSync(glx.dpy, False); - XFreeCursor(glx.dpy, hideCursor); - XFreePixmap(glx.dpy, bitmapNoData); - } else { - XUndefineCursor(glx.dpy, glx.win); - XSync(glx.dpy, False); - } - -} - -static void gfx_glx_set_fullscreen_state(bool on, bool call_callback) { - if (glx.is_fullscreen == on) { - return; - } - glx.is_fullscreen = on; - - XEvent xev; - xev.xany.type = ClientMessage; - xev.xclient.message_type = glx.atom_wm_state; - xev.xclient.format = 32; - xev.xclient.window = glx.win; - xev.xclient.data.l[0] = on; - xev.xclient.data.l[1] = glx.atom_wm_state_fullscreen; - xev.xclient.data.l[2] = 0; - xev.xclient.data.l[3] = 0; - XSendEvent(glx.dpy, glx.root, 0, SubstructureNotifyMask | SubstructureRedirectMask, &xev); - gfx_glx_hide_mouse(on); - - if (glx.on_fullscreen_changed != NULL && call_callback) { - glx.on_fullscreen_changed(on); - } -} - -static bool gfx_glx_check_extension(const char *extensions, const char *extension) { - size_t len = strlen(extension); - const char *pos = extensions; - while ((pos = strstr(pos, extension)) != NULL) { - if ((pos[len] == ' ' || pos[len] == '\0') && (pos == extensions || pos[-1] == ' ')) { - return true; - } - if (pos[len] == '\0') { - break; - } - pos += len + 1; - } - return false; -} - -static void gfx_glx_init(const char *game_name, bool start_in_fullscreen) { - // On NVIDIA proprietary driver, make the driver queue up to two frames on glXSwapBuffers, - // which means that glXSwapBuffers should be non-blocking, - // if we are sure to wait at least one vsync interval between calls. - setenv("__GL_MaxFramesAllowed", "2", true); - - glx.dpy = XOpenDisplay(NULL); - if (glx.dpy == NULL) { - fprintf(stderr, "Cannot connect to X server\n"); - exit(1); - } - int screen = DefaultScreen(glx.dpy); - glx.root = RootWindow(glx.dpy, screen); - - GLint att[] = { GLX_RGBA, GLX_DEPTH_SIZE, 24, GLX_DOUBLEBUFFER, None }; - XVisualInfo *vi = glXChooseVisual(glx.dpy, 0, att); - if (vi == NULL) { - fprintf(stderr, "No appropriate GLX visual found\n"); - exit(1); - } - Colormap cmap = XCreateColormap(glx.dpy, glx.root, vi->visual, AllocNone); - XSetWindowAttributes swa; - swa.colormap = cmap; - swa.event_mask = ExposureMask | KeyPressMask | KeyReleaseMask | FocusChangeMask; - glx.win = XCreateWindow(glx.dpy, glx.root, 0, 0, DESIRED_SCREEN_WIDTH, DESIRED_SCREEN_HEIGHT, 0, vi->depth, InputOutput, vi->visual, CWColormap | CWEventMask, &swa); - - glx.atom_wm_state = XInternAtom(glx.dpy, "_NET_WM_STATE", False); - glx.atom_wm_state_fullscreen = XInternAtom(glx.dpy, "_NET_WM_STATE_FULLSCREEN", False); - XMapWindow(glx.dpy, glx.win); - - if (start_in_fullscreen) { - gfx_glx_set_fullscreen_state(true, false); - } - - char title[512]; - int len = sprintf(title, "%s (%s)", game_name, GFX_API_NAME); - - XStoreName(glx.dpy, glx.win, title); - GLXContext glc = glXCreateContext(glx.dpy, vi, NULL, GL_TRUE); - glXMakeCurrent(glx.dpy, glx.win, glc); - - init_keymap(); - - const char *extensions = glXQueryExtensionsString(glx.dpy, screen); - - if (gfx_glx_check_extension(extensions, "GLX_OML_sync_control")) { - glx.glXGetSyncValuesOML = (PFNGLXGETSYNCVALUESOMLPROC)glXGetProcAddressARB((const GLubyte *)"glXGetSyncValuesOML"); - glx.glXSwapBuffersMscOML = (PFNGLXSWAPBUFFERSMSCOMLPROC)glXGetProcAddressARB((const GLubyte *)"glXSwapBuffersMscOML"); - glx.glXWaitForSbcOML = (PFNGLXWAITFORSBCOMLPROC)glXGetProcAddressARB((const GLubyte *)"glXWaitForSbcOML"); - } - if (gfx_glx_check_extension(extensions, "GLX_EXT_swap_control")) { - glx.glXSwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)glXGetProcAddressARB((const GLubyte *)"glXSwapIntervalEXT"); - } - if (gfx_glx_check_extension(extensions, "GLX_SGI_swap_control")) { - glx.glXSwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC)glXGetProcAddressARB((const GLubyte *)"glXSwapIntervalSGI"); - } - if (gfx_glx_check_extension(extensions, "GLX_SGI_video_sync")) { - glx.glXGetVideoSyncSGI = (PFNGLXGETVIDEOSYNCSGIPROC)glXGetProcAddressARB((const GLubyte *)"glXGetVideoSyncSGI"); - glx.glXWaitVideoSyncSGI = (PFNGLXWAITVIDEOSYNCSGIPROC)glXGetProcAddressARB((const GLubyte *)"glXWaitVideoSyncSGI"); - } - - int64_t ust, msc, sbc; - if (glx.glXGetSyncValuesOML != NULL && glx.glXGetSyncValuesOML(glx.dpy, glx.win, &ust, &msc, &sbc)) { - glx.has_oml_sync_control = true; - glx.ust0 = (uint64_t)ust; - } else { - glx.ust0 = get_time(); - if (glx.glXSwapIntervalEXT != NULL) { - glx.glXSwapIntervalEXT(glx.dpy, glx.win, 1); - } else if (glx.glXSwapIntervalSGI != NULL) { - glx.glXSwapIntervalSGI(1); - } - if (glx.glXGetVideoSyncSGI != NULL) { - // Try if it really works - unsigned int count; - if (glx.glXGetVideoSyncSGI(&count) == 0) { - glx.last_sync_counter = count; - glx.has_sgi_video_sync = true; - } - } - } - glx.vsync_interval = 16666; -} - -static void gfx_glx_set_fullscreen_changed_callback(void (*on_fullscreen_changed)(bool is_now_fullscreen)) { - glx.on_fullscreen_changed = on_fullscreen_changed; -} - -static void gfx_glx_set_fullscreen(bool enable) { - gfx_glx_set_fullscreen_state(enable, true); -} - -static void gfx_glx_set_keyboard_callbacks(bool (*on_key_down)(int scancode), bool (*on_key_up)(int scancode), void (*on_all_keys_up)(void)) { - glx.on_key_down = on_key_down; - glx.on_key_up = on_key_up; - glx.on_all_keys_up = on_all_keys_up; -} - -static void gfx_glx_main_loop(void (*run_one_game_iter)(void)) { - while (1) { - run_one_game_iter(); - } -} - -static void gfx_glx_get_dimensions(uint32_t *width, uint32_t *height) { - XWindowAttributes attributes; - XGetWindowAttributes(glx.dpy, glx.win, &attributes); - *width = attributes.width; - *height = attributes.height; -} - -static void gfx_glx_handle_events(void) { - Atom wm_delete_window = XInternAtom(glx.dpy, "WM_DELETE_WINDOW", 0); - XSetWMProtocols(glx.dpy, glx.win, & wm_delete_window, 1); - while (XPending(glx.dpy)) { - XEvent xev; - XNextEvent(glx.dpy, &xev); - if (xev.type == FocusOut) { - if (glx.on_all_keys_up != NULL) { - glx.on_all_keys_up(); - } - } - if (xev.type == KeyPress || xev.type == KeyRelease) { - if (xev.xkey.keycode < 256) { - int scancode = glx.keymap[xev.xkey.keycode]; - if (scancode != 0) { - if (xev.type == KeyPress) { - if (scancode == 0x44) { // F10 - gfx_glx_set_fullscreen_state(!glx.is_fullscreen, true); - } - if (glx.on_key_down != NULL) { - glx.on_key_down(scancode); - } - } else { - if (glx.on_key_up != NULL) { - glx.on_key_up(scancode); - } - } - } - } - } - if (xev.type == ClientMessage) { - if (xev.xclient.data.l[0] == wm_delete_window) { - exit(0); - } - } - } -} - -static bool gfx_glx_start_frame(void) { - return true; -} - -static void gfx_glx_swap_buffers_begin(void) { - glx.wanted_ust += FRAME_INTERVAL_US_NUMERATOR; // advance 1/30 seconds on JP/US or 1/25 seconds on EU - - if (!glx.has_oml_sync_control && !glx.has_sgi_video_sync) { - glFlush(); - - uint64_t target = glx.wanted_ust / FRAME_INTERVAL_US_DENOMINATOR; - uint64_t now; - while (target > (now = (uint64_t)get_time() - glx.ust0)) { - struct timespec ts = {(target - now) / 1000000, ((target - now) % 1000000) * 1000}; - if (nanosleep(&ts, NULL) == 0) { - break; - } - } - - if (target + 2 * FRAME_INTERVAL_US_NUMERATOR / FRAME_INTERVAL_US_DENOMINATOR < now) { - if (target + 32 * FRAME_INTERVAL_US_NUMERATOR / FRAME_INTERVAL_US_DENOMINATOR >= now) { - printf("Dropping frame\n"); - glx.dropped_frame = true; - return; - } else { - // Reset timer since we are way out of sync - glx.wanted_ust = now * FRAME_INTERVAL_US_DENOMINATOR; - } - } - glXSwapBuffers(glx.dpy, glx.win); - glx.dropped_frame = false; - - return; - } - - double vsyncs_to_wait = (int64_t)(glx.wanted_ust / FRAME_INTERVAL_US_DENOMINATOR - glx.last_ust) / (double)glx.vsync_interval; - if (vsyncs_to_wait <= 0) { - printf("Dropping frame\n"); - // Drop frame - glx.dropped_frame = true; - return; - } - if (floor(vsyncs_to_wait) != vsyncs_to_wait) { - uint64_t left_ust = glx.last_ust + floor(vsyncs_to_wait) * glx.vsync_interval; - uint64_t right_ust = glx.last_ust + ceil(vsyncs_to_wait) * glx.vsync_interval; - uint64_t adjusted_wanted_ust = glx.wanted_ust / FRAME_INTERVAL_US_DENOMINATOR + (glx.last_ust + FRAME_INTERVAL_US_NUMERATOR / FRAME_INTERVAL_US_DENOMINATOR > glx.wanted_ust / FRAME_INTERVAL_US_DENOMINATOR ? 2000 : -2000); - int64_t diff_left = adjusted_wanted_ust - left_ust; - int64_t diff_right = right_ust - adjusted_wanted_ust; - if (diff_left < 0) { - diff_left = -diff_left; - } - if (diff_right < 0) { - diff_right = -diff_right; - } - if (diff_left < diff_right) { - vsyncs_to_wait = floor(vsyncs_to_wait); - } else { - vsyncs_to_wait = ceil(vsyncs_to_wait); - } - if (vsyncs_to_wait <= -4) { - printf("vsyncs_to_wait became -4 or less so dropping frame\n"); - glx.dropped_frame = true; - return; - } else if (vsyncs_to_wait < 1) { - vsyncs_to_wait = 1; - } - } - glx.dropped_frame = false; - //printf("Vsyncs to wait: %d, diff: %d\n", (int)vsyncs_to_wait, (int)(glx.last_ust + (int64_t)vsyncs_to_wait * glx.vsync_interval - glx.wanted_ust / 3)); - if (vsyncs_to_wait > 30) { - // Unreasonable, so change to 2 - vsyncs_to_wait = 2; - } - glx.target_msc = glx.last_msc + vsyncs_to_wait; - - if (glx.has_oml_sync_control) { - glx.glXSwapBuffersMscOML(glx.dpy, glx.win, glx.target_msc, 0, 0); - } else if (glx.has_sgi_video_sync) { - glFlush(); // Try to submit pending work. Don't use glFinish since that busy loops on NVIDIA proprietary driver. - - //uint64_t counter0; - uint64_t counter1, counter2; - - //uint64_t before_wait = get_time(); - - counter1 = glXGetVideoSyncSGI_wrapper(); - //counter0 = counter1; - //int waits = 0; - while (counter1 < (uint64_t)glx.target_msc - 1) { - counter1 = glXWaitVideoSyncSGI_wrapper(); - //++waits; - } - - //uint64_t before = get_time(); - glXSwapBuffers(glx.dpy, glx.win); - - - counter2 = glXGetVideoSyncSGI_wrapper(); - while (counter2 < (uint64_t)glx.target_msc) { - counter2 = glXWaitVideoSyncSGI_wrapper(); - } - uint64_t after = get_time(); - - //printf("%.3f %.3f %.3f\t%.3f\t%u %d %.2f %u %d\n", before_wait * 0.000060, before * 0.000060, after * 0.000060, (after - before) * 0.000060, counter0, counter2 - counter0, vsyncs_to_wait, (unsigned int)glx.target_msc, waits); - glx.this_msc = counter2; - glx.this_ust = after; - } -} - -static void gfx_glx_swap_buffers_end(void) { - if (glx.dropped_frame || (!glx.has_oml_sync_control && !glx.has_sgi_video_sync)) { - return; - } - - int64_t ust, msc, sbc; - if (glx.has_oml_sync_control) { - if (!glx.glXWaitForSbcOML(glx.dpy, glx.win, 0, &ust, &msc, &sbc)) { - // X connection broke or something? - glx.last_ust += (glx.target_msc - glx.last_msc) * glx.vsync_interval; - glx.last_msc = glx.target_msc; - return; - } - } else { - ust = glx.this_ust; - msc = glx.this_msc; - } - uint64_t this_ust = ust - glx.ust0; - uint64_t vsyncs_passed = msc - glx.last_msc; - bool bad_vsync_interval = false; - if (glx.last_ust != 0 && vsyncs_passed != 0) { - uint64_t new_vsync_interval = (this_ust - glx.last_ust) / vsyncs_passed; - if (new_vsync_interval <= 500000) { - // Should be less than 0.5 seconds to be trusted - glx.vsync_interval = new_vsync_interval; - } else { - bad_vsync_interval = true; - } - //printf("glx.vsync_interval: %d\n", (int)glx.vsync_interval); - } - glx.last_ust = this_ust; - glx.last_msc = msc; - if (msc != glx.target_msc) { - printf("Frame too late by %d vsyncs\n", (int)(msc - glx.target_msc)); - } - if (msc - glx.target_msc >= 8 || bad_vsync_interval) { - // Frame arrived way too late, so reset timer from here - printf("Reseting timer\n"); - glx.wanted_ust = this_ust * FRAME_INTERVAL_US_DENOMINATOR; - } -} - -static double gfx_glx_get_time(void) { - return 0.0; -} - -struct GfxWindowManagerAPI gfx_glx = { - gfx_glx_init, - gfx_glx_set_keyboard_callbacks, - gfx_glx_set_fullscreen_changed_callback, - gfx_glx_set_fullscreen, - gfx_glx_main_loop, - gfx_glx_get_dimensions, - gfx_glx_handle_events, - gfx_glx_start_frame, - gfx_glx_swap_buffers_begin, - gfx_glx_swap_buffers_end, - gfx_glx_get_time -}; - -#endif diff --git a/src/decomp/pc/gfx/gfx_glx.h b/src/decomp/pc/gfx/gfx_glx.h deleted file mode 100644 index 1ca4109..0000000 --- a/src/decomp/pc/gfx/gfx_glx.h +++ /dev/null @@ -1,8 +0,0 @@ -#ifndef GFX_GLX_H -#define GFX_GLX_H - -#include "gfx_window_manager_api.h" - -extern struct GfxWindowManagerAPI gfx_glx; - -#endif diff --git a/src/decomp/pc/gfx/gfx_opengl.c b/src/decomp/pc/gfx/gfx_opengl.c deleted file mode 100644 index 7bc9745..0000000 --- a/src/decomp/pc/gfx/gfx_opengl.c +++ /dev/null @@ -1,531 +0,0 @@ -#ifdef ENABLE_OPENGL - -#include -#include - -#ifndef _LANGUAGE_C -#define _LANGUAGE_C -#endif -#include - -#ifdef __MINGW32__ -#define FOR_WINDOWS 1 -#else -#define FOR_WINDOWS 0 -#endif - -#if FOR_WINDOWS -#include -#include "SDL.h" -#define GL_GLEXT_PROTOTYPES 1 -#include "SDL_opengl.h" -#else -#include -#define GL_GLEXT_PROTOTYPES 1 -#include -#endif - -#include "gfx_cc.h" -#include "gfx_rendering_api.h" - -struct ShaderProgram { - uint32_t shader_id; - GLuint opengl_program_id; - uint8_t num_inputs; - bool used_textures[2]; - uint8_t num_floats; - GLint attrib_locations[7]; - uint8_t attrib_sizes[7]; - uint8_t num_attribs; - bool used_noise; - GLint frame_count_location; - GLint window_height_location; -}; - -static struct ShaderProgram shader_program_pool[64]; -static uint8_t shader_program_pool_size; -static GLuint opengl_vbo; - -static uint32_t frame_count; -static uint32_t current_height; - -static bool gfx_opengl_z_is_from_0_to_1(void) { - return false; -} - -static void gfx_opengl_vertex_array_set_attribs(struct ShaderProgram *prg) { - size_t num_floats = prg->num_floats; - size_t pos = 0; - - for (int i = 0; i < prg->num_attribs; i++) { - glEnableVertexAttribArray(prg->attrib_locations[i]); - glVertexAttribPointer(prg->attrib_locations[i], prg->attrib_sizes[i], GL_FLOAT, GL_FALSE, num_floats * sizeof(float), (void *) (pos * sizeof(float))); - pos += prg->attrib_sizes[i]; - } -} - -static void gfx_opengl_set_uniforms(struct ShaderProgram *prg) { - if (prg->used_noise) { - glUniform1i(prg->frame_count_location, frame_count); - glUniform1i(prg->window_height_location, current_height); - } -} - -static void gfx_opengl_unload_shader(struct ShaderProgram *old_prg) { - if (old_prg != NULL) { - for (int i = 0; i < old_prg->num_attribs; i++) { - glDisableVertexAttribArray(old_prg->attrib_locations[i]); - } - } -} - -static void gfx_opengl_load_shader(struct ShaderProgram *new_prg) { - glUseProgram(new_prg->opengl_program_id); - gfx_opengl_vertex_array_set_attribs(new_prg); - gfx_opengl_set_uniforms(new_prg); -} - -static void append_str(char *buf, size_t *len, const char *str) { - while (*str != '\0') buf[(*len)++] = *str++; -} - -static void append_line(char *buf, size_t *len, const char *str) { - while (*str != '\0') buf[(*len)++] = *str++; - buf[(*len)++] = '\n'; -} - -static const char *shader_item_to_str(uint32_t item, bool with_alpha, bool only_alpha, bool inputs_have_alpha, bool hint_single_element) { - if (!only_alpha) { - switch (item) { - case SHADER_0: - return with_alpha ? "vec4(0.0, 0.0, 0.0, 0.0)" : "vec3(0.0, 0.0, 0.0)"; - case SHADER_INPUT_1: - return with_alpha || !inputs_have_alpha ? "vInput1" : "vInput1.rgb"; - case SHADER_INPUT_2: - return with_alpha || !inputs_have_alpha ? "vInput2" : "vInput2.rgb"; - case SHADER_INPUT_3: - return with_alpha || !inputs_have_alpha ? "vInput3" : "vInput3.rgb"; - case SHADER_INPUT_4: - return with_alpha || !inputs_have_alpha ? "vInput4" : "vInput4.rgb"; - case SHADER_TEXEL0: - return with_alpha ? "texVal0" : "texVal0.rgb"; - case SHADER_TEXEL0A: - return hint_single_element ? "texVal0.a" : - (with_alpha ? "vec4(texVal0.a, texVal0.a, texVal0.a, texVal0.a)" : "vec3(texVal0.a, texVal0.a, texVal0.a)"); - case SHADER_TEXEL1: - return with_alpha ? "texVal1" : "texVal1.rgb"; - } - } else { - switch (item) { - case SHADER_0: - return "0.0"; - case SHADER_INPUT_1: - return "vInput1.a"; - case SHADER_INPUT_2: - return "vInput2.a"; - case SHADER_INPUT_3: - return "vInput3.a"; - case SHADER_INPUT_4: - return "vInput4.a"; - case SHADER_TEXEL0: - return "texVal0.a"; - case SHADER_TEXEL0A: - return "texVal0.a"; - case SHADER_TEXEL1: - return "texVal1.a"; - } - } -} - -static void append_formula(char *buf, size_t *len, uint8_t c[2][4], bool do_single, bool do_multiply, bool do_mix, bool with_alpha, bool only_alpha, bool opt_alpha) { - if (do_single) { - append_str(buf, len, shader_item_to_str(c[only_alpha][3], with_alpha, only_alpha, opt_alpha, false)); - } else if (do_multiply) { - append_str(buf, len, shader_item_to_str(c[only_alpha][0], with_alpha, only_alpha, opt_alpha, false)); - append_str(buf, len, " * "); - append_str(buf, len, shader_item_to_str(c[only_alpha][2], with_alpha, only_alpha, opt_alpha, true)); - } else if (do_mix) { - append_str(buf, len, "mix("); - append_str(buf, len, shader_item_to_str(c[only_alpha][1], with_alpha, only_alpha, opt_alpha, false)); - append_str(buf, len, ", "); - append_str(buf, len, shader_item_to_str(c[only_alpha][0], with_alpha, only_alpha, opt_alpha, false)); - append_str(buf, len, ", "); - append_str(buf, len, shader_item_to_str(c[only_alpha][2], with_alpha, only_alpha, opt_alpha, true)); - append_str(buf, len, ")"); - } else { - append_str(buf, len, "("); - append_str(buf, len, shader_item_to_str(c[only_alpha][0], with_alpha, only_alpha, opt_alpha, false)); - append_str(buf, len, " - "); - append_str(buf, len, shader_item_to_str(c[only_alpha][1], with_alpha, only_alpha, opt_alpha, false)); - append_str(buf, len, ") * "); - append_str(buf, len, shader_item_to_str(c[only_alpha][2], with_alpha, only_alpha, opt_alpha, true)); - append_str(buf, len, " + "); - append_str(buf, len, shader_item_to_str(c[only_alpha][3], with_alpha, only_alpha, opt_alpha, false)); - } -} - -static struct ShaderProgram *gfx_opengl_create_and_load_new_shader(uint32_t shader_id) { - struct CCFeatures cc_features; - gfx_cc_get_features(shader_id, &cc_features); - - char vs_buf[1024]; - char fs_buf[1024]; - size_t vs_len = 0; - size_t fs_len = 0; - size_t num_floats = 4; - - // Vertex shader - append_line(vs_buf, &vs_len, "#version 110"); - append_line(vs_buf, &vs_len, "attribute vec4 aVtxPos;"); - if (cc_features.used_textures[0] || cc_features.used_textures[1]) { - append_line(vs_buf, &vs_len, "attribute vec2 aTexCoord;"); - append_line(vs_buf, &vs_len, "varying vec2 vTexCoord;"); - num_floats += 2; - } - if (cc_features.opt_fog) { - append_line(vs_buf, &vs_len, "attribute vec4 aFog;"); - append_line(vs_buf, &vs_len, "varying vec4 vFog;"); - num_floats += 4; - } - for (int i = 0; i < cc_features.num_inputs; i++) { - vs_len += sprintf(vs_buf + vs_len, "attribute vec%d aInput%d;\n", cc_features.opt_alpha ? 4 : 3, i + 1); - vs_len += sprintf(vs_buf + vs_len, "varying vec%d vInput%d;\n", cc_features.opt_alpha ? 4 : 3, i + 1); - num_floats += cc_features.opt_alpha ? 4 : 3; - } - append_line(vs_buf, &vs_len, "void main() {"); - if (cc_features.used_textures[0] || cc_features.used_textures[1]) { - append_line(vs_buf, &vs_len, "vTexCoord = aTexCoord;"); - } - if (cc_features.opt_fog) { - append_line(vs_buf, &vs_len, "vFog = aFog;"); - } - for (int i = 0; i < cc_features.num_inputs; i++) { - vs_len += sprintf(vs_buf + vs_len, "vInput%d = aInput%d;\n", i + 1, i + 1); - } - append_line(vs_buf, &vs_len, "gl_Position = aVtxPos;"); - append_line(vs_buf, &vs_len, "}"); - - // Fragment shader - append_line(fs_buf, &fs_len, "#version 110"); - //append_line(fs_buf, &fs_len, "precision mediump float;"); - if (cc_features.used_textures[0] || cc_features.used_textures[1]) { - append_line(fs_buf, &fs_len, "varying vec2 vTexCoord;"); - } - if (cc_features.opt_fog) { - append_line(fs_buf, &fs_len, "varying vec4 vFog;"); - } - for (int i = 0; i < cc_features.num_inputs; i++) { - fs_len += sprintf(fs_buf + fs_len, "varying vec%d vInput%d;\n", cc_features.opt_alpha ? 4 : 3, i + 1); - } - if (cc_features.used_textures[0]) { - append_line(fs_buf, &fs_len, "uniform sampler2D uTex0;"); - } - if (cc_features.used_textures[1]) { - append_line(fs_buf, &fs_len, "uniform sampler2D uTex1;"); - } - - if (cc_features.opt_alpha && cc_features.opt_noise) { - append_line(fs_buf, &fs_len, "uniform int frame_count;"); - append_line(fs_buf, &fs_len, "uniform int window_height;"); - - append_line(fs_buf, &fs_len, "float random(in vec3 value) {"); - append_line(fs_buf, &fs_len, " float random = dot(sin(value), vec3(12.9898, 78.233, 37.719));"); - append_line(fs_buf, &fs_len, " return fract(sin(random) * 143758.5453);"); - append_line(fs_buf, &fs_len, "}"); - } - - append_line(fs_buf, &fs_len, "void main() {"); - - if (cc_features.used_textures[0]) { - append_line(fs_buf, &fs_len, "vec4 texVal0 = texture2D(uTex0, vTexCoord);"); - } - if (cc_features.used_textures[1]) { - append_line(fs_buf, &fs_len, "vec4 texVal1 = texture2D(uTex1, vTexCoord);"); - } - - append_str(fs_buf, &fs_len, cc_features.opt_alpha ? "vec4 texel = " : "vec3 texel = "); - if (!cc_features.color_alpha_same && cc_features.opt_alpha) { - append_str(fs_buf, &fs_len, "vec4("); - append_formula(fs_buf, &fs_len, cc_features.c, cc_features.do_single[0], cc_features.do_multiply[0], cc_features.do_mix[0], false, false, true); - append_str(fs_buf, &fs_len, ", "); - append_formula(fs_buf, &fs_len, cc_features.c, cc_features.do_single[1], cc_features.do_multiply[1], cc_features.do_mix[1], true, true, true); - append_str(fs_buf, &fs_len, ")"); - } else { - append_formula(fs_buf, &fs_len, cc_features.c, cc_features.do_single[0], cc_features.do_multiply[0], cc_features.do_mix[0], cc_features.opt_alpha, false, cc_features.opt_alpha); - } - append_line(fs_buf, &fs_len, ";"); - - if (cc_features.opt_texture_edge && cc_features.opt_alpha) { - append_line(fs_buf, &fs_len, "if (texel.a > 0.3) texel.a = 1.0; else discard;"); - } - // TODO discard if alpha is 0? - if (cc_features.opt_fog) { - if (cc_features.opt_alpha) { - append_line(fs_buf, &fs_len, "texel = vec4(mix(texel.rgb, vFog.rgb, vFog.a), texel.a);"); - } else { - append_line(fs_buf, &fs_len, "texel = mix(texel, vFog.rgb, vFog.a);"); - } - } - - if (cc_features.opt_alpha && cc_features.opt_noise) { - append_line(fs_buf, &fs_len, "texel.a *= floor(random(vec3(floor(gl_FragCoord.xy * (240.0 / float(window_height))), float(frame_count))) + 0.5);"); - } - - if (cc_features.opt_alpha) { - append_line(fs_buf, &fs_len, "gl_FragColor = texel;"); - } else { - append_line(fs_buf, &fs_len, "gl_FragColor = vec4(texel, 1.0);"); - } - append_line(fs_buf, &fs_len, "}"); - - vs_buf[vs_len] = '\0'; - fs_buf[fs_len] = '\0'; - - /*puts("Vertex shader:"); - puts(vs_buf); - puts("Fragment shader:"); - puts(fs_buf); - puts("End");*/ - - const GLchar *sources[2] = { vs_buf, fs_buf }; - const GLint lengths[2] = { vs_len, fs_len }; - GLint success; - - GLuint vertex_shader = glCreateShader(GL_VERTEX_SHADER); - glShaderSource(vertex_shader, 1, &sources[0], &lengths[0]); - glCompileShader(vertex_shader); - glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &success); - if (!success) { - GLint max_length = 0; - glGetShaderiv(vertex_shader, GL_INFO_LOG_LENGTH, &max_length); - char error_log[1024]; - fprintf(stderr, "Vertex shader compilation failed\n"); - glGetShaderInfoLog(vertex_shader, max_length, &max_length, &error_log[0]); - fprintf(stderr, "%s\n", &error_log[0]); - abort(); - } - - GLuint fragment_shader = glCreateShader(GL_FRAGMENT_SHADER); - glShaderSource(fragment_shader, 1, &sources[1], &lengths[1]); - glCompileShader(fragment_shader); - glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &success); - if (!success) { - GLint max_length = 0; - glGetShaderiv(fragment_shader, GL_INFO_LOG_LENGTH, &max_length); - char error_log[1024]; - fprintf(stderr, "Fragment shader compilation failed\n"); - glGetShaderInfoLog(fragment_shader, max_length, &max_length, &error_log[0]); - fprintf(stderr, "%s\n", &error_log[0]); - abort(); - } - - GLuint shader_program = glCreateProgram(); - glAttachShader(shader_program, vertex_shader); - glAttachShader(shader_program, fragment_shader); - glLinkProgram(shader_program); - - size_t cnt = 0; - - struct ShaderProgram *prg = &shader_program_pool[shader_program_pool_size++]; - prg->attrib_locations[cnt] = glGetAttribLocation(shader_program, "aVtxPos"); - prg->attrib_sizes[cnt] = 4; - ++cnt; - - if (cc_features.used_textures[0] || cc_features.used_textures[1]) { - prg->attrib_locations[cnt] = glGetAttribLocation(shader_program, "aTexCoord"); - prg->attrib_sizes[cnt] = 2; - ++cnt; - } - - if (cc_features.opt_fog) { - prg->attrib_locations[cnt] = glGetAttribLocation(shader_program, "aFog"); - prg->attrib_sizes[cnt] = 4; - ++cnt; - } - - for (int i = 0; i < cc_features.num_inputs; i++) { - char name[16]; - sprintf(name, "aInput%d", i + 1); - prg->attrib_locations[cnt] = glGetAttribLocation(shader_program, name); - prg->attrib_sizes[cnt] = cc_features.opt_alpha ? 4 : 3; - ++cnt; - } - - prg->shader_id = shader_id; - prg->opengl_program_id = shader_program; - prg->num_inputs = cc_features.num_inputs; - prg->used_textures[0] = cc_features.used_textures[0]; - prg->used_textures[1] = cc_features.used_textures[1]; - prg->num_floats = num_floats; - prg->num_attribs = cnt; - - gfx_opengl_load_shader(prg); - - if (cc_features.used_textures[0]) { - GLint sampler_location = glGetUniformLocation(shader_program, "uTex0"); - glUniform1i(sampler_location, 0); - } - if (cc_features.used_textures[1]) { - GLint sampler_location = glGetUniformLocation(shader_program, "uTex1"); - glUniform1i(sampler_location, 1); - } - - if (cc_features.opt_alpha && cc_features.opt_noise) { - prg->frame_count_location = glGetUniformLocation(shader_program, "frame_count"); - prg->window_height_location = glGetUniformLocation(shader_program, "window_height"); - prg->used_noise = true; - } else { - prg->used_noise = false; - } - - return prg; -} - -static struct ShaderProgram *gfx_opengl_lookup_shader(uint32_t shader_id) { - for (size_t i = 0; i < shader_program_pool_size; i++) { - if (shader_program_pool[i].shader_id == shader_id) { - return &shader_program_pool[i]; - } - } - return NULL; -} - -static void gfx_opengl_shader_get_info(struct ShaderProgram *prg, uint8_t *num_inputs, bool used_textures[2]) { - *num_inputs = prg->num_inputs; - used_textures[0] = prg->used_textures[0]; - used_textures[1] = prg->used_textures[1]; -} - -static GLuint gfx_opengl_new_texture(void) { - GLuint ret; - glGenTextures(1, &ret); - return ret; -} - -static void gfx_opengl_select_texture(int tile, GLuint texture_id) { - glActiveTexture(GL_TEXTURE0 + tile); - glBindTexture(GL_TEXTURE_2D, texture_id); -} - -static void gfx_opengl_upload_texture(const uint8_t *rgba32_buf, int width, int height) { - glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, rgba32_buf); -} - -static uint32_t gfx_cm_to_opengl(uint32_t val) { - if (val & G_TX_CLAMP) { - return GL_CLAMP_TO_EDGE; - } - return (val & G_TX_MIRROR) ? GL_MIRRORED_REPEAT : GL_REPEAT; -} - -static void gfx_opengl_set_sampler_parameters(int tile, bool linear_filter, uint32_t cms, uint32_t cmt) { - glActiveTexture(GL_TEXTURE0 + tile); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, linear_filter ? GL_LINEAR : GL_NEAREST); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, linear_filter ? GL_LINEAR : GL_NEAREST); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, gfx_cm_to_opengl(cms)); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, gfx_cm_to_opengl(cmt)); -} - -static void gfx_opengl_set_depth_test(bool depth_test) { - if (depth_test) { - glEnable(GL_DEPTH_TEST); - } else { - glDisable(GL_DEPTH_TEST); - } -} - -static void gfx_opengl_set_depth_mask(bool z_upd) { - glDepthMask(z_upd ? GL_TRUE : GL_FALSE); -} - -static void gfx_opengl_set_zmode_decal(bool zmode_decal) { - if (zmode_decal) { - glPolygonOffset(-2, -2); - glEnable(GL_POLYGON_OFFSET_FILL); - } else { - glPolygonOffset(0, 0); - glDisable(GL_POLYGON_OFFSET_FILL); - } -} - -static void gfx_opengl_set_viewport(int x, int y, int width, int height) { - glViewport(x, y, width, height); - current_height = height; -} - -static void gfx_opengl_set_scissor(int x, int y, int width, int height) { - glScissor(x, y, width, height); -} - -static void gfx_opengl_set_use_alpha(bool use_alpha) { - if (use_alpha) { - glEnable(GL_BLEND); - } else { - glDisable(GL_BLEND); - } -} - -static void gfx_opengl_draw_triangles(float buf_vbo[], size_t buf_vbo_len, size_t buf_vbo_num_tris) { - //printf("flushing %d tris\n", buf_vbo_num_tris); - glBufferData(GL_ARRAY_BUFFER, sizeof(float) * buf_vbo_len, buf_vbo, GL_STREAM_DRAW); - glDrawArrays(GL_TRIANGLES, 0, 3 * buf_vbo_num_tris); -} - -static void gfx_opengl_init(void) { -#if FOR_WINDOWS - glewInit(); -#endif - - glGenBuffers(1, &opengl_vbo); - - glBindBuffer(GL_ARRAY_BUFFER, opengl_vbo); - - glDepthFunc(GL_LEQUAL); - glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); -} - -static void gfx_opengl_on_resize(void) { -} - -static void gfx_opengl_start_frame(void) { - frame_count++; - - glDisable(GL_SCISSOR_TEST); - glDepthMask(GL_TRUE); // Must be set to clear Z-buffer - glClearColor(0.0f, 0.0f, 0.0f, 1.0f); - glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); - glEnable(GL_SCISSOR_TEST); -} - -static void gfx_opengl_end_frame(void) { -} - -static void gfx_opengl_finish_render(void) { -} - -struct GfxRenderingAPI gfx_opengl_api = { - gfx_opengl_z_is_from_0_to_1, - gfx_opengl_unload_shader, - gfx_opengl_load_shader, - gfx_opengl_create_and_load_new_shader, - gfx_opengl_lookup_shader, - gfx_opengl_shader_get_info, - gfx_opengl_new_texture, - gfx_opengl_select_texture, - gfx_opengl_upload_texture, - gfx_opengl_set_sampler_parameters, - gfx_opengl_set_depth_test, - gfx_opengl_set_depth_mask, - gfx_opengl_set_zmode_decal, - gfx_opengl_set_viewport, - gfx_opengl_set_scissor, - gfx_opengl_set_use_alpha, - gfx_opengl_draw_triangles, - gfx_opengl_init, - gfx_opengl_on_resize, - gfx_opengl_start_frame, - gfx_opengl_end_frame, - gfx_opengl_finish_render -}; - -#endif diff --git a/src/decomp/pc/gfx/gfx_opengl.h b/src/decomp/pc/gfx/gfx_opengl.h deleted file mode 100644 index 95be897..0000000 --- a/src/decomp/pc/gfx/gfx_opengl.h +++ /dev/null @@ -1,8 +0,0 @@ -#ifndef GFX_OPENGL_H -#define GFX_OPENGL_H - -#include "gfx_rendering_api.h" - -extern struct GfxRenderingAPI gfx_opengl_api; - -#endif diff --git a/src/decomp/pc/gfx/gfx_pc.c b/src/decomp/pc/gfx/gfx_pc.c deleted file mode 100644 index 15d7b94..0000000 --- a/src/decomp/pc/gfx/gfx_pc.c +++ /dev/null @@ -1,1691 +0,0 @@ -#include -#include -#include -#include -#include -#include - -#ifndef _LANGUAGE_C -#define _LANGUAGE_C -#endif -#include - -#include "gfx_pc.h" -#include "gfx_cc.h" -#include "gfx_window_manager_api.h" -#include "gfx_rendering_api.h" -#include "gfx_screen_config.h" - -#define SUPPORT_CHECK(x) assert(x) - -// SCALE_M_N: upscale/downscale M-bit integer to N-bit -#define SCALE_5_8(VAL_) (((VAL_) * 0xFF) / 0x1F) -#define SCALE_8_5(VAL_) ((((VAL_) + 4) * 0x1F) / 0xFF) -#define SCALE_4_8(VAL_) ((VAL_) * 0x11) -#define SCALE_8_4(VAL_) ((VAL_) / 0x11) -#define SCALE_3_8(VAL_) ((VAL_) * 0x24) -#define SCALE_8_3(VAL_) ((VAL_) / 0x24) - -#define SCREEN_WIDTH 320 -#define SCREEN_HEIGHT 240 -#define HALF_SCREEN_WIDTH (SCREEN_WIDTH / 2) -#define HALF_SCREEN_HEIGHT (SCREEN_HEIGHT / 2) - -#define RATIO_X (gfx_current_dimensions.width / (2.0f * HALF_SCREEN_WIDTH)) -#define RATIO_Y (gfx_current_dimensions.height / (2.0f * HALF_SCREEN_HEIGHT)) - -#define MAX_BUFFERED 256 -#define MAX_LIGHTS 2 -#define MAX_VERTICES 64 - -struct RGBA { - uint8_t r, g, b, a; -}; - -struct XYWidthHeight { - uint16_t x, y, width, height; -}; - -struct LoadedVertex { - float x, y, z, w; - float u, v; - struct RGBA color; - uint8_t clip_rej; -}; - -struct TextureHashmapNode { - struct TextureHashmapNode *next; - - const uint8_t *texture_addr; - uint8_t fmt, siz; - - uint32_t texture_id; - uint8_t cms, cmt; - bool linear_filter; -}; -static struct { - struct TextureHashmapNode *hashmap[1024]; - struct TextureHashmapNode pool[512]; - uint32_t pool_pos; -} gfx_texture_cache; - -struct ColorCombiner { - uint32_t cc_id; - struct ShaderProgram *prg; - uint8_t shader_input_mapping[2][4]; -}; - -static struct ColorCombiner color_combiner_pool[64]; -static uint8_t color_combiner_pool_size; - -static struct RSP { - float modelview_matrix_stack[11][4][4]; - uint8_t modelview_matrix_stack_size; - - float MP_matrix[4][4]; - float P_matrix[4][4]; - - Light_t current_lights[MAX_LIGHTS + 1]; - float current_lights_coeffs[MAX_LIGHTS][3]; - float current_lookat_coeffs[2][3]; // lookat_x, lookat_y - uint8_t current_num_lights; // includes ambient light - bool lights_changed; - - uint32_t geometry_mode; - int16_t fog_mul, fog_offset; - - struct { - // U0.16 - uint16_t s, t; - } texture_scaling_factor; - - struct LoadedVertex loaded_vertices[MAX_VERTICES + 4]; - - uint8_t saved_opcode; - uint8_t saved_tile; - uint16_t saved_uls, saved_ult; - int32_t saved_lrx, saved_lry, saved_ulx, saved_uly; -} rsp; - -static struct RDP { - const uint8_t *palette; - struct { - const uint8_t *addr; - uint8_t siz; - uint8_t tile_number; - } texture_to_load; - struct { - const uint8_t *addr; - uint32_t size_bytes; - } loaded_texture[2]; - struct { - uint8_t fmt; - uint8_t siz; - uint8_t cms, cmt; - uint16_t uls, ult, lrs, lrt; // U10.2 - uint32_t line_size_bytes; - } texture_tile; - bool textures_changed[2]; - - uint32_t other_mode_l, other_mode_h; - uint32_t combine_mode; - - struct RGBA env_color, prim_color, fog_color, fill_color; - struct XYWidthHeight viewport, scissor; - bool viewport_or_scissor_changed; - void *z_buf_address; - void *color_image_address; -} rdp; - -static struct RenderingState { - bool depth_test; - bool depth_mask; - bool decal_mode; - bool alpha_blend; - struct XYWidthHeight viewport, scissor; - struct ShaderProgram *shader_program; - struct TextureHashmapNode *textures[2]; -} rendering_state; - -struct GfxDimensions gfx_current_dimensions; - -static bool dropped_frame; - -static float buf_vbo[MAX_BUFFERED * (26 * 3)]; // 3 vertices in a triangle and 26 floats per vtx -static size_t buf_vbo_len; -static size_t buf_vbo_num_tris; - -static struct GfxWindowManagerAPI *gfx_wapi; -static struct GfxRenderingAPI *gfx_rapi; - -#include -static unsigned long get_time(void) { - struct timespec ts; - clock_gettime(CLOCK_MONOTONIC, &ts); - return (unsigned long)ts.tv_sec * 1000000 + ts.tv_nsec / 1000; -} - -static void gfx_flush(void) { - if (buf_vbo_len > 0) { - int num = buf_vbo_num_tris; - unsigned long t0 = get_time(); - gfx_rapi->draw_triangles(buf_vbo, buf_vbo_len, buf_vbo_num_tris); - buf_vbo_len = 0; - buf_vbo_num_tris = 0; - unsigned long t1 = get_time(); - /*if (t1 - t0 > 1000) { - printf("f: %d %d\n", num, (int)(t1 - t0)); - }*/ - } -} - -static struct ShaderProgram *gfx_lookup_or_create_shader_program(uint32_t shader_id) { - struct ShaderProgram *prg = gfx_rapi->lookup_shader(shader_id); - if (prg == NULL) { - gfx_rapi->unload_shader(rendering_state.shader_program); - prg = gfx_rapi->create_and_load_new_shader(shader_id); - rendering_state.shader_program = prg; - } - return prg; -} - -static void gfx_generate_cc(struct ColorCombiner *comb, uint32_t cc_id) { - uint8_t c[2][4]; - uint32_t shader_id = (cc_id >> 24) << 24; - uint8_t shader_input_mapping[2][4] = {{0}}; - for (int i = 0; i < 4; i++) { - c[0][i] = (cc_id >> (i * 3)) & 7; - c[1][i] = (cc_id >> (12 + i * 3)) & 7; - } - for (int i = 0; i < 2; i++) { - if (c[i][0] == c[i][1] || c[i][2] == CC_0) { - c[i][0] = c[i][1] = c[i][2] = 0; - } - uint8_t input_number[8] = {0}; - int next_input_number = SHADER_INPUT_1; - for (int j = 0; j < 4; j++) { - int val = 0; - switch (c[i][j]) { - case CC_0: - break; - case CC_TEXEL0: - val = SHADER_TEXEL0; - break; - case CC_TEXEL1: - val = SHADER_TEXEL1; - break; - case CC_TEXEL0A: - val = SHADER_TEXEL0A; - break; - case CC_PRIM: - case CC_SHADE: - case CC_ENV: - case CC_LOD: - if (input_number[c[i][j]] == 0) { - shader_input_mapping[i][next_input_number - 1] = c[i][j]; - input_number[c[i][j]] = next_input_number++; - } - val = input_number[c[i][j]]; - break; - } - shader_id |= val << (i * 12 + j * 3); - } - } - comb->cc_id = cc_id; - comb->prg = gfx_lookup_or_create_shader_program(shader_id); - memcpy(comb->shader_input_mapping, shader_input_mapping, sizeof(shader_input_mapping)); -} - -static struct ColorCombiner *gfx_lookup_or_create_color_combiner(uint32_t cc_id) { - static struct ColorCombiner *prev_combiner; - if (prev_combiner != NULL && prev_combiner->cc_id == cc_id) { - return prev_combiner; - } - - for (size_t i = 0; i < color_combiner_pool_size; i++) { - if (color_combiner_pool[i].cc_id == cc_id) { - return prev_combiner = &color_combiner_pool[i]; - } - } - gfx_flush(); - struct ColorCombiner *comb = &color_combiner_pool[color_combiner_pool_size++]; - gfx_generate_cc(comb, cc_id); - return prev_combiner = comb; -} - -static bool gfx_texture_cache_lookup(int tile, struct TextureHashmapNode **n, const uint8_t *orig_addr, uint32_t fmt, uint32_t siz) { - size_t hash = (uintptr_t)orig_addr; - hash = (hash >> 5) & 0x3ff; - struct TextureHashmapNode **node = &gfx_texture_cache.hashmap[hash]; - while (*node != NULL && *node - gfx_texture_cache.pool < (int)gfx_texture_cache.pool_pos) { - if ((*node)->texture_addr == orig_addr && (*node)->fmt == fmt && (*node)->siz == siz) { - gfx_rapi->select_texture(tile, (*node)->texture_id); - *n = *node; - return true; - } - node = &(*node)->next; - } - if (gfx_texture_cache.pool_pos == sizeof(gfx_texture_cache.pool) / sizeof(struct TextureHashmapNode)) { - // Pool is full. We just invalidate everything and start over. - gfx_texture_cache.pool_pos = 0; - node = &gfx_texture_cache.hashmap[hash]; - //puts("Clearing texture cache"); - } - *node = &gfx_texture_cache.pool[gfx_texture_cache.pool_pos++]; - if ((*node)->texture_addr == NULL) { - (*node)->texture_id = gfx_rapi->new_texture(); - } - gfx_rapi->select_texture(tile, (*node)->texture_id); - gfx_rapi->set_sampler_parameters(tile, false, 0, 0); - (*node)->cms = 0; - (*node)->cmt = 0; - (*node)->linear_filter = false; - (*node)->next = NULL; - (*node)->texture_addr = orig_addr; - (*node)->fmt = fmt; - (*node)->siz = siz; - *n = *node; - return false; -} - -static void import_texture_rgba16(int tile) { - uint8_t rgba32_buf[8192]; - - for (uint32_t i = 0; i < rdp.loaded_texture[tile].size_bytes / 2; i++) { - uint16_t col16 = (rdp.loaded_texture[tile].addr[2 * i] << 8) | rdp.loaded_texture[tile].addr[2 * i + 1]; - uint8_t a = col16 & 1; - uint8_t r = col16 >> 11; - uint8_t g = (col16 >> 6) & 0x1f; - uint8_t b = (col16 >> 1) & 0x1f; - rgba32_buf[4*i + 0] = SCALE_5_8(r); - rgba32_buf[4*i + 1] = SCALE_5_8(g); - rgba32_buf[4*i + 2] = SCALE_5_8(b); - rgba32_buf[4*i + 3] = a ? 255 : 0; - } - - uint32_t width = rdp.texture_tile.line_size_bytes / 2; - uint32_t height = rdp.loaded_texture[tile].size_bytes / rdp.texture_tile.line_size_bytes; - - gfx_rapi->upload_texture(rgba32_buf, width, height); -} - -static void import_texture_rgba32(int tile) { - uint32_t width = rdp.texture_tile.line_size_bytes / 2; - uint32_t height = (rdp.loaded_texture[tile].size_bytes / 2) / rdp.texture_tile.line_size_bytes; - gfx_rapi->upload_texture(rdp.loaded_texture[tile].addr, width, height); -} - -static void import_texture_ia4(int tile) { - uint8_t rgba32_buf[32768]; - - for (uint32_t i = 0; i < rdp.loaded_texture[tile].size_bytes * 2; i++) { - uint8_t byte = rdp.loaded_texture[tile].addr[i / 2]; - uint8_t part = (byte >> (4 - (i % 2) * 4)) & 0xf; - uint8_t intensity = part >> 1; - uint8_t alpha = part & 1; - uint8_t r = intensity; - uint8_t g = intensity; - uint8_t b = intensity; - rgba32_buf[4*i + 0] = SCALE_3_8(r); - rgba32_buf[4*i + 1] = SCALE_3_8(g); - rgba32_buf[4*i + 2] = SCALE_3_8(b); - rgba32_buf[4*i + 3] = alpha ? 255 : 0; - } - - uint32_t width = rdp.texture_tile.line_size_bytes * 2; - uint32_t height = rdp.loaded_texture[tile].size_bytes / rdp.texture_tile.line_size_bytes; - - gfx_rapi->upload_texture(rgba32_buf, width, height); -} - -static void import_texture_ia8(int tile) { - uint8_t rgba32_buf[16384]; - - for (uint32_t i = 0; i < rdp.loaded_texture[tile].size_bytes; i++) { - uint8_t intensity = rdp.loaded_texture[tile].addr[i] >> 4; - uint8_t alpha = rdp.loaded_texture[tile].addr[i] & 0xf; - uint8_t r = intensity; - uint8_t g = intensity; - uint8_t b = intensity; - rgba32_buf[4*i + 0] = SCALE_4_8(r); - rgba32_buf[4*i + 1] = SCALE_4_8(g); - rgba32_buf[4*i + 2] = SCALE_4_8(b); - rgba32_buf[4*i + 3] = SCALE_4_8(alpha); - } - - uint32_t width = rdp.texture_tile.line_size_bytes; - uint32_t height = rdp.loaded_texture[tile].size_bytes / rdp.texture_tile.line_size_bytes; - - gfx_rapi->upload_texture(rgba32_buf, width, height); -} - -static void import_texture_ia16(int tile) { - uint8_t rgba32_buf[8192]; - - for (uint32_t i = 0; i < rdp.loaded_texture[tile].size_bytes / 2; i++) { - uint8_t intensity = rdp.loaded_texture[tile].addr[2 * i]; - uint8_t alpha = rdp.loaded_texture[tile].addr[2 * i + 1]; - uint8_t r = intensity; - uint8_t g = intensity; - uint8_t b = intensity; - rgba32_buf[4*i + 0] = r; - rgba32_buf[4*i + 1] = g; - rgba32_buf[4*i + 2] = b; - rgba32_buf[4*i + 3] = alpha; - } - - uint32_t width = rdp.texture_tile.line_size_bytes / 2; - uint32_t height = rdp.loaded_texture[tile].size_bytes / rdp.texture_tile.line_size_bytes; - - gfx_rapi->upload_texture(rgba32_buf, width, height); -} - -static void import_texture_i4(int tile) { - uint8_t rgba32_buf[32768]; - - for (uint32_t i = 0; i < rdp.loaded_texture[tile].size_bytes * 2; i++) { - uint8_t byte = rdp.loaded_texture[tile].addr[i / 2]; - uint8_t part = (byte >> (4 - (i % 2) * 4)) & 0xf; - uint8_t intensity = part; - uint8_t r = intensity; - uint8_t g = intensity; - uint8_t b = intensity; - rgba32_buf[4*i + 0] = SCALE_4_8(r); - rgba32_buf[4*i + 1] = SCALE_4_8(g); - rgba32_buf[4*i + 2] = SCALE_4_8(b); - rgba32_buf[4*i + 3] = 255; - } - - uint32_t width = rdp.texture_tile.line_size_bytes * 2; - uint32_t height = rdp.loaded_texture[tile].size_bytes / rdp.texture_tile.line_size_bytes; - - gfx_rapi->upload_texture(rgba32_buf, width, height); -} - -static void import_texture_i8(int tile) { - uint8_t rgba32_buf[16384]; - - for (uint32_t i = 0; i < rdp.loaded_texture[tile].size_bytes; i++) { - uint8_t intensity = rdp.loaded_texture[tile].addr[i]; - uint8_t r = intensity; - uint8_t g = intensity; - uint8_t b = intensity; - rgba32_buf[4*i + 0] = r; - rgba32_buf[4*i + 1] = g; - rgba32_buf[4*i + 2] = b; - rgba32_buf[4*i + 3] = 255; - } - - uint32_t width = rdp.texture_tile.line_size_bytes; - uint32_t height = rdp.loaded_texture[tile].size_bytes / rdp.texture_tile.line_size_bytes; - - gfx_rapi->upload_texture(rgba32_buf, width, height); -} - - -static void import_texture_ci4(int tile) { - uint8_t rgba32_buf[32768]; - - for (uint32_t i = 0; i < rdp.loaded_texture[tile].size_bytes * 2; i++) { - uint8_t byte = rdp.loaded_texture[tile].addr[i / 2]; - uint8_t idx = (byte >> (4 - (i % 2) * 4)) & 0xf; - uint16_t col16 = (rdp.palette[idx * 2] << 8) | rdp.palette[idx * 2 + 1]; // Big endian load - uint8_t a = col16 & 1; - uint8_t r = col16 >> 11; - uint8_t g = (col16 >> 6) & 0x1f; - uint8_t b = (col16 >> 1) & 0x1f; - rgba32_buf[4*i + 0] = SCALE_5_8(r); - rgba32_buf[4*i + 1] = SCALE_5_8(g); - rgba32_buf[4*i + 2] = SCALE_5_8(b); - rgba32_buf[4*i + 3] = a ? 255 : 0; - } - - uint32_t width = rdp.texture_tile.line_size_bytes * 2; - uint32_t height = rdp.loaded_texture[tile].size_bytes / rdp.texture_tile.line_size_bytes; - - gfx_rapi->upload_texture(rgba32_buf, width, height); -} - -static void import_texture_ci8(int tile) { - uint8_t rgba32_buf[16384]; - - for (uint32_t i = 0; i < rdp.loaded_texture[tile].size_bytes; i++) { - uint8_t idx = rdp.loaded_texture[tile].addr[i]; - uint16_t col16 = (rdp.palette[idx * 2] << 8) | rdp.palette[idx * 2 + 1]; // Big endian load - uint8_t a = col16 & 1; - uint8_t r = col16 >> 11; - uint8_t g = (col16 >> 6) & 0x1f; - uint8_t b = (col16 >> 1) & 0x1f; - rgba32_buf[4*i + 0] = SCALE_5_8(r); - rgba32_buf[4*i + 1] = SCALE_5_8(g); - rgba32_buf[4*i + 2] = SCALE_5_8(b); - rgba32_buf[4*i + 3] = a ? 255 : 0; - } - - uint32_t width = rdp.texture_tile.line_size_bytes; - uint32_t height = rdp.loaded_texture[tile].size_bytes / rdp.texture_tile.line_size_bytes; - - gfx_rapi->upload_texture(rgba32_buf, width, height); -} - -static void import_texture(int tile) { - uint8_t fmt = rdp.texture_tile.fmt; - uint8_t siz = rdp.texture_tile.siz; - - if (gfx_texture_cache_lookup(tile, &rendering_state.textures[tile], rdp.loaded_texture[tile].addr, fmt, siz)) { - return; - } - - int t0 = get_time(); - if (fmt == G_IM_FMT_RGBA) { - if (siz == G_IM_SIZ_16b) { - import_texture_rgba16(tile); - } else if (siz == G_IM_SIZ_32b) { - import_texture_rgba32(tile); - } else { - abort(); - } - } else if (fmt == G_IM_FMT_IA) { - if (siz == G_IM_SIZ_4b) { - import_texture_ia4(tile); - } else if (siz == G_IM_SIZ_8b) { - import_texture_ia8(tile); - } else if (siz == G_IM_SIZ_16b) { - import_texture_ia16(tile); - } else { - abort(); - } - } else if (fmt == G_IM_FMT_CI) { - if (siz == G_IM_SIZ_4b) { - import_texture_ci4(tile); - } else if (siz == G_IM_SIZ_8b) { - import_texture_ci8(tile); - } else { - abort(); - } - } else if (fmt == G_IM_FMT_I) { - if (siz == G_IM_SIZ_4b) { - import_texture_i4(tile); - } else if (siz == G_IM_SIZ_8b) { - import_texture_i8(tile); - } else { - abort(); - } - } else { - abort(); - } - int t1 = get_time(); - //printf("Time diff: %d\n", t1 - t0); -} - -static void gfx_normalize_vector(float v[3]) { - float s = sqrtf(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]); - v[0] /= s; - v[1] /= s; - v[2] /= s; -} - -static void gfx_transposed_matrix_mul(float res[3], const float a[3], const float b[4][4]) { - res[0] = a[0] * b[0][0] + a[1] * b[0][1] + a[2] * b[0][2]; - res[1] = a[0] * b[1][0] + a[1] * b[1][1] + a[2] * b[1][2]; - res[2] = a[0] * b[2][0] + a[1] * b[2][1] + a[2] * b[2][2]; -} - -static void calculate_normal_dir(const Light_t *light, float coeffs[3]) { - float light_dir[3] = { - light->dir[0] / 127.0f, - light->dir[1] / 127.0f, - light->dir[2] / 127.0f - }; - gfx_transposed_matrix_mul(coeffs, light_dir, rsp.modelview_matrix_stack[rsp.modelview_matrix_stack_size - 1]); - gfx_normalize_vector(coeffs); -} - -static void gfx_matrix_mul(float res[4][4], const float a[4][4], const float b[4][4]) { - float tmp[4][4]; - for (int i = 0; i < 4; i++) { - for (int j = 0; j < 4; j++) { - tmp[i][j] = a[i][0] * b[0][j] + - a[i][1] * b[1][j] + - a[i][2] * b[2][j] + - a[i][3] * b[3][j]; - } - } - memcpy(res, tmp, sizeof(tmp)); -} - -static void gfx_sp_matrix(uint8_t parameters, const int32_t *addr) { - float matrix[4][4]; -#ifndef GBI_FLOATS - // Original GBI where fixed point matrices are used - for (int i = 0; i < 4; i++) { - for (int j = 0; j < 4; j += 2) { - int32_t int_part = addr[i * 2 + j / 2]; - uint32_t frac_part = addr[8 + i * 2 + j / 2]; - matrix[i][j] = (int32_t)((int_part & 0xffff0000) | (frac_part >> 16)) / 65536.0f; - matrix[i][j + 1] = (int32_t)((int_part << 16) | (frac_part & 0xffff)) / 65536.0f; - } - } -#else - // For a modified GBI where fixed point values are replaced with floats - memcpy(matrix, addr, sizeof(matrix)); -#endif - - if (parameters & G_MTX_PROJECTION) { - if (parameters & G_MTX_LOAD) { - memcpy(rsp.P_matrix, matrix, sizeof(matrix)); - } else { - gfx_matrix_mul(rsp.P_matrix, matrix, rsp.P_matrix); - } - } else { // G_MTX_MODELVIEW - if ((parameters & G_MTX_PUSH) && rsp.modelview_matrix_stack_size < 11) { - ++rsp.modelview_matrix_stack_size; - memcpy(rsp.modelview_matrix_stack[rsp.modelview_matrix_stack_size - 1], rsp.modelview_matrix_stack[rsp.modelview_matrix_stack_size - 2], sizeof(matrix)); - } - if (parameters & G_MTX_LOAD) { - memcpy(rsp.modelview_matrix_stack[rsp.modelview_matrix_stack_size - 1], matrix, sizeof(matrix)); - } else { - gfx_matrix_mul(rsp.modelview_matrix_stack[rsp.modelview_matrix_stack_size - 1], matrix, rsp.modelview_matrix_stack[rsp.modelview_matrix_stack_size - 1]); - } - rsp.lights_changed = 1; - } - gfx_matrix_mul(rsp.MP_matrix, rsp.modelview_matrix_stack[rsp.modelview_matrix_stack_size - 1], rsp.P_matrix); -} - -static void gfx_sp_pop_matrix(uint32_t count) { - while (count--) { - if (rsp.modelview_matrix_stack_size > 0) { - --rsp.modelview_matrix_stack_size; - if (rsp.modelview_matrix_stack_size > 0) { - gfx_matrix_mul(rsp.MP_matrix, rsp.modelview_matrix_stack[rsp.modelview_matrix_stack_size - 1], rsp.P_matrix); - } - } - } -} - -static float gfx_adjust_x_for_aspect_ratio(float x) { - return x * (4.0f / 3.0f) / ((float)gfx_current_dimensions.width / (float)gfx_current_dimensions.height); -} - -static void gfx_sp_vertex(size_t n_vertices, size_t dest_index, const Vtx *vertices) { - for (size_t i = 0; i < n_vertices; i++, dest_index++) { - const Vtx_t *v = &vertices[i].v; - const Vtx_tn *vn = &vertices[i].n; - struct LoadedVertex *d = &rsp.loaded_vertices[dest_index]; - - float x = v->ob[0] * rsp.MP_matrix[0][0] + v->ob[1] * rsp.MP_matrix[1][0] + v->ob[2] * rsp.MP_matrix[2][0] + rsp.MP_matrix[3][0]; - float y = v->ob[0] * rsp.MP_matrix[0][1] + v->ob[1] * rsp.MP_matrix[1][1] + v->ob[2] * rsp.MP_matrix[2][1] + rsp.MP_matrix[3][1]; - float z = v->ob[0] * rsp.MP_matrix[0][2] + v->ob[1] * rsp.MP_matrix[1][2] + v->ob[2] * rsp.MP_matrix[2][2] + rsp.MP_matrix[3][2]; - float w = v->ob[0] * rsp.MP_matrix[0][3] + v->ob[1] * rsp.MP_matrix[1][3] + v->ob[2] * rsp.MP_matrix[2][3] + rsp.MP_matrix[3][3]; - - x = gfx_adjust_x_for_aspect_ratio(x); - - short U = v->tc[0] * rsp.texture_scaling_factor.s >> 16; - short V = v->tc[1] * rsp.texture_scaling_factor.t >> 16; - - if (rsp.geometry_mode & G_LIGHTING) { - if (rsp.lights_changed) { - for (int i = 0; i < rsp.current_num_lights - 1; i++) { - calculate_normal_dir(&rsp.current_lights[i], rsp.current_lights_coeffs[i]); - } - static const Light_t lookat_x = {{0, 0, 0}, 0, {0, 0, 0}, 0, {127, 0, 0}, 0}; - static const Light_t lookat_y = {{0, 0, 0}, 0, {0, 0, 0}, 0, {0, 127, 0}, 0}; - calculate_normal_dir(&lookat_x, rsp.current_lookat_coeffs[0]); - calculate_normal_dir(&lookat_y, rsp.current_lookat_coeffs[1]); - rsp.lights_changed = false; - } - - int r = rsp.current_lights[rsp.current_num_lights - 1].col[0]; - int g = rsp.current_lights[rsp.current_num_lights - 1].col[1]; - int b = rsp.current_lights[rsp.current_num_lights - 1].col[2]; - - for (int i = 0; i < rsp.current_num_lights - 1; i++) { - float intensity = 0; - intensity += vn->n[0] * rsp.current_lights_coeffs[i][0]; - intensity += vn->n[1] * rsp.current_lights_coeffs[i][1]; - intensity += vn->n[2] * rsp.current_lights_coeffs[i][2]; - intensity /= 127.0f; - if (intensity > 0.0f) { - r += intensity * rsp.current_lights[i].col[0]; - g += intensity * rsp.current_lights[i].col[1]; - b += intensity * rsp.current_lights[i].col[2]; - } - } - - d->color.r = r > 255 ? 255 : r; - d->color.g = g > 255 ? 255 : g; - d->color.b = b > 255 ? 255 : b; - - if (rsp.geometry_mode & G_TEXTURE_GEN) { - float dotx = 0, doty = 0; - dotx += vn->n[0] * rsp.current_lookat_coeffs[0][0]; - dotx += vn->n[1] * rsp.current_lookat_coeffs[0][1]; - dotx += vn->n[2] * rsp.current_lookat_coeffs[0][2]; - doty += vn->n[0] * rsp.current_lookat_coeffs[1][0]; - doty += vn->n[1] * rsp.current_lookat_coeffs[1][1]; - doty += vn->n[2] * rsp.current_lookat_coeffs[1][2]; - - U = (int32_t)((dotx / 127.0f + 1.0f) / 4.0f * rsp.texture_scaling_factor.s); - V = (int32_t)((doty / 127.0f + 1.0f) / 4.0f * rsp.texture_scaling_factor.t); - } - } else { - d->color.r = v->cn[0]; - d->color.g = v->cn[1]; - d->color.b = v->cn[2]; - } - - d->u = U; - d->v = V; - - // trivial clip rejection - d->clip_rej = 0; - if (x < -w) d->clip_rej |= 1; - if (x > w) d->clip_rej |= 2; - if (y < -w) d->clip_rej |= 4; - if (y > w) d->clip_rej |= 8; - if (z < -w) d->clip_rej |= 16; - if (z > w) d->clip_rej |= 32; - - d->x = x; - d->y = y; - d->z = z; - d->w = w; - - if (rsp.geometry_mode & G_FOG) { - if (fabsf(w) < 0.001f) { - // To avoid division by zero - w = 0.001f; - } - - float winv = 1.0f / w; - if (winv < 0.0f) { - winv = 32767.0f; - } - - float fog_z = z * winv * rsp.fog_mul + rsp.fog_offset; - if (fog_z < 0) fog_z = 0; - if (fog_z > 255) fog_z = 255; - d->color.a = fog_z; // Use alpha variable to store fog factor - } else { - d->color.a = v->cn[3]; - } - } -} - -static void gfx_sp_tri1(uint8_t vtx1_idx, uint8_t vtx2_idx, uint8_t vtx3_idx) { - struct LoadedVertex *v1 = &rsp.loaded_vertices[vtx1_idx]; - struct LoadedVertex *v2 = &rsp.loaded_vertices[vtx2_idx]; - struct LoadedVertex *v3 = &rsp.loaded_vertices[vtx3_idx]; - struct LoadedVertex *v_arr[3] = {v1, v2, v3}; - - //if (rand()%2) return; - - if (v1->clip_rej & v2->clip_rej & v3->clip_rej) { - // The whole triangle lies outside the visible area - return; - } - - if ((rsp.geometry_mode & G_CULL_BOTH) != 0) { - float dx1 = v1->x / (v1->w) - v2->x / (v2->w); - float dy1 = v1->y / (v1->w) - v2->y / (v2->w); - float dx2 = v3->x / (v3->w) - v2->x / (v2->w); - float dy2 = v3->y / (v3->w) - v2->y / (v2->w); - float cross = dx1 * dy2 - dy1 * dx2; - - if ((v1->w < 0) ^ (v2->w < 0) ^ (v3->w < 0)) { - // If one vertex lies behind the eye, negating cross will give the correct result. - // If all vertices lie behind the eye, the triangle will be rejected anyway. - cross = -cross; - } - - switch (rsp.geometry_mode & G_CULL_BOTH) { - case G_CULL_FRONT: - if (cross <= 0) return; - break; - case G_CULL_BACK: - if (cross >= 0) return; - break; - case G_CULL_BOTH: - // Why is this even an option? - return; - } - } - - bool depth_test = (rsp.geometry_mode & G_ZBUFFER) == G_ZBUFFER; - if (depth_test != rendering_state.depth_test) { - gfx_flush(); - gfx_rapi->set_depth_test(depth_test); - rendering_state.depth_test = depth_test; - } - - bool z_upd = (rdp.other_mode_l & Z_UPD) == Z_UPD; - if (z_upd != rendering_state.depth_mask) { - gfx_flush(); - gfx_rapi->set_depth_mask(z_upd); - rendering_state.depth_mask = z_upd; - } - - bool zmode_decal = (rdp.other_mode_l & ZMODE_DEC) == ZMODE_DEC; - if (zmode_decal != rendering_state.decal_mode) { - gfx_flush(); - gfx_rapi->set_zmode_decal(zmode_decal); - rendering_state.decal_mode = zmode_decal; - } - - if (rdp.viewport_or_scissor_changed) { - if (memcmp(&rdp.viewport, &rendering_state.viewport, sizeof(rdp.viewport)) != 0) { - gfx_flush(); - gfx_rapi->set_viewport(rdp.viewport.x, rdp.viewport.y, rdp.viewport.width, rdp.viewport.height); - rendering_state.viewport = rdp.viewport; - } - if (memcmp(&rdp.scissor, &rendering_state.scissor, sizeof(rdp.scissor)) != 0) { - gfx_flush(); - gfx_rapi->set_scissor(rdp.scissor.x, rdp.scissor.y, rdp.scissor.width, rdp.scissor.height); - rendering_state.scissor = rdp.scissor; - } - rdp.viewport_or_scissor_changed = false; - } - - uint32_t cc_id = rdp.combine_mode; - - bool use_alpha = (rdp.other_mode_l & (G_BL_A_MEM << 18)) == 0; - bool use_fog = (rdp.other_mode_l >> 30) == G_BL_CLR_FOG; - bool texture_edge = (rdp.other_mode_l & CVG_X_ALPHA) == CVG_X_ALPHA; - bool use_noise = (rdp.other_mode_l & G_AC_DITHER) == G_AC_DITHER; - - if (texture_edge) { - use_alpha = true; - } - - if (use_alpha) cc_id |= SHADER_OPT_ALPHA; - if (use_fog) cc_id |= SHADER_OPT_FOG; - if (texture_edge) cc_id |= SHADER_OPT_TEXTURE_EDGE; - if (use_noise) cc_id |= SHADER_OPT_NOISE; - - if (!use_alpha) { - cc_id &= ~0xfff000; - } - - struct ColorCombiner *comb = gfx_lookup_or_create_color_combiner(cc_id); - struct ShaderProgram *prg = comb->prg; - if (prg != rendering_state.shader_program) { - gfx_flush(); - gfx_rapi->unload_shader(rendering_state.shader_program); - gfx_rapi->load_shader(prg); - rendering_state.shader_program = prg; - } - if (use_alpha != rendering_state.alpha_blend) { - gfx_flush(); - gfx_rapi->set_use_alpha(use_alpha); - rendering_state.alpha_blend = use_alpha; - } - uint8_t num_inputs; - bool used_textures[2]; - gfx_rapi->shader_get_info(prg, &num_inputs, used_textures); - - for (int i = 0; i < 2; i++) { - if (used_textures[i]) { - if (rdp.textures_changed[i]) { - gfx_flush(); - import_texture(i); - rdp.textures_changed[i] = false; - } - bool linear_filter = (rdp.other_mode_h & (3U << G_MDSFT_TEXTFILT)) != G_TF_POINT; - if (linear_filter != rendering_state.textures[i]->linear_filter || rdp.texture_tile.cms != rendering_state.textures[i]->cms || rdp.texture_tile.cmt != rendering_state.textures[i]->cmt) { - gfx_flush(); - gfx_rapi->set_sampler_parameters(i, linear_filter, rdp.texture_tile.cms, rdp.texture_tile.cmt); - rendering_state.textures[i]->linear_filter = linear_filter; - rendering_state.textures[i]->cms = rdp.texture_tile.cms; - rendering_state.textures[i]->cmt = rdp.texture_tile.cmt; - } - } - } - - bool use_texture = used_textures[0] || used_textures[1]; - uint32_t tex_width = (rdp.texture_tile.lrs - rdp.texture_tile.uls + 4) / 4; - uint32_t tex_height = (rdp.texture_tile.lrt - rdp.texture_tile.ult + 4) / 4; - - bool z_is_from_0_to_1 = gfx_rapi->z_is_from_0_to_1(); - - for (int i = 0; i < 3; i++) { - float z = v_arr[i]->z, w = v_arr[i]->w; - if (z_is_from_0_to_1) { - z = (z + w) / 2.0f; - } - buf_vbo[buf_vbo_len++] = v_arr[i]->x; - buf_vbo[buf_vbo_len++] = v_arr[i]->y; - buf_vbo[buf_vbo_len++] = z; - buf_vbo[buf_vbo_len++] = w; - - if (use_texture) { - float u = (v_arr[i]->u - rdp.texture_tile.uls * 8) / 32.0f; - float v = (v_arr[i]->v - rdp.texture_tile.ult * 8) / 32.0f; - if ((rdp.other_mode_h & (3U << G_MDSFT_TEXTFILT)) != G_TF_POINT) { - // Linear filter adds 0.5f to the coordinates - u += 0.5f; - v += 0.5f; - } - buf_vbo[buf_vbo_len++] = u / tex_width; - buf_vbo[buf_vbo_len++] = v / tex_height; - } - - if (use_fog) { - buf_vbo[buf_vbo_len++] = rdp.fog_color.r / 255.0f; - buf_vbo[buf_vbo_len++] = rdp.fog_color.g / 255.0f; - buf_vbo[buf_vbo_len++] = rdp.fog_color.b / 255.0f; - buf_vbo[buf_vbo_len++] = v_arr[i]->color.a / 255.0f; // fog factor (not alpha) - } - - for (int j = 0; j < num_inputs; j++) { - struct RGBA *color; - struct RGBA tmp; - for (int k = 0; k < 1 + (use_alpha ? 1 : 0); k++) { - switch (comb->shader_input_mapping[k][j]) { - case CC_PRIM: - color = &rdp.prim_color; - break; - case CC_SHADE: - color = &v_arr[i]->color; - break; - case CC_ENV: - color = &rdp.env_color; - break; - case CC_LOD: - { - float distance_frac = (v1->w - 3000.0f) / 3000.0f; - if (distance_frac < 0.0f) distance_frac = 0.0f; - if (distance_frac > 1.0f) distance_frac = 1.0f; - tmp.r = tmp.g = tmp.b = tmp.a = distance_frac * 255.0f; - color = &tmp; - break; - } - default: - memset(&tmp, 0, sizeof(tmp)); - color = &tmp; - break; - } - if (k == 0) { - buf_vbo[buf_vbo_len++] = color->r / 255.0f; - buf_vbo[buf_vbo_len++] = color->g / 255.0f; - buf_vbo[buf_vbo_len++] = color->b / 255.0f; - } else { - if (use_fog && color == &v_arr[i]->color) { - // Shade alpha is 100% for fog - buf_vbo[buf_vbo_len++] = 1.0f; - } else { - buf_vbo[buf_vbo_len++] = color->a / 255.0f; - } - } - } - } - /*struct RGBA *color = &v_arr[i]->color; - buf_vbo[buf_vbo_len++] = color->r / 255.0f; - buf_vbo[buf_vbo_len++] = color->g / 255.0f; - buf_vbo[buf_vbo_len++] = color->b / 255.0f; - buf_vbo[buf_vbo_len++] = color->a / 255.0f;*/ - } - if (++buf_vbo_num_tris == MAX_BUFFERED) { - gfx_flush(); - } -} - -static void gfx_sp_geometry_mode(uint32_t clear, uint32_t set) { - rsp.geometry_mode &= ~clear; - rsp.geometry_mode |= set; -} - -static void gfx_calc_and_set_viewport(const Vp_t *viewport) { - // 2 bits fraction - float width = 2.0f * viewport->vscale[0] / 4.0f; - float height = 2.0f * viewport->vscale[1] / 4.0f; - float x = (viewport->vtrans[0] / 4.0f) - width / 2.0f; - float y = SCREEN_HEIGHT - ((viewport->vtrans[1] / 4.0f) + height / 2.0f); - - width *= RATIO_X; - height *= RATIO_Y; - x *= RATIO_X; - y *= RATIO_Y; - - rdp.viewport.x = x; - rdp.viewport.y = y; - rdp.viewport.width = width; - rdp.viewport.height = height; - - rdp.viewport_or_scissor_changed = true; -} - -static void gfx_sp_movemem(uint8_t index, uint8_t offset, const void* data) { - switch (index) { - case G_MV_VIEWPORT: - gfx_calc_and_set_viewport((const Vp_t *) data); - break; -#if 0 - case G_MV_LOOKATY: - case G_MV_LOOKATX: - memcpy(rsp.current_lookat + (index - G_MV_LOOKATY) / 2, data, sizeof(Light_t)); - //rsp.lights_changed = 1; - break; -#endif -#ifdef F3DEX_GBI_2 - case G_MV_LIGHT: { - int lightidx = offset / 24 - 2; - if (lightidx >= 0 && lightidx <= MAX_LIGHTS) { // skip lookat - // NOTE: reads out of bounds if it is an ambient light - memcpy(rsp.current_lights + lightidx, data, sizeof(Light_t)); - } - break; - } -#else - case G_MV_L0: - case G_MV_L1: - case G_MV_L2: - // NOTE: reads out of bounds if it is an ambient light - memcpy(rsp.current_lights + (index - G_MV_L0) / 2, data, sizeof(Light_t)); - break; -#endif - } -} - -static void gfx_sp_moveword(uint8_t index, uint16_t offset, uint32_t data) { - switch (index) { - case G_MW_NUMLIGHT: -#ifdef F3DEX_GBI_2 - rsp.current_num_lights = data / 24 + 1; // add ambient light -#else - // Ambient light is included - // The 31th bit is a flag that lights should be recalculated - rsp.current_num_lights = (data - 0x80000000U) / 32; -#endif - rsp.lights_changed = 1; - break; - case G_MW_FOG: - rsp.fog_mul = (int16_t)(data >> 16); - rsp.fog_offset = (int16_t)data; - break; - } -} - -static void gfx_sp_texture(uint16_t sc, uint16_t tc, uint8_t level, uint8_t tile, uint8_t on) { - rsp.texture_scaling_factor.s = sc; - rsp.texture_scaling_factor.t = tc; -} - -static void gfx_dp_set_scissor(uint32_t mode, uint32_t ulx, uint32_t uly, uint32_t lrx, uint32_t lry) { - float x = ulx / 4.0f * RATIO_X; - float y = (SCREEN_HEIGHT - lry / 4.0f) * RATIO_Y; - float width = (lrx - ulx) / 4.0f * RATIO_X; - float height = (lry - uly) / 4.0f * RATIO_Y; - - rdp.scissor.x = x; - rdp.scissor.y = y; - rdp.scissor.width = width; - rdp.scissor.height = height; - - rdp.viewport_or_scissor_changed = true; -} - -static void gfx_dp_set_texture_image(uint32_t format, uint32_t size, uint32_t width, const void* addr) { - rdp.texture_to_load.addr = addr; - rdp.texture_to_load.siz = size; -} - -static void gfx_dp_set_tile(uint8_t fmt, uint32_t siz, uint32_t line, uint32_t tmem, uint8_t tile, uint32_t palette, uint32_t cmt, uint32_t maskt, uint32_t shiftt, uint32_t cms, uint32_t masks, uint32_t shifts) { - if (tile == G_TX_RENDERTILE) { - SUPPORT_CHECK(palette == 0); // palette should set upper 4 bits of color index in 4b mode - rdp.texture_tile.fmt = fmt; - rdp.texture_tile.siz = siz; - rdp.texture_tile.cms = cms; - rdp.texture_tile.cmt = cmt; - rdp.texture_tile.line_size_bytes = line * 8; - rdp.textures_changed[0] = true; - rdp.textures_changed[1] = true; - } - - if (tile == G_TX_LOADTILE) { - rdp.texture_to_load.tile_number = tmem / 256; - } -} - -static void gfx_dp_set_tile_size(uint8_t tile, uint16_t uls, uint16_t ult, uint16_t lrs, uint16_t lrt) { - if (tile == G_TX_RENDERTILE) { - rdp.texture_tile.uls = uls; - rdp.texture_tile.ult = ult; - rdp.texture_tile.lrs = lrs; - rdp.texture_tile.lrt = lrt; - rdp.textures_changed[0] = true; - rdp.textures_changed[1] = true; - } -} - -static void gfx_dp_load_tlut(uint8_t tile, uint32_t high_index) { - SUPPORT_CHECK(tile == G_TX_LOADTILE); - SUPPORT_CHECK(rdp.texture_to_load.siz == G_IM_SIZ_16b); - rdp.palette = rdp.texture_to_load.addr; -} - -static void gfx_dp_load_block(uint8_t tile, uint32_t uls, uint32_t ult, uint32_t lrs, uint32_t dxt) { - if (tile == 1) return; - SUPPORT_CHECK(tile == G_TX_LOADTILE); - SUPPORT_CHECK(uls == 0); - SUPPORT_CHECK(ult == 0); - - // The lrs field rather seems to be number of pixels to load - uint32_t word_size_shift; - switch (rdp.texture_to_load.siz) { - case G_IM_SIZ_4b: - word_size_shift = 0; // Or -1? It's unused in SM64 anyway. - break; - case G_IM_SIZ_8b: - word_size_shift = 0; - break; - case G_IM_SIZ_16b: - word_size_shift = 1; - break; - case G_IM_SIZ_32b: - word_size_shift = 2; - break; - } - uint32_t size_bytes = (lrs + 1) << word_size_shift; - rdp.loaded_texture[rdp.texture_to_load.tile_number].size_bytes = size_bytes; - assert(size_bytes <= 4096 && "bug: too big texture"); - rdp.loaded_texture[rdp.texture_to_load.tile_number].addr = rdp.texture_to_load.addr; - - rdp.textures_changed[rdp.texture_to_load.tile_number] = true; -} - -static void gfx_dp_load_tile(uint8_t tile, uint32_t uls, uint32_t ult, uint32_t lrs, uint32_t lrt) { - if (tile == 1) return; - SUPPORT_CHECK(tile == G_TX_LOADTILE); - SUPPORT_CHECK(uls == 0); - SUPPORT_CHECK(ult == 0); - - uint32_t word_size_shift; - switch (rdp.texture_to_load.siz) { - case G_IM_SIZ_4b: - word_size_shift = 0; - break; - case G_IM_SIZ_8b: - word_size_shift = 0; - break; - case G_IM_SIZ_16b: - word_size_shift = 1; - break; - case G_IM_SIZ_32b: - word_size_shift = 2; - break; - } - - uint32_t size_bytes = (((lrs >> G_TEXTURE_IMAGE_FRAC) + 1) * ((lrt >> G_TEXTURE_IMAGE_FRAC) + 1)) << word_size_shift; - rdp.loaded_texture[rdp.texture_to_load.tile_number].size_bytes = size_bytes; - - assert(size_bytes <= 4096 && "bug: too big texture"); - rdp.loaded_texture[rdp.texture_to_load.tile_number].addr = rdp.texture_to_load.addr; - rdp.texture_tile.uls = uls; - rdp.texture_tile.ult = ult; - rdp.texture_tile.lrs = lrs; - rdp.texture_tile.lrt = lrt; - - rdp.textures_changed[rdp.texture_to_load.tile_number] = true; -} - - -static uint8_t color_comb_component(uint32_t v) { - switch (v) { - case G_CCMUX_TEXEL0: - return CC_TEXEL0; - case G_CCMUX_TEXEL1: - return CC_TEXEL1; - case G_CCMUX_PRIMITIVE: - return CC_PRIM; - case G_CCMUX_SHADE: - return CC_SHADE; - case G_CCMUX_ENVIRONMENT: - return CC_ENV; - case G_CCMUX_TEXEL0_ALPHA: - return CC_TEXEL0A; - case G_CCMUX_LOD_FRACTION: - return CC_LOD; - default: - return CC_0; - } -} - -static inline uint32_t color_comb(uint32_t a, uint32_t b, uint32_t c, uint32_t d) { - return color_comb_component(a) | - (color_comb_component(b) << 3) | - (color_comb_component(c) << 6) | - (color_comb_component(d) << 9); -} - -static void gfx_dp_set_combine_mode(uint32_t rgb, uint32_t alpha) { - rdp.combine_mode = rgb | (alpha << 12); -} - -static void gfx_dp_set_env_color(uint8_t r, uint8_t g, uint8_t b, uint8_t a) { - rdp.env_color.r = r; - rdp.env_color.g = g; - rdp.env_color.b = b; - rdp.env_color.a = a; -} - -static void gfx_dp_set_prim_color(uint8_t r, uint8_t g, uint8_t b, uint8_t a) { - rdp.prim_color.r = r; - rdp.prim_color.g = g; - rdp.prim_color.b = b; - rdp.prim_color.a = a; -} - -static void gfx_dp_set_fog_color(uint8_t r, uint8_t g, uint8_t b, uint8_t a) { - rdp.fog_color.r = r; - rdp.fog_color.g = g; - rdp.fog_color.b = b; - rdp.fog_color.a = a; -} - -static void gfx_dp_set_fill_color(uint32_t packed_color) { - uint16_t col16 = (uint16_t)packed_color; - uint32_t r = col16 >> 11; - uint32_t g = (col16 >> 6) & 0x1f; - uint32_t b = (col16 >> 1) & 0x1f; - uint32_t a = col16 & 1; - rdp.fill_color.r = SCALE_5_8(r); - rdp.fill_color.g = SCALE_5_8(g); - rdp.fill_color.b = SCALE_5_8(b); - rdp.fill_color.a = a * 255; -} - -static void gfx_draw_rectangle(int32_t ulx, int32_t uly, int32_t lrx, int32_t lry) { - uint32_t saved_other_mode_h = rdp.other_mode_h; - uint32_t cycle_type = (rdp.other_mode_h & (3U << G_MDSFT_CYCLETYPE)); - - if (cycle_type == G_CYC_COPY) { - rdp.other_mode_h = (rdp.other_mode_h & ~(3U << G_MDSFT_TEXTFILT)) | G_TF_POINT; - } - - // U10.2 coordinates - float ulxf = ulx; - float ulyf = uly; - float lrxf = lrx; - float lryf = lry; - - ulxf = ulxf / (4.0f * HALF_SCREEN_WIDTH) - 1.0f; - ulyf = -(ulyf / (4.0f * HALF_SCREEN_HEIGHT)) + 1.0f; - lrxf = lrxf / (4.0f * HALF_SCREEN_WIDTH) - 1.0f; - lryf = -(lryf / (4.0f * HALF_SCREEN_HEIGHT)) + 1.0f; - - ulxf = gfx_adjust_x_for_aspect_ratio(ulxf); - lrxf = gfx_adjust_x_for_aspect_ratio(lrxf); - - struct LoadedVertex* ul = &rsp.loaded_vertices[MAX_VERTICES + 0]; - struct LoadedVertex* ll = &rsp.loaded_vertices[MAX_VERTICES + 1]; - struct LoadedVertex* lr = &rsp.loaded_vertices[MAX_VERTICES + 2]; - struct LoadedVertex* ur = &rsp.loaded_vertices[MAX_VERTICES + 3]; - - ul->x = ulxf; - ul->y = ulyf; - ul->z = -1.0f; - ul->w = 1.0f; - - ll->x = ulxf; - ll->y = lryf; - ll->z = -1.0f; - ll->w = 1.0f; - - lr->x = lrxf; - lr->y = lryf; - lr->z = -1.0f; - lr->w = 1.0f; - - ur->x = lrxf; - ur->y = ulyf; - ur->z = -1.0f; - ur->w = 1.0f; - - // The coordinates for texture rectangle shall bypass the viewport setting - struct XYWidthHeight default_viewport = {0, 0, gfx_current_dimensions.width, gfx_current_dimensions.height}; - struct XYWidthHeight viewport_saved = rdp.viewport; - uint32_t geometry_mode_saved = rsp.geometry_mode; - - rdp.viewport = default_viewport; - rdp.viewport_or_scissor_changed = true; - rsp.geometry_mode = 0; - - gfx_sp_tri1(MAX_VERTICES + 0, MAX_VERTICES + 1, MAX_VERTICES + 3); - gfx_sp_tri1(MAX_VERTICES + 1, MAX_VERTICES + 2, MAX_VERTICES + 3); - - rsp.geometry_mode = geometry_mode_saved; - rdp.viewport = viewport_saved; - rdp.viewport_or_scissor_changed = true; - - if (cycle_type == G_CYC_COPY) { - rdp.other_mode_h = saved_other_mode_h; - } -} - -static void gfx_dp_texture_rectangle(int32_t ulx, int32_t uly, int32_t lrx, int32_t lry, uint8_t tile, int16_t uls, int16_t ult, int16_t dsdx, int16_t dtdy, bool flip) { - uint32_t saved_combine_mode = rdp.combine_mode; - if ((rdp.other_mode_h & (3U << G_MDSFT_CYCLETYPE)) == G_CYC_COPY) { - // Per RDP Command Summary Set Tile's shift s and this dsdx should be set to 4 texels - // Divide by 4 to get 1 instead - dsdx >>= 2; - - // Color combiner is turned off in copy mode - gfx_dp_set_combine_mode(color_comb(0, 0, 0, G_CCMUX_TEXEL0), color_comb(0, 0, 0, G_ACMUX_TEXEL0)); - - // Per documentation one extra pixel is added in this modes to each edge - lrx += 1 << 2; - lry += 1 << 2; - } - - // uls and ult are S10.5 - // dsdx and dtdy are S5.10 - // lrx, lry, ulx, uly are U10.2 - // lrs, lrt are S10.5 - if (flip) { - dsdx = -dsdx; - dtdy = -dtdy; - } - int16_t width = !flip ? lrx - ulx : lry - uly; - int16_t height = !flip ? lry - uly : lrx - ulx; - float lrs = ((uls << 7) + dsdx * width) >> 7; - float lrt = ((ult << 7) + dtdy * height) >> 7; - - struct LoadedVertex* ul = &rsp.loaded_vertices[MAX_VERTICES + 0]; - struct LoadedVertex* ll = &rsp.loaded_vertices[MAX_VERTICES + 1]; - struct LoadedVertex* lr = &rsp.loaded_vertices[MAX_VERTICES + 2]; - struct LoadedVertex* ur = &rsp.loaded_vertices[MAX_VERTICES + 3]; - ul->u = uls; - ul->v = ult; - lr->u = lrs; - lr->v = lrt; - if (!flip) { - ll->u = uls; - ll->v = lrt; - ur->u = lrs; - ur->v = ult; - } else { - ll->u = lrs; - ll->v = ult; - ur->u = uls; - ur->v = lrt; - } - - gfx_draw_rectangle(ulx, uly, lrx, lry); - rdp.combine_mode = saved_combine_mode; -} - -static void gfx_dp_fill_rectangle(int32_t ulx, int32_t uly, int32_t lrx, int32_t lry) { - if (rdp.color_image_address == rdp.z_buf_address) { - // Don't clear Z buffer here since we already did it with glClear - return; - } - uint32_t mode = (rdp.other_mode_h & (3U << G_MDSFT_CYCLETYPE)); - - if (mode == G_CYC_COPY || mode == G_CYC_FILL) { - // Per documentation one extra pixel is added in this modes to each edge - lrx += 1 << 2; - lry += 1 << 2; - } - - for (int i = MAX_VERTICES; i < MAX_VERTICES + 4; i++) { - struct LoadedVertex* v = &rsp.loaded_vertices[i]; - v->color = rdp.fill_color; - } - - uint32_t saved_combine_mode = rdp.combine_mode; - gfx_dp_set_combine_mode(color_comb(0, 0, 0, G_CCMUX_SHADE), color_comb(0, 0, 0, G_ACMUX_SHADE)); - gfx_draw_rectangle(ulx, uly, lrx, lry); - rdp.combine_mode = saved_combine_mode; -} - -static void gfx_dp_set_z_image(void *z_buf_address) { - rdp.z_buf_address = z_buf_address; -} - -static void gfx_dp_set_color_image(uint32_t format, uint32_t size, uint32_t width, void* address) { - rdp.color_image_address = address; -} - -static void gfx_sp_set_other_mode(uint32_t shift, uint32_t num_bits, uint64_t mode) { - uint64_t mask = (((uint64_t)1 << num_bits) - 1) << shift; - uint64_t om = rdp.other_mode_l | ((uint64_t)rdp.other_mode_h << 32); - om = (om & ~mask) | mode; - rdp.other_mode_l = (uint32_t)om; - rdp.other_mode_h = (uint32_t)(om >> 32); -} - -static inline void *seg_addr(uintptr_t w1) { - return (void *) w1; -} - -#define C0(pos, width) ((cmd->words.w0 >> (pos)) & ((1U << width) - 1)) -#define C1(pos, width) ((cmd->words.w1 >> (pos)) & ((1U << width) - 1)) - -static void gfx_run_dl(Gfx* cmd) { - int dummy = 0; - for (;;) { - uint32_t opcode = cmd->words.w0 >> 24; - - switch (opcode) { - // RSP commands: - case G_MTX: -#ifdef F3DEX_GBI_2 - gfx_sp_matrix(C0(0, 8) ^ G_MTX_PUSH, (const int32_t *) seg_addr(cmd->words.w1)); -#else - gfx_sp_matrix(C0(16, 8), (const int32_t *) seg_addr(cmd->words.w1)); -#endif - break; - case (uint8_t)G_POPMTX: -#ifdef F3DEX_GBI_2 - gfx_sp_pop_matrix(cmd->words.w1 / 64); -#else - gfx_sp_pop_matrix(1); -#endif - break; - case G_MOVEMEM: -#ifdef F3DEX_GBI_2 - gfx_sp_movemem(C0(0, 8), C0(8, 8) * 8, seg_addr(cmd->words.w1)); -#else - gfx_sp_movemem(C0(16, 8), 0, seg_addr(cmd->words.w1)); -#endif - break; - case (uint8_t)G_MOVEWORD: -#ifdef F3DEX_GBI_2 - gfx_sp_moveword(C0(16, 8), C0(0, 16), cmd->words.w1); -#else - gfx_sp_moveword(C0(0, 8), C0(8, 16), cmd->words.w1); -#endif - break; - case (uint8_t)G_TEXTURE: -#ifdef F3DEX_GBI_2 - gfx_sp_texture(C1(16, 16), C1(0, 16), C0(11, 3), C0(8, 3), C0(1, 7)); -#else - gfx_sp_texture(C1(16, 16), C1(0, 16), C0(11, 3), C0(8, 3), C0(0, 8)); -#endif - break; - case G_VTX: -#ifdef F3DEX_GBI_2 - gfx_sp_vertex(C0(12, 8), C0(1, 7) - C0(12, 8), seg_addr(cmd->words.w1)); -#elif defined(F3DEX_GBI) || defined(F3DLP_GBI) - gfx_sp_vertex(C0(10, 6), C0(16, 8) / 2, seg_addr(cmd->words.w1)); -#else - gfx_sp_vertex((C0(0, 16)) / sizeof(Vtx), C0(16, 4), seg_addr(cmd->words.w1)); -#endif - break; - case G_DL: - if (C0(16, 1) == 0) { - // Push return address - gfx_run_dl((Gfx *)seg_addr(cmd->words.w1)); - } else { - cmd = (Gfx *)seg_addr(cmd->words.w1); - --cmd; // increase after break - } - break; - case (uint8_t)G_ENDDL: - return; -#ifdef F3DEX_GBI_2 - case G_GEOMETRYMODE: - gfx_sp_geometry_mode(~C0(0, 24), cmd->words.w1); - break; -#else - case (uint8_t)G_SETGEOMETRYMODE: - gfx_sp_geometry_mode(0, cmd->words.w1); - break; - case (uint8_t)G_CLEARGEOMETRYMODE: - gfx_sp_geometry_mode(cmd->words.w1, 0); - break; -#endif - case (uint8_t)G_TRI1: -#ifdef F3DEX_GBI_2 - gfx_sp_tri1(C0(16, 8) / 2, C0(8, 8) / 2, C0(0, 8) / 2); -#elif defined(F3DEX_GBI) || defined(F3DLP_GBI) - gfx_sp_tri1(C1(16, 8) / 2, C1(8, 8) / 2, C1(0, 8) / 2); -#else - gfx_sp_tri1(C1(16, 8) / 10, C1(8, 8) / 10, C1(0, 8) / 10); -#endif - break; -#if defined(F3DEX_GBI) || defined(F3DLP_GBI) - case (uint8_t)G_TRI2: - gfx_sp_tri1(C0(16, 8) / 2, C0(8, 8) / 2, C0(0, 8) / 2); - gfx_sp_tri1(C1(16, 8) / 2, C1(8, 8) / 2, C1(0, 8) / 2); - break; -#endif - case (uint8_t)G_SETOTHERMODE_L: -#ifdef F3DEX_GBI_2 - gfx_sp_set_other_mode(31 - C0(8, 8) - C0(0, 8), C0(0, 8) + 1, cmd->words.w1); -#else - gfx_sp_set_other_mode(C0(8, 8), C0(0, 8), cmd->words.w1); -#endif - break; - case (uint8_t)G_SETOTHERMODE_H: -#ifdef F3DEX_GBI_2 - gfx_sp_set_other_mode(63 - C0(8, 8) - C0(0, 8), C0(0, 8) + 1, (uint64_t) cmd->words.w1 << 32); -#else - gfx_sp_set_other_mode(C0(8, 8) + 32, C0(0, 8), (uint64_t) cmd->words.w1 << 32); -#endif - break; -#ifdef F3D_OLD - case (uint8_t)G_RDPHALF_2: -#else - case (uint8_t)G_RDPHALF_1: -#endif - switch (rsp.saved_opcode) { - case G_TEXRECT: - case G_TEXRECTFLIP: -#ifdef F3DEX_GBI_2E - rsp.saved_ulx = (int32_t)(C0(0, 24) << 8) >> 8; -#endif - rsp.saved_uls = (uint16_t)C1(16, 16); - rsp.saved_ult = (uint16_t)C1(0, 16); - break; -#ifdef F3DEX_GBI_2E - case G_FILLRECT: - { - int32_t ulx = (int32_t)(C0(0, 24) << 8) >> 8; - int32_t uly = (int32_t)(C1(0, 24) << 8) >> 8; - gfx_dp_fill_rectangle(ulx, uly, rsp.saved_lrx, rsp.saved_lry); - rsp.saved_opcode = G_NOOP; - break; - } -#endif - } - break; -#ifdef F3D_OLD - case (uint8_t)G_RDPHALF_CONT: -#else - case (uint8_t)G_RDPHALF_2: -#endif - switch (rsp.saved_opcode) { - case G_TEXRECT: - case G_TEXRECTFLIP: - { - uint8_t tile = rsp.saved_tile; - int32_t ulx = rsp.saved_ulx, lrx = rsp.saved_lrx, lry = rsp.saved_lry; - uint16_t uls = rsp.saved_uls, ult = rsp.saved_ult; -#ifdef F3DEX_GBI_2E - int32_t uly = (int32_t)(C0(0, 24) << 8) >> 8; -#else - int32_t uly = rsp.saved_uly; -#endif - uint16_t dsdx = (uint16_t)C1(16, 16); - uint16_t dtdy = (uint16_t)C1(0, 16); - gfx_dp_texture_rectangle(ulx, uly, lrx, lry, tile, uls, ult, dsdx, dtdy, rsp.saved_opcode == G_TEXRECTFLIP); - rsp.saved_opcode = G_NOOP; - break; - } - } - - // RDP Commands: - case G_SETTIMG: - gfx_dp_set_texture_image(C0(21, 3), C0(19, 2), C0(0, 10), seg_addr(cmd->words.w1)); - break; - case G_LOADBLOCK: - gfx_dp_load_block(C1(24, 3), C0(12, 12), C0(0, 12), C1(12, 12), C1(0, 12)); - break; - case G_LOADTILE: - gfx_dp_load_tile(C1(24, 3), C0(12, 12), C0(0, 12), C1(12, 12), C1(0, 12)); - break; - case G_SETTILE: - gfx_dp_set_tile(C0(21, 3), C0(19, 2), C0(9, 9), C0(0, 9), C1(24, 3), C1(20, 4), C1(18, 2), C1(14, 4), C1(10, 4), C1(8, 2), C1(4, 4), C1(0, 4)); - break; - case G_SETTILESIZE: - gfx_dp_set_tile_size(C1(24, 3), C0(12, 12), C0(0, 12), C1(12, 12), C1(0, 12)); - break; - case G_LOADTLUT: - gfx_dp_load_tlut(C1(24, 3), C1(14, 10)); - break; - case G_SETENVCOLOR: - gfx_dp_set_env_color(C1(24, 8), C1(16, 8), C1(8, 8), C1(0, 8)); - break; - case G_SETPRIMCOLOR: - gfx_dp_set_prim_color(C1(24, 8), C1(16, 8), C1(8, 8), C1(0, 8)); - break; - case G_SETFOGCOLOR: - gfx_dp_set_fog_color(C1(24, 8), C1(16, 8), C1(8, 8), C1(0, 8)); - break; - case G_SETFILLCOLOR: - gfx_dp_set_fill_color(cmd->words.w1); - break; - case G_SETCOMBINE: - gfx_dp_set_combine_mode( - color_comb(C0(20, 4), C1(28, 4), C0(15, 5), C1(15, 3)), - color_comb(C0(12, 3), C1(12, 3), C0(9, 3), C1(9, 3))); - /*color_comb(C0(5, 4), C1(24, 4), C0(0, 5), C1(6, 3)), - color_comb(C1(21, 3), C1(3, 3), C1(18, 3), C1(0, 3)));*/ - break; - // G_SETPRIMCOLOR, G_CCMUX_PRIMITIVE, G_ACMUX_PRIMITIVE, is used by Goddard - // G_CCMUX_TEXEL1, LOD_FRACTION is used in Bowser room 1 - case G_TEXRECT: - case G_TEXRECTFLIP: - { - rsp.saved_opcode = opcode; -#ifdef F3DEX_GBI_2E - rsp.saved_lrx = (int32_t)(C0(0, 24) << 8) >> 8; - rsp.saved_lry = (int32_t)(C1(0, 24) << 8) >> 8; - rsp.saved_tile = (int32_t)C1(24, 3); -#else - rsp.saved_lrx = C0(12, 12); - rsp.saved_lry = C0(0, 12); - rsp.saved_tile = C1(24, 3); - rsp.saved_ulx = C1(12, 12); - rsp.saved_uly = C1(0, 12); -#endif - break; - } - case G_FILLRECT: -#ifdef F3DEX_GBI_2E - { - rsp.saved_opcode = G_FILLRECT; - rsp.saved_lrx = (int32_t)(C0(0, 24) << 8) >> 8; - rsp.saved_lry = (int32_t)(C1(0, 24) << 8) >> 8; - break; - } -#else - gfx_dp_fill_rectangle(C1(12, 12), C1(0, 12), C0(12, 12), C0(0, 12)); - break; -#endif - case G_SETSCISSOR: - gfx_dp_set_scissor(C1(24, 2), C0(12, 12), C0(0, 12), C1(12, 12), C1(0, 12)); - break; - case G_SETZIMG: - gfx_dp_set_z_image(seg_addr(cmd->words.w1)); - break; - case G_SETCIMG: - gfx_dp_set_color_image(C0(21, 3), C0(19, 2), C0(0, 11), seg_addr(cmd->words.w1)); - break; - } - ++cmd; - } -} - -static void gfx_sp_reset() { - rsp.modelview_matrix_stack_size = 1; - rsp.current_num_lights = 2; - rsp.lights_changed = true; -} - -void gfx_get_dimensions(uint32_t *width, uint32_t *height) { - gfx_wapi->get_dimensions(width, height); -} - -void gfx_init(struct GfxWindowManagerAPI *wapi, struct GfxRenderingAPI *rapi, const char *game_name, bool start_in_fullscreen) { - gfx_wapi = wapi; - gfx_rapi = rapi; - gfx_wapi->init(game_name, start_in_fullscreen); - gfx_rapi->init(); - - // Used in the 120 star TAS - static uint32_t precomp_shaders[] = { - 0x01200200, - 0x00000045, - 0x00000200, - 0x01200a00, - 0x00000a00, - 0x01a00045, - 0x00000551, - 0x01045045, - 0x05a00a00, - 0x01200045, - 0x05045045, - 0x01045a00, - 0x01a00a00, - 0x0000038d, - 0x01081081, - 0x0120038d, - 0x03200045, - 0x03200a00, - 0x01a00a6f, - 0x01141045, - 0x07a00a00, - 0x05200200, - 0x03200200, - 0x09200200, - 0x0920038d, - 0x09200045 - }; - for (size_t i = 0; i < sizeof(precomp_shaders) / sizeof(uint32_t); i++) { - gfx_lookup_or_create_shader_program(precomp_shaders[i]); - } -} - -struct GfxRenderingAPI *gfx_get_current_rendering_api(void) { - return gfx_rapi; -} - -void gfx_start_frame(void) { - gfx_wapi->handle_events(); - gfx_wapi->get_dimensions(&gfx_current_dimensions.width, &gfx_current_dimensions.height); - if (gfx_current_dimensions.height == 0) { - // Avoid division by zero - gfx_current_dimensions.height = 1; - } - gfx_current_dimensions.aspect_ratio = (float)gfx_current_dimensions.width / (float)gfx_current_dimensions.height; -} - -void gfx_run(Gfx *commands) { - gfx_sp_reset(); - - //puts("New frame"); - - if (!gfx_wapi->start_frame()) { - dropped_frame = true; - return; - } - dropped_frame = false; - - double t0 = gfx_wapi->get_time(); - gfx_rapi->start_frame(); - gfx_run_dl(commands); - gfx_flush(); - double t1 = gfx_wapi->get_time(); - //printf("Process %f %f\n", t1, t1 - t0); - gfx_rapi->end_frame(); - gfx_wapi->swap_buffers_begin(); -} - -void gfx_end_frame(void) { - if (!dropped_frame) { - gfx_rapi->finish_render(); - gfx_wapi->swap_buffers_end(); - } -} diff --git a/src/decomp/pc/gfx/gfx_pc.h b/src/decomp/pc/gfx/gfx_pc.h deleted file mode 100644 index 0ad4a30..0000000 --- a/src/decomp/pc/gfx/gfx_pc.h +++ /dev/null @@ -1,30 +0,0 @@ -#ifndef GFX_PC_H -#define GFX_PC_H - -#include - -struct GfxRenderingAPI; -struct GfxWindowManagerAPI; - -struct GfxDimensions { - uint32_t width, height; - float aspect_ratio; -}; - -extern struct GfxDimensions gfx_current_dimensions; - -#ifdef __cplusplus -extern "C" { -#endif - -void gfx_init(struct GfxWindowManagerAPI *wapi, struct GfxRenderingAPI *rapi, const char *game_name, bool start_in_fullscreen); -struct GfxRenderingAPI *gfx_get_current_rendering_api(void); -void gfx_start_frame(void); -void gfx_run(Gfx *commands); -void gfx_end_frame(void); - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/src/decomp/pc/gfx/gfx_rendering_api.h b/src/decomp/pc/gfx/gfx_rendering_api.h deleted file mode 100644 index ed6f1c4..0000000 --- a/src/decomp/pc/gfx/gfx_rendering_api.h +++ /dev/null @@ -1,35 +0,0 @@ -#ifndef GFX_RENDERING_API_H -#define GFX_RENDERING_API_H - -#include -#include -#include - -struct ShaderProgram; - -struct GfxRenderingAPI { - bool (*z_is_from_0_to_1)(void); - void (*unload_shader)(struct ShaderProgram *old_prg); - void (*load_shader)(struct ShaderProgram *new_prg); - struct ShaderProgram *(*create_and_load_new_shader)(uint32_t shader_id); - struct ShaderProgram *(*lookup_shader)(uint32_t shader_id); - void (*shader_get_info)(struct ShaderProgram *prg, uint8_t *num_inputs, bool used_textures[2]); - uint32_t (*new_texture)(void); - void (*select_texture)(int tile, uint32_t texture_id); - void (*upload_texture)(const uint8_t *rgba32_buf, int width, int height); - void (*set_sampler_parameters)(int sampler, bool linear_filter, uint32_t cms, uint32_t cmt); - void (*set_depth_test)(bool depth_test); - void (*set_depth_mask)(bool z_upd); - void (*set_zmode_decal)(bool zmode_decal); - void (*set_viewport)(int x, int y, int width, int height); - void (*set_scissor)(int x, int y, int width, int height); - void (*set_use_alpha)(bool use_alpha); - void (*draw_triangles)(float buf_vbo[], size_t buf_vbo_len, size_t buf_vbo_num_tris); - void (*init)(void); - void (*on_resize)(void); - void (*start_frame)(void); - void (*end_frame)(void); - void (*finish_render)(void); -}; - -#endif diff --git a/src/decomp/pc/gfx/gfx_screen_config.h b/src/decomp/pc/gfx/gfx_screen_config.h deleted file mode 100644 index 5b933f8..0000000 --- a/src/decomp/pc/gfx/gfx_screen_config.h +++ /dev/null @@ -1,7 +0,0 @@ -#ifndef GFX_SCREEN_CONFIG_H -#define GFX_SCREEN_CONFIG_H - -#define DESIRED_SCREEN_WIDTH 640 -#define DESIRED_SCREEN_HEIGHT 480 - -#endif diff --git a/src/decomp/pc/gfx/gfx_sdl.h b/src/decomp/pc/gfx/gfx_sdl.h deleted file mode 100644 index 458eccb..0000000 --- a/src/decomp/pc/gfx/gfx_sdl.h +++ /dev/null @@ -1,8 +0,0 @@ -#ifndef GFX_SDL_H -#define GFX_SDL_H - -#include "gfx_window_manager_api.h" - -extern struct GfxWindowManagerAPI gfx_sdl; - -#endif diff --git a/src/decomp/pc/gfx/gfx_sdl2.c b/src/decomp/pc/gfx/gfx_sdl2.c deleted file mode 100644 index 4fd5c43..0000000 --- a/src/decomp/pc/gfx/gfx_sdl2.c +++ /dev/null @@ -1,315 +0,0 @@ -#include "../compat.h" - -#if !defined(__linux__) && !defined(__BSD__) && defined(ENABLE_OPENGL) - -#ifdef __MINGW32__ -#define FOR_WINDOWS 1 -#else -#define FOR_WINDOWS 0 -#endif - -#if FOR_WINDOWS -#include -#include "SDL.h" -#define GL_GLEXT_PROTOTYPES 1 -#include "SDL_opengl.h" -#else -#include -#define GL_GLEXT_PROTOTYPES 1 -#include -#endif - -#include "gfx_window_manager_api.h" -#include "gfx_screen_config.h" - -#define GFX_API_NAME "SDL2 - OpenGL" - -static SDL_Window *wnd; -static int inverted_scancode_table[512]; -static int vsync_enabled = 0; -static unsigned int window_width = DESIRED_SCREEN_WIDTH; -static unsigned int window_height = DESIRED_SCREEN_HEIGHT; -static bool fullscreen_state; -static void (*on_fullscreen_changed_callback)(bool is_now_fullscreen); -static bool (*on_key_down_callback)(int scancode); -static bool (*on_key_up_callback)(int scancode); -static void (*on_all_keys_up_callback)(void); - -const SDL_Scancode windows_scancode_table[] = -{ - /* 0 1 2 3 4 5 6 7 */ - /* 8 9 A B C D E F */ - SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_ESCAPE, SDL_SCANCODE_1, SDL_SCANCODE_2, SDL_SCANCODE_3, SDL_SCANCODE_4, SDL_SCANCODE_5, SDL_SCANCODE_6, /* 0 */ - SDL_SCANCODE_7, SDL_SCANCODE_8, SDL_SCANCODE_9, SDL_SCANCODE_0, SDL_SCANCODE_MINUS, SDL_SCANCODE_EQUALS, SDL_SCANCODE_BACKSPACE, SDL_SCANCODE_TAB, /* 0 */ - - SDL_SCANCODE_Q, SDL_SCANCODE_W, SDL_SCANCODE_E, SDL_SCANCODE_R, SDL_SCANCODE_T, SDL_SCANCODE_Y, SDL_SCANCODE_U, SDL_SCANCODE_I, /* 1 */ - SDL_SCANCODE_O, SDL_SCANCODE_P, SDL_SCANCODE_LEFTBRACKET, SDL_SCANCODE_RIGHTBRACKET, SDL_SCANCODE_RETURN, SDL_SCANCODE_LCTRL, SDL_SCANCODE_A, SDL_SCANCODE_S, /* 1 */ - - SDL_SCANCODE_D, SDL_SCANCODE_F, SDL_SCANCODE_G, SDL_SCANCODE_H, SDL_SCANCODE_J, SDL_SCANCODE_K, SDL_SCANCODE_L, SDL_SCANCODE_SEMICOLON, /* 2 */ - SDL_SCANCODE_APOSTROPHE, SDL_SCANCODE_GRAVE, SDL_SCANCODE_LSHIFT, SDL_SCANCODE_BACKSLASH, SDL_SCANCODE_Z, SDL_SCANCODE_X, SDL_SCANCODE_C, SDL_SCANCODE_V, /* 2 */ - - SDL_SCANCODE_B, SDL_SCANCODE_N, SDL_SCANCODE_M, SDL_SCANCODE_COMMA, SDL_SCANCODE_PERIOD, SDL_SCANCODE_SLASH, SDL_SCANCODE_RSHIFT, SDL_SCANCODE_PRINTSCREEN,/* 3 */ - SDL_SCANCODE_LALT, SDL_SCANCODE_SPACE, SDL_SCANCODE_CAPSLOCK, SDL_SCANCODE_F1, SDL_SCANCODE_F2, SDL_SCANCODE_F3, SDL_SCANCODE_F4, SDL_SCANCODE_F5, /* 3 */ - - SDL_SCANCODE_F6, SDL_SCANCODE_F7, SDL_SCANCODE_F8, SDL_SCANCODE_F9, SDL_SCANCODE_F10, SDL_SCANCODE_NUMLOCKCLEAR, SDL_SCANCODE_SCROLLLOCK, SDL_SCANCODE_HOME, /* 4 */ - SDL_SCANCODE_UP, SDL_SCANCODE_PAGEUP, SDL_SCANCODE_KP_MINUS, SDL_SCANCODE_LEFT, SDL_SCANCODE_KP_5, SDL_SCANCODE_RIGHT, SDL_SCANCODE_KP_PLUS, SDL_SCANCODE_END, /* 4 */ - - SDL_SCANCODE_DOWN, SDL_SCANCODE_PAGEDOWN, SDL_SCANCODE_INSERT, SDL_SCANCODE_DELETE, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_NONUSBACKSLASH,SDL_SCANCODE_F11, /* 5 */ - SDL_SCANCODE_F12, SDL_SCANCODE_PAUSE, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_LGUI, SDL_SCANCODE_RGUI, SDL_SCANCODE_APPLICATION, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, /* 5 */ - - SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_F13, SDL_SCANCODE_F14, SDL_SCANCODE_F15, SDL_SCANCODE_F16, /* 6 */ - SDL_SCANCODE_F17, SDL_SCANCODE_F18, SDL_SCANCODE_F19, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, /* 6 */ - - SDL_SCANCODE_INTERNATIONAL2, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_INTERNATIONAL1, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN, /* 7 */ - SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_INTERNATIONAL4, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_INTERNATIONAL5, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_INTERNATIONAL3, SDL_SCANCODE_UNKNOWN, SDL_SCANCODE_UNKNOWN /* 7 */ -}; - -const SDL_Scancode scancode_rmapping_extended[][2] = { - {SDL_SCANCODE_KP_ENTER, SDL_SCANCODE_RETURN}, - {SDL_SCANCODE_RALT, SDL_SCANCODE_LALT}, - {SDL_SCANCODE_RCTRL, SDL_SCANCODE_LCTRL}, - {SDL_SCANCODE_KP_DIVIDE, SDL_SCANCODE_SLASH}, - //{SDL_SCANCODE_KP_PLUS, SDL_SCANCODE_CAPSLOCK} -}; - -const SDL_Scancode scancode_rmapping_nonextended[][2] = { - {SDL_SCANCODE_KP_7, SDL_SCANCODE_HOME}, - {SDL_SCANCODE_KP_8, SDL_SCANCODE_UP}, - {SDL_SCANCODE_KP_9, SDL_SCANCODE_PAGEUP}, - {SDL_SCANCODE_KP_4, SDL_SCANCODE_LEFT}, - {SDL_SCANCODE_KP_6, SDL_SCANCODE_RIGHT}, - {SDL_SCANCODE_KP_1, SDL_SCANCODE_END}, - {SDL_SCANCODE_KP_2, SDL_SCANCODE_DOWN}, - {SDL_SCANCODE_KP_3, SDL_SCANCODE_PAGEDOWN}, - {SDL_SCANCODE_KP_0, SDL_SCANCODE_INSERT}, - {SDL_SCANCODE_KP_PERIOD, SDL_SCANCODE_DELETE}, - {SDL_SCANCODE_KP_MULTIPLY, SDL_SCANCODE_PRINTSCREEN} -}; - -static void set_fullscreen(bool on, bool call_callback) { - if (fullscreen_state == on) { - return; - } - fullscreen_state = on; - - if (on) { - SDL_DisplayMode mode; - SDL_GetDesktopDisplayMode(0, &mode); - window_width = mode.w; - window_height = mode.h; - } else { - window_width = DESIRED_SCREEN_WIDTH; - window_height = DESIRED_SCREEN_HEIGHT; - } - SDL_SetWindowSize(wnd, window_width, window_height); - SDL_SetWindowFullscreen(wnd, on ? SDL_WINDOW_FULLSCREEN : 0); - - if (on_fullscreen_changed_callback != NULL && call_callback) { - on_fullscreen_changed_callback(on); - } -} - -int test_vsync(void) { - // Even if SDL_GL_SetSwapInterval succeeds, it doesn't mean that VSync actually works. - // A 60 Hz monitor should have a swap interval of 16.67 milliseconds. - // Try to detect the length of a vsync by swapping buffers some times. - // Since the graphics card may enqueue a fixed number of frames, - // first send in four dummy frames to hopefully fill the queue. - // This method will fail if the refresh rate is changed, which, in - // combination with that we can't control the queue size (i.e. lag) - // is a reason this generic SDL2 backend should only be used as last resort. - Uint32 start; - Uint32 end; - - SDL_GL_SwapWindow(wnd); - SDL_GL_SwapWindow(wnd); - SDL_GL_SwapWindow(wnd); - SDL_GL_SwapWindow(wnd); - SDL_GL_SwapWindow(wnd); - SDL_GL_SwapWindow(wnd); - SDL_GL_SwapWindow(wnd); - SDL_GL_SwapWindow(wnd); - start = SDL_GetTicks(); - SDL_GL_SwapWindow(wnd); - SDL_GL_SwapWindow(wnd); - SDL_GL_SwapWindow(wnd); - SDL_GL_SwapWindow(wnd); - end = SDL_GetTicks(); - - float average = 4.0 * 1000.0 / (end - start); - - vsync_enabled = 1; - if (average > 27 && average < 33) { - SDL_GL_SetSwapInterval(1); - } else if (average > 57 && average < 63) { - SDL_GL_SetSwapInterval(2); - } else if (average > 86 && average < 94) { - SDL_GL_SetSwapInterval(3); - } else if (average > 115 && average < 125) { - SDL_GL_SetSwapInterval(4); - } else { - vsync_enabled = 0; - } -} - -static void gfx_sdl_init(const char *game_name, bool start_in_fullscreen) { - SDL_Init(SDL_INIT_VIDEO); - - SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24); - SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); - - //SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1); - //SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4); - - char title[512]; - int len = sprintf(title, "%s (%s)", game_name, GFX_API_NAME); - - wnd = SDL_CreateWindow(title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, - window_width, window_height, SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE); - - if (start_in_fullscreen) { - set_fullscreen(true, false); - } - - SDL_GL_CreateContext(wnd); - - SDL_GL_SetSwapInterval(1); - test_vsync(); - if (!vsync_enabled) - puts("Warning: VSync is not enabled or not working. Falling back to timer for synchronization"); - - for (size_t i = 0; i < sizeof(windows_scancode_table) / sizeof(SDL_Scancode); i++) { - inverted_scancode_table[windows_scancode_table[i]] = i; - } - - for (size_t i = 0; i < sizeof(scancode_rmapping_extended) / sizeof(scancode_rmapping_extended[0]); i++) { - inverted_scancode_table[scancode_rmapping_extended[i][0]] = inverted_scancode_table[scancode_rmapping_extended[i][1]] + 0x100; - } - - for (size_t i = 0; i < sizeof(scancode_rmapping_nonextended) / sizeof(scancode_rmapping_nonextended[0]); i++) { - inverted_scancode_table[scancode_rmapping_extended[i][0]] = inverted_scancode_table[scancode_rmapping_extended[i][1]]; - inverted_scancode_table[scancode_rmapping_extended[i][1]] += 0x100; - } -} - -static void gfx_sdl_set_fullscreen_changed_callback(void (*on_fullscreen_changed)(bool is_now_fullscreen)) { - on_fullscreen_changed_callback = on_fullscreen_changed; -} - -static void gfx_sdl_set_fullscreen(bool enable) { - set_fullscreen(enable, true); -} - -static void gfx_sdl_set_keyboard_callbacks(bool (*on_key_down)(int scancode), bool (*on_key_up)(int scancode), void (*on_all_keys_up)(void)) { - on_key_down_callback = on_key_down; - on_key_up_callback = on_key_up; - on_all_keys_up_callback = on_all_keys_up; -} - -static void gfx_sdl_main_loop(void (*run_one_game_iter)(void)) { - while (1) { - run_one_game_iter(); - } -} - -static void gfx_sdl_get_dimensions(uint32_t *width, uint32_t *height) { - *width = window_width; - *height = window_height; -} - -static int translate_scancode(int scancode) { - if (scancode < 512) { - return inverted_scancode_table[scancode]; - } else { - return 0; - } -} - -static void gfx_sdl_onkeydown(int scancode) { - int key = translate_scancode(scancode); - if (on_key_down_callback != NULL) { - on_key_down_callback(key); - } -} - -static void gfx_sdl_onkeyup(int scancode) { - int key = translate_scancode(scancode); - if (on_key_up_callback != NULL) { - on_key_up_callback(key); - } -} - -static void gfx_sdl_handle_events(void) { - SDL_Event event; - while (SDL_PollEvent(&event)) { - switch (event.type) { -#ifndef TARGET_WEB - // Scancodes are broken in Emscripten SDL2: https://bugzilla.libsdl.org/show_bug.cgi?id=3259 - case SDL_KEYDOWN: - if (event.key.keysym.sym == SDLK_F10) { - set_fullscreen(!fullscreen_state, true); - break; - } - gfx_sdl_onkeydown(event.key.keysym.scancode); - break; - case SDL_KEYUP: - gfx_sdl_onkeyup(event.key.keysym.scancode); - break; -#endif - case SDL_WINDOWEVENT: - if (event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED) { - window_width = event.window.data1; - window_height = event.window.data2; - } - break; - case SDL_QUIT: - exit(0); - } - } -} - -static bool gfx_sdl_start_frame(void) { - return true; -} - -static void sync_framerate_with_timer(void) { - // Number of milliseconds a frame should take (30 fps) - const Uint32 FRAME_TIME = 1000 / 30; - static Uint32 last_time; - Uint32 elapsed = SDL_GetTicks() - last_time; - - if (elapsed < FRAME_TIME) - SDL_Delay(FRAME_TIME - elapsed); - last_time += FRAME_TIME; -} - -static void gfx_sdl_swap_buffers_begin(void) { - if (!vsync_enabled) { - sync_framerate_with_timer(); - } - - SDL_GL_SwapWindow(wnd); -} - -static void gfx_sdl_swap_buffers_end(void) { -} - -static double gfx_sdl_get_time(void) { - return 0.0; -} - -struct GfxWindowManagerAPI gfx_sdl = { - gfx_sdl_init, - gfx_sdl_set_keyboard_callbacks, - gfx_sdl_set_fullscreen_changed_callback, - gfx_sdl_set_fullscreen, - gfx_sdl_main_loop, - gfx_sdl_get_dimensions, - gfx_sdl_handle_events, - gfx_sdl_start_frame, - gfx_sdl_swap_buffers_begin, - gfx_sdl_swap_buffers_end, - gfx_sdl_get_time -}; - -#endif diff --git a/src/decomp/pc/gfx/gfx_window_manager_api.h b/src/decomp/pc/gfx/gfx_window_manager_api.h deleted file mode 100644 index 6ba4a2d..0000000 --- a/src/decomp/pc/gfx/gfx_window_manager_api.h +++ /dev/null @@ -1,21 +0,0 @@ -#ifndef GFX_WINDOW_MANAGER_API_H -#define GFX_WINDOW_MANAGER_API_H - -#include -#include - -struct GfxWindowManagerAPI { - void (*init)(const char *game_name, bool start_in_fullscreen); - void (*set_keyboard_callbacks)(bool (*on_key_down)(int scancode), bool (*on_key_up)(int scancode), void (*on_all_keys_up)(void)); - void (*set_fullscreen_changed_callback)(void (*on_fullscreen_changed)(bool is_now_fullscreen)); - void (*set_fullscreen)(bool enable); - void (*main_loop)(void (*run_one_game_iter)(void)); - void (*get_dimensions)(uint32_t *width, uint32_t *height); - void (*handle_events)(void); - bool (*start_frame)(void); - void (*swap_buffers_begin)(void); - void (*swap_buffers_end)(void); - double (*get_time)(void); // For debug -}; - -#endif From bbf882701188dfc27ec94b8c4aff09c51edfc72a Mon Sep 17 00:00:00 2001 From: MeltyPlayer Date: Mon, 24 Oct 2022 02:58:53 -0500 Subject: [PATCH 06/16] Deleted input/alloc logic that isn't actually used. --- src/decomp/pc/configfile.c | 236 - src/decomp/pc/configfile.h | 22 - src/decomp/pc/controller/controller_api.h | 11 - .../controller_emscripten_keyboard.c | 151 - .../controller_emscripten_keyboard.h | 8 - .../pc/controller/controller_entry_point.c | 53 - .../pc/controller/controller_keyboard.c | 88 - .../pc/controller/controller_keyboard.h | 19 - .../pc/controller/controller_recorded_tas.c | 29 - .../pc/controller/controller_recorded_tas.h | 8 - src/decomp/pc/controller/controller_sdl.c | 103 - src/decomp/pc/controller/controller_sdl.h | 8 - src/decomp/pc/controller/controller_wup.c | 51 - src/decomp/pc/controller/controller_wup.h | 12 - src/decomp/pc/controller/controller_xinput.c | 51 - src/decomp/pc/controller/controller_xinput.h | 12 - src/decomp/pc/controller/wup.c | 362 - src/decomp/pc/dlmalloc.c | 6289 ----------------- 18 files changed, 7513 deletions(-) delete mode 100644 src/decomp/pc/configfile.c delete mode 100644 src/decomp/pc/configfile.h delete mode 100644 src/decomp/pc/controller/controller_api.h delete mode 100644 src/decomp/pc/controller/controller_emscripten_keyboard.c delete mode 100644 src/decomp/pc/controller/controller_emscripten_keyboard.h delete mode 100644 src/decomp/pc/controller/controller_entry_point.c delete mode 100644 src/decomp/pc/controller/controller_keyboard.c delete mode 100644 src/decomp/pc/controller/controller_keyboard.h delete mode 100644 src/decomp/pc/controller/controller_recorded_tas.c delete mode 100644 src/decomp/pc/controller/controller_recorded_tas.h delete mode 100644 src/decomp/pc/controller/controller_sdl.c delete mode 100644 src/decomp/pc/controller/controller_sdl.h delete mode 100644 src/decomp/pc/controller/controller_wup.c delete mode 100644 src/decomp/pc/controller/controller_wup.h delete mode 100644 src/decomp/pc/controller/controller_xinput.c delete mode 100644 src/decomp/pc/controller/controller_xinput.h delete mode 100644 src/decomp/pc/controller/wup.c delete mode 100644 src/decomp/pc/dlmalloc.c diff --git a/src/decomp/pc/configfile.c b/src/decomp/pc/configfile.c deleted file mode 100644 index 10ff1e6..0000000 --- a/src/decomp/pc/configfile.c +++ /dev/null @@ -1,236 +0,0 @@ -// configfile.c - handles loading and saving the configuration options -#include -#include -#include -#include -#include -#include - -#include "configfile.h" - -#define ARRAY_LEN(arr) (sizeof(arr) / sizeof(arr[0])) - -enum ConfigOptionType { - CONFIG_TYPE_BOOL, - CONFIG_TYPE_UINT, - CONFIG_TYPE_FLOAT, -}; - -struct ConfigOption { - const char *name; - enum ConfigOptionType type; - union { - bool *boolValue; - unsigned int *uintValue; - float *floatValue; - }; -}; - -/* - *Config options and default values - */ -bool configFullscreen = false; -// Keyboard mappings (scancode values) -unsigned int configKeyA = 0x26; -unsigned int configKeyB = 0x33; -unsigned int configKeyStart = 0x39; -unsigned int configKeyR = 0x36; -unsigned int configKeyZ = 0x25; -unsigned int configKeyCUp = 0x148; -unsigned int configKeyCDown = 0x150; -unsigned int configKeyCLeft = 0x14B; -unsigned int configKeyCRight = 0x14D; -unsigned int configKeyStickUp = 0x11; -unsigned int configKeyStickDown = 0x1F; -unsigned int configKeyStickLeft = 0x1E; -unsigned int configKeyStickRight = 0x20; - - -static const struct ConfigOption options[] = { - {.name = "fullscreen", .type = CONFIG_TYPE_BOOL, .boolValue = &configFullscreen}, - {.name = "key_a", .type = CONFIG_TYPE_UINT, .uintValue = &configKeyA}, - {.name = "key_b", .type = CONFIG_TYPE_UINT, .uintValue = &configKeyB}, - {.name = "key_start", .type = CONFIG_TYPE_UINT, .uintValue = &configKeyStart}, - {.name = "key_r", .type = CONFIG_TYPE_UINT, .uintValue = &configKeyR}, - {.name = "key_z", .type = CONFIG_TYPE_UINT, .uintValue = &configKeyZ}, - {.name = "key_cup", .type = CONFIG_TYPE_UINT, .uintValue = &configKeyCUp}, - {.name = "key_cdown", .type = CONFIG_TYPE_UINT, .uintValue = &configKeyCDown}, - {.name = "key_cleft", .type = CONFIG_TYPE_UINT, .uintValue = &configKeyCLeft}, - {.name = "key_cright", .type = CONFIG_TYPE_UINT, .uintValue = &configKeyCRight}, - {.name = "key_stickup", .type = CONFIG_TYPE_UINT, .uintValue = &configKeyStickUp}, - {.name = "key_stickdown", .type = CONFIG_TYPE_UINT, .uintValue = &configKeyStickDown}, - {.name = "key_stickleft", .type = CONFIG_TYPE_UINT, .uintValue = &configKeyStickLeft}, - {.name = "key_stickright", .type = CONFIG_TYPE_UINT, .uintValue = &configKeyStickRight}, -}; - -// Reads an entire line from a file (excluding the newline character) and returns an allocated string -// Returns NULL if no lines could be read from the file -static char *read_file_line(FILE *file) { - char *buffer; - size_t bufferSize = 8; - size_t offset = 0; // offset in buffer to write - - buffer = malloc(bufferSize); - while (1) { - // Read a line from the file - if (fgets(buffer + offset, bufferSize - offset, file) == NULL) { - free(buffer); - return NULL; // Nothing could be read. - } - offset = strlen(buffer); - assert(offset > 0); - - // If a newline was found, remove the trailing newline and exit - if (buffer[offset - 1] == '\n') { - buffer[offset - 1] = '\0'; - break; - } - - if (feof(file)) // EOF was reached - break; - - // If no newline or EOF was reached, then the whole line wasn't read. - bufferSize *= 2; // Increase buffer size - buffer = realloc(buffer, bufferSize); - assert(buffer != NULL); - } - - return buffer; -} - -// Returns the position of the first non-whitespace character -static char *skip_whitespace(char *str) { - while (isspace(*str)) - str++; - return str; -} - -// NULL-terminates the current whitespace-delimited word, and returns a pointer to the next word -static char *word_split(char *str) { - // Precondition: str must not point to whitespace - assert(!isspace(*str)); - - // Find either the next whitespace char or end of string - while (!isspace(*str) && *str != '\0') - str++; - if (*str == '\0') // End of string - return str; - - // Terminate current word - *(str++) = '\0'; - - // Skip whitespace to next word - return skip_whitespace(str); -} - -// Splits a string into words, and stores the words into the 'tokens' array -// 'maxTokens' is the length of the 'tokens' array -// Returns the number of tokens parsed -static unsigned int tokenize_string(char *str, int maxTokens, char **tokens) { - int count = 0; - - str = skip_whitespace(str); - while (str[0] != '\0' && count < maxTokens) { - tokens[count] = str; - str = word_split(str); - count++; - } - return count; -} - -// Loads the config file specified by 'filename' -void configfile_load(const char *filename) { - FILE *file; - char *line; - - printf("Loading configuration from '%s'\n", filename); - - file = fopen(filename, "r"); - if (file == NULL) { - // Create a new config file and save defaults - printf("Config file '%s' not found. Creating it.\n", filename); - configfile_save(filename); - return; - } - - // Go through each line in the file - while ((line = read_file_line(file)) != NULL) { - char *p = line; - char *tokens[2]; - int numTokens; - - while (isspace(*p)) - p++; - numTokens = tokenize_string(p, 2, tokens); - if (numTokens != 0) { - if (numTokens == 2) { - const struct ConfigOption *option = NULL; - - for (unsigned int i = 0; i < ARRAY_LEN(options); i++) { - if (strcmp(tokens[0], options[i].name) == 0) { - option = &options[i]; - break; - } - } - if (option == NULL) - printf("unknown option '%s'\n", tokens[0]); - else { - switch (option->type) { - case CONFIG_TYPE_BOOL: - if (strcmp(tokens[1], "true") == 0) - *option->boolValue = true; - else if (strcmp(tokens[1], "false") == 0) - *option->boolValue = false; - break; - case CONFIG_TYPE_UINT: - sscanf(tokens[1], "%u", option->uintValue); - break; - case CONFIG_TYPE_FLOAT: - sscanf(tokens[1], "%f", option->floatValue); - break; - default: - assert(0); // bad type - } - printf("option: '%s', value: '%s'\n", tokens[0], tokens[1]); - } - } else - puts("error: expected value"); - } - free(line); - } - - fclose(file); -} - -// Writes the config file to 'filename' -void configfile_save(const char *filename) { - FILE *file; - - printf("Saving configuration to '%s'\n", filename); - - file = fopen(filename, "w"); - if (file == NULL) { - // error - return; - } - - for (unsigned int i = 0; i < ARRAY_LEN(options); i++) { - const struct ConfigOption *option = &options[i]; - - switch (option->type) { - case CONFIG_TYPE_BOOL: - fprintf(file, "%s %s\n", option->name, *option->boolValue ? "true" : "false"); - break; - case CONFIG_TYPE_UINT: - fprintf(file, "%s %u\n", option->name, *option->uintValue); - break; - case CONFIG_TYPE_FLOAT: - fprintf(file, "%s %f\n", option->name, *option->floatValue); - break; - default: - assert(0); // unknown type - } - } - - fclose(file); -} diff --git a/src/decomp/pc/configfile.h b/src/decomp/pc/configfile.h deleted file mode 100644 index ae9070b..0000000 --- a/src/decomp/pc/configfile.h +++ /dev/null @@ -1,22 +0,0 @@ -#ifndef CONFIGFILE_H -#define CONFIGFILE_H - -extern bool configFullscreen; -extern unsigned int configKeyA; -extern unsigned int configKeyB; -extern unsigned int configKeyStart; -extern unsigned int configKeyR; -extern unsigned int configKeyZ; -extern unsigned int configKeyCUp; -extern unsigned int configKeyCDown; -extern unsigned int configKeyCLeft; -extern unsigned int configKeyCRight; -extern unsigned int configKeyStickUp; -extern unsigned int configKeyStickDown; -extern unsigned int configKeyStickLeft; -extern unsigned int configKeyStickRight; - -void configfile_load(const char *filename); -void configfile_save(const char *filename); - -#endif diff --git a/src/decomp/pc/controller/controller_api.h b/src/decomp/pc/controller/controller_api.h deleted file mode 100644 index dd318a8..0000000 --- a/src/decomp/pc/controller/controller_api.h +++ /dev/null @@ -1,11 +0,0 @@ -#ifndef CONTROLLER_API -#define CONTROLLER_API - -#include - -struct ControllerAPI { - void (*init)(void); - void (*read)(OSContPad *pad); -}; - -#endif diff --git a/src/decomp/pc/controller/controller_emscripten_keyboard.c b/src/decomp/pc/controller/controller_emscripten_keyboard.c deleted file mode 100644 index cf78cf6..0000000 --- a/src/decomp/pc/controller/controller_emscripten_keyboard.c +++ /dev/null @@ -1,151 +0,0 @@ -#ifdef TARGET_WEB - -#include -#include -#include "macros.h" -#include "controller_keyboard.h" - -static const struct { - const char *code; - int scancode; -} keymap_browser[] = { - {"Escape", 0x01}, - {"Digit1", 0x02 }, - {"Digit2", 0x03 }, - {"Digit3", 0x04 }, - {"Digit4", 0x05 }, - {"Digit5", 0x06 }, - {"Digit6", 0x07 }, - {"Digit7", 0x08 }, - {"Digit8", 0x09 }, - {"Digit9", 0x0a }, - {"Digit0", 0x0b }, - {"Minus", 0x0c }, - {"Equal", 0x0d }, - {"Backspace", 0x0e }, - {"Tab", 0x0f }, - {"KeyQ", 0x10 }, - {"KeyW", 0x11 }, - {"KeyE", 0x12 }, - {"KeyR", 0x13 }, - {"KeyT", 0x14 }, - {"KeyY", 0x15 }, - {"KeyU", 0x16 }, - {"KeyI", 0x17 }, - {"KeyO", 0x18 }, - {"KeyP", 0x19 }, - {"BracketLeft", 0x1a }, - {"BracketRight", 0x1b }, - {"Enter", 0x1c }, - {"ControlLeft", 0x1d }, - {"KeyA", 0x1e }, - {"KeyS", 0x1f }, - {"KeyD", 0x20 }, - {"KeyF", 0x21 }, - {"KeyG", 0x22 }, - {"KeyH", 0x23 }, - {"KeyJ", 0x24 }, - {"KeyK", 0x25 }, - {"KeyL", 0x26 }, - {"Semicolon", 0x27 }, - {"Quote", 0x28 }, - {"Backquote", 0x29 }, - {"ShiftLeft", 0x2a }, - {"Backslash", 0x2b }, - {"KeyZ", 0x2c }, - {"KeyX", 0x2d }, - {"KeyC", 0x2e }, - {"KeyV", 0x2f }, - {"KeyB", 0x30 }, - {"KeyN", 0x31 }, - {"KeyM", 0x32 }, - {"Comma", 0x33 }, - {"Period", 0x34 }, - {"Slash", 0x35 }, - {"ShiftRight", 0x36 }, - {"NumpadMultiply", 0x37 }, - {"AltLeft", 0x38 }, - {"Space", 0x39 }, - {"CapsLock", 0x3a }, - {"F1", 0x3b }, - {"F2", 0x3c }, - {"F3", 0x3d }, - {"F4", 0x3e }, - {"F5", 0x3f }, - {"F6", 0x40 }, - {"F7", 0x41 }, - {"F8", 0x42 }, - {"F9", 0x43 }, - {"F10", 0x44 }, - {"NumLock", 0x45 }, - {"ScrollLock", 0x46 }, - {"Numpad7", 0x47 }, - {"Numpad8", 0x48 }, - {"Numpad9", 0x49 }, - {"NumpadSubtract", 0x4a }, - {"Numpad4", 0x4b }, - {"Numpad5", 0x4c }, - {"Numpad6", 0x4d }, - {"NumpadAdd", 0x4e }, - {"Numpad1", 0x4f }, - {"Numpad2", 0x50 }, - {"Numpad3", 0x51 }, - {"Numpad0", 0x52 }, - {"NumpadDecimal", 0x53 }, - {"PrintScreen", 0x54 }, - // 0x55 - {"IntlBackslash", 0x56 }, - {"F11", 0x57 }, - {"F12", 0x58 }, - {"IntlRo", 0x59 }, - //{"Katakana", 0 }, - //{"Hiragana", 0 }, - {"NumpadEnter", 0x11c }, - {"ControlRight", 0x11d }, - {"NumpadDivide", 0x135 }, - {"AltRight", 0x138 }, - {"Home", 0x147 }, - {"ArrowUp", 0x148 }, - {"PageUp", 0x149 }, - {"ArrowLeft", 0x14b }, - {"ArrowRight", 0x14d }, - {"End", 0x14f }, - {"ArrowDown", 0x150 }, - {"PageDown", 0x151 }, - {"Insert", 0x152 }, - {"Delete", 0x153 }, - {"Pause", 0x21d }, - {"MetaLeft", 0x15b }, - {"MetaRight", 0x15c }, - {"ContextMenu", 0x15d }, -}; - -static EM_BOOL controller_emscripten_keyboard_handler(int event_type, const EmscriptenKeyboardEvent *key_event, UNUSED void *user_data) { - for (size_t i = 0; i < sizeof(keymap_browser) / sizeof(keymap_browser[0]); i++) { - if (strcmp(key_event->code, keymap_browser[i].code) == 0) { - if (event_type == EMSCRIPTEN_EVENT_KEYDOWN) { - return keyboard_on_key_down(keymap_browser[i].scancode); - } else if (event_type == EMSCRIPTEN_EVENT_KEYUP) { - return keyboard_on_key_up(keymap_browser[i].scancode); - } - break; - } - } - return EM_FALSE; -} - -static EM_BOOL controller_emscripten_keyboard_blur_handler(UNUSED int event_type, UNUSED const EmscriptenFocusEvent *focus_event, UNUSED void *user_data) { - keyboard_on_all_keys_up(); - return EM_TRUE; -} - -void controller_emscripten_keyboard_init(void) { - // Should be #window according to docs, but that crashes - const char *target = EMSCRIPTEN_EVENT_TARGET_WINDOW; - - emscripten_set_keydown_callback(target, NULL, EM_FALSE, controller_emscripten_keyboard_handler); - emscripten_set_keyup_callback(target, NULL, EM_FALSE, controller_emscripten_keyboard_handler); - emscripten_set_blur_callback(target, NULL, EM_FALSE, controller_emscripten_keyboard_blur_handler); -} - -#endif diff --git a/src/decomp/pc/controller/controller_emscripten_keyboard.h b/src/decomp/pc/controller/controller_emscripten_keyboard.h deleted file mode 100644 index 9b72873..0000000 --- a/src/decomp/pc/controller/controller_emscripten_keyboard.h +++ /dev/null @@ -1,8 +0,0 @@ -#ifndef CONTROLLER_KEYBOARD_EMSCRIPTEN_H -#define CONTROLLER_KEYBOARD_EMSCRIPTEN_H - -#ifdef TARGET_WEB -void controller_emscripten_keyboard_init(void); -#endif - -#endif diff --git a/src/decomp/pc/controller/controller_entry_point.c b/src/decomp/pc/controller/controller_entry_point.c deleted file mode 100644 index f86cf0d..0000000 --- a/src/decomp/pc/controller/controller_entry_point.c +++ /dev/null @@ -1,53 +0,0 @@ -#include "macros.h" - -#include "lib/src/libultra_internal.h" -#include "lib/src/osContInternal.h" - -#include "controller_recorded_tas.h" -#include "controller_keyboard.h" - -#if defined(_WIN32) || defined(_WIN64) -#include "controller_xinput.h" -#else -#include "controller_sdl.h" -#endif - -#ifdef __linux__ -#include "controller_wup.h" -#endif - -static struct ControllerAPI *controller_implementations[] = { - &controller_recorded_tas, -#if defined(_WIN32) || defined(_WIN64) - &controller_xinput, -#else - &controller_sdl, -#endif -#ifdef __linux__ - &controller_wup, -#endif - &controller_keyboard, -}; - -s32 osContInit(UNUSED OSMesgQueue *mq, u8 *controllerBits, UNUSED OSContStatus *status) { - for (size_t i = 0; i < sizeof(controller_implementations) / sizeof(struct ControllerAPI *); i++) { - controller_implementations[i]->init(); - } - *controllerBits = 1; - return 0; -} - -s32 osContStartReadData(UNUSED OSMesgQueue *mesg) { - return 0; -} - -void osContGetReadData(OSContPad *pad) { - pad->button = 0; - pad->stick_x = 0; - pad->stick_y = 0; - pad->errnum = 0; - - for (size_t i = 0; i < sizeof(controller_implementations) / sizeof(struct ControllerAPI *); i++) { - controller_implementations[i]->read(pad); - } -} diff --git a/src/decomp/pc/controller/controller_keyboard.c b/src/decomp/pc/controller/controller_keyboard.c deleted file mode 100644 index a49b86a..0000000 --- a/src/decomp/pc/controller/controller_keyboard.c +++ /dev/null @@ -1,88 +0,0 @@ -#include -#include - -#include "controller_api.h" - -#ifdef TARGET_WEB -#include "controller_emscripten_keyboard.h" -#endif - -#include "../configfile.h" - -static int keyboard_buttons_down; - -static int keyboard_mapping[13][2]; - -static int keyboard_map_scancode(int scancode) { - int ret = 0; - for (size_t i = 0; i < sizeof(keyboard_mapping) / sizeof(keyboard_mapping[0]); i++) { - if (keyboard_mapping[i][0] == scancode) { - ret |= keyboard_mapping[i][1]; - } - } - return ret; -} - -bool keyboard_on_key_down(int scancode) { - int mapped = keyboard_map_scancode(scancode); - keyboard_buttons_down |= mapped; - return mapped != 0; -} - -bool keyboard_on_key_up(int scancode) { - int mapped = keyboard_map_scancode(scancode); - keyboard_buttons_down &= ~mapped; - return mapped != 0; -} - -void keyboard_on_all_keys_up(void) { - keyboard_buttons_down = 0; -} - -static void set_keyboard_mapping(int index, int mask, int scancode) { - keyboard_mapping[index][0] = scancode; - keyboard_mapping[index][1] = mask; -} - -static void keyboard_init(void) { - int i = 0; - - set_keyboard_mapping(i++, 0x80000, configKeyStickUp); - set_keyboard_mapping(i++, 0x10000, configKeyStickLeft); - set_keyboard_mapping(i++, 0x40000, configKeyStickDown); - set_keyboard_mapping(i++, 0x20000, configKeyStickRight); - set_keyboard_mapping(i++, A_BUTTON, configKeyA); - set_keyboard_mapping(i++, B_BUTTON, configKeyB); - set_keyboard_mapping(i++, Z_TRIG, configKeyZ); - set_keyboard_mapping(i++, U_CBUTTONS, configKeyCUp); - set_keyboard_mapping(i++, L_CBUTTONS, configKeyCLeft); - set_keyboard_mapping(i++, D_CBUTTONS, configKeyCDown); - set_keyboard_mapping(i++, R_CBUTTONS, configKeyCRight); - set_keyboard_mapping(i++, R_TRIG, configKeyR); - set_keyboard_mapping(i++, START_BUTTON, configKeyStart); - -#ifdef TARGET_WEB - controller_emscripten_keyboard_init(); -#endif -} - -static void keyboard_read(OSContPad *pad) { - pad->button |= keyboard_buttons_down; - if ((keyboard_buttons_down & 0x30000) == 0x10000) { - pad->stick_x = -128; - } - if ((keyboard_buttons_down & 0x30000) == 0x20000) { - pad->stick_x = 127; - } - if ((keyboard_buttons_down & 0xc0000) == 0x40000) { - pad->stick_y = -128; - } - if ((keyboard_buttons_down & 0xc0000) == 0x80000) { - pad->stick_y = 127; - } -} - -struct ControllerAPI controller_keyboard = { - keyboard_init, - keyboard_read -}; diff --git a/src/decomp/pc/controller/controller_keyboard.h b/src/decomp/pc/controller/controller_keyboard.h deleted file mode 100644 index e2c0858..0000000 --- a/src/decomp/pc/controller/controller_keyboard.h +++ /dev/null @@ -1,19 +0,0 @@ -#ifndef CONTROLLER_KEYBOARD_H -#define CONTROLLER_KEYBOARD_H - -#include -#include "controller_api.h" - -#ifdef __cplusplus -extern "C" { -#endif -bool keyboard_on_key_down(int scancode); -bool keyboard_on_key_up(int scancode); -void keyboard_on_all_keys_up(void); -#ifdef __cplusplus -} -#endif - -extern struct ControllerAPI controller_keyboard; - -#endif diff --git a/src/decomp/pc/controller/controller_recorded_tas.c b/src/decomp/pc/controller/controller_recorded_tas.c deleted file mode 100644 index 4f5c1bb..0000000 --- a/src/decomp/pc/controller/controller_recorded_tas.c +++ /dev/null @@ -1,29 +0,0 @@ -#include -#include - -#include "controller_api.h" - -static FILE *fp; - -static void tas_init(void) { - fp = fopen("cont.m64", "rb"); - if (fp != NULL) { - uint8_t buf[0x400]; - fread(buf, 1, sizeof(buf), fp); - } -} - -static void tas_read(OSContPad *pad) { - if (fp != NULL) { - uint8_t bytes[4] = {0}; - fread(bytes, 1, 4, fp); - pad->button = (bytes[0] << 8) | bytes[1]; - pad->stick_x = bytes[2]; - pad->stick_y = bytes[3]; - } -} - -struct ControllerAPI controller_recorded_tas = { - tas_init, - tas_read -}; diff --git a/src/decomp/pc/controller/controller_recorded_tas.h b/src/decomp/pc/controller/controller_recorded_tas.h deleted file mode 100644 index 15ead4b..0000000 --- a/src/decomp/pc/controller/controller_recorded_tas.h +++ /dev/null @@ -1,8 +0,0 @@ -#ifndef CONTROLLER_RECORDED_TAS_H -#define CONTROLLER_RECORDED_TAS_H - -#include "controller_api.h" - -extern struct ControllerAPI controller_recorded_tas; - -#endif diff --git a/src/decomp/pc/controller/controller_sdl.c b/src/decomp/pc/controller/controller_sdl.c deleted file mode 100644 index f6880e7..0000000 --- a/src/decomp/pc/controller/controller_sdl.c +++ /dev/null @@ -1,103 +0,0 @@ -#if !defined(_WIN32) && !defined(_WIN64) - -#include -#include -#include -#include - -#include - -#include - -#include "controller_api.h" - -#define DEADZONE 4960 - -static bool init_ok; -static SDL_GameController *sdl_cntrl; - -static void controller_sdl_init(void) { - if (SDL_Init(SDL_INIT_GAMECONTROLLER) != 0) { - fprintf(stderr, "SDL init error: %s\n", SDL_GetError()); - return; - } - - init_ok = true; -} - -static void controller_sdl_read(OSContPad *pad) { - if (!init_ok) { - return; - } - - SDL_GameControllerUpdate(); - - if (sdl_cntrl != NULL && !SDL_GameControllerGetAttached(sdl_cntrl)) { - SDL_GameControllerClose(sdl_cntrl); - sdl_cntrl = NULL; - } - if (sdl_cntrl == NULL) { - for (int i = 0; i < SDL_NumJoysticks(); i++) { - if (SDL_IsGameController(i)) { - sdl_cntrl = SDL_GameControllerOpen(i); - if (sdl_cntrl != NULL) { - break; - } - } - } - if (sdl_cntrl == NULL) { - return; - } - } - - if (SDL_GameControllerGetButton(sdl_cntrl, SDL_CONTROLLER_BUTTON_START)) pad->button |= START_BUTTON; - if (SDL_GameControllerGetButton(sdl_cntrl, SDL_CONTROLLER_BUTTON_LEFTSHOULDER)) pad->button |= Z_TRIG; - if (SDL_GameControllerGetButton(sdl_cntrl, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER)) pad->button |= R_TRIG; - if (SDL_GameControllerGetButton(sdl_cntrl, SDL_CONTROLLER_BUTTON_A)) pad->button |= A_BUTTON; - if (SDL_GameControllerGetButton(sdl_cntrl, SDL_CONTROLLER_BUTTON_X)) pad->button |= B_BUTTON; - - int16_t leftx = SDL_GameControllerGetAxis(sdl_cntrl, SDL_CONTROLLER_AXIS_LEFTX); - int16_t lefty = SDL_GameControllerGetAxis(sdl_cntrl, SDL_CONTROLLER_AXIS_LEFTY); - int16_t rightx = SDL_GameControllerGetAxis(sdl_cntrl, SDL_CONTROLLER_AXIS_RIGHTX); - int16_t righty = SDL_GameControllerGetAxis(sdl_cntrl, SDL_CONTROLLER_AXIS_RIGHTY); - - int16_t ltrig = SDL_GameControllerGetAxis(sdl_cntrl, SDL_CONTROLLER_AXIS_TRIGGERLEFT); - int16_t rtrig = SDL_GameControllerGetAxis(sdl_cntrl, SDL_CONTROLLER_AXIS_TRIGGERRIGHT); - -#ifdef TARGET_WEB - // Firefox has a bug: https://bugzilla.mozilla.org/show_bug.cgi?id=1606562 - // It sets down y to 32768.0f / 32767.0f, which is greater than the allowed 1.0f, - // which SDL then converts to a int16_t by multiplying by 32767.0f, which overflows into -32768. - // Maximum up will hence never become -32768 with the current version of SDL2, - // so this workaround should be safe in compliant browsers. - if (lefty == -32768) { - lefty = 32767; - } - if (righty == -32768) { - righty = 32767; - } -#endif - - if (rightx < -0x4000) pad->button |= L_CBUTTONS; - if (rightx > 0x4000) pad->button |= R_CBUTTONS; - if (righty < -0x4000) pad->button |= U_CBUTTONS; - if (righty > 0x4000) pad->button |= D_CBUTTONS; - - if (ltrig > 30 * 256) pad->button |= Z_TRIG; - if (rtrig > 30 * 256) pad->button |= R_TRIG; - - uint32_t magnitude_sq = (uint32_t)(leftx * leftx) + (uint32_t)(lefty * lefty); - if (magnitude_sq > (uint32_t)(DEADZONE * DEADZONE)) { - // Game expects stick coordinates within -80..80 - // 32768 / 409 = ~80 - pad->stick_x = leftx / 409; - pad->stick_y = -lefty / 409; - } -} - -struct ControllerAPI controller_sdl = { - controller_sdl_init, - controller_sdl_read -}; - -#endif diff --git a/src/decomp/pc/controller/controller_sdl.h b/src/decomp/pc/controller/controller_sdl.h deleted file mode 100644 index 02aec8d..0000000 --- a/src/decomp/pc/controller/controller_sdl.h +++ /dev/null @@ -1,8 +0,0 @@ -#ifndef CONTROLLER_SDL_H -#define CONTROLLER_SDL_H - -#include "controller_api.h" - -extern struct ControllerAPI controller_sdl; - -#endif diff --git a/src/decomp/pc/controller/controller_wup.c b/src/decomp/pc/controller/controller_wup.c deleted file mode 100644 index 0a675ff..0000000 --- a/src/decomp/pc/controller/controller_wup.c +++ /dev/null @@ -1,51 +0,0 @@ -#ifdef __linux__ - -#include -#include - -#include - -#include "controller_api.h" - -void *wup_start(void *a); -bool wup_get_controller_input(uint16_t *buttons, uint8_t axis[6]); - -static int8_t saturate(int v) { - v = v * 3 / 2; - return v < -128 ? -128 : v > 127 ? 127 : v; -} - -static void controller_wup_init(void) { - pthread_t pid; - pthread_create(&pid, NULL, wup_start, NULL); -} - -static void controller_wup_read(OSContPad *pad) { - uint16_t buttons; - uint8_t axis[6]; - if (wup_get_controller_input(&buttons, axis)) { - if (buttons & 0x0001) pad->button |= START_BUTTON; - if (buttons & 0x0008) pad->button |= Z_TRIG; - if (buttons & 0x0004) pad->button |= R_TRIG; - if (buttons & 0x0100) pad->button |= A_BUTTON; - if (buttons & 0x0200) pad->button |= B_BUTTON; - if (buttons & 0x1000) pad->button |= L_TRIG; - if (axis[2] < 0x40) pad->button |= L_CBUTTONS; - if (axis[2] > 0xC0) pad->button |= R_CBUTTONS; - if (axis[3] < 0x40) pad->button |= D_CBUTTONS; - if (axis[3] > 0xC0) pad->button |= U_CBUTTONS; - int8_t stick_x = saturate(axis[0] - 128 - 0); - int8_t stick_y = saturate(axis[1] - 128 - 0); - if (stick_x != 0 || stick_y != 0) { - pad->stick_x = stick_x; - pad->stick_y = stick_y; - } - } -} - -struct ControllerAPI controller_wup = { - controller_wup_init, - controller_wup_read -}; - -#endif diff --git a/src/decomp/pc/controller/controller_wup.h b/src/decomp/pc/controller/controller_wup.h deleted file mode 100644 index 3c5674c..0000000 --- a/src/decomp/pc/controller/controller_wup.h +++ /dev/null @@ -1,12 +0,0 @@ -#ifndef CONTROLLER_WUP_H -#define CONTROLLER_WUP_H - -#ifdef __linux__ - -#include "controller_api.h" - -extern struct ControllerAPI controller_wup; - -#endif - -#endif diff --git a/src/decomp/pc/controller/controller_xinput.c b/src/decomp/pc/controller/controller_xinput.c deleted file mode 100644 index e8634d7..0000000 --- a/src/decomp/pc/controller/controller_xinput.c +++ /dev/null @@ -1,51 +0,0 @@ -#if defined(_WIN32) || defined(_WIN64) - -#include -#include - -#include - -#include "controller_api.h" - -#define DEADZONE 4960 - -static void xinput_init(void) { -} - -static void xinput_read(OSContPad *pad) { - for (int i = 0; i < XUSER_MAX_COUNT; i++) { - XINPUT_STATE state; - memset(&state, 0, sizeof(XINPUT_STATE)); - if (XInputGetState(i, &state) == ERROR_SUCCESS) { - XINPUT_GAMEPAD *gp = &state.Gamepad; - if (gp->wButtons & XINPUT_GAMEPAD_START) pad->button |= START_BUTTON; - if (gp->wButtons & XINPUT_GAMEPAD_LEFT_SHOULDER) pad->button |= Z_TRIG; - if (gp->bLeftTrigger > XINPUT_GAMEPAD_TRIGGER_THRESHOLD) pad->button |= Z_TRIG; - if (gp->wButtons & XINPUT_GAMEPAD_RIGHT_SHOULDER) pad->button |= R_TRIG; - if (gp->bRightTrigger > XINPUT_GAMEPAD_TRIGGER_THRESHOLD) pad->button |= R_TRIG; - if (gp->wButtons & XINPUT_GAMEPAD_A) pad->button |= A_BUTTON; - if (gp->wButtons & XINPUT_GAMEPAD_X) pad->button |= B_BUTTON; - if (gp->wButtons & XINPUT_GAMEPAD_DPAD_LEFT) pad->button |= L_TRIG; - if (gp->sThumbRX < -0x4000) pad->button |= L_CBUTTONS; - if (gp->sThumbRX > 0x4000) pad->button |= R_CBUTTONS; - if (gp->sThumbRY < -0x4000) pad->button |= D_CBUTTONS; - if (gp->sThumbRY > 0x4000) pad->button |= U_CBUTTONS; - - uint32_t magnitude_sq = (uint32_t)(gp->sThumbLX * gp->sThumbLX) + (uint32_t)(gp->sThumbLY * gp->sThumbLY); - if (magnitude_sq > (uint32_t)(DEADZONE * DEADZONE)) { - // Game expects stick coordinates within -80..80 - // 32768 / 409 = ~80 - pad->stick_x = gp->sThumbLX / 409; - pad->stick_y = gp->sThumbLY / 409; - } - break; - } - } -} - -struct ControllerAPI controller_xinput = { - xinput_init, - xinput_read -}; - -#endif diff --git a/src/decomp/pc/controller/controller_xinput.h b/src/decomp/pc/controller/controller_xinput.h deleted file mode 100644 index be1e68c..0000000 --- a/src/decomp/pc/controller/controller_xinput.h +++ /dev/null @@ -1,12 +0,0 @@ -#ifndef CONTROLLER_XINPUT_H -#define CONTROLLER_XINPUT_H - -#if defined(_WIN32) || defined(_WIN64) - -#include "controller_api.h" - -extern struct ControllerAPI controller_xinput; - -#endif - -#endif diff --git a/src/decomp/pc/controller/wup.c b/src/decomp/pc/controller/wup.c deleted file mode 100644 index 9de54c1..0000000 --- a/src/decomp/pc/controller/wup.c +++ /dev/null @@ -1,362 +0,0 @@ -#if !defined(__MINGW32__) && !defined(__BSD__) && !defined(TARGET_WEB) -// See LICENSE for license - -#define _XOPEN_SOURCE 600 - -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include -#include - -//#include -#include -#include - -#include "macros.h" - -#if (!defined(LIBUSBX_API_VERSION) || LIBUSBX_API_VERSION < 0x01000102) && (!defined(LIBUSB_API_VERSION) || LIBUSB_API_VERSION < 0x01000102) -#error libusb(x) 1.0.16 or higher is required -#endif - -#define EP_IN 0x81 -#define EP_OUT 0x02 - -#define STATE_NORMAL 0x10 -#define STATE_WAVEBIRD 0x20 - -const int BUTTON_OFFSET_VALUES[16] = { - BTN_START, - BTN_TR2, - BTN_TR, - BTN_TL, - -1, - -1, - -1, - -1, - BTN_SOUTH, - BTN_WEST, - BTN_EAST, - BTN_NORTH, - BTN_DPAD_LEFT, - BTN_DPAD_RIGHT, - BTN_DPAD_DOWN, - BTN_DPAD_UP, -}; - -const int AXIS_OFFSET_VALUES[6] = { - ABS_X, - ABS_Y, - ABS_RX, - ABS_RY, - ABS_Z, - ABS_RZ -}; - -struct ports -{ - bool connected; - bool extra_power; - unsigned char type; - uint16_t buttons; - uint8_t axis[6]; -}; - -struct adapter -{ - volatile bool quitting; - struct libusb_device *device; - struct libusb_device_handle *handle; - pthread_t thread; - unsigned char rumble[5]; - struct ports controllers[4]; - struct adapter *next; -}; - -static bool raw_mode; - -static volatile int quitting; - -static struct adapter adapters; - -static const char *uinput_path; - -bool wup_get_controller_input(uint16_t *buttons, uint8_t axis[6]) { - struct adapter *adapter = adapters.next; - if (adapter != NULL) { - *buttons = adapter->controllers[0].buttons; - memcpy(axis, adapter->controllers[0].axis, 6); - return true; - } else { - return false; - } -} - -static unsigned char connected_type(unsigned char status) -{ - unsigned char type = status & (STATE_NORMAL | STATE_WAVEBIRD); - switch (type) - { - case STATE_NORMAL: - case STATE_WAVEBIRD: - return type; - default: - return 0; - } -} - -static void handle_payload(int i, struct ports *port, unsigned char *payload) -{ - unsigned char status = payload[0]; - unsigned char type = connected_type(status); - - if (type != 0 && !port->connected) - { - //uinput_create(i, port, type); - port->type = type; - port->connected = true; - } - else if (type == 0 && port->connected) - { - //uinput_destroy(i, port); - port->connected = false; - } - - if (!port->connected) - return; - - port->extra_power = ((status & 0x04) != 0); - - if (type != port->type) - { - fprintf(stderr, "controller on port %d changed controller type???", i+1); - port->type = type; - } - - uint16_t btns = (uint16_t) payload[1] << 8 | (uint16_t) payload[2]; - port->buttons = btns; - //printf("Btns: %04x\n", btns); - - //printf("Axis:"); - for (int j = 0; j < 6; j++) - { - unsigned char value = payload[j+3]; - port->axis[j] = value; - //printf(" %02x", value); - } - //puts(""); -} - -static int64_t to_ms(struct timespec* t) { - return t->tv_sec * 1000 + t->tv_nsec / 1000000; -} - -static void *adapter_thread(void *data) -{ - struct adapter *a = (struct adapter *)data; - - int bytes_transferred; - unsigned char payload[1] = { 0x13 }; - - int transfer_ret = libusb_interrupt_transfer(a->handle, EP_OUT, payload, sizeof(payload), &bytes_transferred, 0); - - if (transfer_ret != 0) { - fprintf(stderr, "libusb_interrupt_transfer: %s\n", libusb_error_name(transfer_ret)); - return NULL; - } - if (bytes_transferred != sizeof(payload)) { - fprintf(stderr, "libusb_interrupt_transfer %d/%lu bytes transferred.\n", bytes_transferred, sizeof(payload)); - return NULL; - } - - while (!a->quitting) - { - //struct timespec time_before = { 0 }, time_after = { 0 }; - unsigned char payload[37]; - int size = 0; - //clock_gettime(CLOCK_MONOTONIC, &time_before); - int transfer_ret = libusb_interrupt_transfer(a->handle, EP_IN, payload, sizeof(payload), &size, 0); - //clock_gettime(CLOCK_MONOTONIC, &time_after); - //printf("Time taken: %d\n", (int)(to_ms(&time_after) - to_ms(&time_before))); - if (transfer_ret != 0) { - fprintf(stderr, "libusb_interrupt_transfer error %d\n", transfer_ret); - a->quitting = true; - break; - } - if (size != 37 || payload[0] != 0x21) - continue; - - unsigned char *controller = &payload[1]; - - unsigned char rumble[5] = { 0x11, 0, 0, 0, 0 }; - //struct timespec current_time = { 0 }; - //clock_gettime(CLOCK_REALTIME, ¤t_time); - //printf("Time: %d %d\n", (int)current_time.tv_sec, (int)current_time.tv_nsec); - for (int i = 0; i < 4; i++, controller += 9) - { - handle_payload(i, &a->controllers[i], controller); - rumble[i+1] = 0; - /*if (a->controllers[i].extra_power && a->controllers[i].type == STATE_NORMAL) - { - for (int j = 0; j < MAX_FF_EVENTS; j++) - { - struct ff_event *e = &a->controllers[i].ff_events[j]; - if (e->in_use) - { - if (ts_lessthan(&e->start_time, ¤t_time) && ts_greaterthan(&e->end_time, ¤t_time)) - rumble[i+1] = 1; - else - update_ff_start_stop(e, ¤t_time); - } - } - }*/ - } - - if (memcmp(rumble, a->rumble, sizeof(rumble)) != 0) - { - memcpy(a->rumble, rumble, sizeof(rumble)); - transfer_ret = libusb_interrupt_transfer(a->handle, EP_OUT, a->rumble, sizeof(a->rumble), &size, 0); - if (transfer_ret != 0) { - fprintf(stderr, "libusb_interrupt_transfer error %d\n", transfer_ret); - a->quitting = true; - break; - } - } - } - - for (int i = 0; i < 4; i++) - { - /*if (a->controllers[i].connected) - uinput_destroy(i, &a->controllers[i]);*/ - } - - return NULL; -} - -static void add_adapter(struct libusb_device *dev) -{ - struct adapter *a = calloc(1, sizeof(struct adapter)); - if (a == NULL) - { - fprintf(stderr, "FATAL: calloc() failed"); - exit(-1); - } - a->device = dev; - - if (libusb_open(a->device, &a->handle) != 0) - { - fprintf(stderr, "Error opening device 0x%p\n", a->device); - return; - } - - if (libusb_kernel_driver_active(a->handle, 0) == 1) { - fprintf(stderr, "Detaching kernel driver\n"); - if (libusb_detach_kernel_driver(a->handle, 0)) { - fprintf(stderr, "Error detaching handle 0x%p from kernel\n", a->handle); - return; - } - } - - struct adapter *old_head = adapters.next; - adapters.next = a; - a->next = old_head; - - pthread_create(&a->thread, NULL, adapter_thread, a); - - fprintf(stderr, "adapter 0x%p connected\n", a->device); -} - -static void remove_adapter(struct libusb_device *dev) -{ - struct adapter *a = &adapters; - while (a->next != NULL) - { - if (a->next->device == dev) - { - a->next->quitting = true; - pthread_join(a->next->thread, NULL); - fprintf(stderr, "adapter 0x%p disconnected\n", a->next->device); - libusb_close(a->next->handle); - struct adapter *new_next = a->next->next; - free(a->next); - a->next = new_next; - return; - } - - a = a->next; - } -} - -static int LIBUSB_CALL hotplug_callback(struct libusb_context *ctx, struct libusb_device *dev, libusb_hotplug_event event, void *user_data) -{ - (void)ctx; - (void)user_data; - if (event == LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED) - { - add_adapter(dev); - } - else if (event == LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT) - { - remove_adapter(dev); - } - - return 0; -} - -void *wup_start(UNUSED void *a) -{ - libusb_init(NULL); - - struct libusb_device **devices; - - int count = libusb_get_device_list(NULL, &devices); - - for (int i = 0; i < count; i++) - { - struct libusb_device_descriptor desc; - libusb_get_device_descriptor(devices[i], &desc); - if (desc.idVendor == 0x057e && desc.idProduct == 0x0337) - add_adapter(devices[i]); - } - - if (count > 0) - libusb_free_device_list(devices, 1); - - libusb_hotplug_callback_handle callback; - - int hotplug_capability = libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG); - if (hotplug_capability) { - int hotplug_ret = libusb_hotplug_register_callback(NULL, - LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED | LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT, - LIBUSB_HOTPLUG_NO_FLAGS, 0x057e, 0x0337, - LIBUSB_HOTPLUG_MATCH_ANY, hotplug_callback, NULL, &callback); - - if (hotplug_ret != LIBUSB_SUCCESS) { - fprintf(stderr, "cannot register hotplug callback, hotplugging not enabled\n"); - hotplug_capability = 0; - } - } - - // pump events until shutdown & all helper threads finish cleaning up - while (!quitting) - libusb_handle_events_completed(NULL, (int *)&quitting); - - while (adapters.next) - remove_adapter(adapters.next->device); - - if (hotplug_capability) - libusb_hotplug_deregister_callback(NULL, callback); - - libusb_exit(NULL); - return (void *)0; -} -#endif diff --git a/src/decomp/pc/dlmalloc.c b/src/decomp/pc/dlmalloc.c deleted file mode 100644 index 27322a6..0000000 --- a/src/decomp/pc/dlmalloc.c +++ /dev/null @@ -1,6289 +0,0 @@ -// Windows has terrible malloc/free performance, so use dlmalloc -// instead. This makes malloc/free time per frame go from order of -// milliseconds to tens of microseconds. -#ifdef _WIN32 -#include -#define FORCEINLINE // define this to nothing to make gcc happy -#define USE_LOCKS 1 - -/* - This is a version (aka dlmalloc) of malloc/free/realloc written by - Doug Lea and released to the public domain, as explained at - http://creativecommons.org/publicdomain/zero/1.0/ Send questions, - comments, complaints, performance data, etc to dl@cs.oswego.edu - -* Version 2.8.6 Wed Aug 29 06:57:58 2012 Doug Lea - Note: There may be an updated version of this malloc obtainable at - ftp://gee.cs.oswego.edu/pub/misc/malloc.c - Check before installing! - -* Quickstart - - This library is all in one file to simplify the most common usage: - ftp it, compile it (-O3), and link it into another program. All of - the compile-time options default to reasonable values for use on - most platforms. You might later want to step through various - compile-time and dynamic tuning options. - - For convenience, an include file for code using this malloc is at: - ftp://gee.cs.oswego.edu/pub/misc/malloc-2.8.6.h - You don't really need this .h file unless you call functions not - defined in your system include files. The .h file contains only the - excerpts from this file needed for using this malloc on ANSI C/C++ - systems, so long as you haven't changed compile-time options about - naming and tuning parameters. If you do, then you can create your - own malloc.h that does include all settings by cutting at the point - indicated below. Note that you may already by default be using a C - library containing a malloc that is based on some version of this - malloc (for example in linux). You might still want to use the one - in this file to customize settings or to avoid overheads associated - with library versions. - -* Vital statistics: - - Supported pointer/size_t representation: 4 or 8 bytes - size_t MUST be an unsigned type of the same width as - pointers. (If you are using an ancient system that declares - size_t as a signed type, or need it to be a different width - than pointers, you can use a previous release of this malloc - (e.g. 2.7.2) supporting these.) - - Alignment: 8 bytes (minimum) - This suffices for nearly all current machines and C compilers. - However, you can define MALLOC_ALIGNMENT to be wider than this - if necessary (up to 128bytes), at the expense of using more space. - - Minimum overhead per allocated chunk: 4 or 8 bytes (if 4byte sizes) - 8 or 16 bytes (if 8byte sizes) - Each malloced chunk has a hidden word of overhead holding size - and status information, and additional cross-check word - if FOOTERS is defined. - - Minimum allocated size: 4-byte ptrs: 16 bytes (including overhead) - 8-byte ptrs: 32 bytes (including overhead) - - Even a request for zero bytes (i.e., malloc(0)) returns a - pointer to something of the minimum allocatable size. - The maximum overhead wastage (i.e., number of extra bytes - allocated than were requested in malloc) is less than or equal - to the minimum size, except for requests >= mmap_threshold that - are serviced via mmap(), where the worst case wastage is about - 32 bytes plus the remainder from a system page (the minimal - mmap unit); typically 4096 or 8192 bytes. - - Security: static-safe; optionally more or less - The "security" of malloc refers to the ability of malicious - code to accentuate the effects of errors (for example, freeing - space that is not currently malloc'ed or overwriting past the - ends of chunks) in code that calls malloc. This malloc - guarantees not to modify any memory locations below the base of - heap, i.e., static variables, even in the presence of usage - errors. The routines additionally detect most improper frees - and reallocs. All this holds as long as the static bookkeeping - for malloc itself is not corrupted by some other means. This - is only one aspect of security -- these checks do not, and - cannot, detect all possible programming errors. - - If FOOTERS is defined nonzero, then each allocated chunk - carries an additional check word to verify that it was malloced - from its space. These check words are the same within each - execution of a program using malloc, but differ across - executions, so externally crafted fake chunks cannot be - freed. This improves security by rejecting frees/reallocs that - could corrupt heap memory, in addition to the checks preventing - writes to statics that are always on. This may further improve - security at the expense of time and space overhead. (Note that - FOOTERS may also be worth using with MSPACES.) - - By default detected errors cause the program to abort (calling - "abort()"). You can override this to instead proceed past - errors by defining PROCEED_ON_ERROR. In this case, a bad free - has no effect, and a malloc that encounters a bad address - caused by user overwrites will ignore the bad address by - dropping pointers and indices to all known memory. This may - be appropriate for programs that should continue if at all - possible in the face of programming errors, although they may - run out of memory because dropped memory is never reclaimed. - - If you don't like either of these options, you can define - CORRUPTION_ERROR_ACTION and USAGE_ERROR_ACTION to do anything - else. And if if you are sure that your program using malloc has - no errors or vulnerabilities, you can define INSECURE to 1, - which might (or might not) provide a small performance improvement. - - It is also possible to limit the maximum total allocatable - space, using malloc_set_footprint_limit. This is not - designed as a security feature in itself (calls to set limits - are not screened or privileged), but may be useful as one - aspect of a secure implementation. - - Thread-safety: NOT thread-safe unless USE_LOCKS defined non-zero - When USE_LOCKS is defined, each public call to malloc, free, - etc is surrounded with a lock. By default, this uses a plain - pthread mutex, win32 critical section, or a spin-lock if if - available for the platform and not disabled by setting - USE_SPIN_LOCKS=0. However, if USE_RECURSIVE_LOCKS is defined, - recursive versions are used instead (which are not required for - base functionality but may be needed in layered extensions). - Using a global lock is not especially fast, and can be a major - bottleneck. It is designed only to provide minimal protection - in concurrent environments, and to provide a basis for - extensions. If you are using malloc in a concurrent program, - consider instead using nedmalloc - (http://www.nedprod.com/programs/portable/nedmalloc/) or - ptmalloc (See http://www.malloc.de), which are derived from - versions of this malloc. - - System requirements: Any combination of MORECORE and/or MMAP/MUNMAP - This malloc can use unix sbrk or any emulation (invoked using - the CALL_MORECORE macro) and/or mmap/munmap or any emulation - (invoked using CALL_MMAP/CALL_MUNMAP) to get and release system - memory. On most unix systems, it tends to work best if both - MORECORE and MMAP are enabled. On Win32, it uses emulations - based on VirtualAlloc. It also uses common C library functions - like memset. - - Compliance: I believe it is compliant with the Single Unix Specification - (See http://www.unix.org). Also SVID/XPG, ANSI C, and probably - others as well. - -* Overview of algorithms - - This is not the fastest, most space-conserving, most portable, or - most tunable malloc ever written. However it is among the fastest - while also being among the most space-conserving, portable and - tunable. Consistent balance across these factors results in a good - general-purpose allocator for malloc-intensive programs. - - In most ways, this malloc is a best-fit allocator. Generally, it - chooses the best-fitting existing chunk for a request, with ties - broken in approximately least-recently-used order. (This strategy - normally maintains low fragmentation.) However, for requests less - than 256bytes, it deviates from best-fit when there is not an - exactly fitting available chunk by preferring to use space adjacent - to that used for the previous small request, as well as by breaking - ties in approximately most-recently-used order. (These enhance - locality of series of small allocations.) And for very large requests - (>= 256Kb by default), it relies on system memory mapping - facilities, if supported. (This helps avoid carrying around and - possibly fragmenting memory used only for large chunks.) - - All operations (except malloc_stats and mallinfo) have execution - times that are bounded by a constant factor of the number of bits in - a size_t, not counting any clearing in calloc or copying in realloc, - or actions surrounding MORECORE and MMAP that have times - proportional to the number of non-contiguous regions returned by - system allocation routines, which is often just 1. In real-time - applications, you can optionally suppress segment traversals using - NO_SEGMENT_TRAVERSAL, which assures bounded execution even when - system allocators return non-contiguous spaces, at the typical - expense of carrying around more memory and increased fragmentation. - - The implementation is not very modular and seriously overuses - macros. Perhaps someday all C compilers will do as good a job - inlining modular code as can now be done by brute-force expansion, - but now, enough of them seem not to. - - Some compilers issue a lot of warnings about code that is - dead/unreachable only on some platforms, and also about intentional - uses of negation on unsigned types. All known cases of each can be - ignored. - - For a longer but out of date high-level description, see - http://gee.cs.oswego.edu/dl/html/malloc.html - -* MSPACES - If MSPACES is defined, then in addition to malloc, free, etc., - this file also defines mspace_malloc, mspace_free, etc. These - are versions of malloc routines that take an "mspace" argument - obtained using create_mspace, to control all internal bookkeeping. - If ONLY_MSPACES is defined, only these versions are compiled. - So if you would like to use this allocator for only some allocations, - and your system malloc for others, you can compile with - ONLY_MSPACES and then do something like... - static mspace mymspace = create_mspace(0,0); // for example - #define mymalloc(bytes) mspace_malloc(mymspace, bytes) - - (Note: If you only need one instance of an mspace, you can instead - use "USE_DL_PREFIX" to relabel the global malloc.) - - You can similarly create thread-local allocators by storing - mspaces as thread-locals. For example: - static __thread mspace tlms = 0; - void* tlmalloc(size_t bytes) { - if (tlms == 0) tlms = create_mspace(0, 0); - return mspace_malloc(tlms, bytes); - } - void tlfree(void* mem) { mspace_free(tlms, mem); } - - Unless FOOTERS is defined, each mspace is completely independent. - You cannot allocate from one and free to another (although - conformance is only weakly checked, so usage errors are not always - caught). If FOOTERS is defined, then each chunk carries around a tag - indicating its originating mspace, and frees are directed to their - originating spaces. Normally, this requires use of locks. - - ------------------------- Compile-time options --------------------------- - -Be careful in setting #define values for numerical constants of type -size_t. On some systems, literal values are not automatically extended -to size_t precision unless they are explicitly casted. You can also -use the symbolic values MAX_SIZE_T, SIZE_T_ONE, etc below. - -WIN32 default: defined if _WIN32 defined - Defining WIN32 sets up defaults for MS environment and compilers. - Otherwise defaults are for unix. Beware that there seem to be some - cases where this malloc might not be a pure drop-in replacement for - Win32 malloc: Random-looking failures from Win32 GDI API's (eg; - SetDIBits()) may be due to bugs in some video driver implementations - when pixel buffers are malloc()ed, and the region spans more than - one VirtualAlloc()ed region. Because dlmalloc uses a small (64Kb) - default granularity, pixel buffers may straddle virtual allocation - regions more often than when using the Microsoft allocator. You can - avoid this by using VirtualAlloc() and VirtualFree() for all pixel - buffers rather than using malloc(). If this is not possible, - recompile this malloc with a larger DEFAULT_GRANULARITY. Note: - in cases where MSC and gcc (cygwin) are known to differ on WIN32, - conditions use _MSC_VER to distinguish them. - -DLMALLOC_EXPORT default: extern - Defines how public APIs are declared. If you want to export via a - Windows DLL, you might define this as - #define DLMALLOC_EXPORT extern __declspec(dllexport) - If you want a POSIX ELF shared object, you might use - #define DLMALLOC_EXPORT extern __attribute__((visibility("default"))) - -MALLOC_ALIGNMENT default: (size_t)(2 * sizeof(void *)) - Controls the minimum alignment for malloc'ed chunks. It must be a - power of two and at least 8, even on machines for which smaller - alignments would suffice. It may be defined as larger than this - though. Note however that code and data structures are optimized for - the case of 8-byte alignment. - -MSPACES default: 0 (false) - If true, compile in support for independent allocation spaces. - This is only supported if HAVE_MMAP is true. - -ONLY_MSPACES default: 0 (false) - If true, only compile in mspace versions, not regular versions. - -USE_LOCKS default: 0 (false) - Causes each call to each public routine to be surrounded with - pthread or WIN32 mutex lock/unlock. (If set true, this can be - overridden on a per-mspace basis for mspace versions.) If set to a - non-zero value other than 1, locks are used, but their - implementation is left out, so lock functions must be supplied manually, - as described below. - -USE_SPIN_LOCKS default: 1 iff USE_LOCKS and spin locks available - If true, uses custom spin locks for locking. This is currently - supported only gcc >= 4.1, older gccs on x86 platforms, and recent - MS compilers. Otherwise, posix locks or win32 critical sections are - used. - -USE_RECURSIVE_LOCKS default: not defined - If defined nonzero, uses recursive (aka reentrant) locks, otherwise - uses plain mutexes. This is not required for malloc proper, but may - be needed for layered allocators such as nedmalloc. - -LOCK_AT_FORK default: not defined - If defined nonzero, performs pthread_atfork upon initialization - to initialize child lock while holding parent lock. The implementation - assumes that pthread locks (not custom locks) are being used. In other - cases, you may need to customize the implementation. - -FOOTERS default: 0 - If true, provide extra checking and dispatching by placing - information in the footers of allocated chunks. This adds - space and time overhead. - -INSECURE default: 0 - If true, omit checks for usage errors and heap space overwrites. - -USE_DL_PREFIX default: NOT defined - Causes compiler to prefix all public routines with the string 'dl'. - This can be useful when you only want to use this malloc in one part - of a program, using your regular system malloc elsewhere. - -MALLOC_INSPECT_ALL default: NOT defined - If defined, compiles malloc_inspect_all and mspace_inspect_all, that - perform traversal of all heap space. Unless access to these - functions is otherwise restricted, you probably do not want to - include them in secure implementations. - -ABORT default: defined as abort() - Defines how to abort on failed checks. On most systems, a failed - check cannot die with an "assert" or even print an informative - message, because the underlying print routines in turn call malloc, - which will fail again. Generally, the best policy is to simply call - abort(). It's not very useful to do more than this because many - errors due to overwriting will show up as address faults (null, odd - addresses etc) rather than malloc-triggered checks, so will also - abort. Also, most compilers know that abort() does not return, so - can better optimize code conditionally calling it. - -PROCEED_ON_ERROR default: defined as 0 (false) - Controls whether detected bad addresses cause them to bypassed - rather than aborting. If set, detected bad arguments to free and - realloc are ignored. And all bookkeeping information is zeroed out - upon a detected overwrite of freed heap space, thus losing the - ability to ever return it from malloc again, but enabling the - application to proceed. If PROCEED_ON_ERROR is defined, the - static variable malloc_corruption_error_count is compiled in - and can be examined to see if errors have occurred. This option - generates slower code than the default abort policy. - -DEBUG default: NOT defined - The DEBUG setting is mainly intended for people trying to modify - this code or diagnose problems when porting to new platforms. - However, it may also be able to better isolate user errors than just - using runtime checks. The assertions in the check routines spell - out in more detail the assumptions and invariants underlying the - algorithms. The checking is fairly extensive, and will slow down - execution noticeably. Calling malloc_stats or mallinfo with DEBUG - set will attempt to check every non-mmapped allocated and free chunk - in the course of computing the summaries. - -ABORT_ON_ASSERT_FAILURE default: defined as 1 (true) - Debugging assertion failures can be nearly impossible if your - version of the assert macro causes malloc to be called, which will - lead to a cascade of further failures, blowing the runtime stack. - ABORT_ON_ASSERT_FAILURE cause assertions failures to call abort(), - which will usually make debugging easier. - -MALLOC_FAILURE_ACTION default: sets errno to ENOMEM, or no-op on win32 - The action to take before "return 0" when malloc fails to be able to - return memory because there is none available. - -HAVE_MORECORE default: 1 (true) unless win32 or ONLY_MSPACES - True if this system supports sbrk or an emulation of it. - -MORECORE default: sbrk - The name of the sbrk-style system routine to call to obtain more - memory. See below for guidance on writing custom MORECORE - functions. The type of the argument to sbrk/MORECORE varies across - systems. It cannot be size_t, because it supports negative - arguments, so it is normally the signed type of the same width as - size_t (sometimes declared as "intptr_t"). It doesn't much matter - though. Internally, we only call it with arguments less than half - the max value of a size_t, which should work across all reasonable - possibilities, although sometimes generating compiler warnings. - -MORECORE_CONTIGUOUS default: 1 (true) if HAVE_MORECORE - If true, take advantage of fact that consecutive calls to MORECORE - with positive arguments always return contiguous increasing - addresses. This is true of unix sbrk. It does not hurt too much to - set it true anyway, since malloc copes with non-contiguities. - Setting it false when definitely non-contiguous saves time - and possibly wasted space it would take to discover this though. - -MORECORE_CANNOT_TRIM default: NOT defined - True if MORECORE cannot release space back to the system when given - negative arguments. This is generally necessary only if you are - using a hand-crafted MORECORE function that cannot handle negative - arguments. - -NO_SEGMENT_TRAVERSAL default: 0 - If non-zero, suppresses traversals of memory segments - returned by either MORECORE or CALL_MMAP. This disables - merging of segments that are contiguous, and selectively - releasing them to the OS if unused, but bounds execution times. - -HAVE_MMAP default: 1 (true) - True if this system supports mmap or an emulation of it. If so, and - HAVE_MORECORE is not true, MMAP is used for all system - allocation. If set and HAVE_MORECORE is true as well, MMAP is - primarily used to directly allocate very large blocks. It is also - used as a backup strategy in cases where MORECORE fails to provide - space from system. Note: A single call to MUNMAP is assumed to be - able to unmap memory that may have be allocated using multiple calls - to MMAP, so long as they are adjacent. - -HAVE_MREMAP default: 1 on linux, else 0 - If true realloc() uses mremap() to re-allocate large blocks and - extend or shrink allocation spaces. - -MMAP_CLEARS default: 1 except on WINCE. - True if mmap clears memory so calloc doesn't need to. This is true - for standard unix mmap using /dev/zero and on WIN32 except for WINCE. - -USE_BUILTIN_FFS default: 0 (i.e., not used) - Causes malloc to use the builtin ffs() function to compute indices. - Some compilers may recognize and intrinsify ffs to be faster than the - supplied C version. Also, the case of x86 using gcc is special-cased - to an asm instruction, so is already as fast as it can be, and so - this setting has no effect. Similarly for Win32 under recent MS compilers. - (On most x86s, the asm version is only slightly faster than the C version.) - -malloc_getpagesize default: derive from system includes, or 4096. - The system page size. To the extent possible, this malloc manages - memory from the system in page-size units. This may be (and - usually is) a function rather than a constant. This is ignored - if WIN32, where page size is determined using getSystemInfo during - initialization. - -USE_DEV_RANDOM default: 0 (i.e., not used) - Causes malloc to use /dev/random to initialize secure magic seed for - stamping footers. Otherwise, the current time is used. - -NO_MALLINFO default: 0 - If defined, don't compile "mallinfo". This can be a simple way - of dealing with mismatches between system declarations and - those in this file. - -MALLINFO_FIELD_TYPE default: size_t - The type of the fields in the mallinfo struct. This was originally - defined as "int" in SVID etc, but is more usefully defined as - size_t. The value is used only if HAVE_USR_INCLUDE_MALLOC_H is not set - -NO_MALLOC_STATS default: 0 - If defined, don't compile "malloc_stats". This avoids calls to - fprintf and bringing in stdio dependencies you might not want. - -REALLOC_ZERO_BYTES_FREES default: not defined - This should be set if a call to realloc with zero bytes should - be the same as a call to free. Some people think it should. Otherwise, - since this malloc returns a unique pointer for malloc(0), so does - realloc(p, 0). - -LACKS_UNISTD_H, LACKS_FCNTL_H, LACKS_SYS_PARAM_H, LACKS_SYS_MMAN_H -LACKS_STRINGS_H, LACKS_STRING_H, LACKS_SYS_TYPES_H, LACKS_ERRNO_H -LACKS_STDLIB_H LACKS_SCHED_H LACKS_TIME_H default: NOT defined unless on WIN32 - Define these if your system does not have these header files. - You might need to manually insert some of the declarations they provide. - -DEFAULT_GRANULARITY default: page size if MORECORE_CONTIGUOUS, - system_info.dwAllocationGranularity in WIN32, - otherwise 64K. - Also settable using mallopt(M_GRANULARITY, x) - The unit for allocating and deallocating memory from the system. On - most systems with contiguous MORECORE, there is no reason to - make this more than a page. However, systems with MMAP tend to - either require or encourage larger granularities. You can increase - this value to prevent system allocation functions to be called so - often, especially if they are slow. The value must be at least one - page and must be a power of two. Setting to 0 causes initialization - to either page size or win32 region size. (Note: In previous - versions of malloc, the equivalent of this option was called - "TOP_PAD") - -DEFAULT_TRIM_THRESHOLD default: 2MB - Also settable using mallopt(M_TRIM_THRESHOLD, x) - The maximum amount of unused top-most memory to keep before - releasing via malloc_trim in free(). Automatic trimming is mainly - useful in long-lived programs using contiguous MORECORE. Because - trimming via sbrk can be slow on some systems, and can sometimes be - wasteful (in cases where programs immediately afterward allocate - more large chunks) the value should be high enough so that your - overall system performance would improve by releasing this much - memory. As a rough guide, you might set to a value close to the - average size of a process (program) running on your system. - Releasing this much memory would allow such a process to run in - memory. Generally, it is worth tuning trim thresholds when a - program undergoes phases where several large chunks are allocated - and released in ways that can reuse each other's storage, perhaps - mixed with phases where there are no such chunks at all. The trim - value must be greater than page size to have any useful effect. To - disable trimming completely, you can set to MAX_SIZE_T. Note that the trick - some people use of mallocing a huge space and then freeing it at - program startup, in an attempt to reserve system memory, doesn't - have the intended effect under automatic trimming, since that memory - will immediately be returned to the system. - -DEFAULT_MMAP_THRESHOLD default: 256K - Also settable using mallopt(M_MMAP_THRESHOLD, x) - The request size threshold for using MMAP to directly service a - request. Requests of at least this size that cannot be allocated - using already-existing space will be serviced via mmap. (If enough - normal freed space already exists it is used instead.) Using mmap - segregates relatively large chunks of memory so that they can be - individually obtained and released from the host system. A request - serviced through mmap is never reused by any other request (at least - not directly; the system may just so happen to remap successive - requests to the same locations). Segregating space in this way has - the benefits that: Mmapped space can always be individually released - back to the system, which helps keep the system level memory demands - of a long-lived program low. Also, mapped memory doesn't become - `locked' between other chunks, as can happen with normally allocated - chunks, which means that even trimming via malloc_trim would not - release them. However, it has the disadvantage that the space - cannot be reclaimed, consolidated, and then used to service later - requests, as happens with normal chunks. The advantages of mmap - nearly always outweigh disadvantages for "large" chunks, but the - value of "large" may vary across systems. The default is an - empirically derived value that works well in most systems. You can - disable mmap by setting to MAX_SIZE_T. - -MAX_RELEASE_CHECK_RATE default: 4095 unless not HAVE_MMAP - The number of consolidated frees between checks to release - unused segments when freeing. When using non-contiguous segments, - especially with multiple mspaces, checking only for topmost space - doesn't always suffice to trigger trimming. To compensate for this, - free() will, with a period of MAX_RELEASE_CHECK_RATE (or the - current number of segments, if greater) try to release unused - segments to the OS when freeing chunks that result in - consolidation. The best value for this parameter is a compromise - between slowing down frees with relatively costly checks that - rarely trigger versus holding on to unused memory. To effectively - disable, set to MAX_SIZE_T. This may lead to a very slight speed - improvement at the expense of carrying around more memory. -*/ - -/* Version identifier to allow people to support multiple versions */ -#ifndef DLMALLOC_VERSION -#define DLMALLOC_VERSION 20806 -#endif /* DLMALLOC_VERSION */ - -#ifndef DLMALLOC_EXPORT -#define DLMALLOC_EXPORT extern -#endif - -#ifndef WIN32 -#ifdef _WIN32 -#define WIN32 1 -#endif /* _WIN32 */ -#ifdef _WIN32_WCE -#define LACKS_FCNTL_H -#define WIN32 1 -#endif /* _WIN32_WCE */ -#endif /* WIN32 */ -#ifdef WIN32 -#define WIN32_LEAN_AND_MEAN -#include -#include -#define HAVE_MMAP 1 -#define HAVE_MORECORE 0 -#define LACKS_UNISTD_H -#define LACKS_SYS_PARAM_H -#define LACKS_SYS_MMAN_H -#define LACKS_STRING_H -#define LACKS_STRINGS_H -#define LACKS_SYS_TYPES_H -#define LACKS_ERRNO_H -#define LACKS_SCHED_H -#ifndef MALLOC_FAILURE_ACTION -#define MALLOC_FAILURE_ACTION -#endif /* MALLOC_FAILURE_ACTION */ -#ifndef MMAP_CLEARS -#ifdef _WIN32_WCE /* WINCE reportedly does not clear */ -#define MMAP_CLEARS 0 -#else -#define MMAP_CLEARS 1 -#endif /* _WIN32_WCE */ -#endif /*MMAP_CLEARS */ -#endif /* WIN32 */ - -#if defined(DARWIN) || defined(_DARWIN) -/* Mac OSX docs advise not to use sbrk; it seems better to use mmap */ -#ifndef HAVE_MORECORE -#define HAVE_MORECORE 0 -#define HAVE_MMAP 1 -/* OSX allocators provide 16 byte alignment */ -#ifndef MALLOC_ALIGNMENT -#define MALLOC_ALIGNMENT ((size_t)16U) -#endif -#endif /* HAVE_MORECORE */ -#endif /* DARWIN */ - -#ifndef LACKS_SYS_TYPES_H -#include /* For size_t */ -#endif /* LACKS_SYS_TYPES_H */ - -/* The maximum possible size_t value has all bits set */ -#define MAX_SIZE_T (~(size_t)0) - -#ifndef USE_LOCKS /* ensure true if spin or recursive locks set */ -#define USE_LOCKS ((defined(USE_SPIN_LOCKS) && USE_SPIN_LOCKS != 0) || \ - (defined(USE_RECURSIVE_LOCKS) && USE_RECURSIVE_LOCKS != 0)) -#endif /* USE_LOCKS */ - -#if USE_LOCKS /* Spin locks for gcc >= 4.1, older gcc on x86, MSC >= 1310 */ -#if ((defined(__GNUC__) && \ - ((__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)) || \ - defined(__i386__) || defined(__x86_64__))) || \ - (defined(_MSC_VER) && _MSC_VER>=1310)) -#ifndef USE_SPIN_LOCKS -#define USE_SPIN_LOCKS 1 -#endif /* USE_SPIN_LOCKS */ -#elif USE_SPIN_LOCKS -#error "USE_SPIN_LOCKS defined without implementation" -#endif /* ... locks available... */ -#elif !defined(USE_SPIN_LOCKS) -#define USE_SPIN_LOCKS 0 -#endif /* USE_LOCKS */ - -#ifndef ONLY_MSPACES -#define ONLY_MSPACES 0 -#endif /* ONLY_MSPACES */ -#ifndef MSPACES -#if ONLY_MSPACES -#define MSPACES 1 -#else /* ONLY_MSPACES */ -#define MSPACES 0 -#endif /* ONLY_MSPACES */ -#endif /* MSPACES */ -#ifndef MALLOC_ALIGNMENT -#define MALLOC_ALIGNMENT ((size_t)(2 * sizeof(void *))) -#endif /* MALLOC_ALIGNMENT */ -#ifndef FOOTERS -#define FOOTERS 0 -#endif /* FOOTERS */ -#ifndef ABORT -#define ABORT abort() -#endif /* ABORT */ -#ifndef ABORT_ON_ASSERT_FAILURE -#define ABORT_ON_ASSERT_FAILURE 1 -#endif /* ABORT_ON_ASSERT_FAILURE */ -#ifndef PROCEED_ON_ERROR -#define PROCEED_ON_ERROR 0 -#endif /* PROCEED_ON_ERROR */ - -#ifndef INSECURE -#define INSECURE 0 -#endif /* INSECURE */ -#ifndef MALLOC_INSPECT_ALL -#define MALLOC_INSPECT_ALL 0 -#endif /* MALLOC_INSPECT_ALL */ -#ifndef HAVE_MMAP -#define HAVE_MMAP 1 -#endif /* HAVE_MMAP */ -#ifndef MMAP_CLEARS -#define MMAP_CLEARS 1 -#endif /* MMAP_CLEARS */ -#ifndef HAVE_MREMAP -#ifdef linux -#define HAVE_MREMAP 1 -#define _GNU_SOURCE /* Turns on mremap() definition */ -#else /* linux */ -#define HAVE_MREMAP 0 -#endif /* linux */ -#endif /* HAVE_MREMAP */ -#ifndef MALLOC_FAILURE_ACTION -#define MALLOC_FAILURE_ACTION errno = ENOMEM; -#endif /* MALLOC_FAILURE_ACTION */ -#ifndef HAVE_MORECORE -#if ONLY_MSPACES -#define HAVE_MORECORE 0 -#else /* ONLY_MSPACES */ -#define HAVE_MORECORE 1 -#endif /* ONLY_MSPACES */ -#endif /* HAVE_MORECORE */ -#if !HAVE_MORECORE -#define MORECORE_CONTIGUOUS 0 -#else /* !HAVE_MORECORE */ -#define MORECORE_DEFAULT sbrk -#ifndef MORECORE_CONTIGUOUS -#define MORECORE_CONTIGUOUS 1 -#endif /* MORECORE_CONTIGUOUS */ -#endif /* HAVE_MORECORE */ -#ifndef DEFAULT_GRANULARITY -#if (MORECORE_CONTIGUOUS || defined(WIN32)) -#define DEFAULT_GRANULARITY (0) /* 0 means to compute in init_mparams */ -#else /* MORECORE_CONTIGUOUS */ -#define DEFAULT_GRANULARITY ((size_t)64U * (size_t)1024U) -#endif /* MORECORE_CONTIGUOUS */ -#endif /* DEFAULT_GRANULARITY */ -#ifndef DEFAULT_TRIM_THRESHOLD -#ifndef MORECORE_CANNOT_TRIM -#define DEFAULT_TRIM_THRESHOLD ((size_t)2U * (size_t)1024U * (size_t)1024U) -#else /* MORECORE_CANNOT_TRIM */ -#define DEFAULT_TRIM_THRESHOLD MAX_SIZE_T -#endif /* MORECORE_CANNOT_TRIM */ -#endif /* DEFAULT_TRIM_THRESHOLD */ -#ifndef DEFAULT_MMAP_THRESHOLD -#if HAVE_MMAP -#define DEFAULT_MMAP_THRESHOLD ((size_t)256U * (size_t)1024U) -#else /* HAVE_MMAP */ -#define DEFAULT_MMAP_THRESHOLD MAX_SIZE_T -#endif /* HAVE_MMAP */ -#endif /* DEFAULT_MMAP_THRESHOLD */ -#ifndef MAX_RELEASE_CHECK_RATE -#if HAVE_MMAP -#define MAX_RELEASE_CHECK_RATE 4095 -#else -#define MAX_RELEASE_CHECK_RATE MAX_SIZE_T -#endif /* HAVE_MMAP */ -#endif /* MAX_RELEASE_CHECK_RATE */ -#ifndef USE_BUILTIN_FFS -#define USE_BUILTIN_FFS 0 -#endif /* USE_BUILTIN_FFS */ -#ifndef USE_DEV_RANDOM -#define USE_DEV_RANDOM 0 -#endif /* USE_DEV_RANDOM */ -#ifndef NO_MALLINFO -#define NO_MALLINFO 0 -#endif /* NO_MALLINFO */ -#ifndef MALLINFO_FIELD_TYPE -#define MALLINFO_FIELD_TYPE size_t -#endif /* MALLINFO_FIELD_TYPE */ -#ifndef NO_MALLOC_STATS -#define NO_MALLOC_STATS 0 -#endif /* NO_MALLOC_STATS */ -#ifndef NO_SEGMENT_TRAVERSAL -#define NO_SEGMENT_TRAVERSAL 0 -#endif /* NO_SEGMENT_TRAVERSAL */ - -/* - mallopt tuning options. SVID/XPG defines four standard parameter - numbers for mallopt, normally defined in malloc.h. None of these - are used in this malloc, so setting them has no effect. But this - malloc does support the following options. -*/ - -#define M_TRIM_THRESHOLD (-1) -#define M_GRANULARITY (-2) -#define M_MMAP_THRESHOLD (-3) - -/* ------------------------ Mallinfo declarations ------------------------ */ - -#if !NO_MALLINFO -/* - This version of malloc supports the standard SVID/XPG mallinfo - routine that returns a struct containing usage properties and - statistics. It should work on any system that has a - /usr/include/malloc.h defining struct mallinfo. The main - declaration needed is the mallinfo struct that is returned (by-copy) - by mallinfo(). The malloinfo struct contains a bunch of fields that - are not even meaningful in this version of malloc. These fields are - are instead filled by mallinfo() with other numbers that might be of - interest. - - HAVE_USR_INCLUDE_MALLOC_H should be set if you have a - /usr/include/malloc.h file that includes a declaration of struct - mallinfo. If so, it is included; else a compliant version is - declared below. These must be precisely the same for mallinfo() to - work. The original SVID version of this struct, defined on most - systems with mallinfo, declares all fields as ints. But some others - define as unsigned long. If your system defines the fields using a - type of different width than listed here, you MUST #include your - system version and #define HAVE_USR_INCLUDE_MALLOC_H. -*/ - -/* #define HAVE_USR_INCLUDE_MALLOC_H */ - -#ifdef HAVE_USR_INCLUDE_MALLOC_H -#include "/usr/include/malloc.h" -#else /* HAVE_USR_INCLUDE_MALLOC_H */ -#ifndef STRUCT_MALLINFO_DECLARED -/* HP-UX (and others?) redefines mallinfo unless _STRUCT_MALLINFO is defined */ -#define _STRUCT_MALLINFO -#define STRUCT_MALLINFO_DECLARED 1 -struct mallinfo { - MALLINFO_FIELD_TYPE arena; /* non-mmapped space allocated from system */ - MALLINFO_FIELD_TYPE ordblks; /* number of free chunks */ - MALLINFO_FIELD_TYPE smblks; /* always 0 */ - MALLINFO_FIELD_TYPE hblks; /* always 0 */ - MALLINFO_FIELD_TYPE hblkhd; /* space in mmapped regions */ - MALLINFO_FIELD_TYPE usmblks; /* maximum total allocated space */ - MALLINFO_FIELD_TYPE fsmblks; /* always 0 */ - MALLINFO_FIELD_TYPE uordblks; /* total allocated space */ - MALLINFO_FIELD_TYPE fordblks; /* total free space */ - MALLINFO_FIELD_TYPE keepcost; /* releasable (via malloc_trim) space */ -}; -#endif /* STRUCT_MALLINFO_DECLARED */ -#endif /* HAVE_USR_INCLUDE_MALLOC_H */ -#endif /* NO_MALLINFO */ - -/* - Try to persuade compilers to inline. The most critical functions for - inlining are defined as macros, so these aren't used for them. -*/ - -#ifndef FORCEINLINE - #if defined(__GNUC__) -#define FORCEINLINE __inline __attribute__ ((always_inline)) - #elif defined(_MSC_VER) - #define FORCEINLINE __forceinline - #endif -#endif -#ifndef NOINLINE - #if defined(__GNUC__) - #define NOINLINE __attribute__ ((noinline)) - #elif defined(_MSC_VER) - #define NOINLINE __declspec(noinline) - #else - #define NOINLINE - #endif -#endif - -#ifdef __cplusplus -extern "C" { -#ifndef FORCEINLINE - #define FORCEINLINE inline -#endif -#endif /* __cplusplus */ -#ifndef FORCEINLINE - #define FORCEINLINE -#endif - -#if !ONLY_MSPACES - -/* ------------------- Declarations of public routines ------------------- */ - -#ifndef USE_DL_PREFIX -#define dlcalloc calloc -#define dlfree free -#define dlmalloc malloc -#define dlmemalign memalign -#define dlposix_memalign posix_memalign -#define dlrealloc realloc -#define dlrealloc_in_place realloc_in_place -#define dlvalloc valloc -#define dlpvalloc pvalloc -#define dlmallinfo mallinfo -#define dlmallopt mallopt -#define dlmalloc_trim malloc_trim -#define dlmalloc_stats malloc_stats -#define dlmalloc_usable_size malloc_usable_size -#define dlmalloc_footprint malloc_footprint -#define dlmalloc_max_footprint malloc_max_footprint -#define dlmalloc_footprint_limit malloc_footprint_limit -#define dlmalloc_set_footprint_limit malloc_set_footprint_limit -#define dlmalloc_inspect_all malloc_inspect_all -#define dlindependent_calloc independent_calloc -#define dlindependent_comalloc independent_comalloc -#define dlbulk_free bulk_free -#endif /* USE_DL_PREFIX */ - -/* - malloc(size_t n) - Returns a pointer to a newly allocated chunk of at least n bytes, or - null if no space is available, in which case errno is set to ENOMEM - on ANSI C systems. - - If n is zero, malloc returns a minimum-sized chunk. (The minimum - size is 16 bytes on most 32bit systems, and 32 bytes on 64bit - systems.) Note that size_t is an unsigned type, so calls with - arguments that would be negative if signed are interpreted as - requests for huge amounts of space, which will often fail. The - maximum supported value of n differs across systems, but is in all - cases less than the maximum representable value of a size_t. -*/ -DLMALLOC_EXPORT void* dlmalloc(size_t); - -/* - free(void* p) - Releases the chunk of memory pointed to by p, that had been previously - allocated using malloc or a related routine such as realloc. - It has no effect if p is null. If p was not malloced or already - freed, free(p) will by default cause the current program to abort. -*/ -DLMALLOC_EXPORT void dlfree(void*); - -/* - calloc(size_t n_elements, size_t element_size); - Returns a pointer to n_elements * element_size bytes, with all locations - set to zero. -*/ -DLMALLOC_EXPORT void* dlcalloc(size_t, size_t); - -/* - realloc(void* p, size_t n) - Returns a pointer to a chunk of size n that contains the same data - as does chunk p up to the minimum of (n, p's size) bytes, or null - if no space is available. - - The returned pointer may or may not be the same as p. The algorithm - prefers extending p in most cases when possible, otherwise it - employs the equivalent of a malloc-copy-free sequence. - - If p is null, realloc is equivalent to malloc. - - If space is not available, realloc returns null, errno is set (if on - ANSI) and p is NOT freed. - - if n is for fewer bytes than already held by p, the newly unused - space is lopped off and freed if possible. realloc with a size - argument of zero (re)allocates a minimum-sized chunk. - - The old unix realloc convention of allowing the last-free'd chunk - to be used as an argument to realloc is not supported. -*/ -DLMALLOC_EXPORT void* dlrealloc(void*, size_t); - -/* - realloc_in_place(void* p, size_t n) - Resizes the space allocated for p to size n, only if this can be - done without moving p (i.e., only if there is adjacent space - available if n is greater than p's current allocated size, or n is - less than or equal to p's size). This may be used instead of plain - realloc if an alternative allocation strategy is needed upon failure - to expand space; for example, reallocation of a buffer that must be - memory-aligned or cleared. You can use realloc_in_place to trigger - these alternatives only when needed. - - Returns p if successful; otherwise null. -*/ -DLMALLOC_EXPORT void* dlrealloc_in_place(void*, size_t); - -/* - memalign(size_t alignment, size_t n); - Returns a pointer to a newly allocated chunk of n bytes, aligned - in accord with the alignment argument. - - The alignment argument should be a power of two. If the argument is - not a power of two, the nearest greater power is used. - 8-byte alignment is guaranteed by normal malloc calls, so don't - bother calling memalign with an argument of 8 or less. - - Overreliance on memalign is a sure way to fragment space. -*/ -DLMALLOC_EXPORT void* dlmemalign(size_t, size_t); - -/* - int posix_memalign(void** pp, size_t alignment, size_t n); - Allocates a chunk of n bytes, aligned in accord with the alignment - argument. Differs from memalign only in that it (1) assigns the - allocated memory to *pp rather than returning it, (2) fails and - returns EINVAL if the alignment is not a power of two (3) fails and - returns ENOMEM if memory cannot be allocated. -*/ -DLMALLOC_EXPORT int dlposix_memalign(void**, size_t, size_t); - -/* - valloc(size_t n); - Equivalent to memalign(pagesize, n), where pagesize is the page - size of the system. If the pagesize is unknown, 4096 is used. -*/ -DLMALLOC_EXPORT void* dlvalloc(size_t); - -/* - mallopt(int parameter_number, int parameter_value) - Sets tunable parameters The format is to provide a - (parameter-number, parameter-value) pair. mallopt then sets the - corresponding parameter to the argument value if it can (i.e., so - long as the value is meaningful), and returns 1 if successful else - 0. To workaround the fact that mallopt is specified to use int, - not size_t parameters, the value -1 is specially treated as the - maximum unsigned size_t value. - - SVID/XPG/ANSI defines four standard param numbers for mallopt, - normally defined in malloc.h. None of these are use in this malloc, - so setting them has no effect. But this malloc also supports other - options in mallopt. See below for details. Briefly, supported - parameters are as follows (listed defaults are for "typical" - configurations). - - Symbol param # default allowed param values - M_TRIM_THRESHOLD -1 2*1024*1024 any (-1 disables) - M_GRANULARITY -2 page size any power of 2 >= page size - M_MMAP_THRESHOLD -3 256*1024 any (or 0 if no MMAP support) -*/ -DLMALLOC_EXPORT int dlmallopt(int, int); - -/* - malloc_footprint(); - Returns the number of bytes obtained from the system. The total - number of bytes allocated by malloc, realloc etc., is less than this - value. Unlike mallinfo, this function returns only a precomputed - result, so can be called frequently to monitor memory consumption. - Even if locks are otherwise defined, this function does not use them, - so results might not be up to date. -*/ -DLMALLOC_EXPORT size_t dlmalloc_footprint(void); - -/* - malloc_max_footprint(); - Returns the maximum number of bytes obtained from the system. This - value will be greater than current footprint if deallocated space - has been reclaimed by the system. The peak number of bytes allocated - by malloc, realloc etc., is less than this value. Unlike mallinfo, - this function returns only a precomputed result, so can be called - frequently to monitor memory consumption. Even if locks are - otherwise defined, this function does not use them, so results might - not be up to date. -*/ -DLMALLOC_EXPORT size_t dlmalloc_max_footprint(void); - -/* - malloc_footprint_limit(); - Returns the number of bytes that the heap is allowed to obtain from - the system, returning the last value returned by - malloc_set_footprint_limit, or the maximum size_t value if - never set. The returned value reflects a permission. There is no - guarantee that this number of bytes can actually be obtained from - the system. -*/ -DLMALLOC_EXPORT size_t dlmalloc_footprint_limit(); - -/* - malloc_set_footprint_limit(); - Sets the maximum number of bytes to obtain from the system, causing - failure returns from malloc and related functions upon attempts to - exceed this value. The argument value may be subject to page - rounding to an enforceable limit; this actual value is returned. - Using an argument of the maximum possible size_t effectively - disables checks. If the argument is less than or equal to the - current malloc_footprint, then all future allocations that require - additional system memory will fail. However, invocation cannot - retroactively deallocate existing used memory. -*/ -DLMALLOC_EXPORT size_t dlmalloc_set_footprint_limit(size_t bytes); - -#if MALLOC_INSPECT_ALL -/* - malloc_inspect_all(void(*handler)(void *start, - void *end, - size_t used_bytes, - void* callback_arg), - void* arg); - Traverses the heap and calls the given handler for each managed - region, skipping all bytes that are (or may be) used for bookkeeping - purposes. Traversal does not include include chunks that have been - directly memory mapped. Each reported region begins at the start - address, and continues up to but not including the end address. The - first used_bytes of the region contain allocated data. If - used_bytes is zero, the region is unallocated. The handler is - invoked with the given callback argument. If locks are defined, they - are held during the entire traversal. It is a bad idea to invoke - other malloc functions from within the handler. - - For example, to count the number of in-use chunks with size greater - than 1000, you could write: - static int count = 0; - void count_chunks(void* start, void* end, size_t used, void* arg) { - if (used >= 1000) ++count; - } - then: - malloc_inspect_all(count_chunks, NULL); - - malloc_inspect_all is compiled only if MALLOC_INSPECT_ALL is defined. -*/ -DLMALLOC_EXPORT void dlmalloc_inspect_all(void(*handler)(void*, void *, size_t, void*), - void* arg); - -#endif /* MALLOC_INSPECT_ALL */ - -#if !NO_MALLINFO -/* - mallinfo() - Returns (by copy) a struct containing various summary statistics: - - arena: current total non-mmapped bytes allocated from system - ordblks: the number of free chunks - smblks: always zero. - hblks: current number of mmapped regions - hblkhd: total bytes held in mmapped regions - usmblks: the maximum total allocated space. This will be greater - than current total if trimming has occurred. - fsmblks: always zero - uordblks: current total allocated space (normal or mmapped) - fordblks: total free space - keepcost: the maximum number of bytes that could ideally be released - back to system via malloc_trim. ("ideally" means that - it ignores page restrictions etc.) - - Because these fields are ints, but internal bookkeeping may - be kept as longs, the reported values may wrap around zero and - thus be inaccurate. -*/ -DLMALLOC_EXPORT struct mallinfo dlmallinfo(void); -#endif /* NO_MALLINFO */ - -/* - independent_calloc(size_t n_elements, size_t element_size, void* chunks[]); - - independent_calloc is similar to calloc, but instead of returning a - single cleared space, it returns an array of pointers to n_elements - independent elements that can hold contents of size elem_size, each - of which starts out cleared, and can be independently freed, - realloc'ed etc. The elements are guaranteed to be adjacently - allocated (this is not guaranteed to occur with multiple callocs or - mallocs), which may also improve cache locality in some - applications. - - The "chunks" argument is optional (i.e., may be null, which is - probably the most typical usage). If it is null, the returned array - is itself dynamically allocated and should also be freed when it is - no longer needed. Otherwise, the chunks array must be of at least - n_elements in length. It is filled in with the pointers to the - chunks. - - In either case, independent_calloc returns this pointer array, or - null if the allocation failed. If n_elements is zero and "chunks" - is null, it returns a chunk representing an array with zero elements - (which should be freed if not wanted). - - Each element must be freed when it is no longer needed. This can be - done all at once using bulk_free. - - independent_calloc simplifies and speeds up implementations of many - kinds of pools. It may also be useful when constructing large data - structures that initially have a fixed number of fixed-sized nodes, - but the number is not known at compile time, and some of the nodes - may later need to be freed. For example: - - struct Node { int item; struct Node* next; }; - - struct Node* build_list() { - struct Node** pool; - int n = read_number_of_nodes_needed(); - if (n <= 0) return 0; - pool = (struct Node**)(independent_calloc(n, sizeof(struct Node), 0); - if (pool == 0) die(); - // organize into a linked list... - struct Node* first = pool[0]; - for (i = 0; i < n-1; ++i) - pool[i]->next = pool[i+1]; - free(pool); // Can now free the array (or not, if it is needed later) - return first; - } -*/ -DLMALLOC_EXPORT void** dlindependent_calloc(size_t, size_t, void**); - -/* - independent_comalloc(size_t n_elements, size_t sizes[], void* chunks[]); - - independent_comalloc allocates, all at once, a set of n_elements - chunks with sizes indicated in the "sizes" array. It returns - an array of pointers to these elements, each of which can be - independently freed, realloc'ed etc. The elements are guaranteed to - be adjacently allocated (this is not guaranteed to occur with - multiple callocs or mallocs), which may also improve cache locality - in some applications. - - The "chunks" argument is optional (i.e., may be null). If it is null - the returned array is itself dynamically allocated and should also - be freed when it is no longer needed. Otherwise, the chunks array - must be of at least n_elements in length. It is filled in with the - pointers to the chunks. - - In either case, independent_comalloc returns this pointer array, or - null if the allocation failed. If n_elements is zero and chunks is - null, it returns a chunk representing an array with zero elements - (which should be freed if not wanted). - - Each element must be freed when it is no longer needed. This can be - done all at once using bulk_free. - - independent_comallac differs from independent_calloc in that each - element may have a different size, and also that it does not - automatically clear elements. - - independent_comalloc can be used to speed up allocation in cases - where several structs or objects must always be allocated at the - same time. For example: - - struct Head { ... } - struct Foot { ... } - - void send_message(char* msg) { - int msglen = strlen(msg); - size_t sizes[3] = { sizeof(struct Head), msglen, sizeof(struct Foot) }; - void* chunks[3]; - if (independent_comalloc(3, sizes, chunks) == 0) - die(); - struct Head* head = (struct Head*)(chunks[0]); - char* body = (char*)(chunks[1]); - struct Foot* foot = (struct Foot*)(chunks[2]); - // ... - } - - In general though, independent_comalloc is worth using only for - larger values of n_elements. For small values, you probably won't - detect enough difference from series of malloc calls to bother. - - Overuse of independent_comalloc can increase overall memory usage, - since it cannot reuse existing noncontiguous small chunks that - might be available for some of the elements. -*/ -DLMALLOC_EXPORT void** dlindependent_comalloc(size_t, size_t*, void**); - -/* - bulk_free(void* array[], size_t n_elements) - Frees and clears (sets to null) each non-null pointer in the given - array. This is likely to be faster than freeing them one-by-one. - If footers are used, pointers that have been allocated in different - mspaces are not freed or cleared, and the count of all such pointers - is returned. For large arrays of pointers with poor locality, it - may be worthwhile to sort this array before calling bulk_free. -*/ -DLMALLOC_EXPORT size_t dlbulk_free(void**, size_t n_elements); - -/* - pvalloc(size_t n); - Equivalent to valloc(minimum-page-that-holds(n)), that is, - round up n to nearest pagesize. - */ -DLMALLOC_EXPORT void* dlpvalloc(size_t); - -/* - malloc_trim(size_t pad); - - If possible, gives memory back to the system (via negative arguments - to sbrk) if there is unused memory at the `high' end of the malloc - pool or in unused MMAP segments. You can call this after freeing - large blocks of memory to potentially reduce the system-level memory - requirements of a program. However, it cannot guarantee to reduce - memory. Under some allocation patterns, some large free blocks of - memory will be locked between two used chunks, so they cannot be - given back to the system. - - The `pad' argument to malloc_trim represents the amount of free - trailing space to leave untrimmed. If this argument is zero, only - the minimum amount of memory to maintain internal data structures - will be left. Non-zero arguments can be supplied to maintain enough - trailing space to service future expected allocations without having - to re-obtain memory from the system. - - Malloc_trim returns 1 if it actually released any memory, else 0. -*/ -DLMALLOC_EXPORT int dlmalloc_trim(size_t); - -/* - malloc_stats(); - Prints on stderr the amount of space obtained from the system (both - via sbrk and mmap), the maximum amount (which may be more than - current if malloc_trim and/or munmap got called), and the current - number of bytes allocated via malloc (or realloc, etc) but not yet - freed. Note that this is the number of bytes allocated, not the - number requested. It will be larger than the number requested - because of alignment and bookkeeping overhead. Because it includes - alignment wastage as being in use, this figure may be greater than - zero even when no user-level chunks are allocated. - - The reported current and maximum system memory can be inaccurate if - a program makes other calls to system memory allocation functions - (normally sbrk) outside of malloc. - - malloc_stats prints only the most commonly interesting statistics. - More information can be obtained by calling mallinfo. -*/ -DLMALLOC_EXPORT void dlmalloc_stats(void); - -/* - malloc_usable_size(void* p); - - Returns the number of bytes you can actually use in - an allocated chunk, which may be more than you requested (although - often not) due to alignment and minimum size constraints. - You can use this many bytes without worrying about - overwriting other allocated objects. This is not a particularly great - programming practice. malloc_usable_size can be more useful in - debugging and assertions, for example: - - p = malloc(n); - assert(malloc_usable_size(p) >= 256); -*/ -size_t dlmalloc_usable_size(void*); - -#endif /* ONLY_MSPACES */ - -#if MSPACES - -/* - mspace is an opaque type representing an independent - region of space that supports mspace_malloc, etc. -*/ -typedef void* mspace; - -/* - create_mspace creates and returns a new independent space with the - given initial capacity, or, if 0, the default granularity size. It - returns null if there is no system memory available to create the - space. If argument locked is non-zero, the space uses a separate - lock to control access. The capacity of the space will grow - dynamically as needed to service mspace_malloc requests. You can - control the sizes of incremental increases of this space by - compiling with a different DEFAULT_GRANULARITY or dynamically - setting with mallopt(M_GRANULARITY, value). -*/ -DLMALLOC_EXPORT mspace create_mspace(size_t capacity, int locked); - -/* - destroy_mspace destroys the given space, and attempts to return all - of its memory back to the system, returning the total number of - bytes freed. After destruction, the results of access to all memory - used by the space become undefined. -*/ -DLMALLOC_EXPORT size_t destroy_mspace(mspace msp); - -/* - create_mspace_with_base uses the memory supplied as the initial base - of a new mspace. Part (less than 128*sizeof(size_t) bytes) of this - space is used for bookkeeping, so the capacity must be at least this - large. (Otherwise 0 is returned.) When this initial space is - exhausted, additional memory will be obtained from the system. - Destroying this space will deallocate all additionally allocated - space (if possible) but not the initial base. -*/ -DLMALLOC_EXPORT mspace create_mspace_with_base(void* base, size_t capacity, int locked); - -/* - mspace_track_large_chunks controls whether requests for large chunks - are allocated in their own untracked mmapped regions, separate from - others in this mspace. By default large chunks are not tracked, - which reduces fragmentation. However, such chunks are not - necessarily released to the system upon destroy_mspace. Enabling - tracking by setting to true may increase fragmentation, but avoids - leakage when relying on destroy_mspace to release all memory - allocated using this space. The function returns the previous - setting. -*/ -DLMALLOC_EXPORT int mspace_track_large_chunks(mspace msp, int enable); - - -/* - mspace_malloc behaves as malloc, but operates within - the given space. -*/ -DLMALLOC_EXPORT void* mspace_malloc(mspace msp, size_t bytes); - -/* - mspace_free behaves as free, but operates within - the given space. - - If compiled with FOOTERS==1, mspace_free is not actually needed. - free may be called instead of mspace_free because freed chunks from - any space are handled by their originating spaces. -*/ -DLMALLOC_EXPORT void mspace_free(mspace msp, void* mem); - -/* - mspace_realloc behaves as realloc, but operates within - the given space. - - If compiled with FOOTERS==1, mspace_realloc is not actually - needed. realloc may be called instead of mspace_realloc because - realloced chunks from any space are handled by their originating - spaces. -*/ -DLMALLOC_EXPORT void* mspace_realloc(mspace msp, void* mem, size_t newsize); - -/* - mspace_calloc behaves as calloc, but operates within - the given space. -*/ -DLMALLOC_EXPORT void* mspace_calloc(mspace msp, size_t n_elements, size_t elem_size); - -/* - mspace_memalign behaves as memalign, but operates within - the given space. -*/ -DLMALLOC_EXPORT void* mspace_memalign(mspace msp, size_t alignment, size_t bytes); - -/* - mspace_independent_calloc behaves as independent_calloc, but - operates within the given space. -*/ -DLMALLOC_EXPORT void** mspace_independent_calloc(mspace msp, size_t n_elements, - size_t elem_size, void* chunks[]); - -/* - mspace_independent_comalloc behaves as independent_comalloc, but - operates within the given space. -*/ -DLMALLOC_EXPORT void** mspace_independent_comalloc(mspace msp, size_t n_elements, - size_t sizes[], void* chunks[]); - -/* - mspace_footprint() returns the number of bytes obtained from the - system for this space. -*/ -DLMALLOC_EXPORT size_t mspace_footprint(mspace msp); - -/* - mspace_max_footprint() returns the peak number of bytes obtained from the - system for this space. -*/ -DLMALLOC_EXPORT size_t mspace_max_footprint(mspace msp); - - -#if !NO_MALLINFO -/* - mspace_mallinfo behaves as mallinfo, but reports properties of - the given space. -*/ -DLMALLOC_EXPORT struct mallinfo mspace_mallinfo(mspace msp); -#endif /* NO_MALLINFO */ - -/* - malloc_usable_size(void* p) behaves the same as malloc_usable_size; -*/ -DLMALLOC_EXPORT size_t mspace_usable_size(const void* mem); - -/* - mspace_malloc_stats behaves as malloc_stats, but reports - properties of the given space. -*/ -DLMALLOC_EXPORT void mspace_malloc_stats(mspace msp); - -/* - mspace_trim behaves as malloc_trim, but - operates within the given space. -*/ -DLMALLOC_EXPORT int mspace_trim(mspace msp, size_t pad); - -/* - An alias for mallopt. -*/ -DLMALLOC_EXPORT int mspace_mallopt(int, int); - -#endif /* MSPACES */ - -#ifdef __cplusplus -} /* end of extern "C" */ -#endif /* __cplusplus */ - -/* - ======================================================================== - To make a fully customizable malloc.h header file, cut everything - above this line, put into file malloc.h, edit to suit, and #include it - on the next line, as well as in programs that use this malloc. - ======================================================================== -*/ - -/* #include "malloc.h" */ - -/*------------------------------ internal #includes ---------------------- */ - -#ifdef _MSC_VER -#pragma warning( disable : 4146 ) /* no "unsigned" warnings */ -#endif /* _MSC_VER */ -#if !NO_MALLOC_STATS -#include /* for printing in malloc_stats */ -#endif /* NO_MALLOC_STATS */ -#ifndef LACKS_ERRNO_H -#include /* for MALLOC_FAILURE_ACTION */ -#endif /* LACKS_ERRNO_H */ -#ifdef DEBUG -#if ABORT_ON_ASSERT_FAILURE -#undef assert -#define assert(x) if(!(x)) ABORT -#else /* ABORT_ON_ASSERT_FAILURE */ -#include -#endif /* ABORT_ON_ASSERT_FAILURE */ -#else /* DEBUG */ -#ifndef assert -#define assert(x) -#endif -#define DEBUG 0 -#endif /* DEBUG */ -#if !defined(WIN32) && !defined(LACKS_TIME_H) -#include /* for magic initialization */ -#endif /* WIN32 */ -#ifndef LACKS_STDLIB_H -#include /* for abort() */ -#endif /* LACKS_STDLIB_H */ -#ifndef LACKS_STRING_H -#include /* for memset etc */ -#endif /* LACKS_STRING_H */ -#if USE_BUILTIN_FFS -#ifndef LACKS_STRINGS_H -#include /* for ffs */ -#endif /* LACKS_STRINGS_H */ -#endif /* USE_BUILTIN_FFS */ -#if HAVE_MMAP -#ifndef LACKS_SYS_MMAN_H -/* On some versions of linux, mremap decl in mman.h needs __USE_GNU set */ -#if (defined(linux) && !defined(__USE_GNU)) -#define __USE_GNU 1 -#include /* for mmap */ -#undef __USE_GNU -#else -#include /* for mmap */ -#endif /* linux */ -#endif /* LACKS_SYS_MMAN_H */ -#ifndef LACKS_FCNTL_H -#include -#endif /* LACKS_FCNTL_H */ -#endif /* HAVE_MMAP */ -#ifndef LACKS_UNISTD_H -#include /* for sbrk, sysconf */ -#else /* LACKS_UNISTD_H */ -#if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__NetBSD__) -extern void* sbrk(ptrdiff_t); -#endif /* FreeBSD etc */ -#endif /* LACKS_UNISTD_H */ - -/* Declarations for locking */ -#if USE_LOCKS -#ifndef WIN32 -#if defined (__SVR4) && defined (__sun) /* solaris */ -#include -#elif !defined(LACKS_SCHED_H) -#include -#endif /* solaris or LACKS_SCHED_H */ -#if (defined(USE_RECURSIVE_LOCKS) && USE_RECURSIVE_LOCKS != 0) || !USE_SPIN_LOCKS -#include -#endif /* USE_RECURSIVE_LOCKS ... */ -#elif defined(_MSC_VER) -#ifndef _M_AMD64 -/* These are already defined on AMD64 builds */ -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ -LONG __cdecl _InterlockedCompareExchange(LONG volatile *Dest, LONG Exchange, LONG Comp); -LONG __cdecl _InterlockedExchange(LONG volatile *Target, LONG Value); -#ifdef __cplusplus -} -#endif /* __cplusplus */ -#endif /* _M_AMD64 */ -#pragma intrinsic (_InterlockedCompareExchange) -#pragma intrinsic (_InterlockedExchange) -#define interlockedcompareexchange _InterlockedCompareExchange -#define interlockedexchange _InterlockedExchange -#elif defined(WIN32) && defined(__GNUC__) -#define interlockedcompareexchange(a, b, c) __sync_val_compare_and_swap(a, c, b) -#define interlockedexchange __sync_lock_test_and_set -#endif /* Win32 */ -#else /* USE_LOCKS */ -#endif /* USE_LOCKS */ - -#ifndef LOCK_AT_FORK -#define LOCK_AT_FORK 0 -#endif - -/* Declarations for bit scanning on win32 */ -#if defined(_MSC_VER) && _MSC_VER>=1300 -#ifndef BitScanForward /* Try to avoid pulling in WinNT.h */ -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ -unsigned char _BitScanForward(unsigned long *index, unsigned long mask); -unsigned char _BitScanReverse(unsigned long *index, unsigned long mask); -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#define BitScanForward _BitScanForward -#define BitScanReverse _BitScanReverse -#pragma intrinsic(_BitScanForward) -#pragma intrinsic(_BitScanReverse) -#endif /* BitScanForward */ -#endif /* defined(_MSC_VER) && _MSC_VER>=1300 */ - -#ifndef WIN32 -#ifndef malloc_getpagesize -# ifdef _SC_PAGESIZE /* some SVR4 systems omit an underscore */ -# ifndef _SC_PAGE_SIZE -# define _SC_PAGE_SIZE _SC_PAGESIZE -# endif -# endif -# ifdef _SC_PAGE_SIZE -# define malloc_getpagesize sysconf(_SC_PAGE_SIZE) -# else -# if defined(BSD) || defined(DGUX) || defined(HAVE_GETPAGESIZE) - extern size_t getpagesize(); -# define malloc_getpagesize getpagesize() -# else -# ifdef WIN32 /* use supplied emulation of getpagesize */ -# define malloc_getpagesize getpagesize() -# else -# ifndef LACKS_SYS_PARAM_H -# include -# endif -# ifdef EXEC_PAGESIZE -# define malloc_getpagesize EXEC_PAGESIZE -# else -# ifdef NBPG -# ifndef CLSIZE -# define malloc_getpagesize NBPG -# else -# define malloc_getpagesize (NBPG * CLSIZE) -# endif -# else -# ifdef NBPC -# define malloc_getpagesize NBPC -# else -# ifdef PAGESIZE -# define malloc_getpagesize PAGESIZE -# else /* just guess */ -# define malloc_getpagesize ((size_t)4096U) -# endif -# endif -# endif -# endif -# endif -# endif -# endif -#endif -#endif - -/* ------------------- size_t and alignment properties -------------------- */ - -/* The byte and bit size of a size_t */ -#define SIZE_T_SIZE (sizeof(size_t)) -#define SIZE_T_BITSIZE (sizeof(size_t) << 3) - -/* Some constants coerced to size_t */ -/* Annoying but necessary to avoid errors on some platforms */ -#define SIZE_T_ZERO ((size_t)0) -#define SIZE_T_ONE ((size_t)1) -#define SIZE_T_TWO ((size_t)2) -#define SIZE_T_FOUR ((size_t)4) -#define TWO_SIZE_T_SIZES (SIZE_T_SIZE<<1) -#define FOUR_SIZE_T_SIZES (SIZE_T_SIZE<<2) -#define SIX_SIZE_T_SIZES (FOUR_SIZE_T_SIZES+TWO_SIZE_T_SIZES) -#define HALF_MAX_SIZE_T (MAX_SIZE_T / 2U) - -/* The bit mask value corresponding to MALLOC_ALIGNMENT */ -#define CHUNK_ALIGN_MASK (MALLOC_ALIGNMENT - SIZE_T_ONE) - -/* True if address a has acceptable alignment */ -#define is_aligned(A) (((size_t)((A)) & (CHUNK_ALIGN_MASK)) == 0) - -/* the number of bytes to offset an address to align it */ -#define align_offset(A)\ - ((((size_t)(A) & CHUNK_ALIGN_MASK) == 0)? 0 :\ - ((MALLOC_ALIGNMENT - ((size_t)(A) & CHUNK_ALIGN_MASK)) & CHUNK_ALIGN_MASK)) - -/* -------------------------- MMAP preliminaries ------------------------- */ - -/* - If HAVE_MORECORE or HAVE_MMAP are false, we just define calls and - checks to fail so compiler optimizer can delete code rather than - using so many "#if"s. -*/ - - -/* MORECORE and MMAP must return MFAIL on failure */ -#define MFAIL ((void*)(MAX_SIZE_T)) -#define CMFAIL ((char*)(MFAIL)) /* defined for convenience */ - -#if HAVE_MMAP - -#ifndef WIN32 -#define MUNMAP_DEFAULT(a, s) munmap((a), (s)) -#define MMAP_PROT (PROT_READ|PROT_WRITE) -#if !defined(MAP_ANONYMOUS) && defined(MAP_ANON) -#define MAP_ANONYMOUS MAP_ANON -#endif /* MAP_ANON */ -#ifdef MAP_ANONYMOUS -#define MMAP_FLAGS (MAP_PRIVATE|MAP_ANONYMOUS) -#define MMAP_DEFAULT(s) mmap(0, (s), MMAP_PROT, MMAP_FLAGS, -1, 0) -#else /* MAP_ANONYMOUS */ -/* - Nearly all versions of mmap support MAP_ANONYMOUS, so the following - is unlikely to be needed, but is supplied just in case. -*/ -#define MMAP_FLAGS (MAP_PRIVATE) -static int dev_zero_fd = -1; /* Cached file descriptor for /dev/zero. */ -#define MMAP_DEFAULT(s) ((dev_zero_fd < 0) ? \ - (dev_zero_fd = open("/dev/zero", O_RDWR), \ - mmap(0, (s), MMAP_PROT, MMAP_FLAGS, dev_zero_fd, 0)) : \ - mmap(0, (s), MMAP_PROT, MMAP_FLAGS, dev_zero_fd, 0)) -#endif /* MAP_ANONYMOUS */ - -#define DIRECT_MMAP_DEFAULT(s) MMAP_DEFAULT(s) - -#else /* WIN32 */ - -/* Win32 MMAP via VirtualAlloc */ -static FORCEINLINE void* win32mmap(size_t size) { - void* ptr = VirtualAlloc(0, size, MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE); - return (ptr != 0)? ptr: MFAIL; -} - -/* For direct MMAP, use MEM_TOP_DOWN to minimize interference */ -static FORCEINLINE void* win32direct_mmap(size_t size) { - void* ptr = VirtualAlloc(0, size, MEM_RESERVE|MEM_COMMIT|MEM_TOP_DOWN, - PAGE_READWRITE); - return (ptr != 0)? ptr: MFAIL; -} - -/* This function supports releasing coalesed segments */ -static FORCEINLINE int win32munmap(void* ptr, size_t size) { - MEMORY_BASIC_INFORMATION minfo; - char* cptr = (char*)ptr; - while (size) { - if (VirtualQuery(cptr, &minfo, sizeof(minfo)) == 0) - return -1; - if (minfo.BaseAddress != cptr || minfo.AllocationBase != cptr || - minfo.State != MEM_COMMIT || minfo.RegionSize > size) - return -1; - if (VirtualFree(cptr, 0, MEM_RELEASE) == 0) - return -1; - cptr += minfo.RegionSize; - size -= minfo.RegionSize; - } - return 0; -} - -#define MMAP_DEFAULT(s) win32mmap(s) -#define MUNMAP_DEFAULT(a, s) win32munmap((a), (s)) -#define DIRECT_MMAP_DEFAULT(s) win32direct_mmap(s) -#endif /* WIN32 */ -#endif /* HAVE_MMAP */ - -#if HAVE_MREMAP -#ifndef WIN32 -#define MREMAP_DEFAULT(addr, osz, nsz, mv) mremap((addr), (osz), (nsz), (mv)) -#endif /* WIN32 */ -#endif /* HAVE_MREMAP */ - -/** - * Define CALL_MORECORE - */ -#if HAVE_MORECORE - #ifdef MORECORE - #define CALL_MORECORE(S) MORECORE(S) - #else /* MORECORE */ - #define CALL_MORECORE(S) MORECORE_DEFAULT(S) - #endif /* MORECORE */ -#else /* HAVE_MORECORE */ - #define CALL_MORECORE(S) MFAIL -#endif /* HAVE_MORECORE */ - -/** - * Define CALL_MMAP/CALL_MUNMAP/CALL_DIRECT_MMAP - */ -#if HAVE_MMAP - #define USE_MMAP_BIT (SIZE_T_ONE) - - #ifdef MMAP - #define CALL_MMAP(s) MMAP(s) - #else /* MMAP */ - #define CALL_MMAP(s) MMAP_DEFAULT(s) - #endif /* MMAP */ - #ifdef MUNMAP - #define CALL_MUNMAP(a, s) MUNMAP((a), (s)) - #else /* MUNMAP */ - #define CALL_MUNMAP(a, s) MUNMAP_DEFAULT((a), (s)) - #endif /* MUNMAP */ - #ifdef DIRECT_MMAP - #define CALL_DIRECT_MMAP(s) DIRECT_MMAP(s) - #else /* DIRECT_MMAP */ - #define CALL_DIRECT_MMAP(s) DIRECT_MMAP_DEFAULT(s) - #endif /* DIRECT_MMAP */ -#else /* HAVE_MMAP */ - #define USE_MMAP_BIT (SIZE_T_ZERO) - - #define MMAP(s) MFAIL - #define MUNMAP(a, s) (-1) - #define DIRECT_MMAP(s) MFAIL - #define CALL_DIRECT_MMAP(s) DIRECT_MMAP(s) - #define CALL_MMAP(s) MMAP(s) - #define CALL_MUNMAP(a, s) MUNMAP((a), (s)) -#endif /* HAVE_MMAP */ - -/** - * Define CALL_MREMAP - */ -#if HAVE_MMAP && HAVE_MREMAP - #ifdef MREMAP - #define CALL_MREMAP(addr, osz, nsz, mv) MREMAP((addr), (osz), (nsz), (mv)) - #else /* MREMAP */ - #define CALL_MREMAP(addr, osz, nsz, mv) MREMAP_DEFAULT((addr), (osz), (nsz), (mv)) - #endif /* MREMAP */ -#else /* HAVE_MMAP && HAVE_MREMAP */ - #define CALL_MREMAP(addr, osz, nsz, mv) MFAIL -#endif /* HAVE_MMAP && HAVE_MREMAP */ - -/* mstate bit set if continguous morecore disabled or failed */ -#define USE_NONCONTIGUOUS_BIT (4U) - -/* segment bit set in create_mspace_with_base */ -#define EXTERN_BIT (8U) - - -/* --------------------------- Lock preliminaries ------------------------ */ - -/* - When locks are defined, there is one global lock, plus - one per-mspace lock. - - The global lock_ensures that mparams.magic and other unique - mparams values are initialized only once. It also protects - sequences of calls to MORECORE. In many cases sys_alloc requires - two calls, that should not be interleaved with calls by other - threads. This does not protect against direct calls to MORECORE - by other threads not using this lock, so there is still code to - cope the best we can on interference. - - Per-mspace locks surround calls to malloc, free, etc. - By default, locks are simple non-reentrant mutexes. - - Because lock-protected regions generally have bounded times, it is - OK to use the supplied simple spinlocks. Spinlocks are likely to - improve performance for lightly contended applications, but worsen - performance under heavy contention. - - If USE_LOCKS is > 1, the definitions of lock routines here are - bypassed, in which case you will need to define the type MLOCK_T, - and at least INITIAL_LOCK, DESTROY_LOCK, ACQUIRE_LOCK, RELEASE_LOCK - and TRY_LOCK. You must also declare a - static MLOCK_T malloc_global_mutex = { initialization values };. - -*/ - -#if !USE_LOCKS -#define USE_LOCK_BIT (0U) -#define INITIAL_LOCK(l) (0) -#define DESTROY_LOCK(l) (0) -#define ACQUIRE_MALLOC_GLOBAL_LOCK() -#define RELEASE_MALLOC_GLOBAL_LOCK() - -#else -#if USE_LOCKS > 1 -/* ----------------------- User-defined locks ------------------------ */ -/* Define your own lock implementation here */ -/* #define INITIAL_LOCK(lk) ... */ -/* #define DESTROY_LOCK(lk) ... */ -/* #define ACQUIRE_LOCK(lk) ... */ -/* #define RELEASE_LOCK(lk) ... */ -/* #define TRY_LOCK(lk) ... */ -/* static MLOCK_T malloc_global_mutex = ... */ - -#elif USE_SPIN_LOCKS - -/* First, define CAS_LOCK and CLEAR_LOCK on ints */ -/* Note CAS_LOCK defined to return 0 on success */ - -#if defined(__GNUC__)&& (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)) -#define CAS_LOCK(sl) __sync_lock_test_and_set(sl, 1) -#define CLEAR_LOCK(sl) __sync_lock_release(sl) - -#elif (defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))) -/* Custom spin locks for older gcc on x86 */ -static FORCEINLINE int x86_cas_lock(int *sl) { - int ret; - int val = 1; - int cmp = 0; - __asm__ __volatile__ ("lock; cmpxchgl %1, %2" - : "=a" (ret) - : "r" (val), "m" (*(sl)), "0"(cmp) - : "memory", "cc"); - return ret; -} - -static FORCEINLINE void x86_clear_lock(int* sl) { - assert(*sl != 0); - int prev = 0; - int ret; - __asm__ __volatile__ ("lock; xchgl %0, %1" - : "=r" (ret) - : "m" (*(sl)), "0"(prev) - : "memory"); -} - -#define CAS_LOCK(sl) x86_cas_lock(sl) -#define CLEAR_LOCK(sl) x86_clear_lock(sl) - -#else /* Win32 MSC */ -#define CAS_LOCK(sl) interlockedexchange(sl, (LONG)1) -#define CLEAR_LOCK(sl) interlockedexchange (sl, (LONG)0) - -#endif /* ... gcc spins locks ... */ - -/* How to yield for a spin lock */ -#define SPINS_PER_YIELD 63 -#if defined(_MSC_VER) -#define SLEEP_EX_DURATION 50 /* delay for yield/sleep */ -#define SPIN_LOCK_YIELD SleepEx(SLEEP_EX_DURATION, FALSE) -#elif defined (__SVR4) && defined (__sun) /* solaris */ -#define SPIN_LOCK_YIELD thr_yield(); -#elif !defined(LACKS_SCHED_H) -#define SPIN_LOCK_YIELD sched_yield(); -#else -#define SPIN_LOCK_YIELD -#endif /* ... yield ... */ - -#if !defined(USE_RECURSIVE_LOCKS) || USE_RECURSIVE_LOCKS == 0 -/* Plain spin locks use single word (embedded in malloc_states) */ -static int spin_acquire_lock(int *sl) { - int spins = 0; - while (*(volatile int *)sl != 0 || CAS_LOCK(sl)) { - if ((++spins & SPINS_PER_YIELD) == 0) { - SPIN_LOCK_YIELD; - } - } - return 0; -} - -#define MLOCK_T int -#define TRY_LOCK(sl) !CAS_LOCK(sl) -#define RELEASE_LOCK(sl) CLEAR_LOCK(sl) -#define ACQUIRE_LOCK(sl) (CAS_LOCK(sl)? spin_acquire_lock(sl) : 0) -#define INITIAL_LOCK(sl) (*sl = 0) -#define DESTROY_LOCK(sl) (0) -static MLOCK_T malloc_global_mutex = 0; - -#else /* USE_RECURSIVE_LOCKS */ -/* types for lock owners */ -#ifdef WIN32 -#define THREAD_ID_T DWORD -#define CURRENT_THREAD GetCurrentThreadId() -#define EQ_OWNER(X,Y) ((X) == (Y)) -#else -/* - Note: the following assume that pthread_t is a type that can be - initialized to (casted) zero. If this is not the case, you will need to - somehow redefine these or not use spin locks. -*/ -#define THREAD_ID_T pthread_t -#define CURRENT_THREAD pthread_self() -#define EQ_OWNER(X,Y) pthread_equal(X, Y) -#endif - -struct malloc_recursive_lock { - int sl; - unsigned int c; - THREAD_ID_T threadid; -}; - -#define MLOCK_T struct malloc_recursive_lock -static MLOCK_T malloc_global_mutex = { 0, 0, (THREAD_ID_T)0}; - -static FORCEINLINE void recursive_release_lock(MLOCK_T *lk) { - assert(lk->sl != 0); - if (--lk->c == 0) { - CLEAR_LOCK(&lk->sl); - } -} - -static FORCEINLINE int recursive_acquire_lock(MLOCK_T *lk) { - THREAD_ID_T mythreadid = CURRENT_THREAD; - int spins = 0; - for (;;) { - if (*((volatile int *)(&lk->sl)) == 0) { - if (!CAS_LOCK(&lk->sl)) { - lk->threadid = mythreadid; - lk->c = 1; - return 0; - } - } - else if (EQ_OWNER(lk->threadid, mythreadid)) { - ++lk->c; - return 0; - } - if ((++spins & SPINS_PER_YIELD) == 0) { - SPIN_LOCK_YIELD; - } - } -} - -static FORCEINLINE int recursive_try_lock(MLOCK_T *lk) { - THREAD_ID_T mythreadid = CURRENT_THREAD; - if (*((volatile int *)(&lk->sl)) == 0) { - if (!CAS_LOCK(&lk->sl)) { - lk->threadid = mythreadid; - lk->c = 1; - return 1; - } - } - else if (EQ_OWNER(lk->threadid, mythreadid)) { - ++lk->c; - return 1; - } - return 0; -} - -#define RELEASE_LOCK(lk) recursive_release_lock(lk) -#define TRY_LOCK(lk) recursive_try_lock(lk) -#define ACQUIRE_LOCK(lk) recursive_acquire_lock(lk) -#define INITIAL_LOCK(lk) ((lk)->threadid = (THREAD_ID_T)0, (lk)->sl = 0, (lk)->c = 0) -#define DESTROY_LOCK(lk) (0) -#endif /* USE_RECURSIVE_LOCKS */ - -#elif defined(WIN32) /* Win32 critical sections */ -#define MLOCK_T CRITICAL_SECTION -#define ACQUIRE_LOCK(lk) (EnterCriticalSection(lk), 0) -#define RELEASE_LOCK(lk) LeaveCriticalSection(lk) -#define TRY_LOCK(lk) TryEnterCriticalSection(lk) -#define INITIAL_LOCK(lk) (!InitializeCriticalSectionAndSpinCount((lk), 0x80000000|4000)) -#define DESTROY_LOCK(lk) (DeleteCriticalSection(lk), 0) -#define NEED_GLOBAL_LOCK_INIT - -static MLOCK_T malloc_global_mutex; -static volatile LONG malloc_global_mutex_status; - -/* Use spin loop to initialize global lock */ -static void init_malloc_global_mutex() { - for (;;) { - long stat = malloc_global_mutex_status; - if (stat > 0) - return; - /* transition to < 0 while initializing, then to > 0) */ - if (stat == 0 && - interlockedcompareexchange(&malloc_global_mutex_status, (LONG)-1, (LONG)0) == 0) { - InitializeCriticalSection(&malloc_global_mutex); - interlockedexchange(&malloc_global_mutex_status, (LONG)1); - return; - } - SleepEx(0, FALSE); - } -} - -#else /* pthreads-based locks */ -#define MLOCK_T pthread_mutex_t -#define ACQUIRE_LOCK(lk) pthread_mutex_lock(lk) -#define RELEASE_LOCK(lk) pthread_mutex_unlock(lk) -#define TRY_LOCK(lk) (!pthread_mutex_trylock(lk)) -#define INITIAL_LOCK(lk) pthread_init_lock(lk) -#define DESTROY_LOCK(lk) pthread_mutex_destroy(lk) - -#if defined(USE_RECURSIVE_LOCKS) && USE_RECURSIVE_LOCKS != 0 && defined(linux) && !defined(PTHREAD_MUTEX_RECURSIVE) -/* Cope with old-style linux recursive lock initialization by adding */ -/* skipped internal declaration from pthread.h */ -extern int pthread_mutexattr_setkind_np __P ((pthread_mutexattr_t *__attr, - int __kind)); -#define PTHREAD_MUTEX_RECURSIVE PTHREAD_MUTEX_RECURSIVE_NP -#define pthread_mutexattr_settype(x,y) pthread_mutexattr_setkind_np(x,y) -#endif /* USE_RECURSIVE_LOCKS ... */ - -static MLOCK_T malloc_global_mutex = PTHREAD_MUTEX_INITIALIZER; - -static int pthread_init_lock (MLOCK_T *lk) { - pthread_mutexattr_t attr; - if (pthread_mutexattr_init(&attr)) return 1; -#if defined(USE_RECURSIVE_LOCKS) && USE_RECURSIVE_LOCKS != 0 - if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE)) return 1; -#endif - if (pthread_mutex_init(lk, &attr)) return 1; - if (pthread_mutexattr_destroy(&attr)) return 1; - return 0; -} - -#endif /* ... lock types ... */ - -/* Common code for all lock types */ -#define USE_LOCK_BIT (2U) - -#ifndef ACQUIRE_MALLOC_GLOBAL_LOCK -#define ACQUIRE_MALLOC_GLOBAL_LOCK() ACQUIRE_LOCK(&malloc_global_mutex); -#endif - -#ifndef RELEASE_MALLOC_GLOBAL_LOCK -#define RELEASE_MALLOC_GLOBAL_LOCK() RELEASE_LOCK(&malloc_global_mutex); -#endif - -#endif /* USE_LOCKS */ - -/* ----------------------- Chunk representations ------------------------ */ - -/* - (The following includes lightly edited explanations by Colin Plumb.) - - The malloc_chunk declaration below is misleading (but accurate and - necessary). It declares a "view" into memory allowing access to - necessary fields at known offsets from a given base. - - Chunks of memory are maintained using a `boundary tag' method as - originally described by Knuth. (See the paper by Paul Wilson - ftp://ftp.cs.utexas.edu/pub/garbage/allocsrv.ps for a survey of such - techniques.) Sizes of free chunks are stored both in the front of - each chunk and at the end. This makes consolidating fragmented - chunks into bigger chunks fast. The head fields also hold bits - representing whether chunks are free or in use. - - Here are some pictures to make it clearer. They are "exploded" to - show that the state of a chunk can be thought of as extending from - the high 31 bits of the head field of its header through the - prev_foot and PINUSE_BIT bit of the following chunk header. - - A chunk that's in use looks like: - - chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - | Size of previous chunk (if P = 0) | - +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |P| - | Size of this chunk 1| +-+ - mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - | | - +- -+ - | | - +- -+ - | : - +- size - sizeof(size_t) available payload bytes -+ - : | - chunk-> +- -+ - | | - +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |1| - | Size of next chunk (may or may not be in use) | +-+ - mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - - And if it's free, it looks like this: - - chunk-> +- -+ - | User payload (must be in use, or we would have merged!) | - +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |P| - | Size of this chunk 0| +-+ - mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - | Next pointer | - +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - | Prev pointer | - +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - | : - +- size - sizeof(struct chunk) unused bytes -+ - : | - chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - | Size of this chunk | - +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |0| - | Size of next chunk (must be in use, or we would have merged)| +-+ - mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - | : - +- User payload -+ - : | - +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - |0| - +-+ - Note that since we always merge adjacent free chunks, the chunks - adjacent to a free chunk must be in use. - - Given a pointer to a chunk (which can be derived trivially from the - payload pointer) we can, in O(1) time, find out whether the adjacent - chunks are free, and if so, unlink them from the lists that they - are on and merge them with the current chunk. - - Chunks always begin on even word boundaries, so the mem portion - (which is returned to the user) is also on an even word boundary, and - thus at least double-word aligned. - - The P (PINUSE_BIT) bit, stored in the unused low-order bit of the - chunk size (which is always a multiple of two words), is an in-use - bit for the *previous* chunk. If that bit is *clear*, then the - word before the current chunk size contains the previous chunk - size, and can be used to find the front of the previous chunk. - The very first chunk allocated always has this bit set, preventing - access to non-existent (or non-owned) memory. If pinuse is set for - any given chunk, then you CANNOT determine the size of the - previous chunk, and might even get a memory addressing fault when - trying to do so. - - The C (CINUSE_BIT) bit, stored in the unused second-lowest bit of - the chunk size redundantly records whether the current chunk is - inuse (unless the chunk is mmapped). This redundancy enables usage - checks within free and realloc, and reduces indirection when freeing - and consolidating chunks. - - Each freshly allocated chunk must have both cinuse and pinuse set. - That is, each allocated chunk borders either a previously allocated - and still in-use chunk, or the base of its memory arena. This is - ensured by making all allocations from the `lowest' part of any - found chunk. Further, no free chunk physically borders another one, - so each free chunk is known to be preceded and followed by either - inuse chunks or the ends of memory. - - Note that the `foot' of the current chunk is actually represented - as the prev_foot of the NEXT chunk. This makes it easier to - deal with alignments etc but can be very confusing when trying - to extend or adapt this code. - - The exceptions to all this are - - 1. The special chunk `top' is the top-most available chunk (i.e., - the one bordering the end of available memory). It is treated - specially. Top is never included in any bin, is used only if - no other chunk is available, and is released back to the - system if it is very large (see M_TRIM_THRESHOLD). In effect, - the top chunk is treated as larger (and thus less well - fitting) than any other available chunk. The top chunk - doesn't update its trailing size field since there is no next - contiguous chunk that would have to index off it. However, - space is still allocated for it (TOP_FOOT_SIZE) to enable - separation or merging when space is extended. - - 3. Chunks allocated via mmap, have both cinuse and pinuse bits - cleared in their head fields. Because they are allocated - one-by-one, each must carry its own prev_foot field, which is - also used to hold the offset this chunk has within its mmapped - region, which is needed to preserve alignment. Each mmapped - chunk is trailed by the first two fields of a fake next-chunk - for sake of usage checks. - -*/ - -struct malloc_chunk { - size_t prev_foot; /* Size of previous chunk (if free). */ - size_t head; /* Size and inuse bits. */ - struct malloc_chunk* fd; /* double links -- used only if free. */ - struct malloc_chunk* bk; -}; - -typedef struct malloc_chunk mchunk; -typedef struct malloc_chunk* mchunkptr; -typedef struct malloc_chunk* sbinptr; /* The type of bins of chunks */ -typedef unsigned int bindex_t; /* Described below */ -typedef unsigned int binmap_t; /* Described below */ -typedef unsigned int flag_t; /* The type of various bit flag sets */ - -/* ------------------- Chunks sizes and alignments ----------------------- */ - -#define MCHUNK_SIZE (sizeof(mchunk)) - -#if FOOTERS -#define CHUNK_OVERHEAD (TWO_SIZE_T_SIZES) -#else /* FOOTERS */ -#define CHUNK_OVERHEAD (SIZE_T_SIZE) -#endif /* FOOTERS */ - -/* MMapped chunks need a second word of overhead ... */ -#define MMAP_CHUNK_OVERHEAD (TWO_SIZE_T_SIZES) -/* ... and additional padding for fake next-chunk at foot */ -#define MMAP_FOOT_PAD (FOUR_SIZE_T_SIZES) - -/* The smallest size we can malloc is an aligned minimal chunk */ -#define MIN_CHUNK_SIZE\ - ((MCHUNK_SIZE + CHUNK_ALIGN_MASK) & ~CHUNK_ALIGN_MASK) - -/* conversion from malloc headers to user pointers, and back */ -#define chunk2mem(p) ((void*)((char*)(p) + TWO_SIZE_T_SIZES)) -#define mem2chunk(mem) ((mchunkptr)((char*)(mem) - TWO_SIZE_T_SIZES)) -/* chunk associated with aligned address A */ -#define align_as_chunk(A) (mchunkptr)((A) + align_offset(chunk2mem(A))) - -/* Bounds on request (not chunk) sizes. */ -#define MAX_REQUEST ((-MIN_CHUNK_SIZE) << 2) -#define MIN_REQUEST (MIN_CHUNK_SIZE - CHUNK_OVERHEAD - SIZE_T_ONE) - -/* pad request bytes into a usable size */ -#define pad_request(req) \ - (((req) + CHUNK_OVERHEAD + CHUNK_ALIGN_MASK) & ~CHUNK_ALIGN_MASK) - -/* pad request, checking for minimum (but not maximum) */ -#define request2size(req) \ - (((req) < MIN_REQUEST)? MIN_CHUNK_SIZE : pad_request(req)) - - -/* ------------------ Operations on head and foot fields ----------------- */ - -/* - The head field of a chunk is or'ed with PINUSE_BIT when previous - adjacent chunk in use, and or'ed with CINUSE_BIT if this chunk is in - use, unless mmapped, in which case both bits are cleared. - - FLAG4_BIT is not used by this malloc, but might be useful in extensions. -*/ - -#define PINUSE_BIT (SIZE_T_ONE) -#define CINUSE_BIT (SIZE_T_TWO) -#define FLAG4_BIT (SIZE_T_FOUR) -#define INUSE_BITS (PINUSE_BIT|CINUSE_BIT) -#define FLAG_BITS (PINUSE_BIT|CINUSE_BIT|FLAG4_BIT) - -/* Head value for fenceposts */ -#define FENCEPOST_HEAD (INUSE_BITS|SIZE_T_SIZE) - -/* extraction of fields from head words */ -#define cinuse(p) ((p)->head & CINUSE_BIT) -#define pinuse(p) ((p)->head & PINUSE_BIT) -#define flag4inuse(p) ((p)->head & FLAG4_BIT) -#define is_inuse(p) (((p)->head & INUSE_BITS) != PINUSE_BIT) -#define is_mmapped(p) (((p)->head & INUSE_BITS) == 0) - -#define chunksize(p) ((p)->head & ~(FLAG_BITS)) - -#define clear_pinuse(p) ((p)->head &= ~PINUSE_BIT) -#define set_flag4(p) ((p)->head |= FLAG4_BIT) -#define clear_flag4(p) ((p)->head &= ~FLAG4_BIT) - -/* Treat space at ptr +/- offset as a chunk */ -#define chunk_plus_offset(p, s) ((mchunkptr)(((char*)(p)) + (s))) -#define chunk_minus_offset(p, s) ((mchunkptr)(((char*)(p)) - (s))) - -/* Ptr to next or previous physical malloc_chunk. */ -#define next_chunk(p) ((mchunkptr)( ((char*)(p)) + ((p)->head & ~FLAG_BITS))) -#define prev_chunk(p) ((mchunkptr)( ((char*)(p)) - ((p)->prev_foot) )) - -/* extract next chunk's pinuse bit */ -#define next_pinuse(p) ((next_chunk(p)->head) & PINUSE_BIT) - -/* Get/set size at footer */ -#define get_foot(p, s) (((mchunkptr)((char*)(p) + (s)))->prev_foot) -#define set_foot(p, s) (((mchunkptr)((char*)(p) + (s)))->prev_foot = (s)) - -/* Set size, pinuse bit, and foot */ -#define set_size_and_pinuse_of_free_chunk(p, s)\ - ((p)->head = (s|PINUSE_BIT), set_foot(p, s)) - -/* Set size, pinuse bit, foot, and clear next pinuse */ -#define set_free_with_pinuse(p, s, n)\ - (clear_pinuse(n), set_size_and_pinuse_of_free_chunk(p, s)) - -/* Get the internal overhead associated with chunk p */ -#define overhead_for(p)\ - (is_mmapped(p)? MMAP_CHUNK_OVERHEAD : CHUNK_OVERHEAD) - -/* Return true if malloced space is not necessarily cleared */ -#if MMAP_CLEARS -#define calloc_must_clear(p) (!is_mmapped(p)) -#else /* MMAP_CLEARS */ -#define calloc_must_clear(p) (1) -#endif /* MMAP_CLEARS */ - -/* ---------------------- Overlaid data structures ----------------------- */ - -/* - When chunks are not in use, they are treated as nodes of either - lists or trees. - - "Small" chunks are stored in circular doubly-linked lists, and look - like this: - - chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - | Size of previous chunk | - +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - `head:' | Size of chunk, in bytes |P| - mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - | Forward pointer to next chunk in list | - +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - | Back pointer to previous chunk in list | - +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - | Unused space (may be 0 bytes long) . - . . - . | -nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - `foot:' | Size of chunk, in bytes | - +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - - Larger chunks are kept in a form of bitwise digital trees (aka - tries) keyed on chunksizes. Because malloc_tree_chunks are only for - free chunks greater than 256 bytes, their size doesn't impose any - constraints on user chunk sizes. Each node looks like: - - chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - | Size of previous chunk | - +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - `head:' | Size of chunk, in bytes |P| - mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - | Forward pointer to next chunk of same size | - +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - | Back pointer to previous chunk of same size | - +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - | Pointer to left child (child[0]) | - +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - | Pointer to right child (child[1]) | - +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - | Pointer to parent | - +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - | bin index of this chunk | - +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - | Unused space . - . | -nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - `foot:' | Size of chunk, in bytes | - +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - - Each tree holding treenodes is a tree of unique chunk sizes. Chunks - of the same size are arranged in a circularly-linked list, with only - the oldest chunk (the next to be used, in our FIFO ordering) - actually in the tree. (Tree members are distinguished by a non-null - parent pointer.) If a chunk with the same size an an existing node - is inserted, it is linked off the existing node using pointers that - work in the same way as fd/bk pointers of small chunks. - - Each tree contains a power of 2 sized range of chunk sizes (the - smallest is 0x100 <= x < 0x180), which is is divided in half at each - tree level, with the chunks in the smaller half of the range (0x100 - <= x < 0x140 for the top nose) in the left subtree and the larger - half (0x140 <= x < 0x180) in the right subtree. This is, of course, - done by inspecting individual bits. - - Using these rules, each node's left subtree contains all smaller - sizes than its right subtree. However, the node at the root of each - subtree has no particular ordering relationship to either. (The - dividing line between the subtree sizes is based on trie relation.) - If we remove the last chunk of a given size from the interior of the - tree, we need to replace it with a leaf node. The tree ordering - rules permit a node to be replaced by any leaf below it. - - The smallest chunk in a tree (a common operation in a best-fit - allocator) can be found by walking a path to the leftmost leaf in - the tree. Unlike a usual binary tree, where we follow left child - pointers until we reach a null, here we follow the right child - pointer any time the left one is null, until we reach a leaf with - both child pointers null. The smallest chunk in the tree will be - somewhere along that path. - - The worst case number of steps to add, find, or remove a node is - bounded by the number of bits differentiating chunks within - bins. Under current bin calculations, this ranges from 6 up to 21 - (for 32 bit sizes) or up to 53 (for 64 bit sizes). The typical case - is of course much better. -*/ - -struct malloc_tree_chunk { - /* The first four fields must be compatible with malloc_chunk */ - size_t prev_foot; - size_t head; - struct malloc_tree_chunk* fd; - struct malloc_tree_chunk* bk; - - struct malloc_tree_chunk* child[2]; - struct malloc_tree_chunk* parent; - bindex_t index; -}; - -typedef struct malloc_tree_chunk tchunk; -typedef struct malloc_tree_chunk* tchunkptr; -typedef struct malloc_tree_chunk* tbinptr; /* The type of bins of trees */ - -/* A little helper macro for trees */ -#define leftmost_child(t) ((t)->child[0] != 0? (t)->child[0] : (t)->child[1]) - -/* ----------------------------- Segments -------------------------------- */ - -/* - Each malloc space may include non-contiguous segments, held in a - list headed by an embedded malloc_segment record representing the - top-most space. Segments also include flags holding properties of - the space. Large chunks that are directly allocated by mmap are not - included in this list. They are instead independently created and - destroyed without otherwise keeping track of them. - - Segment management mainly comes into play for spaces allocated by - MMAP. Any call to MMAP might or might not return memory that is - adjacent to an existing segment. MORECORE normally contiguously - extends the current space, so this space is almost always adjacent, - which is simpler and faster to deal with. (This is why MORECORE is - used preferentially to MMAP when both are available -- see - sys_alloc.) When allocating using MMAP, we don't use any of the - hinting mechanisms (inconsistently) supported in various - implementations of unix mmap, or distinguish reserving from - committing memory. Instead, we just ask for space, and exploit - contiguity when we get it. It is probably possible to do - better than this on some systems, but no general scheme seems - to be significantly better. - - Management entails a simpler variant of the consolidation scheme - used for chunks to reduce fragmentation -- new adjacent memory is - normally prepended or appended to an existing segment. However, - there are limitations compared to chunk consolidation that mostly - reflect the fact that segment processing is relatively infrequent - (occurring only when getting memory from system) and that we - don't expect to have huge numbers of segments: - - * Segments are not indexed, so traversal requires linear scans. (It - would be possible to index these, but is not worth the extra - overhead and complexity for most programs on most platforms.) - * New segments are only appended to old ones when holding top-most - memory; if they cannot be prepended to others, they are held in - different segments. - - Except for the top-most segment of an mstate, each segment record - is kept at the tail of its segment. Segments are added by pushing - segment records onto the list headed by &mstate.seg for the - containing mstate. - - Segment flags control allocation/merge/deallocation policies: - * If EXTERN_BIT set, then we did not allocate this segment, - and so should not try to deallocate or merge with others. - (This currently holds only for the initial segment passed - into create_mspace_with_base.) - * If USE_MMAP_BIT set, the segment may be merged with - other surrounding mmapped segments and trimmed/de-allocated - using munmap. - * If neither bit is set, then the segment was obtained using - MORECORE so can be merged with surrounding MORECORE'd segments - and deallocated/trimmed using MORECORE with negative arguments. -*/ - -struct malloc_segment { - char* base; /* base address */ - size_t size; /* allocated size */ - struct malloc_segment* next; /* ptr to next segment */ - flag_t sflags; /* mmap and extern flag */ -}; - -#define is_mmapped_segment(S) ((S)->sflags & USE_MMAP_BIT) -#define is_extern_segment(S) ((S)->sflags & EXTERN_BIT) - -typedef struct malloc_segment msegment; -typedef struct malloc_segment* msegmentptr; - -/* ---------------------------- malloc_state ----------------------------- */ - -/* - A malloc_state holds all of the bookkeeping for a space. - The main fields are: - - Top - The topmost chunk of the currently active segment. Its size is - cached in topsize. The actual size of topmost space is - topsize+TOP_FOOT_SIZE, which includes space reserved for adding - fenceposts and segment records if necessary when getting more - space from the system. The size at which to autotrim top is - cached from mparams in trim_check, except that it is disabled if - an autotrim fails. - - Designated victim (dv) - This is the preferred chunk for servicing small requests that - don't have exact fits. It is normally the chunk split off most - recently to service another small request. Its size is cached in - dvsize. The link fields of this chunk are not maintained since it - is not kept in a bin. - - SmallBins - An array of bin headers for free chunks. These bins hold chunks - with sizes less than MIN_LARGE_SIZE bytes. Each bin contains - chunks of all the same size, spaced 8 bytes apart. To simplify - use in double-linked lists, each bin header acts as a malloc_chunk - pointing to the real first node, if it exists (else pointing to - itself). This avoids special-casing for headers. But to avoid - waste, we allocate only the fd/bk pointers of bins, and then use - repositioning tricks to treat these as the fields of a chunk. - - TreeBins - Treebins are pointers to the roots of trees holding a range of - sizes. There are 2 equally spaced treebins for each power of two - from TREE_SHIFT to TREE_SHIFT+16. The last bin holds anything - larger. - - Bin maps - There is one bit map for small bins ("smallmap") and one for - treebins ("treemap). Each bin sets its bit when non-empty, and - clears the bit when empty. Bit operations are then used to avoid - bin-by-bin searching -- nearly all "search" is done without ever - looking at bins that won't be selected. The bit maps - conservatively use 32 bits per map word, even if on 64bit system. - For a good description of some of the bit-based techniques used - here, see Henry S. Warren Jr's book "Hacker's Delight" (and - supplement at http://hackersdelight.org/). Many of these are - intended to reduce the branchiness of paths through malloc etc, as - well as to reduce the number of memory locations read or written. - - Segments - A list of segments headed by an embedded malloc_segment record - representing the initial space. - - Address check support - The least_addr field is the least address ever obtained from - MORECORE or MMAP. Attempted frees and reallocs of any address less - than this are trapped (unless INSECURE is defined). - - Magic tag - A cross-check field that should always hold same value as mparams.magic. - - Max allowed footprint - The maximum allowed bytes to allocate from system (zero means no limit) - - Flags - Bits recording whether to use MMAP, locks, or contiguous MORECORE - - Statistics - Each space keeps track of current and maximum system memory - obtained via MORECORE or MMAP. - - Trim support - Fields holding the amount of unused topmost memory that should trigger - trimming, and a counter to force periodic scanning to release unused - non-topmost segments. - - Locking - If USE_LOCKS is defined, the "mutex" lock is acquired and released - around every public call using this mspace. - - Extension support - A void* pointer and a size_t field that can be used to help implement - extensions to this malloc. -*/ - -/* Bin types, widths and sizes */ -#define NSMALLBINS (32U) -#define NTREEBINS (32U) -#define SMALLBIN_SHIFT (3U) -#define SMALLBIN_WIDTH (SIZE_T_ONE << SMALLBIN_SHIFT) -#define TREEBIN_SHIFT (8U) -#define MIN_LARGE_SIZE (SIZE_T_ONE << TREEBIN_SHIFT) -#define MAX_SMALL_SIZE (MIN_LARGE_SIZE - SIZE_T_ONE) -#define MAX_SMALL_REQUEST (MAX_SMALL_SIZE - CHUNK_ALIGN_MASK - CHUNK_OVERHEAD) - -struct malloc_state { - binmap_t smallmap; - binmap_t treemap; - size_t dvsize; - size_t topsize; - char* least_addr; - mchunkptr dv; - mchunkptr top; - size_t trim_check; - size_t release_checks; - size_t magic; - mchunkptr smallbins[(NSMALLBINS+1)*2]; - tbinptr treebins[NTREEBINS]; - size_t footprint; - size_t max_footprint; - size_t footprint_limit; /* zero means no limit */ - flag_t mflags; -#if USE_LOCKS - MLOCK_T mutex; /* locate lock among fields that rarely change */ -#endif /* USE_LOCKS */ - msegment seg; - void* extp; /* Unused but available for extensions */ - size_t exts; -}; - -typedef struct malloc_state* mstate; - -/* ------------- Global malloc_state and malloc_params ------------------- */ - -/* - malloc_params holds global properties, including those that can be - dynamically set using mallopt. There is a single instance, mparams, - initialized in init_mparams. Note that the non-zeroness of "magic" - also serves as an initialization flag. -*/ - -struct malloc_params { - size_t magic; - size_t page_size; - size_t granularity; - size_t mmap_threshold; - size_t trim_threshold; - flag_t default_mflags; -}; - -static struct malloc_params mparams; - -/* Ensure mparams initialized */ -#define ensure_initialization() (void)(mparams.magic != 0 || init_mparams()) - -#if !ONLY_MSPACES - -/* The global malloc_state used for all non-"mspace" calls */ -static struct malloc_state _gm_; -#define gm (&_gm_) -#define is_global(M) ((M) == &_gm_) - -#endif /* !ONLY_MSPACES */ - -#define is_initialized(M) ((M)->top != 0) - -/* -------------------------- system alloc setup ------------------------- */ - -/* Operations on mflags */ - -#define use_lock(M) ((M)->mflags & USE_LOCK_BIT) -#define enable_lock(M) ((M)->mflags |= USE_LOCK_BIT) -#if USE_LOCKS -#define disable_lock(M) ((M)->mflags &= ~USE_LOCK_BIT) -#else -#define disable_lock(M) -#endif - -#define use_mmap(M) ((M)->mflags & USE_MMAP_BIT) -#define enable_mmap(M) ((M)->mflags |= USE_MMAP_BIT) -#if HAVE_MMAP -#define disable_mmap(M) ((M)->mflags &= ~USE_MMAP_BIT) -#else -#define disable_mmap(M) -#endif - -#define use_noncontiguous(M) ((M)->mflags & USE_NONCONTIGUOUS_BIT) -#define disable_contiguous(M) ((M)->mflags |= USE_NONCONTIGUOUS_BIT) - -#define set_lock(M,L)\ - ((M)->mflags = (L)?\ - ((M)->mflags | USE_LOCK_BIT) :\ - ((M)->mflags & ~USE_LOCK_BIT)) - -/* page-align a size */ -#define page_align(S)\ - (((S) + (mparams.page_size - SIZE_T_ONE)) & ~(mparams.page_size - SIZE_T_ONE)) - -/* granularity-align a size */ -#define granularity_align(S)\ - (((S) + (mparams.granularity - SIZE_T_ONE))\ - & ~(mparams.granularity - SIZE_T_ONE)) - - -/* For mmap, use granularity alignment on windows, else page-align */ -#ifdef WIN32 -#define mmap_align(S) granularity_align(S) -#else -#define mmap_align(S) page_align(S) -#endif - -/* For sys_alloc, enough padding to ensure can malloc request on success */ -#define SYS_ALLOC_PADDING (TOP_FOOT_SIZE + MALLOC_ALIGNMENT) - -#define is_page_aligned(S)\ - (((size_t)(S) & (mparams.page_size - SIZE_T_ONE)) == 0) -#define is_granularity_aligned(S)\ - (((size_t)(S) & (mparams.granularity - SIZE_T_ONE)) == 0) - -/* True if segment S holds address A */ -#define segment_holds(S, A)\ - ((char*)(A) >= S->base && (char*)(A) < S->base + S->size) - -/* Return segment holding given address */ -static msegmentptr segment_holding(mstate m, char* addr) { - msegmentptr sp = &m->seg; - for (;;) { - if (addr >= sp->base && addr < sp->base + sp->size) - return sp; - if ((sp = sp->next) == 0) - return 0; - } -} - -/* Return true if segment contains a segment link */ -static int has_segment_link(mstate m, msegmentptr ss) { - msegmentptr sp = &m->seg; - for (;;) { - if ((char*)sp >= ss->base && (char*)sp < ss->base + ss->size) - return 1; - if ((sp = sp->next) == 0) - return 0; - } -} - -#ifndef MORECORE_CANNOT_TRIM -#define should_trim(M,s) ((s) > (M)->trim_check) -#else /* MORECORE_CANNOT_TRIM */ -#define should_trim(M,s) (0) -#endif /* MORECORE_CANNOT_TRIM */ - -/* - TOP_FOOT_SIZE is padding at the end of a segment, including space - that may be needed to place segment records and fenceposts when new - noncontiguous segments are added. -*/ -#define TOP_FOOT_SIZE\ - (align_offset(chunk2mem(0))+pad_request(sizeof(struct malloc_segment))+MIN_CHUNK_SIZE) - - -/* ------------------------------- Hooks -------------------------------- */ - -/* - PREACTION should be defined to return 0 on success, and nonzero on - failure. If you are not using locking, you can redefine these to do - anything you like. -*/ - -#if USE_LOCKS -#define PREACTION(M) ((use_lock(M))? ACQUIRE_LOCK(&(M)->mutex) : 0) -#define POSTACTION(M) { if (use_lock(M)) RELEASE_LOCK(&(M)->mutex); } -#else /* USE_LOCKS */ - -#ifndef PREACTION -#define PREACTION(M) (0) -#endif /* PREACTION */ - -#ifndef POSTACTION -#define POSTACTION(M) -#endif /* POSTACTION */ - -#endif /* USE_LOCKS */ - -/* - CORRUPTION_ERROR_ACTION is triggered upon detected bad addresses. - USAGE_ERROR_ACTION is triggered on detected bad frees and - reallocs. The argument p is an address that might have triggered the - fault. It is ignored by the two predefined actions, but might be - useful in custom actions that try to help diagnose errors. -*/ - -#if PROCEED_ON_ERROR - -/* A count of the number of corruption errors causing resets */ -int malloc_corruption_error_count; - -/* default corruption action */ -static void reset_on_error(mstate m); - -#define CORRUPTION_ERROR_ACTION(m) reset_on_error(m) -#define USAGE_ERROR_ACTION(m, p) - -#else /* PROCEED_ON_ERROR */ - -#ifndef CORRUPTION_ERROR_ACTION -#define CORRUPTION_ERROR_ACTION(m) ABORT -#endif /* CORRUPTION_ERROR_ACTION */ - -#ifndef USAGE_ERROR_ACTION -#define USAGE_ERROR_ACTION(m,p) ABORT -#endif /* USAGE_ERROR_ACTION */ - -#endif /* PROCEED_ON_ERROR */ - - -/* -------------------------- Debugging setup ---------------------------- */ - -#if ! DEBUG - -#define check_free_chunk(M,P) -#define check_inuse_chunk(M,P) -#define check_malloced_chunk(M,P,N) -#define check_mmapped_chunk(M,P) -#define check_malloc_state(M) -#define check_top_chunk(M,P) - -#else /* DEBUG */ -#define check_free_chunk(M,P) do_check_free_chunk(M,P) -#define check_inuse_chunk(M,P) do_check_inuse_chunk(M,P) -#define check_top_chunk(M,P) do_check_top_chunk(M,P) -#define check_malloced_chunk(M,P,N) do_check_malloced_chunk(M,P,N) -#define check_mmapped_chunk(M,P) do_check_mmapped_chunk(M,P) -#define check_malloc_state(M) do_check_malloc_state(M) - -static void do_check_any_chunk(mstate m, mchunkptr p); -static void do_check_top_chunk(mstate m, mchunkptr p); -static void do_check_mmapped_chunk(mstate m, mchunkptr p); -static void do_check_inuse_chunk(mstate m, mchunkptr p); -static void do_check_free_chunk(mstate m, mchunkptr p); -static void do_check_malloced_chunk(mstate m, void* mem, size_t s); -static void do_check_tree(mstate m, tchunkptr t); -static void do_check_treebin(mstate m, bindex_t i); -static void do_check_smallbin(mstate m, bindex_t i); -static void do_check_malloc_state(mstate m); -static int bin_find(mstate m, mchunkptr x); -static size_t traverse_and_check(mstate m); -#endif /* DEBUG */ - -/* ---------------------------- Indexing Bins ---------------------------- */ - -#define is_small(s) (((s) >> SMALLBIN_SHIFT) < NSMALLBINS) -#define small_index(s) (bindex_t)((s) >> SMALLBIN_SHIFT) -#define small_index2size(i) ((i) << SMALLBIN_SHIFT) -#define MIN_SMALL_INDEX (small_index(MIN_CHUNK_SIZE)) - -/* addressing by index. See above about smallbin repositioning */ -#define smallbin_at(M, i) ((sbinptr)((char*)&((M)->smallbins[(i)<<1]))) -#define treebin_at(M,i) (&((M)->treebins[i])) - -/* assign tree index for size S to variable I. Use x86 asm if possible */ -#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) -#define compute_tree_index(S, I)\ -{\ - unsigned int X = S >> TREEBIN_SHIFT;\ - if (X == 0)\ - I = 0;\ - else if (X > 0xFFFF)\ - I = NTREEBINS-1;\ - else {\ - unsigned int K = (unsigned) sizeof(X)*__CHAR_BIT__ - 1 - (unsigned) __builtin_clz(X); \ - I = (bindex_t)((K << 1) + ((S >> (K + (TREEBIN_SHIFT-1)) & 1)));\ - }\ -} - -#elif defined (__INTEL_COMPILER) -#define compute_tree_index(S, I)\ -{\ - size_t X = S >> TREEBIN_SHIFT;\ - if (X == 0)\ - I = 0;\ - else if (X > 0xFFFF)\ - I = NTREEBINS-1;\ - else {\ - unsigned int K = _bit_scan_reverse (X); \ - I = (bindex_t)((K << 1) + ((S >> (K + (TREEBIN_SHIFT-1)) & 1)));\ - }\ -} - -#elif defined(_MSC_VER) && _MSC_VER>=1300 -#define compute_tree_index(S, I)\ -{\ - size_t X = S >> TREEBIN_SHIFT;\ - if (X == 0)\ - I = 0;\ - else if (X > 0xFFFF)\ - I = NTREEBINS-1;\ - else {\ - unsigned int K;\ - _BitScanReverse((DWORD *) &K, (DWORD) X);\ - I = (bindex_t)((K << 1) + ((S >> (K + (TREEBIN_SHIFT-1)) & 1)));\ - }\ -} - -#else /* GNUC */ -#define compute_tree_index(S, I)\ -{\ - size_t X = S >> TREEBIN_SHIFT;\ - if (X == 0)\ - I = 0;\ - else if (X > 0xFFFF)\ - I = NTREEBINS-1;\ - else {\ - unsigned int Y = (unsigned int)X;\ - unsigned int N = ((Y - 0x100) >> 16) & 8;\ - unsigned int K = (((Y <<= N) - 0x1000) >> 16) & 4;\ - N += K;\ - N += K = (((Y <<= K) - 0x4000) >> 16) & 2;\ - K = 14 - N + ((Y <<= K) >> 15);\ - I = (K << 1) + ((S >> (K + (TREEBIN_SHIFT-1)) & 1));\ - }\ -} -#endif /* GNUC */ - -/* Bit representing maximum resolved size in a treebin at i */ -#define bit_for_tree_index(i) \ - (i == NTREEBINS-1)? (SIZE_T_BITSIZE-1) : (((i) >> 1) + TREEBIN_SHIFT - 2) - -/* Shift placing maximum resolved bit in a treebin at i as sign bit */ -#define leftshift_for_tree_index(i) \ - ((i == NTREEBINS-1)? 0 : \ - ((SIZE_T_BITSIZE-SIZE_T_ONE) - (((i) >> 1) + TREEBIN_SHIFT - 2))) - -/* The size of the smallest chunk held in bin with index i */ -#define minsize_for_tree_index(i) \ - ((SIZE_T_ONE << (((i) >> 1) + TREEBIN_SHIFT)) | \ - (((size_t)((i) & SIZE_T_ONE)) << (((i) >> 1) + TREEBIN_SHIFT - 1))) - - -/* ------------------------ Operations on bin maps ----------------------- */ - -/* bit corresponding to given index */ -#define idx2bit(i) ((binmap_t)(1) << (i)) - -/* Mark/Clear bits with given index */ -#define mark_smallmap(M,i) ((M)->smallmap |= idx2bit(i)) -#define clear_smallmap(M,i) ((M)->smallmap &= ~idx2bit(i)) -#define smallmap_is_marked(M,i) ((M)->smallmap & idx2bit(i)) - -#define mark_treemap(M,i) ((M)->treemap |= idx2bit(i)) -#define clear_treemap(M,i) ((M)->treemap &= ~idx2bit(i)) -#define treemap_is_marked(M,i) ((M)->treemap & idx2bit(i)) - -/* isolate the least set bit of a bitmap */ -#define least_bit(x) ((x) & -(x)) - -/* mask with all bits to left of least bit of x on */ -#define left_bits(x) ((x<<1) | -(x<<1)) - -/* mask with all bits to left of or equal to least bit of x on */ -#define same_or_left_bits(x) ((x) | -(x)) - -/* index corresponding to given bit. Use x86 asm if possible */ - -#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) -#define compute_bit2idx(X, I)\ -{\ - unsigned int J;\ - J = __builtin_ctz(X); \ - I = (bindex_t)J;\ -} - -#elif defined (__INTEL_COMPILER) -#define compute_bit2idx(X, I)\ -{\ - unsigned int J;\ - J = _bit_scan_forward (X); \ - I = (bindex_t)J;\ -} - -#elif defined(_MSC_VER) && _MSC_VER>=1300 -#define compute_bit2idx(X, I)\ -{\ - unsigned int J;\ - _BitScanForward((DWORD *) &J, X);\ - I = (bindex_t)J;\ -} - -#elif USE_BUILTIN_FFS -#define compute_bit2idx(X, I) I = ffs(X)-1 - -#else -#define compute_bit2idx(X, I)\ -{\ - unsigned int Y = X - 1;\ - unsigned int K = Y >> (16-4) & 16;\ - unsigned int N = K; Y >>= K;\ - N += K = Y >> (8-3) & 8; Y >>= K;\ - N += K = Y >> (4-2) & 4; Y >>= K;\ - N += K = Y >> (2-1) & 2; Y >>= K;\ - N += K = Y >> (1-0) & 1; Y >>= K;\ - I = (bindex_t)(N + Y);\ -} -#endif /* GNUC */ - - -/* ----------------------- Runtime Check Support ------------------------- */ - -/* - For security, the main invariant is that malloc/free/etc never - writes to a static address other than malloc_state, unless static - malloc_state itself has been corrupted, which cannot occur via - malloc (because of these checks). In essence this means that we - believe all pointers, sizes, maps etc held in malloc_state, but - check all of those linked or offsetted from other embedded data - structures. These checks are interspersed with main code in a way - that tends to minimize their run-time cost. - - When FOOTERS is defined, in addition to range checking, we also - verify footer fields of inuse chunks, which can be used guarantee - that the mstate controlling malloc/free is intact. This is a - streamlined version of the approach described by William Robertson - et al in "Run-time Detection of Heap-based Overflows" LISA'03 - http://www.usenix.org/events/lisa03/tech/robertson.html The footer - of an inuse chunk holds the xor of its mstate and a random seed, - that is checked upon calls to free() and realloc(). This is - (probabalistically) unguessable from outside the program, but can be - computed by any code successfully malloc'ing any chunk, so does not - itself provide protection against code that has already broken - security through some other means. Unlike Robertson et al, we - always dynamically check addresses of all offset chunks (previous, - next, etc). This turns out to be cheaper than relying on hashes. -*/ - -#if !INSECURE -/* Check if address a is at least as high as any from MORECORE or MMAP */ -#define ok_address(M, a) ((char*)(a) >= (M)->least_addr) -/* Check if address of next chunk n is higher than base chunk p */ -#define ok_next(p, n) ((char*)(p) < (char*)(n)) -/* Check if p has inuse status */ -#define ok_inuse(p) is_inuse(p) -/* Check if p has its pinuse bit on */ -#define ok_pinuse(p) pinuse(p) - -#else /* !INSECURE */ -#define ok_address(M, a) (1) -#define ok_next(b, n) (1) -#define ok_inuse(p) (1) -#define ok_pinuse(p) (1) -#endif /* !INSECURE */ - -#if (FOOTERS && !INSECURE) -/* Check if (alleged) mstate m has expected magic field */ -#define ok_magic(M) ((M)->magic == mparams.magic) -#else /* (FOOTERS && !INSECURE) */ -#define ok_magic(M) (1) -#endif /* (FOOTERS && !INSECURE) */ - -/* In gcc, use __builtin_expect to minimize impact of checks */ -#if !INSECURE -#if defined(__GNUC__) && __GNUC__ >= 3 -#define RTCHECK(e) __builtin_expect(e, 1) -#else /* GNUC */ -#define RTCHECK(e) (e) -#endif /* GNUC */ -#else /* !INSECURE */ -#define RTCHECK(e) (1) -#endif /* !INSECURE */ - -/* macros to set up inuse chunks with or without footers */ - -#if !FOOTERS - -#define mark_inuse_foot(M,p,s) - -/* Macros for setting head/foot of non-mmapped chunks */ - -/* Set cinuse bit and pinuse bit of next chunk */ -#define set_inuse(M,p,s)\ - ((p)->head = (((p)->head & PINUSE_BIT)|s|CINUSE_BIT),\ - ((mchunkptr)(((char*)(p)) + (s)))->head |= PINUSE_BIT) - -/* Set cinuse and pinuse of this chunk and pinuse of next chunk */ -#define set_inuse_and_pinuse(M,p,s)\ - ((p)->head = (s|PINUSE_BIT|CINUSE_BIT),\ - ((mchunkptr)(((char*)(p)) + (s)))->head |= PINUSE_BIT) - -/* Set size, cinuse and pinuse bit of this chunk */ -#define set_size_and_pinuse_of_inuse_chunk(M, p, s)\ - ((p)->head = (s|PINUSE_BIT|CINUSE_BIT)) - -#else /* FOOTERS */ - -/* Set foot of inuse chunk to be xor of mstate and seed */ -#define mark_inuse_foot(M,p,s)\ - (((mchunkptr)((char*)(p) + (s)))->prev_foot = ((size_t)(M) ^ mparams.magic)) - -#define get_mstate_for(p)\ - ((mstate)(((mchunkptr)((char*)(p) +\ - (chunksize(p))))->prev_foot ^ mparams.magic)) - -#define set_inuse(M,p,s)\ - ((p)->head = (((p)->head & PINUSE_BIT)|s|CINUSE_BIT),\ - (((mchunkptr)(((char*)(p)) + (s)))->head |= PINUSE_BIT), \ - mark_inuse_foot(M,p,s)) - -#define set_inuse_and_pinuse(M,p,s)\ - ((p)->head = (s|PINUSE_BIT|CINUSE_BIT),\ - (((mchunkptr)(((char*)(p)) + (s)))->head |= PINUSE_BIT),\ - mark_inuse_foot(M,p,s)) - -#define set_size_and_pinuse_of_inuse_chunk(M, p, s)\ - ((p)->head = (s|PINUSE_BIT|CINUSE_BIT),\ - mark_inuse_foot(M, p, s)) - -#endif /* !FOOTERS */ - -/* ---------------------------- setting mparams -------------------------- */ - -#if LOCK_AT_FORK -static void pre_fork(void) { ACQUIRE_LOCK(&(gm)->mutex); } -static void post_fork_parent(void) { RELEASE_LOCK(&(gm)->mutex); } -static void post_fork_child(void) { INITIAL_LOCK(&(gm)->mutex); } -#endif /* LOCK_AT_FORK */ - -/* Initialize mparams */ -static int init_mparams(void) { -#ifdef NEED_GLOBAL_LOCK_INIT - if (malloc_global_mutex_status <= 0) - init_malloc_global_mutex(); -#endif - - ACQUIRE_MALLOC_GLOBAL_LOCK(); - if (mparams.magic == 0) { - size_t magic; - size_t psize; - size_t gsize; - -#ifndef WIN32 - psize = malloc_getpagesize; - gsize = ((DEFAULT_GRANULARITY != 0)? DEFAULT_GRANULARITY : psize); -#else /* WIN32 */ - { - SYSTEM_INFO system_info; - GetSystemInfo(&system_info); - psize = system_info.dwPageSize; - gsize = ((DEFAULT_GRANULARITY != 0)? - DEFAULT_GRANULARITY : system_info.dwAllocationGranularity); - } -#endif /* WIN32 */ - - /* Sanity-check configuration: - size_t must be unsigned and as wide as pointer type. - ints must be at least 4 bytes. - alignment must be at least 8. - Alignment, min chunk size, and page size must all be powers of 2. - */ - if ((sizeof(size_t) != sizeof(char*)) || - (MAX_SIZE_T < MIN_CHUNK_SIZE) || - (sizeof(int) < 4) || - (MALLOC_ALIGNMENT < (size_t)8U) || - ((MALLOC_ALIGNMENT & (MALLOC_ALIGNMENT-SIZE_T_ONE)) != 0) || - ((MCHUNK_SIZE & (MCHUNK_SIZE-SIZE_T_ONE)) != 0) || - ((gsize & (gsize-SIZE_T_ONE)) != 0) || - ((psize & (psize-SIZE_T_ONE)) != 0)) - ABORT; - mparams.granularity = gsize; - mparams.page_size = psize; - mparams.mmap_threshold = DEFAULT_MMAP_THRESHOLD; - mparams.trim_threshold = DEFAULT_TRIM_THRESHOLD; -#if MORECORE_CONTIGUOUS - mparams.default_mflags = USE_LOCK_BIT|USE_MMAP_BIT; -#else /* MORECORE_CONTIGUOUS */ - mparams.default_mflags = USE_LOCK_BIT|USE_MMAP_BIT|USE_NONCONTIGUOUS_BIT; -#endif /* MORECORE_CONTIGUOUS */ - -#if !ONLY_MSPACES - /* Set up lock for main malloc area */ - gm->mflags = mparams.default_mflags; - (void)INITIAL_LOCK(&gm->mutex); -#endif -#if LOCK_AT_FORK - pthread_atfork(&pre_fork, &post_fork_parent, &post_fork_child); -#endif - - { -#if USE_DEV_RANDOM - int fd; - unsigned char buf[sizeof(size_t)]; - /* Try to use /dev/urandom, else fall back on using time */ - if ((fd = open("/dev/urandom", O_RDONLY)) >= 0 && - read(fd, buf, sizeof(buf)) == sizeof(buf)) { - magic = *((size_t *) buf); - close(fd); - } - else -#endif /* USE_DEV_RANDOM */ -#ifdef WIN32 - magic = (size_t)(GetTickCount() ^ (size_t)0x55555555U); -#elif defined(LACKS_TIME_H) - magic = (size_t)&magic ^ (size_t)0x55555555U; -#else - magic = (size_t)(time(0) ^ (size_t)0x55555555U); -#endif - magic |= (size_t)8U; /* ensure nonzero */ - magic &= ~(size_t)7U; /* improve chances of fault for bad values */ - /* Until memory modes commonly available, use volatile-write */ - (*(volatile size_t *)(&(mparams.magic))) = magic; - } - } - - RELEASE_MALLOC_GLOBAL_LOCK(); - return 1; -} - -/* support for mallopt */ -static int change_mparam(int param_number, int value) { - size_t val; - ensure_initialization(); - val = (value == -1)? MAX_SIZE_T : (size_t)value; - switch(param_number) { - case M_TRIM_THRESHOLD: - mparams.trim_threshold = val; - return 1; - case M_GRANULARITY: - if (val >= mparams.page_size && ((val & (val-1)) == 0)) { - mparams.granularity = val; - return 1; - } - else - return 0; - case M_MMAP_THRESHOLD: - mparams.mmap_threshold = val; - return 1; - default: - return 0; - } -} - -#if DEBUG -/* ------------------------- Debugging Support --------------------------- */ - -/* Check properties of any chunk, whether free, inuse, mmapped etc */ -static void do_check_any_chunk(mstate m, mchunkptr p) { - assert((is_aligned(chunk2mem(p))) || (p->head == FENCEPOST_HEAD)); - assert(ok_address(m, p)); -} - -/* Check properties of top chunk */ -static void do_check_top_chunk(mstate m, mchunkptr p) { - msegmentptr sp = segment_holding(m, (char*)p); - size_t sz = p->head & ~INUSE_BITS; /* third-lowest bit can be set! */ - assert(sp != 0); - assert((is_aligned(chunk2mem(p))) || (p->head == FENCEPOST_HEAD)); - assert(ok_address(m, p)); - assert(sz == m->topsize); - assert(sz > 0); - assert(sz == ((sp->base + sp->size) - (char*)p) - TOP_FOOT_SIZE); - assert(pinuse(p)); - assert(!pinuse(chunk_plus_offset(p, sz))); -} - -/* Check properties of (inuse) mmapped chunks */ -static void do_check_mmapped_chunk(mstate m, mchunkptr p) { - size_t sz = chunksize(p); - size_t len = (sz + (p->prev_foot) + MMAP_FOOT_PAD); - assert(is_mmapped(p)); - assert(use_mmap(m)); - assert((is_aligned(chunk2mem(p))) || (p->head == FENCEPOST_HEAD)); - assert(ok_address(m, p)); - assert(!is_small(sz)); - assert((len & (mparams.page_size-SIZE_T_ONE)) == 0); - assert(chunk_plus_offset(p, sz)->head == FENCEPOST_HEAD); - assert(chunk_plus_offset(p, sz+SIZE_T_SIZE)->head == 0); -} - -/* Check properties of inuse chunks */ -static void do_check_inuse_chunk(mstate m, mchunkptr p) { - do_check_any_chunk(m, p); - assert(is_inuse(p)); - assert(next_pinuse(p)); - /* If not pinuse and not mmapped, previous chunk has OK offset */ - assert(is_mmapped(p) || pinuse(p) || next_chunk(prev_chunk(p)) == p); - if (is_mmapped(p)) - do_check_mmapped_chunk(m, p); -} - -/* Check properties of free chunks */ -static void do_check_free_chunk(mstate m, mchunkptr p) { - size_t sz = chunksize(p); - mchunkptr next = chunk_plus_offset(p, sz); - do_check_any_chunk(m, p); - assert(!is_inuse(p)); - assert(!next_pinuse(p)); - assert (!is_mmapped(p)); - if (p != m->dv && p != m->top) { - if (sz >= MIN_CHUNK_SIZE) { - assert((sz & CHUNK_ALIGN_MASK) == 0); - assert(is_aligned(chunk2mem(p))); - assert(next->prev_foot == sz); - assert(pinuse(p)); - assert (next == m->top || is_inuse(next)); - assert(p->fd->bk == p); - assert(p->bk->fd == p); - } - else /* markers are always of size SIZE_T_SIZE */ - assert(sz == SIZE_T_SIZE); - } -} - -/* Check properties of malloced chunks at the point they are malloced */ -static void do_check_malloced_chunk(mstate m, void* mem, size_t s) { - if (mem != 0) { - mchunkptr p = mem2chunk(mem); - size_t sz = p->head & ~INUSE_BITS; - do_check_inuse_chunk(m, p); - assert((sz & CHUNK_ALIGN_MASK) == 0); - assert(sz >= MIN_CHUNK_SIZE); - assert(sz >= s); - /* unless mmapped, size is less than MIN_CHUNK_SIZE more than request */ - assert(is_mmapped(p) || sz < (s + MIN_CHUNK_SIZE)); - } -} - -/* Check a tree and its subtrees. */ -static void do_check_tree(mstate m, tchunkptr t) { - tchunkptr head = 0; - tchunkptr u = t; - bindex_t tindex = t->index; - size_t tsize = chunksize(t); - bindex_t idx; - compute_tree_index(tsize, idx); - assert(tindex == idx); - assert(tsize >= MIN_LARGE_SIZE); - assert(tsize >= minsize_for_tree_index(idx)); - assert((idx == NTREEBINS-1) || (tsize < minsize_for_tree_index((idx+1)))); - - do { /* traverse through chain of same-sized nodes */ - do_check_any_chunk(m, ((mchunkptr)u)); - assert(u->index == tindex); - assert(chunksize(u) == tsize); - assert(!is_inuse(u)); - assert(!next_pinuse(u)); - assert(u->fd->bk == u); - assert(u->bk->fd == u); - if (u->parent == 0) { - assert(u->child[0] == 0); - assert(u->child[1] == 0); - } - else { - assert(head == 0); /* only one node on chain has parent */ - head = u; - assert(u->parent != u); - assert (u->parent->child[0] == u || - u->parent->child[1] == u || - *((tbinptr*)(u->parent)) == u); - if (u->child[0] != 0) { - assert(u->child[0]->parent == u); - assert(u->child[0] != u); - do_check_tree(m, u->child[0]); - } - if (u->child[1] != 0) { - assert(u->child[1]->parent == u); - assert(u->child[1] != u); - do_check_tree(m, u->child[1]); - } - if (u->child[0] != 0 && u->child[1] != 0) { - assert(chunksize(u->child[0]) < chunksize(u->child[1])); - } - } - u = u->fd; - } while (u != t); - assert(head != 0); -} - -/* Check all the chunks in a treebin. */ -static void do_check_treebin(mstate m, bindex_t i) { - tbinptr* tb = treebin_at(m, i); - tchunkptr t = *tb; - int empty = (m->treemap & (1U << i)) == 0; - if (t == 0) - assert(empty); - if (!empty) - do_check_tree(m, t); -} - -/* Check all the chunks in a smallbin. */ -static void do_check_smallbin(mstate m, bindex_t i) { - sbinptr b = smallbin_at(m, i); - mchunkptr p = b->bk; - unsigned int empty = (m->smallmap & (1U << i)) == 0; - if (p == b) - assert(empty); - if (!empty) { - for (; p != b; p = p->bk) { - size_t size = chunksize(p); - mchunkptr q; - /* each chunk claims to be free */ - do_check_free_chunk(m, p); - /* chunk belongs in bin */ - assert(small_index(size) == i); - assert(p->bk == b || chunksize(p->bk) == chunksize(p)); - /* chunk is followed by an inuse chunk */ - q = next_chunk(p); - if (q->head != FENCEPOST_HEAD) - do_check_inuse_chunk(m, q); - } - } -} - -/* Find x in a bin. Used in other check functions. */ -static int bin_find(mstate m, mchunkptr x) { - size_t size = chunksize(x); - if (is_small(size)) { - bindex_t sidx = small_index(size); - sbinptr b = smallbin_at(m, sidx); - if (smallmap_is_marked(m, sidx)) { - mchunkptr p = b; - do { - if (p == x) - return 1; - } while ((p = p->fd) != b); - } - } - else { - bindex_t tidx; - compute_tree_index(size, tidx); - if (treemap_is_marked(m, tidx)) { - tchunkptr t = *treebin_at(m, tidx); - size_t sizebits = size << leftshift_for_tree_index(tidx); - while (t != 0 && chunksize(t) != size) { - t = t->child[(sizebits >> (SIZE_T_BITSIZE-SIZE_T_ONE)) & 1]; - sizebits <<= 1; - } - if (t != 0) { - tchunkptr u = t; - do { - if (u == (tchunkptr)x) - return 1; - } while ((u = u->fd) != t); - } - } - } - return 0; -} - -/* Traverse each chunk and check it; return total */ -static size_t traverse_and_check(mstate m) { - size_t sum = 0; - if (is_initialized(m)) { - msegmentptr s = &m->seg; - sum += m->topsize + TOP_FOOT_SIZE; - while (s != 0) { - mchunkptr q = align_as_chunk(s->base); - mchunkptr lastq = 0; - assert(pinuse(q)); - while (segment_holds(s, q) && - q != m->top && q->head != FENCEPOST_HEAD) { - sum += chunksize(q); - if (is_inuse(q)) { - assert(!bin_find(m, q)); - do_check_inuse_chunk(m, q); - } - else { - assert(q == m->dv || bin_find(m, q)); - assert(lastq == 0 || is_inuse(lastq)); /* Not 2 consecutive free */ - do_check_free_chunk(m, q); - } - lastq = q; - q = next_chunk(q); - } - s = s->next; - } - } - return sum; -} - - -/* Check all properties of malloc_state. */ -static void do_check_malloc_state(mstate m) { - bindex_t i; - size_t total; - /* check bins */ - for (i = 0; i < NSMALLBINS; ++i) - do_check_smallbin(m, i); - for (i = 0; i < NTREEBINS; ++i) - do_check_treebin(m, i); - - if (m->dvsize != 0) { /* check dv chunk */ - do_check_any_chunk(m, m->dv); - assert(m->dvsize == chunksize(m->dv)); - assert(m->dvsize >= MIN_CHUNK_SIZE); - assert(bin_find(m, m->dv) == 0); - } - - if (m->top != 0) { /* check top chunk */ - do_check_top_chunk(m, m->top); - /*assert(m->topsize == chunksize(m->top)); redundant */ - assert(m->topsize > 0); - assert(bin_find(m, m->top) == 0); - } - - total = traverse_and_check(m); - assert(total <= m->footprint); - assert(m->footprint <= m->max_footprint); -} -#endif /* DEBUG */ - -/* ----------------------------- statistics ------------------------------ */ - -#if !NO_MALLINFO -static struct mallinfo internal_mallinfo(mstate m) { - struct mallinfo nm = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; - ensure_initialization(); - if (!PREACTION(m)) { - check_malloc_state(m); - if (is_initialized(m)) { - size_t nfree = SIZE_T_ONE; /* top always free */ - size_t mfree = m->topsize + TOP_FOOT_SIZE; - size_t sum = mfree; - msegmentptr s = &m->seg; - while (s != 0) { - mchunkptr q = align_as_chunk(s->base); - while (segment_holds(s, q) && - q != m->top && q->head != FENCEPOST_HEAD) { - size_t sz = chunksize(q); - sum += sz; - if (!is_inuse(q)) { - mfree += sz; - ++nfree; - } - q = next_chunk(q); - } - s = s->next; - } - - nm.arena = sum; - nm.ordblks = nfree; - nm.hblkhd = m->footprint - sum; - nm.usmblks = m->max_footprint; - nm.uordblks = m->footprint - mfree; - nm.fordblks = mfree; - nm.keepcost = m->topsize; - } - - POSTACTION(m); - } - return nm; -} -#endif /* !NO_MALLINFO */ - -#if !NO_MALLOC_STATS -static void internal_malloc_stats(mstate m) { - ensure_initialization(); - if (!PREACTION(m)) { - size_t maxfp = 0; - size_t fp = 0; - size_t used = 0; - check_malloc_state(m); - if (is_initialized(m)) { - msegmentptr s = &m->seg; - maxfp = m->max_footprint; - fp = m->footprint; - used = fp - (m->topsize + TOP_FOOT_SIZE); - - while (s != 0) { - mchunkptr q = align_as_chunk(s->base); - while (segment_holds(s, q) && - q != m->top && q->head != FENCEPOST_HEAD) { - if (!is_inuse(q)) - used -= chunksize(q); - q = next_chunk(q); - } - s = s->next; - } - } - POSTACTION(m); /* drop lock */ - fprintf(stderr, "max system bytes = %10lu\n", (unsigned long)(maxfp)); - fprintf(stderr, "system bytes = %10lu\n", (unsigned long)(fp)); - fprintf(stderr, "in use bytes = %10lu\n", (unsigned long)(used)); - } -} -#endif /* NO_MALLOC_STATS */ - -/* ----------------------- Operations on smallbins ----------------------- */ - -/* - Various forms of linking and unlinking are defined as macros. Even - the ones for trees, which are very long but have very short typical - paths. This is ugly but reduces reliance on inlining support of - compilers. -*/ - -/* Link a free chunk into a smallbin */ -#define insert_small_chunk(M, P, S) {\ - bindex_t I = small_index(S);\ - mchunkptr B = smallbin_at(M, I);\ - mchunkptr F = B;\ - assert(S >= MIN_CHUNK_SIZE);\ - if (!smallmap_is_marked(M, I))\ - mark_smallmap(M, I);\ - else if (RTCHECK(ok_address(M, B->fd)))\ - F = B->fd;\ - else {\ - CORRUPTION_ERROR_ACTION(M);\ - }\ - B->fd = P;\ - F->bk = P;\ - P->fd = F;\ - P->bk = B;\ -} - -/* Unlink a chunk from a smallbin */ -#define unlink_small_chunk(M, P, S) {\ - mchunkptr F = P->fd;\ - mchunkptr B = P->bk;\ - bindex_t I = small_index(S);\ - assert(P != B);\ - assert(P != F);\ - assert(chunksize(P) == small_index2size(I));\ - if (RTCHECK(F == smallbin_at(M,I) || (ok_address(M, F) && F->bk == P))) { \ - if (B == F) {\ - clear_smallmap(M, I);\ - }\ - else if (RTCHECK(B == smallbin_at(M,I) ||\ - (ok_address(M, B) && B->fd == P))) {\ - F->bk = B;\ - B->fd = F;\ - }\ - else {\ - CORRUPTION_ERROR_ACTION(M);\ - }\ - }\ - else {\ - CORRUPTION_ERROR_ACTION(M);\ - }\ -} - -/* Unlink the first chunk from a smallbin */ -#define unlink_first_small_chunk(M, B, P, I) {\ - mchunkptr F = P->fd;\ - assert(P != B);\ - assert(P != F);\ - assert(chunksize(P) == small_index2size(I));\ - if (B == F) {\ - clear_smallmap(M, I);\ - }\ - else if (RTCHECK(ok_address(M, F) && F->bk == P)) {\ - F->bk = B;\ - B->fd = F;\ - }\ - else {\ - CORRUPTION_ERROR_ACTION(M);\ - }\ -} - -/* Replace dv node, binning the old one */ -/* Used only when dvsize known to be small */ -#define replace_dv(M, P, S) {\ - size_t DVS = M->dvsize;\ - assert(is_small(DVS));\ - if (DVS != 0) {\ - mchunkptr DV = M->dv;\ - insert_small_chunk(M, DV, DVS);\ - }\ - M->dvsize = S;\ - M->dv = P;\ -} - -/* ------------------------- Operations on trees ------------------------- */ - -/* Insert chunk into tree */ -#define insert_large_chunk(M, X, S) {\ - tbinptr* H;\ - bindex_t I;\ - compute_tree_index(S, I);\ - H = treebin_at(M, I);\ - X->index = I;\ - X->child[0] = X->child[1] = 0;\ - if (!treemap_is_marked(M, I)) {\ - mark_treemap(M, I);\ - *H = X;\ - X->parent = (tchunkptr)H;\ - X->fd = X->bk = X;\ - }\ - else {\ - tchunkptr T = *H;\ - size_t K = S << leftshift_for_tree_index(I);\ - for (;;) {\ - if (chunksize(T) != S) {\ - tchunkptr* C = &(T->child[(K >> (SIZE_T_BITSIZE-SIZE_T_ONE)) & 1]);\ - K <<= 1;\ - if (*C != 0)\ - T = *C;\ - else if (RTCHECK(ok_address(M, C))) {\ - *C = X;\ - X->parent = T;\ - X->fd = X->bk = X;\ - break;\ - }\ - else {\ - CORRUPTION_ERROR_ACTION(M);\ - break;\ - }\ - }\ - else {\ - tchunkptr F = T->fd;\ - if (RTCHECK(ok_address(M, T) && ok_address(M, F))) {\ - T->fd = F->bk = X;\ - X->fd = F;\ - X->bk = T;\ - X->parent = 0;\ - break;\ - }\ - else {\ - CORRUPTION_ERROR_ACTION(M);\ - break;\ - }\ - }\ - }\ - }\ -} - -/* - Unlink steps: - - 1. If x is a chained node, unlink it from its same-sized fd/bk links - and choose its bk node as its replacement. - 2. If x was the last node of its size, but not a leaf node, it must - be replaced with a leaf node (not merely one with an open left or - right), to make sure that lefts and rights of descendents - correspond properly to bit masks. We use the rightmost descendent - of x. We could use any other leaf, but this is easy to locate and - tends to counteract removal of leftmosts elsewhere, and so keeps - paths shorter than minimally guaranteed. This doesn't loop much - because on average a node in a tree is near the bottom. - 3. If x is the base of a chain (i.e., has parent links) relink - x's parent and children to x's replacement (or null if none). -*/ - -#define unlink_large_chunk(M, X) {\ - tchunkptr XP = X->parent;\ - tchunkptr R;\ - if (X->bk != X) {\ - tchunkptr F = X->fd;\ - R = X->bk;\ - if (RTCHECK(ok_address(M, F) && F->bk == X && R->fd == X)) {\ - F->bk = R;\ - R->fd = F;\ - }\ - else {\ - CORRUPTION_ERROR_ACTION(M);\ - }\ - }\ - else {\ - tchunkptr* RP;\ - if (((R = *(RP = &(X->child[1]))) != 0) ||\ - ((R = *(RP = &(X->child[0]))) != 0)) {\ - tchunkptr* CP;\ - while ((*(CP = &(R->child[1])) != 0) ||\ - (*(CP = &(R->child[0])) != 0)) {\ - R = *(RP = CP);\ - }\ - if (RTCHECK(ok_address(M, RP)))\ - *RP = 0;\ - else {\ - CORRUPTION_ERROR_ACTION(M);\ - }\ - }\ - }\ - if (XP != 0) {\ - tbinptr* H = treebin_at(M, X->index);\ - if (X == *H) {\ - if ((*H = R) == 0) \ - clear_treemap(M, X->index);\ - }\ - else if (RTCHECK(ok_address(M, XP))) {\ - if (XP->child[0] == X) \ - XP->child[0] = R;\ - else \ - XP->child[1] = R;\ - }\ - else\ - CORRUPTION_ERROR_ACTION(M);\ - if (R != 0) {\ - if (RTCHECK(ok_address(M, R))) {\ - tchunkptr C0, C1;\ - R->parent = XP;\ - if ((C0 = X->child[0]) != 0) {\ - if (RTCHECK(ok_address(M, C0))) {\ - R->child[0] = C0;\ - C0->parent = R;\ - }\ - else\ - CORRUPTION_ERROR_ACTION(M);\ - }\ - if ((C1 = X->child[1]) != 0) {\ - if (RTCHECK(ok_address(M, C1))) {\ - R->child[1] = C1;\ - C1->parent = R;\ - }\ - else\ - CORRUPTION_ERROR_ACTION(M);\ - }\ - }\ - else\ - CORRUPTION_ERROR_ACTION(M);\ - }\ - }\ -} - -/* Relays to large vs small bin operations */ - -#define insert_chunk(M, P, S)\ - if (is_small(S)) insert_small_chunk(M, P, S)\ - else { tchunkptr TP = (tchunkptr)(P); insert_large_chunk(M, TP, S); } - -#define unlink_chunk(M, P, S)\ - if (is_small(S)) unlink_small_chunk(M, P, S)\ - else { tchunkptr TP = (tchunkptr)(P); unlink_large_chunk(M, TP); } - - -/* Relays to internal calls to malloc/free from realloc, memalign etc */ - -#if ONLY_MSPACES -#define internal_malloc(m, b) mspace_malloc(m, b) -#define internal_free(m, mem) mspace_free(m,mem); -#else /* ONLY_MSPACES */ -#if MSPACES -#define internal_malloc(m, b)\ - ((m == gm)? dlmalloc(b) : mspace_malloc(m, b)) -#define internal_free(m, mem)\ - if (m == gm) dlfree(mem); else mspace_free(m,mem); -#else /* MSPACES */ -#define internal_malloc(m, b) dlmalloc(b) -#define internal_free(m, mem) dlfree(mem) -#endif /* MSPACES */ -#endif /* ONLY_MSPACES */ - -/* ----------------------- Direct-mmapping chunks ----------------------- */ - -/* - Directly mmapped chunks are set up with an offset to the start of - the mmapped region stored in the prev_foot field of the chunk. This - allows reconstruction of the required argument to MUNMAP when freed, - and also allows adjustment of the returned chunk to meet alignment - requirements (especially in memalign). -*/ - -/* Malloc using mmap */ -static void* mmap_alloc(mstate m, size_t nb) { - size_t mmsize = mmap_align(nb + SIX_SIZE_T_SIZES + CHUNK_ALIGN_MASK); - if (m->footprint_limit != 0) { - size_t fp = m->footprint + mmsize; - if (fp <= m->footprint || fp > m->footprint_limit) - return 0; - } - if (mmsize > nb) { /* Check for wrap around 0 */ - char* mm = (char*)(CALL_DIRECT_MMAP(mmsize)); - if (mm != CMFAIL) { - size_t offset = align_offset(chunk2mem(mm)); - size_t psize = mmsize - offset - MMAP_FOOT_PAD; - mchunkptr p = (mchunkptr)(mm + offset); - p->prev_foot = offset; - p->head = psize; - mark_inuse_foot(m, p, psize); - chunk_plus_offset(p, psize)->head = FENCEPOST_HEAD; - chunk_plus_offset(p, psize+SIZE_T_SIZE)->head = 0; - - if (m->least_addr == 0 || mm < m->least_addr) - m->least_addr = mm; - if ((m->footprint += mmsize) > m->max_footprint) - m->max_footprint = m->footprint; - assert(is_aligned(chunk2mem(p))); - check_mmapped_chunk(m, p); - return chunk2mem(p); - } - } - return 0; -} - -/* Realloc using mmap */ -static mchunkptr mmap_resize(mstate m, mchunkptr oldp, size_t nb, int flags) { - size_t oldsize = chunksize(oldp); - (void)flags; /* placate people compiling -Wunused */ - if (is_small(nb)) /* Can't shrink mmap regions below small size */ - return 0; - /* Keep old chunk if big enough but not too big */ - if (oldsize >= nb + SIZE_T_SIZE && - (oldsize - nb) <= (mparams.granularity << 1)) - return oldp; - else { - size_t offset = oldp->prev_foot; - size_t oldmmsize = oldsize + offset + MMAP_FOOT_PAD; - size_t newmmsize = mmap_align(nb + SIX_SIZE_T_SIZES + CHUNK_ALIGN_MASK); - char* cp = (char*)CALL_MREMAP((char*)oldp - offset, - oldmmsize, newmmsize, flags); - if (cp != CMFAIL) { - mchunkptr newp = (mchunkptr)(cp + offset); - size_t psize = newmmsize - offset - MMAP_FOOT_PAD; - newp->head = psize; - mark_inuse_foot(m, newp, psize); - chunk_plus_offset(newp, psize)->head = FENCEPOST_HEAD; - chunk_plus_offset(newp, psize+SIZE_T_SIZE)->head = 0; - - if (cp < m->least_addr) - m->least_addr = cp; - if ((m->footprint += newmmsize - oldmmsize) > m->max_footprint) - m->max_footprint = m->footprint; - check_mmapped_chunk(m, newp); - return newp; - } - } - return 0; -} - - -/* -------------------------- mspace management -------------------------- */ - -/* Initialize top chunk and its size */ -static void init_top(mstate m, mchunkptr p, size_t psize) { - /* Ensure alignment */ - size_t offset = align_offset(chunk2mem(p)); - p = (mchunkptr)((char*)p + offset); - psize -= offset; - - m->top = p; - m->topsize = psize; - p->head = psize | PINUSE_BIT; - /* set size of fake trailing chunk holding overhead space only once */ - chunk_plus_offset(p, psize)->head = TOP_FOOT_SIZE; - m->trim_check = mparams.trim_threshold; /* reset on each update */ -} - -/* Initialize bins for a new mstate that is otherwise zeroed out */ -static void init_bins(mstate m) { - /* Establish circular links for smallbins */ - bindex_t i; - for (i = 0; i < NSMALLBINS; ++i) { - sbinptr bin = smallbin_at(m,i); - bin->fd = bin->bk = bin; - } -} - -#if PROCEED_ON_ERROR - -/* default corruption action */ -static void reset_on_error(mstate m) { - int i; - ++malloc_corruption_error_count; - /* Reinitialize fields to forget about all memory */ - m->smallmap = m->treemap = 0; - m->dvsize = m->topsize = 0; - m->seg.base = 0; - m->seg.size = 0; - m->seg.next = 0; - m->top = m->dv = 0; - for (i = 0; i < NTREEBINS; ++i) - *treebin_at(m, i) = 0; - init_bins(m); -} -#endif /* PROCEED_ON_ERROR */ - -/* Allocate chunk and prepend remainder with chunk in successor base. */ -static void* prepend_alloc(mstate m, char* newbase, char* oldbase, - size_t nb) { - mchunkptr p = align_as_chunk(newbase); - mchunkptr oldfirst = align_as_chunk(oldbase); - size_t psize = (char*)oldfirst - (char*)p; - mchunkptr q = chunk_plus_offset(p, nb); - size_t qsize = psize - nb; - set_size_and_pinuse_of_inuse_chunk(m, p, nb); - - assert((char*)oldfirst > (char*)q); - assert(pinuse(oldfirst)); - assert(qsize >= MIN_CHUNK_SIZE); - - /* consolidate remainder with first chunk of old base */ - if (oldfirst == m->top) { - size_t tsize = m->topsize += qsize; - m->top = q; - q->head = tsize | PINUSE_BIT; - check_top_chunk(m, q); - } - else if (oldfirst == m->dv) { - size_t dsize = m->dvsize += qsize; - m->dv = q; - set_size_and_pinuse_of_free_chunk(q, dsize); - } - else { - if (!is_inuse(oldfirst)) { - size_t nsize = chunksize(oldfirst); - unlink_chunk(m, oldfirst, nsize); - oldfirst = chunk_plus_offset(oldfirst, nsize); - qsize += nsize; - } - set_free_with_pinuse(q, qsize, oldfirst); - insert_chunk(m, q, qsize); - check_free_chunk(m, q); - } - - check_malloced_chunk(m, chunk2mem(p), nb); - return chunk2mem(p); -} - -/* Add a segment to hold a new noncontiguous region */ -static void add_segment(mstate m, char* tbase, size_t tsize, flag_t mmapped) { - /* Determine locations and sizes of segment, fenceposts, old top */ - char* old_top = (char*)m->top; - msegmentptr oldsp = segment_holding(m, old_top); - char* old_end = oldsp->base + oldsp->size; - size_t ssize = pad_request(sizeof(struct malloc_segment)); - char* rawsp = old_end - (ssize + FOUR_SIZE_T_SIZES + CHUNK_ALIGN_MASK); - size_t offset = align_offset(chunk2mem(rawsp)); - char* asp = rawsp + offset; - char* csp = (asp < (old_top + MIN_CHUNK_SIZE))? old_top : asp; - mchunkptr sp = (mchunkptr)csp; - msegmentptr ss = (msegmentptr)(chunk2mem(sp)); - mchunkptr tnext = chunk_plus_offset(sp, ssize); - mchunkptr p = tnext; - int nfences = 0; - - /* reset top to new space */ - init_top(m, (mchunkptr)tbase, tsize - TOP_FOOT_SIZE); - - /* Set up segment record */ - assert(is_aligned(ss)); - set_size_and_pinuse_of_inuse_chunk(m, sp, ssize); - *ss = m->seg; /* Push current record */ - m->seg.base = tbase; - m->seg.size = tsize; - m->seg.sflags = mmapped; - m->seg.next = ss; - - /* Insert trailing fenceposts */ - for (;;) { - mchunkptr nextp = chunk_plus_offset(p, SIZE_T_SIZE); - p->head = FENCEPOST_HEAD; - ++nfences; - if ((char*)(&(nextp->head)) < old_end) - p = nextp; - else - break; - } - assert(nfences >= 2); - - /* Insert the rest of old top into a bin as an ordinary free chunk */ - if (csp != old_top) { - mchunkptr q = (mchunkptr)old_top; - size_t psize = csp - old_top; - mchunkptr tn = chunk_plus_offset(q, psize); - set_free_with_pinuse(q, psize, tn); - insert_chunk(m, q, psize); - } - - check_top_chunk(m, m->top); -} - -/* -------------------------- System allocation -------------------------- */ - -/* Get memory from system using MORECORE or MMAP */ -static void* sys_alloc(mstate m, size_t nb) { - char* tbase = CMFAIL; - size_t tsize = 0; - flag_t mmap_flag = 0; - size_t asize; /* allocation size */ - - ensure_initialization(); - - /* Directly map large chunks, but only if already initialized */ - if (use_mmap(m) && nb >= mparams.mmap_threshold && m->topsize != 0) { - void* mem = mmap_alloc(m, nb); - if (mem != 0) - return mem; - } - - asize = granularity_align(nb + SYS_ALLOC_PADDING); - if (asize <= nb) - return 0; /* wraparound */ - if (m->footprint_limit != 0) { - size_t fp = m->footprint + asize; - if (fp <= m->footprint || fp > m->footprint_limit) - return 0; - } - - /* - Try getting memory in any of three ways (in most-preferred to - least-preferred order): - 1. A call to MORECORE that can normally contiguously extend memory. - (disabled if not MORECORE_CONTIGUOUS or not HAVE_MORECORE or - or main space is mmapped or a previous contiguous call failed) - 2. A call to MMAP new space (disabled if not HAVE_MMAP). - Note that under the default settings, if MORECORE is unable to - fulfill a request, and HAVE_MMAP is true, then mmap is - used as a noncontiguous system allocator. This is a useful backup - strategy for systems with holes in address spaces -- in this case - sbrk cannot contiguously expand the heap, but mmap may be able to - find space. - 3. A call to MORECORE that cannot usually contiguously extend memory. - (disabled if not HAVE_MORECORE) - - In all cases, we need to request enough bytes from system to ensure - we can malloc nb bytes upon success, so pad with enough space for - top_foot, plus alignment-pad to make sure we don't lose bytes if - not on boundary, and round this up to a granularity unit. - */ - - if (MORECORE_CONTIGUOUS && !use_noncontiguous(m)) { - char* br = CMFAIL; - size_t ssize = asize; /* sbrk call size */ - msegmentptr ss = (m->top == 0)? 0 : segment_holding(m, (char*)m->top); - ACQUIRE_MALLOC_GLOBAL_LOCK(); - - if (ss == 0) { /* First time through or recovery */ - char* base = (char*)CALL_MORECORE(0); - if (base != CMFAIL) { - size_t fp; - /* Adjust to end on a page boundary */ - if (!is_page_aligned(base)) - ssize += (page_align((size_t)base) - (size_t)base); - fp = m->footprint + ssize; /* recheck limits */ - if (ssize > nb && ssize < HALF_MAX_SIZE_T && - (m->footprint_limit == 0 || - (fp > m->footprint && fp <= m->footprint_limit)) && - (br = (char*)(CALL_MORECORE(ssize))) == base) { - tbase = base; - tsize = ssize; - } - } - } - else { - /* Subtract out existing available top space from MORECORE request. */ - ssize = granularity_align(nb - m->topsize + SYS_ALLOC_PADDING); - /* Use mem here only if it did continuously extend old space */ - if (ssize < HALF_MAX_SIZE_T && - (br = (char*)(CALL_MORECORE(ssize))) == ss->base+ss->size) { - tbase = br; - tsize = ssize; - } - } - - if (tbase == CMFAIL) { /* Cope with partial failure */ - if (br != CMFAIL) { /* Try to use/extend the space we did get */ - if (ssize < HALF_MAX_SIZE_T && - ssize < nb + SYS_ALLOC_PADDING) { - size_t esize = granularity_align(nb + SYS_ALLOC_PADDING - ssize); - if (esize < HALF_MAX_SIZE_T) { - char* end = (char*)CALL_MORECORE(esize); - if (end != CMFAIL) - ssize += esize; - else { /* Can't use; try to release */ - (void) CALL_MORECORE(-ssize); - br = CMFAIL; - } - } - } - } - if (br != CMFAIL) { /* Use the space we did get */ - tbase = br; - tsize = ssize; - } - else - disable_contiguous(m); /* Don't try contiguous path in the future */ - } - - RELEASE_MALLOC_GLOBAL_LOCK(); - } - - if (HAVE_MMAP && tbase == CMFAIL) { /* Try MMAP */ - char* mp = (char*)(CALL_MMAP(asize)); - if (mp != CMFAIL) { - tbase = mp; - tsize = asize; - mmap_flag = USE_MMAP_BIT; - } - } - - if (HAVE_MORECORE && tbase == CMFAIL) { /* Try noncontiguous MORECORE */ - if (asize < HALF_MAX_SIZE_T) { - char* br = CMFAIL; - char* end = CMFAIL; - ACQUIRE_MALLOC_GLOBAL_LOCK(); - br = (char*)(CALL_MORECORE(asize)); - end = (char*)(CALL_MORECORE(0)); - RELEASE_MALLOC_GLOBAL_LOCK(); - if (br != CMFAIL && end != CMFAIL && br < end) { - size_t ssize = end - br; - if (ssize > nb + TOP_FOOT_SIZE) { - tbase = br; - tsize = ssize; - } - } - } - } - - if (tbase != CMFAIL) { - - if ((m->footprint += tsize) > m->max_footprint) - m->max_footprint = m->footprint; - - if (!is_initialized(m)) { /* first-time initialization */ - if (m->least_addr == 0 || tbase < m->least_addr) - m->least_addr = tbase; - m->seg.base = tbase; - m->seg.size = tsize; - m->seg.sflags = mmap_flag; - m->magic = mparams.magic; - m->release_checks = MAX_RELEASE_CHECK_RATE; - init_bins(m); -#if !ONLY_MSPACES - if (is_global(m)) - init_top(m, (mchunkptr)tbase, tsize - TOP_FOOT_SIZE); - else -#endif - { - /* Offset top by embedded malloc_state */ - mchunkptr mn = next_chunk(mem2chunk(m)); - init_top(m, mn, (size_t)((tbase + tsize) - (char*)mn) -TOP_FOOT_SIZE); - } - } - - else { - /* Try to merge with an existing segment */ - msegmentptr sp = &m->seg; - /* Only consider most recent segment if traversal suppressed */ - while (sp != 0 && tbase != sp->base + sp->size) - sp = (NO_SEGMENT_TRAVERSAL) ? 0 : sp->next; - if (sp != 0 && - !is_extern_segment(sp) && - (sp->sflags & USE_MMAP_BIT) == mmap_flag && - segment_holds(sp, m->top)) { /* append */ - sp->size += tsize; - init_top(m, m->top, m->topsize + tsize); - } - else { - if (tbase < m->least_addr) - m->least_addr = tbase; - sp = &m->seg; - while (sp != 0 && sp->base != tbase + tsize) - sp = (NO_SEGMENT_TRAVERSAL) ? 0 : sp->next; - if (sp != 0 && - !is_extern_segment(sp) && - (sp->sflags & USE_MMAP_BIT) == mmap_flag) { - char* oldbase = sp->base; - sp->base = tbase; - sp->size += tsize; - return prepend_alloc(m, tbase, oldbase, nb); - } - else - add_segment(m, tbase, tsize, mmap_flag); - } - } - - if (nb < m->topsize) { /* Allocate from new or extended top space */ - size_t rsize = m->topsize -= nb; - mchunkptr p = m->top; - mchunkptr r = m->top = chunk_plus_offset(p, nb); - r->head = rsize | PINUSE_BIT; - set_size_and_pinuse_of_inuse_chunk(m, p, nb); - check_top_chunk(m, m->top); - check_malloced_chunk(m, chunk2mem(p), nb); - return chunk2mem(p); - } - } - - MALLOC_FAILURE_ACTION; - return 0; -} - -/* ----------------------- system deallocation -------------------------- */ - -/* Unmap and unlink any mmapped segments that don't contain used chunks */ -static size_t release_unused_segments(mstate m) { - size_t released = 0; - int nsegs = 0; - msegmentptr pred = &m->seg; - msegmentptr sp = pred->next; - while (sp != 0) { - char* base = sp->base; - size_t size = sp->size; - msegmentptr next = sp->next; - ++nsegs; - if (is_mmapped_segment(sp) && !is_extern_segment(sp)) { - mchunkptr p = align_as_chunk(base); - size_t psize = chunksize(p); - /* Can unmap if first chunk holds entire segment and not pinned */ - if (!is_inuse(p) && (char*)p + psize >= base + size - TOP_FOOT_SIZE) { - tchunkptr tp = (tchunkptr)p; - assert(segment_holds(sp, (char*)sp)); - if (p == m->dv) { - m->dv = 0; - m->dvsize = 0; - } - else { - unlink_large_chunk(m, tp); - } - if (CALL_MUNMAP(base, size) == 0) { - released += size; - m->footprint -= size; - /* unlink obsoleted record */ - sp = pred; - sp->next = next; - } - else { /* back out if cannot unmap */ - insert_large_chunk(m, tp, psize); - } - } - } - if (NO_SEGMENT_TRAVERSAL) /* scan only first segment */ - break; - pred = sp; - sp = next; - } - /* Reset check counter */ - m->release_checks = (((size_t) nsegs > (size_t) MAX_RELEASE_CHECK_RATE)? - (size_t) nsegs : (size_t) MAX_RELEASE_CHECK_RATE); - return released; -} - -static int sys_trim(mstate m, size_t pad) { - size_t released = 0; - ensure_initialization(); - if (pad < MAX_REQUEST && is_initialized(m)) { - pad += TOP_FOOT_SIZE; /* ensure enough room for segment overhead */ - - if (m->topsize > pad) { - /* Shrink top space in granularity-size units, keeping at least one */ - size_t unit = mparams.granularity; - size_t extra = ((m->topsize - pad + (unit - SIZE_T_ONE)) / unit - - SIZE_T_ONE) * unit; - msegmentptr sp = segment_holding(m, (char*)m->top); - - if (!is_extern_segment(sp)) { - if (is_mmapped_segment(sp)) { - if (HAVE_MMAP && - sp->size >= extra && - !has_segment_link(m, sp)) { /* can't shrink if pinned */ - size_t newsize = sp->size - extra; - (void)newsize; /* placate people compiling -Wunused-variable */ - /* Prefer mremap, fall back to munmap */ - if ((CALL_MREMAP(sp->base, sp->size, newsize, 0) != MFAIL) || - (CALL_MUNMAP(sp->base + newsize, extra) == 0)) { - released = extra; - } - } - } - else if (HAVE_MORECORE) { - if (extra >= HALF_MAX_SIZE_T) /* Avoid wrapping negative */ - extra = (HALF_MAX_SIZE_T) + SIZE_T_ONE - unit; - ACQUIRE_MALLOC_GLOBAL_LOCK(); - { - /* Make sure end of memory is where we last set it. */ - char* old_br = (char*)(CALL_MORECORE(0)); - if (old_br == sp->base + sp->size) { - char* rel_br = (char*)(CALL_MORECORE(-extra)); - char* new_br = (char*)(CALL_MORECORE(0)); - if (rel_br != CMFAIL && new_br < old_br) - released = old_br - new_br; - } - } - RELEASE_MALLOC_GLOBAL_LOCK(); - } - } - - if (released != 0) { - sp->size -= released; - m->footprint -= released; - init_top(m, m->top, m->topsize - released); - check_top_chunk(m, m->top); - } - } - - /* Unmap any unused mmapped segments */ - if (HAVE_MMAP) - released += release_unused_segments(m); - - /* On failure, disable autotrim to avoid repeated failed future calls */ - if (released == 0 && m->topsize > m->trim_check) - m->trim_check = MAX_SIZE_T; - } - - return (released != 0)? 1 : 0; -} - -/* Consolidate and bin a chunk. Differs from exported versions - of free mainly in that the chunk need not be marked as inuse. -*/ -static void dispose_chunk(mstate m, mchunkptr p, size_t psize) { - mchunkptr next = chunk_plus_offset(p, psize); - if (!pinuse(p)) { - mchunkptr prev; - size_t prevsize = p->prev_foot; - if (is_mmapped(p)) { - psize += prevsize + MMAP_FOOT_PAD; - if (CALL_MUNMAP((char*)p - prevsize, psize) == 0) - m->footprint -= psize; - return; - } - prev = chunk_minus_offset(p, prevsize); - psize += prevsize; - p = prev; - if (RTCHECK(ok_address(m, prev))) { /* consolidate backward */ - if (p != m->dv) { - unlink_chunk(m, p, prevsize); - } - else if ((next->head & INUSE_BITS) == INUSE_BITS) { - m->dvsize = psize; - set_free_with_pinuse(p, psize, next); - return; - } - } - else { - CORRUPTION_ERROR_ACTION(m); - return; - } - } - if (RTCHECK(ok_address(m, next))) { - if (!cinuse(next)) { /* consolidate forward */ - if (next == m->top) { - size_t tsize = m->topsize += psize; - m->top = p; - p->head = tsize | PINUSE_BIT; - if (p == m->dv) { - m->dv = 0; - m->dvsize = 0; - } - return; - } - else if (next == m->dv) { - size_t dsize = m->dvsize += psize; - m->dv = p; - set_size_and_pinuse_of_free_chunk(p, dsize); - return; - } - else { - size_t nsize = chunksize(next); - psize += nsize; - unlink_chunk(m, next, nsize); - set_size_and_pinuse_of_free_chunk(p, psize); - if (p == m->dv) { - m->dvsize = psize; - return; - } - } - } - else { - set_free_with_pinuse(p, psize, next); - } - insert_chunk(m, p, psize); - } - else { - CORRUPTION_ERROR_ACTION(m); - } -} - -/* ---------------------------- malloc --------------------------- */ - -/* allocate a large request from the best fitting chunk in a treebin */ -static void* tmalloc_large(mstate m, size_t nb) { - tchunkptr v = 0; - size_t rsize = -nb; /* Unsigned negation */ - tchunkptr t; - bindex_t idx; - compute_tree_index(nb, idx); - if ((t = *treebin_at(m, idx)) != 0) { - /* Traverse tree for this bin looking for node with size == nb */ - size_t sizebits = nb << leftshift_for_tree_index(idx); - tchunkptr rst = 0; /* The deepest untaken right subtree */ - for (;;) { - tchunkptr rt; - size_t trem = chunksize(t) - nb; - if (trem < rsize) { - v = t; - if ((rsize = trem) == 0) - break; - } - rt = t->child[1]; - t = t->child[(sizebits >> (SIZE_T_BITSIZE-SIZE_T_ONE)) & 1]; - if (rt != 0 && rt != t) - rst = rt; - if (t == 0) { - t = rst; /* set t to least subtree holding sizes > nb */ - break; - } - sizebits <<= 1; - } - } - if (t == 0 && v == 0) { /* set t to root of next non-empty treebin */ - binmap_t leftbits = left_bits(idx2bit(idx)) & m->treemap; - if (leftbits != 0) { - bindex_t i; - binmap_t leastbit = least_bit(leftbits); - compute_bit2idx(leastbit, i); - t = *treebin_at(m, i); - } - } - - while (t != 0) { /* find smallest of tree or subtree */ - size_t trem = chunksize(t) - nb; - if (trem < rsize) { - rsize = trem; - v = t; - } - t = leftmost_child(t); - } - - /* If dv is a better fit, return 0 so malloc will use it */ - if (v != 0 && rsize < (size_t)(m->dvsize - nb)) { - if (RTCHECK(ok_address(m, v))) { /* split */ - mchunkptr r = chunk_plus_offset(v, nb); - assert(chunksize(v) == rsize + nb); - if (RTCHECK(ok_next(v, r))) { - unlink_large_chunk(m, v); - if (rsize < MIN_CHUNK_SIZE) - set_inuse_and_pinuse(m, v, (rsize + nb)); - else { - set_size_and_pinuse_of_inuse_chunk(m, v, nb); - set_size_and_pinuse_of_free_chunk(r, rsize); - insert_chunk(m, r, rsize); - } - return chunk2mem(v); - } - } - CORRUPTION_ERROR_ACTION(m); - } - return 0; -} - -/* allocate a small request from the best fitting chunk in a treebin */ -static void* tmalloc_small(mstate m, size_t nb) { - tchunkptr t, v; - size_t rsize; - bindex_t i; - binmap_t leastbit = least_bit(m->treemap); - compute_bit2idx(leastbit, i); - v = t = *treebin_at(m, i); - rsize = chunksize(t) - nb; - - while ((t = leftmost_child(t)) != 0) { - size_t trem = chunksize(t) - nb; - if (trem < rsize) { - rsize = trem; - v = t; - } - } - - if (RTCHECK(ok_address(m, v))) { - mchunkptr r = chunk_plus_offset(v, nb); - assert(chunksize(v) == rsize + nb); - if (RTCHECK(ok_next(v, r))) { - unlink_large_chunk(m, v); - if (rsize < MIN_CHUNK_SIZE) - set_inuse_and_pinuse(m, v, (rsize + nb)); - else { - set_size_and_pinuse_of_inuse_chunk(m, v, nb); - set_size_and_pinuse_of_free_chunk(r, rsize); - replace_dv(m, r, rsize); - } - return chunk2mem(v); - } - } - - CORRUPTION_ERROR_ACTION(m); - return 0; -} - -#if !ONLY_MSPACES - -void* dlmalloc(size_t bytes) { - /* - Basic algorithm: - If a small request (< 256 bytes minus per-chunk overhead): - 1. If one exists, use a remainderless chunk in associated smallbin. - (Remainderless means that there are too few excess bytes to - represent as a chunk.) - 2. If it is big enough, use the dv chunk, which is normally the - chunk adjacent to the one used for the most recent small request. - 3. If one exists, split the smallest available chunk in a bin, - saving remainder in dv. - 4. If it is big enough, use the top chunk. - 5. If available, get memory from system and use it - Otherwise, for a large request: - 1. Find the smallest available binned chunk that fits, and use it - if it is better fitting than dv chunk, splitting if necessary. - 2. If better fitting than any binned chunk, use the dv chunk. - 3. If it is big enough, use the top chunk. - 4. If request size >= mmap threshold, try to directly mmap this chunk. - 5. If available, get memory from system and use it - - The ugly goto's here ensure that postaction occurs along all paths. - */ - -#if USE_LOCKS - ensure_initialization(); /* initialize in sys_alloc if not using locks */ -#endif - - if (!PREACTION(gm)) { - void* mem; - size_t nb; - if (bytes <= MAX_SMALL_REQUEST) { - bindex_t idx; - binmap_t smallbits; - nb = (bytes < MIN_REQUEST)? MIN_CHUNK_SIZE : pad_request(bytes); - idx = small_index(nb); - smallbits = gm->smallmap >> idx; - - if ((smallbits & 0x3U) != 0) { /* Remainderless fit to a smallbin. */ - mchunkptr b, p; - idx += ~smallbits & 1; /* Uses next bin if idx empty */ - b = smallbin_at(gm, idx); - p = b->fd; - assert(chunksize(p) == small_index2size(idx)); - unlink_first_small_chunk(gm, b, p, idx); - set_inuse_and_pinuse(gm, p, small_index2size(idx)); - mem = chunk2mem(p); - check_malloced_chunk(gm, mem, nb); - goto postaction; - } - - else if (nb > gm->dvsize) { - if (smallbits != 0) { /* Use chunk in next nonempty smallbin */ - mchunkptr b, p, r; - size_t rsize; - bindex_t i; - binmap_t leftbits = (smallbits << idx) & left_bits(idx2bit(idx)); - binmap_t leastbit = least_bit(leftbits); - compute_bit2idx(leastbit, i); - b = smallbin_at(gm, i); - p = b->fd; - assert(chunksize(p) == small_index2size(i)); - unlink_first_small_chunk(gm, b, p, i); - rsize = small_index2size(i) - nb; - /* Fit here cannot be remainderless if 4byte sizes */ - if (SIZE_T_SIZE != 4 && rsize < MIN_CHUNK_SIZE) - set_inuse_and_pinuse(gm, p, small_index2size(i)); - else { - set_size_and_pinuse_of_inuse_chunk(gm, p, nb); - r = chunk_plus_offset(p, nb); - set_size_and_pinuse_of_free_chunk(r, rsize); - replace_dv(gm, r, rsize); - } - mem = chunk2mem(p); - check_malloced_chunk(gm, mem, nb); - goto postaction; - } - - else if (gm->treemap != 0 && (mem = tmalloc_small(gm, nb)) != 0) { - check_malloced_chunk(gm, mem, nb); - goto postaction; - } - } - } - else if (bytes >= MAX_REQUEST) - nb = MAX_SIZE_T; /* Too big to allocate. Force failure (in sys alloc) */ - else { - nb = pad_request(bytes); - if (gm->treemap != 0 && (mem = tmalloc_large(gm, nb)) != 0) { - check_malloced_chunk(gm, mem, nb); - goto postaction; - } - } - - if (nb <= gm->dvsize) { - size_t rsize = gm->dvsize - nb; - mchunkptr p = gm->dv; - if (rsize >= MIN_CHUNK_SIZE) { /* split dv */ - mchunkptr r = gm->dv = chunk_plus_offset(p, nb); - gm->dvsize = rsize; - set_size_and_pinuse_of_free_chunk(r, rsize); - set_size_and_pinuse_of_inuse_chunk(gm, p, nb); - } - else { /* exhaust dv */ - size_t dvs = gm->dvsize; - gm->dvsize = 0; - gm->dv = 0; - set_inuse_and_pinuse(gm, p, dvs); - } - mem = chunk2mem(p); - check_malloced_chunk(gm, mem, nb); - goto postaction; - } - - else if (nb < gm->topsize) { /* Split top */ - size_t rsize = gm->topsize -= nb; - mchunkptr p = gm->top; - mchunkptr r = gm->top = chunk_plus_offset(p, nb); - r->head = rsize | PINUSE_BIT; - set_size_and_pinuse_of_inuse_chunk(gm, p, nb); - mem = chunk2mem(p); - check_top_chunk(gm, gm->top); - check_malloced_chunk(gm, mem, nb); - goto postaction; - } - - mem = sys_alloc(gm, nb); - - postaction: - POSTACTION(gm); - return mem; - } - - return 0; -} - -/* ---------------------------- free --------------------------- */ - -void dlfree(void* mem) { - /* - Consolidate freed chunks with preceeding or succeeding bordering - free chunks, if they exist, and then place in a bin. Intermixed - with special cases for top, dv, mmapped chunks, and usage errors. - */ - - if (mem != 0) { - mchunkptr p = mem2chunk(mem); -#if FOOTERS - mstate fm = get_mstate_for(p); - if (!ok_magic(fm)) { - USAGE_ERROR_ACTION(fm, p); - return; - } -#else /* FOOTERS */ -#define fm gm -#endif /* FOOTERS */ - if (!PREACTION(fm)) { - check_inuse_chunk(fm, p); - if (RTCHECK(ok_address(fm, p) && ok_inuse(p))) { - size_t psize = chunksize(p); - mchunkptr next = chunk_plus_offset(p, psize); - if (!pinuse(p)) { - size_t prevsize = p->prev_foot; - if (is_mmapped(p)) { - psize += prevsize + MMAP_FOOT_PAD; - if (CALL_MUNMAP((char*)p - prevsize, psize) == 0) - fm->footprint -= psize; - goto postaction; - } - else { - mchunkptr prev = chunk_minus_offset(p, prevsize); - psize += prevsize; - p = prev; - if (RTCHECK(ok_address(fm, prev))) { /* consolidate backward */ - if (p != fm->dv) { - unlink_chunk(fm, p, prevsize); - } - else if ((next->head & INUSE_BITS) == INUSE_BITS) { - fm->dvsize = psize; - set_free_with_pinuse(p, psize, next); - goto postaction; - } - } - else - goto erroraction; - } - } - - if (RTCHECK(ok_next(p, next) && ok_pinuse(next))) { - if (!cinuse(next)) { /* consolidate forward */ - if (next == fm->top) { - size_t tsize = fm->topsize += psize; - fm->top = p; - p->head = tsize | PINUSE_BIT; - if (p == fm->dv) { - fm->dv = 0; - fm->dvsize = 0; - } - if (should_trim(fm, tsize)) - sys_trim(fm, 0); - goto postaction; - } - else if (next == fm->dv) { - size_t dsize = fm->dvsize += psize; - fm->dv = p; - set_size_and_pinuse_of_free_chunk(p, dsize); - goto postaction; - } - else { - size_t nsize = chunksize(next); - psize += nsize; - unlink_chunk(fm, next, nsize); - set_size_and_pinuse_of_free_chunk(p, psize); - if (p == fm->dv) { - fm->dvsize = psize; - goto postaction; - } - } - } - else - set_free_with_pinuse(p, psize, next); - - if (is_small(psize)) { - insert_small_chunk(fm, p, psize); - check_free_chunk(fm, p); - } - else { - tchunkptr tp = (tchunkptr)p; - insert_large_chunk(fm, tp, psize); - check_free_chunk(fm, p); - if (--fm->release_checks == 0) - release_unused_segments(fm); - } - goto postaction; - } - } - erroraction: - USAGE_ERROR_ACTION(fm, p); - postaction: - POSTACTION(fm); - } - } -#if !FOOTERS -#undef fm -#endif /* FOOTERS */ -} - -void* dlcalloc(size_t n_elements, size_t elem_size) { - void* mem; - size_t req = 0; - if (n_elements != 0) { - req = n_elements * elem_size; - if (((n_elements | elem_size) & ~(size_t)0xffff) && - (req / n_elements != elem_size)) - req = MAX_SIZE_T; /* force downstream failure on overflow */ - } - mem = dlmalloc(req); - if (mem != 0 && calloc_must_clear(mem2chunk(mem))) - memset(mem, 0, req); - return mem; -} - -#endif /* !ONLY_MSPACES */ - -/* ------------ Internal support for realloc, memalign, etc -------------- */ - -/* Try to realloc; only in-place unless can_move true */ -static mchunkptr try_realloc_chunk(mstate m, mchunkptr p, size_t nb, - int can_move) { - mchunkptr newp = 0; - size_t oldsize = chunksize(p); - mchunkptr next = chunk_plus_offset(p, oldsize); - if (RTCHECK(ok_address(m, p) && ok_inuse(p) && - ok_next(p, next) && ok_pinuse(next))) { - if (is_mmapped(p)) { - newp = mmap_resize(m, p, nb, can_move); - } - else if (oldsize >= nb) { /* already big enough */ - size_t rsize = oldsize - nb; - if (rsize >= MIN_CHUNK_SIZE) { /* split off remainder */ - mchunkptr r = chunk_plus_offset(p, nb); - set_inuse(m, p, nb); - set_inuse(m, r, rsize); - dispose_chunk(m, r, rsize); - } - newp = p; - } - else if (next == m->top) { /* extend into top */ - if (oldsize + m->topsize > nb) { - size_t newsize = oldsize + m->topsize; - size_t newtopsize = newsize - nb; - mchunkptr newtop = chunk_plus_offset(p, nb); - set_inuse(m, p, nb); - newtop->head = newtopsize |PINUSE_BIT; - m->top = newtop; - m->topsize = newtopsize; - newp = p; - } - } - else if (next == m->dv) { /* extend into dv */ - size_t dvs = m->dvsize; - if (oldsize + dvs >= nb) { - size_t dsize = oldsize + dvs - nb; - if (dsize >= MIN_CHUNK_SIZE) { - mchunkptr r = chunk_plus_offset(p, nb); - mchunkptr n = chunk_plus_offset(r, dsize); - set_inuse(m, p, nb); - set_size_and_pinuse_of_free_chunk(r, dsize); - clear_pinuse(n); - m->dvsize = dsize; - m->dv = r; - } - else { /* exhaust dv */ - size_t newsize = oldsize + dvs; - set_inuse(m, p, newsize); - m->dvsize = 0; - m->dv = 0; - } - newp = p; - } - } - else if (!cinuse(next)) { /* extend into next free chunk */ - size_t nextsize = chunksize(next); - if (oldsize + nextsize >= nb) { - size_t rsize = oldsize + nextsize - nb; - unlink_chunk(m, next, nextsize); - if (rsize < MIN_CHUNK_SIZE) { - size_t newsize = oldsize + nextsize; - set_inuse(m, p, newsize); - } - else { - mchunkptr r = chunk_plus_offset(p, nb); - set_inuse(m, p, nb); - set_inuse(m, r, rsize); - dispose_chunk(m, r, rsize); - } - newp = p; - } - } - } - else { - USAGE_ERROR_ACTION(m, chunk2mem(p)); - } - return newp; -} - -static void* internal_memalign(mstate m, size_t alignment, size_t bytes) { - void* mem = 0; - if (alignment < MIN_CHUNK_SIZE) /* must be at least a minimum chunk size */ - alignment = MIN_CHUNK_SIZE; - if ((alignment & (alignment-SIZE_T_ONE)) != 0) {/* Ensure a power of 2 */ - size_t a = MALLOC_ALIGNMENT << 1; - while (a < alignment) a <<= 1; - alignment = a; - } - if (bytes >= MAX_REQUEST - alignment) { - if (m != 0) { /* Test isn't needed but avoids compiler warning */ - MALLOC_FAILURE_ACTION; - } - } - else { - size_t nb = request2size(bytes); - size_t req = nb + alignment + MIN_CHUNK_SIZE - CHUNK_OVERHEAD; - mem = internal_malloc(m, req); - if (mem != 0) { - mchunkptr p = mem2chunk(mem); - if (PREACTION(m)) - return 0; - if ((((size_t)(mem)) & (alignment - 1)) != 0) { /* misaligned */ - /* - Find an aligned spot inside chunk. Since we need to give - back leading space in a chunk of at least MIN_CHUNK_SIZE, if - the first calculation places us at a spot with less than - MIN_CHUNK_SIZE leader, we can move to the next aligned spot. - We've allocated enough total room so that this is always - possible. - */ - char* br = (char*)mem2chunk((size_t)(((size_t)((char*)mem + alignment - - SIZE_T_ONE)) & - -alignment)); - char* pos = ((size_t)(br - (char*)(p)) >= MIN_CHUNK_SIZE)? - br : br+alignment; - mchunkptr newp = (mchunkptr)pos; - size_t leadsize = pos - (char*)(p); - size_t newsize = chunksize(p) - leadsize; - - if (is_mmapped(p)) { /* For mmapped chunks, just adjust offset */ - newp->prev_foot = p->prev_foot + leadsize; - newp->head = newsize; - } - else { /* Otherwise, give back leader, use the rest */ - set_inuse(m, newp, newsize); - set_inuse(m, p, leadsize); - dispose_chunk(m, p, leadsize); - } - p = newp; - } - - /* Give back spare room at the end */ - if (!is_mmapped(p)) { - size_t size = chunksize(p); - if (size > nb + MIN_CHUNK_SIZE) { - size_t remainder_size = size - nb; - mchunkptr remainder = chunk_plus_offset(p, nb); - set_inuse(m, p, nb); - set_inuse(m, remainder, remainder_size); - dispose_chunk(m, remainder, remainder_size); - } - } - - mem = chunk2mem(p); - assert (chunksize(p) >= nb); - assert(((size_t)mem & (alignment - 1)) == 0); - check_inuse_chunk(m, p); - POSTACTION(m); - } - } - return mem; -} - -/* - Common support for independent_X routines, handling - all of the combinations that can result. - The opts arg has: - bit 0 set if all elements are same size (using sizes[0]) - bit 1 set if elements should be zeroed -*/ -static void** ialloc(mstate m, - size_t n_elements, - size_t* sizes, - int opts, - void* chunks[]) { - - size_t element_size; /* chunksize of each element, if all same */ - size_t contents_size; /* total size of elements */ - size_t array_size; /* request size of pointer array */ - void* mem; /* malloced aggregate space */ - mchunkptr p; /* corresponding chunk */ - size_t remainder_size; /* remaining bytes while splitting */ - void** marray; /* either "chunks" or malloced ptr array */ - mchunkptr array_chunk; /* chunk for malloced ptr array */ - flag_t was_enabled; /* to disable mmap */ - size_t size; - size_t i; - - ensure_initialization(); - /* compute array length, if needed */ - if (chunks != 0) { - if (n_elements == 0) - return chunks; /* nothing to do */ - marray = chunks; - array_size = 0; - } - else { - /* if empty req, must still return chunk representing empty array */ - if (n_elements == 0) - return (void**)internal_malloc(m, 0); - marray = 0; - array_size = request2size(n_elements * (sizeof(void*))); - } - - /* compute total element size */ - if (opts & 0x1) { /* all-same-size */ - element_size = request2size(*sizes); - contents_size = n_elements * element_size; - } - else { /* add up all the sizes */ - element_size = 0; - contents_size = 0; - for (i = 0; i != n_elements; ++i) - contents_size += request2size(sizes[i]); - } - - size = contents_size + array_size; - - /* - Allocate the aggregate chunk. First disable direct-mmapping so - malloc won't use it, since we would not be able to later - free/realloc space internal to a segregated mmap region. - */ - was_enabled = use_mmap(m); - disable_mmap(m); - mem = internal_malloc(m, size - CHUNK_OVERHEAD); - if (was_enabled) - enable_mmap(m); - if (mem == 0) - return 0; - - if (PREACTION(m)) return 0; - p = mem2chunk(mem); - remainder_size = chunksize(p); - - assert(!is_mmapped(p)); - - if (opts & 0x2) { /* optionally clear the elements */ - memset((size_t*)mem, 0, remainder_size - SIZE_T_SIZE - array_size); - } - - /* If not provided, allocate the pointer array as final part of chunk */ - if (marray == 0) { - size_t array_chunk_size; - array_chunk = chunk_plus_offset(p, contents_size); - array_chunk_size = remainder_size - contents_size; - marray = (void**) (chunk2mem(array_chunk)); - set_size_and_pinuse_of_inuse_chunk(m, array_chunk, array_chunk_size); - remainder_size = contents_size; - } - - /* split out elements */ - for (i = 0; ; ++i) { - marray[i] = chunk2mem(p); - if (i != n_elements-1) { - if (element_size != 0) - size = element_size; - else - size = request2size(sizes[i]); - remainder_size -= size; - set_size_and_pinuse_of_inuse_chunk(m, p, size); - p = chunk_plus_offset(p, size); - } - else { /* the final element absorbs any overallocation slop */ - set_size_and_pinuse_of_inuse_chunk(m, p, remainder_size); - break; - } - } - -#if DEBUG - if (marray != chunks) { - /* final element must have exactly exhausted chunk */ - if (element_size != 0) { - assert(remainder_size == element_size); - } - else { - assert(remainder_size == request2size(sizes[i])); - } - check_inuse_chunk(m, mem2chunk(marray)); - } - for (i = 0; i != n_elements; ++i) - check_inuse_chunk(m, mem2chunk(marray[i])); - -#endif /* DEBUG */ - - POSTACTION(m); - return marray; -} - -/* Try to free all pointers in the given array. - Note: this could be made faster, by delaying consolidation, - at the price of disabling some user integrity checks, We - still optimize some consolidations by combining adjacent - chunks before freeing, which will occur often if allocated - with ialloc or the array is sorted. -*/ -static size_t internal_bulk_free(mstate m, void* array[], size_t nelem) { - size_t unfreed = 0; - if (!PREACTION(m)) { - void** a; - void** fence = &(array[nelem]); - for (a = array; a != fence; ++a) { - void* mem = *a; - if (mem != 0) { - mchunkptr p = mem2chunk(mem); - size_t psize = chunksize(p); -#if FOOTERS - if (get_mstate_for(p) != m) { - ++unfreed; - continue; - } -#endif - check_inuse_chunk(m, p); - *a = 0; - if (RTCHECK(ok_address(m, p) && ok_inuse(p))) { - void ** b = a + 1; /* try to merge with next chunk */ - mchunkptr next = next_chunk(p); - if (b != fence && *b == chunk2mem(next)) { - size_t newsize = chunksize(next) + psize; - set_inuse(m, p, newsize); - *b = chunk2mem(p); - } - else - dispose_chunk(m, p, psize); - } - else { - CORRUPTION_ERROR_ACTION(m); - break; - } - } - } - if (should_trim(m, m->topsize)) - sys_trim(m, 0); - POSTACTION(m); - } - return unfreed; -} - -/* Traversal */ -#if MALLOC_INSPECT_ALL -static void internal_inspect_all(mstate m, - void(*handler)(void *start, - void *end, - size_t used_bytes, - void* callback_arg), - void* arg) { - if (is_initialized(m)) { - mchunkptr top = m->top; - msegmentptr s; - for (s = &m->seg; s != 0; s = s->next) { - mchunkptr q = align_as_chunk(s->base); - while (segment_holds(s, q) && q->head != FENCEPOST_HEAD) { - mchunkptr next = next_chunk(q); - size_t sz = chunksize(q); - size_t used; - void* start; - if (is_inuse(q)) { - used = sz - CHUNK_OVERHEAD; /* must not be mmapped */ - start = chunk2mem(q); - } - else { - used = 0; - if (is_small(sz)) { /* offset by possible bookkeeping */ - start = (void*)((char*)q + sizeof(struct malloc_chunk)); - } - else { - start = (void*)((char*)q + sizeof(struct malloc_tree_chunk)); - } - } - if (start < (void*)next) /* skip if all space is bookkeeping */ - handler(start, next, used, arg); - if (q == top) - break; - q = next; - } - } - } -} -#endif /* MALLOC_INSPECT_ALL */ - -/* ------------------ Exported realloc, memalign, etc -------------------- */ - -#if !ONLY_MSPACES - -void* dlrealloc(void* oldmem, size_t bytes) { - void* mem = 0; - if (oldmem == 0) { - mem = dlmalloc(bytes); - } - else if (bytes >= MAX_REQUEST) { - MALLOC_FAILURE_ACTION; - } -#ifdef REALLOC_ZERO_BYTES_FREES - else if (bytes == 0) { - dlfree(oldmem); - } -#endif /* REALLOC_ZERO_BYTES_FREES */ - else { - size_t nb = request2size(bytes); - mchunkptr oldp = mem2chunk(oldmem); -#if ! FOOTERS - mstate m = gm; -#else /* FOOTERS */ - mstate m = get_mstate_for(oldp); - if (!ok_magic(m)) { - USAGE_ERROR_ACTION(m, oldmem); - return 0; - } -#endif /* FOOTERS */ - if (!PREACTION(m)) { - mchunkptr newp = try_realloc_chunk(m, oldp, nb, 1); - POSTACTION(m); - if (newp != 0) { - check_inuse_chunk(m, newp); - mem = chunk2mem(newp); - } - else { - mem = internal_malloc(m, bytes); - if (mem != 0) { - size_t oc = chunksize(oldp) - overhead_for(oldp); - memcpy(mem, oldmem, (oc < bytes)? oc : bytes); - internal_free(m, oldmem); - } - } - } - } - return mem; -} - -void* dlrealloc_in_place(void* oldmem, size_t bytes) { - void* mem = 0; - if (oldmem != 0) { - if (bytes >= MAX_REQUEST) { - MALLOC_FAILURE_ACTION; - } - else { - size_t nb = request2size(bytes); - mchunkptr oldp = mem2chunk(oldmem); -#if ! FOOTERS - mstate m = gm; -#else /* FOOTERS */ - mstate m = get_mstate_for(oldp); - if (!ok_magic(m)) { - USAGE_ERROR_ACTION(m, oldmem); - return 0; - } -#endif /* FOOTERS */ - if (!PREACTION(m)) { - mchunkptr newp = try_realloc_chunk(m, oldp, nb, 0); - POSTACTION(m); - if (newp == oldp) { - check_inuse_chunk(m, newp); - mem = oldmem; - } - } - } - } - return mem; -} - -void* dlmemalign(size_t alignment, size_t bytes) { - if (alignment <= MALLOC_ALIGNMENT) { - return dlmalloc(bytes); - } - return internal_memalign(gm, alignment, bytes); -} - -int dlposix_memalign(void** pp, size_t alignment, size_t bytes) { - void* mem = 0; - if (alignment == MALLOC_ALIGNMENT) - mem = dlmalloc(bytes); - else { - size_t d = alignment / sizeof(void*); - size_t r = alignment % sizeof(void*); - if (r != 0 || d == 0 || (d & (d-SIZE_T_ONE)) != 0) - return EINVAL; - else if (bytes <= MAX_REQUEST - alignment) { - if (alignment < MIN_CHUNK_SIZE) - alignment = MIN_CHUNK_SIZE; - mem = internal_memalign(gm, alignment, bytes); - } - } - if (mem == 0) - return ENOMEM; - else { - *pp = mem; - return 0; - } -} - -void* dlvalloc(size_t bytes) { - size_t pagesz; - ensure_initialization(); - pagesz = mparams.page_size; - return dlmemalign(pagesz, bytes); -} - -void* dlpvalloc(size_t bytes) { - size_t pagesz; - ensure_initialization(); - pagesz = mparams.page_size; - return dlmemalign(pagesz, (bytes + pagesz - SIZE_T_ONE) & ~(pagesz - SIZE_T_ONE)); -} - -void** dlindependent_calloc(size_t n_elements, size_t elem_size, - void* chunks[]) { - size_t sz = elem_size; /* serves as 1-element array */ - return ialloc(gm, n_elements, &sz, 3, chunks); -} - -void** dlindependent_comalloc(size_t n_elements, size_t sizes[], - void* chunks[]) { - return ialloc(gm, n_elements, sizes, 0, chunks); -} - -size_t dlbulk_free(void* array[], size_t nelem) { - return internal_bulk_free(gm, array, nelem); -} - -#if MALLOC_INSPECT_ALL -void dlmalloc_inspect_all(void(*handler)(void *start, - void *end, - size_t used_bytes, - void* callback_arg), - void* arg) { - ensure_initialization(); - if (!PREACTION(gm)) { - internal_inspect_all(gm, handler, arg); - POSTACTION(gm); - } -} -#endif /* MALLOC_INSPECT_ALL */ - -int dlmalloc_trim(size_t pad) { - int result = 0; - ensure_initialization(); - if (!PREACTION(gm)) { - result = sys_trim(gm, pad); - POSTACTION(gm); - } - return result; -} - -size_t dlmalloc_footprint(void) { - return gm->footprint; -} - -size_t dlmalloc_max_footprint(void) { - return gm->max_footprint; -} - -size_t dlmalloc_footprint_limit(void) { - size_t maf = gm->footprint_limit; - return maf == 0 ? MAX_SIZE_T : maf; -} - -size_t dlmalloc_set_footprint_limit(size_t bytes) { - size_t result; /* invert sense of 0 */ - if (bytes == 0) - result = granularity_align(1); /* Use minimal size */ - if (bytes == MAX_SIZE_T) - result = 0; /* disable */ - else - result = granularity_align(bytes); - return gm->footprint_limit = result; -} - -#if !NO_MALLINFO -struct mallinfo dlmallinfo(void) { - return internal_mallinfo(gm); -} -#endif /* NO_MALLINFO */ - -#if !NO_MALLOC_STATS -void dlmalloc_stats() { - internal_malloc_stats(gm); -} -#endif /* NO_MALLOC_STATS */ - -int dlmallopt(int param_number, int value) { - return change_mparam(param_number, value); -} - -size_t dlmalloc_usable_size(void* mem) { - if (mem != 0) { - mchunkptr p = mem2chunk(mem); - if (is_inuse(p)) - return chunksize(p) - overhead_for(p); - } - return 0; -} - -#endif /* !ONLY_MSPACES */ - -/* ----------------------------- user mspaces ---------------------------- */ - -#if MSPACES - -static mstate init_user_mstate(char* tbase, size_t tsize) { - size_t msize = pad_request(sizeof(struct malloc_state)); - mchunkptr mn; - mchunkptr msp = align_as_chunk(tbase); - mstate m = (mstate)(chunk2mem(msp)); - memset(m, 0, msize); - (void)INITIAL_LOCK(&m->mutex); - msp->head = (msize|INUSE_BITS); - m->seg.base = m->least_addr = tbase; - m->seg.size = m->footprint = m->max_footprint = tsize; - m->magic = mparams.magic; - m->release_checks = MAX_RELEASE_CHECK_RATE; - m->mflags = mparams.default_mflags; - m->extp = 0; - m->exts = 0; - disable_contiguous(m); - init_bins(m); - mn = next_chunk(mem2chunk(m)); - init_top(m, mn, (size_t)((tbase + tsize) - (char*)mn) - TOP_FOOT_SIZE); - check_top_chunk(m, m->top); - return m; -} - -mspace create_mspace(size_t capacity, int locked) { - mstate m = 0; - size_t msize; - ensure_initialization(); - msize = pad_request(sizeof(struct malloc_state)); - if (capacity < (size_t) -(msize + TOP_FOOT_SIZE + mparams.page_size)) { - size_t rs = ((capacity == 0)? mparams.granularity : - (capacity + TOP_FOOT_SIZE + msize)); - size_t tsize = granularity_align(rs); - char* tbase = (char*)(CALL_MMAP(tsize)); - if (tbase != CMFAIL) { - m = init_user_mstate(tbase, tsize); - m->seg.sflags = USE_MMAP_BIT; - set_lock(m, locked); - } - } - return (mspace)m; -} - -mspace create_mspace_with_base(void* base, size_t capacity, int locked) { - mstate m = 0; - size_t msize; - ensure_initialization(); - msize = pad_request(sizeof(struct malloc_state)); - if (capacity > msize + TOP_FOOT_SIZE && - capacity < (size_t) -(msize + TOP_FOOT_SIZE + mparams.page_size)) { - m = init_user_mstate((char*)base, capacity); - m->seg.sflags = EXTERN_BIT; - set_lock(m, locked); - } - return (mspace)m; -} - -int mspace_track_large_chunks(mspace msp, int enable) { - int ret = 0; - mstate ms = (mstate)msp; - if (!PREACTION(ms)) { - if (!use_mmap(ms)) { - ret = 1; - } - if (!enable) { - enable_mmap(ms); - } else { - disable_mmap(ms); - } - POSTACTION(ms); - } - return ret; -} - -size_t destroy_mspace(mspace msp) { - size_t freed = 0; - mstate ms = (mstate)msp; - if (ok_magic(ms)) { - msegmentptr sp = &ms->seg; - (void)DESTROY_LOCK(&ms->mutex); /* destroy before unmapped */ - while (sp != 0) { - char* base = sp->base; - size_t size = sp->size; - flag_t flag = sp->sflags; - (void)base; /* placate people compiling -Wunused-variable */ - sp = sp->next; - if ((flag & USE_MMAP_BIT) && !(flag & EXTERN_BIT) && - CALL_MUNMAP(base, size) == 0) - freed += size; - } - } - else { - USAGE_ERROR_ACTION(ms,ms); - } - return freed; -} - -/* - mspace versions of routines are near-clones of the global - versions. This is not so nice but better than the alternatives. -*/ - -void* mspace_malloc(mspace msp, size_t bytes) { - mstate ms = (mstate)msp; - if (!ok_magic(ms)) { - USAGE_ERROR_ACTION(ms,ms); - return 0; - } - if (!PREACTION(ms)) { - void* mem; - size_t nb; - if (bytes <= MAX_SMALL_REQUEST) { - bindex_t idx; - binmap_t smallbits; - nb = (bytes < MIN_REQUEST)? MIN_CHUNK_SIZE : pad_request(bytes); - idx = small_index(nb); - smallbits = ms->smallmap >> idx; - - if ((smallbits & 0x3U) != 0) { /* Remainderless fit to a smallbin. */ - mchunkptr b, p; - idx += ~smallbits & 1; /* Uses next bin if idx empty */ - b = smallbin_at(ms, idx); - p = b->fd; - assert(chunksize(p) == small_index2size(idx)); - unlink_first_small_chunk(ms, b, p, idx); - set_inuse_and_pinuse(ms, p, small_index2size(idx)); - mem = chunk2mem(p); - check_malloced_chunk(ms, mem, nb); - goto postaction; - } - - else if (nb > ms->dvsize) { - if (smallbits != 0) { /* Use chunk in next nonempty smallbin */ - mchunkptr b, p, r; - size_t rsize; - bindex_t i; - binmap_t leftbits = (smallbits << idx) & left_bits(idx2bit(idx)); - binmap_t leastbit = least_bit(leftbits); - compute_bit2idx(leastbit, i); - b = smallbin_at(ms, i); - p = b->fd; - assert(chunksize(p) == small_index2size(i)); - unlink_first_small_chunk(ms, b, p, i); - rsize = small_index2size(i) - nb; - /* Fit here cannot be remainderless if 4byte sizes */ - if (SIZE_T_SIZE != 4 && rsize < MIN_CHUNK_SIZE) - set_inuse_and_pinuse(ms, p, small_index2size(i)); - else { - set_size_and_pinuse_of_inuse_chunk(ms, p, nb); - r = chunk_plus_offset(p, nb); - set_size_and_pinuse_of_free_chunk(r, rsize); - replace_dv(ms, r, rsize); - } - mem = chunk2mem(p); - check_malloced_chunk(ms, mem, nb); - goto postaction; - } - - else if (ms->treemap != 0 && (mem = tmalloc_small(ms, nb)) != 0) { - check_malloced_chunk(ms, mem, nb); - goto postaction; - } - } - } - else if (bytes >= MAX_REQUEST) - nb = MAX_SIZE_T; /* Too big to allocate. Force failure (in sys alloc) */ - else { - nb = pad_request(bytes); - if (ms->treemap != 0 && (mem = tmalloc_large(ms, nb)) != 0) { - check_malloced_chunk(ms, mem, nb); - goto postaction; - } - } - - if (nb <= ms->dvsize) { - size_t rsize = ms->dvsize - nb; - mchunkptr p = ms->dv; - if (rsize >= MIN_CHUNK_SIZE) { /* split dv */ - mchunkptr r = ms->dv = chunk_plus_offset(p, nb); - ms->dvsize = rsize; - set_size_and_pinuse_of_free_chunk(r, rsize); - set_size_and_pinuse_of_inuse_chunk(ms, p, nb); - } - else { /* exhaust dv */ - size_t dvs = ms->dvsize; - ms->dvsize = 0; - ms->dv = 0; - set_inuse_and_pinuse(ms, p, dvs); - } - mem = chunk2mem(p); - check_malloced_chunk(ms, mem, nb); - goto postaction; - } - - else if (nb < ms->topsize) { /* Split top */ - size_t rsize = ms->topsize -= nb; - mchunkptr p = ms->top; - mchunkptr r = ms->top = chunk_plus_offset(p, nb); - r->head = rsize | PINUSE_BIT; - set_size_and_pinuse_of_inuse_chunk(ms, p, nb); - mem = chunk2mem(p); - check_top_chunk(ms, ms->top); - check_malloced_chunk(ms, mem, nb); - goto postaction; - } - - mem = sys_alloc(ms, nb); - - postaction: - POSTACTION(ms); - return mem; - } - - return 0; -} - -void mspace_free(mspace msp, void* mem) { - if (mem != 0) { - mchunkptr p = mem2chunk(mem); -#if FOOTERS - mstate fm = get_mstate_for(p); - (void)msp; /* placate people compiling -Wunused */ -#else /* FOOTERS */ - mstate fm = (mstate)msp; -#endif /* FOOTERS */ - if (!ok_magic(fm)) { - USAGE_ERROR_ACTION(fm, p); - return; - } - if (!PREACTION(fm)) { - check_inuse_chunk(fm, p); - if (RTCHECK(ok_address(fm, p) && ok_inuse(p))) { - size_t psize = chunksize(p); - mchunkptr next = chunk_plus_offset(p, psize); - if (!pinuse(p)) { - size_t prevsize = p->prev_foot; - if (is_mmapped(p)) { - psize += prevsize + MMAP_FOOT_PAD; - if (CALL_MUNMAP((char*)p - prevsize, psize) == 0) - fm->footprint -= psize; - goto postaction; - } - else { - mchunkptr prev = chunk_minus_offset(p, prevsize); - psize += prevsize; - p = prev; - if (RTCHECK(ok_address(fm, prev))) { /* consolidate backward */ - if (p != fm->dv) { - unlink_chunk(fm, p, prevsize); - } - else if ((next->head & INUSE_BITS) == INUSE_BITS) { - fm->dvsize = psize; - set_free_with_pinuse(p, psize, next); - goto postaction; - } - } - else - goto erroraction; - } - } - - if (RTCHECK(ok_next(p, next) && ok_pinuse(next))) { - if (!cinuse(next)) { /* consolidate forward */ - if (next == fm->top) { - size_t tsize = fm->topsize += psize; - fm->top = p; - p->head = tsize | PINUSE_BIT; - if (p == fm->dv) { - fm->dv = 0; - fm->dvsize = 0; - } - if (should_trim(fm, tsize)) - sys_trim(fm, 0); - goto postaction; - } - else if (next == fm->dv) { - size_t dsize = fm->dvsize += psize; - fm->dv = p; - set_size_and_pinuse_of_free_chunk(p, dsize); - goto postaction; - } - else { - size_t nsize = chunksize(next); - psize += nsize; - unlink_chunk(fm, next, nsize); - set_size_and_pinuse_of_free_chunk(p, psize); - if (p == fm->dv) { - fm->dvsize = psize; - goto postaction; - } - } - } - else - set_free_with_pinuse(p, psize, next); - - if (is_small(psize)) { - insert_small_chunk(fm, p, psize); - check_free_chunk(fm, p); - } - else { - tchunkptr tp = (tchunkptr)p; - insert_large_chunk(fm, tp, psize); - check_free_chunk(fm, p); - if (--fm->release_checks == 0) - release_unused_segments(fm); - } - goto postaction; - } - } - erroraction: - USAGE_ERROR_ACTION(fm, p); - postaction: - POSTACTION(fm); - } - } -} - -void* mspace_calloc(mspace msp, size_t n_elements, size_t elem_size) { - void* mem; - size_t req = 0; - mstate ms = (mstate)msp; - if (!ok_magic(ms)) { - USAGE_ERROR_ACTION(ms,ms); - return 0; - } - if (n_elements != 0) { - req = n_elements * elem_size; - if (((n_elements | elem_size) & ~(size_t)0xffff) && - (req / n_elements != elem_size)) - req = MAX_SIZE_T; /* force downstream failure on overflow */ - } - mem = internal_malloc(ms, req); - if (mem != 0 && calloc_must_clear(mem2chunk(mem))) - memset(mem, 0, req); - return mem; -} - -void* mspace_realloc(mspace msp, void* oldmem, size_t bytes) { - void* mem = 0; - if (oldmem == 0) { - mem = mspace_malloc(msp, bytes); - } - else if (bytes >= MAX_REQUEST) { - MALLOC_FAILURE_ACTION; - } -#ifdef REALLOC_ZERO_BYTES_FREES - else if (bytes == 0) { - mspace_free(msp, oldmem); - } -#endif /* REALLOC_ZERO_BYTES_FREES */ - else { - size_t nb = request2size(bytes); - mchunkptr oldp = mem2chunk(oldmem); -#if ! FOOTERS - mstate m = (mstate)msp; -#else /* FOOTERS */ - mstate m = get_mstate_for(oldp); - if (!ok_magic(m)) { - USAGE_ERROR_ACTION(m, oldmem); - return 0; - } -#endif /* FOOTERS */ - if (!PREACTION(m)) { - mchunkptr newp = try_realloc_chunk(m, oldp, nb, 1); - POSTACTION(m); - if (newp != 0) { - check_inuse_chunk(m, newp); - mem = chunk2mem(newp); - } - else { - mem = mspace_malloc(m, bytes); - if (mem != 0) { - size_t oc = chunksize(oldp) - overhead_for(oldp); - memcpy(mem, oldmem, (oc < bytes)? oc : bytes); - mspace_free(m, oldmem); - } - } - } - } - return mem; -} - -void* mspace_realloc_in_place(mspace msp, void* oldmem, size_t bytes) { - void* mem = 0; - if (oldmem != 0) { - if (bytes >= MAX_REQUEST) { - MALLOC_FAILURE_ACTION; - } - else { - size_t nb = request2size(bytes); - mchunkptr oldp = mem2chunk(oldmem); -#if ! FOOTERS - mstate m = (mstate)msp; -#else /* FOOTERS */ - mstate m = get_mstate_for(oldp); - (void)msp; /* placate people compiling -Wunused */ - if (!ok_magic(m)) { - USAGE_ERROR_ACTION(m, oldmem); - return 0; - } -#endif /* FOOTERS */ - if (!PREACTION(m)) { - mchunkptr newp = try_realloc_chunk(m, oldp, nb, 0); - POSTACTION(m); - if (newp == oldp) { - check_inuse_chunk(m, newp); - mem = oldmem; - } - } - } - } - return mem; -} - -void* mspace_memalign(mspace msp, size_t alignment, size_t bytes) { - mstate ms = (mstate)msp; - if (!ok_magic(ms)) { - USAGE_ERROR_ACTION(ms,ms); - return 0; - } - if (alignment <= MALLOC_ALIGNMENT) - return mspace_malloc(msp, bytes); - return internal_memalign(ms, alignment, bytes); -} - -void** mspace_independent_calloc(mspace msp, size_t n_elements, - size_t elem_size, void* chunks[]) { - size_t sz = elem_size; /* serves as 1-element array */ - mstate ms = (mstate)msp; - if (!ok_magic(ms)) { - USAGE_ERROR_ACTION(ms,ms); - return 0; - } - return ialloc(ms, n_elements, &sz, 3, chunks); -} - -void** mspace_independent_comalloc(mspace msp, size_t n_elements, - size_t sizes[], void* chunks[]) { - mstate ms = (mstate)msp; - if (!ok_magic(ms)) { - USAGE_ERROR_ACTION(ms,ms); - return 0; - } - return ialloc(ms, n_elements, sizes, 0, chunks); -} - -size_t mspace_bulk_free(mspace msp, void* array[], size_t nelem) { - return internal_bulk_free((mstate)msp, array, nelem); -} - -#if MALLOC_INSPECT_ALL -void mspace_inspect_all(mspace msp, - void(*handler)(void *start, - void *end, - size_t used_bytes, - void* callback_arg), - void* arg) { - mstate ms = (mstate)msp; - if (ok_magic(ms)) { - if (!PREACTION(ms)) { - internal_inspect_all(ms, handler, arg); - POSTACTION(ms); - } - } - else { - USAGE_ERROR_ACTION(ms,ms); - } -} -#endif /* MALLOC_INSPECT_ALL */ - -int mspace_trim(mspace msp, size_t pad) { - int result = 0; - mstate ms = (mstate)msp; - if (ok_magic(ms)) { - if (!PREACTION(ms)) { - result = sys_trim(ms, pad); - POSTACTION(ms); - } - } - else { - USAGE_ERROR_ACTION(ms,ms); - } - return result; -} - -#if !NO_MALLOC_STATS -void mspace_malloc_stats(mspace msp) { - mstate ms = (mstate)msp; - if (ok_magic(ms)) { - internal_malloc_stats(ms); - } - else { - USAGE_ERROR_ACTION(ms,ms); - } -} -#endif /* NO_MALLOC_STATS */ - -size_t mspace_footprint(mspace msp) { - size_t result = 0; - mstate ms = (mstate)msp; - if (ok_magic(ms)) { - result = ms->footprint; - } - else { - USAGE_ERROR_ACTION(ms,ms); - } - return result; -} - -size_t mspace_max_footprint(mspace msp) { - size_t result = 0; - mstate ms = (mstate)msp; - if (ok_magic(ms)) { - result = ms->max_footprint; - } - else { - USAGE_ERROR_ACTION(ms,ms); - } - return result; -} - -size_t mspace_footprint_limit(mspace msp) { - size_t result = 0; - mstate ms = (mstate)msp; - if (ok_magic(ms)) { - size_t maf = ms->footprint_limit; - result = (maf == 0) ? MAX_SIZE_T : maf; - } - else { - USAGE_ERROR_ACTION(ms,ms); - } - return result; -} - -size_t mspace_set_footprint_limit(mspace msp, size_t bytes) { - size_t result = 0; - mstate ms = (mstate)msp; - if (ok_magic(ms)) { - if (bytes == 0) - result = granularity_align(1); /* Use minimal size */ - if (bytes == MAX_SIZE_T) - result = 0; /* disable */ - else - result = granularity_align(bytes); - ms->footprint_limit = result; - } - else { - USAGE_ERROR_ACTION(ms,ms); - } - return result; -} - -#if !NO_MALLINFO -struct mallinfo mspace_mallinfo(mspace msp) { - mstate ms = (mstate)msp; - if (!ok_magic(ms)) { - USAGE_ERROR_ACTION(ms,ms); - } - return internal_mallinfo(ms); -} -#endif /* NO_MALLINFO */ - -size_t mspace_usable_size(const void* mem) { - if (mem != 0) { - mchunkptr p = mem2chunk(mem); - if (is_inuse(p)) - return chunksize(p) - overhead_for(p); - } - return 0; -} - -int mspace_mallopt(int param_number, int value) { - return change_mparam(param_number, value); -} - -#endif /* MSPACES */ - - -/* -------------------- Alternative MORECORE functions ------------------- */ - -/* - Guidelines for creating a custom version of MORECORE: - - * For best performance, MORECORE should allocate in multiples of pagesize. - * MORECORE may allocate more memory than requested. (Or even less, - but this will usually result in a malloc failure.) - * MORECORE must not allocate memory when given argument zero, but - instead return one past the end address of memory from previous - nonzero call. - * For best performance, consecutive calls to MORECORE with positive - arguments should return increasing addresses, indicating that - space has been contiguously extended. - * Even though consecutive calls to MORECORE need not return contiguous - addresses, it must be OK for malloc'ed chunks to span multiple - regions in those cases where they do happen to be contiguous. - * MORECORE need not handle negative arguments -- it may instead - just return MFAIL when given negative arguments. - Negative arguments are always multiples of pagesize. MORECORE - must not misinterpret negative args as large positive unsigned - args. You can suppress all such calls from even occurring by defining - MORECORE_CANNOT_TRIM, - - As an example alternative MORECORE, here is a custom allocator - kindly contributed for pre-OSX macOS. It uses virtually but not - necessarily physically contiguous non-paged memory (locked in, - present and won't get swapped out). You can use it by uncommenting - this section, adding some #includes, and setting up the appropriate - defines above: - - #define MORECORE osMoreCore - - There is also a shutdown routine that should somehow be called for - cleanup upon program exit. - - #define MAX_POOL_ENTRIES 100 - #define MINIMUM_MORECORE_SIZE (64 * 1024U) - static int next_os_pool; - void *our_os_pools[MAX_POOL_ENTRIES]; - - void *osMoreCore(int size) - { - void *ptr = 0; - static void *sbrk_top = 0; - - if (size > 0) - { - if (size < MINIMUM_MORECORE_SIZE) - size = MINIMUM_MORECORE_SIZE; - if (CurrentExecutionLevel() == kTaskLevel) - ptr = PoolAllocateResident(size + RM_PAGE_SIZE, 0); - if (ptr == 0) - { - return (void *) MFAIL; - } - // save ptrs so they can be freed during cleanup - our_os_pools[next_os_pool] = ptr; - next_os_pool++; - ptr = (void *) ((((size_t) ptr) + RM_PAGE_MASK) & ~RM_PAGE_MASK); - sbrk_top = (char *) ptr + size; - return ptr; - } - else if (size < 0) - { - // we don't currently support shrink behavior - return (void *) MFAIL; - } - else - { - return sbrk_top; - } - } - - // cleanup any allocated memory pools - // called as last thing before shutting down driver - - void osCleanupMem(void) - { - void **ptr; - - for (ptr = our_os_pools; ptr < &our_os_pools[MAX_POOL_ENTRIES]; ptr++) - if (*ptr) - { - PoolDeallocate(*ptr); - *ptr = 0; - } - } - -*/ - - -/* ----------------------------------------------------------------------- -History: - v2.8.6 Wed Aug 29 06:57:58 2012 Doug Lea - * fix bad comparison in dlposix_memalign - * don't reuse adjusted asize in sys_alloc - * add LOCK_AT_FORK -- thanks to Kirill Artamonov for the suggestion - * reduce compiler warnings -- thanks to all who reported/suggested these - - v2.8.5 Sun May 22 10:26:02 2011 Doug Lea (dl at gee) - * Always perform unlink checks unless INSECURE - * Add posix_memalign. - * Improve realloc to expand in more cases; expose realloc_in_place. - Thanks to Peter Buhr for the suggestion. - * Add footprint_limit, inspect_all, bulk_free. Thanks - to Barry Hayes and others for the suggestions. - * Internal refactorings to avoid calls while holding locks - * Use non-reentrant locks by default. Thanks to Roland McGrath - for the suggestion. - * Small fixes to mspace_destroy, reset_on_error. - * Various configuration extensions/changes. Thanks - to all who contributed these. - - V2.8.4a Thu Apr 28 14:39:43 2011 (dl at gee.cs.oswego.edu) - * Update Creative Commons URL - - V2.8.4 Wed May 27 09:56:23 2009 Doug Lea (dl at gee) - * Use zeros instead of prev foot for is_mmapped - * Add mspace_track_large_chunks; thanks to Jean Brouwers - * Fix set_inuse in internal_realloc; thanks to Jean Brouwers - * Fix insufficient sys_alloc padding when using 16byte alignment - * Fix bad error check in mspace_footprint - * Adaptations for ptmalloc; thanks to Wolfram Gloger. - * Reentrant spin locks; thanks to Earl Chew and others - * Win32 improvements; thanks to Niall Douglas and Earl Chew - * Add NO_SEGMENT_TRAVERSAL and MAX_RELEASE_CHECK_RATE options - * Extension hook in malloc_state - * Various small adjustments to reduce warnings on some compilers - * Various configuration extensions/changes for more platforms. Thanks - to all who contributed these. - - V2.8.3 Thu Sep 22 11:16:32 2005 Doug Lea (dl at gee) - * Add max_footprint functions - * Ensure all appropriate literals are size_t - * Fix conditional compilation problem for some #define settings - * Avoid concatenating segments with the one provided - in create_mspace_with_base - * Rename some variables to avoid compiler shadowing warnings - * Use explicit lock initialization. - * Better handling of sbrk interference. - * Simplify and fix segment insertion, trimming and mspace_destroy - * Reinstate REALLOC_ZERO_BYTES_FREES option from 2.7.x - * Thanks especially to Dennis Flanagan for help on these. - - V2.8.2 Sun Jun 12 16:01:10 2005 Doug Lea (dl at gee) - * Fix memalign brace error. - - V2.8.1 Wed Jun 8 16:11:46 2005 Doug Lea (dl at gee) - * Fix improper #endif nesting in C++ - * Add explicit casts needed for C++ - - V2.8.0 Mon May 30 14:09:02 2005 Doug Lea (dl at gee) - * Use trees for large bins - * Support mspaces - * Use segments to unify sbrk-based and mmap-based system allocation, - removing need for emulation on most platforms without sbrk. - * Default safety checks - * Optional footer checks. Thanks to William Robertson for the idea. - * Internal code refactoring - * Incorporate suggestions and platform-specific changes. - Thanks to Dennis Flanagan, Colin Plumb, Niall Douglas, - Aaron Bachmann, Emery Berger, and others. - * Speed up non-fastbin processing enough to remove fastbins. - * Remove useless cfree() to avoid conflicts with other apps. - * Remove internal memcpy, memset. Compilers handle builtins better. - * Remove some options that no one ever used and rename others. - - V2.7.2 Sat Aug 17 09:07:30 2002 Doug Lea (dl at gee) - * Fix malloc_state bitmap array misdeclaration - - V2.7.1 Thu Jul 25 10:58:03 2002 Doug Lea (dl at gee) - * Allow tuning of FIRST_SORTED_BIN_SIZE - * Use PTR_UINT as type for all ptr->int casts. Thanks to John Belmonte. - * Better detection and support for non-contiguousness of MORECORE. - Thanks to Andreas Mueller, Conal Walsh, and Wolfram Gloger - * Bypass most of malloc if no frees. Thanks To Emery Berger. - * Fix freeing of old top non-contiguous chunk im sysmalloc. - * Raised default trim and map thresholds to 256K. - * Fix mmap-related #defines. Thanks to Lubos Lunak. - * Fix copy macros; added LACKS_FCNTL_H. Thanks to Neal Walfield. - * Branch-free bin calculation - * Default trim and mmap thresholds now 256K. - - V2.7.0 Sun Mar 11 14:14:06 2001 Doug Lea (dl at gee) - * Introduce independent_comalloc and independent_calloc. - Thanks to Michael Pachos for motivation and help. - * Make optional .h file available - * Allow > 2GB requests on 32bit systems. - * new WIN32 sbrk, mmap, munmap, lock code from . - Thanks also to Andreas Mueller , - and Anonymous. - * Allow override of MALLOC_ALIGNMENT (Thanks to Ruud Waij for - helping test this.) - * memalign: check alignment arg - * realloc: don't try to shift chunks backwards, since this - leads to more fragmentation in some programs and doesn't - seem to help in any others. - * Collect all cases in malloc requiring system memory into sysmalloc - * Use mmap as backup to sbrk - * Place all internal state in malloc_state - * Introduce fastbins (although similar to 2.5.1) - * Many minor tunings and cosmetic improvements - * Introduce USE_PUBLIC_MALLOC_WRAPPERS, USE_MALLOC_LOCK - * Introduce MALLOC_FAILURE_ACTION, MORECORE_CONTIGUOUS - Thanks to Tony E. Bennett and others. - * Include errno.h to support default failure action. - - V2.6.6 Sun Dec 5 07:42:19 1999 Doug Lea (dl at gee) - * return null for negative arguments - * Added Several WIN32 cleanups from Martin C. Fong - * Add 'LACKS_SYS_PARAM_H' for those systems without 'sys/param.h' - (e.g. WIN32 platforms) - * Cleanup header file inclusion for WIN32 platforms - * Cleanup code to avoid Microsoft Visual C++ compiler complaints - * Add 'USE_DL_PREFIX' to quickly allow co-existence with existing - memory allocation routines - * Set 'malloc_getpagesize' for WIN32 platforms (needs more work) - * Use 'assert' rather than 'ASSERT' in WIN32 code to conform to - usage of 'assert' in non-WIN32 code - * Improve WIN32 'sbrk()' emulation's 'findRegion()' routine to - avoid infinite loop - * Always call 'fREe()' rather than 'free()' - - V2.6.5 Wed Jun 17 15:57:31 1998 Doug Lea (dl at gee) - * Fixed ordering problem with boundary-stamping - - V2.6.3 Sun May 19 08:17:58 1996 Doug Lea (dl at gee) - * Added pvalloc, as recommended by H.J. Liu - * Added 64bit pointer support mainly from Wolfram Gloger - * Added anonymously donated WIN32 sbrk emulation - * Malloc, calloc, getpagesize: add optimizations from Raymond Nijssen - * malloc_extend_top: fix mask error that caused wastage after - foreign sbrks - * Add linux mremap support code from HJ Liu - - V2.6.2 Tue Dec 5 06:52:55 1995 Doug Lea (dl at gee) - * Integrated most documentation with the code. - * Add support for mmap, with help from - Wolfram Gloger (Gloger@lrz.uni-muenchen.de). - * Use last_remainder in more cases. - * Pack bins using idea from colin@nyx10.cs.du.edu - * Use ordered bins instead of best-fit threshhold - * Eliminate block-local decls to simplify tracing and debugging. - * Support another case of realloc via move into top - * Fix error occuring when initial sbrk_base not word-aligned. - * Rely on page size for units instead of SBRK_UNIT to - avoid surprises about sbrk alignment conventions. - * Add mallinfo, mallopt. Thanks to Raymond Nijssen - (raymond@es.ele.tue.nl) for the suggestion. - * Add `pad' argument to malloc_trim and top_pad mallopt parameter. - * More precautions for cases where other routines call sbrk, - courtesy of Wolfram Gloger (Gloger@lrz.uni-muenchen.de). - * Added macros etc., allowing use in linux libc from - H.J. Lu (hjl@gnu.ai.mit.edu) - * Inverted this history list - - V2.6.1 Sat Dec 2 14:10:57 1995 Doug Lea (dl at gee) - * Re-tuned and fixed to behave more nicely with V2.6.0 changes. - * Removed all preallocation code since under current scheme - the work required to undo bad preallocations exceeds - the work saved in good cases for most test programs. - * No longer use return list or unconsolidated bins since - no scheme using them consistently outperforms those that don't - given above changes. - * Use best fit for very large chunks to prevent some worst-cases. - * Added some support for debugging - - V2.6.0 Sat Nov 4 07:05:23 1995 Doug Lea (dl at gee) - * Removed footers when chunks are in use. Thanks to - Paul Wilson (wilson@cs.texas.edu) for the suggestion. - - V2.5.4 Wed Nov 1 07:54:51 1995 Doug Lea (dl at gee) - * Added malloc_trim, with help from Wolfram Gloger - (wmglo@Dent.MED.Uni-Muenchen.DE). - - V2.5.3 Tue Apr 26 10:16:01 1994 Doug Lea (dl at g) - - V2.5.2 Tue Apr 5 16:20:40 1994 Doug Lea (dl at g) - * realloc: try to expand in both directions - * malloc: swap order of clean-bin strategy; - * realloc: only conditionally expand backwards - * Try not to scavenge used bins - * Use bin counts as a guide to preallocation - * Occasionally bin return list chunks in first scan - * Add a few optimizations from colin@nyx10.cs.du.edu - - V2.5.1 Sat Aug 14 15:40:43 1993 Doug Lea (dl at g) - * faster bin computation & slightly different binning - * merged all consolidations to one part of malloc proper - (eliminating old malloc_find_space & malloc_clean_bin) - * Scan 2 returns chunks (not just 1) - * Propagate failure in realloc if malloc returns 0 - * Add stuff to allow compilation on non-ANSI compilers - from kpv@research.att.com - - V2.5 Sat Aug 7 07:41:59 1993 Doug Lea (dl at g.oswego.edu) - * removed potential for odd address access in prev_chunk - * removed dependency on getpagesize.h - * misc cosmetics and a bit more internal documentation - * anticosmetics: mangled names in macros to evade debugger strangeness - * tested on sparc, hp-700, dec-mips, rs6000 - with gcc & native cc (hp, dec only) allowing - Detlefs & Zorn comparison study (in SIGPLAN Notices.) - - Trial version Fri Aug 28 13:14:29 1992 Doug Lea (dl at g.oswego.edu) - * Based loosely on libg++-1.2X malloc. (It retains some of the overall - structure of old version, but most details differ.) - -*/ -#endif From 0bfd2b9ed2e26e31c76f4ddb9dddd1256c8f0a88 Mon Sep 17 00:00:00 2001 From: MeltyPlayer Date: Mon, 24 Oct 2022 03:02:31 -0500 Subject: [PATCH 07/16] Deleted unused compat file. --- src/decomp/pc/compat.h | 8 -------- 1 file changed, 8 deletions(-) delete mode 100644 src/decomp/pc/compat.h diff --git a/src/decomp/pc/compat.h b/src/decomp/pc/compat.h deleted file mode 100644 index 8d6a3d4..0000000 --- a/src/decomp/pc/compat.h +++ /dev/null @@ -1,8 +0,0 @@ -#ifndef COMPAT_H -#define COMPAT_H value - -#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) -#define __BSD__ -#endif - -#endif \ No newline at end of file From fed6deebc3e60b1ec22ba09c0c3a0c53895a3349 Mon Sep 17 00:00:00 2001 From: MeltyPlayer Date: Wed, 26 Oct 2022 16:21:50 -0500 Subject: [PATCH 08/16] Removed print statements that were accidentally kept in convUtils. --- src/decomp/tools/convUtils.c | 22 +--------------------- 1 file changed, 1 insertion(+), 21 deletions(-) diff --git a/src/decomp/tools/convUtils.c b/src/decomp/tools/convUtils.c index bf4d3b6..5ee21f4 100644 --- a/src/decomp/tools/convUtils.c +++ b/src/decomp/tools/convUtils.c @@ -4,9 +4,9 @@ #include "utils.h" #include #include +#include #include "convUtils.h" #include "convTypes.h" -#include "../../debug_print.h" /** * This code is based on the only documentation that exists (that I know of) for the SM64 CTL/TBL format @@ -21,15 +21,10 @@ unsigned char* gCtlSeqs; struct seqFile* parse_seqfile(unsigned char* seq){ /* Read SeqFile data */ - DEBUG_PRINT("parse_seqfile()"); - short revision = read_u16_be(seq); short bankCount = read_u16_be(seq + 2); - DEBUG_PRINT("- bankCount: %d", bankCount); unsigned int size = sizeof(struct seqFile) + (bankCount-1) * sizeof(struct seqObject); - DEBUG_PRINT("- seqFile size: %d", sizeof(struct seqFile)); - DEBUG_PRINT("- actual size: %d", size); struct seqFile* seqFile = (struct seqFile*)calloc(size, 1); seqFile->revision = revision; @@ -40,7 +35,6 @@ struct seqFile* parse_seqfile(unsigned char* seq){ /* Read SeqFile data */ } if (revision == TYPE_CTL){ - DEBUG_PRINT("- found ctl!"); // CTL file, contains instrument and drum data, this is really the only one that needs to be parsed, the rest only needs a header change gCtlSeqs = (unsigned char*)calloc(0x20B40, 1); // We only really need 0x20AD0 bytes but still uintptr_t pos = (uintptr_t)gCtlSeqs; @@ -51,21 +45,17 @@ struct seqFile* parse_seqfile(unsigned char* seq){ /* Read SeqFile data */ seqFile->seqArray[i].len = (unsigned int)(pos - start); } }else if (revision == TYPE_TBL){ - DEBUG_PRINT("- found tbl!"); // TBL file, contains raw audio data for (int i = 0; i < bankCount; i++){ seqFile->seqArray[i].offset = seq+(seqFile->seqArray[i].offset); } }else if (revision == TYPE_SEQ){ - DEBUG_PRINT("- found seq!"); // SEQ file, contains music files (*.m64) for (int i = 0; i < bankCount; i++){ seqFile->seqArray[i].offset = seq+(seqFile->seqArray[i].offset); } } - DEBUG_PRINT("- returning seq: %p", seqFile); - return seqFile; } @@ -83,23 +73,14 @@ void snd_ptrs_to_offsets(struct CSound* snd, uintptr_t ctlData){ } void ptrs_to_offsets(struct seqFile* ctl){ - DEBUG_PRINT("ptrs_to_offsets()"); - - DEBUG_PRINT("- checking if type is not ctl..."); - DEBUG_PRINT("%p", ctl); if (ctl->revision != TYPE_CTL){ - DEBUG_PRINT("Sequence file is not a CTL file\n"); return; } - DEBUG_PRINT("- looping through ctl"); - DEBUG_PRINT("seq count: %d", ctl->seqCount); for (int i = 0; i < ctl->seqCount; i++){ - DEBUG_PRINT("- for seq"); struct CTL* ptr = (struct CTL*)ctl->seqArray[i].offset; uintptr_t ctlData = (uintptr_t)ptr + 0x10; // find all samples in the CTL file - DEBUG_PRINT("- finding samples"); for (int j = 0; j < ptr->numInstruments; j++){ struct CInstrument* inst = ptr->instrument_pointers[j]; if (inst==0x0) @@ -116,7 +97,6 @@ void ptrs_to_offsets(struct seqFile* ctl){ } ptr->instrument_pointers[j] = (struct CInstrument*)((uintptr_t)(inst) - ctlData); } - DEBUG_PRINT("- finding drums"); if(ptr->numDrums != 0){ for (int j = 0; j < ptr->numDrums; j++){ struct CDrum* drum = ptr->drum_pointers[j]; From 7bd0cc9a2ce4aaeaf68b836bddaf70f296c453f8 Mon Sep 17 00:00:00 2001 From: MeltyPlayer Date: Thu, 27 Oct 2022 22:37:33 -0500 Subject: [PATCH 09/16] Enabled NO_SEGMENTED_MEMORY flag in order to fix bug when converting virtual to physical memory addresses. --- Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Makefile b/Makefile index ba4d43e..59df3ee 100644 --- a/Makefile +++ b/Makefile @@ -7,7 +7,7 @@ else CC := cc LDFLAGS := -lm -shared endif -CFLAGS := -g -Wall -fPIC -DSM64_LIB_EXPORT -DGBI_FLOATS -DVERSION_US +CFLAGS := -g -Wall -fPIC -DSM64_LIB_EXPORT -DGBI_FLOATS -DVERSION_US -DNO_SEGMENTED_MEMORY SRC_DIRS := src src/decomp src/decomp/engine src/decomp/include/PR src/decomp/game src/decomp/pc src/decomp/pc/audio src/decomp/mario src/decomp/tools src/decomp/audio BUILD_DIR := build From 3a4115e8f6fb8c0ad3ffd51e94000cca82609f0e Mon Sep 17 00:00:00 2001 From: MeltyPlayer Date: Sun, 6 Nov 2022 20:22:00 -0600 Subject: [PATCH 10/16] Pushed the final changes that got audio working! --- src/decomp/audio/external.c | 30 +++- src/decomp/audio/external.h | 10 +- src/decomp/audio/heap.c | 23 +-- src/decomp/audio/load.c | 115 ++++++------ src/decomp/audio/seqplayer.c | 52 ++++-- src/decomp/audio/synthesis.c | 269 +++++++---------------------- src/decomp/include/PR/abi.h | 8 +- src/decomp/include/PR/libaudio.h | 42 +---- src/decomp/include/platform_info.h | 2 +- src/decomp/pc/alBnkfNew.c | 7 + src/decomp/pc/mixer.c | 3 + src/decomp/tools/convUtils.c | 12 ++ src/libsm64.c | 24 ++- src/libsm64.h | 3 +- src/load_audio_data.c | 30 ++-- src/load_audio_data.h | 7 +- src/play_sound.c | 8 + 17 files changed, 274 insertions(+), 371 deletions(-) diff --git a/src/decomp/audio/external.c b/src/decomp/audio/external.c index fabb36f..a2222d7 100644 --- a/src/decomp/audio/external.c +++ b/src/decomp/audio/external.c @@ -35,11 +35,6 @@ #define SAMPLES_TO_OVERPRODUCE 0x10 #define EXTRA_BUFFERED_AI_SAMPLES_TARGET 0x40 -struct Sound { - s32 soundBits; - f32 *position; -}; // size = 0x8 - struct ChannelVolumeScaleFade { f32 velocity; u8 target; @@ -413,7 +408,7 @@ extern void func_802ad74c(u32 bits, u32 arg); extern void func_802ad770(u32 bits, s8 arg); static void update_background_music_after_sound(u8 bank, u8 soundIndex); -static void update_game_sound(void); +void update_game_sound(void); static void fade_channel_volume_scale(u8 player, u8 channelId, u8 targetScale, u16 fadeTimer); void process_level_music_dynamics(void); static u8 begin_background_music_fade(u16 fadeDuration); @@ -663,7 +658,11 @@ extern void func_sh_802F64C8(void); * Called from threads: thread5_game_loop */ void maybe_tick_game_sound(void) { + DEBUG_PRINT("maybe_tick_game_sound()"); + + DEBUG_PRINT("- if game loop ticked is false..."); if (sGameLoopTicked != 0) { + DEBUG_PRINT("- updating game sound"); update_game_sound(); sGameLoopTicked = 0; } @@ -794,14 +793,17 @@ struct SPTask *create_next_audio_frame_task(void) { return NULL; } void create_next_audio_buffer(s16 *samples, u32 num_samples) { + DEBUG_PRINT("create_next_audio_buffer()"); gAudioFrameCount++; if (sGameLoopTicked != 0) { update_game_sound(); sGameLoopTicked = 0; } s32 writtenCmds; + DEBUG_PRINT("- synthesis execute"); synthesis_execute(gAudioCmdBuffers[0], &writtenCmds, samples, num_samples); gAudioRandom = ((gAudioRandom + gAudioFrameCount) * gAudioFrameCount); + DEBUG_PRINT("- decrease sample dma ttls"); decrease_sample_dma_ttls(); } #endif @@ -811,7 +813,7 @@ void create_next_audio_buffer(s16 *samples, u32 num_samples) { * Called from threads: thread4_sound, thread5_game_loop (EU only) */ static void process_sound_request(u32 bits, f32 *pos) { - //DEBUG_PRINT("process_sound_request %d\n", bits); + DEBUG_PRINT("# process_sound_request %d\n", bits); u8 bank; u8 soundIndex; u8 counter = 0; @@ -874,7 +876,7 @@ static void process_sound_request(u32 bits, f32 *pos) { // If free list has more than one element remaining if (sSoundBanks[bank][sSoundBankFreeListFront[bank]].next != 0xff && soundIndex != 0) { - //DEBUG_PRINT("process_sound_request2: soundIndex %d\n", soundIndex); + DEBUG_PRINT("process_sound_request2: soundIndex %d\n", soundIndex); // Allocate from free list soundIndex = sSoundBankFreeListFront[bank]; @@ -1333,7 +1335,7 @@ void audio_signal_game_loop_tick(void) { /** * Called from threads: thread4_sound, thread5_game_loop (EU and SH only) */ -static void update_game_sound(void) { +void update_game_sound(void) { u8 soundStatus; u8 i; u8 soundId; @@ -2628,6 +2630,7 @@ void play_toads_jingle(void) { * Called from threads: thread5_game_loop */ void sound_reset(u8 presetId) { + DEBUG_PRINT("sound_reset()"); #ifndef VERSION_JP if (presetId >= 8) { presetId = 0; @@ -2635,26 +2638,35 @@ void sound_reset(u8 presetId) { } #endif sGameLoopTicked = 0; + DEBUG_PRINT("- disable all sequence players"); disable_all_sequence_players(); + DEBUG_PRINT("- sound init"); sound_init(); #ifdef VERSION_SH func_802ad74c(0xF2000000, 0); #endif #if defined(VERSION_JP) || defined(VERSION_US) + DEBUG_PRINT("- audio reset session"); audio_reset_session(&gAudioSessionPresets[presetId]); #else audio_reset_session_eu(presetId); #endif + DEBUG_PRINT("- os write back dcache all"); osWritebackDCacheAll(); if (presetId != 7) { + DEBUG_PRINT("- preloading solve puzzle sequence"); preload_sequence(SEQ_EVENT_SOLVE_PUZZLE, PRELOAD_BANKS | PRELOAD_SEQUENCE); + DEBUG_PRINT("- preloading peach message"); preload_sequence(SEQ_EVENT_PEACH_MESSAGE, PRELOAD_BANKS | PRELOAD_SEQUENCE); + DEBUG_PRINT("- preloading star spawn"); preload_sequence(SEQ_EVENT_CUTSCENE_STAR_SPAWN, PRELOAD_BANKS | PRELOAD_SEQUENCE); } + DEBUG_PRINT("- playing sfx sequence"); seq_player_play_sequence(SEQ_PLAYER_SFX, SEQ_SOUND_PLAYER, 0); D_80332108 = (D_80332108 & 0xf0) + presetId; gSoundMode = D_80332108 >> 4; sHasStartedFadeOut = FALSE; + DEBUG_PRINT("- done resetting sound"); } /** diff --git a/src/decomp/audio/external.h b/src/decomp/audio/external.h index 53f97d2..00c6d39 100644 --- a/src/decomp/audio/external.h +++ b/src/decomp/audio/external.h @@ -24,11 +24,20 @@ extern u32 gAudioRandom; extern f32 gAudioVolume; extern u8 gAudioReverb; +struct Sound { + s32 soundBits; + f32 *position; +}; // size = 0x8 + +extern struct Sound sSoundRequests[0x100]; +extern u8 sSoundRequestCount; + extern u8 gAudioSPTaskYieldBuffer[]; // ucode yield data ptr; only used in JP struct SPTask *create_next_audio_frame_task(void); void create_next_audio_buffer(s16 *samples, u32 num_samples); void audio_signal_game_loop_tick(void); +void update_game_sound(void); void seq_player_fade_out(u8 player, u16 fadeDuration); void fade_volume_scale(u8 player, u8 targetScale, u16 fadeDuration); void seq_player_lower_volume(u8 player, u16 fadeDuration, u8 percentage); @@ -41,7 +50,6 @@ void stop_sounds_from_source(f32 *pos); void stop_sounds_in_continuous_banks(void); void sound_banks_disable(u8 player, u16 bankMask); void sound_banks_enable(u8 player, u16 bankMask); -void func_80320A4C(u8 bankIndex, u8 arg1); void set_sound_moving_speed(u8 bank, u8 speed); void play_dialog_sound(u8 dialogID); void play_music(u8 player, u16 seqArgs, u16 fadeTimer); diff --git a/src/decomp/audio/heap.c b/src/decomp/audio/heap.c index 27281d8..2ad885b 100644 --- a/src/decomp/audio/heap.c +++ b/src/decomp/audio/heap.c @@ -1,5 +1,6 @@ #include +#include "../../debug_print.h" #include "heap.h" #include "data.h" #include "load.h" @@ -252,26 +253,7 @@ void discard_sequence(s32 seqId) { } void *soundAlloc(struct SoundAllocPool *pool, u32 size) { -#if defined(VERSION_EU) || defined(VERSION_SH) - u8 *start; - u8 *pos; - u32 alignedSize = ALIGN16(size); - - start = pool->cur; - if (start + alignedSize <= pool->start + pool->size) { - pool->cur += alignedSize; - for (pos = start; pos < pool->cur; pos++) { - *pos = 0; - } - } else { - eu_stubbed_printf_1("Heap OverFlow : Not Allocate %d!\n", size); - return NULL; - } -#ifdef VERSION_SH - pool->numAllocatedEntries++; -#endif - return start; -#else + DEBUG_PRINT("soundAlloc()"); u8 *start; s32 last; s32 i; @@ -287,7 +269,6 @@ void *soundAlloc(struct SoundAllocPool *pool, u32 size) { return NULL; } return start; -#endif } #ifdef VERSION_SH diff --git a/src/decomp/audio/load.c b/src/decomp/audio/load.c index 58a2ba3..9dfe84c 100644 --- a/src/decomp/audio/load.c +++ b/src/decomp/audio/load.c @@ -1,6 +1,7 @@ #ifndef VERSION_SH #include +#include "../../debug_print.h" #include "data.h" #include "external.h" #include "heap.h" @@ -110,10 +111,17 @@ ALSeqFile *get_audio_file_header(s32 arg0); * Performs an immediate DMA copy */ void audio_dma_copy_immediate(uintptr_t devAddr, void *vAddr, size_t nbytes) { + DEBUG_PRINT("audio_dma_copy_immediate()"); + DEBUG_PRINT("- dev addr: %x", devAddr); + DEBUG_PRINT("- vAddr: %x", vAddr); + DEBUG_PRINT("- # bytes: %d", nbytes); eu_stubbed_printf_3("Romcopy %x -> %x ,size %x\n", devAddr, vAddr, nbytes); + DEBUG_PRINT("- invalidate d cache"); osInvalDCache(vAddr, nbytes); + DEBUG_PRINT("- start dma"); osPiStartDma(&gAudioDmaIoMesg, OS_MESG_PRI_HIGH, OS_READ, devAddr, vAddr, nbytes, &gAudioDmaMesgQueue); + DEBUG_PRINT("- recv message"); osRecvMesg(&gAudioDmaMesgQueue, NULL, OS_MESG_BLOCK); eu_stubbed_printf_0("Romcopyend\n"); } @@ -580,6 +588,8 @@ l2: } struct AudioBank *bank_load_immediate(s32 bankId, s32 arg1) { + DEBUG_PRINT("bank_load_immediate()"); + UNUSED u32 pad1[4]; u32 buf[4]; u32 numInstruments, numDrums; @@ -589,24 +599,35 @@ struct AudioBank *bank_load_immediate(s32 bankId, s32 arg1) { // (This is broken if the length is 1 (mod 16), but that never happens -- // it's always divisible by 4.) + DEBUG_PRINT("- getting alloc"); alloc = gAlCtlHeader->seqArray[bankId].len + 0xf; + DEBUG_PRINT("- aligning"); alloc = ALIGN16(alloc); alloc -= 0x10; + DEBUG_PRINT("- getting ctl data for bank %d", bankId); ctlData = gAlCtlHeader->seqArray[bankId].offset; + DEBUG_PRINT("- alloc bank or seq"); ret = alloc_bank_or_seq(&gBankLoadedPool, 1, alloc, arg1, bankId); if (ret == NULL) { return NULL; } + DEBUG_PRINT("- copying dma immediate 1"); + DEBUG_PRINT("- ctlData: %x", ctlData); audio_dma_copy_immediate((uintptr_t) ctlData, buf, 0x10); + DEBUG_PRINT("- getting nums"); numInstruments = buf[0]; numDrums = buf[1]; + DEBUG_PRINT("- copying dma immediate 2"); audio_dma_copy_immediate((uintptr_t)(ctlData + 0x10), ret, alloc); + DEBUG_PRINT("- patching bank"); patch_audio_bank(ret, gAlTbl->seqArray[bankId].offset, numInstruments, numDrums); + DEBUG_PRINT("- setting ctl entries"); gCtlEntries[bankId].numInstruments = (u8) numInstruments; gCtlEntries[bankId].numDrums = (u8) numDrums; gCtlEntries[bankId].instruments = ret->instruments; gCtlEntries[bankId].drums = ret->drums; + DEBUG_PRINT("- setting load status"); gBankLoadStatus[bankId] = SOUND_LOAD_STATUS_COMPLETE; return ret; } @@ -763,26 +784,32 @@ u8 get_missing_bank(u32 seqId, s32 *nonNullCount, s32 *nullCount) { } struct AudioBank *load_banks_immediate(s32 seqId, u8 *outDefaultBank) { + DEBUG_PRINT("load_banks_immediate()"); void *ret; u32 bankId; u16 offset; u8 i; + DEBUG_PRINT("- getting offset"); offset = ((u16 *) gAlBankSets)[seqId]; #ifdef VERSION_EU for (i = gAlBankSets[offset++]; i != 0; i--) { bankId = gAlBankSets[offset++]; #else offset++; + DEBUG_PRINT("- looping through bank sets"); for (i = gAlBankSets[offset - 1]; i != 0; i--) { offset++; + DEBUG_PRINT("- getting bank id"); bankId = gAlBankSets[offset - 1]; #endif + DEBUG_PRINT("- checking if bank load is complete"); if (IS_BANK_LOAD_COMPLETE(bankId) == TRUE) { #ifdef VERSION_EU ret = get_bank_or_seq(&gBankLoadedPool, 2, bankId); #else + DEBUG_PRINT("- getting bank or seq"); ret = get_bank_or_seq(&gBankLoadedPool, 2, gAlBankSets[offset - 1]); #endif } else { @@ -790,6 +817,7 @@ struct AudioBank *load_banks_immediate(s32 seqId, u8 *outDefaultBank) { } if (ret == NULL) { + DEBUG_PRINT("- bank load immediate"); ret = bank_load_immediate(bankId, 2); } } @@ -798,6 +826,7 @@ struct AudioBank *load_banks_immediate(s32 seqId, u8 *outDefaultBank) { } void preload_sequence(u32 seqId, u8 preloadMask) { + DEBUG_PRINT("preload_sequence()"); void *sequenceData; u8 temp; @@ -807,17 +836,21 @@ void preload_sequence(u32 seqId, u8 preloadMask) { gAudioLoadLock = AUDIO_LOCK_LOADING; if (preloadMask & PRELOAD_BANKS) { + DEBUG_PRINT("- load banks immediate"); load_banks_immediate(seqId, &temp); } if (preloadMask & PRELOAD_SEQUENCE) { // @bug should be IS_SEQ_LOAD_COMPLETE + DEBUG_PRINT("- checking if bank load immediate"); if (IS_BANK_LOAD_COMPLETE(seqId) == TRUE) { eu_stubbed_printf_1("SEQ %d ALREADY CACHED\n", seqId); + DEBUG_PRINT("- getting bank or seq"); sequenceData = get_bank_or_seq(&gSeqLoadedPool, 2, seqId); } else { sequenceData = NULL; } + DEBUG_PRINT("- checking dma immediate"); if (sequenceData == NULL && sequence_dma_immediate(seqId, 2) == NULL) { gAudioLoadLock = AUDIO_LOCK_NOT_LOADING; return; @@ -905,22 +938,12 @@ void load_sequence_internal(u32 player, u32 seqId, s32 loadAsync) { // (void) must be omitted from parameters to fix stack with -framepointer void audio_init() { -#if defined(VERSION_EU) - UNUSED s8 pad[16]; -#else + DEBUG_PRINT("audio_init()"); UNUSED s8 pad[32]; -#endif -#if defined(VERSION_JP) || defined(VERSION_US) u8 buf[0x10]; -#endif s32 i, j, UNUSED k; UNUSED s32 lim1; // lim1 unused in EU -#if defined(VERSION_EU) - UNUSED u8 buf[0x10]; - s32 UNUSED lim2, lim3; -#else s32 lim2, UNUSED lim3; -#endif UNUSED u32 size; UNUSED u64 *ptr64; void *data; @@ -928,57 +951,19 @@ void audio_init() { gAudioLoadLock = AUDIO_LOCK_UNINITIALIZED; -#if defined(VERSION_JP) || defined(VERSION_US) + DEBUG_PRINT("- setting values in unused"); lim1 = gUnusedCount80333EE8; for (i = 0; i < lim1; i++) { gUnused80226E58[i] = 0; gUnused80226E98[i] = 0; } + DEBUG_PRINT("- clearing audio heap"); lim2 = gAudioHeapSize; for (i = 0; i <= lim2 / 8 - 1; i++) { ((u64 *) gAudioHeap)[i] = 0; } -#ifdef TARGET_N64 - // It seems boot.s doesn't clear the .bss area for audio, so do it here. - i = 0; - lim3 = ((uintptr_t) &gAudioGlobalsEndMarker - (uintptr_t) &gAudioGlobalsStartMarker) / 8; - ptr64 = &gAudioGlobalsStartMarker - 1; - for (k = lim3; k >= 0; k--) { - i++; - ptr64[i] = 0; - } -#endif - -#else - for (i = 0; i < gAudioHeapSize / 8; i++) { - ((u64 *) gAudioHeap)[i] = 0; - } - -#ifdef TARGET_N64 - // It seems boot.s doesn't clear the .bss area for audio, so do it here. - lim3 = ((uintptr_t) &gAudioGlobalsEndMarker - (uintptr_t) &gAudioGlobalsStartMarker) / 8; - ptr64 = &gAudioGlobalsStartMarker; - for (k = lim3; k >= 0; k--) { - *ptr64++ = 0; - } -#endif - - D_EU_802298D0 = 20.03042f; - gRefreshRate = 50; - port_eu_init(); - if (k) { - } -#endif - -#ifdef TARGET_N64 - eu_stubbed_printf_3("Clear Workarea %x -%x size %x \n", - (uintptr_t) &gAudioGlobalsStartMarker, - (uintptr_t) &gAudioGlobalsEndMarker, - (uintptr_t) &gAudioGlobalsEndMarker - (uintptr_t) &gAudioGlobalsStartMarker - ); -#endif eu_stubbed_printf_1("AudioHeap is %x\n", gAudioHeapSize); @@ -1009,13 +994,7 @@ void audio_init() { } } -#if defined(VERSION_EU) - gAudioResetPresetIdToLoad = 0; - gAudioResetStatus = 1; - audio_shut_down_and_reset_step(); -#else audio_reset_session(&gAudioSessionPresets[0]); -#endif // Not sure about these prints eu_stubbed_printf_1("Heap reset.Synth Change %x \n", 0); @@ -1027,33 +1006,45 @@ void audio_init() { data = gMusicData; audio_dma_copy_immediate((uintptr_t) data, gSeqFileHeader, 0x10); gSequenceCount = gSeqFileHeader->seqCount; -#if defined(VERSION_EU) - size = gSequenceCount * sizeof(ALSeqData) + 4; - size = ALIGN16(size); -#else size = ALIGN16(gSequenceCount * sizeof(ALSeqData) + 4); -#endif gSeqFileHeader = soundAlloc(&gAudioInitPool, size); audio_dma_copy_immediate((uintptr_t) data, gSeqFileHeader, size); alSeqFileNew(gSeqFileHeader, data); // Load header for CTL (instrument metadata) + DEBUG_PRINT("- loading ctl header"); gAlCtlHeader = (ALSeqFile *) buf; data = gSoundDataADSR; + DEBUG_PRINT("- copying dma immediate"); audio_dma_copy_immediate((uintptr_t) data, gAlCtlHeader, 0x10); size = gAlCtlHeader->seqCount * sizeof(ALSeqData) + 4; + DEBUG_PRINT("- seq count: %d", gAlCtlHeader->seqCount); + DEBUG_PRINT("- size after read: %d", size); size = ALIGN16(size); + DEBUG_PRINT("- size after align: %d", size); gCtlEntries = soundAlloc(&gAudioInitPool, gAlCtlHeader->seqCount * sizeof(struct CtlEntry)); gAlCtlHeader = soundAlloc(&gAudioInitPool, size); + DEBUG_PRINT("@ copying data from sound data adsr to ctl header"); + DEBUG_PRINT("- data: %x", data); + DEBUG_PRINT("- ctl header: %x", gAlCtlHeader); + DEBUG_PRINT("- size: %d", size); audio_dma_copy_immediate((uintptr_t) data, gAlCtlHeader, size); + DEBUG_PRINT("- creating new seq file for ctl"); alSeqFileNew(gAlCtlHeader, data); // Load header for TBL (raw sound data) + DEBUG_PRINT("- loading tbl"); gAlTbl = (ALSeqFile *) buf; + DEBUG_PRINT("- copying dma"); audio_dma_copy_immediate((uintptr_t) data, gAlTbl, 0x10); + DEBUG_PRINT("- tbl seq count: %d", gAlTbl->seqCount); size = gAlTbl->seqCount * sizeof(ALSeqData) + 4; + DEBUG_PRINT("- size: %d", size); size = ALIGN16(size); + DEBUG_PRINT("- size after align: %d", size); gAlTbl = soundAlloc(&gAudioInitPool, size); + DEBUG_PRINT("- tbl alloc at %x", gAlTbl); + DEBUG_PRINT("- gSoundDataRaw at %x", gSoundDataRaw); audio_dma_copy_immediate((uintptr_t) gSoundDataRaw, gAlTbl, size); alSeqFileNew(gAlTbl, gSoundDataRaw); diff --git a/src/decomp/audio/seqplayer.c b/src/decomp/audio/seqplayer.c index 9055160..c9e95b6 100644 --- a/src/decomp/audio/seqplayer.c +++ b/src/decomp/audio/seqplayer.c @@ -6,6 +6,7 @@ #include "heap.h" #include "load.h" #include "seqplayer.h" +#include "../../debug_print.h" #define PORTAMENTO_IS_SPECIAL(x) ((x).mode & 0x80) #define PORTAMENTO_MODE(x) ((x).mode & ~0x80) @@ -398,12 +399,11 @@ void init_layer_freelist(void) { } u8 m64_read_u8(struct M64ScriptState *state) { -#if defined(VERSION_EU) || defined(VERSION_SH) - return *(state->pc++); -#else + DEBUG_PRINT("m64_read_u8()"); + DEBUG_PRINT("- state at %x", state); u8 *midiArg = state->pc++; + DEBUG_PRINT("- read u8 (%d) at (%x)", *midiArg, midiArg); return *midiArg; -#endif } s16 m64_read_s16(struct M64ScriptState *state) { @@ -1109,7 +1109,11 @@ s32 seq_channel_layer_process_script_part2(struct SequenceChannelLayer *layer) { break; case 0xc6: // layer_setinstr + DEBUG_PRINT(" - cmd 0xc6, setinstr"); + cmd = m64_read_u8(state); + DEBUG_PRINT(" - read %d from state", cmd); + if (cmd >= 0x7f) { if (cmd == 0x7f) { layer->instOrWave = 0; @@ -1401,6 +1405,9 @@ s32 seq_channel_layer_process_script_part3(struct SequenceChannelLayer *layer, s #endif u8 get_instrument(struct SequenceChannel *seqChannel, u8 instId, struct Instrument **instOut, struct AdsrSettings *adsr) { + DEBUG_PRINT("@ get_instrument()"); + DEBUG_PRINT("- instrument id: %d", instId); + struct Instrument *inst; #if defined(VERSION_EU) || defined(VERSION_SH) inst = get_instrument_inner(seqChannel->bankId, instId); @@ -1458,6 +1465,10 @@ u8 get_instrument(struct SequenceChannel *seqChannel, u8 instId, struct Instrume } void set_instrument(struct SequenceChannel *seqChannel, u8 instId) { + DEBUG_PRINT("@ set_instrument()"); + DEBUG_PRINT("- bank id: %d", seqChannel->bankId); + DEBUG_PRINT("- instrument id: %d", instId); + if (instId >= 0x80) { seqChannel->instOrWave = instId; seqChannel->instrument = NULL; @@ -1486,6 +1497,8 @@ void sequence_channel_set_volume(struct SequenceChannel *seqChannel, u8 volume) } void sequence_channel_process_script(struct SequenceChannel *seqChannel) { + DEBUG_PRINT("sequence_channel_process_script()"); + struct M64ScriptState *state; struct SequencePlayer *seqPlayer; u8 cmd; @@ -1523,6 +1536,8 @@ void sequence_channel_process_script(struct SequenceChannel *seqChannel) { if (seqChannel->delay == 0) { for (;;) { cmd = m64_read_u8(state); + DEBUG_PRINT("- handling command: %x", cmd); + #if !defined(VERSION_EU) && !defined(VERSION_SH) if (cmd == 0xff) // chan_end { @@ -1703,7 +1718,12 @@ void sequence_channel_process_script(struct SequenceChannel *seqChannel) { #endif case 0xc1: // chan_setinstr ("set program"?) - set_instrument(seqChannel, m64_read_u8(state)); + DEBUG_PRINT(" - cmd 0xc1, setinstr"); + + u8 instrId = m64_read_u8(state); + DEBUG_PRINT(" - read %d from state", instrId); + + set_instrument(seqChannel, instrId); break; case 0xc3: // chan_largenotesoff @@ -1832,25 +1852,21 @@ void sequence_channel_process_script(struct SequenceChannel *seqChannel) { break; case 0xc6: // chan_setbank; switch bank within set + DEBUG_PRINT(" - case 0xc6 - switch bank"); + + DEBUG_PRINT(" - seq id %d", seqPlayer->seqId); + cmd = m64_read_u8(state); + DEBUG_PRINT(" - backwards bank id %d", cmd); + // Switch to the temp's (0-indexed) bank in this sequence's // bank set. Note that in the binary format (not in the JSON!) // the banks are listed backwards, so we counts from the back. // (gAlBankSets[offset] is number of banks) -#if defined(VERSION_EU) || defined(VERSION_SH) - sp38 = ((u16 *) gAlBankSets)[seqPlayer->seqId]; - loBits = *(sp38 + gAlBankSets); - cmd = gAlBankSets[(s32)sp38 + loBits - cmd]; -#else sp5A = ((u16 *) gAlBankSets)[seqPlayer->seqId]; loBits = *(sp5A + gAlBankSets); cmd = gAlBankSets[sp5A + loBits - cmd]; -#endif -#ifdef VERSION_SH - if (get_bank_or_seq(1, 2, cmd) != NULL) -#else if (get_bank_or_seq(&gBankLoadedPool, 2, cmd) != NULL) -#endif { seqChannel->bankId = cmd; } else { @@ -2138,6 +2154,8 @@ void sequence_channel_process_script(struct SequenceChannel *seqChannel) { #else case 0x80: // chan_ioreadval; read data from audio lib #endif + DEBUG_PRINT("- cmd 0x80, read data from audio lib"); + DEBUG_PRINT(" - reading index: %d", loBits); value = seqChannel->soundScriptIO[loBits]; if (loBits < 4) { seqChannel->soundScriptIO[loBits] = -1; @@ -2229,7 +2247,9 @@ void sequence_channel_process_script(struct SequenceChannel *seqChannel) { } void sequence_player_process_sequence(struct SequencePlayer *seqPlayer) { - u8 cmd; + DEBUG_PRINT("sequence_player_process_sequence()"); + + u8 cmd; #ifdef VERSION_SH UNUSED u32 pad; #endif diff --git a/src/decomp/audio/synthesis.c b/src/decomp/audio/synthesis.c index 727f195..d673171 100644 --- a/src/decomp/audio/synthesis.c +++ b/src/decomp/audio/synthesis.c @@ -1,6 +1,7 @@ #ifndef VERSION_SH #include +#include "../../debug_print.h" #include "synthesis.h" #include "heap.h" #include "data.h" @@ -27,9 +28,13 @@ #define DMEM_ADDR_WET_RIGHT_CH 0x880 #define aSetLoadBufferPair(pkt, c, off) \ + DEBUG_PRINT("- (in set load buffer pair, set buffer 1) "); \ aSetBuffer(pkt, 0, c + DMEM_ADDR_WET_LEFT_CH, 0, DEFAULT_LEN_1CH - c); \ + DEBUG_PRINT("- (in set load buffer pair, load buffer 1) "); \ aLoadBuffer(pkt, VIRTUAL_TO_PHYSICAL2(gSynthesisReverb.ringBuffer.left + (off))); \ + DEBUG_PRINT("- (in set load buffer pair, set buffer 2) "); \ aSetBuffer(pkt, 0, c + DMEM_ADDR_WET_RIGHT_CH, 0, DEFAULT_LEN_1CH - c); \ + DEBUG_PRINT("- (in set load buffer pair, load buffer 2) "); \ aLoadBuffer(pkt, VIRTUAL_TO_PHYSICAL2(gSynthesisReverb.ringBuffer.right + (off))) #define aSetSaveBufferPair(pkt, c, d, off) \ @@ -324,6 +329,7 @@ u64 *synthesis_execute(u64 *cmdBuf, s32 *writtenCmds, s16 *aiBuf, s32 bufLen) { #else // bufLen will be divisible by 16 u64 *synthesis_execute(u64 *cmdBuf, s32 *writtenCmds, s16 *aiBuf, s32 bufLen) { + DEBUG_PRINT("synthesis_execute()"); s32 chunkLen; s32 i; u32 *aiBufPtr = (u32 *) aiBuf; @@ -506,6 +512,8 @@ u64 *synthesis_do_one_audio_update(s16 *aiBuf, s32 bufLen, u64 *cmd, s32 updateI } #else u64 *synthesis_do_one_audio_update(s16 *aiBuf, s32 bufLen, u64 *cmd, s32 updateIndex) { + DEBUG_PRINT("synthesis_do_one_audio_update()"); + UNUSED s32 pad1[1]; s16 ra; s16 t4; @@ -514,35 +522,52 @@ u64 *synthesis_do_one_audio_update(s16 *aiBuf, s32 bufLen, u64 *cmd, s32 updateI UNUSED s32 pad2[1]; s16 temp; + DEBUG_PRINT("- curFrame: %d", gSynthesisReverb.curFrame); + DEBUG_PRINT("- updateIndex: %d", updateIndex); + v1 = &gSynthesisReverb.items[gSynthesisReverb.curFrame][updateIndex]; + DEBUG_PRINT("- v1: %x", v1); if (gSynthesisReverb.useReverb == 0) { + DEBUG_PRINT("- w/o reverb"); aClearBuffer(cmd++, DMEM_ADDR_LEFT_CH, DEFAULT_LEN_2CH); cmd = synthesis_process_notes(aiBuf, bufLen, cmd); } else { + DEBUG_PRINT("- w/ reverb"); if (gReverbDownsampleRate == 1) { + DEBUG_PRINT("- w/ reverb downsample"); + // Put the oldest samples in the ring buffer into the wet channels + DEBUG_PRINT("- set load buffer pair 1"); + DEBUG_PRINT("- startPos: %d", v1->startPos); aSetLoadBufferPair(cmd++, 0, v1->startPos); if (v1->lengthB != 0) { // Ring buffer wrapped + DEBUG_PRINT("- set load buffer pair 2"); aSetLoadBufferPair(cmd++, v1->lengthA, 0); temp = 0; } // Use the reverb sound as initial sound for this audio update + DEBUG_PRINT("- dmem move"); aDMEMMove(cmd++, DMEM_ADDR_WET_LEFT_CH, DMEM_ADDR_LEFT_CH, DEFAULT_LEN_2CH); // (Hopefully) lower the volume of the wet channels. New reverb will later be mixed into // these channels. + DEBUG_PRINT("- set buffer"); aSetBuffer(cmd++, 0, 0, 0, DEFAULT_LEN_2CH); // 0x8000 here is -100% + DEBUG_PRINT("- mix"); aMix(cmd++, 0, /*gain*/ 0x8000 + gSynthesisReverb.reverbGain, /*in*/ DMEM_ADDR_WET_LEFT_CH, /*out*/ DMEM_ADDR_WET_LEFT_CH); } else { + DEBUG_PRINT("- w/o reverb downsample"); + // Same as above but upsample the previously downsampled samples used for reverb first temp = 0; //! jesus christ t4 = (v1->startPos & 7) * 2; ra = ALIGN(v1->lengthA + t4, 4); + DEBUG_PRINT("- set load buffer pair"); aSetLoadBufferPair(cmd++, 0, v1->startPos - t4 / 2); if (v1->lengthB != 0) { // Ring buffer wrapped @@ -553,12 +578,19 @@ u64 *synthesis_do_one_audio_update(s16 *aiBuf, s32 bufLen, u64 *cmd, s32 updateI //! useless assignment. ra = ra + temp; } + DEBUG_PRINT("- set buffer 1"); aSetBuffer(cmd++, 0, t4 + DMEM_ADDR_WET_LEFT_CH, DMEM_ADDR_LEFT_CH, bufLen << 1); + DEBUG_PRINT("- resample 1"); aResample(cmd++, gSynthesisReverb.resampleFlags, (u16) gSynthesisReverb.resampleRate, VIRTUAL_TO_PHYSICAL2(gSynthesisReverb.resampleStateLeft)); + DEBUG_PRINT("- set buffer 2"); aSetBuffer(cmd++, 0, t4 + DMEM_ADDR_WET_RIGHT_CH, DMEM_ADDR_RIGHT_CH, bufLen << 1); + DEBUG_PRINT("- resample 2"); aResample(cmd++, gSynthesisReverb.resampleFlags, (u16) gSynthesisReverb.resampleRate, VIRTUAL_TO_PHYSICAL2(gSynthesisReverb.resampleStateRight)); + DEBUG_PRINT("- set buffer 3"); aSetBuffer(cmd++, 0, 0, 0, DEFAULT_LEN_2CH); + DEBUG_PRINT("- mix"); aMix(cmd++, 0, /*gain*/ 0x8000 + gSynthesisReverb.reverbGain, /*in*/ DMEM_ADDR_LEFT_CH, /*out*/ DMEM_ADDR_LEFT_CH); + DEBUG_PRINT("- dmem move"); aDMEMMove(cmd++, DMEM_ADDR_LEFT_CH, DMEM_ADDR_WET_LEFT_CH, DEFAULT_LEN_2CH); } cmd = synthesis_process_notes(aiBuf, bufLen, cmd); @@ -586,6 +618,8 @@ u64 *synthesis_process_note(struct Note *note, struct NoteSubEu *noteSubEu, stru UNUSED s32 pad0[3]; #else u64 *synthesis_process_notes(s16 *aiBuf, s32 bufLen, u64 *cmd) { + DEBUG_PRINT("synthesis_process_notes()"); + s32 noteIndex; // sp174 struct Note *note; // s7 UNUSED u8 pad0[0x08]; @@ -669,49 +703,35 @@ u64 *synthesis_process_notes(s16 *aiBuf, s32 bufLen, u64 *cmd) { u16 noteSamplesDmemAddrBeforeResampling; // spD6, spAA -#ifndef VERSION_EU for (noteIndex = 0; noteIndex < gMaxSimultaneousNotes; noteIndex++) { + DEBUG_PRINT("- for note index %d/%d", noteIndex, gMaxSimultaneousNotes); + + DEBUG_PRINT("- getting note"); note = &gNotes[noteIndex]; -#ifdef VERSION_US + //! This function requires note->enabled to be volatile, but it breaks other functions like note_enable. //! Casting to a struct with just the volatile bitfield works, but there may be a better way to match. + DEBUG_PRINT("- if note is enabled but not loaded"); if (((struct vNote *)note)->enabled && IS_BANK_LOAD_COMPLETE(note->bankId) == FALSE) { -#else - if (IS_BANK_LOAD_COMPLETE(note->bankId) == FALSE) { -#endif + DEBUG_PRINT("- note is enabled but not loaded"); gAudioErrorFlags = (note->bankId << 8) + noteIndex + 0x1000000; - } else if (((struct vNote *)note)->enabled) { -#else - if (note->noteSubEu.enabled == FALSE) { - return cmd; - } else { -#endif - flags = 0; -#ifdef VERSION_EU - tempBufLen = bufLen; -#endif + continue; + } -#ifdef VERSION_EU - if (noteSubEu->needsInit == TRUE) { -#else + DEBUG_PRINT("- if note is enabled"); + if (((struct vNote *)note)->enabled) { + DEBUG_PRINT("$ note is enabled!"); + + flags = 0; + + DEBUG_PRINT("- if note needs to be init"); if (note->needsInit == TRUE) { -#endif flags = A_INIT; -#ifndef VERSION_EU note->samplePosInt = 0; note->samplePosFrac = 0; -#else - synthesisState->restart = FALSE; - synthesisState->samplePosInt = 0; - synthesisState->samplePosFrac = 0; - synthesisState->curVolLeft = 1; - synthesisState->curVolRight = 1; - synthesisState->prevHeadsetPanRight = 0; - synthesisState->prevHeadsetPanLeft = 0; -#endif } -#ifndef VERSION_EU + DEBUG_PRINT("- if note frequency is less than 2"); if (note->frequency < US_FLOAT(2.0)) { nParts = 1; if (note->frequency > US_FLOAT(1.99996)) { @@ -730,43 +750,29 @@ u64 *synthesis_process_notes(s16 *aiBuf, s32 bufLen, u64 *cmd) { resamplingRateFixedPoint = (u16)(s32)(resamplingRate * 32768.0f); samplesLenFixedPoint = note->samplePosFrac + (resamplingRateFixedPoint * bufLen) * 2; note->samplePosFrac = samplesLenFixedPoint & 0xFFFF; // 16-bit store, can't reuse -#else - resamplingRateFixedPoint = noteSubEu->resamplingRateFixedPoint; - nParts = noteSubEu->hasTwoAdpcmParts + 1; - samplesLenFixedPoint = (resamplingRateFixedPoint * tempBufLen * 2) + synthesisState->samplePosFrac; - synthesisState->samplePosFrac = samplesLenFixedPoint & 0xFFFF; -#endif -#ifdef VERSION_EU - if (noteSubEu->isSyntheticWave) { - cmd = load_wave_samples(cmd, noteSubEu, synthesisState, samplesLenFixedPoint >> 0x10); - noteSamplesDmemAddrBeforeResampling = (synthesisState->samplePosInt * 2) + DMEM_ADDR_UNCOMPRESSED_NOTE; - synthesisState->samplePosInt += samplesLenFixedPoint >> 0x10; - } -#else + DEBUG_PRINT("- if note sound is null"); if (note->sound == NULL) { // A wave synthesis note (not ADPCM) + DEBUG_PRINT("- note is null, do wave synthesis"); cmd = load_wave_samples(cmd, note, samplesLenFixedPoint >> 0x10); noteSamplesDmemAddrBeforeResampling = DMEM_ADDR_UNCOMPRESSED_NOTE + note->samplePosInt * 2; note->samplePosInt += (samplesLenFixedPoint >> 0x10); flags = 0; } -#endif else { // ADPCM note + DEBUG_PRINT("- @ handle adpcm note"); -#ifdef VERSION_EU - audioBookSample = noteSubEu->sound.audioBankSound->sample; -#else audioBookSample = note->sound->sample; -#endif loopInfo = audioBookSample->loop; endPos = loopInfo->end; sampleAddr = audioBookSample->sampleAddr; resampledTempLen = 0; for (curPart = 0; curPart < nParts; curPart++) { + DEBUG_PRINT("- for part %d", curPart); nAdpcmSamplesProcessed = 0; // s8 s5 = 0; // s4 @@ -782,21 +788,11 @@ u64 *synthesis_process_notes(s16 *aiBuf, s32 bufLen, u64 *cmd) { if (curLoadedBook != audioBookSample->book->book) { u32 nEntries; // v1 curLoadedBook = audioBookSample->book->book; -#ifdef VERSION_EU - nEntries = 16 * audioBookSample->book->order * audioBookSample->book->npredictors; - aLoadADPCM(cmd++, nEntries, VIRTUAL_TO_PHYSICAL2(curLoadedBook + noteSubEu->bookOffset)); -#else nEntries = audioBookSample->book->order * audioBookSample->book->npredictors; + DEBUG_PRINT("- loading adpcm"); aLoadADPCM(cmd++, nEntries * 16, VIRTUAL_TO_PHYSICAL2(curLoadedBook)); -#endif } -#ifdef VERSION_EU - if (noteSubEu->bookOffset) { - curLoadedBook = euUnknownData_80301950; // what's this? never read - } -#endif - while (nAdpcmSamplesProcessed != samplesLenAdjusted) { s32 samplesRemaining; // v1 s32 s0; @@ -804,23 +800,12 @@ u64 *synthesis_process_notes(s16 *aiBuf, s32 bufLen, u64 *cmd) { noteFinished = FALSE; restart = FALSE; nSamplesToProcess = samplesLenAdjusted - nAdpcmSamplesProcessed; -#ifdef VERSION_EU - s2 = synthesisState->samplePosInt & 0xf; - samplesRemaining = endPos - synthesisState->samplePosInt; -#else s2 = note->samplePosInt & 0xf; samplesRemaining = endPos - note->samplePosInt; -#endif -#ifdef VERSION_EU - if (s2 == 0 && synthesisState->restart == FALSE) { - s2 = 16; - } -#else if (s2 == 0 && note->restart == FALSE) { s2 = 16; } -#endif s6 = 16 - s2; // a1 if (nSamplesToProcess < samplesRemaining) { @@ -828,11 +813,7 @@ u64 *synthesis_process_notes(s16 *aiBuf, s32 bufLen, u64 *cmd) { s0 = t0 * 16; s3 = s6 + s0 - nSamplesToProcess; } else { -#ifndef VERSION_EU s0 = samplesRemaining + s2 - 0x10; -#else - s0 = samplesRemaining - s6; -#endif s3 = 0; if (s0 <= 0) { s0 = 0; @@ -848,21 +829,10 @@ u64 *synthesis_process_notes(s16 *aiBuf, s32 bufLen, u64 *cmd) { } if (t0 != 0) { -#ifdef VERSION_EU - temp = (synthesisState->samplePosInt - s2 + 0x10) / 16; - if (audioBookSample->loaded == 0x81) { - v0_2 = sampleAddr + temp * 9; - } else { - v0_2 = dma_sample_data( - (uintptr_t) (sampleAddr + temp * 9), - t0 * 9, flags, &synthesisState->sampleDmaIndex); - } -#else temp = (note->samplePosInt - s2 + 0x10) / 16; v0_2 = dma_sample_data( (uintptr_t) (sampleAddr + temp * 9), t0 * 9, flags, ¬e->sampleDmaIndex); -#endif a3 = (u32)((uintptr_t) v0_2 & 0xf); aSetBuffer(cmd++, 0, DMEM_ADDR_COMPRESSED_ADPCM_DATA, 0, t0 * 9 + a3); aLoadBuffer(cmd++, VIRTUAL_TO_PHYSICAL2(v0_2 - a3)); @@ -871,38 +841,14 @@ u64 *synthesis_process_notes(s16 *aiBuf, s32 bufLen, u64 *cmd) { a3 = 0; } -#ifdef VERSION_EU - if (synthesisState->restart != FALSE) { - aSetLoop(cmd++, VIRTUAL_TO_PHYSICAL2(audioBookSample->loop->state)); - flags = A_LOOP; // = 2 - synthesisState->restart = FALSE; - } -#else + DEBUG_PRINT("- if not note restart"); if (note->restart != FALSE) { aSetLoop(cmd++, VIRTUAL_TO_PHYSICAL2(audioBookSample->loop->state)); flags = A_LOOP; // = 2 note->restart = FALSE; } -#endif nSamplesInThisIteration = s0 + s6 - s3; -#ifdef VERSION_EU - if (nAdpcmSamplesProcessed == 0) { - aSetBuffer(cmd++, 0, DMEM_ADDR_COMPRESSED_ADPCM_DATA + a3, - DMEM_ADDR_UNCOMPRESSED_NOTE, s0 * 2); - aADPCMdec(cmd++, flags, - VIRTUAL_TO_PHYSICAL2(synthesisState->synthesisBuffers->adpcmdecState)); - sp130 = s2 * 2; - } else { - s5Aligned = ALIGN(s5, 5); - aSetBuffer(cmd++, 0, DMEM_ADDR_COMPRESSED_ADPCM_DATA + a3, - DMEM_ADDR_UNCOMPRESSED_NOTE + s5Aligned, s0 * 2); - aADPCMdec(cmd++, flags, - VIRTUAL_TO_PHYSICAL2(synthesisState->synthesisBuffers->adpcmdecState)); - aDMEMMove(cmd++, DMEM_ADDR_UNCOMPRESSED_NOTE + s5Aligned + (s2 * 2), - DMEM_ADDR_UNCOMPRESSED_NOTE + s5, (nSamplesInThisIteration) * 2); - } -#else if (nAdpcmSamplesProcessed == 0) { aSetBuffer(cmd++, 0, DMEM_ADDR_COMPRESSED_ADPCM_DATA + a3, DMEM_ADDR_UNCOMPRESSED_NOTE, s0 * 2); aADPCMdec(cmd++, flags, VIRTUAL_TO_PHYSICAL2(note->synthesisBuffers->adpcmdecState)); @@ -912,7 +858,6 @@ u64 *synthesis_process_notes(s16 *aiBuf, s32 bufLen, u64 *cmd) { aADPCMdec(cmd++, flags, VIRTUAL_TO_PHYSICAL2(note->synthesisBuffers->adpcmdecState)); aDMEMMove(cmd++, DMEM_ADDR_UNCOMPRESSED_NOTE + ALIGN(s5, 5) + (s2 * 2), DMEM_ADDR_UNCOMPRESSED_NOTE + s5, (nSamplesInThisIteration) * 2); } -#endif nAdpcmSamplesProcessed += nSamplesInThisIteration; @@ -936,35 +881,23 @@ u64 *synthesis_process_notes(s16 *aiBuf, s32 bufLen, u64 *cmd) { } flags = 0; + DEBUG_PRINT("- if note finished"); if (noteFinished) { aClearBuffer(cmd++, DMEM_ADDR_UNCOMPRESSED_NOTE + s5, (samplesLenAdjusted - nAdpcmSamplesProcessed) * 2); -#ifdef VERSION_EU - noteSubEu->finished = 1; - note->noteSubEu.finished = 1; - note->noteSubEu.enabled = 0; -#else note->samplePosInt = 0; note->finished = 1; ((struct vNote *)note)->enabled = 0; -#endif break; } -#ifdef VERSION_EU - if (restart) { - synthesisState->restart = TRUE; - synthesisState->samplePosInt = loopInfo->start; - } else { - synthesisState->samplePosInt += nSamplesToProcess; - } -#else + + DEBUG_PRINT("- if restart"); if (restart) { note->restart = TRUE; note->samplePosInt = loopInfo->start; } else { note->samplePosInt += nSamplesToProcess; } -#endif } switch (nParts) { @@ -976,18 +909,10 @@ u64 *synthesis_process_notes(s16 *aiBuf, s32 bufLen, u64 *cmd) { switch (curPart) { case 0: aSetBuffer(cmd++, 0, DMEM_ADDR_UNCOMPRESSED_NOTE + sp130, DMEM_ADDR_RESAMPLED, samplesLenAdjusted + 4); -#ifdef VERSION_EU - aResample(cmd++, A_INIT, 0xff60, VIRTUAL_TO_PHYSICAL2(synthesisState->synthesisBuffers->dummyResampleState)); -#else aResample(cmd++, A_INIT, 0xff60, VIRTUAL_TO_PHYSICAL2(note->synthesisBuffers->dummyResampleState)); -#endif resampledTempLen = samplesLenAdjusted + 4; noteSamplesDmemAddrBeforeResampling = DMEM_ADDR_RESAMPLED + 4; -#ifdef VERSION_EU - if (noteSubEu->finished != FALSE) { -#else if (note->finished != FALSE) { -#endif aClearBuffer(cmd++, DMEM_ADDR_RESAMPLED + resampledTempLen, samplesLenAdjusted + 0x10); } break; @@ -996,15 +921,9 @@ u64 *synthesis_process_notes(s16 *aiBuf, s32 bufLen, u64 *cmd) { aSetBuffer(cmd++, 0, DMEM_ADDR_UNCOMPRESSED_NOTE + sp130, DMEM_ADDR_RESAMPLED2, samplesLenAdjusted + 8); -#ifdef VERSION_EU - aResample(cmd++, A_INIT, 0xff60, - VIRTUAL_TO_PHYSICAL2( - synthesisState->synthesisBuffers->dummyResampleState)); -#else aResample(cmd++, A_INIT, 0xff60, VIRTUAL_TO_PHYSICAL2( note->synthesisBuffers->dummyResampleState)); -#endif aDMEMMove(cmd++, DMEM_ADDR_RESAMPLED2 + 4, DMEM_ADDR_RESAMPLED + resampledTempLen, samplesLenAdjusted + 4); @@ -1012,11 +931,7 @@ u64 *synthesis_process_notes(s16 *aiBuf, s32 bufLen, u64 *cmd) { } } -#ifdef VERSION_EU - if (noteSubEu->finished != FALSE) { -#else if (note->finished != FALSE) { -#endif break; } } @@ -1024,15 +939,6 @@ u64 *synthesis_process_notes(s16 *aiBuf, s32 bufLen, u64 *cmd) { flags = 0; -#ifdef VERSION_EU - if (noteSubEu->needsInit == TRUE) { - flags = A_INIT; - noteSubEu->needsInit = FALSE; - } - - cmd = final_resample(cmd, synthesisState, bufLen * 2, resamplingRateFixedPoint, - noteSamplesDmemAddrBeforeResampling, flags); -#else if (note->needsInit == TRUE) { flags = A_INIT; note->needsInit = FALSE; @@ -1040,75 +946,41 @@ u64 *synthesis_process_notes(s16 *aiBuf, s32 bufLen, u64 *cmd) { cmd = final_resample(cmd, note, bufLen * 2, resamplingRateFixedPoint, noteSamplesDmemAddrBeforeResampling, flags); -#endif -#ifdef VERSION_EU - if (noteSubEu->headsetPanRight != 0 || synthesisState->prevHeadsetPanRight != 0) { - leftRight = 1; - } else if (noteSubEu->headsetPanLeft != 0 || synthesisState->prevHeadsetPanLeft != 0) { - leftRight = 2; -#else if (note->headsetPanRight != 0 || note->prevHeadsetPanRight != 0) { leftRight = 1; } else if (note->headsetPanLeft != 0 || note->prevHeadsetPanLeft != 0) { leftRight = 2; -#endif } else { leftRight = 0; } -#ifdef VERSION_EU - cmd = process_envelope(cmd, noteSubEu, synthesisState, bufLen, 0, leftRight, flags); -#else cmd = process_envelope(cmd, note, bufLen, 0, leftRight, flags); -#endif -#ifdef VERSION_EU - if (noteSubEu->usesHeadsetPanEffects) { - cmd = note_apply_headset_pan_effects(cmd, noteSubEu, synthesisState, bufLen * 2, flags, leftRight); - } -#else if (note->usesHeadsetPanEffects) { cmd = note_apply_headset_pan_effects(cmd, note, bufLen * 2, flags, leftRight); } -#endif } -#ifndef VERSION_EU } + DEBUG_PRINT("- done handling notes"); + + DEBUG_PRINT("- setting buffer 1"); t9 = bufLen * 2; aSetBuffer(cmd++, 0, 0, DMEM_ADDR_TEMP, t9); + DEBUG_PRINT("- interleaving"); aInterleave(cmd++, DMEM_ADDR_LEFT_CH, DMEM_ADDR_RIGHT_CH); t9 *= 2; + DEBUG_PRINT("- setting buffer 2"); aSetBuffer(cmd++, 0, 0, DMEM_ADDR_TEMP, t9); + DEBUG_PRINT("- saving buffer"); aSaveBuffer(cmd++, VIRTUAL_TO_PHYSICAL2(aiBuf)); -#endif + DEBUG_PRINT("- returning from process notes"); return cmd; } -#ifdef VERSION_EU -u64 *load_wave_samples(u64 *cmd, struct NoteSubEu *noteSubEu, struct NoteSynthesisState *synthesisState, s32 nSamplesToLoad) { - s32 a3; - s32 repeats; - s32 i; - aSetBuffer(cmd++, /*flags*/ 0, /*dmemin*/ DMEM_ADDR_UNCOMPRESSED_NOTE, /*dmemout*/ 0, /*count*/ 128); - aLoadBuffer(cmd++, VIRTUAL_TO_PHYSICAL2(noteSubEu->sound.samples)); - synthesisState->samplePosInt &= 0x3f; - a3 = 64 - synthesisState->samplePosInt; - if (a3 < nSamplesToLoad) { - repeats = (nSamplesToLoad - a3 + 63) / 64; - for (i = 0; i < repeats; i++) { - aDMEMMove(cmd++, - /*dmemin*/ DMEM_ADDR_UNCOMPRESSED_NOTE, - /*dmemout*/ DMEM_ADDR_UNCOMPRESSED_NOTE + (1 + i) * 128, - /*count*/ 128); - } - } - return cmd; -} -#else u64 *load_wave_samples(u64 *cmd, struct Note *note, s32 nSamplesToLoad) { s32 a3; s32 i; @@ -1124,21 +996,12 @@ u64 *load_wave_samples(u64 *cmd, struct Note *note, s32 nSamplesToLoad) { } return cmd; } -#endif -#ifdef VERSION_EU -u64 *final_resample(u64 *cmd, struct NoteSynthesisState *synthesisState, s32 count, u16 pitch, u16 dmemIn, u32 flags) { - aSetBuffer(cmd++, /*flags*/ 0, dmemIn, /*dmemout*/ DMEM_ADDR_TEMP, count); - aResample(cmd++, flags, pitch, VIRTUAL_TO_PHYSICAL2(synthesisState->synthesisBuffers->finalResampleState)); - return cmd; -} -#else u64 *final_resample(u64 *cmd, struct Note *note, s32 count, u16 pitch, u16 dmemIn, u32 flags) { aSetBuffer(cmd++, /*flags*/ 0, dmemIn, /*dmemout*/ DMEM_ADDR_TEMP, count); aResample(cmd++, flags, pitch, VIRTUAL_TO_PHYSICAL2(note->synthesisBuffers->finalResampleState)); return cmd; } -#endif #ifndef VERSION_EU u64 *process_envelope(u64 *cmd, struct Note *note, s32 nSamples, u16 inBuf, s32 headsetPanSettings, diff --git a/src/decomp/include/PR/abi.h b/src/decomp/include/PR/abi.h index b73cb72..b4b2f84 100644 --- a/src/decomp/include/PR/abi.h +++ b/src/decomp/include/PR/abi.h @@ -439,10 +439,14 @@ typedef short ENVMIX_STATE[40]; * s parameter to this command is the source in DRAM. */ #define aLoadBuffer(pkt, s) \ -{ \ +{ \ + DEBUG_PRINT("aLoadBuffer()"); \ + DEBUG_PRINT("- getting pkt"); \ Acmd *_a = (Acmd *)pkt; \ \ + DEBUG_PRINT("- setting first word"); \ _a->words.w0 = _SHIFTL(A_LOADBUFF, 24, 8); \ + DEBUG_PRINT("- setting second word"); \ _a->words.w1 = (uintptr_t)(s); \ } @@ -558,6 +562,8 @@ typedef short ENVMIX_STATE[40]; */ #define aSetBuffer(pkt, f, i, o, c) \ { \ + DEBUG_PRINT("aSetBuffer()"); \ + DEBUG_PRINT("- getting pkt"); \ Acmd *_a = (Acmd *)pkt; \ \ _a->words.w0 = (_SHIFTL(A_SETBUFF, 24, 8) | _SHIFTL(f, 16, 8) | \ diff --git a/src/decomp/include/PR/libaudio.h b/src/decomp/include/PR/libaudio.h index cb7a5b1..81d1c18 100644 --- a/src/decomp/include/PR/libaudio.h +++ b/src/decomp/include/PR/libaudio.h @@ -2,49 +2,21 @@ #define _ULTRA64_LIBAUDIO_H_ #include "abi.h" +#include typedef struct { - u8 *offset; - s32 len; -#ifdef VERSION_SH - s8 medium; - s8 magic; // tbl: 0x04, otherwise: 0x03 - - // for ctl (else zeros): - union { - // unused, just for clarification (big endian) - struct { - u8 bank; - u8 ff; - u8 numInstruments; - u8 numDrums; - } as_u8; - - // used - struct { - s16 bankAndFf; - s16 numInstrumentsAndDrums; - } as_s16; - } ctl; -#endif + u8 *offset __attribute__((aligned (8))); + s32 len __attribute__((aligned (8))); } ALSeqData; typedef struct { -#ifndef VERSION_SH - s16 revision; -#endif - s16 seqCount; -#ifdef VERSION_SH - s16 unk2; - u8 *data; -#if !IS_64_BIT - s32 pad[2]; -#endif -#endif + unsigned short revision; + unsigned short seqCount; + unsigned int pad; ALSeqData seqArray[1]; -} ALSeqFile; +} __attribute__((aligned (16))) ALSeqFile; void alSeqFileNew(ALSeqFile *f, u8 *base); diff --git a/src/decomp/include/platform_info.h b/src/decomp/include/platform_info.h index 310aa4d..f8ccbe2 100644 --- a/src/decomp/include/platform_info.h +++ b/src/decomp/include/platform_info.h @@ -10,6 +10,6 @@ #define IS_BIG_ENDIAN (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) #endif -#define DOUBLE_SIZE_ON_64_BIT(size) ((size) * (sizeof(void *) / 4)) +#define DOUBLE_SIZE_ON_64_BIT(size) ((size) * 2) #endif // PLATFORM_INFO_H diff --git a/src/decomp/pc/alBnkfNew.c b/src/decomp/pc/alBnkfNew.c index bb04df3..fa003b1 100644 --- a/src/decomp/pc/alBnkfNew.c +++ b/src/decomp/pc/alBnkfNew.c @@ -1,12 +1,19 @@ #include "libultra_internal.h" #include "libaudio_internal.h" +#include "../../debug_print.h" + #define PATCH(SRC, BASE, TYPE) //SRC = (TYPE)((uintptr_t) SRC + (uintptr_t) BASE) void alSeqFileNew(ALSeqFile *f, u8 *base) { + DEBUG_PRINT("alSeqFileNew()"); int i; + DEBUG_PRINT("- patching %d entries", f->seqCount); for (i = 0; i < f->seqCount; i++) { + DEBUG_PRINT("- handling entry %d", i); + DEBUG_PRINT("- patching offset (%x) with base (%x)", f->seqArray[i].offset, base); PATCH(f->seqArray[i].offset, base, u8 *); + DEBUG_PRINT("- result is (%x)", f->seqArray[i].offset); } } diff --git a/src/decomp/pc/mixer.c b/src/decomp/pc/mixer.c index 62d2cbb..8c53ad4 100644 --- a/src/decomp/pc/mixer.c +++ b/src/decomp/pc/mixer.c @@ -4,6 +4,7 @@ #include #include "mixer.h" +#include "../../debug_print.h" #ifdef __SSE4_1__ #include @@ -147,6 +148,8 @@ void aSaveBufferImpl(uint16_t source_addr, int16_t *dest_addr, uint16_t nbytes) } #else void aLoadBufferImpl(const void *source_addr) { + DEBUG_PRINT("aLoadBufferImpl()"); + DEBUG_PRINT("- source_addr: %x", source_addr); memcpy(BUF_U8(rspa.in), source_addr, ROUND_UP_8(rspa.nbytes)); } diff --git a/src/decomp/tools/convUtils.c b/src/decomp/tools/convUtils.c index 5ee21f4..d9b3794 100644 --- a/src/decomp/tools/convUtils.c +++ b/src/decomp/tools/convUtils.c @@ -1,6 +1,7 @@ #pragma once #include "convUtils.h" +#include "../../debug_print.h" #include "utils.h" #include #include @@ -21,6 +22,8 @@ unsigned char* gCtlSeqs; struct seqFile* parse_seqfile(unsigned char* seq){ /* Read SeqFile data */ + DEBUG_PRINT("parse_seqfile()"); + short revision = read_u16_be(seq); short bankCount = read_u16_be(seq + 2); @@ -34,14 +37,20 @@ struct seqFile* parse_seqfile(unsigned char* seq){ /* Read SeqFile data */ seqFile->seqArray[i].len = read_u32_be((seq + 4 + i * 8 + 4)); } + DEBUG_PRINT("- revision: %d", revision); if (revision == TYPE_CTL){ + DEBUG_PRINT("- ctl!"); // CTL file, contains instrument and drum data, this is really the only one that needs to be parsed, the rest only needs a header change gCtlSeqs = (unsigned char*)calloc(0x20B40, 1); // We only really need 0x20AD0 bytes but still uintptr_t pos = (uintptr_t)gCtlSeqs; + DEBUG_PRINT("- bank count: %d", bankCount); for (int i = 0; i < bankCount; i++){ + DEBUG_PRINT("- ctl bank index: %d", i); uintptr_t start = pos; struct CTL* ptr = parse_ctl_data(seq+(seqFile->seqArray[i].offset), &pos); + DEBUG_PRINT("- read ptr: %x", ptr); seqFile->seqArray[i].offset = ptr; + DEBUG_PRINT("- stored offset: %x", seqFile->seqArray[i].offset); seqFile->seqArray[i].len = (unsigned int)(pos - start); } }else if (revision == TYPE_TBL){ @@ -247,6 +256,9 @@ struct SEQ* parse_seq_data(unsigned char* seq){ } struct CTL* parse_ctl_data(unsigned char* ctlData, uintptr_t* pos){ + DEBUG_PRINT("parse_ctl_data()"); + DEBUG_PRINT("- ctlData: %x", ctlData); + DEBUG_PRINT("- pos: %x", pos); int instruments=read_u32_be(ctlData); unsigned int size = sizeof(struct CTL) + sizeof(struct CInstrument*) * (instruments-1); struct CTL* ctl = (struct CTL*)(*pos); diff --git a/src/libsm64.c b/src/libsm64.c index dd8c15d..5157113 100644 --- a/src/libsm64.c +++ b/src/libsm64.c @@ -10,6 +10,7 @@ #include #include +#include "decomp/audio/external.h" #include "decomp/include/PR/os_cont.h" #include "decomp/engine/math_util.h" #include "decomp/include/sm64.h" @@ -135,8 +136,27 @@ SM64_LIB_FN void sm64_global_terminate( void ) memory_terminate(); } -SM64_LIB_FN struct AudioBanks sm64_asset_load_audio_banks( uint8_t *rom ) { - return load_audio_banks( rom ); +SM64_LIB_FN void sm64_audio_init( uint8_t *rom ) { + load_audio_banks( rom ); +} + +#define SAMPLES_HIGH 544 +#define SAMPLES_LOW 528 + +extern SM64_LIB_FN uint32_t sm64_audio_tick( uint32_t numQueuedSamples, uint32_t numDesiredSamples, int16_t *audio_buffer ) { + DEBUG_PRINT("sm64_tick_audio()"); + + DEBUG_PRINT("- update game sound"); + update_game_sound(); + + DEBUG_PRINT("- create next audio buffer"); + u32 num_audio_samples = numQueuedSamples < numDesiredSamples ? SAMPLES_HIGH : SAMPLES_LOW; + for (int i = 0; i < 2; i++) + { + create_next_audio_buffer(audio_buffer + i * (2 * num_audio_samples), num_audio_samples); + } + + return num_audio_samples; } SM64_LIB_FN void sm64_static_surfaces_load( const struct SM64Surface *surfaceArray, uint32_t numSurfaces ) diff --git a/src/libsm64.h b/src/libsm64.h index 53ac004..0a7d902 100644 --- a/src/libsm64.h +++ b/src/libsm64.h @@ -80,7 +80,8 @@ extern SM64_LIB_FN void sm64_register_play_sound_function( SM64PlaySoundFunction extern SM64_LIB_FN void sm64_global_init( uint8_t *rom, uint8_t *outTexture ); extern SM64_LIB_FN void sm64_global_terminate( void ); -extern SM64_LIB_FN struct AudioBanks sm64_asset_load_audio_banks( uint8_t *rom ); +extern SM64_LIB_FN void sm64_audio_init( uint8_t *rom ); +extern SM64_LIB_FN uint32_t sm64_audio_tick( uint32_t numQueuedSamples, uint32_t numDesiredSamples, int16_t *audio_buffer ); extern SM64_LIB_FN void sm64_static_surfaces_load( const struct SM64Surface *surfaceArray, uint32_t numSurfaces ); diff --git a/src/load_audio_data.c b/src/load_audio_data.c index efa500c..b8c1363 100644 --- a/src/load_audio_data.c +++ b/src/load_audio_data.c @@ -1,32 +1,36 @@ #include "load_audio_data.h" +#include "debug_print.h" #include "decomp/tools/convUtils.h" #include "decomp/audio/load.h" #include "decomp/audio/load_dat.h" -extern struct AudioBanks load_audio_banks( uint8_t *rom ) { +extern void load_audio_banks( uint8_t *rom ) { + DEBUG_PRINT("load_audio_banks()"); + DEBUG_PRINT("- malloc"); uint8_t *rom2 = malloc(0x800000); + DEBUG_PRINT("- memcpy"); memcpy(rom2, rom, 0x800000); rom = rom2; + DEBUG_PRINT("- parse ctl"); gSoundDataADSR = parse_seqfile(rom+0x57B720); //ctl + DEBUG_PRINT("- parse tbl"); gSoundDataRaw = parse_seqfile(rom+0x593560); //tbl + DEBUG_PRINT("- parse music"); gMusicData = parse_seqfile(rom+0x7B0860); gBankSetsData = rom+0x7CC621; + DEBUG_PRINT("- memmove"); memmove(gBankSetsData+0x45,gBankSetsData+0x45-1,0x5B); gBankSetsData[0x45]=0x00; + DEBUG_PRINT("- ptrs to offsets"); ptrs_to_offsets(gSoundDataADSR); - audio_init(); - - int numBanks = 10; - for (int i = 0; i < 10; ++i) { - bank_load_immediate(i, 2); - } - - struct AudioBanks audioBanks; - audioBanks.numCtlEntries = numBanks; - audioBanks.ctlEntries = gCtlEntries; - - return audioBanks; + DEBUG_PRINT("- audio init"); + audio_init(); + DEBUG_PRINT("- sound init"); + sound_init(); + DEBUG_PRINT("- sound reset"); + sound_reset(0); + DEBUG_PRINT("- done with audio init!"); } \ No newline at end of file diff --git a/src/load_audio_data.h b/src/load_audio_data.h index 90b99c8..6d9c537 100644 --- a/src/load_audio_data.h +++ b/src/load_audio_data.h @@ -2,9 +2,4 @@ #include -struct AudioBanks { - int numCtlEntries; - struct CtlEntry * ctlEntries; -}; - -extern struct AudioBanks load_audio_banks( uint8_t *rom ); \ No newline at end of file +extern void load_audio_banks( uint8_t *rom ); \ No newline at end of file diff --git a/src/play_sound.c b/src/play_sound.c index 0560ba3..10efbd1 100644 --- a/src/play_sound.c +++ b/src/play_sound.c @@ -1,8 +1,16 @@ #include "play_sound.h" +#include "decomp/audio/external.h" +#include "debug_print.h" + SM64PlaySoundFunctionPtr g_play_sound_func = NULL; extern void play_sound( uint32_t soundBits, f32 *pos ) { + DEBUG_PRINT("$ play_sound(%d) request %d; pos %f %f %f\n", soundBits,sSoundRequestCount,pos[0],pos[1],pos[2]); + sSoundRequests[sSoundRequestCount].soundBits = soundBits; + sSoundRequests[sSoundRequestCount].position = pos; + sSoundRequestCount++; + if ( g_play_sound_func ) { g_play_sound_func(soundBits, pos); } From 3937c6176524d9316b1390471771982597dec977 Mon Sep 17 00:00:00 2001 From: MeltyPlayer Date: Tue, 6 Dec 2022 16:55:39 -0600 Subject: [PATCH 11/16] Removed a ton of DEBUG_PRINT statements. --- src/decomp/audio/external.c | 18 ------------------ src/decomp/audio/heap.c | 2 -- src/libsm64.c | 4 ---- src/load_audio_data.c | 13 ------------- 4 files changed, 37 deletions(-) diff --git a/src/decomp/audio/external.c b/src/decomp/audio/external.c index a2222d7..0d525cd 100644 --- a/src/decomp/audio/external.c +++ b/src/decomp/audio/external.c @@ -658,11 +658,7 @@ extern void func_sh_802F64C8(void); * Called from threads: thread5_game_loop */ void maybe_tick_game_sound(void) { - DEBUG_PRINT("maybe_tick_game_sound()"); - - DEBUG_PRINT("- if game loop ticked is false..."); if (sGameLoopTicked != 0) { - DEBUG_PRINT("- updating game sound"); update_game_sound(); sGameLoopTicked = 0; } @@ -793,17 +789,14 @@ struct SPTask *create_next_audio_frame_task(void) { return NULL; } void create_next_audio_buffer(s16 *samples, u32 num_samples) { - DEBUG_PRINT("create_next_audio_buffer()"); gAudioFrameCount++; if (sGameLoopTicked != 0) { update_game_sound(); sGameLoopTicked = 0; } s32 writtenCmds; - DEBUG_PRINT("- synthesis execute"); synthesis_execute(gAudioCmdBuffers[0], &writtenCmds, samples, num_samples); gAudioRandom = ((gAudioRandom + gAudioFrameCount) * gAudioFrameCount); - DEBUG_PRINT("- decrease sample dma ttls"); decrease_sample_dma_ttls(); } #endif @@ -813,7 +806,6 @@ void create_next_audio_buffer(s16 *samples, u32 num_samples) { * Called from threads: thread4_sound, thread5_game_loop (EU only) */ static void process_sound_request(u32 bits, f32 *pos) { - DEBUG_PRINT("# process_sound_request %d\n", bits); u8 bank; u8 soundIndex; u8 counter = 0; @@ -2630,7 +2622,6 @@ void play_toads_jingle(void) { * Called from threads: thread5_game_loop */ void sound_reset(u8 presetId) { - DEBUG_PRINT("sound_reset()"); #ifndef VERSION_JP if (presetId >= 8) { presetId = 0; @@ -2638,35 +2629,26 @@ void sound_reset(u8 presetId) { } #endif sGameLoopTicked = 0; - DEBUG_PRINT("- disable all sequence players"); disable_all_sequence_players(); - DEBUG_PRINT("- sound init"); sound_init(); #ifdef VERSION_SH func_802ad74c(0xF2000000, 0); #endif #if defined(VERSION_JP) || defined(VERSION_US) - DEBUG_PRINT("- audio reset session"); audio_reset_session(&gAudioSessionPresets[presetId]); #else audio_reset_session_eu(presetId); #endif - DEBUG_PRINT("- os write back dcache all"); osWritebackDCacheAll(); if (presetId != 7) { - DEBUG_PRINT("- preloading solve puzzle sequence"); preload_sequence(SEQ_EVENT_SOLVE_PUZZLE, PRELOAD_BANKS | PRELOAD_SEQUENCE); - DEBUG_PRINT("- preloading peach message"); preload_sequence(SEQ_EVENT_PEACH_MESSAGE, PRELOAD_BANKS | PRELOAD_SEQUENCE); - DEBUG_PRINT("- preloading star spawn"); preload_sequence(SEQ_EVENT_CUTSCENE_STAR_SPAWN, PRELOAD_BANKS | PRELOAD_SEQUENCE); } - DEBUG_PRINT("- playing sfx sequence"); seq_player_play_sequence(SEQ_PLAYER_SFX, SEQ_SOUND_PLAYER, 0); D_80332108 = (D_80332108 & 0xf0) + presetId; gSoundMode = D_80332108 >> 4; sHasStartedFadeOut = FALSE; - DEBUG_PRINT("- done resetting sound"); } /** diff --git a/src/decomp/audio/heap.c b/src/decomp/audio/heap.c index 2ad885b..c11c24c 100644 --- a/src/decomp/audio/heap.c +++ b/src/decomp/audio/heap.c @@ -1,6 +1,5 @@ #include -#include "../../debug_print.h" #include "heap.h" #include "data.h" #include "load.h" @@ -253,7 +252,6 @@ void discard_sequence(s32 seqId) { } void *soundAlloc(struct SoundAllocPool *pool, u32 size) { - DEBUG_PRINT("soundAlloc()"); u8 *start; s32 last; s32 i; diff --git a/src/libsm64.c b/src/libsm64.c index 5157113..8a40bc7 100644 --- a/src/libsm64.c +++ b/src/libsm64.c @@ -144,12 +144,8 @@ SM64_LIB_FN void sm64_audio_init( uint8_t *rom ) { #define SAMPLES_LOW 528 extern SM64_LIB_FN uint32_t sm64_audio_tick( uint32_t numQueuedSamples, uint32_t numDesiredSamples, int16_t *audio_buffer ) { - DEBUG_PRINT("sm64_tick_audio()"); - - DEBUG_PRINT("- update game sound"); update_game_sound(); - DEBUG_PRINT("- create next audio buffer"); u32 num_audio_samples = numQueuedSamples < numDesiredSamples ? SAMPLES_HIGH : SAMPLES_LOW; for (int i = 0; i < 2; i++) { diff --git a/src/load_audio_data.c b/src/load_audio_data.c index b8c1363..d860d3e 100644 --- a/src/load_audio_data.c +++ b/src/load_audio_data.c @@ -1,36 +1,23 @@ #include "load_audio_data.h" -#include "debug_print.h" #include "decomp/tools/convUtils.h" #include "decomp/audio/load.h" #include "decomp/audio/load_dat.h" extern void load_audio_banks( uint8_t *rom ) { - DEBUG_PRINT("load_audio_banks()"); - DEBUG_PRINT("- malloc"); uint8_t *rom2 = malloc(0x800000); - DEBUG_PRINT("- memcpy"); memcpy(rom2, rom, 0x800000); rom = rom2; - DEBUG_PRINT("- parse ctl"); gSoundDataADSR = parse_seqfile(rom+0x57B720); //ctl - DEBUG_PRINT("- parse tbl"); gSoundDataRaw = parse_seqfile(rom+0x593560); //tbl - DEBUG_PRINT("- parse music"); gMusicData = parse_seqfile(rom+0x7B0860); gBankSetsData = rom+0x7CC621; - DEBUG_PRINT("- memmove"); memmove(gBankSetsData+0x45,gBankSetsData+0x45-1,0x5B); gBankSetsData[0x45]=0x00; - DEBUG_PRINT("- ptrs to offsets"); ptrs_to_offsets(gSoundDataADSR); - DEBUG_PRINT("- audio init"); audio_init(); - DEBUG_PRINT("- sound init"); sound_init(); - DEBUG_PRINT("- sound reset"); sound_reset(0); - DEBUG_PRINT("- done with audio init!"); } \ No newline at end of file From 5faeaff90829f1c1dff359ab06c36909691e173f Mon Sep 17 00:00:00 2001 From: MeltyPlayer Date: Tue, 6 Dec 2022 17:07:14 -0600 Subject: [PATCH 12/16] Removed some more DEBUG_PRINT statements and fixed padding. --- src/decomp/tools/convUtils.c | 362 +++++++++++++++++------------------ src/libsm64.c | 10 +- src/load_audio_data.c | 28 +-- src/play_sound.c | 16 +- 4 files changed, 202 insertions(+), 214 deletions(-) diff --git a/src/decomp/tools/convUtils.c b/src/decomp/tools/convUtils.c index d9b3794..fa67888 100644 --- a/src/decomp/tools/convUtils.c +++ b/src/decomp/tools/convUtils.c @@ -1,7 +1,6 @@ #pragma once #include "convUtils.h" -#include "../../debug_print.h" #include "utils.h" #include #include @@ -22,13 +21,11 @@ unsigned char* gCtlSeqs; struct seqFile* parse_seqfile(unsigned char* seq){ /* Read SeqFile data */ - DEBUG_PRINT("parse_seqfile()"); - short revision = read_u16_be(seq); short bankCount = read_u16_be(seq + 2); - - unsigned int size = sizeof(struct seqFile) + (bankCount-1) * sizeof(struct seqObject); - + + unsigned int size = sizeof(struct seqFile) + (bankCount-1) * sizeof(struct seqObject); + struct seqFile* seqFile = (struct seqFile*)calloc(size, 1); seqFile->revision = revision; seqFile->seqCount = bankCount; @@ -37,21 +34,15 @@ struct seqFile* parse_seqfile(unsigned char* seq){ /* Read SeqFile data */ seqFile->seqArray[i].len = read_u32_be((seq + 4 + i * 8 + 4)); } - DEBUG_PRINT("- revision: %d", revision); if (revision == TYPE_CTL){ - DEBUG_PRINT("- ctl!"); // CTL file, contains instrument and drum data, this is really the only one that needs to be parsed, the rest only needs a header change - gCtlSeqs = (unsigned char*)calloc(0x20B40, 1); // We only really need 0x20AD0 bytes but still - uintptr_t pos = (uintptr_t)gCtlSeqs; - DEBUG_PRINT("- bank count: %d", bankCount); - for (int i = 0; i < bankCount; i++){ - DEBUG_PRINT("- ctl bank index: %d", i); - uintptr_t start = pos; + gCtlSeqs = (unsigned char*)calloc(0x20B40, 1); // We only really need 0x20AD0 bytes but still + uintptr_t pos = (uintptr_t)gCtlSeqs; + for (int i = 0; i < bankCount; i++){ + uintptr_t start = pos; struct CTL* ptr = parse_ctl_data(seq+(seqFile->seqArray[i].offset), &pos); - DEBUG_PRINT("- read ptr: %x", ptr); seqFile->seqArray[i].offset = ptr; - DEBUG_PRINT("- stored offset: %x", seqFile->seqArray[i].offset); - seqFile->seqArray[i].len = (unsigned int)(pos - start); + seqFile->seqArray[i].len = (unsigned int)(pos - start); } }else if (revision == TYPE_TBL){ // TBL file, contains raw audio data @@ -69,32 +60,32 @@ struct seqFile* parse_seqfile(unsigned char* seq){ /* Read SeqFile data */ } void ctl_free(){ - free(gCtlSeqs); + free(gCtlSeqs); } void snd_ptrs_to_offsets(struct CSound* snd, uintptr_t ctlData){ - struct CSample* smp = snd->sample_addr; - if((uintptr_t)(smp->loop) > ctlData) - smp->loop = (struct CLoop*)((uintptr_t)(smp->loop) - ctlData); - if((uintptr_t)(smp->book) > ctlData) - smp->book = (struct CBook*)((uintptr_t)(smp->book) - ctlData); - snd->sample_addr = (struct CSample*)((uintptr_t)(snd->sample_addr) - ctlData); + struct CSample* smp = snd->sample_addr; + if((uintptr_t)(smp->loop) > ctlData) + smp->loop = (struct CLoop*)((uintptr_t)(smp->loop) - ctlData); + if((uintptr_t)(smp->book) > ctlData) + smp->book = (struct CBook*)((uintptr_t)(smp->book) - ctlData); + snd->sample_addr = (struct CSample*)((uintptr_t)(snd->sample_addr) - ctlData); } void ptrs_to_offsets(struct seqFile* ctl){ - if (ctl->revision != TYPE_CTL){ + if (ctl->revision != TYPE_CTL){ return; } - for (int i = 0; i < ctl->seqCount; i++){ + for (int i = 0; i < ctl->seqCount; i++){ struct CTL* ptr = (struct CTL*)ctl->seqArray[i].offset; - uintptr_t ctlData = (uintptr_t)ptr + 0x10; + uintptr_t ctlData = (uintptr_t)ptr + 0x10; // find all samples in the CTL file for (int j = 0; j < ptr->numInstruments; j++){ struct CInstrument* inst = ptr->instrument_pointers[j]; if (inst==0x0) continue; // null instrument. - inst->env_addr = (struct CEnvelope*)((uintptr_t)inst->env_addr - ctlData); + inst->env_addr = (struct CEnvelope*)((uintptr_t)inst->env_addr - ctlData); if (inst->sound_hi.sample_addr!=0x0){ snd_ptrs_to_offsets(&(inst->sound_hi), ctlData); } @@ -104,38 +95,38 @@ void ptrs_to_offsets(struct seqFile* ctl){ if (inst->sound_lo.sample_addr!=0x0){ snd_ptrs_to_offsets(&(inst->sound_lo), ctlData); } - ptr->instrument_pointers[j] = (struct CInstrument*)((uintptr_t)(inst) - ctlData); + ptr->instrument_pointers[j] = (struct CInstrument*)((uintptr_t)(inst) - ctlData); + } + if(ptr->numDrums != 0){ + for (int j = 0; j < ptr->numDrums; j++){ + struct CDrum* drum = ptr->drum_pointers[j]; + if (drum==0x0) + continue; // null drum. + drum->env_addr = (struct CEnvelope*)((uintptr_t)drum->env_addr - ctlData); + if (drum->snd.sample_addr!=0x0){ + snd_ptrs_to_offsets(&(drum->snd), ctlData); + } + ptr->drum_pointers[j] = (struct CDrum*)((uintptr_t)(drum) - ctlData); + } + ptr->drum_pointers = (struct CDrum**)((uintptr_t)(ptr->drum_pointers) - ctlData); } - if(ptr->numDrums != 0){ - for (int j = 0; j < ptr->numDrums; j++){ - struct CDrum* drum = ptr->drum_pointers[j]; - if (drum==0x0) - continue; // null drum. - drum->env_addr = (struct CEnvelope*)((uintptr_t)drum->env_addr - ctlData); - if (drum->snd.sample_addr!=0x0){ - snd_ptrs_to_offsets(&(drum->snd), ctlData); - } - ptr->drum_pointers[j] = (struct CDrum*)((uintptr_t)(drum) - ctlData); - } - ptr->drum_pointers = (struct CDrum**)((uintptr_t)(ptr->drum_pointers) - ctlData); - } } } struct CLoop* parse_loop(unsigned char* loop, uintptr_t* pos){ - uint32_t count = read_u32_be(loop + 8); // variable is signed, but the data is being read as unsigned. - unsigned int size = sizeof(struct CLoop) - 4; - if(count != 0){ - size = sizeof(struct CLoop) - 4 + sizeof(short) * 16; - } - struct CLoop* loop_ptr = (struct CLoop*)(*pos); - *pos += size; - *pos = ALIGN16(*pos); - + uint32_t count = read_u32_be(loop + 8); // variable is signed, but the data is being read as unsigned. + unsigned int size = sizeof(struct CLoop) - 4; + if(count != 0){ + size = sizeof(struct CLoop) - 4 + sizeof(short) * 16; + } + struct CLoop* loop_ptr = (struct CLoop*)(*pos); + *pos += size; + *pos = ALIGN16(*pos); + loop_ptr->start = read_u32_be(loop); loop_ptr->end = read_u32_be(loop + 4); loop_ptr->count = count; - loop_ptr->pad = read_u32_be(loop + 12); + loop_ptr->pad = read_u32_be(loop + 12); if (loop_ptr->count!=0){ for (int i = 0;i<16;i++){ @@ -147,9 +138,9 @@ struct CLoop* parse_loop(unsigned char* loop, uintptr_t* pos){ } struct CBook* parse_book(unsigned char* book, uintptr_t* pos){ - struct CBook* book_ptr = (struct CBook*)(*pos); - *pos += sizeof(struct CBook); - *pos = ALIGN16(*pos); + struct CBook* book_ptr = (struct CBook*)(*pos); + *pos += sizeof(struct CBook); + *pos = ALIGN16(*pos); book_ptr->order = read_u32_be(book); book_ptr->npredictors = read_u32_be(book + 4); // both are signed unsigned char* table_data = book+8; @@ -160,41 +151,41 @@ struct CBook* parse_book(unsigned char* book, uintptr_t* pos){ } struct CSample* parse_sample(unsigned char* sample,unsigned char* ctl, uintptr_t* pos){ - struct CSample* samp = (struct CSample*)(*pos); - *pos += sizeof(struct CSample); - *pos = ALIGN16(*pos); + struct CSample* samp = (struct CSample*)(*pos); + *pos += sizeof(struct CSample); + *pos = ALIGN16(*pos); samp->zero=read_u32_be(sample); samp->addr=read_u32_be(sample+4); samp->loop=read_u32_be(sample+8);// loop address samp->book=read_u32_be(sample+12);// book address samp->sample_size=read_u32_be(sample+16); - samp->book=parse_book(ctl+((uintptr_t)samp->book), pos); + samp->book=parse_book(ctl+((uintptr_t)samp->book), pos); samp->loop=parse_loop(ctl+((uintptr_t)samp->loop), pos); return samp; } struct CSound* parse_sound(unsigned char* sound,unsigned char* ctl, uintptr_t* pos, uintptr_t sndPos, struct SampleList* samples){ - struct CSound* snd = (struct CSound*)(sndPos); + struct CSound* snd = (struct CSound*)(sndPos); snd->sample_addr=read_u32_be(sound); snd->tuning = (float)read_f32_be(sound+4); // if sample_addr is 0 then the sound is null if (snd->sample_addr!=0){ - int smpIndex = -1; - for(int i = 0; i < samples->count; i++){ - if(samples->orig_addrs[i] == (uintptr_t)(snd->sample_addr)){ - smpIndex = i; - break; - } - } - if(smpIndex < 0){ - samples->orig_addrs[samples->count] = (uintptr_t)(snd->sample_addr); - snd->sample_addr = parse_sample(ctl+((uintptr_t)snd->sample_addr),ctl, pos); - samples->addrs[samples->count] = snd->sample_addr; - samples->count++; - } else { - snd->sample_addr = samples->addrs[smpIndex]; - } + int smpIndex = -1; + for(int i = 0; i < samples->count; i++){ + if(samples->orig_addrs[i] == (uintptr_t)(snd->sample_addr)){ + smpIndex = i; + break; + } + } + if(smpIndex < 0){ + samples->orig_addrs[samples->count] = (uintptr_t)(snd->sample_addr); + snd->sample_addr = parse_sample(ctl+((uintptr_t)snd->sample_addr),ctl, pos); + samples->addrs[samples->count] = snd->sample_addr; + samples->count++; + } else { + snd->sample_addr = samples->addrs[smpIndex]; + } } return snd; } @@ -211,17 +202,17 @@ struct CDrum* parse_drum(unsigned char* drum,unsigned char* ctl, uintptr_t* pos, } struct CEnvelope* parse_envelope(unsigned char* env, uintptr_t* pos, int* size){ - int count = 0; - while(1){ - unsigned short delay = read_u16_le(env + count * 4); + int count = 0; + while(1){ + unsigned short delay = read_u16_le(env + count * 4); unsigned short arg = read_u16_le(env + count * 4 + 2); - unsigned short delayC = (-delay); - count++; + unsigned short delayC = (-delay); + count++; if ((1 <= delayC && delayC <= 3) || delay == 0) break; - } - *size = sizeof(struct CEnvelope) + sizeof(struct delay_arg) * (count-1); - struct CEnvelope* envData = malloc(*size); + } + *size = sizeof(struct CEnvelope) + sizeof(struct delay_arg) * (count-1); + struct CEnvelope* envData = malloc(*size); for (int i = 0; i < count; i++){ envData->delay_args[i].delay = read_u16_le(env + i * 4); envData->delay_args[i].arg = read_u16_le(env + i * 4 + 2); @@ -239,7 +230,7 @@ struct CInstrument* parse_instrument(unsigned char* instrument,unsigned char* ct inst->sound_lo=*parse_sound(instrument+8,ctl, pos, &(inst->sound_lo), samples); inst->sound_med=*parse_sound(instrument+16,ctl, pos, &(inst->sound_med), samples); inst->sound_hi=*parse_sound(instrument+24,ctl, pos, &(inst->sound_hi), samples); - + return inst; } @@ -249,63 +240,60 @@ struct TBL* parse_tbl_data(unsigned char* tbl){ return tblData; } -struct SEQ* parse_seq_data(unsigned char* seq){ + struct SEQ* parse_seq_data(unsigned char* seq){ struct SEQ* seqData = malloc(sizeof(struct SEQ)); seqData->data = seq; return seqData; } struct CTL* parse_ctl_data(unsigned char* ctlData, uintptr_t* pos){ - DEBUG_PRINT("parse_ctl_data()"); - DEBUG_PRINT("- ctlData: %x", ctlData); - DEBUG_PRINT("- pos: %x", pos); - int instruments=read_u32_be(ctlData); - unsigned int size = sizeof(struct CTL) + sizeof(struct CInstrument*) * (instruments-1); - struct CTL* ctl = (struct CTL*)(*pos); - *pos += size; - *pos = ALIGN16(*pos); + int instruments=read_u32_be(ctlData); + unsigned int size = sizeof(struct CTL) + sizeof(struct CInstrument*) * (instruments-1); + struct CTL* ctl = (struct CTL*)(*pos); + *pos += size; + *pos = ALIGN16(*pos); #pragma region Parse CTL header ctl->numInstruments = read_u32_be(ctlData); ctl->numDrums = read_u32_be(ctlData + 4); ctl->shared = read_u32_be(ctlData + 8); ctl->iso_date = read_u32_be(ctlData + 12); #pragma endregion - struct SampleList samples = {0}; - struct EnvelopeMeta envData[128] = {0}; - int envCount = 0; - samples.count = 0; + struct SampleList samples = {0}; + struct EnvelopeMeta envData[128] = {0}; + int envCount = 0; + samples.count = 0; // header parsed, now read data - if(ctl->numDrums != 0) { - ctl->drum_pointers= (struct CDrum**)(*pos); - size = sizeof(struct CDrum*) * ctl->numDrums; - *pos += size; - *pos = ALIGN16(*pos); - int drumTablePtr = read_u32_be(ctlData + 16); - for (int i = 0; i < ctl->numDrums; i++){ - uint32_t data = read_u32_be(ctlData + drumTablePtr+16 + i * 4); - - struct CDrum* d = parse_drum(ctlData+data+16,ctlData+16, pos, &samples); - bool used = 0; - for(int j = 0; j < envCount; j++){ - if(envData[j].orig == (uintptr_t)d->env_addr){ - used = 1; - break; - } - } - if(used == 0){ - int size = 0; - unsigned char* addr = ctlData+((uintptr_t)d->env_addr)+16; - envData[envCount].orig = (uintptr_t)(d->env_addr); - envData[envCount].addr = parse_envelope(addr, pos, &size); - envData[envCount].size = size; - envCount++; - } - ctl->drum_pointers[i] = d; - } - *pos = ALIGN16(*pos); - } else { - ctl->drum_pointers= NULL; - } + if(ctl->numDrums != 0) { + ctl->drum_pointers= (struct CDrum**)(*pos); + size = sizeof(struct CDrum*) * ctl->numDrums; + *pos += size; + *pos = ALIGN16(*pos); + int drumTablePtr = read_u32_be(ctlData + 16); + for (int i = 0; i < ctl->numDrums; i++){ + uint32_t data = read_u32_be(ctlData + drumTablePtr+16 + i * 4); + + struct CDrum* d = parse_drum(ctlData+data+16,ctlData+16, pos, &samples); + bool used = 0; + for(int j = 0; j < envCount; j++){ + if(envData[j].orig == (uintptr_t)d->env_addr){ + used = 1; + break; + } + } + if(used == 0){ + int size = 0; + unsigned char* addr = ctlData+((uintptr_t)d->env_addr)+16; + envData[envCount].orig = (uintptr_t)(d->env_addr); + envData[envCount].addr = parse_envelope(addr, pos, &size); + envData[envCount].size = size; + envCount++; + } + ctl->drum_pointers[i] = d; + } + *pos = ALIGN16(*pos); + } else { + ctl->drum_pointers= NULL; + } // parse instrument data int instTablePtr = 4; for (int i = 0; i < ctl->numInstruments; i++){ @@ -313,73 +301,73 @@ struct CTL* parse_ctl_data(unsigned char* ctlData, uintptr_t* pos){ if (data == 0) continue; struct CInstrument* inst = parse_instrument(ctlData+16+data,ctlData+16, pos, &samples); - bool used = 0; - for(int j = 0; j < envCount; j++){ - if(envData[j].orig == (uintptr_t)inst->env_addr){ - used = 1; - break; - } - } - if(used == 0){ - int size = 0; - unsigned char* addr = ctlData+((uintptr_t)inst->env_addr)+16; - envData[envCount].orig = (uintptr_t)(inst->env_addr); - envData[envCount].addr = parse_envelope(addr, pos, &size); - envData[envCount].size = size; - envCount++; - } + bool used = 0; + for(int j = 0; j < envCount; j++){ + if(envData[j].orig == (uintptr_t)inst->env_addr){ + used = 1; + break; + } + } + if(used == 0){ + int size = 0; + unsigned char* addr = ctlData+((uintptr_t)inst->env_addr)+16; + envData[envCount].orig = (uintptr_t)(inst->env_addr); + envData[envCount].addr = parse_envelope(addr, pos, &size); + envData[envCount].size = size; + envCount++; + } ctl->instrument_pointers[i] = inst; } - *pos = ALIGN16(*pos); - - // Copy envelopes to ctl - for (int i = 0; i < envCount; i++){ - struct CEnvelope* env = envData[i].addr; + *pos = ALIGN16(*pos); + + // Copy envelopes to ctl + for (int i = 0; i < envCount; i++){ + struct CEnvelope* env = envData[i].addr; memcpy((uint8_t*)(*pos), env, envData[i].size); - for (int j = 0; j < ctl->numInstruments; j++){ - struct CInstrument* inst = ctl->instrument_pointers[j]; - if (inst == 0x0) - continue; - if((uintptr_t)(inst->env_addr) == envData[i].orig){ - inst->env_addr = (struct CEnvelope*)(*pos); - } - } - for (int j = 0; j < ctl->numDrums; j++){ - struct CDrum* drum = ctl->drum_pointers[j]; - if (drum == 0x0) - continue; - if((uintptr_t)(drum->env_addr) == envData[i].orig){ - drum->env_addr = (struct CEnvelope*)(*pos); - } - } - free(env); - *pos += envData[i].size; + for (int j = 0; j < ctl->numInstruments; j++){ + struct CInstrument* inst = ctl->instrument_pointers[j]; + if (inst == 0x0) + continue; + if((uintptr_t)(inst->env_addr) == envData[i].orig){ + inst->env_addr = (struct CEnvelope*)(*pos); + } + } + for (int j = 0; j < ctl->numDrums; j++){ + struct CDrum* drum = ctl->drum_pointers[j]; + if (drum == 0x0) + continue; + if((uintptr_t)(drum->env_addr) == envData[i].orig){ + drum->env_addr = (struct CEnvelope*)(*pos); + } + } + free(env); + *pos += envData[i].size; } - *pos = ALIGN16(*pos); - - // Copy instruments to ctl - for (int i = 0; i < ctl->numInstruments; i++){ - struct CInstrument* inst = ctl->instrument_pointers[i]; - if (inst == 0x0) - continue; + *pos = ALIGN16(*pos); + + // Copy instruments to ctl + for (int i = 0; i < ctl->numInstruments; i++){ + struct CInstrument* inst = ctl->instrument_pointers[i]; + if (inst == 0x0) + continue; memcpy((uint8_t*)(*pos), inst, sizeof(struct CInstrument)); - free(inst); - ctl->instrument_pointers[i] = (struct CInstrument*)(*pos); - *pos += sizeof(struct CInstrument); + free(inst); + ctl->instrument_pointers[i] = (struct CInstrument*)(*pos); + *pos += sizeof(struct CInstrument); } - *pos = ALIGN16(*pos); - - // Copy drums to ctl - for (int i = 0; i < ctl->numDrums; i++){ - struct CDrum* drum = ctl->drum_pointers[i]; - if (drum == 0x0) - continue; + *pos = ALIGN16(*pos); + + // Copy drums to ctl + for (int i = 0; i < ctl->numDrums; i++){ + struct CDrum* drum = ctl->drum_pointers[i]; + if (drum == 0x0) + continue; memcpy((uint8_t*)(*pos), drum, sizeof(struct CDrum)); - free(drum); - ctl->drum_pointers[i] = (struct CDrum*)(*pos); - *pos += sizeof(struct CDrum); + free(drum); + ctl->drum_pointers[i] = (struct CDrum*)(*pos); + *pos += sizeof(struct CDrum); } - *pos = ALIGN16(*pos); + *pos = ALIGN16(*pos); // return ctl; diff --git a/src/libsm64.c b/src/libsm64.c index 7b26967..7476efc 100644 --- a/src/libsm64.c +++ b/src/libsm64.c @@ -144,15 +144,15 @@ SM64_LIB_FN void sm64_audio_init( uint8_t *rom ) { #define SAMPLES_LOW 528 extern SM64_LIB_FN uint32_t sm64_audio_tick( uint32_t numQueuedSamples, uint32_t numDesiredSamples, int16_t *audio_buffer ) { - update_game_sound(); + update_game_sound(); u32 num_audio_samples = numQueuedSamples < numDesiredSamples ? SAMPLES_HIGH : SAMPLES_LOW; for (int i = 0; i < 2; i++) - { - create_next_audio_buffer(audio_buffer + i * (2 * num_audio_samples), num_audio_samples); + { + create_next_audio_buffer( audio_buffer + i * ( 2 * num_audio_samples ), num_audio_samples ); } - - return num_audio_samples; + + return num_audio_samples; } SM64_LIB_FN void sm64_static_surfaces_load( const struct SM64Surface *surfaceArray, uint32_t numSurfaces ) diff --git a/src/load_audio_data.c b/src/load_audio_data.c index d860d3e..4ff206a 100644 --- a/src/load_audio_data.c +++ b/src/load_audio_data.c @@ -5,19 +5,19 @@ #include "decomp/audio/load_dat.h" extern void load_audio_banks( uint8_t *rom ) { - uint8_t *rom2 = malloc(0x800000); + uint8_t *rom2 = malloc( 0x800000 ); - memcpy(rom2, rom, 0x800000); - rom = rom2; - gSoundDataADSR = parse_seqfile(rom+0x57B720); //ctl - gSoundDataRaw = parse_seqfile(rom+0x593560); //tbl - gMusicData = parse_seqfile(rom+0x7B0860); - gBankSetsData = rom+0x7CC621; - memmove(gBankSetsData+0x45,gBankSetsData+0x45-1,0x5B); - gBankSetsData[0x45]=0x00; - ptrs_to_offsets(gSoundDataADSR); - - audio_init(); - sound_init(); - sound_reset(0); + memcpy( rom2, rom, 0x800000 ); + rom = rom2; + gSoundDataADSR = parse_seqfile( rom+0x57B720 ); //ctl + gSoundDataRaw = parse_seqfile( rom+0x593560 ); //tbl + gMusicData = parse_seqfile( rom+0x7B0860 ); + gBankSetsData = rom+0x7CC621; + memmove( gBankSetsData+0x45,gBankSetsData+0x45-1,0x5B ); + gBankSetsData[0x45]=0x00; + ptrs_to_offsets( gSoundDataADSR ); + + audio_init(); + sound_init(); + sound_reset( 0 ); } \ No newline at end of file diff --git a/src/play_sound.c b/src/play_sound.c index 10efbd1..c05c7e2 100644 --- a/src/play_sound.c +++ b/src/play_sound.c @@ -6,12 +6,12 @@ SM64PlaySoundFunctionPtr g_play_sound_func = NULL; extern void play_sound( uint32_t soundBits, f32 *pos ) { - DEBUG_PRINT("$ play_sound(%d) request %d; pos %f %f %f\n", soundBits,sSoundRequestCount,pos[0],pos[1],pos[2]); - sSoundRequests[sSoundRequestCount].soundBits = soundBits; - sSoundRequests[sSoundRequestCount].position = pos; - sSoundRequestCount++; - - if ( g_play_sound_func ) { - g_play_sound_func(soundBits, pos); - } + DEBUG_PRINT("$ play_sound(%d) request %d; pos %f %f %f\n", soundBits,sSoundRequestCount,pos[0],pos[1],pos[2]); + sSoundRequests[sSoundRequestCount].soundBits = soundBits; + sSoundRequests[sSoundRequestCount].position = pos; + sSoundRequestCount++; + + if ( g_play_sound_func ) { + g_play_sound_func(soundBits, pos); + } } \ No newline at end of file From a81188b4ff266aec55ae1fa012b7ed572bc6ec76 Mon Sep 17 00:00:00 2001 From: MeltyPlayer Date: Tue, 6 Dec 2022 17:27:14 -0600 Subject: [PATCH 13/16] Removed DEBUG_PRINT statements from alBnkfNew. --- src/decomp/pc/alBnkfNew.c | 7 ------- 1 file changed, 7 deletions(-) diff --git a/src/decomp/pc/alBnkfNew.c b/src/decomp/pc/alBnkfNew.c index fa003b1..bb04df3 100644 --- a/src/decomp/pc/alBnkfNew.c +++ b/src/decomp/pc/alBnkfNew.c @@ -1,19 +1,12 @@ #include "libultra_internal.h" #include "libaudio_internal.h" -#include "../../debug_print.h" - #define PATCH(SRC, BASE, TYPE) //SRC = (TYPE)((uintptr_t) SRC + (uintptr_t) BASE) void alSeqFileNew(ALSeqFile *f, u8 *base) { - DEBUG_PRINT("alSeqFileNew()"); int i; - DEBUG_PRINT("- patching %d entries", f->seqCount); for (i = 0; i < f->seqCount; i++) { - DEBUG_PRINT("- handling entry %d", i); - DEBUG_PRINT("- patching offset (%x) with base (%x)", f->seqArray[i].offset, base); PATCH(f->seqArray[i].offset, base, u8 *); - DEBUG_PRINT("- result is (%x)", f->seqArray[i].offset); } } From 85422d9d59ff5b9a89cd6e9af9d587360a32d29b Mon Sep 17 00:00:00 2001 From: MeltyPlayer Date: Tue, 6 Dec 2022 17:38:17 -0600 Subject: [PATCH 14/16] Verified that audio has been initialized before playing sounds or ticking audio. --- src/libsm64.c | 5 +++++ src/load_audio_data.c | 4 ++++ src/load_audio_data.h | 2 ++ src/play_sound.c | 11 +++++++---- 4 files changed, 18 insertions(+), 4 deletions(-) diff --git a/src/libsm64.c b/src/libsm64.c index 7476efc..c3df3e7 100644 --- a/src/libsm64.c +++ b/src/libsm64.c @@ -144,6 +144,11 @@ SM64_LIB_FN void sm64_audio_init( uint8_t *rom ) { #define SAMPLES_LOW 528 extern SM64_LIB_FN uint32_t sm64_audio_tick( uint32_t numQueuedSamples, uint32_t numDesiredSamples, int16_t *audio_buffer ) { + if ( !is_audio_initialized ) { + DEBUG_PRINT("Attempted to tick audio, but sm64_audio_init() has not been called yet."); + return 0; + } + update_game_sound(); u32 num_audio_samples = numQueuedSamples < numDesiredSamples ? SAMPLES_HIGH : SAMPLES_LOW; diff --git a/src/load_audio_data.c b/src/load_audio_data.c index 4ff206a..5fe394f 100644 --- a/src/load_audio_data.c +++ b/src/load_audio_data.c @@ -4,6 +4,8 @@ #include "decomp/audio/load.h" #include "decomp/audio/load_dat.h" +bool is_audio_initialized = false; + extern void load_audio_banks( uint8_t *rom ) { uint8_t *rom2 = malloc( 0x800000 ); @@ -20,4 +22,6 @@ extern void load_audio_banks( uint8_t *rom ) { audio_init(); sound_init(); sound_reset( 0 ); + + is_audio_initialized = true; } \ No newline at end of file diff --git a/src/load_audio_data.h b/src/load_audio_data.h index 6d9c537..97c2d84 100644 --- a/src/load_audio_data.h +++ b/src/load_audio_data.h @@ -2,4 +2,6 @@ #include +extern bool is_audio_initialized; + extern void load_audio_banks( uint8_t *rom ); \ No newline at end of file diff --git a/src/play_sound.c b/src/play_sound.c index c05c7e2..59ccf5b 100644 --- a/src/play_sound.c +++ b/src/play_sound.c @@ -2,14 +2,17 @@ #include "decomp/audio/external.h" #include "debug_print.h" +#include "load_audio_data.h" SM64PlaySoundFunctionPtr g_play_sound_func = NULL; extern void play_sound( uint32_t soundBits, f32 *pos ) { - DEBUG_PRINT("$ play_sound(%d) request %d; pos %f %f %f\n", soundBits,sSoundRequestCount,pos[0],pos[1],pos[2]); - sSoundRequests[sSoundRequestCount].soundBits = soundBits; - sSoundRequests[sSoundRequestCount].position = pos; - sSoundRequestCount++; + if ( is_audio_initialized ) { + DEBUG_PRINT("$ play_sound(%d) request %d; pos %f %f %f\n", soundBits,sSoundRequestCount,pos[0],pos[1],pos[2]); + sSoundRequests[sSoundRequestCount].soundBits = soundBits; + sSoundRequests[sSoundRequestCount].position = pos; + sSoundRequestCount++; + } if ( g_play_sound_func ) { g_play_sound_func(soundBits, pos); From 1f657175a3a5ae404dc205ba12be158146bcea83 Mon Sep 17 00:00:00 2001 From: MeltyPlayer Date: Tue, 6 Dec 2022 17:40:41 -0600 Subject: [PATCH 15/16] Included a required library for using booleans, whoops. --- src/load_audio_data.h | 1 + 1 file changed, 1 insertion(+) diff --git a/src/load_audio_data.h b/src/load_audio_data.h index 97c2d84..8e2140c 100644 --- a/src/load_audio_data.h +++ b/src/load_audio_data.h @@ -1,5 +1,6 @@ #pragma once +#include #include extern bool is_audio_initialized; From de21ba18fad766e907acb781b6037ef1a0fe33ad Mon Sep 17 00:00:00 2001 From: MeltyPlayer Date: Tue, 6 Dec 2022 18:42:22 -0600 Subject: [PATCH 16/16] Included so that uintptr_t is provided for the GitHub action. --- src/decomp/tools/convTypes.h | 1 + src/decomp/tools/convUtils.h | 3 +++ 2 files changed, 4 insertions(+) diff --git a/src/decomp/tools/convTypes.h b/src/decomp/tools/convTypes.h index cec8151..63dc5c8 100644 --- a/src/decomp/tools/convTypes.h +++ b/src/decomp/tools/convTypes.h @@ -1,5 +1,6 @@ #pragma once +#include #include #define TYPE_CTL 1 diff --git a/src/decomp/tools/convUtils.h b/src/decomp/tools/convUtils.h index 4f82584..5f5b30f 100644 --- a/src/decomp/tools/convUtils.h +++ b/src/decomp/tools/convUtils.h @@ -1,4 +1,7 @@ #pragma once + +#include + #include "../pc/libaudio_internal.h" #define read_u16_le(p) ((uint8_t*)p)[1] * 0x100u + ((uint8_t*)p)[0]