[−][src]Struct rspirv::dr::Builder

pub struct Builder { /* fields omitted */ }

The data representation builder.

Constructs a Module by aggregating results from method calls for various instructions.

This builder is designed to be low level; its build methods' signatures basically reflects the layout of the corresponding SPIR-V instructions faithfully.

If a SPIR-V instruction generates a result id and the result id can be forward referenced, the build method will take an optional result_id parameter. Filling it with Some(val) will instruct the builder to use the given val as the result id. For other cases, an unused result id will be automatically assigned from the builder.

So for instructions forward referencing an id, to avoid id collision, you can either

first append the target instruction generating that id and then append the forward referencing instruction; or
use the id() method to get an unused id from the builder, use it in the forward referencing instruction, and then later fill the optional result_id parameter of the target instruction with the same id.

Instructions belonging to the module (e.g., OpDecorate) can be appended at any time, no matter that a block is currently under construction or not. Intructions that can appear both in the module and block (e.g., OpVariable) will be inserted to the current block under construction first, if any.

Errors

Methods in the builder implement little sanity check; only appending instructions that violates the module structure is guarded. So methods possibly returning errors are basically those related to function and block construction (e.g., OpFunction and OpLabel).

Errors returned are enumerants related to function structure from the Error enum.

Examples

extern crate rspirv;
extern crate spirv_headers as spirv;

use rspirv::binary::Disassemble;

fn main() {
    let mut b = rspirv::dr::Builder::new();
    b.set_version(1, 0);
    b.memory_model(spirv::AddressingModel::Logical, spirv::MemoryModel::Simple);
    let void = b.type_void();
    let voidf = b.type_function(void, vec![void]);
    b.begin_function(void,
                     None,
                     (spirv::FunctionControl::DONT_INLINE |
                      spirv::FunctionControl::CONST),
                     voidf)
     .unwrap();
    b.begin_block(None).unwrap();
    b.ret().unwrap();
    b.end_function().unwrap();

    assert_eq!(b.module().disassemble(),
               "; SPIR-V\n\
                ; Version: 1.0\n\
                ; Generator: rspirv\n\
                ; Bound: 5\n\
                OpMemoryModel Logical Simple\n\
                %1 = OpTypeVoid\n\
                %2 = OpTypeFunction %1 %1\n\
                %3 = OpFunction  %1  DontInline|Const %2\n\
                %4 = OpLabel\n\
                OpReturn\n\
                OpFunctionEnd");
}

Methods

`impl Builder`[src]

`pub fn new() -> Builder`[src]

Creates a new empty builder.

`pub fn set_version(&mut self, major: u8, minor: u8)`[src]

Sets the SPIR-V version to the given major.minor version.

If this method is not called, the generated SPIR-V will be set as the newest version supported.

`pub fn module(self) -> Module`[src]

Returns the Module under construction.

`pub fn id(&mut self) -> Word`[src]

Returns the next unused id.

`pub fn begin_function( &mut self, return_type: Word, function_id: Option<Word>, control: FunctionControl, function_type: Word ) -> Result<Word, Error>`[src]

Begins building of a new function.

If function_id is Some(val), then val will be used as the result id of the function under construction; otherwise, an unused result id will be automatically assigned.

`pub fn end_function(&mut self) -> Result<(), Error>`[src]

Ends building of the current function.

`pub fn function_parameter(&mut self, result_type: Word) -> Result<Word, Error>`[src]

Declares a formal parameter for the current function.

`pub fn begin_block(&mut self, label_id: Option<Word>) -> Result<Word, Error>`[src]

Begins building of a new block.

If label_id is Some(val), then val will be used as the result id for the OpLabel instruction begining this block; otherwise, a unused result id will be automatically assigned.

`pub fn capability(&mut self, capability: Capability)`[src]

Appends an OpCapability instruction.

`pub fn extension<T: Into<String>>(&mut self, extension: T)`[src]

Appends an OpExtension instruction.

`pub fn ext_inst_import<T: Into<String>>(&mut self, extended_inst_set: T) -> Word`[src]

Appends an OpExtInstImport instruction and returns the result id.

`pub fn memory_model( &mut self, addressing_model: AddressingModel, memory_model: MemoryModel )`[src]

Appends an OpMemoryModel instruction.

`pub fn entry_point<T: Into<String>, U: AsRef<[Word]>>( &mut self, execution_model: ExecutionModel, entry_point: Word, name: T, interface: U )`[src]

Appends an OpEntryPoint instruction.

`pub fn execution_mode<T: AsRef<[u32]>>( &mut self, entry_point: Word, execution_mode: ExecutionMode, params: T )`[src]

Appends an OpExecutionMode instruction.

`impl Builder`[src]

`pub fn type_void(&mut self) -> Word`[src]

Appends an OpTypeVoid instruction and returns the result id.

`pub fn type_bool(&mut self) -> Word`[src]

Appends an OpTypeBool instruction and returns the result id.

`pub fn type_int(&mut self, width: u32, signedness: u32) -> Word`[src]

Appends an OpTypeInt instruction and returns the result id.

`pub fn type_float(&mut self, width: u32) -> Word`[src]

Appends an OpTypeFloat instruction and returns the result id.

`pub fn type_vector( &mut self, component_type: Word, component_count: u32 ) -> Word`[src]

Appends an OpTypeVector instruction and returns the result id.

`pub fn type_matrix(&mut self, column_type: Word, column_count: u32) -> Word`[src]

Appends an OpTypeMatrix instruction and returns the result id.

`pub fn type_image( &mut self, sampled_type: Word, dim: Dim, depth: u32, arrayed: u32, ms: u32, sampled: u32, image_format: ImageFormat, access_qualifier: Option<AccessQualifier> ) -> Word`[src]

Appends an OpTypeImage instruction and returns the result id.

`pub fn type_sampler(&mut self) -> Word`[src]

Appends an OpTypeSampler instruction and returns the result id.

`pub fn type_sampled_image(&mut self, image_type: Word) -> Word`[src]

Appends an OpTypeSampledImage instruction and returns the result id.

`pub fn type_array(&mut self, element_type: Word, length: Word) -> Word`[src]

Appends an OpTypeArray instruction and returns the result id.

`pub fn type_runtime_array(&mut self, element_type: Word) -> Word`[src]

Appends an OpTypeRuntimeArray instruction and returns the result id.

`pub fn type_struct<T: AsRef<[Word]>>( &mut self, member_0_type_member_1_type: T ) -> Word`[src]

Appends an OpTypeStruct instruction and returns the result id.

`pub fn type_function<T: AsRef<[Word]>>( &mut self, return_type: Word, parameter_0_type_parameter_1_type: T ) -> Word`[src]

Appends an OpTypeFunction instruction and returns the result id.

`pub fn type_event(&mut self) -> Word`[src]

Appends an OpTypeEvent instruction and returns the result id.

`pub fn type_device_event(&mut self) -> Word`[src]

Appends an OpTypeDeviceEvent instruction and returns the result id.

`pub fn type_reserve_id(&mut self) -> Word`[src]

Appends an OpTypeReserveId instruction and returns the result id.

`pub fn type_queue(&mut self) -> Word`[src]

Appends an OpTypeQueue instruction and returns the result id.

`pub fn type_pipe(&mut self, qualifier: AccessQualifier) -> Word`[src]

Appends an OpTypePipe instruction and returns the result id.

`pub fn type_pipe_storage(&mut self) -> Word`[src]

Appends an OpTypePipeStorage instruction and returns the result id.

`pub fn type_named_barrier(&mut self) -> Word`[src]

Appends an OpTypeNamedBarrier instruction and returns the result id.

`pub fn type_acceleration_structure_nv(&mut self) -> Word`[src]

Appends an OpTypeAccelerationStructureNV instruction and returns the result id.

`pub fn type_cooperative_matrix_nv( &mut self, component_type: Word, execution: Word, rows: Word, columns: Word ) -> Word`[src]

Appends an OpTypeCooperativeMatrixNV instruction and returns the result id.

`pub fn type_vme_image_intel(&mut self, image_type: Word) -> Word`[src]

Appends an OpTypeVmeImageINTEL instruction and returns the result id.

`pub fn type_avc_ime_payload_intel(&mut self) -> Word`[src]

Appends an OpTypeAvcImePayloadINTEL instruction and returns the result id.

`pub fn type_avc_ref_payload_intel(&mut self) -> Word`[src]

Appends an OpTypeAvcRefPayloadINTEL instruction and returns the result id.

`pub fn type_avc_sic_payload_intel(&mut self) -> Word`[src]

Appends an OpTypeAvcSicPayloadINTEL instruction and returns the result id.

`pub fn type_avc_mce_payload_intel(&mut self) -> Word`[src]

Appends an OpTypeAvcMcePayloadINTEL instruction and returns the result id.

`pub fn type_avc_mce_result_intel(&mut self) -> Word`[src]

Appends an OpTypeAvcMceResultINTEL instruction and returns the result id.

`pub fn type_avc_ime_result_intel(&mut self) -> Word`[src]

Appends an OpTypeAvcImeResultINTEL instruction and returns the result id.

`pub fn type_avc_ime_result_single_reference_streamout_intel(&mut self) -> Word`[src]

Appends an OpTypeAvcImeResultSingleReferenceStreamoutINTEL instruction and returns the result id.

`pub fn type_avc_ime_result_dual_reference_streamout_intel(&mut self) -> Word`[src]

Appends an OpTypeAvcImeResultDualReferenceStreamoutINTEL instruction and returns the result id.

`pub fn type_avc_ime_single_reference_streamin_intel(&mut self) -> Word`[src]

Appends an OpTypeAvcImeSingleReferenceStreaminINTEL instruction and returns the result id.

`pub fn type_avc_ime_dual_reference_streamin_intel(&mut self) -> Word`[src]

Appends an OpTypeAvcImeDualReferenceStreaminINTEL instruction and returns the result id.

`pub fn type_avc_ref_result_intel(&mut self) -> Word`[src]

Appends an OpTypeAvcRefResultINTEL instruction and returns the result id.

`pub fn type_avc_sic_result_intel(&mut self) -> Word`[src]

Appends an OpTypeAvcSicResultINTEL instruction and returns the result id.

`impl Builder`[src]

`pub fn constant_true(&mut self, result_type: Word) -> Word`[src]

Appends an OpConstantTrue instruction.

`pub fn constant_false(&mut self, result_type: Word) -> Word`[src]

Appends an OpConstantFalse instruction.

`pub fn constant_composite<T: AsRef<[Word]>>( &mut self, result_type: Word, constituents: T ) -> Word`[src]

Appends an OpConstantComposite instruction.

`pub fn constant_sampler( &mut self, result_type: Word, sampler_addressing_mode: SamplerAddressingMode, param: u32, sampler_filter_mode: SamplerFilterMode ) -> Word`[src]

Appends an OpConstantSampler instruction.

`pub fn constant_null(&mut self, result_type: Word) -> Word`[src]

Appends an OpConstantNull instruction.

`pub fn spec_constant_true(&mut self, result_type: Word) -> Word`[src]

Appends an OpSpecConstantTrue instruction.

`pub fn spec_constant_false(&mut self, result_type: Word) -> Word`[src]

Appends an OpSpecConstantFalse instruction.

`pub fn spec_constant_composite<T: AsRef<[Word]>>( &mut self, result_type: Word, constituents: T ) -> Word`[src]

Appends an OpSpecConstantComposite instruction.

`pub fn spec_constant_op(&mut self, result_type: Word, opcode: Op) -> Word`[src]

Appends an OpSpecConstantOp instruction.

`pub fn constant_pipe_storage( &mut self, result_type: Word, packet_size: u32, packet_alignment: u32, capacity: u32 ) -> Word`[src]

Appends an OpConstantPipeStorage instruction.

`impl Builder`[src]

`pub fn decorate<T: AsRef<[Operand]>>( &mut self, target: Word, decoration: Decoration, additional_params: T )`[src]

Appends an OpDecorate instruction.

`pub fn member_decorate<T: AsRef<[Operand]>>( &mut self, structure_type: Word, member: u32, decoration: Decoration, additional_params: T )`[src]

Appends an OpMemberDecorate instruction.

`pub fn group_decorate<T: AsRef<[Word]>>( &mut self, decoration_group: Word, targets: T )`[src]

Appends an OpGroupDecorate instruction.

`pub fn group_member_decorate<T: AsRef<[(Word, u32)]>>( &mut self, decoration_group: Word, targets: T )`[src]

Appends an OpGroupMemberDecorate instruction.

`pub fn decorate_id<T: AsRef<[Operand]>>( &mut self, target: Word, decoration: Decoration, additional_params: T )`[src]

Appends an OpDecorateId instruction.

`pub fn decorate_string<T: AsRef<[Operand]>>( &mut self, target: Word, decoration: Decoration, additional_params: T )`[src]

Appends an OpDecorateString instruction.

`pub fn decorate_string_google<T: AsRef<[Operand]>>( &mut self, target: Word, decoration: Decoration, additional_params: T )`[src]

Appends an OpDecorateStringGOOGLE instruction.

`pub fn member_decorate_string<T: AsRef<[Operand]>>( &mut self, struct_type: Word, member: u32, decoration: Decoration, additional_params: T )`[src]

Appends an OpMemberDecorateString instruction.

`pub fn member_decorate_string_google<T: AsRef<[Operand]>>( &mut self, struct_type: Word, member: u32, decoration: Decoration, additional_params: T )`[src]

Appends an OpMemberDecorateStringGOOGLE instruction.

`impl Builder`[src]

`pub fn branch(&mut self, target_label: Word) -> Result<(), Error>`[src]

Appends an OpBranch instruction and ends the current block.

`pub fn branch_conditional<T: AsRef<[u32]>>( &mut self, condition: Word, true_label: Word, false_label: Word, branch_weights: T ) -> Result<(), Error>`[src]

Appends an OpBranchConditional instruction and ends the current block.

