knightfox75/nds_nflib
1
Fork 0
mirror of https://github.com/knightfox75/nds_nflib.git synced 2025-06-18 16:55:32 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity

build: Reorganize directories

Browse Source 
- Bring the source and include directories in nflib to the root of the
  repository to match the organization of other libraries.

- Expect users to install NFlib in the devkitPro folder.

- Update all Makefiles for modern devkitPro.

- Remove all redundant copies of NFlib in all examples. The only
  remaining copy of the library is in the extras/wifi example, but
  that one includes more files, so I have left it untouched for now.
This commit is contained in:
Antonio Niño Díaz 2022-11-08 01:13:23 +00:00
parent a8c42cf530
commit daee0a3334
966 changed files with 6114 additions and 102773 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
nflib/Makefile → Makefile
View File

@ -15,7 +15,7 @@ include $(DEVKITARM)/ds_rules
# DATA is a list of directories containing data files
# INCLUDES is a list of directories containing header files
#---------------------------------------------------------------------------------
TARGET := $(shell basename $(CURDIR))
TARGET := nflib
BUILD := build
SOURCES := source
DATA := data

222
examples/3dsprites/alpha/Makefile Normal file
View File

@ -0,0 +1,222 @@
#---------------------------------------------------------------------------------
.SUFFIXES:
#---------------------------------------------------------------------------------
ifeq ($(strip $(DEVKITARM)),)
$(error "Please set DEVKITARM in your environment. export DEVKITARM=<path to>devkitARM")
endif
# These set the information text in the nds file
#GAME_TITLE := My Wonderful Homebrew
#GAME_SUBTITLE1 := built with devkitARM
#GAME_SUBTITLE2 := http://devitpro.org
include $(DEVKITARM)/ds_rules
#---------------------------------------------------------------------------------
# TARGET is the name of the output
# BUILD is the directory where object files & intermediate files will be placed
# SOURCES is a list of directories containing source code
# INCLUDES is a list of directories containing extra header files
# DATA is a list of directories containing binary files embedded using bin2o
# GRAPHICS is a list of directories containing image files to be converted with grit
# AUDIO is a list of directories containing audio to be converted by maxmod
# ICON is the image used to create the game icon, leave blank to use default rule
# NITRO is a directory that will be accessible via NitroFS
#---------------------------------------------------------------------------------
TARGET := $(shell basename $(CURDIR))
BUILD := build
SOURCES := source
INCLUDES := include
DATA := data
GRAPHICS :=
AUDIO :=
ICON :=
# specify a directory which contains the nitro filesystem
# this is relative to the Makefile
NITRO := nitrofiles
#---------------------------------------------------------------------------------
# options for code generation
#---------------------------------------------------------------------------------
ARCH := -marm -mthumb-interwork -march=armv5te -mtune=arm946e-s
CFLAGS := -g -Wall -O3\
$(ARCH) $(INCLUDE) -DARM9
CXXFLAGS := $(CFLAGS) -fno-rtti -fno-exceptions
ASFLAGS := -g $(ARCH)
LDFLAGS = -specs=ds_arm9.specs -g $(ARCH) -Wl,-Map,$(notdir $*.map)
#---------------------------------------------------------------------------------
# any extra libraries we wish to link with the project (order is important)
#---------------------------------------------------------------------------------
LIBS := -lnflib
# automatigically add libraries for NitroFS
ifneq ($(strip $(NITRO)),)
LIBS := $(LIBS) -lfilesystem -lfat
endif
# automagically add maxmod library
ifneq ($(strip $(AUDIO)),)
LIBS := $(LIBS) -lmm9
endif
LIBS := $(LIBS) -lnds9
#---------------------------------------------------------------------------------
# list of directories containing libraries, this must be the top level containing
# include and lib
#---------------------------------------------------------------------------------
LIBDIRS := $(LIBNDS) $(PORTLIBS) $(DEVKITPRO)/nflib
#---------------------------------------------------------------------------------
# no real need to edit anything past this point unless you need to add additional
# rules for different file extensions
#---------------------------------------------------------------------------------
ifneq ($(BUILD),$(notdir $(CURDIR)))
#---------------------------------------------------------------------------------
export OUTPUT := $(CURDIR)/$(TARGET)
export VPATH := $(CURDIR)/$(subst /,,$(dir $(ICON)))\
$(foreach dir,$(SOURCES),$(CURDIR)/$(dir))\
$(foreach dir,$(DATA),$(CURDIR)/$(dir))\
$(foreach dir,$(GRAPHICS),$(CURDIR)/$(dir))
export DEPSDIR := $(CURDIR)/$(BUILD)
CFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
CPPFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
SFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
PNGFILES := $(foreach dir,$(GRAPHICS),$(notdir $(wildcard $(dir)/*.png)))
BINFILES := $(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
# prepare NitroFS directory
ifneq ($(strip $(NITRO)),)
export NITRO_FILES := $(CURDIR)/$(NITRO)
endif
# get audio list for maxmod
ifneq ($(strip $(AUDIO)),)
export MODFILES := $(foreach dir,$(notdir $(wildcard $(AUDIO)/*.*)),$(CURDIR)/$(AUDIO)/$(dir))
# place the soundbank file in NitroFS if using it
ifneq ($(strip $(NITRO)),)
export SOUNDBANK := $(NITRO_FILES)/soundbank.bin
# otherwise, needs to be loaded from memory
else
export SOUNDBANK := soundbank.bin
BINFILES += $(SOUNDBANK)
endif
endif
#---------------------------------------------------------------------------------
# use CXX for linking C++ projects, CC for standard C
#---------------------------------------------------------------------------------
ifeq ($(strip $(CPPFILES)),)
#---------------------------------------------------------------------------------
export LD := $(CC)
#---------------------------------------------------------------------------------
else
#---------------------------------------------------------------------------------
export LD := $(CXX)
#---------------------------------------------------------------------------------
endif
#---------------------------------------------------------------------------------
export OFILES_BIN := $(addsuffix .o,$(BINFILES))
export OFILES_SOURCES := $(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
export OFILES := $(PNGFILES:.png=.o) $(OFILES_BIN) $(OFILES_SOURCES)
export HFILES := $(PNGFILES:.png=.h) $(addsuffix .h,$(subst .,_,$(BINFILES)))
export INCLUDE := $(foreach dir,$(INCLUDES),-iquote $(CURDIR)/$(dir))\
$(foreach dir,$(LIBDIRS),-I$(dir)/include)\
-I$(CURDIR)/$(BUILD)
export LIBPATHS := $(foreach dir,$(LIBDIRS),-L$(dir)/lib)
ifeq ($(strip $(ICON)),)
icons := $(wildcard *.bmp)
ifneq (,$(findstring $(TARGET).bmp,$(icons)))
export GAME_ICON := $(CURDIR)/$(TARGET).bmp
else
ifneq (,$(findstring icon.bmp,$(icons)))
export GAME_ICON := $(CURDIR)/icon.bmp
endif
endif
else
ifeq ($(suffix $(ICON)), .grf)
export GAME_ICON := $(CURDIR)/$(ICON)
else
export GAME_ICON := $(CURDIR)/$(BUILD)/$(notdir $(basename $(ICON))).grf
endif
endif
.PHONY: $(BUILD) clean
#---------------------------------------------------------------------------------
$(BUILD):
@mkdir -p $@
@$(MAKE) --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
#---------------------------------------------------------------------------------
clean:
@echo clean ...
@rm -fr $(BUILD) $(TARGET).elf $(TARGET).nds $(SOUNDBANK)
#---------------------------------------------------------------------------------
else
#---------------------------------------------------------------------------------
# main targets
#---------------------------------------------------------------------------------
$(OUTPUT).nds: $(OUTPUT).elf $(NITRO_FILES) $(GAME_ICON)
$(OUTPUT).elf: $(OFILES)
# source files depend on generated headers
$(OFILES_SOURCES) : $(HFILES)
# need to build soundbank first
$(OFILES): $(SOUNDBANK)
#---------------------------------------------------------------------------------
# rule to build solution from music files
#---------------------------------------------------------------------------------
$(SOUNDBANK) : $(MODFILES)
#---------------------------------------------------------------------------------
mmutil $^ -d -o$@ -hsoundbank.h
#---------------------------------------------------------------------------------
%.bin.o %_bin.h : %.bin
#---------------------------------------------------------------------------------
@echo $(notdir $<)
@$(bin2o)
#---------------------------------------------------------------------------------
# This rule creates assembly source files using grit
# grit takes an image file and a .grit describing how the file is to be processed
# add additional rules like this for each image extension
# you use in the graphics folders
#---------------------------------------------------------------------------------
%.s %.h: %.png %.grit
#---------------------------------------------------------------------------------
grit $< -fts -o$*
#---------------------------------------------------------------------------------
# Convert non-GRF game icon to GRF if needed
#---------------------------------------------------------------------------------
$(GAME_ICON): $(notdir $(ICON))
#---------------------------------------------------------------------------------
@echo convert $(notdir $<)
@grit $< -g -gt -gB4 -gT FF00FF -m! -p -pe 16 -fh! -ftr
-include $(DEPSDIR)/*.d
#---------------------------------------------------------------------------------------
endif
#---------------------------------------------------------------------------------------

5
examples/3dsprites/alpha/clean.bat
View File

@ -1,5 +0,0 @@
@echo off
cls
make clean
pause
exit

5
examples/3dsprites/alpha/compile.bat
View File

@ -1,5 +0,0 @@
@echo off
cls
make
pause
exit

BIN
examples/3dsprites/alpha/icon.bmp
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 1.1 KiB

186
examples/3dsprites/alpha/makefile
View File

@ -1,186 +0,0 @@
#---------------------------------------------------------------------------------
# Makefile for NightFox's Lib Projects
#---------------------------------------------------------------------------------
#---------------------------------------------------------------------------------
.SUFFIXES:
#---------------------------------------------------------------------------------
ifeq ($(strip $(DEVKITARM)),)
$(error "Please set DEVKITARM in your environment. export DEVKITARM=<path to>devkitARM")
endif
#---------------------------------------------------------------------------------
# This part substitutes this include:
# include $(DEVKITARM)/ds_rules
# This allows you to set ROM info and icon easy
# Please update this block from DS_RULES file at every DEVKITARM update
#---------------------------------------------------------------------------------
include $(DEVKITARM)/base_rules
LIBNDS := $(DEVKITPRO)/libnds
GAME_TITLE := Text 1
GAME_SUBTITLE1 := Text 2
GAME_SUBTITLE2 := Text 3
GAME_ICON := $(CURDIR)/../icon.bmp
_ADDFILES := -d $(NITRO_FILES)
#---------------------------------------------------------------------------------
%.nds: %.arm9
@ndstool -c $@ -9 $< -b $(GAME_ICON) "$(GAME_TITLE);$(GAME_SUBTITLE1);$(GAME_SUBTITLE2)" $(_ADDFILES)
@echo built ... $(notdir $@)
#---------------------------------------------------------------------------------
%.nds: %.elf
@ndstool -c $@ -9 $< -b $(GAME_ICON) "$(GAME_TITLE);$(GAME_SUBTITLE1);$(GAME_SUBTITLE2)" $(_ADDFILES)
@echo built ... $(notdir $@)
#---------------------------------------------------------------------------------
%.arm9: %.elf
@$(OBJCOPY) -O binary $< $@
@echo built ... $(notdir $@)
#---------------------------------------------------------------------------------
%.arm7: %.elf
@$(OBJCOPY) -O binary $< $@
@echo built ... $(notdir $@)
#---------------------------------------------------------------------------------
%.elf:
@echo linking $(notdir $@)
@$(LD) $(LDFLAGS) $(OFILES) $(LIBPATHS) $(LIBS) -o $@
#---------------------------------------------------------------------------------
# TARGET is the name of the output
# BUILD is the directory where object files & intermediate files will be placed
# SOURCES is a list of directories containing source code
# INCLUDES is a list of directories containing extra header files
# DATA is a list of directories containing binary files embedded using bin2o
# NITRODATA is the directory where files for NitroFS will be placed
#---------------------------------------------------------------------------------
TARGET := $(shell basename $(CURDIR))
BUILD := build
SOURCES := source
INCLUDES := include
DATA := data
NITRODATA := nitrofiles
#---------------------------------------------------------------------------------
# options for code generation
#---------------------------------------------------------------------------------
ARCH := -mthumb -mthumb-interwork
CFLAGS := -g -Wall -O2\
-march=armv5te -mtune=arm946e-s -fomit-frame-pointer\
-ffast-math \
$(ARCH)
CFLAGS += $(INCLUDE) -DARM9
CXXFLAGS := $(CFLAGS) -fno-rtti -fno-exceptions
ASFLAGS := -g $(ARCH)
LDFLAGS = -specs=ds_arm9.specs -g $(ARCH) -Wl,-Map,$(notdir $*.map)
#---------------------------------------------------------------------------------
# any extra libraries we wish to link with the project
#---------------------------------------------------------------------------------
LIBS := -lnflib -lfilesystem -lfat -lnds9
#---------------------------------------------------------------------------------
# list of directories containing libraries, this must be the top level containing
# include and lib
#---------------------------------------------------------------------------------
LIBDIRS := $(LIBNDS) $(CURDIR)/nflib
#---------------------------------------------------------------------------------
# no real need to edit anything past this point unless you need to add additional
# rules for different file extensions
#---------------------------------------------------------------------------------
ifneq ($(BUILD),$(notdir $(CURDIR)))
#---------------------------------------------------------------------------------
export OUTPUT := $(CURDIR)/$(TARGET)
export VPATH := $(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
$(foreach dir,$(DATA),$(CURDIR)/$(dir))
export DEPSDIR := $(CURDIR)/$(BUILD)
export NITRO_FILES := $(CURDIR)/$(NITRODATA)
CFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
CPPFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
SFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
BINFILES := $(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
#---------------------------------------------------------------------------------
# use CXX for linking C++ projects, CC for standard C
#---------------------------------------------------------------------------------
ifeq ($(strip $(CPPFILES)),)
#---------------------------------------------------------------------------------
export LD := $(CC)
#---------------------------------------------------------------------------------
else
#---------------------------------------------------------------------------------
export LD := $(CXX)
#---------------------------------------------------------------------------------
endif
#---------------------------------------------------------------------------------
export OFILES := $(addsuffix .o,$(BINFILES)) \
$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
export INCLUDE := $(foreach dir,$(INCLUDES),-iquote $(CURDIR)/$(dir)) \
$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
-I$(CURDIR)/$(BUILD)
export LIBPATHS := $(foreach dir,$(LIBDIRS),-L$(dir)/lib)
icons := $(wildcard *.bmp)
ifneq (,$(findstring $(TARGET).bmp,$(icons)))
export GAME_ICON := $(CURDIR)/$(TARGET).bmp
else
ifneq (,$(findstring icon.bmp,$(icons)))
export GAME_ICON := $(CURDIR)/icon.bmp
endif
endif
.PHONY: $(BUILD) clean
#---------------------------------------------------------------------------------
$(BUILD):
@[ -d $@ ] || mkdir -p $@
@make --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
#---------------------------------------------------------------------------------
clean:
@echo clean ...
@rm -fr $(BUILD) $(TARGET).elf $(TARGET).nds $(TARGET).arm9
#---------------------------------------------------------------------------------
else
#---------------------------------------------------------------------------------
# main targets
#---------------------------------------------------------------------------------
$(OUTPUT).nds : $(OUTPUT).elf
$(OUTPUT).elf : $(OFILES)
#---------------------------------------------------------------------------------
%.bin.o : %.bin
#---------------------------------------------------------------------------------
@echo $(notdir $<)
$(bin2o)
#---------------------------------------------------------------------------------------
endif
#---------------------------------------------------------------------------------------

BIN
examples/3dsprites/alpha/nflib/lib/libnflib.a
View File

Binary file not shown.

238
examples/3dsprites/animation/Makefile
View File

@ -1,60 +1,17 @@
#---------------------------------------------------------------------------------
# Makefile for NightFox's Lib Projects
#---------------------------------------------------------------------------------
#---------------------------------------------------------------------------------
.SUFFIXES:
#---------------------------------------------------------------------------------
ifeq ($(strip $(DEVKITARM)),)
$(error "Please set DEVKITARM in your environment. export DEVKITARM=<path to>devkitARM")
endif
# These set the information text in the nds file
#GAME_TITLE := My Wonderful Homebrew
#GAME_SUBTITLE1 := built with devkitARM
#GAME_SUBTITLE2 := http://devitpro.org
#---------------------------------------------------------------------------------
# This part substitutes this include:
# include $(DEVKITARM)/ds_rules
# This allows you to set ROM info and icon easy
# Please update this block from DS_RULES file at every DEVKITARM update
#---------------------------------------------------------------------------------
include $(DEVKITARM)/base_rules
LIBNDS := $(DEVKITPRO)/libnds
GAME_TITLE := Text 1
GAME_SUBTITLE1 := Text 2
GAME_SUBTITLE2 := Text 3
GAME_ICON := $(CURDIR)/../icon.bmp
_ADDFILES := -d $(NITRO_FILES)
#---------------------------------------------------------------------------------
%.nds: %.arm9
@ndstool -c $@ -9 $< -b $(GAME_ICON) "$(GAME_TITLE);$(GAME_SUBTITLE1);$(GAME_SUBTITLE2)" $(_ADDFILES)
@echo built ... $(notdir $@)
#---------------------------------------------------------------------------------
%.nds: %.elf
@ndstool -c $@ -9 $< -b $(GAME_ICON) "$(GAME_TITLE);$(GAME_SUBTITLE1);$(GAME_SUBTITLE2)" $(_ADDFILES)
@echo built ... $(notdir $@)
#---------------------------------------------------------------------------------
%.arm9: %.elf
@$(OBJCOPY) -O binary $< $@
@echo built ... $(notdir $@)
#---------------------------------------------------------------------------------
%.arm7: %.elf
@$(OBJCOPY) -O binary $< $@
@echo built ... $(notdir $@)
#---------------------------------------------------------------------------------
%.elf:
@echo linking $(notdir $@)
@$(LD) $(LDFLAGS) $(OFILES) $(LIBPATHS) $(LIBS) -o $@
include $(DEVKITARM)/ds_rules
#---------------------------------------------------------------------------------
# TARGET is the name of the output
@ -62,43 +19,56 @@ _ADDFILES := -d $(NITRO_FILES)
# SOURCES is a list of directories containing source code
# INCLUDES is a list of directories containing extra header files
# DATA is a list of directories containing binary files embedded using bin2o
# NITRODATA is the directory where files for NitroFS will be placed
# GRAPHICS is a list of directories containing image files to be converted with grit
# AUDIO is a list of directories containing audio to be converted by maxmod
# ICON is the image used to create the game icon, leave blank to use default rule
# NITRO is a directory that will be accessible via NitroFS
#---------------------------------------------------------------------------------
TARGET := $(shell basename $(CURDIR))
BUILD := build
SOURCES := source
INCLUDES := include
DATA := data
NITRODATA := nitrofiles
TARGET := $(shell basename $(CURDIR))
BUILD := build
SOURCES := source
INCLUDES := include
DATA := data
GRAPHICS :=
AUDIO :=
ICON :=
# specify a directory which contains the nitro filesystem
# this is relative to the Makefile
NITRO := nitrofiles
#---------------------------------------------------------------------------------
# options for code generation
#---------------------------------------------------------------------------------
ARCH := -mthumb -mthumb-interwork
ARCH := -marm -mthumb-interwork -march=armv5te -mtune=arm946e-s
CFLAGS := -g -Wall -O2\
-march=armv5te -mtune=arm946e-s -fomit-frame-pointer\
-ffast-math \
$(ARCH)
CFLAGS += $(INCLUDE) -DARM9
CXXFLAGS := $(CFLAGS) -fno-rtti -fno-exceptions
ASFLAGS := -g $(ARCH)
LDFLAGS = -specs=ds_arm9.specs -g $(ARCH) -Wl,-Map,$(notdir $*.map)
CFLAGS := -g -Wall -O3\
$(ARCH) $(INCLUDE) -DARM9
CXXFLAGS := $(CFLAGS) -fno-rtti -fno-exceptions
ASFLAGS := -g $(ARCH)
LDFLAGS = -specs=ds_arm9.specs -g $(ARCH) -Wl,-Map,$(notdir $*.map)
#---------------------------------------------------------------------------------
# any extra libraries we wish to link with the project
# any extra libraries we wish to link with the project (order is important)
#---------------------------------------------------------------------------------
LIBS := -lnflib -lfilesystem -lfat -lnds9
LIBS := -lnflib
# automatigically add libraries for NitroFS
ifneq ($(strip $(NITRO)),)
LIBS := $(LIBS) -lfilesystem -lfat
endif
# automagically add maxmod library
ifneq ($(strip $(AUDIO)),)
LIBS := $(LIBS) -lmm9
endif
LIBS := $(LIBS) -lnds9
#---------------------------------------------------------------------------------
# list of directories containing libraries, this must be the top level containing
# include and lib
#---------------------------------------------------------------------------------
LIBDIRS := $(LIBNDS) $(CURDIR)/nflib
LIBDIRS := $(LIBNDS) $(PORTLIBS) $(DEVKITPRO)/nflib
#---------------------------------------------------------------------------------
# no real need to edit anything past this point unless you need to add additional
@ -107,64 +77,97 @@ LIBDIRS := $(LIBNDS) $(CURDIR)/nflib
ifneq ($(BUILD),$(notdir $(CURDIR)))
#---------------------------------------------------------------------------------
export OUTPUT := $(CURDIR)/$(TARGET)
export OUTPUT := $(CURDIR)/$(TARGET)
export VPATH := $(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
$(foreach dir,$(DATA),$(CURDIR)/$(dir))
export VPATH := $(CURDIR)/$(subst /,,$(dir $(ICON)))\
$(foreach dir,$(SOURCES),$(CURDIR)/$(dir))\
$(foreach dir,$(DATA),$(CURDIR)/$(dir))\
$(foreach dir,$(GRAPHICS),$(CURDIR)/$(dir))
export DEPSDIR := $(CURDIR)/$(BUILD)
export DEPSDIR := $(CURDIR)/$(BUILD)
export NITRO_FILES := $(CURDIR)/$(NITRODATA)
CFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
CPPFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
SFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
PNGFILES := $(foreach dir,$(GRAPHICS),$(notdir $(wildcard $(dir)/*.png)))
BINFILES := $(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
CFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
CPPFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
SFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
BINFILES := $(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
# prepare NitroFS directory
ifneq ($(strip $(NITRO)),)
export NITRO_FILES := $(CURDIR)/$(NITRO)
endif
# get audio list for maxmod
ifneq ($(strip $(AUDIO)),)
export MODFILES := $(foreach dir,$(notdir $(wildcard $(AUDIO)/*.*)),$(CURDIR)/$(AUDIO)/$(dir))
# place the soundbank file in NitroFS if using it
ifneq ($(strip $(NITRO)),)
export SOUNDBANK := $(NITRO_FILES)/soundbank.bin
# otherwise, needs to be loaded from memory
else
export SOUNDBANK := soundbank.bin
BINFILES += $(SOUNDBANK)
endif
endif
#---------------------------------------------------------------------------------
# use CXX for linking C++ projects, CC for standard C
#---------------------------------------------------------------------------------
ifeq ($(strip $(CPPFILES)),)
#---------------------------------------------------------------------------------
export LD := $(CC)
export LD := $(CC)
#---------------------------------------------------------------------------------
else
#---------------------------------------------------------------------------------
export LD := $(CXX)
export LD := $(CXX)
#---------------------------------------------------------------------------------
endif
#---------------------------------------------------------------------------------
export OFILES := $(addsuffix .o,$(BINFILES)) \
$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
export OFILES_BIN := $(addsuffix .o,$(BINFILES))
export INCLUDE := $(foreach dir,$(INCLUDES),-iquote $(CURDIR)/$(dir)) \
$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
-I$(CURDIR)/$(BUILD)
export OFILES_SOURCES := $(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
export LIBPATHS := $(foreach dir,$(LIBDIRS),-L$(dir)/lib)
export OFILES := $(PNGFILES:.png=.o) $(OFILES_BIN) $(OFILES_SOURCES)
icons := $(wildcard *.bmp)
export HFILES := $(PNGFILES:.png=.h) $(addsuffix .h,$(subst .,_,$(BINFILES)))
ifneq (,$(findstring $(TARGET).bmp,$(icons)))
export GAME_ICON := $(CURDIR)/$(TARGET).bmp
export INCLUDE := $(foreach dir,$(INCLUDES),-iquote $(CURDIR)/$(dir))\
$(foreach dir,$(LIBDIRS),-I$(dir)/include)\
-I$(CURDIR)/$(BUILD)
export LIBPATHS := $(foreach dir,$(LIBDIRS),-L$(dir)/lib)
ifeq ($(strip $(ICON)),)
icons := $(wildcard *.bmp)
ifneq (,$(findstring $(TARGET).bmp,$(icons)))
export GAME_ICON := $(CURDIR)/$(TARGET).bmp
else
ifneq (,$(findstring icon.bmp,$(icons)))
export GAME_ICON := $(CURDIR)/icon.bmp
endif
endif
else
ifneq (,$(findstring icon.bmp,$(icons)))
export GAME_ICON := $(CURDIR)/icon.bmp
endif
ifeq ($(suffix $(ICON)), .grf)
export GAME_ICON := $(CURDIR)/$(ICON)
else
export GAME_ICON := $(CURDIR)/$(BUILD)/$(notdir $(basename $(ICON))).grf
endif
endif
.PHONY: $(BUILD) clean
#---------------------------------------------------------------------------------
$(BUILD):
@[ -d $@ ] || mkdir -p $@
@make --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
@mkdir -p $@
@$(MAKE) --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
#---------------------------------------------------------------------------------
clean:
@echo clean ...
@rm -fr $(BUILD) $(TARGET).elf $(TARGET).nds $(TARGET).arm9
@rm -fr $(BUILD) $(TARGET).elf $(TARGET).nds $(SOUNDBANK)
#---------------------------------------------------------------------------------
else
@ -172,14 +175,47 @@ else
#---------------------------------------------------------------------------------
# main targets
#---------------------------------------------------------------------------------
$(OUTPUT).nds : $(OUTPUT).elf
$(OUTPUT).elf : $(OFILES)
$(OUTPUT).nds: $(OUTPUT).elf $(NITRO_FILES) $(GAME_ICON)
$(OUTPUT).elf: $(OFILES)
# source files depend on generated headers
$(OFILES_SOURCES) : $(HFILES)
# need to build soundbank first
$(OFILES): $(SOUNDBANK)
#---------------------------------------------------------------------------------
%.bin.o : %.bin
# rule to build solution from music files
#---------------------------------------------------------------------------------
$(SOUNDBANK) : $(MODFILES)
#---------------------------------------------------------------------------------
mmutil $^ -d -o$@ -hsoundbank.h
#---------------------------------------------------------------------------------
%.bin.o %_bin.h : %.bin
#---------------------------------------------------------------------------------
@echo $(notdir $<)
$(bin2o)
@$(bin2o)
#---------------------------------------------------------------------------------
# This rule creates assembly source files using grit
# grit takes an image file and a .grit describing how the file is to be processed
# add additional rules like this for each image extension
# you use in the graphics folders
#---------------------------------------------------------------------------------
%.s %.h: %.png %.grit
#---------------------------------------------------------------------------------
grit $< -fts -o$*
#---------------------------------------------------------------------------------
# Convert non-GRF game icon to GRF if needed
#---------------------------------------------------------------------------------
$(GAME_ICON): $(notdir $(ICON))
#---------------------------------------------------------------------------------
@echo convert $(notdir $<)
@grit $< -g -gt -gB4 -gT FF00FF -m! -p -pe 16 -fh! -ftr
-include $(DEPSDIR)/*.d
#---------------------------------------------------------------------------------------
endif

BIN
examples/3dsprites/animation/animation.elf
View File

Binary file not shown.

BIN
examples/3dsprites/animation/animation.nds
View File

Binary file not shown.

4137
examples/3dsprites/animation/build/animation.map
View File

File diff suppressed because it is too large Load Diff

227
examples/3dsprites/animation/build/main.d
View File

@ -1,227 +0,0 @@
main.o: \
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/source/main.c \
c:/code/devkitPro/libnds/include/nds.h \
c:/code/devkitPro/libnds/include/nds/libversion.h \
c:/code/devkitPro/libnds/include/nds/ndstypes.h \
c:/code/devkitPro/libnds/include/nds/bios.h \
c:/code/devkitPro/libnds/include/nds/ndstypes.h \
c:/code/devkitPro/libnds/include/nds/card.h \
c:/code/devkitPro/libnds/include/nds/ndstypes.h \
c:/code/devkitPro/libnds/include/nds/debug.h \
c:/code/devkitPro/libnds/include/nds/dma.h \
c:/code/devkitPro/libnds/include/nds/interrupts.h \
c:/code/devkitPro/libnds/include/nds/ipc.h \
c:/code/devkitPro/libnds/include/nds/memory.h \
c:/code/devkitPro/libnds/include/nds/system.h \
c:/code/devkitPro/libnds/include/nds/timers.h \
c:/code/devkitPro/libnds/include/nds/fifocommon.h \
c:/code/devkitPro/libnds/include/nds/interrupts.h \
c:/code/devkitPro/libnds/include/nds/touch.h \
c:/code/devkitPro/libnds/include/nds/input.h \
c:/code/devkitPro/libnds/include/nds/arm9/dynamicArray.h \
c:/code/devkitPro/libnds/include/nds/arm9/linkedlist.h \
c:/code/devkitPro/libnds/include/nds/arm9/background.h \
c:/code/devkitPro/libnds/include/nds/arm9/video.h \
c:/code/devkitPro/libnds/include/nds/arm9/sassert.h \
c:/code/devkitPro/libnds/include/nds/memory.h \
c:/code/devkitPro/libnds/include/nds/dma.h \
c:/code/devkitPro/libnds/include/nds/arm9/boxtest.h \
c:/code/devkitPro/libnds/include/nds/arm9/videoGL.h \
c:/code/devkitPro/libnds/include/nds/arm9/cache.h \
c:/code/devkitPro/libnds/include/nds/arm9/trig_lut.h \
c:/code/devkitPro/libnds/include/nds/arm9/math.h \
c:/code/devkitPro/libnds/include/nds/arm9/dynamicArray.h \
c:/code/devkitPro/libnds/include/nds/arm9/cache.h \
c:/code/devkitPro/libnds/include/nds/arm9/console.h \
c:/code/devkitPro/libnds/include/nds/arm9/background.h \
c:/code/devkitPro/libnds/include/nds/arm9/decompress.h \
c:/code/devkitPro/libnds/include/nds/bios.h \
c:/code/devkitPro/libnds/include/nds/arm9/exceptions.h \
c:/code/devkitPro/libnds/include/nds/arm9/guitarGrip.h \
c:/code/devkitPro/libnds/include/nds/arm9/image.h \
c:/code/devkitPro/libnds/include/nds/arm9/pcx.h \
c:/code/devkitPro/libnds/include/nds/arm9/input.h \
c:/code/devkitPro/libnds/include/nds/touch.h \
c:/code/devkitPro/libnds/include/nds/input.h \
c:/code/devkitPro/libnds/include/nds/arm9/keyboard.h \
c:/code/devkitPro/libnds/include/nds/arm9/math.h \
c:/code/devkitPro/libnds/include/nds/arm9/paddle.h \
c:/code/devkitPro/libnds/include/nds/arm9/pcx.h \
c:/code/devkitPro/libnds/include/nds/arm9/piano.h \
c:/code/devkitPro/libnds/include/nds/arm9/rumble.h \
c:/code/devkitPro/libnds/include/nds/arm9/sassert.h \
c:/code/devkitPro/libnds/include/nds/arm9/sound.h \
c:/code/devkitPro/libnds/include/nds/arm9/sprite.h \
c:/code/devkitPro/libnds/include/nds/system.h \
c:/code/devkitPro/libnds/include/nds/arm9/window.h \
c:/code/devkitPro/libnds/include/nds/arm9/sprite.h \
c:/code/devkitPro/libnds/include/nds/arm9/trig_lut.h \
c:/code/devkitPro/libnds/include/nds/arm9/video.h \
c:/code/devkitPro/libnds/include/nds/arm9/videoGL.h \
c:/code/devkitPro/libnds/include/nds/arm9/nand.h \
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_lib.h \
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_defines.h \
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_basic.h \
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_2d.h \
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_tiledbg.h \
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_affinebg.h \
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_bitmapbg.h \
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_mixedbg.h \
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_sprite256.h \
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_text.h \
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_text16.h \
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_colision.h \
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_sound.h \
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_media.h \
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_3d.h \
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_sprite3d.h
c:/code/devkitPro/libnds/include/nds.h:
c:/code/devkitPro/libnds/include/nds/libversion.h:
c:/code/devkitPro/libnds/include/nds/ndstypes.h:
c:/code/devkitPro/libnds/include/nds/bios.h:
c:/code/devkitPro/libnds/include/nds/ndstypes.h:
c:/code/devkitPro/libnds/include/nds/card.h:
c:/code/devkitPro/libnds/include/nds/ndstypes.h:
c:/code/devkitPro/libnds/include/nds/debug.h:
c:/code/devkitPro/libnds/include/nds/dma.h:
c:/code/devkitPro/libnds/include/nds/interrupts.h:
c:/code/devkitPro/libnds/include/nds/ipc.h:
c:/code/devkitPro/libnds/include/nds/memory.h:
c:/code/devkitPro/libnds/include/nds/system.h:
c:/code/devkitPro/libnds/include/nds/timers.h:
c:/code/devkitPro/libnds/include/nds/fifocommon.h:
c:/code/devkitPro/libnds/include/nds/interrupts.h:
c:/code/devkitPro/libnds/include/nds/touch.h:
c:/code/devkitPro/libnds/include/nds/input.h:
c:/code/devkitPro/libnds/include/nds/arm9/dynamicArray.h:
c:/code/devkitPro/libnds/include/nds/arm9/linkedlist.h:
c:/code/devkitPro/libnds/include/nds/arm9/background.h:
c:/code/devkitPro/libnds/include/nds/arm9/video.h:
c:/code/devkitPro/libnds/include/nds/arm9/sassert.h:
c:/code/devkitPro/libnds/include/nds/memory.h:
c:/code/devkitPro/libnds/include/nds/dma.h:
c:/code/devkitPro/libnds/include/nds/arm9/boxtest.h:
c:/code/devkitPro/libnds/include/nds/arm9/videoGL.h:
c:/code/devkitPro/libnds/include/nds/arm9/cache.h:
c:/code/devkitPro/libnds/include/nds/arm9/trig_lut.h:
c:/code/devkitPro/libnds/include/nds/arm9/math.h:
c:/code/devkitPro/libnds/include/nds/arm9/dynamicArray.h:
c:/code/devkitPro/libnds/include/nds/arm9/cache.h:
c:/code/devkitPro/libnds/include/nds/arm9/console.h:
c:/code/devkitPro/libnds/include/nds/arm9/background.h:
c:/code/devkitPro/libnds/include/nds/arm9/decompress.h:
c:/code/devkitPro/libnds/include/nds/bios.h:
c:/code/devkitPro/libnds/include/nds/arm9/exceptions.h:
c:/code/devkitPro/libnds/include/nds/arm9/guitarGrip.h:
c:/code/devkitPro/libnds/include/nds/arm9/image.h:
c:/code/devkitPro/libnds/include/nds/arm9/pcx.h:
c:/code/devkitPro/libnds/include/nds/arm9/input.h:
c:/code/devkitPro/libnds/include/nds/touch.h:
c:/code/devkitPro/libnds/include/nds/input.h:
c:/code/devkitPro/libnds/include/nds/arm9/keyboard.h:
c:/code/devkitPro/libnds/include/nds/arm9/math.h:
c:/code/devkitPro/libnds/include/nds/arm9/paddle.h:
c:/code/devkitPro/libnds/include/nds/arm9/pcx.h:
c:/code/devkitPro/libnds/include/nds/arm9/piano.h:
c:/code/devkitPro/libnds/include/nds/arm9/rumble.h:
c:/code/devkitPro/libnds/include/nds/arm9/sassert.h:
c:/code/devkitPro/libnds/include/nds/arm9/sound.h:
c:/code/devkitPro/libnds/include/nds/arm9/sprite.h:
c:/code/devkitPro/libnds/include/nds/system.h:
c:/code/devkitPro/libnds/include/nds/arm9/window.h:
c:/code/devkitPro/libnds/include/nds/arm9/sprite.h:
c:/code/devkitPro/libnds/include/nds/arm9/trig_lut.h:
c:/code/devkitPro/libnds/include/nds/arm9/video.h:
c:/code/devkitPro/libnds/include/nds/arm9/videoGL.h:
c:/code/devkitPro/libnds/include/nds/arm9/nand.h:
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_lib.h:
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_defines.h:
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_basic.h:
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_2d.h:
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_tiledbg.h:
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_affinebg.h:
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_bitmapbg.h:
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_mixedbg.h:
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_sprite256.h:
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_text.h:
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_text16.h:
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_colision.h:
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_sound.h:
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_media.h:
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_3d.h:
d:/Work/NDS/projects/NFlib/nflib/examples/3dsprites/animation/nflib/include/nf_sprite3d.h:

BIN
examples/3dsprites/animation/build/main.o
View File

Binary file not shown.

5
examples/3dsprites/animation/clean.bat
View File

@ -1,5 +0,0 @@
@echo off
cls
make clean
pause
exit

5
examples/3dsprites/animation/compile.bat
View File

@ -1,5 +0,0 @@
@echo off
cls
make
pause
exit

BIN
examples/3dsprites/animation/icon.bmp
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 1.1 KiB

139
examples/3dsprites/animation/nflib/include/nf_2d.h
View File

@ -1,139 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_2D_H__
#define __NF_2D_H__
// NightFox LIB - Include de funciones 2D comunes
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Funcion NF_Set2D();
void NF_Set2D(u8 screen, u8 mode);
// Inicia el modo 2D seleccionado en la pantalla deseada
// Funcion NF_ShowBg();
void NF_ShowBg(u8 screen, u8 layer);
// Haz visible el fondo de la capa y pantalla dados
// Funcion NF_HideBg();
void NF_HideBg(u8 screen, u8 layer);
// Oculta el fondo de la capa y pantalla dados
// Funcion NF_ScrollBg();
void NF_ScrollBg(u8 screen, u8 layer, s16 x, s16 y);
// Mueve el fondo a las coordenadas especificadas.
// Debes de indicar la pantalla, capa, y coordenadas X e Y
// Si el mapa es mayor de 512 en alguna medida, debes de mantener el fondo en RAM
// Funcion NF_MoveSprite();
void NF_MoveSprite(u8 screen, u8 id, s16 x, s16 y);
// Mueve el Sprite a las coordenadas especificadas
// Debes de indicar la pantalla, id de sprite y coordenadas
// Funcion NF_SpriteLayer();
void NF_SpriteLayer(u8 screen, u8 id, u8 layer);
// Define la capa sobre la que el sprite sera dibujado
// Debes de indicar la pantalla, id del sprite y capa
// Funcion NF_ShowSprite();
void NF_ShowSprite(u8 screen, u8 id, bool show);
// Muestra o oculta el sprite
// Debes especificar la pantalla, id del sprite y el estado (true, false)
// Funcion NF_HflipSprite();
void NF_HflipSprite(u8 screen, u8 id, bool hflip);
// Voltea el Sprite horizontalmente
// Debes especificar la pantalla, id del sprite y el estado (true, false)
// Funcion NF_GetSpriteHflip();
extern bool NF_GetSpriteHflip(u8 screen, u8 id);
// Devuelve el estado del volteado horizontal de un sprite
// Debes especificar la pantalla y la id del sprite
// Funcion NF_VflipSprite();
void NF_VflipSprite(u8 screen, u8 id, bool vflip);
// Voltea el Sprite verticalmente
// Debes especificar la pantalla, id del sprite y el estado (true, false)
// Funcion NF_GetSpriteVflip();
extern bool NF_GetSpriteVflip(u8 screen, u8 id);
// Devuelve el estado del volteado vertical de un sprite
// Debes especificar la pantalla y la id del sprite
// Funcion NF_SpriteFrame();
void NF_SpriteFrame(u8 screen, u8 id, u16 frame);
// Cambia el frame de un Sprite
// Debes especificar la pantalla, el Id del sprite y el frame
// Funcion NF_EnableSpriteRotScale();
void NF_EnableSpriteRotScale(u8 screen, u8 sprite, u8 id, bool doublesize);
// Habilita el sprite como rotable y escalable
// Debes especificar la pantalla, nº de sprite, id de rotacion y si
// tiene que activarse el doublesize (tamaño x2)
// Funcion NF_DisableSpriteRotScale();
void NF_DisableSpriteRotScale(u8 screen, u8 sprite);
// Deshabilita un sprite como rotable y escalable
// Debes especificar la pantalla y el nº de sprite
// Funcion NF_SpriteRotScale();
void NF_SpriteRotScale(u8 screen, u8 id, s16 angle, u16 sx, u16 sy);
// Define el angulo de rotacion y escala de los Sprites asociados a la Id.
// El rango del angulo es desde -512 a 512, siendo 0 el valor central
// El rango de escalado va de 0 a 512, siendo 256 el valor normal (100%)
#endif
#ifdef __cplusplus
}
#endif

50
examples/3dsprites/animation/nflib/include/nf_3d.h
View File

@ -1,50 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_3D_H__
#define __NF_3D_H__
// NightFox LIB - Include de funciones 3D
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Funcion NF_Set3D();
void NF_Set3D(u8 screen, u8 mode);
// Inicia el modo 3D seleccionado en la pantalla deseada
// Funcion NF_InitOpenGL();
void NF_InitOpenGL(void);
// Inicializa el OpenGL para la libreria
// Funcion NF_GetTextureSize();
extern u16 NF_GetTextureSize(u16 textel);
// Devuelve el tamaño del textel
#endif
#ifdef __cplusplus
}
#endif

106
examples/3dsprites/animation/nflib/include/nf_affinebg.h
View File

@ -1,106 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_AFFINEBG_H__
#define __NF_AFFINEBG_H__
// NightFox LIB - Includes de Fondos Affine
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Estructura para almacenar los parametros de los fondos Affine
typedef struct {
s32 x; // Posicion X
s32 y; // Posicion Y
s32 x_center; // Centro X
s32 y_center; // Centro Y
s32 x_scale; // Valor Zoom X (PA)
s32 y_scale; // Valor Zoom Y (PD)
s32 x_tilt; // Valor Inclinacion X (PB)
s32 y_tilt; // Valor Inclinacion Y (PC)
s32 angle; // Valor de la rotacion
} NF_TYPE_AFFINE_BG;
extern NF_TYPE_AFFINE_BG NF_AFFINE_BG[2][4];
// Funcion NF_InitTiledBgSys();
void NF_InitAffineBgSys(u8 screen);
// Inicializa el sistema de fondos Affine. Solo puede usarse en las capas 2 y 3, los fondos en
// la misma pantalla deben de compartir la paleta y no pueden tener mas de 256 tiles.
// Funcion NF_LoadAffineBg();
void NF_LoadAffineBg(const char* file, const char* name, u16 width, u16 height);
// Carga un fondo tileado desde FAT
// Debes de especificar el archivo que se cargara (sin extension) y el nombre
// que le quieres dar y las medidas en pixeles
// Los buffers para fondos tileados deben estar inicializados antes de usar esta funcion
// Funcion NF_UnloadAffineBg();
void NF_UnloadAffineBg(const char* name);
// Borra de la RAM el fondo affine especificado. Es una simple llamada a la funcion NF_UnloadTiledBg();
// Funcion NF_CreateAffineBg();
void NF_CreateAffineBg(u8 screen, u8 layer, const char* name, u8 wrap);
// Crea un fondo con los parametros dados, indicale la pantalla, capa, nombre y si se activa la opcion
// de WRAP arround (0 desactivado, 1 activado).
// Funcion NF_DeleteAffineBg();
void NF_DeleteAffineBg(u8 screen, u8 layer);
// Borra el fondo Affine especificado
// Funcion NF_AffineBgTransform();
void NF_AffineBgTransform(u8 screen, u8 layer, s32 x_scale, s32 y_scale, s32 x_tilt, s32 y_tilt);
// Modifica los parametros de la matriz de transformacion del fondo affine
// Funcion NF_AffineBgMove();
void NF_AffineBgMove(u8 screen, u8 layer, s32 x, s32 y, s32 angle);
// Desplaza el fondo affine y rotalo (-2048 a 2048)
// Funcion NF_AffineBgCenter();
void NF_AffineBgCenter(u8 screen, u8 layer, s32 x, s32 y);
// Define el centro de rotacion de un fondo affine
#endif
#ifdef __cplusplus
}
#endif

89
examples/3dsprites/animation/nflib/include/nf_basic.h
View File

@ -1,89 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_BASIC_H__
#define __NF_BASIC_H__
// NightFox LIB - Include de funciones basicas
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define la variable global NF_ROOTFOLDER
extern char NF_ROOTFOLDER[32];
// Funcion NF_Error();
void NF_Error(u16 code, const char* text, u32 value);
// Errores para debug. Detiene el sistema e informa del error
// 101: Fichero no encontrado
// 102: Memoria insuficiente
// 103: No quedan Slots libres
// 104: Fondo no encontrado
// 105: Fondo no creado
// 106: Fuera de rango
// 107: Insuficientes bloques contiguos en VRAM (Tiles)
// 108: Insuficientes bloques contiguos en VRAM (Maps)
// 109: Id ocupada (ya esta en uso)
// 110: Id no cargada (en RAM)
// 111: Id no en VRAM
// 112: Sprite no creado
// 113: Memoria VRAM insuficiente
// 114: La capa de Texto no existe
// 115: Medidas del fondo no compatibles (no son multiplos de 256)
// 116: Archivo demasiado grande
// 117: Medidas del fondo affine incorrectas
// 118: Capa de creacion del fondo affine incorrecta
// Funcion NF_SetRootFolder();
void NF_SetRootFolder(const char* folder);
// Define el nombre de la carpeta que se usara como "root" si se usa la FAT
// Funcion NF_DmaMemCopy();
void NF_DmaMemCopy(void* destination, const void* source, u32 size);
// Copia un bloque de memoria usando DMA (canal 3, halfwords) y vaciando previamente
// el cache. Con pruebas de bloques grandes (64kb o 128kb) he observado que memcpy();
// sigue siendo mas rapida.
// Funcion NF_GetLanguage();
extern u8 NF_GetLanguage(void);
// Devuelve el ID del idioma del usuario
// 0 : Japanese
// 1 : English
// 2 : French
// 3 : German
// 4 : Italian
// 5 : Spanish
// 6 : Chinese
#endif
#ifdef __cplusplus
}
#endif

234
examples/3dsprites/animation/nflib/include/nf_bitmapbg.h
View File

@ -1,234 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_BITMAPBG_H__
#define __NF_BITMAPBG_H__
// NightFox LIB - Include de funciones de fondos en modo Bitmap
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define los slots maximos para los fondos de 16 bits
#define NF_SLOTS_BG16B 16
// Define los slots maximos para los fondos de 8 bits
#define NF_SLOTS_BG8B 16
// Define los Buffers para almacenar datos de 16 bits
typedef struct {
u16* buffer; // Buffer de datos
u32 size; // Tamaño del buffer
u16 width; // Ancho de la imagen (256 max)
u16 height; // Altura de la imagen (256 max)
bool inuse; // Esta en uso el buffer?
} NF_TYPE_BG16B_INFO;
extern NF_TYPE_BG16B_INFO NF_BG16B[NF_SLOTS_BG16B]; // Fondos RAW de 16 bits
// BackBuffer de 16 bits de cada pantalla
extern u16* NF_16BITS_BACKBUFFER[2];
// Define los Buffers para almacenar datos de 8 bits
typedef struct {
u8* data; // Buffer de datos
u32 data_size; // Tamaño del buffer de datos
u16* pal; // Buffer para la paleta
u32 pal_size; // Tamaño de la paleta
bool inuse; // Esta en uso el buffer?
} NF_TYPE_BG8B_INFO;
extern NF_TYPE_BG8B_INFO NF_BG8B[NF_SLOTS_BG8B]; // Fondos indexados de 8 bits
// BackBuffer de 8 bits de cada pantalla
typedef struct {
u8* data;
u16* pal;
} NF_TYPE_BB8B_INFO;
extern NF_TYPE_BB8B_INFO NF_8BITS_BACKBUFFER[2];
// Funcion NF_Init16bitsBgBuffers();
void NF_Init16bitsBgBuffers(void);
// Inicia los buffers para almacenar fondos de BITMAP 16 bits
// Usalo UNA SOLA VEZ antes de usar los buffers
// Funcion NF_Reset16bitsBgBuffers();
void NF_Reset16bitsBgBuffers(void);
// Reinicia los buffers para almacenar fondos de BITMAP 16 bits,
// borrado su contenido
// Funcion NF_Init16bitsBackBuffer();
void NF_Init16bitsBackBuffer(u8 screen);
// Inicia el backbuffer de la pantalla dada.
// Usalo UNA SOLA VEZ antes de usar el backbuffer
// Funcion NF_Enable16bitsBackBuffer();
void NF_Enable16bitsBackBuffer(u8 screen);
// Habilita el backbuffer de la pantalla indicada.
// Si el buffer ya existe, la funcion borrara el contenido del mismo,
// poniendo a 0 todos los bytes del buffer.
// Funcion NF_Disble16bitsBackBuffer();
void NF_Disble16bitsBackBuffer(u8 screen);
// Deshabilita el backbuffer de la pantalla indicada, liberando de la
// RAM el espacio usado.
// Funcion NF_Flip16bitsBackBuffer();
void NF_Flip16bitsBackBuffer(u8 screen);
// Copia el contenido del backbuffer a la VRAM de la pantalla indicada.
// Funcion NF_InitBitmapBgSys();
void NF_InitBitmapBgSys(u8 screen, u8 mode);
// Inicia el modo BITMAP en la pantalla especificada, con la profundidad de color
// especificada. (0 -> 256 colores, 1 -> 16 bits)
// Funcion NF_Load16bitsBg();
void NF_Load16bitsBg(const char* file, u8 slot);
// Carga un Fondo BITMAP (en formato RAW) en el slot indicado,
// de un tamaño maximo de 256x256 pixeles.
// Debes especificar el nombre de archivo sin extension.
// El archivo debe ser un binario con extension .img
// Funcion NF_Load16bitsImage();
void NF_Load16bitsImage(const char* file, u8 slot, u16 size_x, u16 size_y);
// Carga una imagen BITMAP (en formato RAW) en el slot indicado,
// de un tamaño maximo de 256x256 pixeles.
// Debes especificar el nombre de archivo sin extension.
// El archivo debe ser un binario con extension .img
// Todos los pixeles Magenta de la imagen (0xFF00FF) seran transparentes.
// Funcion NF_Load16bImgData();
void NF_Load16bImgData(const char* file, u8 slot, u16 x, u16 y, u8 type);
// Funcion de uso interno, no documentar ni usar.
// Cargador generico de datos de imagen de 16 bits a la RAM.
// Funcion NF_Unload16bitsBg();
void NF_Unload16bitsBg(u8 slot);
// Borra de la RAM los datos del buffer especificado
// Funcion NF_Copy16bitsBuffer();
void NF_Copy16bitsBuffer(u8 screen, u8 destination, u8 slot);
// Copia los datos cargados en un Buffer de Bitmap a la VRAM o al BackBuffer
// destination: 0 -> VRAM, 1 -> BackBuffer
// Funcion NF_Draw16bitsImage();
void NF_Draw16bitsImage(u8 screen, u8 slot, s16 x, s16 y, bool alpha);
// Copia la imagen cargada en un Buffer de Bitmap al Backbuffer de la pantalla especificada
// Funcion NF_Init8bitsBgBuffers();
void NF_Init8bitsBgBuffers(void);
// Inicializa los buffers necesarios para la carda de fondos en modo BITMAP de 8 bits.
// Debes usar esta funcion antes de poder usar ninguno de los buffers.
// Funcion NF_Reset8bitsBgBuffers();
void NF_Reset8bitsBgBuffers(void);
// Reinicia los buffers de fondos de 8 bits, borrando todo el contenido de los buffers.
// Funcion NF_Load8bitsBg();
void NF_Load8bitsBg(const char* file, u8 slot);
// Carga los archivos necesarios de un fondo de 8 bits en el Slot indicado.
// Debes especificar el nombre de archivo sin extension.
// El archivo debe ser un binario con extension .img
// La paleta debe tener la extension .pal
// Funcion NF_Unload8bitsBg();
void NF_Unload8bitsBg(u8 slot);
// Borra de la RAM el fondo del slot indicado.
// Funcion NF_Copy8bitsBuffer();
void NF_Copy8bitsBuffer(u8 screen, u8 destination, u8 slot);
// Transfiere la imagen del buffer seleccionado a la pantalla y capas indicado o
// al backbuffer.
// Funcion NF_Init8bitsBackBuffer();
void NF_Init8bitsBackBuffer(u8 screen);
// Inicializa los buffers del backbuffer para la pantalla indicada.
// Debes usar esta funcion una vez antes de usar el backbuffer
// Funcion NF_Enable8bitsBackBuffer();
void NF_Enable8bitsBackBuffer(u8 screen);
// Habilita el backbuffer de la pantalla indicada.
// Si el buffer ya existe, la funcion borrara el contenido del mismo,
// poniendo a 0 todos los bytes del buffer.
// Funcion NF_Disble8bitsBackBuffer();
void NF_Disble8bitsBackBuffer(u8 screen);
// Deshabilita el backbuffer de la pantalla indicada, liberando de la
// RAM el espacio usado.
// Funcion NF_Flip8bitsBackBuffer();
void NF_Flip8bitsBackBuffer(u8 screen, u8 destination);
// Copia el contenido del backbuffer a la VRAM de la pantalla indicada.
// Debes especificar la capa de destino:
// 0 -> Capa 2
// 1 -> Capa 3
#endif
#ifdef __cplusplus
}
#endif

110
examples/3dsprites/animation/nflib/include/nf_colision.h
View File

@ -1,110 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_COLISION_H__
#define __NF_COLISION_H__
// NightFox LIB - Include de Colisiones
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define los slots maximos para los mapas de colisiones
#define NF_SLOTS_CMAP 32
// Define la estructura de control de mapas de colisiones
typedef struct {
char* tiles; // Buffer para almacenar los tiles
char* map; // Buffer para almacenar el mapa
char* pal; // Buffer para almacenar la paleta
u32 tiles_size; // Tamaño de los archivos
u32 map_size;
u32 pal_size;
u16 width; // Ancho del mapa (en pixeles)
u16 height; // Alto del mapa (en pixeles)
bool inuse; // Esta en uso el slot?
} NF_TYPE_CMAP_INFO;
extern NF_TYPE_CMAP_INFO NF_CMAP[NF_SLOTS_CMAP]; // Datos de los mapas de colision
// Funcion NF_InitCmapBuffers();
void NF_InitCmapBuffers(void);
// Inicializa los buffers que almacenaran los mapas de colision
// Debes usar esta funcion una unica vez antes de cargar ningun mapa de colision
// Funcion NF_ResetCmapBuffers();
void NF_ResetCmapBuffers(void);
// Reinicia los buffers y variables de los mapas de colisiones.
// Funcion NF_LoadColisionMap();
void NF_LoadColisionMap(const char* file, u8 id, u16 width, u16 height);
// Carga un mapa de colisiones en el slot indicado.
// Funcion NF_UnloadColisionMap();
void NF_UnloadColisionMap(u8 id);
// Borra de la RAM el mapa de colisiones con el nº de slot indicado.
// Funcion NF_GetTile();
extern u16 NF_GetTile(u8 slot, s32 x, s32 y);
// Devuelve el numero de tile de la posicion especificada.
// Funcion NF_SetTile();
void NF_SetTile(u8 slot, s32 x, s32 y, u16 value);
// Cambia el valor del tile en la posicion especificada.
// Funcion NF_LoadColisionBg();
void NF_LoadColisionBg(const char* file, u8 id, u16 width, u16 height);
// Carga un fondo de colisiones para pixel perfect
// Funcion NF_UnloadColisionBg();
void NF_UnloadColisionBg(u8 id);
// Descarga un fondo de colisiones para pixel perfect
// Funcion NF_GetPoint();
extern u8 NF_GetPoint(u8 slot, s32 x, s32 y);
// Obten el color del pixel de las coordenadas dadas
#endif
#ifdef __cplusplus
}
#endif

79
examples/3dsprites/animation/nflib/include/nf_defines.h
View File

@ -1,79 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_DEFINES_H__
#define __NF_DEFINES_H__
// NightFox LIB - Definiciones General
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Definicion de los datos del usuario
// Informacion obtenida de PALIB source code
// Referencias usadas de http://nds.metawiki.com/Firmware
/*
FW offset* RAM address Bytes Description
0x000020 2 user settings offset / 8 (default 0x7FC0 => 0x3FE00)
0x00002A 2 CRC16 (with initial value 0) of 0x2C with config length
0x00002C 2 config length (0x138)
0x000036 6 MAC address
0x00003C 4 enabled channels
0x000065 1 ?
0x000082 1 ?
0x000100 1 ?
0x000146 14 ?
0x000162 1 ?
0x03Fx00 0x023FFC80 1 version (5)
0x03Fx02 0x027FFC82 1 favorite color (0-15)
0x03Fx03 0x027FFC83 1 birthday month (1-12)
0x03Fx04 0x027FFC84 1 birthday day (1-31)
0x03Fx06 0x027FFC86 20 name, UTF-16
0x03Fx1A 0x027FFC9A 1/2 length of name in characters
0x03Fx1C 0x027FFC9C 52 message, UTF-16
0x03Fx50 0x027FFCD0 1/2 length of message in characters
0x03Fx52 0x027FFCD2 1 alarm hour
0x03Fx53 0x027FFCD3 1 alarm minute
0x03Fx56 0x027FFCD6 1 0x80=enable alarm, bit 0..6=enable?
0x027FFCD8 12 touch-screen calibration
0x027FFCE4 bit 0..2 language
0x027FFCE4 bit 3 GBA mode screen selection. 0=upper, 1=lower
0x027FFCE4 bit 6 auto/manual mode. 0=manual, 1=auto
WIFI power calibration
0x03Fx70 1/2 update counter (used to check latest)
0x03Fx72 CRC16 of 0x03FF00, 0x70 bytes
*/
#define NF_UDATA_COLOR *(u8*)(0x027FFC82)
#define NF_UDATA_BDAY_MONTH *(u8*)(0x027FFC83)
#define NF_UDATA_BDAY_DAY *(u8*)(0x027FFC84)
#define NF_UDATA_ALARM_HOUR *(u8*)(0x027FFCD2)
#define NF_UDATA_ALARM_MINUTE *(u8*)(0x027FFCD3)
#define NF_UDATA_NAME *(u8*)(0x027FFC86)
#define NF_UDATA_NAME_SIZE *(u8*)(0x027FFC9A)
#define NF_UDATA_MSG *(u8*)(0x027FFC9C)
#define NF_UDATA_MSG_SIZE *(u8*)(0x027FFCD0)
#define NF_UDATA_LANG *(u8*)(0x027FFCE4)
#endif
#ifdef __cplusplus
}
#endif

114
examples/3dsprites/animation/nflib/include/nf_lib.h
View File

@ -1,114 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_LIB_H__
#define __NF_LIB_H__
// NightFox LIB - Include General
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
/*
Notas sobre BITSHIFT
(n >> x) Divide n / x
(n << x) Multiplica n * x
Valores de X
2 = 1
4 = 2
8 = 3
16 = 4
32 = 5
64 = 6
128 = 7
256 = 8
512 = 9
1024 = 10
2048 = 11
4096 = 12
8192 = 13
16384 = 14
32768 = 15
65536 = 16
Dado que la DS no tiene unidad de coma flotante, siempre que dividas o
multipliques por numeros de base 2, usa el bitshift
Por ejemplo:
a = (512 / 8);
seria equivalente a
a = (512 >> 3);
Multiplicando
b = (3 * 2048);
seria con bitshift
b = (3 << 11);
*/
// Definiciones comunes
#include "nf_defines.h"
// Libreria de funciones basicas y comunes
#include "nf_basic.h"
// Libreria de funciones 2D comunes
#include "nf_2d.h"
// Libreria de fondos con Tiles
#include "nf_tiledbg.h"
// Libreria de fondos Affine
#include "nf_affinebg.h"
// Libreria de fondos en modo Bitmap
#include "nf_bitmapbg.h"
// Libreria de fondos en modo mixto (Tiled / Bitmap 8 bits)
#include "nf_mixedbg.h"
// Libreria de sprites de 256 colores
#include "nf_sprite256.h"
// Libreria de textos
#include "nf_text.h"
// Libreria de textos de 16 pixeles
#include "nf_text16.h"
// Libreria de colisiones
#include "nf_colision.h"
// Libreria de sonido
#include "nf_sound.h"
// Libreria de archivos multimedia
#include "nf_media.h"
// Libreria 3D, funciones comunes
#include "nf_3d.h"
// Libreria 3D, Sprites
#include "nf_sprite3d.h"
#endif
#ifdef __cplusplus
}
#endif

41
examples/3dsprites/animation/nflib/include/nf_media.h
View File

@ -1,41 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_MEDIA_H__
#define __NF_MEDIA_H__
// NightFox LIB - Include de funciones de carga de archivos multimedia
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Funcion NF_LoadBMP();
void NF_LoadBMP(const char* file, u8 slot);
// Carga un archivo BMP de 8, 16 o 24 bits en un slot de imagenes de 16 bits.
// Debes inicializar el modo 16 bits, el backbuffer y usar la funcion NF_Draw16bitsImage();
// para mostrarlo.
#endif
#ifdef __cplusplus
}
#endif

41
examples/3dsprites/animation/nflib/include/nf_mixedbg.h
View File

@ -1,41 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_MIXEDBG_H__
#define __NF_MIXEDBG_H__
// NightFox LIB - Include de Fondos mixtos (Tiled / Bitmap 8 bits)
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Funcion NF_InitMixedBgSys();
void NF_InitMixedBgSys(u8 screen);
// Inicializa el modo mixto para fondo (Tiled BG + Bitmap 8 bits)
// Capas 0 a 2 - Tiled
// Capa 3 - Bitmap 8 bits
#endif
#ifdef __cplusplus
}
#endif

96
examples/3dsprites/animation/nflib/include/nf_sound.h
View File

@ -1,96 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_SOUND_H__
#define __NF_SOUND_H__
// NightFox LIB - Include de funciones de sonido
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define los Slots para archivos de audio
#define NF_SLOTS_RAWSOUND 32
// Define los Buffers para almacenar los archivos de audio
extern char* NF_BUFFER_RAWSOUND[NF_SLOTS_RAWSOUND];
// Define la estructura de datos de los buffers (Audio)
typedef struct {
bool available; // Disponibilidat del Slot
u32 size; // Tamaño (en bytes) del sonido
u16 freq; // Frecuencia del sample
u8 format; // Formato del sample
} NF_TYPE_RAWSOUND_INFO;
extern NF_TYPE_RAWSOUND_INFO NF_RAWSOUND[NF_SLOTS_RAWSOUND]; // Datos de los sonidos cargado
// Funcion NF_InitRawSoundBuffers();
void NF_InitRawSoundBuffers(void);
// Iniciliaza los buffers y estructuras de datos para cargar sonidos en
// formato RAW. Debes de ejecutar esta funcion una vez antes de cargar
// ningun sonido en este formato
// Funcion NF_ResetRawSoundBuffers();
void NF_ResetRawSoundBuffers(void);
// Reinicia todos los buffers de sonido. Esta funcion es util para vaciar todos los datos
// en un cambio de pantalla, etc.
// Funcion NF_LoadRawSound();
void NF_LoadRawSound(const char* file, u16 id, u16 freq, u8 format);
// Carga un archivo RAW a la RAM desde la FAT o EFS
// Debes especificar el nombre del archivo sin extension, el slot
// donde lo guardaras (0 - 31), la frecuencia del sample (en Hz,
// por ejemplo 11050) y el formato de datos
// (0 - > 8 bits, 1 - > 16 bits, 2 -> ADPCM)
// Funcion UnloadRawSound();
void NF_UnloadRawSound(u8 id);
// Borra de la RAM el archivo cargado en el slot indicado.
// Debes especificar el slot a borrar (0 - 31)
// Funcion NF_PlayRawSound();
extern u8 NF_PlayRawSound(u8 id, u8 volume, u8 pan, bool loop, u16 loopfrom);
// Reproduce un archivo de sonido cargado en RAM.
// Debes especificar el slot donde se ha cargado el sonido, el volumen (0 - 127),
// el balance (0 Izquierda, 64 Centro, 127 Derecha), si se reproducira en bucle y
// de ser asi, a partir de que sample se producira este.
// Esta funcion devuelve el canal asignado a esta reproduccion
#endif
#ifdef __cplusplus
}
#endif

265
examples/3dsprites/animation/nflib/include/nf_sprite256.h
View File

@ -1,265 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_SPRITE256_H__
#define __NF_SPRITE256_H__
// NightFox LIB - Include de Sprites a 256 colores
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define los Slots para sprites
#define NF_SLOTS_SPR256GFX 256 // Almacena los graficos
#define NF_SLOTS_SPR256PAL 64 // Almacena las paletas
// Define los Buffers para almacenar los Sprites
extern char* NF_BUFFER_SPR256GFX[NF_SLOTS_SPR256GFX];
extern char* NF_BUFFER_SPR256PAL[NF_SLOTS_SPR256PAL];
// Define la estructura de datos de los buffers (GFX)
typedef struct {
u32 size; // Tamaño (en bytes) del grafico (GFX)
u16 width; // Ancho del Gfx
u16 height; // Altura del Gfx
bool available; // Disponibilidat del Slot
} NF_TYPE_SPR256GFX_INFO;
extern NF_TYPE_SPR256GFX_INFO NF_SPR256GFX[NF_SLOTS_SPR256GFX]; // Buffers de Graficos
// Define la estructura de datos de los buffers (PAL)
typedef struct {
u32 size; // Tamaño (en bytes) de la paleta (PAL)
bool available; // Disponibilidat del Slot
} NF_TYPE_SPR256PAL_INFO;
extern NF_TYPE_SPR256PAL_INFO NF_SPR256PAL[NF_SLOTS_SPR256PAL]; // Buffers de Paletas
// Define la estructura de Gfx en VRAM
typedef struct {
u32 size; // Tamaño (en bytes) del Gfx
u16 width; // Ancho del Gfx
u16 height; // Altura del Gfx
u32 address; // Posicion en la VRAM
u16 ramid; // Numero de Slot en RAM del que provienes
u16 framesize; // Tamaño del frame (en bytes)
u16 lastframe; // Ultimo frame
bool keepframes; // Si es un Sprite animado, debes de mantener los frames en RAM ?
bool inuse; // Disponibilidat del Slot
} NF_TYPE_SPR256VRAM_INFO;
extern NF_TYPE_SPR256VRAM_INFO NF_SPR256VRAM[2][128];
// Datos de paletas de Sprites en VRAM (en uso, slot en ram, etc)
typedef struct {
bool inuse; // Slot en uso
u8 ramslot; // Paleta original en RAM
} NF_TYPE_SPRPALSLOT_INFO;
extern NF_TYPE_SPRPALSLOT_INFO NF_SPRPALSLOT[2][16];
// Define la estructura de datos del OAM (Sprites)
typedef struct {
u8 index; // Numero de Sprite
s16 x; // Coordenada X del Sprite
s16 y; // Coordenada Y del Sprite
u8 layer; // Prioridad en las capas
u8 pal; // Paleta que usaras
u32 size; // Tamaño del Sprite (macro)
u32 color; // Modo de color (macro)
u32* gfx; // Puntero al grafico usado
s8 rot; // Id de rotacion (-1 ninguno) (0 - 31 Id de rotacion)
bool doublesize; // Usar el "double size" al rotar ?
bool hide; // Ocultar el Sprite
bool vflip; // Volteado Vertical
bool hflip; // Volteado Horizontal
bool mosaic; // Mosaico
u16 gfxid; // Id de Gfx usado
u16 frame; // Frame actual
u16 framesize; // Tamaño del frame (en bytes)
u16 lastframe; // Ultimo frame
bool created; // Esta creado este sprite ?
} NF_TYPE_SPRITEOAM_INFO;
extern NF_TYPE_SPRITEOAM_INFO NF_SPRITEOAM[2][128]; // 2 pantallas, 128 sprites
// Define la esturctura de control de la VRAM para Sprites
typedef struct {
s32 free; // Memoria VRAM libre
u32 next; // Siguiente posicion libre
u32 last; // Ultima posicion usada
u32 pos[128]; // Posicion en VRAM para reusar despues de un borrado
u32 size[128]; // Tamaño del bloque libre para reusar
u16 deleted; // Numero de bloques borrados
s32 fragmented; // Memoria VRAM fragmentada
s32 inarow; // Memoria VRAM contigua
s32 max; // Maxima memoria VRAM direccionable
} NF_TYPE_SPRVRAM_INFO;
extern NF_TYPE_SPRVRAM_INFO NF_SPRVRAM[2]; // Informacion VRAM de Sprites en ambas pantallas
// Funcion NF_InitSpriteBuffers()
void NF_InitSpriteBuffers(void);
// Inicializa los buffers y estructuras de datos de los Buffers para almacenar Sprites
// Usala antes de cargar cualquier Sprites
// No uses esta funcion mas de una vez en tu codigo
// Funcion NF_ResetSpriteBuffers()
void NF_ResetSpriteBuffers(void);
// Reinicia los buffers y datos para almacenar Sprites
// Funcion NF_InitSpriteSys();
void NF_InitSpriteSys(int screen, ...);
// Inicializa las variables de control de Sprites y paletas
// Asigna 128kb de RAM para Sprites
// Activa el Soporte para Sprites
// Se debe especificar la pantalla (0 o 1)
// Funcion NF_LoadSpriteGfx();
void NF_LoadSpriteGfx(const char* file, u16 id, u16 width, u16 height);
// Carga un grafico para usarlo despues en la creacion de Sprites
// Especifica el archivo, ID exclusivo (0 - 255) y medidas del grafico
// Funcion NF_UnloadSpriteGfx();
void NF_UnloadSpriteGfx(u16 id);
// Borra de la RAM un Gfx cargado previamente con NF_LoadSpriteGfx();
// Especifica la Id exclusiva (0 - 255) de grafico a borrar.
// Funcion NF_LoadSpritePal();
void NF_LoadSpritePal(const char* file, u8 id);
// Carga una paleta para usarla despues en la creacion de Sprites
// Especifica el archivo y ID exclusivo (0 - 63)
// Funcion NF_UnloadSpritePal();
void NF_UnloadSpritePal(u8 id);
// Borra de la RAM una Paleta cargada previamente con NF_LoadSpritePal();
// Especifica la Id exclusiva (0 - 63) de la paleta a borrar.
// Funcion NF_VramSpriteGfx();
void NF_VramSpriteGfx(u8 screen, u16 ram, u16 vram, bool keepframes);
// Transfiere un Grafico cargado para Sprites a la VRAM
// Debes especificar la pantalla, el Id del Grafico en RAM (origen),
// la Id del grafico en VRAM (destino) y si, en caso de estar animado,
// debe de copiar a la VRAM todos los frames o solo el que este en uso
// Funcion NF_FreeSpriteGfx();
void NF_FreeSpriteGfx(u8 screen, u16 id);
// Borra de la VRAM el Grafico con la Id. especificada.
// Cualquier Sprite que este usando ese Gfx, quedara corrupto.
// Funcion NF_VramSpriteGfxDefrag();
void NF_VramSpriteGfxDefrag(u8 screen);
// Desfragmenta la VRAM de Sprites (Gfx) de la pantalla dada
// Esta se realiza automaticamente al borrar un Gfx de la VRAM
// si la memoria fragmentada es superior a la contigua libre.
// Puedes consultar estos valores con las siguientes variables
// NF_SPRVRAM[u8 screen].free <- Memoria VRAM de Sprites libre
// NF_SPRVRAM[u8 screen].fragmented <- Memoria VRAM de sprites libre fragmentada
// NF_SPRVRAM[u8 screen].inarow <- Memoria VRAM de sprites libre, ultimo bloque mas grande
// NF_SPRVRAM[u8 screen].lost <- Memoria VRAM libre no usable por fragmentacion
// Funcion NF_VramSpritePal();
void NF_VramSpritePal(u8 screen, u8 id, u8 slot);
// Transfiere una Paleta cargada para Sprites a la VRAM
// Debes especificar la pantalla, la Id de la Paleta a trasnferir
// y el slot de destino (0 - 15)
// Funcion NF_CreateSprite();
void NF_CreateSprite(u8 screen, u8 id, u16 gfx, u8 pal, s16 x, s16 y);
// Crea un sprite en la pantalla.
// Debes especificar la pantalla, la ID del Sprite (0 - 127),
// la ID del Grafico que usaras (0 - 255), el slot de paleta (0 - 15),
// y las coordenadas donde lo crearas.
// Funcion NF_DeleteSprite();
void NF_DeleteSprite(u8 screen, u8 id);
// Borra un sprite de la pantalla
// Debes especificar la pantalla y la Id del Sprite a borrar
// Funcion NF_SpriteOamSet();
void NF_SpriteOamSet(u8 screen);
// Copia los datos del array propio de OAM al OAM real
// Debes especificar la pantalla
// Funcion NF_SpriteSetPalColor();
void NF_SpriteSetPalColor(u8 screen, u8 pal, u8 number, u8 r, u8 g, u8 b);
// Cambia el valor de un color de la paleta de sprites especificada.
// Debes especificar la pantalla, slot de la paleta en VRAM, numero de color
// a cambiar dentro de la paleta y el nuevo valor a darle en formato RGB
// Funcion NF_SpriteEditPalColor();
void NF_SpriteEditPalColor(u8 screen, u8 pal, u8 number, u8 r, u8 g, u8 b);
// Modifica los valores de la paleta seleccionada. Las modificaciones se efectuan
// sobre la copia en RAM, por lo que los cambios no seran visibles hasta que se
// transfiera la paleta a la VRAM
// Funcion NF_SpriteUpdatePalette();
void NF_SpriteUpdatePalette(u8 screen, u8 pal);
// Actualiza la paleta en VRAM con la copia que se encuentra en la RAM
// Funcion NF_SpriteGetPalColor();
void NF_SpriteGetPalColor(u8 screen, u8 pal, u8 number, u8* r, u8* g, u8* b);
// Obtiene el valor de un color de la paleta que se encuentra en la RAM
#endif
#ifdef __cplusplus
}
#endif

243
examples/3dsprites/animation/nflib/include/nf_sprite3d.h
View File

@ -1,243 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_SPRITE3D_H__
#define __NF_SPRITE3D_H__
// NightFox LIB - Include de funciones 3D
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
//////////////////////////////////
// Defines y variables globales //
//////////////////////////////////
// Numero maximo de sprites en pantalla
#define NF_3DSPRITES 256
// Estructura de control de los sprites 3d
typedef struct {
s16 x; // Coordenada X
s16 y; // Coordenada Y
s16 z; // Coordenada Z
s16 rx; // Rotacion Eje X (-512/0/512) << 6
s16 ry; // Rotacion Eje Y (-512/0/512) << 6
s16 rz; // Rotacion Eje Z (-512/0/512) << 6
bool rot; // Rotacion en uso
u16 sx; // Escala X (0/64/512) << 6
u16 sy; // Escala Y (0/64/512) << 6
bool scale; // Escalado en uso
s16 width; // Ancho del sprite
s16 height; // Alto del sprite
bool inuse; // Esta en uso?
bool show; // Debe mostrarse el sprite?
u32 gfx_tex_format; // Guarda el formato de la textura
u32 gfx; // Direccion donde esta almacenado el grafico en VRAM
u16 gfxid; // Id de Gfx usado
u16 frame; // Frame actual
u16 newframe; // Frame al que cambiar
u16 framesize; // Tamaño del frame (en bytes)
u16 lastframe; // Ultimo frame
u32 gfx_pal_format; // Guarda el formato de la paleta
u32 pal; // Direccion donde esta almacenada la paleta en VRAM
u16 palid; // Id de la paleta usada
u16 prio; // Prioridad de dibujado del sprite
u8 poly_id; // Identificador unico para el Alpha (0 por defecto, 63 prohibido)
u8 alpha; // Nivel de alpha (0 - 31) (31 por defecto)
} NF_TYPE_3DSPRITE_INFO;
extern NF_TYPE_3DSPRITE_INFO NF_3DSPRITE[NF_3DSPRITES];
// Estructura de control Texturas en VRAM
typedef struct {
u32 size; // Tamaño (en bytes) del Gfx
u16 width; // Ancho del Gfx
u16 height; // Altura del Gfx
u32 address; // Posicion en la VRAM
u16 ramid; // Numero de Slot en RAM del que provienes
u16 framesize; // Tamaño del frame (en bytes)
u16 lastframe; // Ultimo frame
bool keepframes; // Si es un Sprite animado, debes de mantener los frames en RAM ?
bool inuse; // Disponibilidat del Slot
} NF_TYPE_TEX256VRAM_INFO;
extern NF_TYPE_TEX256VRAM_INFO NF_TEX256VRAM[NF_3DSPRITES];
// Estructura de control de las paletas en VRAM
typedef struct {
bool inuse; // Slot en uso
u8 ramslot; // Paleta original en RAM
} NF_TYPE_3DSPRPALSLOT_INFO;
extern NF_TYPE_3DSPRPALSLOT_INFO NF_TEXPALSLOT[32];
// Define la esturctura de control de la VRAM para Sprites 3d
typedef struct {
s32 free; // Memoria VRAM libre
u32 next; // Siguiente posicion libre
u32 last; // Ultima posicion usada
u32 pos[NF_3DSPRITES]; // Posicion en VRAM para reusar despues de un borrado
u32 size[NF_3DSPRITES]; // Tamaño del bloque libre para reusar
u16 deleted; // Numero de bloques borrados
s32 fragmented; // Memoria VRAM fragmentada
s32 inarow; // Memoria VRAM contigua
} NF_TYPE_TEXVRAM_INFO;
extern NF_TYPE_TEXVRAM_INFO NF_TEXVRAM; // Informacion VRAM de texturas
// Define la estructura de control de los sprites 3d creados
typedef struct {
s16 total; // Numero de sprites creados
u16 id[NF_3DSPRITES]; // ID del Sprite
u16 bck[NF_3DSPRITES]; // Backup del ID
} NF_TYPE_CREATED_3DSPRITE_INFO;
extern NF_TYPE_CREATED_3DSPRITE_INFO NF_CREATED_3DSPRITE;
// Funcion NF_Init3dSpriteSys();
void NF_Init3dSpriteSys(void);
// Inicializa el sistema de Sprites en 3D
// Funcion NF_Vram3dSpriteGfx();
void NF_Vram3dSpriteGfx(u16 ram, u16 vram, bool keepframes);
// Transfiere un grafico de la RAM a la VRAM
// Funcion NF_Free3dSpriteGfx();
void NF_Free3dSpriteGfx(u16 id);
// Elimina de la VRAM un grafico de texturas y desfragmenta la VRAM si es necesario
// Funcion NF_Vram3dSpriteGfxDefrag();
void NF_Vram3dSpriteGfxDefrag(void);
// Desfragmenta la VRAM usada para texturas
// Funcion NF_Vram3dSpritePal();
void NF_Vram3dSpritePal(u8 id, u8 slot);
// Copia una paleta a la VRAM
// Funcion NF_Create3dSprite();
void NF_Create3dSprite(u16 id, u16 gfx, u16 pal, s16 x, s16 y);
// Crea un Sprite 3D en las coordenadas indicadas
// Funcion NF_Delete3dSprite();
void NF_Delete3dSprite(u16 id);
// Borra el Sprite con la ID indicada
// Funcion NF_Sort3dSprites();
void NF_Sort3dSprites(void);
// Reordena la cola de Sprites 3D creados de menor a mayor segun su ID
// Los Sprites con numeros mas bajos tienen prioridad.
// Funcion NF_Set3dSpritePriority();
void NF_Set3dSpritePriority(u16 id, u16 prio);
// Cambia la prioridad del Sprite
// Funcion NF_Swap3dSpritePriority();
void NF_Swap3dSpritePriority(u16 id_a, u16 id_b);
// Intercambia la prioridad de dos Sprites
// Funcion NF_Move3dSprite();
void NF_Move3dSprite(u16 id, s16 x, s16 y);
// Mueve el Sprite seleccionado a las coordenadas dadas
// Funcion NF_Show3dSprite();
void NF_Show3dSprite(u16 id, bool show);
// Muestra u oculta el sprite con la id indicada
// Funcion NF_Set3dSpriteFrame();
void NF_Set3dSpriteFrame(u16 id, u16 frame);
// Cambia el frame visible del sprite indicado
// Funcion NF_Draw3dSprites();
void NF_Draw3dSprites(void);
// Dibuja en pantalla todos los sprites creados
// Funcion NF_Update3dSpritesGfx();
void NF_Update3dSpritesGfx(void);
// Actualiza si es necesario las texturas de los sprites animados
// Funcion NF_Rotate3dSprite();
void NF_Rotate3dSprite(u16 id, s16 x, s16 y, s16 z);
// Rota el Sprite sobre los ejes indicados (-512/0/512)
// Funcion NF_Scale3dSprite();
void NF_Scale3dSprite(u16 id, u16 x, u16 y);
// Escala el sprite al tamaño indicado (0/64/512)
// Funcion NF_Blend3dSprite();
void NF_Blend3dSprite(u8 sprite, u8 poly_id, u8 alpha);
// Habilita y cambia el nivel de alpha de el sprite 3d indicado. Para que la transparencia
// sea efectiva entre Sprites, debes especificar un poly_id diferente para cada sprite
// (entre 1 y 62). El rango de alpha es de 0 a 31, siendo 31 opaco. Para eliminar la
// transparencia, selecciona un valor para alpha de 31 o especifica como poly_id el nº 0.
// Funcion NF_3dSpritesLayer();
void NF_3dSpritesLayer(u8 layer);
// Selecciona la capa en la que se dibujaran los Sprites 3D. (0 - 3)
// En realidad los Sprites 3D siempre se dibujan sobre la CAPA 0, esta funcion solo cambia
// la prioridad de esta capa sobre las demas.
// Funcion NF_3dSpriteEditPalColor();
void NF_3dSpriteEditPalColor(u8 pal, u8 number, u8 r, u8 g, u8 b);
// Modifica los valores de la paleta seleccionada. Las modificaciones se efectuan
// sobre la copia en RAM, por lo que los cambios no seran visibles hasta que se
// transfiera la paleta a la VRAM
// Funcion NF_3dSpriteUpdatePalette();
void NF_3dSpriteUpdatePalette(u8 pal);
// Actualiza la paleta en VRAM con la copia que se encuentra en la RAM
// Funcion NF_3dSpriteGetPalColor();
void NF_3dSpriteGetPalColor(u8 pal, u8 number, u8* r, u8* g, u8* b);
// Obtiene el valor de un color de la paleta que se encuentra en la RAM
// Funcion NF_3dSpriteSetDeep();
void NF_3dSpriteSetDeep(u8 id, s16 z);
// Cambia la profuncidad de dibujado (z) del sprite (-512/0/512),
// siendo -512 el punto mas cercano, 0 el centro por defecto
// y 512 el punto mas lejano.
#endif
#ifdef __cplusplus
}
#endif

124
examples/3dsprites/animation/nflib/include/nf_text.h
View File

@ -1,124 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_TEXT_H__
#define __NF_TEXT_H__
// NightFox LIB - Include de Textos
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define el nº de caracteres que tiene la fuente
#define NF_TEXT_FONT_CHARS 127
#define NF_TEXT_FONT_LAST_VALID_CHAR 113
// Define la estructura de control de textos
typedef struct {
u16 width; // Ultimo tile de la fila (0 - x) 32 tiles serian 0 - 31
u16 height; // Ultimo tile de la columna (0 - y)
u8 rotation; // Rotacion del texto
u8 slot; // Slot donde esta cargado el tileset de esta capa de texto
u8 pal; // Paleta que usara el texto (0 por defecto)
bool exist; // Existe la capa de texto?
bool update; // Tienes que actualizar la capa?
} NF_TYPE_TEXT_INFO;
extern NF_TYPE_TEXT_INFO NF_TEXT[2][4]; // Datos de las capas de texto
// Funcion NF_InitTextSys();
void NF_InitTextSys(u8 screen);
// Inicializa el sistema de Texto para la pantalla dada
// Funcion NF_LoadTextFont();
void NF_LoadTextFont(const char* file, const char* name, u16 width, u16 height, u8 rotation);
// Carga una fuente para usar como texto
// La fuente se cargara en un slot libre de fondos tileados
// Debes especificar el archivos sin extension y un nombre para referenciarla
// En caso de que la fuente tenga los sets de rotacion a izquierda y derecha,
// especificar 1 o 2 en el parametro "rot". 0 carga la fuente sin rotacion
// Funcion NF_UnloadTextFont();
void NF_UnloadTextFont(const char* name);
// Borra un fuente cargada en RAM
// Esta funcion simplemente llama a NF_UnloadTiledBg(); para su borrado
// Funcion NF_CreateTextLayer();
void NF_CreateTextLayer(u8 screen, u8 layer, u8 rotation, const char* name);
// Crea un fondo tileado para usarlo con texto
// Esta funcion simplemente llama a NF_CreateTiledBg(); para su creacion
// Funcion NF_DeleteTextLayer();
void NF_DeleteTextLayer(u8 screen, u8 layer);
// Borra un fondo usado como capa de texto y sus buffers y variables asociadas
// Funcion NF_WriteText();
void NF_WriteText(u8 screen, u8 layer, u16 x, u16 y, const char* text);
// Escribe un texto en el buffer de texto de la pantalla y capa seleccionada
// Funcion NF_UpdateTextLayers();
void NF_UpdateTextLayers(void);
// Copia el buffer de texto a la VRAM en las capas que sea necesario
// realizar una actualizacion
// Funcion NF_ClearTextLayer();
void NF_ClearTextLayer(u8 screen, u8 layer);
// Borra el contanido de la capa de texto seleccionada
// Funcion NF_DefineTextColor();
void NF_DefineTextColor(u8 screen, u8 layer, u8 color, u8 r, u8 g, u8 b);
// Define uno de los 16 colores disponibles para texto, en formato RGB
// Function NF_SetTextColor();
void NF_SetTextColor(u8 screen, u8 layer, u8 color);
// Selecciona con que color definido se escribira el texto (no cambia el color del texto ya escrito)
#endif
#ifdef __cplusplus
}
#endif

64
examples/3dsprites/animation/nflib/include/nf_text16.h
View File

@ -1,64 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_TEXT16_H__
#define __NF_TEXT16_H__
// NightFox LIB - Include de Textos de 16 pixels
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define el nº de caracteres que tiene la fuente
#define NF_TEXT_FONT_CHARS_16 127
#define NF_TEXT_FONT_LAST_VALID_CHAR_16 113
// Funcion NF_LoadTextFont16();
void NF_LoadTextFont16(const char* file, const char* name, u16 width, u16 height, u8 rotation);
// Carga una fuente para texto de 16 pixeles de altura
// Funcion NF_CreateTextLayer16();
void NF_CreateTextLayer16(u8 screen, u8 layer, u8 rotation, const char* name);
// Crea una capa de texto para fuentes de 16 pixeles
// Funcion NF_WriteText16();
void NF_WriteText16(u8 screen, u8 layer, u16 x, u16 y, const char* text);
// Escribe un texto en la capa y pantalla especificados
// Funcion NF_ClearTextLayer16();
void NF_ClearTextLayer16(u8 screen, u8 layer);
// Limpia la capa de texto especificada
#endif
#ifdef __cplusplus
}
#endif

320
examples/3dsprites/animation/nflib/include/nf_tiledbg.h
View File

@ -1,320 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_TILEDBG_H__
#define __NF_TILEDBG_H__
// NightFox LIB - Include de Fondos con tiles
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define los slots maximos para los fondos
#define NF_SLOTS_TBG 64 // Datos de los fondos
#define NF_SLOTS_EXBGPAL 128 // Paletas extendidas (maximo 16 paletas por fondo)
// Define el numero maximo de bancos para tiles y mapas
#define NF_MAX_BANKS_TILES 8
#define NF_MAX_BANKS_MAPS 16
// Define el numero de bancos de Mapas y Tiles
extern u8 NF_BANKS_TILES[2]; // (1 banks = 16kb) Cada banco de tiles puede alvergar 8 bancos de Mapas
extern u8 NF_BANKS_MAPS[2]; // (1 bank = 2kb) Usar multiplos de 8. Cada set de 8 bancos consume 1 banco de tiles
// Define los Buffers para almacenar los fondos
extern char* NF_BUFFER_BGTILES[NF_SLOTS_TBG];
extern char* NF_BUFFER_BGMAP[NF_SLOTS_TBG];
extern char* NF_BUFFER_BGPAL[NF_SLOTS_TBG];
// Define estructura para almacenar la info de los fondos
typedef struct {
char name[32]; // Nombre del fondo
u32 tilesize; // Tamaño del Tileset
u32 mapsize; // Tamaño del Map
u32 palsize; // Tamaño de la Paleta
u16 width; // Ancho del fondo
u16 height; // Altura del fondo
bool available; // Disponibilidat del Slot
} NF_TYPE_TBG_INFO;
extern NF_TYPE_TBG_INFO NF_TILEDBG[NF_SLOTS_TBG]; // Datos de los fondos
// Define la estructura para almacenar la info y datos de las paletas extendidas
typedef struct {
char* buffer; // Buffer para almacenar la paleta
u32 palsize; // Tamaño de la paleta
bool inuse; // Slot libre o en uso
} NF_TYPE_EXBGPAL_INFO;
extern NF_TYPE_EXBGPAL_INFO NF_EXBGPAL[NF_SLOTS_EXBGPAL]; // Datos de las paletas extendidas
// Define estructura para almacenar la info de los fondos en pantalla
typedef struct {
u8 tilebase; // Bloque de inicio en VRAM del Tileset
u8 tileblocks; // Bloques usados por el Tileset
u8 mapbase; // Bloque de inicio en VRAM del Map
u8 mapblocks; // Bloques usados por el Map
u16 bgwidth; // Ancho del fondo
u16 bgheight; // Altura del fondo
u16 mapwidth; // Ancho del mapa
u16 mapheight; // Altura del mapa
u8 bgtype; // Tipo de mapa
u8 bgslot; // Buffer de graficos usado (NF_BUFFER_BGMAP)
u8 blockx; // Bloque de mapa (horizontal)
u8 blocky; // bloque de mapa (vertical)
bool created; // Flag de si esta creado
} NF_TYPE_TBGLAYERS_INFO;
// El hardware de la DS no permite mapas mayores de 512x512
// Asi que informaremos si nuestor mapa lo gestionara el hardware si es menor o
// igual a 512x512, o usaremos nuestro motor de Tile Swaping
// bgtype 0: Normal (maximo 512 x 512)
// bgtype 1: >512 x 256
// bgtype 2: 256 x >512
// bgtype 3: >512 x >512
extern NF_TYPE_TBGLAYERS_INFO NF_TILEDBG_LAYERS[2][4]; //[screen][layer]
// Define el array de bloques libres
extern u8 NF_TILEBLOCKS[2][NF_MAX_BANKS_TILES];
extern u8 NF_MAPBLOCKS[2][NF_MAX_BANKS_MAPS];
// Funcion NF_InitTiledBgBuffers();
void NF_InitTiledBgBuffers(void);
// Inicializa los buffers y estructuras de control para usar los fondos "tileados"
// Se debe usar antes de cargar o usar cualquier fondo
// No uses esta funcion mas de una vez en tu codigo
// Funcion NF_ResetTiledBgBuffers();
void NF_ResetTiledBgBuffers(void);
// Borra todos los buffers y reinicia las estructuras de fondos "tileados"
// Usala para los cambios de nivel y similares
// Funcion NF_InitTiledBgSys();
void NF_InitTiledBgSys(u8 screen);
// Inicializa las variables de control de tiles, mapas y paletas
// Asigna 128kb de RAM para fondos tileados
// Se debe especificar la pantalla (0 o 1)
// Funcion NF_LoadTiledBg();
void NF_LoadTiledBg(const char* file, const char* name, u16 width, u16 height);
// Carga un fondo tileado desde FAT
// Debes de especificar el archivo que se cargara (sin extension) y el nombre
// que le quieres dar y las medidas en pixeles
// Funcion NF_LoadTilesForBg();
void NF_LoadTilesForBg(const char* file, const char* name, u16 width, u16 height, u16 tile_start, u16 tile_end);
// Carga desde la FAT los tiles especificados y su paleta
// Ademas, crea un mapa vacio de la medida especificada
// Esta funcion es util para cargar varios tiles y despues generar fondos
// modificando el MAP desde cogido (Generador de escenarios, animaciones, etc)
// Funcion NF_UnloadTiledBg();
void NF_UnloadTiledBg(const char* name);
// Borra de la RAM un fondo cargado con NF_LoadTiledBg();
// Debes especificar el nombre que le diste al fondo
// Funcion NF_CreateTiledBg();
void NF_CreateTiledBg(u8 screen, u8 layer, const char* name);
// Crea un fondo con los parametros dados, indicale la pantalla, capa y nombre
// Funcion NF_DeleteTiledBg();
void NF_DeleteTiledBg(u8 screen, u8 layer);
// Borra un fondo de la memoria VRAM
// Debes especificar la pantalla y numero de capa
// Funcion NF_GetTileMapAddress();
extern u32 NF_GetTileMapAddress(u8 screen, u8 layer, u16 tile_x, u16 tile_y);
// Funcion de uso interno de la libreria
// Devuelve la direccion en el buffer de un tile concreto
// Funcion NF_GetTileOfMap();
extern u16 NF_GetTileOfMap(u8 screen, u8 layer, u16 tile_x, u16 tile_y);
// Obten el valor del tile del mapa indicado en las coordenadas (en tiles) indicadas.
// Funcion NF_SetTileOfMap();
void NF_SetTileOfMap(u8 screen, u8 layer, u16 tile_x, u16 tile_y, u16 tile);
// Cambia el valor del tile del mapa indicado en las coordenadas (en tiles) indicadas.
// Funcion NF_UpdateVramMap();
void NF_UpdateVramMap(u8 screen, u8 layer);
// Actualiza en VRAM el contenido del mapa seleccionado.
// Funcion NF_BgSetPalColor();
void NF_BgSetPalColor(u8 screen, u8 layer, u8 number, u8 r, u8 g, u8 b);
// Cambia al momento el valor de un color de la paleta
// Cuidado! Funcion Muy lenta, usar solo para 2 o 3 colores por ciclo
// Cambia el color directamente en la VRAM
// Funcion NF_BgEditPalColor();
void NF_BgEditPalColor(u8 screen, u8 layer, u8 number, u8 r, u8 g, u8 b);
// Edita un color de la paleta seleccionada.
// El color se edita en el buffer de RAM, para que sea efectivo,
// mandala a la VRAM con NF_UpdatePalette();
// Funcion NF_BgUpdatePalette();
void NF_BgUpdatePalette(u8 screen, u8 layer);
// Actualiza la paleta en VRAM con la que se encuentra en el buffer de RAM
// Funcion NF_BgGetPalColor();
void NF_BgGetPalColor(u8 screen, u8 layer, u8 number, u8* r, u8* g, u8* b);
// Obtiene el valor de un color de la paleta que se encuentra en la RAM
// Funcion NF_GetTilePal();
extern u8 NF_GetTilePal(u8 screen, u8 layer, u16 tile_x, u16 tile_y);
// Devuelve que numero de paleta (0 - 15) esta usando el tile del fondo especificado.
// Por defecto, todos los tiles usan la paleta del Slot nº0
// Los datos se obtienen de la compia en RAM del mapa del fondo.
// Funcion NF_SetTilePal();
void NF_SetTilePal(u8 screen, u8 layer, u16 tile_x, u16 tile_y, u8 pal);
// Cambia el numero de paleta (0 - 15) que usara el tile del fondo especificado.
// Por defecto, todos los tiles usan la paleta del Slot nº0
// Los datos se escriben de la compia en RAM del mapa del fondo, por lo que no seran
// visibles hasta que ejecutes la funcion NF_UpdateVramMap();
// Funcion NF_LoadExBgPal();
void NF_LoadExBgPal(const char* file, u8 slot);
// Carga en el buffer de RAM correspondiente una paleta de fondos, para poderla usar
// mas tarde como paleta extendida.
// Funcion NF_UnloadExBgPal();
void NF_UnloadExBgPal(u8 slot);
// Borra de la RAM la paleta del slot especificado.
// Funcion NF_VramExBgPal();
void NF_VramExBgPal(u8 screen, u8 layer, u8 id, u8 slot);
// Transfiere a la VRAM una paleta extendida en el slot de la pantalla y
// fondo especificados.
// Funcion NF_SetExBgPal();
void NF_SetExBgPal(u8 screen, u8 layer, u8 pal);
// Cambia la paleta extendida que usara un fondo.
// La paleta debe de estar transferida en la VRAM previamente
// Funcion NF_SetTileHflip();
void NF_SetTileHflip(u8 screen, u8 layer, u16 tile_x, u16 tile_y);
// Invierte horizontalmente el estado actual del tile seleccionado
// Los cambios no seran visibles hasta que actualices el mapa
// con la funcion NF_UpdateVramMap();
// Funcion NF_SetTileVflip();
void NF_SetTileVflip(u8 screen, u8 layer, u16 tile_x, u16 tile_y);
// Invierte verticalmente el estado actual del tile seleccionado
// Los cambios no seran visibles hasta que actualices el mapa
// con la funcion NF_UpdateVramMap();
// Funcion NF_RotateTileGfx();
void NF_RotateTileGfx(u8 slot, u16 tile, u8 rotation);
// Rota el grafico de un tile especificado. Rota el tile almacenado en un buffer de fondos
// que se encuentra en RAM. Debes especificar el SLOT del buffer, numero de tile en el buffer
// y el angulo de la rotacion.
// 1 - 90º a la derecha
// 2 - 90º a la izquierda
// 3 - 180º
#endif
#ifdef __cplusplus
}
#endif

BIN
examples/3dsprites/animation/nflib/lib/libnflib.a
View File

Binary file not shown.

238
examples/3dsprites/basic/Makefile
View File

@ -1,60 +1,17 @@
#---------------------------------------------------------------------------------
# Makefile for NightFox's Lib Projects
#---------------------------------------------------------------------------------
#---------------------------------------------------------------------------------
.SUFFIXES:
#---------------------------------------------------------------------------------
ifeq ($(strip $(DEVKITARM)),)
$(error "Please set DEVKITARM in your environment. export DEVKITARM=<path to>devkitARM")
endif
# These set the information text in the nds file
#GAME_TITLE := My Wonderful Homebrew
#GAME_SUBTITLE1 := built with devkitARM
#GAME_SUBTITLE2 := http://devitpro.org
#---------------------------------------------------------------------------------
# This part substitutes this include:
# include $(DEVKITARM)/ds_rules
# This allows you to set ROM info and icon easy
# Please update this block from DS_RULES file at every DEVKITARM update
#---------------------------------------------------------------------------------
include $(DEVKITARM)/base_rules
LIBNDS := $(DEVKITPRO)/libnds
GAME_TITLE := Text 1
GAME_SUBTITLE1 := Text 2
GAME_SUBTITLE2 := Text 3
GAME_ICON := $(CURDIR)/../icon.bmp
_ADDFILES := -d $(NITRO_FILES)
#---------------------------------------------------------------------------------
%.nds: %.arm9
@ndstool -c $@ -9 $< -b $(GAME_ICON) "$(GAME_TITLE);$(GAME_SUBTITLE1);$(GAME_SUBTITLE2)" $(_ADDFILES)
@echo built ... $(notdir $@)
#---------------------------------------------------------------------------------
%.nds: %.elf
@ndstool -c $@ -9 $< -b $(GAME_ICON) "$(GAME_TITLE);$(GAME_SUBTITLE1);$(GAME_SUBTITLE2)" $(_ADDFILES)
@echo built ... $(notdir $@)
#---------------------------------------------------------------------------------
%.arm9: %.elf
@$(OBJCOPY) -O binary $< $@
@echo built ... $(notdir $@)
#---------------------------------------------------------------------------------
%.arm7: %.elf
@$(OBJCOPY) -O binary $< $@
@echo built ... $(notdir $@)
#---------------------------------------------------------------------------------
%.elf:
@echo linking $(notdir $@)
@$(LD) $(LDFLAGS) $(OFILES) $(LIBPATHS) $(LIBS) -o $@
include $(DEVKITARM)/ds_rules
#---------------------------------------------------------------------------------
# TARGET is the name of the output
@ -62,43 +19,56 @@ _ADDFILES := -d $(NITRO_FILES)
# SOURCES is a list of directories containing source code
# INCLUDES is a list of directories containing extra header files
# DATA is a list of directories containing binary files embedded using bin2o
# NITRODATA is the directory where files for NitroFS will be placed
# GRAPHICS is a list of directories containing image files to be converted with grit
# AUDIO is a list of directories containing audio to be converted by maxmod
# ICON is the image used to create the game icon, leave blank to use default rule
# NITRO is a directory that will be accessible via NitroFS
#---------------------------------------------------------------------------------
TARGET := $(shell basename $(CURDIR))
BUILD := build
SOURCES := source
INCLUDES := include
DATA := data
NITRODATA := nitrofiles
TARGET := $(shell basename $(CURDIR))
BUILD := build
SOURCES := source
INCLUDES := include
DATA := data
GRAPHICS :=
AUDIO :=
ICON :=
# specify a directory which contains the nitro filesystem
# this is relative to the Makefile
NITRO := nitrofiles
#---------------------------------------------------------------------------------
# options for code generation
#---------------------------------------------------------------------------------
ARCH := -mthumb -mthumb-interwork
ARCH := -marm -mthumb-interwork -march=armv5te -mtune=arm946e-s
CFLAGS := -g -Wall -O2\
-march=armv5te -mtune=arm946e-s -fomit-frame-pointer\
-ffast-math \
$(ARCH)
CFLAGS += $(INCLUDE) -DARM9
CXXFLAGS := $(CFLAGS) -fno-rtti -fno-exceptions
ASFLAGS := -g $(ARCH)
LDFLAGS = -specs=ds_arm9.specs -g $(ARCH) -Wl,-Map,$(notdir $*.map)
CFLAGS := -g -Wall -O3\
$(ARCH) $(INCLUDE) -DARM9
CXXFLAGS := $(CFLAGS) -fno-rtti -fno-exceptions
ASFLAGS := -g $(ARCH)
LDFLAGS = -specs=ds_arm9.specs -g $(ARCH) -Wl,-Map,$(notdir $*.map)
#---------------------------------------------------------------------------------
# any extra libraries we wish to link with the project
# any extra libraries we wish to link with the project (order is important)
#---------------------------------------------------------------------------------
LIBS := -lnflib -lfilesystem -lfat -lnds9
LIBS := -lnflib
# automatigically add libraries for NitroFS
ifneq ($(strip $(NITRO)),)
LIBS := $(LIBS) -lfilesystem -lfat
endif
# automagically add maxmod library
ifneq ($(strip $(AUDIO)),)
LIBS := $(LIBS) -lmm9
endif
LIBS := $(LIBS) -lnds9
#---------------------------------------------------------------------------------
# list of directories containing libraries, this must be the top level containing
# include and lib
#---------------------------------------------------------------------------------
LIBDIRS := $(LIBNDS) $(CURDIR)/nflib
LIBDIRS := $(LIBNDS) $(PORTLIBS) $(DEVKITPRO)/nflib
#---------------------------------------------------------------------------------
# no real need to edit anything past this point unless you need to add additional
@ -107,64 +77,97 @@ LIBDIRS := $(LIBNDS) $(CURDIR)/nflib
ifneq ($(BUILD),$(notdir $(CURDIR)))
#---------------------------------------------------------------------------------
export OUTPUT := $(CURDIR)/$(TARGET)
export OUTPUT := $(CURDIR)/$(TARGET)
export VPATH := $(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
$(foreach dir,$(DATA),$(CURDIR)/$(dir))
export VPATH := $(CURDIR)/$(subst /,,$(dir $(ICON)))\
$(foreach dir,$(SOURCES),$(CURDIR)/$(dir))\
$(foreach dir,$(DATA),$(CURDIR)/$(dir))\
$(foreach dir,$(GRAPHICS),$(CURDIR)/$(dir))
export DEPSDIR := $(CURDIR)/$(BUILD)
export DEPSDIR := $(CURDIR)/$(BUILD)
export NITRO_FILES := $(CURDIR)/$(NITRODATA)
CFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
CPPFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
SFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
PNGFILES := $(foreach dir,$(GRAPHICS),$(notdir $(wildcard $(dir)/*.png)))
BINFILES := $(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
CFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
CPPFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
SFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
BINFILES := $(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
# prepare NitroFS directory
ifneq ($(strip $(NITRO)),)
export NITRO_FILES := $(CURDIR)/$(NITRO)
endif
# get audio list for maxmod
ifneq ($(strip $(AUDIO)),)
export MODFILES := $(foreach dir,$(notdir $(wildcard $(AUDIO)/*.*)),$(CURDIR)/$(AUDIO)/$(dir))
# place the soundbank file in NitroFS if using it
ifneq ($(strip $(NITRO)),)
export SOUNDBANK := $(NITRO_FILES)/soundbank.bin
# otherwise, needs to be loaded from memory
else
export SOUNDBANK := soundbank.bin
BINFILES += $(SOUNDBANK)
endif
endif
#---------------------------------------------------------------------------------
# use CXX for linking C++ projects, CC for standard C
#---------------------------------------------------------------------------------
ifeq ($(strip $(CPPFILES)),)
#---------------------------------------------------------------------------------
export LD := $(CC)
export LD := $(CC)
#---------------------------------------------------------------------------------
else
#---------------------------------------------------------------------------------
export LD := $(CXX)
export LD := $(CXX)
#---------------------------------------------------------------------------------
endif
#---------------------------------------------------------------------------------
export OFILES := $(addsuffix .o,$(BINFILES)) \
$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
export OFILES_BIN := $(addsuffix .o,$(BINFILES))
export INCLUDE := $(foreach dir,$(INCLUDES),-iquote $(CURDIR)/$(dir)) \
$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
-I$(CURDIR)/$(BUILD)
export OFILES_SOURCES := $(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
export LIBPATHS := $(foreach dir,$(LIBDIRS),-L$(dir)/lib)
export OFILES := $(PNGFILES:.png=.o) $(OFILES_BIN) $(OFILES_SOURCES)
icons := $(wildcard *.bmp)
export HFILES := $(PNGFILES:.png=.h) $(addsuffix .h,$(subst .,_,$(BINFILES)))
ifneq (,$(findstring $(TARGET).bmp,$(icons)))
export GAME_ICON := $(CURDIR)/$(TARGET).bmp
export INCLUDE := $(foreach dir,$(INCLUDES),-iquote $(CURDIR)/$(dir))\
$(foreach dir,$(LIBDIRS),-I$(dir)/include)\
-I$(CURDIR)/$(BUILD)
export LIBPATHS := $(foreach dir,$(LIBDIRS),-L$(dir)/lib)
ifeq ($(strip $(ICON)),)
icons := $(wildcard *.bmp)
ifneq (,$(findstring $(TARGET).bmp,$(icons)))
export GAME_ICON := $(CURDIR)/$(TARGET).bmp
else
ifneq (,$(findstring icon.bmp,$(icons)))
export GAME_ICON := $(CURDIR)/icon.bmp
endif
endif
else
ifneq (,$(findstring icon.bmp,$(icons)))
export GAME_ICON := $(CURDIR)/icon.bmp
endif
ifeq ($(suffix $(ICON)), .grf)
export GAME_ICON := $(CURDIR)/$(ICON)
else
export GAME_ICON := $(CURDIR)/$(BUILD)/$(notdir $(basename $(ICON))).grf
endif
endif
.PHONY: $(BUILD) clean
#---------------------------------------------------------------------------------
$(BUILD):
@[ -d $@ ] || mkdir -p $@
@make --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
@mkdir -p $@
@$(MAKE) --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
#---------------------------------------------------------------------------------
clean:
@echo clean ...
@rm -fr $(BUILD) $(TARGET).elf $(TARGET).nds $(TARGET).arm9
@rm -fr $(BUILD) $(TARGET).elf $(TARGET).nds $(SOUNDBANK)
#---------------------------------------------------------------------------------
else
@ -172,14 +175,47 @@ else
#---------------------------------------------------------------------------------
# main targets
#---------------------------------------------------------------------------------
$(OUTPUT).nds : $(OUTPUT).elf
$(OUTPUT).elf : $(OFILES)
$(OUTPUT).nds: $(OUTPUT).elf $(NITRO_FILES) $(GAME_ICON)
$(OUTPUT).elf: $(OFILES)
# source files depend on generated headers
$(OFILES_SOURCES) : $(HFILES)
# need to build soundbank first
$(OFILES): $(SOUNDBANK)
#---------------------------------------------------------------------------------
%.bin.o : %.bin
# rule to build solution from music files
#---------------------------------------------------------------------------------
$(SOUNDBANK) : $(MODFILES)
#---------------------------------------------------------------------------------
mmutil $^ -d -o$@ -hsoundbank.h
#---------------------------------------------------------------------------------
%.bin.o %_bin.h : %.bin
#---------------------------------------------------------------------------------
@echo $(notdir $<)
$(bin2o)
@$(bin2o)
#---------------------------------------------------------------------------------
# This rule creates assembly source files using grit
# grit takes an image file and a .grit describing how the file is to be processed
# add additional rules like this for each image extension
# you use in the graphics folders
#---------------------------------------------------------------------------------
%.s %.h: %.png %.grit
#---------------------------------------------------------------------------------
grit $< -fts -o$*
#---------------------------------------------------------------------------------
# Convert non-GRF game icon to GRF if needed
#---------------------------------------------------------------------------------
$(GAME_ICON): $(notdir $(ICON))
#---------------------------------------------------------------------------------
@echo convert $(notdir $<)
@grit $< -g -gt -gB4 -gT FF00FF -m! -p -pe 16 -fh! -ftr
-include $(DEPSDIR)/*.d
#---------------------------------------------------------------------------------------
endif

5
examples/3dsprites/basic/clean.bat
View File

@ -1,5 +0,0 @@
@echo off
cls
make clean
pause
exit

5
examples/3dsprites/basic/compile.bat
View File

@ -1,5 +0,0 @@
@echo off
cls
make
pause
exit

BIN
examples/3dsprites/basic/icon.bmp
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 1.1 KiB

139
examples/3dsprites/basic/nflib/include/nf_2d.h
View File

@ -1,139 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_2D_H__
#define __NF_2D_H__
// NightFox LIB - Include de funciones 2D comunes
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Funcion NF_Set2D();
void NF_Set2D(u8 screen, u8 mode);
// Inicia el modo 2D seleccionado en la pantalla deseada
// Funcion NF_ShowBg();
void NF_ShowBg(u8 screen, u8 layer);
// Haz visible el fondo de la capa y pantalla dados
// Funcion NF_HideBg();
void NF_HideBg(u8 screen, u8 layer);
// Oculta el fondo de la capa y pantalla dados
// Funcion NF_ScrollBg();
void NF_ScrollBg(u8 screen, u8 layer, s16 x, s16 y);
// Mueve el fondo a las coordenadas especificadas.
// Debes de indicar la pantalla, capa, y coordenadas X e Y
// Si el mapa es mayor de 512 en alguna medida, debes de mantener el fondo en RAM
// Funcion NF_MoveSprite();
void NF_MoveSprite(u8 screen, u8 id, s16 x, s16 y);
// Mueve el Sprite a las coordenadas especificadas
// Debes de indicar la pantalla, id de sprite y coordenadas
// Funcion NF_SpriteLayer();
void NF_SpriteLayer(u8 screen, u8 id, u8 layer);
// Define la capa sobre la que el sprite sera dibujado
// Debes de indicar la pantalla, id del sprite y capa
// Funcion NF_ShowSprite();
void NF_ShowSprite(u8 screen, u8 id, bool show);
// Muestra o oculta el sprite
// Debes especificar la pantalla, id del sprite y el estado (true, false)
// Funcion NF_HflipSprite();
void NF_HflipSprite(u8 screen, u8 id, bool hflip);
// Voltea el Sprite horizontalmente
// Debes especificar la pantalla, id del sprite y el estado (true, false)
// Funcion NF_GetSpriteHflip();
extern bool NF_GetSpriteHflip(u8 screen, u8 id);
// Devuelve el estado del volteado horizontal de un sprite
// Debes especificar la pantalla y la id del sprite
// Funcion NF_VflipSprite();
void NF_VflipSprite(u8 screen, u8 id, bool vflip);
// Voltea el Sprite verticalmente
// Debes especificar la pantalla, id del sprite y el estado (true, false)
// Funcion NF_GetSpriteVflip();
extern bool NF_GetSpriteVflip(u8 screen, u8 id);
// Devuelve el estado del volteado vertical de un sprite
// Debes especificar la pantalla y la id del sprite
// Funcion NF_SpriteFrame();
void NF_SpriteFrame(u8 screen, u8 id, u16 frame);
// Cambia el frame de un Sprite
// Debes especificar la pantalla, el Id del sprite y el frame
// Funcion NF_EnableSpriteRotScale();
void NF_EnableSpriteRotScale(u8 screen, u8 sprite, u8 id, bool doublesize);
// Habilita el sprite como rotable y escalable
// Debes especificar la pantalla, nº de sprite, id de rotacion y si
// tiene que activarse el doublesize (tamaño x2)
// Funcion NF_DisableSpriteRotScale();
void NF_DisableSpriteRotScale(u8 screen, u8 sprite);
// Deshabilita un sprite como rotable y escalable
// Debes especificar la pantalla y el nº de sprite
// Funcion NF_SpriteRotScale();
void NF_SpriteRotScale(u8 screen, u8 id, s16 angle, u16 sx, u16 sy);
// Define el angulo de rotacion y escala de los Sprites asociados a la Id.
// El rango del angulo es desde -512 a 512, siendo 0 el valor central
// El rango de escalado va de 0 a 512, siendo 256 el valor normal (100%)
#endif
#ifdef __cplusplus
}
#endif

50
examples/3dsprites/basic/nflib/include/nf_3d.h
View File

@ -1,50 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_3D_H__
#define __NF_3D_H__
// NightFox LIB - Include de funciones 3D
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Funcion NF_Set3D();
void NF_Set3D(u8 screen, u8 mode);
// Inicia el modo 3D seleccionado en la pantalla deseada
// Funcion NF_InitOpenGL();
void NF_InitOpenGL(void);
// Inicializa el OpenGL para la libreria
// Funcion NF_GetTextureSize();
extern u16 NF_GetTextureSize(u16 textel);
// Devuelve el tamaño del textel
#endif
#ifdef __cplusplus
}
#endif

106
examples/3dsprites/basic/nflib/include/nf_affinebg.h
View File

@ -1,106 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_AFFINEBG_H__
#define __NF_AFFINEBG_H__
// NightFox LIB - Includes de Fondos Affine
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Estructura para almacenar los parametros de los fondos Affine
typedef struct {
s32 x; // Posicion X
s32 y; // Posicion Y
s32 x_center; // Centro X
s32 y_center; // Centro Y
s32 x_scale; // Valor Zoom X (PA)
s32 y_scale; // Valor Zoom Y (PD)
s32 x_tilt; // Valor Inclinacion X (PB)
s32 y_tilt; // Valor Inclinacion Y (PC)
s32 angle; // Valor de la rotacion
} NF_TYPE_AFFINE_BG;
extern NF_TYPE_AFFINE_BG NF_AFFINE_BG[2][4];
// Funcion NF_InitTiledBgSys();
void NF_InitAffineBgSys(u8 screen);
// Inicializa el sistema de fondos Affine. Solo puede usarse en las capas 2 y 3, los fondos en
// la misma pantalla deben de compartir la paleta y no pueden tener mas de 256 tiles.
// Funcion NF_LoadAffineBg();
void NF_LoadAffineBg(const char* file, const char* name, u16 width, u16 height);
// Carga un fondo tileado desde FAT
// Debes de especificar el archivo que se cargara (sin extension) y el nombre
// que le quieres dar y las medidas en pixeles
// Los buffers para fondos tileados deben estar inicializados antes de usar esta funcion
// Funcion NF_UnloadAffineBg();
void NF_UnloadAffineBg(const char* name);
// Borra de la RAM el fondo affine especificado. Es una simple llamada a la funcion NF_UnloadTiledBg();
// Funcion NF_CreateAffineBg();
void NF_CreateAffineBg(u8 screen, u8 layer, const char* name, u8 wrap);
// Crea un fondo con los parametros dados, indicale la pantalla, capa, nombre y si se activa la opcion
// de WRAP arround (0 desactivado, 1 activado).
// Funcion NF_DeleteAffineBg();
void NF_DeleteAffineBg(u8 screen, u8 layer);
// Borra el fondo Affine especificado
// Funcion NF_AffineBgTransform();
void NF_AffineBgTransform(u8 screen, u8 layer, s32 x_scale, s32 y_scale, s32 x_tilt, s32 y_tilt);
// Modifica los parametros de la matriz de transformacion del fondo affine
// Funcion NF_AffineBgMove();
void NF_AffineBgMove(u8 screen, u8 layer, s32 x, s32 y, s32 angle);
// Desplaza el fondo affine y rotalo (-2048 a 2048)
// Funcion NF_AffineBgCenter();
void NF_AffineBgCenter(u8 screen, u8 layer, s32 x, s32 y);
// Define el centro de rotacion de un fondo affine
#endif
#ifdef __cplusplus
}
#endif

89
examples/3dsprites/basic/nflib/include/nf_basic.h
View File

@ -1,89 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_BASIC_H__
#define __NF_BASIC_H__
// NightFox LIB - Include de funciones basicas
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define la variable global NF_ROOTFOLDER
extern char NF_ROOTFOLDER[32];
// Funcion NF_Error();
void NF_Error(u16 code, const char* text, u32 value);
// Errores para debug. Detiene el sistema e informa del error
// 101: Fichero no encontrado
// 102: Memoria insuficiente
// 103: No quedan Slots libres
// 104: Fondo no encontrado
// 105: Fondo no creado
// 106: Fuera de rango
// 107: Insuficientes bloques contiguos en VRAM (Tiles)
// 108: Insuficientes bloques contiguos en VRAM (Maps)
// 109: Id ocupada (ya esta en uso)
// 110: Id no cargada (en RAM)
// 111: Id no en VRAM
// 112: Sprite no creado
// 113: Memoria VRAM insuficiente
// 114: La capa de Texto no existe
// 115: Medidas del fondo no compatibles (no son multiplos de 256)
// 116: Archivo demasiado grande
// 117: Medidas del fondo affine incorrectas
// 118: Capa de creacion del fondo affine incorrecta
// Funcion NF_SetRootFolder();
void NF_SetRootFolder(const char* folder);
// Define el nombre de la carpeta que se usara como "root" si se usa la FAT
// Funcion NF_DmaMemCopy();
void NF_DmaMemCopy(void* destination, const void* source, u32 size);
// Copia un bloque de memoria usando DMA (canal 3, halfwords) y vaciando previamente
// el cache. Con pruebas de bloques grandes (64kb o 128kb) he observado que memcpy();
// sigue siendo mas rapida.
// Funcion NF_GetLanguage();
extern u8 NF_GetLanguage(void);
// Devuelve el ID del idioma del usuario
// 0 : Japanese
// 1 : English
// 2 : French
// 3 : German
// 4 : Italian
// 5 : Spanish
// 6 : Chinese
#endif
#ifdef __cplusplus
}
#endif

234
examples/3dsprites/basic/nflib/include/nf_bitmapbg.h
View File

@ -1,234 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_BITMAPBG_H__
#define __NF_BITMAPBG_H__
// NightFox LIB - Include de funciones de fondos en modo Bitmap
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define los slots maximos para los fondos de 16 bits
#define NF_SLOTS_BG16B 16
// Define los slots maximos para los fondos de 8 bits
#define NF_SLOTS_BG8B 16
// Define los Buffers para almacenar datos de 16 bits
typedef struct {
u16* buffer; // Buffer de datos
u32 size; // Tamaño del buffer
u16 width; // Ancho de la imagen (256 max)
u16 height; // Altura de la imagen (256 max)
bool inuse; // Esta en uso el buffer?
} NF_TYPE_BG16B_INFO;
extern NF_TYPE_BG16B_INFO NF_BG16B[NF_SLOTS_BG16B]; // Fondos RAW de 16 bits
// BackBuffer de 16 bits de cada pantalla
extern u16* NF_16BITS_BACKBUFFER[2];
// Define los Buffers para almacenar datos de 8 bits
typedef struct {
u8* data; // Buffer de datos
u32 data_size; // Tamaño del buffer de datos
u16* pal; // Buffer para la paleta
u32 pal_size; // Tamaño de la paleta
bool inuse; // Esta en uso el buffer?
} NF_TYPE_BG8B_INFO;
extern NF_TYPE_BG8B_INFO NF_BG8B[NF_SLOTS_BG8B]; // Fondos indexados de 8 bits
// BackBuffer de 8 bits de cada pantalla
typedef struct {
u8* data;
u16* pal;
} NF_TYPE_BB8B_INFO;
extern NF_TYPE_BB8B_INFO NF_8BITS_BACKBUFFER[2];
// Funcion NF_Init16bitsBgBuffers();
void NF_Init16bitsBgBuffers(void);
// Inicia los buffers para almacenar fondos de BITMAP 16 bits
// Usalo UNA SOLA VEZ antes de usar los buffers
// Funcion NF_Reset16bitsBgBuffers();
void NF_Reset16bitsBgBuffers(void);
// Reinicia los buffers para almacenar fondos de BITMAP 16 bits,
// borrado su contenido
// Funcion NF_Init16bitsBackBuffer();
void NF_Init16bitsBackBuffer(u8 screen);
// Inicia el backbuffer de la pantalla dada.
// Usalo UNA SOLA VEZ antes de usar el backbuffer
// Funcion NF_Enable16bitsBackBuffer();
void NF_Enable16bitsBackBuffer(u8 screen);
// Habilita el backbuffer de la pantalla indicada.
// Si el buffer ya existe, la funcion borrara el contenido del mismo,
// poniendo a 0 todos los bytes del buffer.
// Funcion NF_Disble16bitsBackBuffer();
void NF_Disble16bitsBackBuffer(u8 screen);
// Deshabilita el backbuffer de la pantalla indicada, liberando de la
// RAM el espacio usado.
// Funcion NF_Flip16bitsBackBuffer();
void NF_Flip16bitsBackBuffer(u8 screen);
// Copia el contenido del backbuffer a la VRAM de la pantalla indicada.
// Funcion NF_InitBitmapBgSys();
void NF_InitBitmapBgSys(u8 screen, u8 mode);
// Inicia el modo BITMAP en la pantalla especificada, con la profundidad de color
// especificada. (0 -> 256 colores, 1 -> 16 bits)
// Funcion NF_Load16bitsBg();
void NF_Load16bitsBg(const char* file, u8 slot);
// Carga un Fondo BITMAP (en formato RAW) en el slot indicado,
// de un tamaño maximo de 256x256 pixeles.
// Debes especificar el nombre de archivo sin extension.
// El archivo debe ser un binario con extension .img
// Funcion NF_Load16bitsImage();
void NF_Load16bitsImage(const char* file, u8 slot, u16 size_x, u16 size_y);
// Carga una imagen BITMAP (en formato RAW) en el slot indicado,
// de un tamaño maximo de 256x256 pixeles.
// Debes especificar el nombre de archivo sin extension.
// El archivo debe ser un binario con extension .img
// Todos los pixeles Magenta de la imagen (0xFF00FF) seran transparentes.
// Funcion NF_Load16bImgData();
void NF_Load16bImgData(const char* file, u8 slot, u16 x, u16 y, u8 type);
// Funcion de uso interno, no documentar ni usar.
// Cargador generico de datos de imagen de 16 bits a la RAM.
// Funcion NF_Unload16bitsBg();
void NF_Unload16bitsBg(u8 slot);
// Borra de la RAM los datos del buffer especificado
// Funcion NF_Copy16bitsBuffer();
void NF_Copy16bitsBuffer(u8 screen, u8 destination, u8 slot);
// Copia los datos cargados en un Buffer de Bitmap a la VRAM o al BackBuffer
// destination: 0 -> VRAM, 1 -> BackBuffer
// Funcion NF_Draw16bitsImage();
void NF_Draw16bitsImage(u8 screen, u8 slot, s16 x, s16 y, bool alpha);
// Copia la imagen cargada en un Buffer de Bitmap al Backbuffer de la pantalla especificada
// Funcion NF_Init8bitsBgBuffers();
void NF_Init8bitsBgBuffers(void);
// Inicializa los buffers necesarios para la carda de fondos en modo BITMAP de 8 bits.
// Debes usar esta funcion antes de poder usar ninguno de los buffers.
// Funcion NF_Reset8bitsBgBuffers();
void NF_Reset8bitsBgBuffers(void);
// Reinicia los buffers de fondos de 8 bits, borrando todo el contenido de los buffers.
// Funcion NF_Load8bitsBg();
void NF_Load8bitsBg(const char* file, u8 slot);
// Carga los archivos necesarios de un fondo de 8 bits en el Slot indicado.
// Debes especificar el nombre de archivo sin extension.
// El archivo debe ser un binario con extension .img
// La paleta debe tener la extension .pal
// Funcion NF_Unload8bitsBg();
void NF_Unload8bitsBg(u8 slot);
// Borra de la RAM el fondo del slot indicado.
// Funcion NF_Copy8bitsBuffer();
void NF_Copy8bitsBuffer(u8 screen, u8 destination, u8 slot);
// Transfiere la imagen del buffer seleccionado a la pantalla y capas indicado o
// al backbuffer.
// Funcion NF_Init8bitsBackBuffer();
void NF_Init8bitsBackBuffer(u8 screen);
// Inicializa los buffers del backbuffer para la pantalla indicada.
// Debes usar esta funcion una vez antes de usar el backbuffer
// Funcion NF_Enable8bitsBackBuffer();
void NF_Enable8bitsBackBuffer(u8 screen);
// Habilita el backbuffer de la pantalla indicada.
// Si el buffer ya existe, la funcion borrara el contenido del mismo,
// poniendo a 0 todos los bytes del buffer.
// Funcion NF_Disble8bitsBackBuffer();
void NF_Disble8bitsBackBuffer(u8 screen);
// Deshabilita el backbuffer de la pantalla indicada, liberando de la
// RAM el espacio usado.
// Funcion NF_Flip8bitsBackBuffer();
void NF_Flip8bitsBackBuffer(u8 screen, u8 destination);
// Copia el contenido del backbuffer a la VRAM de la pantalla indicada.
// Debes especificar la capa de destino:
// 0 -> Capa 2
// 1 -> Capa 3
#endif
#ifdef __cplusplus
}
#endif

110
examples/3dsprites/basic/nflib/include/nf_colision.h
View File

@ -1,110 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_COLISION_H__
#define __NF_COLISION_H__
// NightFox LIB - Include de Colisiones
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define los slots maximos para los mapas de colisiones
#define NF_SLOTS_CMAP 32
// Define la estructura de control de mapas de colisiones
typedef struct {
char* tiles; // Buffer para almacenar los tiles
char* map; // Buffer para almacenar el mapa
char* pal; // Buffer para almacenar la paleta
u32 tiles_size; // Tamaño de los archivos
u32 map_size;
u32 pal_size;
u16 width; // Ancho del mapa (en pixeles)
u16 height; // Alto del mapa (en pixeles)
bool inuse; // Esta en uso el slot?
} NF_TYPE_CMAP_INFO;
extern NF_TYPE_CMAP_INFO NF_CMAP[NF_SLOTS_CMAP]; // Datos de los mapas de colision
// Funcion NF_InitCmapBuffers();
void NF_InitCmapBuffers(void);
// Inicializa los buffers que almacenaran los mapas de colision
// Debes usar esta funcion una unica vez antes de cargar ningun mapa de colision
// Funcion NF_ResetCmapBuffers();
void NF_ResetCmapBuffers(void);
// Reinicia los buffers y variables de los mapas de colisiones.
// Funcion NF_LoadColisionMap();
void NF_LoadColisionMap(const char* file, u8 id, u16 width, u16 height);
// Carga un mapa de colisiones en el slot indicado.
// Funcion NF_UnloadColisionMap();
void NF_UnloadColisionMap(u8 id);
// Borra de la RAM el mapa de colisiones con el nº de slot indicado.
// Funcion NF_GetTile();
extern u16 NF_GetTile(u8 slot, s32 x, s32 y);
// Devuelve el numero de tile de la posicion especificada.
// Funcion NF_SetTile();
void NF_SetTile(u8 slot, s32 x, s32 y, u16 value);
// Cambia el valor del tile en la posicion especificada.
// Funcion NF_LoadColisionBg();
void NF_LoadColisionBg(const char* file, u8 id, u16 width, u16 height);
// Carga un fondo de colisiones para pixel perfect
// Funcion NF_UnloadColisionBg();
void NF_UnloadColisionBg(u8 id);
// Descarga un fondo de colisiones para pixel perfect
// Funcion NF_GetPoint();
extern u8 NF_GetPoint(u8 slot, s32 x, s32 y);
// Obten el color del pixel de las coordenadas dadas
#endif
#ifdef __cplusplus
}
#endif

79
examples/3dsprites/basic/nflib/include/nf_defines.h
View File

@ -1,79 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_DEFINES_H__
#define __NF_DEFINES_H__
// NightFox LIB - Definiciones General
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Definicion de los datos del usuario
// Informacion obtenida de PALIB source code
// Referencias usadas de http://nds.metawiki.com/Firmware
/*
FW offset* RAM address Bytes Description
0x000020 2 user settings offset / 8 (default 0x7FC0 => 0x3FE00)
0x00002A 2 CRC16 (with initial value 0) of 0x2C with config length
0x00002C 2 config length (0x138)
0x000036 6 MAC address
0x00003C 4 enabled channels
0x000065 1 ?
0x000082 1 ?
0x000100 1 ?
0x000146 14 ?
0x000162 1 ?
0x03Fx00 0x023FFC80 1 version (5)
0x03Fx02 0x027FFC82 1 favorite color (0-15)
0x03Fx03 0x027FFC83 1 birthday month (1-12)
0x03Fx04 0x027FFC84 1 birthday day (1-31)
0x03Fx06 0x027FFC86 20 name, UTF-16
0x03Fx1A 0x027FFC9A 1/2 length of name in characters
0x03Fx1C 0x027FFC9C 52 message, UTF-16
0x03Fx50 0x027FFCD0 1/2 length of message in characters
0x03Fx52 0x027FFCD2 1 alarm hour
0x03Fx53 0x027FFCD3 1 alarm minute
0x03Fx56 0x027FFCD6 1 0x80=enable alarm, bit 0..6=enable?
0x027FFCD8 12 touch-screen calibration
0x027FFCE4 bit 0..2 language
0x027FFCE4 bit 3 GBA mode screen selection. 0=upper, 1=lower
0x027FFCE4 bit 6 auto/manual mode. 0=manual, 1=auto
WIFI power calibration
0x03Fx70 1/2 update counter (used to check latest)
0x03Fx72 CRC16 of 0x03FF00, 0x70 bytes
*/
#define NF_UDATA_COLOR *(u8*)(0x027FFC82)
#define NF_UDATA_BDAY_MONTH *(u8*)(0x027FFC83)
#define NF_UDATA_BDAY_DAY *(u8*)(0x027FFC84)
#define NF_UDATA_ALARM_HOUR *(u8*)(0x027FFCD2)
#define NF_UDATA_ALARM_MINUTE *(u8*)(0x027FFCD3)
#define NF_UDATA_NAME *(u8*)(0x027FFC86)
#define NF_UDATA_NAME_SIZE *(u8*)(0x027FFC9A)
#define NF_UDATA_MSG *(u8*)(0x027FFC9C)
#define NF_UDATA_MSG_SIZE *(u8*)(0x027FFCD0)
#define NF_UDATA_LANG *(u8*)(0x027FFCE4)
#endif
#ifdef __cplusplus
}
#endif

114
examples/3dsprites/basic/nflib/include/nf_lib.h
View File

@ -1,114 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_LIB_H__
#define __NF_LIB_H__
// NightFox LIB - Include General
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
/*
Notas sobre BITSHIFT
(n >> x) Divide n / x
(n << x) Multiplica n * x
Valores de X
2 = 1
4 = 2
8 = 3
16 = 4
32 = 5
64 = 6
128 = 7
256 = 8
512 = 9
1024 = 10
2048 = 11
4096 = 12
8192 = 13
16384 = 14
32768 = 15
65536 = 16
Dado que la DS no tiene unidad de coma flotante, siempre que dividas o
multipliques por numeros de base 2, usa el bitshift
Por ejemplo:
a = (512 / 8);
seria equivalente a
a = (512 >> 3);
Multiplicando
b = (3 * 2048);
seria con bitshift
b = (3 << 11);
*/
// Definiciones comunes
#include "nf_defines.h"
// Libreria de funciones basicas y comunes
#include "nf_basic.h"
// Libreria de funciones 2D comunes
#include "nf_2d.h"
// Libreria de fondos con Tiles
#include "nf_tiledbg.h"
// Libreria de fondos Affine
#include "nf_affinebg.h"
// Libreria de fondos en modo Bitmap
#include "nf_bitmapbg.h"
// Libreria de fondos en modo mixto (Tiled / Bitmap 8 bits)
#include "nf_mixedbg.h"
// Libreria de sprites de 256 colores
#include "nf_sprite256.h"
// Libreria de textos
#include "nf_text.h"
// Libreria de textos de 16 pixeles
#include "nf_text16.h"
// Libreria de colisiones
#include "nf_colision.h"
// Libreria de sonido
#include "nf_sound.h"
// Libreria de archivos multimedia
#include "nf_media.h"
// Libreria 3D, funciones comunes
#include "nf_3d.h"
// Libreria 3D, Sprites
#include "nf_sprite3d.h"
#endif
#ifdef __cplusplus
}
#endif

41
examples/3dsprites/basic/nflib/include/nf_media.h
View File

@ -1,41 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_MEDIA_H__
#define __NF_MEDIA_H__
// NightFox LIB - Include de funciones de carga de archivos multimedia
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Funcion NF_LoadBMP();
void NF_LoadBMP(const char* file, u8 slot);
// Carga un archivo BMP de 8, 16 o 24 bits en un slot de imagenes de 16 bits.
// Debes inicializar el modo 16 bits, el backbuffer y usar la funcion NF_Draw16bitsImage();
// para mostrarlo.
#endif
#ifdef __cplusplus
}
#endif

41
examples/3dsprites/basic/nflib/include/nf_mixedbg.h
View File

@ -1,41 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_MIXEDBG_H__
#define __NF_MIXEDBG_H__
// NightFox LIB - Include de Fondos mixtos (Tiled / Bitmap 8 bits)
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Funcion NF_InitMixedBgSys();
void NF_InitMixedBgSys(u8 screen);
// Inicializa el modo mixto para fondo (Tiled BG + Bitmap 8 bits)
// Capas 0 a 2 - Tiled
// Capa 3 - Bitmap 8 bits
#endif
#ifdef __cplusplus
}
#endif

96
examples/3dsprites/basic/nflib/include/nf_sound.h
View File

@ -1,96 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_SOUND_H__
#define __NF_SOUND_H__
// NightFox LIB - Include de funciones de sonido
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define los Slots para archivos de audio
#define NF_SLOTS_RAWSOUND 32
// Define los Buffers para almacenar los archivos de audio
extern char* NF_BUFFER_RAWSOUND[NF_SLOTS_RAWSOUND];
// Define la estructura de datos de los buffers (Audio)
typedef struct {
bool available; // Disponibilidat del Slot
u32 size; // Tamaño (en bytes) del sonido
u16 freq; // Frecuencia del sample
u8 format; // Formato del sample
} NF_TYPE_RAWSOUND_INFO;
extern NF_TYPE_RAWSOUND_INFO NF_RAWSOUND[NF_SLOTS_RAWSOUND]; // Datos de los sonidos cargado
// Funcion NF_InitRawSoundBuffers();
void NF_InitRawSoundBuffers(void);
// Iniciliaza los buffers y estructuras de datos para cargar sonidos en
// formato RAW. Debes de ejecutar esta funcion una vez antes de cargar
// ningun sonido en este formato
// Funcion NF_ResetRawSoundBuffers();
void NF_ResetRawSoundBuffers(void);
// Reinicia todos los buffers de sonido. Esta funcion es util para vaciar todos los datos
// en un cambio de pantalla, etc.
// Funcion NF_LoadRawSound();
void NF_LoadRawSound(const char* file, u16 id, u16 freq, u8 format);
// Carga un archivo RAW a la RAM desde la FAT o EFS
// Debes especificar el nombre del archivo sin extension, el slot
// donde lo guardaras (0 - 31), la frecuencia del sample (en Hz,
// por ejemplo 11050) y el formato de datos
// (0 - > 8 bits, 1 - > 16 bits, 2 -> ADPCM)
// Funcion UnloadRawSound();
void NF_UnloadRawSound(u8 id);
// Borra de la RAM el archivo cargado en el slot indicado.
// Debes especificar el slot a borrar (0 - 31)
// Funcion NF_PlayRawSound();
extern u8 NF_PlayRawSound(u8 id, u8 volume, u8 pan, bool loop, u16 loopfrom);
// Reproduce un archivo de sonido cargado en RAM.
// Debes especificar el slot donde se ha cargado el sonido, el volumen (0 - 127),
// el balance (0 Izquierda, 64 Centro, 127 Derecha), si se reproducira en bucle y
// de ser asi, a partir de que sample se producira este.
// Esta funcion devuelve el canal asignado a esta reproduccion
#endif
#ifdef __cplusplus
}
#endif

265
examples/3dsprites/basic/nflib/include/nf_sprite256.h
View File

@ -1,265 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_SPRITE256_H__
#define __NF_SPRITE256_H__
// NightFox LIB - Include de Sprites a 256 colores
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define los Slots para sprites
#define NF_SLOTS_SPR256GFX 256 // Almacena los graficos
#define NF_SLOTS_SPR256PAL 64 // Almacena las paletas
// Define los Buffers para almacenar los Sprites
extern char* NF_BUFFER_SPR256GFX[NF_SLOTS_SPR256GFX];
extern char* NF_BUFFER_SPR256PAL[NF_SLOTS_SPR256PAL];
// Define la estructura de datos de los buffers (GFX)
typedef struct {
u32 size; // Tamaño (en bytes) del grafico (GFX)
u16 width; // Ancho del Gfx
u16 height; // Altura del Gfx
bool available; // Disponibilidat del Slot
} NF_TYPE_SPR256GFX_INFO;
extern NF_TYPE_SPR256GFX_INFO NF_SPR256GFX[NF_SLOTS_SPR256GFX]; // Buffers de Graficos
// Define la estructura de datos de los buffers (PAL)
typedef struct {
u32 size; // Tamaño (en bytes) de la paleta (PAL)
bool available; // Disponibilidat del Slot
} NF_TYPE_SPR256PAL_INFO;
extern NF_TYPE_SPR256PAL_INFO NF_SPR256PAL[NF_SLOTS_SPR256PAL]; // Buffers de Paletas
// Define la estructura de Gfx en VRAM
typedef struct {
u32 size; // Tamaño (en bytes) del Gfx
u16 width; // Ancho del Gfx
u16 height; // Altura del Gfx
u32 address; // Posicion en la VRAM
u16 ramid; // Numero de Slot en RAM del que provienes
u16 framesize; // Tamaño del frame (en bytes)
u16 lastframe; // Ultimo frame
bool keepframes; // Si es un Sprite animado, debes de mantener los frames en RAM ?
bool inuse; // Disponibilidat del Slot
} NF_TYPE_SPR256VRAM_INFO;
extern NF_TYPE_SPR256VRAM_INFO NF_SPR256VRAM[2][128];
// Datos de paletas de Sprites en VRAM (en uso, slot en ram, etc)
typedef struct {
bool inuse; // Slot en uso
u8 ramslot; // Paleta original en RAM
} NF_TYPE_SPRPALSLOT_INFO;
extern NF_TYPE_SPRPALSLOT_INFO NF_SPRPALSLOT[2][16];
// Define la estructura de datos del OAM (Sprites)
typedef struct {
u8 index; // Numero de Sprite
s16 x; // Coordenada X del Sprite
s16 y; // Coordenada Y del Sprite
u8 layer; // Prioridad en las capas
u8 pal; // Paleta que usaras
u32 size; // Tamaño del Sprite (macro)
u32 color; // Modo de color (macro)
u32* gfx; // Puntero al grafico usado
s8 rot; // Id de rotacion (-1 ninguno) (0 - 31 Id de rotacion)
bool doublesize; // Usar el "double size" al rotar ?
bool hide; // Ocultar el Sprite
bool vflip; // Volteado Vertical
bool hflip; // Volteado Horizontal
bool mosaic; // Mosaico
u16 gfxid; // Id de Gfx usado
u16 frame; // Frame actual
u16 framesize; // Tamaño del frame (en bytes)
u16 lastframe; // Ultimo frame
bool created; // Esta creado este sprite ?
} NF_TYPE_SPRITEOAM_INFO;
extern NF_TYPE_SPRITEOAM_INFO NF_SPRITEOAM[2][128]; // 2 pantallas, 128 sprites
// Define la esturctura de control de la VRAM para Sprites
typedef struct {
s32 free; // Memoria VRAM libre
u32 next; // Siguiente posicion libre
u32 last; // Ultima posicion usada
u32 pos[128]; // Posicion en VRAM para reusar despues de un borrado
u32 size[128]; // Tamaño del bloque libre para reusar
u16 deleted; // Numero de bloques borrados
s32 fragmented; // Memoria VRAM fragmentada
s32 inarow; // Memoria VRAM contigua
s32 max; // Maxima memoria VRAM direccionable
} NF_TYPE_SPRVRAM_INFO;
extern NF_TYPE_SPRVRAM_INFO NF_SPRVRAM[2]; // Informacion VRAM de Sprites en ambas pantallas
// Funcion NF_InitSpriteBuffers()
void NF_InitSpriteBuffers(void);
// Inicializa los buffers y estructuras de datos de los Buffers para almacenar Sprites
// Usala antes de cargar cualquier Sprites
// No uses esta funcion mas de una vez en tu codigo
// Funcion NF_ResetSpriteBuffers()
void NF_ResetSpriteBuffers(void);
// Reinicia los buffers y datos para almacenar Sprites
// Funcion NF_InitSpriteSys();
void NF_InitSpriteSys(int screen, ...);
// Inicializa las variables de control de Sprites y paletas
// Asigna 128kb de RAM para Sprites
// Activa el Soporte para Sprites
// Se debe especificar la pantalla (0 o 1)
// Funcion NF_LoadSpriteGfx();
void NF_LoadSpriteGfx(const char* file, u16 id, u16 width, u16 height);
// Carga un grafico para usarlo despues en la creacion de Sprites
// Especifica el archivo, ID exclusivo (0 - 255) y medidas del grafico
// Funcion NF_UnloadSpriteGfx();
void NF_UnloadSpriteGfx(u16 id);
// Borra de la RAM un Gfx cargado previamente con NF_LoadSpriteGfx();
// Especifica la Id exclusiva (0 - 255) de grafico a borrar.
// Funcion NF_LoadSpritePal();
void NF_LoadSpritePal(const char* file, u8 id);
// Carga una paleta para usarla despues en la creacion de Sprites
// Especifica el archivo y ID exclusivo (0 - 63)
// Funcion NF_UnloadSpritePal();
void NF_UnloadSpritePal(u8 id);
// Borra de la RAM una Paleta cargada previamente con NF_LoadSpritePal();
// Especifica la Id exclusiva (0 - 63) de la paleta a borrar.
// Funcion NF_VramSpriteGfx();
void NF_VramSpriteGfx(u8 screen, u16 ram, u16 vram, bool keepframes);
// Transfiere un Grafico cargado para Sprites a la VRAM
// Debes especificar la pantalla, el Id del Grafico en RAM (origen),
// la Id del grafico en VRAM (destino) y si, en caso de estar animado,
// debe de copiar a la VRAM todos los frames o solo el que este en uso
// Funcion NF_FreeSpriteGfx();
void NF_FreeSpriteGfx(u8 screen, u16 id);
// Borra de la VRAM el Grafico con la Id. especificada.
// Cualquier Sprite que este usando ese Gfx, quedara corrupto.
// Funcion NF_VramSpriteGfxDefrag();
void NF_VramSpriteGfxDefrag(u8 screen);
// Desfragmenta la VRAM de Sprites (Gfx) de la pantalla dada
// Esta se realiza automaticamente al borrar un Gfx de la VRAM
// si la memoria fragmentada es superior a la contigua libre.
// Puedes consultar estos valores con las siguientes variables
// NF_SPRVRAM[u8 screen].free <- Memoria VRAM de Sprites libre
// NF_SPRVRAM[u8 screen].fragmented <- Memoria VRAM de sprites libre fragmentada
// NF_SPRVRAM[u8 screen].inarow <- Memoria VRAM de sprites libre, ultimo bloque mas grande
// NF_SPRVRAM[u8 screen].lost <- Memoria VRAM libre no usable por fragmentacion
// Funcion NF_VramSpritePal();
void NF_VramSpritePal(u8 screen, u8 id, u8 slot);
// Transfiere una Paleta cargada para Sprites a la VRAM
// Debes especificar la pantalla, la Id de la Paleta a trasnferir
// y el slot de destino (0 - 15)
// Funcion NF_CreateSprite();
void NF_CreateSprite(u8 screen, u8 id, u16 gfx, u8 pal, s16 x, s16 y);
// Crea un sprite en la pantalla.
// Debes especificar la pantalla, la ID del Sprite (0 - 127),
// la ID del Grafico que usaras (0 - 255), el slot de paleta (0 - 15),
// y las coordenadas donde lo crearas.
// Funcion NF_DeleteSprite();
void NF_DeleteSprite(u8 screen, u8 id);
// Borra un sprite de la pantalla
// Debes especificar la pantalla y la Id del Sprite a borrar
// Funcion NF_SpriteOamSet();
void NF_SpriteOamSet(u8 screen);
// Copia los datos del array propio de OAM al OAM real
// Debes especificar la pantalla
// Funcion NF_SpriteSetPalColor();
void NF_SpriteSetPalColor(u8 screen, u8 pal, u8 number, u8 r, u8 g, u8 b);
// Cambia el valor de un color de la paleta de sprites especificada.
// Debes especificar la pantalla, slot de la paleta en VRAM, numero de color
// a cambiar dentro de la paleta y el nuevo valor a darle en formato RGB
// Funcion NF_SpriteEditPalColor();
void NF_SpriteEditPalColor(u8 screen, u8 pal, u8 number, u8 r, u8 g, u8 b);
// Modifica los valores de la paleta seleccionada. Las modificaciones se efectuan
// sobre la copia en RAM, por lo que los cambios no seran visibles hasta que se
// transfiera la paleta a la VRAM
// Funcion NF_SpriteUpdatePalette();
void NF_SpriteUpdatePalette(u8 screen, u8 pal);
// Actualiza la paleta en VRAM con la copia que se encuentra en la RAM
// Funcion NF_SpriteGetPalColor();
void NF_SpriteGetPalColor(u8 screen, u8 pal, u8 number, u8* r, u8* g, u8* b);
// Obtiene el valor de un color de la paleta que se encuentra en la RAM
#endif
#ifdef __cplusplus
}
#endif

243
examples/3dsprites/basic/nflib/include/nf_sprite3d.h
View File

@ -1,243 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_SPRITE3D_H__
#define __NF_SPRITE3D_H__
// NightFox LIB - Include de funciones 3D
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
//////////////////////////////////
// Defines y variables globales //
//////////////////////////////////
// Numero maximo de sprites en pantalla
#define NF_3DSPRITES 256
// Estructura de control de los sprites 3d
typedef struct {
s16 x; // Coordenada X
s16 y; // Coordenada Y
s16 z; // Coordenada Z
s16 rx; // Rotacion Eje X (-512/0/512) << 6
s16 ry; // Rotacion Eje Y (-512/0/512) << 6
s16 rz; // Rotacion Eje Z (-512/0/512) << 6
bool rot; // Rotacion en uso
u16 sx; // Escala X (0/64/512) << 6
u16 sy; // Escala Y (0/64/512) << 6
bool scale; // Escalado en uso
s16 width; // Ancho del sprite
s16 height; // Alto del sprite
bool inuse; // Esta en uso?
bool show; // Debe mostrarse el sprite?
u32 gfx_tex_format; // Guarda el formato de la textura
u32 gfx; // Direccion donde esta almacenado el grafico en VRAM
u16 gfxid; // Id de Gfx usado
u16 frame; // Frame actual
u16 newframe; // Frame al que cambiar
u16 framesize; // Tamaño del frame (en bytes)
u16 lastframe; // Ultimo frame
u32 gfx_pal_format; // Guarda el formato de la paleta
u32 pal; // Direccion donde esta almacenada la paleta en VRAM
u16 palid; // Id de la paleta usada
u16 prio; // Prioridad de dibujado del sprite
u8 poly_id; // Identificador unico para el Alpha (0 por defecto, 63 prohibido)
u8 alpha; // Nivel de alpha (0 - 31) (31 por defecto)
} NF_TYPE_3DSPRITE_INFO;
extern NF_TYPE_3DSPRITE_INFO NF_3DSPRITE[NF_3DSPRITES];
// Estructura de control Texturas en VRAM
typedef struct {
u32 size; // Tamaño (en bytes) del Gfx
u16 width; // Ancho del Gfx
u16 height; // Altura del Gfx
u32 address; // Posicion en la VRAM
u16 ramid; // Numero de Slot en RAM del que provienes
u16 framesize; // Tamaño del frame (en bytes)
u16 lastframe; // Ultimo frame
bool keepframes; // Si es un Sprite animado, debes de mantener los frames en RAM ?
bool inuse; // Disponibilidat del Slot
} NF_TYPE_TEX256VRAM_INFO;
extern NF_TYPE_TEX256VRAM_INFO NF_TEX256VRAM[NF_3DSPRITES];
// Estructura de control de las paletas en VRAM
typedef struct {
bool inuse; // Slot en uso
u8 ramslot; // Paleta original en RAM
} NF_TYPE_3DSPRPALSLOT_INFO;
extern NF_TYPE_3DSPRPALSLOT_INFO NF_TEXPALSLOT[32];
// Define la esturctura de control de la VRAM para Sprites 3d
typedef struct {
s32 free; // Memoria VRAM libre
u32 next; // Siguiente posicion libre
u32 last; // Ultima posicion usada
u32 pos[NF_3DSPRITES]; // Posicion en VRAM para reusar despues de un borrado
u32 size[NF_3DSPRITES]; // Tamaño del bloque libre para reusar
u16 deleted; // Numero de bloques borrados
s32 fragmented; // Memoria VRAM fragmentada
s32 inarow; // Memoria VRAM contigua
} NF_TYPE_TEXVRAM_INFO;
extern NF_TYPE_TEXVRAM_INFO NF_TEXVRAM; // Informacion VRAM de texturas
// Define la estructura de control de los sprites 3d creados
typedef struct {
s16 total; // Numero de sprites creados
u16 id[NF_3DSPRITES]; // ID del Sprite
u16 bck[NF_3DSPRITES]; // Backup del ID
} NF_TYPE_CREATED_3DSPRITE_INFO;
extern NF_TYPE_CREATED_3DSPRITE_INFO NF_CREATED_3DSPRITE;
// Funcion NF_Init3dSpriteSys();
void NF_Init3dSpriteSys(void);
// Inicializa el sistema de Sprites en 3D
// Funcion NF_Vram3dSpriteGfx();
void NF_Vram3dSpriteGfx(u16 ram, u16 vram, bool keepframes);
// Transfiere un grafico de la RAM a la VRAM
// Funcion NF_Free3dSpriteGfx();
void NF_Free3dSpriteGfx(u16 id);
// Elimina de la VRAM un grafico de texturas y desfragmenta la VRAM si es necesario
// Funcion NF_Vram3dSpriteGfxDefrag();
void NF_Vram3dSpriteGfxDefrag(void);
// Desfragmenta la VRAM usada para texturas
// Funcion NF_Vram3dSpritePal();
void NF_Vram3dSpritePal(u8 id, u8 slot);
// Copia una paleta a la VRAM
// Funcion NF_Create3dSprite();
void NF_Create3dSprite(u16 id, u16 gfx, u16 pal, s16 x, s16 y);
// Crea un Sprite 3D en las coordenadas indicadas
// Funcion NF_Delete3dSprite();
void NF_Delete3dSprite(u16 id);
// Borra el Sprite con la ID indicada
// Funcion NF_Sort3dSprites();
void NF_Sort3dSprites(void);
// Reordena la cola de Sprites 3D creados de menor a mayor segun su ID
// Los Sprites con numeros mas bajos tienen prioridad.
// Funcion NF_Set3dSpritePriority();
void NF_Set3dSpritePriority(u16 id, u16 prio);
// Cambia la prioridad del Sprite
// Funcion NF_Swap3dSpritePriority();
void NF_Swap3dSpritePriority(u16 id_a, u16 id_b);
// Intercambia la prioridad de dos Sprites
// Funcion NF_Move3dSprite();
void NF_Move3dSprite(u16 id, s16 x, s16 y);
// Mueve el Sprite seleccionado a las coordenadas dadas
// Funcion NF_Show3dSprite();
void NF_Show3dSprite(u16 id, bool show);
// Muestra u oculta el sprite con la id indicada
// Funcion NF_Set3dSpriteFrame();
void NF_Set3dSpriteFrame(u16 id, u16 frame);
// Cambia el frame visible del sprite indicado
// Funcion NF_Draw3dSprites();
void NF_Draw3dSprites(void);
// Dibuja en pantalla todos los sprites creados
// Funcion NF_Update3dSpritesGfx();
void NF_Update3dSpritesGfx(void);
// Actualiza si es necesario las texturas de los sprites animados
// Funcion NF_Rotate3dSprite();
void NF_Rotate3dSprite(u16 id, s16 x, s16 y, s16 z);
// Rota el Sprite sobre los ejes indicados (-512/0/512)
// Funcion NF_Scale3dSprite();
void NF_Scale3dSprite(u16 id, u16 x, u16 y);
// Escala el sprite al tamaño indicado (0/64/512)
// Funcion NF_Blend3dSprite();
void NF_Blend3dSprite(u8 sprite, u8 poly_id, u8 alpha);
// Habilita y cambia el nivel de alpha de el sprite 3d indicado. Para que la transparencia
// sea efectiva entre Sprites, debes especificar un poly_id diferente para cada sprite
// (entre 1 y 62). El rango de alpha es de 0 a 31, siendo 31 opaco. Para eliminar la
// transparencia, selecciona un valor para alpha de 31 o especifica como poly_id el nº 0.
// Funcion NF_3dSpritesLayer();
void NF_3dSpritesLayer(u8 layer);
// Selecciona la capa en la que se dibujaran los Sprites 3D. (0 - 3)
// En realidad los Sprites 3D siempre se dibujan sobre la CAPA 0, esta funcion solo cambia
// la prioridad de esta capa sobre las demas.
// Funcion NF_3dSpriteEditPalColor();
void NF_3dSpriteEditPalColor(u8 pal, u8 number, u8 r, u8 g, u8 b);
// Modifica los valores de la paleta seleccionada. Las modificaciones se efectuan
// sobre la copia en RAM, por lo que los cambios no seran visibles hasta que se
// transfiera la paleta a la VRAM
// Funcion NF_3dSpriteUpdatePalette();
void NF_3dSpriteUpdatePalette(u8 pal);
// Actualiza la paleta en VRAM con la copia que se encuentra en la RAM
// Funcion NF_3dSpriteGetPalColor();
void NF_3dSpriteGetPalColor(u8 pal, u8 number, u8* r, u8* g, u8* b);
// Obtiene el valor de un color de la paleta que se encuentra en la RAM
// Funcion NF_3dSpriteSetDeep();
void NF_3dSpriteSetDeep(u8 id, s16 z);
// Cambia la profuncidad de dibujado (z) del sprite (-512/0/512),
// siendo -512 el punto mas cercano, 0 el centro por defecto
// y 512 el punto mas lejano.
#endif
#ifdef __cplusplus
}
#endif

124
examples/3dsprites/basic/nflib/include/nf_text.h
View File

@ -1,124 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_TEXT_H__
#define __NF_TEXT_H__
// NightFox LIB - Include de Textos
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define el nº de caracteres que tiene la fuente
#define NF_TEXT_FONT_CHARS 127
#define NF_TEXT_FONT_LAST_VALID_CHAR 113
// Define la estructura de control de textos
typedef struct {
u16 width; // Ultimo tile de la fila (0 - x) 32 tiles serian 0 - 31
u16 height; // Ultimo tile de la columna (0 - y)
u8 rotation; // Rotacion del texto
u8 slot; // Slot donde esta cargado el tileset de esta capa de texto
u8 pal; // Paleta que usara el texto (0 por defecto)
bool exist; // Existe la capa de texto?
bool update; // Tienes que actualizar la capa?
} NF_TYPE_TEXT_INFO;
extern NF_TYPE_TEXT_INFO NF_TEXT[2][4]; // Datos de las capas de texto
// Funcion NF_InitTextSys();
void NF_InitTextSys(u8 screen);
// Inicializa el sistema de Texto para la pantalla dada
// Funcion NF_LoadTextFont();
void NF_LoadTextFont(const char* file, const char* name, u16 width, u16 height, u8 rotation);
// Carga una fuente para usar como texto
// La fuente se cargara en un slot libre de fondos tileados
// Debes especificar el archivos sin extension y un nombre para referenciarla
// En caso de que la fuente tenga los sets de rotacion a izquierda y derecha,
// especificar 1 o 2 en el parametro "rot". 0 carga la fuente sin rotacion
// Funcion NF_UnloadTextFont();
void NF_UnloadTextFont(const char* name);
// Borra un fuente cargada en RAM
// Esta funcion simplemente llama a NF_UnloadTiledBg(); para su borrado
// Funcion NF_CreateTextLayer();
void NF_CreateTextLayer(u8 screen, u8 layer, u8 rotation, const char* name);
// Crea un fondo tileado para usarlo con texto
// Esta funcion simplemente llama a NF_CreateTiledBg(); para su creacion
// Funcion NF_DeleteTextLayer();
void NF_DeleteTextLayer(u8 screen, u8 layer);
// Borra un fondo usado como capa de texto y sus buffers y variables asociadas
// Funcion NF_WriteText();
void NF_WriteText(u8 screen, u8 layer, u16 x, u16 y, const char* text);
// Escribe un texto en el buffer de texto de la pantalla y capa seleccionada
// Funcion NF_UpdateTextLayers();
void NF_UpdateTextLayers(void);
// Copia el buffer de texto a la VRAM en las capas que sea necesario
// realizar una actualizacion
// Funcion NF_ClearTextLayer();
void NF_ClearTextLayer(u8 screen, u8 layer);
// Borra el contanido de la capa de texto seleccionada
// Funcion NF_DefineTextColor();
void NF_DefineTextColor(u8 screen, u8 layer, u8 color, u8 r, u8 g, u8 b);
// Define uno de los 16 colores disponibles para texto, en formato RGB
// Function NF_SetTextColor();
void NF_SetTextColor(u8 screen, u8 layer, u8 color);
// Selecciona con que color definido se escribira el texto (no cambia el color del texto ya escrito)
#endif
#ifdef __cplusplus
}
#endif

64
examples/3dsprites/basic/nflib/include/nf_text16.h
View File

@ -1,64 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_TEXT16_H__
#define __NF_TEXT16_H__
// NightFox LIB - Include de Textos de 16 pixels
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define el nº de caracteres que tiene la fuente
#define NF_TEXT_FONT_CHARS_16 127
#define NF_TEXT_FONT_LAST_VALID_CHAR_16 113
// Funcion NF_LoadTextFont16();
void NF_LoadTextFont16(const char* file, const char* name, u16 width, u16 height, u8 rotation);
// Carga una fuente para texto de 16 pixeles de altura
// Funcion NF_CreateTextLayer16();
void NF_CreateTextLayer16(u8 screen, u8 layer, u8 rotation, const char* name);
// Crea una capa de texto para fuentes de 16 pixeles
// Funcion NF_WriteText16();
void NF_WriteText16(u8 screen, u8 layer, u16 x, u16 y, const char* text);
// Escribe un texto en la capa y pantalla especificados
// Funcion NF_ClearTextLayer16();
void NF_ClearTextLayer16(u8 screen, u8 layer);
// Limpia la capa de texto especificada
#endif
#ifdef __cplusplus
}
#endif

320
examples/3dsprites/basic/nflib/include/nf_tiledbg.h
View File

@ -1,320 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_TILEDBG_H__
#define __NF_TILEDBG_H__
// NightFox LIB - Include de Fondos con tiles
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define los slots maximos para los fondos
#define NF_SLOTS_TBG 64 // Datos de los fondos
#define NF_SLOTS_EXBGPAL 128 // Paletas extendidas (maximo 16 paletas por fondo)
// Define el numero maximo de bancos para tiles y mapas
#define NF_MAX_BANKS_TILES 8
#define NF_MAX_BANKS_MAPS 16
// Define el numero de bancos de Mapas y Tiles
extern u8 NF_BANKS_TILES[2]; // (1 banks = 16kb) Cada banco de tiles puede alvergar 8 bancos de Mapas
extern u8 NF_BANKS_MAPS[2]; // (1 bank = 2kb) Usar multiplos de 8. Cada set de 8 bancos consume 1 banco de tiles
// Define los Buffers para almacenar los fondos
extern char* NF_BUFFER_BGTILES[NF_SLOTS_TBG];
extern char* NF_BUFFER_BGMAP[NF_SLOTS_TBG];
extern char* NF_BUFFER_BGPAL[NF_SLOTS_TBG];
// Define estructura para almacenar la info de los fondos
typedef struct {
char name[32]; // Nombre del fondo
u32 tilesize; // Tamaño del Tileset
u32 mapsize; // Tamaño del Map
u32 palsize; // Tamaño de la Paleta
u16 width; // Ancho del fondo
u16 height; // Altura del fondo
bool available; // Disponibilidat del Slot
} NF_TYPE_TBG_INFO;
extern NF_TYPE_TBG_INFO NF_TILEDBG[NF_SLOTS_TBG]; // Datos de los fondos
// Define la estructura para almacenar la info y datos de las paletas extendidas
typedef struct {
char* buffer; // Buffer para almacenar la paleta
u32 palsize; // Tamaño de la paleta
bool inuse; // Slot libre o en uso
} NF_TYPE_EXBGPAL_INFO;
extern NF_TYPE_EXBGPAL_INFO NF_EXBGPAL[NF_SLOTS_EXBGPAL]; // Datos de las paletas extendidas
// Define estructura para almacenar la info de los fondos en pantalla
typedef struct {
u8 tilebase; // Bloque de inicio en VRAM del Tileset
u8 tileblocks; // Bloques usados por el Tileset
u8 mapbase; // Bloque de inicio en VRAM del Map
u8 mapblocks; // Bloques usados por el Map
u16 bgwidth; // Ancho del fondo
u16 bgheight; // Altura del fondo
u16 mapwidth; // Ancho del mapa
u16 mapheight; // Altura del mapa
u8 bgtype; // Tipo de mapa
u8 bgslot; // Buffer de graficos usado (NF_BUFFER_BGMAP)
u8 blockx; // Bloque de mapa (horizontal)
u8 blocky; // bloque de mapa (vertical)
bool created; // Flag de si esta creado
} NF_TYPE_TBGLAYERS_INFO;
// El hardware de la DS no permite mapas mayores de 512x512
// Asi que informaremos si nuestor mapa lo gestionara el hardware si es menor o
// igual a 512x512, o usaremos nuestro motor de Tile Swaping
// bgtype 0: Normal (maximo 512 x 512)
// bgtype 1: >512 x 256
// bgtype 2: 256 x >512
// bgtype 3: >512 x >512
extern NF_TYPE_TBGLAYERS_INFO NF_TILEDBG_LAYERS[2][4]; //[screen][layer]
// Define el array de bloques libres
extern u8 NF_TILEBLOCKS[2][NF_MAX_BANKS_TILES];
extern u8 NF_MAPBLOCKS[2][NF_MAX_BANKS_MAPS];
// Funcion NF_InitTiledBgBuffers();
void NF_InitTiledBgBuffers(void);
// Inicializa los buffers y estructuras de control para usar los fondos "tileados"
// Se debe usar antes de cargar o usar cualquier fondo
// No uses esta funcion mas de una vez en tu codigo
// Funcion NF_ResetTiledBgBuffers();
void NF_ResetTiledBgBuffers(void);
// Borra todos los buffers y reinicia las estructuras de fondos "tileados"
// Usala para los cambios de nivel y similares
// Funcion NF_InitTiledBgSys();
void NF_InitTiledBgSys(u8 screen);
// Inicializa las variables de control de tiles, mapas y paletas
// Asigna 128kb de RAM para fondos tileados
// Se debe especificar la pantalla (0 o 1)
// Funcion NF_LoadTiledBg();
void NF_LoadTiledBg(const char* file, const char* name, u16 width, u16 height);
// Carga un fondo tileado desde FAT
// Debes de especificar el archivo que se cargara (sin extension) y el nombre
// que le quieres dar y las medidas en pixeles
// Funcion NF_LoadTilesForBg();
void NF_LoadTilesForBg(const char* file, const char* name, u16 width, u16 height, u16 tile_start, u16 tile_end);
// Carga desde la FAT los tiles especificados y su paleta
// Ademas, crea un mapa vacio de la medida especificada
// Esta funcion es util para cargar varios tiles y despues generar fondos
// modificando el MAP desde cogido (Generador de escenarios, animaciones, etc)
// Funcion NF_UnloadTiledBg();
void NF_UnloadTiledBg(const char* name);
// Borra de la RAM un fondo cargado con NF_LoadTiledBg();
// Debes especificar el nombre que le diste al fondo
// Funcion NF_CreateTiledBg();
void NF_CreateTiledBg(u8 screen, u8 layer, const char* name);
// Crea un fondo con los parametros dados, indicale la pantalla, capa y nombre
// Funcion NF_DeleteTiledBg();
void NF_DeleteTiledBg(u8 screen, u8 layer);
// Borra un fondo de la memoria VRAM
// Debes especificar la pantalla y numero de capa
// Funcion NF_GetTileMapAddress();
extern u32 NF_GetTileMapAddress(u8 screen, u8 layer, u16 tile_x, u16 tile_y);
// Funcion de uso interno de la libreria
// Devuelve la direccion en el buffer de un tile concreto
// Funcion NF_GetTileOfMap();
extern u16 NF_GetTileOfMap(u8 screen, u8 layer, u16 tile_x, u16 tile_y);
// Obten el valor del tile del mapa indicado en las coordenadas (en tiles) indicadas.
// Funcion NF_SetTileOfMap();
void NF_SetTileOfMap(u8 screen, u8 layer, u16 tile_x, u16 tile_y, u16 tile);
// Cambia el valor del tile del mapa indicado en las coordenadas (en tiles) indicadas.
// Funcion NF_UpdateVramMap();
void NF_UpdateVramMap(u8 screen, u8 layer);
// Actualiza en VRAM el contenido del mapa seleccionado.
// Funcion NF_BgSetPalColor();
void NF_BgSetPalColor(u8 screen, u8 layer, u8 number, u8 r, u8 g, u8 b);
// Cambia al momento el valor de un color de la paleta
// Cuidado! Funcion Muy lenta, usar solo para 2 o 3 colores por ciclo
// Cambia el color directamente en la VRAM
// Funcion NF_BgEditPalColor();
void NF_BgEditPalColor(u8 screen, u8 layer, u8 number, u8 r, u8 g, u8 b);
// Edita un color de la paleta seleccionada.
// El color se edita en el buffer de RAM, para que sea efectivo,
// mandala a la VRAM con NF_UpdatePalette();
// Funcion NF_BgUpdatePalette();
void NF_BgUpdatePalette(u8 screen, u8 layer);
// Actualiza la paleta en VRAM con la que se encuentra en el buffer de RAM
// Funcion NF_BgGetPalColor();
void NF_BgGetPalColor(u8 screen, u8 layer, u8 number, u8* r, u8* g, u8* b);
// Obtiene el valor de un color de la paleta que se encuentra en la RAM
// Funcion NF_GetTilePal();
extern u8 NF_GetTilePal(u8 screen, u8 layer, u16 tile_x, u16 tile_y);
// Devuelve que numero de paleta (0 - 15) esta usando el tile del fondo especificado.
// Por defecto, todos los tiles usan la paleta del Slot nº0
// Los datos se obtienen de la compia en RAM del mapa del fondo.
// Funcion NF_SetTilePal();
void NF_SetTilePal(u8 screen, u8 layer, u16 tile_x, u16 tile_y, u8 pal);
// Cambia el numero de paleta (0 - 15) que usara el tile del fondo especificado.
// Por defecto, todos los tiles usan la paleta del Slot nº0
// Los datos se escriben de la compia en RAM del mapa del fondo, por lo que no seran
// visibles hasta que ejecutes la funcion NF_UpdateVramMap();
// Funcion NF_LoadExBgPal();
void NF_LoadExBgPal(const char* file, u8 slot);
// Carga en el buffer de RAM correspondiente una paleta de fondos, para poderla usar
// mas tarde como paleta extendida.
// Funcion NF_UnloadExBgPal();
void NF_UnloadExBgPal(u8 slot);
// Borra de la RAM la paleta del slot especificado.
// Funcion NF_VramExBgPal();
void NF_VramExBgPal(u8 screen, u8 layer, u8 id, u8 slot);
// Transfiere a la VRAM una paleta extendida en el slot de la pantalla y
// fondo especificados.
// Funcion NF_SetExBgPal();
void NF_SetExBgPal(u8 screen, u8 layer, u8 pal);
// Cambia la paleta extendida que usara un fondo.
// La paleta debe de estar transferida en la VRAM previamente
// Funcion NF_SetTileHflip();
void NF_SetTileHflip(u8 screen, u8 layer, u16 tile_x, u16 tile_y);
// Invierte horizontalmente el estado actual del tile seleccionado
// Los cambios no seran visibles hasta que actualices el mapa
// con la funcion NF_UpdateVramMap();
// Funcion NF_SetTileVflip();
void NF_SetTileVflip(u8 screen, u8 layer, u16 tile_x, u16 tile_y);
// Invierte verticalmente el estado actual del tile seleccionado
// Los cambios no seran visibles hasta que actualices el mapa
// con la funcion NF_UpdateVramMap();
// Funcion NF_RotateTileGfx();
void NF_RotateTileGfx(u8 slot, u16 tile, u8 rotation);
// Rota el grafico de un tile especificado. Rota el tile almacenado en un buffer de fondos
// que se encuentra en RAM. Debes especificar el SLOT del buffer, numero de tile en el buffer
// y el angulo de la rotacion.
// 1 - 90º a la derecha
// 2 - 90º a la izquierda
// 3 - 180º
#endif
#ifdef __cplusplus
}
#endif

BIN
examples/3dsprites/basic/nflib/lib/libnflib.a
View File

Binary file not shown.

238
examples/3dsprites/rotscale/Makefile
View File

@ -1,60 +1,17 @@
#---------------------------------------------------------------------------------
# Makefile for NightFox's Lib Projects
#---------------------------------------------------------------------------------
#---------------------------------------------------------------------------------
.SUFFIXES:
#---------------------------------------------------------------------------------
ifeq ($(strip $(DEVKITARM)),)
$(error "Please set DEVKITARM in your environment. export DEVKITARM=<path to>devkitARM")
endif
# These set the information text in the nds file
#GAME_TITLE := My Wonderful Homebrew
#GAME_SUBTITLE1 := built with devkitARM
#GAME_SUBTITLE2 := http://devitpro.org
#---------------------------------------------------------------------------------
# This part substitutes this include:
# include $(DEVKITARM)/ds_rules
# This allows you to set ROM info and icon easy
# Please update this block from DS_RULES file at every DEVKITARM update
#---------------------------------------------------------------------------------
include $(DEVKITARM)/base_rules
LIBNDS := $(DEVKITPRO)/libnds
GAME_TITLE := Text 1
GAME_SUBTITLE1 := Text 2
GAME_SUBTITLE2 := Text 3
GAME_ICON := $(CURDIR)/../icon.bmp
_ADDFILES := -d $(NITRO_FILES)
#---------------------------------------------------------------------------------
%.nds: %.arm9
@ndstool -c $@ -9 $< -b $(GAME_ICON) "$(GAME_TITLE);$(GAME_SUBTITLE1);$(GAME_SUBTITLE2)" $(_ADDFILES)
@echo built ... $(notdir $@)
#---------------------------------------------------------------------------------
%.nds: %.elf
@ndstool -c $@ -9 $< -b $(GAME_ICON) "$(GAME_TITLE);$(GAME_SUBTITLE1);$(GAME_SUBTITLE2)" $(_ADDFILES)
@echo built ... $(notdir $@)
#---------------------------------------------------------------------------------
%.arm9: %.elf
@$(OBJCOPY) -O binary $< $@
@echo built ... $(notdir $@)
#---------------------------------------------------------------------------------
%.arm7: %.elf
@$(OBJCOPY) -O binary $< $@
@echo built ... $(notdir $@)
#---------------------------------------------------------------------------------
%.elf:
@echo linking $(notdir $@)
@$(LD) $(LDFLAGS) $(OFILES) $(LIBPATHS) $(LIBS) -o $@
include $(DEVKITARM)/ds_rules
#---------------------------------------------------------------------------------
# TARGET is the name of the output
@ -62,43 +19,56 @@ _ADDFILES := -d $(NITRO_FILES)
# SOURCES is a list of directories containing source code
# INCLUDES is a list of directories containing extra header files
# DATA is a list of directories containing binary files embedded using bin2o
# NITRODATA is the directory where files for NitroFS will be placed
# GRAPHICS is a list of directories containing image files to be converted with grit
# AUDIO is a list of directories containing audio to be converted by maxmod
# ICON is the image used to create the game icon, leave blank to use default rule
# NITRO is a directory that will be accessible via NitroFS
#---------------------------------------------------------------------------------
TARGET := $(shell basename $(CURDIR))
BUILD := build
SOURCES := source
INCLUDES := include
DATA := data
NITRODATA := nitrofiles
TARGET := $(shell basename $(CURDIR))
BUILD := build
SOURCES := source
INCLUDES := include
DATA := data
GRAPHICS :=
AUDIO :=
ICON :=
# specify a directory which contains the nitro filesystem
# this is relative to the Makefile
NITRO := nitrofiles
#---------------------------------------------------------------------------------
# options for code generation
#---------------------------------------------------------------------------------
ARCH := -mthumb -mthumb-interwork
ARCH := -marm -mthumb-interwork -march=armv5te -mtune=arm946e-s
CFLAGS := -g -Wall -O2\
-march=armv5te -mtune=arm946e-s -fomit-frame-pointer\
-ffast-math \
$(ARCH)
CFLAGS += $(INCLUDE) -DARM9
CXXFLAGS := $(CFLAGS) -fno-rtti -fno-exceptions
ASFLAGS := -g $(ARCH)
LDFLAGS = -specs=ds_arm9.specs -g $(ARCH) -Wl,-Map,$(notdir $*.map)
CFLAGS := -g -Wall -O3\
$(ARCH) $(INCLUDE) -DARM9
CXXFLAGS := $(CFLAGS) -fno-rtti -fno-exceptions
ASFLAGS := -g $(ARCH)
LDFLAGS = -specs=ds_arm9.specs -g $(ARCH) -Wl,-Map,$(notdir $*.map)
#---------------------------------------------------------------------------------
# any extra libraries we wish to link with the project
# any extra libraries we wish to link with the project (order is important)
#---------------------------------------------------------------------------------
LIBS := -lnflib -lfilesystem -lfat -lnds9
LIBS := -lnflib
# automatigically add libraries for NitroFS
ifneq ($(strip $(NITRO)),)
LIBS := $(LIBS) -lfilesystem -lfat
endif
# automagically add maxmod library
ifneq ($(strip $(AUDIO)),)
LIBS := $(LIBS) -lmm9
endif
LIBS := $(LIBS) -lnds9
#---------------------------------------------------------------------------------
# list of directories containing libraries, this must be the top level containing
# include and lib
#---------------------------------------------------------------------------------
LIBDIRS := $(LIBNDS) $(CURDIR)/nflib
LIBDIRS := $(LIBNDS) $(PORTLIBS) $(DEVKITPRO)/nflib
#---------------------------------------------------------------------------------
# no real need to edit anything past this point unless you need to add additional
@ -107,64 +77,97 @@ LIBDIRS := $(LIBNDS) $(CURDIR)/nflib
ifneq ($(BUILD),$(notdir $(CURDIR)))
#---------------------------------------------------------------------------------
export OUTPUT := $(CURDIR)/$(TARGET)
export OUTPUT := $(CURDIR)/$(TARGET)
export VPATH := $(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
$(foreach dir,$(DATA),$(CURDIR)/$(dir))
export VPATH := $(CURDIR)/$(subst /,,$(dir $(ICON)))\
$(foreach dir,$(SOURCES),$(CURDIR)/$(dir))\
$(foreach dir,$(DATA),$(CURDIR)/$(dir))\
$(foreach dir,$(GRAPHICS),$(CURDIR)/$(dir))
export DEPSDIR := $(CURDIR)/$(BUILD)
export DEPSDIR := $(CURDIR)/$(BUILD)
export NITRO_FILES := $(CURDIR)/$(NITRODATA)
CFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
CPPFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
SFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
PNGFILES := $(foreach dir,$(GRAPHICS),$(notdir $(wildcard $(dir)/*.png)))
BINFILES := $(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
CFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
CPPFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
SFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
BINFILES := $(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
# prepare NitroFS directory
ifneq ($(strip $(NITRO)),)
export NITRO_FILES := $(CURDIR)/$(NITRO)
endif
# get audio list for maxmod
ifneq ($(strip $(AUDIO)),)
export MODFILES := $(foreach dir,$(notdir $(wildcard $(AUDIO)/*.*)),$(CURDIR)/$(AUDIO)/$(dir))
# place the soundbank file in NitroFS if using it
ifneq ($(strip $(NITRO)),)
export SOUNDBANK := $(NITRO_FILES)/soundbank.bin
# otherwise, needs to be loaded from memory
else
export SOUNDBANK := soundbank.bin
BINFILES += $(SOUNDBANK)
endif
endif
#---------------------------------------------------------------------------------
# use CXX for linking C++ projects, CC for standard C
#---------------------------------------------------------------------------------
ifeq ($(strip $(CPPFILES)),)
#---------------------------------------------------------------------------------
export LD := $(CC)
export LD := $(CC)
#---------------------------------------------------------------------------------
else
#---------------------------------------------------------------------------------
export LD := $(CXX)
export LD := $(CXX)
#---------------------------------------------------------------------------------
endif
#---------------------------------------------------------------------------------
export OFILES := $(addsuffix .o,$(BINFILES)) \
$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
export OFILES_BIN := $(addsuffix .o,$(BINFILES))
export INCLUDE := $(foreach dir,$(INCLUDES),-iquote $(CURDIR)/$(dir)) \
$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
-I$(CURDIR)/$(BUILD)
export OFILES_SOURCES := $(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
export LIBPATHS := $(foreach dir,$(LIBDIRS),-L$(dir)/lib)
export OFILES := $(PNGFILES:.png=.o) $(OFILES_BIN) $(OFILES_SOURCES)
icons := $(wildcard *.bmp)
export HFILES := $(PNGFILES:.png=.h) $(addsuffix .h,$(subst .,_,$(BINFILES)))
ifneq (,$(findstring $(TARGET).bmp,$(icons)))
export GAME_ICON := $(CURDIR)/$(TARGET).bmp
export INCLUDE := $(foreach dir,$(INCLUDES),-iquote $(CURDIR)/$(dir))\
$(foreach dir,$(LIBDIRS),-I$(dir)/include)\
-I$(CURDIR)/$(BUILD)
export LIBPATHS := $(foreach dir,$(LIBDIRS),-L$(dir)/lib)
ifeq ($(strip $(ICON)),)
icons := $(wildcard *.bmp)
ifneq (,$(findstring $(TARGET).bmp,$(icons)))
export GAME_ICON := $(CURDIR)/$(TARGET).bmp
else
ifneq (,$(findstring icon.bmp,$(icons)))
export GAME_ICON := $(CURDIR)/icon.bmp
endif
endif
else
ifneq (,$(findstring icon.bmp,$(icons)))
export GAME_ICON := $(CURDIR)/icon.bmp
endif
ifeq ($(suffix $(ICON)), .grf)
export GAME_ICON := $(CURDIR)/$(ICON)
else
export GAME_ICON := $(CURDIR)/$(BUILD)/$(notdir $(basename $(ICON))).grf
endif
endif
.PHONY: $(BUILD) clean
#---------------------------------------------------------------------------------
$(BUILD):
@[ -d $@ ] || mkdir -p $@
@make --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
@mkdir -p $@
@$(MAKE) --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
#---------------------------------------------------------------------------------
clean:
@echo clean ...
@rm -fr $(BUILD) $(TARGET).elf $(TARGET).nds $(TARGET).arm9
@rm -fr $(BUILD) $(TARGET).elf $(TARGET).nds $(SOUNDBANK)
#---------------------------------------------------------------------------------
else
@ -172,14 +175,47 @@ else
#---------------------------------------------------------------------------------
# main targets
#---------------------------------------------------------------------------------
$(OUTPUT).nds : $(OUTPUT).elf
$(OUTPUT).elf : $(OFILES)
$(OUTPUT).nds: $(OUTPUT).elf $(NITRO_FILES) $(GAME_ICON)
$(OUTPUT).elf: $(OFILES)
# source files depend on generated headers
$(OFILES_SOURCES) : $(HFILES)
# need to build soundbank first
$(OFILES): $(SOUNDBANK)
#---------------------------------------------------------------------------------
%.bin.o : %.bin
# rule to build solution from music files
#---------------------------------------------------------------------------------
$(SOUNDBANK) : $(MODFILES)
#---------------------------------------------------------------------------------
mmutil $^ -d -o$@ -hsoundbank.h
#---------------------------------------------------------------------------------
%.bin.o %_bin.h : %.bin
#---------------------------------------------------------------------------------
@echo $(notdir $<)
$(bin2o)
@$(bin2o)
#---------------------------------------------------------------------------------
# This rule creates assembly source files using grit
# grit takes an image file and a .grit describing how the file is to be processed
# add additional rules like this for each image extension
# you use in the graphics folders
#---------------------------------------------------------------------------------
%.s %.h: %.png %.grit
#---------------------------------------------------------------------------------
grit $< -fts -o$*
#---------------------------------------------------------------------------------
# Convert non-GRF game icon to GRF if needed
#---------------------------------------------------------------------------------
$(GAME_ICON): $(notdir $(ICON))
#---------------------------------------------------------------------------------
@echo convert $(notdir $<)
@grit $< -g -gt -gB4 -gT FF00FF -m! -p -pe 16 -fh! -ftr
-include $(DEPSDIR)/*.d
#---------------------------------------------------------------------------------------
endif

5
examples/3dsprites/rotscale/clean.bat
View File

@ -1,5 +0,0 @@
@echo off
cls
make clean
pause
exit

5
examples/3dsprites/rotscale/compile.bat
View File

@ -1,5 +0,0 @@
@echo off
cls
make
pause
exit

BIN
examples/3dsprites/rotscale/icon.bmp
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 1.1 KiB

139
examples/3dsprites/rotscale/nflib/include/nf_2d.h
View File

@ -1,139 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_2D_H__
#define __NF_2D_H__
// NightFox LIB - Include de funciones 2D comunes
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Funcion NF_Set2D();
void NF_Set2D(u8 screen, u8 mode);
// Inicia el modo 2D seleccionado en la pantalla deseada
// Funcion NF_ShowBg();
void NF_ShowBg(u8 screen, u8 layer);
// Haz visible el fondo de la capa y pantalla dados
// Funcion NF_HideBg();
void NF_HideBg(u8 screen, u8 layer);
// Oculta el fondo de la capa y pantalla dados
// Funcion NF_ScrollBg();
void NF_ScrollBg(u8 screen, u8 layer, s16 x, s16 y);
// Mueve el fondo a las coordenadas especificadas.
// Debes de indicar la pantalla, capa, y coordenadas X e Y
// Si el mapa es mayor de 512 en alguna medida, debes de mantener el fondo en RAM
// Funcion NF_MoveSprite();
void NF_MoveSprite(u8 screen, u8 id, s16 x, s16 y);
// Mueve el Sprite a las coordenadas especificadas
// Debes de indicar la pantalla, id de sprite y coordenadas
// Funcion NF_SpriteLayer();
void NF_SpriteLayer(u8 screen, u8 id, u8 layer);
// Define la capa sobre la que el sprite sera dibujado
// Debes de indicar la pantalla, id del sprite y capa
// Funcion NF_ShowSprite();
void NF_ShowSprite(u8 screen, u8 id, bool show);
// Muestra o oculta el sprite
// Debes especificar la pantalla, id del sprite y el estado (true, false)
// Funcion NF_HflipSprite();
void NF_HflipSprite(u8 screen, u8 id, bool hflip);
// Voltea el Sprite horizontalmente
// Debes especificar la pantalla, id del sprite y el estado (true, false)
// Funcion NF_GetSpriteHflip();
extern bool NF_GetSpriteHflip(u8 screen, u8 id);
// Devuelve el estado del volteado horizontal de un sprite
// Debes especificar la pantalla y la id del sprite
// Funcion NF_VflipSprite();
void NF_VflipSprite(u8 screen, u8 id, bool vflip);
// Voltea el Sprite verticalmente
// Debes especificar la pantalla, id del sprite y el estado (true, false)
// Funcion NF_GetSpriteVflip();
extern bool NF_GetSpriteVflip(u8 screen, u8 id);
// Devuelve el estado del volteado vertical de un sprite
// Debes especificar la pantalla y la id del sprite
// Funcion NF_SpriteFrame();
void NF_SpriteFrame(u8 screen, u8 id, u16 frame);
// Cambia el frame de un Sprite
// Debes especificar la pantalla, el Id del sprite y el frame
// Funcion NF_EnableSpriteRotScale();
void NF_EnableSpriteRotScale(u8 screen, u8 sprite, u8 id, bool doublesize);
// Habilita el sprite como rotable y escalable
// Debes especificar la pantalla, nº de sprite, id de rotacion y si
// tiene que activarse el doublesize (tamaño x2)
// Funcion NF_DisableSpriteRotScale();
void NF_DisableSpriteRotScale(u8 screen, u8 sprite);
// Deshabilita un sprite como rotable y escalable
// Debes especificar la pantalla y el nº de sprite
// Funcion NF_SpriteRotScale();
void NF_SpriteRotScale(u8 screen, u8 id, s16 angle, u16 sx, u16 sy);
// Define el angulo de rotacion y escala de los Sprites asociados a la Id.
// El rango del angulo es desde -512 a 512, siendo 0 el valor central
// El rango de escalado va de 0 a 512, siendo 256 el valor normal (100%)
#endif
#ifdef __cplusplus
}
#endif

50
examples/3dsprites/rotscale/nflib/include/nf_3d.h
View File

@ -1,50 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_3D_H__
#define __NF_3D_H__
// NightFox LIB - Include de funciones 3D
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Funcion NF_Set3D();
void NF_Set3D(u8 screen, u8 mode);
// Inicia el modo 3D seleccionado en la pantalla deseada
// Funcion NF_InitOpenGL();
void NF_InitOpenGL(void);
// Inicializa el OpenGL para la libreria
// Funcion NF_GetTextureSize();
extern u16 NF_GetTextureSize(u16 textel);
// Devuelve el tamaño del textel
#endif
#ifdef __cplusplus
}
#endif

106
examples/3dsprites/rotscale/nflib/include/nf_affinebg.h
View File

@ -1,106 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_AFFINEBG_H__
#define __NF_AFFINEBG_H__
// NightFox LIB - Includes de Fondos Affine
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Estructura para almacenar los parametros de los fondos Affine
typedef struct {
s32 x; // Posicion X
s32 y; // Posicion Y
s32 x_center; // Centro X
s32 y_center; // Centro Y
s32 x_scale; // Valor Zoom X (PA)
s32 y_scale; // Valor Zoom Y (PD)
s32 x_tilt; // Valor Inclinacion X (PB)
s32 y_tilt; // Valor Inclinacion Y (PC)
s32 angle; // Valor de la rotacion
} NF_TYPE_AFFINE_BG;
extern NF_TYPE_AFFINE_BG NF_AFFINE_BG[2][4];
// Funcion NF_InitTiledBgSys();
void NF_InitAffineBgSys(u8 screen);
// Inicializa el sistema de fondos Affine. Solo puede usarse en las capas 2 y 3, los fondos en
// la misma pantalla deben de compartir la paleta y no pueden tener mas de 256 tiles.
// Funcion NF_LoadAffineBg();
void NF_LoadAffineBg(const char* file, const char* name, u16 width, u16 height);
// Carga un fondo tileado desde FAT
// Debes de especificar el archivo que se cargara (sin extension) y el nombre
// que le quieres dar y las medidas en pixeles
// Los buffers para fondos tileados deben estar inicializados antes de usar esta funcion
// Funcion NF_UnloadAffineBg();
void NF_UnloadAffineBg(const char* name);
// Borra de la RAM el fondo affine especificado. Es una simple llamada a la funcion NF_UnloadTiledBg();
// Funcion NF_CreateAffineBg();
void NF_CreateAffineBg(u8 screen, u8 layer, const char* name, u8 wrap);
// Crea un fondo con los parametros dados, indicale la pantalla, capa, nombre y si se activa la opcion
// de WRAP arround (0 desactivado, 1 activado).
// Funcion NF_DeleteAffineBg();
void NF_DeleteAffineBg(u8 screen, u8 layer);
// Borra el fondo Affine especificado
// Funcion NF_AffineBgTransform();
void NF_AffineBgTransform(u8 screen, u8 layer, s32 x_scale, s32 y_scale, s32 x_tilt, s32 y_tilt);
// Modifica los parametros de la matriz de transformacion del fondo affine
// Funcion NF_AffineBgMove();
void NF_AffineBgMove(u8 screen, u8 layer, s32 x, s32 y, s32 angle);
// Desplaza el fondo affine y rotalo (-2048 a 2048)
// Funcion NF_AffineBgCenter();
void NF_AffineBgCenter(u8 screen, u8 layer, s32 x, s32 y);
// Define el centro de rotacion de un fondo affine
#endif
#ifdef __cplusplus
}
#endif

89
examples/3dsprites/rotscale/nflib/include/nf_basic.h
View File

@ -1,89 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_BASIC_H__
#define __NF_BASIC_H__
// NightFox LIB - Include de funciones basicas
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define la variable global NF_ROOTFOLDER
extern char NF_ROOTFOLDER[32];
// Funcion NF_Error();
void NF_Error(u16 code, const char* text, u32 value);
// Errores para debug. Detiene el sistema e informa del error
// 101: Fichero no encontrado
// 102: Memoria insuficiente
// 103: No quedan Slots libres
// 104: Fondo no encontrado
// 105: Fondo no creado
// 106: Fuera de rango
// 107: Insuficientes bloques contiguos en VRAM (Tiles)
// 108: Insuficientes bloques contiguos en VRAM (Maps)
// 109: Id ocupada (ya esta en uso)
// 110: Id no cargada (en RAM)
// 111: Id no en VRAM
// 112: Sprite no creado
// 113: Memoria VRAM insuficiente
// 114: La capa de Texto no existe
// 115: Medidas del fondo no compatibles (no son multiplos de 256)
// 116: Archivo demasiado grande
// 117: Medidas del fondo affine incorrectas
// 118: Capa de creacion del fondo affine incorrecta
// Funcion NF_SetRootFolder();
void NF_SetRootFolder(const char* folder);
// Define el nombre de la carpeta que se usara como "root" si se usa la FAT
// Funcion NF_DmaMemCopy();
void NF_DmaMemCopy(void* destination, const void* source, u32 size);
// Copia un bloque de memoria usando DMA (canal 3, halfwords) y vaciando previamente
// el cache. Con pruebas de bloques grandes (64kb o 128kb) he observado que memcpy();
// sigue siendo mas rapida.
// Funcion NF_GetLanguage();
extern u8 NF_GetLanguage(void);
// Devuelve el ID del idioma del usuario
// 0 : Japanese
// 1 : English
// 2 : French
// 3 : German
// 4 : Italian
// 5 : Spanish
// 6 : Chinese
#endif
#ifdef __cplusplus
}
#endif

234
examples/3dsprites/rotscale/nflib/include/nf_bitmapbg.h
View File

@ -1,234 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_BITMAPBG_H__
#define __NF_BITMAPBG_H__
// NightFox LIB - Include de funciones de fondos en modo Bitmap
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define los slots maximos para los fondos de 16 bits
#define NF_SLOTS_BG16B 16
// Define los slots maximos para los fondos de 8 bits
#define NF_SLOTS_BG8B 16
// Define los Buffers para almacenar datos de 16 bits
typedef struct {
u16* buffer; // Buffer de datos
u32 size; // Tamaño del buffer
u16 width; // Ancho de la imagen (256 max)
u16 height; // Altura de la imagen (256 max)
bool inuse; // Esta en uso el buffer?
} NF_TYPE_BG16B_INFO;
extern NF_TYPE_BG16B_INFO NF_BG16B[NF_SLOTS_BG16B]; // Fondos RAW de 16 bits
// BackBuffer de 16 bits de cada pantalla
extern u16* NF_16BITS_BACKBUFFER[2];
// Define los Buffers para almacenar datos de 8 bits
typedef struct {
u8* data; // Buffer de datos
u32 data_size; // Tamaño del buffer de datos
u16* pal; // Buffer para la paleta
u32 pal_size; // Tamaño de la paleta
bool inuse; // Esta en uso el buffer?
} NF_TYPE_BG8B_INFO;
extern NF_TYPE_BG8B_INFO NF_BG8B[NF_SLOTS_BG8B]; // Fondos indexados de 8 bits
// BackBuffer de 8 bits de cada pantalla
typedef struct {
u8* data;
u16* pal;
} NF_TYPE_BB8B_INFO;
extern NF_TYPE_BB8B_INFO NF_8BITS_BACKBUFFER[2];
// Funcion NF_Init16bitsBgBuffers();
void NF_Init16bitsBgBuffers(void);
// Inicia los buffers para almacenar fondos de BITMAP 16 bits
// Usalo UNA SOLA VEZ antes de usar los buffers
// Funcion NF_Reset16bitsBgBuffers();
void NF_Reset16bitsBgBuffers(void);
// Reinicia los buffers para almacenar fondos de BITMAP 16 bits,
// borrado su contenido
// Funcion NF_Init16bitsBackBuffer();
void NF_Init16bitsBackBuffer(u8 screen);
// Inicia el backbuffer de la pantalla dada.
// Usalo UNA SOLA VEZ antes de usar el backbuffer
// Funcion NF_Enable16bitsBackBuffer();
void NF_Enable16bitsBackBuffer(u8 screen);
// Habilita el backbuffer de la pantalla indicada.
// Si el buffer ya existe, la funcion borrara el contenido del mismo,
// poniendo a 0 todos los bytes del buffer.
// Funcion NF_Disble16bitsBackBuffer();
void NF_Disble16bitsBackBuffer(u8 screen);
// Deshabilita el backbuffer de la pantalla indicada, liberando de la
// RAM el espacio usado.
// Funcion NF_Flip16bitsBackBuffer();
void NF_Flip16bitsBackBuffer(u8 screen);
// Copia el contenido del backbuffer a la VRAM de la pantalla indicada.
// Funcion NF_InitBitmapBgSys();
void NF_InitBitmapBgSys(u8 screen, u8 mode);
// Inicia el modo BITMAP en la pantalla especificada, con la profundidad de color
// especificada. (0 -> 256 colores, 1 -> 16 bits)
// Funcion NF_Load16bitsBg();
void NF_Load16bitsBg(const char* file, u8 slot);
// Carga un Fondo BITMAP (en formato RAW) en el slot indicado,
// de un tamaño maximo de 256x256 pixeles.
// Debes especificar el nombre de archivo sin extension.
// El archivo debe ser un binario con extension .img
// Funcion NF_Load16bitsImage();
void NF_Load16bitsImage(const char* file, u8 slot, u16 size_x, u16 size_y);
// Carga una imagen BITMAP (en formato RAW) en el slot indicado,
// de un tamaño maximo de 256x256 pixeles.
// Debes especificar el nombre de archivo sin extension.
// El archivo debe ser un binario con extension .img
// Todos los pixeles Magenta de la imagen (0xFF00FF) seran transparentes.
// Funcion NF_Load16bImgData();
void NF_Load16bImgData(const char* file, u8 slot, u16 x, u16 y, u8 type);
// Funcion de uso interno, no documentar ni usar.
// Cargador generico de datos de imagen de 16 bits a la RAM.
// Funcion NF_Unload16bitsBg();
void NF_Unload16bitsBg(u8 slot);
// Borra de la RAM los datos del buffer especificado
// Funcion NF_Copy16bitsBuffer();
void NF_Copy16bitsBuffer(u8 screen, u8 destination, u8 slot);
// Copia los datos cargados en un Buffer de Bitmap a la VRAM o al BackBuffer
// destination: 0 -> VRAM, 1 -> BackBuffer
// Funcion NF_Draw16bitsImage();
void NF_Draw16bitsImage(u8 screen, u8 slot, s16 x, s16 y, bool alpha);
// Copia la imagen cargada en un Buffer de Bitmap al Backbuffer de la pantalla especificada
// Funcion NF_Init8bitsBgBuffers();
void NF_Init8bitsBgBuffers(void);
// Inicializa los buffers necesarios para la carda de fondos en modo BITMAP de 8 bits.
// Debes usar esta funcion antes de poder usar ninguno de los buffers.
// Funcion NF_Reset8bitsBgBuffers();
void NF_Reset8bitsBgBuffers(void);
// Reinicia los buffers de fondos de 8 bits, borrando todo el contenido de los buffers.
// Funcion NF_Load8bitsBg();
void NF_Load8bitsBg(const char* file, u8 slot);
// Carga los archivos necesarios de un fondo de 8 bits en el Slot indicado.
// Debes especificar el nombre de archivo sin extension.
// El archivo debe ser un binario con extension .img
// La paleta debe tener la extension .pal
// Funcion NF_Unload8bitsBg();
void NF_Unload8bitsBg(u8 slot);
// Borra de la RAM el fondo del slot indicado.
// Funcion NF_Copy8bitsBuffer();
void NF_Copy8bitsBuffer(u8 screen, u8 destination, u8 slot);
// Transfiere la imagen del buffer seleccionado a la pantalla y capas indicado o
// al backbuffer.
// Funcion NF_Init8bitsBackBuffer();
void NF_Init8bitsBackBuffer(u8 screen);
// Inicializa los buffers del backbuffer para la pantalla indicada.
// Debes usar esta funcion una vez antes de usar el backbuffer
// Funcion NF_Enable8bitsBackBuffer();
void NF_Enable8bitsBackBuffer(u8 screen);
// Habilita el backbuffer de la pantalla indicada.
// Si el buffer ya existe, la funcion borrara el contenido del mismo,
// poniendo a 0 todos los bytes del buffer.
// Funcion NF_Disble8bitsBackBuffer();
void NF_Disble8bitsBackBuffer(u8 screen);
// Deshabilita el backbuffer de la pantalla indicada, liberando de la
// RAM el espacio usado.
// Funcion NF_Flip8bitsBackBuffer();
void NF_Flip8bitsBackBuffer(u8 screen, u8 destination);
// Copia el contenido del backbuffer a la VRAM de la pantalla indicada.
// Debes especificar la capa de destino:
// 0 -> Capa 2
// 1 -> Capa 3
#endif
#ifdef __cplusplus
}
#endif

110
examples/3dsprites/rotscale/nflib/include/nf_colision.h
View File

@ -1,110 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_COLISION_H__
#define __NF_COLISION_H__
// NightFox LIB - Include de Colisiones
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define los slots maximos para los mapas de colisiones
#define NF_SLOTS_CMAP 32
// Define la estructura de control de mapas de colisiones
typedef struct {
char* tiles; // Buffer para almacenar los tiles
char* map; // Buffer para almacenar el mapa
char* pal; // Buffer para almacenar la paleta
u32 tiles_size; // Tamaño de los archivos
u32 map_size;
u32 pal_size;
u16 width; // Ancho del mapa (en pixeles)
u16 height; // Alto del mapa (en pixeles)
bool inuse; // Esta en uso el slot?
} NF_TYPE_CMAP_INFO;
extern NF_TYPE_CMAP_INFO NF_CMAP[NF_SLOTS_CMAP]; // Datos de los mapas de colision
// Funcion NF_InitCmapBuffers();
void NF_InitCmapBuffers(void);
// Inicializa los buffers que almacenaran los mapas de colision
// Debes usar esta funcion una unica vez antes de cargar ningun mapa de colision
// Funcion NF_ResetCmapBuffers();
void NF_ResetCmapBuffers(void);
// Reinicia los buffers y variables de los mapas de colisiones.
// Funcion NF_LoadColisionMap();
void NF_LoadColisionMap(const char* file, u8 id, u16 width, u16 height);
// Carga un mapa de colisiones en el slot indicado.
// Funcion NF_UnloadColisionMap();
void NF_UnloadColisionMap(u8 id);
// Borra de la RAM el mapa de colisiones con el nº de slot indicado.
// Funcion NF_GetTile();
extern u16 NF_GetTile(u8 slot, s32 x, s32 y);
// Devuelve el numero de tile de la posicion especificada.
// Funcion NF_SetTile();
void NF_SetTile(u8 slot, s32 x, s32 y, u16 value);
// Cambia el valor del tile en la posicion especificada.
// Funcion NF_LoadColisionBg();
void NF_LoadColisionBg(const char* file, u8 id, u16 width, u16 height);
// Carga un fondo de colisiones para pixel perfect
// Funcion NF_UnloadColisionBg();
void NF_UnloadColisionBg(u8 id);
// Descarga un fondo de colisiones para pixel perfect
// Funcion NF_GetPoint();
extern u8 NF_GetPoint(u8 slot, s32 x, s32 y);
// Obten el color del pixel de las coordenadas dadas
#endif
#ifdef __cplusplus
}
#endif

79
examples/3dsprites/rotscale/nflib/include/nf_defines.h
View File

@ -1,79 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_DEFINES_H__
#define __NF_DEFINES_H__
// NightFox LIB - Definiciones General
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Definicion de los datos del usuario
// Informacion obtenida de PALIB source code
// Referencias usadas de http://nds.metawiki.com/Firmware
/*
FW offset* RAM address Bytes Description
0x000020 2 user settings offset / 8 (default 0x7FC0 => 0x3FE00)
0x00002A 2 CRC16 (with initial value 0) of 0x2C with config length
0x00002C 2 config length (0x138)
0x000036 6 MAC address
0x00003C 4 enabled channels
0x000065 1 ?
0x000082 1 ?
0x000100 1 ?
0x000146 14 ?
0x000162 1 ?
0x03Fx00 0x023FFC80 1 version (5)
0x03Fx02 0x027FFC82 1 favorite color (0-15)
0x03Fx03 0x027FFC83 1 birthday month (1-12)
0x03Fx04 0x027FFC84 1 birthday day (1-31)
0x03Fx06 0x027FFC86 20 name, UTF-16
0x03Fx1A 0x027FFC9A 1/2 length of name in characters
0x03Fx1C 0x027FFC9C 52 message, UTF-16
0x03Fx50 0x027FFCD0 1/2 length of message in characters
0x03Fx52 0x027FFCD2 1 alarm hour
0x03Fx53 0x027FFCD3 1 alarm minute
0x03Fx56 0x027FFCD6 1 0x80=enable alarm, bit 0..6=enable?
0x027FFCD8 12 touch-screen calibration
0x027FFCE4 bit 0..2 language
0x027FFCE4 bit 3 GBA mode screen selection. 0=upper, 1=lower
0x027FFCE4 bit 6 auto/manual mode. 0=manual, 1=auto
WIFI power calibration
0x03Fx70 1/2 update counter (used to check latest)
0x03Fx72 CRC16 of 0x03FF00, 0x70 bytes
*/
#define NF_UDATA_COLOR *(u8*)(0x027FFC82)
#define NF_UDATA_BDAY_MONTH *(u8*)(0x027FFC83)
#define NF_UDATA_BDAY_DAY *(u8*)(0x027FFC84)
#define NF_UDATA_ALARM_HOUR *(u8*)(0x027FFCD2)
#define NF_UDATA_ALARM_MINUTE *(u8*)(0x027FFCD3)
#define NF_UDATA_NAME *(u8*)(0x027FFC86)
#define NF_UDATA_NAME_SIZE *(u8*)(0x027FFC9A)
#define NF_UDATA_MSG *(u8*)(0x027FFC9C)
#define NF_UDATA_MSG_SIZE *(u8*)(0x027FFCD0)
#define NF_UDATA_LANG *(u8*)(0x027FFCE4)
#endif
#ifdef __cplusplus
}
#endif

114
examples/3dsprites/rotscale/nflib/include/nf_lib.h
View File

@ -1,114 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_LIB_H__
#define __NF_LIB_H__
// NightFox LIB - Include General
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
/*
Notas sobre BITSHIFT
(n >> x) Divide n / x
(n << x) Multiplica n * x
Valores de X
2 = 1
4 = 2
8 = 3
16 = 4
32 = 5
64 = 6
128 = 7
256 = 8
512 = 9
1024 = 10
2048 = 11
4096 = 12
8192 = 13
16384 = 14
32768 = 15
65536 = 16
Dado que la DS no tiene unidad de coma flotante, siempre que dividas o
multipliques por numeros de base 2, usa el bitshift
Por ejemplo:
a = (512 / 8);
seria equivalente a
a = (512 >> 3);
Multiplicando
b = (3 * 2048);
seria con bitshift
b = (3 << 11);
*/
// Definiciones comunes
#include "nf_defines.h"
// Libreria de funciones basicas y comunes
#include "nf_basic.h"
// Libreria de funciones 2D comunes
#include "nf_2d.h"
// Libreria de fondos con Tiles
#include "nf_tiledbg.h"
// Libreria de fondos Affine
#include "nf_affinebg.h"
// Libreria de fondos en modo Bitmap
#include "nf_bitmapbg.h"
// Libreria de fondos en modo mixto (Tiled / Bitmap 8 bits)
#include "nf_mixedbg.h"
// Libreria de sprites de 256 colores
#include "nf_sprite256.h"
// Libreria de textos
#include "nf_text.h"
// Libreria de textos de 16 pixeles
#include "nf_text16.h"
// Libreria de colisiones
#include "nf_colision.h"
// Libreria de sonido
#include "nf_sound.h"
// Libreria de archivos multimedia
#include "nf_media.h"
// Libreria 3D, funciones comunes
#include "nf_3d.h"
// Libreria 3D, Sprites
#include "nf_sprite3d.h"
#endif
#ifdef __cplusplus
}
#endif

41
examples/3dsprites/rotscale/nflib/include/nf_media.h
View File

@ -1,41 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_MEDIA_H__
#define __NF_MEDIA_H__
// NightFox LIB - Include de funciones de carga de archivos multimedia
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Funcion NF_LoadBMP();
void NF_LoadBMP(const char* file, u8 slot);
// Carga un archivo BMP de 8, 16 o 24 bits en un slot de imagenes de 16 bits.
// Debes inicializar el modo 16 bits, el backbuffer y usar la funcion NF_Draw16bitsImage();
// para mostrarlo.
#endif
#ifdef __cplusplus
}
#endif

41
examples/3dsprites/rotscale/nflib/include/nf_mixedbg.h
View File

@ -1,41 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_MIXEDBG_H__
#define __NF_MIXEDBG_H__
// NightFox LIB - Include de Fondos mixtos (Tiled / Bitmap 8 bits)
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Funcion NF_InitMixedBgSys();
void NF_InitMixedBgSys(u8 screen);
// Inicializa el modo mixto para fondo (Tiled BG + Bitmap 8 bits)
// Capas 0 a 2 - Tiled
// Capa 3 - Bitmap 8 bits
#endif
#ifdef __cplusplus
}
#endif

96
examples/3dsprites/rotscale/nflib/include/nf_sound.h
View File

@ -1,96 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_SOUND_H__
#define __NF_SOUND_H__
// NightFox LIB - Include de funciones de sonido
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define los Slots para archivos de audio
#define NF_SLOTS_RAWSOUND 32
// Define los Buffers para almacenar los archivos de audio
extern char* NF_BUFFER_RAWSOUND[NF_SLOTS_RAWSOUND];
// Define la estructura de datos de los buffers (Audio)
typedef struct {
bool available; // Disponibilidat del Slot
u32 size; // Tamaño (en bytes) del sonido
u16 freq; // Frecuencia del sample
u8 format; // Formato del sample
} NF_TYPE_RAWSOUND_INFO;
extern NF_TYPE_RAWSOUND_INFO NF_RAWSOUND[NF_SLOTS_RAWSOUND]; // Datos de los sonidos cargado
// Funcion NF_InitRawSoundBuffers();
void NF_InitRawSoundBuffers(void);
// Iniciliaza los buffers y estructuras de datos para cargar sonidos en
// formato RAW. Debes de ejecutar esta funcion una vez antes de cargar
// ningun sonido en este formato
// Funcion NF_ResetRawSoundBuffers();
void NF_ResetRawSoundBuffers(void);
// Reinicia todos los buffers de sonido. Esta funcion es util para vaciar todos los datos
// en un cambio de pantalla, etc.
// Funcion NF_LoadRawSound();
void NF_LoadRawSound(const char* file, u16 id, u16 freq, u8 format);
// Carga un archivo RAW a la RAM desde la FAT o EFS
// Debes especificar el nombre del archivo sin extension, el slot
// donde lo guardaras (0 - 31), la frecuencia del sample (en Hz,
// por ejemplo 11050) y el formato de datos
// (0 - > 8 bits, 1 - > 16 bits, 2 -> ADPCM)
// Funcion UnloadRawSound();
void NF_UnloadRawSound(u8 id);
// Borra de la RAM el archivo cargado en el slot indicado.
// Debes especificar el slot a borrar (0 - 31)
// Funcion NF_PlayRawSound();
extern u8 NF_PlayRawSound(u8 id, u8 volume, u8 pan, bool loop, u16 loopfrom);
// Reproduce un archivo de sonido cargado en RAM.
// Debes especificar el slot donde se ha cargado el sonido, el volumen (0 - 127),
// el balance (0 Izquierda, 64 Centro, 127 Derecha), si se reproducira en bucle y
// de ser asi, a partir de que sample se producira este.
// Esta funcion devuelve el canal asignado a esta reproduccion
#endif
#ifdef __cplusplus
}
#endif

265
examples/3dsprites/rotscale/nflib/include/nf_sprite256.h
View File

@ -1,265 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_SPRITE256_H__
#define __NF_SPRITE256_H__
// NightFox LIB - Include de Sprites a 256 colores
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define los Slots para sprites
#define NF_SLOTS_SPR256GFX 256 // Almacena los graficos
#define NF_SLOTS_SPR256PAL 64 // Almacena las paletas
// Define los Buffers para almacenar los Sprites
extern char* NF_BUFFER_SPR256GFX[NF_SLOTS_SPR256GFX];
extern char* NF_BUFFER_SPR256PAL[NF_SLOTS_SPR256PAL];
// Define la estructura de datos de los buffers (GFX)
typedef struct {
u32 size; // Tamaño (en bytes) del grafico (GFX)
u16 width; // Ancho del Gfx
u16 height; // Altura del Gfx
bool available; // Disponibilidat del Slot
} NF_TYPE_SPR256GFX_INFO;
extern NF_TYPE_SPR256GFX_INFO NF_SPR256GFX[NF_SLOTS_SPR256GFX]; // Buffers de Graficos
// Define la estructura de datos de los buffers (PAL)
typedef struct {
u32 size; // Tamaño (en bytes) de la paleta (PAL)
bool available; // Disponibilidat del Slot
} NF_TYPE_SPR256PAL_INFO;
extern NF_TYPE_SPR256PAL_INFO NF_SPR256PAL[NF_SLOTS_SPR256PAL]; // Buffers de Paletas
// Define la estructura de Gfx en VRAM
typedef struct {
u32 size; // Tamaño (en bytes) del Gfx
u16 width; // Ancho del Gfx
u16 height; // Altura del Gfx
u32 address; // Posicion en la VRAM
u16 ramid; // Numero de Slot en RAM del que provienes
u16 framesize; // Tamaño del frame (en bytes)
u16 lastframe; // Ultimo frame
bool keepframes; // Si es un Sprite animado, debes de mantener los frames en RAM ?
bool inuse; // Disponibilidat del Slot
} NF_TYPE_SPR256VRAM_INFO;
extern NF_TYPE_SPR256VRAM_INFO NF_SPR256VRAM[2][128];
// Datos de paletas de Sprites en VRAM (en uso, slot en ram, etc)
typedef struct {
bool inuse; // Slot en uso
u8 ramslot; // Paleta original en RAM
} NF_TYPE_SPRPALSLOT_INFO;
extern NF_TYPE_SPRPALSLOT_INFO NF_SPRPALSLOT[2][16];
// Define la estructura de datos del OAM (Sprites)
typedef struct {
u8 index; // Numero de Sprite
s16 x; // Coordenada X del Sprite
s16 y; // Coordenada Y del Sprite
u8 layer; // Prioridad en las capas
u8 pal; // Paleta que usaras
u32 size; // Tamaño del Sprite (macro)
u32 color; // Modo de color (macro)
u32* gfx; // Puntero al grafico usado
s8 rot; // Id de rotacion (-1 ninguno) (0 - 31 Id de rotacion)
bool doublesize; // Usar el "double size" al rotar ?
bool hide; // Ocultar el Sprite
bool vflip; // Volteado Vertical
bool hflip; // Volteado Horizontal
bool mosaic; // Mosaico
u16 gfxid; // Id de Gfx usado
u16 frame; // Frame actual
u16 framesize; // Tamaño del frame (en bytes)
u16 lastframe; // Ultimo frame
bool created; // Esta creado este sprite ?
} NF_TYPE_SPRITEOAM_INFO;
extern NF_TYPE_SPRITEOAM_INFO NF_SPRITEOAM[2][128]; // 2 pantallas, 128 sprites
// Define la esturctura de control de la VRAM para Sprites
typedef struct {
s32 free; // Memoria VRAM libre
u32 next; // Siguiente posicion libre
u32 last; // Ultima posicion usada
u32 pos[128]; // Posicion en VRAM para reusar despues de un borrado
u32 size[128]; // Tamaño del bloque libre para reusar
u16 deleted; // Numero de bloques borrados
s32 fragmented; // Memoria VRAM fragmentada
s32 inarow; // Memoria VRAM contigua
s32 max; // Maxima memoria VRAM direccionable
} NF_TYPE_SPRVRAM_INFO;
extern NF_TYPE_SPRVRAM_INFO NF_SPRVRAM[2]; // Informacion VRAM de Sprites en ambas pantallas
// Funcion NF_InitSpriteBuffers()
void NF_InitSpriteBuffers(void);
// Inicializa los buffers y estructuras de datos de los Buffers para almacenar Sprites
// Usala antes de cargar cualquier Sprites
// No uses esta funcion mas de una vez en tu codigo
// Funcion NF_ResetSpriteBuffers()
void NF_ResetSpriteBuffers(void);
// Reinicia los buffers y datos para almacenar Sprites
// Funcion NF_InitSpriteSys();
void NF_InitSpriteSys(int screen, ...);
// Inicializa las variables de control de Sprites y paletas
// Asigna 128kb de RAM para Sprites
// Activa el Soporte para Sprites
// Se debe especificar la pantalla (0 o 1)
// Funcion NF_LoadSpriteGfx();
void NF_LoadSpriteGfx(const char* file, u16 id, u16 width, u16 height);
// Carga un grafico para usarlo despues en la creacion de Sprites
// Especifica el archivo, ID exclusivo (0 - 255) y medidas del grafico
// Funcion NF_UnloadSpriteGfx();
void NF_UnloadSpriteGfx(u16 id);
// Borra de la RAM un Gfx cargado previamente con NF_LoadSpriteGfx();
// Especifica la Id exclusiva (0 - 255) de grafico a borrar.
// Funcion NF_LoadSpritePal();
void NF_LoadSpritePal(const char* file, u8 id);
// Carga una paleta para usarla despues en la creacion de Sprites
// Especifica el archivo y ID exclusivo (0 - 63)
// Funcion NF_UnloadSpritePal();
void NF_UnloadSpritePal(u8 id);
// Borra de la RAM una Paleta cargada previamente con NF_LoadSpritePal();
// Especifica la Id exclusiva (0 - 63) de la paleta a borrar.
// Funcion NF_VramSpriteGfx();
void NF_VramSpriteGfx(u8 screen, u16 ram, u16 vram, bool keepframes);
// Transfiere un Grafico cargado para Sprites a la VRAM
// Debes especificar la pantalla, el Id del Grafico en RAM (origen),
// la Id del grafico en VRAM (destino) y si, en caso de estar animado,
// debe de copiar a la VRAM todos los frames o solo el que este en uso
// Funcion NF_FreeSpriteGfx();
void NF_FreeSpriteGfx(u8 screen, u16 id);
// Borra de la VRAM el Grafico con la Id. especificada.
// Cualquier Sprite que este usando ese Gfx, quedara corrupto.
// Funcion NF_VramSpriteGfxDefrag();
void NF_VramSpriteGfxDefrag(u8 screen);
// Desfragmenta la VRAM de Sprites (Gfx) de la pantalla dada
// Esta se realiza automaticamente al borrar un Gfx de la VRAM
// si la memoria fragmentada es superior a la contigua libre.
// Puedes consultar estos valores con las siguientes variables
// NF_SPRVRAM[u8 screen].free <- Memoria VRAM de Sprites libre
// NF_SPRVRAM[u8 screen].fragmented <- Memoria VRAM de sprites libre fragmentada
// NF_SPRVRAM[u8 screen].inarow <- Memoria VRAM de sprites libre, ultimo bloque mas grande
// NF_SPRVRAM[u8 screen].lost <- Memoria VRAM libre no usable por fragmentacion
// Funcion NF_VramSpritePal();
void NF_VramSpritePal(u8 screen, u8 id, u8 slot);
// Transfiere una Paleta cargada para Sprites a la VRAM
// Debes especificar la pantalla, la Id de la Paleta a trasnferir
// y el slot de destino (0 - 15)
// Funcion NF_CreateSprite();
void NF_CreateSprite(u8 screen, u8 id, u16 gfx, u8 pal, s16 x, s16 y);
// Crea un sprite en la pantalla.
// Debes especificar la pantalla, la ID del Sprite (0 - 127),
// la ID del Grafico que usaras (0 - 255), el slot de paleta (0 - 15),
// y las coordenadas donde lo crearas.
// Funcion NF_DeleteSprite();
void NF_DeleteSprite(u8 screen, u8 id);
// Borra un sprite de la pantalla
// Debes especificar la pantalla y la Id del Sprite a borrar
// Funcion NF_SpriteOamSet();
void NF_SpriteOamSet(u8 screen);
// Copia los datos del array propio de OAM al OAM real
// Debes especificar la pantalla
// Funcion NF_SpriteSetPalColor();
void NF_SpriteSetPalColor(u8 screen, u8 pal, u8 number, u8 r, u8 g, u8 b);
// Cambia el valor de un color de la paleta de sprites especificada.
// Debes especificar la pantalla, slot de la paleta en VRAM, numero de color
// a cambiar dentro de la paleta y el nuevo valor a darle en formato RGB
// Funcion NF_SpriteEditPalColor();
void NF_SpriteEditPalColor(u8 screen, u8 pal, u8 number, u8 r, u8 g, u8 b);
// Modifica los valores de la paleta seleccionada. Las modificaciones se efectuan
// sobre la copia en RAM, por lo que los cambios no seran visibles hasta que se
// transfiera la paleta a la VRAM
// Funcion NF_SpriteUpdatePalette();
void NF_SpriteUpdatePalette(u8 screen, u8 pal);
// Actualiza la paleta en VRAM con la copia que se encuentra en la RAM
// Funcion NF_SpriteGetPalColor();
void NF_SpriteGetPalColor(u8 screen, u8 pal, u8 number, u8* r, u8* g, u8* b);
// Obtiene el valor de un color de la paleta que se encuentra en la RAM
#endif
#ifdef __cplusplus
}
#endif

243
examples/3dsprites/rotscale/nflib/include/nf_sprite3d.h
View File

@ -1,243 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_SPRITE3D_H__
#define __NF_SPRITE3D_H__
// NightFox LIB - Include de funciones 3D
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
//////////////////////////////////
// Defines y variables globales //
//////////////////////////////////
// Numero maximo de sprites en pantalla
#define NF_3DSPRITES 256
// Estructura de control de los sprites 3d
typedef struct {
s16 x; // Coordenada X
s16 y; // Coordenada Y
s16 z; // Coordenada Z
s16 rx; // Rotacion Eje X (-512/0/512) << 6
s16 ry; // Rotacion Eje Y (-512/0/512) << 6
s16 rz; // Rotacion Eje Z (-512/0/512) << 6
bool rot; // Rotacion en uso
u16 sx; // Escala X (0/64/512) << 6
u16 sy; // Escala Y (0/64/512) << 6
bool scale; // Escalado en uso
s16 width; // Ancho del sprite
s16 height; // Alto del sprite
bool inuse; // Esta en uso?
bool show; // Debe mostrarse el sprite?
u32 gfx_tex_format; // Guarda el formato de la textura
u32 gfx; // Direccion donde esta almacenado el grafico en VRAM
u16 gfxid; // Id de Gfx usado
u16 frame; // Frame actual
u16 newframe; // Frame al que cambiar
u16 framesize; // Tamaño del frame (en bytes)
u16 lastframe; // Ultimo frame
u32 gfx_pal_format; // Guarda el formato de la paleta
u32 pal; // Direccion donde esta almacenada la paleta en VRAM
u16 palid; // Id de la paleta usada
u16 prio; // Prioridad de dibujado del sprite
u8 poly_id; // Identificador unico para el Alpha (0 por defecto, 63 prohibido)
u8 alpha; // Nivel de alpha (0 - 31) (31 por defecto)
} NF_TYPE_3DSPRITE_INFO;
extern NF_TYPE_3DSPRITE_INFO NF_3DSPRITE[NF_3DSPRITES];
// Estructura de control Texturas en VRAM
typedef struct {
u32 size; // Tamaño (en bytes) del Gfx
u16 width; // Ancho del Gfx
u16 height; // Altura del Gfx
u32 address; // Posicion en la VRAM
u16 ramid; // Numero de Slot en RAM del que provienes
u16 framesize; // Tamaño del frame (en bytes)
u16 lastframe; // Ultimo frame
bool keepframes; // Si es un Sprite animado, debes de mantener los frames en RAM ?
bool inuse; // Disponibilidat del Slot
} NF_TYPE_TEX256VRAM_INFO;
extern NF_TYPE_TEX256VRAM_INFO NF_TEX256VRAM[NF_3DSPRITES];
// Estructura de control de las paletas en VRAM
typedef struct {
bool inuse; // Slot en uso
u8 ramslot; // Paleta original en RAM
} NF_TYPE_3DSPRPALSLOT_INFO;
extern NF_TYPE_3DSPRPALSLOT_INFO NF_TEXPALSLOT[32];
// Define la esturctura de control de la VRAM para Sprites 3d
typedef struct {
s32 free; // Memoria VRAM libre
u32 next; // Siguiente posicion libre
u32 last; // Ultima posicion usada
u32 pos[NF_3DSPRITES]; // Posicion en VRAM para reusar despues de un borrado
u32 size[NF_3DSPRITES]; // Tamaño del bloque libre para reusar
u16 deleted; // Numero de bloques borrados
s32 fragmented; // Memoria VRAM fragmentada
s32 inarow; // Memoria VRAM contigua
} NF_TYPE_TEXVRAM_INFO;
extern NF_TYPE_TEXVRAM_INFO NF_TEXVRAM; // Informacion VRAM de texturas
// Define la estructura de control de los sprites 3d creados
typedef struct {
s16 total; // Numero de sprites creados
u16 id[NF_3DSPRITES]; // ID del Sprite
u16 bck[NF_3DSPRITES]; // Backup del ID
} NF_TYPE_CREATED_3DSPRITE_INFO;
extern NF_TYPE_CREATED_3DSPRITE_INFO NF_CREATED_3DSPRITE;
// Funcion NF_Init3dSpriteSys();
void NF_Init3dSpriteSys(void);
// Inicializa el sistema de Sprites en 3D
// Funcion NF_Vram3dSpriteGfx();
void NF_Vram3dSpriteGfx(u16 ram, u16 vram, bool keepframes);
// Transfiere un grafico de la RAM a la VRAM
// Funcion NF_Free3dSpriteGfx();
void NF_Free3dSpriteGfx(u16 id);
// Elimina de la VRAM un grafico de texturas y desfragmenta la VRAM si es necesario
// Funcion NF_Vram3dSpriteGfxDefrag();
void NF_Vram3dSpriteGfxDefrag(void);
// Desfragmenta la VRAM usada para texturas
// Funcion NF_Vram3dSpritePal();
void NF_Vram3dSpritePal(u8 id, u8 slot);
// Copia una paleta a la VRAM
// Funcion NF_Create3dSprite();
void NF_Create3dSprite(u16 id, u16 gfx, u16 pal, s16 x, s16 y);
// Crea un Sprite 3D en las coordenadas indicadas
// Funcion NF_Delete3dSprite();
void NF_Delete3dSprite(u16 id);
// Borra el Sprite con la ID indicada
// Funcion NF_Sort3dSprites();
void NF_Sort3dSprites(void);
// Reordena la cola de Sprites 3D creados de menor a mayor segun su ID
// Los Sprites con numeros mas bajos tienen prioridad.
// Funcion NF_Set3dSpritePriority();
void NF_Set3dSpritePriority(u16 id, u16 prio);
// Cambia la prioridad del Sprite
// Funcion NF_Swap3dSpritePriority();
void NF_Swap3dSpritePriority(u16 id_a, u16 id_b);
// Intercambia la prioridad de dos Sprites
// Funcion NF_Move3dSprite();
void NF_Move3dSprite(u16 id, s16 x, s16 y);
// Mueve el Sprite seleccionado a las coordenadas dadas
// Funcion NF_Show3dSprite();
void NF_Show3dSprite(u16 id, bool show);
// Muestra u oculta el sprite con la id indicada
// Funcion NF_Set3dSpriteFrame();
void NF_Set3dSpriteFrame(u16 id, u16 frame);
// Cambia el frame visible del sprite indicado
// Funcion NF_Draw3dSprites();
void NF_Draw3dSprites(void);
// Dibuja en pantalla todos los sprites creados
// Funcion NF_Update3dSpritesGfx();
void NF_Update3dSpritesGfx(void);
// Actualiza si es necesario las texturas de los sprites animados
// Funcion NF_Rotate3dSprite();
void NF_Rotate3dSprite(u16 id, s16 x, s16 y, s16 z);
// Rota el Sprite sobre los ejes indicados (-512/0/512)
// Funcion NF_Scale3dSprite();
void NF_Scale3dSprite(u16 id, u16 x, u16 y);
// Escala el sprite al tamaño indicado (0/64/512)
// Funcion NF_Blend3dSprite();
void NF_Blend3dSprite(u8 sprite, u8 poly_id, u8 alpha);
// Habilita y cambia el nivel de alpha de el sprite 3d indicado. Para que la transparencia
// sea efectiva entre Sprites, debes especificar un poly_id diferente para cada sprite
// (entre 1 y 62). El rango de alpha es de 0 a 31, siendo 31 opaco. Para eliminar la
// transparencia, selecciona un valor para alpha de 31 o especifica como poly_id el nº 0.
// Funcion NF_3dSpritesLayer();
void NF_3dSpritesLayer(u8 layer);
// Selecciona la capa en la que se dibujaran los Sprites 3D. (0 - 3)
// En realidad los Sprites 3D siempre se dibujan sobre la CAPA 0, esta funcion solo cambia
// la prioridad de esta capa sobre las demas.
// Funcion NF_3dSpriteEditPalColor();
void NF_3dSpriteEditPalColor(u8 pal, u8 number, u8 r, u8 g, u8 b);
// Modifica los valores de la paleta seleccionada. Las modificaciones se efectuan
// sobre la copia en RAM, por lo que los cambios no seran visibles hasta que se
// transfiera la paleta a la VRAM
// Funcion NF_3dSpriteUpdatePalette();
void NF_3dSpriteUpdatePalette(u8 pal);
// Actualiza la paleta en VRAM con la copia que se encuentra en la RAM
// Funcion NF_3dSpriteGetPalColor();
void NF_3dSpriteGetPalColor(u8 pal, u8 number, u8* r, u8* g, u8* b);
// Obtiene el valor de un color de la paleta que se encuentra en la RAM
// Funcion NF_3dSpriteSetDeep();
void NF_3dSpriteSetDeep(u8 id, s16 z);
// Cambia la profuncidad de dibujado (z) del sprite (-512/0/512),
// siendo -512 el punto mas cercano, 0 el centro por defecto
// y 512 el punto mas lejano.
#endif
#ifdef __cplusplus
}
#endif

124
examples/3dsprites/rotscale/nflib/include/nf_text.h
View File

@ -1,124 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_TEXT_H__
#define __NF_TEXT_H__
// NightFox LIB - Include de Textos
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define el nº de caracteres que tiene la fuente
#define NF_TEXT_FONT_CHARS 127
#define NF_TEXT_FONT_LAST_VALID_CHAR 113
// Define la estructura de control de textos
typedef struct {
u16 width; // Ultimo tile de la fila (0 - x) 32 tiles serian 0 - 31
u16 height; // Ultimo tile de la columna (0 - y)
u8 rotation; // Rotacion del texto
u8 slot; // Slot donde esta cargado el tileset de esta capa de texto
u8 pal; // Paleta que usara el texto (0 por defecto)
bool exist; // Existe la capa de texto?
bool update; // Tienes que actualizar la capa?
} NF_TYPE_TEXT_INFO;
extern NF_TYPE_TEXT_INFO NF_TEXT[2][4]; // Datos de las capas de texto
// Funcion NF_InitTextSys();
void NF_InitTextSys(u8 screen);
// Inicializa el sistema de Texto para la pantalla dada
// Funcion NF_LoadTextFont();
void NF_LoadTextFont(const char* file, const char* name, u16 width, u16 height, u8 rotation);
// Carga una fuente para usar como texto
// La fuente se cargara en un slot libre de fondos tileados
// Debes especificar el archivos sin extension y un nombre para referenciarla
// En caso de que la fuente tenga los sets de rotacion a izquierda y derecha,
// especificar 1 o 2 en el parametro "rot". 0 carga la fuente sin rotacion
// Funcion NF_UnloadTextFont();
void NF_UnloadTextFont(const char* name);
// Borra un fuente cargada en RAM
// Esta funcion simplemente llama a NF_UnloadTiledBg(); para su borrado
// Funcion NF_CreateTextLayer();
void NF_CreateTextLayer(u8 screen, u8 layer, u8 rotation, const char* name);
// Crea un fondo tileado para usarlo con texto
// Esta funcion simplemente llama a NF_CreateTiledBg(); para su creacion
// Funcion NF_DeleteTextLayer();
void NF_DeleteTextLayer(u8 screen, u8 layer);
// Borra un fondo usado como capa de texto y sus buffers y variables asociadas
// Funcion NF_WriteText();
void NF_WriteText(u8 screen, u8 layer, u16 x, u16 y, const char* text);
// Escribe un texto en el buffer de texto de la pantalla y capa seleccionada
// Funcion NF_UpdateTextLayers();
void NF_UpdateTextLayers(void);
// Copia el buffer de texto a la VRAM en las capas que sea necesario
// realizar una actualizacion
// Funcion NF_ClearTextLayer();
void NF_ClearTextLayer(u8 screen, u8 layer);
// Borra el contanido de la capa de texto seleccionada
// Funcion NF_DefineTextColor();
void NF_DefineTextColor(u8 screen, u8 layer, u8 color, u8 r, u8 g, u8 b);
// Define uno de los 16 colores disponibles para texto, en formato RGB
// Function NF_SetTextColor();
void NF_SetTextColor(u8 screen, u8 layer, u8 color);
// Selecciona con que color definido se escribira el texto (no cambia el color del texto ya escrito)
#endif
#ifdef __cplusplus
}
#endif

64
examples/3dsprites/rotscale/nflib/include/nf_text16.h
View File

@ -1,64 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_TEXT16_H__
#define __NF_TEXT16_H__
// NightFox LIB - Include de Textos de 16 pixels
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define el nº de caracteres que tiene la fuente
#define NF_TEXT_FONT_CHARS_16 127
#define NF_TEXT_FONT_LAST_VALID_CHAR_16 113
// Funcion NF_LoadTextFont16();
void NF_LoadTextFont16(const char* file, const char* name, u16 width, u16 height, u8 rotation);
// Carga una fuente para texto de 16 pixeles de altura
// Funcion NF_CreateTextLayer16();
void NF_CreateTextLayer16(u8 screen, u8 layer, u8 rotation, const char* name);
// Crea una capa de texto para fuentes de 16 pixeles
// Funcion NF_WriteText16();
void NF_WriteText16(u8 screen, u8 layer, u16 x, u16 y, const char* text);
// Escribe un texto en la capa y pantalla especificados
// Funcion NF_ClearTextLayer16();
void NF_ClearTextLayer16(u8 screen, u8 layer);
// Limpia la capa de texto especificada
#endif
#ifdef __cplusplus
}
#endif

320
examples/3dsprites/rotscale/nflib/include/nf_tiledbg.h
View File

@ -1,320 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_TILEDBG_H__
#define __NF_TILEDBG_H__
// NightFox LIB - Include de Fondos con tiles
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define los slots maximos para los fondos
#define NF_SLOTS_TBG 64 // Datos de los fondos
#define NF_SLOTS_EXBGPAL 128 // Paletas extendidas (maximo 16 paletas por fondo)
// Define el numero maximo de bancos para tiles y mapas
#define NF_MAX_BANKS_TILES 8
#define NF_MAX_BANKS_MAPS 16
// Define el numero de bancos de Mapas y Tiles
extern u8 NF_BANKS_TILES[2]; // (1 banks = 16kb) Cada banco de tiles puede alvergar 8 bancos de Mapas
extern u8 NF_BANKS_MAPS[2]; // (1 bank = 2kb) Usar multiplos de 8. Cada set de 8 bancos consume 1 banco de tiles
// Define los Buffers para almacenar los fondos
extern char* NF_BUFFER_BGTILES[NF_SLOTS_TBG];
extern char* NF_BUFFER_BGMAP[NF_SLOTS_TBG];
extern char* NF_BUFFER_BGPAL[NF_SLOTS_TBG];
// Define estructura para almacenar la info de los fondos
typedef struct {
char name[32]; // Nombre del fondo
u32 tilesize; // Tamaño del Tileset
u32 mapsize; // Tamaño del Map
u32 palsize; // Tamaño de la Paleta
u16 width; // Ancho del fondo
u16 height; // Altura del fondo
bool available; // Disponibilidat del Slot
} NF_TYPE_TBG_INFO;
extern NF_TYPE_TBG_INFO NF_TILEDBG[NF_SLOTS_TBG]; // Datos de los fondos
// Define la estructura para almacenar la info y datos de las paletas extendidas
typedef struct {
char* buffer; // Buffer para almacenar la paleta
u32 palsize; // Tamaño de la paleta
bool inuse; // Slot libre o en uso
} NF_TYPE_EXBGPAL_INFO;
extern NF_TYPE_EXBGPAL_INFO NF_EXBGPAL[NF_SLOTS_EXBGPAL]; // Datos de las paletas extendidas
// Define estructura para almacenar la info de los fondos en pantalla
typedef struct {
u8 tilebase; // Bloque de inicio en VRAM del Tileset
u8 tileblocks; // Bloques usados por el Tileset
u8 mapbase; // Bloque de inicio en VRAM del Map
u8 mapblocks; // Bloques usados por el Map
u16 bgwidth; // Ancho del fondo
u16 bgheight; // Altura del fondo
u16 mapwidth; // Ancho del mapa
u16 mapheight; // Altura del mapa
u8 bgtype; // Tipo de mapa
u8 bgslot; // Buffer de graficos usado (NF_BUFFER_BGMAP)
u8 blockx; // Bloque de mapa (horizontal)
u8 blocky; // bloque de mapa (vertical)
bool created; // Flag de si esta creado
} NF_TYPE_TBGLAYERS_INFO;
// El hardware de la DS no permite mapas mayores de 512x512
// Asi que informaremos si nuestor mapa lo gestionara el hardware si es menor o
// igual a 512x512, o usaremos nuestro motor de Tile Swaping
// bgtype 0: Normal (maximo 512 x 512)
// bgtype 1: >512 x 256
// bgtype 2: 256 x >512
// bgtype 3: >512 x >512
extern NF_TYPE_TBGLAYERS_INFO NF_TILEDBG_LAYERS[2][4]; //[screen][layer]
// Define el array de bloques libres
extern u8 NF_TILEBLOCKS[2][NF_MAX_BANKS_TILES];
extern u8 NF_MAPBLOCKS[2][NF_MAX_BANKS_MAPS];
// Funcion NF_InitTiledBgBuffers();
void NF_InitTiledBgBuffers(void);
// Inicializa los buffers y estructuras de control para usar los fondos "tileados"
// Se debe usar antes de cargar o usar cualquier fondo
// No uses esta funcion mas de una vez en tu codigo
// Funcion NF_ResetTiledBgBuffers();
void NF_ResetTiledBgBuffers(void);
// Borra todos los buffers y reinicia las estructuras de fondos "tileados"
// Usala para los cambios de nivel y similares
// Funcion NF_InitTiledBgSys();
void NF_InitTiledBgSys(u8 screen);
// Inicializa las variables de control de tiles, mapas y paletas
// Asigna 128kb de RAM para fondos tileados
// Se debe especificar la pantalla (0 o 1)
// Funcion NF_LoadTiledBg();
void NF_LoadTiledBg(const char* file, const char* name, u16 width, u16 height);
// Carga un fondo tileado desde FAT
// Debes de especificar el archivo que se cargara (sin extension) y el nombre
// que le quieres dar y las medidas en pixeles
// Funcion NF_LoadTilesForBg();
void NF_LoadTilesForBg(const char* file, const char* name, u16 width, u16 height, u16 tile_start, u16 tile_end);
// Carga desde la FAT los tiles especificados y su paleta
// Ademas, crea un mapa vacio de la medida especificada
// Esta funcion es util para cargar varios tiles y despues generar fondos
// modificando el MAP desde cogido (Generador de escenarios, animaciones, etc)
// Funcion NF_UnloadTiledBg();
void NF_UnloadTiledBg(const char* name);
// Borra de la RAM un fondo cargado con NF_LoadTiledBg();
// Debes especificar el nombre que le diste al fondo
// Funcion NF_CreateTiledBg();
void NF_CreateTiledBg(u8 screen, u8 layer, const char* name);
// Crea un fondo con los parametros dados, indicale la pantalla, capa y nombre
// Funcion NF_DeleteTiledBg();
void NF_DeleteTiledBg(u8 screen, u8 layer);
// Borra un fondo de la memoria VRAM
// Debes especificar la pantalla y numero de capa
// Funcion NF_GetTileMapAddress();
extern u32 NF_GetTileMapAddress(u8 screen, u8 layer, u16 tile_x, u16 tile_y);
// Funcion de uso interno de la libreria
// Devuelve la direccion en el buffer de un tile concreto
// Funcion NF_GetTileOfMap();
extern u16 NF_GetTileOfMap(u8 screen, u8 layer, u16 tile_x, u16 tile_y);
// Obten el valor del tile del mapa indicado en las coordenadas (en tiles) indicadas.
// Funcion NF_SetTileOfMap();
void NF_SetTileOfMap(u8 screen, u8 layer, u16 tile_x, u16 tile_y, u16 tile);
// Cambia el valor del tile del mapa indicado en las coordenadas (en tiles) indicadas.
// Funcion NF_UpdateVramMap();
void NF_UpdateVramMap(u8 screen, u8 layer);
// Actualiza en VRAM el contenido del mapa seleccionado.
// Funcion NF_BgSetPalColor();
void NF_BgSetPalColor(u8 screen, u8 layer, u8 number, u8 r, u8 g, u8 b);
// Cambia al momento el valor de un color de la paleta
// Cuidado! Funcion Muy lenta, usar solo para 2 o 3 colores por ciclo
// Cambia el color directamente en la VRAM
// Funcion NF_BgEditPalColor();
void NF_BgEditPalColor(u8 screen, u8 layer, u8 number, u8 r, u8 g, u8 b);
// Edita un color de la paleta seleccionada.
// El color se edita en el buffer de RAM, para que sea efectivo,
// mandala a la VRAM con NF_UpdatePalette();
// Funcion NF_BgUpdatePalette();
void NF_BgUpdatePalette(u8 screen, u8 layer);
// Actualiza la paleta en VRAM con la que se encuentra en el buffer de RAM
// Funcion NF_BgGetPalColor();
void NF_BgGetPalColor(u8 screen, u8 layer, u8 number, u8* r, u8* g, u8* b);
// Obtiene el valor de un color de la paleta que se encuentra en la RAM
// Funcion NF_GetTilePal();
extern u8 NF_GetTilePal(u8 screen, u8 layer, u16 tile_x, u16 tile_y);
// Devuelve que numero de paleta (0 - 15) esta usando el tile del fondo especificado.
// Por defecto, todos los tiles usan la paleta del Slot nº0
// Los datos se obtienen de la compia en RAM del mapa del fondo.
// Funcion NF_SetTilePal();
void NF_SetTilePal(u8 screen, u8 layer, u16 tile_x, u16 tile_y, u8 pal);
// Cambia el numero de paleta (0 - 15) que usara el tile del fondo especificado.
// Por defecto, todos los tiles usan la paleta del Slot nº0
// Los datos se escriben de la compia en RAM del mapa del fondo, por lo que no seran
// visibles hasta que ejecutes la funcion NF_UpdateVramMap();
// Funcion NF_LoadExBgPal();
void NF_LoadExBgPal(const char* file, u8 slot);
// Carga en el buffer de RAM correspondiente una paleta de fondos, para poderla usar
// mas tarde como paleta extendida.
// Funcion NF_UnloadExBgPal();
void NF_UnloadExBgPal(u8 slot);
// Borra de la RAM la paleta del slot especificado.
// Funcion NF_VramExBgPal();
void NF_VramExBgPal(u8 screen, u8 layer, u8 id, u8 slot);
// Transfiere a la VRAM una paleta extendida en el slot de la pantalla y
// fondo especificados.
// Funcion NF_SetExBgPal();
void NF_SetExBgPal(u8 screen, u8 layer, u8 pal);
// Cambia la paleta extendida que usara un fondo.
// La paleta debe de estar transferida en la VRAM previamente
// Funcion NF_SetTileHflip();
void NF_SetTileHflip(u8 screen, u8 layer, u16 tile_x, u16 tile_y);
// Invierte horizontalmente el estado actual del tile seleccionado
// Los cambios no seran visibles hasta que actualices el mapa
// con la funcion NF_UpdateVramMap();
// Funcion NF_SetTileVflip();
void NF_SetTileVflip(u8 screen, u8 layer, u16 tile_x, u16 tile_y);
// Invierte verticalmente el estado actual del tile seleccionado
// Los cambios no seran visibles hasta que actualices el mapa
// con la funcion NF_UpdateVramMap();
// Funcion NF_RotateTileGfx();
void NF_RotateTileGfx(u8 slot, u16 tile, u8 rotation);
// Rota el grafico de un tile especificado. Rota el tile almacenado en un buffer de fondos
// que se encuentra en RAM. Debes especificar el SLOT del buffer, numero de tile en el buffer
// y el angulo de la rotacion.
// 1 - 90º a la derecha
// 2 - 90º a la izquierda
// 3 - 180º
#endif
#ifdef __cplusplus
}
#endif

BIN
examples/3dsprites/rotscale/nflib/lib/libnflib.a
View File

Binary file not shown.

238
examples/3dsprites/setlayer/Makefile
View File

@ -1,60 +1,17 @@
#---------------------------------------------------------------------------------
# Makefile for NightFox's Lib Projects
#---------------------------------------------------------------------------------
#---------------------------------------------------------------------------------
.SUFFIXES:
#---------------------------------------------------------------------------------
ifeq ($(strip $(DEVKITARM)),)
$(error "Please set DEVKITARM in your environment. export DEVKITARM=<path to>devkitARM")
endif
# These set the information text in the nds file
#GAME_TITLE := My Wonderful Homebrew
#GAME_SUBTITLE1 := built with devkitARM
#GAME_SUBTITLE2 := http://devitpro.org
#---------------------------------------------------------------------------------
# This part substitutes this include:
# include $(DEVKITARM)/ds_rules
# This allows you to set ROM info and icon easy
# Please update this block from DS_RULES file at every DEVKITARM update
#---------------------------------------------------------------------------------
include $(DEVKITARM)/base_rules
LIBNDS := $(DEVKITPRO)/libnds
GAME_TITLE := Text 1
GAME_SUBTITLE1 := Text 2
GAME_SUBTITLE2 := Text 3
GAME_ICON := $(CURDIR)/../icon.bmp
_ADDFILES := -d $(NITRO_FILES)
#---------------------------------------------------------------------------------
%.nds: %.arm9
@ndstool -c $@ -9 $< -b $(GAME_ICON) "$(GAME_TITLE);$(GAME_SUBTITLE1);$(GAME_SUBTITLE2)" $(_ADDFILES)
@echo built ... $(notdir $@)
#---------------------------------------------------------------------------------
%.nds: %.elf
@ndstool -c $@ -9 $< -b $(GAME_ICON) "$(GAME_TITLE);$(GAME_SUBTITLE1);$(GAME_SUBTITLE2)" $(_ADDFILES)
@echo built ... $(notdir $@)
#---------------------------------------------------------------------------------
%.arm9: %.elf
@$(OBJCOPY) -O binary $< $@
@echo built ... $(notdir $@)
#---------------------------------------------------------------------------------
%.arm7: %.elf
@$(OBJCOPY) -O binary $< $@
@echo built ... $(notdir $@)
#---------------------------------------------------------------------------------
%.elf:
@echo linking $(notdir $@)
@$(LD) $(LDFLAGS) $(OFILES) $(LIBPATHS) $(LIBS) -o $@
include $(DEVKITARM)/ds_rules
#---------------------------------------------------------------------------------
# TARGET is the name of the output
@ -62,43 +19,56 @@ _ADDFILES := -d $(NITRO_FILES)
# SOURCES is a list of directories containing source code
# INCLUDES is a list of directories containing extra header files
# DATA is a list of directories containing binary files embedded using bin2o
# NITRODATA is the directory where files for NitroFS will be placed
# GRAPHICS is a list of directories containing image files to be converted with grit
# AUDIO is a list of directories containing audio to be converted by maxmod
# ICON is the image used to create the game icon, leave blank to use default rule
# NITRO is a directory that will be accessible via NitroFS
#---------------------------------------------------------------------------------
TARGET := $(shell basename $(CURDIR))
BUILD := build
SOURCES := source
INCLUDES := include
DATA := data
NITRODATA := nitrofiles
TARGET := $(shell basename $(CURDIR))
BUILD := build
SOURCES := source
INCLUDES := include
DATA := data
GRAPHICS :=
AUDIO :=
ICON :=
# specify a directory which contains the nitro filesystem
# this is relative to the Makefile
NITRO := nitrofiles
#---------------------------------------------------------------------------------
# options for code generation
#---------------------------------------------------------------------------------
ARCH := -mthumb -mthumb-interwork
ARCH := -marm -mthumb-interwork -march=armv5te -mtune=arm946e-s
CFLAGS := -g -Wall -O2\
-march=armv5te -mtune=arm946e-s -fomit-frame-pointer\
-ffast-math \
$(ARCH)
CFLAGS += $(INCLUDE) -DARM9
CXXFLAGS := $(CFLAGS) -fno-rtti -fno-exceptions
ASFLAGS := -g $(ARCH)
LDFLAGS = -specs=ds_arm9.specs -g $(ARCH) -Wl,-Map,$(notdir $*.map)
CFLAGS := -g -Wall -O3\
$(ARCH) $(INCLUDE) -DARM9
CXXFLAGS := $(CFLAGS) -fno-rtti -fno-exceptions
ASFLAGS := -g $(ARCH)
LDFLAGS = -specs=ds_arm9.specs -g $(ARCH) -Wl,-Map,$(notdir $*.map)
#---------------------------------------------------------------------------------
# any extra libraries we wish to link with the project
# any extra libraries we wish to link with the project (order is important)
#---------------------------------------------------------------------------------
LIBS := -lnflib -lfilesystem -lfat -lnds9
LIBS := -lnflib
# automatigically add libraries for NitroFS
ifneq ($(strip $(NITRO)),)
LIBS := $(LIBS) -lfilesystem -lfat
endif
# automagically add maxmod library
ifneq ($(strip $(AUDIO)),)
LIBS := $(LIBS) -lmm9
endif
LIBS := $(LIBS) -lnds9
#---------------------------------------------------------------------------------
# list of directories containing libraries, this must be the top level containing
# include and lib
#---------------------------------------------------------------------------------
LIBDIRS := $(LIBNDS) $(CURDIR)/nflib
LIBDIRS := $(LIBNDS) $(PORTLIBS) $(DEVKITPRO)/nflib
#---------------------------------------------------------------------------------
# no real need to edit anything past this point unless you need to add additional
@ -107,64 +77,97 @@ LIBDIRS := $(LIBNDS) $(CURDIR)/nflib
ifneq ($(BUILD),$(notdir $(CURDIR)))
#---------------------------------------------------------------------------------
export OUTPUT := $(CURDIR)/$(TARGET)
export OUTPUT := $(CURDIR)/$(TARGET)
export VPATH := $(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
$(foreach dir,$(DATA),$(CURDIR)/$(dir))
export VPATH := $(CURDIR)/$(subst /,,$(dir $(ICON)))\
$(foreach dir,$(SOURCES),$(CURDIR)/$(dir))\
$(foreach dir,$(DATA),$(CURDIR)/$(dir))\
$(foreach dir,$(GRAPHICS),$(CURDIR)/$(dir))
export DEPSDIR := $(CURDIR)/$(BUILD)
export DEPSDIR := $(CURDIR)/$(BUILD)
export NITRO_FILES := $(CURDIR)/$(NITRODATA)
CFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
CPPFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
SFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
PNGFILES := $(foreach dir,$(GRAPHICS),$(notdir $(wildcard $(dir)/*.png)))
BINFILES := $(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
CFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
CPPFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
SFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
BINFILES := $(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
# prepare NitroFS directory
ifneq ($(strip $(NITRO)),)
export NITRO_FILES := $(CURDIR)/$(NITRO)
endif
# get audio list for maxmod
ifneq ($(strip $(AUDIO)),)
export MODFILES := $(foreach dir,$(notdir $(wildcard $(AUDIO)/*.*)),$(CURDIR)/$(AUDIO)/$(dir))
# place the soundbank file in NitroFS if using it
ifneq ($(strip $(NITRO)),)
export SOUNDBANK := $(NITRO_FILES)/soundbank.bin
# otherwise, needs to be loaded from memory
else
export SOUNDBANK := soundbank.bin
BINFILES += $(SOUNDBANK)
endif
endif
#---------------------------------------------------------------------------------
# use CXX for linking C++ projects, CC for standard C
#---------------------------------------------------------------------------------
ifeq ($(strip $(CPPFILES)),)
#---------------------------------------------------------------------------------
export LD := $(CC)
export LD := $(CC)
#---------------------------------------------------------------------------------
else
#---------------------------------------------------------------------------------
export LD := $(CXX)
export LD := $(CXX)
#---------------------------------------------------------------------------------
endif
#---------------------------------------------------------------------------------
export OFILES := $(addsuffix .o,$(BINFILES)) \
$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
export OFILES_BIN := $(addsuffix .o,$(BINFILES))
export INCLUDE := $(foreach dir,$(INCLUDES),-iquote $(CURDIR)/$(dir)) \
$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
-I$(CURDIR)/$(BUILD)
export OFILES_SOURCES := $(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
export LIBPATHS := $(foreach dir,$(LIBDIRS),-L$(dir)/lib)
export OFILES := $(PNGFILES:.png=.o) $(OFILES_BIN) $(OFILES_SOURCES)
icons := $(wildcard *.bmp)
export HFILES := $(PNGFILES:.png=.h) $(addsuffix .h,$(subst .,_,$(BINFILES)))
ifneq (,$(findstring $(TARGET).bmp,$(icons)))
export GAME_ICON := $(CURDIR)/$(TARGET).bmp
export INCLUDE := $(foreach dir,$(INCLUDES),-iquote $(CURDIR)/$(dir))\
$(foreach dir,$(LIBDIRS),-I$(dir)/include)\
-I$(CURDIR)/$(BUILD)
export LIBPATHS := $(foreach dir,$(LIBDIRS),-L$(dir)/lib)
ifeq ($(strip $(ICON)),)
icons := $(wildcard *.bmp)
ifneq (,$(findstring $(TARGET).bmp,$(icons)))
export GAME_ICON := $(CURDIR)/$(TARGET).bmp
else
ifneq (,$(findstring icon.bmp,$(icons)))
export GAME_ICON := $(CURDIR)/icon.bmp
endif
endif
else
ifneq (,$(findstring icon.bmp,$(icons)))
export GAME_ICON := $(CURDIR)/icon.bmp
endif
ifeq ($(suffix $(ICON)), .grf)
export GAME_ICON := $(CURDIR)/$(ICON)
else
export GAME_ICON := $(CURDIR)/$(BUILD)/$(notdir $(basename $(ICON))).grf
endif
endif
.PHONY: $(BUILD) clean
#---------------------------------------------------------------------------------
$(BUILD):
@[ -d $@ ] || mkdir -p $@
@make --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
@mkdir -p $@
@$(MAKE) --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
#---------------------------------------------------------------------------------
clean:
@echo clean ...
@rm -fr $(BUILD) $(TARGET).elf $(TARGET).nds $(TARGET).arm9
@rm -fr $(BUILD) $(TARGET).elf $(TARGET).nds $(SOUNDBANK)
#---------------------------------------------------------------------------------
else
@ -172,14 +175,47 @@ else
#---------------------------------------------------------------------------------
# main targets
#---------------------------------------------------------------------------------
$(OUTPUT).nds : $(OUTPUT).elf
$(OUTPUT).elf : $(OFILES)
$(OUTPUT).nds: $(OUTPUT).elf $(NITRO_FILES) $(GAME_ICON)
$(OUTPUT).elf: $(OFILES)
# source files depend on generated headers
$(OFILES_SOURCES) : $(HFILES)
# need to build soundbank first
$(OFILES): $(SOUNDBANK)
#---------------------------------------------------------------------------------
%.bin.o : %.bin
# rule to build solution from music files
#---------------------------------------------------------------------------------
$(SOUNDBANK) : $(MODFILES)
#---------------------------------------------------------------------------------
mmutil $^ -d -o$@ -hsoundbank.h
#---------------------------------------------------------------------------------
%.bin.o %_bin.h : %.bin
#---------------------------------------------------------------------------------
@echo $(notdir $<)
$(bin2o)
@$(bin2o)
#---------------------------------------------------------------------------------
# This rule creates assembly source files using grit
# grit takes an image file and a .grit describing how the file is to be processed
# add additional rules like this for each image extension
# you use in the graphics folders
#---------------------------------------------------------------------------------
%.s %.h: %.png %.grit
#---------------------------------------------------------------------------------
grit $< -fts -o$*
#---------------------------------------------------------------------------------
# Convert non-GRF game icon to GRF if needed
#---------------------------------------------------------------------------------
$(GAME_ICON): $(notdir $(ICON))
#---------------------------------------------------------------------------------
@echo convert $(notdir $<)
@grit $< -g -gt -gB4 -gT FF00FF -m! -p -pe 16 -fh! -ftr
-include $(DEPSDIR)/*.d
#---------------------------------------------------------------------------------------
endif

5
examples/3dsprites/setlayer/clean.bat
View File

@ -1,5 +0,0 @@
@echo off
cls
make clean
pause
exit

5
examples/3dsprites/setlayer/compile.bat
View File

@ -1,5 +0,0 @@
@echo off
cls
make
pause
exit

BIN
examples/3dsprites/setlayer/icon.bmp
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 1.1 KiB

139
examples/3dsprites/setlayer/nflib/include/nf_2d.h
View File

@ -1,139 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_2D_H__
#define __NF_2D_H__
// NightFox LIB - Include de funciones 2D comunes
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Funcion NF_Set2D();
void NF_Set2D(u8 screen, u8 mode);
// Inicia el modo 2D seleccionado en la pantalla deseada
// Funcion NF_ShowBg();
void NF_ShowBg(u8 screen, u8 layer);
// Haz visible el fondo de la capa y pantalla dados
// Funcion NF_HideBg();
void NF_HideBg(u8 screen, u8 layer);
// Oculta el fondo de la capa y pantalla dados
// Funcion NF_ScrollBg();
void NF_ScrollBg(u8 screen, u8 layer, s16 x, s16 y);
// Mueve el fondo a las coordenadas especificadas.
// Debes de indicar la pantalla, capa, y coordenadas X e Y
// Si el mapa es mayor de 512 en alguna medida, debes de mantener el fondo en RAM
// Funcion NF_MoveSprite();
void NF_MoveSprite(u8 screen, u8 id, s16 x, s16 y);
// Mueve el Sprite a las coordenadas especificadas
// Debes de indicar la pantalla, id de sprite y coordenadas
// Funcion NF_SpriteLayer();
void NF_SpriteLayer(u8 screen, u8 id, u8 layer);
// Define la capa sobre la que el sprite sera dibujado
// Debes de indicar la pantalla, id del sprite y capa
// Funcion NF_ShowSprite();
void NF_ShowSprite(u8 screen, u8 id, bool show);
// Muestra o oculta el sprite
// Debes especificar la pantalla, id del sprite y el estado (true, false)
// Funcion NF_HflipSprite();
void NF_HflipSprite(u8 screen, u8 id, bool hflip);
// Voltea el Sprite horizontalmente
// Debes especificar la pantalla, id del sprite y el estado (true, false)
// Funcion NF_GetSpriteHflip();
extern bool NF_GetSpriteHflip(u8 screen, u8 id);
// Devuelve el estado del volteado horizontal de un sprite
// Debes especificar la pantalla y la id del sprite
// Funcion NF_VflipSprite();
void NF_VflipSprite(u8 screen, u8 id, bool vflip);
// Voltea el Sprite verticalmente
// Debes especificar la pantalla, id del sprite y el estado (true, false)
// Funcion NF_GetSpriteVflip();
extern bool NF_GetSpriteVflip(u8 screen, u8 id);
// Devuelve el estado del volteado vertical de un sprite
// Debes especificar la pantalla y la id del sprite
// Funcion NF_SpriteFrame();
void NF_SpriteFrame(u8 screen, u8 id, u16 frame);
// Cambia el frame de un Sprite
// Debes especificar la pantalla, el Id del sprite y el frame
// Funcion NF_EnableSpriteRotScale();
void NF_EnableSpriteRotScale(u8 screen, u8 sprite, u8 id, bool doublesize);
// Habilita el sprite como rotable y escalable
// Debes especificar la pantalla, nº de sprite, id de rotacion y si
// tiene que activarse el doublesize (tamaño x2)
// Funcion NF_DisableSpriteRotScale();
void NF_DisableSpriteRotScale(u8 screen, u8 sprite);
// Deshabilita un sprite como rotable y escalable
// Debes especificar la pantalla y el nº de sprite
// Funcion NF_SpriteRotScale();
void NF_SpriteRotScale(u8 screen, u8 id, s16 angle, u16 sx, u16 sy);
// Define el angulo de rotacion y escala de los Sprites asociados a la Id.
// El rango del angulo es desde -512 a 512, siendo 0 el valor central
// El rango de escalado va de 0 a 512, siendo 256 el valor normal (100%)
#endif
#ifdef __cplusplus
}
#endif

50
examples/3dsprites/setlayer/nflib/include/nf_3d.h
View File

@ -1,50 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_3D_H__
#define __NF_3D_H__
// NightFox LIB - Include de funciones 3D
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Funcion NF_Set3D();
void NF_Set3D(u8 screen, u8 mode);
// Inicia el modo 3D seleccionado en la pantalla deseada
// Funcion NF_InitOpenGL();
void NF_InitOpenGL(void);
// Inicializa el OpenGL para la libreria
// Funcion NF_GetTextureSize();
extern u16 NF_GetTextureSize(u16 textel);
// Devuelve el tamaño del textel
#endif
#ifdef __cplusplus
}
#endif

106
examples/3dsprites/setlayer/nflib/include/nf_affinebg.h
View File

@ -1,106 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_AFFINEBG_H__
#define __NF_AFFINEBG_H__
// NightFox LIB - Includes de Fondos Affine
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Estructura para almacenar los parametros de los fondos Affine
typedef struct {
s32 x; // Posicion X
s32 y; // Posicion Y
s32 x_center; // Centro X
s32 y_center; // Centro Y
s32 x_scale; // Valor Zoom X (PA)
s32 y_scale; // Valor Zoom Y (PD)
s32 x_tilt; // Valor Inclinacion X (PB)
s32 y_tilt; // Valor Inclinacion Y (PC)
s32 angle; // Valor de la rotacion
} NF_TYPE_AFFINE_BG;
extern NF_TYPE_AFFINE_BG NF_AFFINE_BG[2][4];
// Funcion NF_InitTiledBgSys();
void NF_InitAffineBgSys(u8 screen);
// Inicializa el sistema de fondos Affine. Solo puede usarse en las capas 2 y 3, los fondos en
// la misma pantalla deben de compartir la paleta y no pueden tener mas de 256 tiles.
// Funcion NF_LoadAffineBg();
void NF_LoadAffineBg(const char* file, const char* name, u16 width, u16 height);
// Carga un fondo tileado desde FAT
// Debes de especificar el archivo que se cargara (sin extension) y el nombre
// que le quieres dar y las medidas en pixeles
// Los buffers para fondos tileados deben estar inicializados antes de usar esta funcion
// Funcion NF_UnloadAffineBg();
void NF_UnloadAffineBg(const char* name);
// Borra de la RAM el fondo affine especificado. Es una simple llamada a la funcion NF_UnloadTiledBg();
// Funcion NF_CreateAffineBg();
void NF_CreateAffineBg(u8 screen, u8 layer, const char* name, u8 wrap);
// Crea un fondo con los parametros dados, indicale la pantalla, capa, nombre y si se activa la opcion
// de WRAP arround (0 desactivado, 1 activado).
// Funcion NF_DeleteAffineBg();
void NF_DeleteAffineBg(u8 screen, u8 layer);
// Borra el fondo Affine especificado
// Funcion NF_AffineBgTransform();
void NF_AffineBgTransform(u8 screen, u8 layer, s32 x_scale, s32 y_scale, s32 x_tilt, s32 y_tilt);
// Modifica los parametros de la matriz de transformacion del fondo affine
// Funcion NF_AffineBgMove();
void NF_AffineBgMove(u8 screen, u8 layer, s32 x, s32 y, s32 angle);
// Desplaza el fondo affine y rotalo (-2048 a 2048)
// Funcion NF_AffineBgCenter();
void NF_AffineBgCenter(u8 screen, u8 layer, s32 x, s32 y);
// Define el centro de rotacion de un fondo affine
#endif
#ifdef __cplusplus
}
#endif

89
examples/3dsprites/setlayer/nflib/include/nf_basic.h
View File

@ -1,89 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_BASIC_H__
#define __NF_BASIC_H__
// NightFox LIB - Include de funciones basicas
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define la variable global NF_ROOTFOLDER
extern char NF_ROOTFOLDER[32];
// Funcion NF_Error();
void NF_Error(u16 code, const char* text, u32 value);
// Errores para debug. Detiene el sistema e informa del error
// 101: Fichero no encontrado
// 102: Memoria insuficiente
// 103: No quedan Slots libres
// 104: Fondo no encontrado
// 105: Fondo no creado
// 106: Fuera de rango
// 107: Insuficientes bloques contiguos en VRAM (Tiles)
// 108: Insuficientes bloques contiguos en VRAM (Maps)
// 109: Id ocupada (ya esta en uso)
// 110: Id no cargada (en RAM)
// 111: Id no en VRAM
// 112: Sprite no creado
// 113: Memoria VRAM insuficiente
// 114: La capa de Texto no existe
// 115: Medidas del fondo no compatibles (no son multiplos de 256)
// 116: Archivo demasiado grande
// 117: Medidas del fondo affine incorrectas
// 118: Capa de creacion del fondo affine incorrecta
// Funcion NF_SetRootFolder();
void NF_SetRootFolder(const char* folder);
// Define el nombre de la carpeta que se usara como "root" si se usa la FAT
// Funcion NF_DmaMemCopy();
void NF_DmaMemCopy(void* destination, const void* source, u32 size);
// Copia un bloque de memoria usando DMA (canal 3, halfwords) y vaciando previamente
// el cache. Con pruebas de bloques grandes (64kb o 128kb) he observado que memcpy();
// sigue siendo mas rapida.
// Funcion NF_GetLanguage();
extern u8 NF_GetLanguage(void);
// Devuelve el ID del idioma del usuario
// 0 : Japanese
// 1 : English
// 2 : French
// 3 : German
// 4 : Italian
// 5 : Spanish
// 6 : Chinese
#endif
#ifdef __cplusplus
}
#endif

234
examples/3dsprites/setlayer/nflib/include/nf_bitmapbg.h
View File

@ -1,234 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_BITMAPBG_H__
#define __NF_BITMAPBG_H__
// NightFox LIB - Include de funciones de fondos en modo Bitmap
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define los slots maximos para los fondos de 16 bits
#define NF_SLOTS_BG16B 16
// Define los slots maximos para los fondos de 8 bits
#define NF_SLOTS_BG8B 16
// Define los Buffers para almacenar datos de 16 bits
typedef struct {
u16* buffer; // Buffer de datos
u32 size; // Tamaño del buffer
u16 width; // Ancho de la imagen (256 max)
u16 height; // Altura de la imagen (256 max)
bool inuse; // Esta en uso el buffer?
} NF_TYPE_BG16B_INFO;
extern NF_TYPE_BG16B_INFO NF_BG16B[NF_SLOTS_BG16B]; // Fondos RAW de 16 bits
// BackBuffer de 16 bits de cada pantalla
extern u16* NF_16BITS_BACKBUFFER[2];
// Define los Buffers para almacenar datos de 8 bits
typedef struct {
u8* data; // Buffer de datos
u32 data_size; // Tamaño del buffer de datos
u16* pal; // Buffer para la paleta
u32 pal_size; // Tamaño de la paleta
bool inuse; // Esta en uso el buffer?
} NF_TYPE_BG8B_INFO;
extern NF_TYPE_BG8B_INFO NF_BG8B[NF_SLOTS_BG8B]; // Fondos indexados de 8 bits
// BackBuffer de 8 bits de cada pantalla
typedef struct {
u8* data;
u16* pal;
} NF_TYPE_BB8B_INFO;
extern NF_TYPE_BB8B_INFO NF_8BITS_BACKBUFFER[2];
// Funcion NF_Init16bitsBgBuffers();
void NF_Init16bitsBgBuffers(void);
// Inicia los buffers para almacenar fondos de BITMAP 16 bits
// Usalo UNA SOLA VEZ antes de usar los buffers
// Funcion NF_Reset16bitsBgBuffers();
void NF_Reset16bitsBgBuffers(void);
// Reinicia los buffers para almacenar fondos de BITMAP 16 bits,
// borrado su contenido
// Funcion NF_Init16bitsBackBuffer();
void NF_Init16bitsBackBuffer(u8 screen);
// Inicia el backbuffer de la pantalla dada.
// Usalo UNA SOLA VEZ antes de usar el backbuffer
// Funcion NF_Enable16bitsBackBuffer();
void NF_Enable16bitsBackBuffer(u8 screen);
// Habilita el backbuffer de la pantalla indicada.
// Si el buffer ya existe, la funcion borrara el contenido del mismo,
// poniendo a 0 todos los bytes del buffer.
// Funcion NF_Disble16bitsBackBuffer();
void NF_Disble16bitsBackBuffer(u8 screen);
// Deshabilita el backbuffer de la pantalla indicada, liberando de la
// RAM el espacio usado.
// Funcion NF_Flip16bitsBackBuffer();
void NF_Flip16bitsBackBuffer(u8 screen);
// Copia el contenido del backbuffer a la VRAM de la pantalla indicada.
// Funcion NF_InitBitmapBgSys();
void NF_InitBitmapBgSys(u8 screen, u8 mode);
// Inicia el modo BITMAP en la pantalla especificada, con la profundidad de color
// especificada. (0 -> 256 colores, 1 -> 16 bits)
// Funcion NF_Load16bitsBg();
void NF_Load16bitsBg(const char* file, u8 slot);
// Carga un Fondo BITMAP (en formato RAW) en el slot indicado,
// de un tamaño maximo de 256x256 pixeles.
// Debes especificar el nombre de archivo sin extension.
// El archivo debe ser un binario con extension .img
// Funcion NF_Load16bitsImage();
void NF_Load16bitsImage(const char* file, u8 slot, u16 size_x, u16 size_y);
// Carga una imagen BITMAP (en formato RAW) en el slot indicado,
// de un tamaño maximo de 256x256 pixeles.
// Debes especificar el nombre de archivo sin extension.
// El archivo debe ser un binario con extension .img
// Todos los pixeles Magenta de la imagen (0xFF00FF) seran transparentes.
// Funcion NF_Load16bImgData();
void NF_Load16bImgData(const char* file, u8 slot, u16 x, u16 y, u8 type);
// Funcion de uso interno, no documentar ni usar.
// Cargador generico de datos de imagen de 16 bits a la RAM.
// Funcion NF_Unload16bitsBg();
void NF_Unload16bitsBg(u8 slot);
// Borra de la RAM los datos del buffer especificado
// Funcion NF_Copy16bitsBuffer();
void NF_Copy16bitsBuffer(u8 screen, u8 destination, u8 slot);
// Copia los datos cargados en un Buffer de Bitmap a la VRAM o al BackBuffer
// destination: 0 -> VRAM, 1 -> BackBuffer
// Funcion NF_Draw16bitsImage();
void NF_Draw16bitsImage(u8 screen, u8 slot, s16 x, s16 y, bool alpha);
// Copia la imagen cargada en un Buffer de Bitmap al Backbuffer de la pantalla especificada
// Funcion NF_Init8bitsBgBuffers();
void NF_Init8bitsBgBuffers(void);
// Inicializa los buffers necesarios para la carda de fondos en modo BITMAP de 8 bits.
// Debes usar esta funcion antes de poder usar ninguno de los buffers.
// Funcion NF_Reset8bitsBgBuffers();
void NF_Reset8bitsBgBuffers(void);
// Reinicia los buffers de fondos de 8 bits, borrando todo el contenido de los buffers.
// Funcion NF_Load8bitsBg();
void NF_Load8bitsBg(const char* file, u8 slot);
// Carga los archivos necesarios de un fondo de 8 bits en el Slot indicado.
// Debes especificar el nombre de archivo sin extension.
// El archivo debe ser un binario con extension .img
// La paleta debe tener la extension .pal
// Funcion NF_Unload8bitsBg();
void NF_Unload8bitsBg(u8 slot);
// Borra de la RAM el fondo del slot indicado.
// Funcion NF_Copy8bitsBuffer();
void NF_Copy8bitsBuffer(u8 screen, u8 destination, u8 slot);
// Transfiere la imagen del buffer seleccionado a la pantalla y capas indicado o
// al backbuffer.
// Funcion NF_Init8bitsBackBuffer();
void NF_Init8bitsBackBuffer(u8 screen);
// Inicializa los buffers del backbuffer para la pantalla indicada.
// Debes usar esta funcion una vez antes de usar el backbuffer
// Funcion NF_Enable8bitsBackBuffer();
void NF_Enable8bitsBackBuffer(u8 screen);
// Habilita el backbuffer de la pantalla indicada.
// Si el buffer ya existe, la funcion borrara el contenido del mismo,
// poniendo a 0 todos los bytes del buffer.
// Funcion NF_Disble8bitsBackBuffer();
void NF_Disble8bitsBackBuffer(u8 screen);
// Deshabilita el backbuffer de la pantalla indicada, liberando de la
// RAM el espacio usado.
// Funcion NF_Flip8bitsBackBuffer();
void NF_Flip8bitsBackBuffer(u8 screen, u8 destination);
// Copia el contenido del backbuffer a la VRAM de la pantalla indicada.
// Debes especificar la capa de destino:
// 0 -> Capa 2
// 1 -> Capa 3
#endif
#ifdef __cplusplus
}
#endif

110
examples/3dsprites/setlayer/nflib/include/nf_colision.h
View File

@ -1,110 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_COLISION_H__
#define __NF_COLISION_H__
// NightFox LIB - Include de Colisiones
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define los slots maximos para los mapas de colisiones
#define NF_SLOTS_CMAP 32
// Define la estructura de control de mapas de colisiones
typedef struct {
char* tiles; // Buffer para almacenar los tiles
char* map; // Buffer para almacenar el mapa
char* pal; // Buffer para almacenar la paleta
u32 tiles_size; // Tamaño de los archivos
u32 map_size;
u32 pal_size;
u16 width; // Ancho del mapa (en pixeles)
u16 height; // Alto del mapa (en pixeles)
bool inuse; // Esta en uso el slot?
} NF_TYPE_CMAP_INFO;
extern NF_TYPE_CMAP_INFO NF_CMAP[NF_SLOTS_CMAP]; // Datos de los mapas de colision
// Funcion NF_InitCmapBuffers();
void NF_InitCmapBuffers(void);
// Inicializa los buffers que almacenaran los mapas de colision
// Debes usar esta funcion una unica vez antes de cargar ningun mapa de colision
// Funcion NF_ResetCmapBuffers();
void NF_ResetCmapBuffers(void);
// Reinicia los buffers y variables de los mapas de colisiones.
// Funcion NF_LoadColisionMap();
void NF_LoadColisionMap(const char* file, u8 id, u16 width, u16 height);
// Carga un mapa de colisiones en el slot indicado.
// Funcion NF_UnloadColisionMap();
void NF_UnloadColisionMap(u8 id);
// Borra de la RAM el mapa de colisiones con el nº de slot indicado.
// Funcion NF_GetTile();
extern u16 NF_GetTile(u8 slot, s32 x, s32 y);
// Devuelve el numero de tile de la posicion especificada.
// Funcion NF_SetTile();
void NF_SetTile(u8 slot, s32 x, s32 y, u16 value);
// Cambia el valor del tile en la posicion especificada.
// Funcion NF_LoadColisionBg();
void NF_LoadColisionBg(const char* file, u8 id, u16 width, u16 height);
// Carga un fondo de colisiones para pixel perfect
// Funcion NF_UnloadColisionBg();
void NF_UnloadColisionBg(u8 id);
// Descarga un fondo de colisiones para pixel perfect
// Funcion NF_GetPoint();
extern u8 NF_GetPoint(u8 slot, s32 x, s32 y);
// Obten el color del pixel de las coordenadas dadas
#endif
#ifdef __cplusplus
}
#endif

79
examples/3dsprites/setlayer/nflib/include/nf_defines.h
View File

@ -1,79 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_DEFINES_H__
#define __NF_DEFINES_H__
// NightFox LIB - Definiciones General
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Definicion de los datos del usuario
// Informacion obtenida de PALIB source code
// Referencias usadas de http://nds.metawiki.com/Firmware
/*
FW offset* RAM address Bytes Description
0x000020 2 user settings offset / 8 (default 0x7FC0 => 0x3FE00)
0x00002A 2 CRC16 (with initial value 0) of 0x2C with config length
0x00002C 2 config length (0x138)
0x000036 6 MAC address
0x00003C 4 enabled channels
0x000065 1 ?
0x000082 1 ?
0x000100 1 ?
0x000146 14 ?
0x000162 1 ?
0x03Fx00 0x023FFC80 1 version (5)
0x03Fx02 0x027FFC82 1 favorite color (0-15)
0x03Fx03 0x027FFC83 1 birthday month (1-12)
0x03Fx04 0x027FFC84 1 birthday day (1-31)
0x03Fx06 0x027FFC86 20 name, UTF-16
0x03Fx1A 0x027FFC9A 1/2 length of name in characters
0x03Fx1C 0x027FFC9C 52 message, UTF-16
0x03Fx50 0x027FFCD0 1/2 length of message in characters
0x03Fx52 0x027FFCD2 1 alarm hour
0x03Fx53 0x027FFCD3 1 alarm minute
0x03Fx56 0x027FFCD6 1 0x80=enable alarm, bit 0..6=enable?
0x027FFCD8 12 touch-screen calibration
0x027FFCE4 bit 0..2 language
0x027FFCE4 bit 3 GBA mode screen selection. 0=upper, 1=lower
0x027FFCE4 bit 6 auto/manual mode. 0=manual, 1=auto
WIFI power calibration
0x03Fx70 1/2 update counter (used to check latest)
0x03Fx72 CRC16 of 0x03FF00, 0x70 bytes
*/
#define NF_UDATA_COLOR *(u8*)(0x027FFC82)
#define NF_UDATA_BDAY_MONTH *(u8*)(0x027FFC83)
#define NF_UDATA_BDAY_DAY *(u8*)(0x027FFC84)
#define NF_UDATA_ALARM_HOUR *(u8*)(0x027FFCD2)
#define NF_UDATA_ALARM_MINUTE *(u8*)(0x027FFCD3)
#define NF_UDATA_NAME *(u8*)(0x027FFC86)
#define NF_UDATA_NAME_SIZE *(u8*)(0x027FFC9A)
#define NF_UDATA_MSG *(u8*)(0x027FFC9C)
#define NF_UDATA_MSG_SIZE *(u8*)(0x027FFCD0)
#define NF_UDATA_LANG *(u8*)(0x027FFCE4)
#endif
#ifdef __cplusplus
}
#endif

114
examples/3dsprites/setlayer/nflib/include/nf_lib.h
View File

@ -1,114 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_LIB_H__
#define __NF_LIB_H__
// NightFox LIB - Include General
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
/*
Notas sobre BITSHIFT
(n >> x) Divide n / x
(n << x) Multiplica n * x
Valores de X
2 = 1
4 = 2
8 = 3
16 = 4
32 = 5
64 = 6
128 = 7
256 = 8
512 = 9
1024 = 10
2048 = 11
4096 = 12
8192 = 13
16384 = 14
32768 = 15
65536 = 16
Dado que la DS no tiene unidad de coma flotante, siempre que dividas o
multipliques por numeros de base 2, usa el bitshift
Por ejemplo:
a = (512 / 8);
seria equivalente a
a = (512 >> 3);
Multiplicando
b = (3 * 2048);
seria con bitshift
b = (3 << 11);
*/
// Definiciones comunes
#include "nf_defines.h"
// Libreria de funciones basicas y comunes
#include "nf_basic.h"
// Libreria de funciones 2D comunes
#include "nf_2d.h"
// Libreria de fondos con Tiles
#include "nf_tiledbg.h"
// Libreria de fondos Affine
#include "nf_affinebg.h"
// Libreria de fondos en modo Bitmap
#include "nf_bitmapbg.h"
// Libreria de fondos en modo mixto (Tiled / Bitmap 8 bits)
#include "nf_mixedbg.h"
// Libreria de sprites de 256 colores
#include "nf_sprite256.h"
// Libreria de textos
#include "nf_text.h"
// Libreria de textos de 16 pixeles
#include "nf_text16.h"
// Libreria de colisiones
#include "nf_colision.h"
// Libreria de sonido
#include "nf_sound.h"
// Libreria de archivos multimedia
#include "nf_media.h"
// Libreria 3D, funciones comunes
#include "nf_3d.h"
// Libreria 3D, Sprites
#include "nf_sprite3d.h"
#endif
#ifdef __cplusplus
}
#endif

41
examples/3dsprites/setlayer/nflib/include/nf_media.h
View File

@ -1,41 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_MEDIA_H__
#define __NF_MEDIA_H__
// NightFox LIB - Include de funciones de carga de archivos multimedia
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Funcion NF_LoadBMP();
void NF_LoadBMP(const char* file, u8 slot);
// Carga un archivo BMP de 8, 16 o 24 bits en un slot de imagenes de 16 bits.
// Debes inicializar el modo 16 bits, el backbuffer y usar la funcion NF_Draw16bitsImage();
// para mostrarlo.
#endif
#ifdef __cplusplus
}
#endif

41
examples/3dsprites/setlayer/nflib/include/nf_mixedbg.h
View File

@ -1,41 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_MIXEDBG_H__
#define __NF_MIXEDBG_H__
// NightFox LIB - Include de Fondos mixtos (Tiled / Bitmap 8 bits)
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Funcion NF_InitMixedBgSys();
void NF_InitMixedBgSys(u8 screen);
// Inicializa el modo mixto para fondo (Tiled BG + Bitmap 8 bits)
// Capas 0 a 2 - Tiled
// Capa 3 - Bitmap 8 bits
#endif
#ifdef __cplusplus
}
#endif

96
examples/3dsprites/setlayer/nflib/include/nf_sound.h
View File

@ -1,96 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_SOUND_H__
#define __NF_SOUND_H__
// NightFox LIB - Include de funciones de sonido
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define los Slots para archivos de audio
#define NF_SLOTS_RAWSOUND 32
// Define los Buffers para almacenar los archivos de audio
extern char* NF_BUFFER_RAWSOUND[NF_SLOTS_RAWSOUND];
// Define la estructura de datos de los buffers (Audio)
typedef struct {
bool available; // Disponibilidat del Slot
u32 size; // Tamaño (en bytes) del sonido
u16 freq; // Frecuencia del sample
u8 format; // Formato del sample
} NF_TYPE_RAWSOUND_INFO;
extern NF_TYPE_RAWSOUND_INFO NF_RAWSOUND[NF_SLOTS_RAWSOUND]; // Datos de los sonidos cargado
// Funcion NF_InitRawSoundBuffers();
void NF_InitRawSoundBuffers(void);
// Iniciliaza los buffers y estructuras de datos para cargar sonidos en
// formato RAW. Debes de ejecutar esta funcion una vez antes de cargar
// ningun sonido en este formato
// Funcion NF_ResetRawSoundBuffers();
void NF_ResetRawSoundBuffers(void);
// Reinicia todos los buffers de sonido. Esta funcion es util para vaciar todos los datos
// en un cambio de pantalla, etc.
// Funcion NF_LoadRawSound();
void NF_LoadRawSound(const char* file, u16 id, u16 freq, u8 format);
// Carga un archivo RAW a la RAM desde la FAT o EFS
// Debes especificar el nombre del archivo sin extension, el slot
// donde lo guardaras (0 - 31), la frecuencia del sample (en Hz,
// por ejemplo 11050) y el formato de datos
// (0 - > 8 bits, 1 - > 16 bits, 2 -> ADPCM)
// Funcion UnloadRawSound();
void NF_UnloadRawSound(u8 id);
// Borra de la RAM el archivo cargado en el slot indicado.
// Debes especificar el slot a borrar (0 - 31)
// Funcion NF_PlayRawSound();
extern u8 NF_PlayRawSound(u8 id, u8 volume, u8 pan, bool loop, u16 loopfrom);
// Reproduce un archivo de sonido cargado en RAM.
// Debes especificar el slot donde se ha cargado el sonido, el volumen (0 - 127),
// el balance (0 Izquierda, 64 Centro, 127 Derecha), si se reproducira en bucle y
// de ser asi, a partir de que sample se producira este.
// Esta funcion devuelve el canal asignado a esta reproduccion
#endif
#ifdef __cplusplus
}
#endif

265
examples/3dsprites/setlayer/nflib/include/nf_sprite256.h
View File

@ -1,265 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_SPRITE256_H__
#define __NF_SPRITE256_H__
// NightFox LIB - Include de Sprites a 256 colores
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define los Slots para sprites
#define NF_SLOTS_SPR256GFX 256 // Almacena los graficos
#define NF_SLOTS_SPR256PAL 64 // Almacena las paletas
// Define los Buffers para almacenar los Sprites
extern char* NF_BUFFER_SPR256GFX[NF_SLOTS_SPR256GFX];
extern char* NF_BUFFER_SPR256PAL[NF_SLOTS_SPR256PAL];
// Define la estructura de datos de los buffers (GFX)
typedef struct {
u32 size; // Tamaño (en bytes) del grafico (GFX)
u16 width; // Ancho del Gfx
u16 height; // Altura del Gfx
bool available; // Disponibilidat del Slot
} NF_TYPE_SPR256GFX_INFO;
extern NF_TYPE_SPR256GFX_INFO NF_SPR256GFX[NF_SLOTS_SPR256GFX]; // Buffers de Graficos
// Define la estructura de datos de los buffers (PAL)
typedef struct {
u32 size; // Tamaño (en bytes) de la paleta (PAL)
bool available; // Disponibilidat del Slot
} NF_TYPE_SPR256PAL_INFO;
extern NF_TYPE_SPR256PAL_INFO NF_SPR256PAL[NF_SLOTS_SPR256PAL]; // Buffers de Paletas
// Define la estructura de Gfx en VRAM
typedef struct {
u32 size; // Tamaño (en bytes) del Gfx
u16 width; // Ancho del Gfx
u16 height; // Altura del Gfx
u32 address; // Posicion en la VRAM
u16 ramid; // Numero de Slot en RAM del que provienes
u16 framesize; // Tamaño del frame (en bytes)
u16 lastframe; // Ultimo frame
bool keepframes; // Si es un Sprite animado, debes de mantener los frames en RAM ?
bool inuse; // Disponibilidat del Slot
} NF_TYPE_SPR256VRAM_INFO;
extern NF_TYPE_SPR256VRAM_INFO NF_SPR256VRAM[2][128];
// Datos de paletas de Sprites en VRAM (en uso, slot en ram, etc)
typedef struct {
bool inuse; // Slot en uso
u8 ramslot; // Paleta original en RAM
} NF_TYPE_SPRPALSLOT_INFO;
extern NF_TYPE_SPRPALSLOT_INFO NF_SPRPALSLOT[2][16];
// Define la estructura de datos del OAM (Sprites)
typedef struct {
u8 index; // Numero de Sprite
s16 x; // Coordenada X del Sprite
s16 y; // Coordenada Y del Sprite
u8 layer; // Prioridad en las capas
u8 pal; // Paleta que usaras
u32 size; // Tamaño del Sprite (macro)
u32 color; // Modo de color (macro)
u32* gfx; // Puntero al grafico usado
s8 rot; // Id de rotacion (-1 ninguno) (0 - 31 Id de rotacion)
bool doublesize; // Usar el "double size" al rotar ?
bool hide; // Ocultar el Sprite
bool vflip; // Volteado Vertical
bool hflip; // Volteado Horizontal
bool mosaic; // Mosaico
u16 gfxid; // Id de Gfx usado
u16 frame; // Frame actual
u16 framesize; // Tamaño del frame (en bytes)
u16 lastframe; // Ultimo frame
bool created; // Esta creado este sprite ?
} NF_TYPE_SPRITEOAM_INFO;
extern NF_TYPE_SPRITEOAM_INFO NF_SPRITEOAM[2][128]; // 2 pantallas, 128 sprites
// Define la esturctura de control de la VRAM para Sprites
typedef struct {
s32 free; // Memoria VRAM libre
u32 next; // Siguiente posicion libre
u32 last; // Ultima posicion usada
u32 pos[128]; // Posicion en VRAM para reusar despues de un borrado
u32 size[128]; // Tamaño del bloque libre para reusar
u16 deleted; // Numero de bloques borrados
s32 fragmented; // Memoria VRAM fragmentada
s32 inarow; // Memoria VRAM contigua
s32 max; // Maxima memoria VRAM direccionable
} NF_TYPE_SPRVRAM_INFO;
extern NF_TYPE_SPRVRAM_INFO NF_SPRVRAM[2]; // Informacion VRAM de Sprites en ambas pantallas
// Funcion NF_InitSpriteBuffers()
void NF_InitSpriteBuffers(void);
// Inicializa los buffers y estructuras de datos de los Buffers para almacenar Sprites
// Usala antes de cargar cualquier Sprites
// No uses esta funcion mas de una vez en tu codigo
// Funcion NF_ResetSpriteBuffers()
void NF_ResetSpriteBuffers(void);
// Reinicia los buffers y datos para almacenar Sprites
// Funcion NF_InitSpriteSys();
void NF_InitSpriteSys(int screen, ...);
// Inicializa las variables de control de Sprites y paletas
// Asigna 128kb de RAM para Sprites
// Activa el Soporte para Sprites
// Se debe especificar la pantalla (0 o 1)
// Funcion NF_LoadSpriteGfx();
void NF_LoadSpriteGfx(const char* file, u16 id, u16 width, u16 height);
// Carga un grafico para usarlo despues en la creacion de Sprites
// Especifica el archivo, ID exclusivo (0 - 255) y medidas del grafico
// Funcion NF_UnloadSpriteGfx();
void NF_UnloadSpriteGfx(u16 id);
// Borra de la RAM un Gfx cargado previamente con NF_LoadSpriteGfx();
// Especifica la Id exclusiva (0 - 255) de grafico a borrar.
// Funcion NF_LoadSpritePal();
void NF_LoadSpritePal(const char* file, u8 id);
// Carga una paleta para usarla despues en la creacion de Sprites
// Especifica el archivo y ID exclusivo (0 - 63)
// Funcion NF_UnloadSpritePal();
void NF_UnloadSpritePal(u8 id);
// Borra de la RAM una Paleta cargada previamente con NF_LoadSpritePal();
// Especifica la Id exclusiva (0 - 63) de la paleta a borrar.
// Funcion NF_VramSpriteGfx();
void NF_VramSpriteGfx(u8 screen, u16 ram, u16 vram, bool keepframes);
// Transfiere un Grafico cargado para Sprites a la VRAM
// Debes especificar la pantalla, el Id del Grafico en RAM (origen),
// la Id del grafico en VRAM (destino) y si, en caso de estar animado,
// debe de copiar a la VRAM todos los frames o solo el que este en uso
// Funcion NF_FreeSpriteGfx();
void NF_FreeSpriteGfx(u8 screen, u16 id);
// Borra de la VRAM el Grafico con la Id. especificada.
// Cualquier Sprite que este usando ese Gfx, quedara corrupto.
// Funcion NF_VramSpriteGfxDefrag();
void NF_VramSpriteGfxDefrag(u8 screen);
// Desfragmenta la VRAM de Sprites (Gfx) de la pantalla dada
// Esta se realiza automaticamente al borrar un Gfx de la VRAM
// si la memoria fragmentada es superior a la contigua libre.
// Puedes consultar estos valores con las siguientes variables
// NF_SPRVRAM[u8 screen].free <- Memoria VRAM de Sprites libre
// NF_SPRVRAM[u8 screen].fragmented <- Memoria VRAM de sprites libre fragmentada
// NF_SPRVRAM[u8 screen].inarow <- Memoria VRAM de sprites libre, ultimo bloque mas grande
// NF_SPRVRAM[u8 screen].lost <- Memoria VRAM libre no usable por fragmentacion
// Funcion NF_VramSpritePal();
void NF_VramSpritePal(u8 screen, u8 id, u8 slot);
// Transfiere una Paleta cargada para Sprites a la VRAM
// Debes especificar la pantalla, la Id de la Paleta a trasnferir
// y el slot de destino (0 - 15)
// Funcion NF_CreateSprite();
void NF_CreateSprite(u8 screen, u8 id, u16 gfx, u8 pal, s16 x, s16 y);
// Crea un sprite en la pantalla.
// Debes especificar la pantalla, la ID del Sprite (0 - 127),
// la ID del Grafico que usaras (0 - 255), el slot de paleta (0 - 15),
// y las coordenadas donde lo crearas.
// Funcion NF_DeleteSprite();
void NF_DeleteSprite(u8 screen, u8 id);
// Borra un sprite de la pantalla
// Debes especificar la pantalla y la Id del Sprite a borrar
// Funcion NF_SpriteOamSet();
void NF_SpriteOamSet(u8 screen);
// Copia los datos del array propio de OAM al OAM real
// Debes especificar la pantalla
// Funcion NF_SpriteSetPalColor();
void NF_SpriteSetPalColor(u8 screen, u8 pal, u8 number, u8 r, u8 g, u8 b);
// Cambia el valor de un color de la paleta de sprites especificada.
// Debes especificar la pantalla, slot de la paleta en VRAM, numero de color
// a cambiar dentro de la paleta y el nuevo valor a darle en formato RGB
// Funcion NF_SpriteEditPalColor();
void NF_SpriteEditPalColor(u8 screen, u8 pal, u8 number, u8 r, u8 g, u8 b);
// Modifica los valores de la paleta seleccionada. Las modificaciones se efectuan
// sobre la copia en RAM, por lo que los cambios no seran visibles hasta que se
// transfiera la paleta a la VRAM
// Funcion NF_SpriteUpdatePalette();
void NF_SpriteUpdatePalette(u8 screen, u8 pal);
// Actualiza la paleta en VRAM con la copia que se encuentra en la RAM
// Funcion NF_SpriteGetPalColor();
void NF_SpriteGetPalColor(u8 screen, u8 pal, u8 number, u8* r, u8* g, u8* b);
// Obtiene el valor de un color de la paleta que se encuentra en la RAM
#endif
#ifdef __cplusplus
}
#endif

243
examples/3dsprites/setlayer/nflib/include/nf_sprite3d.h
View File

@ -1,243 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_SPRITE3D_H__
#define __NF_SPRITE3D_H__
// NightFox LIB - Include de funciones 3D
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
//////////////////////////////////
// Defines y variables globales //
//////////////////////////////////
// Numero maximo de sprites en pantalla
#define NF_3DSPRITES 256
// Estructura de control de los sprites 3d
typedef struct {
s16 x; // Coordenada X
s16 y; // Coordenada Y
s16 z; // Coordenada Z
s16 rx; // Rotacion Eje X (-512/0/512) << 6
s16 ry; // Rotacion Eje Y (-512/0/512) << 6
s16 rz; // Rotacion Eje Z (-512/0/512) << 6
bool rot; // Rotacion en uso
u16 sx; // Escala X (0/64/512) << 6
u16 sy; // Escala Y (0/64/512) << 6
bool scale; // Escalado en uso
s16 width; // Ancho del sprite
s16 height; // Alto del sprite
bool inuse; // Esta en uso?
bool show; // Debe mostrarse el sprite?
u32 gfx_tex_format; // Guarda el formato de la textura
u32 gfx; // Direccion donde esta almacenado el grafico en VRAM
u16 gfxid; // Id de Gfx usado
u16 frame; // Frame actual
u16 newframe; // Frame al que cambiar
u16 framesize; // Tamaño del frame (en bytes)
u16 lastframe; // Ultimo frame
u32 gfx_pal_format; // Guarda el formato de la paleta
u32 pal; // Direccion donde esta almacenada la paleta en VRAM
u16 palid; // Id de la paleta usada
u16 prio; // Prioridad de dibujado del sprite
u8 poly_id; // Identificador unico para el Alpha (0 por defecto, 63 prohibido)
u8 alpha; // Nivel de alpha (0 - 31) (31 por defecto)
} NF_TYPE_3DSPRITE_INFO;
extern NF_TYPE_3DSPRITE_INFO NF_3DSPRITE[NF_3DSPRITES];
// Estructura de control Texturas en VRAM
typedef struct {
u32 size; // Tamaño (en bytes) del Gfx
u16 width; // Ancho del Gfx
u16 height; // Altura del Gfx
u32 address; // Posicion en la VRAM
u16 ramid; // Numero de Slot en RAM del que provienes
u16 framesize; // Tamaño del frame (en bytes)
u16 lastframe; // Ultimo frame
bool keepframes; // Si es un Sprite animado, debes de mantener los frames en RAM ?
bool inuse; // Disponibilidat del Slot
} NF_TYPE_TEX256VRAM_INFO;
extern NF_TYPE_TEX256VRAM_INFO NF_TEX256VRAM[NF_3DSPRITES];
// Estructura de control de las paletas en VRAM
typedef struct {
bool inuse; // Slot en uso
u8 ramslot; // Paleta original en RAM
} NF_TYPE_3DSPRPALSLOT_INFO;
extern NF_TYPE_3DSPRPALSLOT_INFO NF_TEXPALSLOT[32];
// Define la esturctura de control de la VRAM para Sprites 3d
typedef struct {
s32 free; // Memoria VRAM libre
u32 next; // Siguiente posicion libre
u32 last; // Ultima posicion usada
u32 pos[NF_3DSPRITES]; // Posicion en VRAM para reusar despues de un borrado
u32 size[NF_3DSPRITES]; // Tamaño del bloque libre para reusar
u16 deleted; // Numero de bloques borrados
s32 fragmented; // Memoria VRAM fragmentada
s32 inarow; // Memoria VRAM contigua
} NF_TYPE_TEXVRAM_INFO;
extern NF_TYPE_TEXVRAM_INFO NF_TEXVRAM; // Informacion VRAM de texturas
// Define la estructura de control de los sprites 3d creados
typedef struct {
s16 total; // Numero de sprites creados
u16 id[NF_3DSPRITES]; // ID del Sprite
u16 bck[NF_3DSPRITES]; // Backup del ID
} NF_TYPE_CREATED_3DSPRITE_INFO;
extern NF_TYPE_CREATED_3DSPRITE_INFO NF_CREATED_3DSPRITE;
// Funcion NF_Init3dSpriteSys();
void NF_Init3dSpriteSys(void);
// Inicializa el sistema de Sprites en 3D
// Funcion NF_Vram3dSpriteGfx();
void NF_Vram3dSpriteGfx(u16 ram, u16 vram, bool keepframes);
// Transfiere un grafico de la RAM a la VRAM
// Funcion NF_Free3dSpriteGfx();
void NF_Free3dSpriteGfx(u16 id);
// Elimina de la VRAM un grafico de texturas y desfragmenta la VRAM si es necesario
// Funcion NF_Vram3dSpriteGfxDefrag();
void NF_Vram3dSpriteGfxDefrag(void);
// Desfragmenta la VRAM usada para texturas
// Funcion NF_Vram3dSpritePal();
void NF_Vram3dSpritePal(u8 id, u8 slot);
// Copia una paleta a la VRAM
// Funcion NF_Create3dSprite();
void NF_Create3dSprite(u16 id, u16 gfx, u16 pal, s16 x, s16 y);
// Crea un Sprite 3D en las coordenadas indicadas
// Funcion NF_Delete3dSprite();
void NF_Delete3dSprite(u16 id);
// Borra el Sprite con la ID indicada
// Funcion NF_Sort3dSprites();
void NF_Sort3dSprites(void);
// Reordena la cola de Sprites 3D creados de menor a mayor segun su ID
// Los Sprites con numeros mas bajos tienen prioridad.
// Funcion NF_Set3dSpritePriority();
void NF_Set3dSpritePriority(u16 id, u16 prio);
// Cambia la prioridad del Sprite
// Funcion NF_Swap3dSpritePriority();
void NF_Swap3dSpritePriority(u16 id_a, u16 id_b);
// Intercambia la prioridad de dos Sprites
// Funcion NF_Move3dSprite();
void NF_Move3dSprite(u16 id, s16 x, s16 y);
// Mueve el Sprite seleccionado a las coordenadas dadas
// Funcion NF_Show3dSprite();
void NF_Show3dSprite(u16 id, bool show);
// Muestra u oculta el sprite con la id indicada
// Funcion NF_Set3dSpriteFrame();
void NF_Set3dSpriteFrame(u16 id, u16 frame);
// Cambia el frame visible del sprite indicado
// Funcion NF_Draw3dSprites();
void NF_Draw3dSprites(void);
// Dibuja en pantalla todos los sprites creados
// Funcion NF_Update3dSpritesGfx();
void NF_Update3dSpritesGfx(void);
// Actualiza si es necesario las texturas de los sprites animados
// Funcion NF_Rotate3dSprite();
void NF_Rotate3dSprite(u16 id, s16 x, s16 y, s16 z);
// Rota el Sprite sobre los ejes indicados (-512/0/512)
// Funcion NF_Scale3dSprite();
void NF_Scale3dSprite(u16 id, u16 x, u16 y);
// Escala el sprite al tamaño indicado (0/64/512)
// Funcion NF_Blend3dSprite();
void NF_Blend3dSprite(u8 sprite, u8 poly_id, u8 alpha);
// Habilita y cambia el nivel de alpha de el sprite 3d indicado. Para que la transparencia
// sea efectiva entre Sprites, debes especificar un poly_id diferente para cada sprite
// (entre 1 y 62). El rango de alpha es de 0 a 31, siendo 31 opaco. Para eliminar la
// transparencia, selecciona un valor para alpha de 31 o especifica como poly_id el nº 0.
// Funcion NF_3dSpritesLayer();
void NF_3dSpritesLayer(u8 layer);
// Selecciona la capa en la que se dibujaran los Sprites 3D. (0 - 3)
// En realidad los Sprites 3D siempre se dibujan sobre la CAPA 0, esta funcion solo cambia
// la prioridad de esta capa sobre las demas.
// Funcion NF_3dSpriteEditPalColor();
void NF_3dSpriteEditPalColor(u8 pal, u8 number, u8 r, u8 g, u8 b);
// Modifica los valores de la paleta seleccionada. Las modificaciones se efectuan
// sobre la copia en RAM, por lo que los cambios no seran visibles hasta que se
// transfiera la paleta a la VRAM
// Funcion NF_3dSpriteUpdatePalette();
void NF_3dSpriteUpdatePalette(u8 pal);
// Actualiza la paleta en VRAM con la copia que se encuentra en la RAM
// Funcion NF_3dSpriteGetPalColor();
void NF_3dSpriteGetPalColor(u8 pal, u8 number, u8* r, u8* g, u8* b);
// Obtiene el valor de un color de la paleta que se encuentra en la RAM
// Funcion NF_3dSpriteSetDeep();
void NF_3dSpriteSetDeep(u8 id, s16 z);
// Cambia la profuncidad de dibujado (z) del sprite (-512/0/512),
// siendo -512 el punto mas cercano, 0 el centro por defecto
// y 512 el punto mas lejano.
#endif
#ifdef __cplusplus
}
#endif

124
examples/3dsprites/setlayer/nflib/include/nf_text.h
View File

@ -1,124 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_TEXT_H__
#define __NF_TEXT_H__
// NightFox LIB - Include de Textos
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define el nº de caracteres que tiene la fuente
#define NF_TEXT_FONT_CHARS 127
#define NF_TEXT_FONT_LAST_VALID_CHAR 113
// Define la estructura de control de textos
typedef struct {
u16 width; // Ultimo tile de la fila (0 - x) 32 tiles serian 0 - 31
u16 height; // Ultimo tile de la columna (0 - y)
u8 rotation; // Rotacion del texto
u8 slot; // Slot donde esta cargado el tileset de esta capa de texto
u8 pal; // Paleta que usara el texto (0 por defecto)
bool exist; // Existe la capa de texto?
bool update; // Tienes que actualizar la capa?
} NF_TYPE_TEXT_INFO;
extern NF_TYPE_TEXT_INFO NF_TEXT[2][4]; // Datos de las capas de texto
// Funcion NF_InitTextSys();
void NF_InitTextSys(u8 screen);
// Inicializa el sistema de Texto para la pantalla dada
// Funcion NF_LoadTextFont();
void NF_LoadTextFont(const char* file, const char* name, u16 width, u16 height, u8 rotation);
// Carga una fuente para usar como texto
// La fuente se cargara en un slot libre de fondos tileados
// Debes especificar el archivos sin extension y un nombre para referenciarla
// En caso de que la fuente tenga los sets de rotacion a izquierda y derecha,
// especificar 1 o 2 en el parametro "rot". 0 carga la fuente sin rotacion
// Funcion NF_UnloadTextFont();
void NF_UnloadTextFont(const char* name);
// Borra un fuente cargada en RAM
// Esta funcion simplemente llama a NF_UnloadTiledBg(); para su borrado
// Funcion NF_CreateTextLayer();
void NF_CreateTextLayer(u8 screen, u8 layer, u8 rotation, const char* name);
// Crea un fondo tileado para usarlo con texto
// Esta funcion simplemente llama a NF_CreateTiledBg(); para su creacion
// Funcion NF_DeleteTextLayer();
void NF_DeleteTextLayer(u8 screen, u8 layer);
// Borra un fondo usado como capa de texto y sus buffers y variables asociadas
// Funcion NF_WriteText();
void NF_WriteText(u8 screen, u8 layer, u16 x, u16 y, const char* text);
// Escribe un texto en el buffer de texto de la pantalla y capa seleccionada
// Funcion NF_UpdateTextLayers();
void NF_UpdateTextLayers(void);
// Copia el buffer de texto a la VRAM en las capas que sea necesario
// realizar una actualizacion
// Funcion NF_ClearTextLayer();
void NF_ClearTextLayer(u8 screen, u8 layer);
// Borra el contanido de la capa de texto seleccionada
// Funcion NF_DefineTextColor();
void NF_DefineTextColor(u8 screen, u8 layer, u8 color, u8 r, u8 g, u8 b);
// Define uno de los 16 colores disponibles para texto, en formato RGB
// Function NF_SetTextColor();
void NF_SetTextColor(u8 screen, u8 layer, u8 color);
// Selecciona con que color definido se escribira el texto (no cambia el color del texto ya escrito)
#endif
#ifdef __cplusplus
}
#endif

64
examples/3dsprites/setlayer/nflib/include/nf_text16.h
View File

@ -1,64 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_TEXT16_H__
#define __NF_TEXT16_H__
// NightFox LIB - Include de Textos de 16 pixels
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define el nº de caracteres que tiene la fuente
#define NF_TEXT_FONT_CHARS_16 127
#define NF_TEXT_FONT_LAST_VALID_CHAR_16 113
// Funcion NF_LoadTextFont16();
void NF_LoadTextFont16(const char* file, const char* name, u16 width, u16 height, u8 rotation);
// Carga una fuente para texto de 16 pixeles de altura
// Funcion NF_CreateTextLayer16();
void NF_CreateTextLayer16(u8 screen, u8 layer, u8 rotation, const char* name);
// Crea una capa de texto para fuentes de 16 pixeles
// Funcion NF_WriteText16();
void NF_WriteText16(u8 screen, u8 layer, u16 x, u16 y, const char* text);
// Escribe un texto en la capa y pantalla especificados
// Funcion NF_ClearTextLayer16();
void NF_ClearTextLayer16(u8 screen, u8 layer);
// Limpia la capa de texto especificada
#endif
#ifdef __cplusplus
}
#endif

320
examples/3dsprites/setlayer/nflib/include/nf_tiledbg.h
View File

@ -1,320 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __NF_TILEDBG_H__
#define __NF_TILEDBG_H__
// NightFox LIB - Include de Fondos con tiles
// Requiere DevkitARM
// Codigo por Cesar Rincon "NightFox"
// http://www.nightfoxandco.com/
// Version 20140413
// Includes devKitPro
#include <nds.h>
// Define los slots maximos para los fondos
#define NF_SLOTS_TBG 64 // Datos de los fondos
#define NF_SLOTS_EXBGPAL 128 // Paletas extendidas (maximo 16 paletas por fondo)
// Define el numero maximo de bancos para tiles y mapas
#define NF_MAX_BANKS_TILES 8
#define NF_MAX_BANKS_MAPS 16
// Define el numero de bancos de Mapas y Tiles
extern u8 NF_BANKS_TILES[2]; // (1 banks = 16kb) Cada banco de tiles puede alvergar 8 bancos de Mapas
extern u8 NF_BANKS_MAPS[2]; // (1 bank = 2kb) Usar multiplos de 8. Cada set de 8 bancos consume 1 banco de tiles
// Define los Buffers para almacenar los fondos
extern char* NF_BUFFER_BGTILES[NF_SLOTS_TBG];
extern char* NF_BUFFER_BGMAP[NF_SLOTS_TBG];
extern char* NF_BUFFER_BGPAL[NF_SLOTS_TBG];
// Define estructura para almacenar la info de los fondos
typedef struct {
char name[32]; // Nombre del fondo
u32 tilesize; // Tamaño del Tileset
u32 mapsize; // Tamaño del Map
u32 palsize; // Tamaño de la Paleta
u16 width; // Ancho del fondo
u16 height; // Altura del fondo
bool available; // Disponibilidat del Slot
} NF_TYPE_TBG_INFO;
extern NF_TYPE_TBG_INFO NF_TILEDBG[NF_SLOTS_TBG]; // Datos de los fondos
// Define la estructura para almacenar la info y datos de las paletas extendidas
typedef struct {
char* buffer; // Buffer para almacenar la paleta
u32 palsize; // Tamaño de la paleta
bool inuse; // Slot libre o en uso
} NF_TYPE_EXBGPAL_INFO;
extern NF_TYPE_EXBGPAL_INFO NF_EXBGPAL[NF_SLOTS_EXBGPAL]; // Datos de las paletas extendidas
// Define estructura para almacenar la info de los fondos en pantalla
typedef struct {
u8 tilebase; // Bloque de inicio en VRAM del Tileset
u8 tileblocks; // Bloques usados por el Tileset
u8 mapbase; // Bloque de inicio en VRAM del Map
u8 mapblocks; // Bloques usados por el Map
u16 bgwidth; // Ancho del fondo
u16 bgheight; // Altura del fondo
u16 mapwidth; // Ancho del mapa
u16 mapheight; // Altura del mapa
u8 bgtype; // Tipo de mapa
u8 bgslot; // Buffer de graficos usado (NF_BUFFER_BGMAP)
u8 blockx; // Bloque de mapa (horizontal)
u8 blocky; // bloque de mapa (vertical)
bool created; // Flag de si esta creado
} NF_TYPE_TBGLAYERS_INFO;
// El hardware de la DS no permite mapas mayores de 512x512
// Asi que informaremos si nuestor mapa lo gestionara el hardware si es menor o
// igual a 512x512, o usaremos nuestro motor de Tile Swaping
// bgtype 0: Normal (maximo 512 x 512)
// bgtype 1: >512 x 256
// bgtype 2: 256 x >512
// bgtype 3: >512 x >512
extern NF_TYPE_TBGLAYERS_INFO NF_TILEDBG_LAYERS[2][4]; //[screen][layer]
// Define el array de bloques libres
extern u8 NF_TILEBLOCKS[2][NF_MAX_BANKS_TILES];
extern u8 NF_MAPBLOCKS[2][NF_MAX_BANKS_MAPS];
// Funcion NF_InitTiledBgBuffers();
void NF_InitTiledBgBuffers(void);
// Inicializa los buffers y estructuras de control para usar los fondos "tileados"
// Se debe usar antes de cargar o usar cualquier fondo
// No uses esta funcion mas de una vez en tu codigo
// Funcion NF_ResetTiledBgBuffers();
void NF_ResetTiledBgBuffers(void);
// Borra todos los buffers y reinicia las estructuras de fondos "tileados"
// Usala para los cambios de nivel y similares
// Funcion NF_InitTiledBgSys();
void NF_InitTiledBgSys(u8 screen);
// Inicializa las variables de control de tiles, mapas y paletas
// Asigna 128kb de RAM para fondos tileados
// Se debe especificar la pantalla (0 o 1)
// Funcion NF_LoadTiledBg();
void NF_LoadTiledBg(const char* file, const char* name, u16 width, u16 height);
// Carga un fondo tileado desde FAT
// Debes de especificar el archivo que se cargara (sin extension) y el nombre
// que le quieres dar y las medidas en pixeles
// Funcion NF_LoadTilesForBg();
void NF_LoadTilesForBg(const char* file, const char* name, u16 width, u16 height, u16 tile_start, u16 tile_end);
// Carga desde la FAT los tiles especificados y su paleta
// Ademas, crea un mapa vacio de la medida especificada
// Esta funcion es util para cargar varios tiles y despues generar fondos
// modificando el MAP desde cogido (Generador de escenarios, animaciones, etc)
// Funcion NF_UnloadTiledBg();
void NF_UnloadTiledBg(const char* name);
// Borra de la RAM un fondo cargado con NF_LoadTiledBg();
// Debes especificar el nombre que le diste al fondo
// Funcion NF_CreateTiledBg();
void NF_CreateTiledBg(u8 screen, u8 layer, const char* name);
// Crea un fondo con los parametros dados, indicale la pantalla, capa y nombre
// Funcion NF_DeleteTiledBg();
void NF_DeleteTiledBg(u8 screen, u8 layer);
// Borra un fondo de la memoria VRAM
// Debes especificar la pantalla y numero de capa
// Funcion NF_GetTileMapAddress();
extern u32 NF_GetTileMapAddress(u8 screen, u8 layer, u16 tile_x, u16 tile_y);
// Funcion de uso interno de la libreria
// Devuelve la direccion en el buffer de un tile concreto
// Funcion NF_GetTileOfMap();
extern u16 NF_GetTileOfMap(u8 screen, u8 layer, u16 tile_x, u16 tile_y);
// Obten el valor del tile del mapa indicado en las coordenadas (en tiles) indicadas.
// Funcion NF_SetTileOfMap();
void NF_SetTileOfMap(u8 screen, u8 layer, u16 tile_x, u16 tile_y, u16 tile);
// Cambia el valor del tile del mapa indicado en las coordenadas (en tiles) indicadas.
// Funcion NF_UpdateVramMap();
void NF_UpdateVramMap(u8 screen, u8 layer);
// Actualiza en VRAM el contenido del mapa seleccionado.
// Funcion NF_BgSetPalColor();
void NF_BgSetPalColor(u8 screen, u8 layer, u8 number, u8 r, u8 g, u8 b);
// Cambia al momento el valor de un color de la paleta
// Cuidado! Funcion Muy lenta, usar solo para 2 o 3 colores por ciclo
// Cambia el color directamente en la VRAM
// Funcion NF_BgEditPalColor();
void NF_BgEditPalColor(u8 screen, u8 layer, u8 number, u8 r, u8 g, u8 b);
// Edita un color de la paleta seleccionada.
// El color se edita en el buffer de RAM, para que sea efectivo,
// mandala a la VRAM con NF_UpdatePalette();
// Funcion NF_BgUpdatePalette();
void NF_BgUpdatePalette(u8 screen, u8 layer);
// Actualiza la paleta en VRAM con la que se encuentra en el buffer de RAM
// Funcion NF_BgGetPalColor();
void NF_BgGetPalColor(u8 screen, u8 layer, u8 number, u8* r, u8* g, u8* b);
// Obtiene el valor de un color de la paleta que se encuentra en la RAM
// Funcion NF_GetTilePal();
extern u8 NF_GetTilePal(u8 screen, u8 layer, u16 tile_x, u16 tile_y);
// Devuelve que numero de paleta (0 - 15) esta usando el tile del fondo especificado.
// Por defecto, todos los tiles usan la paleta del Slot nº0
// Los datos se obtienen de la compia en RAM del mapa del fondo.
// Funcion NF_SetTilePal();
void NF_SetTilePal(u8 screen, u8 layer, u16 tile_x, u16 tile_y, u8 pal);
// Cambia el numero de paleta (0 - 15) que usara el tile del fondo especificado.
// Por defecto, todos los tiles usan la paleta del Slot nº0
// Los datos se escriben de la compia en RAM del mapa del fondo, por lo que no seran
// visibles hasta que ejecutes la funcion NF_UpdateVramMap();
// Funcion NF_LoadExBgPal();
void NF_LoadExBgPal(const char* file, u8 slot);
// Carga en el buffer de RAM correspondiente una paleta de fondos, para poderla usar
// mas tarde como paleta extendida.
// Funcion NF_UnloadExBgPal();
void NF_UnloadExBgPal(u8 slot);
// Borra de la RAM la paleta del slot especificado.
// Funcion NF_VramExBgPal();
void NF_VramExBgPal(u8 screen, u8 layer, u8 id, u8 slot);
// Transfiere a la VRAM una paleta extendida en el slot de la pantalla y
// fondo especificados.
// Funcion NF_SetExBgPal();
void NF_SetExBgPal(u8 screen, u8 layer, u8 pal);
// Cambia la paleta extendida que usara un fondo.
// La paleta debe de estar transferida en la VRAM previamente
// Funcion NF_SetTileHflip();
void NF_SetTileHflip(u8 screen, u8 layer, u16 tile_x, u16 tile_y);
// Invierte horizontalmente el estado actual del tile seleccionado
// Los cambios no seran visibles hasta que actualices el mapa
// con la funcion NF_UpdateVramMap();
// Funcion NF_SetTileVflip();
void NF_SetTileVflip(u8 screen, u8 layer, u16 tile_x, u16 tile_y);
// Invierte verticalmente el estado actual del tile seleccionado
// Los cambios no seran visibles hasta que actualices el mapa
// con la funcion NF_UpdateVramMap();
// Funcion NF_RotateTileGfx();
void NF_RotateTileGfx(u8 slot, u16 tile, u8 rotation);
// Rota el grafico de un tile especificado. Rota el tile almacenado en un buffer de fondos
// que se encuentra en RAM. Debes especificar el SLOT del buffer, numero de tile en el buffer
// y el angulo de la rotacion.
// 1 - 90º a la derecha
// 2 - 90º a la izquierda
// 3 - 180º
#endif
#ifdef __cplusplus
}
#endif

BIN
examples/3dsprites/setlayer/nflib/lib/libnflib.a
View File

Binary file not shown.

238
examples/3dsprites/setpriority/Makefile
View File

@ -1,60 +1,17 @@
#---------------------------------------------------------------------------------
# Makefile for NightFox's Lib Projects
#---------------------------------------------------------------------------------
#---------------------------------------------------------------------------------
.SUFFIXES:
#---------------------------------------------------------------------------------
ifeq ($(strip $(DEVKITARM)),)
$(error "Please set DEVKITARM in your environment. export DEVKITARM=<path to>devkitARM")
endif
# These set the information text in the nds file
#GAME_TITLE := My Wonderful Homebrew
#GAME_SUBTITLE1 := built with devkitARM
#GAME_SUBTITLE2 := http://devitpro.org
#---------------------------------------------------------------------------------
# This part substitutes this include:
# include $(DEVKITARM)/ds_rules
# This allows you to set ROM info and icon easy
# Please update this block from DS_RULES file at every DEVKITARM update
#---------------------------------------------------------------------------------
include $(DEVKITARM)/base_rules
LIBNDS := $(DEVKITPRO)/libnds
GAME_TITLE := Text 1
GAME_SUBTITLE1 := Text 2
GAME_SUBTITLE2 := Text 3
GAME_ICON := $(CURDIR)/../icon.bmp
_ADDFILES := -d $(NITRO_FILES)
#---------------------------------------------------------------------------------
%.nds: %.arm9
@ndstool -c $@ -9 $< -b $(GAME_ICON) "$(GAME_TITLE);$(GAME_SUBTITLE1);$(GAME_SUBTITLE2)" $(_ADDFILES)
@echo built ... $(notdir $@)
#---------------------------------------------------------------------------------
%.nds: %.elf
@ndstool -c $@ -9 $< -b $(GAME_ICON) "$(GAME_TITLE);$(GAME_SUBTITLE1);$(GAME_SUBTITLE2)" $(_ADDFILES)
@echo built ... $(notdir $@)
#---------------------------------------------------------------------------------
%.arm9: %.elf
@$(OBJCOPY) -O binary $< $@
@echo built ... $(notdir $@)
#---------------------------------------------------------------------------------
%.arm7: %.elf
@$(OBJCOPY) -O binary $< $@
@echo built ... $(notdir $@)
#---------------------------------------------------------------------------------
%.elf:
@echo linking $(notdir $@)
@$(LD) $(LDFLAGS) $(OFILES) $(LIBPATHS) $(LIBS) -o $@
include $(DEVKITARM)/ds_rules
#---------------------------------------------------------------------------------
# TARGET is the name of the output
@ -62,43 +19,56 @@ _ADDFILES := -d $(NITRO_FILES)
# SOURCES is a list of directories containing source code
# INCLUDES is a list of directories containing extra header files
# DATA is a list of directories containing binary files embedded using bin2o
# NITRODATA is the directory where files for NitroFS will be placed
# GRAPHICS is a list of directories containing image files to be converted with grit
# AUDIO is a list of directories containing audio to be converted by maxmod
# ICON is the image used to create the game icon, leave blank to use default rule
# NITRO is a directory that will be accessible via NitroFS
#---------------------------------------------------------------------------------
TARGET := $(shell basename $(CURDIR))
BUILD := build
SOURCES := source
INCLUDES := include
DATA := data
NITRODATA := nitrofiles
TARGET := $(shell basename $(CURDIR))
BUILD := build
SOURCES := source
INCLUDES := include
DATA := data
GRAPHICS :=
AUDIO :=
ICON :=
# specify a directory which contains the nitro filesystem
# this is relative to the Makefile
NITRO := nitrofiles
#---------------------------------------------------------------------------------
# options for code generation
#---------------------------------------------------------------------------------
ARCH := -mthumb -mthumb-interwork
ARCH := -marm -mthumb-interwork -march=armv5te -mtune=arm946e-s
CFLAGS := -g -Wall -O2\
-march=armv5te -mtune=arm946e-s -fomit-frame-pointer\
-ffast-math \
$(ARCH)
CFLAGS += $(INCLUDE) -DARM9
CXXFLAGS := $(CFLAGS) -fno-rtti -fno-exceptions
ASFLAGS := -g $(ARCH)
LDFLAGS = -specs=ds_arm9.specs -g $(ARCH) -Wl,-Map,$(notdir $*.map)
CFLAGS := -g -Wall -O3\
$(ARCH) $(INCLUDE) -DARM9
CXXFLAGS := $(CFLAGS) -fno-rtti -fno-exceptions
ASFLAGS := -g $(ARCH)
LDFLAGS = -specs=ds_arm9.specs -g $(ARCH) -Wl,-Map,$(notdir $*.map)
#---------------------------------------------------------------------------------
# any extra libraries we wish to link with the project
# any extra libraries we wish to link with the project (order is important)
#---------------------------------------------------------------------------------
LIBS := -lnflib -lfilesystem -lfat -lnds9
LIBS := -lnflib
# automatigically add libraries for NitroFS
ifneq ($(strip $(NITRO)),)
LIBS := $(LIBS) -lfilesystem -lfat
endif
# automagically add maxmod library
ifneq ($(strip $(AUDIO)),)
LIBS := $(LIBS) -lmm9
endif
LIBS := $(LIBS) -lnds9
#---------------------------------------------------------------------------------
# list of directories containing libraries, this must be the top level containing
# include and lib
#---------------------------------------------------------------------------------
LIBDIRS := $(LIBNDS) $(CURDIR)/nflib
LIBDIRS := $(LIBNDS) $(PORTLIBS) $(DEVKITPRO)/nflib
#---------------------------------------------------------------------------------
# no real need to edit anything past this point unless you need to add additional
@ -107,64 +77,97 @@ LIBDIRS := $(LIBNDS) $(CURDIR)/nflib
ifneq ($(BUILD),$(notdir $(CURDIR)))
#---------------------------------------------------------------------------------
export OUTPUT := $(CURDIR)/$(TARGET)
export OUTPUT := $(CURDIR)/$(TARGET)
export VPATH := $(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
$(foreach dir,$(DATA),$(CURDIR)/$(dir))
export VPATH := $(CURDIR)/$(subst /,,$(dir $(ICON)))\
$(foreach dir,$(SOURCES),$(CURDIR)/$(dir))\
$(foreach dir,$(DATA),$(CURDIR)/$(dir))\
$(foreach dir,$(GRAPHICS),$(CURDIR)/$(dir))
export DEPSDIR := $(CURDIR)/$(BUILD)
export DEPSDIR := $(CURDIR)/$(BUILD)
export NITRO_FILES := $(CURDIR)/$(NITRODATA)
CFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
CPPFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
SFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
PNGFILES := $(foreach dir,$(GRAPHICS),$(notdir $(wildcard $(dir)/*.png)))
BINFILES := $(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
CFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
CPPFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
SFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
BINFILES := $(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
# prepare NitroFS directory
ifneq ($(strip $(NITRO)),)
export NITRO_FILES := $(CURDIR)/$(NITRO)
endif
# get audio list for maxmod
ifneq ($(strip $(AUDIO)),)
export MODFILES := $(foreach dir,$(notdir $(wildcard $(AUDIO)/*.*)),$(CURDIR)/$(AUDIO)/$(dir))
# place the soundbank file in NitroFS if using it
ifneq ($(strip $(NITRO)),)
export SOUNDBANK := $(NITRO_FILES)/soundbank.bin
# otherwise, needs to be loaded from memory
else
export SOUNDBANK := soundbank.bin
BINFILES += $(SOUNDBANK)
endif
endif
#---------------------------------------------------------------------------------
# use CXX for linking C++ projects, CC for standard C
#---------------------------------------------------------------------------------
ifeq ($(strip $(CPPFILES)),)
#---------------------------------------------------------------------------------
export LD := $(CC)
export LD := $(CC)
#---------------------------------------------------------------------------------
else
#---------------------------------------------------------------------------------
export LD := $(CXX)
export LD := $(CXX)
#---------------------------------------------------------------------------------
endif
#---------------------------------------------------------------------------------
export OFILES := $(addsuffix .o,$(BINFILES)) \
$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
export OFILES_BIN := $(addsuffix .o,$(BINFILES))
export INCLUDE := $(foreach dir,$(INCLUDES),-iquote $(CURDIR)/$(dir)) \
$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
-I$(CURDIR)/$(BUILD)
export OFILES_SOURCES := $(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
export LIBPATHS := $(foreach dir,$(LIBDIRS),-L$(dir)/lib)
export OFILES := $(PNGFILES:.png=.o) $(OFILES_BIN) $(OFILES_SOURCES)
icons := $(wildcard *.bmp)
export HFILES := $(PNGFILES:.png=.h) $(addsuffix .h,$(subst .,_,$(BINFILES)))
ifneq (,$(findstring $(TARGET).bmp,$(icons)))
export GAME_ICON := $(CURDIR)/$(TARGET).bmp
export INCLUDE := $(foreach dir,$(INCLUDES),-iquote $(CURDIR)/$(dir))\
$(foreach dir,$(LIBDIRS),-I$(dir)/include)\
-I$(CURDIR)/$(BUILD)
export LIBPATHS := $(foreach dir,$(LIBDIRS),-L$(dir)/lib)
ifeq ($(strip $(ICON)),)
icons := $(wildcard *.bmp)
ifneq (,$(findstring $(TARGET).bmp,$(icons)))
export GAME_ICON := $(CURDIR)/$(TARGET).bmp
else
ifneq (,$(findstring icon.bmp,$(icons)))
export GAME_ICON := $(CURDIR)/icon.bmp
endif
endif
else
ifneq (,$(findstring icon.bmp,$(icons)))
export GAME_ICON := $(CURDIR)/icon.bmp
endif
ifeq ($(suffix $(ICON)), .grf)
export GAME_ICON := $(CURDIR)/$(ICON)
else
export GAME_ICON := $(CURDIR)/$(BUILD)/$(notdir $(basename $(ICON))).grf
endif
endif
.PHONY: $(BUILD) clean
#---------------------------------------------------------------------------------
$(BUILD):
@[ -d $@ ] || mkdir -p $@
@make --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
@mkdir -p $@
@$(MAKE) --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
#---------------------------------------------------------------------------------
clean:
@echo clean ...
@rm -fr $(BUILD) $(TARGET).elf $(TARGET).nds $(TARGET).arm9
@rm -fr $(BUILD) $(TARGET).elf $(TARGET).nds $(SOUNDBANK)
#---------------------------------------------------------------------------------
else
@ -172,14 +175,47 @@ else
#---------------------------------------------------------------------------------
# main targets
#---------------------------------------------------------------------------------
$(OUTPUT).nds : $(OUTPUT).elf
$(OUTPUT).elf : $(OFILES)
$(OUTPUT).nds: $(OUTPUT).elf $(NITRO_FILES) $(GAME_ICON)
$(OUTPUT).elf: $(OFILES)
# source files depend on generated headers
$(OFILES_SOURCES) : $(HFILES)
# need to build soundbank first
$(OFILES): $(SOUNDBANK)
#---------------------------------------------------------------------------------
%.bin.o : %.bin
# rule to build solution from music files
#---------------------------------------------------------------------------------
$(SOUNDBANK) : $(MODFILES)
#---------------------------------------------------------------------------------
mmutil $^ -d -o$@ -hsoundbank.h
#---------------------------------------------------------------------------------
%.bin.o %_bin.h : %.bin
#---------------------------------------------------------------------------------
@echo $(notdir $<)
$(bin2o)
@$(bin2o)
#---------------------------------------------------------------------------------
# This rule creates assembly source files using grit
# grit takes an image file and a .grit describing how the file is to be processed
# add additional rules like this for each image extension
# you use in the graphics folders
#---------------------------------------------------------------------------------
%.s %.h: %.png %.grit
#---------------------------------------------------------------------------------
grit $< -fts -o$*
#---------------------------------------------------------------------------------
# Convert non-GRF game icon to GRF if needed
#---------------------------------------------------------------------------------
$(GAME_ICON): $(notdir $(ICON))
#---------------------------------------------------------------------------------
@echo convert $(notdir $<)
@grit $< -g -gt -gB4 -gT FF00FF -m! -p -pe 16 -fh! -ftr
-include $(DEPSDIR)/*.d
#---------------------------------------------------------------------------------------
endif

5
examples/3dsprites/setpriority/clean.bat
View File

@ -1,5 +0,0 @@
@echo off
cls
make clean
pause
exit

5
examples/3dsprites/setpriority/compile.bat
View File

@ -1,5 +0,0 @@
@echo off
cls
make
pause
exit

BIN
examples/3dsprites/setpriority/icon.bmp
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 1.1 KiB

Some files were not shown because too many files have changed in this diff Show More