RuiFPB/tyra-linux
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

tyrav2 init

Browse Source
This commit is contained in:
h4570
2022-07-17 10:21:35 +02:00
parent 44c1ee4fe8
commit c8b22ff331
249 changed files with 18187 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.clang-format
+40
View File
@@ -0,0 +1,40 @@
# Use the Google style in this project.
BasedOnStyle: Google
# Some folks prefer to write "int& foo" while others prefer "int &foo". The
# Google Style Guide only asks for consistency within a project, we chose
# "int& foo" for this project:
DerivePointerAlignment: false
PointerAlignment: Left
SortIncludes: false
IncludeBlocks: Merge
IncludeCategories:
# Matches common headers first, but sorts them after project includes
- Regex: '^\"google/cloud/internal/disable_deprecation_warnings.inc\"$'
Priority: -1
- Regex: '^\"google/cloud/(internal/|grpc_utils/|testing_util/|[^/]+\.h)'
Priority: 1000
- Regex: '^\"google/cloud/' # project includes should sort first
Priority: 500
- Regex: '^\"'
Priority: 1500
- Regex: '^<grpc/'
Priority: 2000
- Regex: '^<google/*'
Priority: 3000
- Regex: '^<.*/.*'
Priority: 4000
- Regex: '^<[^/]*>'
Priority: 5000
# Format raw string literals with a `pb` or `proto` tag as proto.
RawStringFormats:
- Language: TextProto
Delimiters:
- 'pb'
- 'proto'
BasedOnStyle: Google
CommentPragmas: '(@copydoc)'
.dockerignore
+5
View File
@@ -0,0 +1,5 @@
*.elf
.git/
.vscode/
docs/
tools/
.gitattributes
+2
View File
@@ -0,0 +1,2 @@
# Ignore all differences in line endings
* -crlf
.gitignore
+37
View File
@@ -0,0 +1,37 @@
# ---
# Prerequisites
*.d
# Compiled Object files
*.slo
*.lo
*.o
*.vsm
# Precompiled Headers
*.gch
*.pch
# Compiled Dynamic libraries
*.so
*.dylib
*.dll
# Binary files
bin/
obj/
res/
# Compiled Static libraries
*.lai
*.la
*.a
*.lib
# Executables
*.exe
*.out
*.app
*.erl
*.elf
.vscode/.gitignore
+6
View File
@@ -0,0 +1,6 @@
*.log
# Configuration files
/c_cpp_properties.json
/tasks.json
/settings.json
.vscode/configurations/windows-docker/c_cpp_properties.json
Vendored
+40
View File
@@ -0,0 +1,40 @@
{
"configurations": [
{
"name": "Docker PS2SDK",
"includePath": [
"${workspaceFolder}/**",
"C:/Users/YOUR-INTELLISENSE-PATH/ps2dev-intellisense/ps2sdk/common/include/**",
"C:/Users/YOUR-INTELLISENSE-PATH/ps2dev-intellisense/ps2sdk/ee/include/**",
"C:/Users/YOUR-INTELLISENSE-PATH/ps2dev-intellisense/ps2sdk/iop/include/**",
"C:/Users/YOUR-INTELLISENSE-PATH/ps2dev-intellisense/ps2sdk/ports/include/**",
"C:/Users/YOUR-INTELLISENSE-PATH/ps2dev-intellisense/ee/include/**",
"C:/Users/YOUR-INTELLISENSE-PATH/ps2dev-intellisense/ee/lib/gcc/mips64r5900el-ps2-elf/11.3.0/include/**",
"C:/Users/YOUR-INTELLISENSE-PATH/ps2dev-intellisense/ee/lib/gcc/mips64r5900el-ps2-elf/11.3.0/include-fixed/**",
"C:/Users/YOUR-INTELLISENSE-PATH/ps2dev-intellisense/ee/lib/gcc/mips64r5900el-ps2-elf/11.3.0/install-tools/include/**",
"C:/Users/YOUR-INTELLISENSE-PATH/ps2dev-intellisense/ee/lib/gcc/mips64r5900el-ps2-elf/11.3.0/plugin/include/**",
"C:/Users/YOUR-INTELLISENSE-PATH/ps2dev-intellisense/ee/mips64r5900el-ps2-elf/include/**",
"C:/Users/YOUR-INTELLISENSE-PATH/ps2dev-intellisense/ee/mips64r5900el-ps2-elf/sys-include/**",
"C:/Users/YOUR-INTELLISENSE-PATH/ps2dev-intellisense/gsKit/include/**",
"C:/Users/YOUR-INTELLISENSE-PATH/ps2dev-intellisense/iop/lib/gcc/mipsel-ps2-elf/11.3.0/include/**",
"C:/Users/YOUR-INTELLISENSE-PATH/ps2dev-intellisense/iop/lib/gcc/mipsel-ps2-elf/11.3.0/install-tools/include/**",
"C:/Users/YOUR-INTELLISENSE-PATH/ps2dev-intellisense/iop/lib/gcc/mipsel-ps2-elf/11.3.0/plugin/include/**",
"C:/Users/YOUR-INTELLISENSE-PATH/ps2dev-intellisense/iop/lib/gcc/mipsel-ps2-elf/11.3.0/include-fixed/**",
"C:/Users/YOUR-INTELLISENSE-PATH/ps2dev-intellisense/iop/lib/gcc/mipsel-ps2-irx/11.3.0/include/**",
"C:/Users/YOUR-INTELLISENSE-PATH/ps2dev-intellisense/iop/lib/gcc/mipsel-ps2-irx/11.3.0/install-tools/include/**",
"C:/Users/YOUR-INTELLISENSE-PATH/ps2dev-intellisense/iop/lib/gcc/mipsel-ps2-irx/11.3.0/plugin/include/**",
"C:/Users/YOUR-INTELLISENSE-PATH/ps2dev-intellisense/iop/lib/gcc/mipsel-ps2-irx/11.3.0/include-fixed/**"
],
"defines": [
"_EE",
"_IOP",
"INTELLISENSE"
],
"cppStandard": "c++20",
"compilerPath": "", // Should be empty
"intelliSenseMode": "linux-gcc-x86",
"configurationProvider": "ms-vscode.cpptools"
}
],
"version": 4
}
.vscode/configurations/windows-docker/settings.json
Vendored
+14
View File
@@ -0,0 +1,14 @@
{
"buildDirectory": "samples/cube",
"C_Cpp.default.intelliSenseMode": "gcc-x86",
"files.associations": {
"*.vcl": "asm-collection",
"*.i": "asm-collection",
"*.vsm": "asm-collection",
"*.vclpp": "asm-collection",
"*.hpp": "cpp",
"*.cpp": "cpp",
"*.h": "c",
"*.c": "c"
}
}
.vscode/configurations/windows-docker/tasks.json
Vendored
+94
View File
@@ -0,0 +1,94 @@
{
"version": "2.0.0",
"tasks": [
{
"label": "Build & run",
"dependsOrder": "sequence",
"dependsOn": [
"1. Copy source code to docker volume",
"2. Compile via docker container",
"3. Copy binaries to host",
"4. Run PCSX2"
],
"group": {
"kind": "build",
"isDefault": true
}
},
{
"type": "shell",
"label": "1. Copy source code to docker volume",
"command": "docker exec -t tyra-compiler sh -c 'rsync -ac --delete --exclude \".git\" --exclude \"docs\" --exclude \".vscode\" --exclude \"tools\" --exclude \"*obj*/**\" --exclude \"*bin*/**\" /host/ /src/'"
},
{
"type": "shell",
"label": "2. Compile via docker container",
"command": "docker exec -t tyra-compiler sh -c 'cd ${config:buildDirectory} && make build-engine all'",
"problemMatcher": {
"base": "$gcc",
"fileLocation": [
"autoDetect"
]
}
},
{
"type": "shell",
"label": "3. Copy binaries to host",
"command": "docker exec -t tyra-compiler sh -c 'rsync -zac --include=\"*/\" --include=\"*bin*/**\" --exclude=\"*\" /src/ /host/'",
},
{
"type": "shell",
"label": "4. Run PCSX2",
"options": {
"cwd": "${config:buildDirectory}"
},
"command": "./run.ps1"
},
{
"type": "shell",
"label": "Cleanup",
"command": "docker exec -t tyra-compiler sh -c 'rm -rf /src/*'"
},
{
"type": "shell",
"label": "Send to PS2",
"command": "docker exec -t tyra-compiler sh -c 'cd ${config:buildDirectory}/bin && killall -v ps2client || true && ps2client -h ${input:ps2Ip} reset && ps2client -h ${input:ps2Ip} reset && ps2client -h ${input:ps2Ip} execee host:$(find . -maxdepth 1 -type f -name \"*.elf\")'"
},
{
"type": "shell",
"label": "Open PS2 output logger",
"command": "docker stop ps2-logs || true && docker run -t --rm --name=ps2-logs -p ${input:local2Ip}:18194:18194/udp h4570/tyra sh -c 'ps2client -h ${input:ps2Ip} listen'",
"runOptions": {
"instanceLimit": 1
},
"presentation": {
"reveal": "always",
"panel": "new"
}
},
{
"type": "shell",
"label": "Start docker container",
"command": "docker compose up -d"
},
{
"type": "shell",
"label": "Stop docker container",
"command": "docker compose down"
}
],
"inputs": [
{
"id": "ps2Ip",
"description": "PS2link ip address:",
"default": "192.168.1.200",
"type": "promptString"
},
{
"id": "local2Ip",
"description": "Local ip address:",
"default": "192.168.1.245",
"type": "promptString"
}
]
}
.vscode/extensions.json
Vendored
+7
View File
@@ -0,0 +1,7 @@
{
"recommendations": [
"ms-vscode.cpptools-extension-pack",
"ryzngard.vscode-header-source",
"maziac.asm-code-lens"
]
}
Dockerfile
+67
View File
@@ -0,0 +1,67 @@
# syntax=docker/dockerfile:1
FROM ubuntu:20.04
# Install necessary packages for PS2DEV, VCLPP and VCL.
RUN apt-get update
ARG DEBIAN_FRONTEND=noninteractive
RUN apt-get install -y git make g++ texinfo bison flex gettext libgmp3-dev \
libmpfr-dev libmpc-dev gcc binutils cmake wget patch zlib1g-dev libgsl-dev \
unzip
# Setup PS2DEV env
ENV PS2DEV /usr/local/ps2dev
RUN mkdir -p $PS2DEV
RUN chown -R $USER: $PS2DEV
ENV PS2SDK $PS2DEV/ps2sdk
ENV GSKIT $PS2DEV/gsKit
ENV PATH $PATH:${PS2DEV}/bin:${PS2DEV}/ee/bin:${PS2DEV}/iop/bin:${PS2DEV}/dvp/bin:${PS2SDK}/bin
# Compile PS2DEV
RUN mkdir -p /temp/ps2dev
RUN git clone https://github.com/ps2dev/ps2dev.git /temp/ps2dev
WORKDIR "/temp/ps2dev"
RUN ./build-all.sh
# Compile VCLPP
RUN mkdir -p /temp/vclpp
RUN git clone https://github.com/glampert/vclpp.git /temp/vclpp
WORKDIR "/temp/vclpp"
RUN make
# Download VCL
RUN mkdir -p /temp/vcl
WORKDIR "/temp/vcl"
RUN wget http://apgcglz.cluster028.hosting.ovh.net/tyra/vcl.zip
RUN unzip vcl.zip
# ------------------------------------------------------------------------------
# Start from clean image
FROM ubuntu:20.04
# Set ENV variables
ENV PS2DEV /usr/local/ps2dev
ENV PS2SDK $PS2DEV/ps2sdk
ENV PATH $PATH:${PS2DEV}/bin:${PS2DEV}/ee/bin:${PS2DEV}/iop/bin:${PS2DEV}/dvp/bin:${PS2SDK}/bin
# Copy stuff from previous stage
COPY --from=0 ${PS2DEV} ${PS2DEV}
COPY --from=0 /temp/vcl/vcl /usr/bin/vcl
COPY --from=0 /temp/vclpp/vclpp /usr/bin/vclpp
# Install packages for emulating x86 and Tyra (make, libmpc, psmisc)
RUN apt-get update
RUN apt-get install -y make rsync libmpc-dev qemu qemu-user-static binfmt-support psmisc
# Add 32bit executables support for VCL
RUN dpkg --add-architecture i386
RUN apt-get update
RUN apt-get install -y libstdc++5:i386
RUN update-binfmts --install i386 /usr/bin/qemu-i386-static --magic '\x7fELF\x01\x01\x01\x03\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x03\x00\x01\x00\x00\x00' --mask '\xff\xff\xff\xff\xff\xff\xff\xfc\xff\xff\xff\xff\xff\xff\xff\xff\xf8\xff\xff\xff\xff\xff\xff\xff'
# Set chmod
RUN chmod 755 /usr/bin/vclpp
RUN chmod 755 /usr/bin/vcl
WORKDIR /src
CMD ["/bin/bash"]
Makefile.base
+116
View File
@@ -0,0 +1,116 @@
#Compiler and Linker
EE_PREFIX := mips64r5900el-ps2-elf-
AR := $(EE_PREFIX)ar
AS := $(EE_PREFIX)as
CC := $(EE_PREFIX)gcc
CXX := $(EE_PREFIX)g++
STRIP := $(EE_PREFIX)strip
BIN2S := $(PS2SDK)/bin/bin2s
VCL := vcl
VCLPP := vclpp
DVP := dvp-as
IRXEMBEDDEDEXT := irx-em
#Flags, Libraries and Includes
CFLAGS += -D_EE -Wall -O3
LINKFLAGS += -O3 -Wl,-zmax-page-size=128
ASFLAGS += -O3
LIB += -lstdc++ -ldma -lpacket2 -lgraph -ldraw -lmath3d -lpng -lz -lpad -laudsrv -lpatches -lcdvd
INC += -I$(PS2DEV)/ps2sdk/ee/include -I$(PS2DEV)/ps2sdk/common/include -I$(PS2DEV)/ps2sdk/ports/include
#---------------------------------------------------------------------------------
#DO NOT EDIT BELOW THIS LINE
#---------------------------------------------------------------------------------
SOURCES := $(shell find $(SRCDIR) -type f -name *.$(SRCEXT))
OBJECTS := $(patsubst $(SRCDIR)/%,$(BUILDDIR)/%,$(SOURCES:.$(SRCEXT)=.$(OBJEXT)))
IRXEM_SOURCES := $(shell find $(SRCDIR) -type f -name *.$(IRXEMBEDDEDEXT))
IRXEM_OBJECTS := $(patsubst $(SRCDIR)/%,$(BUILDDIR)/%,$(IRXEM_SOURCES:.$(IRXEMBEDDEDEXT)=.$(OBJEXT)))
VU_SOURCES_VCL := $(shell find $(SRCDIR) -type f -name *.$(VCLEXT))
VU_OBJECTS_VCL := $(patsubst $(SRCDIR)/%,$(BUILDDIR)/%,$(VU_SOURCES_VCL:.$(VCLEXT)=.$(OBJEXT)))
VU_SOURCES_VSM := $(shell find $(SRCDIR) -type f -name *.$(VSMEXT))
VU_OBJECTS_VSM := $(patsubst $(SRCDIR)/%,$(BUILDDIR)/%,$(VU_SOURCES_VSM:.$(VSMEXT)=.$(OBJEXT)))
VCL_SOURCES := $(shell find $(SRCDIR) -type f -name *.$(VCLPPEXT))
VCL_OBJECTS := $(patsubst $(SRCDIR)/%,$(BUILDDIR)/%,$(VCL_SOURCES:.$(VCLPPEXT)=.$(OBJEXT)))
#Default Make
all: resources irxcopy $(TARGET)
release:
$(MAKE) CFLAGS="-DNDEBUG $(CFLAGS)"
#Remake
remake: cleaner all
#Copy Resources from Resources Directory to Target Directory
resources: directories
@cp $(RESDIR)/* $(TARGETDIR)/ || true
#Make the Directories
directories:
@mkdir -p $(TARGETDIR)
@mkdir -p $(BUILDDIR)
#Clean only Objects
clean:
@$(RM) -rf $(BUILDDIR)
#Full Clean, Objects and Binaries
cleaner: clean
@$(RM) -rf $(TARGETDIR)
@$(RM) -rf $(BUILDDIR)
irxcopy:
@cp $(PS2SDK)/iop/irx/audsrv.irx $(TARGETDIR)/audsrv.irx
#Pull in dependency info for *existing* .o files
-include $(OBJECTS:.$(OBJEXT)=.$(DEPEXT))
#Link
$(TARGET): $(OBJECTS) $(VCL_OBJECTS) $(VU_OBJECTS_VCL) $(VU_OBJECTS_VSM) $(IRXEM_OBJECTS)
$(CXX) -T$(PS2DEV)/ps2sdk/ee/startup/linkfile -o $(TARGETDIR)/$(TARGET) $^ -L$(PS2DEV)/ps2sdk/ee/lib -L$(PS2SDK)/ports/lib $(LINKFLAGS) $(LIBDIRS) $(LIB)
$(STRIP) --strip-all $(TARGETDIR)/$(TARGET)
$(BUILDDIR)/%.$(OBJEXT): $(SRCDIR)/%.$(IRXEMBEDDEDEXT)
@mkdir -p $(dir $@)
@rm -f $@.s
$(BIN2S) $(shell head -1 $<) $@.s $(shell sed -n '2p' $<)
$(AS) $(ASFLAGS) $@.s -o $@
$(BUILDDIR)/%.$(OBJEXT): $(SRCDIR)/%.$(SRCEXT)
@mkdir -p $(dir $@)
$(CXX) $(CFLAGS) $(INC) -c -o $@ $<
@$(CXX) $(CFLAGS) $(INCDEP) -MM $(SRCDIR)/$*.$(SRCEXT) > $(BUILDDIR)/$*.$(DEPEXT)
@cp -f $(BUILDDIR)/$*.$(DEPEXT) $(BUILDDIR)/$*.$(DEPEXT).tmp
@sed -e 's|.*:|$(BUILDDIR)/$*.$(OBJEXT):|' < $(BUILDDIR)/$*.$(DEPEXT).tmp > $(BUILDDIR)/$*.$(DEPEXT)
@sed -e 's/.*://' -e 's/\\$$//' < $(BUILDDIR)/$*.$(DEPEXT).tmp | fmt -1 | sed -e 's/^ *//' -e 's/$$/:/' >> $(BUILDDIR)/$*.$(DEPEXT)
@rm -f $(BUILDDIR)/$*.$(DEPEXT).tmp
$(BUILDDIR)/%.$(OBJEXT): $(SRCDIR)/%.$(VCLEXT)
@mkdir -p $(dir $@)
@rm -f $@.vsm
$(VCL) $< >> $@.vsm
$(DVP) $@.vsm -o $@
$(BUILDDIR)/%.$(OBJEXT): $(SRCDIR)/%.$(VSMEXT)
@mkdir -p $(dir $@)
$(DVP) $< -o $@
$(BUILDDIR)/%.$(OBJEXT): $(SRCDIR)/%.$(VCLPPEXT)
@mkdir -p $(dir $@)
@rm -f $@.vcl
@rm -f $@.vsm
$(VCLPP) $< $@.vcl
$(VCL) $@.vcl > $@.vsm
$(DVP) $@.vsm -o $@
run-pcsx2:
taskkill.exe /f /t /im pcsx2x64.exe || true
$(WSL_LINUX_PCSX2)/pcsx2x64.exe --elf=$(WSL_MAKE_WINDOWS)$(CURDIR)/$(TARGETDIR)/$(TARGET)
#Non-File Targets
.PHONY: all remake clean cleaner resources
README.MD
+1
View File
@@ -0,0 +1 @@
# Work in progress
ROADMAP.txt
+57
View File
@@ -0,0 +1,57 @@
------------ Tyra's v2.0 roadmap to publish on GitHub ------------
--- H4570
- [Renderer] Move clipping algorithm into VU1
- [Renderer] Move animation calcs into VU1
- [Renderer] Dbufferring during mesh unroll
- [Loaders] Think about ".tyrobj" format - implement it (add multicolor support)
- [Loaders] DFF loader
- [Texture] Test cache hits with large amount of textures (dolphin sample?)
- [Demo] Create cool demo which will show all features of Tyra (I will take this one)
--- Wellinator
- [General] Physics and stuff from threeJS
--- Unassigned
- [General] Control generated id to avoid duplication. Maybe Just increment from 0? Add interface IIdentificable?
- [DMA] Check if all chain transfers have end tag!
- [General] Change libs of sample? (remove -lpng, -lz...), probably they are not required
- [General] Check if there are any TODOs
- [General] Check all TYRA_ASSERT() if there are no asserts like (TYRA_ASSERT(!audsrv_load_adpcm(result, data, adpcmFileSize)))
because this lines will be removed on make-release. Only debug stuff should be checked in assert
- [General] All Copyrights to 2020-2022
- [General] CI in Github via docker image
- [General] Add cpp lint checker in GitHub
- [Tutorials] 1. Hello world! - explain init(), loop() and what should be inside them (every tutorial should be well commented!)
- [Tutorials] 2. 2D - explain beginFrame(), endFrame()
- [Tutorials] 3. Minecraft cube - explain this pipeline, and explain that there are many 3D pipelines
- [Tutorials] 4. Mesh rendering - explain stdPipeline, render .tyrobj file via Mesh class, explain that this is high-level
abstract 3D object class, and what it have (animation etc)
- [Tutorials] 5. Manual rendering via stdPipeline - via Render3DBag (core.render()), render simple poly,
explain that this is lower-level abstract rendering, it have the all the features as Mesh rendering,
because Mesh rendering uses only core.render()
- [Tutorials] 6. Animation in Mesh rendering rendering, explain the API
- [Tutorials] 7. Directional lights in Mesh rendering
- [Tutorials] 8. Color-per-vertex light map in Mesh rendering (color array)
- [Tutorials] 9. Render skybox, and show that stdPipOptions.noClipChecks must be set to false, to turn on clip algorithms (prevent glitches)
------------ Github issues for Tyra v2 ------------
- [3D] Add drawLine(x, y , color, size)
- [3D] Add drawBBox(x, y , color, size)
docker-compose.yml
+14
View File
@@ -0,0 +1,14 @@
version: "3.9"
volumes:
tyra-volume:
services:
compiler:
environment:
TERM: xterm-256color
network_mode: host
image: "h4570/tyra"
tty: true
container_name: tyra-compiler
volumes:
- tyra-volume:/src
- ./:/host
docs/install/README.MD
+25
View File
@@ -0,0 +1,25 @@
# Installing Tyra
[![](https://img.shields.io/badge/Install%20time-5%20minutes-brightgreen)](#)
## Prerequisites:
1. Git
2. VSCode
3. Docker with PowerShell as a default terminal
4. [PCSX2](https://github.com/h4570/tyra/blob/master/docs/install/pcsx2.md#)
---
## Steps:
1. Download [intellisense package](http://apgcglz.cluster028.hosting.ovh.net/tyra/ps2dev-intellisense.rar) and unzip it somewhere in your computer.
2. Open terminal in your favourite repositories directory and execute:
```
docker pull h4570/tyra
git clone https://github.com/h4570/tyra.git
```
3. Open `VSCode` and open previously cloned directory.
4. In `VSCode` open `.vscode/configurations/windows-docker` and copy configuration files into `.vscode/`
5. In `c_cpp_properties.json` fix all `YOUR-INTELLISENSE-PATH` with path from point 2.
6. Click `CTRL+SHIFT+P`, type `Tasks: Run task` and run `Start docker container` - Repeat this step every time you want to start working with Tyra (every reboot)
7. Click `CTRL+SHIFT+P`, type `Tasks: Run build task`
8. Tyra should automatically compile engine, `wellinator` sample and run `PCSX2`. If you want to compile & run other sample, please change `buildDirectory` in `settings.json`
docs/install/pcsx2.md
+19
View File
@@ -0,0 +1,19 @@
## Install & configure PCSX2
- Download & install PCSX2 (1.6+ version) from https://pcsx2.net/
- Extract bios files from https://romsmania.cc/bios/pcsx2-playstation-2-bios-3 to `%UserProfile%\Documents\PCSX2\bios`
- Close `PCSX2` if you have opened!
- Open `%UserProfile%\Documents\PCSX2\inis\PCSX2_vm.ini` in notepad
```
HostFs=enabled
```
- Open PCSX2 and map pad to your keyboard, for example:
```
WASD = Left joy
Arrows = Right joy
Space = X
Circle = C
```
engine/Makefile
+26
View File
@@ -0,0 +1,26 @@
TARGET := libtyra.a
#The Directories, Source, Includes, Objects, Binary and Resources
SRCDIR := src
INCDIR := inc
BUILDDIR := obj
TARGETDIR := bin
RESDIR := res
SRCEXT := cpp
VSMEXT := vsm
VCLEXT := vcl
VCLPPEXT := vclpp
DEPEXT := d
OBJEXT := o
#Flags, Libraries and Includes
CFLAGS :=
LIB :=
LIBDIRS :=
INC := -I$(INCDIR)
INCDEP := -I$(INCDIR)
include ../Makefile.base
$(TARGET): $(OBJECTS) $(VCL_OBJECTS) $(VU_OBJECTS_VCL) $(VU_OBJECTS_VSM) $(IRXEM_OBJECTS)
$(AR) rcs $(TARGETDIR)/$(TARGET) $(OBJECTS) $(VCL_OBJECTS) $(VU_OBJECTS_VCL) $(VU_OBJECTS_VSM) $(IRXEM_OBJECTS)
engine/inc/audio/audio.hpp
+161
View File
@@ -0,0 +1,161 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2020-2022, Tyra - https://github.com/h4570/tyrav2
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
# Wellinator Carvalho <wellcoj@gmail.com>
*/
#pragma once
#include "./audio_listener.hpp"
#include <audsrv.h>
#include <string>
namespace Tyra {
struct AudioListenerRef {
AudioListener* listener;
u32 id;
};
/**
* Class responsible for audio playing.
* There are two main features:
* - WAV song (background music)
* - ADPCM samples
*/
class Audio {
public:
/** Constructor is called by the engine. */
Audio();
~Audio();
void init();
/**
* Load 24bit 22050Hz Stereo WAV.
* Can be used multiple times for song switching.
* @param t_path Example: "host:song.wav" or "host:folder/song.wav"
*/
void loadSong(const char* t_path);
/**
* Load 24bit 22050Hz Stereo WAV.
* Can be used multiple times for song switching.
* @param t_path Example: "host:song.wav" or "host:folder/song.wav"
*/
inline void loadSong(const std::string& t_path) { loadSong(t_path.c_str()); }
void playSong();
void stopSong();
const u8& isSongPlaying() const { return songPlaying; }
const u8& isSongLoaded() const { return songLoaded; }
/**
* Set song loop/noloop.
* @returns Looping state is 0 - noloop / 1 - loop
*/
const u8& isSongInLoop() const { return songInLoop; }
/**
* Set song loop/noloop.
* @param t_set false - noloop, true - loop
*/
void setSongLoop(const u8& t_set) { songInLoop = t_set; }
const u8& getVolume() const { return tyraVolume; }
/**
* Set song volume.
* @param t_vol Value 0-100
*/
void setSongVolume(const u8& t_vol);
/**
* If you want to synchronize some actions with
* background song, add audio listener.
* @returns Listener id.
*/
u32 addSongListener(AudioListener* t_listener);
/** Remove song listener. */
void removeSongListener(const u32& t_id);
/**
* Load ADPCM sample. ADPCM sample is an output from
* "adpenc" tool, shipped with PS2SDK.
* @param t_path Example: "host:hit.adpcm" or "host:folder/jump.adpcm"
*/
audsrv_adpcm_t* loadADPCM(const char* t_path);
/**
* Load ADPCM sample. ADPCM sample is an output from
* "adpenc" tool, shipped with PS2SDK.
* @param t_path Example: "host:hit.adpcm" or "host:folder/jump.adpcm"
*/
inline audsrv_adpcm_t* loadADPCM(const std::string& t_path) {
return loadADPCM(t_path.c_str());
}
/**
* Play ADPCM sample.
* ADPCM sample can't be stopped.
* @param t_adpcm ADPCM data, created by loadADPCM();
*/
void playADPCM(audsrv_adpcm_t* t_adpcm);
/**
* Play ADPCM sample.
* ADPCM sample can't be stopped.
* @param t_adpcm ADPCM data, created by loadADPCM();
* @param t_ch Channel (0-23). Type -1 for use any free channel.
*/
void playADPCM(audsrv_adpcm_t* t_adpcm, const s8& t_ch);
/**
* Set ADPCM volume.
* @param t_vol Value 0-100
* @param t_ch Channel (0-23)
*/
void setADPCMVolume(const u8& t_vol, const s8& t_ch) {
audsrv_adpcm_set_volume(t_ch, t_vol);
}
void work();
private:
u8 songLoaded, tyraVolume, audsrvVolume, songPlaying, songInLoop,
songFinished;
FILE* wav;
audsrv_fmt_t format;
std::vector<AudioListenerRef*> songListeners;
ee_thread_t thread;
int threadId;
static const u16 threadStackSize;
u8* threadStack;
ee_sema_t sema;
s32 fillbufferSema;
static const u16 chunkSize;
char* chunk;
s32 chunkReadStatus;
void setSongFormat();
void unloadSong();
void rewindSongToStart();
u32 getSongListenersCount() const { return songListeners.size(); }
void initSema();
void initAUDSRV();
void initThread();
};
} // namespace Tyra
engine/inc/audio/audio_listener.hpp
+25
View File
@@ -0,0 +1,25 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2020-2022, Tyra - https://github.com/h4570/tyrav2
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
# Wellinator Carvalho <wellcoj@gmail.com>
*/
#pragma once
namespace Tyra {
class AudioListener {
public:
virtual ~AudioListener(){};
virtual void onAudioTick() = 0;
virtual void onAudioFinish() = 0;
private:
};
} // namespace Tyra
engine/inc/debug/debug.hpp
+76
View File
@@ -0,0 +1,76 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#ifdef NDEBUG
#define TYRA_LOG(...) ((void)0)
#define TYRA_WARN(...) ((void)0)
#define TYRA_ERROR(...) ((void)0)
#define TYRA_TRAP(...) ((void)0)
#define TYRA_ASSERT(condition, ...) ((void)0)
#else // IF Debug
#include <stdio.h>
#include <string>
#include <sstream>
#include <utility>
#define TYRA_LOG(...) Debug::writeLines("LOG: ", ##__VA_ARGS__, "\n")
#define TYRA_WARN(...) Debug::writeLines("==WARN: ", ##__VA_ARGS__, "\n")
#define TYRA_ERROR(...) Debug::writeLines("====ERR: ", ##__VA_ARGS__, "\n")
#define TYRA_TRAP(...) Debug::trap(__FILE__, __LINE__, ##__VA_ARGS__)
#define TYRA_BREAKPOINT() Debug::trap(__FILE__, __LINE__, "Breakpoint")
#define TYRA_ASSERT(condition, ...) \
if (!(condition)) Debug::trap(__FILE__, __LINE__, ##__VA_ARGS__)
class Debug {
public:
template <typename Arg, typename... Args>
static void writeLines(Arg&& arg, Args&&... args) {
std::stringstream ss;
ss << std::forward<Arg>(arg);
using expander = int[];
(void)expander{0, (void(ss << std::forward<Args>(args)), 0)...};
printf("%s", ss.str().c_str());
}
template <typename... Args>
static void trap(const char* file, int line, Args... args) {
printf("\n");
printf("============== TYRA ==============\n");
printf("| Assertion failed!\n");
printf("|\n");
writeAssertLines(args...);
printf("|\n");
printf("| File : %s:%d\n", file, line);
printf("====================================\n\n");
for (;;) {
}
}
private:
template <typename Arg, typename... Args>
static void writeAssertLines(Arg&& arg, Args&&... args) {
std::stringstream ss;
ss << "| " << std::forward<Arg>(arg) << "\n";
using expander = int[];
(void)expander{
0, (void(ss << "| " << std::forward<Args>(args) << "\n"), 0)...};
printf("%s", ss.str().c_str());
}
};
#endif // NDEBUG
engine/inc/engine.hpp
+41
View File
@@ -0,0 +1,41 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2020, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "./renderer/renderer.hpp"
#include "./pad/pad.hpp"
#include "./audio/audio.hpp"
#include "./irx/irx_loader.hpp"
#include "./info/info.hpp"
#include "./game.hpp"
namespace Tyra {
class Engine {
public:
Engine();
~Engine();
Renderer renderer;
Pad pad;
Audio audio;
IrxLoader irx;
Info info;
void run(Game* t_game);
private:
Game* game;
void realLoop();
};
} // namespace Tyra
engine/inc/file/file_utils.hpp
+35
View File
@@ -0,0 +1,35 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2020 - 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Wellington Carvalho <wellcoj@gmail.com>
*/
#pragma once
namespace Tyra {
class FileUtils {
public:
FileUtils();
~FileUtils();
static std::string getCwd();
static std::string fromCwd(const char* relativePath);
const char* getElfName() const { return elfName; };
const char* getElfPath() const { return elfPath; };
private:
// Argv name+path & just path
char cwd[NAME_MAX];
char elfName[NAME_MAX];
char elfPath[NAME_MAX - 14];
void setPathInfo(const char* path);
};
} // namespace Tyra
engine/inc/game.hpp
+21
View File
@@ -0,0 +1,21 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2020, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
namespace Tyra {
class Game {
public:
virtual void init() = 0;
virtual void loop() = 0;
};
} // namespace Tyra
engine/inc/info/info.hpp
+36
View File
@@ -0,0 +1,36 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2020 - 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Wellington Carvalho <wellcoj@gmail.com>
*/
#pragma once
#include <tamtypes.h>
#include "time/timer.hpp"
namespace Tyra {
class Info {
public:
Info();
~Info();
/** Called by engine */
void update();
const u32& getFps() const { return fps; };
private:
float calcFps();
u8 fpsDelayer;
u32 fps;
Timer timer;
};
} // namespace Tyra
engine/inc/irx/irx_loader.hpp
+36
View File
@@ -0,0 +1,36 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2020 - 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Wellington Carvalho <wellcoj@gmail.com>
*/
#pragma once
#include <tamtypes.h>
namespace Tyra {
class IrxLoader {
public:
IrxLoader();
~IrxLoader();
/** Load's audio and pad driver */
void loadDefaultDrivers();
void loadUSBDriver();
private:
int applyRpcPatches();
int loadAudio();
int loadPad();
int loadUsb();
void waitUntilUsbDeviceIsReady();
void delay(int count);
};
} // namespace Tyra
engine/inc/loaders/3d/builder/mesh_builder_data.hpp
+44
View File
@@ -0,0 +1,44 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2020, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "./mesh_builder_material_data.hpp"
#include "./mesh_builder_frame_data.hpp"
namespace Tyra {
class MeshBuilderData {
public:
MeshBuilderData();
/**
* Frames array and materials array will be deallocated, but
* data (vert,st, ...) inside it not.
* Data ownership is transferred to
* the Mesh class.
*/
~MeshBuilderData();
MeshBuilderFrameData** frames;
u32 framesCount;
MeshBuilderMaterialData** materials;
u32 materialsCount;
bool textureCoordsEnabled, normalsEnabled, manyColorsEnabled;
void allocateFrames(const u32& count);
void allocateMaterials(const u32& count);
void allocate(const u32& framesCount, const u32& materialsCount);
};
} // namespace Tyra
engine/inc/loaders/3d/builder/mesh_builder_frame_data.hpp
+39
View File
@@ -0,0 +1,39 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2020, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include <tamtypes.h>
#include "math/vec4.hpp"
#include "renderer/models/color.hpp"
namespace Tyra {
/**
* Data is not deallocated here.
* Ownership is moved to Mesh class.
*/
class MeshBuilderFrameData {
public:
MeshBuilderFrameData();
~MeshBuilderFrameData();
Vec4 *vertices, *normals, *textureCoords;
Color* colors;
u32 verticesCount, textureCoordsCount, normalsCount, colorsCount;
void allocateTextureCoords(const u32& count);
void allocateVertices(const u32& count);
void allocateNormals(const u32& count);
void allocateColors(const u32& count);
};
} // namespace Tyra
engine/inc/loaders/3d/builder/mesh_builder_material_data.hpp
+35
View File
@@ -0,0 +1,35 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2020, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include <tamtypes.h>
#include <string>
namespace Tyra {
/**
* Data is not deallocated here.
* Ownership is moved to Mesh class.
*/
class MeshBuilderMaterialData {
public:
MeshBuilderMaterialData();
~MeshBuilderMaterialData();
std::string name;
u32 *vertexFaces, *textureCoordFaces, *normalFaces, *colorFaces;
u32 count;
void allocateFaces(const u32& count);
};
} // namespace Tyra
engine/inc/loaders/3d/md2/anorms.hpp
+103
View File
@@ -0,0 +1,103 @@
/*
Copyright (C) 1997-2001 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#pragma once
namespace Tyra {
const float ANORMS[162][3] = {
{-0.525731f, 0.000000f, 0.850651f}, {-0.442863f, 0.238856f, 0.864188f},
{-0.295242f, 0.000000f, 0.955423f}, {-0.309017f, 0.500000f, 0.809017f},
{-0.162460f, 0.262866f, 0.951056f}, {0.000000f, 0.000000f, 1.000000f},
{0.000000f, 0.850651f, 0.525731f}, {-0.147621f, 0.716567f, 0.681718f},
{0.147621f, 0.716567f, 0.681718f}, {0.000000f, 0.525731f, 0.850651f},
{0.309017f, 0.500000f, 0.809017f}, {0.525731f, 0.000000f, 0.850651f},
{0.295242f, 0.000000f, 0.955423f}, {0.442863f, 0.238856f, 0.864188f},
{0.162460f, 0.262866f, 0.951056f}, {-0.681718f, 0.147621f, 0.716567f},
{-0.809017f, 0.309017f, 0.500000f}, {-0.587785f, 0.425325f, 0.688191f},
{-0.850651f, 0.525731f, 0.000000f}, {-0.864188f, 0.442863f, 0.238856f},
{-0.716567f, 0.681718f, 0.147621f}, {-0.688191f, 0.587785f, 0.425325f},
{-0.500000f, 0.809017f, 0.309017f}, {-0.238856f, 0.864188f, 0.442863f},
{-0.425325f, 0.688191f, 0.587785f}, {-0.716567f, 0.681718f, -0.147621f},
{-0.500000f, 0.809017f, -0.309017f}, {-0.525731f, 0.850651f, 0.000000f},
{0.000000f, 0.850651f, -0.525731f}, {-0.238856f, 0.864188f, -0.442863f},
{0.000000f, 0.955423f, -0.295242f}, {-0.262866f, 0.951056f, -0.162460f},
{0.000000f, 1.000000f, 0.000000f}, {0.000000f, 0.955423f, 0.295242f},
{-0.262866f, 0.951056f, 0.162460f}, {0.238856f, 0.864188f, 0.442863f},
{0.262866f, 0.951056f, 0.162460f}, {0.500000f, 0.809017f, 0.309017f},
{0.238856f, 0.864188f, -0.442863f}, {0.262866f, 0.951056f, -0.162460f},
{0.500000f, 0.809017f, -0.309017f}, {0.850651f, 0.525731f, 0.000000f},
{0.716567f, 0.681718f, 0.147621f}, {0.716567f, 0.681718f, -0.147621f},
{0.525731f, 0.850651f, 0.000000f}, {0.425325f, 0.688191f, 0.587785f},
{0.864188f, 0.442863f, 0.238856f}, {0.688191f, 0.587785f, 0.425325f},
{0.809017f, 0.309017f, 0.500000f}, {0.681718f, 0.147621f, 0.716567f},
{0.587785f, 0.425325f, 0.688191f}, {0.955423f, 0.295242f, 0.000000f},
{1.000000f, 0.000000f, 0.000000f}, {0.951056f, 0.162460f, 0.262866f},
{0.850651f, -0.525731f, 0.000000f}, {0.955423f, -0.295242f, 0.000000f},
{0.864188f, -0.442863f, 0.238856f}, {0.951056f, -0.162460f, 0.262866f},
{0.809017f, -0.309017f, 0.500000f}, {0.681718f, -0.147621f, 0.716567f},
{0.850651f, 0.000000f, 0.525731f}, {0.864188f, 0.442863f, -0.238856f},
{0.809017f, 0.309017f, -0.500000f}, {0.951056f, 0.162460f, -0.262866f},
{0.525731f, 0.000000f, -0.850651f}, {0.681718f, 0.147621f, -0.716567f},
{0.681718f, -0.147621f, -0.716567f}, {0.850651f, 0.000000f, -0.525731f},
{0.809017f, -0.309017f, -0.500000f}, {0.864188f, -0.442863f, -0.238856f},
{0.951056f, -0.162460f, -0.262866f}, {0.147621f, 0.716567f, -0.681718f},
{0.309017f, 0.500000f, -0.809017f}, {0.425325f, 0.688191f, -0.587785f},
{0.442863f, 0.238856f, -0.864188f}, {0.587785f, 0.425325f, -0.688191f},
{0.688191f, 0.587785f, -0.425325f}, {-0.147621f, 0.716567f, -0.681718f},
{-0.309017f, 0.500000f, -0.809017f}, {0.000000f, 0.525731f, -0.850651f},
{-0.525731f, 0.000000f, -0.850651f}, {-0.442863f, 0.238856f, -0.864188f},
{-0.295242f, 0.000000f, -0.955423f}, {-0.162460f, 0.262866f, -0.951056f},
{0.000000f, 0.000000f, -1.000000f}, {0.295242f, 0.000000f, -0.955423f},
{0.162460f, 0.262866f, -0.951056f}, {-0.442863f, -0.238856f, -0.864188f},
{-0.309017f, -0.500000f, -0.809017f}, {-0.162460f, -0.262866f, -0.951056f},
{0.000000f, -0.850651f, -0.525731f}, {-0.147621f, -0.716567f, -0.681718f},
{0.147621f, -0.716567f, -0.681718f}, {0.000000f, -0.525731f, -0.850651f},
{0.309017f, -0.500000f, -0.809017f}, {0.442863f, -0.238856f, -0.864188f},
{0.162460f, -0.262866f, -0.951056f}, {0.238856f, -0.864188f, -0.442863f},
{0.500000f, -0.809017f, -0.309017f}, {0.425325f, -0.688191f, -0.587785f},
{0.716567f, -0.681718f, -0.147621f}, {0.688191f, -0.587785f, -0.425325f},
{0.587785f, -0.425325f, -0.688191f}, {0.000000f, -0.955423f, -0.295242f},
{0.000000f, -1.000000f, 0.000000f}, {0.262866f, -0.951056f, -0.162460f},
{0.000000f, -0.850651f, 0.525731f}, {0.000000f, -0.955423f, 0.295242f},
{0.238856f, -0.864188f, 0.442863f}, {0.262866f, -0.951056f, 0.162460f},
{0.500000f, -0.809017f, 0.309017f}, {0.716567f, -0.681718f, 0.147621f},
{0.525731f, -0.850651f, 0.000000f}, {-0.238856f, -0.864188f, -0.442863f},
{-0.500000f, -0.809017f, -0.309017f}, {-0.262866f, -0.951056f, -0.162460f},
{-0.850651f, -0.525731f, 0.000000f}, {-0.716567f, -0.681718f, -0.147621f},
{-0.716567f, -0.681718f, 0.147621f}, {-0.525731f, -0.850651f, 0.000000f},
{-0.500000f, -0.809017f, 0.309017f}, {-0.238856f, -0.864188f, 0.442863f},
{-0.262866f, -0.951056f, 0.162460f}, {-0.864188f, -0.442863f, 0.238856f},
{-0.809017f, -0.309017f, 0.500000f}, {-0.688191f, -0.587785f, 0.425325f},
{-0.681718f, -0.147621f, 0.716567f}, {-0.442863f, -0.238856f, 0.864188f},
{-0.587785f, -0.425325f, 0.688191f}, {-0.309017f, -0.500000f, 0.809017f},
{-0.147621f, -0.716567f, 0.681718f}, {-0.425325f, -0.688191f, 0.587785f},
{-0.162460f, -0.262866f, 0.951056f}, {0.442863f, -0.238856f, 0.864188f},
{0.162460f, -0.262866f, 0.951056f}, {0.309017f, -0.500000f, 0.809017f},
{0.147621f, -0.716567f, 0.681718f}, {0.000000f, -0.525731f, 0.850651f},
{0.425325f, -0.688191f, 0.587785f}, {0.587785f, -0.425325f, 0.688191f},
{0.688191f, -0.587785f, 0.425325f}, {-0.955423f, 0.295242f, 0.000000f},
{-0.951056f, 0.162460f, 0.262866f}, {-1.000000f, 0.000000f, 0.000000f},
{-0.850651f, 0.000000f, 0.525731f}, {-0.955423f, -0.295242f, 0.000000f},
{-0.951056f, -0.162460f, 0.262866f}, {-0.864188f, 0.442863f, -0.238856f},
{-0.951056f, 0.162460f, -0.262866f}, {-0.809017f, 0.309017f, -0.500000f},
{-0.864188f, -0.442863f, -0.238856f}, {-0.951056f, -0.162460f, -0.262866f},
{-0.809017f, -0.309017f, -0.500000f}, {-0.681718f, 0.147621f, -0.716567f},
{-0.681718f, -0.147621f, -0.716567f}, {-0.850651f, 0.000000f, -0.525731f},
{-0.688191f, 0.587785f, -0.425325f}, {-0.587785f, 0.425325f, -0.688191f},
{-0.425325f, 0.688191f, -0.587785f}, {-0.425325f, -0.688191f, -0.587785f},
{-0.587785f, -0.425325f, -0.688191f}, {-0.688191f, -0.587785f, -0.425325f}};
}
engine/inc/loaders/3d/md2/md2_loader.hpp
+32
View File
@@ -0,0 +1,32 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2020, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include <string>
namespace Tyra {
/** Class responsible for loading&parsing Quake's II ".md2" 3D files */
class MD2Loader : public Loader {
public:
MD2Loader();
~MD2Loader();
MeshBuilderData* load(const char* fullpath, const float& t_scale,
const u8& t_invertT);
inline MeshBuilderData* load(const std::string& fullpath,
const float& t_scale, const u8& t_invertT) {
return load(fullpath.c_str(), t_scale, t_invertT);
}
};
} // namespace Tyra
engine/inc/loaders/loader.hpp
+23
View File
@@ -0,0 +1,23 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2020, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include <string>
namespace Tyra {
class Loader {
protected:
std::string getFilenameFromPath(const std::string& path);
std::string getFilenameWithoutExtension(const std::string& filename);
};
} // namespace Tyra
engine/inc/loaders/texture/base/texture_loader.hpp
+35
View File
@@ -0,0 +1,35 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2020, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "loaders/loader.hpp"
#include "loaders/texture/builder/texture_builder_data.hpp"
#include "renderer/core/texture/models/texture_bpp.hpp"
#include <string>
namespace Tyra {
class TextureLoader : public Loader {
public:
/**
* @brief Loads texture data from file.
* Sets size, name and data.
* @param fullpath Full path to texture file. Example: "host:texture.png"
*/
virtual TextureBuilderData* load(const char* fullpath) = 0;
inline TextureBuilderData* load(const std::string& fullpath) {
return load(fullpath.c_str());
}
u32 getTextureSize(const u32& width, const u32& height,
const TextureBpp& bpp);
};
} // namespace Tyra
engine/inc/loaders/texture/base/texture_loader_selector.hpp
+34
View File
@@ -0,0 +1,34 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2020, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "loaders/texture/base/texture_loader.hpp"
#include "loaders/texture/png_loader.hpp"
#include <string>
namespace Tyra {
class TextureLoaderSelector {
public:
TextureLoaderSelector();
~TextureLoaderSelector();
TextureLoader& getLoaderByFileName(const char* fullpath);
inline TextureLoader& getLoaderByFileName(const std::string& fullpath) {
return getLoaderByFileName(fullpath.c_str());
}
TextureLoader& getLoaderByExtension(const std::string& extension);
private:
PngLoader pngLoader;
};
} // namespace Tyra
engine/inc/loaders/texture/builder/texture_builder_data.hpp
+36
View File
@@ -0,0 +1,36 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2020, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include <tamtypes.h>
#include <string>
#include "renderer/core/texture/models/texture_bpp.hpp"
namespace Tyra {
class TextureBuilderData {
public:
TextureBuilderData();
~TextureBuilderData();
std::string name;
int width, height;
unsigned char* data;
TextureBpp bpp;
unsigned char gsComponents;
int clutWidth, clutHeight;
unsigned char* clut;
TextureBpp clutBpp;
unsigned char clutGsComponents;
};
} // namespace Tyra
engine/inc/loaders/texture/png_loader.hpp
+56
View File
@@ -0,0 +1,56 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2020, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "loaders/texture/base/texture_loader.hpp"
#include "renderer/core/texture/models/texture.hpp"
#ifdef INTELLISENSE
typedef void* png_structp;
typedef void* png_bytep;
typedef void* png_infop;
typedef void* png_colorp;
#else
#include <png.h>
#endif
namespace Tyra {
class PngLoader : public TextureLoader {
public:
PngLoader();
~PngLoader();
TextureBuilderData* load(const char* fullpath);
private:
void handle32bpp(TextureBuilderData* result, png_structp pngPtr,
png_infop infoPtr, png_bytep* rowPointers);
void handle24bpp(TextureBuilderData* result, png_structp pngPtr,
png_infop infoPtr, png_bytep* rowPointers);
void handlePalletized(TextureBuilderData* result, png_structp pngPtr,
png_infop infoPtr, png_bytep* rowPointers,
const int& bitDepth);
void handle8bppPalletized(TextureBuilderData* result, png_structp pngPtr,
png_infop infoPtr, png_bytep* rowPointers,
png_colorp palette, png_bytep trans,
const int& numPallete, const int& numTrans);
void handle4bppPalletized(TextureBuilderData* result, png_structp pngPtr,
png_infop infoPtr, png_bytep* rowPointers,
png_colorp palette, png_bytep trans,
const int& numPallete, const int& numTrans);
};
} // namespace Tyra
engine/inc/math/m4x4.hpp
+194
View File
@@ -0,0 +1,194 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "math/vec4.hpp"
#include "math/math.hpp"
namespace Tyra {
class M4x4 {
public:
MATRIX data alignas(sizeof(float) * 16);
/**
* @param identity true = identity matrix, false = random values
*/
explicit M4x4(const bool& identity = true);
M4x4(const M4x4& v) { copy(this, v); }
explicit M4x4(const float* v) { copy(this, v); }
inline M4x4(const float& m11, const float& m12, const float& m13,
const float& m14, const float& m21, const float& m22,
const float& m23, const float& m24, const float& m31,
const float& m32, const float& m33, const float& m34,
const float& m41, const float& m42, const float& m43,
const float& m44) {
set(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42,
m43, m44);
}
static void copy(M4x4* out, const float* in);
static void copy(M4x4* out, const M4x4& in) { copy(out, in.data); }
void operator=(const M4x4& v);
Vec4 operator*(const Vec4& v) const;
M4x4 operator*(const M4x4& v) const {
M4x4 result;
cross(result.data, this->data, v.data);
return result;
}
void operator*=(const M4x4& v) { cross(this->data, this->data, v.data); }
float& operator[](const u8& index) { return data[index]; }
/**
* 1 0 0 0
* 0 1 0 0
* 0 0 1 0
* 0 0 0 1
*/
void identity();
/**
* 1 0 0 0
* 0 1 0 0
* 0 0 1 0
* 0 0 0 1
*/
void unit() { identity(); }
void set(const float& m11, const float& m12, const float& m13,
const float& m14, const float& m21, const float& m22,
const float& m23, const float& m24, const float& m31,
const float& m32, const float& m33, const float& m34,
const float& m41, const float& m42, const float& m43,
const float& m44);
void translate(const Vec4& v) {
M4x4 temp = M4x4(true);
temp.translationX(v.x);
temp.translationY(v.y);
temp.translationZ(v.z);
cross(this->data, temp.data, this->data);
}
void translateX(const float& v) {
M4x4 temp = M4x4(true);
temp.translationX(v);
cross(this->data, temp.data, this->data);
}
void translateY(const float& v) {
M4x4 temp = M4x4(true);
temp.translationY(v);
cross(this->data, temp.data, this->data);
}
void translateZ(const float& v) {
M4x4 temp = M4x4(true);
temp.translationZ(v);
cross(this->data, temp.data, this->data);
}
/** Rotate M4x4. */
void rotate(const Vec4& v) {
M4x4 temp = M4x4(true);
temp.rotationZ(v.z);
cross(this->data, temp.data, this->data);
temp.identity();
temp.rotationY(v.y);
cross(this->data, temp.data, this->data);
temp.identity();
temp.rotationX(v.x);
cross(this->data, temp.data, this->data);
}
/** Rotate M4x4 by X. */
void rotateX(const float& radians) {
M4x4 temp = M4x4(true);
temp.rotationX(radians);
cross(this->data, temp.data, this->data);
}
/** Rotate M4x4 by Y. */
void rotateY(const float& radians) {
M4x4 temp = M4x4(true);
temp.rotationY(radians);
cross(this->data, temp.data, this->data);
}
/** Rotate M4x4 by Z. */
void rotateZ(const float& radians) {
M4x4 temp = M4x4(true);
temp.rotationZ(radians);
cross(this->data, temp.data, this->data);
}
/** Rotate M4x4 by angle. */
void rotateByAngle(const float& angle, const Vec4& axis) {
M4x4 temp;
temp.rotationByAngle(angle, axis);
cross(this->data, temp.data, this->data);
}
void scale(const float& v) { scale(Vec4(v, v, v, 1.0F)); }
void scaleX(const float& v) { scale(Vec4(v, 1.0F, 1.0F, 1.0F)); }
void scaleY(const float& v) { scale(Vec4(1.0F, v, 1.0F, 1.0F)); }
void scaleZ(const float& v) { scale(Vec4(1.0F, 1.0F, v, 1.0F)); }
void scale(const Vec4& v) {
M4x4 temp = M4x4(true);
temp.setScale(v);
cross(this->data, temp.data, this->data);
}
/** Create perspective projection M4x4 (gluPerspective) */
static M4x4 perspective(const float& fov, const float& width,
const float& height, const float& projectionScale,
const float& aspectRatio, const float& near,
const float& far);
/**
* Create a view M4x4 that transforms coordinates in
* such a way that the user looks at a target vector
* direction from a position vector (glLookAt)
*/
static M4x4 lookAt(const Vec4& position, const Vec4& target);
static void lookAt(M4x4* res, const Vec4& position, const Vec4& target);
void print() const;
void print(const char* name) const;
void print(const std::string& name) const { print(name.c_str()); }
std::string getPrint(const char* name = nullptr) const;
private:
static float upVec[4] alignas(sizeof(float) * 4);
static float viewVec[4] alignas(sizeof(float) * 4);
static void cross(float res[16], const float a[16], const float b[16]);
void rotationX(const float& v);
void rotationY(const float& v);
void rotationZ(const float& v);
void rotationByAngle(const float& angle, const Vec4& axis);
void translationX(const float& v);
void translationY(const float& v);
void translationZ(const float& v);
void setScale(const Vec4& val);
static M4x4 setCamera(const float pos[4], const float vz[4],
const float vy[4]);
};
} // namespace Tyra
engine/inc/math/math.hpp
+38
View File
@@ -0,0 +1,38 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
extern "C" {
#include <tamtypes.h>
}
#include <math.h>
namespace Tyra {
class Math {
public:
constexpr static float HALF_ANG2RAD = 3.14159265358979323846F / 360.0F;
constexpr static float ANG2RAD = 3.14159265358979323846F / 180.0F;
constexpr static float PI = 3.1415926535897932384626433832795F;
constexpr static float HALF_PI = 1.5707963267948966192313216916398F;
static float cos(float x);
static float asin(float x);
static float mod(float x, float y);
static inline float sin(float x) { return cos(x - HALF_PI); }
static inline float tan(float x) { return sin(x) / cos(x); }
static float invSqrt(float x);
private:
Math();
};
} // namespace Tyra
engine/inc/math/plane.hpp
+36
View File
@@ -0,0 +1,36 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
namespace Tyra {
class Plane {
public:
Vec4 normal;
float distance;
Plane();
Plane(const Vec4& a, const Vec4& b, const Vec4& c);
~Plane();
void update(const Vec4& a, const Vec4& b, const Vec4& c);
inline float distanceTo(const Vec4& t_vec) const {
return this->distance + this->normal.innerProduct(t_vec);
}
void print() const;
void print(const char* name) const;
void print(const std::string& name) const { print(name.c_str()); }
std::string getPrint(const char* name = nullptr) const;
};
} // namespace Tyra
engine/inc/math/vec2.hpp
+49
View File
@@ -0,0 +1,49 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
extern "C" {
#include <stdio.h>
#include <tamtypes.h>
}
#include <iomanip>
#include <string>
#include "math/math.hpp"
namespace Tyra {
class Vec2 {
public:
union {
struct {
float x;
float y;
};
float xy[2] alignas(sizeof(float) * 2);
};
Vec2(const float& t_x, const float& t_y);
Vec2(const Vec2& v);
Vec2();
~Vec2();
void set(const float& t_x, const float& t_y);
void set(const Vec2& v);
void rotate(const float& t_angle, const float& t_x, const float& t_y);
void print() const;
void print(const char* name) const;
void print(const std::string& name) const { print(name.c_str()); }
std::string getPrint(const char* name = nullptr) const;
};
} // namespace Tyra
engine/inc/math/vec4.hpp
+151
View File
@@ -0,0 +1,151 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
extern "C" {
#include <stdio.h>
#include <tamtypes.h>
}
#include <math3d.h>
#include <iomanip>
#include <cmath>
#include <sstream>
#include <string>
#include "math/math.hpp"
namespace Tyra {
class Vec4 {
public:
union {
struct {
float x;
float y;
float z;
float w;
};
VECTOR xyzw alignas(sizeof(float) * 4);
};
static void copy(Vec4* out, const float* in);
static inline void copy(Vec4* out, const Vec4& in) { copy(out, in.xyzw); }
/** Initialize Vec4 without setting default values */
Vec4() {}
/** Initialize Vec4 with provided values */
Vec4(const float& x, const float& y = 0.0F, const float& z = 0.0F,
const float& w = 1.0F)
: x(x), y(y), z(z), w(w) {}
/** Initialize Vec4 with other Vec4 values */
Vec4(const Vec4& v) { copy(this, v); }
/** Initialize Vec4 with float[4] values */
explicit Vec4(const float* v) { copy(this, v); }
Vec4 operator+(const Vec4& v) const;
Vec4 operator-(const Vec4& v) const;
/** Cross product */
Vec4 operator*(const Vec4& v) const;
Vec4 operator*(const float& v) const;
Vec4 operator/(const float& v) const;
Vec4 operator-(void) const;
void operator=(const Vec4& v);
void operator+=(const Vec4& v);
void operator*=(const float& v);
void operator*=(const Vec4& v);
void operator/=(const float& v);
inline void set(const Vec4& v) { copy(this, v.xyzw); }
inline void set(const float* v) { copy(this, v); }
void set(const float& x, const float& y = 0.0F, const float& z = 0.0F,
const float& w = 1.0F);
Vec4 cross(const Vec4& v) const;
void rotateZ(const int& angle);
int getRelativeCosBetween(const Vec4& v) const;
int getRelativeAngleBetween(const Vec4& v) const;
float innerProduct(const Vec4& v) const;
inline float dot3(const Vec4& v) const { return innerProduct(v); }
/** Get vector length */
float length() const;
/** Normalize vector */
void normalize();
/** Returns distance between two vectors */
float distanceTo(const Vec4& v) const;
/**
* Checks intersection with given box
* @param min Opposite min vertex (ex. near, left, down vertex of bounding
* box)
* @param max Opposite max vertex (ex. far, right, up vertex of bounding
* box)
*/
u8 collidesBox(const Vec4& min, const Vec4& max) const {
return ((this->x <= max.x && this->x >= min.x) &&
(this->y < max.y && this->y >= min.y) &&
(this->z <= max.z && this->z >= min.z))
? 1
: 0;
}
/**
* Checks if this vector is on given box (this->y >= box.y)
* @param min Opposite min vertex (ex. near, left, down vertex of bounding
* box)
* @param max Opposite max vertex (ex. far, right, up vertex of bounding
* box)
*/
u8 isOnBox(const Vec4& min, const Vec4& max) const {
return ((this->x <= max.x && this->x >= min.x) && (this->y >= max.y) &&
(this->z <= max.z && this->z >= min.z))
? 1
: 0;
}
/** Check if given triangle should be backface culled */
static u8 shouldBeBackfaceCulled(const Vec4* cameraPos, const Vec4* v0,
const Vec4* v1, const Vec4* v2);
/**
* Update this vector by linear interpolation between two vertices
* @param v1 Before vertex
* @param v2 After vertex
* @param interp State of interpolation
*/
void lerp(const Vec4& v1, const Vec4& v2, const float& interp);
/**
* Get vector by linear interpolation between two vertices
* @param v1 Before vertex
* @param v2 After vertex
* @param interp State of interpolation
*/
static Vec4 getByLerp(const Vec4& v1, const Vec4& v2, const float& interp);
void print() const;
void print(const char* name) const;
void print(const std::string& name) const { print(name.c_str()); }
std::string getPrint(const char* name = nullptr) const;
static void setLerp(Vec4* output, const Vec4& v1, const Vec4& v2,
const float& interp);
};
} // namespace Tyra
engine/inc/packet2/packet2_tyra_utils.hpp
+37
View File
@@ -0,0 +1,37 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include <packet2_utils.h>
#include "math/m4x4.hpp"
#include "renderer/models/color.hpp"
namespace Tyra {
class Packet2TyraUtils {
public:
inline static void addM4x4(packet2_t* packet2, const M4x4& val) {
*(reinterpret_cast<M4x4*>(packet2->next)) = val;
packet2_advance_next(packet2, sizeof(MATRIX));
}
inline static void addVec4(packet2_t* packet2, const Vec4& val) {
*(reinterpret_cast<Vec4*>(packet2->next)) = val;
packet2_advance_next(packet2, sizeof(VECTOR));
}
inline static void addColor(packet2_t* packet2, const Color& val) {
*(reinterpret_cast<Color*>(packet2->next)) = val;
packet2_advance_next(packet2, sizeof(VECTOR));
}
};
} // namespace Tyra
engine/inc/pad/pad.hpp
+58
View File
@@ -0,0 +1,58 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2020-2022, tyra - https://github.com/h4570/tyrav2
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
# Sandro Wellinator <wellcoj@gmail.com>
*/
#include <kernel.h>
#include <libpad.h>
#pragma once
namespace Tyra {
struct PadButtons {
u8 Cross, Square, Triangle, Circle, DpadUp, DpadDown, DpadLeft, DpadRight, L1,
L2, L3, R1, R2, R3, Start, Select;
};
struct PadJoy {
u8 h, v, isCentered, isMoved;
};
/** Class responsible for player pad */
class Pad {
public:
Pad();
~Pad();
void init();
void update();
inline const PadButtons& getClicked() { return clicked; }
inline const PadButtons& getPressed() { return pressed; }
inline const PadJoy& getLeftJoyPad() { return leftJoyPad; }
inline const PadJoy& getRightJoyPad() { return rightJoyPad; }
private:
char padBuf[256] alignas(sizeof(char) * 256);
char actAlign[6];
int actuators, ret, port, slot;
padButtonStatus buttons;
u32 padData, oldPad, newPad;
PadButtons pressed, clicked;
PadJoy leftJoyPad, rightJoyPad;
void reset();
void handleClickedButtons();
void handlePressedButtons();
int waitPadReady();
int initPad();
};
} // namespace Tyra
engine/inc/renderer/2d/renderer_2d.hpp
+30
View File
@@ -0,0 +1,30 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "renderer/core/2d/sprite/sprite.hpp"
#include "renderer/core/renderer_core.hpp"
namespace Tyra {
class Renderer2D {
public:
Renderer2D();
~Renderer2D();
void init(RendererCore* rendererCore);
void render(Sprite* sprite);
private:
RendererCore* core;
};
} // namespace Tyra
engine/inc/renderer/3d/bbox/bbox.hpp
+64
View File
@@ -0,0 +1,64 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "./bbox_face.hpp"
#include "renderer/core/3d/bbox/core_bbox.hpp"
#include "math/vec4.hpp"
namespace Tyra {
/** Bounding box with more features */
class BBox : public CoreBBox {
public:
explicit BBox(CoreBBox** t_bboxes, const u32& count);
explicit BBox(Vec4* t_vertices, u32* faces, u32 t_count);
explicit BBox(Vec4* t_vertices, u32 t_count);
explicit BBox(Vec4* t_vertices);
const float& getHeight() { return _height; }
const float& getDepth() { return _depth; }
const float& getWidth() { return _width; }
/** @returns the vector directly in middle of the bounding box. */
const Vec4& getCenter() { return _centerVector; }
/** @returns the front face (further on z-axis) */
const BBoxFace& getFrontFace() { return _frontFace; }
/** @returns the back face (nearer on z-axis) */
const BBoxFace& getBackFace() { return _backFace; }
/** @returns the left face (further on x-axis) */
const BBoxFace& getLeftFace() { return _leftFace; }
/** @returns the right face (nearer on x-axis) */
const BBoxFace& getRightFace() { return _rightFace; }
/** @returns the top face (further on y-axis) */
const BBoxFace& getTopFace() { return _topFace; }
/** @returns the bottom face (nearer on y-axis) */
const BBoxFace& getBottomFace() { return _bottomFace; }
protected:
float _height, _depth, _width;
Vec4 _centerVector;
/** Front face (further on z-axis) */
BBoxFace _frontFace;
/** Back face (nearer on z-axis) */
BBoxFace _backFace;
/** Left face (nearer on x-axis) */
BBoxFace _leftFace;
/** Right face (further on x-axis) */
BBoxFace _rightFace;
/** Top face (further on y-axis) */
BBoxFace _topFace;
/** Bottom face (nearer on y-axis) */
BBoxFace _bottomFace;
private:
void setData();
};
} // namespace Tyra
engine/inc/renderer/3d/bbox/bbox_face.hpp
+35
View File
@@ -0,0 +1,35 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "math/vec4.hpp"
namespace Tyra {
/** BBox face */
class BBoxFace {
public:
BBoxFace() {}
BBoxFace(const Vec4& t_minCorner, const Vec4& t_maxCorner, float t_axisPos) {
minCorner = t_minCorner;
maxCorner = t_maxCorner;
axisPosition = t_axisPos;
}
/** Position of the face on it's respective axis. */
float axisPosition;
/** Corner of the face with lower coordinates */
Vec4 minCorner;
/** Corner of the face with higher coordinates */
Vec4 maxCorner;
};
} // namespace Tyra
engine/inc/renderer/3d/mesh/mesh.hpp
+121
View File
@@ -0,0 +1,121 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "loaders/3d/builder/mesh_builder_data.hpp"
#include "./mesh_frame.hpp"
#include "./mesh_material_frame.hpp"
#include "./mesh_anim_state.hpp"
namespace Tyra {
class Mesh {
public:
explicit Mesh(const MeshBuilderData& data);
explicit Mesh(const Mesh& mesh);
~Mesh();
/** Translation matrix */
M4x4 translation;
/** Rotation matrix */
M4x4 rotation;
/** Scale matrix */
M4x4 scale;
const u32& getId() const { return id; }
const u8& isMother() const { return _isMother; }
/** Get position from translation matrix */
Vec4* getPosition() {
return reinterpret_cast<Vec4*>(&translation.data[3 * 4]);
}
void setPosition(const Vec4& v) {
TYRA_ASSERT(v.w == 1.0F, "Vec4 must be homogeneous");
reinterpret_cast<Vec4*>(&translation.data[3 * 4])->set(v);
}
/** Returns material, which is a mesh "subgroup". */
MeshMaterial* getMaterial(const u32& i) const { return materials[i]; }
const u32& getMaterialsCount() const { return materialsCount; }
const MeshAnimState& getAnimState() const { return animState; }
/** Count of all vertices. */
u32 getVertexCount() { return frames[0]->getVertexCount(); }
/** Returns single frame. */
MeshFrame* getFrame(const u32& i) const { return frames[i]; }
/** Count of frames. Static object (not animated) will have only 1 frame. */
const u32& getFramesCount() const { return framesCount; }
const u32& getCurrentAnimationFrame() const { return animState.currentFrame; }
const u32& getNextAnimationFrame() const { return animState.nextFrame; }
const u32& getStartAnimationFrame() const { return animState.startFrame; }
const u32& getEndAnimationFrame() const { return animState.endFrame; }
const u32& getStayAnimationFrame() const { return animState.stayFrame; }
M4x4 getModelMatrix() const;
// /**
// * Returns material, which is a mesh "subgroup".
// * NULL if not found.
// */
// MeshMaterial* getMaterialById(const u32& t_id) const;
/** @returns bounding box object of current frame. */
const BBox& getCurrentBoundingBox() const {
return frames[animState.currentFrame]->getBBox();
}
/** Check if are there any frames */
u8 isDataLoaded() const { return framesCount > 0; }
/** Loop in one frame */
void playAnimation(const u32& t_frame) { playAnimation(t_frame, t_frame); }
/** Play animation in loop from startFrame to endFrame */
void playAnimation(const u32& t_startFrame, const u32& t_endFrame);
/** Play animation from startFrame to endFrame and after loop in stayFrame
*/
void playAnimation(const u32& t_startFrame, const u32& t_endFrame,
const u32& t_stayFrame);
void setAnimSpeed(const float& t_value) { animState.speed = t_value; }
void animate();
/**
* Check if this class loaded mesh data first.
* Meshes which use loadFrom() method have false there.
*/
const u8& isStayAnimationSet() const { return animState.isStayFrameSet; }
private:
void initMesh();
MeshAnimState animState;
u8 _isMother;
u32 id, framesCount, materialsCount;
MeshFrame** frames;
MeshMaterial** materials;
};
} // namespace Tyra
engine/inc/renderer/3d/mesh/mesh_anim_state.hpp
+30
View File
@@ -0,0 +1,30 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2020, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include <tamtypes.h>
namespace Tyra {
typedef struct {
u32 startFrame;
u32 endFrame;
u32 stayFrame;
u8 isStayFrameSet;
float speed;
float interpolation;
u32 animType;
u32 currentFrame;
u32 nextFrame;
} MeshAnimState;
} // namespace Tyra
engine/inc/renderer/3d/mesh/mesh_frame.hpp
+51
View File
@@ -0,0 +1,51 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "renderer/3d/mesh/mesh_material.hpp"
#include "loaders/3d/builder/mesh_builder_data.hpp"
#include "renderer/3d/bbox/bbox.hpp"
namespace Tyra {
class MeshFrame {
public:
explicit MeshFrame(const MeshBuilderData& data, const u32& index);
explicit MeshFrame(const MeshFrame& frame);
~MeshFrame();
const u32& getId() const { return id; }
const u32& getVertexCount() const { return vertexCount; }
const u32& getTextureCoordsCount() const { return textureCoordsCount; }
const u32& getNormalsCount() const { return normalsCount; }
const u32& getColorsCount() const { return colorsCount; }
const u8& isMother() const { return _isMother; }
const BBox& getBBox() const { return *bbox; }
Vec4* getVertices() const { return vertices; }
Vec4* getNormals() const { return normals; }
Vec4* getTextureCoords() const { return textureCoords; }
Color* getColors() const { return colors; }
void print() const;
void print(const char* name) const;
void print(const std::string& name) const { print(name.c_str()); }
std::string getPrint(const char* name = nullptr) const;
private:
u8 _isMother;
BBox* bbox;
u32 id, vertexCount, textureCoordsCount, normalsCount, colorsCount;
Vec4 *vertices, *textureCoords, *normals;
Color* colors;
};
} // namespace Tyra
engine/inc/renderer/3d/mesh/mesh_material.hpp
+57
View File
@@ -0,0 +1,57 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "debug/debug.hpp"
#include "loaders/3d/builder/mesh_builder_data.hpp"
#include "renderer/3d/mesh/mesh_material_frame.hpp"
namespace Tyra {
class MeshMaterial {
public:
explicit MeshMaterial(const MeshBuilderData& data, const u32& materialIndex);
explicit MeshMaterial(const MeshMaterial& material);
~MeshMaterial();
Color singleColor;
const u32& getId() const { return id; }
const std::string& getName() const { return _name; }
const u32& getFacesCount() const { return facesCount; }
const u8& isMother() const { return _isMother; }
const u8& isSingleColorActivated() const { return singleColorFlag; }
u32* getVertexFaces() const { return vertexFaces; }
u32* getTextureCoordFaces() const { return textureCoordFaces; }
u32* getNormalFaces() const { return normalFaces; }
u32* getColorFaces() const { return normalFaces; }
MeshMaterialFrame* getFrames() const { return *frames; }
const BBox& getBBox(const u32& frame) const;
void setSingleColorFlag(const u8& flag);
void print() const;
void print(const char* name) const;
void print(const std::string& name) const { print(name.c_str()); }
std::string getPrint(const char* name = nullptr) const;
private:
MeshMaterialFrame** frames;
std::string _name;
u8 _isMother, singleColorFlag;
u32 id, facesCount, framesCount;
u32 *vertexFaces, *textureCoordFaces, *normalFaces, *colorFaces;
};
} // namespace Tyra
engine/inc/renderer/3d/mesh/mesh_material_frame.hpp
+35
View File
@@ -0,0 +1,35 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "./renderer/3d/bbox/bbox.hpp"
namespace Tyra {
class MeshMaterialFrame {
public:
explicit MeshMaterialFrame(const MeshBuilderData& data, const u32& frameIndex,
const u32& materialIndex);
explicit MeshMaterialFrame(const MeshMaterialFrame& frame);
~MeshMaterialFrame();
const u32& getId() const { return id; }
const u8& isMother() const { return _isMother; }
const BBox& getBBox() const { return *bbox; }
private:
BBox* bbox;
u8 _isMother;
u32 id;
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/minecraft/data/mcpip_block_data.hpp
+31
View File
@@ -0,0 +1,31 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "math/vec4.hpp"
namespace Tyra {
class McpipBlockData {
public:
McpipBlockData();
~McpipBlockData();
u32 count;
float offset;
u32 getComboCount() const { return count * 2; }
Tyra::Vec4* comboData;
Tyra::Vec4* vertices;
Tyra::Vec4* textureCoords;
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/minecraft/data/mcpip_multi_tex_block_data.hpp
+35
View File
@@ -0,0 +1,35 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "debug/debug.hpp"
#include "./mcpip_block_data.hpp"
#include "string"
namespace Tyra {
class McpipMultiTexBlockData : public McpipBlockData {
public:
McpipMultiTexBlockData();
~McpipMultiTexBlockData();
private:
Vec4* tempVerts;
Vec4* tempTexCoords;
u32* tempVertFaces;
u32* tempTexCoordsFaces;
void allocateTempData();
void unroll();
void dellocateTempData();
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/minecraft/data/mcpip_single_tex_block_data.hpp
+35
View File
@@ -0,0 +1,35 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "debug/debug.hpp"
#include "./mcpip_block_data.hpp"
#include "string"
namespace Tyra {
class McpipSingleTexBlockData : public McpipBlockData {
public:
McpipSingleTexBlockData();
~McpipSingleTexBlockData();
private:
Vec4* tempVerts;
Vec4* tempTexCoords;
u32* tempVertFaces;
u32* tempTexCoordsFaces;
void allocateTempData();
void unroll();
void dellocateTempData();
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/minecraft/mcpip_block.hpp
+30
View File
@@ -0,0 +1,30 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include <tamtypes.h>
#include "math/m4x4.hpp"
#include "math/vec4.hpp"
#include "renderer/models/color.hpp"
namespace Tyra {
class McpipBlock {
public:
McpipBlock() {}
~McpipBlock() {}
M4x4 model;
Color color;
Vec4 textureOffset;
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/minecraft/minecraft_pipeline.hpp
+58
View File
@@ -0,0 +1,58 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "./mcpip_block.hpp"
#include "./programs/mcpip_programs_manager.hpp"
#include "renderer/3d/pipeline/renderer_3d_pipeline.hpp"
#include "renderer/core/3d/bbox/core_bbox_frustum.hpp"
#include "renderer/core/3d/bbox/render_bbox.hpp"
namespace Tyra {
class MinecraftPipeline : public Renderer3DPipeline {
public:
MinecraftPipeline();
~MinecraftPipeline();
void init(RendererCore* core);
void onUse();
void render(McpipBlock* blocks, const u32& count, Texture* t_tex,
const bool& isMulti = false, const bool& noClipChecks = true);
inline const float& getTextureOffset() const {
return manager.getTextureOffset();
}
private:
BlockizerProgramsManager manager;
RendererCore* rendererCore;
RenderBBox* bbox;
McpipProgramName latestMode;
void initBBox();
void changeMode(const McpipProgramName& requestedMode, const u8& force);
void cull(McpipBlock* blocks, const std::vector<u32>& indexes,
RendererCoreTextureBuffers* texBuffers,
const bool& isMulti = false);
void clip(McpipBlock* blocks, const std::vector<u32>& indexes,
RendererCoreTextureBuffers* texBuffers,
const bool& isMulti = false);
Tyra::CoreBBoxFrustum isInFrustum(const McpipBlock& block) const;
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/minecraft/programs/as_is/mcpip_as_is_vu1_program.hpp
+28
View File
@@ -0,0 +1,28 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include <packet2_utils.h>
#include <string>
#include "debug/debug.hpp"
#include "renderer/3d/pipeline/minecraft/programs/mcpip_program.hpp"
namespace Tyra {
class McpipAsIsVU1Program : public McpipProgram {
public:
McpipAsIsVU1Program();
~McpipAsIsVU1Program();
std::string getStringName() const;
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/minecraft/programs/as_is/mcpip_clip.hpp
+70
View File
@@ -0,0 +1,70 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include <packet2_utils.h>
#include "debug/debug.hpp"
#include "renderer/renderer.hpp"
#include "packet2/packet2_tyra_utils.hpp"
#include "../mcpip_programs_repository.hpp"
#include "../../mcpip_block.hpp"
#include "../../data/mcpip_block_data.hpp"
#include "./mcpip_vu1_as_is_shared_defines.h"
#include "renderer/core/paths/path1/clipper/path1_ee_clip_algorithm.hpp"
namespace Tyra {
class McpipClip {
public:
McpipClip();
~McpipClip();
Path1EEClipAlgorithm algorithm;
Path1EEClipAlgorithmSettings algoSettings;
void init(RendererCore* core, McpipBlockData* t_singleBlockData,
McpipBlockData* t_multiBlockData);
u32 uploadVU1Program(McpipProgramsRepository* repo, const u32& addr);
void configureVU1AndSendStaticData();
void addData(McpipBlock* block, const bool& isMulti,
RendererCoreTextureBuffers* texBuffers, packet2_t* packet,
const u8& context);
private:
RendererCore* rendererCore;
McpipBlockData* singleBlockData;
McpipBlockData* multiBlockData;
packet2_t* staticPacket;
u16 vu1DBufferSize;
std::vector<Path1ClipVertex> clippedTriangle;
std::vector<Path1ClipVertex> inputTriangle;
Vec4 vertexBuffers[2][108];
Vec4 texCoordBuffers[2][108];
void addCorrections(std::vector<Path1ClipVertex>* vertices,
McpipBlock* block);
void moveDataToBuffer(std::vector<Path1ClipVertex>* vertices,
const u8& context);
void addDataToPacket(packet2_t* packet, const u8& context, McpipBlock* block,
const int& count,
RendererCoreTextureBuffers* texBuffers);
void initStaticPacket();
void sendVU1StaticData();
void setDBufferSize();
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/minecraft/programs/as_is/mcpip_vu1_as_is_shared_defines.h
+22
View File
@@ -0,0 +1,22 @@
//
// ______ ____ ___
// | \/ ____| |___|
// | | | \ | |
//-----------------------------------------------------------------------
// Copyright 2022, tyra - https://github.com/h4570/tyra
// Licenced under Apache License 2.0
// Sandro Sobczyński <sandro.sobczynski@gmail.com>
//
// Static data for blockizer program
#define VU1_MCPIP_AS_IS_STATIC_LOD 0
#define VU1_MCPIP_AS_IS_STATIC_SET_TAG 1
#define VU1_MCPIP_AS_IS_STATIC_LAST_DATA_ADDR 1
// Dynamic data (unpack per VU1 call)
#define VU1_MCPIP_AS_IS_DYNAMIC_SCALE 0
#define VU1_MCPIP_AS_IS_DYNAMIC_PRIM 1
#define VU1_MCPIP_AS_IS_DYNAMIC_CLUT 2
#define VU1_MCPIP_AS_IS_DYNAMIC_COLOR 3
#define VU1_MCPIP_AS_IS_DYNAMIC_VERTEX_DATA_ADDR 4
engine/inc/renderer/3d/pipeline/minecraft/programs/cull/mcpip_cull.hpp
+52
View File
@@ -0,0 +1,52 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include <packet2_utils.h>
#include "debug/debug.hpp"
#include "renderer/renderer.hpp"
#include "packet2/packet2_tyra_utils.hpp"
#include "../mcpip_programs_repository.hpp"
#include "../../mcpip_block.hpp"
#include "../../data/mcpip_block_data.hpp"
#include "./mcpip_vu1_cull_shared_defines.h"
namespace Tyra {
class McpipCull {
public:
McpipCull();
~McpipCull();
void init(RendererCore* core, McpipBlockData* t_blockData);
u32 uploadVU1Program(McpipProgramsRepository* repo, const u32& addr);
void configureVU1AndSendStaticData();
u32 getMaxBlocksCountPerQBuffer() const;
void addData(packet2_t* packet, McpipBlock** blockPointerArray,
u32 blockPointerArrayCount,
RendererCoreTextureBuffers* texBuffers, bool isMulti);
private:
RendererCore* rendererCore;
u16 vu1DBufferSize;
McpipBlockData* blockData;
packet2_t* staticPacket;
void initStaticPacket();
void sendVU1StaticData();
void setDBufferSize();
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/minecraft/programs/cull/mcpip_cull_vu1_program.hpp
+28
View File
@@ -0,0 +1,28 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include <packet2_utils.h>
#include <string>
#include "debug/debug.hpp"
#include "renderer/3d/pipeline/minecraft/programs/mcpip_program.hpp"
namespace Tyra {
class McpipCullVU1Program : public McpipProgram {
public:
McpipCullVU1Program();
~McpipCullVU1Program();
std::string getStringName() const;
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/minecraft/programs/cull/mcpip_vu1_cull_shared_defines.h
+33
View File
@@ -0,0 +1,33 @@
//
// ______ ____ ___
// | \/ ____| |___|
// | | | \ | |
//-----------------------------------------------------------------------
// Copyright 2022, tyra - https://github.com/h4570/tyra
// Licenced under Apache License 2.0
// Sandro Sobczyński <sandro.sobczynski@gmail.com>
//
// Static data for blockizer program
#define VU1_MCPIP_CULL_VERTEX_COUNT 36
#define VU1_MCPIP_CULL_QWORDS_PER_BLOCK 6
#define VU1_MCPIP_CULL_STATIC_LOD 0
#define VU1_MCPIP_CULL_STATIC_PRIM 1
#define VU1_MCPIP_CULL_STATIC_SET_TAG 2
#define VU1_MCPIP_CULL_STATIC_VU1_OPTIONS 3
#define VU1_MCPIP_CULL_STATIC_VERTEX_DATA 4
#define VU1_MCPIP_CULL_STATIC_TEX_COORD_DATA 4 + 36
#define VU1_MCPIP_CULL_STATIC_LAST_DATA_ADDR \
VU1_MCPIP_CULL_STATIC_TEX_COORD_DATA + 36
// Dynamic data (unpack per VU1 call)
#define VU1_MCPIP_CULL_DYNAMIC_SCALE_AND_BLOCKS_COUNT_ADDR 0
#define VU1_MCPIP_CULL_DYNAMIC_CLUT_TEX 1
#define VU1_MCPIP_CULL_DYNAMIC_VIEW_PROJ_MATRIX_ADDR 2
#define VU1_MCPIP_CULL_DYNAMIC_BLOCKS_DATA 6
// Output mini double buffer inside VU1 mem
#define VU1_MCPIP_CULL_DYNAMIC_OUTPUT_DOUBLE_BUFF1_ADDR 774
#define VU1_MCPIP_CULL_DYNAMIC_OUTPUT_DOUBLE_BUFF2_ADDR 887
engine/inc/renderer/3d/pipeline/minecraft/programs/mcpip_program.hpp
+29
View File
@@ -0,0 +1,29 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "./mcpip_program_name.hpp"
#include "renderer/core/paths/path1/vu1_program.hpp"
namespace Tyra {
class McpipProgram : public VU1Program {
public:
McpipProgram(const McpipProgramName& name, u32* start, u32* end);
~McpipProgram();
const McpipProgramName& getName() const;
protected:
McpipProgramName name;
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/minecraft/programs/mcpip_program_name.hpp
+21
View File
@@ -0,0 +1,21 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
namespace Tyra {
enum McpipProgramName {
UndefinedMcpipProgram,
McPipCull,
McPipAsIs,
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/minecraft/programs/mcpip_programs_manager.hpp
+75
View File
@@ -0,0 +1,75 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include <packet2_utils.h>
#include "debug/debug.hpp"
#include "renderer/renderer.hpp"
#include "./cull/mcpip_cull.hpp"
#include "./as_is/mcpip_clip.hpp"
#include "./mcpip_programs_repository.hpp"
#include "../data/mcpip_single_tex_block_data.hpp"
#include "../data/mcpip_multi_tex_block_data.hpp"
#include "../mcpip_block.hpp"
namespace Tyra {
enum McpipStaticBlockData {
BlockNotUploaded,
BlockMultiUploaded,
BlockSingleUploaded
};
class BlockizerProgramsManager {
public:
BlockizerProgramsManager();
~BlockizerProgramsManager();
McpipCull culler;
McpipClip clipper;
void init(RendererCore* core);
void uploadVU1Programs();
void clearLastProgram() { lastProgramName = UndefinedMcpipProgram; }
void cull(McpipBlock** blockPointerArray, u32 blockPointerArrayCount,
RendererCoreTextureBuffers* texBuffers, const bool& isMulti);
void clip(McpipBlock* block, RendererCoreTextureBuffers* texBuffers,
const bool& isMulti);
inline const float& getTextureOffset() const {
return singleTexBlockData.offset;
}
const McpipBlockData& getBlockData() const { return singleTexBlockData; }
private:
McpipProgramsRepository repo;
Renderer* renderer;
McpipSingleTexBlockData singleTexBlockData;
McpipMultiTexBlockData multiTexBlockData;
McpipProgramName lastProgramName;
packet2_t* programsPacket;
packet2_t* staticPacket;
packet2_t* dynamicPackets[2];
u8 context;
McpipStaticBlockData vu1BlockData;
void setProgramsCache();
void uploadBlock(bool isMulti);
void sendPacket(McpipProgram* program);
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/minecraft/programs/mcpip_programs_repository.hpp
+32
View File
@@ -0,0 +1,32 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "debug/debug.hpp"
#include "./mcpip_program.hpp"
#include "cull/mcpip_cull_vu1_program.hpp"
#include "as_is/mcpip_as_is_vu1_program.hpp"
namespace Tyra {
class McpipProgramsRepository {
public:
McpipProgramsRepository();
~McpipProgramsRepository();
McpipProgram* getProgram(const McpipProgramName& name);
private:
McpipCullVU1Program cull;
McpipAsIsVU1Program asIs;
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/renderer_3d_pipeline.hpp
+26
View File
@@ -0,0 +1,26 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "renderer/core/renderer_core.hpp"
namespace Tyra {
class Renderer3DPipeline {
public:
Renderer3DPipeline() {}
~Renderer3DPipeline() {}
virtual void init(RendererCore* core) = 0;
virtual void onUse() = 0;
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/std/core/bag/packaging/stdpip_bag_package.hpp
+50
View File
@@ -0,0 +1,50 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "../stdpip_bag.hpp"
#include "renderer/core/3d/bbox/core_bbox_frustum.hpp"
namespace Tyra {
class StdpipBagPackage {
public:
StdpipBagPackage();
~StdpipBagPackage();
StdpipBag* bag;
Vec4* vertices;
Vec4* sts;
Vec4* normals;
Vec4* colors;
/** maxVertCount is max value, because we decided to put max maxVertCount
* verts to single quad buffer in VU1 */
u16 size;
CoreBBoxFrustum isInFrustum;
/**
* We are creating StdpipBagPackagesBBox which checks CoreBBoxBBox for every
* maxVertCount / 3. So this variable is index of starting
* StdpipBagPackagesBBox's CoreBBoxBBox. If package have <= maxVertCount / 3
* verts, we will need only single (starting) bbox. if package have
* maxVertCount verts, we will calculate CoreBBoxBBox from 3
* StdpipBagPackagesBBox's bboxes.
*/
u32 indexOf1By3BBox;
void print() const;
void print(const char* name) const;
void print(const std::string& name) const { print(name.c_str()); }
std::string getPrint(const char* name = nullptr) const;
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/std/core/bag/packaging/stdpip_bag_packager.hpp
+52
View File
@@ -0,0 +1,52 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "renderer/core/3d/bbox/core_bbox.hpp"
#include "renderer/core/3d/renderer_3d_frustum_planes.hpp"
#include "renderer/core/paths/path1/clipper/path1_ee_clip_algorithm.hpp"
#include "./stdpip_bag_packages_bbox.hpp"
#include "./stdpip_bag_package.hpp"
#include "../stdpip_bag.hpp"
namespace Tyra {
class StdpipBagPackager {
public:
StdpipBagPackager();
~StdpipBagPackager();
void init(Renderer3DFrustumPlanes* frustumPlanes);
void setRenderBBox(StdpipBagPackagesBBox* bbox) { renderBBox = bbox; }
void setMaxVertCount(const u32& count);
/**
* @brief Create render packages from provided render data
*
* @param size Max maxVertCount verts (VU1 buffer size)
*/
StdpipBagPackage* create(u16* o_size, StdpipBag* data, u16 size);
/**
* @brief Split render package to smaller packages
*
* @param size Max maxVertCount verts (VU1 buffer size)
*/
StdpipBagPackage* create(u16* o_size, const StdpipBagPackage& pkg, u16 size);
CoreBBoxFrustum checkFrustum(const StdpipBagPackage& pkg);
private:
u32 maxVertCount;
Renderer3DFrustumPlanes* frustumPlanes;
StdpipBagPackagesBBox* renderBBox;
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/std/core/bag/packaging/stdpip_bag_packages_bbox.hpp
+69
View File
@@ -0,0 +1,69 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "renderer/core/3d/bbox/render_bbox.hpp"
namespace Tyra {
/**
* Splits all 3D input vertices into 16vert parts and creates child bboxes for
* it
*/
class StdpipBagPackagesBBox {
public:
StdpipBagPackagesBBox(Vec4* t_vertices, u32* t_faces, const u32& t_facesCount,
const u32& t_maxVertCount);
StdpipBagPackagesBBox(Vec4* t_vertices, const u32& t_counts,
const u32& t_maxVertCount);
~StdpipBagPackagesBBox();
void setMaxVertCount(const u32& count);
/**
* @param index Index of part
*/
const RenderBBox& getChildBBox1By3(const u32& index) const;
/** @brief CoreBBox created from all of vertices */
RenderBBox* getMainBBox();
/** @brief Get amount of child Bbox1/3 parts */
const u32& getPartsCount() const;
/** @brief Get amount of vertices */
const u32& getVertexCount() const;
/**
* @brief For example if we want to build a bbox from 96-112 vertices, we
* should input index = 3, partsSize = 1
* @param index Index of part
* @param partsSize How many 1/3 parts
*/
RenderBBox createChildBBox(const u32& index, const u16& partsSize) const;
void print() const;
void print(const char* name) const;
void print(const std::string& name) const { print(name.c_str()); }
std::string getPrint(const char* name = nullptr) const;
private:
u32 maxVertCount;
u32 vertexCount, partsCount;
/** @brief CoreBBox of all vertices */
RenderBBox* mainBBox;
/** @brief Bounding boxes of 1/3 vertices */
std::vector<CoreBBox>* bboxParts;
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/std/core/bag/stdpip_bag.hpp
+62
View File
@@ -0,0 +1,62 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "math/vec4.hpp"
#include "./stdpip_lighting_bag.hpp"
#include "./stdpip_info_bag.hpp"
#include "./stdpip_color_bag.hpp"
#include "./stdpip_texture_bag.hpp"
#include "renderer/core/texture/models/texture.hpp"
#include "./packaging/stdpip_bag_packages_bbox.hpp"
namespace Tyra {
/**
* @brief 3D Render data bag.
* Supports frustum culling, clipping, lighting,
* texture and single color / many colors.
*/
class StdpipBag {
public:
StdpipBag();
~StdpipBag();
/** Mandatory. Object info. */
StdpipInfoBag* info;
/** Mandatory. Object color(s). */
StdpipColorBag* color;
/** Mandatory. Vertex count. */
u32 count;
/** Mandatory. Vertices. */
Vec4* vertices;
/** Optional. Texture coordinates and image. */
StdpipTextureBag* texture;
/** Optional. Object lighting. */
StdpipLightingBag* lighting;
/**
* @param maxVertCount This parameter is available in renderer API.
*/
StdpipBagPackagesBBox calculateBbox(const u32& maxVertCount);
void print() const;
void print(const char* name) const;
void print(const std::string& name) const { print(name.c_str()); }
std::string getPrint(const char* name = nullptr) const;
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/std/core/bag/stdpip_color_bag.hpp
+32
View File
@@ -0,0 +1,32 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "renderer/models/color.hpp"
namespace Tyra {
/**
* @brief Color data. At least one color data is required (single/many).
*/
class StdpipColorBag {
public:
StdpipColorBag();
~StdpipColorBag();
/** Optional. Single color for all vertices. */
Color* single;
/** Optional. Color per vertex. */
Color* many;
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/std/core/bag/stdpip_info_bag.hpp
+34
View File
@@ -0,0 +1,34 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include <draw.h>
#include "math/m4x4.hpp"
#include "math/vec4.hpp"
#include "../../stdpip_shading_type.hpp"
namespace Tyra {
class StdpipInfoBag {
public:
StdpipInfoBag();
~StdpipInfoBag();
/** Mandatory. Model matrix */
M4x4* model;
StdpipShadingType shadingType;
bool blendingEnabled;
bool antiAliasingEnabled;
bool noClipChecks;
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/std/core/bag/stdpip_lighting_bag.hpp
+56
View File
@@ -0,0 +1,56 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "renderer/models/color.hpp"
#include "math/m4x4.hpp"
#include "math/vec4.hpp"
namespace Tyra {
enum StdpipLightingBagMode { Auto, Manual };
class StdpipLightingBag {
public:
explicit StdpipLightingBag(const bool& manual = false);
~StdpipLightingBag();
Vec4* normals;
M4x4* lightMatrix;
void setAmbientColor(const Color& color);
void setDirectionalLightColors(Color* colors, const u8& count);
void setDirectionalLightDirections(Vec4* directions, const u8& count);
void setDirectionalLightColor(const Color& color, const u8& index);
void setDirectionalLightDirection(const Vec4& direction, const u8& index);
void setLightsManually(Vec4* colors, Vec4* directions);
void disableManualMode();
Vec4* getLightColors() { return lightColors; }
Vec4* getLightDirections() { return lightDirections; }
void forceDeallocateColors();
void forceDeallocateDirections();
private:
void allocate();
void deallocate();
void forceDeallocate();
u8 isAllocated;
StdpipLightingBagMode mode;
Vec4* lightColors;
Vec4* lightDirections;
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/std/core/bag/stdpip_texture_bag.hpp
+30
View File
@@ -0,0 +1,30 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "math/vec4.hpp"
#include "renderer/core/texture/models/texture.hpp"
namespace Tyra {
class StdpipTextureBag {
public:
StdpipTextureBag();
~StdpipTextureBag();
/** Mandatory. Texture coordinates per vertex. */
Vec4* coordinates;
/** Mandatory. Texture image. */
Texture* texture;
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/std/core/path1/programs/as_is/stdpip_as_is_c_vu1_program.hpp
+30
View File
@@ -0,0 +1,30 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include <packet2_utils.h>
#include <string>
#include "../../stdpip_vu1_program.hpp"
namespace Tyra {
class StdpipAsIsCVU1Program : public StdpipVU1Program {
public:
StdpipAsIsCVU1Program();
~StdpipAsIsCVU1Program();
std::string getStringName() const;
void addProgramQBufferDataToPacket(packet2_t* packet,
StdpipQBuffer* qbuffer) const;
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/std/core/path1/programs/as_is/stdpip_as_is_d_vu1_program.hpp
+29
View File
@@ -0,0 +1,29 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include <packet2_utils.h>
#include <string>
#include "../../stdpip_vu1_program.hpp"
namespace Tyra {
class StdpipAsIsDVU1Program : public StdpipVU1Program {
public:
StdpipAsIsDVU1Program();
~StdpipAsIsDVU1Program();
std::string getStringName() const;
void addProgramQBufferDataToPacket(packet2_t* packet,
StdpipQBuffer* qbuffer) const;
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/std/core/path1/programs/as_is/stdpip_as_is_tc_vu1_program.hpp
+29
View File
@@ -0,0 +1,29 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include <packet2_utils.h>
#include <string>
#include "../../stdpip_vu1_program.hpp"
namespace Tyra {
class StdpipAsIsTCVU1Program : public StdpipVU1Program {
public:
StdpipAsIsTCVU1Program();
~StdpipAsIsTCVU1Program();
std::string getStringName() const;
void addProgramQBufferDataToPacket(packet2_t* packet,
StdpipQBuffer* qbuffer) const;
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/std/core/path1/programs/as_is/stdpip_as_is_td_vu1_program.hpp
+29
View File
@@ -0,0 +1,29 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include <packet2_utils.h>
#include <string>
#include "../../stdpip_vu1_program.hpp"
namespace Tyra {
class StdpipAsIsTDVU1Program : public StdpipVU1Program {
public:
StdpipAsIsTDVU1Program();
~StdpipAsIsTDVU1Program();
std::string getStringName() const;
void addProgramQBufferDataToPacket(packet2_t* packet,
StdpipQBuffer* qbuffer) const;
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/std/core/path1/programs/cull/stdpip_cull_c_vu1_program.hpp
+29
View File
@@ -0,0 +1,29 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include <packet2_utils.h>
#include <string>
#include "../../stdpip_vu1_program.hpp"
namespace Tyra {
class StdpipCullCVU1Program : public StdpipVU1Program {
public:
StdpipCullCVU1Program();
~StdpipCullCVU1Program();
std::string getStringName() const;
void addProgramQBufferDataToPacket(packet2_t* packet,
StdpipQBuffer* qbuffer) const;
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/std/core/path1/programs/cull/stdpip_cull_d_vu1_program.hpp
+29
View File
@@ -0,0 +1,29 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include <packet2_utils.h>
#include <string>
#include "../../stdpip_vu1_program.hpp"
namespace Tyra {
class StdpipCullDVU1Program : public StdpipVU1Program {
public:
StdpipCullDVU1Program();
~StdpipCullDVU1Program();
std::string getStringName() const;
void addProgramQBufferDataToPacket(packet2_t* packet,
StdpipQBuffer* qbuffer) const;
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/std/core/path1/programs/cull/stdpip_cull_tc_vu1_program.hpp
+29
View File
@@ -0,0 +1,29 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include <packet2_utils.h>
#include <string>
#include "../../stdpip_vu1_program.hpp"
namespace Tyra {
class StdpipCullTCVU1Program : public StdpipVU1Program {
public:
StdpipCullTCVU1Program();
~StdpipCullTCVU1Program();
std::string getStringName() const;
void addProgramQBufferDataToPacket(packet2_t* packet,
StdpipQBuffer* qbuffer) const;
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/std/core/path1/programs/cull/stdpip_cull_td_vu1_program.hpp
+29
View File
@@ -0,0 +1,29 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include <packet2_utils.h>
#include <string>
#include "../../stdpip_vu1_program.hpp"
namespace Tyra {
class StdpipCullTDVU1Program : public StdpipVU1Program {
public:
StdpipCullTDVU1Program();
~StdpipCullTDVU1Program();
std::string getStringName() const;
void addProgramQBufferDataToPacket(packet2_t* packet,
StdpipQBuffer* qbuffer) const;
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/std/core/path1/programs/stdpip_vu1_shared_defines.h
+24
View File
@@ -0,0 +1,24 @@
//
// ______ ____ ___
// | \/ ____| |___|
// | | | \ | |
//-----------------------------------------------------------------------
// Copyright 2022, tyra - https://github.com/h4570/tyra
// Licenced under Apache License 2.0
// Sandro Sobczyński <sandro.sobczynski@gmail.com>
//
// Updated once per mesh
#define VU1_MVP_MATRIX_ADDR 0
#define VU1_LIGHTS_MATRIX_ADDR 4
#define VU1_SINGLE_COLOR_ADDR 7
#define VU1_OPTIONS_ADDR 8
#define VU1_LOD_ADDR 9
#define VU1_CLUT_ADDR 10
#define VU1_LIGHTS_DIRS_ADDR 11
#define VU1_LIGHTS_COLORS_ADDR 14
#define VU1_SET_GIFTAG_ADDR 18
#define VU1_LAST_ITEM_ADDR 18
// Buffer data (xtop)
#define VU1_VERT_DATA_ADDR 2
engine/inc/renderer/3d/pipeline/std/core/path1/stdpip_clipper.hpp
+47
View File
@@ -0,0 +1,47 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include <vector>
#include "debug/debug.hpp"
#include "./stdpip_qbuffer.hpp"
#include "renderer/renderer_settings.hpp"
#include "renderer/core/paths/path1/clipper/path1_ee_clip_algorithm.hpp"
namespace Tyra {
/**
* @brief This class requires VU1 buffer with max buffsize/3 vertices.
* It will clip triangles and fill the buffer.
*
* To be honest clipping algorithm should be moved to VU1 and "AsIs" VU1 program
* should be renamed to "Clip" - I don't want to do it now, too much time.
*/
class StdpipClipper {
public:
StdpipClipper();
~StdpipClipper();
void clip(StdpipQBuffer* buffer);
void init(const RendererSettings& settings);
void setMaxVertCount(const u32& count);
void setMVP(M4x4* mvp);
private:
u32 maxVertCount;
Path1EEClipAlgorithm algorithm;
M4x4* mvp;
void perspectiveDivide(std::vector<Path1ClipVertex>* vertices);
void moveDataToBuffer(const std::vector<Path1ClipVertex>& vertices,
StdpipQBuffer* buffer);
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/std/core/path1/stdpip_program_name.hpp
+31
View File
@@ -0,0 +1,31 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
namespace Tyra {
enum StdpipProgramName {
StdipUndefinedProgram,
StdpipCullColor,
StdpipAsIsColor,
StdpipCullDirLights,
StdpipAsIsDirLights,
StdpipCullTextureDirLights,
StdpipAsIsTextureDirLights,
StdpipCullTextureColor,
StdpipAsIsTextureColor,
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/std/core/path1/stdpip_program_type.hpp
+22
View File
@@ -0,0 +1,22 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
namespace Tyra {
enum StdpipProgramType {
StdpipVU1Color,
StdpipVU1DirLights,
StdpipVU1TextureDirLights,
StdpipVU1TextureColor,
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/std/core/path1/stdpip_programs_repository.hpp
+49
View File
@@ -0,0 +1,49 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "debug/debug.hpp"
#include "renderer/core/paths/path1/vu1_program.hpp"
#include "./programs/as_is/stdpip_as_is_c_vu1_program.hpp"
#include "./programs/as_is/stdpip_as_is_d_vu1_program.hpp"
#include "./programs/as_is/stdpip_as_is_td_vu1_program.hpp"
#include "./programs/as_is/stdpip_as_is_tc_vu1_program.hpp"
#include "./programs/cull/stdpip_cull_c_vu1_program.hpp"
#include "./programs/cull/stdpip_cull_d_vu1_program.hpp"
#include "./programs/cull/stdpip_cull_td_vu1_program.hpp"
#include "./programs/cull/stdpip_cull_tc_vu1_program.hpp"
#include "renderer/core/paths/path1/programs/draw_finish/vu1_draw_finish.hpp"
namespace Tyra {
class StdpipProgramsRepository {
public:
StdpipProgramsRepository();
~StdpipProgramsRepository();
StdpipVU1Program* getProgram(const StdpipProgramName& name);
private:
StdpipAsIsCVU1Program asIsColor;
StdpipCullCVU1Program cullColor;
StdpipAsIsDVU1Program asIsLightingColor;
StdpipCullDVU1Program cullLightingColor;
StdpipAsIsTDVU1Program asIsLightingTextureColor;
StdpipCullTDVU1Program cullLightingTextureColor;
StdpipAsIsTCVU1Program asIsTextureColor;
StdpipCullTCVU1Program cullTextureColor;
VU1DrawFinish drawFinish;
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/std/core/path1/stdpip_qbuffer.hpp
+84
View File
@@ -0,0 +1,84 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include <math3d.h>
#include <string>
#include <sstream>
#include "debug/debug.hpp"
#include "../bag/packaging/stdpip_bag_package.hpp"
#include "../bag/stdpip_bag.hpp"
namespace Tyra {
class StdpipQBuffer {
public:
StdpipQBuffer();
~StdpipQBuffer();
void setMaxVertCount(const u32& count);
/**
* @brief Dont allocate any dynamic data in buffer.
* Just copy pointers to input data.
*/
void fillByPointer(const StdpipBagPackage& pkg);
/**
* @brief Allocate dynamic data in buffer
* And copy input data to it.
*/
void fillByCopyMax(const StdpipBagPackage& pkg1, const StdpipBagPackage& pkg2,
const StdpipBagPackage& pkg3);
/**
* @brief Allocate dynamic data in buffer
* And copy input data to it.
*/
void fillByCopy1By2(const StdpipBagPackage& pkg1,
const StdpipBagPackage& pkg2);
/**
* @brief Allocate dynamic data in buffer
* And copy input data to it.
*/
void fillByCopy1By3(const StdpipBagPackage& pkg);
/**
* @brief Deallocate dynamic data if it was allocated and allocate new data
* specified by size.
* @param size 48 is max
*/
void reallocateManually(const u16& size);
bool any() const;
StdpipBag* bag;
Vec4* vertices;
Vec4* sts;
Vec4* colors;
Vec4* normals;
u32 size;
void print() const;
void print(const char* name) const;
void print(const std::string& name) const { print(name.c_str()); }
std::string getPrint(const char* name = nullptr) const;
private:
u32 maxVertCount;
void deallocateDynamicData();
void allocateDynamicData(u16 size, StdpipBag* bag);
u8 _isDynamicallyAllocated, _stAllocated, _colorAllocated, _normalAllocated;
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/std/core/path1/stdpip_qbuffer_renderer.hpp
+98
View File
@@ -0,0 +1,98 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include <dma.h>
#include <packet2_utils.h>
#include <vector>
#include "debug/debug.hpp"
#include "math/m4x4.hpp"
#include "renderer/renderer_settings.hpp"
#include "renderer/models/color.hpp"
#include "./stdpip_qbuffer.hpp"
#include "./stdpip_program_type.hpp"
#include "./stdpip_program_name.hpp"
#include "./stdpip_programs_repository.hpp"
#include "./stdpip_clipper.hpp"
#include "renderer/core/paths/path1/path1.hpp"
#include "renderer/core/renderer_core.hpp"
#include "renderer/core/texture/renderer_core_texture_buffers.hpp"
namespace Tyra {
class StdpipQBufferRenderer {
public:
StdpipQBufferRenderer();
~StdpipQBufferRenderer();
void init(RendererCore* t_core);
void reinitVU1();
void setClipperMVP(M4x4* mvp) { clipper.setMVP(mvp); }
StdpipQBuffer* getBuffer();
void sendObjectData(StdpipBag* bag, M4x4* mvp,
RendererCoreTextureBuffers* texBuffers) const;
void setMaxVertCount(const u32& count);
void setInfo(StdpipInfoBag* bag);
/** Fast render with culling */
void cull(StdpipQBuffer* buffer);
/** Slower render with clipping */
void clip(StdpipQBuffer* buffer);
void clearLastProgramName();
StdpipVU1Program* getCullProgramByBag(const StdpipBag* bag);
StdpipVU1Program* getCullProgramByParams(const bool& isLightingEnabled,
const bool& isTextureEnabled);
const u16& getBufferSize() { return bufferSize; }
private:
void sendStaticData() const;
void setProgramsCache();
void uploadPrograms();
void setDoubleBuffer();
StdpipVU1Program* getProgramByName(const StdpipProgramName& name);
void addBufferDataToPacket(StdpipVU1Program* program, StdpipQBuffer* buffer);
void sendPacket();
StdpipVU1Program* getAsIsProgramByBag(const StdpipBag* bag);
StdpipVU1Program* getCullProgramByType(const StdpipProgramType& programType);
StdpipProgramType getDrawProgramTypeByBag(const StdpipBag* bag) const;
StdpipProgramType getDrawProgramTypeByParams(
const bool& isLightingEnabled, const bool& isTextureEnabled) const;
packet2_t* packets[2];
packet2_t* programsPacket;
StdpipQBuffer buffers[2];
packet2_t* currentPacket;
packet2_t* staticDataPacket;
packet2_t* objectDataPacket;
RendererCore* rendererCore;
StdpipProgramName lastProgramName;
Path1* path1;
StdpipClipper clipper;
StdpipProgramsRepository repository;
u16 bufferSize;
u8 context;
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/std/core/path1/stdpip_vu1_program.hpp
+50
View File
@@ -0,0 +1,50 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "./stdpip_program_name.hpp"
#include "renderer/core/paths/path1/vu1_program.hpp"
#include "./stdpip_qbuffer.hpp"
#include "./programs/stdpip_vu1_shared_defines.h"
namespace Tyra {
class StdpipVU1Program : public VU1Program {
public:
StdpipVU1Program(const StdpipProgramName& name, u32* start, u32* end,
const u32& t_reglist, const u8& t_reglistCount,
const u8& t_elementsPerVertex);
~StdpipVU1Program();
u32& getReglist();
const StdpipProgramName& getName() const;
u16 getMaxVertCount(const bool& singleColorEnabled,
const u16& vu1DBufferSize) const;
void addBufferDataToPacket(packet2_t* packet, StdpipQBuffer* buffer,
prim_t* prim);
protected:
StdpipProgramName name;
u8 reglistCount, elementsPerVertex;
u32 destinationAddress, reglist;
virtual void addProgramQBufferDataToPacket(packet2_t* packet,
StdpipQBuffer* qbuffer) const = 0;
private:
void addStandardBufferDataToPacket(packet2_t* packet, StdpipQBuffer* buffer,
prim_t* prim);
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/std/core/std_pipeline_core.hpp
+59
View File
@@ -0,0 +1,59 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include <tamtypes.h>
#include "./bag/stdpip_bag.hpp"
#include "./bag/packaging/stdpip_bag_packages_bbox.hpp"
#include "./bag/packaging/stdpip_bag_package.hpp"
#include "./bag/packaging/stdpip_bag_packager.hpp"
#include "./path1/stdpip_qbuffer_renderer.hpp"
namespace Tyra {
class StdPipelineCore {
public:
StdPipelineCore();
~StdPipelineCore();
void init(RendererCore* t_core);
/** Render 3D data via "bags" */
void render(StdpipBag* data, StdpipBagPackagesBBox* bbox = nullptr);
/** Get max vert count of VU1 qbuffer (for optimizations) */
u32 getMaxVertCountByParams(const bool& isSingleColor,
const bool& isLightingEnabled,
const bool& isTextureEnabled);
/** Get max vert count of VU1 qbuffer (for optimizations) */
u32 getMaxVertCountByBag(const StdpipBag* bag);
/**
* - Uploads standard VU1 programs.
* - Sends static "Tyra Renderer3D" VU1 data.
* - Sets double buffers exactly for "Tyra Renderer3D"
* Should be called if VU1 was used by your non standard programs.
*/
void reinitStandardVU1Programs();
private:
u32 maxVertCount;
RendererCore* rendererCore;
void setMaxVertCount(const u32& count);
StdpipBagPackager packager;
StdpipQBufferRenderer qbufferRenderer;
void renderPkgs(StdpipBagPackage* packages, u16 count);
void renderSubpkgs(StdpipBagPackage* packages, u16 count);
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/std/std_pipeline.hpp
+59
View File
@@ -0,0 +1,59 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include <tamtypes.h>
#include "../renderer_3d_pipeline.hpp"
#include "./stdpip_options.hpp"
#include "renderer/core/renderer_core.hpp"
#include "renderer/3d/mesh/mesh.hpp"
#include "./core/std_pipeline_core.hpp"
namespace Tyra {
class StdPipeline : public Renderer3DPipeline {
public:
StdPipeline();
~StdPipeline();
void init(RendererCore* core);
void onUse();
/**
* Render 3D data via "meshes".
* This render() method is a bridge to core.renderer3D.render() method.
*/
void render(Mesh* mesh, const StdpipOptions* options = nullptr);
private:
StdPipelineCore core;
RendererCore* rendererCore;
Vec4* colorsCache;
void addVertices(Mesh* mesh, MeshMaterial* material, StdpipBag* bag,
MeshFrame* frameFrom, MeshFrame* frameTo) const;
StdpipInfoBag* getInfoBag(Mesh* mesh, const StdpipOptions* options,
M4x4* model) const;
StdpipColorBag* getColorBag(Mesh* mesh, MeshMaterial* material,
MeshFrame* frameFrom, MeshFrame* frameTo) const;
StdpipTextureBag* getTextureBag(Mesh* mesh, MeshMaterial* material,
MeshFrame* frameFrom, MeshFrame* frameTo);
StdpipLightingBag* getLightingBag(Mesh* mesh, MeshMaterial* material,
M4x4* model, MeshFrame* frameFrom,
MeshFrame* frameTo,
const StdpipOptions* options) const;
void deallocDrawBags(StdpipBag* bag, MeshMaterial* material) const;
void setLightingColorsCache(StdpipLightingOptions* lightingOptions);
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/std/stdpip_lighting_options.hpp
+44
View File
@@ -0,0 +1,44 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "math/vec4.hpp"
#include "renderer/models/color.hpp"
namespace Tyra {
class StdpipLightingOptions {
public:
StdpipLightingOptions() {}
~StdpipLightingOptions() {}
/**
* Mandatory.
* Default 128.0F, 128.0F, 128.0F, 128.0F
*/
Color* ambientColor;
/**
* Mandatory.
* Min/max length - 3.
* Example color value: 64.0F, 0.0F, 0.0F, 1.0F
*/
Color* directionalColors;
/**
* Mandatory.
* Min/max length - 3.
* Example dir value: 1.0F, 0.0F, 0.0F, 1.0F
*/
Vec4* directionalDirections;
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/std/stdpip_options.hpp
+32
View File
@@ -0,0 +1,32 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "./stdpip_shading_type.hpp"
#include "./stdpip_lighting_options.hpp"
namespace Tyra {
class StdpipOptions {
public:
StdpipOptions() {}
~StdpipOptions() {}
StdpipShadingType shadingType;
bool blendingEnabled;
bool antiAliasingEnabled;
bool noClipChecks;
/** Optional */
StdpipLightingOptions* lighting;
};
} // namespace Tyra
engine/inc/renderer/3d/pipeline/std/stdpip_shading_type.hpp
+20
View File
@@ -0,0 +1,20 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
namespace Tyra {
enum StdpipShadingType {
StdpipShadingFlat,
StdpipShadingGouraud,
};
} // namespace Tyra
engine/inc/renderer/3d/renderer_3d.hpp
+28
View File
@@ -0,0 +1,28 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "./pipeline/renderer_3d_pipeline.hpp"
namespace Tyra {
class Renderer3D {
public:
Renderer3D();
~Renderer3D();
void usePipeline(Renderer3DPipeline* pipeline);
private:
Renderer3DPipeline* currentPipeline;
};
} // namespace Tyra
engine/inc/renderer/core/2d/renderer_core_2d.hpp
+44
View File
@@ -0,0 +1,44 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include "debug/debug.hpp"
#include "renderer/core/2d/sprite/sprite.hpp"
#include "renderer/core/texture/renderer_core_texture_buffers.hpp"
#include "renderer/core/texture/models/texture.hpp"
#include "renderer/renderer_settings.hpp"
#include <packet2_utils.h>
#include <draw2d.h>
namespace Tyra {
class RendererCore2D {
public:
RendererCore2D();
~RendererCore2D();
void init(RendererSettings* settings, clutbuffer_t* clutBuffer);
void render(Sprite* sprite, const RendererCoreTextureBuffers& texBuffers,
Texture* texture);
private:
static const float GS_CENTER;
static const float SCREEN_CENTER;
u8 context;
RendererSettings* settings;
clutbuffer_t* clutBuffer;
packet2_t* packets[2];
texrect_t* rects[2];
};
} // namespace Tyra
engine/inc/renderer/core/2d/sprite/sprite.hpp
+71
View File
@@ -0,0 +1,71 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include <draw_types.h>
#include <draw_buffers.h>
#include "./sprite_mode.hpp"
#include "math/vec2.hpp"
#include "renderer/models/color.hpp"
namespace Tyra {
class Sprite {
public:
Sprite();
~Sprite();
Vec2 position, size;
float scale;
Color color;
// ----
// Getters
// ----
/** Auto generated unique Id. */
inline const u32& getId() const { return id; };
/** Get sprite drawing mode. */
inline const SpriteMode& getMode() const { return mode; };
// ----
// Setters
// ----
/** Set sprite drawing mode. */
void setMode(const SpriteMode& t_val) { mode = t_val; }
// ----
// Other
// ----
/** Flip texture horizontally. */
inline void flipHorizontally(const u8& t_set) { _flipH = t_set; };
/** Flip texture vertically. */
inline void flipVertically(const u8& t_set) { _flipV = t_set; };
/** Check if texture is vertically flipped. */
inline const u8& isFlippedVertically() const { return _flipV; };
/** Check if texture is horizontally flipped. */
inline const u8& isFlippedHorizontally() const { return _flipH; };
private:
u32 id;
SpriteMode mode;
u8 _isSizeSet, _flipH, _flipV;
void setDefaultColor();
void setDefaultLODAndClut();
};
} // namespace Tyra
engine/inc/renderer/core/2d/sprite/sprite_mode.hpp
+17
View File
@@ -0,0 +1,17 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
namespace Tyra {
enum SpriteMode { MODE_STRETCH, MODE_REPEAT };
}
engine/inc/renderer/core/3d/bbox/core_bbox.hpp
+43
View File
@@ -0,0 +1,43 @@
/*
# ______ ____ ___
# | \/ ____| |___|
# | | | \ | |
#-----------------------------------------------------------------------
# Copyright 2022, tyra - https://github.com/h4570/tyra
# Licenced under Apache License 2.0
# Sandro Sobczyński <sandro.sobczynski@gmail.com>
*/
#pragma once
#include <vector>
#include "./core_bbox_frustum.hpp"
#include "math/m4x4.hpp"
#include "math/plane.hpp"
namespace Tyra {
/** Bounding box */
class CoreBBox {
public:
explicit CoreBBox(Vec4* t_vertices, u32* faces, u32 t_count);
explicit CoreBBox(Vec4* t_vertices, u32 t_count);
explicit CoreBBox(Vec4* t_vertices);
explicit CoreBBox(CoreBBox** t_bboxes, const u32& count);
explicit CoreBBox(const std::vector<CoreBBox>& t_bboxes,
const u32& startIndex, const u32& stopIndex);
const Vec4& operator[](const u8& i) { return _vertices[i]; }
const Vec4& getVertex(const u8& i) { return _vertices[i]; }
Vec4* getVertices() { return _vertices; }
void print() const;
void print(const char* name) const;
void print(const std::string& name) const { print(name.c_str()); }
std::string getPrint(const char* name = nullptr) const;
protected:
Vec4 _vertices[8];
};
} // namespace Tyra

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