`pub fn switch<T: AsRef<[(u32, Word)]>>( &mut self, selector: Word, default: Word, target: T ) -> Result<(), Error>`[src]

Appends an OpSwitch instruction and ends the current block.

`pub fn kill(&mut self) -> Result<(), Error>`[src]

Appends an OpKill instruction and ends the current block.

`pub fn ret(&mut self) -> Result<(), Error>`[src]

Appends an OpReturn instruction and ends the current block.

`pub fn ret_value(&mut self, value: Word) -> Result<(), Error>`[src]

Appends an OpReturnValue instruction and ends the current block.

`pub fn unreachable(&mut self) -> Result<(), Error>`[src]

Appends an OpUnreachable instruction and ends the current block.

`impl Builder`[src]

`pub fn source_continued<T: Into<String>>(&mut self, continued_source: T)`[src]

Appends an OpSourceContinued instruction.

`pub fn source<T: Into<String>>( &mut self, source_language: SourceLanguage, version: u32, file: Option<Word>, source: Option<T> )`[src]

Appends an OpSource instruction.

`pub fn source_extension<T: Into<String>>(&mut self, extension: T)`[src]

Appends an OpSourceExtension instruction.

`pub fn name<T: Into<String>>(&mut self, target: Word, name: T)`[src]

Appends an OpName instruction.

`pub fn member_name<T: Into<String>>(&mut self, ty: Word, member: u32, name: T)`[src]

Appends an OpMemberName instruction.

`pub fn module_processed<T: Into<String>>(&mut self, process: T)`[src]

Appends an OpModuleProcessed instruction.

`impl Builder`[src]

`pub fn decoration_group(&mut self) -> Word`[src]

Appends an OpDecorationGroup instruction and returns the result id.

`pub fn string<T: Into<String>>(&mut self, s: T) -> Word`[src]

`pub fn line(&mut self, file: Word, line: Word, column: Word)`[src]

`pub fn no_line(&mut self)`[src]

`impl Builder`[src]

`pub fn type_forward_pointer( &mut self, pointer_type: Word, storage_class: StorageClass )`[src]

Appends an OpTypeForwardPointer instruction.

`pub fn type_pointer( &mut self, result_id: Option<Word>, storage_class: StorageClass, pointee_type: Word ) -> Word`[src]

Appends an OpTypePointer instruction and returns the result id.

`pub fn type_opaque<T: Into<String>>(&mut self, type_name: T) -> Word`[src]

Appends an OpTypeOpaque instruction and returns the result id.

`pub fn constant_f32(&mut self, result_type: Word, value: f32) -> Word`[src]

Appends an OpConstant instruction with the given 32-bit float value. or the module if no block is under construction.

`pub fn constant_u32(&mut self, result_type: Word, value: u32) -> Word`[src]

Appends an OpConstant instruction with the given 32-bit integer value. or the module if no block is under construction.

`pub fn spec_constant_f32(&mut self, result_type: Word, value: f32) -> Word`[src]

Appends an OpSpecConstant instruction with the given 32-bit float value. or the module if no block is under construction.

`pub fn spec_constant_u32(&mut self, result_type: Word, value: u32) -> Word`[src]

Appends an OpSpecConstant instruction with the given 32-bit integer value. or the module if no block is under construction.

`pub fn variable( &mut self, result_type: Word, result_id: Option<Word>, storage_class: StorageClass, initializer: Option<Word> ) -> Word`[src]

Appends an OpVariable instruction to either the current block or the module if no block is under construction.

`pub fn undef(&mut self, result_type: Word, result_id: Option<Word>) -> Word`[src]

Appends an OpUndef instruction to either the current block or the module if no block is under construction.

`impl Builder`[src]

`pub fn nop(&mut self) -> Result<(), Error>`[src]

Appends an OpNop instruction to the current block.

`pub fn ext_inst<T: AsRef<[Word]>>( &mut self, result_type: Word, result_id: Option<Word>, set: Word, instruction: u32, operand_1_operand_2: T ) -> Result<Word, Error>`[src]

Appends an OpExtInst instruction to the current block.

`pub fn function_call<T: AsRef<[Word]>>( &mut self, result_type: Word, result_id: Option<Word>, function: Word, argument_0_argument_1: T ) -> Result<Word, Error>`[src]

Appends an OpFunctionCall instruction to the current block.

`pub fn image_texel_pointer( &mut self, result_type: Word, result_id: Option<Word>, image: Word, coordinate: Word, sample: Word ) -> Result<Word, Error>`[src]

Appends an OpImageTexelPointer instruction to the current block.

`pub fn load<T: AsRef<[Operand]>>( &mut self, result_type: Word, result_id: Option<Word>, pointer: Word, memory_access: Option<MemoryAccess>, additional_params: T ) -> Result<Word, Error>`[src]

Appends an OpLoad instruction to the current block.

`pub fn store<T: AsRef<[Operand]>>( &mut self, pointer: Word, object: Word, memory_access: Option<MemoryAccess>, additional_params: T ) -> Result<(), Error>`[src]

Appends an OpStore instruction to the current block.

`pub fn copy_memory<T: AsRef<[Operand]>>( &mut self, target: Word, source: Word, src_mem_access: Option<MemoryAccess>, dst_mem_access: Option<MemoryAccess>, additional_params: T ) -> Result<(), Error>`[src]

Appends an OpCopyMemory instruction to the current block.

`pub fn copy_memory_sized<T: AsRef<[Operand]>>( &mut self, target: Word, source: Word, size: Word, src_mem_access: Option<MemoryAccess>, dst_mem_access: Option<MemoryAccess>, additional_params: T ) -> Result<(), Error>`[src]

Appends an OpCopyMemorySized instruction to the current block.

`pub fn access_chain<T: AsRef<[Word]>>( &mut self, result_type: Word, result_id: Option<Word>, base: Word, indexes: T ) -> Result<Word, Error>`[src]

Appends an OpAccessChain instruction to the current block.

`pub fn in_bounds_access_chain<T: AsRef<[Word]>>( &mut self, result_type: Word, result_id: Option<Word>, base: Word, indexes: T ) -> Result<Word, Error>`[src]

Appends an OpInBoundsAccessChain instruction to the current block.

`pub fn ptr_access_chain<T: AsRef<[Word]>>( &mut self, result_type: Word, result_id: Option<Word>, base: Word, element: Word, indexes: T ) -> Result<Word, Error>`[src]

Appends an OpPtrAccessChain instruction to the current block.

`pub fn array_length( &mut self, result_type: Word, result_id: Option<Word>, structure: Word, array_member: u32 ) -> Result<Word, Error>`[src]

Appends an OpArrayLength instruction to the current block.

`pub fn generic_ptr_mem_semantics( &mut self, result_type: Word, result_id: Option<Word>, pointer: Word ) -> Result<Word, Error>`[src]

Appends an OpGenericPtrMemSemantics instruction to the current block.

`pub fn in_bounds_ptr_access_chain<T: AsRef<[Word]>>( &mut self, result_type: Word, result_id: Option<Word>, base: Word, element: Word, indexes: T ) -> Result<Word, Error>`[src]

Appends an OpInBoundsPtrAccessChain instruction to the current block.

`pub fn vector_extract_dynamic( &mut self, result_type: Word, result_id: Option<Word>, vector: Word, index: Word ) -> Result<Word, Error>`[src]

Appends an OpVectorExtractDynamic instruction to the current block.

`pub fn vector_insert_dynamic( &mut self, result_type: Word, result_id: Option<Word>, vector: Word, component: Word, index: Word ) -> Result<Word, Error>`[src]

Appends an OpVectorInsertDynamic instruction to the current block.

`pub fn vector_shuffle<T: AsRef<[u32]>>( &mut self, result_type: Word, result_id: Option<Word>, vector_1: Word, vector_2: Word, components: T ) -> Result<Word, Error>`[src]

Appends an OpVectorShuffle instruction to the current block.

`pub fn composite_construct<T: AsRef<[Word]>>( &mut self, result_type: Word, result_id: Option<Word>, constituents: T ) -> Result<Word, Error>`[src]

Appends an OpCompositeConstruct instruction to the current block.

`pub fn composite_extract<T: AsRef<[u32]>>( &mut self, result_type: Word, result_id: Option<Word>, composite: Word, indexes: T ) -> Result<Word, Error>`[src]

Appends an OpCompositeExtract instruction to the current block.

`pub fn composite_insert<T: AsRef<[u32]>>( &mut self, result_type: Word, result_id: Option<Word>, object: Word, composite: Word, indexes: T ) -> Result<Word, Error>`[src]

Appends an OpCompositeInsert instruction to the current block.

`pub fn copy_object( &mut self, result_type: Word, result_id: Option<Word>, operand: Word ) -> Result<Word, Error>`[src]

Appends an OpCopyObject instruction to the current block.

`pub fn transpose( &mut self, result_type: Word, result_id: Option<Word>, matrix: Word ) -> Result<Word, Error>`[src]

Appends an OpTranspose instruction to the current block.

`pub fn sampled_image( &mut self, result_type: Word, result_id: Option<Word>, image: Word, sampler: Word ) -> Result<Word, Error>`[src]

Appends an OpSampledImage instruction to the current block.

`pub fn image_sample_implicit_lod<T: AsRef<[Operand]>>( &mut self, result_type: Word, result_id: Option<Word>, sampled_image: Word, coordinate: Word, image_operands: Option<ImageOperands>, additional_params: T ) -> Result<Word, Error>`[src]

Appends an OpImageSampleImplicitLod instruction to the current block.

`pub fn image_sample_explicit_lod<T: AsRef<[Operand]>>( &mut self, result_type: Word, result_id: Option<Word>, sampled_image: Word, coordinate: Word, image_operands: ImageOperands, additional_params: T ) -> Result<Word, Error>`[src]

Appends an OpImageSampleExplicitLod instruction to the current block.

`pub fn image_sample_dref_implicit_lod<T: AsRef<[Operand]>>( &mut self, result_type: Word, result_id: Option<Word>, sampled_image: Word, coordinate: Word, d_ref: Word, image_operands: Option<ImageOperands>, additional_params: T ) -> Result<Word, Error>`[src]

Appends an OpImageSampleDrefImplicitLod instruction to the current block.

`pub fn image_sample_dref_explicit_lod<T: AsRef<[Operand]>>( &mut self, result_type: Word, result_id: Option<Word>, sampled_image: Word, coordinate: Word, d_ref: Word, image_operands: ImageOperands, additional_params: T ) -> Result<Word, Error>`[src]

Appends an OpImageSampleDrefExplicitLod instruction to the current block.

`pub fn image_sample_proj_implicit_lod<T: AsRef<[Operand]>>( &mut self, result_type: Word, result_id: Option<Word>, sampled_image: Word, coordinate: Word, image_operands: Option<ImageOperands>, additional_params: T ) -> Result<Word, Error>`[src]

Appends an OpImageSampleProjImplicitLod instruction to the current block.

`pub fn image_sample_proj_explicit_lod<T: AsRef<[Operand]>>( &mut self, result_type: Word, result_id: Option<Word>, sampled_image: Word, coordinate: Word, image_operands: ImageOperands, additional_params: T ) -> Result<Word, Error>`[src]

Appends an OpImageSampleProjExplicitLod instruction to the current block.

`pub fn image_sample_proj_dref_implicit_lod<T: AsRef<[Operand]>>( &mut self, result_type: Word, result_id: Option<Word>, sampled_image: Word, coordinate: Word, d_ref: Word, image_operands: Option<ImageOperands>, additional_params: T ) -> Result<Word, Error>`[src]

Appends an OpImageSampleProjDrefImplicitLod instruction to the current block.

`pub fn image_sample_proj_dref_explicit_lod<T: AsRef<[Operand]>>( &mut self, result_type: Word, result_id: Option<Word>, sampled_image: Word, coordinate: Word, d_ref: Word, image_operands: ImageOperands, additional_params: T ) -> Result<Word, Error>`[src]

Appends an OpImageSampleProjDrefExplicitLod instruction to the current block.

`pub fn image_fetch<T: AsRef<[Operand]>>( &mut self, result_type: Word, result_id: Option<Word>, image: Word, coordinate: Word, image_operands: Option<ImageOperands>, additional_params: T ) -> Result<Word, Error>`[src]

Appends an OpImageFetch instruction to the current block.

`pub fn image_gather<T: AsRef<[Operand]>>( &mut self, result_type: Word, result_id: Option<Word>, sampled_image: Word, coordinate: Word, component: Word, image_operands: Option<ImageOperands>, additional_params: T ) -> Result<Word, Error>`[src]

Appends an OpImageGather instruction to the current block.

`pub fn image_dref_gather<T: AsRef<[Operand]>>( &mut self, result_type: Word, result_id: Option<Word>, sampled_image: Word, coordinate: Word, d_ref: Word, image_operands: Option<ImageOperands>, additional_params: T ) -> Result<Word, Error>`[src]

Appends an OpImageDrefGather instruction to the current block.

`pub fn image_read<T: AsRef<[Operand]>>( &mut self, result_type: Word, result_id: Option<Word>, image: Word, coordinate: Word, image_operands: Option<ImageOperands>, additional_params: T ) -> Result<Word, Error>`[src]

Appends an OpImageRead instruction to the current block.

`pub fn image_write<T: AsRef<[Operand]>>( &mut self, image: Word, coordinate: Word, texel: Word, image_operands: Option<ImageOperands>, additional_params: T ) -> Result<(), Error>`[src]

Appends an OpImageWrite instruction to the current block.

`pub fn image( &mut self, result_type: Word, result_id: Option<Word>, sampled_image: Word ) -> Result<Word, Error>`[src]

Appends an OpImage instruction to the current block.

`pub fn image_query_format( &mut self, result_type: Word, result_id: Option<Word>, image: Word ) -> Result<Word, Error>`[src]

Appends an OpImageQueryFormat instruction to the current block.

