Vu (Virtual Universe) 3D Engine

Use the following aliases and functions in your ~/.bashrc to streamline Go development, Git operations, and file editing.

Key Aliases

• Go Build: gb (standard), gd (with debug tags), gbwin (Windows GUI mode, no console), gbrel (Windows release mode, stripped).
• Git: gl (formatted log).
• Vim: vi (opens in tabs).

Custom Functions

• rgv: Uses ripgrep to find files matching a pattern and opens them in Vim tabs.

Environment Variables

• Ensure PATH includes ~/bin and the Windows SDK path if packaging Windows Store apps.

# needed for bash shared by all users.
cd $HOME

# edit files that match a ripgrep pattern
function rgv {
	vi -p $(rg -l $1)
}

# open vim files in tabs.
alias vi='vim -p'

# golang
alias gb='go build'
alias gd='go build --tags debug'
# build windows app without console popping up.
alias gbwin='go build -ldflags "-H windowsgui"'
alias gbrel='go build -ldflags "-H windowsgui -s -w"'

# put the following in .inputrc
#set bell-style none

# git
alias gl='git log --date=short --pretty=format:"%C(yellow)%h%Cblue%>(12)%ad %Cgreen%<(7)%aN %Cred%d%Creset %s"'

# git aware prompt
export PS1="\[\e[32m\][\w]\e[89m\$(GIT_PS1_SHOWDIRTYSTATE=1 __git_ps1)\e[00m $ "
# add local binaries
export PATH=$PATH:~/bin
# add windows SDK for packaging windows store apps
export PATH=$PATH:"/c/Program Files (x86)/Windows Kits/10/bin/10.0.26100.0/x64/"

To support the project's workflow, use a .vimrc configured for Go and GLSL development. Key features include:

• Go Integration: Automatically runs gofmt on save and sets go build as the makeprg for the quickfix window.
• GLSL Support: Enables syntax highlighting for .frag, .vert, and .glsl files.
• Tab Management: Configured for heavy tab usage with shortcuts for switching and editing.
• Formatting: Includes a command to clear trailing whitespace and a custom GoFmt command.

Recommended .vimrc configuration

"prevent backup files
set nobackup nowritebackup

" want some nice colors
syntax on
set background=dark
colorscheme solarized

" turn on nice indenting with 4 spaces per tab.
set tabstop=4 shiftwidth=4 expandtab
set laststatus=2
" turn on the status line so line numbers are there too.
set statusline=%t\ %y\ format:\ %{&ff};\ [%c,%l]
" allow lots of tabs.
set tabpagemax=100

" vim-tabs
set tabpagemax=50
nnoremap <S-l> :tabnext<CR>
noremap <S-h> :tabprevious<CR>
noremap tt :tabedit<Space>
noremap tn :tabm<Space>

" save with Control-X
noremap <C-x> :w<CR>

" clear trailing spaces with \s
noremap \s ::%s/\s\+$//e<CR>

" highlight trailing whitespace
highlight ExtraWhitespace ctermbg=red guibg=red
match ExtraWhitespace /\s\+$/

" glsl syntax highlighting
" from https://www.vim.org/scripts/script.php?script_id=1002
augroup glsl_syntax
	autocmd!
	autocmd BufNewFile,BufRead *.frag,*.vert,*.glsl setf glsl
augroup END

" gofmt based on https://stackoverflow.com/questions/72135274/run-gofmt-on-vim-without-plugin
function! GoFmt()
	cexpr system('gofmt -e -w ' . expand('%'))
	edit!
endfunction
command! GoFmt call GoFmt()
augroup go_autocmd
	autocmd BufWritePost *.go GoFmt
augroup END

" go compile
autocmd Filetype go set makeprg=go\ build
autocmd QuickFixCmdPost [^l]* cwindow
noremap <F5> :silent make<CR><C-L><CR>

" use existing tabs or switch to a new tab
set switchbuf+=usetab,newtab

The vu development environment varies by platform. Ensure you have the following tools installed to maintain compatibility with the project's build and runtime requirements.

Essential Tools (All Platforms)

• Go: The primary programming language.
• Vulkan SDK: For graphics.
• OpenAL + OpenAL-Soft: For audio.

Platform Specifics

Windows

• Git for Windows: Provides git, vim, and bash.
• Windows Terminal: Use with a bash shell.
• RenderDoc: For graphics debugging.
• glslc: For compiling shaders.
• Note: The project prefers syscall over c-go on Windows.

