tobid7/renderd7
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

merge into: tobid7:main
Branches Tags
tobid7:main
tobid7:095-26062024
tobid7:gh-pages
tobid7:0.6.2
tobid7:0.6.1
tobid7:alpha-0-3-0
tobid7:0.7.0
tobid7:v0.9.4
tobid7:v0.9.3
tobid7:v0.8.5-pre1
tobid7:v0.8.4-pre1
tobid7:v0.8.3-pre1
tobid7:0.8.1-pre1
tobid7:v0.8.0-pre2
tobid7:v0.8.0-pre1
...
pull from: tobid7:095-26062024
Branches Tags
tobid7:095-26062024
tobid7:main
tobid7:gh-pages
tobid7:0.6.2
tobid7:0.6.1
tobid7:alpha-0-3-0
tobid7:0.7.0
tobid7:v0.9.4
tobid7:v0.9.3
tobid7:v0.8.5-pre1
tobid7:v0.8.4-pre1
tobid7:v0.8.3-pre1
tobid7:0.8.1-pre1
tobid7:v0.8.0-pre2
tobid7:v0.8.0-pre1

1 Commits
main ... 095-260620

Author SHA1 Message Date
tobid7
c6804dfc03 Codebase of 0.9.5 26.06.2024 found on my OneDrive 2025-02-18 10:26:51 +01:00
131 changed files with 84983 additions and 63010 deletions
Show Stats Expand all files Collapse all files

259
.clang-format Normal file
View File

@ -0,0 +1,259 @@
---
Language: Cpp
# BasedOnStyle: Google
AccessModifierOffset: -1
AlignAfterOpenBracket: Align
AlignArrayOfStructures: None
AlignConsecutiveAssignments:
Enabled: false
AcrossEmptyLines: false
AcrossComments: false
AlignCompound: false
PadOperators: true
AlignConsecutiveBitFields:
Enabled: false
AcrossEmptyLines: false
AcrossComments: false
AlignCompound: false
PadOperators: false
AlignConsecutiveDeclarations:
Enabled: false
AcrossEmptyLines: false
AcrossComments: false
AlignCompound: false
PadOperators: false
AlignConsecutiveMacros:
Enabled: false
AcrossEmptyLines: false
AcrossComments: false
AlignCompound: false
PadOperators: false
AlignEscapedNewlines: Left
AlignOperands: Align
AlignTrailingComments:
Kind: Always
OverEmptyLines: 0
AllowAllArgumentsOnNextLine: true
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortBlocksOnASingleLine: Never
AllowShortCaseLabelsOnASingleLine: false
AllowShortEnumsOnASingleLine: true
AllowShortFunctionsOnASingleLine: All
AllowShortIfStatementsOnASingleLine: WithoutElse
AllowShortLambdasOnASingleLine: All
AllowShortLoopsOnASingleLine: true
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: true
AlwaysBreakTemplateDeclarations: Yes
AttributeMacros:
- __capability
BinPackArguments: true
BinPackParameters: true
BitFieldColonSpacing: Both
BraceWrapping:
AfterCaseLabel: false
AfterClass: false
AfterControlStatement: Never
AfterEnum: false
AfterExternBlock: false
AfterFunction: false
AfterNamespace: false
AfterObjCDeclaration: false
AfterStruct: false
AfterUnion: false
BeforeCatch: false
BeforeElse: false
BeforeLambdaBody: false
BeforeWhile: false
IndentBraces: false
SplitEmptyFunction: true
SplitEmptyRecord: true
SplitEmptyNamespace: true
BreakAfterAttributes: Never
BreakAfterJavaFieldAnnotations: false
BreakArrays: true
BreakBeforeBinaryOperators: None
BreakBeforeConceptDeclarations: Always
BreakBeforeBraces: Attach
BreakBeforeInlineASMColon: OnlyMultiline
BreakBeforeTernaryOperators: true
BreakConstructorInitializers: BeforeColon
BreakInheritanceList: BeforeColon
BreakStringLiterals: true
ColumnLimit: 80
CommentPragmas: '^ IWYU pragma:'
CompactNamespaces: false
ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4
Cpp11BracedListStyle: true
DerivePointerAlignment: true
DisableFormat: false
EmptyLineAfterAccessModifier: Never
EmptyLineBeforeAccessModifier: LogicalBlock
ExperimentalAutoDetectBinPacking: false
FixNamespaceComments: true
ForEachMacros:
- foreach
- Q_FOREACH
- BOOST_FOREACH
IfMacros:
- KJ_IF_MAYBE
IncludeBlocks: Regroup
IncludeCategories:
- Regex: '^<ext/.*\.h>'
Priority: 2
SortPriority: 0
CaseSensitive: false
- Regex: '^<.*\.h>'
Priority: 1
SortPriority: 0
CaseSensitive: false
- Regex: '^<.*'
Priority: 2
SortPriority: 0
CaseSensitive: false
- Regex: '.*'
Priority: 3
SortPriority: 0
CaseSensitive: false
IncludeIsMainRegex: '([-_](test|unittest))?$'
IncludeIsMainSourceRegex: ''
IndentAccessModifiers: false
IndentCaseBlocks: false
IndentCaseLabels: true
IndentExternBlock: AfterExternBlock
IndentGotoLabels: true
IndentPPDirectives: None
IndentRequiresClause: true
IndentWidth: 2
IndentWrappedFunctionNames: false
InsertBraces: false
InsertNewlineAtEOF: false
InsertTrailingCommas: None
IntegerLiteralSeparator:
Binary: 0
BinaryMinDigits: 0
Decimal: 0
DecimalMinDigits: 0
Hex: 0
HexMinDigits: 0
JavaScriptQuotes: Leave
JavaScriptWrapImports: true
KeepEmptyLinesAtTheStartOfBlocks: false
LambdaBodyIndentation: Signature
LineEnding: DeriveLF
MacroBlockBegin: ''
MacroBlockEnd: ''
MaxEmptyLinesToKeep: 1
NamespaceIndentation: None
ObjCBinPackProtocolList: Never
ObjCBlockIndentWidth: 2
ObjCBreakBeforeNestedBlockParam: true
ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: true
PackConstructorInitializers: NextLine
PenaltyBreakAssignment: 2
PenaltyBreakBeforeFirstCallParameter: 1
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120
PenaltyBreakOpenParenthesis: 0
PenaltyBreakString: 1000
PenaltyBreakTemplateDeclaration: 10
PenaltyExcessCharacter: 1000000
PenaltyIndentedWhitespace: 0
PenaltyReturnTypeOnItsOwnLine: 200
PointerAlignment: Left
PPIndentWidth: -1
QualifierAlignment: Leave
RawStringFormats:
- Language: Cpp
Delimiters:
- cc
- CC
- cpp
- Cpp
- CPP
- 'c++'
- 'C++'
CanonicalDelimiter: ''
BasedOnStyle: google
- Language: TextProto
Delimiters:
- pb
- PB
- proto
- PROTO
EnclosingFunctions:
- EqualsProto
- EquivToProto
- PARSE_PARTIAL_TEXT_PROTO
- PARSE_TEST_PROTO
- PARSE_TEXT_PROTO
- ParseTextOrDie
- ParseTextProtoOrDie
- ParseTestProto
- ParsePartialTestProto
CanonicalDelimiter: pb
BasedOnStyle: google
ReferenceAlignment: Pointer
ReflowComments: true
RemoveBracesLLVM: false
RemoveSemicolon: false
RequiresClausePosition: OwnLine
RequiresExpressionIndentation: OuterScope
SeparateDefinitionBlocks: Leave
ShortNamespaceLines: 1
SortIncludes: CaseSensitive
SortJavaStaticImport: Before
SortUsingDeclarations: LexicographicNumeric
SpaceAfterCStyleCast: false
SpaceAfterLogicalNot: false
SpaceAfterTemplateKeyword: true
SpaceAroundPointerQualifiers: Default
SpaceBeforeAssignmentOperators: true
SpaceBeforeCaseColon: false
SpaceBeforeCpp11BracedList: false
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements
SpaceBeforeParensOptions:
AfterControlStatements: true
AfterForeachMacros: true
AfterFunctionDefinitionName: false
AfterFunctionDeclarationName: false
AfterIfMacros: true
AfterOverloadedOperator: false
AfterRequiresInClause: false
AfterRequiresInExpression: false
BeforeNonEmptyParentheses: false
SpaceBeforeRangeBasedForLoopColon: true
SpaceBeforeSquareBrackets: false
SpaceInEmptyBlock: false
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 2
SpacesInAngles: Never
SpacesInConditionalStatement: false
SpacesInContainerLiterals: true
SpacesInCStyleCastParentheses: false
SpacesInLineCommentPrefix:
Minimum: 1
Maximum: -1
SpacesInParentheses: false
SpacesInSquareBrackets: false
Standard: Auto
StatementAttributeLikeMacros:
- Q_EMIT
StatementMacros:
- Q_UNUSED
- QT_REQUIRE_VERSION
TabWidth: 8
UseTab: Never
WhitespaceSensitiveMacros:
- BOOST_PP_STRINGIZE
- CF_SWIFT_NAME
- NS_SWIFT_NAME
- PP_STRINGIZE
- STRINGIZE
...

100
.github/workflows/Docs.yml vendored
View File

@ -1,50 +1,50 @@
name: 📄 name: 📄
on: on:
push: push:
branches: [ "!*" ] branches: [ "!*" ]
pull_request: pull_request:
branches: [ "*" ] branches: [ "*" ]
jobs: jobs:
# This workflow contains a single job called "build" # This workflow contains a single job called "build"
build: build:
# The type of runner that the job will run on # The type of runner that the job will run on
runs-on: ubuntu-latest runs-on: ubuntu-latest
# Steps represent a sequence of tasks that will be executed as part of the job # Steps represent a sequence of tasks that will be executed as part of the job
steps: steps:
# Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
- uses: actions/checkout@v2 - uses: actions/checkout@v2
- name: Extract branch name - name: Extract branch name
shell: bash shell: bash
run: echo "##[set-output name=branch;]$(echo ${GITHUB_REF#refs/heads/})" run: echo "##[set-output name=branch;]$(echo ${GITHUB_REF#refs/heads/})"
id: branch id: branch
- name: Display branch name - name: Display branch name
shell: bash shell: bash
run: echo ${{ steps.branch.outputs.branch }} run: echo ${{ steps.branch.outputs.branch }}
# Runs a single command using the runners shell # Runs a single command using the runners shell
- name: Run a one-line script - name: Run a one-line script
run: | run: |
git config --global user.email "tobid7@outlook.de" git config --global user.email "tobid7@outlook.de"
git config --global user.name "Tobi-D7" git config --global user.name "Tobi-D7"
sudo apt-get install doxygen cmake -y sudo apt-get install doxygen cmake -y
doxygen doxygen
echo done echo done
ls -r ls -r
cd .. cd ..
git clone --depth 1 https://${{ secrets.TOKEN }}@github.com/NPI-D7/RenderD7.git RD7 -b gh-pages git clone --depth 1 https://${{ secrets.TOKEN }}@github.com/NPI-D7/RenderD7.git RD7 -b gh-pages
mv -v RenderD7/doc/html/* RD7/ mv -v RenderD7/doc/html/* RD7/
#rm -r doc #rm -r doc
cd RD7 cd RD7
echo tobid7 echo tobid7
git stage * git stage *
echo staged echo staged
git commit -m "Documentation1" git commit -m "Documentation1"
git tag doc git tag doc
echo commited echo commited
git push origin gh-pages git push origin gh-pages
echo pushed echo pushed

100
.github/workflows/Update extlibs.yml vendored
View File

@ -1,50 +1,50 @@
name: Extlibs name: Extlibs
on: on:
push: push:
branches: [ '!*' ] branches: [ '!*' ]
pull_request: pull_request:
branches: [ '!*' ] branches: [ '!*' ]
# Allows you to run this workflow manually from the Actions tab # Allows you to run this workflow manually from the Actions tab
workflow_dispatch: workflow_dispatch:
# A workflow run is made up of one or more jobs that can run sequentially or in parallel # A workflow run is made up of one or more jobs that can run sequentially or in parallel
jobs: jobs:
# This workflow contains a single job called "build" # This workflow contains a single job called "build"
build: build:
# The type of runner that the job will run on # The type of runner that the job will run on
runs-on: ubuntu-latest runs-on: ubuntu-latest
# Steps represent a sequence of tasks that will be executed as part of the job # Steps represent a sequence of tasks that will be executed as part of the job
steps: steps:
# Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
- uses: actions/checkout@v2 - uses: actions/checkout@v2
- name: update - name: update
run: | run: |
#gl #gl
cd .. cd ..
git clone https://github.com/lua/lua.git git clone https://github.com/lua/lua.git
cd RenderD7 cd RenderD7
mkdir -p extlibs/ mkdir -p extlibs/
mkdir -p extlibs/lua/ mkdir -p extlibs/lua/
cp -r ../lua/*.c extlibs/lua/ cp -r ../lua/*.c extlibs/lua/
cp -r ../lua/*.h extlibs/lua/ cp -r ../lua/*.h extlibs/lua/
cp -r ../lua/*.md extlibs/lua/ cp -r ../lua/*.md extlibs/lua/
#RenderD7 #RenderD7
cd .. cd ..
git clone https://github.com/NPI-D7/RenderD7.git git clone https://github.com/NPI-D7/RenderD7.git
cd lp-next-ctr cd lp-next-ctr
mkdir -p extlibs/ mkdir -p extlibs/
rm -r extlibs/RenderD7 rm -r extlibs/RenderD7
mkdir -p extlibs/RenderD7/ mkdir -p extlibs/RenderD7/
cp -r ../RenderD7/*.c* extlibs/RenderD7/ cp -r ../RenderD7/*.c* extlibs/RenderD7/
cp -r ../RenderD7/*.h* extlibs/RenderD7/ cp -r ../RenderD7/*.h* extlibs/RenderD7/
cp -r ../RenderD7/*.md extlibs/RenderD7/ cp -r ../RenderD7/*.md extlibs/RenderD7/
#config #config
git config --global user.email "tobid7@outlook.de" git config --global user.email "tobid7@outlook.de"
git config --global user.name "Tobi-D7" git config --global user.name "Tobi-D7"
#commit #commit
git stage * git stage *
git commit -m "update extlibs" git commit -m "update extlibs"
git push origin main git push origin main

10
.gitignore vendored
View File

@ -1,4 +1,6 @@
release/ release/
debug/ debug/
lib/ lib/
*.bz2 *.bz2
rd7le/
*.DS_Store*

34
.vscode/c_cpp_properties.json vendored
View File

@ -1,18 +1,18 @@
{ {
"configurations": [ "configurations": [
{ {
"name": "3DS | Windows", "name": "3DS | Windows",
"includePath": [ "includePath": [
"${workspaceFolder}/**", "${workspaceFolder}/**",
"C:/devkitpro/libctru/include/**", "C:/devkitpro/libctru/include/**",
"C:/devkitpro/devkitARM/include/**", "C:/devkitpro/devkitARM/include/**",
"C:/devkitpro/devkitARM/arm-none-eabi/include/**", "C:/devkitpro/devkitARM/arm-none-eabi/include/**",
"C:/devkitpro/portlibs/3ds/include/**", "C:/devkitpro/portlibs/3ds/include/**",
"/opt/devkitpro/libctru/include/**", "/opt/devkitpro/libctru/include/**",
"/opt/devkitpro/portlibs/**" "/opt/devkitpro/portlibs/**"
] ]
} }
], ],
"version": 4 "version": 4
} }

115
.vscode/launch.json vendored Normal file
View File

@ -0,0 +1,115 @@
{
"version": "0.2.0",
"configurations": [
{
"name": "(gdb) Launch",
"type": "cppdbg",
"request": "launch",
"program": "${workspaceFolder}/rd7tf/rd7tf.elf",
"targetArchitecture": "arm",
"serverLaunchTimeout": 10000,
"stopAtEntry": true,
"cwd": "${workspaceFolder}",
"environment": [],
"externalConsole": true,
"MIMode": "gdb",
"miDebuggerPath": "/opt/devkitPro/devkitARM/bin/arm-none-eabi-gdb",
"miDebuggerServerAddress": "192.168.2.220:4003",
"setupCommands": [
{
"description": "Enable pretty-printing",
"text": "file ${workspaceFolder}/rd7tf/rd7tf.elf -enable-pretty-printing",
"ignoreFailures": true
}
]
},
{
"name": "(gdb-emu) Launch",
"type": "cppdbg",
"request": "launch",
"program": "${workspaceFolder}/rd7tf/rd7tf.elf",
"targetArchitecture": "arm",
"serverLaunchTimeout": 10000,
"stopAtEntry": true,
"cwd": "${workspaceFolder}",
"environment": [],
"externalConsole": true,
"MIMode": "gdb",
"miDebuggerPath": "/opt/devkitPro/devkitARM/bin/arm-none-eabi-gdb",
"miDebuggerServerAddress": "localhost:4003",
"setupCommands": [
{
"description": "Enable pretty-printing",
"text": "file ${workspaceFolder}/rd7tf/rd7tf.elf -enable-pretty-printing",
"ignoreFailures": true
}
]
},
{
"name": "(gdb-emu) lua",
"type": "cppdbg",
"request": "launch",
"program": "${workspaceFolder}/rd7le/rd7le.elf",
"targetArchitecture": "arm",
"serverLaunchTimeout": 10000,
"stopAtEntry": true,
"cwd": "${workspaceFolder}",
"environment": [],
"externalConsole": true,
"MIMode": "gdb",
"miDebuggerPath": "C:\\devkitPro\\devkitARM\\bin\\arm-none-eabi-gdb.exe",
"miDebuggerServerAddress": "localhost:4003",
"setupCommands": [
{
"description": "Enable pretty-printing",
"text": "file ${workspaceFolder}/rd7le/rd7le.elf -enable-pretty-printing",
"ignoreFailures": true
}
]
},
{
"name": "(gdb) lua",
"type": "cppdbg",
"request": "launch",
"program": "${workspaceFolder}/rd7le/rd7le.elf",
"targetArchitecture": "arm",
"serverLaunchTimeout": 10000,
"stopAtEntry": true,
"cwd": "${workspaceFolder}",
"environment": [],
"externalConsole": true,
"MIMode": "gdb",
"miDebuggerPath": "C:\\devkitPro\\devkitARM\\bin\\arm-none-eabi-gdb.exe",
"miDebuggerServerAddress": "192.168.2.220:4003",
"setupCommands": [
{
"description": "Enable pretty-printing",
"text": "file ${workspaceFolder}/rd7le/rd7le.elf -enable-pretty-printing",
"ignoreFailures": true
}
]
},
{
"name": "(gdb) testgame",
"type": "cppdbg",
"request": "launch",
"program": "${workspaceFolder}/testgame/testgame.elf",
"targetArchitecture": "arm",
"serverLaunchTimeout": 10000,
"stopAtEntry": true,
"cwd": "${workspaceFolder}",
"environment": [],
"externalConsole": true,
"MIMode": "gdb",
"miDebuggerPath": "C:\\devkitPro\\devkitARM\\bin\\arm-none-eabi-gdb.exe",
"miDebuggerServerAddress": "localhost:4003",
"setupCommands": [
{
"description": "Enable pretty-printing",
"text": "file ${workspaceFolder}/testgame/testgame.elf -enable-pretty-printing",
"ignoreFailures": true
}
]
}
]
}

218
.vscode/settings.json vendored
View File

@ -1,102 +1,118 @@
{ {
"files.associations": { "files.associations": {
"array": "cpp", "array": "cpp",
"*.tcc": "cpp", "*.tcc": "cpp",
"cctype": "cpp", "cctype": "cpp",
"clocale": "cpp", "clocale": "cpp",
"cmath": "cpp", "cmath": "cpp",
"cstdarg": "cpp", "cstdarg": "cpp",
"cstddef": "cpp", "cstddef": "cpp",
"cstdint": "cpp", "cstdint": "cpp",
"cstdio": "cpp", "cstdio": "cpp",
"cstdlib": "cpp", "cstdlib": "cpp",
"cwchar": "cpp", "cwchar": "cpp",
"cwctype": "cpp", "cwctype": "cpp",
"unordered_map": "cpp", "unordered_map": "cpp",
"vector": "cpp", "vector": "cpp",
"exception": "cpp", "exception": "cpp",
"algorithm": "cpp", "algorithm": "cpp",
"functional": "cpp", "functional": "cpp",
"iterator": "cpp", "iterator": "cpp",
"memory": "cpp", "memory": "cpp",
"numeric": "cpp", "numeric": "cpp",
"type_traits": "cpp", "type_traits": "cpp",
"fstream": "cpp", "fstream": "cpp",
"initializer_list": "cpp", "initializer_list": "cpp",
"iosfwd": "cpp", "iosfwd": "cpp",
"iostream": "cpp", "iostream": "cpp",
"istream": "cpp", "istream": "cpp",
"limits": "cpp", "limits": "cpp",
"new": "cpp", "new": "cpp",
"optional": "cpp", "optional": "cpp",
"ostream": "cpp", "ostream": "cpp",
"sstream": "cpp", "sstream": "cpp",
"stdexcept": "cpp", "stdexcept": "cpp",
"streambuf": "cpp", "streambuf": "cpp",
"string": "cpp", "string": "cpp",
"string_view": "cpp", "string_view": "cpp",
"system_error": "cpp", "system_error": "cpp",
"tuple": "cpp", "tuple": "cpp",
"typeinfo": "cpp", "typeinfo": "cpp",
"utility": "cpp", "utility": "cpp",
"atomic": "cpp", "atomic": "cpp",
"bit": "cpp", "bit": "cpp",
"bitset": "cpp", "bitset": "cpp",
"chrono": "cpp", "chrono": "cpp",
"codecvt": "cpp", "codecvt": "cpp",
"condition_variable": "cpp", "condition_variable": "cpp",
"cstring": "cpp", "cstring": "cpp",
"ctime": "cpp", "ctime": "cpp",
"deque": "cpp", "deque": "cpp",
"forward_list": "cpp", "forward_list": "cpp",
"map": "cpp", "map": "cpp",
"iomanip": "cpp", "iomanip": "cpp",
"memory_resource": "cpp", "memory_resource": "cpp",
"ratio": "cpp", "ratio": "cpp",
"regex": "cpp", "regex": "cpp",
"shared_mutex": "cpp", "shared_mutex": "cpp",
"valarray": "cpp", "valarray": "cpp",
"random": "cpp", "random": "cpp",
"cuchar": "cpp", "cuchar": "cpp",
"compare": "cpp", "compare": "cpp",
"concepts": "cpp", "concepts": "cpp",
"numbers": "cpp", "numbers": "cpp",
"filesystem": "cpp", "filesystem": "cpp",
"xstring": "cpp", "xstring": "cpp",
"charconv": "cpp", "charconv": "cpp",
"format": "cpp", "format": "cpp",
"ios": "cpp", "ios": "cpp",
"list": "cpp", "list": "cpp",
"locale": "cpp", "locale": "cpp",
"mutex": "cpp", "mutex": "cpp",
"stack": "cpp", "stack": "cpp",
"stop_token": "cpp", "stop_token": "cpp",
"thread": "cpp", "thread": "cpp",
"xfacet": "cpp", "xfacet": "cpp",
"xhash": "cpp", "xhash": "cpp",
"xiosbase": "cpp", "xiosbase": "cpp",
"xlocale": "cpp", "xlocale": "cpp",
"xlocbuf": "cpp", "xlocbuf": "cpp",
"xlocinfo": "cpp", "xlocinfo": "cpp",
"xlocmes": "cpp", "xlocmes": "cpp",
"xlocmon": "cpp", "xlocmon": "cpp",
"xlocnum": "cpp", "xlocnum": "cpp",
"xloctime": "cpp", "xloctime": "cpp",
"xmemory": "cpp", "xmemory": "cpp",
"xstddef": "cpp", "xstddef": "cpp",
"xtr1common": "cpp", "xtr1common": "cpp",
"xtree": "cpp", "xtree": "cpp",
"xutility": "cpp", "xutility": "cpp",
"queue": "cpp", "queue": "cpp",
"semaphore": "cpp", "semaphore": "cpp",
"hash_map": "cpp", "hash_map": "cpp",
"set": "cpp", "set": "cpp",
"unordered_set": "cpp", "unordered_set": "cpp",
"source_location": "cpp", "source_location": "cpp",
"future": "cpp", "future": "cpp",
"cfenv": "cpp", "cfenv": "cpp",
"cinttypes": "cpp", "cinttypes": "cpp",
"typeindex": "cpp", "typeindex": "cpp",
"variant": "cpp" "variant": "cpp",
} "ranges": "cpp",
"span": "cpp",
"coroutine": "cpp",
"__bit_reference": "cpp",
"__config": "cpp",
"__debug": "cpp",
"__errc": "cpp",
"__hash_table": "cpp",
"__locale": "cpp",
"__mutex_base": "cpp",
"__node_handle": "cpp",
"__split_buffer": "cpp",
"__threading_support": "cpp",
"__tree": "cpp",
"__verbose_abort": "cpp",
"complex": "cpp"
}
} }

98
CHANGELOG.md Normal file
View File

@ -0,0 +1,98 @@
# RenderD7 Changelog
## 0.9.5
- Remove Npi Intro and NVID Api
- Replace Toasts System with Message
- Lots of Optimisations
- Added GetTime
- Implement Draw2 Api
- Implement RD7Color and R7Vec2
- Add new Features to Color::RGBA
- Cleanup Code
- Added RenderD7 Keyboard (Overlay)
- Added Ftrace Overlay
- Moved MetrikOVL into an Overlay
- Removed Old Font/Text Handlers
- Added UI7 (New UI Api)
- Remove Old UI Api
- Added Music Player (MP3, Vorbis)
- Rewrite of RenderD7::Image
- Internal Debugger/Database (IDB)
- Removed BitmapPrinter
- Added nimg and nimg_engine
- Removed Old Error/Message Handler
- GetTextSize (extra buffer) + New TextShorter
## 0.9.4
- Implement new Security System To prevent from crashes
- Implement Functiontrace for better Timing Tests
- Implement MemAlloc Tracker (only size)
- Add some new Overlays (not functional yet)
- Complete Rewrite of Overlay System
- Fixed the FrameEnd Crash
- New System to get Hardware Info
- Removed RenderD7 Super Reselution (800px mode)
## 0.9.3
- Completly Documented Everything
- Fix typo in Sprite::getHeight
- Remove Deprecated/Useless Stuff
## 0.9.2
- Add Nvid Support(v0.0.1)
- Add Basic RenderD7 Splash
- Faster Graphics Init
- Fade Effects
- Fix Changelog Screen
## 0.9.1
- Fix Critical bug in Spritesheet animations
- Fix RenderD7::Color::Hex (Major performance tweak)
## 0.9.0
- Remove Stupid try of Console
- Add Services list
- Clean up Code
- Added Minimal Init for hax2.x
## 0.8.5
- Fix Deltatime
## 0.8.4
- A lot of Fixes
- New Features for BitmapPrinter
## 0.8.3
- Added Overlaycount to Info
- Addet ResultDecoder for errors
## 0.8.2
- Fix a lot of Stuff
- Use c++17 std::filesystem for RenderD7::Filesystem
## 0.8.1
- Add abillity to Get Stdout as string to render it to the screen.
## 0.8.0
- Implement BitmapPrinter
## 0.7.3
- Implement Over Render Overlay Framework
## 0.7.2
- Implement MT to csv file saving
- Add RGB2HEX
## 0.7.1
- Add the New Overlay Handler. Its Just in code and does nothing yet
## 0.7.0
- Made Big Progress In the MT Ovl but it still crashes On a 2nd C3D_FrameEnd \
- Implement 800px but doesn't work that good
## 0.6.2
- Fix Crash when exiting through Home Menu.
## 0.6.10
- Rewrite Threadsystem
- Improve framerate
## 0.6.02
- Fix Code in lang.hpp
- Add Draw Text Left Function (Right since 0.7.0)
- Add changelog
## 0.6.01
- Add Threading system
## 0.6.0
- Better Scene Management
## 0.5.0
- Fixed some Bugs!
## 0.4.0
- Trying to fix Filesystem and Bugs
## 0.3.0
- Recreate D7-Core into RenderD7
## 0.2.0
- Trying to create Animations of Images instead of Sheets
## 0.1.0
- Inital Release of D7-Core sprite animation plugin

5132
Doxyfile
View File

File diff suppressed because it is too large Load Diff

1348
LICENSE
View File

File diff suppressed because it is too large Load Diff

400
Makefile
View File

@ -1,201 +1,201 @@
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
.SUFFIXES: .SUFFIXES:
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
ifeq ($(strip $(DEVKITARM)),) ifeq ($(strip $(DEVKITARM)),)
$(error "Please set DEVKITARM in your environment. export DEVKITARM=<path to>devkitARM") $(error "Please set DEVKITARM in your environment. export DEVKITARM=<path to>devkitARM")
endif endif
include $(DEVKITARM)/3ds_rules include $(DEVKITARM)/3ds_rules
export renderd7_MAJOR := 0 export renderd7_MAJOR := 0
export renderd7_MINOR := 9 export renderd7_MINOR := 9
export renderd7_PATCH := 4 export renderd7_PATCH := 4
VERSION := $(renderd7_MAJOR).$(renderd7_MINOR).$(renderd7_PATCH) VERSION := $(renderd7_MAJOR).$(renderd7_MINOR).$(renderd7_PATCH)
# If on a tagged commit, use the tag instead of the commit # If on a tagged commit, use the tag instead of the commit
ifneq ($(shell echo $(shell git tag -l --points-at HEAD) | head -c 1),) ifneq ($(shell echo $(shell git tag -l --points-at HEAD) | head -c 1),)
GIT_VER := $(shell git tag -l --points-at HEAD) GIT_VER := $(shell git tag -l --points-at HEAD)
else else
GIT_VER := $(shell git rev-parse --short HEAD) GIT_VER := $(shell git rev-parse --short HEAD)
endif endif
TIME_TIME := $(shell date --iso=seconds) TIME_TIME := $(shell date --iso=seconds)
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
# TARGET is the name of the output # TARGET is the name of the output
# BUILD is the directory where object files & intermediate files will be placed # BUILD is the directory where object files & intermediate files will be placed
# SOURCES is a list of directories containing source code # SOURCES is a list of directories containing source code
# DATA is a list of directories containing data files # DATA is a list of directories containing data files
# INCLUDES is a list of directories containing header files # INCLUDES is a list of directories containing header files
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
TARGET := renderd7 TARGET := renderd7
SOURCES := source external/source SOURCES := source source/external source/music
DATA := data DATA := data
INCLUDES := include INCLUDES := include
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
# options for code generation # options for code generation
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
ARCH := -march=armv6k -mtune=mpcore -mfloat-abi=hard -mtp=soft ARCH := -march=armv6k -mtune=mpcore -mfloat-abi=hard -mtp=soft
CFLAGS := -g -Wall -Werror -mword-relocations -save-temps\ CFLAGS := -g -Wall -mword-relocations -save-temps\
-DV_STRING=\"$(GIT_VER)\" \ -DV_RD7CSTRING=\"$(GIT_VER)\" \
-DV_TIME=\"$(TIME_TIME)\" \ -DV_RD7BTIME=\"$(TIME_TIME)\" \
-ffunction-sections -fdata-sections \ -ffunction-sections -fdata-sections \
$(ARCH) $(BUILD_CFLAGS) $(ARCH) $(BUILD_CFLAGS)
CFLAGS += $(INCLUDE) -D__3DS__ -D_GNU_SOURCE=1 CFLAGS += $(INCLUDE) -D__3DS__ -D_GNU_SOURCE=1
CXXFLAGS := $(CFLAGS) -fno-rtti -fno-exceptions -std=gnu++20 CXXFLAGS := $(CFLAGS) -fno-rtti -fno-exceptions -std=gnu++20
ASFLAGS := -g $(ARCH) $(DEFINES) ASFLAGS := -g $(ARCH) $(DEFINES)
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
# list of directories containing libraries, this must be the top level containing # list of directories containing libraries, this must be the top level containing
# include and lib # include and lib
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
LIBDIRS := $(PORTLIBS) $(CTRULIB) LIBDIRS := $(PORTLIBS) $(CTRULIB)
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
# no real need to edit anything past this point unless you need to add additional # no real need to edit anything past this point unless you need to add additional
# rules for different file extensions # rules for different file extensions
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
ifneq ($(BUILD),$(notdir $(CURDIR))) ifneq ($(BUILD),$(notdir $(CURDIR)))
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
export VPATH := $(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \ export VPATH := $(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
$(foreach dir,$(DATA),$(CURDIR)/$(dir)) $(foreach dir,$(DATA),$(CURDIR)/$(dir))
CFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c))) CFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
CPPFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp))) CPPFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
SFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s))) SFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
PICAFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.v.pica))) PICAFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.v.pica)))
SHLISTFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.shlist))) SHLISTFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.shlist)))
BINFILES := $(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*))) BINFILES := $(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
# use CXX for linking C++ projects, CC for standard C # use CXX for linking C++ projects, CC for standard C
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
ifeq ($(strip $(CPPFILES)),) ifeq ($(strip $(CPPFILES)),)
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
export LD := $(CC) export LD := $(CC)
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
else else
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
export LD := $(CXX) export LD := $(CXX)
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
endif endif
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
export OFILES_SOURCES := $(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o) export OFILES_SOURCES := $(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
export OFILES_BIN := $(addsuffix .o,$(BINFILES)) \ export OFILES_BIN := $(addsuffix .o,$(BINFILES)) \
$(PICAFILES:.v.pica=.shbin.o) $(SHLISTFILES:.shlist=.shbin.o) $(PICAFILES:.v.pica=.shbin.o) $(SHLISTFILES:.shlist=.shbin.o)
export OFILES := $(OFILES_BIN) $(OFILES_SOURCES) export OFILES := $(OFILES_BIN) $(OFILES_SOURCES)
export HFILES := $(PICAFILES:.v.pica=_shbin.h) $(addsuffix .h,$(subst .,_,$(BINFILES))) export HFILES := $(PICAFILES:.v.pica=_shbin.h) $(addsuffix .h,$(subst .,_,$(BINFILES)))
export INCLUDE := $(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \ export INCLUDE := $(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
$(foreach dir,$(LIBDIRS),-I$(dir)/include) \ $(foreach dir,$(LIBDIRS),-I$(dir)/include) \
-I. -I.
.PHONY: clean all doc .PHONY: clean all doc
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
all: lib/librenderd7.a lib/librenderd7d.a all: lib/librenderd7.a lib/librenderd7d.a
doc: doc:
@doxygen Doxyfile @doxygen Doxyfile
dist-bin: all dist-bin: all
@tar --exclude=*~ -cjf $(TARGET).tar.bz2 include lib @tar --exclude=*~ -cjf $(TARGET).tar.bz2 include lib
dist-src: dist-src:
@tar --exclude=*~ -cjf $(TARGET)-src.tar.bz2 include $(SOURCES) Makefile @tar --exclude=*~ -cjf $(TARGET)-src.tar.bz2 include $(SOURCES) Makefile
dist: dist-src dist-bin dist: dist-src dist-bin
lib: lib:
@[ -d $@ ] || mkdir -p $@ @[ -d $@ ] || mkdir -p $@
release: release:
@[ -d $@ ] || mkdir -p $@ @[ -d $@ ] || mkdir -p $@
debug: debug:
@[ -d $@ ] || mkdir -p $@ @[ -d $@ ] || mkdir -p $@
lib/librenderd7.a : lib release $(SOURCES) $(INCLUDES) lib/librenderd7.a : lib release $(SOURCES) $(INCLUDES)
@$(MAKE) BUILD=release OUTPUT=$(CURDIR)/$@ \ @$(MAKE) BUILD=release OUTPUT=$(CURDIR)/$@ \
BUILD_CFLAGS="-DNDEBUG=1 -O2 -fomit-frame-pointer" \ BUILD_CFLAGS="-DNDEBUG=1 -O2 -fomit-frame-pointer" \
DEPSDIR=$(CURDIR)/release \ DEPSDIR=$(CURDIR)/release \
--no-print-directory -C release \ --no-print-directory -C release \
-f $(CURDIR)/Makefile -f $(CURDIR)/Makefile
lib/librenderd7d.a : lib debug $(SOURCES) $(INCLUDES) lib/librenderd7d.a : lib debug $(SOURCES) $(INCLUDES)
@$(MAKE) BUILD=debug OUTPUT=$(CURDIR)/$@ \ @$(MAKE) BUILD=debug OUTPUT=$(CURDIR)/$@ \
BUILD_CFLAGS="-DDEBUG=1 -Og" \ BUILD_CFLAGS="-DDEBUG=1 -Og" \
DEPSDIR=$(CURDIR)/debug \ DEPSDIR=$(CURDIR)/debug \
--no-print-directory -C debug \ --no-print-directory -C debug \
-f $(CURDIR)/Makefile -f $(CURDIR)/Makefile
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
clean: clean:
@echo clean ... @echo clean ...
@rm -fr release debug lib includes @rm -fr release debug lib includes
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
else else
DEPENDS := $(OFILES:.o=.d) DEPENDS := $(OFILES:.o=.d)
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
# main targets # main targets
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
$(OUTPUT) : $(OFILES) $(OUTPUT) : $(OFILES)
$(OFILES_SOURCES) : $(HFILES) $(OFILES_SOURCES) : $(HFILES)
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
# you need a rule like this for each extension you use as binary data # you need a rule like this for each extension you use as binary data
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
%.bin.o %_bin.h : %.bin %.bin.o %_bin.h : %.bin
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
@echo $(notdir $<) @echo $(notdir $<)
@$(bin2o) @$(bin2o)
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
# rules for assembling GPU shaders # rules for assembling GPU shaders
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
define shader-as define shader-as
$(eval CURBIN := $*.shbin) $(eval CURBIN := $*.shbin)
$(eval DEPSFILE := $(DEPSDIR)/$*.shbin.d) $(eval DEPSFILE := $(DEPSDIR)/$*.shbin.d)
echo "$(CURBIN).o: $< $1" > $(DEPSFILE) echo "$(CURBIN).o: $< $1" > $(DEPSFILE)
echo "extern const u8" `(echo $(CURBIN) | sed -e 's/^\([0-9]\)/_\1/' | tr . _)`"_end[];" > `(echo $(CURBIN) | tr . _)`.h echo "extern const u8" `(echo $(CURBIN) | sed -e 's/^\([0-9]\)/_\1/' | tr . _)`"_end[];" > `(echo $(CURBIN) | tr . _)`.h
echo "extern const u8" `(echo $(CURBIN) | sed -e 's/^\([0-9]\)/_\1/' | tr . _)`"[];" >> `(echo $(CURBIN) | tr . _)`.h echo "extern const u8" `(echo $(CURBIN) | sed -e 's/^\([0-9]\)/_\1/' | tr . _)`"[];" >> `(echo $(CURBIN) | tr . _)`.h
echo "extern const u32" `(echo $(CURBIN) | sed -e 's/^\([0-9]\)/_\1/' | tr . _)`_size";" >> `(echo $(CURBIN) | tr . _)`.h echo "extern const u32" `(echo $(CURBIN) | sed -e 's/^\([0-9]\)/_\1/' | tr . _)`_size";" >> `(echo $(CURBIN) | tr . _)`.h
picasso -o $(CURBIN) $1 picasso -o $(CURBIN) $1
bin2s $(CURBIN) | $(AS) -o $*.shbin.o bin2s $(CURBIN) | $(AS) -o $*.shbin.o
endef endef
%.shbin.o %_shbin.h : %.v.pica %.g.pica %.shbin.o %_shbin.h : %.v.pica %.g.pica
@echo $(notdir $^) @echo $(notdir $^)
@$(call shader-as,$^) @$(call shader-as,$^)
%.shbin.o %_shbin.h : %.v.pica %.shbin.o %_shbin.h : %.v.pica
@echo $(notdir $<) @echo $(notdir $<)
@$(call shader-as,$<) @$(call shader-as,$<)
%.shbin.o %_shbin.h : %.shlist %.shbin.o %_shbin.h : %.shlist
@echo $(notdir $<) @echo $(notdir $<)
@$(call shader-as,$(foreach file,$(shell cat $<),$(dir $<)$(file))) @$(call shader-as,$(foreach file,$(shell cat $<),$(dir $<)$(file)))
-include $(DEPENDS) -include $(DEPENDS)
#--------------------------------------------------------------------------------------- #---------------------------------------------------------------------------------------
endif endif
#--------------------------------------------------------------------------------------- #---------------------------------------------------------------------------------------

2
README.md
View File

@ -1,4 +1,4 @@
# <img alt="LOGO" src="https://github.com/NPI-D7/RenderD7/blob/main/logo.png" height="90"> # <img alt="LOGO" src="https://github.com/NPI-D7/RenderD7/raw/main/logo.png" height="90">
RenderD7 is now LibRenderD7. RenderD7 is now LibRenderD7.
### Installation ### Installation
Download a Package From Releses Page Download a Package From Releses Page

60
assets/build_assets.sh
View File

@ -1,31 +1,31 @@
#!/bin/bash #!/bin/bash
echo "Create Directorys" echo "Create Directorys"
mkdir -p build mkdir -p build
mkdir -p code mkdir -p code
echo "Generating Spritesheets" echo "Generating Spritesheets"
cd resources cd resources
for file in *.t3s for file in *.t3s
do do
filename=$(basename "$file" .t3s).t3x filename=$(basename "$file" .t3s).t3x
tex3ds -o "../build/$filename" -i "${file}" tex3ds -o "../build/$filename" -i "${file}"
done done
echo "Converting Spritesheets into C++ Code" echo "Converting Spritesheets into C++ Code"
cd ../code cd ../code
for file in ../build/*.t3x for file in ../build/*.t3x
do do
name="${file##*/}" name="${file##*/}"
name="${name%.*}" name="${name%.*}"
../../tools/bin/file2array "${file}" "${name}" ../../tools/bin/file2array "${file}" "${name}"
done done
echo "Fix The Output of file2array" echo "Fix The Output of file2array"
for file in ./*.cpp for file in ./*.cpp
do do
../../tools/bin/rd7f2afix "${file}" "renderd7" ../../tools/bin/rd7f2afix "${file}" "renderd7"
done done
echo "Finished!" echo "Finished!"

12
assets/clear_assets.sh
View File

@ -1,7 +1,7 @@
#!/bin/bash #!/bin/bash
echo "Deleting Directorys" echo "Deleting Directorys"
rm -rf build rm -rf build
rm -rf code rm -rf code
echo "Finished!" echo "Finished!"

4
assets/resources/renderd7_logo.t3s
View File

@ -1,3 +1,3 @@
--atlas -f rgba -z auto --atlas -f rgba -z auto
renderd7_logo/renderd7_logo.png renderd7_logo/renderd7_logo.png

BIN
assets/resources/renderd7_logo/renderd7_logo.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 13 KiB

After

Width:  |  Height:  |  Size: 17 KiB

14
cformat.sh
View File

@ -1,8 +1,8 @@
#!/bin/bash #!/bin/bash
find . -type f \( -name '*.h' -o -name '*.hpp' -o -name '*.hh' -o -name '*.ino' -o -name '*.cpp' -o -name '*.c' -o -name '*.cxx' -o -name '*.inl' \) -and -not -path './build/*' -not -path './base/external/*' -not -path './DPP/*' | while read file; do find . -type f \( -name '*.h' -o -name '*.hpp' -o -name '*.hh' -o -name '*.ino' -o -name '*.cpp' -o -name '*.c' -o -name '*.cxx' -o -name '*.inl' \) -and -not -path './build/*' -not -path './base/external/*' -not -path './DPP/*' | while read file; do
if [[ "$file" != *"json.hpp" ]]; then if [[ "$file" != *"json.hpp" ]]; then
echo "Formatting $file..." echo "Formatting $file..."
clang-format -i --style=LLVM $file clang-format -i --style=LLVM $file
fi fi
done done

1274
docsn.css
View File

File diff suppressed because it is too large Load Diff

44
envsetup.sh
View File

@ -1,23 +1,23 @@
#!/bin/bash #!/bin/bash
#Build Tools #Build Tools
echo "Build Tools..." echo "Build Tools..."
cd tools cd tools
./build_tools.sh ./build_tools.sh
cd .. cd ..
#Setup asset-arrays #Setup asset-arrays
echo "Generate Asset-Arrays..." echo "Generate Asset-Arrays..."
cd assets cd assets
./build_assets.sh ./build_assets.sh
echo "Update Files in RenderD7..." echo "Update Files in RenderD7..."
cp -rf code/*.cpp ../source/ cp -rf code/*.cpp ../source/
cp -rf code/*.hpp ../include/renderd7/ cp -rf code/*.hpp ../include/renderd7/
echo "Clean Assets..." echo "Clean Assets..."
./clear_assets.sh ./clear_assets.sh
cd .. cd ..
#Clear Tools #Clear Tools
echo "Clean Tools..." echo "Clean Tools..."
cd tools cd tools
./clear_tools.sh ./clear_tools.sh
cd .. cd ..
#Finished #Finished
echo "Done!" echo "Done!"

23
include/rd7.hpp
View File

@ -1,7 +1,16 @@
#pragma once #pragma once
#include <renderd7/StealConsole.hpp> #include <renderd7/StealConsole.hpp>
#include <renderd7/bmp.hpp> #include <renderd7/renderd7.hpp>
#include <renderd7/renderd7.hpp> #include <renderd7/sound.hpp>
#include <renderd7/sound.hpp> #include <renderd7/Message.hpp>
#include <renderd7/ToastsV2.hpp> #include <renderd7/DrawV2.hpp>
#include <renderd7/Hid.hpp>
#include <renderd7/UI7.hpp>
#include <renderd7/FileSystem.hpp>
#include <renderd7/Image.hpp>
#include <renderd7/Timer.hpp>
#include <renderd7/music/Music.hpp>
#include <renderd7/nimg_engine.hpp>
#include <renderd7/global_db.hpp>
#include <renderd7/Error.hpp>

219
include/renderd7/BitmapPrinter.hpp
View File

@ -1,219 +0,0 @@
#pragma once
#include <string>
#include <vector>
#include <renderd7/bmp.hpp>
#include <renderd7/bmpconverter.hpp>
#include <renderd7/Image.hpp>
#include <renderd7/Screen.hpp>
#include <renderd7/Time.hpp>
#include <renderd7/Fonts/NFontApi.hpp>
namespace RenderD7 {
/// @brief Encoder
enum Encoder {
BITMAP, ///< Encode Data to Bitmap
DIRECT, ///< Encode Direct to Framebuffer(No Decoder Required)
C3D ///< Encode Directly to C3D_Tex (Just an Idea)
};
/// @brief Decoder
enum Decoder {
BITMAP2C3D, ///< Decode and Encode to C3D_Tex (Currently Fastest) (47,4ms)
BITMAP2PNG2C3D ///< Decode Bitmap end Convert to Png, then C3D (Very Slow)
///< (201,4ms)
};
/// @brief BitmapPrinetr Class
class BitmapPrinter {
public:
/// @brief Constructor
/// @param w Widrth
/// @param h Height
BitmapPrinter(int w, int h);
/// @brief Deconstructor
~BitmapPrinter();
/// @brief Dexode Bitmap File
/// @param file path to File
/// @return success ?
bool DecodeFile(std::string file);
/// @brief Set the Decoder
/// @param deccc Decoder
void SetDecoder(Decoder deccc) { decc = deccc; }
/// @brief Draw a Pixel
/// @param x pos x
/// @param y pos y
/// @param b color blue
/// @param g color green
/// @param r color red
/// @param a color alpha
void DrawPixel(int x, int y, u8 b, u8 g, u8 r, u8 a);
/// @brief Draw Rectangle
/// @param x pos x
/// @param y pos y
/// @param w width
/// @param h height
/// @param line_w line width
/// @param b color blue
/// @param g color green
/// @param r color red
/// @param a colr alpha
void DrawRect(int x, int y, int w, int h, u8 line_w, u8 b, u8 g, u8 r, u8 a);
/// @brief Draw a Fillif Rectangle
/// @param x pos x
/// @param y pos y
/// @param w width
/// @param h height
/// @param b color blue
/// @param g color green
/// @param r color red
/// @param a color alpha
void DrawRectFilled(int x, int y, int w, int h, u8 b, u8 g, u8 r, u8 a);
/// @brief Draw Bitmap
/// @param x pos x
/// @param y pos y
/// @param map Bitmap to Print
void DrawBitmap(int x, int y, BMP map);
/// @brief Use Prebuild Bitmap
/// @param map bitmap
void UsePreMap(BMP map);
/// @brief Use Prebuild Printer Setup
/// @param printmap Printer
void UsePrePrintMap(BitmapPrinter printmap);
/// @brief Get Bitmap
/// @return Bitmap
BMP GetBitmap() { return bitmap; }
/// @brief Save to File
/// @param name Name/Path
void SaveBmp(std::string name);
/// @brief Save as Png
/// @param name Name/Path
void SavePng(std::string name);
/// @brief Setup Screen
/// @param target Screen
void CreateScreen(C3D_RenderTarget *target);
/// @brief Draw Directly to Screen With Framerate
/// @param framerate Framerate
/// @return
bool DrawScreenDirectF(int framerate);
/// @brief Draw Directly to Screen
/// @return
bool DrawScreenDirect();
/// @brief Render on Screen by Framerate
/// @param framerate Framerate
void DrawScreenF(int framerate);
/// @brief Draw to Screen
void DrawScreen();
/// @brief Update Image by Framerate
/// @param framerate Framerate
/// @return
bool UpdateScreenF(int framerate);
/// @brief Update Image
/// @return
bool UpdateScreen();
/// @brief Clear by Color
/// @param b color blue
/// @param g color green
/// @param r color red
/// @param a color alpha
void Clear(u8 b = 0, u8 g = 0, u8 r = 0, u8 a = 255);
/// @brief Clear Completly Blank
void ClearBlank();
/// @brief Get Rendered Image
/// @return Image
RenderD7::Image GetImage();
/// Test to Find out The Best Settings for BitmapPrinter
void Benchmark();
/// @brief Setup the Benchmark
/// \param framerate The Fps of the ScreenUpdates
void SetupBenchmark(int framerate);
/// @brief Check if Benchmark is Running
/// @return is running or not
bool IsBenchmarkRunning() { return this->benchmark; }
/// @brief Draw a Dubug Text
/// @param x pos x
/// @param y pos y
/// @param t_size Size of the Text
/// @param color Color of the Text
/// @param text String of the Text
void DrawDebugText(int x, int y, int t_size, u32 color, std::string text);
/// @brief Draw a Text width NFontApi (TTF)
/// @param x pos x
/// @param y pos y
/// @param t_size size of the Text
/// @param color Color of The Text
/// @param text String of The Text
/// @param font TTF Font
void DrawText(int x, int y, float t_size, u32 color, std::string text,
RenderD7::NFontApi font);
private:
// funcs
/// @brief Decode 2 RenderD7::Image
/// @param deccc Decoder
/// @return
bool Decode(Decoder deccc);
/// @brief Draw Char Func
/// @param posX pos x
/// @param posY pos y
/// @param t_size size
/// @param color color
/// @param character char
void DrawDebugChar(u32 posX, u32 posY, int t_size, u32 color, char character);
/// @brief NFont Draw Char
/// @param posX pos x
/// @param posY pos y
/// @param t_size size
/// @param color color
/// @param character char
/// @param font ttf
void DrawChar(int posX, int posY, float t_size, u32 color, char character,
RenderD7::NFontApi font);
// parameter
int frame = 0;
RenderD7::Image renderframe;
bool isscreen = false;
C3D_RenderTarget *targetr;
BMP bitmap = BMP(
20, 20,
true); // Need to Set e Predefined Bitmap. If not the System will Crash.
BMP blank = BMP(
20, 20,
true); // Need to Set e Predefined Bitmap. If not the System will Crash.
///////////////////////////////////////////////////////////////////////////////////////////////////
// Benchmark Stuff;
int testfpsd;
bool benchmark = false;
bool setupbenchmark;
float frametime = 0;
uint64_t lastTime = 0;
float dtt = 0.f;
float dtt2 = 0.f;
float dtt3 = 0.f;
float timer = 0;
float mhdtt = 0;
float mdtt2;
float mdtt3;
float fpsClock = 0.f;
int frameCounter = 0, fps = 0;
std::vector<float> hdttt;
std::vector<float> hdttt2;
std::vector<float> hdttt3;
std::vector<int> fpscountc;
int renderedframes = 0;
int testfps = 60;
Encoder encc = Encoder::BITMAP;
Decoder decc = Decoder::BITMAP2C3D;
////////////////////////////////////////////////////////////////////////////////////////////////
};
} // namespace RenderD7

219
include/renderd7/Color.hpp
View File

@ -1,50 +1,169 @@
#pragma once #pragma once
#include <cstring> #include <unistd.h>
#include <functional>
#include <memory> #include <cstring>
#include <regex> #include <functional>
#include <sstream> #include <memory>
#include <string> #include <regex>
#include <unistd.h> #include <sstream>
#include <string>
#define UNPACK_RGBA(col) (uint8_t)(col >> 24), (col >> 16), (col >> 8), (col)
#define UNPACK_BGRA(col) (uint8_t)(col >> 8), (col >> 16), (col >> 24), (col) #define UNPACK_RGBA(col) (uint8_t)(col >> 24), (col >> 16), (col >> 8), (col)
#define UNPACK_BGRA(col) (uint8_t)(col >> 8), (col >> 16), (col >> 24), (col)
namespace RenderD7 { // it is actually not RGBA lol
namespace Color { inline uint32_t RGBA8(uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255) {
/// @brief RGBA Struct #define ISIMPLEPAK(x, y) (((x) & 0xff) << y)
struct rgba { return (ISIMPLEPAK(r, 0) | ISIMPLEPAK(g, 8) | ISIMPLEPAK(b, 16) |
/// @brief rgba Colors ISIMPLEPAK(a, 24));
uint8_t r, g, b, a; }
};
/// @brief RGBA Class /*#define RGBA8(r, g, b, a) \
class RGBA { ((((r)&0xFF) << 0) | (((g)&0xFF) << 8) | (((b)&0xFF) << 16) | \
public: (((a)&0xFF) << 24))*/
/// @brief Construct
/// @param r typedef int RD7Color;
/// @param g
/// @param b // MultiColor (Less FunctionNameLen)
/// @param a
RGBA(uint8_t r, uint8_t g, uint8_t b, uint8_t a) struct Color2 {
: m_r(r), m_g(g), m_b(b), m_a(a) {} unsigned int color0;
/// @brief Get as Uint32 unsigned int color1;
/// @return color };
uint32_t toRGBA() const {
return (m_r << 24) | (m_g << 16) | (m_b << 8) | m_a; struct Color3 {
} unsigned int color0;
unsigned int color1;
uint8_t m_r, m_g, m_b, m_a; unsigned int color2;
}; };
/// @brief Convert RGB to Hex
/// @param r struct Color4 {
/// @param g unsigned int color0;
/// @param b unsigned int color1;
/// @return Hex-String unsigned int color2;
std::string RGB2Hex(int r, int g, int b); unsigned int color3;
/// @brief Hex to U32 };
/// @param color
/// @param a enum RD7Color_ {
/// @return Color32 RD7Color_Text, ///< This Color Should always be used for Light Backgrounds
uint32_t Hex(const std::string &color, uint8_t a = 255); RD7Color_TextDisabled, /// Text Disabled Color
} // namespace Color RD7Color_Text2, ///< And This want for Texts on Dark Backgrounds
} // namespace RenderD7 RD7Color_Background, ///< Your Bg Color
RD7Color_Header, ///< Header Color (if the header is dark text2 is used)
RD7Color_Selector,
RD7Color_SelectorFade,
RD7Color_List0,
RD7Color_List1,
RD7Color_MessageBackground,
RD7Color_Button,
RD7Color_ButtonHovered,
RD7Color_ButtonDisabled,
RD7Color_ButtonActive,
RD7Color_Checkmark,
RD7Color_FrameBg,
RD7Color_FrameBgHovered,
RD7Color_Progressbar,
};
namespace RenderD7 {
unsigned int StyleColor(RD7Color color);
void RedirectColor(RD7Color to, RD7Color from);
void TextColorByBg(RD7Color background);
/// @brief Customices a color until undone
/// For example with RebderD7::Color::Hex
void CustomizeColor(RD7Color color, unsigned int custom);
/// @brief Completly changes a theme color
void ColorNew(RD7Color color, unsigned int new_color);
void UndoColorEdit(RD7Color color);
void UndoAllColorEdits();
namespace Color {
/// @brief RGBA Class
class RGBA {
public:
/// @brief Construct
/// @param r
/// @param g
/// @param b
/// @param a
RGBA(uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255)
: m_r(r), m_g(g), m_b(b), m_a(a) {}
/// @brief Construct
/// @param r
/// @param g
/// @param b
/// @param a
RGBA(float r, float g, float b, float a = 1.f)
: m_r(r * 255.f), m_g(g * 255.f), m_b(b * 255.f), m_a(a * 255.f) {}
RGBA(unsigned int in) {
#define ISIMPLEUNPAK(x, y) (((x) >> y) & 0xFF)
m_r = ISIMPLEUNPAK(in, 0);
m_g = ISIMPLEUNPAK(in, 8);
m_b = ISIMPLEUNPAK(in, 16);
m_a = ISIMPLEUNPAK(in, 24);
}
RGBA(RD7Color in) {
unsigned int col = RenderD7::StyleColor(in);
m_r = ISIMPLEUNPAK(col, 0);
m_g = ISIMPLEUNPAK(col, 8);
m_b = ISIMPLEUNPAK(col, 16);
m_a = ISIMPLEUNPAK(col, 24);
}
RGBA &changeR(unsigned char r) {
m_r = r;
return *this;
}
RGBA &changeG(unsigned char g) {
m_g = g;
return *this;
}
RGBA &changeB(unsigned char b) {
m_b = b;
return *this;
}
RGBA &changeA(unsigned char a) {
m_a = a;
return *this;
}
RGBA &fade_to(const RGBA &color, float p) {
m_a =
m_a + static_cast<unsigned char>((color.m_a - m_a) * ((p + 1.0f) / 2));
m_b =
m_b + static_cast<unsigned char>((color.m_b - m_b) * ((p + 1.0f) / 2));
m_g =
m_g + static_cast<unsigned char>((color.m_g - m_g) * ((p + 1.0f) / 2));
m_r =
m_r + static_cast<unsigned char>((color.m_r - m_r) * ((p + 1.0f) / 2));
return *this;
}
/// @brief Get as Uint32
/// @return color
uint32_t toRGBA() const { return RGBA8(m_r, m_g, m_b, m_a); }
// Just calculate the "lightness" f.e. to use Text or Text2
float luminance() const {
// For Reference https://en.wikipedia.org/wiki/HSL_and_HSV#Lightness
return (0.3 * (m_r / 255.f) + 0.59 * (m_g / 255.f) + 0.11 * (m_b / 255.f));
}
bool is_light() {
// Gives us the light or dark to not
// always use the below "if" statement
return (luminance() >= 0.5);
}
uint8_t m_r, m_g, m_b, m_a;
};
/// @brief Convert RGB to Hex
/// @param r
/// @param g
/// @param b
/// @return Hex-String
std::string RGB2Hex(int r, int g, int b);
/// @brief Hex to U32
/// @param color
/// @param a
/// @return Color32
uint32_t Hex(const std::string &color, uint8_t a = 255);
} // namespace Color
} // namespace RenderD7

111
include/renderd7/Draw.hpp
View File

@ -1,111 +0,0 @@
#pragma once
#include <3ds.h>
#include <citro2d.h>
#include <citro3d.h>
#include <string>
namespace RenderD7 {
namespace Draw {
/// @brief Draw Rectangle
/// @param x Pos X
/// @param y Pos Y
/// @param w Width
/// @param h Height
/// @param color Color
/// @return success ?
bool Rect(float x, float y, float w, float h, u32 color);
/// @brief Draw a not filled Rectangle
/// @param p1x Pos X
/// @param p1y Pos Y
/// @param w Width
/// @param h Height
/// @param color Color
/// @param scale Scale
/// @return success ?
bool NFRect(float p1x, float p1y, float w, float h, u32 color, float scale = 1);
/// @brief Draw A Pixel
/// @param x Pos X
/// @param y Pos Y
/// @param color Color
/// @return success ?
bool Px(float x, float y, u32 color);
/// @brief Draw a Centered Text
/// @param x Pos X
/// @param y Pos Y
/// @param size Scale of the Text
/// @param color Color of The Text
/// @param Text Striing to Display
/// @param maxWidth Width to Calculate Centered Pos
/// @param maxHeight Height to Calculate Centered Pos
/// @param fnt Custom Font
void TextCentered(float x, float y, float size, u32 color, std::string Text,
int maxWidth = 0, int maxHeight = 0, C2D_Font fnt = nullptr);
/// @brief Draw a Text
/// @param x Pos X
/// @param y Pos Y
/// @param size Scale of the Text
/// @param color Color of The Text
/// @param Text Striing to Display
/// @param maxWidth Width to Calculate Centered Pos
/// @param maxHeight Height to Calculate Centered Pos
/// @param fnt Custom Font
void Text(float x, float y, float size, u32 color, std::string Text,
int maxWidth = 0, int maxHeight = 0, C2D_Font fnt = nullptr);
/// @brief Draw a Text Set to the Right
/// @param x Pos X
/// @param y Pos Y
/// @param size Scale of the Text
/// @param color Color of The Text
/// @param Text Striing to Display
/// @param maxWidth Width to Calculate Centered Pos
/// @param maxHeight Height to Calculate Centered Pos
/// @param fnt Custom Font
void TextRight(float x, float y, float size, u32 color, std::string Text,
int maxWidth = 0, int maxHeight = 0, C2D_Font fnt = nullptr);
/// @brief Get Width of Text
/// @param size Size of the Text
/// @param Text String of The text
/// @param fnt Custom Font
/// @return The Size
float GetTextWidth(float size, std::string Text, C2D_Font fnt = nullptr);
/// @brief Get Text Size
/// @param size Size of The Text
/// @param width Width of the Text
/// @param height Height of The Text
/// @param Text String of Text
/// @param fnt Custom Font
void GetTextSize(float size, float *width, float *height, std::string Text,
C2D_Font fnt = nullptr);
/// @brief Get Height of the Text
/// @param size Size of the Text
/// @param Text String of the Text
/// @param fnt Custom Font
/// @return The Height
float GetTextHeight(float size, std::string Text, C2D_Font fnt = nullptr);
/// @brief Load A .bcfnt
/// @param fnt Output Font
/// @param Path path of The File
/// @return Result Code
Result LoadFont(C2D_Font &fnt, const char *Path = "");
/// @brief Unload a Font
/// @param fnt Font to Unload
/// @return Result Code
Result UnloadFont(C2D_Font &fnt);
/// @brief Draw a Circle
/// @param x Pos X
/// @param y Pos Y
/// @param radius Radius of the Circle
/// @param color Color of the circle
/// @return success ?
bool Circle(float x, float y, float radius, u32 color);
/// @brief Draw A Citro2D Image
/// @param img Image to Draw
/// @param x Pos X
/// @param y Pos Y
/// @param scaleX Scale of X-Axis
/// @param scaleY Scale of Y-Axis
/// @return success ?
bool Image(C2D_Image img, float x, float y, float scaleX = 1.0f,
float scaleY = 1.0f);
} // namespace Draw
} // namespace RenderD7

51
include/renderd7/DrawV2.hpp Normal file
View File

@ -0,0 +1,51 @@
#pragma once
#include <citro2d.h>
#include <renderd7/Color.hpp>
#include <renderd7/R7Vec.hpp>
#include <renderd7/Image.hpp>
#include <string>
#define MAKEFLAG(x) (1 << x)
typedef unsigned int RD7TextFlags;
enum RD7TextFlags_ {
RD7TextFlags_None = 0, //< Align is Left and Other things are disabled
RD7TextFlags_AlignRight = MAKEFLAG(0),
RD7TextFlags_AlignMid = MAKEFLAG(1),
RD7TextFlags_Shaddow = MAKEFLAG(2), // TextBuf Killer lol (doubled Text)
RD7TextFlags_Wrap = MAKEFLAG(3),
RD7TextFlags_Short = MAKEFLAG(4),
RD7TextFlags_Scroll = MAKEFLAG(5),
};
namespace RenderD7 {
R7Vec2 GetTextDimensions(const std::string &text);
void CustomTextSize(float size);
void TextDefaultSize();
std::string TextShort(const std::string& in, int max_len);
// Overrite TextBox Size (by default Screenwidth x Text.h)
void TextMaxBox(R7Vec2 size);
void TextDefaultBox();
void TextFont(C2D_Font fnt);
void TextDefaultFont();
namespace Draw2 {
void Rect(R7Vec2 pos, R7Vec2 size, unsigned int color, int t = 1);
void RectFilled(R7Vec2 pos, R7Vec2 size, Color4 colors);
void RectFilledSolid(R7Vec2 pos, R7Vec2 size, unsigned int color);
// Wrapper of RectFilledSolid
inline void RFS(R7Vec2 pos, R7Vec2 size, unsigned int color) {
RectFilledSolid(pos, size, color);
}
void Line(R7Vec2 pos0, R7Vec2 pos1, unsigned int color, int t = 1);
void Triangle(R7Vec2 pos0, R7Vec2 pos1, R7Vec2 pos2, Color3 colors);
void TriangleSolid(R7Vec2 pos0, R7Vec2 pos1, R7Vec2 pos2, unsigned int color);
// Beta and Very unstable
void TriangleLined(R7Vec2 pos0, R7Vec2 pos1, R7Vec2 pos2, unsigned int color,
int t = 1);
void Text(R7Vec2 pos, const std::string& text, RD7TextFlags flags = 0);
void Image(RenderD7::Image* img, const R7Vec2& pos = R7Vec2(0, 0), const R7Vec2& scale = R7Vec2(1, 1));
} // namespace Draw2
} // namespace RenderD7

16
include/renderd7/Error.hpp Normal file
View File

@ -0,0 +1,16 @@
#pragma once
#include <string>
namespace RenderD7 {
void Error(const std::string& msg);
inline void InlineError(const std::string& msg) {
std::string location = __FILE__ + std::string(":") + std::to_string(__LINE__);
Error("Error: \n" + location + "\n" + msg);
}
inline void InlineAssert(bool v, const std::string& msg) {
std::string location = __FILE__ + std::string(":") + std::to_string(__LINE__);
if(v == false)
Error("Assert Failed:\n" + location + "\n" + msg);
}
}

46
include/renderd7/FileSystem.hpp
View File

@ -1,23 +1,25 @@
// FileSystem based on libphyfs based on #pragma once
// https://github.com/TurtleP/3ds-examples/blob/fs/physfs/fs/physfs/include/filesystem.h #include <string>
#pragma once #include <vector>
#include <string>
#include <vector> namespace RenderD7 {
namespace FileSystem {
namespace RenderD7 { /// @brief A Directory Entry
namespace FileSystem { struct Entry {
/// @brief A Directory Entry /// @brief Patf of The Entry
struct Entry { std::string path;
/// @brief Patf of The Entry /// @brief Name of The Entry
std::string path; std::string name;
/// @brief Name of The Entry /// @brief Directory or File
std::string name; bool dir = false;
/// @brief Directory or File };
bool dir = false; /// @brief Gets All Entrys of A Directory into a Vector
}; /// @param path The Path of the Directory
/// @brief Gets All Entrys of A Directory into a Vector /// @return The Vector of found Entrys
/// @param path The Path of the Directory std::vector<RenderD7::FileSystem::Entry> GetDirContent(std::string path);
/// @return The Vector of found Entrys std::string GetParentPath(std::string path, std::string mount_point);
std::vector<RenderD7::FileSystem::Entry> GetDirContent(std::string path); std::vector<Entry>
} // namespace FileSystem GetDirContentsExt(std::string &path,
const std::vector<std::string> &extensions);
} // namespace FileSystem
} // namespace RenderD7 } // namespace RenderD7

142
include/renderd7/Fonts/NFontApi.hpp
View File

@ -1,142 +0,0 @@
#pragma once
#include <bitset>
#include <iostream>
#include <string>
#include <vector>
#include <renderd7/external/stb_truetype.h>
#define MAXUNICODE 0x10FFFF
namespace RenderD7 {
inline int utf8_decode(const char *o) {
static const unsigned int limits[] = {0xFF, 0x7F, 0x7FF, 0xFFFF};
const unsigned char *s = (const unsigned char *)o;
unsigned int c = s[0];
unsigned int res = 0; /* final result */
if (c < 0x80) /* ascii? */
res = c;
else {
int count = 0; /* to count number of continuation bytes */
while (c & 0x40) { /* still have continuation bytes? */
int cc = s[++count]; /* read next byte */
if ((cc & 0xC0) != 0x80) /* not a continuation byte? */
return -1; /* invalid byte sequence */
res = (res << 6) | (cc & 0x3F); /* add lower 6 bits from cont. byte */
c <<= 1; /* to test next bit */
}
res |= ((c & 0x7F) << (count * 5)); /* add first byte */
if (count > 3 || res > MAXUNICODE || res <= limits[count])
return -1; /* invalid byte sequence */
s += count; /* skip continuation bytes read */
}
return res;
}
inline std::string IntToUtf8(int convertval) {
// We only care about plane 1 right now,
// but know that we have other options (0x10FFFF)
// Technically UTF-8 is "limited" to 4 bytes, so it's not
// Like it matters much anyways these days
if (convertval == 0)
return " ";
if ((convertval <= 0x7F) && (convertval > 0x00)) {
std::string out(".");
std::bitset<8> x(convertval);
unsigned long l = x.to_ulong();
unsigned char c = static_cast<unsigned char>(l);
out[0] = c;
return out;
} else if ((convertval >= 0x80) && (convertval <= 0x07FF)) {
std::string out("..");
int firstShift = (convertval >> 0x06) ^ 0xC0;
int secondShift = ((convertval ^ 0xFFC0) | 0x80) & ~0x40;
std::bitset<8> first(firstShift);
std::bitset<8> last(secondShift);
unsigned long l = first.to_ulong();
unsigned char c = static_cast<unsigned char>(l);
out[0] = c;
unsigned long ltwo = last.to_ulong();
unsigned char ctwo = static_cast<unsigned char>(ltwo);
out[1] = ctwo;
return out;
} else if ((convertval >= 0x0800) && (convertval <= 0xFFFF)) {
std::string out("...");
int firstShift = ((convertval ^ 0xFC0FFF) >> 0x0C) | 0xE0;
int secondShift = (((convertval ^ 0xFFF03F) >> 0x06) | 0x80) & ~0x40;
int thirdShift = ((convertval ^ 0xFFFC0) | 0x80) & ~0x40;
std::bitset<8> first(firstShift);
std::bitset<8> second(secondShift);
std::bitset<8> third(thirdShift);
unsigned long lone = first.to_ulong();
unsigned char cone = static_cast<unsigned char>(lone);
out[0] = cone;
unsigned long ltwo = second.to_ulong();
unsigned char ctwo = static_cast<unsigned char>(ltwo);
out[1] = ctwo;
unsigned long lthree = third.to_ulong();
unsigned char cthree = static_cast<unsigned char>(lthree);
out[2] = cthree;
return out;
} else {
return " ";
}
}
#define I2U82I(val) RenderD7::utf8_decode(RenderD7::IntToUtf8(val).c_str())
class NFontApi {
public:
NFontApi();
~NFontApi();
void LoadTTF(std::string path);
unsigned char *GetGlyphBitmap(char glyph);
std::string GetStatus() { return status; }
float GetScale() { return scale; }
int GetGlyphWidth(char glyph);
int GetGlyphHeight(char glyph);
int GetLineHeight() { return l_h; }
int GetBaseHeight() { return height; }
private:
std::string status;
int height;
float scale;
int b_w;
int b_h;
int l_h;
int w;
int h;
int x0, y0, x1, y1;
int ascent, baseline, decent, linegap;
int linespace;
stbtt_fontinfo font;
};
} // namespace RenderD7

103
include/renderd7/FunctionTrace.hpp
View File

@ -1,52 +1,53 @@
#pragma once #pragma once
// Base includes // Base includes
#include <functional> #include <functional>
#include <map> #include <map>
#include <memory> #include <memory>
#include <string> #include <string>
#include <vector> #include <vector>
// 3ds does not support std::chrono // 3ds does not support std::chrono
#include <3ds.h> #include <3ds.h>
/// @brief 3ds System Ticks per milli second /// @brief 3ds System Ticks per milli second
#define TICKS_PER_MSEC 268111.856 #define TICKS_PER_MSEC 268111.856
#define f2s(x_) #x_ #define f2s(x_) #x_
#define scomb(x1, x2) std::string(x1 + x2) #define scomb(x1, x2) std::string(x1 + x2)
namespace RenderD7 { namespace RenderD7 {
namespace Ftrace { namespace Ftrace {
/// @brief Result of FTrace /// @brief Result of FTrace
struct FTRes { struct FTRes {
std::string group; ///< Group of the Trace std::string group; ///< Group of the Trace
std::string func_name; ///< Function Name std::string func_name; ///< Function Name
uint64_t time_start; ///< when started uint64_t time_start; ///< when started
uint64_t time_end; ///< when stopped uint64_t time_end; ///< when stopped
float time_of; ///< stop - start (how long) float time_of; ///< stop - start (how long)
}; bool is_ovl; ///< is displayed in overlay?
};
/// @brief Map of Traces
extern std::map<std::string, RenderD7::Ftrace::FTRes> rd7_traces; /// @brief Map of Traces
extern std::map<std::string, RenderD7::Ftrace::FTRes> rd7_traces;
/// @brief Set a Start TracePoint
/// @param group Set a Group Name /// @brief Set a Start TracePoint
/// @param func_name Set a Function Name /// @param group Set a Group Name
inline void Beg(std::string group, std::string func_name) { /// @param func_name Set a Function Name
std::string trace_id = scomb(group, func_name); inline void Beg(std::string group, std::string func_name) {
rd7_traces[trace_id].group = group; std::string trace_id = scomb(group, func_name);
rd7_traces[trace_id].func_name = func_name; rd7_traces[trace_id].group = group;
rd7_traces[trace_id].time_start = svcGetSystemTick(); rd7_traces[trace_id].func_name = func_name;
} rd7_traces[trace_id].time_start = svcGetSystemTick();
/// @brief Set an End TracePoint }
/// @param group Set a Group Name /// @brief Set an End TracePoint
/// @param func_name Set a Function Name /// @param group Set a Group Name
inline void End(std::string group, std::string func_name) { /// @param func_name Set a Function Name
std::string trace_id = scomb(group, func_name); inline void End(std::string group, std::string func_name) {
rd7_traces[trace_id].time_end = svcGetSystemTick(); std::string trace_id = scomb(group, func_name);
rd7_traces[trace_id].time_of = static_cast<float>( rd7_traces[trace_id].time_end = svcGetSystemTick();
rd7_traces[trace_id].time_end / (float)TICKS_PER_MSEC - rd7_traces[trace_id].time_of = static_cast<float>(
rd7_traces[trace_id].time_start / (float)TICKS_PER_MSEC); rd7_traces[trace_id].time_end / (float)TICKS_PER_MSEC -
} rd7_traces[trace_id].time_start / (float)TICKS_PER_MSEC);
} // namespace Ftrace }
} // namespace Ftrace
} // namespace RenderD7 } // namespace RenderD7

44
include/renderd7/Hardware.hpp
View File

@ -1,23 +1,23 @@
#pragma once #pragma once
namespace RenderD7 { namespace RenderD7 {
namespace Hardware { namespace Hardware {
/// @brief Initialisize required Services /// @brief Initialisize required Services
void Initialisize(); void Initialisize();
/// @brief Check if Headphones are Plugged in /// @brief Check if Headphones are Plugged in
/// @return true if headphones plugged in /// @return true if headphones plugged in
bool IsHeadphones(); bool IsHeadphones();
/// @brief Check if the 3ds Is Charging /// @brief Check if the 3ds Is Charging
/// @return true if System gets Charged /// @return true if System gets Charged
bool IsCharging(); bool IsCharging();
/// @brief Check the Battery Percentage /// @brief Check the Battery Percentage
/// @return Persentage as float /// @return Persentage as float
float GetBatteryPercentage(); float GetBatteryPercentage();
/// @brief Get current State of 3d Slider /// @brief Get current State of 3d Slider
/// @return current 3dslider poition /// @return current 3dslider poition
float Get3dSliderLevel(); float Get3dSliderLevel();
/// @brief Get Current state of Sound Slider /// @brief Get Current state of Sound Slider
/// @return current SoundSlider state /// @return current SoundSlider state
float GetSoundSliderLevel(); float GetSoundSliderLevel();
} // namespace Hardware } // namespace Hardware
} // namespace RenderD7 } // namespace RenderD7

41
include/renderd7/Hid.hpp Normal file
View File

@ -0,0 +1,41 @@
/// WARNING
/// THIS IS BETA STUFF
/// ITS MAKE LIKE EXTERNAL BUT
/// FOR RENDERD7 ITS INTEGRATED
#pragma once
#include <renderd7/R7Vec.hpp>
#include <string>
namespace RenderD7 {
namespace Hid {
enum Actions {
Down = 0,
Held = 1,
Up = 2,
DownRepeat = 3,
};
// Register Functions
// Register Current state values
void RegKeyDown(uint32_t &key_down);
void RegKeyHeld(uint32_t &key_held);
void RegKeyUp(uint32_t &key_up);
void RegKeyRepeat(uint32_t &repeat);
void RegTouchCoords(R7Vec2 &touch_pos);
// Not Corectly Implemented Yet
void RegAnalog1Movement(R7Vec2 &movement);
void RegAnalog2Movement(R7Vec2 &movement);
// Register Keys
void RegKeyEvent(const std::string &event, uint32_t key);
// KeyEvents
bool IsEvent(const std::string &event, Actions action);
R7Vec2 GetTouchPosition();
R7Vec2 GetLastTouchPosition();
void Update();
// Lock/Unlock Input api for example for Keyboard
void Lock();
void Unlock();
void Clear();
} // namespace Hid
} // namespace RenderD7

80
include/renderd7/Image.hpp
View File

@ -1,50 +1,30 @@
#pragma once #pragma once
#include <citro2d.h>
#include <citro3d.h> #include <citro2d.h>
#include <memory> #include <3ds.h>
#include <renderd7/Sheet.hpp> #include <renderd7/R7Vec.hpp>
#include <renderd7/bmp.hpp> #include <renderd7/nimg.hpp>
#include <renderd7/bmpconverter.hpp>
#include <string>
#include <cassert>
#include <cstring> namespace RenderD7 {
#include <renderd7/Color.hpp> class Image {
#include <renderd7/external/lodepng.h> public:
Image();
namespace RenderD7 { ~Image();
/// Image Class void load(const std::string& path);
class Image { void from_nimg(const nimg& image);
public:
/// @brief Constructor C2D_Image get();
Image() {} C2D_Image& get_ref();
/// @brief Deconstructor void set(const C2D_Image& i);
~Image(); R7Vec2 get_size();
/// @brief Unload The Image bool loaded();
void Unload();
/// Load Image from Png private:
/// \param path path to png file void safe_del();
void LoadPng(const std::string path); bool ld = false;
/// Load the Image from buffer C2D_Image img;
/// \param buffer the frame buffer };
void LoadPFromBuffer(const std::vector<u8> &buffer); }
void LoadFromBitmap(BMP bitmap);
void LoadJpg(std::string path);
void LoadPixels(int w, int h, int bpp, void *buffer);
/// Draw the Image directly
/// \param x The x position
/// \param y the y position
/// \param scaleX x scale from 0.0 to 1.0
/// \param scaleY y scale from 0.0 to 1.0
bool Draw(float x, float y, float scaleX = 1.0f, float scaleY = 1.0f);
/// \brief Get The Image
/// \return C2D_Image
C2D_Image Get() { return this->img; }
void FromSheet(RenderD7::Sheet sheet, size_t index);
/// \param img this is the C2D_Image
C2D_Image img;
/// \param loadet whether the image is loadet or not
bool loadet = false;
};
} // namespace RenderD7

50
include/renderd7/Memory.hpp
View File

@ -1,25 +1,25 @@
#pragma once #pragma once
#include <cstdint> #include <cstdint>
#include <memory> #include <memory>
namespace RenderD7 { namespace RenderD7 {
namespace Memory { namespace Memory {
/// @brief Metriks struct For the Internal Tracker /// @brief Metriks struct For the Internal Tracker
struct memory_metrics { struct memory_metrics {
uint32_t t_TotalAllocated = 0; ///< Total Allocated Memory uint32_t t_TotalAllocated = 0; ///< Total Allocated Memory
uint32_t t_TotalFreed = 0; ///< Total Deleted Memory uint32_t t_TotalFreed = 0; ///< Total Deleted Memory
/// @brief Gets the Currently Allocated Memory /// @brief Gets the Currently Allocated Memory
uint32_t t_CurrentlyAllocated() { return t_TotalAllocated - t_TotalFreed; } uint32_t t_CurrentlyAllocated() { return t_TotalAllocated - t_TotalFreed; }
}; };
/// @brief Get Total Allocated Memory /// @brief Get Total Allocated Memory
/// @return Total Allocated Memory /// @return Total Allocated Memory
size_t GetTotalAllocated(); size_t GetTotalAllocated();
/// @brief Get Total Deleted Memory /// @brief Get Total Deleted Memory
/// @return Total Deleted Memory /// @return Total Deleted Memory
size_t GetTotalFreed(); size_t GetTotalFreed();
/// @brief Get Current Allocated Memory /// @brief Get Current Allocated Memory
/// @return Current Allocated Memory /// @return Current Allocated Memory
size_t GetCurrent(); size_t GetCurrent();
} // namespace Memory } // namespace Memory
} // namespace RenderD7 } // namespace RenderD7

46
include/renderd7/ToastsV2.hpp → include/renderd7/Message.hpp
View File

@ -1,24 +1,24 @@
#pragma once #pragma once
#include <string> #include <string>
namespace RenderD7 { namespace RenderD7 {
struct Message { struct Message {
Message(std::string t, std::string m) { Message(std::string t, std::string m) {
title = t; title = t;
message = m; message = m;
animationframe = 0; animationframe = 0;
} }
std::string title; std::string title;
std::string message; std::string message;
int animationframe; int animationframe;
}; };
void ProcessMessages(); void ProcessMessages();
void PushMessage(const Message& msg); void PushMessage(const Message& msg);
// Config // Config
void SetIdleStartFrame(int frame); void SetMessageIdleStartFrame(int frame);
void SetTotalAnimationFrames(int total_frames); void SetMessageTotalAnimationFrames(int total_frames);
void SetFadeOutStartFrame(int frame); void SetMessageFadeOutStartFrame(int frame);
} }

16
include/renderd7/Ovarlays.hpp
View File

@ -1,16 +0,0 @@
#pragma once
#include <renderd7/Ovl.hpp>
namespace RenderD7 {
class Ovl_Ftrace : public RenderD7::Ovl {
/// @brief Constructor
Ovl_Ftrace();
/// @brief Override for Draw
void Draw(void) const override;
/// @brief Override for Logic
void Logic() override;
private:
};
} // namespace RenderD7

74
include/renderd7/Overlays.hpp Normal file
View File

@ -0,0 +1,74 @@
#pragma once
#include <renderd7/Ovl.hpp>
#include <string>
namespace RenderD7 {
class Ovl_Ftrace : public RenderD7::Ovl {
public:
/// @brief Constructor
Ovl_Ftrace(bool* is_enabled);
/// @brief Override for Draw
void Draw(void) const override;
/// @brief Override for Logic
void Logic() override;
private:
bool* i_is_enabled;
};
class Ovl_Metrik : public RenderD7::Ovl {
public:
/// @brief Constructor
Ovl_Metrik(bool* is_enabled, bool* screen, uint32_t* mt_color, uint32_t* txt_color, float* txt_size);
/// @brief Override for Draw
void Draw(void) const override;
/// @brief Override for Logic
void Logic() override;
private:
// Mutable internal values
mutable std::string mt_fps;
mutable std::string mt_cpu;
mutable std::string mt_gpu;
mutable std::string mt_cmd;
mutable std::string mt_lfr;
mutable std::string mt_tbs;
// Importand Adresses
bool* i_is_enabled;
bool* i_screen;
uint32_t* i_mt_color;
uint32_t* i_txt_color;
float* i_txt_size;
};
typedef int RD7Keyboard;
enum RD7Keyboard_ {
RD7Keyboard_Default,
RD7Keyboard_Numpad,
RD7Keyboard_Password,
};
class Ovl_Keyboard : public RenderD7::Ovl {
public:
/// @brief Constructor
/// Keyboard Type not Supported for now
Ovl_Keyboard(std::string& ref, const std::string& hint = "", RD7Keyboard type = 0);
/// @brief Deconstructor
~Ovl_Keyboard();
/// @brief Override for Draw
void Draw(void) const override;
/// @brief Override for Logic
void Logic() override;
private:
mutable std::map<unsigned char, char> shared_data;
// Pointer to useres String
std::string *typed_text = nullptr;
std::string str_bak;
int mode = 0;
int ft3 = 0;
};
} // namespace RenderD7

52
include/renderd7/Ovl.hpp
View File

@ -1,27 +1,27 @@
#pragma once #pragma once
#include <memory> #include <memory>
namespace RenderD7 { namespace RenderD7 {
/// @brief The Overlay Class (Used for Toasts for example) /// @brief The Overlay Class (Used for Toasts for example)
class Ovl { class Ovl {
public: public:
/// @brief Deconstructor /// @brief Deconstructor
virtual ~Ovl() {} virtual ~Ovl() {}
/// @brief Function Called to Draw this /// @brief Function Called to Draw this
virtual void Draw() const = 0; virtual void Draw() const = 0;
/// @brief Logic of the Overlay /// @brief Logic of the Overlay
virtual void Logic() = 0; virtual void Logic() = 0;
/// @brief Should the overlay be killed /// @brief Should the overlay be killed
/// @return Killed or Not /// @return Killed or Not
inline bool IsKilled() { return this->iskilled; } inline bool IsKilled() { return this->iskilled; }
/// @brief Kill The Overlay /// @brief Kill The Overlay
inline void Kill() { iskilled = true; } inline void Kill() { iskilled = true; }
private: private:
/// @param iskilled For IsKilled(); /// @param iskilled For IsKilled();
bool iskilled = false; bool iskilled = false;
}; };
/// @brief Add an Overlay to the Screen /// @brief Add an Overlay to the Screen
/// @param scene Overlay to push to Screen /// @param scene Overlay to push to Screen
void AddOvl(std::unique_ptr<RenderD7::Ovl> scene); void AddOvl(std::unique_ptr<RenderD7::Ovl> scene);
} // namespace RenderD7 } // namespace RenderD7

42
include/renderd7/R7Vec.hpp Normal file
View File

@ -0,0 +1,42 @@
#pragma once
struct R7Vec2 {
// Init Funcs
R7Vec2() : x(0), y(0) {}
R7Vec2(float i0, float i1) : x(i0), y(i1) {}
R7Vec2(const R7Vec2 &i) {
x = i.x;
y = i.y;
}
// Operators
// Add
R7Vec2 &operator+=(const R7Vec2 &i) {
x += i.x;
y += i.y;
return *this;
}
R7Vec2 operator+(const R7Vec2 &i) const { return R7Vec2(x + i.x, y + i.y); }
// Sub
R7Vec2 &operator-=(const R7Vec2 &i) {
x -= i.x;
y -= i.y;
return *this;
}
R7Vec2 operator-(const R7Vec2 &i) const { return R7Vec2(x - i.x, y - i.y); }
// Compare
bool operator==(const R7Vec2 &in) const { return x == in.x && y == in.y; }
bool operator!=(const R7Vec2 &in) const {
// use the first comparefuncs result
// and swap it lol
return !(*this == in);
}
// Internal Values
float x;
float y;
};

102
include/renderd7/ResultDecoder.hpp
View File

@ -1,51 +1,53 @@
#pragma once #pragma once
#include <3ds.h> #include <3ds.h>
#include <string> #include <string>
namespace RenderD7 { namespace RenderD7 {
/// @brief Decoder for 3ds Result Codes /// @brief Decoder for 3ds Result Codes
class ResultDecoder { class ResultDecoder {
public: public:
/// @brief Constructor /// @brief Constructor
ResultDecoder() {} ResultDecoder() {}
/// @brief Deconstructor /// @brief Deconstructor
~ResultDecoder() {} ~ResultDecoder() {}
/// @brief Load a Result into Decoder /// @brief Load a Result into Decoder
/// @param rescode Result Code /// @param rescode Result Code
void Load(Result rescode); void Load(Result rescode);
/// @brief Load A Hex Converted Code into Decoder /// @brief Load A Hex Converted Code into Decoder
/// @param rescode Result-Hex Code /// @param rescode Result-Hex Code
void Load(std::string rescode); void Load(std::string rescode);
/// @brief Get Hex Code /// @brief Get Hex Code
/// @return Hex-Code /// @return Hex-Code
std::string GetCode(); std::string GetCode();
/// @brief Get Level Name /// @brief Get Level Name
/// @return Level Name /// @return Level Name
std::string GetLevel(); std::string GetLevel();
/// @brief Get Level Value /// @brief Get Level Value
/// @return Level Value /// @return Level Value
int GetLevelInt(); int GetLevelInt();
/// @brief Get The Mosule Name /// @brief Get The Mosule Name
/// @return Module Name /// @return Module Name
std::string GetModule(); std::string GetModule();
/// @brief Get The Module Value /// @brief Get The Module Value
/// @return Module Value /// @return Module Value
int GetModuleInt(); int GetModuleInt();
/// @brief Get The Description /// @brief Get The Description
/// @return Description /// @return Description
std::string GetDescription(); std::string GetDescription();
/// @brief Get The Description Valur /// @brief Get The Description Valur
/// @return Description Value /// @return Description Value
int GetDescriptionInt(); int GetDescriptionInt();
/// @brief Get the Summary /// @brief Get the Summary
/// @return Summary /// @return Summary
std::string GetSummary(); std::string GetSummary();
/// @brief Get the Summary Value /// @brief Get the Summary Value
/// @return Summary Value /// @return Summary Value
int GetSummaryInt(); int GetSummaryInt();
/// @brief Write a Result log file to sd
private: void WriteLog(void);
/// @param m_rescode Result code
Result m_rescode; private:
}; /// @param m_rescode Result code
Result m_rescode;
};
} // namespace RenderD7 } // namespace RenderD7

32
include/renderd7/Screen.hpp
View File

@ -1,16 +1,16 @@
#pragma once #pragma once
#include <citro2d.h> #include <citro2d.h>
#include <citro3d.h> #include <citro3d.h>
/// \param Top Tob-Screen Target /// \param Top Tob-Screen Target
extern C3D_RenderTarget *Top; extern C3D_RenderTarget *Top;
/// \param TopRight Top-Right-Screen Target (Never atually used) /// \param TopRight Top-Right-Screen Target (Never atually used)
extern C3D_RenderTarget *TopRight; extern C3D_RenderTarget *TopRight;
/// \param Bottom Bottom-Screen Target /// \param Bottom Bottom-Screen Target
extern C3D_RenderTarget *Bottom; extern C3D_RenderTarget *Bottom;
namespace RenderD7 { namespace RenderD7 {
/// @brief Begin Drawing On Specific Screen /// @brief Begin Drawing On Specific Screen
/// @param target The Screen Target (Top, Bottom or TopTight) /// @param target The Screen Target (Top, Bottom or TopTight)
void OnScreen(C3D_RenderTarget *target); void OnScreen(C3D_RenderTarget *target);
} // namespace RenderD7 } // namespace RenderD7

118
include/renderd7/Security.hpp
View File

@ -1,60 +1,60 @@
#pragma once #pragma once
#include <cstdint> #include <cstdint>
#include <functional> #include <functional>
#include <string> #include <string>
#include <vector> #include <vector>
#include <3ds.h> #include <3ds.h>
namespace RenderD7 { namespace RenderD7 {
namespace Init { namespace Init {
void Security(); void Security();
} }
class Security { class Security {
public: public:
/// @brief Security Levels /// @brief Security Levels
enum Level { enum Level {
NONE, ///< Do Completly Nothing (excludes FrameEnd Security) NONE, ///< Do Completly Nothing (excludes FrameEnd Security)
FULL, ///< Display Every Reports even Success FULL, ///< Display Every Reports even Success
ERRORS, ///< Display Only Errors ERRORS, ///< Display Only Errors
WARNINGS, ///< Display Errors and Warnings WARNINGS, ///< Display Errors and Warnings
LOG, ///< Log Every Error with Detailed Information LOG, ///< Log Every Error with Detailed Information
}; };
Security(); Security();
~Security(); ~Security();
/// @brief Report an Output (For SafeTraceInit) /// @brief Report an Output (For SafeTraceInit)
/// @param addr Adress of Pointer /// @param addr Adress of Pointer
/// @param result_ptr Pointer to the result /// @param result_ptr Pointer to the result
void Report(uint32_t addr, void *result_ptr); void Report(uint32_t addr, void *result_ptr);
/// @brief Set the Security Level /// @brief Set the Security Level
/// @param level Level to use /// @param level Level to use
void SetLevel(Level level); void SetLevel(Level level);
/// @brief Get Current Security Level /// @brief Get Current Security Level
/// @return Security Level /// @return Security Level
Level GetLevel(); Level GetLevel();
/// @brief Call a Function at Program Crash/Exit /// @brief Call a Function at Program Crash/Exit
/// @param exit_func Function to Call /// @param exit_func Function to Call
void SafeExit(void (*exit_func)()); void SafeExit(void (*exit_func)());
/// @brief SaveInit a Function and define a Exit Func /// @brief SaveInit a Function and define a Exit Func
/// @param init_func Init Function /// @param init_func Init Function
/// @param exit_func Exit Function /// @param exit_func Exit Function
void SafeInit(void (*init_func)(), void (*exit_func)()); void SafeInit(void (*init_func)(), void (*exit_func)());
/// @brief SaveInit a Function and define a Exit Func /// @brief SaveInit a Function and define a Exit Func
/// @param init_func Init Function /// @param init_func Init Function
/// @param exit_func Exit Function /// @param exit_func Exit Function
void SafeInit(Result (*init_func)(), void (*exit_func)()); void SafeInit(Result (*init_func)(), void (*exit_func)());
/// @brief SaveInit a Function and define a Exit Func /// @brief SaveInit a Function and define a Exit Func
/// @param init_func Init Function /// @param init_func Init Function
/// @param exit_func Exit Function /// @param exit_func Exit Function
void SafeInit(void (*init_func)(), Result (*exit_func)()); void SafeInit(void (*init_func)(), Result (*exit_func)());
/// @brief SaveInit a Function and define a Exit Func /// @brief SaveInit a Function and define a Exit Func
/// @param init_func Init Function /// @param init_func Init Function
/// @param exit_func Exit Function /// @param exit_func Exit Function
void SafeInit(Result (*init_func)(), Result (*exit_func)()); void SafeInit(Result (*init_func)(), Result (*exit_func)());
}; };
} // namespace RenderD7 } // namespace RenderD7
/// @brief RenderD7 Security Object /// @brief RenderD7 Security Object
extern RenderD7::Security *rd7_security; extern RenderD7::Security *rd7_security;

44
include/renderd7/Sheet.hpp
View File

@ -1,22 +1,24 @@
#pragma once #pragma once
#include <citro2d.h> #include <citro2d.h>
#include <citro3d.h> #include <citro3d.h>
#include <3ds.h> // Result
namespace RenderD7 { #include <string>
/// @brief SpriteSheet Class
class Sheet { namespace RenderD7 {
public: /// @brief SpriteSheet Class
/// @brief Constructor class Sheet {
Sheet(); public:
/// @brief Deconstructor /// @brief Constructor
~Sheet(); Sheet();
/// @brief Load A Spritesheet File /// @brief Deconstructor
/// @param path Path to the t3x ~Sheet();
/// @return Result Code /// @brief Load A Spritesheet File
Result Load(const char *path); /// @param path Path to the t3x
/// @brief Unload the Sheet /// @return Result Code
void Free(); Result Load(const std::string& path);
/// \param spritesheet The Sheet /// @brief Unload the Sheet
C2D_SpriteSheet spritesheet; void Free();
}; /// \param spritesheet The Sheet
C2D_SpriteSheet spritesheet;
};
} // namespace RenderD7 } // namespace RenderD7

126
include/renderd7/Sprite.hpp
View File

@ -1,64 +1,64 @@
#pragma once #pragma once
#include <citro2d.h> #include <citro2d.h>
#include <citro3d.h> #include <citro3d.h>
#include <renderd7/Image.hpp> #include <renderd7/Image.hpp>
#include <renderd7/Sheet.hpp> #include <renderd7/Sheet.hpp>
namespace RenderD7 { namespace RenderD7 {
/// @brief Sprite Class /// @brief Sprite Class
class Sprite { class Sprite {
public: public:
/// \brief Construct Sprite /// \brief Construct Sprite
Sprite(); Sprite();
/// \brief Deconstruct Sprite /// \brief Deconstruct Sprite
~Sprite(); ~Sprite();
/// \brief Load a Sprite From SpriteSheet /// \brief Load a Sprite From SpriteSheet
/// \param sheet the Sheet to load from.(RenderD7::Sheet) /// \param sheet the Sheet to load from.(RenderD7::Sheet)
/// \param index the number of the Sprite in the Sheet /// \param index the number of the Sprite in the Sheet
void FromSheet(RenderD7::Sheet *sheet, size_t index); void FromSheet(RenderD7::Sheet *sheet, size_t index);
/// \brief Load a Sprite From SpriteSheet /// \brief Load a Sprite From SpriteSheet
/// \param img the Image to load from.(RenderD7::Image) /// \param img the Image to load from.(RenderD7::Image)
void FromImage(RenderD7::Image *img); void FromImage(RenderD7::Image *img);
/// @brief Draw the Sprite /// @brief Draw the Sprite
/// @return success ? /// @return success ?
bool Draw(); bool Draw();
/// @brief Set the Center Position /// @brief Set the Center Position
/// @param x X Pos /// @param x X Pos
/// @param y Y Pos /// @param y Y Pos
void SetCenter(float x, float y); void SetCenter(float x, float y);
/// @brief Set the Sprite's Position /// @brief Set the Sprite's Position
/// @param x X Pos /// @param x X Pos
/// @param y Y Pos /// @param y Y Pos
void SetPos(float x, float y); void SetPos(float x, float y);
/// @brief Set The Sprite's Scale /// @brief Set The Sprite's Scale
/// @param x Scale on X-Axis /// @param x Scale on X-Axis
/// @param y Scale on Y-Axis /// @param y Scale on Y-Axis
void SetScale(float x, float y); void SetScale(float x, float y);
/// @brief Set the Sprite's Rotation /// @brief Set the Sprite's Rotation
/// @param rotation ratation /// @param rotation ratation
void SetRotation(float rotation); void SetRotation(float rotation);
/// @brief Rotate the Sprite /// @brief Rotate the Sprite
/// @param speed Speed to Rotate /// @param speed Speed to Rotate
void Rotate(float speed); void Rotate(float speed);
/// @brief Get Tje Sprite's Width /// @brief Get Tje Sprite's Width
/// @return Width /// @return Width
float getWidth(); float getWidth();
/// @brief Get the Sprite's Height /// @brief Get the Sprite's Height
/// @return Height /// @return Height
float getHeight(); float getHeight();
/// @brief Get The Sprite's X Position /// @brief Get The Sprite's X Position
/// @return X Position /// @return X Position
float getPosX(); float getPosX();
/// @brief Get the Sprite's Y Position /// @brief Get the Sprite's Y Position
/// @return Y Position /// @return Y Position
float getPosY(); float getPosY();
private: private:
/// @param tint ImageTint (unused) /// @param tint ImageTint (unused)
C2D_ImageTint tint; C2D_ImageTint tint;
/// @param sprite The Sprite /// @param sprite The Sprite
C2D_Sprite sprite; C2D_Sprite sprite;
}; };
} // namespace RenderD7 } // namespace RenderD7

80
include/renderd7/SpriteAnimation.hpp
View File

@ -1,41 +1,41 @@
#pragma once #pragma once
#include <renderd7/Sheet.hpp> #include <renderd7/Sheet.hpp>
#include <renderd7/Sprite.hpp> #include <renderd7/Sprite.hpp>
#include <citro2d.h> #include <citro2d.h>
#include <citro3d.h> #include <citro3d.h>
namespace RenderD7 { namespace RenderD7 {
/// @brief SpriteSheetAnimation Class /// @brief SpriteSheetAnimation Class
class SpriteSheetAnimation : public RenderD7::Sprite { class SpriteSheetAnimation : public RenderD7::Sprite {
public: public:
/// @brief Constructor /// @brief Constructor
SpriteSheetAnimation(); SpriteSheetAnimation();
/// @brief Deconstructor /// @brief Deconstructor
~SpriteSheetAnimation(); ~SpriteSheetAnimation();
/// @brief Setup an Animation /// @brief Setup an Animation
/// @param sheet Input Spritesheet /// @param sheet Input Spritesheet
/// @param imagecount Count of Images /// @param imagecount Count of Images
/// @param startimage Where to Start the Loop /// @param startimage Where to Start the Loop
/// @param frame_begin Current Time (Should be 0) /// @param frame_begin Current Time (Should be 0)
/// @param frame_finish Time Length /// @param frame_finish Time Length
void Setup(RenderD7::Sheet *sheet, size_t imagecount, size_t startimage, void Setup(RenderD7::Sheet *sheet, size_t imagecount, size_t startimage,
float frame_begin, float frame_finish); float frame_begin, float frame_finish);
/// @brief Play the Animation /// @brief Play the Animation
/// @param timespeed Speed of the animation /// @param timespeed Speed of the animation
void Play(float timespeed); void Play(float timespeed);
private: private:
/// @param images Count of Images /// @param images Count of Images
size_t images; size_t images;
/// @param imgs Another Count of images ??? /// @param imgs Another Count of images ???
size_t imgs = 0; size_t imgs = 0;
/// @param D_totaltime Current Time /// @param D_totaltime Current Time
float D_totaltime; float D_totaltime;
/// @param sheet The Sheet of Images /// @param sheet The Sheet of Images
RenderD7::Sheet *sheet; RenderD7::Sheet *sheet;
/// @param time Total Time from frame_finish /// @param time Total Time from frame_finish
float time; float time;
}; };
} // namespace RenderD7 } // namespace RenderD7

40
include/renderd7/StealConsole.hpp
View File

@ -1,21 +1,21 @@
#pragma once #pragma once
#include <sstream> #include <sstream>
#include <string> #include <string>
namespace RenderD7 { namespace RenderD7 {
/// @brief StealConsole Class /// @brief StealConsole Class
class StealConsole { class StealConsole {
public: public:
/// @brief Constructor /// @brief Constructor
StealConsole(); StealConsole();
/// @brief Deconstructor /// @brief Deconstructor
~StealConsole(); ~StealConsole();
/// @brief The Stolen Stdout /// @brief The Stolen Stdout
/// @return Stdout as string /// @return Stdout as string
std::string GetStdout(); std::string GetStdout();
private: private:
/// @param stolen_stdout Stolen Stdout /// @param stolen_stdout Stolen Stdout
std::stringstream stolen_stdout; std::stringstream stolen_stdout;
}; };
} // namespace RenderD7 } // namespace RenderD7

24
include/renderd7/Tasks.hpp
View File

@ -1,13 +1,13 @@
#pragma once #pragma once
#include <3ds.h> #include <3ds.h>
#include <vector> #include <vector>
namespace RenderD7 { namespace RenderD7 {
namespace Tasks { namespace Tasks {
/// @brief Push A Task /// @brief Push A Task
/// @param entrypoint Function of Your Task /// @param entrypoint Function of Your Task
void create(ThreadFunc entrypoint); void create(ThreadFunc entrypoint);
/// @brief Destroy all Tasks /// @brief Destroy all Tasks
void destroy(void); void destroy(void);
} // namespace Tasks } // namespace Tasks
} // namespace RenderD7 } // namespace RenderD7

24
include/renderd7/Time.hpp
View File

@ -1,13 +1,13 @@
#pragma once #pragma once
#include <string> #include <string>
namespace RenderD7 { namespace RenderD7 {
/// @brief Format a String /// @brief Format a String
/// @param fmt_str Format To /// @param fmt_str Format To
/// @param ... Additional Args /// @param ... Additional Args
/// @return Formatted String /// @return Formatted String
std::string FormatString(std::string fmt_str, ...); std::string FormatString(std::string fmt_str, ...);
/// @brief Get Current Time as String /// @brief Get Current Time as String
/// @return Time-String /// @return Time-String
std::string GetTimeStr(void); std::string GetTimeStr(void);
} // namespace RenderD7 } // namespace RenderD7

22
include/renderd7/Timer.hpp Normal file
View File

@ -0,0 +1,22 @@
#pragma once
#include <3ds.h>
namespace RenderD7 {
class Timer {
public:
Timer(bool autostart = true);
~Timer() {}
void reset();
void tick();
void pause();
void resume();
float get();
float get_live();
bool running();
private:
uint64_t last = 0;
uint64_t current = 0;
bool is_running = false;
};
}

49
include/renderd7/UI7.hpp Normal file
View File

@ -0,0 +1,49 @@
#pragma once
#include <algorithm>
#include <renderd7/R7Vec.hpp>
#include <renderd7/DrawV2.hpp>
#include <string>
#include <vector>
// UI7: The new RenderD7 UI Standart based on
// Draw2 (based on Citro2D)
#define UI7MAKEFLAG(x) (1 << x)
typedef int UI7MenuFlags;
enum UI7MenuFlags_ {
UI7MenuFlags_None = 0,
UI7MenuFlags_NoTitlebar = UI7MAKEFLAG(0),
UI7MenuFlags_TitleMid = UI7MAKEFLAG(1),
};
namespace UI7 {
// Key functions
void Init();
void Deinit();
void Update();
float GetTime();
float GetDeltaTime();
bool Button(const std::string &label, R7Vec2 size = R7Vec2(0, 0));
void Checkbox(const std::string &label, bool &c);
void Label(const std::string &label, RD7TextFlags flags = 0);
void Progressbar(float value);
/// @brief Draw Image in Menu
/// @param img Pointer f.e to RenderD7::Image2
void Image(RenderD7::Image* img);
void BrowserList(const std::vector<std::string> &entrys, int &selection, RD7TextFlags txtflags = 0,
R7Vec2 size = R7Vec2(0, 0), int max_entrys = 13);
void InputText(const std::string &label, std::string &text,
const std::string &hint = "");
bool BeginMenu(const std::string &title, R7Vec2 size = R7Vec2(0, 0),
UI7MenuFlags flags = 0);
void EndMenu();
void Grid(const std::string& name, const R7Vec2 &size, R7Vec2(*display_func)(void*, R7Vec2), void**data_array, size_t num_entrys);
R7Vec2 GetCursorPos();
void SetCursorPos(R7Vec2 cp);
void RestoreCursor();
void SameLine();
} // namespace UI7

707
include/renderd7/bmp.hpp
View File

@ -1,707 +0,0 @@
#pragma once
#include <fstream>
#include <iostream>
#include <iterator>
#include <sstream>
#include <stdexcept>
#include <vector>
using namespace std;
#pragma pack(push, 1)
struct BMPFileHeader {
uint16_t file_type{0x4D42}; // File type always BM which is 0x4D42 (stored as
// hex uint16_t in little endian)
uint32_t file_size{0}; // Size of the file (in bytes)
uint16_t reserved1{0}; // Reserved, always 0
uint16_t reserved2{0}; // Reserved, always 0
uint32_t offset_data{
0}; // Start position of pixel data (bytes from the beginning of the file)
};
struct BMPInfoHeader {
uint32_t size{0}; // Size of this header (in bytes)
int32_t width{0}; // width of bitmap in pixels
int32_t height{
0}; // height of bitmap in pixels
// (if positive, bottom-up, with origin in lower left corner)
// (if negative, top-down, with origin in upper left corner)
uint16_t planes{1}; // No. of planes for the target device, this is always 1
uint16_t bit_count{0}; // No. of bits per pixel
uint32_t compression{0}; // 0 or 3 - uncompressed. THIS PROGRAM CONSIDERS ONLY
// UNCOMPRESSED BMP images
uint32_t size_image{0}; // 0 - for uncompressed images
int32_t x_pixels_per_meter{0};
int32_t y_pixels_per_meter{0};
uint32_t colors_used{0}; // No. color indexes in the color table. Use 0 for
// the max number of colors allowed by bit_count
uint32_t colors_important{0}; // No. of colors used for displaying the bitmap.
// If 0 all colors are required
};
struct BMPColorHeader {
uint32_t red_mask{0x00ff0000}; // Bit mask for the red channel
uint32_t green_mask{0x0000ff00}; // Bit mask for the green channel
uint32_t blue_mask{0x000000ff}; // Bit mask for the blue channel
uint32_t alpha_mask{0xff000000}; // Bit mask for the alpha channel
uint32_t color_space_type{0x73524742}; // Default "sRGB" (0x73524742)
uint32_t unused[16]{0}; // Unused data for sRGB color space
};
#pragma pack(pop)
class BMP {
public:
BMPFileHeader file_header;
BMPInfoHeader bmp_info_header;
BMPColorHeader bmp_color_header;
std::vector<uint8_t> data;
BMP(const char *fname) { read(fname); }
int read(const char *fname) {
std::ifstream inp{fname, std::ios_base::binary};
if (inp) {
inp.read((char *)&file_header, sizeof(file_header));
if (file_header.file_type != 0x4D42) {
return 50;
// throw std::runtime_error("Error! Unrecognized file format.");
}
inp.read((char *)&bmp_info_header, sizeof(bmp_info_header));
// The BMPColorHeader is used only for transparent images
if (bmp_info_header.bit_count == 32) {
// Check if the file has bit mask color information
if (bmp_info_header.size >=
(sizeof(BMPInfoHeader) + sizeof(BMPColorHeader))) {
inp.read((char *)&bmp_color_header, sizeof(bmp_color_header));
// Check if the pixel data is stored as BGRA and if the color space
// type is sRGB
check_color_header(bmp_color_header);
} else {
// std::cerr << "Error! The file \"" << fname << "\" does not seem to
// contain bit mask information\n"; return 51;//throw
// std::runtime_error("Error! Unrecognized file format.");
}
}
// Jump to the pixel data location
inp.seekg(file_header.offset_data, inp.beg);
// Adjust the header fields for output.
// Some editors will put extra info in the image file, we only save the
// headers and the data.
if (bmp_info_header.bit_count == 32) {
bmp_info_header.size = sizeof(BMPInfoHeader) + sizeof(BMPColorHeader);
file_header.offset_data = sizeof(BMPFileHeader) +
sizeof(BMPInfoHeader) +
sizeof(BMPColorHeader);
} else {
bmp_info_header.size = sizeof(BMPInfoHeader);
file_header.offset_data = sizeof(BMPFileHeader) + sizeof(BMPInfoHeader);
}
file_header.file_size = file_header.offset_data;
if (bmp_info_header.height < 0) {
return 52; // throw std::runtime_error("The program can treat only BMP
// images with the origin in the bottom left corner!");
}
data.resize(bmp_info_header.width * bmp_info_header.height *
bmp_info_header.bit_count / 8);
// Here we check if we need to take into account row padding
if (bmp_info_header.width % 4 == 0) {
inp.read((char *)data.data(), data.size());
file_header.file_size += static_cast<uint32_t>(data.size());
} else {
row_stride = bmp_info_header.width * bmp_info_header.bit_count / 8;
uint32_t new_stride = make_stride_aligned(4);
std::vector<uint8_t> padding_row(new_stride - row_stride);
for (int y = 0; y < bmp_info_header.height; ++y) {
inp.read((char *)(data.data() + row_stride * y), row_stride);
inp.read((char *)padding_row.data(), padding_row.size());
}
file_header.file_size +=
static_cast<uint32_t>(data.size()) +
bmp_info_header.height * static_cast<uint32_t>(padding_row.size());
}
} else {
return 53; // throw std::runtime_error("Unable to open the input image
// file "+std::string(fname));
}
return 0;
}
int read_mem(std::vector<unsigned char> buffer) {
std::stringstream inp;
std::copy(buffer.begin(), buffer.end(),
std::ostream_iterator<unsigned char>(inp, "\n"));
std::cout << buffer.size() << std::endl;
if (inp) {
inp.read((char *)&file_header, sizeof(file_header));
if (file_header.file_type != 0x4D42) {
return 50;
// throw std::runtime_error("Error! Unrecognized file format. Header " +
// std::to_string(file_header.file_type));
}
inp.read((char *)&bmp_info_header, sizeof(bmp_info_header));
// The BMPColorHeader is used only for transparent images
if (bmp_info_header.bit_count == 32) {
// Check if the file has bit mask color information
if (bmp_info_header.size >=
(sizeof(BMPInfoHeader) + sizeof(BMPColorHeader))) {
inp.read((char *)&bmp_color_header, sizeof(bmp_color_header));
// Check if the pixel data is stored as BGRA and if the color space
// type is sRGB
check_color_header(bmp_color_header);
} else {
// std::cerr << "Error! The file \"" << fname << "\" does not seem to
// contain bit mask information\n";
return 51;
// throw std::runtime_error("Error! Unrecognized file format. Size");
}
}
// Jump to the pixel data location
inp.seekg(file_header.offset_data, inp.beg);
// Adjust the header fields for output.
// Some editors will put extra info in the image file, we only save the
// headers and the data.
if (bmp_info_header.bit_count == 32) {
bmp_info_header.size = sizeof(BMPInfoHeader) + sizeof(BMPColorHeader);
file_header.offset_data = sizeof(BMPFileHeader) +
sizeof(BMPInfoHeader) +
sizeof(BMPColorHeader);
} else {
bmp_info_header.size = sizeof(BMPInfoHeader);
file_header.offset_data = sizeof(BMPFileHeader) + sizeof(BMPInfoHeader);
}
file_header.file_size = file_header.offset_data;
if (bmp_info_header.height < 0) {
return 52;
// throw std::runtime_error("The program can treat only BMP images with
// "
// "the origin in the bottom left corner!");
}
data.resize(bmp_info_header.width * bmp_info_header.height *
bmp_info_header.bit_count / 8);
// Here we check if we need to take into account row padding
if (bmp_info_header.width % 4 == 0) {
inp.read((char *)data.data(), data.size());
file_header.file_size += static_cast<uint32_t>(data.size());
} else {
row_stride = bmp_info_header.width * bmp_info_header.bit_count / 8;
uint32_t new_stride = make_stride_aligned(4);
std::vector<uint8_t> padding_row(new_stride - row_stride);
for (int y = 0; y < bmp_info_header.height; ++y) {
inp.read((char *)(data.data() + row_stride * y), row_stride);
inp.read((char *)padding_row.data(), padding_row.size());
}
file_header.file_size +=
static_cast<uint32_t>(data.size()) +
bmp_info_header.height * static_cast<uint32_t>(padding_row.size());
}
} else {
return 53;
// throw std::runtime_error("Unable to open the input image buffer");
}
return 0;
}
BMP(int32_t width, int32_t height, bool has_alpha = true) {
if (width <= 0 || height <= 0) {
width = 1;
height = 1;
}
bmp_info_header.width = width;
bmp_info_header.height = height;
if (has_alpha) {
bmp_info_header.size = sizeof(BMPInfoHeader) + sizeof(BMPColorHeader);
file_header.offset_data = sizeof(BMPFileHeader) + sizeof(BMPInfoHeader) +
sizeof(BMPColorHeader);
bmp_info_header.bit_count = 32;
bmp_info_header.compression = 3;
row_stride = width * 4;
data.resize(row_stride * height);
file_header.file_size = file_header.offset_data + data.size();
} else {
bmp_info_header.size = sizeof(BMPInfoHeader);
file_header.offset_data = sizeof(BMPFileHeader) + sizeof(BMPInfoHeader);
bmp_info_header.bit_count = 24;
bmp_info_header.compression = 0;
row_stride = width * 3;
data.resize(row_stride * height);
uint32_t new_stride = make_stride_aligned(4);
file_header.file_size =
file_header.offset_data + static_cast<uint32_t>(data.size()) +
bmp_info_header.height * (new_stride - row_stride);
}
}
unsigned write(const char *fname) {
std::ofstream of{fname, std::ios_base::binary};
if (of) {
if (bmp_info_header.bit_count == 32) {
write_headers_and_data(of);
} else if (bmp_info_header.bit_count == 24) {
if (bmp_info_header.width % 4 == 0) {
write_headers_and_data(of);
} else {
uint32_t new_stride = make_stride_aligned(4);
std::vector<uint8_t> padding_row(new_stride - row_stride);
write_headers(of);
for (int y = 0; y < bmp_info_header.height; ++y) {
of.write((const char *)(data.data() + row_stride * y), row_stride);
of.write((const char *)padding_row.data(), padding_row.size());
}
}
} else {
return 54; // throw std::runtime_error("The program can treat only 24 or
// 32 bits per pixel BMP files");
}
} else {
return 55; // throw std::runtime_error("Unable to open the output image
// file.");
}
return 0;
}
std::vector<unsigned char> DATA() {
std::stringstream ss;
if (ss) {
if (bmp_info_header.bit_count == 32) {
write_headers_and_datass(ss);
} else if (bmp_info_header.bit_count == 24) {
if (bmp_info_header.width % 4 == 0) {
write_headers_and_datass(ss);
} else {
uint32_t new_stride = make_stride_aligned(4);
std::vector<uint8_t> padding_row(new_stride - row_stride);
write_headersss(ss);
for (int y = 0; y < bmp_info_header.height; ++y) {
ss.write((const char *)(data.data() + row_stride * y), row_stride);
ss.write((const char *)padding_row.data(), padding_row.size());
}
}
} else {
}
} else {
}
std::string test11 = ss.str();
std::vector<unsigned char> test12(test11.begin(), test11.end());
return test12;
}
unsigned fill_region(uint32_t x0, uint32_t y0, uint32_t w, uint32_t h,
uint8_t B, uint8_t G, uint8_t R, uint8_t A) {
uint32_t channels = bmp_info_header.bit_count / 8;
for (uint32_t y = y0; y < y0 + h; ++y) {
for (uint32_t x = x0; x < x0 + w; ++x) {
/*if (x + w > (uint32_t)bmp_info_header.width || y + h >
(uint32_t)bmp_info_header.height) {
//
}*/
// else{
data[channels * (y * bmp_info_header.width + x) + 0] = B;
data[channels * (y * bmp_info_header.width + x) + 1] = G;
data[channels * (y * bmp_info_header.width + x) + 2] = R;
if (channels == 4) {
data[channels * (y * bmp_info_header.width + x) + 3] = A;
}
//}
}
}
return 0;
}
void fill_region_df(uint32_t x1, uint32_t y1, uint32_t w, uint32_t h,
uint8_t B, uint8_t G, uint8_t R, uint8_t A) {
int x0 = x1;
int y0 = this->bmp_info_header.height - y1 - h;
uint32_t channels = bmp_info_header.bit_count / 8;
for (uint32_t y = y0; y < y0 + h; ++y) {
for (uint32_t x = x0; x < x0 + w; ++x) {
if ((x + w < (uint32_t)bmp_info_header.width) ||
this->bmp_info_header.height - y - h > 0) {
data[channels * (y * bmp_info_header.width + x) + 0] = B;
data[channels * (y * bmp_info_header.width + x) + 1] = G;
data[channels * (y * bmp_info_header.width + x) + 2] = R;
if (channels == 4) {
data[channels * (y * bmp_info_header.width + x) + 3] = A;
}
}
}
}
}
void manipulate_region(uint32_t x0, uint32_t y0, uint32_t w, uint32_t h,
uint8_t A) {
int choice, choice2, intensity;
cout << "What color do you want to change? " << endl;
cout << "Enter 1 for Blue, 2 for Green, 3 for Red " << endl;
cin >> choice;
cout << "To what color do you want to change it too?" << endl;
cout << "Enter 1 for Blue, 2 for Green, 3 for Red " << endl;
cin >> choice2;
cout << "Enter the intensity of the color. (From 0 to 255) " << endl;
cin >> intensity;
if (x0 + w > (uint32_t)bmp_info_header.width ||
y0 + h > (uint32_t)bmp_info_header.height) {
return; // throw std::runtime_error("The region does not fit in the
// image!");
}
uint32_t channels = bmp_info_header.bit_count / 8;
if (choice == 1 && choice2 == 1) {
for (uint32_t y = y0; y < y0 + h; ++y) {
for (uint32_t x = x0; x < x0 + w; ++x) {
cout << channels * (y * bmp_info_header.width + x) << endl;
// Make blue thing blue
if (data[channels * (y * bmp_info_header.width + x) + 0] > 80 &&
data[channels * (y * bmp_info_header.width + x) + 0] < 255) {
data[channels * (y * bmp_info_header.width + x) + 0] = intensity;
data[channels * (y * bmp_info_header.width + x) + 1] = 0;
data[channels * (y * bmp_info_header.width + x) + 2] = 0;
}
// data[channels * (y * bmp_info_header.width + x) + 0] = B;
// data[channels * (y * bmp_info_header.width + x) + 1] = G;
// data[channels * (y * bmp_info_header.width + x) + 2] = R;
if (channels == 4) {
data[channels * (y * bmp_info_header.width + x) + 3] = A;
}
}
}
}
if (choice == 1 && choice2 == 2) {
for (uint32_t y = y0; y < y0 + h; ++y) {
for (uint32_t x = x0; x < x0 + w; ++x) {
cout << channels * (y * bmp_info_header.width + x) << endl;
// Make blue thing green
if (data[channels * (y * bmp_info_header.width + x) + 0] > 80 &&
data[channels * (y * bmp_info_header.width + x) + 0] < 255) {
data[channels * (y * bmp_info_header.width + x) + 0] = 0;
data[channels * (y * bmp_info_header.width + x) + 1] = intensity;
data[channels * (y * bmp_info_header.width + x) + 2] = 0;
}
if (channels == 4) {
data[channels * (y * bmp_info_header.width + x) + 3] = A;
}
}
}
}
if (choice == 1 && choice2 == 3) {
for (uint32_t y = y0; y < y0 + h; ++y) {
for (uint32_t x = x0; x < x0 + w; ++x) {
cout << channels * (y * bmp_info_header.width + x) << endl;
// Make blue thing red
if (data[channels * (y * bmp_info_header.width + x) + 0] > 80 &&
data[channels * (y * bmp_info_header.width + x) + 0] < 255) {
data[channels * (y * bmp_info_header.width + x) + 0] = 0;
data[channels * (y * bmp_info_header.width + x) + 1] = 0;
data[channels * (y * bmp_info_header.width + x) + 2] = intensity;
}
if (channels == 4) {
data[channels * (y * bmp_info_header.width + x) + 3] = A;
}
}
}
}
if (choice == 2 && choice2 == 1) {
for (uint32_t y = y0; y < y0 + h; ++y) {
for (uint32_t x = x0; x < x0 + w; ++x) {
cout << channels * (y * bmp_info_header.width + x) << endl;
// Make green thing blue
if (data[channels * (y * bmp_info_header.width + x) + 1] > 80 &&
data[channels * (y * bmp_info_header.width + x) + 1] < 255) {
data[channels * (y * bmp_info_header.width + x) + 0] = intensity;
data[channels * (y * bmp_info_header.width + x) + 1] = 0;
data[channels * (y * bmp_info_header.width + x) + 2] = 0;
}
if (channels == 4) {
data[channels * (y * bmp_info_header.width + x) + 3] = A;
}
}
}
}
if (choice == 2 && choice2 == 2) {
for (uint32_t y = y0; y < y0 + h; ++y) {
for (uint32_t x = x0; x < x0 + w; ++x) {
cout << channels * (y * bmp_info_header.width + x) << endl;
// Make green thing green
if (data[channels * (y * bmp_info_header.width + x) + 1] > 80 &&
data[channels * (y * bmp_info_header.width + x) + 1] < 255) {
data[channels * (y * bmp_info_header.width + x) + 0] = 0;
data[channels * (y * bmp_info_header.width + x) + 1] = intensity;
data[channels * (y * bmp_info_header.width + x) + 2] = 0;
}
if (channels == 4) {
data[channels * (y * bmp_info_header.width + x) + 3] = A;
}
}
}
}
if (choice == 2 && choice2 == 3) {
for (uint32_t y = y0; y < y0 + h; ++y) {
for (uint32_t x = x0; x < x0 + w; ++x) {
cout << channels * (y * bmp_info_header.width + x) << endl;
// Make green thing red
if (data[channels * (y * bmp_info_header.width + x) + 1] > 80 &&
data[channels * (y * bmp_info_header.width + x) + 1] < 255) {
data[channels * (y * bmp_info_header.width + x) + 0] = 0;
data[channels * (y * bmp_info_header.width + x) + 1] = 0;
data[channels * (y * bmp_info_header.width + x) + 2] = intensity;
}
if (channels == 4) {
data[channels * (y * bmp_info_header.width + x) + 3] = A;
}
}
}
}
if (choice == 3 && choice2 == 1) {
for (uint32_t y = y0; y < y0 + h; ++y) {
for (uint32_t x = x0; x < x0 + w; ++x) {
cout << channels * (y * bmp_info_header.width + x) << endl;
// Make red thing blue
if (data[channels * (y * bmp_info_header.width + x) + 2] > 80 &&
data[channels * (y * bmp_info_header.width + x) + 2] < 255) {
data[channels * (y * bmp_info_header.width + x) + 0] = intensity;
data[channels * (y * bmp_info_header.width + x) + 1] = 0;
data[channels * (y * bmp_info_header.width + x) + 2] = 0;
}
if (channels == 4) {
data[channels * (y * bmp_info_header.width + x) + 3] = A;
}
}
}
}
if (choice == 3 && choice2 == 2) {
for (uint32_t y = y0; y < y0 + h; ++y) {
for (uint32_t x = x0; x < x0 + w; ++x) {
cout << channels * (y * bmp_info_header.width + x) << endl;
// Make red thing green
if (data[channels * (y * bmp_info_header.width + x) + 2] > 80 &&
data[channels * (y * bmp_info_header.width + x) + 2] < 255) {
data[channels * (y * bmp_info_header.width + x) + 0] = 0;
data[channels * (y * bmp_info_header.width + x) + 1] = intensity;
data[channels * (y * bmp_info_header.width + x) + 2] = 0;
}
if (channels == 4) {
data[channels * (y * bmp_info_header.width + x) + 3] = A;
}
}
}
}
if (choice == 3 && choice2 == 3) {
for (uint32_t y = y0; y < y0 + h; ++y) {
for (uint32_t x = x0; x < x0 + w; ++x) {
cout << channels * (y * bmp_info_header.width + x) << endl;
// Make red thing blue
if (data[channels * (y * bmp_info_header.width + x) + 2] > 80 &&
data[channels * (y * bmp_info_header.width + x) + 2] < 255) {
data[channels * (y * bmp_info_header.width + x) + 0] = 0;
data[channels * (y * bmp_info_header.width + x) + 1] = 0;
data[channels * (y * bmp_info_header.width + x) + 2] = intensity;
}
if (channels == 4) {
data[channels * (y * bmp_info_header.width + x) + 3] = A;
}
}
}
}
}
unsigned set_pixel(uint32_t x0, uint32_t y0, uint8_t B, uint8_t G, uint8_t R,
uint8_t A) {
if (x0 >= (uint32_t)bmp_info_header.width ||
y0 >= (uint32_t)bmp_info_header.height || x0 < 0 || y0 < 0) {
return 59;
// std::string errr = "The point is outside the image boundaries! -> " +
// std::to_string(x0) + "," + std::to_string(y0); throw
// std::runtime_error(errr);
}
uint32_t channels = bmp_info_header.bit_count / 8;
data[channels * (y0 * bmp_info_header.width + x0) + 0] = B;
data[channels * (y0 * bmp_info_header.width + x0) + 1] = G;
data[channels * (y0 * bmp_info_header.width + x0) + 2] = R;
if (channels == 4) {
data[channels * (y0 * bmp_info_header.width + x0) + 3] = A;
}
return 0;
}
void set_pixel_df(uint32_t x0, uint32_t y0, uint8_t B, uint8_t G, uint8_t R,
uint8_t A) {
uint32_t y1 = this->bmp_info_header.height - y0;
if (x0 >= (uint32_t)bmp_info_header.width ||
y1 <= (uint32_t)bmp_info_header.width || x0 < 0 || y0 > 0) {
return;
// throw std::runtime_error("The point is outside the image boundaries! ->
// " + std::to_string(x0) + "," + std::to_string(y1));
}
uint32_t channels = bmp_info_header.bit_count / 8;
data[channels * (y0 * bmp_info_header.width + x0) + 0] = B;
data[channels * (y0 * bmp_info_header.width + x0) + 1] = G;
data[channels * (y0 * bmp_info_header.width + x0) + 2] = R;
if (channels == 4) {
data[channels * (y0 * bmp_info_header.width + x0) + 3] = A;
}
}
uint32_t get_pixel(uint32_t x0, uint32_t y0) {
if (x0 >= (uint32_t)bmp_info_header.width ||
y0 >= (uint32_t)bmp_info_header.height || x0 < 0 || y0 < 0) {
return 59; // throw std::runtime_error("The point is outside the image
// boundaries!");
}
uint32_t channels = bmp_info_header.bit_count / 8;
uint32_t outcol = 0;
uint8_t red = 0;
uint8_t green = 0;
uint8_t blue = 0;
uint8_t alpha = 255;
blue = data[channels * (y0 * bmp_info_header.width + x0) + 0];
green = data[channels * (y0 * bmp_info_header.width + x0) + 1];
red = data[channels * (y0 * bmp_info_header.width + x0) + 2];
if (channels == 4) {
alpha = data[channels * (y0 * bmp_info_header.width + x0) + 3];
}
outcol = ((red << 24) | (green << 16) | (blue << 8) | alpha);
return outcol;
}
uint32_t get_pixel_df(uint32_t x0, uint32_t y0) {
uint32_t y1 = this->bmp_info_header.height - y0;
if (x0 >= (uint32_t)bmp_info_header.width ||
y1 <= (uint32_t)bmp_info_header.width || x0 < 0 || y0 > 0) {
return 0; // throw std::runtime_error("The point is outside the image
// boundaries!");
}
uint32_t channels = bmp_info_header.bit_count / 8;
uint32_t outcol = 0;
uint8_t red = 0;
uint8_t green = 0;
uint8_t blue = 0;
uint8_t alpha = 255;
blue = data[channels * (y0 * bmp_info_header.width + x0) + 0];
green = data[channels * (y0 * bmp_info_header.width + x0) + 1];
red = data[channels * (y0 * bmp_info_header.width + x0) + 2];
if (channels == 4) {
alpha = data[channels * (y0 * bmp_info_header.width + x0) + 3];
}
outcol = ((red << 24) | (green << 16) | (blue << 8) | alpha);
return outcol;
}
unsigned draw_rectangle(uint32_t x0, uint32_t y0, uint32_t w, uint32_t h,
uint8_t B, uint8_t G, uint8_t R, uint8_t A,
uint8_t line_w) {
if (x0 + w > (uint32_t)bmp_info_header.width ||
y0 + h > (uint32_t)bmp_info_header.height) {
return 59; // throw std::runtime_error("The rectangle does not fit in the
// image!");
}
fill_region(x0, y0, w, line_w, B, G, R, A); // top line
fill_region(x0, (y0 + h - line_w), w, line_w, B, G, R, A); // bottom line
fill_region((x0 + w - line_w), (y0 + line_w), line_w, (h - (2 * line_w)), B,
G, R, A); // right line
fill_region(x0, (y0 + line_w), line_w, (h - (2 * line_w)), B, G, R,
A); // left line
return 0;
}
void draw_rectangle_df(uint32_t x0, uint32_t y0, uint32_t w, uint32_t h,
uint8_t B, uint8_t G, uint8_t R, uint8_t A,
uint8_t line_w) {
if (x0 + w > (uint32_t)bmp_info_header.width ||
y0 + h > (uint32_t)bmp_info_header.height) {
return; // throw std::runtime_error("The rectangle does not fit in the
// image!");
}
fill_region_df(x0, y0, w, line_w, B, G, R, A); // top line
fill_region_df(x0, (y0 + h - line_w), w, line_w, B, G, R, A); // bottom line
fill_region_df((x0 + w - line_w), (y0 + line_w), line_w, (h - (2 * line_w)),
B, G, R, A); // right line
fill_region_df(x0, (y0 + line_w), line_w, (h - (2 * line_w)), B, G, R,
A); // left line
}
private:
uint32_t row_stride{0};
void write_headers(std::ofstream &of) {
of.write((const char *)&file_header, sizeof(file_header));
of.write((const char *)&bmp_info_header, sizeof(bmp_info_header));
if (bmp_info_header.bit_count == 32) {
of.write((const char *)&bmp_color_header, sizeof(bmp_color_header));
}
}
void write_headers_and_data(std::ofstream &of) {
write_headers(of);
of.write((const char *)data.data(), data.size());
}
void write_headersss(std::stringstream &of) {
of.write((const char *)&file_header, sizeof(file_header));
of.write((const char *)&bmp_info_header, sizeof(bmp_info_header));
if (bmp_info_header.bit_count == 32) {
of.write((const char *)&bmp_color_header, sizeof(bmp_color_header));
}
}
void write_headers_and_datass(std::stringstream &of) {
write_headersss(of);
of.write((const char *)data.data(), data.size());
}
// Add 1 to the row_stride until it is divisible with align_stride
uint32_t make_stride_aligned(uint32_t align_stride) {
uint32_t new_stride = row_stride;
while (new_stride % align_stride != 0) {
new_stride++;
}
return new_stride;
}
// Check if the pixel data is stored as BGRA and if the color space type is
// sRGB
void check_color_header(BMPColorHeader &bmp_color_header) {
BMPColorHeader expected_color_header;
if (expected_color_header.red_mask != bmp_color_header.red_mask ||
expected_color_header.blue_mask != bmp_color_header.blue_mask ||
expected_color_header.green_mask != bmp_color_header.green_mask ||
expected_color_header.alpha_mask != bmp_color_header.alpha_mask) {
return; // throw std::runtime_error("Unexpected color mask format! The
// program expects the pixel data to be in the BGRA format");
}
if (expected_color_header.color_space_type !=
bmp_color_header.color_space_type) {
return; // throw std::runtime_error("Unexpected color space type! The
// program expects sRGB values");
}
}
};

21
include/renderd7/bmpconverter.hpp
View File

@ -1,21 +0,0 @@
#pragma once
#include <renderd7/external/lodepng.h>
#include <iostream>
namespace BitmapConverter {
/// returns 0 if all went ok, non-0 if error
/// output image is always given in RGBA (with alpha channel), even if it's a
/// BMP without alpha channel
unsigned decodeBMP(std::vector<unsigned char> &image, unsigned &w, unsigned &h,
const std::vector<unsigned char> &bmp);
/// @brief Convert A File
/// @param filename
/// @return data
std::vector<unsigned char> ConvertFile(std::string filename);
/// @brief Convert data
/// @param data
/// @return data
std::vector<unsigned char> ConvertData(std::vector<unsigned char> data);
} // namespace BitmapConverter

187
include/renderd7/debugfont.h
View File

@ -1,187 +0,0 @@
/*
This file was autogenerated by raw2c.
Visit http://www.devkitpro.org
*/
//---------------------------------------------------------------------------------
#ifndef _debugfont_h_
#define _debugfont_h_
//---------------------------------------------------------------------------------
static const unsigned char debugfont[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x81, 0xa5, 0x81,
0xbd, 0x99, 0x81, 0x7e, 0x7e, 0xff, 0xdb, 0xff, 0xc3, 0xe7, 0xff, 0x7e,
0x6c, 0xfe, 0xfe, 0xfe, 0x7c, 0x38, 0x10, 0x00, 0x10, 0x38, 0x7c, 0xfe,
0x7c, 0x38, 0x10, 0x00, 0x3c, 0x3c, 0x18, 0xff, 0xe7, 0x18, 0x3c, 0x00,
0x10, 0x38, 0x7c, 0xfe, 0xee, 0x10, 0x38, 0x00, 0x00, 0x00, 0x18, 0x3c,
0x3c, 0x18, 0x00, 0x00, 0xff, 0xff, 0xe7, 0xc3, 0xc3, 0xe7, 0xff, 0xff,
0x00, 0x3c, 0x66, 0x42, 0x42, 0x66, 0x3c, 0x00, 0xff, 0xc3, 0x99, 0xbd,
0xbd, 0x99, 0xc3, 0xff, 0x0f, 0x07, 0x0f, 0x7d, 0xcc, 0xcc, 0xcc, 0x78,
0x3c, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x7e, 0x18, 0x08, 0x0c, 0x0a, 0x0a,
0x08, 0x78, 0xf0, 0x00, 0x18, 0x14, 0x1a, 0x16, 0x72, 0xe2, 0x0e, 0x1c,
0x10, 0x54, 0x38, 0xee, 0x38, 0x54, 0x10, 0x00, 0x80, 0xe0, 0xf8, 0xfe,
0xf8, 0xe0, 0x80, 0x00, 0x02, 0x0e, 0x3e, 0xfe, 0x3e, 0x0e, 0x02, 0x00,
0x18, 0x3c, 0x5a, 0x18, 0x5a, 0x3c, 0x18, 0x00, 0x66, 0x66, 0x66, 0x66,
0x66, 0x00, 0x66, 0x00, 0x7f, 0xdb, 0xdb, 0xdb, 0x7b, 0x1b, 0x1b, 0x00,
0x1c, 0x22, 0x38, 0x44, 0x44, 0x38, 0x88, 0x70, 0x00, 0x00, 0x00, 0x00,
0x7e, 0x7e, 0x7e, 0x00, 0x18, 0x3c, 0x5a, 0x18, 0x5a, 0x3c, 0x18, 0x7e,
0x18, 0x3c, 0x5a, 0x18, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x18,
0x5a, 0x3c, 0x18, 0x00, 0x00, 0x18, 0x0c, 0xfe, 0x0c, 0x18, 0x00, 0x00,
0x00, 0x30, 0x60, 0xfe, 0x60, 0x30, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0,
0xc0, 0xfe, 0x00, 0x00, 0x00, 0x24, 0x42, 0xff, 0x42, 0x24, 0x00, 0x00,
0x00, 0x10, 0x38, 0x7c, 0xfe, 0xfe, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0x7c,
0x38, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x18, 0x3c, 0x3c, 0x18, 0x18, 0x00, 0x18, 0x00, 0x6c, 0x24, 0x24, 0x00,
0x00, 0x00, 0x00, 0x00, 0x6c, 0x6c, 0xfe, 0x6c, 0xfe, 0x6c, 0x6c, 0x00,
0x10, 0x7c, 0xd0, 0x7c, 0x16, 0xfc, 0x10, 0x00, 0x00, 0x66, 0xac, 0xd8,
0x36, 0x6a, 0xcc, 0x00, 0x38, 0x4c, 0x38, 0x78, 0xce, 0xcc, 0x7a, 0x00,
0x30, 0x10, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x30, 0x60, 0x60,
0x60, 0x30, 0x18, 0x00, 0x60, 0x30, 0x18, 0x18, 0x18, 0x30, 0x60, 0x00,
0x00, 0x66, 0x3c, 0xff, 0x3c, 0x66, 0x00, 0x00, 0x00, 0x30, 0x30, 0xfc,
0x30, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x10, 0x20,
0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x30, 0x00, 0x02, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0x00,
0x7c, 0xce, 0xde, 0xf6, 0xe6, 0xe6, 0x7c, 0x00, 0x18, 0x38, 0x78, 0x18,
0x18, 0x18, 0x7e, 0x00, 0x7c, 0xc6, 0x06, 0x1c, 0x70, 0xc6, 0xfe, 0x00,
0x7c, 0xc6, 0x06, 0x3c, 0x06, 0xc6, 0x7c, 0x00, 0x1c, 0x3c, 0x6c, 0xcc,
0xfe, 0x0c, 0x1e, 0x00, 0xfe, 0xc0, 0xfc, 0x06, 0x06, 0xc6, 0x7c, 0x00,
0x7c, 0xc6, 0xc0, 0xfc, 0xc6, 0xc6, 0x7c, 0x00, 0xfe, 0xc6, 0x0c, 0x18,
0x30, 0x30, 0x30, 0x00, 0x7c, 0xc6, 0xc6, 0x7c, 0xc6, 0xc6, 0x7c, 0x00,
0x7c, 0xc6, 0xc6, 0x7e, 0x06, 0xc6, 0x7c, 0x00, 0x00, 0x30, 0x00, 0x00,
0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x10, 0x20,
0x0c, 0x18, 0x30, 0x60, 0x30, 0x18, 0x0c, 0x00, 0x00, 0x00, 0x7e, 0x00,
0x00, 0x7e, 0x00, 0x00, 0x60, 0x30, 0x18, 0x0c, 0x18, 0x30, 0x60, 0x00,
0x78, 0xcc, 0x0c, 0x18, 0x30, 0x00, 0x30, 0x00, 0x7c, 0x82, 0x9e, 0xa6,
0x9e, 0x80, 0x7c, 0x00, 0x7c, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0x00,
0xfc, 0x66, 0x66, 0x7c, 0x66, 0x66, 0xfc, 0x00, 0x7c, 0xc6, 0xc0, 0xc0,
0xc0, 0xc6, 0x7c, 0x00, 0xfc, 0x66, 0x66, 0x66, 0x66, 0x66, 0xfc, 0x00,
0xfe, 0x62, 0x68, 0x78, 0x68, 0x62, 0xfe, 0x00, 0xfe, 0x62, 0x68, 0x78,
0x68, 0x60, 0xf0, 0x00, 0x7c, 0xc6, 0xc6, 0xc0, 0xce, 0xc6, 0x7e, 0x00,
0xc6, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0x00, 0x3c, 0x18, 0x18, 0x18,
0x18, 0x18, 0x3c, 0x00, 0x1e, 0x0c, 0x0c, 0x0c, 0xcc, 0xcc, 0x78, 0x00,
0xe6, 0x66, 0x6c, 0x78, 0x6c, 0x66, 0xe6, 0x00, 0xf0, 0x60, 0x60, 0x60,
0x62, 0x66, 0xfe, 0x00, 0x82, 0xc6, 0xee, 0xfe, 0xd6, 0xc6, 0xc6, 0x00,
0xc6, 0xe6, 0xf6, 0xde, 0xce, 0xc6, 0xc6, 0x00, 0x7c, 0xc6, 0xc6, 0xc6,
0xc6, 0xc6, 0x7c, 0x00, 0xfc, 0x66, 0x66, 0x7c, 0x60, 0x60, 0xf0, 0x00,
0x7c, 0xc6, 0xc6, 0xc6, 0xd6, 0xde, 0x7c, 0x06, 0xfc, 0x66, 0x66, 0x7c,
0x66, 0x66, 0xe6, 0x00, 0x7c, 0xc6, 0xc0, 0x7c, 0x06, 0xc6, 0x7c, 0x00,
0x7e, 0x5a, 0x5a, 0x18, 0x18, 0x18, 0x3c, 0x00, 0xc6, 0xc6, 0xc6, 0xc6,
0xc6, 0xc6, 0x7c, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0x6c, 0x38, 0x10, 0x00,
0xc6, 0xc6, 0xd6, 0xfe, 0xee, 0xc6, 0x82, 0x00, 0xc6, 0x6c, 0x38, 0x38,
0x38, 0x6c, 0xc6, 0x00, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x18, 0x3c, 0x00,
0xfe, 0xc6, 0x8c, 0x18, 0x32, 0x66, 0xfe, 0x00, 0x78, 0x60, 0x60, 0x60,
0x60, 0x60, 0x78, 0x00, 0xc0, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x02, 0x00,
0x78, 0x18, 0x18, 0x18, 0x18, 0x18, 0x78, 0x00, 0x10, 0x38, 0x6c, 0xc6,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
0x30, 0x20, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x0c,
0x7c, 0xcc, 0x76, 0x00, 0xe0, 0x60, 0x60, 0x7c, 0x66, 0x66, 0x7c, 0x00,
0x00, 0x00, 0x7c, 0xc6, 0xc0, 0xc6, 0x7c, 0x00, 0x1c, 0x0c, 0x0c, 0x7c,
0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0x7c, 0x00,
0x1c, 0x36, 0x30, 0x78, 0x30, 0x30, 0x78, 0x00, 0x00, 0x00, 0x76, 0xcc,
0xcc, 0x7c, 0x0c, 0x78, 0xe0, 0x60, 0x6c, 0x76, 0x66, 0x66, 0xe6, 0x00,
0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x0c, 0x00, 0x1c,
0x0c, 0x0c, 0xcc, 0x78, 0xe0, 0x60, 0x66, 0x6c, 0x78, 0x6c, 0xe6, 0x00,
0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0xcc, 0xfe,
0xd6, 0xd6, 0xd6, 0x00, 0x00, 0x00, 0xdc, 0x66, 0x66, 0x66, 0x66, 0x00,
0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0xdc, 0x66,
0x66, 0x7c, 0x60, 0xf0, 0x00, 0x00, 0x7c, 0xcc, 0xcc, 0x7c, 0x0c, 0x1e,
0x00, 0x00, 0xde, 0x76, 0x60, 0x60, 0xf0, 0x00, 0x00, 0x00, 0x7c, 0xc0,
0x7c, 0x06, 0x7c, 0x00, 0x10, 0x30, 0xfc, 0x30, 0x30, 0x34, 0x18, 0x00,
0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0xc6, 0xc6,
0x6c, 0x38, 0x10, 0x00, 0x00, 0x00, 0xc6, 0xd6, 0xd6, 0xfe, 0x6c, 0x00,
0x00, 0x00, 0xc6, 0x6c, 0x38, 0x6c, 0xc6, 0x00, 0x00, 0x00, 0xcc, 0xcc,
0xcc, 0x7c, 0x0c, 0xf8, 0x00, 0x00, 0xfc, 0x98, 0x30, 0x64, 0xfc, 0x00,
0x0e, 0x18, 0x18, 0x30, 0x18, 0x18, 0x0e, 0x00, 0x18, 0x18, 0x18, 0x00,
0x18, 0x18, 0x18, 0x00, 0xe0, 0x30, 0x30, 0x18, 0x30, 0x30, 0xe0, 0x00,
0x76, 0xdc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x6c,
0xc6, 0xc6, 0xfe, 0x00, 0x7c, 0xc6, 0xc0, 0xc0, 0xc6, 0x7c, 0x18, 0x70,
0xcc, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x0e, 0x10, 0x7c, 0xc6,
0xfe, 0xc0, 0x7c, 0x00, 0x7c, 0x82, 0x38, 0x0c, 0x7c, 0xcc, 0x76, 0x00,
0xcc, 0x00, 0x78, 0x0c, 0x7c, 0xcc, 0x76, 0x00, 0xe0, 0x10, 0x78, 0x0c,
0x7c, 0xcc, 0x76, 0x00, 0x30, 0x30, 0x78, 0x0c, 0x7c, 0xcc, 0x76, 0x00,
0x00, 0x00, 0x7c, 0xc0, 0xc0, 0x7c, 0x18, 0x70, 0x7c, 0x82, 0x7c, 0xc6,
0xfe, 0xc0, 0x7c, 0x00, 0xc6, 0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0x7c, 0x00,
0xe0, 0x10, 0x7c, 0xc6, 0xfe, 0xc0, 0x7c, 0x00, 0x66, 0x00, 0x38, 0x18,
0x18, 0x18, 0x3c, 0x00, 0x7c, 0x82, 0x38, 0x18, 0x18, 0x18, 0x3c, 0x00,
0xe0, 0x10, 0x38, 0x18, 0x18, 0x18, 0x3c, 0x00, 0xc6, 0x00, 0x7c, 0xc6,
0xfe, 0xc6, 0xc6, 0x00, 0x38, 0x38, 0x7c, 0xc6, 0xfe, 0xc6, 0xc6, 0x00,
0x0e, 0x10, 0xfe, 0x60, 0x78, 0x60, 0xfe, 0x00, 0x00, 0x00, 0x7c, 0x12,
0x7e, 0xd0, 0x7e, 0x00, 0x7e, 0xc8, 0xc8, 0xfe, 0xc8, 0xc8, 0xce, 0x00,
0x7c, 0x82, 0x7c, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0xc6, 0x00, 0x7c, 0xc6,
0xc6, 0xc6, 0x7c, 0x00, 0xe0, 0x10, 0x7c, 0xc6, 0xc6, 0xc6, 0x7c, 0x00,
0x7c, 0x82, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0xe0, 0x10, 0xcc, 0xcc,
0xcc, 0xcc, 0x76, 0x00, 0xcc, 0x00, 0xcc, 0xcc, 0xcc, 0x7c, 0x0c, 0xf8,
0xc6, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0xc6, 0x00, 0xc6, 0xc6,
0xc6, 0xc6, 0x7c, 0x00, 0x18, 0x7c, 0xd6, 0xd0, 0xd6, 0x7c, 0x18, 0x00,
0x38, 0x6c, 0x60, 0xf0, 0x60, 0xf2, 0xdc, 0x00, 0x66, 0x3c, 0x18, 0x7e,
0x18, 0x7e, 0x18, 0x00, 0xf8, 0xcc, 0xf8, 0xc4, 0xcc, 0xde, 0xcc, 0x06,
0x0e, 0x1b, 0x18, 0x3c, 0x18, 0x18, 0xd8, 0x70, 0x0e, 0x10, 0x78, 0x0c,
0x7c, 0xcc, 0x76, 0x00, 0x0e, 0x10, 0x38, 0x18, 0x18, 0x18, 0x3c, 0x00,
0x0e, 0x10, 0x7c, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x0e, 0x10, 0xcc, 0xcc,
0xcc, 0xcc, 0x76, 0x00, 0x66, 0x98, 0xdc, 0x66, 0x66, 0x66, 0x66, 0x00,
0x66, 0x98, 0xe6, 0xf6, 0xde, 0xce, 0xc6, 0x00, 0x38, 0x0c, 0x3c, 0x34,
0x00, 0x7e, 0x00, 0x00, 0x38, 0x6c, 0x6c, 0x38, 0x00, 0x7c, 0x00, 0x00,
0x30, 0x00, 0x30, 0x60, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0xfc,
0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x0c, 0x0c, 0x00, 0x00,
0xc0, 0xc8, 0xd0, 0xfe, 0x46, 0x8c, 0x1e, 0x00, 0xc0, 0xc8, 0xd0, 0xec,
0x5c, 0xbe, 0x0c, 0x00, 0x18, 0x00, 0x18, 0x18, 0x3c, 0x3c, 0x18, 0x00,
0x00, 0x36, 0x6c, 0xd8, 0x6c, 0x36, 0x00, 0x00, 0x00, 0xd8, 0x6c, 0x36,
0x6c, 0xd8, 0x00, 0x00, 0x22, 0x88, 0x22, 0x88, 0x22, 0x88, 0x22, 0x88,
0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0xdb, 0x77, 0xdb, 0xee,
0xdb, 0x77, 0xdb, 0xee, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
0x18, 0x18, 0x18, 0x18, 0xf8, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0x18,
0xf8, 0x18, 0x18, 0x18, 0x36, 0x36, 0x36, 0x36, 0xf6, 0x36, 0x36, 0x36,
0x00, 0x00, 0x00, 0x00, 0xfe, 0x36, 0x36, 0x36, 0x00, 0x00, 0xf8, 0x18,
0xf8, 0x18, 0x18, 0x18, 0x36, 0x36, 0xf6, 0x06, 0xf6, 0x36, 0x36, 0x36,
0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 0xfe, 0x06,
0xf6, 0x36, 0x36, 0x36, 0x36, 0x36, 0xf6, 0x06, 0xfe, 0x00, 0x00, 0x00,
0x36, 0x36, 0x36, 0x36, 0xfe, 0x00, 0x00, 0x00, 0x18, 0x18, 0xf8, 0x18,
0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x18, 0x18, 0x18,
0x18, 0x18, 0x18, 0x18, 0x1f, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18,
0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x18, 0x18, 0x18,
0x18, 0x18, 0x18, 0x18, 0x1f, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00,
0xff, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0xff, 0x18, 0x18, 0x18,
0x18, 0x18, 0x1f, 0x18, 0x1f, 0x18, 0x18, 0x18, 0x36, 0x36, 0x36, 0x36,
0x37, 0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x30, 0x3f, 0x00, 0x00, 0x00,
0x00, 0x00, 0x3f, 0x30, 0x37, 0x36, 0x36, 0x36, 0x36, 0x36, 0xf7, 0x00,
0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xf7, 0x36, 0x36, 0x36,
0x36, 0x36, 0x37, 0x30, 0x37, 0x36, 0x36, 0x36, 0x00, 0x00, 0xff, 0x00,
0xff, 0x00, 0x00, 0x00, 0x36, 0x36, 0xf7, 0x00, 0xf7, 0x36, 0x36, 0x36,
0x18, 0x18, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x36, 0x36, 0x36, 0x36,
0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x18, 0x18, 0x18,
0x00, 0x00, 0x00, 0x00, 0xff, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
0x3f, 0x00, 0x00, 0x00, 0x18, 0x18, 0x1f, 0x18, 0x1f, 0x00, 0x00, 0x00,
0x00, 0x00, 0x1f, 0x18, 0x1f, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00,
0x3f, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xff, 0x36, 0x36, 0x36,
0x18, 0x18, 0xff, 0x18, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x18, 0x18, 0x18,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
0xff, 0xff, 0xff, 0xff, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0,
0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0xff, 0xff, 0xff, 0xff,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x74, 0xcc, 0xc8, 0xdc, 0x76, 0x00,
0x78, 0xcc, 0xd8, 0xcc, 0xc6, 0xc6, 0xdc, 0x40, 0xfe, 0x62, 0x60, 0x60,
0x60, 0x60, 0xf0, 0x00, 0x00, 0x02, 0x7e, 0xec, 0x6c, 0x6c, 0x48, 0x00,
0xfe, 0x62, 0x30, 0x18, 0x30, 0x62, 0xfe, 0x00, 0x00, 0x00, 0x7e, 0xd0,
0xc8, 0xc8, 0x70, 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xf8, 0x80,
0x00, 0x00, 0x7e, 0xd8, 0x18, 0x18, 0x10, 0x00, 0x38, 0x10, 0x7c, 0xd6,
0xd6, 0x7c, 0x10, 0x38, 0x7c, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0x7c, 0x00,
0x7c, 0xc6, 0xc6, 0xc6, 0x6c, 0x28, 0xee, 0x00, 0x3c, 0x22, 0x18, 0x7c,
0xcc, 0xcc, 0x78, 0x00, 0x00, 0x00, 0x66, 0x99, 0x99, 0x66, 0x00, 0x00,
0x00, 0x06, 0x7c, 0x9e, 0xf2, 0x7c, 0xc0, 0x00, 0x00, 0x00, 0x7c, 0xc0,
0xf8, 0xc0, 0x7c, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00,
0x00, 0xfe, 0x00, 0xfe, 0x00, 0xfe, 0x00, 0x00, 0x18, 0x18, 0x7e, 0x18,
0x18, 0x00, 0x7e, 0x00, 0x30, 0x18, 0x0c, 0x18, 0x30, 0x00, 0x7c, 0x00,
0x18, 0x30, 0x60, 0x30, 0x18, 0x00, 0x7c, 0x00, 0x0e, 0x1b, 0x1b, 0x18,
0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xd8, 0xd8, 0x70,
0x00, 0x18, 0x00, 0x7e, 0x00, 0x18, 0x00, 0x00, 0x00, 0x76, 0xdc, 0x00,
0x76, 0xdc, 0x00, 0x00, 0x38, 0x6c, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x18, 0x00, 0x00, 0x00, 0x0f, 0x0c, 0x0c, 0x0c, 0xec, 0x6c, 0x3c, 0x00,
0xd8, 0x6c, 0x6c, 0x6c, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x30, 0xc0, 0xf0,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x3c, 0x3c, 0x3c, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
const int debugfont_size = sizeof(debugfont);
//---------------------------------------------------------------------------------
#endif //_font_h_
//---------------------------------------------------------------------------------

12532
include/renderd7/external/dr_flac.h vendored Normal file
View File

File diff suppressed because it is too large Load Diff

8668
include/renderd7/external/dr_wav.h vendored Normal file
View File

File diff suppressed because it is too large Load Diff

50894
include/renderd7/external/json.hpp vendored
View File

File diff suppressed because it is too large Load Diff

4228
include/renderd7/external/lodepng.h vendored
View File

File diff suppressed because it is too large Load Diff

17362
include/renderd7/external/stb_image.h vendored
View File

File diff suppressed because it is too large Load Diff

4108
include/renderd7/external/stb_image_write.h vendored
View File

File diff suppressed because it is too large Load Diff

11272
include/renderd7/external/stb_truetype.h vendored
View File

File diff suppressed because it is too large Load Diff

28
include/renderd7/global_db.hpp Normal file
View File

@ -0,0 +1,28 @@
#pragma once
#include <renderd7/renderd7.hpp>
#include <renderd7/external/json.hpp>
// Outdated HidApi (HidV2Patched)
extern u32 d7_hDown;
extern u32 d7_hHeld;
extern u32 d7_hUp;
extern u32 d7_hRepeat; // Inofficial lol
extern touchPosition d7_touch;
// Outdated Screens
extern C3D_RenderTarget *Top;
extern C3D_RenderTarget *TopRight;
extern C3D_RenderTarget *Bottom;
// Modern Global Api
extern int rd7_max_objects;
extern bool rd7_do_splash;
extern bool rd7_enable_scene_system;
extern bool rd7_debugging;
extern C3D_RenderTarget *rd7_top;
extern C3D_RenderTarget *rd7_top_right;
extern C3D_RenderTarget *rd7_bottom;
// Draw2
extern float rd7_draw2_tsm;

1090
include/renderd7/ini.hpp
View File

File diff suppressed because it is too large Load Diff

55
include/renderd7/internal_db.hpp Normal file
View File

@ -0,0 +1,55 @@
#pragma once
#include <renderd7/renderd7.hpp>
#include <renderd7/external/json.hpp>
#include <renderd7/global_db.hpp>
#define CFGVER "0"
#ifndef V_RD7BTIME
#define V_RD7BTIME "SUBMODULE"
#endif
#ifndef V_RD7CSTRING
#define V_RD7CSTRING "SUBMODULE"
#endif
/// Base ///
extern std::string rd7i_app_name;
extern std::string rd7i_config_path;
extern nlohmann::json rd7i_config;
extern u8 rd7i_console_model;
extern u8 rd7i_system_region;
extern bool rd7i_is_citra;
extern bool rd7i_settings;
extern R7Vec2 rd7i_hid_touch_pos;
extern C2D_TextBuf rd7i_text_buffer;
extern C2D_TextBuf rd7i_d2_dimbuf;
extern C2D_Font rd7i_base_font;
extern bool rd7i_is_ndsp;
extern bool rd7i_running;
extern std::unique_ptr<RenderD7::Scene> rd7i_fade_scene;
extern std::vector<std::unique_ptr<RenderD7::Ovl>> rd7i_overlays;
extern unsigned int rd7i_frames;
extern u64 rd7i_last_time;
extern float rd7i_framerate;
extern u32 rd7i_mt_color;
extern u32 rd7i_mt_txtcolor;
extern bool rd7i_mt_screen;
extern float rd7i_mt_txtSize;
extern bool rd7i_metrikd;
extern bool rd7i_ftraced;
extern bool rd7i_current_screen;
extern u64 rd7i_delta_time;
extern u64 rd7i_last_tm;
extern float rd7i_dtm;
extern float rd7i_time;
extern bool rd7i_fadeout;
extern bool rd7i_fadein;
extern bool rd7i_fadeout2;
extern bool rd7i_fadein2;
extern int rd7i_fadealpha;
extern int rd7i_fadecolor;
extern bool rd7i_wait_fade;
extern bool rd7i_fade_exit;
extern bool rd7i_fade_scene_wait;
extern bool rd7i_idb_running;
extern bool rd7i_graphics_on;

40
include/renderd7/lang.hpp
View File

@ -1,20 +1,20 @@
#pragma once #pragma once
// clang-format off // clang-format off
#include <string> #include <string>
#include <renderd7/external/json.hpp> #include <renderd7/external/json.hpp>
// clang-format on // clang-format on
namespace RenderD7 { namespace RenderD7 {
namespace Lang { namespace Lang {
/// @brief Get 3ds System lang! [en] by default /// @brief Get 3ds System lang! [en] by default
/// @return Sytemlang as string /// @return Sytemlang as string
std::string getSys(); std::string getSys();
/// @brief Get The Translation String /// @brief Get The Translation String
/// @param key Key of Translation /// @param key Key of Translation
/// @return The Translated String /// @return The Translated String
std::string get(const std::string &key); std::string get(const std::string &key);
/// @brief Load A Language json /// @brief Load A Language json
/// @param lang The Language Key [en], [de], etc, or getSys() /// @param lang The Language Key [en], [de], etc, or getSys()
void load(const std::string &lang); void load(const std::string &lang);
} // namespace Lang } // namespace Lang
} // namespace RenderD7 } // namespace RenderD7

28
include/renderd7/music/Mp3.hpp Normal file
View File

@ -0,0 +1,28 @@
#pragma once
#include <renderd7/music/Music.hpp>
#include <fstream>
#include <mpg123.h>
namespace RenderD7 {
class Mp3Decoder : public MusicDecoder {
public:
Mp3Decoder() {}
~Mp3Decoder() {}
int _init(const std::string& path, MusicMeta& meta) override;
unsigned int _getSampleRate() override;
unsigned char _getChannels() override;
size_t _getBufSize() override;
unsigned long long _decode(signed short* buf_addr) override;
void _deinit() override;
size_t _getFileSamples() override;
private:
mpg123_handle *hnd = nullptr;
size_t buf_size = 0;
long rate = 0;
int channels = 0;
};
}

90
include/renderd7/music/Music.hpp Normal file
View File

@ -0,0 +1,90 @@
// RenderD7 Music Backend
#pragma once
#include <string>
namespace RenderD7 {
class MusicMeta {
public:
MusicMeta() {
ititle = "Unknown";
ialbum = "Unknown";
iyear = "Unknown";
iname = "Unknown";
ipath = "Unknown";
iartist = "Unknown";
imdt = "Unknown";
}
~MusicMeta() {}
std::string name() { return iname; }
std::string album() { return ialbum; }
std::string year() { return iyear; }
std::string title() { return ititle; }
std::string path() { return ipath; }
std::string artist() { return iartist; }
std::string mdt() { return imdt; }
void name(std::string name) { iname = name; }
void album(std::string album) { ialbum = album; }
void year(std::string year) { iyear = year; }
void title(std::string title) { ititle = title; }
void path(std::string path) { ipath = path; }
void artist(std::string artist) { iartist = artist; }
void mdt(std::string mdt) { imdt = mdt; }
private:
std::string ititle = "";
std::string ialbum = "";
std::string iyear = "";
std::string iname = "";
std::string ipath = "";
std::string iartist = "";
std::string imdt = "";
};
// Template Class for Decoders
class MusicDecoder {
public:
MusicDecoder() = default;
virtual ~MusicDecoder() {}
static void LoadFile(const std::string &path);
static void CleanUp();
static int init(const std::string &path, MusicMeta &meta) {
return decoder->_init(path, meta);
}
static unsigned int getSampleRate() { return decoder->_getSampleRate(); }
static unsigned char getChannels() { return decoder->_getChannels(); }
static size_t getBufSize() { return decoder->_getBufSize(); }
static unsigned long long decode(signed short *buf_addr) {
return decoder->_decode(buf_addr);
}
static void deinit() { decoder->_deinit(); }
static size_t getFileSamples() { return decoder->_getFileSamples(); }
static MusicDecoder *decoder;
protected:
virtual int _init(const std::string &path, MusicMeta &meta) = 0;
virtual unsigned int _getSampleRate() = 0;
virtual unsigned char _getChannels() = 0;
virtual size_t _getBufSize() = 0;
virtual unsigned long long _decode(signed short *buf_addr) = 0;
virtual void _deinit() = 0;
virtual size_t _getFileSamples() = 0;
};
namespace MusicPlayer {
void PlayFile(const std::string &path);
void Play();
void Pause();
void Stop();
bool IsPlaying();
bool IsRunning();
int PosCurrent();
int Total();
int SampleRate();
MusicMeta GetMeta();
} // namespace MusicPlayer
} // namespace RenderD7

29
include/renderd7/music/Vorbis.hpp Normal file
View File

@ -0,0 +1,29 @@
#pragma once
#include <renderd7/music/Music.hpp>
#include <fstream>
#include <tremor/ivorbiscodec.h>
#include <tremor/ivorbisfile.h>
namespace RenderD7 {
class VorbisDecoder : public MusicDecoder {
public:
VorbisDecoder() {}
~VorbisDecoder() {}
int _init(const std::string& path, MusicMeta& meta) override;
unsigned int _getSampleRate() override;
unsigned char _getChannels() override;
size_t _getBufSize() override;
unsigned long long _decode(signed short* buf_addr) override;
void _deinit() override;
size_t _getFileSamples() override;
private:
OggVorbis_File vorbis_file;
vorbis_info *vi;
FILE* f; // Only used cause required by lib
const size_t buf_size = 8 * 4096;
};
}

47
include/renderd7/nimg.hpp Normal file
View File

@ -0,0 +1,47 @@
#pragma once
#include <vector>
#include <cstdint>
#include <iostream>
#define NPI_NIMG_ (uint32_t)0x4e494d47 // Magic: NIMG
/**
* NIMG Format Value Description
* int format
* 0 = rgba32
* 1 = rgb24 (3x8bit)
*/
/**
* NIMG Compression Value Description
* int compression
* 0 = no compression
* 1 = npi_simple_compress (RLE Style)
*/
namespace RenderD7
{
struct nimg
{
unsigned int magic; // Magic number defaults do NPI_NIMG_
int width;
int height;
int format;
int compression;
std::vector<unsigned char> pixel_buffer;
nimg(int w = 0, int h = 0, int fmt = 0, int cmp = 0)
{
magic = NPI_NIMG_;
width = w;
height = h;
format = fmt;
compression = cmp;
pixel_buffer.resize((w*h)*(format ? 3 : 4));
}
};
nimg NIMG_Load(std::string path);
nimg NIMG_LoadFromMem(unsigned char* buffer, size_t bf_size);
void NIMG_Save(nimg image, std::string path);
}

26
include/renderd7/nimg_engine.hpp Normal file
View File

@ -0,0 +1,26 @@
#pragma once
#include <renderd7/nimg.hpp>
namespace RenderD7
{
class NIMG_Engine
{
public:
NIMG_Engine(int w, int h);
NIMG_Engine();
~NIMG_Engine();
nimg& GetImage() { return image; }
void load_file(const std::string& path);
void load_nimg(const std::string& path);
// Rendering
void draw_pixel(int x, int y, unsigned int color);
void draw_rect(int x, int y, int w, int h, unsigned int color, int t = 1);
void draw_rect_solid(int x, int y, int w, int h, unsigned int color);
void flip(bool h, bool v);
private:
nimg image;
};
}

236
include/renderd7/parameter.hpp
View File

@ -1,118 +1,118 @@
#pragma once #pragma once
#include <tuple> #include <tuple>
namespace RenderD7 { namespace RenderD7 {
class Parameter { class Parameter {
private: private:
using id = size_t; using id = size_t;
template <typename T> struct type { template <typename T> struct type {
static void id() {} static void id() {}
}; };
template <typename T> static id type_id() { template <typename T> static id type_id() {
return reinterpret_cast<id>(&type<T>::id); return reinterpret_cast<id>(&type<T>::id);
} }
template <typename T> using decay = typename std::decay<T>::type; template <typename T> using decay = typename std::decay<T>::type;
template <typename T> template <typename T>
using none = using none =
typename std::enable_if<!std::is_same<Parameter, T>::value>::type; typename std::enable_if<!std::is_same<Parameter, T>::value>::type;
struct base { struct base {
virtual ~base() {} virtual ~base() {}
virtual bool is(id) const = 0; virtual bool is(id) const = 0;
virtual base *copy() const = 0; virtual base *copy() const = 0;
} *p = nullptr; } *p = nullptr;
template <typename T> struct data : base, std::tuple<T> { template <typename T> struct data : base, std::tuple<T> {
using std::tuple<T>::tuple; using std::tuple<T>::tuple;
T &get() & { return std::get<0>(*this); } T &get() & { return std::get<0>(*this); }
T const &get() const & { return std::get<0>(*this); } T const &get() const & { return std::get<0>(*this); }
bool is(id i) const override { return i == type_id<T>(); } bool is(id i) const override { return i == type_id<T>(); }
base *copy() const override { return new data{get()}; } base *copy() const override { return new data{get()}; }
}; };
template <typename T> T &stat() { return static_cast<data<T> &>(*p).get(); } template <typename T> T &stat() { return static_cast<data<T> &>(*p).get(); }
template <typename T> T const &stat() const { template <typename T> T const &stat() const {
return static_cast<data<T> const &>(*p).get(); return static_cast<data<T> const &>(*p).get();
} }
template <typename T> T &dyn() { return dynamic_cast<data<T> &>(*p).get(); } template <typename T> T &dyn() { return dynamic_cast<data<T> &>(*p).get(); }
template <typename T> T const &dyn() const { template <typename T> T const &dyn() const {
return dynamic_cast<data<T> const &>(*p).get(); return dynamic_cast<data<T> const &>(*p).get();
} }
public: public:
/** /**
* @brief Default constructor * @brief Default constructor
*/ */
Parameter() {} Parameter() {}
/** /**
* @brief Destructs the Parameter * @brief Destructs the Parameter
*/ */
~Parameter() { delete p; } ~Parameter() { delete p; }
/** /**
* @brief Copy constructor * @brief Copy constructor
* @param s The Parameter to copy * @param s The Parameter to copy
*/ */
Parameter(Parameter &&s) : p{s.p} { s.p = nullptr; } Parameter(Parameter &&s) : p{s.p} { s.p = nullptr; }
/** /**
* @brief Const copy constructor * @brief Const copy constructor
* @param s The Parameter to copy * @param s The Parameter to copy
*/ */
Parameter(Parameter const &s) : p{s.p->copy()} {} Parameter(Parameter const &s) : p{s.p->copy()} {}
/** /**
* @brief Initializes the Parameter with the given value * @brief Initializes the Parameter with the given value
* @param x The value to initialize the Parameter with * @param x The value to initialize the Parameter with
*/ */
template <typename T, typename U = decay<T>, typename = none<U>> template <typename T, typename U = decay<T>, typename = none<U>>
Parameter(T &&x) : p{new data<U>{std::forward<T>(x)}} {} Parameter(T &&x) : p{new data<U>{std::forward<T>(x)}} {}
/** /**
* @brief Overloads the assignment operator * @brief Overloads the assignment operator
* @param s The value to set the Parameter to * @param s The value to set the Parameter to
*/ */
Parameter &operator=(Parameter s) { Parameter &operator=(Parameter s) {
swap(*this, s); swap(*this, s);
return *this; return *this;
} }
friend void swap(Parameter &s, Parameter &r) { std::swap(s.p, r.p); } friend void swap(Parameter &s, Parameter &r) { std::swap(s.p, r.p); }
/** /**
* @brief Clears the Parameter * @brief Clears the Parameter
*/ */
void clear() { void clear() {
delete p; delete p;
p = nullptr; p = nullptr;
} }
/** /**
* @brief Checks whether the Parameter is the given type * @brief Checks whether the Parameter is the given type
* @tparam T The type to check * @tparam T The type to check
* @return Whether the Parameter has the given type or not * @return Whether the Parameter has the given type or not
*/ */
template <typename T> bool is() const { template <typename T> bool is() const {
return p ? p->is(type_id<T>()) : false; return p ? p->is(type_id<T>()) : false;
} }
/** /**
* @brief Returns the value of the Parameter * @brief Returns the value of the Parameter
* @tparam T The type of the Parameter * @tparam T The type of the Parameter
* @return The value of the Parameter * @return The value of the Parameter
* @warning If the type of the Parameter doesn't match the type of it's stored * @warning If the type of the Parameter doesn't match the type of it's stored
* value, it will result in undefined behaviour. * value, it will result in undefined behaviour.
*/ */
template <typename T> T &get() & { return stat<T>(); } template <typename T> T &get() & { return stat<T>(); }
}; };
} // namespace RenderD7 } // namespace RenderD7

221
include/renderd7/renderd7.hpp
View File

@ -24,12 +24,9 @@
#include <citro2d.h> #include <citro2d.h>
#include <citro3d.h> #include <citro3d.h>
/// RenderD7 Includes /// RenderD7 Includes
#include <renderd7/BitmapPrinter.hpp>
#include <renderd7/Color.hpp> #include <renderd7/Color.hpp>
#include <renderd7/Draw.hpp>
#include <renderd7/FunctionTrace.hpp> #include <renderd7/FunctionTrace.hpp>
#include <renderd7/Hardware.hpp> #include <renderd7/Hardware.hpp>
#include <renderd7/Image.hpp>
#include <renderd7/Memory.hpp> #include <renderd7/Memory.hpp>
#include <renderd7/Ovl.hpp> #include <renderd7/Ovl.hpp>
#include <renderd7/ResultDecoder.hpp> #include <renderd7/ResultDecoder.hpp>
@ -40,8 +37,6 @@
#include <renderd7/SpriteAnimation.hpp> #include <renderd7/SpriteAnimation.hpp>
#include <renderd7/Tasks.hpp> #include <renderd7/Tasks.hpp>
#include <renderd7/Time.hpp> #include <renderd7/Time.hpp>
#include <renderd7/bmp.hpp>
#include <renderd7/bmpconverter.hpp>
#include <renderd7/external/lodepng.h> #include <renderd7/external/lodepng.h>
#include <renderd7/ini.hpp> #include <renderd7/ini.hpp>
#include <renderd7/lang.hpp> #include <renderd7/lang.hpp>
@ -50,78 +45,24 @@
#include <renderd7/thread.hpp> #include <renderd7/thread.hpp>
#define RENDERD7VSTRING "0.9.5" #define RENDERD7VSTRING "0.9.5"
#define CHANGELOG \
"0.9.5: Remove Npi Intro and NVID Api\nReplace Toasts System with " \
"ToastsV2\n aka MessageHandler\nLots of Optimisations\n" \
"0.9.4: Implement new Security System\n To prevent from crashes\nImplement " \
"Functiontrace for better\nTiming Tests\nImplement MemAlloc Tracker (only " \
"size)\nAdd some new Overlays (not functional yet)\nComplete Rewrite of " \
"Overlay System\nFixed the FrameEnd Crash\nNew System to get Hardware " \
"Info\nRemoved RD7SR\n0.9.3: Completly Documented Everything\nFix typo " \
"in " \
"Sprite::getHeight()\nRemove Deprecated/Useless Stuff\n0.9.2: Add " \
"NpiSplashVideo\nNvid Support(v0.0.1)\nAdd " \
"Basic RenderD7 " \
"Splash\nFaster Graphics Init\nFade Effects\nFix Screen for this " \
"Changelog\n0.9.1: Fix Critical bug in\nSpritesheet animations\nFix " \
"Color " \
"Conver(Hex)\n0.9.0: Remove Stupid try of Console\nAdd Services list and " \
"Clean up " \
"Code.\nAlso added Minimal Init for hax2.x\n0.8.5: Fix Deltatime \n0.8.4: " \
"A lot of Fixes and new\nFeatures for BitmapPrinter! \n0.8.3: Addet " \
"Overlaycount to Info\nand Addet ResultDecoder for errors.\n0.8.2: Fix a " \
"lot of Stuff and\nadd c++17 based filesystem class.\n0.8.1: Add abillity " \
"to Get Stdout as string\nto render it to the screen.\n0.8.0: Implement " \
"BitmapPrinter\n0.7.3: Implement Over\nRender Overlay Framework\n0.7.2: " \
"Implement MT to csv file\nsaving.(removed) Add RGB2HEX.\n0.7.1: Add the " \
"New Overlay Handler. Its\nJust in code and does nothing yet.\n0.7.0: Made " \
"Big Progress In the MT\nOvl but it still crashes On\na Scnd " \
"C3D_FrameEnd()." \
"\nImplement 800px but\ndoesn't work that good. \n0.6.2: Fix Crash when " \
"exiting\ntrouth Home Menu.\n0.6.10: rewrite Threadsystem,\nImprove " \
"framerate\n0.6.02: Fix Code in lang.hpp\nadd Draw Text Left " \
"Function\n(Right since 0.7.0).\nadd changelog\n0.6.01: add Threading " \
"system.\n0.6.0: Better " \
"Scene Management\n0.5.0: Fixed some Bugs!\n0.4.0: Trying to fix " \
"Filesystem and Bugs!\n0.3.0: Recreate D7-Core into RenderD7!\n0.2.0: " \
"Trying to create Animations of\nImages instead of Sheets!\n0.1.0: Initial " \
"Release of\nD7-Core sprite animation plugin!"
#define DEFAULT_CENTER 0.5f #define DEFAULT_CENTER 0.5f
#define RD7_DEPRECATED // __attribute__ ((deprecated))
/// @param d7_hDown Current Key Down
extern u32 d7_hDown;
/// @param d7_hHeld Current Key Held
extern u32 d7_hHeld;
/// @param d7_hUp Current Key Up
extern u32 d7_hUp;
/// @param d7_touch Current Touch Position
extern touchPosition d7_touch;
/// @param dspststus Dsp Status String
extern std::string dspststus;
/// @param rd7_do_splash Config Value To Enable RenderD7 Splash /// @param rd7_do_splash Config Value To Enable RenderD7 Splash
extern bool rd7_do_splash; extern bool rd7_do_splash;
/// @param rd7_enable_memtrack Config Value to Track Mem Allocations /// @param rd7_enable_memtrack Config Value to Track Mem Allocations
extern bool rd7_enable_memtrack; extern bool rd7_enable_memtrack;
/// @param rd7_max_objects Config Param for C2D Mac objects
extern int rd7_max_objects;
/// @param rd7_enable_scene_system Enable/Disable Scene System (for example for your own implementations)
extern bool rd7_enable_scene_system;
/// RenderD7 /// RenderD7
namespace RenderD7 { namespace RenderD7 {
/// @brief Get Deltatime /// @brief Get Deltatime
/// @return Deltatime /// @return Deltatime
float GetDeltaTime(); float GetDeltaTime();
/// @brief Keyboard
enum kbd {
/// @brief libctru Keyboard
SWKBD,
/// @brief Unk (Not Usable)
BKBD
};
/// @brief Keyboar Type
enum kbd_type { NUMPAD, STANDARD };
/// @brief A Button /// @brief A Button
struct TObject { struct TObject {
int x; ///< Position X int x; ///< Position X
@ -138,12 +79,7 @@ public:
static std::stack<std::unique_ptr<Scene>> scenes; static std::stack<std::unique_ptr<Scene>> scenes;
/// @brief Deconstructor /// @brief Deconstructor
virtual ~Scene() {} virtual ~Scene() {}
/// @brief Logic To Overide virtual void Logic() = 0;
/// @param hDown Key Down
/// @param hHeld Key Held
/// @param hUp Key Up
/// @param touch Touch Position
virtual void Logic(u32 hDown, u32 hHeld, u32 hUp, touchPosition touch) = 0;
/// @brief Draw Func to Override /// @brief Draw Func to Override
virtual void Draw() const = 0; virtual void Draw() const = 0;
/// @brief Push a Scene to Stack /// @brief Push a Scene to Stack
@ -154,43 +90,31 @@ public:
static void Back(); static void Back();
/// @brief do the Draw (Called in RenderD7::MainLoop()) /// @brief do the Draw (Called in RenderD7::MainLoop())
static void doDraw(); static void doDraw();
/// @brief do the Logic (Called in RenderD7::MainLoop()) static void doLogic();
/// @param hDown Key Down
/// @param hHeld Key Held
/// @param hUp Key Up
/// @param touch Touch Positon
static void doLogic(u32 hDown, u32 hHeld, u32 hUp, touchPosition touch);
}; };
/// @brief Integrated Setting Menu of RenderD7 /// @brief Integrated Setting Menu of RenderD7
class RSettings : public RenderD7::Scene { class RSettings : public RenderD7::Scene {
private: private:
/// @brief Calculate the Changelog Screen Stuff
/// @param lines vector of Lines
/// @param screen_index Current Screen
/// @param screens Count of Possible Screens
void calculate_screens(const std::vector<std::string> &lines,
int &screen_index, int &screens);
/// @brief State (Define for Menus) /// @brief State (Define for Menus)
enum RState { enum RState {
RSETTINGS, RSETTINGS,
RINFO, RINFO,
RSERVICES, RSERVICES,
RCLOG,
RMCONFIG, RMCONFIG,
RFTRACE, RFTRACE,
RSECM, RUI7,
RCREDITS RCREDITS
}; };
/// @param shared_request Defines requests from Draw to Logic
/// As it is not planned to make Draw non const you'll need
/// A map of data or bool values that are mutable ake
/// editable by const functions
mutable std::map<unsigned int, unsigned int> shared_request;
/// @param m_state Current menu State (Default=MainMenu aka RSETTINGS) /// @param m_state Current menu State (Default=MainMenu aka RSETTINGS)
RenderD7::RSettings::RState m_state = RenderD7::RSettings::RState::RSETTINGS; RenderD7::RSettings::RState m_state = RenderD7::RSettings::RState::RSETTINGS;
/// @param screens Count of Changelog Screens
int screens = 0;
/// @param screen_index Current Changelog Screen
int screen_index = 0;
/// @param lines Vector of Changelog-Lines
std::vector<std::string> lines;
/// @brief Position in FTrace Menu /// @brief Position in FTrace Menu
int ftrace_index = 0; int ftrace_index = 0;
@ -198,13 +122,9 @@ private:
std::string mtovlstate = "false"; std::string mtovlstate = "false";
/// @param mtscreenstate Screen the Overlay is Set to /// @param mtscreenstate Screen the Overlay is Set to
std::string mtscreenstate = "Top"; std::string mtscreenstate = "Top";
std::string kbd_test;
/// @param buttons Vector of Buttons bool statemtold = false;
std::vector<RenderD7::TObject> buttons = { bool stateftold = false;
{20, 35, 120, 35, "NotYET"}, {20, 85, 120, 35, "Changelog"},
{20, 135, 120, 35, "Metrik-Ovl"}, {20, 185, 120, 35, "Tasks"},
{180, 35, 120, 35, "FTrace"}, {180, 85, 120, 35, "Credits"},
{180, 135, 120, 35, "Info"}, {180, 185, 120, 35, "Security"}};
public: public:
/// @brief Constructor /// @brief Constructor
@ -214,30 +134,23 @@ public:
void Draw(void) const override; void Draw(void) const override;
/// @brief Deconstructor /// @brief Deconstructor
~RSettings(); ~RSettings();
/// @brief Override for Logic void Logic() override;
/// @param hDown Key Down
/// @param hHeld Key Held
/// @param hUp Key Up
/// @param touch Touch Position
void Logic(u32 hDown, u32 hHeld, u32 hUp, touchPosition touch) override;
}; };
/// @brief Show Up the RenderD7-Settings Menu /// @brief Show Up the RenderD7-Settings Menu
void LoadSettings(); void LoadSettings();
/// @brief Get's The Programs Time running
/// @return Time Running
float GetTime();
/// @brief Get Framerate as Number
/// @return FPS
int GetFps();
/// @brief Get A Rendom Int /// @brief Get A Rendom Int
/// @param b From /// @param b From
/// @param e To /// @param e To
/// @return Random Int /// @return Random Int
int GetRandomInt(int b, int e); int GetRandomInt(int b, int e);
/// @brief Short a String with (..,)
/// @param in Input string
/// @param size Size of Input Text
/// @param maxlen Max length of texr
/// @param font Custom Font for Correct Size Calculation
/// @return Shorted String
std::string ShortString(std::string in, float size, int maxlen,
C2D_Font font = nullptr);
/// @brief DrawMetrikOvl (YOUR OWN RISK) /// @brief DrawMetrikOvl (YOUR OWN RISK)
void DrawMetrikOvl(); void DrawMetrikOvl();
/// @brief Draw Image from RenderD7 Sheet /// @brief Draw Image from RenderD7 Sheet
@ -259,17 +172,10 @@ void FadeOut();
/// @brief Display Fade Effects /// @brief Display Fade Effects
void FadeDisplay(); void FadeDisplay();
namespace Error { /// @brief Loads a font
/// @brief DEPRECATED Display Error for n Seconds /// @param path path to font (bcfnt)
/// @param toptext Head Text /// @return link to C2D_Font Object
/// @param errortext Error Text C2D_Font LoadFont(const std::string& path);
/// @param timesec Time n to Display in Seconds
void DisplayError(std::string toptext, std::string errortext, int timesec = 3);
/// @brief Display A Fatal Error
/// @param toptext Head Text
/// @param errortext Error Text
void DisplayFatalError(std::string toptext, std::string errortext);
} // namespace Error
namespace Init { namespace Init {
/// @brief Init Default RenderD7 /// @brief Init Default RenderD7
@ -289,23 +195,6 @@ void Graphics();
void NdspFirm(); void NdspFirm();
} // namespace Init } // namespace Init
namespace Msg {
/// @brief Display A Message
/// @param titletxt Header Text
/// @param subtext Message Text
/// @param target Screen
void Display(std::string titletxt, std::string subtext,
C3D_RenderTarget *target);
/// @brief Display A Message Wit Progress
/// @param titletext Header Text
/// @param subtext Message Text
/// @param current Current Progress
/// @param total Total Progress
/// @param prgbarcolor Color of Progressbar
void DisplayWithProgress(std::string titletext, std::string subtext,
float current, float total, u32 prgbarcolor);
} // namespace Msg
namespace Convert { namespace Convert {
/// @brief Convert a String to Flaot /// @brief Convert a String to Flaot
/// @param inp Input String /// @param inp Input String
@ -344,59 +233,11 @@ void ExitApp();
/// @param /// @param
void ClearTextBufs(void); void ClearTextBufs(void);
/// @brief Open A Keyboard (SWKBD)
/// @param lenght Length of the string
/// @param tp Type of The Keyboard
/// @return the string if pressed Ok
std::string Kbd(int lenght, SwkbdType tp);
/// @brief Draw Overlays And end the Frame. DO NEVER USE C3D_FRAMEEND cause it /// @brief Draw Overlays And end the Frame. DO NEVER USE C3D_FRAMEEND cause it
/// breaks Overlay crash Security /// breaks Overlay crash Security
void FrameEnd(); void FrameEnd();
/// @brief Textless Button /// @brief Returns App Working Directory path
struct TLBtn { /// @return AppDir Path
int x; ///< Position X std::string GetAppDirectory();
int y; ///< Position Y
int w; ///< Button Width
int h; ///< Button Height
};
/// @brief Draw Buttons
/// @param tobjects Vector of Buttons
/// @param color Color of the Buttons
/// @param txtcolor Color of The Text
/// @param selection Positon of Selection
/// @param selbgcolor Selection BackgroundColor
/// @param selcolor Selection Color
void DrawTObjects(std::vector<RenderD7::TObject> tobjects, u32 color,
u32 txtcolor, int selection = -1,
u32 selbgcolor = RenderD7::Color::Hex("#2D98AF"),
u32 selcolor = RenderD7::Color::Hex("#000000"));
/// @brief Draw A Single Button
/// @param tobject Button
/// @param tobjectindex Button Index
/// @param color Color of the Button
/// @param txtcolor Color of The Text
void DrawSTObject(std::vector<RenderD7::TObject> tobject, int tobjectindex,
u32 color, u32 txtcolor);
/// @brief Touched A Button
/// @param touch Touch Position
/// @param button Button
/// @return is touched or not
bool touchTObj(touchPosition touch, RenderD7::TObject button);
/// @brief Touched A Textless Button
/// @param touch Touch Position
/// @param button Button
/// @return is touched or not
bool touchTLBtn(touchPosition touch, RenderD7::TLBtn button);
/// @brief Draw Textless Buttons
/// @param tobjects Vector of Buttons
/// @param color Color of the Buttons
/// @param selection Positon of Selection
/// @param selbgcolor Selection BackgroundColor
/// @param selcolor Selection Color
void DrawTLBtns(std::vector<RenderD7::TLBtn> btns, u32 color,
int selection = -1,
u32 selbgcolor = RenderD7::Color::Hex("#2D98AF"),
u32 selcolor = RenderD7::Color::Hex("#000000"));
} // namespace RenderD7 } // namespace RenderD7

8
include/renderd7/renderd7_logo.hpp
View File

@ -1,5 +1,5 @@
#pragma once #pragma once
#include <cstddef> #include <cstddef>
extern unsigned char renderd7_logo[]; extern unsigned char renderd7_logo[];
extern size_t renderd7_logo_size; extern size_t renderd7_logo_size;

182
include/renderd7/stringtool.hpp
View File

@ -1,81 +1,103 @@
#pragma once #pragma once
#include <iomanip> #include <iomanip>
#include <iostream> #include <iostream>
#include <sstream> #include <sstream>
#include <string> #include <string>
namespace RenderD7 { namespace RenderD7 {
/// @brief Check if A String ends with /// @brief Check if A String ends with
/// @param name Input String /// @param name Input String
/// @param extensions Extensions to Check for /// @param extensions Extensions to Check for
/// @return Ends with or not /// @return Ends with or not
inline bool NameIsEndingWith(const std::string &name, inline bool NameIsEndingWith(const std::string &name,
const std::vector<std::string> &extensions) { const std::vector<std::string> &extensions) {
if (name.substr(0, 2) == "._") if (name.substr(0, 2) == "._") return false;
return false;
if (name.size() == 0) return false;
if (name.size() == 0)
return false; if (extensions.size() == 0) return true;
if (extensions.size() == 0) for (int i = 0; i < (int)extensions.size(); i++) {
return true; const std::string ext = extensions.at(i);
if (strcasecmp(name.c_str() + name.size() - ext.size(), ext.c_str()) == 0)
for (int i = 0; i < (int)extensions.size(); i++) { return true;
const std::string ext = extensions.at(i); }
if (strcasecmp(name.c_str() + name.size() - ext.size(), ext.c_str()) == 0)
return true; return false;
} }
/// @brief Format Milliseconds to clean string (Stolen from one of my Mc
return false; /// Plugins)
} /// @param t_time Time in ms
/// @brief Format Milliseconds to clean string (Stolen from one of my Mc /// @return String
/// Plugins) inline std::string MsTimeFmt(float t_time, bool dems = false) {
/// @param t_time Time in ms std::ostringstream oss;
/// @return String
inline std::string MsTimeFmt(float t_time) { if (t_time < 0.001f) {
std::ostringstream oss; oss << std::fixed << std::setprecision(2) << t_time * 1000.0f << "ns";
} else if (t_time < 1.0f) {
if (t_time < 0.001f) { oss << std::fixed << std::setprecision(2) << t_time << "ms";
oss << std::fixed << std::setprecision(2) << t_time * 1000.0f << "ns"; } else if (t_time < 60000.0f) {
} else if (t_time < 1.0f) { int seconds = static_cast<int>(t_time / 1000.0f);
oss << std::fixed << std::setprecision(2) << t_time << "ms"; float milliseconds = t_time - (seconds * 1000.0f);
} else if (t_time < 60000.0f) {
int seconds = static_cast<int>(t_time / 1000.0f); if (seconds > 0) {
float milliseconds = t_time - (seconds * 1000.0f); oss << seconds << "s ";
}
if (seconds > 0) { if (!dems)
oss << seconds << "s "; oss << std::fixed << std::setprecision(2) << milliseconds << "ms";
} } else {
oss << std::fixed << std::setprecision(2) << milliseconds << "ms"; int minutes = static_cast<int>(t_time / 60000.0f);
} else { int seconds = static_cast<int>((t_time - (minutes * 60000.0f)) / 1000.0f);
int minutes = static_cast<int>(t_time / 60000.0f); float milliseconds = t_time - (minutes * 60000.0f) - (seconds * 1000.0f);
int seconds = static_cast<int>((t_time - (minutes * 60000.0f)) / 1000.0f);
float milliseconds = t_time - (minutes * 60000.0f) - (seconds * 1000.0f); oss << minutes << "m ";
if (seconds > 0 || milliseconds > 0.0f) {
oss << minutes << "m "; oss << seconds << "s ";
if (seconds > 0 || milliseconds > 0.0f) { }
oss << seconds << "s "; if (milliseconds > 0.0f && !dems) {
} oss << std::fixed << std::setprecision(2) << milliseconds << "ms";
if (milliseconds > 0.0f) { }
oss << std::fixed << std::setprecision(2) << milliseconds << "ms"; }
}
} return oss.str();
}
return oss.str();
} inline std::string FormatBytes(int bytes) {
} // namespace RenderD7 char out[32];
template <class T> T GetFileName(T const &path, T const &delims = "/\\") { if (bytes == 1)
return path.substr(path.find_last_of(delims) + 1); snprintf(out, sizeof(out), "%d Byte", bytes);
}
template <class T> T remove_ext(T const &filename) { else if (bytes < 1024)
typename T::size_type const p(filename.find_last_of('.')); snprintf(out, sizeof(out), "%d Bytes", bytes);
return p > 0 && p != T::npos ? filename.substr(0, p) : filename;
} else if (bytes < 1024 * 1024)
snprintf(out, sizeof(out), "%.1f KB", (float)bytes / 1024);
template <typename T> std::string Int_To_Hex(T i) {
std::stringstream stream; else if (bytes < 1024 * 1024 * 1024)
stream << "0x" << std::setfill('0') << std::setw(sizeof(T) * 2) << std::hex snprintf(out, sizeof(out), "%.1f MB", (float)bytes / 1024 / 1024);
<< i;
return stream.str(); else
snprintf(out, sizeof(out), "%.1f GB", (float)bytes / 1024 / 1024 / 1024);
return out;
}
} // namespace RenderD7
template <class T>
T GetFileName(T const &path, T const &delims = "/\\") {
return path.substr(path.find_last_of(delims) + 1);
}
template <class T>
T remove_ext(T const &filename) {
typename T::size_type const p(filename.find_last_of('.'));
return p > 0 && p != T::npos ? filename.substr(0, p) : filename;
}
template <typename T>
std::string Int_To_Hex(T i) {
std::stringstream stream;
stream << "0x" << std::setfill('0') << std::setw(sizeof(T) * 2) << std::hex
<< i;
return stream.str();
} }

244
include/renderd7/thread.hpp
View File

@ -1,122 +1,122 @@
#pragma once #pragma once
#include <3ds.h> #include <3ds.h>
#include <atomic> #include <atomic>
#include <functional> #include <functional>
#include <renderd7/parameter.hpp> #include <renderd7/parameter.hpp>
#include <string> #include <string>
using CTRU_Thread = Thread; using CTRU_Thread = Thread;
#define THREAD_STACK_SIZE 0x1000 #define THREAD_STACK_SIZE 0x1000
namespace RenderD7 { namespace RenderD7 {
class Thread { class Thread {
public: public:
/** /**
* @brief Default constructor * @brief Default constructor
* @note This should only be called when calling m3d::Thread::initialize() * @note This should only be called when calling m3d::Thread::initialize()
* before calling m3d::Thread::start() * before calling m3d::Thread::start()
*/ */
Thread(); Thread();
/** /**
* @brief Constructs the thread * @brief Constructs the thread
* @param t_function The thread function * @param t_function The thread function
* @param t_parameter The parameter to pass to the function * @param t_parameter The parameter to pass to the function
* @param t_autostart Whether the thread should start instantly * @param t_autostart Whether the thread should start instantly
* @param t_detached Whether the thread starts detached or not * @param t_detached Whether the thread starts detached or not
* @param t_stackSize The stacksize allocated for the thread in bytes (rounded * @param t_stackSize The stacksize allocated for the thread in bytes (rounded
* to multiples of 8 bytes) * to multiples of 8 bytes)
* @note t_function needs to be of type `void` and take one (and only one) * @note t_function needs to be of type `void` and take one (and only one)
* parameter of type m3d::Parameter * parameter of type m3d::Parameter
* @warning If the thread priority is lower than the priority of the calling * @warning If the thread priority is lower than the priority of the calling
* thread, the thread will never get executed. Use * thread, the thread will never get executed. Use
* m3d::Thread::getCurrentPriority() to get the priority of the current thread * m3d::Thread::getCurrentPriority() to get the priority of the current thread
*/ */
Thread(std::function<void(RenderD7::Parameter)> t_function, Thread(std::function<void(RenderD7::Parameter)> t_function,
RenderD7::Parameter t_parameter = nullptr, bool t_autostart = false, RenderD7::Parameter t_parameter = nullptr, bool t_autostart = false,
bool t_detached = false, bool t_detached = false,
unsigned long long int t_stackSize = 4 * 1024); unsigned long long int t_stackSize = 4 * 1024);
/** /**
* @brief Destructs the thread * @brief Destructs the thread
*/ */
virtual ~Thread(); virtual ~Thread();
/** /**
* @brief Initializes the thread * @brief Initializes the thread
* @param t_function The thread function * @param t_function The thread function
* @param t_parameter The parameter to pass to the function * @param t_parameter The parameter to pass to the function
* @param t_autostart Whether the thread should start instantly * @param t_autostart Whether the thread should start instantly
* @param t_detached Whether the thread starts detached or not * @param t_detached Whether the thread starts detached or not
* @param t_stackSize The stacksize allocated for the thread in bytes (rounded * @param t_stackSize The stacksize allocated for the thread in bytes (rounded
* to multiples of 8 bytes) * to multiples of 8 bytes)
* @note t_function needs to be of type `void` and take one (and only one) * @note t_function needs to be of type `void` and take one (and only one)
* parameter of type m3d::Parameter * parameter of type m3d::Parameter
* @warning If the thread priority is lower than the priority of the calling * @warning If the thread priority is lower than the priority of the calling
* thread, the thread will never get executed. Use * thread, the thread will never get executed. Use
* m3d::Thread::getCurrentPriority() to get the priority of the current thread * m3d::Thread::getCurrentPriority() to get the priority of the current thread
*/ */
void initialize(std::function<void(RenderD7::Parameter)> t_function, void initialize(std::function<void(RenderD7::Parameter)> t_function,
RenderD7::Parameter t_parameter = nullptr, RenderD7::Parameter t_parameter = nullptr,
bool t_autostart = false, bool t_detached = false, bool t_autostart = false, bool t_detached = false,
unsigned long long int t_stackSize = 4 * 1024); unsigned long long int t_stackSize = 4 * 1024);
/** /**
* @brief Sets the size of the stack that gets allocated for the next thread * @brief Sets the size of the stack that gets allocated for the next thread
* that get's started * that get's started
* @param t_stackSize The allocated space in bytes (rounded to multiples of 8 * @param t_stackSize The allocated space in bytes (rounded to multiples of 8
* bytes) * bytes)
*/ */
void setStackSize(unsigned long long int t_stackSize); void setStackSize(unsigned long long int t_stackSize);
/** /**
* @brief Starts the thread. To restart it, call Thread::join() before * @brief Starts the thread. To restart it, call Thread::join() before
* @param t_detached Whether the thread should start detached or not * @param t_detached Whether the thread should start detached or not
*/ */
void start(bool t_detached = false); void start(bool t_detached = false);
/** /**
* @brief Detaches the thread * @brief Detaches the thread
*/ */
void kill(); void kill();
/** /**
* @brief Waits for the thread to finish * @brief Waits for the thread to finish
* @param t_timeout The timeout in nanoseconds. Leave it for no timeout * @param t_timeout The timeout in nanoseconds. Leave it for no timeout
*/ */
void join(long long unsigned int t_timeout = U64_MAX); void join(long long unsigned int t_timeout = U64_MAX);
bool isRunning(); bool isRunning();
/** /**
* @brief Puts the thread to sleep * @brief Puts the thread to sleep
* *
* This is needed if you have multiple threads running at the same time. It * This is needed if you have multiple threads running at the same time. It
* doesn't affect the execution-time of the thread, it just makes it possible * doesn't affect the execution-time of the thread, it just makes it possible
* for the other threads to get their chance to shine. * for the other threads to get their chance to shine.
*/ */
static void sleep(); static void sleep();
/** /**
* @brief Sleeps for the given time * @brief Sleeps for the given time
* @param t_milliseconds The time to sleep in milliseconds * @param t_milliseconds The time to sleep in milliseconds
*/ */
static void sleep(int t_milliseconds); static void sleep(int t_milliseconds);
private: private:
struct ThreadData { struct ThreadData {
RenderD7::Parameter m_parameter; RenderD7::Parameter m_parameter;
std::function<void(RenderD7::Parameter)> m_function; std::function<void(RenderD7::Parameter)> m_function;
std::atomic<bool> *m_running; std::atomic<bool> *m_running;
}; };
static void threadFunction(void *t_arg); static void threadFunction(void *t_arg);
/* data */ /* data */
int m_priority, m_stackSize; int m_priority, m_stackSize;
bool m_started; bool m_started;
std::atomic<bool> m_running; std::atomic<bool> m_running;
RenderD7::Thread::ThreadData m_data; RenderD7::Thread::ThreadData m_data;
CTRU_Thread m_thread; CTRU_Thread m_thread;
}; };
} // namespace RenderD7 } // namespace RenderD7

BIN
logo.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 13 KiB

After

Width:  |  Height:  |  Size: 17 KiB

52
not_functional/Flac.cpp Normal file
View File

@ -0,0 +1,52 @@
#include <renderd7/music/Flac.hpp>
#ifdef RENDERD7_MUSICDEC
#define DR_FLAC_IMPLEMENTATION
#include <renderd7/external/dr_flac.h>
int rd7i_check_flac(const std::string &path) {
int err = -1;
drflac* flac = drflac_open_file(path.c_str(), NULL);
if(flac != NULL)
err = 0;
drflac_close(flac);
return err;
}
namespace RenderD7 {
int FlacDecoder::_init(const std::string &path, MusicMeta& meta) {
meta.path(path);
if(path.find_last_of('/') != path.npos)
meta.name(path.substr(path.find_last_of('/')));
else
meta.name(path);
flac = drflac_open_file(path.c_str(), NULL);
return flac == NULL ? -1 : 0;
}
unsigned int FlacDecoder::_getSampleRate() { return flac->sampleRate; }
unsigned char FlacDecoder::_getChannels() { return flac->channels; }
size_t FlacDecoder::_getBufSize() { return buf_size; }
unsigned long long FlacDecoder::_decode(signed short*buf_addr) {
unsigned long long bsf = (unsigned long long)buf_size/(unsigned long long)flac->channels;
unsigned long long samples_read = drflac_read_pcm_frames_s16(flac, bsf, buf_addr);
samples_read *= (unsigned long long)flac->channels;
return samples_read;
}
void FlacDecoder::_deinit() {
drflac_close(flac);
}
size_t FlacDecoder::_getFileSamples() {
return flac->totalPCMFrameCount * (size_t)flac->channels;
}
} // namespace RenderD7
#endif

26
not_functional/Flac.hpp Normal file
View File

@ -0,0 +1,26 @@
#pragma once
#include <renderd7/music/Music.hpp>
#include <fstream>
#include <renderd7/external/dr_flac.h>
namespace RenderD7 {
class FlacDecoder : public MusicDecoder {
public:
FlacDecoder() {}
~FlacDecoder() {}
int _init(const std::string& pat, MusicMeta& meta) override;
unsigned int _getSampleRate() override;
unsigned char _getChannels() override;
size_t _getBufSize() override;
unsigned long long _decode(signed short* buf_addr) override;
void _deinit() override;
size_t _getFileSamples() override;
private:
drflac* flac;
const size_t buf_size = 16 * 1024;
};
}

40
not_functional/MUSIC.md Normal file
View File

@ -0,0 +1,40 @@
# Copy of removed Music.cpp file loaders
```
#include <renderd7/music/Flac.hpp>
#include <renderd7/music/Wav.hpp>
// "RIFF"
/*case 0x46464952:
// "riff"
case 0x66666972:
// "RIFX"
case 0x58464952:
// "RF64"
case 0x34364652:
// "FORM"
case 0x4D524F46:
decoder = new WavDecoder();
if (init(path, rd7i_mp_internal_data.meta)) {
MusicDecoder::CleanUp();
return;
}
break;*/
// Flac
/*case 0x43614c66:
decoder = new FlacDecoder();
if (init(path, rd7i_mp_internal_data.meta)) {
RenderD7::PushMessage(
RenderD7::Message("Music Player", "Failed to load FLAC"));
MusicDecoder::CleanUp();
return;
}
break;*/
// The other one
/*else if (rd7i_check_flac(path) == 0) {
decoder = new FlacDecoder();
if (init(path, rd7i_mp_internal_data.meta)) {
MusicDecoder::CleanUp();
return;
}
}*/
```

41
not_functional/Wav.cpp Normal file
View File

@ -0,0 +1,41 @@
#include <renderd7/music/Wav.hpp>
#ifdef RENDERD7_MUSICDEC
#define DR_WAV_IMPLEMENTATION
#include <renderd7/external/dr_wav.h>
namespace RenderD7 {
int WavDecoder::_init(const std::string &path, MusicMeta& meta) {
meta.path(path);
if(path.find_last_of('/') != path.npos)
meta.name(path.substr(path.find_last_of('/')));
else
meta.name(path);
return !drwav_init_file(&wav, path.c_str(), NULL);
}
unsigned int WavDecoder::_getSampleRate() { return wav.sampleRate; }
unsigned char WavDecoder::_getChannels() { return wav.channels; }
size_t WavDecoder::_getBufSize() { return buf_size; }
unsigned long long WavDecoder::_decode(signed short*buf_addr) {
unsigned long long bsf = (unsigned long long)buf_size/(unsigned long long)wav.channels;
unsigned long long samples_read = drwav_read_pcm_frames(&wav, bsf, buf_addr);
samples_read *= (unsigned long long)wav.channels;
return samples_read;
}
void WavDecoder::_deinit() {
drwav_uninit(&wav);
}
size_t WavDecoder::_getFileSamples() {
return wav.totalPCMFrameCount * (size_t)wav.channels;
}
} // namespace RenderD7
#endif

26
not_functional/Wav.hpp Normal file
View File

@ -0,0 +1,26 @@
#pragma once
#include <renderd7/music/Music.hpp>
#include <fstream>
#include <renderd7/external/dr_wav.h>
namespace RenderD7 {
class WavDecoder : public MusicDecoder {
public:
WavDecoder() {}
~WavDecoder() {}
int _init(const std::string& path, MusicMeta& meta) override;
unsigned int _getSampleRate() override;
unsigned char _getChannels() override;
size_t _getBufSize() override;
unsigned long long _decode(signed short* buf_addr) override;
void _deinit() override;
size_t _getFileSamples() override;
private:
drwav wav;
const size_t buf_size = 16 * 1024;
};
}

553
rd7tf/Makefile
View File

@ -1,275 +1,278 @@
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
.SUFFIXES: .SUFFIXES:
#nicetest #nicetest
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
ifeq ($(strip $(DEVKITARM)),) ifeq ($(strip $(DEVKITARM)),)
$(error "Please set DEVKITARM in your environment. export DEVKITARM=<path to>devkitARM") $(error "Please set DEVKITARM in your environment. export DEVKITARM=<path to>devkitARM")
endif endif
TOPDIR ?= $(CURDIR) TOPDIR ?= $(CURDIR)
include $(DEVKITARM)/3ds_rules include $(DEVKITARM)/3ds_rules
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
# TARGET is the name of the output # TARGET is the name of the output
# BUILD is the directory where object files & intermediate files will be placed # BUILD is the directory where object files & intermediate files will be placed
# SOURCES is a list of directories containing source code # SOURCES is a list of directories containing source code
# DATA is a list of directories containing data files # DATA is a list of directories containing data files
# INCLUDES is a list of directories containing header files # INCLUDES is a list of directories containing header files
# GRAPHICS is a list of directories containing graphics files # GRAPHICS is a list of directories containing graphics files
# GFXBUILD is the directory where converted graphics files will be placed # GFXBUILD is the directory where converted graphics files will be placed
# If set to $(BUILD), it will statically link in the converted # If set to $(BUILD), it will statically link in the converted
# files as if they were data files. # files as if they were data files.
# #
# NO_SMDH: if set to anything, no SMDH file is generated. # NO_SMDH: if set to anything, no SMDH file is generated.
# ROMFS is the directory which contains the RomFS, relative to the Makefile (Optional) # ROMFS is the directory which contains the RomFS, relative to the Makefile (Optional)
# APP_TITLE is the name of the app stored in the SMDH file (Optional) # APP_TITLE is the name of the app stored in the SMDH file (Optional)
# APP_DESCRIPTION is the description of the app stored in the SMDH file (Optional) # APP_DESCRIPTION is the description of the app stored in the SMDH file (Optional)
# APP_AUTHOR is the author of the app stored in the SMDH file (Optional) # APP_AUTHOR is the author of the app stored in the SMDH file (Optional)
# ICON is the filename of the icon (.png), relative to the project folder. # ICON is the filename of the icon (.png), relative to the project folder.
# If not set, it attempts to use one of the following (in this order): # If not set, it attempts to use one of the following (in this order):
# - <Project name>.png # - <Project name>.png
# - icon.png # - icon.png
# - <libctru folder>/default_icon.png # - <libctru folder>/default_icon.png
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
# External tools # External tools
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
ifeq ($(OS),Windows_NT) ifeq ($(OS),Windows_NT)
MAKEROM ?= C:/devkitpro/tools/bin/makerom.exe MAKEROM ?= C:/devkitpro/tools/bin/makerom.exe
BANNERTOOL ?= C:/devkitpro/tools/bin/bannertool.exe BANNERTOOL ?= C:/devkitpro/tools/bin/bannertool.exe
else else
MAKEROM ?= makerom MAKEROM ?= makerom
BANNERTOOL ?= bannertool BANNERTOOL ?= bannertool
endif endif
# If on a tagged commit, use the tag instead of the commit # If on a tagged commit, use the tag instead of the commit
ifneq ($(shell echo $(shell git tag -l --points-at HEAD) | head -c 1),) ifneq ($(shell echo $(shell git tag -l --points-at HEAD) | head -c 1),)
GIT_VER := $(shell git tag -l --points-at HEAD) GIT_VER := $(shell git tag -l --points-at HEAD)
else else
GIT_VER := $(shell git rev-parse --short HEAD) GIT_VER := $(shell git rev-parse --short HEAD)
endif endif
TIME_TIME := $(shell date --iso=seconds) TIME_TIME := unk
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
# Version number # Version number
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
VERSION_MAJOR := 1 VERSION_MAJOR := 1
VERSION_MINOR := 0 VERSION_MINOR := 0
VERSION_MICRO := 0 VERSION_MICRO := 0
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
# Make Sure to Change this paths if your Submodule # Make Sure to Change this paths if your Submodule
# is located somewhere else # is located somewhere else
# Using ../ cause rd7tf is shipped with the RenderD7 # Using ../ cause rd7tf is shipped with the RenderD7
# Repository! # Repository!
RENDERD7_SRC := ../source ../external RENDERD7_SRC := ../source ../external ../source/music
RENDERD7_INC := ../include RENDERD7_INC := ../include
TARGET := rd7tf # Libraries used for RenderD7
BUILD := build # if you already use -lm, -lctru etc place a # before -lm
SOURCES := source $(RENDERD7_SRC) RENDERD7_LIBS := -lcurl -lm -lcitro2dd -lcitro3d -lctru
DATA := data TARGET := rd7tf
INCLUDES := source $(RENDERD7_INC) BUILD := build
GRAPHICS := gfx SOURCES := source $(RENDERD7_SRC)
#GFXBUILD := $(BUILD) DATA := data
ROMFS := romfs INCLUDES := source $(RENDERD7_INC)
GFXBUILD := $(ROMFS)/gfx GRAPHICS := gfx
APP_AUTHOR := NPI-D7 #GFXBUILD := $(BUILD)
APP_DESCRIPTION := RenderD7 Test Framework ROMFS := romfs
ICON := app/icon.png GFXBUILD := $(ROMFS)/gfx
APP_AUTHOR := NPI-D7
#--------------------------------------------------------------------------------- APP_DESCRIPTION := RenderD7 Test Framework
# options for code generation ICON := app/icon.png
#---------------------------------------------------------------------------------
ARCH := -march=armv6k -mtune=mpcore -mfloat-abi=hard -mtp=soft #---------------------------------------------------------------------------------
# options for code generation
CFLAGS := -g -Wall -Wno-psabi -O2 -mword-relocations \ #---------------------------------------------------------------------------------
-DV_STRING=\"$(GIT_VER)\" \ ARCH := -march=armv6k -mtune=mpcore -mfloat-abi=hard -mtp=soft
-DV_TIME=\"$(TIME_TIME)\" \
-fomit-frame-pointer -ffunction-sections \ CFLAGS := -g -Wall -Wno-psabi -O2 -mword-relocations \
$(ARCH) -DV_STRING=\"$(GIT_VER)\" \
-DV_TIME=\"$(TIME_TIME)\" \
CFLAGS += $(INCLUDE) -D__3DS__ -D_GNU_SOURCE=1 -ffunction-sections \
$(ARCH)
CXXFLAGS := $(CFLAGS) -fno-rtti -fno-exceptions -std=gnu++20
CFLAGS += $(INCLUDE) -D__3DS__ -D_GNU_SOURCE=1
ASFLAGS := -g $(ARCH)
LDFLAGS = -specs=3dsx.specs -g $(ARCH) -Wl,-Map,$(notdir $*.map) CXXFLAGS := $(CFLAGS) -fno-rtti -fno-exceptions -std=gnu++20
LIBS := -lcurl -lstdc++ -lm -lz -lcitro2d -lcitro3d -lctru -ljpeg ASFLAGS := -g $(ARCH)
LDFLAGS = -specs=3dsx.specs -g $(ARCH) -Wl,-Map,$(notdir $*.map)
#--------------------------------------------------------------------------------- LIBS := -lstdc++ $(RENDERD7_LIBS)
# list of directories containing libraries, this must be the top level containing
# include and lib
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
LIBDIRS := $(PORTLIBS) $(CTRULIB) # list of directories containing libraries, this must be the top level containing
# include and lib
#---------------------------------------------------------------------------------
#--------------------------------------------------------------------------------- LIBDIRS := $(PORTLIBS) $(CTRULIB)
# no real need to edit anything past this point unless you need to add additional
# rules for different file extensions
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
ifneq ($(BUILD),$(notdir $(CURDIR))) # no real need to edit anything past this point unless you need to add additional
#--------------------------------------------------------------------------------- # rules for different file extensions
#---------------------------------------------------------------------------------
export OUTPUT := $(CURDIR)/$(TARGET) ifneq ($(BUILD),$(notdir $(CURDIR)))
export TOPDIR := $(CURDIR) #---------------------------------------------------------------------------------
export VPATH := $(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \ export OUTPUT := $(CURDIR)/$(TARGET)
$(foreach dir,$(GRAPHICS),$(CURDIR)/$(dir)) \ export TOPDIR := $(CURDIR)
$(foreach dir,$(DATA),$(CURDIR)/$(dir))
export VPATH := $(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
export DEPSDIR := $(CURDIR)/$(BUILD) $(foreach dir,$(GRAPHICS),$(CURDIR)/$(dir)) \
$(foreach dir,$(DATA),$(CURDIR)/$(dir))
CFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
CPPFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp))) export DEPSDIR := $(CURDIR)/$(BUILD)
SFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
PICAFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.v.pica))) CFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
SHLISTFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.shlist))) CPPFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
GFXFILES := $(foreach dir,$(GRAPHICS),$(notdir $(wildcard $(dir)/*.t3s))) SFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
BINFILES := $(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*))) PICAFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.v.pica)))
SHLISTFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.shlist)))
#--------------------------------------------------------------------------------- GFXFILES := $(foreach dir,$(GRAPHICS),$(notdir $(wildcard $(dir)/*.t3s)))
# use CXX for linking C++ projects, CC for standard C BINFILES := $(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
#---------------------------------------------------------------------------------
ifeq ($(strip $(CPPFILES)),) #---------------------------------------------------------------------------------
#--------------------------------------------------------------------------------- # use CXX for linking C++ projects, CC for standard C
export LD := $(CC) #---------------------------------------------------------------------------------
#--------------------------------------------------------------------------------- ifeq ($(strip $(CPPFILES)),)
else #---------------------------------------------------------------------------------
#--------------------------------------------------------------------------------- export LD := $(CC)
export LD := $(CXX) #---------------------------------------------------------------------------------
#--------------------------------------------------------------------------------- else
endif #---------------------------------------------------------------------------------
#--------------------------------------------------------------------------------- export LD := $(CXX)
#---------------------------------------------------------------------------------
#--------------------------------------------------------------------------------- endif
ifeq ($(GFXBUILD),$(BUILD)) #---------------------------------------------------------------------------------
#---------------------------------------------------------------------------------
export T3XFILES := $(GFXFILES:.t3s=.t3x) #---------------------------------------------------------------------------------
#--------------------------------------------------------------------------------- ifeq ($(GFXBUILD),$(BUILD))
else #---------------------------------------------------------------------------------
#--------------------------------------------------------------------------------- export T3XFILES := $(GFXFILES:.t3s=.t3x)
export ROMFS_T3XFILES := $(patsubst %.t3s, $(GFXBUILD)/%.t3x, $(GFXFILES)) #---------------------------------------------------------------------------------
export T3XHFILES := $(patsubst %.t3s, $(BUILD)/%.h, $(GFXFILES)) else
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
endif export ROMFS_T3XFILES := $(patsubst %.t3s, $(GFXBUILD)/%.t3x, $(GFXFILES))
#--------------------------------------------------------------------------------- export T3XHFILES := $(patsubst %.t3s, $(BUILD)/%.h, $(GFXFILES))
#---------------------------------------------------------------------------------
export OFILES_SOURCES := $(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o) endif
#---------------------------------------------------------------------------------
export OFILES_BIN := $(addsuffix .o,$(BINFILES)) \
$(PICAFILES:.v.pica=.shbin.o) $(SHLISTFILES:.shlist=.shbin.o) export OFILES_SOURCES := $(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
export OFILES := $(OFILES_BIN) $(OFILES_SOURCES) export OFILES_BIN := $(addsuffix .o,$(BINFILES)) \
$(PICAFILES:.v.pica=.shbin.o) $(SHLISTFILES:.shlist=.shbin.o)
export HFILES := $(PICAFILES:.v.pica=_shbin.h) $(SHLISTFILES:.shlist=_shbin.h) \
$(addsuffix .h,$(subst .,_,$(BINFILES))) export OFILES := $(OFILES_BIN) $(OFILES_SOURCES)
export INCLUDE := $(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \ export HFILES := $(PICAFILES:.v.pica=_shbin.h) $(SHLISTFILES:.shlist=_shbin.h) \
$(foreach dir,$(LIBDIRS),-I$(dir)/include) \ $(addsuffix .h,$(subst .,_,$(BINFILES)))
-I$(CURDIR)/$(BUILD)
export INCLUDE := $(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
export LIBPATHS := $(foreach dir,$(LIBDIRS),-L$(dir)/lib) $(foreach dir,$(LIBDIRS),-I$(dir)/include) \
-I$(CURDIR)/$(BUILD)
export _3DSXDEPS := $(if $(NO_SMDH),,$(OUTPUT).smdh)
export LIBPATHS := $(foreach dir,$(LIBDIRS),-L$(dir)/lib)
ifeq ($(strip $(ICON)),)
icons := $(wildcard *.png) export _3DSXDEPS := $(if $(NO_SMDH),,$(OUTPUT).smdh)
ifneq (,$(findstring $(TARGET).png,$(icons)))
export APP_ICON := $(TOPDIR)/$(TARGET).png ifeq ($(strip $(ICON)),)
else icons := $(wildcard *.png)
ifneq (,$(findstring icon.png,$(icons))) ifneq (,$(findstring $(TARGET).png,$(icons)))
export APP_ICON := $(TOPDIR)/icon.png export APP_ICON := $(TOPDIR)/$(TARGET).png
endif else
endif ifneq (,$(findstring icon.png,$(icons)))
else export APP_ICON := $(TOPDIR)/icon.png
export APP_ICON := $(TOPDIR)/$(ICON) endif
endif endif
else
ifeq ($(strip $(NO_SMDH)),) export APP_ICON := $(TOPDIR)/$(ICON)
export _3DSXFLAGS += --smdh=$(CURDIR)/$(TARGET).smdh endif
endif
ifeq ($(strip $(NO_SMDH)),)
ifneq ($(ROMFS),) export _3DSXFLAGS += --smdh=$(CURDIR)/$(TARGET).smdh
export _3DSXFLAGS += --romfs=$(CURDIR)/$(ROMFS) endif
endif
ifneq ($(ROMFS),)
.PHONY: all clean export _3DSXFLAGS += --romfs=$(CURDIR)/$(ROMFS)
endif
#---------------------------------------------------------------------------------
all: $(BUILD) $(GFXBUILD) $(DEPSDIR) $(ROMFS_T3XFILES) $(T3XHFILES) .PHONY: all clean
@$(MAKE) --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
#---------------------------------------------------------------------------------
#------------------------------------------------------------------------------ all: $(BUILD) $(GFXBUILD) $(DEPSDIR) $(ROMFS_T3XFILES) $(T3XHFILES)
clean: @$(MAKE) --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
@echo clean ...
@rm -fr $(BUILD) $(TARGET).elf $(TARGET).3dsx $(TARGET).cia $(TARGET).smdh app/*.bin #------------------------------------------------------------------------------
@rm -fr $(OUTDIR) clean:
@echo clean ...
#--------------------------------------------------------------------------------- @rm -fr $(BUILD) $(TARGET).elf $(TARGET).3dsx $(TARGET).cia $(TARGET).smdh app/*.bin
send: @rm -fr $(OUTDIR)
@3dslink -a $(IP) $(TARGET).3dsx
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
run: send:
@flatpak run org.citra_emu.citra $(TARGET).3dsx @3dslink -a $(IP) $(TARGET).3dsx
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
#--------------------------------------------------------------------------------- run:
3dsx: $(BUILD) @flatpak run org.citra_emu.citra $(TARGET).3dsx
@$(MAKE) --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile 3dsx #---------------------------------------------------------------------------------
#---------------------------------------------------------------------------------
#--------------------------------------------------------------------------------- 3dsx: $(BUILD)
$(GFXBUILD)/%.t3x $(BUILD)/%.h : %.t3s @$(MAKE) --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile 3dsx
#---------------------------------------------------------------------------------
@echo $(notdir $<) #---------------------------------------------------------------------------------
$(DEVKITPRO)/tools/bin/tex3ds -i $< -H $(BUILD)/$*.h -d $(DEPSDIR)/$*.d -o $(GFXBUILD)/$*.t3x $(GFXBUILD)/%.t3x $(BUILD)/%.h : %.t3s
#---------------------------------------------------------------------------------
#--------------------------------------------------------------------------------- @echo $(notdir $<)
$(BUILD): $(DEVKITPRO)/tools/bin/tex3ds -i $< -H $(BUILD)/$*.h -d $(DEPSDIR)/$*.d -o $(GFXBUILD)/$*.t3x
@[ -d $@ ] || mkdir -p $@
#---------------------------------------------------------------------------------
#--------------------------------------------------------------------------------- $(BUILD):
else @[ -d $@ ] || mkdir -p $@
#--------------------------------------------------------------------------------- #---------------------------------------------------------------------------------
# main targets else
#---------------------------------------------------------------------------------
all: $(OUTPUT).elf $(OUTPUT).3dsx #---------------------------------------------------------------------------------
# main targets
$(OUTPUT).elf : $(OFILES) #---------------------------------------------------------------------------------
$(OUTPUT).3dsx : $(_3DSXDEPS) all: $(OUTPUT).elf $(OUTPUT).3dsx
#---------------------------------------------------------------------------------
# you need a rule like this for each extension you use as binary data $(OUTPUT).elf : $(OFILES)
#--------------------------------------------------------------------------------- $(OUTPUT).3dsx : $(_3DSXDEPS)
%.bin.o %_bin.h : %.bin #---------------------------------------------------------------------------------
#--------------------------------------------------------------------------------- # you need a rule like this for each extension you use as binary data
@echo $(notdir $<) #---------------------------------------------------------------------------------
@$(bin2o) %.bin.o %_bin.h : %.bin
#---------------------------------------------------------------------------------
#--------------------------------------------------------------------------------- @echo $(notdir $<)
.PRECIOUS : %.t3x %.shbin @$(bin2o)
#---------------------------------------------------------------------------------
%.t3x.o %_t3x.h : %.t3x #---------------------------------------------------------------------------------
#--------------------------------------------------------------------------------- .PRECIOUS : %.t3x %.shbin
$(SILENTMSG) $(notdir $<) #---------------------------------------------------------------------------------
$(bin2o) %.t3x.o %_t3x.h : %.t3x
#---------------------------------------------------------------------------------
#--------------------------------------------------------------------------------- $(SILENTMSG) $(notdir $<)
%.shbin.o %_shbin.h : %.shbin $(bin2o)
#---------------------------------------------------------------------------------
$(SILENTMSG) $(notdir $<) #---------------------------------------------------------------------------------
$(bin2o) %.shbin.o %_shbin.h : %.shbin
#---------------------------------------------------------------------------------
-include $(DEPSDIR)/*.d $(SILENTMSG) $(notdir $<)
$(bin2o)
#---------------------------------------------------------------------------------------
endif -include $(DEPSDIR)/*.d
#---------------------------------------------------------------------------------------
#---------------------------------------------------------------------------------------
endif
#---------------------------------------------------------------------------------------

16
rd7tf/clean.sh
View File

@ -1,9 +1,9 @@
#!/bin/bash #!/bin/bash
#Clean old build #Clean old build
echo "Cleaning..." echo "Cleaning..."
make clean make clean
rm -rf libs/* rm -rf libs/*
cd .. cd ..
make clean make clean
echo "Done!" echo "Done!"

BIN
rd7tf/romfs/icons/icon.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 844 B

BIN
rd7tf/romfs/roboto_bold.bcfnt Normal file
View File

Binary file not shown.

77
rd7tf/source/main.cpp
View File

@ -1,27 +1,52 @@
#include <rd7.hpp> #include "scene.hpp"
#include "renderd7/music/Music.hpp"
int main() {
rd7_do_splash = true; void ColorThemeSample() {
RenderD7::Ftrace::Beg("app", "app_init"); RenderD7::ColorNew(RD7Color_Text, RenderD7::Color::Hex("#000000", 255));
RenderD7::Init::Main("rd7tf"); RenderD7::ColorNew(RD7Color_TextDisabled, RenderD7::Color::Hex("#212121", 200));
RenderD7::Init::NdspFirm(); RenderD7::ColorNew(RD7Color_Text2, RenderD7::Color::Hex("#ffffff", 255));
RenderD7::Ftrace::Beg("app", f2s(RenderD7::LoadSettings)); RenderD7::ColorNew(RD7Color_Background, RenderD7::Color::Hex("#eeeeee", 170));
RenderD7::LoadSettings(); RenderD7::ColorNew(RD7Color_Header, RenderD7::Color::Hex("#222222", 190));
RenderD7::Ftrace::End("app", f2s(RenderD7::LoadSettings)); RenderD7::ColorNew(RD7Color_Selector, RenderD7::Color::Hex("#4444dd", 200));
sound snd("romfs:/thesound.wav", 0); RenderD7::ColorNew(RD7Color_SelectorFade, RenderD7::Color::Hex("#7777dd", 200));
snd.play(); RenderD7::ColorNew(RD7Color_List0, RenderD7::Color::Hex("#555555", 130));
RenderD7::PushMessage(RenderD7::Message(std::string("RenderD7 ") + RENDERD7VSTRING, "Testing the ToastsV2")); RenderD7::ColorNew(RD7Color_List1, RenderD7::Color::Hex("#777777", 130));
RenderD7::Ftrace::End("app", "app_init"); RenderD7::ColorNew(RD7Color_MessageBackground, RenderD7::Color::Hex("#222222", 180));
while (RenderD7::MainLoop()) { RenderD7::ColorNew(RD7Color_Button, RenderD7::Color::Hex("#4444dd", 150));
RenderD7::Ftrace::Beg("app", "app_mainloop"); RenderD7::ColorNew(RD7Color_ButtonHovered, RenderD7::Color::Hex("#6666dd", 150));
if (d7_hDown & KEY_START) RenderD7::ColorNew(RD7Color_ButtonDisabled, RenderD7::Color::Hex("#2222dd", 150));
RenderD7::ExitApp(); RenderD7::ColorNew(RD7Color_ButtonActive, RenderD7::Color::Hex("#7777dd", 150));
if(d7_hDown & KEY_A) { RenderD7::ColorNew(RD7Color_Checkmark, RenderD7::Color::Hex("#4444dd", 130));
RenderD7::PushMessage(RenderD7::Message(std::string("RenderD7 ") + RENDERD7VSTRING, "Testing the ToastsV2\nPressed A")); RenderD7::ColorNew(RD7Color_FrameBg, RenderD7::Color::Hex("#555555", 160));
} RenderD7::ColorNew(RD7Color_FrameBgHovered, RenderD7::Color::Hex("#777777", 160));
RenderD7::FrameEnd(); RenderD7::ColorNew(RD7Color_Progressbar, RenderD7::Color::Hex("#4444dd", 200));
RenderD7::Ftrace::End("app", "app_mainloop"); }
}
extern void IdbServer();
return 0;
int main() {
rd7_enable_memtrack = true;
rd7_do_splash = true;
RenderD7::Ftrace::Beg("app", "app_init");
RenderD7::Init::Main("rd7tf");
RenderD7::FadeIn();
//RenderD7::InlineAssert(1 == 2, "1 is not 2!");
//IdbServer();
ColorThemeSample();
RenderD7::Init::NdspFirm();
RenderD7::Scene::Load(std::make_unique<Sample>());
RenderD7::Ftrace::End("app", "app_init");
while (RenderD7::MainLoop()) {
RenderD7::OnScreen(Top);
RenderD7::Ftrace::Beg("app", "app_mainloop");
if (d7_hDown & KEY_START) {
RenderD7::FadeOut();
RenderD7::ExitApp();
}
RenderD7::OnScreen(Top);
RenderD7::FrameEnd();
RenderD7::Ftrace::End("app", "app_mainloop");
}
return 0;
} }

132
rd7tf/source/scene.cpp Normal file
View File

@ -0,0 +1,132 @@
#include "scene.hpp"
#include <cmath>
static float MakeOffset(float x) {
float y = cos(x) * 42;
return y - floor(y);
}
static void Wave(int index, R7Vec2 position, R7Vec2 size, float time,
bool dbg) {
float offset = MakeOffset(index) * 62;
float x_position =
position.x + size.x / 8 * ((index % 11) - 1) + cos(offset + time) * 10;
float y_position = position.y + size.y / 8 * (index / 11) + 40 +
sin(offset + time) * 10 + 30;
float color_effect = 1 - exp(-(index / 11) / 3.0f);
// As this is 3ds dont go out of the box
int shrink = 0;
if (y_position >= position.y + size.y - 90) {
shrink = y_position - (position.y + size.y - 90);
}
// Just to make sure...
y_position = std::min(y_position, position.y + size.y - (90 - shrink));
if (dbg)
RenderD7::Draw2::TriangleLined(
R7Vec2(x_position, y_position),
R7Vec2(x_position + 300, y_position + (90 - shrink)),
R7Vec2(x_position - 300, y_position + (90 - shrink)),
RenderD7::Color::RGBA(.94f - .17f * color_effect,
.61f - .25f * color_effect,
.36f + .38f * color_effect)
.toRGBA());
else
RenderD7::Draw2::TriangleSolid(
R7Vec2(x_position, y_position),
R7Vec2(x_position + 300, y_position + (90 - shrink)),
R7Vec2(x_position - 300, y_position + (90 - shrink)),
RenderD7::Color::RGBA(.94f - .17f * color_effect,
.61f - .25f * color_effect,
.36f + .38f * color_effect)
.toRGBA());
}
void DrawWave(R7Vec2 position, R7Vec2 size, float time, bool dbg) {
RenderD7::Draw2::RectFilledSolid(position, size, 0xff64c9fd);
int i = 0;
for (; i < 44; i++) Wave(i, position, size, time, dbg);
}
R7Vec2 testv2 = R7Vec2(48, 48);
R7Vec2 grid_display_entry(void* data, R7Vec2 pos) {
auto img = reinterpret_cast<RenderD7::Image*>(data);
RenderD7::Draw2::Image(img, pos);
RenderD7::Draw2::RFS(pos, testv2, RenderD7::Color::Hex("#0000ff", 140));
return testv2;
}
std::vector<RenderD7::Image*> imgdb;
Sample::Sample() {
/*RenderD7::Image* im = new RenderD7::Image();
im->load("romfs:/icons/icon.png");
for(int i = 0; i < 64; i++)
imgdb.push_back(im);*/
auto t = RenderD7::FileSystem::GetDirContent("sdmc:/music/");
for(const auto& it : t)
names.push_back(it.path);
}
Sample::~Sample() {
// Here you can clear your data
}
void Sample::Draw() const {
// Draw Things to Screen:
// Step 1 -> Select Screen
RenderD7::OnScreen(Top);
// Step 2 -> Draw Things
// The hbloader Triangle Wave
DrawWave(R7Vec2(0, 0), R7Vec2(400, 240), RenderD7::GetTime(),
debug_background);
// For Example A Rect with Draw2 and StyleColorApi
// And the RFS Wrapper for RectFilledSolid lol
/*RenderD7::Draw2::RFS(R7Vec2(0, 0), R7Vec2(400, 20),
RenderD7::StyleColor(RD7Color_Header));
// As the Top bar is Dark you need TextColor2
RenderD7::RedirectColor(RD7Color_Text, RD7Color_Text2);
RenderD7::Draw2::Text(R7Vec2(5, 2), "RenderD7 - Test Framework");
RenderD7::Draw2::Text(R7Vec2(395, 2), RENDERD7VSTRING,
RD7TextFlags_AlignRight);
RenderD7::UndoColorEdit(RD7Color_Text);*/
if (UI7::BeginMenu("RenderD7 Test Framework")) {
UI7::SetCursorPos(R7Vec2(395, 2));
UI7::Label(RenderD7::FormatBytes(RenderD7::Memory::GetCurrent()), RD7TextFlags_AlignRight);
UI7::RestoreCursor();
//UI7::Grid("Files", R7Vec2(390, 210), grid_display_entry, reinterpret_cast<void**>(imgdb.data()), imgdb.size());
UI7::BrowserList(names, sel);
UI7::EndMenu();
}
RenderD7::OnScreen(Bottom);
if (UI7::BeginMenu("Control Center")) {
if (UI7::Button("RenderD7 Settings"))
shared_requests[1U] = 1U; // Request a Toggle
UI7::SameLine();
if (UI7::Button("Test Message"))
shared_requests[2U] = 1U; // Request Test Msg
UI7::Checkbox("Debug BG", debug_background);
UI7::SameLine();
UI7::Checkbox("RD7-Debug", rd7_debugging);
UI7::InputText("Search", search__, "Tap Here");
UI7::EndMenu();
}
}
void Sample::Logic() {
for (const auto& it : shared_requests) {
if (it.first == 1U) {
if (it.second) RenderD7::LoadSettings();
} else if (it.first == 2U) {
if (it.second)
RenderD7::PushMessage(RenderD7::Message(
"Test Message", "Button Bressed\nBest Msg Handler..."));
}
}
// Make sure to clear after processing!!!;
shared_requests.clear();
if (d7_hDown & KEY_B) debug_background = !debug_background;
}

27
rd7tf/source/scene.hpp Normal file
View File

@ -0,0 +1,27 @@
#pragma once
#include <rd7.hpp>
class Sample : public RenderD7::Scene {
public:
Sample();
~Sample();
void Draw() const override;
void Logic() override;
private:
// Just as the RD7 Settings Shows here as example
// by using a mutale map you're able to process
// requests from the const Draw function in the
// Logic Function! you could also create lots of
// mutable bool or make all Variables mutable but
// i think seperating draw and logic is better
// editable map request_id data/operation
mutable std::map<unsigned int, unsigned int> shared_requests;
// For Checkbox its best to use mutable
mutable bool debug_background = false;
mutable std::string search__ = "";
mutable std::vector<std::string> names;
mutable int sel;
};

42
rd7tf/update.sh
View File

@ -1,22 +1,22 @@
#!/bin/bash #!/bin/bash
#Clean old build #Clean old build
echo "Cleaning..." echo "Cleaning..."
rm -rf libs/* rm -rf libs/*
#Format to LLVM #Format to LLVM
echo "Format to LLVM" echo "Format to LLVM"
cd .. cd ..
./cformat.sh ./cformat.sh
#Compile RenderD7 #Compile RenderD7
echo "Compiling RenderD7" echo "Compiling RenderD7"
make make
#Copy new build #Copy new build
echo "Copy New Build" echo "Copy New Build"
cp -r include rd7tf/libs/ cp -r include rd7tf/libs/
cp -r lib rd7tf/libs/ cp -r lib rd7tf/libs/
#Build Test Framework #Build Test Framework
echo "Building Test Framework" echo "Building Test Framework"
cd rd7tf cd rd7tf
make make
echo "Done!" echo "Done!"

475
source/BitmapPrinter.cpp
View File

@ -1,475 +0,0 @@
#include <renderd7/BitmapPrinter.hpp>
#include <renderd7/ToastsV2.hpp>
#include <renderd7/stringtool.hpp>
extern bool shouldbe_disabled;
extern std::string csvpc;
RenderD7::BitmapPrinter::BitmapPrinter(int w, int h) {
BMP newmap(w, h, true);
bitmap = newmap;
// renderframe.LoadPFromBuffer(BitmapConverter::ConvertData(bitmap.DATA()));
blank = newmap;
}
RenderD7::BitmapPrinter::~BitmapPrinter() {
if (this->renderframe.loadet)
this->renderframe.Unload();
}
bool RenderD7::BitmapPrinter::DecodeFile(std::string file) {
unsigned error = bitmap.read(file.c_str());
if (error) {
RenderD7::PushMessage(RenderD7::Message(
"BitmapPrinter", "Error Code: " + std::to_string(error)));
return false;
}
return true;
}
void RenderD7::BitmapPrinter::DrawPixel(int x, int y, u8 b, u8 g, u8 r, u8 a) {
unsigned error =
bitmap.set_pixel(x, bitmap.bmp_info_header.height - y, b, g, r, a);
if (error) {
RenderD7::PushMessage(RenderD7::Message(
"BitmapPrinter->Pixel", "Error Code: " + std::to_string(error)));
}
}
void RenderD7::BitmapPrinter::DrawRect(int x, int y, int w, int h, u8 line_w,
u8 b, u8 g, u8 r, u8 a) {
unsigned error = bitmap.draw_rectangle(
x, bitmap.bmp_info_header.height - y - h, w, h, b, g, r, a, line_w);
if (error) {
RenderD7::PushMessage(RenderD7::Message(
"BitmapPrinter->Rect", "Error Code: " + std::to_string(error)));
}
}
void RenderD7::BitmapPrinter::DrawRectFilled(int x, int y, int w, int h, u8 b,
u8 g, u8 r, u8 a) {
unsigned error = bitmap.fill_region(x, bitmap.bmp_info_header.height - h - y,
w, h, b, g, r, a);
if (error) {
RenderD7::PushMessage(RenderD7::Message(
"BitmapPrinter->RectF", "Error Code: " + std::to_string(error)));
}
}
void RenderD7::BitmapPrinter::SaveBmp(std::string name) {
if (!RenderD7::NameIsEndingWith(name, {"bmp"})) {
name += ".bmp";
}
bitmap.write(name.c_str());
}
void RenderD7::BitmapPrinter::SavePng(std::string name) {
if (!RenderD7::NameIsEndingWith(name, {"png"})) {
name += ".png";
}
std::vector<unsigned char> ImageBuffer;
ImageBuffer = BitmapConverter::ConvertData(bitmap.DATA());
lodepng::save_file(ImageBuffer, name);
}
void RenderD7::BitmapPrinter::CreateScreen(C3D_RenderTarget *target) {
isscreen = true;
targetr = target;
if (target == Top) {
bitmap = BMP(400, 240, true);
blank = BMP(400, 240, true);
}
if (target == TopRight) {
bitmap = BMP(400, 240, true);
blank = BMP(400, 240, true);
}
if (target == Bottom) {
bitmap = BMP(320, 240, true);
blank = BMP(320, 240, true);
}
renderframe.LoadPFromBuffer(BitmapConverter::ConvertData(bitmap.DATA()));
}
bool RenderD7::BitmapPrinter::DrawScreenDirectF(int framerate) {
bool updtt = false;
if (isscreen) {
if (frame == (60 / framerate)) {
RenderD7::OnScreen(targetr);
if (renderframe.loadet)
renderframe.Unload();
this->Decode(decc);
frame = 0;
updtt = true;
}
if (renderframe.loadet)
renderframe.Draw(0, 0);
frame++;
}
return updtt;
}
bool RenderD7::BitmapPrinter::DrawScreenDirect() {
bool updtt = false;
if (isscreen) {
RenderD7::OnScreen(targetr);
if (renderframe.loadet)
renderframe.Unload();
this->Decode(decc);
updtt = true;
if (renderframe.loadet)
renderframe.Draw(0, 0);
}
return updtt;
}
RenderD7::Image RenderD7::BitmapPrinter::GetImage() {
RenderD7::Image img;
img.LoadFromBitmap(bitmap);
return img;
}
void RenderD7::BitmapPrinter::UsePreMap(BMP map) { bitmap = map; }
void RenderD7::BitmapPrinter::UsePrePrintMap(BitmapPrinter printmap) {
bitmap = printmap.GetBitmap();
}
void RenderD7::BitmapPrinter::Clear(u8 b, u8 g, u8 r, u8 a) {
bitmap.fill_region(0, 0, bitmap.bmp_info_header.width,
bitmap.bmp_info_header.height, b, g, r, a);
}
void RenderD7::BitmapPrinter::ClearBlank() { bitmap = blank; }
void RenderD7::BitmapPrinter::DrawScreenF(int framerate) {
if (isscreen) {
if (frame == (60 / framerate)) {
RenderD7::OnScreen(targetr);
frame = 0;
}
if (renderframe.loadet)
renderframe.Draw(0, 0);
frame++;
}
}
void RenderD7::BitmapPrinter::DrawScreen() {
if (isscreen) {
RenderD7::OnScreen(targetr);
if (renderframe.loadet)
renderframe.Draw(0, 0);
}
}
bool RenderD7::BitmapPrinter::UpdateScreenF(int framerate) {
bool updtt = false;
if (isscreen) {
if (frame == (60 / framerate)) {
if (renderframe.loadet)
renderframe.Unload();
// renderframe.LoadFromBitmap(bitmap);
this->Decode(decc);
frame = 0;
updtt = true;
}
frame++;
}
return updtt;
}
bool RenderD7::BitmapPrinter::UpdateScreen() {
bool updtt = false;
if (isscreen) {
if (renderframe.loadet)
renderframe.Unload();
this->Decode(decc);
updtt = true;
}
return updtt;
}
#define TICKS_PER_MSEC 268111.856
void RenderD7::BitmapPrinter::Benchmark() {
if (setupbenchmark) {
frametime = 0;
renderedframes = 0;
timer = 0;
setupbenchmark = false;
lastTime = svcGetSystemTick();
}
if (benchmark) {
if (timer >= 60) {
std::string renderedf = std::to_string(renderedframes);
std::string avgdtt = std::to_string(mhdtt);
float alldtt = 0;
for (size_t i = 1; i < hdttt.size(); i++) {
alldtt += hdttt[i];
}
float alldtt2 = 0;
for (size_t i = 0; i < hdttt2.size(); i++) {
alldtt2 += hdttt2[i];
}
float alldtt3 = 0;
for (size_t i = 0; i < hdttt3.size(); i++) {
alldtt3 += hdttt3[i];
}
int allfps = 0;
for (size_t f = 1; f < fpscountc.size(); f++) {
allfps += fpscountc[f];
}
std::string avgcpu = std::to_string((alldtt / (float)hdttt.size() - 1));
std::string avgcpu2 =
std::to_string(((alldtt2 / (float)hdttt2.size()) * 1000));
std::string avgcpu3 =
std::to_string(((alldtt3 / (float)hdttt3.size()) * 1000));
std::string avgfps = std::to_string((allfps / (int)fpscountc.size() - 1));
std::string resultt =
"TestMode: " + std::to_string(testfpsd) + "fps" +
"\nRendered Frames: " + renderedf + "\nMax Cpu Time: " + avgdtt +
"\nAvg Cpu Time: " + avgcpu + "\nAvg Fps: " + avgfps +
"\nAvg EncodeTime: " + avgcpu2 + "ms/f\nAvg DecodeTime: " + avgcpu3 +
"ms\n";
this->ClearBlank();
this->DrawRectFilled(0, 0, this->bitmap.bmp_info_header.width,
this->bitmap.bmp_info_header.height, 0, 0, 0, 255);
this->DrawDebugText(0, 0, 0, RenderD7::Color::Hex("#ffffff"), resultt);
std::string outname =
csvpc + "/benchmark_" + RenderD7::GetTimeStr() + ".png";
this->SavePng(outname);
RenderD7::PushMessage(
RenderD7::Message("Benchmark", "Saved to: \n" + outname));
benchmark = false;
}
uint64_t currentTime = svcGetSystemTick();
dtt = ((float)(currentTime / (float)TICKS_PER_MSEC) -
(float)(lastTime / (float)TICKS_PER_MSEC)) /
1000.f;
lastTime = currentTime;
lastTime = currentTime;
frameCounter++;
fpsClock += dtt;
if (fpsClock >= 1.f) {
fps = frameCounter;
frameCounter = 0;
fpsClock = 0.f;
}
uint64_t lastTime2 = svcGetSystemTick();
this->ClearBlank();
this->DrawRectFilled(0, 0, this->bitmap.bmp_info_header.width,
this->bitmap.bmp_info_header.width, 255, 255, 255,
255);
this->DrawRect(5, 5, this->bitmap.bmp_info_header.width - 10,
this->bitmap.bmp_info_header.height - 10, 5, 0, 0, 0, 0);
// this->DrawDebugText(20, 20, 0, RenderD7::Color::Hex("#ffffff"), "Fps: " +
// std::to_string(fps));
this->DrawDebugText(0, 0, 0.5f, RenderD7::Color::Hex("#ff0000"),
"Time: " + std::to_string(timer));
this->DrawDebugText(0, 10, 0.5f, RenderD7::Color::Hex("#ff0000"),
"Fps: " + std::to_string(fps));
this->DrawDebugText(0, 20, 0.5f, RenderD7::Color::Hex("#ff0000"),
"dt: " + std::to_string(dtt));
this->DrawDebugText(0, 30, 0.5f, RenderD7::Color::Hex("#ff0000"),
"MaxEncodeTime: " + std::to_string(mdtt2 * 1000) +
"ms/f");
this->DrawDebugText(0, 40, 0.5f, RenderD7::Color::Hex("#ff0000"),
"MaxDecodeTime: " + std::to_string(mdtt3 * 1000) +
"ms");
uint64_t currentTime2 = svcGetSystemTick();
dtt2 = ((float)(currentTime2 / (float)TICKS_PER_MSEC) -
(float)(lastTime2 / (float)TICKS_PER_MSEC)) /
1000.f;
hdttt2.push_back(dtt2);
lastTime2 = svcGetSystemTick();
bool updgg = this->UpdateScreenF(testfps);
currentTime2 = svcGetSystemTick();
dtt3 = ((float)(currentTime2 / (float)TICKS_PER_MSEC) -
(float)(lastTime2 / (float)TICKS_PER_MSEC)) /
1000.f;
if (updgg)
hdttt3.push_back(dtt3);
if (!shouldbe_disabled)
this->DrawScreen();
renderedframes++;
if (mdtt2 < dtt2) {
mdtt2 = dtt2;
}
if (mdtt3 < dtt3 && updgg) {
mdtt3 = dtt3;
}
timer += 1 * dtt;
float hdtt = C3D_GetProcessingTime();
hdttt.push_back(hdtt);
fpscountc.push_back(fps);
if (mhdtt < hdtt) {
mhdtt = C3D_GetProcessingTime();
}
/*if (!shouldbe_disabled)
{
RenderD7::OnScreen(Bottom);
RenderD7::DrawText(0, 0, 0.5f, RenderD7::Color::Hex("#ff0000"),
"Time: " + std::to_string(timer)); RenderD7::DrawText(0, 20, 0.5f,
RenderD7::Color::Hex("#ff0000"), "Fps: " + std::to_string(fps));
RenderD7::DrawText(0, 40, 0.5f, RenderD7::Color::Hex("#ff0000"),
"dt: " + std::to_string(dtt)); RenderD7::DrawText(0, 60, 0.5f,
RenderD7::Color::Hex("#ff0000"), "MaxRenderTime: " +
std::to_string(mdtt2*1000) + "ms/f"); RenderD7::DrawText(0, 80, 0.5f,
RenderD7::Color::Hex("#ff0000"), "MaxConvertTime: " +
std::to_string(mdtt3*1000) + "ms");
}*/
}
}
void RenderD7::BitmapPrinter::SetupBenchmark(int framerate) {
benchmark = true;
setupbenchmark = true;
this->testfps = framerate;
this->testfpsd = framerate;
}
#include <renderd7/debugfont.h>
void RenderD7::BitmapPrinter::DrawDebugChar(u32 posX, u32 posY, int t_size,
u32 color, char character) {
bool isscale = (t_size > 1) ? true : false;
for (u32 y = 0; y < 8; y++) {
char charPos = debugfont[character * 8 + y];
for (u32 x = 0; x < 8; x++)
if (((charPos >> (7 - x)) & 1) == 1) {
if (!isscale)
DrawPixel((int)posX + x + 1, (int)posY + y + 1, UNPACK_BGRA(color));
if (isscale)
DrawRectFilled(((int)posX) + (x * t_size) + 1,
((int)posY) + (y * t_size) + 1, t_size, t_size,
UNPACK_BGRA(color));
}
}
}
void RenderD7::BitmapPrinter::DrawChar(int posX, int posY, float t_size,
u32 color, char character,
RenderD7::NFontApi font) {
for (int y = 0; y < font.GetGlyphHeight(character); y++) {
for (int x = 0; x < font.GetGlyphWidth(character); x++) {
DrawPixel(posX + x + 1, posY + y + 1, 255, 255, 255,
font.GetGlyphBitmap(
character)[((y * font.GetGlyphWidth(character) + x) * 1)]);
if (((font.GetGlyphBitmap(
character)[font.GetGlyphHeight(character) + y] >>
(font.GetGlyphWidth(character - 1) - x)) &
1) == 1) {
}
}
}
// for(int y = 0; y < font.GetGlyphHeight(character) *
// font.GetGlyphWidth(character); y++)
//{
// DrawPixel(posX + x + 1, posY + y + 1, UNPACK_BGRA(color));
//}
}
#define SPACING_Y 10
#define SPACING_X 8
void RenderD7::BitmapPrinter::DrawDebugText(int x, int y, int t_size, u32 color,
std::string text) {
if (t_size < 1) {
t_size = 1;
}
for (u32 i = 0, line_i = 0; i < strlen(text.c_str()); i++)
switch (text[i]) {
case '\n':
y += (SPACING_Y * t_size);
line_i = 0;
break;
case '\t':
line_i += 2;
break;
default:
// Make sure we never get out of the screen
if (line_i >= (((u32)this->bitmap.bmp_info_header.width) - (u32)x) /
(SPACING_X * t_size)) {
y += (SPACING_Y * t_size);
line_i = 1; // Little offset so we know the same text continues
if (text[i] == ' ')
break; // Spaces at the start look weird
}
this->DrawDebugChar((u32)x + line_i * (SPACING_X * t_size), (u32)y,
t_size, color, text[i]);
line_i++;
break;
}
}
void RenderD7::BitmapPrinter::DrawText(int x, int y, float t_size, u32 color,
std::string text,
RenderD7::NFontApi font) {
if (t_size < 1) {
t_size = 1;
}
for (u32 i = 0, line_i = 0; i < strlen(text.c_str()); i++)
switch (text[i]) {
case '\n':
y += (font.GetLineHeight());
line_i = 0;
break;
case '\t':
line_i += 2;
break;
default:
// Make sure we never get out of the screen
if (line_i >= (((u32)this->bitmap.bmp_info_header.width) - (u32)x) /
(u32)(font.GetGlyphWidth(text[i]))) {
y += (SPACING_Y * t_size);
line_i = 1; // Little offset so we know the same text continues
if (text[i] == ' ')
break; // Spaces at the start look weird
}
this->DrawChar(x + line_i * (font.GetGlyphWidth(text[i])), y, t_size,
color, text[i], font);
line_i++;
break;
}
}
bool RenderD7::BitmapPrinter::Decode(Decoder deccc) {
bool res = false;
switch (deccc) {
case Decoder::BITMAP2PNG2C3D:
renderframe.LoadPFromBuffer(
BitmapConverter::ConvertData(this->bitmap.DATA()));
res = true;
break;
case Decoder::BITMAP2C3D:
renderframe.LoadFromBitmap(this->bitmap);
res = true;
break;
default:
res = false;
break;
}
return res;
}
void RenderD7::BitmapPrinter::DrawBitmap(int x, int y, BMP map) {
for (int i = 0; i < map.bmp_info_header.width; i++) {
for (int j = 0; j < map.bmp_info_header.height; j++) {
bitmap.set_pixel(
x + i, (bitmap.bmp_info_header.height - 1) - (y + j),
UNPACK_BGRA(map.get_pixel(i, (map.bmp_info_header.height - 1) - j)));
}
}
}

138
source/Color.cpp
View File

@ -1,46 +1,94 @@
#include <map> #include <map>
#include <renderd7/Color.hpp> #include <renderd7/Color.hpp>
#define RGBA8(r, g, b, a) \ // This is btw the default theme setup
((((r)&0xFF) << 0) | (((g)&0xFF) << 8) | (((b)&0xFF) << 16) | \ // RenderD7 StyleColor Api
(((a)&0xFF) << 24)) // not const cause const = error lol
std::map<RD7Color, unsigned int> rd7i_color_map = {
// uint32_t RenderD7::Color::Hex(const std::string &color, uint8_t a) { {RD7Color_Text, RGBA8(0, 0, 0, 255)},
// if (color.length() < 7 || {RD7Color_Text2, RGBA8(255, 255, 255, 255)}, // For Background change or so
// std::regex_search(color.substr(1), {RD7Color_TextDisabled, RGBA8(170, 170, 170, 255)},
// std::regex("[^0-9A-Fa-f]"))) { // invalid color. {RD7Color_Background, RGBA8(238, 238, 238, 255)},
// return RenderD7::Color::Hex("#000000", 0); {RD7Color_Header, RGBA8(17, 17, 17, 255)},
// } {RD7Color_Selector, RGBA8(34, 34, 34, 255)},
// int r = std::stoi(color.substr(1, 2), nullptr, 16); {RD7Color_SelectorFade, RGBA8(90, 90, 90, 255)},
// int g = std::stoi(color.substr(3, 2), nullptr, 16); {RD7Color_List0, RGBA8(204, 204, 204, 255)}, // List0 = % 2
// int b = std::stoi(color.substr(5, 2), nullptr, 16); {RD7Color_List1, RGBA8(187, 187, 187, 255)},
// return RGBA8(r, g, b, a); {RD7Color_MessageBackground, RGBA8(51, 51, 51, 255)},
// } {RD7Color_Button, RGBA8(17, 17, 17, 255)},
{RD7Color_ButtonHovered, RGBA8(34, 34, 34, 255)},
// Lookup-Table für Hex-to-Dez-Konvertierung {RD7Color_ButtonDisabled, RGBA8(8, 8, 8, 255)},
static const std::map<char, int> HEX_TO_DEC = { {RD7Color_ButtonActive, RGBA8(42, 42, 42, 255)},
{'0', 0}, {'1', 1}, {'2', 2}, {'3', 3}, {'4', 4}, {'5', 5}, {RD7Color_Checkmark, RGBA8(42, 42, 42, 255)},
{'6', 6}, {'7', 7}, {'8', 8}, {'9', 9}, {'a', 10}, {'b', 11}, {RD7Color_FrameBg, RGBA8(85, 85, 85, 255)},
{'c', 12}, {'d', 13}, {'e', 14}, {'f', 15}, {'A', 10}, {'B', 11}, {RD7Color_FrameBgHovered, RGBA8(119, 119, 119, 255)},
{'C', 12}, {'D', 13}, {'E', 14}, {'F', 15}}; {RD7Color_Progressbar, RGBA8(0, 255, 0, 255)},
};
uint32_t RenderD7::Color::Hex(const std::string &color, uint8_t a) {
if (color.length() < 7 || std::map<RD7Color, unsigned int> rd7i_color_swap_map;
std::find_if(color.begin() + 1, color.end(),
[](char c) { return !std::isxdigit(c); }) != color.end()) { unsigned int RenderD7::StyleColor(RD7Color color) {
return RenderD7::Color::Hex("#000000", 0); if (rd7i_color_swap_map.find(color) != rd7i_color_swap_map.end())
} return rd7i_color_swap_map[color];
else if (rd7i_color_map.find(color) != rd7i_color_map.end())
int r = HEX_TO_DEC.at(color[1]) * 16 + HEX_TO_DEC.at(color[2]); return rd7i_color_map[color];
int g = HEX_TO_DEC.at(color[3]) * 16 + HEX_TO_DEC.at(color[4]); return RGBA8(0, 0, 0, 0);
int b = HEX_TO_DEC.at(color[5]) * 16 + HEX_TO_DEC.at(color[6]); }
return RGBA8(r, g, b, a); void RenderD7::ColorNew(RD7Color color, unsigned int new_color) {
} rd7i_color_map[color] = new_color;
}
std::string RenderD7::Color::RGB2Hex(int r, int g, int b) {
std::stringstream ss; void RenderD7::RedirectColor(RD7Color to, RD7Color from) {
ss << "#"; // As you see at the code Redirect doesnt redirect xd
ss << std::hex << (r << 16 | g << 8 | b); // Just named cause it feels like redirecting
return ss.str(); // Oh and if the color is edit you redirect to it is
// grabs that redirected lol
rd7i_color_swap_map[to] = StyleColor(from);
}
void RenderD7::CustomizeColor(RD7Color color, unsigned int custom) {
rd7i_color_swap_map[color] = custom;
}
void RenderD7::TextColorByBg(RD7Color background) {
UndoColorEdit(RD7Color_Text); // To be sure
rd7i_color_swap_map[RD7Color_Text] = StyleColor(
Color::RGBA(background).is_light() ? RD7Color_Text : RD7Color_Text2);
}
void RenderD7::UndoColorEdit(RD7Color color) {
if (rd7i_color_swap_map.find(color) == rd7i_color_swap_map.end())
return;
rd7i_color_swap_map.erase(color);
}
void RenderD7::UndoAllColorEdits() { rd7i_color_swap_map.clear(); }
// Standart Color Converter
static const std::map<char, int> HEX_TO_DEC = {
{'0', 0}, {'1', 1}, {'2', 2}, {'3', 3}, {'4', 4}, {'5', 5},
{'6', 6}, {'7', 7}, {'8', 8}, {'9', 9}, {'a', 10}, {'b', 11},
{'c', 12}, {'d', 13}, {'e', 14}, {'f', 15}, {'A', 10}, {'B', 11},
{'C', 12}, {'D', 13}, {'E', 14}, {'F', 15}};
uint32_t RenderD7::Color::Hex(const std::string &color, uint8_t a) {
if (color.length() < 7 ||
std::find_if(color.begin() + 1, color.end(),
[](char c) { return !std::isxdigit(c); }) != color.end()) {
return RenderD7::Color::Hex("#000000", 0);
}
int r = HEX_TO_DEC.at(color[1]) * 16 + HEX_TO_DEC.at(color[2]);
int g = HEX_TO_DEC.at(color[3]) * 16 + HEX_TO_DEC.at(color[4]);
int b = HEX_TO_DEC.at(color[5]) * 16 + HEX_TO_DEC.at(color[6]);
return RGBA8(r, g, b, a);
}
std::string RenderD7::Color::RGB2Hex(int r, int g, int b) {
std::stringstream ss;
ss << "#";
ss << std::hex << (r << 16 | g << 8 | b);
return ss.str();
} }

216
source/Draw.cpp
View File

@ -1,216 +0,0 @@
#include <renderd7/Draw.hpp>
extern C2D_TextBuf TextBuf;
extern C2D_Font Font;
extern bool currentScreen;
bool RenderD7::Draw::Rect(float x, float y, float w, float h, u32 color) {
return C2D_DrawRectSolid(x, y, 0.5f, w, h, color);
}
bool RenderD7::Draw::Px(float x, float y, u32 color) {
return C2D_DrawRectSolid(x, y, 0.5f, 1, 1, color);
}
void RenderD7::Draw::TextCentered(float x, float y, float size, u32 color,
std::string Text, int maxWidth, int maxHeight,
C2D_Font fnt) {
float lineHeight, widthScale;
// Check for the lineHeight.
if (fnt != nullptr) {
lineHeight = RenderD7::Draw::GetTextHeight(size, " ", fnt);
} else {
lineHeight = RenderD7::Draw::GetTextHeight(size, " ");
}
int line = 0;
while (Text.find('\n') != Text.npos) {
if (maxWidth == 0) {
// Do the widthScale.
if (fnt != nullptr) {
widthScale = RenderD7::Draw::GetTextWidth(
size, Text.substr(0, Text.find('\n')), fnt);
} else {
widthScale =
RenderD7::Draw::GetTextWidth(size, Text.substr(0, Text.find('\n')));
}
} else {
// Do the widthScale 2.
if (fnt != nullptr) {
widthScale = std::min((float)maxWidth,
RenderD7::Draw::GetTextWidth(
size, Text.substr(0, Text.find('\n')), fnt));
} else {
widthScale = std::min((float)maxWidth,
RenderD7::Draw::GetTextWidth(
size, Text.substr(0, Text.find('\n'))));
}
}
if (fnt != nullptr) {
RenderD7::Draw::Text((currentScreen ? 200 : 160) + x - (widthScale / 2),
y + (lineHeight * line), size, color,
Text.substr(0, Text.find('\n')), maxWidth, maxHeight,
fnt);
} else {
RenderD7::Draw::Text((currentScreen ? 200 : 160) + x - (widthScale / 2),
y + (lineHeight * line), size, color,
Text.substr(0, Text.find('\n')), maxWidth,
maxHeight);
}
Text = Text.substr(Text.find('\n') + 1);
line++;
}
if (maxWidth == 0) {
// Do the next WidthScale.
if (fnt != nullptr) {
widthScale = RenderD7::Draw::GetTextWidth(
size, Text.substr(0, Text.find('\n')), fnt);
} else {
widthScale =
RenderD7::Draw::GetTextWidth(size, Text.substr(0, Text.find('\n')));
}
} else {
// And again.
if (fnt != nullptr) {
widthScale = std::min((float)maxWidth,
RenderD7::Draw::GetTextWidth(
size, Text.substr(0, Text.find('\n')), fnt));
} else {
widthScale = std::min(
(float)maxWidth,
RenderD7::Draw::GetTextWidth(size, Text.substr(0, Text.find('\n'))));
}
}
if (fnt != nullptr) {
RenderD7::Draw::Text((currentScreen ? 200 : 160) + x - (widthScale / 2),
y + (lineHeight * line), size, color,
Text.substr(0, Text.find('\n')), maxWidth, maxHeight,
fnt);
} else {
RenderD7::Draw::Text((currentScreen ? 200 : 160) + x - (widthScale / 2),
y + (lineHeight * line), size, color,
Text.substr(0, Text.find('\n')), maxWidth, maxHeight);
}
}
// Draw String or Text.
void RenderD7::Draw::Text(float x, float y, float size, u32 color,
std::string Text, int maxWidth, int maxHeight,
C2D_Font fnt) {
C2D_Text c2d_text;
if (fnt != nullptr) {
C2D_TextFontParse(&c2d_text, fnt, TextBuf, Text.c_str());
} else {
C2D_TextFontParse(&c2d_text, Font, TextBuf, Text.c_str());
}
C2D_TextOptimize(&c2d_text);
float heightScale;
if (maxHeight == 0) {
heightScale = size;
} else {
if (fnt != nullptr) {
heightScale = std::min(
size,
size * (maxHeight / RenderD7::Draw::GetTextHeight(size, Text, fnt)));
} else {
heightScale = std::min(
size, size * (maxHeight / RenderD7::Draw::GetTextHeight(size, Text)));
}
}
if (maxWidth == 0) {
C2D_DrawText(&c2d_text, C2D_WithColor, x, y, 0.5f, size, heightScale,
color);
} else {
if (fnt != nullptr) {
C2D_DrawText(
&c2d_text, C2D_WithColor, x, y, 0.5f,
std::min(size, size * (maxWidth / RenderD7::Draw::GetTextWidth(
size, Text, fnt))),
heightScale, color);
} else {
C2D_DrawText(
&c2d_text, C2D_WithColor, x, y, 0.5f,
std::min(size, size * (maxWidth /
RenderD7::Draw::GetTextWidth(size, Text))),
heightScale, color);
}
}
}
void RenderD7::Draw::TextRight(float x, float y, float size, u32 color,
std::string Text, int maxWidth, int maxHeight,
C2D_Font fnt) {
RenderD7::Draw::Text(x - RenderD7::Draw::GetTextWidth(size, Text, fnt), y,
size, color, Text, maxWidth, maxHeight, fnt);
}
// Get String or Text Width.
float RenderD7::Draw::GetTextWidth(float size, std::string Text, C2D_Font fnt) {
float width = 0;
if (fnt != nullptr) {
GetTextSize(size, &width, NULL, Text, fnt);
} else {
GetTextSize(size, &width, NULL, Text);
}
return width;
}
// Get String or Text Size.
void RenderD7::Draw::GetTextSize(float size, float *width, float *height,
std::string Text, C2D_Font fnt) {
C2D_Text c2d_text;
if (fnt != nullptr) {
C2D_TextFontParse(&c2d_text, fnt, TextBuf, Text.c_str());
} else {
C2D_TextFontParse(&c2d_text, Font, TextBuf, Text.c_str());
}
C2D_TextGetDimensions(&c2d_text, size, size, width, height);
}
// Get String or Text Height.
float RenderD7::Draw::GetTextHeight(float size, std::string Text,
C2D_Font fnt) {
float height = 0;
if (fnt != nullptr) {
GetTextSize(size, NULL, &height, Text.c_str(), fnt);
} else {
GetTextSize(size, NULL, &height, Text.c_str());
}
return height;
}
Result RenderD7::Draw::LoadFont(C2D_Font &fnt, const char *Path) {
fnt = C2D_FontLoad(Path); // Only load if found.
return 0;
}
// Unload a Font.
Result RenderD7::Draw::UnloadFont(C2D_Font &fnt) {
if (fnt != nullptr) {
C2D_FontFree(fnt); // Make sure to only unload if not nullptr.
}
return 0;
}
bool RenderD7::Draw::Circle(float x, float y, float radius, u32 color) {
return C2D_DrawCircleSolid(x, y, 0.5f, radius, color);
}
bool RenderD7::Draw::Image(C2D_Image img, float x, float y, float scaleX,
float scaleY) {
return C2D_DrawImageAt(img, x, y, 0.5f, nullptr, scaleX, scaleY);
}
bool RenderD7::Draw::NFRect(float p1x, float p1y, float w, float h, u32 color,
float scale) {
C2D_DrawLine(p1x, p1y, color, w, p1y, color, scale, 1);
C2D_DrawLine(w, p1y, color, w, h, color, scale, 1);
C2D_DrawLine(w, h, color, p1x, h, color, scale, 1);
C2D_DrawLine(p1x, h, color, p1x, p1y, color, scale, 1);
return true;
}

237
source/DrawV2.cpp Normal file
View File

@ -0,0 +1,237 @@
#include <citro2d.h>
#include <algorithm>
#include <renderd7/DrawV2.hpp>
#include <renderd7/global_db.hpp>
#include <renderd7/internal_db.hpp>
const float rd7i_d7_dts = 0.5f;
float rd7i_d2_txt_size = rd7i_d7_dts;
C2D_Font rd7i_d2_fnt = nullptr;
R7Vec2 rd7i_d7_mwh = R7Vec2(0, 0);
std::map<std::string, float> rd7i_d2_ts;
std::map<std::string, int> rd7i_d2_mln;
bool rd7i_txt_init = false;
std::string GetShortedText(const std::string &in, int maxlen) {
auto textdim = RenderD7::GetTextDimensions(in);
if (textdim.x < (float)maxlen) return in;
std::string ft = "";
std::string worker = in;
if (in.find_last_of('.') != in.npos) {
ft = in.substr(in.find_last_of('.'));
worker = in.substr(0, in.find_last_of('.'));
}
maxlen -= RenderD7::GetTextDimensions(ft).x -
RenderD7::GetTextDimensions("(...)").x;
float len_mod = (float)maxlen / textdim.x;
int pos = (in.length() * len_mod) / rd7_draw2_tsm;
std::string out;
out = in.substr(0, pos);
for (size_t i = pos; i < worker.length(); i++) {
out += worker[i];
if (RenderD7::GetTextDimensions(out + "(...)" + ft).x > (float)maxlen) {
out += "(...)";
out += ft;
return out;
}
}
return ""; // Impossible to reach
}
std::string WrapText(const std ::string &in, int maxlen) {
std::string out;
std::string line;
int line_x = 0;
std::istringstream istream(in);
std::string temp;
while (istream >> temp) {
R7Vec2 dim = RenderD7::GetTextDimensions(line + temp);
if (line_x + dim.x <= maxlen) {
line += temp + ' ';
line_x += dim.x;
} else {
out += line + '\n';
line = temp + ' ';
line_x = dim.x;
}
}
out += line;
return out;
}
bool RD7I_FNT_VALID() {
if (rd7i_d2_fnt != nullptr && !rd7i_txt_init) {
rd7i_txt_init = true;
}
if (!rd7i_txt_init) {
if (rd7i_base_font != nullptr) {
rd7i_d2_fnt = rd7i_base_font;
rd7i_txt_init = true;
return true;
}
}
if (rd7i_d2_fnt != nullptr) {
return true;
} else {
rd7i_d2_fnt = rd7i_base_font;
return true;
}
// Schould never be reached
return false;
}
namespace RenderD7 {
R7Vec2 GetTextDimensions(const std::string &text) {
C2D_TextBufClear(rd7i_d2_dimbuf);
float w = 0, h = 0;
if (!RD7I_FNT_VALID()) return R7Vec2(w, h);
C2D_Text c2dtext;
C2D_TextFontParse(&c2dtext, rd7i_d2_fnt, rd7i_d2_dimbuf, text.c_str());
C2D_TextGetDimensions(&c2dtext, rd7i_d2_txt_size, rd7i_d2_txt_size, &w, &h);
return R7Vec2(w, h);
}
void CustomTextSize(float size) { rd7i_d2_txt_size = size; }
void TextDefaultSize() { rd7i_d2_txt_size = rd7i_d7_dts; }
void TextMaxBox(R7Vec2 size) { rd7i_d7_mwh = size; }
void TextDefaultBox() { rd7i_d7_mwh = R7Vec2(0, 0); }
void TextFont(C2D_Font fnt) { rd7i_d2_fnt = fnt; }
void TextDefaultFont() { rd7i_d2_fnt = rd7i_base_font; }
std::string TextShort(const std::string &in, int max_len) {
return GetShortedText(in, max_len);
}
namespace Draw2 {
void Rect(R7Vec2 pos, R7Vec2 size, unsigned int color, int t) {
// 4 DrawLine Calls Lol
C2D_DrawLine(pos.x, pos.y, color, pos.x + size.x, pos.y, color, t, 1.f);
C2D_DrawLine(pos.x, pos.y, color, pos.x, pos.y + size.y, color, t, 1.f);
C2D_DrawLine(pos.x + size.x, pos.y, color, pos.x + size.x, pos.y + size.y,
color, t, 1.f);
C2D_DrawLine(pos.x, pos.y + size.y, color, pos.x + size.x, pos.y + size.y,
color, t, 1.f);
}
void RectFilled(R7Vec2 pos, R7Vec2 size, Color4 colors) {
C2D_DrawRectangle(pos.x, pos.y, 0.5f, size.x, size.y, colors.color0,
colors.color1, colors.color2, colors.color3);
}
void RectFilledSolid(R7Vec2 pos, R7Vec2 size, unsigned int color) {
C2D_DrawRectSolid(pos.x, pos.y, 0.5f, size.x, size.y, color);
}
void Line(R7Vec2 pos0, R7Vec2 pos1, unsigned int color, int t) {
C2D_DrawLine(pos0.x, pos0.y, color, pos1.x, pos1.y, color, t, 1.f);
}
void Triangle(R7Vec2 pos0, R7Vec2 pos1, R7Vec2 pos2, Color3 colors) {
C2D_DrawTriangle(pos0.x, pos0.y, colors.color0, pos1.x, pos1.y, colors.color1,
pos2.x, pos2.y, colors.color2, 0.5f);
}
void TriangleSolid(R7Vec2 pos0, R7Vec2 pos1, R7Vec2 pos2, unsigned int color) {
C2D_DrawTriangle(pos0.x, pos0.y, color, pos1.x, pos1.y, color, pos2.x, pos2.y,
color, 0.5f);
}
void TriangleLined(R7Vec2 pos0, R7Vec2 pos1, R7Vec2 pos2, unsigned int color,
int t) {
// 3 Line Cqalls lol more efficient than Rect
C2D_DrawLine(pos0.x, pos0.y, color, pos1.x, pos1.y, color, t, 1.f);
C2D_DrawLine(pos0.x, pos0.y, color, pos2.x, pos2.y, color, t, 1.f);
C2D_DrawLine(pos1.x, pos1.y, color, pos2.x, pos2.y, color, t, 1.f);
}
void Text(R7Vec2 pos, const std::string &text, RD7TextFlags flags) {
// The Start of the C2D Text Hell
if (!RD7I_FNT_VALID()) return;
// Variables
bool updated_mwh = false;
if (rd7i_d7_mwh.x == 0.0f) {
rd7i_d7_mwh.x = rd7i_current_screen ? 400 : 320;
updated_mwh = true;
}
if (rd7i_d7_mwh.y == 0.0f) {
rd7i_d7_mwh.y = 240;
updated_mwh = true;
}
std::string edit_text = text;
if (edit_text.substr(text.length() - 1) != "\n")
edit_text.append("\n"); // Add \n to end if not exist
int line = 0;
if(flags & RD7TextFlags_Wrap)
edit_text = WrapText(text, rd7i_d7_mwh.x - pos.x);
while (edit_text.find('\n') != edit_text.npos) {
std::string current_line = edit_text.substr(0, edit_text.find('\n'));
if (flags & RD7TextFlags_Short)
current_line = GetShortedText(current_line, rd7i_d7_mwh.x - pos.x);
R7Vec2 newpos = pos;
// Check Flags
R7Vec2 dim = GetTextDimensions(current_line);
if (flags & RD7TextFlags_AlignRight)
newpos.x = newpos.x - GetTextDimensions(current_line).x;
if (flags & RD7TextFlags_AlignMid) // Offset by inpos
newpos.x = (rd7i_d7_mwh.x * 0.5) - (dim.x * 0.5) + pos.x;
if (flags & RD7TextFlags_Scroll) { // Scroll Text
if (newpos.x + dim.x > rd7i_d7_mwh.x - newpos.x - 10) {
if (rd7i_d2_ts.find(current_line) == rd7i_d2_ts.end())
rd7i_d2_ts[current_line] = 0;
if (rd7i_d2_mln.find(current_line) == rd7i_d2_mln.end())
rd7i_d2_mln[current_line] =
GetShortedText(current_line, rd7i_d7_mwh.x - newpos.x).length();
rd7i_d2_ts[current_line] += rd7i_dtm * 6;
if ((int)rd7i_d2_ts[current_line] >= (int)current_line.length()) {
rd7i_d2_ts[current_line] = 0.0f;
}
std::string bcl = current_line;
current_line = current_line.substr((int)rd7i_d2_ts[current_line],
rd7i_d2_mln[current_line]);
if (newpos.x + GetTextDimensions(current_line).x <
rd7i_d7_mwh.x - newpos.x)
current_line +=
"|" + bcl.substr(0, rd7i_d2_ts[bcl] - (int)current_line.length());
}
}
if (rd7_debugging) {
RenderD7::Draw2::Rect(newpos, dim, RenderD7::Color::Hex("#ff0000"));
}
C2D_Text c2dtext;
C2D_TextFontParse(&c2dtext, rd7i_d2_fnt, rd7i_text_buffer,
current_line.c_str());
C2D_TextOptimize(&c2dtext);
if (flags & RD7TextFlags_Shaddow) // performance Killer xd
C2D_DrawText(&c2dtext, C2D_WithColor, newpos.x + 1 + (dim.y * line),
newpos.y + 1, 0.5, rd7i_d2_txt_size, rd7i_d2_txt_size,
RenderD7::StyleColor(RD7Color_TextDisabled));
C2D_DrawText(&c2dtext, C2D_WithColor, newpos.x, newpos.y + (dim.y * line),
0.5, rd7i_d2_txt_size, rd7i_d2_txt_size,
RenderD7::StyleColor(RD7Color_Text));
edit_text = edit_text.substr(edit_text.find('\n') + 1);
line++;
}
if (updated_mwh) rd7i_d7_mwh = R7Vec2(0, 0);
}
void Image(RenderD7::Image *img, const R7Vec2 &pos, const R7Vec2 &scale) {
if (img->loaded())
C2D_DrawImageAt(img->get(), pos.x, pos.y, 0.5f, nullptr, scale.x, scale.y);
}
} // namespace Draw2
} // namespace RenderD7

44
source/Error.cpp Normal file
View File

@ -0,0 +1,44 @@
#include <renderd7/Error.hpp>
#include <3ds.h>
#include <renderd7/renderd7.hpp>
#include <renderd7/internal_db.hpp>
#include <renderd7/UI7.hpp>
namespace RenderD7 {
void Error(const std::string& msg) {
if(rd7i_graphics_on) {
C3D_FrameEnd(0);
while(aptMainLoop()) {
hidScanInput();
if(hidKeysDown() & KEY_START) break;
C3D_FrameBegin(C3D_FRAME_SYNCDRAW);
RenderD7::ClearTextBufs();
C2D_TargetClear(Top, 0x00000000);
C2D_TargetClear(Bottom, 0x00000000);
RenderD7::OnScreen(Top);
if(UI7::BeginMenu("RenderD7 - Error Manager", R7Vec2(), UI7MenuFlags_TitleMid)) {
UI7::Label(msg, RD7TextFlags_Wrap);
UI7::Label("Press Start to Exit!");
UI7::EndMenu();
}
RenderD7::OnScreen(Bottom);
C3D_FrameEnd(0);
}
exit(0);
} else {
gfxInitDefault();
consoleInit(GFX_TOP, NULL);
printf("RENDERD7 - ERROR MANAGER\n\n%s\n", msg.c_str());
printf("Press Start to Exit\n");
while(aptMainLoop()) {
hidScanInput();
if(hidKeysDown() & KEY_START)
break;
gfxSwapBuffers();
}
gfxExit();
exit(0);
}
}
}

87
source/FileSystem.cpp
View File

@ -1,19 +1,70 @@
#include <3ds.h> #include <3ds.h>
#include <cstring> #include <cstring>
#include <renderd7/FileSystem.hpp> #include <stdarg.h>
// Debugging #include <unistd.h>
#include <memory> #include <stdio.h>
#include <renderd7/stringtool.hpp> #include <renderd7/FileSystem.hpp>
// Debugging
#include <filesystem> #include <memory>
#include <renderd7/stringtool.hpp>
std::vector<RenderD7::FileSystem::Entry> #include <algorithm>
RenderD7::FileSystem::GetDirContent(std::string path) { #include <filesystem>
std::vector<RenderD7::FileSystem::Entry> res;
for (const auto &entry : bool ___dir__predicate__(const RenderD7::FileSystem::Entry &lhs,
std::filesystem::directory_iterator(std::filesystem::path(path))) { const RenderD7::FileSystem::Entry &rhs) {
res.push_back({entry.path().string(), GetFileName(entry.path().string()), if (!lhs.dir && rhs.dir)
entry.is_directory()}); return false;
} if (lhs.dir && !rhs.dir)
return res; return true;
return strcasecmp(lhs.name.c_str(), rhs.name.c_str()) < 0;
}
std::string RenderD7::FileSystem::GetParentPath(std::string path,
std::string mount_point) {
std::string tcl = path;
if (path.substr(path.length() - 1, 1) != "/") {
tcl += "/";
}
std::string res;
if (std::filesystem::exists(
std::filesystem::path(tcl).parent_path().parent_path()))
res = std::filesystem::path(tcl).parent_path().parent_path().string();
if (res.length() > mount_point.length()) {
return res;
}
return mount_point;
}
std::vector<RenderD7::FileSystem::Entry>
RenderD7::FileSystem::GetDirContent(std::string path) {
std::vector<RenderD7::FileSystem::Entry> res;
for (const auto &entry :
std::filesystem::directory_iterator(std::filesystem::path(path))) {
res.push_back({entry.path().string(), GetFileName(entry.path().string()),
entry.is_directory()});
}
return res;
}
std::vector<RenderD7::FileSystem::Entry>
RenderD7::FileSystem::GetDirContentsExt(
std::string &path, const std::vector<std::string> &extensions) {
std::vector<RenderD7::FileSystem::Entry> res;
for (auto const &it :
std::filesystem::directory_iterator(std::filesystem::path(path))) {
RenderD7::FileSystem::Entry temp;
std::string fn = it.path().string();
temp.name = GetFileName(fn);
temp.path = it.path().string().c_str();
temp.dir = it.is_directory();
if (NameIsEndingWith(GetFileName(it.path().string()),
extensions) ||
it.is_directory()) {
res.push_back(temp);
}
}
std::sort(res.begin(), res.end(), ___dir__predicate__);
return res;
} }

4
source/FunctionTrace.cpp
View File

@ -1,3 +1,3 @@
#include <renderd7/FunctionTrace.hpp> #include <renderd7/FunctionTrace.hpp>
std::map<std::string, RenderD7::Ftrace::FTRes> RenderD7::Ftrace::rd7_traces; std::map<std::string, RenderD7::Ftrace::FTRes> RenderD7::Ftrace::rd7_traces;

90
source/Hardware.cpp
View File

@ -1,46 +1,46 @@
#include <renderd7/Hardware.hpp> #include <renderd7/Hardware.hpp>
#include <renderd7/Security.hpp> #include <renderd7/Security.hpp>
// Os Specific includes // Os Specific includes
#include <3ds.h> #include <3ds.h>
// RenderD7 Security // RenderD7 Security
extern bool isndspinit; extern bool isndspinit;
void RenderD7::Hardware::Initialisize() { void RenderD7::Hardware::Initialisize() {
rd7_security->SafeInit(mcuHwcInit, &mcuHwcExit); rd7_security->SafeInit(mcuHwcInit, &mcuHwcExit);
rd7_security->SafeInit(ptmuInit, &ptmuExit); rd7_security->SafeInit(ptmuInit, &ptmuExit);
} }
bool RenderD7::Hardware::IsHeadphones() { bool RenderD7::Hardware::IsHeadphones() {
if (isndspinit) { if (isndspinit) {
bool inserted; bool inserted;
DSP_GetHeadphoneStatus(&inserted); DSP_GetHeadphoneStatus(&inserted);
return inserted; return inserted;
} else } else
return false; return false;
} }
bool RenderD7::Hardware::IsCharging() { bool RenderD7::Hardware::IsCharging() {
uint8_t var; uint8_t var;
PTMU_GetBatteryChargeState(&var); PTMU_GetBatteryChargeState(&var);
// Some Security Stuff // Some Security Stuff
if (var < 0x00 && var > 0x01) { if (var < 0x00 && var > 0x01) {
return false; return false;
} }
return (var == 0x01 ? true : false); return (var == 0x01 ? true : false);
} }
float RenderD7::Hardware::GetBatteryPercentage() { float RenderD7::Hardware::GetBatteryPercentage() {
uint8_t percentLevel; uint8_t percentLevel;
PTMU_GetBatteryLevel(&percentLevel); PTMU_GetBatteryLevel(&percentLevel);
return (float)percentLevel / 100; return (float)percentLevel / 100;
} }
float RenderD7::Hardware::Get3dSliderLevel() { return osGet3DSliderState(); } float RenderD7::Hardware::Get3dSliderLevel() { return osGet3DSliderState(); }
float RenderD7::Hardware::GetSoundSliderLevel() { float RenderD7::Hardware::GetSoundSliderLevel() {
uint8_t percentLevel; uint8_t percentLevel;
MCUHWC_GetSoundSliderLevel(&percentLevel); MCUHWC_GetSoundSliderLevel(&percentLevel);
return (float)percentLevel / 100; return (float)percentLevel / 100;
} }

111
source/Hid.cpp Normal file
View File

@ -0,0 +1,111 @@
#include <map>
#include <renderd7/Hid.hpp>
namespace RenderD7 {
class HidApi {
public:
HidApi() {}
~HidApi() {}
void setKdown(uint32_t &in) { actions[Hid::Down] = &in; }
void setKheld(uint32_t &in) { actions[Hid::Held] = &in; }
void setKup(uint32_t &in) { actions[Hid::Up] = &in; }
void setKrepeat(uint32_t &in) { actions[Hid::DownRepeat] = &in; }
void setTouchCoords(R7Vec2 &touch_coords) { touch_pos = &touch_coords; }
void setJS1Movement(R7Vec2 &mvmt) { js1_mv = &mvmt; }
void setJS2Movement(R7Vec2 &mvmt) { js2_mv = &mvmt; }
void bindKey(const std::string &event, uint32_t key) {
key_bindings[event] = key; // Overrides if existing
}
void lock(bool lock) { locked = lock; }
void clear() {
// Clears Functionality for 1 Frame
last_touch_pos = R7Vec2();
touch_pos[0] = R7Vec2();
backups[Hid::Down] = 0;
backups[Hid::Held] = 0;
backups[Hid::Up] = 0;
backups[Hid::DownRepeat] = 0;
}
bool isEvent(const std::string &event, Hid::Actions action) {
if (locked)
return false;
if (key_bindings.find(event) == key_bindings.end())
return false; // Unknown Event
if (backups.find(action) == backups.end())
return false; // What? NOT Alowed acrion
if (backups[action] & key_bindings[event])
return true; // Action contains key as flag
return false; // Nothing to do
}
R7Vec2 getTouchPos() { return touch_pos[0]; }
R7Vec2 getLastTouchPos() { return last_touch_pos; }
void update() {
last_touch_pos = touch_pos[0];
for (const auto &it : actions) {
backups[it.first] = it.second[0];
}
if(locked) {
actions[Hid::Down][0] = 0;
actions[Hid::Held][0] = 0;
actions[Hid::Up][0] = 0;
actions[Hid::DownRepeat][0] = 0;
}
}
private:
std::map<Hid::Actions, uint32_t *> actions;
std::map<Hid::Actions, uint32_t> backups;
R7Vec2 *touch_pos = nullptr;
R7Vec2 *js1_mv = nullptr;
R7Vec2 *js2_mv = nullptr;
R7Vec2 last_touch_pos;
std::map<std::string, uint32_t> key_bindings;
bool locked = false;
};
static HidApi hid_handler;
namespace Hid {
// Register Functions
// Register Current state values
void RegKeyDown(uint32_t &key_down) { hid_handler.setKdown(key_down); }
void RegKeyHeld(uint32_t &key_held) { hid_handler.setKheld(key_held); }
void RegKeyUp(uint32_t &key_up) { hid_handler.setKup(key_up); }
void RegKeyRepeat(uint32_t &repeat) { hid_handler.setKrepeat(repeat); }
void RegTouchCoords(R7Vec2 &touch_pos) {
hid_handler.setTouchCoords(touch_pos);
}
void RegAnalog1Movement(R7Vec2 &movement) {
hid_handler.setJS1Movement(movement);
}
void RegAnalog2Movement(R7Vec2 &movement) {
hid_handler.setJS2Movement(movement);
}
// Register Keys
void RegKeyEvent(const std::string &event, uint32_t key) {
hid_handler.bindKey(event, key);
}
bool IsEvent(const std::string &event, Actions action) {
return hid_handler.isEvent(event, action);
}
R7Vec2 GetTouchPosition() { return hid_handler.getTouchPos(); }
R7Vec2 GetLastTouchPosition() { return hid_handler.getLastTouchPos(); }
void Update() { hid_handler.update(); }
void Lock() { hid_handler.lock(true); }
void Unlock() { hid_handler.lock(false); }
void Clear() { hid_handler.clear(); }
} // namespace Hid
} // namespace RenderD7

506
source/Image.cpp
View File

@ -1,338 +1,168 @@
#include <renderd7/Image.hpp> #include <renderd7/external/stb_image.h>
#include <renderd7/ToastsV2.hpp>
#include <renderd7/external/stb_image.h> #include <renderd7/Image.hpp>
extern bool usedbgmsg; #include <vector>
void convert24to32(unsigned char *inputImage, int width, int height, static u32 __rd7i_gp2o__(u32 v) {
unsigned char *outputImage) { v--;
for (int y = 0; y < height; y++) { v |= v >> 1;
for (int x = 0; x < width; x++) { v |= v >> 2;
int i = (y * width + x) * 3; // index of current pixel in input image v |= v >> 4;
int j = (y * width + x) * 4; // index of current pixel in output image v |= v >> 8;
outputImage[j] = inputImage[i]; // copy red channel v |= v >> 16;
outputImage[j + 1] = inputImage[i + 1]; // copy green channel v++;
outputImage[j + 2] = inputImage[i + 2]; // copy blue channel return (v >= 64 ? v : 64);
outputImage[j + 3] = 255; // set alpha channel to 255 (fully opaque) }
}
} static void __rd7i_r24r32(std::vector<uint8_t> &out,
} const std::vector<uint8_t> &in, const int &w,
const int &h) {
static u32 GetNextPowerOf2(u32 v) { // Converts RGB24 to RGBA32
v--; for (int y = 0; y < h; y++) {
v |= v >> 1; for (int x = 0; x < w; x++) {
v |= v >> 2; int src = (y * w + x) * 3;
v |= v >> 4; int dst = (y * w + x) * 4;
v |= v >> 8; out[dst + 0] = in[src + 0];
v |= v >> 16; out[dst + 1] = in[src + 1];
v++; out[dst + 2] = in[src + 2];
return (v >= 64 ? v : 64); out[dst + 3] = 255;
} }
}
static bool C3DTexToC2DImage(C2D_Image *texture, u32 width, u32 height, }
u8 *buf) {
if (width >= 1024 || height >= 1024) static void __rd7i_c3dc2d__(C3D_Tex *tex, Tex3DS_SubTexture *subtex, u8 *buf,
return false; u32 size, u32 width, u32 height) {
// RGBA -> ABGR
C3D_Tex *tex = new C3D_Tex[sizeof(C3D_Tex)]; for (u32 row = 0; row < width; row++) {
Tex3DS_SubTexture *subtex = new Tex3DS_SubTexture[sizeof(Tex3DS_SubTexture)]; for (u32 col = 0; col < height; col++) {
subtex->width = static_cast<u16>(width); u32 z = (row + col * width) * 4;
subtex->height = static_cast<u16>(height);
// RGBA -> ABGR u8 r = *(u8 *)(buf + z);
for (u32 row = 0; row < subtex->width; row++) { u8 g = *(u8 *)(buf + z + 1);
for (u32 col = 0; col < subtex->height; col++) { u8 b = *(u8 *)(buf + z + 2);
u32 z = (row + col * subtex->width) * 4; u8 a = *(u8 *)(buf + z + 3);
u8 r = *(u8 *)(buf + z); *(buf + z) = a;
u8 g = *(u8 *)(buf + z + 1); *(buf + z + 1) = b;
u8 b = *(u8 *)(buf + z + 2); *(buf + z + 2) = g;
u8 a = *(u8 *)(buf + z + 3); *(buf + z + 3) = r;
}
*(buf + z) = a; }
*(buf + z + 1) = b;
*(buf + z + 2) = g; u32 w_pow2 = __rd7i_gp2o__(width);
*(buf + z + 3) = r; u32 h_pow2 = __rd7i_gp2o__(height);
}
} subtex->width = (u16)width;
subtex->height = (u16)height;
u32 w_pow2 = GetNextPowerOf2(subtex->width); subtex->left = 0.0f;
u32 h_pow2 = GetNextPowerOf2(subtex->height); subtex->top = 1.0f;
subtex->left = 0.f; subtex->right = (width / (float)w_pow2);
subtex->top = 1.f; subtex->bottom = 1.0 - (height / (float)h_pow2);
subtex->right = (subtex->width / static_cast<float>(w_pow2));
subtex->bottom = (1.0 - (subtex->height / static_cast<float>(h_pow2))); C3D_TexInit(tex, (u16)w_pow2, (u16)h_pow2, GPU_RGBA8);
C3D_TexInit(tex, static_cast<u16>(w_pow2), static_cast<u16>(h_pow2), C3D_TexSetFilter(tex, GPU_NEAREST, GPU_NEAREST);
GPU_RGBA8);
C3D_TexSetFilter(tex, GPU_NEAREST, GPU_NEAREST); u32 pixel_size = (size / width / height);
std::memset(tex->data, 0, tex->size); memset(tex->data, 0, tex->size);
for (u32 x = 0; x < subtex->width; x++) { for (u32 x = 0; x < width; x++) {
for (u32 y = 0; y < subtex->height; y++) { for (u32 y = 0; y < height; y++) {
u32 dst_pos = ((((y >> 3) * (w_pow2 >> 3) + (x >> 3)) << 6) + u32 dst_pos = ((((y >> 3) * (w_pow2 >> 3) + (x >> 3)) << 6) +
((x & 1) | ((y & 1) << 1) | ((x & 2) << 1) | ((x & 1) | ((y & 1) << 1) | ((x & 2) << 1) |
((y & 2) << 2) | ((x & 4) << 2) | ((y & 4) << 3))) * ((y & 2) << 2) | ((x & 4) << 2) | ((y & 4) << 3))) *
4; pixel_size;
u32 src_pos = (y * subtex->width + x) * 4; u32 src_pos = (y * width + x) * pixel_size;
std::memcpy(&(static_cast<u8 *>(tex->data))[dst_pos],
&(static_cast<u8 *>(buf))[src_pos], 4); memcpy(&((u8 *)tex->data)[dst_pos], &((u8 *)buf)[src_pos], pixel_size);
} }
} }
C3D_TexFlush(tex); C3D_TexFlush(tex);
tex->border = RenderD7::Color::Hex("#000000", 0);
C3D_TexSetWrap(tex, GPU_CLAMP_TO_BORDER, GPU_CLAMP_TO_BORDER); tex->border = 0x00000000;
if (tex && subtex) { C3D_TexSetWrap(tex, GPU_CLAMP_TO_BORDER, GPU_CLAMP_TO_BORDER);
texture->tex = tex; // linearFree(buf);
texture->subtex = subtex; }
return true;
} namespace RenderD7 {
return false; Image::Image() {
} img.tex = nullptr;
img.subtex = nullptr;
static void OLD_C3DTexToC2DImage(C3D_Tex *tex, Tex3DS_SubTexture *subtex, }
u8 *buf, u32 size, u32 width, u32 height,
GPU_TEXCOLOR format) { Image::~Image() { safe_del(); }
// RGBA -> ABGR
for (u32 row = 0; row < width; row++) { void Image::load(const std::string &path) {
for (u32 col = 0; col < height; col++) { // Make sure to cleanup
u32 z = (row + col * width) * 4; safe_del();
ld = false;
u8 r = *(u8 *)(buf + z); // Setup Func and Load Data
u8 g = *(u8 *)(buf + z + 1); int w, h, c = 0;
u8 b = *(u8 *)(buf + z + 2); uint8_t *image = stbi_load(path.c_str(), &w, &h, &c, 4);
u8 a = *(u8 *)(buf + z + 3); if (image == nullptr) {
return;
*(buf + z) = a; }
*(buf + z + 1) = b; // Size/Fmt Check
*(buf + z + 2) = g; if (w > 1024 || h > 1024) {
*(buf + z + 3) = r; // Reason: Image to Large
} stbi_image_free(image);
} return;
}
u32 w_pow2 = GetNextPowerOf2(width);
u32 h_pow2 = GetNextPowerOf2(height); std::vector<uint8_t> wimg(w * h * 4);
if (c == 3) {
subtex->width = (u16)width; stbi_image_free(image);
subtex->height = (u16)height; image = stbi_load(path.c_str(), &w, &h, &c, 3);
subtex->left = 0.0f; __rd7i_r24r32(wimg, std::vector<uint8_t>(image, image + (w * h * 3)), w, h);
subtex->top = 1.0f; } else {
subtex->right = (width / (float)w_pow2); // Maybe find a better solution later
subtex->bottom = 1.0 - (height / (float)h_pow2); for (size_t i = 0; i < wimg.size(); i++) {
wimg[i] = image[i];
C3D_TexInit(tex, (u16)w_pow2, (u16)h_pow2, format); }
C3D_TexSetFilter(tex, GPU_NEAREST, GPU_NEAREST); }
stbi_image_free(image);
u32 pixel_size = (size / width / height); // Create C2D_Image
C3D_Tex *tex = new C3D_Tex;
memset(tex->data, 0, tex->size); Tex3DS_SubTexture *subtex = new Tex3DS_SubTexture;
__rd7i_c3dc2d__(tex, subtex, wimg.data(), (u32)(w * h * 4), (u32)w, (u32)h);
for (u32 x = 0; x < width; x++) { img.tex = tex;
for (u32 y = 0; y < height; y++) { img.subtex = subtex;
u32 dst_pos = ((((y >> 3) * (w_pow2 >> 3) + (x >> 3)) << 6) + ld = true;
((x & 1) | ((y & 1) << 1) | ((x & 2) << 1) | }
((y & 2) << 2) | ((x & 4) << 2) | ((y & 4) << 3))) *
pixel_size; void Image::from_nimg(const nimg &image) {
u32 src_pos = (y * width + x) * pixel_size; // Make sure to cleanup
safe_del();
memcpy(&((u8 *)tex->data)[dst_pos], &((u8 *)buf)[src_pos], pixel_size); ld = false;
} if (image.width > 1024 || image.height > 1024) return;
} C3D_Tex *tex = new C3D_Tex;
Tex3DS_SubTexture *subtex = new Tex3DS_SubTexture;
C3D_TexFlush(tex); __rd7i_c3dc2d__(tex, subtex, (u8 *)image.pixel_buffer.data(),
(u32)image.pixel_buffer.size(), (u32)image.width,
tex->border = 0x00000000; (u32)image.height);
C3D_TexSetWrap(tex, GPU_CLAMP_TO_BORDER, GPU_CLAMP_TO_BORDER); img.tex = tex;
linearFree(buf); img.subtex = subtex;
} ld = true;
}
bool IMG_LoadImageFile(C2D_Image *texture, const char *path) {
stbi_uc *image = NULL; C2D_Image Image::get() { return img; }
int width = 0, height = 0; C2D_Image &Image::get_ref() { return img; }
int nc;
void Image::set(const C2D_Image &i) {
image = stbi_load(path, &width, &height, &nc, 4); safe_del();
img = i;
if (width > 1024 || height > 1024) { }
stbi_image_free(image);
return false; R7Vec2 Image::get_size() {
} if (!img.subtex) return R7Vec2(0, 0);
return R7Vec2(img.subtex->width, img.subtex->height);
C3D_Tex *tex = new C3D_Tex; }
Tex3DS_SubTexture *subtex = new Tex3DS_SubTexture;
OLD_C3DTexToC2DImage(tex, subtex, image, (u32)(width * height * 4), void Image::safe_del() {
(u32)width, (u32)height, GPU_RGBA8); if (img.subtex != nullptr) delete img.subtex;
texture->tex = tex; if (img.tex != nullptr) delete img.tex;
texture->subtex = subtex; }
stbi_image_free(image);
return true; bool Image::loaded() { return ld; }
} } // namespace RenderD7
void RenderD7::Image::LoadPng(const std::string path) {
if (usedbgmsg) {
// RenderD7::Msg::Display("RenderD7", "Loading Png:" + path, Top);
}
std::vector<u8> ImageBuffer;
unsigned width, height;
if (loadet) {
C3D_TexDelete(this->img.tex);
loadet = false;
}
lodepng::decode(ImageBuffer, width, height, path);
this->img.tex = new C3D_Tex;
this->img.subtex =
new Tex3DS_SubTexture({(u16)width, (u16)height, 0.0f, 1.0f,
width / 1024.0f, 1.0f - (height / 1024.0f)});
C3D_TexInit(this->img.tex, 1024, 1024, GPU_RGBA8);
C3D_TexSetFilter(this->img.tex, GPU_LINEAR, GPU_LINEAR);
this->img.tex->border = 0xFFFFFFFF;
C3D_TexSetWrap(this->img.tex, GPU_CLAMP_TO_BORDER, GPU_CLAMP_TO_BORDER);
for (u32 x = 0; x < width && x < 1024; x++) {
for (u32 y = 0; y < height && y < 1024; y++) {
const u32 dstPos = ((((y >> 3) * (1024 >> 3) + (x >> 3)) << 6) +
((x & 1) | ((y & 1) << 1) | ((x & 2) << 1) |
((y & 2) << 2) | ((x & 4) << 2) | ((y & 4) << 3))) *
4;
const u32 srcPos = (y * width + x) * 4;
((uint8_t *)this->img.tex->data)[dstPos + 0] =
ImageBuffer.data()[srcPos + 3];
((uint8_t *)this->img.tex->data)[dstPos + 1] =
ImageBuffer.data()[srcPos + 2];
((uint8_t *)this->img.tex->data)[dstPos + 2] =
ImageBuffer.data()[srcPos + 1];
((uint8_t *)this->img.tex->data)[dstPos + 3] =
ImageBuffer.data()[srcPos + 0];
}
}
loadet = true;
}
RenderD7::Image::~Image() {
if (loadet)
C3D_TexDelete(img.tex);
loadet = false;
}
void RenderD7::Image::Unload() {
if (loadet)
C3D_TexDelete(img.tex);
loadet = false;
}
void RenderD7::Image::LoadPFromBuffer(const std::vector<u8> &buffer) {
std::vector<u8> ImageBuffer;
if (loadet) {
C3D_TexDelete(this->img.tex);
loadet = false;
}
unsigned width, height;
lodepng::decode(ImageBuffer, width, height, buffer);
img.tex = new C3D_Tex;
img.subtex =
new Tex3DS_SubTexture({(u16)width, (u16)height, 0.0f, 1.0f,
width / 512.0f, 1.0f - (height / 512.0f)});
C3D_TexInit(img.tex, 512, 512, GPU_RGBA8);
C3D_TexSetFilter(img.tex, GPU_LINEAR, GPU_LINEAR);
img.tex->border = 0xFFFFFFFF;
C3D_TexSetWrap(img.tex, GPU_CLAMP_TO_BORDER, GPU_CLAMP_TO_BORDER);
for (u32 x = 0; x < width && x < 512; x++) {
for (u32 y = 0; y < height && y < 512; y++) {
const u32 dstPos = ((((y >> 3) * (512 >> 3) + (x >> 3)) << 6) +
((x & 1) | ((y & 1) << 1) | ((x & 2) << 1) |
((y & 2) << 2) | ((x & 4) << 2) | ((y & 4) << 3))) *
4;
const u32 srcPos = (y * width + x) * 4;
((uint8_t *)img.tex->data)[dstPos + 0] = ImageBuffer.data()[srcPos + 3];
((uint8_t *)img.tex->data)[dstPos + 1] = ImageBuffer.data()[srcPos + 2];
((uint8_t *)img.tex->data)[dstPos + 2] = ImageBuffer.data()[srcPos + 1];
((uint8_t *)img.tex->data)[dstPos + 3] = ImageBuffer.data()[srcPos + 0];
}
}
}
void RenderD7::Image::FromSheet(RenderD7::Sheet sheet, size_t index) {}
bool RenderD7::Image::Draw(float x, float y, float scaleX, float scaleY) {
if (loadet)
return C2D_DrawImageAt(this->img, x, y, 0.5f, nullptr, scaleX, scaleY);
return false;
}
void RenderD7::Image::LoadFromBitmap(BMP bitmap) {
loadet = false;
unsigned error =
C3DTexToC2DImage(&this->img, bitmap.bmp_info_header.width,
bitmap.bmp_info_header.height, bitmap.data.data());
if (error == 0) {
this->loadet = true;
}
if (error) {
std::cout << "BMP decoding error " << error << std::endl;
RenderD7::PushMessage(
RenderD7::Message("Bmp - Error", "Code: " + std::to_string(error)));
}
}
namespace RenderD7 {
void Image::LoadJpg(std::string path) {
if (usedbgmsg) {
// RenderD7::Msg::Display("RenderD7", "Loading Png:" + path, Top);
}
if (loadet) {
C3D_TexDelete(this->img.tex);
loadet = false;
}
IMG_LoadImageFile(&this->img, path.c_str());
loadet = true;
}
void Image::LoadPixels(int w, int h, int bpp, void *buffer) {
if (loadet) {
C3D_TexDelete(this->img.tex);
loadet = false;
}
unsigned width, height;
width = w;
height = h;
uint8_t *ImageBuffer = new uint8_t[w * h * 4];
if (bpp == 3)
convert24to32((uint8_t *)buffer, width, height, ImageBuffer);
img.tex = new C3D_Tex;
img.subtex =
new Tex3DS_SubTexture({(u16)width, (u16)height, 0.0f, 1.0f,
width / 512.0f, 1.0f - (height / 512.0f)});
C3D_TexInit(img.tex, 512, 512, GPU_RGBA8);
C3D_TexSetFilter(img.tex, GPU_LINEAR, GPU_LINEAR);
img.tex->border = 0xFFFFFFFF;
C3D_TexSetWrap(img.tex, GPU_CLAMP_TO_BORDER, GPU_CLAMP_TO_BORDER);
for (u32 x = 0; x < width && x < 512; x++) {
for (u32 y = 0; y < height && y < 512; y++) {
const u32 dstPos = ((((y >> 3) * (512 >> 3) + (x >> 3)) << 6) +
((x & 1) | ((y & 1) << 1) | ((x & 2) << 1) |
((y & 2) << 2) | ((x & 4) << 2) | ((y & 4) << 3))) *
4;
const u32 srcPos = (y * width + x) * 4;
((uint8_t *)img.tex->data)[dstPos + 0] = ImageBuffer[srcPos + 3];
((uint8_t *)img.tex->data)[dstPos + 1] = ImageBuffer[srcPos + 2];
((uint8_t *)img.tex->data)[dstPos + 2] = ImageBuffer[srcPos + 1];
((uint8_t *)img.tex->data)[dstPos + 3] = ImageBuffer[srcPos + 0];
}
}
delete[] ImageBuffer;
loadet = true;
}
} // namespace RenderD7

119
source/Memory.cpp
View File

@ -1,60 +1,61 @@
#include <map> #include <map>
#include <renderd7/Memory.hpp> #include <cstdlib>
#include <renderd7/Memory.hpp>
static RenderD7::Memory::memory_metrics metrics;
static RenderD7::Memory::memory_metrics metrics;
bool rd7_enable_memtrack;
bool rd7_enable_memtrack;
void *operator new(size_t size) {
void *ptr = malloc(size); void *operator new(size_t size) {
if (rd7_enable_memtrack) void *ptr = malloc(size);
metrics.t_TotalAllocated += size; if (rd7_enable_memtrack)
return ptr; metrics.t_TotalAllocated += size;
} return ptr;
}
void operator delete(void *memory, size_t size) {
if (rd7_enable_memtrack) void operator delete(void *memory, size_t size) {
metrics.t_TotalFreed += size; if (rd7_enable_memtrack)
free(memory); metrics.t_TotalFreed += size;
} free(memory);
}
int allocations = 0;
int total_size = 0; int allocations = 0;
std::map<void *, size_t> sizes; int total_size = 0;
std::map<void *, size_t> sizes;
void *operator new[](size_t size) {
if (rd7_enable_memtrack) void *operator new[](size_t size) {
allocations++; if (rd7_enable_memtrack)
if (rd7_enable_memtrack) allocations++;
total_size += size; if (rd7_enable_memtrack)
void *ptr = malloc(size); total_size += size;
if (rd7_enable_memtrack) void *ptr = malloc(size);
sizes[ptr] = size; if (rd7_enable_memtrack)
if (rd7_enable_memtrack) sizes[ptr] = size;
metrics.t_TotalAllocated += size; if (rd7_enable_memtrack)
return ptr; metrics.t_TotalAllocated += size;
} return ptr;
}
void operator delete[](void *ptr) {
if (rd7_enable_memtrack) void operator delete[](void *ptr) {
allocations--; if (rd7_enable_memtrack)
if (rd7_enable_memtrack) allocations--;
total_size -= sizes[ptr]; if (rd7_enable_memtrack)
if (rd7_enable_memtrack) total_size -= sizes[ptr];
metrics.t_TotalFreed += sizes[ptr]; if (rd7_enable_memtrack)
if (rd7_enable_memtrack) metrics.t_TotalFreed += sizes[ptr];
sizes.erase(ptr); if (rd7_enable_memtrack)
free(ptr); sizes.erase(ptr);
} free(ptr);
}
namespace RenderD7 {
namespace RenderD7 {
namespace Memory {
namespace Memory {
size_t GetTotalAllocated() { return metrics.t_TotalAllocated; }
size_t GetTotalAllocated() { return metrics.t_TotalAllocated; }
size_t GetTotalFreed() { return metrics.t_TotalFreed; }
size_t GetTotalFreed() { return metrics.t_TotalFreed; }
size_t GetCurrent() { return metrics.t_CurrentlyAllocated(); }
} // namespace Memory size_t GetCurrent() { return metrics.t_CurrentlyAllocated(); }
} // namespace Memory
} // namespace RenderD7 } // namespace RenderD7

190
source/ToastsV2.cpp → source/Message.cpp
View File

@ -1,93 +1,99 @@
#include <renderd7/Color.hpp> #include <renderd7/Color.hpp>
#include <renderd7/Draw.hpp> #include <renderd7/DrawV2.hpp> // Update to Draw2
#include <renderd7/Screen.hpp> #include <renderd7/Screen.hpp>
#include <renderd7/ToastsV2.hpp> #include <renderd7/Message.hpp>
#include <algorithm> #include <algorithm>
#include <memory> #include <memory>
#include <vector> #include <vector>
extern bool rd7_debugging; extern bool rd7_debugging;
std::vector<std::shared_ptr<RenderD7::Message>> msg_lst; std::vector<std::shared_ptr<RenderD7::Message>> msg_lst;
int fade_outs = 200; // Start of fadeout int fade_outs = 200; // Start of fadeout
int idles = 60; // start of Idle int idles = 60; // start of Idle
int anim_len = 300; // Full Length of Animation int anim_len = 300; // Full Length of Animation
std::pair<int, int> MakePos(int frame, int entry) { R7Vec2 MakePos(int frame, int entry) {
float fol = anim_len - fade_outs; float fol = anim_len - fade_outs;
if (frame > fade_outs) if (frame > fade_outs)
return std::make_pair(5, 240 - ((entry + 1) * 55) - 5 + return R7Vec2(5, 240 - ((entry + 1) * 55) - 5 +
(float)((frame - fade_outs) / fol) * -20); (float)((frame - fade_outs) / fol) * -20);
if (frame > idles) if (frame > idles)
return std::make_pair(5, 240 - ((entry + 1) * 55) - 5); return R7Vec2(5, 240 - ((entry + 1) * 55) - 5);
return std::make_pair(-150 + ((float)(frame / (float)idles) * 155), return R7Vec2(-150 + ((float)(frame / (float)idles) * 155),
240 - ((entry + 1) * 55) - 5); 240 - ((entry + 1) * 55) - 5);
} }
namespace RenderD7 { namespace RenderD7 {
float GetDeltaTime(); // Extern from renderd7.cpp float GetDeltaTime(); // Extern from renderd7.cpp
void ProcessMessages() { void ProcessMessages() {
// Draw in ovl mode // Draw in ovl mode
RenderD7::OnScreen(Top); RenderD7::OnScreen(Top);
float fol = anim_len - fade_outs; float fol = anim_len - fade_outs;
std::reverse(msg_lst.begin(), msg_lst.end()); std::reverse(msg_lst.begin(), msg_lst.end());
for (size_t i = 0; i < msg_lst.size(); i++) { for (size_t i = 0; i < msg_lst.size(); i++) {
std::pair<int, int> pos = MakePos(msg_lst[i]->animationframe, i); R7Vec2 pos = MakePos(msg_lst[i]->animationframe, i);
if ((pos.second + 150) < 0) { if ((pos.y + 150) < 0) {
// Dont Render Out of Screen // Dont Render Out of Screen
// And as thay aren't relevant anymore // And as thay aren't relevant anymore
// Thay get deleted! // Thay get deleted!
msg_lst.erase(msg_lst.begin() + i); msg_lst.erase(msg_lst.begin() + i);
} else { } else {
int new_alpha = 200; int new_alpha = 200;
if (msg_lst[i]->animationframe > fade_outs) { if (msg_lst[i]->animationframe > fade_outs) {
new_alpha = new_alpha =
200 - (float(msg_lst[i]->animationframe - fade_outs) / fol) * 200; 200 - (float(msg_lst[i]->animationframe - fade_outs) / fol) * 200;
} }
u32 txtcol = RenderD7::Color::Hex("#ffffff", new_alpha); // Wtf is this function lol
RenderD7::Draw::Rect(pos.first, pos.second, 150, 50, RenderD7::CustomizeColor(RD7Color_MessageBackground,
RenderD7::Color::Hex("#333333", new_alpha)); RenderD7::Color::RGBA(RD7Color_MessageBackground)
RenderD7::Draw::Text(pos.first + 5, pos.second + 1, 0.4f, txtcol, .changeA(new_alpha)
msg_lst[i]->title); .toRGBA());
RenderD7::Draw::Text(pos.first + 5, pos.second + 17, 0.4f, txtcol, RenderD7::CustomizeColor(
msg_lst[i]->message); RD7Color_Text,
if (rd7_debugging) RenderD7::Color::RGBA(RD7Color_Text2).changeA(new_alpha).toRGBA());
RenderD7::Draw::Text(pos.first + 160, pos.second + 1, 0.5f, RenderD7::Draw2::RFS(pos, R7Vec2(150, 50),
RenderD7::Color::Hex("#000000"), RenderD7::StyleColor(RD7Color_MessageBackground));
std::to_string(msg_lst[i]->animationframe)); RenderD7::Draw2::Text(pos + R7Vec2(5, 1), msg_lst[i]->title);
// Why Frameadd? because Message uses int as frame and RenderD7::Draw2::Text(pos + R7Vec2(5, 17), msg_lst[i]->message);
// It seems that lower 0.5 will be rounded to 0 if (rd7_debugging)
// Why not replace int with float ? RenderD7::Draw2::Text(pos + R7Vec2(155, 1),
// cause of buggy positions (seen in Flappy Bird 3ds for example) std::to_string(msg_lst[i]->animationframe));
float frameadd = 60.f * RenderD7::GetDeltaTime(); RenderD7::UndoColorEdit(RD7Color_Text);
// 60fps animation * delta to not slowdown RenderD7::UndoColorEdit(RD7Color_MessageBackground);
// Oh and fix for Startup lol // Why Frameadd? because Message uses int as frame and
// Todo: Only do this on AppStart // It seems that lower 0.5 will be rounded to 0
if (msg_lst[i]->animationframe == 0) { // Why not replace int with float ?
msg_lst[i]->animationframe += 1; // cause of buggy positions (seen in Flappy Bird 3ds for example)
} else { float frameadd = 60.f * RenderD7::GetDeltaTime();
msg_lst[i]->animationframe += (frameadd < 1.f ? 1.f : frameadd); // 60fps animation * delta to not slowdown
} // Oh and fix for Startup lol
if (msg_lst[i]->animationframe > anim_len) { // Todo: Only do this on AppStart
msg_lst.erase(msg_lst.begin() + i); if (msg_lst[i]->animationframe == 0) {
} msg_lst[i]->animationframe += 1;
} } else {
} msg_lst[i]->animationframe += (frameadd < 1.f ? 1.f : frameadd);
// ReReverse ?? lol }
// Cause otherwise the Toasts will swap if (msg_lst[i]->animationframe > anim_len) {
std::reverse(msg_lst.begin(), msg_lst.end()); msg_lst.erase(msg_lst.begin() + i);
} }
}
void PushMessage(const Message &msg) { }
msg_lst.push_back(std::make_shared<RenderD7::Message>(msg)); // ReReverse ?? lol
} // Cause otherwise the Toasts will swap
std::reverse(msg_lst.begin(), msg_lst.end());
void SetIdleStartFrame(int frame) { idles = frame; } }
void SetTotalAnimationFrames(int total_frames) { anim_len = total_frames; } void PushMessage(const Message &msg) {
msg_lst.push_back(std::make_shared<RenderD7::Message>(msg));
void SetFadeOutStartFrame(int frame) { fade_outs = frame; } }
void SetMessageIdleStartFrame(int frame) { idles = frame; }
void SetMessageTotalAnimationFrames(int total_frames) { anim_len = total_frames; }
void SetMessageFadeOutStartFrame(int frame) { fade_outs = frame; }
} // namespace RenderD7 } // namespace RenderD7

71
source/NFontApi.cpp
View File

@ -1,71 +0,0 @@
#include <renderd7/Fonts/NFontApi.hpp>
#define STB_TRUETYPE_IMPLEMENTATION // force following include to generate
// implementation
#include <renderd7/external/stb_truetype.h>
#define STB_IMAGE_WRITE_IMPLEMENTATION
#include <renderd7/external/stb_image_write.h>
#include <fstream>
RenderD7::NFontApi::NFontApi() {}
RenderD7::NFontApi::~NFontApi() {}
void RenderD7::NFontApi::LoadTTF(std::string path) {
/////READ FILE
unsigned char *buffer;
long size = 0;
std::fstream ttf__(path, std::ios::in | std::ios::binary);
if(!ttf__.is_open()) {
return; // Add Error Handler in future
}
ttf__.seekg(0, std::ios::end);
size = ttf__.tellg();
ttf__.seekg(0, std::ios::beg);
buffer = (unsigned char *)malloc(size);
ttf__.read(reinterpret_cast<char*>(buffer), size);
ttf__.close();
/////Setup Font
if (!stbtt_InitFont(&font, buffer, 0)) {
printf("failed\n");
status += "failed\n";
return;
}
status += "success!\n";
b_h = 128;
b_w = 512;
l_h = 24; /* line height */
scale = stbtt_ScaleForPixelHeight(&font, l_h);
stbtt_GetFontVMetrics(&font, &ascent, &decent, &linegap);
linespace = scale * (ascent - decent + linegap);
baseline = (int)(ascent * scale);
height = (int)((ascent - decent) * scale);
}
unsigned char *RenderD7::NFontApi::GetGlyphBitmap(char glyph) {
// stbtt_GetGlyphBitmapBox(&font, glyph, scale, scale, &x0, &y0, &x1, &y1);
stbtt_GetCodepointBitmapBox(&font, glyph, scale, scale, &x0, &y0, &x1, &y1);
w = x1 - x0;
h = y1 - y0;
unsigned char *bitmap;
bitmap = stbtt_GetCodepointBitmap(&font, scale, scale, glyph, &w, &h, 0, 0);
return bitmap;
}
int RenderD7::NFontApi::GetGlyphHeight(char glyph) {
stbtt_GetCodepointBitmapBox(&font, glyph, scale, scale, &x0, &y0, &x1, &y1);
w = x1 - x0;
h = y1 - y0;
return h;
}
int RenderD7::NFontApi::GetGlyphWidth(char glyph) {
stbtt_GetCodepointBitmapBox(&font, glyph, scale, scale, &x0, &y0, &x1, &y1);
w = x1 - x0;
h = y1 - y0;
return w;
}

11
source/Ovarlays.cpp
View File

@ -1,11 +0,0 @@
#include <renderd7/FunctionTrace.hpp>
#include <renderd7/Ovarlays.hpp>
#include <renderd7/renderd7.hpp>
namespace RenderD7 {
Ovl_Ftrace::Ovl_Ftrace() {}
void Ovl_Ftrace::Draw(void) const { RenderD7::OnScreen(Top); }
void Ovl_Ftrace::Logic() {}
} // namespace RenderD7

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