`pub fn image_query_order( &mut self, result_type: Word, result_id: Option<Word>, image: Word ) -> Result<Word, Error>`[src]

Appends an OpImageQueryOrder instruction to the current block.

`pub fn image_query_size_lod( &mut self, result_type: Word, result_id: Option<Word>, image: Word, level_of_detail: Word ) -> Result<Word, Error>`[src]

Appends an OpImageQuerySizeLod instruction to the current block.

`pub fn image_query_size( &mut self, result_type: Word, result_id: Option<Word>, image: Word ) -> Result<Word, Error>`[src]

Appends an OpImageQuerySize instruction to the current block.

`pub fn image_query_lod( &mut self, result_type: Word, result_id: Option<Word>, sampled_image: Word, coordinate: Word ) -> Result<Word, Error>`[src]

Appends an OpImageQueryLod instruction to the current block.

`pub fn image_query_levels( &mut self, result_type: Word, result_id: Option<Word>, image: Word ) -> Result<Word, Error>`[src]

Appends an OpImageQueryLevels instruction to the current block.

`pub fn image_query_samples( &mut self, result_type: Word, result_id: Option<Word>, image: Word ) -> Result<Word, Error>`[src]

Appends an OpImageQuerySamples instruction to the current block.

`pub fn convert_f_to_u( &mut self, result_type: Word, result_id: Option<Word>, float_value: Word ) -> Result<Word, Error>`[src]

Appends an OpConvertFToU instruction to the current block.

`pub fn convert_f_to_s( &mut self, result_type: Word, result_id: Option<Word>, float_value: Word ) -> Result<Word, Error>`[src]

Appends an OpConvertFToS instruction to the current block.

`pub fn convert_s_to_f( &mut self, result_type: Word, result_id: Option<Word>, signed_value: Word ) -> Result<Word, Error>`[src]

Appends an OpConvertSToF instruction to the current block.

`pub fn convert_u_to_f( &mut self, result_type: Word, result_id: Option<Word>, unsigned_value: Word ) -> Result<Word, Error>`[src]

Appends an OpConvertUToF instruction to the current block.

`pub fn u_convert( &mut self, result_type: Word, result_id: Option<Word>, unsigned_value: Word ) -> Result<Word, Error>`[src]

Appends an OpUConvert instruction to the current block.

`pub fn s_convert( &mut self, result_type: Word, result_id: Option<Word>, signed_value: Word ) -> Result<Word, Error>`[src]

Appends an OpSConvert instruction to the current block.

`pub fn f_convert( &mut self, result_type: Word, result_id: Option<Word>, float_value: Word ) -> Result<Word, Error>`[src]

Appends an OpFConvert instruction to the current block.

`pub fn quantize_to_f16( &mut self, result_type: Word, result_id: Option<Word>, value: Word ) -> Result<Word, Error>`[src]

Appends an OpQuantizeToF16 instruction to the current block.

`pub fn convert_ptr_to_u( &mut self, result_type: Word, result_id: Option<Word>, pointer: Word ) -> Result<Word, Error>`[src]

Appends an OpConvertPtrToU instruction to the current block.

`pub fn sat_convert_s_to_u( &mut self, result_type: Word, result_id: Option<Word>, signed_value: Word ) -> Result<Word, Error>`[src]

Appends an OpSatConvertSToU instruction to the current block.

`pub fn sat_convert_u_to_s( &mut self, result_type: Word, result_id: Option<Word>, unsigned_value: Word ) -> Result<Word, Error>`[src]

Appends an OpSatConvertUToS instruction to the current block.

`pub fn convert_u_to_ptr( &mut self, result_type: Word, result_id: Option<Word>, integer_value: Word ) -> Result<Word, Error>`[src]

Appends an OpConvertUToPtr instruction to the current block.

`pub fn ptr_cast_to_generic( &mut self, result_type: Word, result_id: Option<Word>, pointer: Word ) -> Result<Word, Error>`[src]

Appends an OpPtrCastToGeneric instruction to the current block.

`pub fn generic_cast_to_ptr( &mut self, result_type: Word, result_id: Option<Word>, pointer: Word ) -> Result<Word, Error>`[src]

Appends an OpGenericCastToPtr instruction to the current block.

`pub fn generic_cast_to_ptr_explicit( &mut self, result_type: Word, result_id: Option<Word>, pointer: Word, storage: StorageClass ) -> Result<Word, Error>`[src]

Appends an OpGenericCastToPtrExplicit instruction to the current block.

`pub fn bitcast( &mut self, result_type: Word, result_id: Option<Word>, operand: Word ) -> Result<Word, Error>`[src]

Appends an OpBitcast instruction to the current block.

`pub fn s_negate( &mut self, result_type: Word, result_id: Option<Word>, operand: Word ) -> Result<Word, Error>`[src]

Appends an OpSNegate instruction to the current block.

`pub fn f_negate( &mut self, result_type: Word, result_id: Option<Word>, operand: Word ) -> Result<Word, Error>`[src]

Appends an OpFNegate instruction to the current block.

