The term direct addressing implies the address to be directly included in the instruction is an operand. One of the examples may be a far call/jmp. Most of Windows, executables are loaded at address 0x00400000 with the first section, which is by default the code section being loaded at address 0x00401000. For the sake of the example, let us imagine that we have an executable which, we are sure, is loaded at the aforementioned address, with its code section being located at offset 0x1000 from the base address (the address our executable is loaded at), and we have some sort of a special code right in the beginning of the first section. Let it be an error handler that would terminate the execution of our program in the right way. In such a case, we may direct the execution flow to that code by using either a far call or a far jump:

; The following call would be encoded as (address is underlined):
; 0xff 0x1d 0x00 0x10 0x40 0x00
call far [0x00401000] 

; or as
; 0xff 0x2d 0x00 0x10 0x40 0x00
jmp far [0x00401000]

However, the more common example would be the register call, where the target address is stored in a register:

lea rax, [my_proc]
call rax

In the preceding code, we loaded the RAX register with the address of the my_proc procedure that we want to call on the first line, and the second line is the call itself. Such a mode is used, for example, by compilers when translating the switch clause to Assembly, when the address of the code corresponding to a specific case is either loaded from the jump table or calculated using some hardcoded base (it may well be relocated at execution time) and an offset taken from the jump table.