Turánszki János
1257 lines
45 KiB
C++
1257 lines
45 KiB
C++
#include "stdafx.h"
|
|
|
|
using namespace wi::ecs;
|
|
using namespace wi::scene;
|
|
|
|
enum TEST_TYPE
|
|
{
|
|
HELLOWORLD,
|
|
MODEL,
|
|
EMITTEDPARTICLE1,
|
|
EMITTEDPARTICLE2,
|
|
HAIRPARTICLE,
|
|
LUASCRIPT,
|
|
WATERTEST,
|
|
SHADOWSTEST,
|
|
PHYSICSTEST,
|
|
CLOTHPHYSICSTEST,
|
|
JOBSYSTEMTEST,
|
|
FONTTEST,
|
|
VOLUMETRICTEST,
|
|
SPRITETEST,
|
|
LIGHTMAPBAKETEST,
|
|
NETWORKTEST,
|
|
CONTROLLERTEST,
|
|
INVERSEKINEMATICSTEST,
|
|
INSTANCESTEST,
|
|
CONTAINERPERF,
|
|
};
|
|
|
|
// Controller Test UI Data, info down below will be using Xbox Controller as reference
|
|
wi::SpriteFont
|
|
b_a, b_b, b_x, b_y, // Action Buttons: A, B, X, Y
|
|
b_du, b_dd, b_dl, b_dr, // Directional Buttons: Up, Down, Left, Right
|
|
b_sta, b_bck, // Menu Buttons: Start, Back
|
|
b_lb, b_rb, // Shoulder Buttons: LB, RB
|
|
b_ls, b_rs, // Stick Press Buttons: Left Stick, Right Stick
|
|
t_l, t_r, // Trigger Inputs: LT, RT
|
|
s_l, s_r, // Stick Axes: Left Stick, Right Stick
|
|
i_led; // Controller LED status
|
|
|
|
void Tests::Initialize()
|
|
{
|
|
wi::Application::Initialize();
|
|
|
|
infoDisplay.active = true;
|
|
infoDisplay.watermark = true;
|
|
infoDisplay.fpsinfo = true;
|
|
infoDisplay.resolution = true;
|
|
infoDisplay.heap_allocation_counter = true;
|
|
|
|
renderer.init(canvas);
|
|
renderer.Load();
|
|
|
|
ActivatePath(&renderer);
|
|
}
|
|
|
|
void TestsRenderer::ResizeLayout()
|
|
{
|
|
RenderPath3D::ResizeLayout();
|
|
|
|
float screenW = GetLogicalWidth();
|
|
float screenH = GetLogicalHeight();
|
|
label.SetPos(XMFLOAT2(screenW / 2.f - label.scale.x / 2.f, screenH * 0.95f));
|
|
}
|
|
void TestsRenderer::Load()
|
|
{
|
|
setSSREnabled(false);
|
|
setReflectionsEnabled(true);
|
|
setFXAAEnabled(false);
|
|
|
|
wi::gui::GUI& gui = GetGUI();
|
|
|
|
label.Create("Label1");
|
|
label.SetText("Wicked Engine Test Framework");
|
|
label.font.params.h_align = wi::font::WIFALIGN_CENTER;
|
|
label.SetSize(XMFLOAT2(240,20));
|
|
gui.AddWidget(&label);
|
|
|
|
static wi::audio::Sound sound;
|
|
static wi::audio::SoundInstance soundinstance;
|
|
static wi::gui::Button audioTest;
|
|
static wi::gui::Slider volume;
|
|
static wi::gui::Slider direction;
|
|
|
|
audioTest.Create("AudioTest");
|
|
audioTest.SetText("Play Test Audio");
|
|
audioTest.SetSize(XMFLOAT2(200, 20));
|
|
audioTest.SetPos(XMFLOAT2(10, 110));
|
|
audioTest.OnClick([&](wi::gui::EventArgs args) {
|
|
static bool playing = false;
|
|
|
|
if (!sound.IsValid())
|
|
{
|
|
wi::audio::CreateSound("../Content/models/water.wav", &sound);
|
|
wi::audio::CreateSoundInstance(&sound, &soundinstance);
|
|
wi::audio::SetVolume(volume.GetValue() / 100.0f, &soundinstance);
|
|
}
|
|
|
|
if (playing)
|
|
{
|
|
wi::audio::Stop(&soundinstance);
|
|
audioTest.SetText("Play Test Audio");
|
|
}
|
|
else
|
|
{
|
|
wi::audio::Play(&soundinstance);
|
|
audioTest.SetText("Stop Test Audio");
|
|
}
|
|
|
|
playing = !playing;
|
|
});
|
|
gui.AddWidget(&audioTest);
|
|
|
|
|
|
volume.Create(0, 100, 50, 100, "Volume");
|
|
volume.SetText("Volume: ");
|
|
volume.SetSize(XMFLOAT2(120, 20));
|
|
volume.SetPos(XMFLOAT2(65, 140));
|
|
volume.OnSlide([](wi::gui::EventArgs args) {
|
|
wi::audio::SetVolume(args.fValue / 100.0f, &soundinstance);
|
|
});
|
|
gui.AddWidget(&volume);
|
|
|
|
direction.Create(-1, 1, 0, 10000, "Direction");
|
|
direction.SetText("Direction: ");
|
|
direction.SetSize(XMFLOAT2(120, 20));
|
|
direction.SetPos(XMFLOAT2(65, 170));
|
|
direction.OnSlide([](wi::gui::EventArgs args) {
|
|
wi::audio::SoundInstance3D instance3D;
|
|
instance3D.emitterPos = XMFLOAT3(args.fValue, 0, 0);
|
|
instance3D.listenerPos = XMFLOAT3(0, 0, -0.1f);
|
|
wi::audio::Update3D(&soundinstance, instance3D);
|
|
});
|
|
gui.AddWidget(&direction);
|
|
|
|
testSelector.Create("TestSelector");
|
|
testSelector.SetText("Demo: ");
|
|
testSelector.SetSize(XMFLOAT2(140, 20));
|
|
testSelector.SetPos(XMFLOAT2(50, 220));
|
|
testSelector.AddItem("HelloWorld", HELLOWORLD);
|
|
testSelector.AddItem("Model", MODEL);
|
|
testSelector.AddItem("EmittedParticle 1", EMITTEDPARTICLE1);
|
|
testSelector.AddItem("EmittedParticle 2", EMITTEDPARTICLE2);
|
|
testSelector.AddItem("HairParticle", HAIRPARTICLE);
|
|
testSelector.AddItem("Lua Script", LUASCRIPT);
|
|
testSelector.AddItem("Water Test", WATERTEST);
|
|
testSelector.AddItem("Shadows Test", SHADOWSTEST);
|
|
testSelector.AddItem("Physics Test", PHYSICSTEST);
|
|
testSelector.AddItem("Cloth Physics Test", CLOTHPHYSICSTEST);
|
|
testSelector.AddItem("Job System Test", JOBSYSTEMTEST);
|
|
testSelector.AddItem("Font Test", FONTTEST);
|
|
testSelector.AddItem("Volumetric Test", VOLUMETRICTEST);
|
|
testSelector.AddItem("Sprite Test", SPRITETEST);
|
|
testSelector.AddItem("Lightmap Bake Test", LIGHTMAPBAKETEST);
|
|
testSelector.AddItem("Network Test", NETWORKTEST);
|
|
testSelector.AddItem("Controller Test", CONTROLLERTEST);
|
|
testSelector.AddItem("Inverse Kinematics", INVERSEKINEMATICSTEST);
|
|
testSelector.AddItem("65k Instances", INSTANCESTEST);
|
|
testSelector.AddItem("Container perf", CONTAINERPERF);
|
|
testSelector.SetMaxVisibleItemCount(10);
|
|
testSelector.OnSelect([=](wi::gui::EventArgs args) {
|
|
|
|
// Reset all state that tests might have modified:
|
|
wi::eventhandler::SetVSync(true);
|
|
wi::renderer::SetToDrawGridHelper(false);
|
|
wi::renderer::SetTemporalAAEnabled(false);
|
|
wi::renderer::ClearWorld(wi::scene::GetScene());
|
|
wi::scene::GetScene().weather = WeatherComponent();
|
|
this->ClearSprites();
|
|
this->ClearFonts();
|
|
if (wi::lua::GetLuaState() != nullptr) {
|
|
wi::lua::KillProcesses();
|
|
}
|
|
|
|
// Reset camera position:
|
|
TransformComponent transform;
|
|
transform.Translate(XMFLOAT3(0, 2.f, -4.5f));
|
|
transform.UpdateTransform();
|
|
wi::scene::GetCamera().TransformCamera(transform);
|
|
|
|
float screenW = GetLogicalWidth();
|
|
float screenH = GetLogicalHeight();
|
|
|
|
// Based on combobox selection, start the appropriate test:
|
|
switch (args.userdata)
|
|
{
|
|
case HELLOWORLD:
|
|
{
|
|
// This will spawn a sprite with two textures. The first texture is a color texture and it will be animated.
|
|
// The second texture is a static image of "hello world" written on it
|
|
// Then add some animations to the sprite to get a nice wobbly and color changing effect.
|
|
// You can learn more in the Sprite test in RunSpriteTest() function
|
|
static wi::Sprite sprite;
|
|
sprite = wi::Sprite("images/movingtex.png", "images/HelloWorld.png");
|
|
sprite.params.pos = XMFLOAT3(screenW / 2, screenH / 2, 0);
|
|
sprite.params.siz = XMFLOAT2(200, 100);
|
|
sprite.params.pivot = XMFLOAT2(0.5f, 0.5f);
|
|
sprite.anim.rot = XM_PI / 4.0f;
|
|
sprite.anim.wobbleAnim.amount = XMFLOAT2(0.16f, 0.16f);
|
|
sprite.anim.movingTexAnim.speedX = 0;
|
|
sprite.anim.movingTexAnim.speedY = 3;
|
|
AddSprite(&sprite);
|
|
break;
|
|
}
|
|
case MODEL:
|
|
wi::renderer::SetTemporalAAEnabled(true);
|
|
wi::scene::LoadModel("../Content/models/teapot.wiscene");
|
|
break;
|
|
case EMITTEDPARTICLE1:
|
|
wi::scene::LoadModel("../Content/models/emitter_smoke.wiscene");
|
|
break;
|
|
case EMITTEDPARTICLE2:
|
|
wi::scene::LoadModel("../Content/models/emitter_skinned.wiscene");
|
|
break;
|
|
case HAIRPARTICLE:
|
|
wi::scene::LoadModel("../Content/models/hairparticle_torus.wiscene", XMMatrixTranslation(0, 1, 0));
|
|
break;
|
|
case LUASCRIPT:
|
|
wi::renderer::SetToDrawGridHelper(true);
|
|
wi::lua::RunFile("test_script.lua");
|
|
break;
|
|
case WATERTEST:
|
|
wi::renderer::SetTemporalAAEnabled(true);
|
|
wi::scene::LoadModel("../Content/models/water_test.wiscene", XMMatrixTranslation(0, 1, 0));
|
|
break;
|
|
case SHADOWSTEST:
|
|
wi::renderer::SetTemporalAAEnabled(true);
|
|
wi::scene::LoadModel("../Content/models/shadows_test.wiscene", XMMatrixTranslation(0, 1, 0));
|
|
break;
|
|
case PHYSICSTEST:
|
|
wi::renderer::SetTemporalAAEnabled(true);
|
|
wi::scene::LoadModel("../Content/models/physics_test.wiscene");
|
|
break;
|
|
case CLOTHPHYSICSTEST:
|
|
wi::scene::LoadModel("../Content/models/cloth_test.wiscene", XMMatrixTranslation(0, 3, 4));
|
|
break;
|
|
case JOBSYSTEMTEST:
|
|
RunJobSystemTest();
|
|
break;
|
|
case FONTTEST:
|
|
RunFontTest();
|
|
break;
|
|
case VOLUMETRICTEST:
|
|
wi::renderer::SetTemporalAAEnabled(true);
|
|
wi::scene::LoadModel("../Content/models/volumetric_test.wiscene", XMMatrixTranslation(0, 0, 4));
|
|
break;
|
|
case SPRITETEST:
|
|
RunSpriteTest();
|
|
break;
|
|
case LIGHTMAPBAKETEST:
|
|
wi::eventhandler::SetVSync(false); // turn off vsync if we can to accelerate the baking
|
|
wi::renderer::SetTemporalAAEnabled(true);
|
|
wi::scene::LoadModel("../Content/models/lightmap_bake_test.wiscene", XMMatrixTranslation(0, 0, 4));
|
|
break;
|
|
case NETWORKTEST:
|
|
RunNetworkTest();
|
|
break;
|
|
case CONTROLLERTEST:
|
|
{
|
|
float pos_center_x = screenW / 2, pos_center_y = screenH / 2;
|
|
wi::font::Params baseparams(pos_center_x, pos_center_y, 20, wi::font::WIFALIGN_CENTER, wi::font::WIFALIGN_CENTER);
|
|
baseparams.style = wi::font::AddFontStyle("yumin.ttf");
|
|
|
|
std::string head_textbuild = "This test will check for Controller-1's inputs and it will be displayed down below.";
|
|
head_textbuild += "\nPress Button 2 combined with one of the Trigger Buttons to set the controller's vibration.";
|
|
head_textbuild += "\nStrength of the vibration are controlled by how hard the Trigger Buttons get pressed.";
|
|
head_textbuild += "\nPress Button 3 to switch the controller's LED color, every press will bring different colors.";
|
|
static wi::SpriteFont head(head_textbuild, baseparams);
|
|
head.params.posY = pos_center_y-260.f;
|
|
b_a = wi::SpriteFont("Button 2 (Xbox: A, PS: X)", baseparams);
|
|
b_a.params.posY = pos_center_y-160.f;
|
|
b_a.params.posX = pos_center_x-140.f;
|
|
b_b = wi::SpriteFont("Button 3 (Xbox: B, PS: O)", baseparams);
|
|
b_b.params.posY = b_a.params.posY+30.f;
|
|
b_b.params.posX = b_a.params.posX;
|
|
b_x = wi::SpriteFont("Button 1 (Xbox: X, PS: [])", baseparams);
|
|
b_x.params.posY = b_b.params.posY+30.f;
|
|
b_x.params.posX = b_a.params.posX;
|
|
b_y = wi::SpriteFont("Button 4 (Xbox: Y, PS: △)", baseparams);
|
|
b_y.params.posY = b_x.params.posY+30.f;
|
|
b_y.params.posX = b_a.params.posX;
|
|
b_bck = wi::SpriteFont("Button 9 (Xbox: Back, PS: Share)", baseparams);
|
|
b_bck.params.posY = b_y.params.posY+30.f;
|
|
b_bck.params.posX = b_a.params.posX;
|
|
b_sta = wi::SpriteFont("Button 10 (Xbox: Start, PS: Option)", baseparams);
|
|
b_sta.params.posY = b_bck.params.posY+30.f;
|
|
b_sta.params.posX = b_a.params.posX;
|
|
b_ls = wi::SpriteFont("Button 7 (Left Stick)", baseparams);
|
|
b_ls.params.posY = b_sta.params.posY+30.f;
|
|
b_ls.params.posX = b_a.params.posX;
|
|
b_rs = wi::SpriteFont("Button 8 (Right Stick)", baseparams);
|
|
b_rs.params.posY = b_ls.params.posY+30.f;
|
|
b_rs.params.posX = b_a.params.posX;
|
|
s_l = wi::SpriteFont("", baseparams);
|
|
s_l.params.posY = b_rs.params.posY+30.f;
|
|
s_l.params.posX = b_a.params.posX;
|
|
s_r = wi::SpriteFont("", baseparams);
|
|
s_r.params.posY = s_l.params.posY+30.f;
|
|
s_r.params.posX = b_a.params.posX;
|
|
|
|
b_du = wi::SpriteFont("Button Up", baseparams);
|
|
b_du.params.posY = pos_center_y-160.f;
|
|
b_du.params.posX = pos_center_x+140.f;
|
|
b_dd = wi::SpriteFont("Button Down", baseparams);
|
|
b_dd.params.posY = b_du.params.posY+30.f;
|
|
b_dd.params.posX = b_du.params.posX;
|
|
b_dl = wi::SpriteFont("Button Left", baseparams);
|
|
b_dl.params.posY = b_dd.params.posY+30.f;
|
|
b_dl.params.posX = b_du.params.posX;
|
|
b_dr = wi::SpriteFont("Button Right", baseparams);
|
|
b_dr.params.posY = b_dl.params.posY+30.f;
|
|
b_dr.params.posX = b_du.params.posX;
|
|
b_lb = wi::SpriteFont("Button 5 (Xbox: LB, PS: L1)", baseparams);
|
|
b_lb.params.posY = b_dr.params.posY+30.f;
|
|
b_lb.params.posX = b_du.params.posX;
|
|
b_rb = wi::SpriteFont("Button 6 (Xbox: RB, PS: R1)", baseparams);
|
|
b_rb.params.posY = b_lb.params.posY+30.f;
|
|
b_rb.params.posX = b_du.params.posX;
|
|
t_l = wi::SpriteFont("", baseparams);
|
|
t_l.params.posY = b_rb.params.posY+30.f;
|
|
t_l.params.posX = b_du.params.posX;
|
|
t_r = wi::SpriteFont("", baseparams);
|
|
t_r.params.posY = t_l.params.posY+30.f;
|
|
t_r.params.posX = b_du.params.posX;
|
|
|
|
i_led = wi::SpriteFont("", baseparams);
|
|
i_led.params.posY = s_r.params.posY+30.f;
|
|
|
|
AddFont(&head);
|
|
|
|
AddFont(&b_a);
|
|
AddFont(&b_b);
|
|
AddFont(&b_x);
|
|
AddFont(&b_y);
|
|
AddFont(&b_sta);
|
|
AddFont(&b_bck);
|
|
AddFont(&b_ls);
|
|
AddFont(&b_rs);
|
|
AddFont(&s_l);
|
|
AddFont(&s_r);
|
|
AddFont(&b_du);
|
|
AddFont(&b_dd);
|
|
AddFont(&b_dl);
|
|
AddFont(&b_dr);
|
|
AddFont(&b_lb);
|
|
AddFont(&b_rb);
|
|
AddFont(&t_l);
|
|
AddFont(&t_r);
|
|
|
|
AddFont(&i_led);
|
|
}
|
|
break;
|
|
case INVERSEKINEMATICSTEST:
|
|
{
|
|
Scene scene;
|
|
LoadModel(scene, "../Content/scripts/character_controller/assets/character.wiscene", XMMatrixScaling(2, 2, 2));
|
|
if (scene.humanoids.GetCount() == 0)
|
|
break;
|
|
|
|
HumanoidComponent& humanoid = scene.humanoids[0];
|
|
humanoid.SetLookAtEnabled(false);
|
|
ik_entity = humanoid.bones[(size_t)HumanoidComponent::HumanoidBone::LeftHand];
|
|
if (ik_entity != INVALID_ENTITY)
|
|
{
|
|
InverseKinematicsComponent& ik = scene.inverse_kinematics.Create(ik_entity);
|
|
ik.chain_length = 2; // lower and upper arm included (two parents in hierarchy of hand)
|
|
ik.iteration_count = 5; // precision of ik simulation
|
|
ik.target = CreateEntity();
|
|
scene.transforms.Create(ik.target);
|
|
}
|
|
|
|
// Play walk animation:
|
|
Entity walk = scene.Entity_FindByName("walk");
|
|
AnimationComponent* walk_anim = scene.animations.GetComponent(walk);
|
|
if (walk_anim != nullptr)
|
|
{
|
|
walk_anim->Play();
|
|
}
|
|
|
|
// Add some nice weather, not just black:
|
|
auto& weather = scene.weathers.Create(CreateEntity());
|
|
weather.ambient = XMFLOAT3(0.2f, 0.2f, 0.2f);
|
|
weather.horizon = XMFLOAT3(0.38f, 0.38f, 0.38f);
|
|
weather.zenith = XMFLOAT3(0.42f, 0.42f, 0.42f);
|
|
|
|
wi::scene::GetScene().Merge(scene); // add lodaded scene to global scene
|
|
}
|
|
break;
|
|
|
|
case INSTANCESTEST:
|
|
{
|
|
wi::scene::LoadModel("../Content/models/cube.wiscene");
|
|
wi::profiler::SetEnabled(true);
|
|
Scene& scene = wi::scene::GetScene();
|
|
scene.Entity_CreateLight("testlight", XMFLOAT3(0, 2, -4), XMFLOAT3(1, 1, 1), 4, 10);
|
|
Entity cubeentity = scene.Entity_FindByName("Cube");
|
|
const float scale = 0.06f;
|
|
for (int x = 0; x < 32; ++x)
|
|
{
|
|
for (int y = 0; y < 32; ++y)
|
|
{
|
|
for (int z = 0; z < 64; ++z)
|
|
{
|
|
Entity entity = scene.Entity_Duplicate(cubeentity);
|
|
TransformComponent* transform = scene.transforms.GetComponent(entity);
|
|
transform->Scale(XMFLOAT3(scale, scale, scale));
|
|
transform->Translate(XMFLOAT3(-5.5f + 11 * float(x) / 32.f, -0.5f + 5 * y / 32.f, float(z) * 0.5f));
|
|
}
|
|
}
|
|
}
|
|
scene.Entity_Remove(cubeentity);
|
|
}
|
|
break;
|
|
|
|
case CONTAINERPERF:
|
|
ContainerTest();
|
|
break;
|
|
|
|
default:
|
|
assert(0);
|
|
break;
|
|
}
|
|
|
|
});
|
|
testSelector.SetSelected(0);
|
|
gui.AddWidget(&testSelector);
|
|
|
|
// Set a theme globally:
|
|
{
|
|
wi::Color theme_color_idle = wi::Color(100, 130, 150, 150);
|
|
wi::Color theme_color_focus = wi::Color(100, 180, 200, 200);
|
|
wi::Color dark_point = wi::Color(0, 0, 20, 200); // darker elements will lerp towards this
|
|
wi::gui::Theme theme;
|
|
theme.image.background = true;
|
|
theme.image.blendFlag = wi::enums::BLENDMODE_OPAQUE;
|
|
theme.font.color = wi::Color(160, 240, 250, 255);
|
|
theme.shadow_color = wi::Color(100, 180, 200, 100);
|
|
|
|
theme.tooltipImage = theme.image;
|
|
theme.tooltipImage.color = theme_color_idle;
|
|
theme.tooltipFont = theme.font;
|
|
theme.tooltip_shadow_color = theme.shadow_color;
|
|
|
|
wi::Color theme_color_active = wi::Color::White();
|
|
wi::Color theme_color_deactivating = wi::Color::lerp(theme_color_focus, wi::Color::White(), 0.5f);
|
|
|
|
gui.SetTheme(theme); // set basic params to all states
|
|
|
|
// customize colors for specific states:
|
|
gui.SetColor(theme_color_idle, wi::gui::IDLE);
|
|
gui.SetColor(theme_color_focus, wi::gui::FOCUS);
|
|
gui.SetColor(theme_color_active, wi::gui::ACTIVE);
|
|
gui.SetColor(theme_color_deactivating, wi::gui::DEACTIVATING);
|
|
gui.SetColor(wi::Color::lerp(theme_color_idle, dark_point, 0.7f), wi::gui::WIDGET_ID_WINDOW_BASE);
|
|
|
|
gui.SetColor(wi::Color::lerp(theme_color_idle, dark_point, 0.75f), wi::gui::WIDGET_ID_SLIDER_BASE_IDLE);
|
|
gui.SetColor(wi::Color::lerp(theme_color_idle, dark_point, 0.8f), wi::gui::WIDGET_ID_SLIDER_BASE_FOCUS);
|
|
gui.SetColor(wi::Color::lerp(theme_color_idle, dark_point, 0.85f), wi::gui::WIDGET_ID_SLIDER_BASE_ACTIVE);
|
|
gui.SetColor(wi::Color::lerp(theme_color_idle, dark_point, 0.8f), wi::gui::WIDGET_ID_SLIDER_BASE_DEACTIVATING);
|
|
gui.SetColor(theme_color_idle, wi::gui::WIDGET_ID_SLIDER_KNOB_IDLE);
|
|
gui.SetColor(theme_color_focus, wi::gui::WIDGET_ID_SLIDER_KNOB_FOCUS);
|
|
gui.SetColor(theme_color_active, wi::gui::WIDGET_ID_SLIDER_KNOB_ACTIVE);
|
|
gui.SetColor(theme_color_deactivating, wi::gui::WIDGET_ID_SLIDER_KNOB_DEACTIVATING);
|
|
|
|
gui.SetColor(wi::Color::lerp(theme_color_idle, dark_point, 0.75f), wi::gui::WIDGET_ID_SCROLLBAR_BASE_IDLE);
|
|
gui.SetColor(wi::Color::lerp(theme_color_idle, dark_point, 0.8f), wi::gui::WIDGET_ID_SCROLLBAR_BASE_FOCUS);
|
|
gui.SetColor(wi::Color::lerp(theme_color_idle, dark_point, 0.85f), wi::gui::WIDGET_ID_SCROLLBAR_BASE_ACTIVE);
|
|
gui.SetColor(wi::Color::lerp(theme_color_idle, dark_point, 0.8f), wi::gui::WIDGET_ID_SCROLLBAR_BASE_DEACTIVATING);
|
|
gui.SetColor(theme_color_idle, wi::gui::WIDGET_ID_SCROLLBAR_KNOB_INACTIVE);
|
|
gui.SetColor(theme_color_focus, wi::gui::WIDGET_ID_SCROLLBAR_KNOB_HOVER);
|
|
gui.SetColor(theme_color_active, wi::gui::WIDGET_ID_SCROLLBAR_KNOB_GRABBED);
|
|
|
|
gui.SetColor(wi::Color::lerp(theme_color_idle, dark_point, 0.8f), wi::gui::WIDGET_ID_COMBO_DROPDOWN);
|
|
}
|
|
|
|
RenderPath3D::Load();
|
|
}
|
|
void TestsRenderer::Update(float dt)
|
|
{
|
|
int selected = testSelector.GetSelected();
|
|
uint64_t userdata = testSelector.GetItemUserData(selected);
|
|
|
|
switch (userdata)
|
|
{
|
|
case MODEL:
|
|
{
|
|
Scene& scene = wi::scene::GetScene();
|
|
// teapot_material Base Base_mesh Top Top_mesh editorLight
|
|
wi::ecs::Entity e_teapot_base = scene.Entity_FindByName("Base");
|
|
wi::ecs::Entity e_teapot_top = scene.Entity_FindByName("Top");
|
|
assert(e_teapot_base != wi::ecs::INVALID_ENTITY);
|
|
assert(e_teapot_top != wi::ecs::INVALID_ENTITY);
|
|
TransformComponent* transform_base = scene.transforms.GetComponent(e_teapot_base);
|
|
TransformComponent* transform_top = scene.transforms.GetComponent(e_teapot_top);
|
|
assert(transform_base != nullptr);
|
|
assert(transform_top != nullptr);
|
|
float rotation = dt;
|
|
if (wi::input::Down(wi::input::KEYBOARD_BUTTON_LEFT))
|
|
{
|
|
transform_base->Rotate(XMVectorSet(0,rotation,0,1));
|
|
transform_top->Rotate(XMVectorSet(0,rotation,0,1));
|
|
}
|
|
else if (wi::input::Down(wi::input::KEYBOARD_BUTTON_RIGHT))
|
|
{
|
|
transform_base->Rotate(XMVectorSet(0,-rotation,0,1));
|
|
transform_top->Rotate(XMVectorSet(0,-rotation,0,1));
|
|
}
|
|
}
|
|
break;
|
|
case CONTROLLERTEST:
|
|
{
|
|
// Handle displays of all buttons here, the text will turn to white when the associated button are pressed
|
|
b_a.params.color = (wi::input::Down(wi::input::GAMEPAD_BUTTON_2)) ? wi::Color::White() : wi::Color::Green();
|
|
b_b.params.color = (wi::input::Down(wi::input::GAMEPAD_BUTTON_3)) ? wi::Color::White() : wi::Color::Red();
|
|
b_x.params.color = (wi::input::Down(wi::input::GAMEPAD_BUTTON_1)) ? wi::Color::White() : wi::Color::Cyan();
|
|
b_y.params.color = (wi::input::Down(wi::input::GAMEPAD_BUTTON_4)) ? wi::Color::White() : wi::Color::Yellow();
|
|
b_sta.params.color = (wi::input::Down(wi::input::GAMEPAD_BUTTON_10)) ? wi::Color::White() : wi::Color::Gray();
|
|
b_bck.params.color = (wi::input::Down(wi::input::GAMEPAD_BUTTON_9)) ? wi::Color::White() : wi::Color::Gray();
|
|
b_ls.params.color = (wi::input::Down(wi::input::GAMEPAD_BUTTON_7)) ? wi::Color::White() : wi::Color::Gray();
|
|
b_rs.params.color = (wi::input::Down(wi::input::GAMEPAD_BUTTON_8)) ? wi::Color::White() : wi::Color::Gray();
|
|
b_du.params.color = (wi::input::Down(wi::input::GAMEPAD_BUTTON_UP)) ? wi::Color::White() : wi::Color::Gray();
|
|
b_dd.params.color = (wi::input::Down(wi::input::GAMEPAD_BUTTON_DOWN)) ? wi::Color::White() : wi::Color::Gray();
|
|
b_dl.params.color = (wi::input::Down(wi::input::GAMEPAD_BUTTON_LEFT)) ? wi::Color::White() : wi::Color::Gray();
|
|
b_dr.params.color = (wi::input::Down(wi::input::GAMEPAD_BUTTON_RIGHT)) ? wi::Color::White() : wi::Color::Gray();
|
|
b_lb.params.color = (wi::input::Down(wi::input::GAMEPAD_BUTTON_5)) ? wi::Color::White() : wi::Color::Gray();
|
|
b_rb.params.color = (wi::input::Down(wi::input::GAMEPAD_BUTTON_6)) ? wi::Color::White() : wi::Color::Gray();
|
|
|
|
// Handle displays of triggers and axes, will update the text according to the provided data of the controller
|
|
static std::wstring text_head_axes[] = {L"L Trigger (PS: L2): ", L"R Trigger (PS: R2): ", L"L Stick: ", L"R Stick: "};
|
|
t_l.text = text_head_axes[0]+std::to_wstring(wi::input::GetAnalog(wi::input::GAMEPAD_ANALOG_TRIGGER_L).x);
|
|
t_r.text = text_head_axes[1]+std::to_wstring(wi::input::GetAnalog(wi::input::GAMEPAD_ANALOG_TRIGGER_R).x);
|
|
s_l.text = text_head_axes[2]+
|
|
std::to_wstring(wi::input::GetAnalog(wi::input::GAMEPAD_ANALOG_THUMBSTICK_L).x)+L", "+
|
|
std::to_wstring(wi::input::GetAnalog(wi::input::GAMEPAD_ANALOG_THUMBSTICK_L).y);
|
|
s_r.text = text_head_axes[3]+
|
|
std::to_wstring(wi::input::GetAnalog(wi::input::GAMEPAD_ANALOG_THUMBSTICK_R).x)+L", "+
|
|
std::to_wstring(wi::input::GetAnalog(wi::input::GAMEPAD_ANALOG_THUMBSTICK_R).y);
|
|
|
|
// Handling controller's vibrations and LED color
|
|
static float vibration_multipllier = 0.f;
|
|
static int color_index_set = 0;
|
|
static uint32_t color_sets[] = { wi::Color::Black(), wi::Color::Cyan(), wi::Color::Red(), wi::Color::Green(), wi::Color::Yellow()};
|
|
static std::wstring color_sets_desc[] = {L"Controller LED: None", L"Controller LED: Cyan", L"Controller LED: Red", L"Controller LED: Green", L"Controller LED: Yellow"};
|
|
|
|
if(wi::input::Down(wi::input::GAMEPAD_BUTTON_2)) vibration_multipllier = 1.f;
|
|
else vibration_multipllier = 0.f;
|
|
if(wi::input::Press(wi::input::GAMEPAD_BUTTON_3)){
|
|
color_index_set++;
|
|
if (color_index_set > 4) color_index_set = 0;
|
|
}
|
|
|
|
wi::input::ControllerFeedback feedback;
|
|
feedback.led_color.rgba = color_sets[color_index_set];
|
|
feedback.vibration_left = wi::input::GetAnalog(wi::input::GAMEPAD_ANALOG_TRIGGER_L).x*vibration_multipllier;
|
|
feedback.vibration_right = wi::input::GetAnalog(wi::input::GAMEPAD_ANALOG_TRIGGER_R).x*vibration_multipllier;
|
|
wi::input::SetControllerFeedback(feedback, 0);
|
|
|
|
i_led.text = color_sets_desc[color_index_set];
|
|
i_led.params.color = color_sets[color_index_set];
|
|
}
|
|
break;
|
|
case INVERSEKINEMATICSTEST:
|
|
{
|
|
if (ik_entity != INVALID_ENTITY)
|
|
{
|
|
// Inverse kinematics test:
|
|
Scene& scene = wi::scene::GetScene();
|
|
InverseKinematicsComponent& ik = *scene.inverse_kinematics.GetComponent(ik_entity);
|
|
TransformComponent& target = *scene.transforms.GetComponent(ik.target);
|
|
|
|
// place ik target on a plane intersected by mouse ray:
|
|
wi::primitive::Ray ray = wi::renderer::GetPickRay((long)wi::input::GetPointer().x, (long)wi::input::GetPointer().y, *this);
|
|
XMVECTOR plane = XMVectorSet(0, 0, 1, 0.2f);
|
|
XMVECTOR I = XMPlaneIntersectLine(plane, XMLoadFloat3(&ray.origin), XMLoadFloat3(&ray.origin) + XMLoadFloat3(&ray.direction) * 10000);
|
|
target.ClearTransform();
|
|
XMFLOAT3 _I;
|
|
XMStoreFloat3(&_I, I);
|
|
target.Translate(_I);
|
|
target.UpdateTransform();
|
|
|
|
// draw debug ik target position:
|
|
wi::renderer::RenderablePoint pp;
|
|
pp.position = target.GetPosition();
|
|
pp.color = XMFLOAT4(0, 1, 1, 1);
|
|
pp.size = 0.2f;
|
|
wi::renderer::DrawPoint(pp);
|
|
|
|
pp.position = scene.transforms.GetComponent(ik_entity)->GetPosition();
|
|
pp.color = XMFLOAT4(1, 0, 0, 1);
|
|
pp.size = 0.1f;
|
|
wi::renderer::DrawPoint(pp);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case INSTANCESTEST:
|
|
{
|
|
static wi::Timer timer;
|
|
float sec = (float)timer.elapsed_seconds();
|
|
wi::jobsystem::context ctx;
|
|
wi::jobsystem::Dispatch(ctx, (uint32_t)scene->transforms.GetCount(), 1024, [&](wi::jobsystem::JobArgs args) {
|
|
TransformComponent& transform = scene->transforms[args.jobIndex];
|
|
XMStoreFloat4x4(
|
|
&transform.world,
|
|
transform.GetLocalMatrix() * XMMatrixTranslation(0, std::sin(sec + 20 * (float)args.jobIndex / (float)scene->transforms.GetCount()) * 0.1f, 0)
|
|
);
|
|
});
|
|
scene->materials[0].SetEmissiveColor(XMFLOAT4(1, 1, 1, 1));
|
|
wi::jobsystem::Dispatch(ctx, (uint32_t)scene->objects.GetCount(), 1024, [&](wi::jobsystem::JobArgs args) {
|
|
ObjectComponent& object = scene->objects[args.jobIndex];
|
|
float f = std::pow(std::sin(-sec * 2 + 4 * (float)args.jobIndex / (float)scene->objects.GetCount()) * 0.5f + 0.5f, 32.0f);
|
|
object.emissiveColor = XMFLOAT4(0, 0.25f, 1, f * 3);
|
|
});
|
|
wi::jobsystem::Wait(ctx);
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
RenderPath3D::Update(dt);
|
|
}
|
|
|
|
void TestsRenderer::RunJobSystemTest()
|
|
{
|
|
wi::Timer timer;
|
|
|
|
// This is created to be able to wait on the workload independently from other workload:
|
|
wi::jobsystem::context ctx;
|
|
|
|
// This will simulate going over a big dataset first in a simple loop, then with the Job System and compare timings
|
|
uint32_t itemCount = 1000000;
|
|
std::string ss;
|
|
ss += "Job System performance test:\n";
|
|
ss += "You can find out more in Tests.cpp, RunJobSystemTest() function.\n\n";
|
|
|
|
ss += "wi::jobsystem was created with " + std::to_string(wi::jobsystem::GetThreadCount()) + " worker threads.\n\n";
|
|
|
|
ss += "1) Execute() test:\n";
|
|
|
|
// Serial test
|
|
{
|
|
timer.record();
|
|
wi::helper::Spin(100);
|
|
wi::helper::Spin(100);
|
|
wi::helper::Spin(100);
|
|
wi::helper::Spin(100);
|
|
double time = timer.elapsed();
|
|
ss += "Serial took " + std::to_string(time) + " milliseconds\n";
|
|
}
|
|
// Execute test
|
|
{
|
|
timer.record();
|
|
wi::jobsystem::Execute(ctx, [](wi::jobsystem::JobArgs args){ wi::helper::Spin(100); });
|
|
wi::jobsystem::Execute(ctx, [](wi::jobsystem::JobArgs args){ wi::helper::Spin(100); });
|
|
wi::jobsystem::Execute(ctx, [](wi::jobsystem::JobArgs args){ wi::helper::Spin(100); });
|
|
wi::jobsystem::Execute(ctx, [](wi::jobsystem::JobArgs args){ wi::helper::Spin(100); });
|
|
wi::jobsystem::Wait(ctx);
|
|
double time = timer.elapsed();
|
|
ss += "wi::jobsystem::Execute() took " + std::to_string(time) + " milliseconds\n";
|
|
}
|
|
|
|
ss += "\n2) Dispatch() test:\n";
|
|
|
|
// Simple loop test:
|
|
{
|
|
wi::vector<wi::scene::CameraComponent> dataSet(itemCount);
|
|
timer.record();
|
|
for (uint32_t i = 0; i < itemCount; ++i)
|
|
{
|
|
dataSet[i].UpdateCamera();
|
|
}
|
|
double time = timer.elapsed();
|
|
ss += "Simple loop took " + std::to_string(time) + " milliseconds\n";
|
|
}
|
|
|
|
// Dispatch test:
|
|
{
|
|
wi::vector<wi::scene::CameraComponent> dataSet(itemCount);
|
|
timer.record();
|
|
wi::jobsystem::Dispatch(ctx, itemCount, 1000, [&](wi::jobsystem::JobArgs args) {
|
|
dataSet[args.jobIndex].UpdateCamera();
|
|
});
|
|
wi::jobsystem::Wait(ctx);
|
|
double time = timer.elapsed();
|
|
ss += "wi::jobsystem::Dispatch() took " + std::to_string(time) + " milliseconds\n";
|
|
}
|
|
|
|
static wi::SpriteFont font;
|
|
font = wi::SpriteFont(ss);
|
|
font.params.posX = GetLogicalWidth() / 2;
|
|
font.params.posY = GetLogicalHeight() / 2;
|
|
font.params.h_align = wi::font::WIFALIGN_CENTER;
|
|
font.params.v_align = wi::font::WIFALIGN_CENTER;
|
|
font.params.size = 24;
|
|
this->AddFont(&font);
|
|
}
|
|
void TestsRenderer::RunFontTest()
|
|
{
|
|
static wi::SpriteFont font;
|
|
static wi::SpriteFont font_upscaled;
|
|
|
|
font.SetText("This is Liberation Sans, size 32 wi::font");
|
|
font_upscaled.SetText("This is Liberation Sans, size 14 wi::font, but upscaled to 32");
|
|
|
|
font.params.posX = GetLogicalWidth() / 2.0f;
|
|
font.params.posY = GetLogicalHeight() / 6.0f;
|
|
font.params.size = 32;
|
|
|
|
font_upscaled.params = font.params;
|
|
font_upscaled.params.posY += font.TextHeight();
|
|
|
|
font.params.style = 0; // 0 = default font
|
|
font_upscaled.params.style = 0; // 0 = default font
|
|
font_upscaled.params.size = 14;
|
|
font_upscaled.params.scaling = 32.0f / 14.0f;
|
|
|
|
AddFont(&font);
|
|
AddFont(&font_upscaled);
|
|
|
|
static wi::SpriteFont font_aligned;
|
|
font_aligned = font;
|
|
font_aligned.params.posY += font.TextHeight() * 2;
|
|
font_aligned.params.size = 38;
|
|
font_aligned.params.shadowColor = wi::Color::Red();
|
|
font_aligned.params.h_align = wi::font::WIFALIGN_CENTER;
|
|
font_aligned.params.shadow_softness = 0.1f;
|
|
font_aligned.params.shadow_bolden = 0.5f;
|
|
font_aligned.SetText("Center aligned, red shadow, bigger");
|
|
AddFont(&font_aligned);
|
|
|
|
static wi::SpriteFont font_aligned2;
|
|
font_aligned2 = font_aligned;
|
|
font_aligned2.params.scaling = 0.6f;
|
|
font_aligned2.params.posY += font_aligned.TextHeight();
|
|
font_aligned2.params.shadowColor = wi::Color::Purple();
|
|
font_aligned2.params.h_align = wi::font::WIFALIGN_RIGHT;
|
|
font_aligned2.params.shadow_softness = 1;
|
|
font_aligned2.params.shadow_offset_x = 2;
|
|
font_aligned2.params.shadow_offset_y = 2;
|
|
font_aligned2.SetText("Right aligned, downscaled, purple shadow with offset");
|
|
AddFont(&font_aligned2);
|
|
|
|
static wi::SpriteFont font_japanese;
|
|
font_japanese = font_aligned2;
|
|
font_japanese.params.scaling = 1;
|
|
font_japanese.params.posY += font_aligned2.TextHeight();
|
|
font_japanese.params.style = wi::font::AddFontStyle("yumin.ttf");
|
|
font_japanese.params.shadowColor = wi::Color::Transparent();
|
|
font_japanese.params.h_align = wi::font::WIFALIGN_CENTER;
|
|
font_japanese.params.size = 34;
|
|
font_japanese.SetText("ウィケッドエンジンです。よろしくお願いします。 Привет! (ʘ‿ʘ)");
|
|
AddFont(&font_japanese);
|
|
|
|
static wi::SpriteFont font_colored;
|
|
font_colored.params.color = wi::Color::Cyan();
|
|
font_colored.params.h_align = wi::font::WIFALIGN_CENTER;
|
|
font_colored.params.v_align = wi::font::WIFALIGN_TOP;
|
|
font_colored.params.size = 26;
|
|
font_colored.params.posX = GetLogicalWidth() / 2;
|
|
font_colored.params.posY = font_japanese.params.posY + font_japanese.TextHeight();
|
|
font_colored.SetText("Colored font");
|
|
AddFont(&font_colored);
|
|
|
|
static wi::SpriteFont font_nosdf;
|
|
font_nosdf.params.disableSDFRendering();
|
|
font_nosdf.params.color = wi::Color::White();
|
|
font_nosdf.params.h_align = wi::font::WIFALIGN_CENTER;
|
|
font_nosdf.params.v_align = wi::font::WIFALIGN_TOP;
|
|
font_nosdf.params.size = 24;
|
|
font_nosdf.params.posX = GetLogicalWidth() / 2;
|
|
font_nosdf.params.posY = font_colored.params.posY + font_colored.TextHeight();
|
|
font_nosdf.SetText("SDF rendering disabled for this text.");
|
|
AddFont(&font_nosdf);
|
|
}
|
|
void TestsRenderer::RunSpriteTest()
|
|
{
|
|
const float step = 30;
|
|
const float screenW = GetLogicalWidth();
|
|
const float screenH = GetLogicalHeight();
|
|
const XMFLOAT3 startPos = XMFLOAT3(screenW * 0.3f, screenH * 0.2f, 0);
|
|
wi::image::Params params;
|
|
params.pos = startPos;
|
|
params.siz = XMFLOAT2(128, 128);
|
|
params.pivot = XMFLOAT2(0.5f, 0.5f);
|
|
params.quality = wi::image::QUALITY_LINEAR;
|
|
params.sampleFlag = wi::image::SAMPLEMODE_CLAMP;
|
|
params.blendFlag = wi::enums::BLENDMODE_ALPHA;
|
|
|
|
// Info:
|
|
{
|
|
static wi::SpriteFont font("For more information, please see \nTests.cpp, RunSpriteTest() function.");
|
|
font.params.posX = 10;
|
|
font.params.posY = screenH / 2;
|
|
AddFont(&font);
|
|
}
|
|
|
|
// Simple sprite, no animation:
|
|
{
|
|
static wi::Sprite sprite("../Content/logo_small.png");
|
|
sprite.params = params;
|
|
AddSprite(&sprite);
|
|
|
|
static wi::SpriteFont font("No animation: ");
|
|
font.params.h_align = wi::font::WIFALIGN_CENTER;
|
|
font.params.v_align = wi::font::WIFALIGN_BOTTOM;
|
|
font.params.posX = sprite.params.pos.x;
|
|
font.params.posY = sprite.params.pos.y - sprite.params.siz.y * 0.5f;
|
|
AddFont(&font);
|
|
|
|
params.pos.x += sprite.params.siz.x + step;
|
|
}
|
|
|
|
// Simple sprite, fade animation:
|
|
{
|
|
static wi::Sprite sprite("../Content/logo_small.png");
|
|
sprite.params = params;
|
|
sprite.anim = wi::Sprite::Anim();
|
|
sprite.anim.fad = 1.2f; // (you can also do opacity animation with sprite.anim.opa)
|
|
sprite.anim.repeatable = true;
|
|
AddSprite(&sprite);
|
|
|
|
static wi::SpriteFont font("Fade animation: ");
|
|
font.params.h_align = wi::font::WIFALIGN_CENTER;
|
|
font.params.v_align = wi::font::WIFALIGN_BOTTOM;
|
|
font.params.posX = sprite.params.pos.x;
|
|
font.params.posY = sprite.params.pos.y - sprite.params.siz.y * 0.5f;
|
|
AddFont(&font);
|
|
|
|
params.pos.x += sprite.params.siz.x + step;
|
|
}
|
|
|
|
// Simple sprite, wobble animation:
|
|
{
|
|
static wi::Sprite sprite("../Content/logo_small.png");
|
|
sprite.params = params;
|
|
sprite.anim = wi::Sprite::Anim();
|
|
sprite.anim.wobbleAnim.amount = XMFLOAT2(0.11f, 0.18f);
|
|
sprite.anim.wobbleAnim.speed = 1.4f;
|
|
AddSprite(&sprite);
|
|
|
|
static wi::SpriteFont font("Wobble animation: ");
|
|
font.params.h_align = wi::font::WIFALIGN_CENTER;
|
|
font.params.v_align = wi::font::WIFALIGN_BOTTOM;
|
|
font.params.posX = sprite.params.pos.x;
|
|
font.params.posY = sprite.params.pos.y - sprite.params.siz.y * 0.5f;
|
|
AddFont(&font);
|
|
|
|
params.pos.x += sprite.params.siz.x + step;
|
|
}
|
|
|
|
// Simple sprite, rotate animation:
|
|
{
|
|
static wi::Sprite sprite("../Content/logo_small.png");
|
|
sprite.params = params;
|
|
sprite.anim = wi::Sprite::Anim();
|
|
sprite.anim.rot = 2.8f;
|
|
sprite.anim.repeatable = true;
|
|
AddSprite(&sprite);
|
|
|
|
static wi::SpriteFont font("Rotate animation: ");
|
|
font.params.h_align = wi::font::WIFALIGN_CENTER;
|
|
font.params.v_align = wi::font::WIFALIGN_BOTTOM;
|
|
font.params.posX = sprite.params.pos.x;
|
|
font.params.posY = sprite.params.pos.y - sprite.params.siz.y * 0.5f;
|
|
AddFont(&font);
|
|
|
|
params.pos.x += sprite.params.siz.x + step;
|
|
}
|
|
|
|
// Simple sprite, movingtex:
|
|
{
|
|
static wi::Sprite sprite("images/movingtex.png", "../Content/logo_small.png"); // first param is the texture we will display (and also scroll here). Second param is a mask texture
|
|
// Don't overwrite all params for this, because we want to keep the mask...
|
|
sprite.params.pos = params.pos;
|
|
sprite.params.siz = params.siz;
|
|
sprite.params.pivot = params.pivot;
|
|
sprite.params.color = XMFLOAT4(2, 2, 2, 1); // increase brightness a bit
|
|
sprite.params.sampleFlag = wi::image::SAMPLEMODE_MIRROR; // texcoords will be scrolled out of bounds, so set up a wrap mode other than clamp
|
|
sprite.anim.movingTexAnim.speedX = 0;
|
|
sprite.anim.movingTexAnim.speedY = 2; // scroll the texture vertically. This value is pixels/second. So because our texture here is 1x2 pixels, just scroll it once fully per second with a value of 2
|
|
AddSprite(&sprite);
|
|
|
|
static wi::SpriteFont font("MovingTex + mask: ");
|
|
font.params.h_align = wi::font::WIFALIGN_CENTER;
|
|
font.params.v_align = wi::font::WIFALIGN_BOTTOM;
|
|
font.params.posX = sprite.params.pos.x;
|
|
font.params.posY = sprite.params.pos.y - sprite.params.siz.y * 0.5f;
|
|
AddFont(&font);
|
|
|
|
params.pos.x = startPos.x;
|
|
params.pos.y += sprite.params.siz.y + step * 1.5f;
|
|
}
|
|
|
|
|
|
// Now the spritesheets:
|
|
|
|
// Spritesheet, no anim:
|
|
{
|
|
static wi::Sprite sprite("images/spritesheet_grid.png");
|
|
sprite.params = params; // nothing extra, just display the full spritesheet
|
|
AddSprite(&sprite);
|
|
|
|
static wi::SpriteFont font("Spritesheet: \n(without animation)");
|
|
font.params.h_align = wi::font::WIFALIGN_CENTER;
|
|
font.params.v_align = wi::font::WIFALIGN_BOTTOM;
|
|
font.params.posX = sprite.params.pos.x;
|
|
font.params.posY = sprite.params.pos.y - sprite.params.siz.y * 0.5f;
|
|
AddFont(&font);
|
|
|
|
params.pos.x += sprite.params.siz.x + step;
|
|
}
|
|
|
|
// Spritesheet, single line:
|
|
{
|
|
static wi::Sprite sprite("images/spritesheet_grid.png");
|
|
sprite.params = params;
|
|
sprite.params.enableDrawRect(XMFLOAT4(0, 0, 128, 128)); // drawrect cutout for a 0,0,128,128 pixel rect, this is also the first frame of animation
|
|
sprite.anim = wi::Sprite::Anim();
|
|
sprite.anim.repeatable = true; // enable looping
|
|
sprite.anim.drawRectAnim.frameRate = 3; // 3 FPS, to be easily readable
|
|
sprite.anim.drawRectAnim.frameCount = 4; // animate only a single line horizontally
|
|
AddSprite(&sprite);
|
|
|
|
static wi::SpriteFont font("single line anim: \n(4 frames)");
|
|
font.params.h_align = wi::font::WIFALIGN_CENTER;
|
|
font.params.v_align = wi::font::WIFALIGN_BOTTOM;
|
|
font.params.posX = sprite.params.pos.x;
|
|
font.params.posY = sprite.params.pos.y - sprite.params.siz.y * 0.5f;
|
|
AddFont(&font);
|
|
|
|
params.pos.x += sprite.params.siz.x + step;
|
|
}
|
|
|
|
// Spritesheet, single vertical line:
|
|
{
|
|
static wi::Sprite sprite("images/spritesheet_grid.png");
|
|
sprite.params = params;
|
|
sprite.params.enableDrawRect(XMFLOAT4(0, 0, 128, 128)); // drawrect cutout for a 0,0,128,128 pixel rect, this is also the first frame of animation
|
|
sprite.anim = wi::Sprite::Anim();
|
|
sprite.anim.repeatable = true; // enable looping
|
|
sprite.anim.drawRectAnim.frameRate = 3; // 3 FPS, to be easily readable
|
|
sprite.anim.drawRectAnim.frameCount = 4; // again, specify 4 total frames to loop...
|
|
sprite.anim.drawRectAnim.horizontalFrameCount = 1; // ...but this time, limit the horizontal frame count. This way, we can get it to only animate vertically
|
|
AddSprite(&sprite);
|
|
|
|
static wi::SpriteFont font("single line: \n(4 vertical frames)");
|
|
font.params.h_align = wi::font::WIFALIGN_CENTER;
|
|
font.params.v_align = wi::font::WIFALIGN_BOTTOM;
|
|
font.params.posX = sprite.params.pos.x;
|
|
font.params.posY = sprite.params.pos.y - sprite.params.siz.y * 0.5f;
|
|
AddFont(&font);
|
|
|
|
params.pos.x += sprite.params.siz.x + step;
|
|
}
|
|
|
|
// Spritesheet, multiline:
|
|
{
|
|
static wi::Sprite sprite("images/spritesheet_grid.png");
|
|
sprite.params = params;
|
|
sprite.params.enableDrawRect(XMFLOAT4(0, 0, 128, 128)); // drawrect cutout for a 0,0,128,128 pixel rect, this is also the first frame of animation
|
|
sprite.anim = wi::Sprite::Anim();
|
|
sprite.anim.repeatable = true; // enable looping
|
|
sprite.anim.drawRectAnim.frameRate = 3; // 3 FPS, to be easily readable
|
|
sprite.anim.drawRectAnim.frameCount = 16; // all frames
|
|
sprite.anim.drawRectAnim.horizontalFrameCount = 4; // all horizontal frames
|
|
AddSprite(&sprite);
|
|
|
|
static wi::SpriteFont font("multiline: \n(all 16 frames)");
|
|
font.params.h_align = wi::font::WIFALIGN_CENTER;
|
|
font.params.v_align = wi::font::WIFALIGN_BOTTOM;
|
|
font.params.posX = sprite.params.pos.x;
|
|
font.params.posY = sprite.params.pos.y - sprite.params.siz.y * 0.5f;
|
|
AddFont(&font);
|
|
|
|
params.pos.x += sprite.params.siz.x + step;
|
|
}
|
|
|
|
// Spritesheet, multiline, irregular:
|
|
{
|
|
static wi::Sprite sprite("images/spritesheet_grid.png");
|
|
sprite.params = params;
|
|
sprite.params.enableDrawRect(XMFLOAT4(0, 0, 128, 128)); // drawrect cutout for a 0,0,128,128 pixel rect, this is also the first frame of animation
|
|
sprite.anim = wi::Sprite::Anim();
|
|
sprite.anim.repeatable = true; // enable looping
|
|
sprite.anim.drawRectAnim.frameRate = 3; // 3 FPS, to be easily readable
|
|
sprite.anim.drawRectAnim.frameCount = 14; // NOT all frames, which makes it irregular, so the last line will not contain all horizontal frames
|
|
sprite.anim.drawRectAnim.horizontalFrameCount = 4; // all horizontal frames
|
|
AddSprite(&sprite);
|
|
|
|
static wi::SpriteFont font("irregular multiline: \n(14 frames)");
|
|
font.params.h_align = wi::font::WIFALIGN_CENTER;
|
|
font.params.v_align = wi::font::WIFALIGN_BOTTOM;
|
|
font.params.posX = sprite.params.pos.x;
|
|
font.params.posY = sprite.params.pos.y - sprite.params.siz.y * 0.5f;
|
|
AddFont(&font);
|
|
|
|
params.pos.x = startPos.x;
|
|
params.pos.y += sprite.params.siz.y + step * 1.5f;
|
|
}
|
|
|
|
|
|
|
|
|
|
// And the nice ones:
|
|
|
|
{
|
|
static wi::Sprite sprite("images/fire_001.png");
|
|
sprite.params = params;
|
|
sprite.params.enableDrawRect(XMFLOAT4(0, 0, 192, 192)); // set the draw rect (texture cutout). This will also be the first frame of the animation
|
|
sprite.anim = wi::Sprite::Anim(); // reset animation state
|
|
sprite.anim.drawRectAnim.frameCount = 20; // set the total frame count of the animation
|
|
sprite.anim.drawRectAnim.horizontalFrameCount = 5; // this is a multiline spritesheet, so also set how many maximum frames there are in a line
|
|
sprite.anim.drawRectAnim.frameRate = 40; // animation frames per second
|
|
sprite.anim.repeatable = true; // looping
|
|
AddSprite(&sprite);
|
|
|
|
static wi::SpriteFont font("For the following spritesheets, credits belong to: https://mrbubblewand.wordpress.com/download/");
|
|
font.params.v_align = wi::font::WIFALIGN_BOTTOM;
|
|
font.params.posX = sprite.params.pos.x - sprite.params.siz.x * 0.5f;
|
|
font.params.posY = sprite.params.pos.y - sprite.params.siz.y * 0.5f;
|
|
AddFont(&font);
|
|
|
|
params.pos.x += sprite.params.siz.x + step;
|
|
}
|
|
|
|
{
|
|
static wi::Sprite sprite("images/wind_002.png");
|
|
sprite.params = params;
|
|
sprite.params.enableDrawRect(XMFLOAT4(0, 0, 192, 192));
|
|
sprite.anim = wi::Sprite::Anim();
|
|
sprite.anim.drawRectAnim.frameCount = 30;
|
|
sprite.anim.drawRectAnim.horizontalFrameCount = 5;
|
|
sprite.anim.drawRectAnim.frameRate = 30;
|
|
sprite.anim.repeatable = true;
|
|
AddSprite(&sprite);
|
|
|
|
params.pos.x += sprite.params.siz.x + step;
|
|
}
|
|
|
|
{
|
|
static wi::Sprite sprite("images/water_003.png");
|
|
sprite.params = params;
|
|
sprite.params.enableDrawRect(XMFLOAT4(0, 0, 192, 192));
|
|
sprite.anim = wi::Sprite::Anim();
|
|
sprite.anim.drawRectAnim.frameCount = 50;
|
|
sprite.anim.drawRectAnim.horizontalFrameCount = 5;
|
|
sprite.anim.drawRectAnim.frameRate = 27;
|
|
sprite.anim.repeatable = true;
|
|
AddSprite(&sprite);
|
|
|
|
params.pos.x += sprite.params.siz.x + step;
|
|
}
|
|
|
|
{
|
|
static wi::Sprite sprite("images/earth_001.png");
|
|
sprite.params = params;
|
|
sprite.params.enableDrawRect(XMFLOAT4(0, 0, 192, 192));
|
|
sprite.anim = wi::Sprite::Anim();
|
|
sprite.anim.drawRectAnim.frameCount = 20;
|
|
sprite.anim.drawRectAnim.horizontalFrameCount = 5;
|
|
sprite.anim.drawRectAnim.frameRate = 27;
|
|
sprite.anim.repeatable = true;
|
|
AddSprite(&sprite);
|
|
|
|
params.pos.x += sprite.params.siz.x + step;
|
|
}
|
|
|
|
{
|
|
static wi::Sprite sprite("images/special_001.png");
|
|
sprite.params = params;
|
|
sprite.params.enableDrawRect(XMFLOAT4(0, 0, 192, 192));
|
|
sprite.anim = wi::Sprite::Anim();
|
|
sprite.anim.drawRectAnim.frameCount = 40;
|
|
sprite.anim.drawRectAnim.horizontalFrameCount = 5;
|
|
sprite.anim.drawRectAnim.frameRate = 27;
|
|
sprite.anim.repeatable = true;
|
|
AddSprite(&sprite);
|
|
|
|
params.pos.x += sprite.params.siz.x + step;
|
|
}
|
|
|
|
}
|
|
void TestsRenderer::RunNetworkTest()
|
|
{
|
|
static wi::SpriteFont font;
|
|
|
|
wi::network::Connection connection;
|
|
connection.ipaddress = { 127,0,0,1 }; // localhost
|
|
connection.port = 12345; // just any random port really
|
|
|
|
std::thread sender([&] {
|
|
// Create sender socket:
|
|
wi::network::Socket sock;
|
|
wi::network::CreateSocket(&sock);
|
|
|
|
// Create a text message:
|
|
const char message[] = "Hi, this is a text message sent over the network!\nYou can find out more in Tests.cpp, RunNetworkTest() function.";
|
|
const size_t message_size = sizeof(message);
|
|
|
|
// First, send the text message size:
|
|
wi::network::Send(&sock, &connection, &message_size, sizeof(message_size));
|
|
|
|
// Then send the actual text message:
|
|
wi::network::Send(&sock, &connection, message, message_size);
|
|
|
|
});
|
|
|
|
std::thread receiver([&] {
|
|
// Create receiver socket:
|
|
wi::network::Socket sock;
|
|
wi::network::CreateSocket(&sock);
|
|
|
|
// Listen on the port which the sender uses:
|
|
wi::network::ListenPort(&sock, connection.port);
|
|
|
|
// We can check for incoming messages with CanReceive(). A timeout value can be specified in microseconds
|
|
// to let the function block for some time, otherwise it returns imediately
|
|
// It is not necessary to use this, but the wi::network::Receive() will block until there is a message
|
|
if (wi::network::CanReceive(&sock, 1000000))
|
|
{
|
|
// We know that we want a text message in this simple example, but we don't know the size.
|
|
// We also know that the sender sends the text size before the actual text, so first we will receive the text size:
|
|
size_t message_size;
|
|
wi::network::Connection sender_connection; // this will be filled out with the sender's address
|
|
wi::network::Receive(&sock, &sender_connection, &message_size, sizeof(message_size));
|
|
|
|
if (wi::network::CanReceive(&sock, 1000000))
|
|
{
|
|
// Once we know the text message length, we can receive the message itself:
|
|
char* message = new char[message_size]; // allocate text buffer
|
|
wi::network::Receive(&sock, &sender_connection, message, message_size);
|
|
|
|
// Write the message to the screen:
|
|
font.SetText(message);
|
|
|
|
// delete the message:
|
|
delete[] message;
|
|
}
|
|
else
|
|
{
|
|
font.SetText("Failed to receive the message in time");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
font.SetText("Failed to receive the message length in time");
|
|
}
|
|
|
|
});
|
|
|
|
sender.join();
|
|
receiver.join();
|
|
|
|
font.params.posX = GetLogicalWidth() / 2;
|
|
font.params.posY = GetLogicalHeight() / 2;
|
|
font.params.h_align = wi::font::WIFALIGN_CENTER;
|
|
font.params.v_align = wi::font::WIFALIGN_CENTER;
|
|
font.params.size = 24;
|
|
AddFont(&font);
|
|
}
|
|
void TestsRenderer::ContainerTest()
|
|
{
|
|
wi::Timer timer;
|
|
|
|
const size_t elements = 1000000;
|
|
#define shuffle(i) (i * 345734667877) % 98787546343
|
|
|
|
std::string ss = "Container test for " + std::to_string(elements) + " elements:\n";
|
|
|
|
#if WI_UNORDERED_MAP_TYPE
|
|
std::unordered_map<size_t, size_t> std_map;
|
|
{
|
|
timer.record();
|
|
for (size_t i = 0; i < elements; ++i)
|
|
{
|
|
std_map[shuffle(i)] = i;
|
|
}
|
|
ss += "\nstd::unordered_map insertion: " + std::to_string(timer.elapsed_milliseconds()) + " ms\n";
|
|
|
|
timer.record();
|
|
for (size_t i = 0; i < std_map.size(); ++i)
|
|
{
|
|
std_map[shuffle(i)] = 0;
|
|
}
|
|
ss += "std::unordered_map access: " + std::to_string(timer.elapsed_milliseconds()) + " ms";
|
|
}
|
|
|
|
wi::unordered_map<size_t, size_t> wi_map;
|
|
{
|
|
timer.record();
|
|
for (size_t i = 0; i < elements; ++i)
|
|
{
|
|
wi_map[shuffle(i)] = i;
|
|
}
|
|
ss += "\nwi::unordered_map insertion: " + std::to_string(timer.elapsed_milliseconds()) + " ms\n";
|
|
|
|
timer.record();
|
|
for (size_t i = 0; i < wi_map.size(); ++i)
|
|
{
|
|
wi_map[shuffle(i)] = 0;
|
|
}
|
|
ss += "wi::unordered_map access: " + std::to_string(timer.elapsed_milliseconds()) + " ms\n";
|
|
}
|
|
#else
|
|
ss += "wi::unordered_map implementation uses std::unordered_map. There is nothing to test.";
|
|
#endif // WI_UNORDERED_MAP_TYPE
|
|
|
|
ss += "\n";
|
|
|
|
#if WI_VECTOR_TYPE
|
|
std::vector<CameraComponent> std_vector;
|
|
{
|
|
timer.record();
|
|
for (size_t i = 0; i < elements; ++i)
|
|
{
|
|
std_vector.emplace_back();
|
|
}
|
|
ss += "\nstd::vector append: " + std::to_string(timer.elapsed_milliseconds()) + " ms\n";
|
|
|
|
timer.record();
|
|
for (auto& x : std_vector)
|
|
{
|
|
x.aperture_size = 8;
|
|
}
|
|
ss += "std::vector access: " + std::to_string(timer.elapsed_milliseconds()) + " ms";
|
|
}
|
|
|
|
wi::vector<CameraComponent> wi_vector;
|
|
{
|
|
timer.record();
|
|
for (size_t i = 0; i < elements; ++i)
|
|
{
|
|
wi_vector.emplace_back();
|
|
}
|
|
ss += "\nwi::vector append: " + std::to_string(timer.elapsed_milliseconds()) + " ms\n";
|
|
|
|
timer.record();
|
|
for (auto& x : wi_vector)
|
|
{
|
|
x.aperture_size = 8;
|
|
}
|
|
ss += "wi::vector access: " + std::to_string(timer.elapsed_milliseconds()) + " ms\n";
|
|
}
|
|
#else
|
|
ss += "wi::vector implementation uses std::vector. There is nothing to test.";
|
|
#endif // WI_VECTOR_TYPE
|
|
|
|
static wi::SpriteFont font;
|
|
font = wi::SpriteFont(ss);
|
|
font.params.posX = GetLogicalWidth() / 2;
|
|
font.params.posY = GetLogicalHeight() / 2;
|
|
font.params.h_align = wi::font::WIFALIGN_CENTER;
|
|
font.params.v_align = wi::font::WIFALIGN_CENTER;
|
|
font.params.size = 24;
|
|
this->AddFont(&font);
|
|
}
|