`pub fn i_add( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpIAdd instruction to the current block.

`pub fn f_add( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpFAdd instruction to the current block.

`pub fn i_sub( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpISub instruction to the current block.

`pub fn f_sub( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpFSub instruction to the current block.

`pub fn i_mul( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpIMul instruction to the current block.

`pub fn f_mul( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpFMul instruction to the current block.

`pub fn u_div( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpUDiv instruction to the current block.

`pub fn s_div( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpSDiv instruction to the current block.

`pub fn f_div( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpFDiv instruction to the current block.

`pub fn u_mod( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpUMod instruction to the current block.

`pub fn s_rem( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpSRem instruction to the current block.

`pub fn s_mod( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpSMod instruction to the current block.

`pub fn f_rem( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpFRem instruction to the current block.

`pub fn f_mod( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpFMod instruction to the current block.

`pub fn vector_times_scalar( &mut self, result_type: Word, result_id: Option<Word>, vector: Word, scalar: Word ) -> Result<Word, Error>`[src]

Appends an OpVectorTimesScalar instruction to the current block.

`pub fn matrix_times_scalar( &mut self, result_type: Word, result_id: Option<Word>, matrix: Word, scalar: Word ) -> Result<Word, Error>`[src]

Appends an OpMatrixTimesScalar instruction to the current block.

`pub fn vector_times_matrix( &mut self, result_type: Word, result_id: Option<Word>, vector: Word, matrix: Word ) -> Result<Word, Error>`[src]

Appends an OpVectorTimesMatrix instruction to the current block.

`pub fn matrix_times_vector( &mut self, result_type: Word, result_id: Option<Word>, matrix: Word, vector: Word ) -> Result<Word, Error>`[src]

Appends an OpMatrixTimesVector instruction to the current block.

`pub fn matrix_times_matrix( &mut self, result_type: Word, result_id: Option<Word>, left_matrix: Word, right_matrix: Word ) -> Result<Word, Error>`[src]

Appends an OpMatrixTimesMatrix instruction to the current block.

`pub fn outer_product( &mut self, result_type: Word, result_id: Option<Word>, vector_1: Word, vector_2: Word ) -> Result<Word, Error>`[src]

Appends an OpOuterProduct instruction to the current block.

`pub fn dot( &mut self, result_type: Word, result_id: Option<Word>, vector_1: Word, vector_2: Word ) -> Result<Word, Error>`[src]

Appends an OpDot instruction to the current block.

`pub fn i_add_carry( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpIAddCarry instruction to the current block.

`pub fn i_sub_borrow( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpISubBorrow instruction to the current block.

`pub fn u_mul_extended( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpUMulExtended instruction to the current block.

`pub fn s_mul_extended( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpSMulExtended instruction to the current block.

`pub fn any( &mut self, result_type: Word, result_id: Option<Word>, vector: Word ) -> Result<Word, Error>`[src]

Appends an OpAny instruction to the current block.

`pub fn all( &mut self, result_type: Word, result_id: Option<Word>, vector: Word ) -> Result<Word, Error>`[src]

Appends an OpAll instruction to the current block.

`pub fn is_nan( &mut self, result_type: Word, result_id: Option<Word>, x: Word ) -> Result<Word, Error>`[src]

Appends an OpIsNan instruction to the current block.

`pub fn is_inf( &mut self, result_type: Word, result_id: Option<Word>, x: Word ) -> Result<Word, Error>`[src]

Appends an OpIsInf instruction to the current block.

`pub fn is_finite( &mut self, result_type: Word, result_id: Option<Word>, x: Word ) -> Result<Word, Error>`[src]

Appends an OpIsFinite instruction to the current block.

`pub fn is_normal( &mut self, result_type: Word, result_id: Option<Word>, x: Word ) -> Result<Word, Error>`[src]

Appends an OpIsNormal instruction to the current block.

`pub fn sign_bit_set( &mut self, result_type: Word, result_id: Option<Word>, x: Word ) -> Result<Word, Error>`[src]

Appends an OpSignBitSet instruction to the current block.

`pub fn less_or_greater( &mut self, result_type: Word, result_id: Option<Word>, x: Word, y: Word ) -> Result<Word, Error>`[src]

Appends an OpLessOrGreater instruction to the current block.

`pub fn ordered( &mut self, result_type: Word, result_id: Option<Word>, x: Word, y: Word ) -> Result<Word, Error>`[src]

Appends an OpOrdered instruction to the current block.

`pub fn unordered( &mut self, result_type: Word, result_id: Option<Word>, x: Word, y: Word ) -> Result<Word, Error>`[src]

Appends an OpUnordered instruction to the current block.

`pub fn logical_equal( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpLogicalEqual instruction to the current block.

`pub fn logical_not_equal( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpLogicalNotEqual instruction to the current block.

`pub fn logical_or( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpLogicalOr instruction to the current block.

`pub fn logical_and( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpLogicalAnd instruction to the current block.

`pub fn logical_not( &mut self, result_type: Word, result_id: Option<Word>, operand: Word ) -> Result<Word, Error>`[src]

Appends an OpLogicalNot instruction to the current block.

`pub fn select( &mut self, result_type: Word, result_id: Option<Word>, condition: Word, object_1: Word, object_2: Word ) -> Result<Word, Error>`[src]

Appends an OpSelect instruction to the current block.

`pub fn i_equal( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpIEqual instruction to the current block.

`pub fn i_not_equal( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpINotEqual instruction to the current block.

`pub fn u_greater_than( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpUGreaterThan instruction to the current block.

`pub fn s_greater_than( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpSGreaterThan instruction to the current block.

`pub fn u_greater_than_equal( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpUGreaterThanEqual instruction to the current block.

`pub fn s_greater_than_equal( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpSGreaterThanEqual instruction to the current block.

`pub fn u_less_than( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpULessThan instruction to the current block.

`pub fn s_less_than( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpSLessThan instruction to the current block.

`pub fn u_less_than_equal( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpULessThanEqual instruction to the current block.

`pub fn s_less_than_equal( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpSLessThanEqual instruction to the current block.

`pub fn f_ord_equal( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpFOrdEqual instruction to the current block.

`pub fn f_unord_equal( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpFUnordEqual instruction to the current block.

`pub fn f_ord_not_equal( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpFOrdNotEqual instruction to the current block.

`pub fn f_unord_not_equal( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpFUnordNotEqual instruction to the current block.

`pub fn f_ord_less_than( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpFOrdLessThan instruction to the current block.

`pub fn f_unord_less_than( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpFUnordLessThan instruction to the current block.

`pub fn f_ord_greater_than( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpFOrdGreaterThan instruction to the current block.

`pub fn f_unord_greater_than( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpFUnordGreaterThan instruction to the current block.

`pub fn f_ord_less_than_equal( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpFOrdLessThanEqual instruction to the current block.

`pub fn f_unord_less_than_equal( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpFUnordLessThanEqual instruction to the current block.

`pub fn f_ord_greater_than_equal( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpFOrdGreaterThanEqual instruction to the current block.

`pub fn f_unord_greater_than_equal( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpFUnordGreaterThanEqual instruction to the current block.

`pub fn shift_right_logical( &mut self, result_type: Word, result_id: Option<Word>, base: Word, shift: Word ) -> Result<Word, Error>`[src]

Appends an OpShiftRightLogical instruction to the current block.

`pub fn shift_right_arithmetic( &mut self, result_type: Word, result_id: Option<Word>, base: Word, shift: Word ) -> Result<Word, Error>`[src]

Appends an OpShiftRightArithmetic instruction to the current block.

`pub fn shift_left_logical( &mut self, result_type: Word, result_id: Option<Word>, base: Word, shift: Word ) -> Result<Word, Error>`[src]

Appends an OpShiftLeftLogical instruction to the current block.

`pub fn bitwise_or( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpBitwiseOr instruction to the current block.

`pub fn bitwise_xor( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpBitwiseXor instruction to the current block.

`pub fn bitwise_and( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpBitwiseAnd instruction to the current block.

`pub fn not( &mut self, result_type: Word, result_id: Option<Word>, operand: Word ) -> Result<Word, Error>`[src]

Appends an OpNot instruction to the current block.

`pub fn bit_field_insert( &mut self, result_type: Word, result_id: Option<Word>, base: Word, insert: Word, offset: Word, count: Word ) -> Result<Word, Error>`[src]

Appends an OpBitFieldInsert instruction to the current block.

`pub fn bit_field_s_extract( &mut self, result_type: Word, result_id: Option<Word>, base: Word, offset: Word, count: Word ) -> Result<Word, Error>`[src]

Appends an OpBitFieldSExtract instruction to the current block.

`pub fn bit_field_u_extract( &mut self, result_type: Word, result_id: Option<Word>, base: Word, offset: Word, count: Word ) -> Result<Word, Error>`[src]

Appends an OpBitFieldUExtract instruction to the current block.

`pub fn bit_reverse( &mut self, result_type: Word, result_id: Option<Word>, base: Word ) -> Result<Word, Error>`[src]

Appends an OpBitReverse instruction to the current block.

`pub fn bit_count( &mut self, result_type: Word, result_id: Option<Word>, base: Word ) -> Result<Word, Error>`[src]

Appends an OpBitCount instruction to the current block.

`pub fn d_pdx( &mut self, result_type: Word, result_id: Option<Word>, p: Word ) -> Result<Word, Error>`[src]

Appends an OpDPdx instruction to the current block.

`pub fn d_pdy( &mut self, result_type: Word, result_id: Option<Word>, p: Word ) -> Result<Word, Error>`[src]

Appends an OpDPdy instruction to the current block.

`pub fn fwidth( &mut self, result_type: Word, result_id: Option<Word>, p: Word ) -> Result<Word, Error>`[src]

Appends an OpFwidth instruction to the current block.

`pub fn d_pdx_fine( &mut self, result_type: Word, result_id: Option<Word>, p: Word ) -> Result<Word, Error>`[src]

Appends an OpDPdxFine instruction to the current block.

`pub fn d_pdy_fine( &mut self, result_type: Word, result_id: Option<Word>, p: Word ) -> Result<Word, Error>`[src]

Appends an OpDPdyFine instruction to the current block.

`pub fn fwidth_fine( &mut self, result_type: Word, result_id: Option<Word>, p: Word ) -> Result<Word, Error>`[src]

Appends an OpFwidthFine instruction to the current block.

`pub fn d_pdx_coarse( &mut self, result_type: Word, result_id: Option<Word>, p: Word ) -> Result<Word, Error>`[src]

Appends an OpDPdxCoarse instruction to the current block.

`pub fn d_pdy_coarse( &mut self, result_type: Word, result_id: Option<Word>, p: Word ) -> Result<Word, Error>`[src]

Appends an OpDPdyCoarse instruction to the current block.

`pub fn fwidth_coarse( &mut self, result_type: Word, result_id: Option<Word>, p: Word ) -> Result<Word, Error>`[src]

Appends an OpFwidthCoarse instruction to the current block.

`pub fn emit_vertex(&mut self) -> Result<(), Error>`[src]

Appends an OpEmitVertex instruction to the current block.

`pub fn end_primitive(&mut self) -> Result<(), Error>`[src]

Appends an OpEndPrimitive instruction to the current block.

`pub fn emit_stream_vertex(&mut self, stream: Word) -> Result<(), Error>`[src]

Appends an OpEmitStreamVertex instruction to the current block.

`pub fn end_stream_primitive(&mut self, stream: Word) -> Result<(), Error>`[src]

Appends an OpEndStreamPrimitive instruction to the current block.

`pub fn control_barrier( &mut self, execution: Word, memory: Word, semantics: Word ) -> Result<(), Error>`[src]

Appends an OpControlBarrier instruction to the current block.

`pub fn memory_barrier( &mut self, memory: Word, semantics: Word ) -> Result<(), Error>`[src]

Appends an OpMemoryBarrier instruction to the current block.

`pub fn atomic_load( &mut self, result_type: Word, result_id: Option<Word>, pointer: Word, memory: Word, semantics: Word ) -> Result<Word, Error>`[src]

Appends an OpAtomicLoad instruction to the current block.

`pub fn atomic_store( &mut self, pointer: Word, memory: Word, semantics: Word, value: Word ) -> Result<(), Error>`[src]

Appends an OpAtomicStore instruction to the current block.

`pub fn atomic_exchange( &mut self, result_type: Word, result_id: Option<Word>, pointer: Word, memory: Word, semantics: Word, value: Word ) -> Result<Word, Error>`[src]

Appends an OpAtomicExchange instruction to the current block.

`pub fn atomic_compare_exchange( &mut self, result_type: Word, result_id: Option<Word>, pointer: Word, memory: Word, equal: Word, unequal: Word, value: Word, comparator: Word ) -> Result<Word, Error>`[src]

Appends an OpAtomicCompareExchange instruction to the current block.

`pub fn atomic_compare_exchange_weak( &mut self, result_type: Word, result_id: Option<Word>, pointer: Word, memory: Word, equal: Word, unequal: Word, value: Word, comparator: Word ) -> Result<Word, Error>`[src]

Appends an OpAtomicCompareExchangeWeak instruction to the current block.

`pub fn atomic_i_increment( &mut self, result_type: Word, result_id: Option<Word>, pointer: Word, memory: Word, semantics: Word ) -> Result<Word, Error>`[src]

Appends an OpAtomicIIncrement instruction to the current block.

`pub fn atomic_i_decrement( &mut self, result_type: Word, result_id: Option<Word>, pointer: Word, memory: Word, semantics: Word ) -> Result<Word, Error>`[src]

Appends an OpAtomicIDecrement instruction to the current block.

`pub fn atomic_i_add( &mut self, result_type: Word, result_id: Option<Word>, pointer: Word, memory: Word, semantics: Word, value: Word ) -> Result<Word, Error>`[src]

Appends an OpAtomicIAdd instruction to the current block.

`pub fn atomic_i_sub( &mut self, result_type: Word, result_id: Option<Word>, pointer: Word, memory: Word, semantics: Word, value: Word ) -> Result<Word, Error>`[src]

Appends an OpAtomicISub instruction to the current block.

`pub fn atomic_s_min( &mut self, result_type: Word, result_id: Option<Word>, pointer: Word, memory: Word, semantics: Word, value: Word ) -> Result<Word, Error>`[src]

Appends an OpAtomicSMin instruction to the current block.

`pub fn atomic_u_min( &mut self, result_type: Word, result_id: Option<Word>, pointer: Word, memory: Word, semantics: Word, value: Word ) -> Result<Word, Error>`[src]

Appends an OpAtomicUMin instruction to the current block.

`pub fn atomic_s_max( &mut self, result_type: Word, result_id: Option<Word>, pointer: Word, memory: Word, semantics: Word, value: Word ) -> Result<Word, Error>`[src]

Appends an OpAtomicSMax instruction to the current block.

`pub fn atomic_u_max( &mut self, result_type: Word, result_id: Option<Word>, pointer: Word, memory: Word, semantics: Word, value: Word ) -> Result<Word, Error>`[src]

Appends an OpAtomicUMax instruction to the current block.

`pub fn atomic_and( &mut self, result_type: Word, result_id: Option<Word>, pointer: Word, memory: Word, semantics: Word, value: Word ) -> Result<Word, Error>`[src]

Appends an OpAtomicAnd instruction to the current block.

`pub fn atomic_or( &mut self, result_type: Word, result_id: Option<Word>, pointer: Word, memory: Word, semantics: Word, value: Word ) -> Result<Word, Error>`[src]

Appends an OpAtomicOr instruction to the current block.

`pub fn atomic_xor( &mut self, result_type: Word, result_id: Option<Word>, pointer: Word, memory: Word, semantics: Word, value: Word ) -> Result<Word, Error>`[src]

Appends an OpAtomicXor instruction to the current block.

`pub fn phi<T: AsRef<[(Word, Word)]>>( &mut self, result_type: Word, result_id: Option<Word>, variable_parent: T ) -> Result<Word, Error>`[src]

Appends an OpPhi instruction to the current block.

`pub fn loop_merge<T: AsRef<[Operand]>>( &mut self, merge_block: Word, continue_target: Word, loop_control: LoopControl, additional_params: T ) -> Result<(), Error>`[src]

Appends an OpLoopMerge instruction to the current block.

`pub fn selection_merge( &mut self, merge_block: Word, selection_control: SelectionControl ) -> Result<(), Error>`[src]

Appends an OpSelectionMerge instruction to the current block.

`pub fn lifetime_start(&mut self, pointer: Word, size: u32) -> Result<(), Error>`[src]

Appends an OpLifetimeStart instruction to the current block.

`pub fn lifetime_stop(&mut self, pointer: Word, size: u32) -> Result<(), Error>`[src]

Appends an OpLifetimeStop instruction to the current block.

`pub fn group_async_copy( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, destination: Word, source: Word, num_elements: Word, stride: Word, event: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupAsyncCopy instruction to the current block.

`pub fn group_wait_events( &mut self, execution: Word, num_events: Word, events_list: Word ) -> Result<(), Error>`[src]

Appends an OpGroupWaitEvents instruction to the current block.

`pub fn group_all( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, predicate: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupAll instruction to the current block.

`pub fn group_any( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, predicate: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupAny instruction to the current block.

`pub fn group_broadcast( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, value: Word, local_id: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupBroadcast instruction to the current block.

`pub fn group_i_add( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, x: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupIAdd instruction to the current block.

`pub fn group_f_add( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, x: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupFAdd instruction to the current block.

`pub fn group_f_min( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, x: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupFMin instruction to the current block.

`pub fn group_u_min( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, x: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupUMin instruction to the current block.

`pub fn group_s_min( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, x: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupSMin instruction to the current block.

`pub fn group_f_max( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, x: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupFMax instruction to the current block.

`pub fn group_u_max( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, x: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupUMax instruction to the current block.

`pub fn group_s_max( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, x: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupSMax instruction to the current block.

`pub fn read_pipe( &mut self, result_type: Word, result_id: Option<Word>, pipe: Word, pointer: Word, packet_size: Word, packet_alignment: Word ) -> Result<Word, Error>`[src]

Appends an OpReadPipe instruction to the current block.

`pub fn write_pipe( &mut self, result_type: Word, result_id: Option<Word>, pipe: Word, pointer: Word, packet_size: Word, packet_alignment: Word ) -> Result<Word, Error>`[src]

Appends an OpWritePipe instruction to the current block.

`pub fn reserved_read_pipe( &mut self, result_type: Word, result_id: Option<Word>, pipe: Word, reserve_id: Word, index: Word, pointer: Word, packet_size: Word, packet_alignment: Word ) -> Result<Word, Error>`[src]

Appends an OpReservedReadPipe instruction to the current block.

`pub fn reserved_write_pipe( &mut self, result_type: Word, result_id: Option<Word>, pipe: Word, reserve_id: Word, index: Word, pointer: Word, packet_size: Word, packet_alignment: Word ) -> Result<Word, Error>`[src]

Appends an OpReservedWritePipe instruction to the current block.

`pub fn reserve_read_pipe_packets( &mut self, result_type: Word, result_id: Option<Word>, pipe: Word, num_packets: Word, packet_size: Word, packet_alignment: Word ) -> Result<Word, Error>`[src]

Appends an OpReserveReadPipePackets instruction to the current block.

`pub fn reserve_write_pipe_packets( &mut self, result_type: Word, result_id: Option<Word>, pipe: Word, num_packets: Word, packet_size: Word, packet_alignment: Word ) -> Result<Word, Error>`[src]

Appends an OpReserveWritePipePackets instruction to the current block.

`pub fn commit_read_pipe( &mut self, pipe: Word, reserve_id: Word, packet_size: Word, packet_alignment: Word ) -> Result<(), Error>`[src]

Appends an OpCommitReadPipe instruction to the current block.

`pub fn commit_write_pipe( &mut self, pipe: Word, reserve_id: Word, packet_size: Word, packet_alignment: Word ) -> Result<(), Error>`[src]

Appends an OpCommitWritePipe instruction to the current block.

`pub fn is_valid_reserve_id( &mut self, result_type: Word, result_id: Option<Word>, reserve_id: Word ) -> Result<Word, Error>`[src]

Appends an OpIsValidReserveId instruction to the current block.

`pub fn get_num_pipe_packets( &mut self, result_type: Word, result_id: Option<Word>, pipe: Word, packet_size: Word, packet_alignment: Word ) -> Result<Word, Error>`[src]

Appends an OpGetNumPipePackets instruction to the current block.

`pub fn get_max_pipe_packets( &mut self, result_type: Word, result_id: Option<Word>, pipe: Word, packet_size: Word, packet_alignment: Word ) -> Result<Word, Error>`[src]

Appends an OpGetMaxPipePackets instruction to the current block.

`pub fn group_reserve_read_pipe_packets( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, pipe: Word, num_packets: Word, packet_size: Word, packet_alignment: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupReserveReadPipePackets instruction to the current block.

`pub fn group_reserve_write_pipe_packets( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, pipe: Word, num_packets: Word, packet_size: Word, packet_alignment: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupReserveWritePipePackets instruction to the current block.

`pub fn group_commit_read_pipe( &mut self, execution: Word, pipe: Word, reserve_id: Word, packet_size: Word, packet_alignment: Word ) -> Result<(), Error>`[src]

Appends an OpGroupCommitReadPipe instruction to the current block.

`pub fn group_commit_write_pipe( &mut self, execution: Word, pipe: Word, reserve_id: Word, packet_size: Word, packet_alignment: Word ) -> Result<(), Error>`[src]

Appends an OpGroupCommitWritePipe instruction to the current block.

`pub fn enqueue_marker( &mut self, result_type: Word, result_id: Option<Word>, queue: Word, num_events: Word, wait_events: Word, ret_event: Word ) -> Result<Word, Error>`[src]

Appends an OpEnqueueMarker instruction to the current block.

`pub fn enqueue_kernel<T: AsRef<[Word]>>( &mut self, result_type: Word, result_id: Option<Word>, queue: Word, flags: Word, nd_range: Word, num_events: Word, wait_events: Word, ret_event: Word, invoke: Word, param: Word, param_size: Word, param_align: Word, local_size: T ) -> Result<Word, Error>`[src]

Appends an OpEnqueueKernel instruction to the current block.

`pub fn get_kernel_n_drange_sub_group_count( &mut self, result_type: Word, result_id: Option<Word>, nd_range: Word, invoke: Word, param: Word, param_size: Word, param_align: Word ) -> Result<Word, Error>`[src]

Appends an OpGetKernelNDrangeSubGroupCount instruction to the current block.

`pub fn get_kernel_n_drange_max_sub_group_size( &mut self, result_type: Word, result_id: Option<Word>, nd_range: Word, invoke: Word, param: Word, param_size: Word, param_align: Word ) -> Result<Word, Error>`[src]

Appends an OpGetKernelNDrangeMaxSubGroupSize instruction to the current block.

`pub fn get_kernel_work_group_size( &mut self, result_type: Word, result_id: Option<Word>, invoke: Word, param: Word, param_size: Word, param_align: Word ) -> Result<Word, Error>`[src]

Appends an OpGetKernelWorkGroupSize instruction to the current block.

`pub fn get_kernel_preferred_work_group_size_multiple( &mut self, result_type: Word, result_id: Option<Word>, invoke: Word, param: Word, param_size: Word, param_align: Word ) -> Result<Word, Error>`[src]

Appends an OpGetKernelPreferredWorkGroupSizeMultiple instruction to the current block.

`pub fn retain_event(&mut self, event: Word) -> Result<(), Error>`[src]

Appends an OpRetainEvent instruction to the current block.

`pub fn release_event(&mut self, event: Word) -> Result<(), Error>`[src]

Appends an OpReleaseEvent instruction to the current block.

`pub fn create_user_event( &mut self, result_type: Word, result_id: Option<Word> ) -> Result<Word, Error>`[src]

Appends an OpCreateUserEvent instruction to the current block.

`pub fn is_valid_event( &mut self, result_type: Word, result_id: Option<Word>, event: Word ) -> Result<Word, Error>`[src]

Appends an OpIsValidEvent instruction to the current block.

`pub fn set_user_event_status( &mut self, event: Word, status: Word ) -> Result<(), Error>`[src]

Appends an OpSetUserEventStatus instruction to the current block.

`pub fn capture_event_profiling_info( &mut self, event: Word, profiling_info: Word, value: Word ) -> Result<(), Error>`[src]

Appends an OpCaptureEventProfilingInfo instruction to the current block.

`pub fn get_default_queue( &mut self, result_type: Word, result_id: Option<Word> ) -> Result<Word, Error>`[src]

Appends an OpGetDefaultQueue instruction to the current block.

`pub fn build_nd_range( &mut self, result_type: Word, result_id: Option<Word>, global_work_size: Word, local_work_size: Word, global_work_offset: Word ) -> Result<Word, Error>`[src]

Appends an OpBuildNDRange instruction to the current block.

`pub fn image_sparse_sample_implicit_lod<T: AsRef<[Operand]>>( &mut self, result_type: Word, result_id: Option<Word>, sampled_image: Word, coordinate: Word, image_operands: Option<ImageOperands>, additional_params: T ) -> Result<Word, Error>`[src]

Appends an OpImageSparseSampleImplicitLod instruction to the current block.

`pub fn image_sparse_sample_explicit_lod<T: AsRef<[Operand]>>( &mut self, result_type: Word, result_id: Option<Word>, sampled_image: Word, coordinate: Word, image_operands: ImageOperands, additional_params: T ) -> Result<Word, Error>`[src]

Appends an OpImageSparseSampleExplicitLod instruction to the current block.

`pub fn image_sparse_sample_dref_implicit_lod<T: AsRef<[Operand]>>( &mut self, result_type: Word, result_id: Option<Word>, sampled_image: Word, coordinate: Word, d_ref: Word, image_operands: Option<ImageOperands>, additional_params: T ) -> Result<Word, Error>`[src]

Appends an OpImageSparseSampleDrefImplicitLod instruction to the current block.

`pub fn image_sparse_sample_dref_explicit_lod<T: AsRef<[Operand]>>( &mut self, result_type: Word, result_id: Option<Word>, sampled_image: Word, coordinate: Word, d_ref: Word, image_operands: ImageOperands, additional_params: T ) -> Result<Word, Error>`[src]

Appends an OpImageSparseSampleDrefExplicitLod instruction to the current block.

`pub fn image_sparse_sample_proj_implicit_lod<T: AsRef<[Operand]>>( &mut self, result_type: Word, result_id: Option<Word>, sampled_image: Word, coordinate: Word, image_operands: Option<ImageOperands>, additional_params: T ) -> Result<Word, Error>`[src]

Appends an OpImageSparseSampleProjImplicitLod instruction to the current block.

`pub fn image_sparse_sample_proj_explicit_lod<T: AsRef<[Operand]>>( &mut self, result_type: Word, result_id: Option<Word>, sampled_image: Word, coordinate: Word, image_operands: ImageOperands, additional_params: T ) -> Result<Word, Error>`[src]

Appends an OpImageSparseSampleProjExplicitLod instruction to the current block.

`pub fn image_sparse_sample_proj_dref_implicit_lod<T: AsRef<[Operand]>>( &mut self, result_type: Word, result_id: Option<Word>, sampled_image: Word, coordinate: Word, d_ref: Word, image_operands: Option<ImageOperands>, additional_params: T ) -> Result<Word, Error>`[src]

Appends an OpImageSparseSampleProjDrefImplicitLod instruction to the current block.

`pub fn image_sparse_sample_proj_dref_explicit_lod<T: AsRef<[Operand]>>( &mut self, result_type: Word, result_id: Option<Word>, sampled_image: Word, coordinate: Word, d_ref: Word, image_operands: ImageOperands, additional_params: T ) -> Result<Word, Error>`[src]

Appends an OpImageSparseSampleProjDrefExplicitLod instruction to the current block.

`pub fn image_sparse_fetch<T: AsRef<[Operand]>>( &mut self, result_type: Word, result_id: Option<Word>, image: Word, coordinate: Word, image_operands: Option<ImageOperands>, additional_params: T ) -> Result<Word, Error>`[src]

Appends an OpImageSparseFetch instruction to the current block.

`pub fn image_sparse_gather<T: AsRef<[Operand]>>( &mut self, result_type: Word, result_id: Option<Word>, sampled_image: Word, coordinate: Word, component: Word, image_operands: Option<ImageOperands>, additional_params: T ) -> Result<Word, Error>`[src]

Appends an OpImageSparseGather instruction to the current block.

`pub fn image_sparse_dref_gather<T: AsRef<[Operand]>>( &mut self, result_type: Word, result_id: Option<Word>, sampled_image: Word, coordinate: Word, d_ref: Word, image_operands: Option<ImageOperands>, additional_params: T ) -> Result<Word, Error>`[src]

Appends an OpImageSparseDrefGather instruction to the current block.

`pub fn image_sparse_texels_resident( &mut self, result_type: Word, result_id: Option<Word>, resident_code: Word ) -> Result<Word, Error>`[src]

Appends an OpImageSparseTexelsResident instruction to the current block.

`pub fn atomic_flag_test_and_set( &mut self, result_type: Word, result_id: Option<Word>, pointer: Word, memory: Word, semantics: Word ) -> Result<Word, Error>`[src]

Appends an OpAtomicFlagTestAndSet instruction to the current block.

`pub fn atomic_flag_clear( &mut self, pointer: Word, memory: Word, semantics: Word ) -> Result<(), Error>`[src]

Appends an OpAtomicFlagClear instruction to the current block.

`pub fn image_sparse_read<T: AsRef<[Operand]>>( &mut self, result_type: Word, result_id: Option<Word>, image: Word, coordinate: Word, image_operands: Option<ImageOperands>, additional_params: T ) -> Result<Word, Error>`[src]

Appends an OpImageSparseRead instruction to the current block.

`pub fn size_of( &mut self, result_type: Word, result_id: Option<Word>, pointer: Word ) -> Result<Word, Error>`[src]

Appends an OpSizeOf instruction to the current block.

`pub fn create_pipe_from_pipe_storage( &mut self, result_type: Word, result_id: Option<Word>, pipe_storage: Word ) -> Result<Word, Error>`[src]

Appends an OpCreatePipeFromPipeStorage instruction to the current block.

`pub fn get_kernel_local_size_for_subgroup_count( &mut self, result_type: Word, result_id: Option<Word>, subgroup_count: Word, invoke: Word, param: Word, param_size: Word, param_align: Word ) -> Result<Word, Error>`[src]

Appends an OpGetKernelLocalSizeForSubgroupCount instruction to the current block.

`pub fn get_kernel_max_num_subgroups( &mut self, result_type: Word, result_id: Option<Word>, invoke: Word, param: Word, param_size: Word, param_align: Word ) -> Result<Word, Error>`[src]

Appends an OpGetKernelMaxNumSubgroups instruction to the current block.

`pub fn named_barrier_initialize( &mut self, result_type: Word, result_id: Option<Word>, subgroup_count: Word ) -> Result<Word, Error>`[src]

Appends an OpNamedBarrierInitialize instruction to the current block.

`pub fn memory_named_barrier( &mut self, named_barrier: Word, memory: Word, semantics: Word ) -> Result<(), Error>`[src]

Appends an OpMemoryNamedBarrier instruction to the current block.

`pub fn group_non_uniform_elect( &mut self, result_type: Word, result_id: Option<Word>, execution: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformElect instruction to the current block.

`pub fn group_non_uniform_all( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, predicate: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformAll instruction to the current block.

`pub fn group_non_uniform_any( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, predicate: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformAny instruction to the current block.

`pub fn group_non_uniform_all_equal( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, value: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformAllEqual instruction to the current block.

`pub fn group_non_uniform_broadcast( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, value: Word, id: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformBroadcast instruction to the current block.

`pub fn group_non_uniform_broadcast_first( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, value: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformBroadcastFirst instruction to the current block.

`pub fn group_non_uniform_ballot( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, predicate: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformBallot instruction to the current block.

`pub fn group_non_uniform_inverse_ballot( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, value: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformInverseBallot instruction to the current block.

`pub fn group_non_uniform_ballot_bit_extract( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, value: Word, index: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformBallotBitExtract instruction to the current block.

`pub fn group_non_uniform_ballot_bit_count( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, value: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformBallotBitCount instruction to the current block.

`pub fn group_non_uniform_ballot_find_lsb( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, value: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformBallotFindLSB instruction to the current block.

`pub fn group_non_uniform_ballot_find_msb( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, value: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformBallotFindMSB instruction to the current block.

`pub fn group_non_uniform_shuffle( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, value: Word, id: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformShuffle instruction to the current block.

`pub fn group_non_uniform_shuffle_xor( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, value: Word, mask: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformShuffleXor instruction to the current block.

`pub fn group_non_uniform_shuffle_up( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, value: Word, delta: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformShuffleUp instruction to the current block.

`pub fn group_non_uniform_shuffle_down( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, value: Word, delta: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformShuffleDown instruction to the current block.

`pub fn group_non_uniform_i_add( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, value: Word, cluster_size: Option<Word> ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformIAdd instruction to the current block.

`pub fn group_non_uniform_f_add( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, value: Word, cluster_size: Option<Word> ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformFAdd instruction to the current block.

`pub fn group_non_uniform_i_mul( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, value: Word, cluster_size: Option<Word> ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformIMul instruction to the current block.

`pub fn group_non_uniform_f_mul( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, value: Word, cluster_size: Option<Word> ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformFMul instruction to the current block.

`pub fn group_non_uniform_s_min( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, value: Word, cluster_size: Option<Word> ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformSMin instruction to the current block.

`pub fn group_non_uniform_u_min( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, value: Word, cluster_size: Option<Word> ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformUMin instruction to the current block.

`pub fn group_non_uniform_f_min( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, value: Word, cluster_size: Option<Word> ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformFMin instruction to the current block.

`pub fn group_non_uniform_s_max( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, value: Word, cluster_size: Option<Word> ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformSMax instruction to the current block.

`pub fn group_non_uniform_u_max( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, value: Word, cluster_size: Option<Word> ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformUMax instruction to the current block.

`pub fn group_non_uniform_f_max( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, value: Word, cluster_size: Option<Word> ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformFMax instruction to the current block.

`pub fn group_non_uniform_bitwise_and( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, value: Word, cluster_size: Option<Word> ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformBitwiseAnd instruction to the current block.

`pub fn group_non_uniform_bitwise_or( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, value: Word, cluster_size: Option<Word> ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformBitwiseOr instruction to the current block.

`pub fn group_non_uniform_bitwise_xor( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, value: Word, cluster_size: Option<Word> ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformBitwiseXor instruction to the current block.

`pub fn group_non_uniform_logical_and( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, value: Word, cluster_size: Option<Word> ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformLogicalAnd instruction to the current block.

`pub fn group_non_uniform_logical_or( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, value: Word, cluster_size: Option<Word> ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformLogicalOr instruction to the current block.

`pub fn group_non_uniform_logical_xor( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, value: Word, cluster_size: Option<Word> ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformLogicalXor instruction to the current block.

`pub fn group_non_uniform_quad_broadcast( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, value: Word, index: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformQuadBroadcast instruction to the current block.

`pub fn group_non_uniform_quad_swap( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, value: Word, direction: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformQuadSwap instruction to the current block.

`pub fn copy_logical( &mut self, result_type: Word, result_id: Option<Word>, operand: Word ) -> Result<Word, Error>`[src]

Appends an OpCopyLogical instruction to the current block.

`pub fn ptr_equal( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpPtrEqual instruction to the current block.

`pub fn ptr_not_equal( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpPtrNotEqual instruction to the current block.

`pub fn ptr_diff( &mut self, result_type: Word, result_id: Option<Word>, operand_1: Word, operand_2: Word ) -> Result<Word, Error>`[src]

Appends an OpPtrDiff instruction to the current block.

`pub fn subgroup_ballot_khr( &mut self, result_type: Word, result_id: Option<Word>, predicate: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupBallotKHR instruction to the current block.

`pub fn subgroup_first_invocation_khr( &mut self, result_type: Word, result_id: Option<Word>, value: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupFirstInvocationKHR instruction to the current block.

`pub fn subgroup_all_khr( &mut self, result_type: Word, result_id: Option<Word>, predicate: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAllKHR instruction to the current block.

`pub fn subgroup_any_khr( &mut self, result_type: Word, result_id: Option<Word>, predicate: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAnyKHR instruction to the current block.

`pub fn subgroup_all_equal_khr( &mut self, result_type: Word, result_id: Option<Word>, predicate: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAllEqualKHR instruction to the current block.

`pub fn subgroup_read_invocation_khr( &mut self, result_type: Word, result_id: Option<Word>, value: Word, index: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupReadInvocationKHR instruction to the current block.

`pub fn group_i_add_non_uniform_amd( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, x: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupIAddNonUniformAMD instruction to the current block.

`pub fn group_f_add_non_uniform_amd( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, x: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupFAddNonUniformAMD instruction to the current block.

`pub fn group_f_min_non_uniform_amd( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, x: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupFMinNonUniformAMD instruction to the current block.

`pub fn group_u_min_non_uniform_amd( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, x: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupUMinNonUniformAMD instruction to the current block.

`pub fn group_s_min_non_uniform_amd( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, x: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupSMinNonUniformAMD instruction to the current block.

`pub fn group_f_max_non_uniform_amd( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, x: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupFMaxNonUniformAMD instruction to the current block.

`pub fn group_u_max_non_uniform_amd( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, x: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupUMaxNonUniformAMD instruction to the current block.

`pub fn group_s_max_non_uniform_amd( &mut self, result_type: Word, result_id: Option<Word>, execution: Word, operation: GroupOperation, x: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupSMaxNonUniformAMD instruction to the current block.

`pub fn fragment_mask_fetch_amd( &mut self, result_type: Word, result_id: Option<Word>, image: Word, coordinate: Word ) -> Result<Word, Error>`[src]

Appends an OpFragmentMaskFetchAMD instruction to the current block.

`pub fn fragment_fetch_amd( &mut self, result_type: Word, result_id: Option<Word>, image: Word, coordinate: Word, fragment_index: Word ) -> Result<Word, Error>`[src]

Appends an OpFragmentFetchAMD instruction to the current block.

`pub fn image_sample_footprint_nv<T: AsRef<[Operand]>>( &mut self, result_type: Word, result_id: Option<Word>, sampled_image: Word, coordinate: Word, granularity: Word, coarse: Word, image_operands: Option<ImageOperands>, additional_params: T ) -> Result<Word, Error>`[src]

Appends an OpImageSampleFootprintNV instruction to the current block.

`pub fn group_non_uniform_partition_nv( &mut self, result_type: Word, result_id: Option<Word>, value: Word ) -> Result<Word, Error>`[src]

Appends an OpGroupNonUniformPartitionNV instruction to the current block.

`pub fn write_packed_primitive_indices4x8_nv( &mut self, index_offset: Word, packed_indices: Word ) -> Result<(), Error>`[src]

Appends an OpWritePackedPrimitiveIndices4x8NV instruction to the current block.

`pub fn report_intersection_nv( &mut self, result_type: Word, result_id: Option<Word>, hit: Word, hit_kind: Word ) -> Result<Word, Error>`[src]

Appends an OpReportIntersectionNV instruction to the current block.

`pub fn ignore_intersection_nv(&mut self) -> Result<(), Error>`[src]

Appends an OpIgnoreIntersectionNV instruction to the current block.

`pub fn terminate_ray_nv(&mut self) -> Result<(), Error>`[src]

Appends an OpTerminateRayNV instruction to the current block.

`pub fn trace_nv( &mut self, accel: Word, ray_flags: Word, cull_mask: Word, sbt_offset: Word, sbt_stride: Word, miss_index: Word, ray_origin: Word, ray_tmin: Word, ray_direction: Word, ray_tmax: Word, payload_id: Word ) -> Result<(), Error>`[src]

Appends an OpTraceNV instruction to the current block.

`pub fn execute_callable_nv( &mut self, sbt_index: Word, callable_data_id: Word ) -> Result<(), Error>`[src]

Appends an OpExecuteCallableNV instruction to the current block.

`pub fn cooperative_matrix_load_nv<T: AsRef<[Operand]>>( &mut self, result_type: Word, result_id: Option<Word>, pointer: Word, stride: Word, column_major: Word, memory_access: Option<MemoryAccess>, additional_params: T ) -> Result<Word, Error>`[src]

Appends an OpCooperativeMatrixLoadNV instruction to the current block.

`pub fn cooperative_matrix_store_nv<T: AsRef<[Operand]>>( &mut self, pointer: Word, object: Word, stride: Word, column_major: Word, memory_access: Option<MemoryAccess>, additional_params: T ) -> Result<(), Error>`[src]

Appends an OpCooperativeMatrixStoreNV instruction to the current block.

`pub fn cooperative_matrix_mul_add_nv( &mut self, result_type: Word, result_id: Option<Word>, a: Word, b: Word, c: Word ) -> Result<Word, Error>`[src]

Appends an OpCooperativeMatrixMulAddNV instruction to the current block.

`pub fn cooperative_matrix_length_nv( &mut self, result_type: Word, result_id: Option<Word>, ty: Word ) -> Result<Word, Error>`[src]

Appends an OpCooperativeMatrixLengthNV instruction to the current block.

`pub fn subgroup_shuffle_intel( &mut self, result_type: Word, result_id: Option<Word>, data: Word, invocation_id: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupShuffleINTEL instruction to the current block.

`pub fn subgroup_shuffle_down_intel( &mut self, result_type: Word, result_id: Option<Word>, current: Word, next: Word, delta: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupShuffleDownINTEL instruction to the current block.

`pub fn subgroup_shuffle_up_intel( &mut self, result_type: Word, result_id: Option<Word>, previous: Word, current: Word, delta: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupShuffleUpINTEL instruction to the current block.

`pub fn subgroup_shuffle_xor_intel( &mut self, result_type: Word, result_id: Option<Word>, data: Word, value: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupShuffleXorINTEL instruction to the current block.

`pub fn subgroup_block_read_intel( &mut self, result_type: Word, result_id: Option<Word>, ptr: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupBlockReadINTEL instruction to the current block.

`pub fn subgroup_block_write_intel( &mut self, ptr: Word, data: Word ) -> Result<(), Error>`[src]

Appends an OpSubgroupBlockWriteINTEL instruction to the current block.

`pub fn subgroup_image_block_read_intel( &mut self, result_type: Word, result_id: Option<Word>, image: Word, coordinate: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupImageBlockReadINTEL instruction to the current block.

`pub fn subgroup_image_block_write_intel( &mut self, image: Word, coordinate: Word, data: Word ) -> Result<(), Error>`[src]

Appends an OpSubgroupImageBlockWriteINTEL instruction to the current block.

`pub fn subgroup_image_media_block_read_intel( &mut self, result_type: Word, result_id: Option<Word>, image: Word, coordinate: Word, width: Word, height: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupImageMediaBlockReadINTEL instruction to the current block.

`pub fn subgroup_image_media_block_write_intel( &mut self, image: Word, coordinate: Word, width: Word, height: Word, data: Word ) -> Result<(), Error>`[src]

Appends an OpSubgroupImageMediaBlockWriteINTEL instruction to the current block.

`pub fn vme_image_intel( &mut self, result_type: Word, result_id: Option<Word>, image_type: Word, sampler: Word ) -> Result<Word, Error>`[src]

Appends an OpVmeImageINTEL instruction to the current block.

`pub fn subgroup_avc_mce_get_default_inter_base_multi_reference_penalty_intel( &mut self, result_type: Word, result_id: Option<Word>, slice_type: Word, qp: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL instruction to the current block.

`pub fn subgroup_avc_mce_set_inter_base_multi_reference_penalty_intel( &mut self, result_type: Word, result_id: Option<Word>, reference_base_penalty: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL instruction to the current block.

`pub fn subgroup_avc_mce_get_default_inter_shape_penalty_intel( &mut self, result_type: Word, result_id: Option<Word>, slice_type: Word, qp: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL instruction to the current block.

`pub fn subgroup_avc_mce_set_inter_shape_penalty_intel( &mut self, result_type: Word, result_id: Option<Word>, packed_shape_penalty: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceSetInterShapePenaltyINTEL instruction to the current block.

`pub fn subgroup_avc_mce_get_default_inter_direction_penalty_intel( &mut self, result_type: Word, result_id: Option<Word>, slice_type: Word, qp: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL instruction to the current block.

`pub fn subgroup_avc_mce_set_inter_direction_penalty_intel( &mut self, result_type: Word, result_id: Option<Word>, direction_cost: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceSetInterDirectionPenaltyINTEL instruction to the current block.

`pub fn subgroup_avc_mce_get_default_intra_luma_shape_penalty_intel( &mut self, result_type: Word, result_id: Option<Word>, slice_type: Word, qp: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL instruction to the current block.

`pub fn subgroup_avc_mce_get_default_inter_motion_vector_cost_table_intel( &mut self, result_type: Word, result_id: Option<Word>, slice_type: Word, qp: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL instruction to the current block.

`pub fn subgroup_avc_mce_get_default_high_penalty_cost_table_intel( &mut self, result_type: Word, result_id: Option<Word> ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL instruction to the current block.

`pub fn subgroup_avc_mce_get_default_medium_penalty_cost_table_intel( &mut self, result_type: Word, result_id: Option<Word> ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL instruction to the current block.

`pub fn subgroup_avc_mce_get_default_low_penalty_cost_table_intel( &mut self, result_type: Word, result_id: Option<Word> ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL instruction to the current block.

`pub fn subgroup_avc_mce_set_motion_vector_cost_function_intel( &mut self, result_type: Word, result_id: Option<Word>, packed_cost_center_delta: Word, packed_cost_table: Word, cost_precision: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL instruction to the current block.

`pub fn subgroup_avc_mce_get_default_intra_luma_mode_penalty_intel( &mut self, result_type: Word, result_id: Option<Word>, slice_type: Word, qp: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL instruction to the current block.

`pub fn subgroup_avc_mce_get_default_non_dc_luma_intra_penalty_intel( &mut self, result_type: Word, result_id: Option<Word> ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL instruction to the current block.

`pub fn subgroup_avc_mce_get_default_intra_chroma_mode_base_penalty_intel( &mut self, result_type: Word, result_id: Option<Word> ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL instruction to the current block.

`pub fn subgroup_avc_mce_set_ac_only_haar_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceSetAcOnlyHaarINTEL instruction to the current block.

`pub fn subgroup_avc_mce_set_source_interlaced_field_polarity_intel( &mut self, result_type: Word, result_id: Option<Word>, source_field_polarity: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL instruction to the current block.

`pub fn subgroup_avc_mce_set_single_reference_interlaced_field_polarity_intel( &mut self, result_type: Word, result_id: Option<Word>, reference_field_polarity: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL instruction to the current block.

`pub fn subgroup_avc_mce_set_dual_reference_interlaced_field_polarities_intel( &mut self, result_type: Word, result_id: Option<Word>, forward_reference_field_polarity: Word, backward_reference_field_polarity: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL instruction to the current block.

`pub fn subgroup_avc_mce_convert_to_ime_payload_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceConvertToImePayloadINTEL instruction to the current block.

`pub fn subgroup_avc_mce_convert_to_ime_result_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceConvertToImeResultINTEL instruction to the current block.

`pub fn subgroup_avc_mce_convert_to_ref_payload_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceConvertToRefPayloadINTEL instruction to the current block.

`pub fn subgroup_avc_mce_convert_to_ref_result_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceConvertToRefResultINTEL instruction to the current block.

`pub fn subgroup_avc_mce_convert_to_sic_payload_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceConvertToSicPayloadINTEL instruction to the current block.

`pub fn subgroup_avc_mce_convert_to_sic_result_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceConvertToSicResultINTEL instruction to the current block.

`pub fn subgroup_avc_mce_get_motion_vectors_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceGetMotionVectorsINTEL instruction to the current block.

`pub fn subgroup_avc_mce_get_inter_distortions_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceGetInterDistortionsINTEL instruction to the current block.

`pub fn subgroup_avc_mce_get_best_inter_distortions_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceGetBestInterDistortionsINTEL instruction to the current block.

`pub fn subgroup_avc_mce_get_inter_major_shape_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceGetInterMajorShapeINTEL instruction to the current block.

`pub fn subgroup_avc_mce_get_inter_minor_shape_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceGetInterMinorShapeINTEL instruction to the current block.

`pub fn subgroup_avc_mce_get_inter_directions_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceGetInterDirectionsINTEL instruction to the current block.

`pub fn subgroup_avc_mce_get_inter_motion_vector_count_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceGetInterMotionVectorCountINTEL instruction to the current block.

`pub fn subgroup_avc_mce_get_inter_reference_ids_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceGetInterReferenceIdsINTEL instruction to the current block.

`pub fn subgroup_avc_mce_get_inter_reference_interlaced_field_polarities_intel( &mut self, result_type: Word, result_id: Option<Word>, packed_reference_ids: Word, packed_reference_parameter_field_polarities: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL instruction to the current block.

`pub fn subgroup_avc_ime_initialize_intel( &mut self, result_type: Word, result_id: Option<Word>, src_coord: Word, partition_mask: Word, sad_adjustment: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeInitializeINTEL instruction to the current block.

`pub fn subgroup_avc_ime_set_single_reference_intel( &mut self, result_type: Word, result_id: Option<Word>, ref_offset: Word, search_window_config: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeSetSingleReferenceINTEL instruction to the current block.

`pub fn subgroup_avc_ime_set_dual_reference_intel( &mut self, result_type: Word, result_id: Option<Word>, fwd_ref_offset: Word, bwd_ref_offset: Word, id_search_window_config: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeSetDualReferenceINTEL instruction to the current block.

`pub fn subgroup_avc_ime_ref_window_size_intel( &mut self, result_type: Word, result_id: Option<Word>, search_window_config: Word, dual_ref: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeRefWindowSizeINTEL instruction to the current block.

`pub fn subgroup_avc_ime_adjust_ref_offset_intel( &mut self, result_type: Word, result_id: Option<Word>, ref_offset: Word, src_coord: Word, ref_window_size: Word, image_size: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeAdjustRefOffsetINTEL instruction to the current block.

`pub fn subgroup_avc_ime_convert_to_mce_payload_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeConvertToMcePayloadINTEL instruction to the current block.

`pub fn subgroup_avc_ime_set_max_motion_vector_count_intel( &mut self, result_type: Word, result_id: Option<Word>, max_motion_vector_count: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeSetMaxMotionVectorCountINTEL instruction to the current block.

`pub fn subgroup_avc_ime_set_unidirectional_mix_disable_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL instruction to the current block.

`pub fn subgroup_avc_ime_set_early_search_termination_threshold_intel( &mut self, result_type: Word, result_id: Option<Word>, threshold: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL instruction to the current block.

`pub fn subgroup_avc_ime_set_weighted_sad_intel( &mut self, result_type: Word, result_id: Option<Word>, packed_sad_weights: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeSetWeightedSadINTEL instruction to the current block.

`pub fn subgroup_avc_ime_evaluate_with_single_reference_intel( &mut self, result_type: Word, result_id: Option<Word>, src_image: Word, ref_image: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL instruction to the current block.

`pub fn subgroup_avc_ime_evaluate_with_dual_reference_intel( &mut self, result_type: Word, result_id: Option<Word>, src_image: Word, fwd_ref_image: Word, bwd_ref_image: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeEvaluateWithDualReferenceINTEL instruction to the current block.

`pub fn subgroup_avc_ime_evaluate_with_single_reference_streamin_intel( &mut self, result_type: Word, result_id: Option<Word>, src_image: Word, ref_image: Word, payload: Word, streamin_components: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL instruction to the current block.

`pub fn subgroup_avc_ime_evaluate_with_dual_reference_streamin_intel( &mut self, result_type: Word, result_id: Option<Word>, src_image: Word, fwd_ref_image: Word, bwd_ref_image: Word, payload: Word, streamin_components: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL instruction to the current block.

`pub fn subgroup_avc_ime_evaluate_with_single_reference_streamout_intel( &mut self, result_type: Word, result_id: Option<Word>, src_image: Word, ref_image: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL instruction to the current block.

`pub fn subgroup_avc_ime_evaluate_with_dual_reference_streamout_intel( &mut self, result_type: Word, result_id: Option<Word>, src_image: Word, fwd_ref_image: Word, bwd_ref_image: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL instruction to the current block.

`pub fn subgroup_avc_ime_evaluate_with_single_reference_streaminout_intel( &mut self, result_type: Word, result_id: Option<Word>, src_image: Word, ref_image: Word, payload: Word, streamin_components: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL instruction to the current block.

`pub fn subgroup_avc_ime_evaluate_with_dual_reference_streaminout_intel( &mut self, result_type: Word, result_id: Option<Word>, src_image: Word, fwd_ref_image: Word, bwd_ref_image: Word, payload: Word, streamin_components: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL instruction to the current block.

`pub fn subgroup_avc_ime_convert_to_mce_result_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeConvertToMceResultINTEL instruction to the current block.

`pub fn subgroup_avc_ime_get_single_reference_streamin_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeGetSingleReferenceStreaminINTEL instruction to the current block.

`pub fn subgroup_avc_ime_get_dual_reference_streamin_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeGetDualReferenceStreaminINTEL instruction to the current block.

`pub fn subgroup_avc_ime_strip_single_reference_streamout_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL instruction to the current block.

`pub fn subgroup_avc_ime_strip_dual_reference_streamout_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeStripDualReferenceStreamoutINTEL instruction to the current block.

`pub fn subgroup_avc_ime_get_streamout_single_reference_major_shape_motion_vectors_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word, major_shape: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL instruction to the current block.

`pub fn subgroup_avc_ime_get_streamout_single_reference_major_shape_distortions_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word, major_shape: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL instruction to the current block.

`pub fn subgroup_avc_ime_get_streamout_single_reference_major_shape_reference_ids_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word, major_shape: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL instruction to the current block.

`pub fn subgroup_avc_ime_get_streamout_dual_reference_major_shape_motion_vectors_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word, major_shape: Word, direction: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL instruction to the current block.

`pub fn subgroup_avc_ime_get_streamout_dual_reference_major_shape_distortions_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word, major_shape: Word, direction: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL instruction to the current block.

`pub fn subgroup_avc_ime_get_streamout_dual_reference_major_shape_reference_ids_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word, major_shape: Word, direction: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL instruction to the current block.

`pub fn subgroup_avc_ime_get_border_reached_intel( &mut self, result_type: Word, result_id: Option<Word>, image_select: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeGetBorderReachedINTEL instruction to the current block.

`pub fn subgroup_avc_ime_get_truncated_search_indication_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL instruction to the current block.

`pub fn subgroup_avc_ime_get_unidirectional_early_search_termination_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL instruction to the current block.

`pub fn subgroup_avc_ime_get_weighting_pattern_minimum_motion_vector_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL instruction to the current block.

`pub fn subgroup_avc_ime_get_weighting_pattern_minimum_distortion_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL instruction to the current block.

`pub fn subgroup_avc_fme_initialize_intel( &mut self, result_type: Word, result_id: Option<Word>, src_coord: Word, motion_vectors: Word, major_shapes: Word, minor_shapes: Word, direction: Word, pixel_resolution: Word, sad_adjustment: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcFmeInitializeINTEL instruction to the current block.

`pub fn subgroup_avc_bme_initialize_intel( &mut self, result_type: Word, result_id: Option<Word>, src_coord: Word, motion_vectors: Word, major_shapes: Word, minor_shapes: Word, direction: Word, pixel_resolution: Word, bidirectional_weight: Word, sad_adjustment: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcBmeInitializeINTEL instruction to the current block.

`pub fn subgroup_avc_ref_convert_to_mce_payload_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcRefConvertToMcePayloadINTEL instruction to the current block.

`pub fn subgroup_avc_ref_set_bidirectional_mix_disable_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcRefSetBidirectionalMixDisableINTEL instruction to the current block.

`pub fn subgroup_avc_ref_set_bilinear_filter_enable_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcRefSetBilinearFilterEnableINTEL instruction to the current block.

`pub fn subgroup_avc_ref_evaluate_with_single_reference_intel( &mut self, result_type: Word, result_id: Option<Word>, src_image: Word, ref_image: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL instruction to the current block.

`pub fn subgroup_avc_ref_evaluate_with_dual_reference_intel( &mut self, result_type: Word, result_id: Option<Word>, src_image: Word, fwd_ref_image: Word, bwd_ref_image: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcRefEvaluateWithDualReferenceINTEL instruction to the current block.

`pub fn subgroup_avc_ref_evaluate_with_multi_reference_intel( &mut self, result_type: Word, result_id: Option<Word>, src_image: Word, packed_reference_ids: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL instruction to the current block.

`pub fn subgroup_avc_ref_evaluate_with_multi_reference_interlaced_intel( &mut self, result_type: Word, result_id: Option<Word>, src_image: Word, packed_reference_ids: Word, packed_reference_field_polarities: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL instruction to the current block.

`pub fn subgroup_avc_ref_convert_to_mce_result_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcRefConvertToMceResultINTEL instruction to the current block.

`pub fn subgroup_avc_sic_initialize_intel( &mut self, result_type: Word, result_id: Option<Word>, src_coord: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcSicInitializeINTEL instruction to the current block.

`pub fn subgroup_avc_sic_configure_skc_intel( &mut self, result_type: Word, result_id: Option<Word>, skip_block_partition_type: Word, skip_motion_vector_mask: Word, motion_vectors: Word, bidirectional_weight: Word, sad_adjustment: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcSicConfigureSkcINTEL instruction to the current block.

`pub fn subgroup_avc_sic_configure_ipe_luma_intel( &mut self, result_type: Word, result_id: Option<Word>, luma_intra_partition_mask: Word, intra_neighbour_availabilty: Word, left_edge_luma_pixels: Word, upper_left_corner_luma_pixel: Word, upper_edge_luma_pixels: Word, upper_right_edge_luma_pixels: Word, sad_adjustment: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcSicConfigureIpeLumaINTEL instruction to the current block.

pub fn subgroup_avc_sic_configure_ipe_luma_chroma_intel( &mut self, result_type: Word, result_id: Option<Word>, luma_intra_partition_mask: Word, intra_neighbour_availabilty: Word, left_edge_luma_pixels: Word, upper_left_corner_luma_pixel: Word, upper_edge_luma_pixels: Word, upper_right_edge_luma_pixels: Word, left_edge_chroma_pixels: Word, upper_left_corner_chroma_pixel: Word, upper_edge_chroma_pixels: Word, sad_adjustment: Word, payload: Word ) -> Result<Word, Error>[src]

Appends an OpSubgroupAvcSicConfigureIpeLumaChromaINTEL instruction to the current block.

`pub fn subgroup_avc_sic_get_motion_vector_mask_intel( &mut self, result_type: Word, result_id: Option<Word>, skip_block_partition_type: Word, direction: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcSicGetMotionVectorMaskINTEL instruction to the current block.

`pub fn subgroup_avc_sic_convert_to_mce_payload_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcSicConvertToMcePayloadINTEL instruction to the current block.

`pub fn subgroup_avc_sic_set_intra_luma_shape_penalty_intel( &mut self, result_type: Word, result_id: Option<Word>, packed_shape_penalty: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL instruction to the current block.

`pub fn subgroup_avc_sic_set_intra_luma_mode_cost_function_intel( &mut self, result_type: Word, result_id: Option<Word>, luma_mode_penalty: Word, luma_packed_neighbor_modes: Word, luma_packed_non_dc_penalty: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL instruction to the current block.

`pub fn subgroup_avc_sic_set_intra_chroma_mode_cost_function_intel( &mut self, result_type: Word, result_id: Option<Word>, chroma_mode_base_penalty: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL instruction to the current block.

`pub fn subgroup_avc_sic_set_bilinear_filter_enable_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcSicSetBilinearFilterEnableINTEL instruction to the current block.

`pub fn subgroup_avc_sic_set_skc_forward_transform_enable_intel( &mut self, result_type: Word, result_id: Option<Word>, packed_sad_coefficients: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL instruction to the current block.

`pub fn subgroup_avc_sic_set_block_based_raw_skip_sad_intel( &mut self, result_type: Word, result_id: Option<Word>, block_based_skip_type: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL instruction to the current block.

`pub fn subgroup_avc_sic_evaluate_ipe_intel( &mut self, result_type: Word, result_id: Option<Word>, src_image: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcSicEvaluateIpeINTEL instruction to the current block.

`pub fn subgroup_avc_sic_evaluate_with_single_reference_intel( &mut self, result_type: Word, result_id: Option<Word>, src_image: Word, ref_image: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL instruction to the current block.

`pub fn subgroup_avc_sic_evaluate_with_dual_reference_intel( &mut self, result_type: Word, result_id: Option<Word>, src_image: Word, fwd_ref_image: Word, bwd_ref_image: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcSicEvaluateWithDualReferenceINTEL instruction to the current block.

`pub fn subgroup_avc_sic_evaluate_with_multi_reference_intel( &mut self, result_type: Word, result_id: Option<Word>, src_image: Word, packed_reference_ids: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL instruction to the current block.

`pub fn subgroup_avc_sic_evaluate_with_multi_reference_interlaced_intel( &mut self, result_type: Word, result_id: Option<Word>, src_image: Word, packed_reference_ids: Word, packed_reference_field_polarities: Word, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL instruction to the current block.

`pub fn subgroup_avc_sic_convert_to_mce_result_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcSicConvertToMceResultINTEL instruction to the current block.

`pub fn subgroup_avc_sic_get_ipe_luma_shape_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcSicGetIpeLumaShapeINTEL instruction to the current block.

`pub fn subgroup_avc_sic_get_best_ipe_luma_distortion_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL instruction to the current block.

`pub fn subgroup_avc_sic_get_best_ipe_chroma_distortion_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL instruction to the current block.

`pub fn subgroup_avc_sic_get_packed_ipe_luma_modes_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcSicGetPackedIpeLumaModesINTEL instruction to the current block.

`pub fn subgroup_avc_sic_get_ipe_chroma_mode_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcSicGetIpeChromaModeINTEL instruction to the current block.

`pub fn subgroup_avc_sic_get_packed_skc_luma_count_threshold_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL instruction to the current block.

`pub fn subgroup_avc_sic_get_packed_skc_luma_sum_threshold_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL instruction to the current block.

`pub fn subgroup_avc_sic_get_inter_raw_sads_intel( &mut self, result_type: Word, result_id: Option<Word>, payload: Word ) -> Result<Word, Error>`[src]

Appends an OpSubgroupAvcSicGetInterRawSadsINTEL instruction to the current block.

Trait Implementations

`impl Default for Builder`[src]

`fn default() -> Builder`[src]

Auto Trait Implementations

`impl RefUnwindSafe for Builder`

`impl Send for Builder`

`impl Sync for Builder`

`impl Unpin for Builder`

`impl UnwindSafe for Builder`

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> From<T> for T`[src]

`fn from(t: T) -> T`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`fn into(self) -> U`[src]

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

[−][src]Struct rspirv::dr::Builder

Errors

Examples

Methods

impl Builder[src]

pub fn new() -> Builder[src]

pub fn set_version(&mut self, major: u8, minor: u8)[src]

pub fn module(self) -> Module[src]

pub fn id(&mut self) -> Word[src]

pub fn begin_function( &mut self, return_type: Word, function_id: Option<Word>, control: FunctionControl, function_type: Word) -> Result<Word, Error>[src]

pub fn end_function(&mut self) -> Result<(), Error>[src]

pub fn function_parameter(&mut self, result_type: Word) -> Result<Word, Error>[src]

pub fn begin_block(&mut self, label_id: Option<Word>) -> Result<Word, Error>[src]

pub fn capability(&mut self, capability: Capability)[src]

pub fn extension<T: Into<String>>(&mut self, extension: T)[src]

pub fn ext_inst_import<T: Into<String>>(&mut self, extended_inst_set: T) -> Word[src]

pub fn memory_model( &mut self, addressing_model: AddressingModel, memory_model: MemoryModel)[src]

pub fn entry_point<T: Into<String>, U: AsRef<[Word]>>( &mut self, execution_model: ExecutionModel, entry_point: Word, name: T, interface: U)[src]

pub fn execution_mode<T: AsRef<[u32]>>( &mut self, entry_point: Word, execution_mode: ExecutionMode, params: T)[src]

impl Builder[src]

pub fn type_void(&mut self) -> Word[src]

pub fn type_bool(&mut self) -> Word[src]

pub fn type_int(&mut self, width: u32, signedness: u32) -> Word[src]

pub fn type_float(&mut self, width: u32) -> Word[src]

pub fn type_vector( &mut self, component_type: Word, component_count: u32) -> Word[src]

pub fn type_matrix(&mut self, column_type: Word, column_count: u32) -> Word[src]

pub fn type_image( &mut self, sampled_type: Word, dim: Dim, depth: u32, arrayed: u32, ms: u32, sampled: u32, image_format: ImageFormat, access_qualifier: Option<AccessQualifier>) -> Word[src]

pub fn type_sampler(&mut self) -> Word[src]

pub fn type_sampled_image(&mut self, image_type: Word) -> Word[src]

pub fn type_array(&mut self, element_type: Word, length: Word) -> Word[src]

pub fn type_runtime_array(&mut self, element_type: Word) -> Word[src]

pub fn type_struct<T: AsRef<[Word]>>( &mut self, member_0_type_member_1_type: T) -> Word[src]

pub fn type_function<T: AsRef<[Word]>>( &mut self, return_type: Word, parameter_0_type_parameter_1_type: T) -> Word[src]

pub fn type_event(&mut self) -> Word[src]

pub fn type_device_event(&mut self) -> Word[src]

pub fn type_reserve_id(&mut self) -> Word[src]

pub fn type_queue(&mut self) -> Word[src]

pub fn type_pipe(&mut self, qualifier: AccessQualifier) -> Word[src]

pub fn type_pipe_storage(&mut self) -> Word[src]

pub fn type_named_barrier(&mut self) -> Word[src]

pub fn type_acceleration_structure_nv(&mut self) -> Word[src]

pub fn type_cooperative_matrix_nv( &mut self, component_type: Word, execution: Word, rows: Word, columns: Word) -> Word[src]

pub fn type_vme_image_intel(&mut self, image_type: Word) -> Word[src]

pub fn type_avc_ime_payload_intel(&mut self) -> Word[src]

pub fn type_avc_ref_payload_intel(&mut self) -> Word[src]

pub fn type_avc_sic_payload_intel(&mut self) -> Word[src]

pub fn type_avc_mce_payload_intel(&mut self) -> Word[src]

pub fn type_avc_mce_result_intel(&mut self) -> Word[src]

pub fn type_avc_ime_result_intel(&mut self) -> Word[src]

pub fn type_avc_ime_result_single_reference_streamout_intel(&mut self) -> Word[src]

pub fn type_avc_ime_result_dual_reference_streamout_intel(&mut self) -> Word[src]

pub fn type_avc_ime_single_reference_streamin_intel(&mut self) -> Word[src]

pub fn type_avc_ime_dual_reference_streamin_intel(&mut self) -> Word[src]

pub fn type_avc_ref_result_intel(&mut self) -> Word[src]

pub fn type_avc_sic_result_intel(&mut self) -> Word[src]

impl Builder[src]

pub fn constant_true(&mut self, result_type: Word) -> Word[src]

pub fn constant_false(&mut self, result_type: Word) -> Word[src]

pub fn constant_composite<T: AsRef<[Word]>>( &mut self, result_type: Word, constituents: T) -> Word[src]

pub fn constant_sampler( &mut self, result_type: Word, sampler_addressing_mode: SamplerAddressingMode, param: u32, sampler_filter_mode: SamplerFilterMode) -> Word[src]

pub fn constant_null(&mut self, result_type: Word) -> Word[src]

pub fn spec_constant_true(&mut self, result_type: Word) -> Word[src]

pub fn spec_constant_false(&mut self, result_type: Word) -> Word[src]

pub fn spec_constant_composite<T: AsRef<[Word]>>( &mut self, result_type: Word, constituents: T) -> Word[src]

pub fn spec_constant_op(&mut self, result_type: Word, opcode: Op) -> Word[src]

pub fn constant_pipe_storage( &mut self, result_type: Word, packet_size: u32, packet_alignment: u32, capacity: u32) -> Word[src]

impl Builder[src]

pub fn decorate<T: AsRef<[Operand]>>( &mut self, target: Word, decoration: Decoration, additional_params: T)[src]

pub fn member_decorate<T: AsRef<[Operand]>>( &mut self, structure_type: Word, member: u32, decoration: Decoration, additional_params: T)[src]

pub fn group_decorate<T: AsRef<[Word]>>( &mut self, decoration_group: Word, targets: T)[src]

pub fn group_member_decorate<T: AsRef<[(Word, u32)]>>( &mut self, decoration_group: Word, targets: T)[src]

pub fn decorate_id<T: AsRef<[Operand]>>( &mut self, target: Word, decoration: Decoration, additional_params: T)[src]

pub fn decorate_string<T: AsRef<[Operand]>>( &mut self, target: Word, decoration: Decoration, additional_params: T)[src]

pub fn decorate_string_google<T: AsRef<[Operand]>>( &mut self, target: Word, decoration: Decoration, additional_params: T)[src]

pub fn member_decorate_string<T: AsRef<[Operand]>>( &mut self, struct_type: Word, member: u32, decoration: Decoration, additional_params: T)[src]

pub fn member_decorate_string_google<T: AsRef<[Operand]>>( &mut self, struct_type: Word, member: u32, decoration: Decoration, additional_params: T)[src]

impl Builder[src]

pub fn branch(&mut self, target_label: Word) -> Result<(), Error>[src]

pub fn branch_conditional<T: AsRef<[u32]>>( &mut self, condition: Word, true_label: Word, false_label: Word, branch_weights: T) -> Result<(), Error>[src]

pub fn switch<T: AsRef<[(u32, Word)]>>( &mut self, selector: Word, default: Word, target: T) -> Result<(), Error>[src]

`impl Builder`[src]

`pub fn new() -> Builder`[src]

`pub fn set_version(&mut self, major: u8, minor: u8)`[src]

`pub fn module(self) -> Module`[src]

`pub fn id(&mut self) -> Word`[src]

`pub fn begin_function( &mut self, return_type: Word, function_id: Option<Word>, control: FunctionControl, function_type: Word ) -> Result<Word, Error>`[src]

`pub fn end_function(&mut self) -> Result<(), Error>`[src]

`pub fn function_parameter(&mut self, result_type: Word) -> Result<Word, Error>`[src]

`pub fn begin_block(&mut self, label_id: Option<Word>) -> Result<Word, Error>`[src]

`pub fn capability(&mut self, capability: Capability)`[src]

`pub fn extension<T: Into<String>>(&mut self, extension: T)`[src]

`pub fn ext_inst_import<T: Into<String>>(&mut self, extended_inst_set: T) -> Word`[src]

`pub fn memory_model( &mut self, addressing_model: AddressingModel, memory_model: MemoryModel )`[src]

`pub fn entry_point<T: Into<String>, U: AsRef<[Word]>>( &mut self, execution_model: ExecutionModel, entry_point: Word, name: T, interface: U )`[src]

`pub fn execution_mode<T: AsRef<[u32]>>( &mut self, entry_point: Word, execution_mode: ExecutionMode, params: T )`[src]

`impl Builder`[src]

`pub fn type_void(&mut self) -> Word`[src]

`pub fn type_bool(&mut self) -> Word`[src]

`pub fn type_int(&mut self, width: u32, signedness: u32) -> Word`[src]

`pub fn type_float(&mut self, width: u32) -> Word`[src]

`pub fn type_vector( &mut self, component_type: Word, component_count: u32 ) -> Word`[src]

`pub fn type_matrix(&mut self, column_type: Word, column_count: u32) -> Word`[src]

`pub fn type_image( &mut self, sampled_type: Word, dim: Dim, depth: u32, arrayed: u32, ms: u32, sampled: u32, image_format: ImageFormat, access_qualifier: Option<AccessQualifier> ) -> Word`[src]

`pub fn type_sampler(&mut self) -> Word`[src]

`pub fn type_sampled_image(&mut self, image_type: Word) -> Word`[src]

`pub fn type_array(&mut self, element_type: Word, length: Word) -> Word`[src]

`pub fn type_runtime_array(&mut self, element_type: Word) -> Word`[src]

`pub fn type_struct<T: AsRef<[Word]>>( &mut self, member_0_type_member_1_type: T ) -> Word`[src]

`pub fn type_function<T: AsRef<[Word]>>( &mut self, return_type: Word, parameter_0_type_parameter_1_type: T ) -> Word`[src]

`pub fn type_event(&mut self) -> Word`[src]

`pub fn type_device_event(&mut self) -> Word`[src]

`pub fn type_reserve_id(&mut self) -> Word`[src]

`pub fn type_queue(&mut self) -> Word`[src]

`pub fn type_pipe(&mut self, qualifier: AccessQualifier) -> Word`[src]

`pub fn type_pipe_storage(&mut self) -> Word`[src]

`pub fn type_named_barrier(&mut self) -> Word`[src]

`pub fn type_acceleration_structure_nv(&mut self) -> Word`[src]

`pub fn type_cooperative_matrix_nv( &mut self, component_type: Word, execution: Word, rows: Word, columns: Word ) -> Word`[src]

`pub fn type_vme_image_intel(&mut self, image_type: Word) -> Word`[src]

`pub fn type_avc_ime_payload_intel(&mut self) -> Word`[src]

`pub fn type_avc_ref_payload_intel(&mut self) -> Word`[src]

`pub fn type_avc_sic_payload_intel(&mut self) -> Word`[src]

`pub fn type_avc_mce_payload_intel(&mut self) -> Word`[src]

`pub fn type_avc_mce_result_intel(&mut self) -> Word`[src]

`pub fn type_avc_ime_result_intel(&mut self) -> Word`[src]

`pub fn type_avc_ime_result_single_reference_streamout_intel(&mut self) -> Word`[src]

`pub fn type_avc_ime_result_dual_reference_streamout_intel(&mut self) -> Word`[src]

`pub fn type_avc_ime_single_reference_streamin_intel(&mut self) -> Word`[src]

`pub fn type_avc_ime_dual_reference_streamin_intel(&mut self) -> Word`[src]

`pub fn type_avc_ref_result_intel(&mut self) -> Word`[src]

`pub fn type_avc_sic_result_intel(&mut self) -> Word`[src]

`impl Builder`[src]

`pub fn constant_true(&mut self, result_type: Word) -> Word`[src]

`pub fn constant_false(&mut self, result_type: Word) -> Word`[src]

`pub fn constant_composite<T: AsRef<[Word]>>( &mut self, result_type: Word, constituents: T ) -> Word`[src]

`pub fn constant_sampler( &mut self, result_type: Word, sampler_addressing_mode: SamplerAddressingMode, param: u32, sampler_filter_mode: SamplerFilterMode ) -> Word`[src]

`pub fn constant_null(&mut self, result_type: Word) -> Word`[src]

`pub fn spec_constant_true(&mut self, result_type: Word) -> Word`[src]

`pub fn spec_constant_false(&mut self, result_type: Word) -> Word`[src]

`pub fn spec_constant_composite<T: AsRef<[Word]>>( &mut self, result_type: Word, constituents: T ) -> Word`[src]

`pub fn spec_constant_op(&mut self, result_type: Word, opcode: Op) -> Word`[src]

`pub fn constant_pipe_storage( &mut self, result_type: Word, packet_size: u32, packet_alignment: u32, capacity: u32 ) -> Word`[src]

`impl Builder`[src]

`pub fn decorate<T: AsRef<[Operand]>>( &mut self, target: Word, decoration: Decoration, additional_params: T )`[src]

`pub fn member_decorate<T: AsRef<[Operand]>>( &mut self, structure_type: Word, member: u32, decoration: Decoration, additional_params: T )`[src]

`pub fn group_decorate<T: AsRef<[Word]>>( &mut self, decoration_group: Word, targets: T )`[src]

`pub fn group_member_decorate<T: AsRef<[(Word, u32)]>>( &mut self, decoration_group: Word, targets: T )`[src]

`pub fn decorate_id<T: AsRef<[Operand]>>( &mut self, target: Word, decoration: Decoration, additional_params: T )`[src]

`pub fn decorate_string<T: AsRef<[Operand]>>( &mut self, target: Word, decoration: Decoration, additional_params: T )`[src]

`pub fn decorate_string_google<T: AsRef<[Operand]>>( &mut self, target: Word, decoration: Decoration, additional_params: T )`[src]

`pub fn member_decorate_string<T: AsRef<[Operand]>>( &mut self, struct_type: Word, member: u32, decoration: Decoration, additional_params: T )`[src]

`pub fn member_decorate_string_google<T: AsRef<[Operand]>>( &mut self, struct_type: Word, member: u32, decoration: Decoration, additional_params: T )`[src]

`impl Builder`[src]

`pub fn branch(&mut self, target_label: Word) -> Result<(), Error>`[src]

`pub fn branch_conditional<T: AsRef<[u32]>>( &mut self, condition: Word, true_label: Word, false_label: Word, branch_weights: T ) -> Result<(), Error>`[src]

`pub fn switch<T: AsRef<[(u32, Word)]>>( &mut self, selector: Word, default: Word, target: T ) -> Result<(), Error>`[src]

`pub fn kill(&mut self) -> Result<(), Error>`[src]

`pub fn ret(&mut self) -> Result<(), Error>`[src]

`pub fn ret_value(&mut self, value: Word) -> Result<(), Error>`[src]

`pub fn unreachable(&mut self) -> Result<(), Error>`[src]