macOS (+ iOS)

• Xcode Developer Tools: Provides git, vim, zsh, and clang.
• Note: c-go is required (via clang) until purego or an equivalent is implemented.

Recommended Utilities

• Font: Hack font.
• Search/Analysis: ripgrep (search), tre (list), and tokei (code count).
• Asset Creation: Blender (3D), Krita (2D), and Audacity (audio).

Use the following configuration in ~/.zshrc to enable colorized terminals, Git-friendly prompts, and Go development aliases.

Key Aliases

• Go Build: gb (standard), gd (with debug tags).
• Git: gl (formatted log).
• Vim: vi (opens in tabs).

Features

• Git Integration: Uses vcs_info to provide a Git-aware prompt.
• History Management: Ignores duplicate commands and specific commands like ls, fg, and exit.
• Terminal Colors: Enables CLICOLOR and colorized grep output.

# colour the terminal
export CLICOLOR=1
export GREP_OPTIONS='--color=auto'

# use tabbed vim
export EDITOR=vim
alias vi='vim -v -p'

# add local commands
path+=('/usr/local/go/bin')
path+=('/Users/rust/bin')
export PATH

# customize the prompt : https://jonasjacek.github.io/colors/
# 0-15 are the solorized colors in terminal preferences.
export PROMPT='%(?.%F{3}√.%F{1}?%?)%f %F{3}%~%f %# '
# make it git friendly.
autoload -Uz vcs_info
precmd_vcs_info() { vcs_info }
precmd_functions+=( precmd_vcs_info )
setopt prompt_subst
RPROMPT=\$vcs_info_msg_0_
zstyle ':vcs_info:git:*' formats '%F{3}(%b)%f'

# Ignore duplicate commands in history
export HISTORY_IGNORE='(ls|fg|bg|exit)'
setopt hist_ignore_all_dups
setopt hist_find_no_dups
setopt hist_ignore_space
# Dont add ignored commands to history.
zshaddhistory() {
  emulate -L zsh
  ## uncomment if HISTORY_IGNORE
  ## should use EXTENDED_GLOB syntax
  setopt extendedglob
  [[ $1 != ~{$HISTORY_IGNORE} ]]
}

# golang
alias gb='go build'
alias gd='go build --tags debug'

# git
alias gl='git log --date=short --pretty=format:"%C(yellow)%h%Cblue%>(12)%ad %Cgreen%<(7)%aN %Cred%d%Creset %s"'

In vu, an asset is a uniquely identified resource (like a texture or mesh) used to create game objects. Assets are identified by an aid (Asset ID), which is a uint64 hash generated from a combination of the asset's name and its assetType.

To determine the type of an asset from its ID, use the kind() method on an aid. This returns the assetType as a uint32.

Supported assetType values:

• fnt (font)
• shd (shader configuration)
• mat (material)
• msh (mesh)
• tex (texture)
• aud (audio)
• anm (animation rig and skin)

// Example of how asset types are categorized
type assetType uint32

const (
	fnt assetType = iota // font
	shd                  // shader configuration
	mat                  // material
	msh                  // mesh
	tex                  // texture
	aud                  // audio
	anm                  // animation rig and skin
	assetTypes            // end of asset types
)

// kind returns the type of asset data for this aid.
func (a aid) kind() uint32 { return uint32(a & math.MaxUint8) }

To run the engine, you must implement the Loader and Updater interfaces and pass them to eng.Run().

• Loader: Implements Load(eng *Engine) error. Called once at startup to initialize your game state.
• Updater: Implements FrameUpdate and FixedUpdate.
  • FrameUpdate(eng *Engine, i *Input, delta time.Duration, interpolate float64): Called every render frame. Use delta for frame-dependent logic and interpolate for smooth rendering between physics steps. Process input.Pressed and input.Released here.
  • FixedUpdate(eng *Engine, i *Input, step time.Duration): Called at a fixed interval (60Hz) for physics. Use step for physics calculations. Process input.Down here.

type MyGame struct{}

func (g *MyGame) Load(eng *vu.Engine) error {
	// Initialize scenes, entities, etc.
	return nil
}

func (g *MyGame) FrameUpdate(eng *vu.Engine, i *vu.Input, delta time.Duration, interpolate float64) {
	// Handle frame-based logic and input.Pressed/Released
}

func (g *MyGame) FixedUpdate(eng *vu.Engine, i *vu.Input, step time.Duration) {
	// Handle physics and input.Down
}