[−][src]Struct ggbasm::RomBuilder
Keeps track of the state of a rom as it is being constructed.
Keeps track of the current address and inserts binary data and instructions at that address. The address is advanced when binary data or instructions are added and can also be manually advanced. When manually advanced the area in between is filled with zeroes. The address can only be advanced, it can never go backwards.
In *.asm files, the advance_address instruction will cause the space between the last instruction . and the new address to be filled with zeroes.
Implementations
impl RomBuilder[src]
pub fn new() -> Result<RomBuilder, Error>[src]
Creates a RomBuilder.
pub fn add_basic_interrupts_and_jumps(mut self: Self) -> Result<Self, Error>[src]
Adds basic interrupt and jump data from 0x0000 to 0x0103.
The entry point jumps to 0x0150. The interrupts return immediately. The RST commands jump to the entry point. Returns an error if the RomBuilder address is not at 0x0000.
pub fn add_header(mut self: Self, header: Header) -> Result<Self, Error>[src]
Adds provided header data at 0x0104 to 0x149.
Returns an error if the RomBuilder address is not at 0x104
pub fn add_bytes(
mut self: Self,
bytes: Vec<u8>,
identifier: &str
) -> Result<Self, Error>[src]
mut self: Self,
bytes: Vec<u8>,
identifier: &str
) -> Result<Self, Error>
Includes raw bytes in the rom. The name is used to reference the address in assembly code. Returns an error if crosses rom bank boundaries.
pub fn add_image(
mut self: Self,
file_name: &str,
identifier: &str,
color_map: &HashMap<Color, u8>
) -> Result<Self, Error>[src]
mut self: Self,
file_name: &str,
identifier: &str,
color_map: &HashMap<Color, u8>
) -> Result<Self, Error>
Includes graphics data generated from the provided image file in the graphics folder.
The name is used to reference the address in assembly code. Returns an error if crosses rom bank boundaries. The color_map argument specifes how to convert 24 bit rgb color values into the 2 bit color values used by the gameboy.
TODO: Describe the format of generated images.
pub fn add_audio_file(self, file_name: &str) -> Result<Self, Error>[src]
Includes audio data generated from the provided ggbasm audio text file in the audio folder.
Returns an error if crosses rom bank boundaries.
Currently only supports playing one track at a time, playing sound effects on top of background music might not be possible with the current architecture. Oops...
Format
There are long lines containing the data for each sound register and how long to wait before running the next command. There are also various commands to e.g. set a label or continue playing from a specific label
label my_cool_song
07 D6:2:10:7:4Y:NY
07 D6:2:10:7:4Y:NY
07 D6:2:10:7:4Y:NY:Y00
07 D6:2:10:7:4Y:NY
07 D6:2:10:7:4Y:NY:Y00 D6:2:10:7:4Y:NY
playfrom my_cool_song
Channel formats
Data for each channel is written on the same line like this:
RST CHANNEL1 CHANNEL2 CHANNEL3 CHANNEL4
0F D6:2:10:7:4Y:NY:Y00 D6:2:10:7:4Y:NY TODO TODO
Only changes between lines are included in the audio data.
Channel 1 format:
AB:C:DD:E:FG:HI:JKL
Key:
- A: Note A-G (natural), a-g (sharp)
- B: Octave 1-8
- C: Duty 0-3
- DD: length 0-3F
- E: envelope initial volume 0-F
- F: envelope argument 0-7
- G: envelope increase Y/N
- H: enable length Y/N
- I: initial Y/N
- J: sweep increase Y/N
- K: sweep time 0-7
- L: number of sweeps 0-7
For example: D6:2:10:7:4Y:NY:Y00
Channel 2 format:
AB:C:DD:E:FG:HI
Key:
- A: Note A-G (natural), a-g (sharp)
- B: Octave 1-8
- C: Duty 0-3
- DD: length 0-3F
- E: envelope initial volume 0-F
- F: envelope argument 0-7
- G: envelope increase Y/N
- H: enable length Y/N
- I: initial Y/N
For example: D6:2:10:7:4Y:NY
Channel 3 format:
TODO
Channel 4 format:
TODO
Control lines
- rest AA - rest AA frames before continuing
- jp foo - set the GGBASMAudio
- disable - disables audio by setting the value at GGBASMAudioEnable to 0
TODO: Maybe syntax highlighting could help make the audio format more readable
pub fn add_audio_player(self) -> Result<Self, Error>[src]
Includes bytecodes generated from the audio player
Returns an error if crosses rom bank boundaries.
Functions
This should be called once during initialization:
call GGBASMInitAudio
This should be called once per frame:
call GGBASMStepAudio
RAM Locations
These identifiers need to be set to some unused ram values.
GGBASMAudioEnable EQU 0xC020 ; dont process music when 0 otherwise process it
GGBASMAudioBank EQU 0xC021 ; the bank the currently playing song is stored on
GGBASMAudioPointerLo EQU 0xC022 ; pointer to the currently playing song
GGBASMAudioPointerHi EQU 0xC023
GGBASMAudioRest EQU 0xC024 ; rest for this many steps
Change the currently playing song by setting GGBASMAudioBank, GGBASMAudioPointerHi and GGBASMAudioPointerLo to the address of the song you want to play
Make sure the memory is accessible (correct bank enabled) whenever an audio function is called.
pub fn add_asm_file(self, file_name: &str) -> Result<Self, Error>[src]
Includes bytecodes generated from the provided assembly file in the gbasm folder.
TODO: Document the syntax. Its very similar to the RGBDS syntax with the addition of the advance_address command. However we should have our syntax documentation listing every instruction and every operator in rom compile time expressions.
Returns an error if crosses rom bank boundaries. Returns an error if encounters file system issues.
pub fn add_instructions(
self,
instructions: Vec<Instruction>
) -> Result<Self, Error>[src]
self,
instructions: Vec<Instruction>
) -> Result<Self, Error>
This function is used to include instructions in the rom. Returns an error if crosses rom bank boundaries.
pub fn advance_address(
mut self: Self,
rom_bank: u32,
address: u32
) -> Result<Self, Error>[src]
mut self: Self,
rom_bank: u32,
address: u32
) -> Result<Self, Error>
Sets the current address and bank as specified. Returns an error if attempts to go backwards. To cross bank boundaries you need to use this function.
pub fn get_address_global(&self) -> u32[src]
Gets the current address within the entire rom.
pub fn get_address_bank(&self) -> u16[src]
Gets the current address within the current bank.
pub fn get_bank(&self) -> u32[src]
Gets the current bank.
pub fn print_variables_by_value(self) -> Result<Self, Error>[src]
pub fn print_variables_by_identifier(self) -> Result<Self, Error>[src]
pub fn compile(mut self: Self) -> Result<Vec<u8>, Error>[src]
Compiles assembly and binary data into binary rom data.
pub fn write_to_disk(self, name: &str) -> Result<(), Error>[src]
Compile the ROM then write it to disk at the root of the project. The root of the project is the outermost directory containing a Cargo.toml file.
pub fn write_to_disk_html(self, _name: &str) -> Result<(), Error>[src]
Provide some sort of mechanism to generate an html file with embedded gb emulator and rom data. Use Cargo.toml metadata to generate a link to repository, include developers name etc. (use panic-handler as a reference here) This is completely unimplemented, its just a reminder to do this some day.
Auto Trait Implementations
impl RefUnwindSafe for RomBuilder[src]
impl Send for RomBuilder[src]
impl Sync for RomBuilder[src]
impl Unpin for RomBuilder[src]
impl UnwindSafe for RomBuilder[src]
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized, [src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized, [src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized, [src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T[src]
impl<T> Conv for T
impl<T> Conv for T
impl<T> FmtForward for T
pub fn fmt_binary(self) -> FmtBinary<Self> where
Self: Binary,
Self: Binary,
pub fn fmt_display(self) -> FmtDisplay<Self> where
Self: Display,
Self: Display,
pub fn fmt_lower_exp(self) -> FmtLowerExp<Self> where
Self: LowerExp,
Self: LowerExp,
pub fn fmt_lower_hex(self) -> FmtLowerHex<Self> where
Self: LowerHex,
Self: LowerHex,
pub fn fmt_octal(self) -> FmtOctal<Self> where
Self: Octal,
Self: Octal,
pub fn fmt_pointer(self) -> FmtPointer<Self> where
Self: Pointer,
Self: Pointer,
pub fn fmt_upper_exp(self) -> FmtUpperExp<Self> where
Self: UpperExp,
Self: UpperExp,
pub fn fmt_upper_hex(self) -> FmtUpperHex<Self> where
Self: UpperHex,
Self: UpperHex,
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
U: From<T>, [src]
U: From<T>,
impl<T> Pipe for T where
T: ?Sized,
T: ?Sized,
pub fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,
R: 'a,
pub fn pipe_ref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self) -> R
) -> R where
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut Self) -> R
) -> R where
R: 'a,
pub fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where
Self: Borrow<B>,
B: 'a + ?Sized,
R: 'a,
Self: Borrow<B>,
B: 'a + ?Sized,
R: 'a,
pub fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
B: 'a + ?Sized,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
B: 'a + ?Sized,
R: 'a,
pub fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where
Self: AsRef<U>,
U: 'a + ?Sized,
R: 'a,
Self: AsRef<U>,
U: 'a + ?Sized,
R: 'a,
pub fn pipe_as_mut<'a, U, R>(
&'a mut self,
func: impl FnOnce(&'a mut U) -> R
) -> R where
Self: AsMut<U>,
U: 'a + ?Sized,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut U) -> R
) -> R where
Self: AsMut<U>,
U: 'a + ?Sized,
R: 'a,
pub fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,
pub fn pipe_deref_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: DerefMut<Target = T> + Deref,
T: 'a + ?Sized,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: DerefMut<Target = T> + Deref,
T: 'a + ?Sized,
R: 'a,
impl<T> Pipe for T
impl<T> PipeAsRef for T
pub fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: AsRef<T>,
T: 'a,
R: 'a,
Self: AsRef<T>,
T: 'a,
R: 'a,
pub fn pipe_as_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,
impl<T> PipeBorrow for T
pub fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Borrow<T>,
T: 'a,
R: 'a,
Self: Borrow<T>,
T: 'a,
R: 'a,
pub fn pipe_borrow_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,
impl<T> PipeDeref for T
pub fn pipe_deref<'a, R>(
&'a self,
func: impl FnOnce(&'a Self::Target) -> R
) -> R where
Self: Deref,
R: 'a,
&'a self,
func: impl FnOnce(&'a Self::Target) -> R
) -> R where
Self: Deref,
R: 'a,
pub fn pipe_deref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,
impl<T> PipeRef for T
pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,
R: 'a,
pub fn pipe_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,
R: 'a,
impl<T> Pointable for T
pub const ALIGN: usize
type Init = T
The type for initializers.
pub unsafe fn init(init: <T as Pointable>::Init) -> usize
pub unsafe fn deref<'a>(ptr: usize) -> &'a T
pub unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
pub unsafe fn drop(ptr: usize)
impl<T> Tap for T
pub fn tap(self, func: impl FnOnce(&Self)) -> Self
pub fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self
pub fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
Self: Borrow<B>,
B: ?Sized,
pub fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
Self: BorrowMut<B>,
B: ?Sized,
pub fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,
Self: AsRef<R>,
R: ?Sized,
pub fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
Self: AsMut<R>,
R: ?Sized,
pub fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized,
Self: Deref<Target = T>,
T: ?Sized,
pub fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self where
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
pub fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
pub fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
pub fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
Self: Borrow<B>,
B: ?Sized,
pub fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
Self: BorrowMut<B>,
B: ?Sized,
pub fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,
Self: AsRef<R>,
R: ?Sized,
pub fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
Self: AsMut<R>,
R: ?Sized,
pub fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized,
Self: Deref<Target = T>,
T: ?Sized,
pub fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self where
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
impl<T> Tap for T
pub fn tap<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,
F: FnOnce(&Self) -> R,
pub fn tap_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,
F: FnOnce(&Self) -> R,
pub fn tap_mut<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
F: FnOnce(&mut Self) -> R,
pub fn tap_mut_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
F: FnOnce(&mut Self) -> R,
impl<T, U> TapAsRef<U> for T where
U: ?Sized,
U: ?Sized,
pub fn tap_ref<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,
Self: AsRef<T>,
F: FnOnce(&T) -> R,
pub fn tap_ref_dbg<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,
Self: AsRef<T>,
F: FnOnce(&T) -> R,
pub fn tap_ref_mut<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
pub fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
impl<T, U> TapBorrow<U> for T where
U: ?Sized,
U: ?Sized,
pub fn tap_borrow<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
Self: Borrow<T>,
F: FnOnce(&T) -> R,
pub fn tap_borrow_dbg<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
Self: Borrow<T>,
F: FnOnce(&T) -> R,
pub fn tap_borrow_mut<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
pub fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
impl<T> TapDeref for T
pub fn tap_deref<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,
Self: Deref,
F: FnOnce(&Self::Target) -> R,
pub fn tap_deref_dbg<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,
Self: Deref,
F: FnOnce(&Self::Target) -> R,
pub fn tap_deref_mut<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
pub fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
impl<T> TryConv for T
impl<T> TryConv for T
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]
U: TryFrom<T>,