Working on adding Eigen
This commit is contained in:
Vladislav Khorev
parent
c553780b6e
commit
9bfe2bef89
@ -409,6 +409,38 @@ set_target_properties(libzip_external_lib PROPERTIES
|
||||
INTERFACE_LINK_LIBRARIES zlib_external_lib
|
||||
)
|
||||
|
||||
# ===========================================
|
||||
# 5) Eigen (5.0.0.zip → eigen-5.0.0) - HEADER-ONLY
|
||||
# ===========================================
|
||||
set(EIGEN_ARCHIVE "${THIRDPARTY_DIR}/eigen-5.0.0.zip")
|
||||
set(EIGEN_SRC_DIR "${THIRDPARTY_DIR}/eigen-5.0.0")
|
||||
|
||||
if(NOT EXISTS "${EIGEN_ARCHIVE}")
|
||||
log("Downloading Eigen 5.0.0.zip ...")
|
||||
file(DOWNLOAD
|
||||
"https://gitlab.com/libeigen/eigen/-/archive/5.0.0/eigen-5.0.0.zip"
|
||||
"${EIGEN_ARCHIVE}"
|
||||
SHOW_PROGRESS
|
||||
)
|
||||
endif()
|
||||
|
||||
if(NOT EXISTS "${EIGEN_SRC_DIR}/CMakeLists.txt")
|
||||
log("Extracting Eigen 5.0.0.zip ...")
|
||||
execute_process(
|
||||
COMMAND ${CMAKE_COMMAND} -E tar xvf "${EIGEN_ARCHIVE}"
|
||||
WORKING_DIRECTORY "${THIRDPARTY_DIR}"
|
||||
RESULT_VARIABLE _eigen_extract_res
|
||||
)
|
||||
if(NOT _eigen_extract_res EQUAL 0)
|
||||
message(FATAL_ERROR "Failed to extract Eigen archive")
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if(NOT TARGET eigen_external_lib)
|
||||
add_library(eigen_external_lib INTERFACE)
|
||||
target_include_directories(eigen_external_lib INTERFACE "${EIGEN_SRC_DIR}")
|
||||
endif()
|
||||
|
||||
# ===========================================
|
||||
# Основной проект space-game001
|
||||
# ===========================================
|
||||
@ -484,6 +516,7 @@ target_link_libraries(space-game001 PRIVATE
|
||||
libpng_external_lib
|
||||
zlib_external_lib
|
||||
libzip_external_lib
|
||||
eigen_external_lib
|
||||
)
|
||||
|
||||
# Линкуем OpenGL (Windows)
|
||||
|
||||
@ -119,9 +119,9 @@ namespace ZL
|
||||
b = match.suffix().first;
|
||||
}
|
||||
|
||||
bones[i].boneMatrixWorld.m[0] = floatValues[0];
|
||||
bones[i].boneMatrixWorld.m[0 + 1 * 3] = floatValues[1];
|
||||
bones[i].boneMatrixWorld.m[0 + 2 * 3] = floatValues[2];
|
||||
bones[i].boneMatrixWorld.data()[0] = floatValues[0];
|
||||
bones[i].boneMatrixWorld.data()[0 + 1 * 3] = floatValues[1];
|
||||
bones[i].boneMatrixWorld.data()[0 + 2 * 3] = floatValues[2];
|
||||
|
||||
|
||||
std::getline(f, tempLine);
|
||||
@ -134,9 +134,9 @@ namespace ZL
|
||||
b = match.suffix().first;
|
||||
}
|
||||
|
||||
bones[i].boneMatrixWorld.m[1] = floatValues[0];
|
||||
bones[i].boneMatrixWorld.m[1 + 1 * 3] = floatValues[1];
|
||||
bones[i].boneMatrixWorld.m[1 + 2 * 3] = floatValues[2];
|
||||
bones[i].boneMatrixWorld.data()[1] = floatValues[0];
|
||||
bones[i].boneMatrixWorld.data()[1 + 1 * 3] = floatValues[1];
|
||||
bones[i].boneMatrixWorld.data()[1 + 2 * 3] = floatValues[2];
|
||||
|
||||
|
||||
std::getline(f, tempLine);
|
||||
@ -149,9 +149,9 @@ namespace ZL
|
||||
b = match.suffix().first;
|
||||
}
|
||||
|
||||
bones[i].boneMatrixWorld.m[2] = floatValues[0];
|
||||
bones[i].boneMatrixWorld.m[2 + 1 * 3] = floatValues[1];
|
||||
bones[i].boneMatrixWorld.m[2 + 2 * 3] = floatValues[2];
|
||||
bones[i].boneMatrixWorld.data()[2] = floatValues[0];
|
||||
bones[i].boneMatrixWorld.data()[2 + 1 * 3] = floatValues[1];
|
||||
bones[i].boneMatrixWorld.data()[2 + 2 * 3] = floatValues[2];
|
||||
|
||||
//----------- matrix end
|
||||
std::getline(f, tempLine); //parent
|
||||
@ -489,10 +489,10 @@ namespace ZL
|
||||
b = match.suffix().first;
|
||||
}
|
||||
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[0] = floatValues[0];
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[0 + 1 * 4] = floatValues[1];
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[0 + 2 * 4] = floatValues[2];
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[0 + 3 * 4] = floatValues[3];
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[0] = floatValues[0];
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[0 + 1 * 4] = floatValues[1];
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[0 + 2 * 4] = floatValues[2];
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[0 + 3 * 4] = floatValues[3];
|
||||
|
||||
|
||||
std::getline(f, tempLine);
|
||||
@ -504,10 +504,10 @@ namespace ZL
|
||||
b = match.suffix().first;
|
||||
}
|
||||
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[1] = floatValues[0];
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[1 + 1 * 4] = floatValues[1];
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[1 + 2 * 4] = floatValues[2];
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[1 + 3 * 4] = floatValues[3];
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[1] = floatValues[0];
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[1 + 1 * 4] = floatValues[1];
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[1 + 2 * 4] = floatValues[2];
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[1 + 3 * 4] = floatValues[3];
|
||||
|
||||
std::getline(f, tempLine);
|
||||
b = tempLine.cbegin();
|
||||
@ -518,10 +518,10 @@ namespace ZL
|
||||
b = match.suffix().first;
|
||||
}
|
||||
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[2] = floatValues[0];
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[2 + 1 * 4] = floatValues[1];
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[2 + 2 * 4] = floatValues[2];
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[2 + 3 * 4] = floatValues[3];
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[2] = floatValues[0];
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[2 + 1 * 4] = floatValues[1];
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[2 + 2 * 4] = floatValues[2];
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[2 + 3 * 4] = floatValues[3];
|
||||
|
||||
|
||||
std::getline(f, tempLine);
|
||||
@ -533,10 +533,10 @@ namespace ZL
|
||||
b = match.suffix().first;
|
||||
}
|
||||
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[3] = floatValues[0];
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[3 + 1 * 4] = floatValues[1];
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[3 + 2 * 4] = floatValues[2];
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[3 + 3 * 4] = floatValues[3];
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[3] = floatValues[0];
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[3 + 1 * 4] = floatValues[1];
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[3 + 2 * 4] = floatValues[2];
|
||||
animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[3 + 3 * 4] = floatValues[3];
|
||||
|
||||
//std::getline(f, tempLine);// ignore last matrix line
|
||||
|
||||
@ -602,44 +602,48 @@ namespace ZL
|
||||
|
||||
for (int i = 0; i < currentBones.size(); i++)
|
||||
{
|
||||
currentBones[i].boneStartWorld.v[0] = oneFrameBones[i].boneStartWorld.v[0] + t * (nextFrameBones[i].boneStartWorld.v[0] - oneFrameBones[i].boneStartWorld.v[0]);
|
||||
currentBones[i].boneStartWorld.v[1] = oneFrameBones[i].boneStartWorld.v[1] + t * (nextFrameBones[i].boneStartWorld.v[1] - oneFrameBones[i].boneStartWorld.v[1]);
|
||||
currentBones[i].boneStartWorld.v[2] = oneFrameBones[i].boneStartWorld.v[2] + t * (nextFrameBones[i].boneStartWorld.v[2] - oneFrameBones[i].boneStartWorld.v[2]);
|
||||
currentBones[i].boneStartWorld(0) = oneFrameBones[i].boneStartWorld(0) + t * (nextFrameBones[i].boneStartWorld(0) - oneFrameBones[i].boneStartWorld(0));
|
||||
currentBones[i].boneStartWorld(1) = oneFrameBones[i].boneStartWorld(1) + t * (nextFrameBones[i].boneStartWorld(1) - oneFrameBones[i].boneStartWorld(1));
|
||||
currentBones[i].boneStartWorld(2) = oneFrameBones[i].boneStartWorld(2) + t * (nextFrameBones[i].boneStartWorld(2) - oneFrameBones[i].boneStartWorld(2));
|
||||
|
||||
Matrix3f oneFrameBonesMatrix;
|
||||
|
||||
oneFrameBonesMatrix.m[0] = oneFrameBones[i].boneMatrixWorld.m[0];
|
||||
oneFrameBonesMatrix.m[1] = oneFrameBones[i].boneMatrixWorld.m[1];
|
||||
oneFrameBonesMatrix.m[2] = oneFrameBones[i].boneMatrixWorld.m[2];
|
||||
oneFrameBonesMatrix = oneFrameBones[i].boneMatrixWorld.block<3, 3>(0, 0);
|
||||
/*
|
||||
oneFrameBonesMatrix.data()[0] = oneFrameBones[i].boneMatrixWorld.m[0];
|
||||
oneFrameBonesMatrix.data()[1] = oneFrameBones[i].boneMatrixWorld.m[1];
|
||||
oneFrameBonesMatrix.data()[2] = oneFrameBones[i].boneMatrixWorld.m[2];
|
||||
|
||||
oneFrameBonesMatrix.m[3] = oneFrameBones[i].boneMatrixWorld.m[0 + 1*4];
|
||||
oneFrameBonesMatrix.m[4] = oneFrameBones[i].boneMatrixWorld.m[1 + 1*4];
|
||||
oneFrameBonesMatrix.m[5] = oneFrameBones[i].boneMatrixWorld.m[2 + 1*4];
|
||||
|
||||
oneFrameBonesMatrix.m[6] = oneFrameBones[i].boneMatrixWorld.m[0 + 2*4];
|
||||
oneFrameBonesMatrix.m[7] = oneFrameBones[i].boneMatrixWorld.m[1 + 2*4];
|
||||
oneFrameBonesMatrix.m[8] = oneFrameBones[i].boneMatrixWorld.m[2 + 2*4];
|
||||
oneFrameBonesMatrix.data()[3] = oneFrameBones[i].boneMatrixWorld.m[0 + 1*4];
|
||||
oneFrameBonesMatrix.data()[4] = oneFrameBones[i].boneMatrixWorld.m[1 + 1*4];
|
||||
oneFrameBonesMatrix.data()[5] = oneFrameBones[i].boneMatrixWorld.m[2 + 1*4];
|
||||
|
||||
oneFrameBonesMatrix.data()[6] = oneFrameBones[i].boneMatrixWorld.m[0 + 2*4];
|
||||
oneFrameBonesMatrix.data()[7] = oneFrameBones[i].boneMatrixWorld.m[1 + 2*4];
|
||||
oneFrameBonesMatrix.data()[8] = oneFrameBones[i].boneMatrixWorld.m[2 + 2*4];
|
||||
*/
|
||||
Matrix3f nextFrameBonesMatrix;
|
||||
|
||||
nextFrameBonesMatrix.m[0] = nextFrameBones[i].boneMatrixWorld.m[0];
|
||||
nextFrameBonesMatrix.m[1] = nextFrameBones[i].boneMatrixWorld.m[1];
|
||||
nextFrameBonesMatrix.m[2] = nextFrameBones[i].boneMatrixWorld.m[2];
|
||||
nextFrameBonesMatrix = nextFrameBones[i].boneMatrixWorld.block<3, 3>(0, 0);
|
||||
/*
|
||||
nextFrameBonesMatrix.data()[0] = nextFrameBones[i].boneMatrixWorld.m[0];
|
||||
nextFrameBonesMatrix.data()[1] = nextFrameBones[i].boneMatrixWorld.m[1];
|
||||
nextFrameBonesMatrix.data()[2] = nextFrameBones[i].boneMatrixWorld.m[2];
|
||||
|
||||
nextFrameBonesMatrix.m[3] = nextFrameBones[i].boneMatrixWorld.m[0 + 1 * 4];
|
||||
nextFrameBonesMatrix.m[4] = nextFrameBones[i].boneMatrixWorld.m[1 + 1 * 4];
|
||||
nextFrameBonesMatrix.m[5] = nextFrameBones[i].boneMatrixWorld.m[2 + 1 * 4];
|
||||
nextFrameBonesMatrix.data()[3] = nextFrameBones[i].boneMatrixWorld.m[0 + 1 * 4];
|
||||
nextFrameBonesMatrix.data()[4] = nextFrameBones[i].boneMatrixWorld.m[1 + 1 * 4];
|
||||
nextFrameBonesMatrix.data()[5] = nextFrameBones[i].boneMatrixWorld.m[2 + 1 * 4];
|
||||
|
||||
nextFrameBonesMatrix.m[6] = nextFrameBones[i].boneMatrixWorld.m[0 + 2 * 4];
|
||||
nextFrameBonesMatrix.m[7] = nextFrameBones[i].boneMatrixWorld.m[1 + 2 * 4];
|
||||
nextFrameBonesMatrix.m[8] = nextFrameBones[i].boneMatrixWorld.m[2 + 2 * 4];
|
||||
nextFrameBonesMatrix.data()[6] = nextFrameBones[i].boneMatrixWorld.m[0 + 2 * 4];
|
||||
nextFrameBonesMatrix.data()[7] = nextFrameBones[i].boneMatrixWorld.m[1 + 2 * 4];
|
||||
nextFrameBonesMatrix.data()[8] = nextFrameBones[i].boneMatrixWorld.m[2 + 2 * 4];
|
||||
*/
|
||||
Eigen::Quaternionf q1 = MatrixToQuat(oneFrameBonesMatrix);
|
||||
Eigen::Quaternionf q2 = MatrixToQuat(nextFrameBonesMatrix);
|
||||
Eigen::Quaternionf q1_norm = q1.normalized();
|
||||
Eigen::Quaternionf q2_norm = q2.normalized();
|
||||
|
||||
Vector4f q1 = MatrixToQuat(oneFrameBonesMatrix);
|
||||
Vector4f q2 = MatrixToQuat(nextFrameBonesMatrix);
|
||||
Vector4f q1_norm = q1.normalized();
|
||||
Vector4f q2_norm = q2.normalized();
|
||||
|
||||
Vector4f result = slerp(q1_norm, q2_norm, t);
|
||||
Eigen::Quaternionf result = q1_norm.slerp(t, q2_norm);
|
||||
|
||||
Matrix3f boneMatrixWorld3 = QuatToMatrix(result);
|
||||
|
||||
@ -654,36 +658,16 @@ namespace ZL
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
for (int i = 0; i < currentBones.size(); i++)
|
||||
{
|
||||
currentBones[i].boneStartWorld = oneFrameBones[i].boneStartWorld;
|
||||
currentBones[i].boneMatrixWorld = oneFrameBones[i].boneMatrixWorld;
|
||||
//Matrix4f currentBoneMatrixWorld4 = MakeMatrix4x4(currentBones[i].boneMatrixWorld, currentBones[i].boneStartWorld);
|
||||
//Matrix4f startBoneMatrixWorld4 = MakeMatrix4x4(animations[0].keyFrames[0].bones[i].boneMatrixWorld, animations[0].keyFrames[0].bones[i].boneStartWorld);
|
||||
Matrix4f currentBoneMatrixWorld4 = currentBones[i].boneMatrixWorld;
|
||||
Matrix4f startBoneMatrixWorld4 = animations[0].keyFrames[0].bones[i].boneMatrixWorld;
|
||||
Matrix4f inverstedStartBoneMatrixWorld4 = InverseMatrix(startBoneMatrixWorld4);
|
||||
skinningMatrixForEachBone[i] = MultMatrixMatrix(currentBoneMatrixWorld4, inverstedStartBoneMatrixWorld4);
|
||||
|
||||
if (i == 10)
|
||||
{
|
||||
std::cout << i << std::endl;
|
||||
}
|
||||
}*/
|
||||
|
||||
for (int i = 0; i < mesh.PositionData.size(); i++)
|
||||
{
|
||||
Vector4f originalPos = {
|
||||
startMesh.PositionData[i].v[0],
|
||||
startMesh.PositionData[i].v[1],
|
||||
startMesh.PositionData[i].v[2], 1.0};
|
||||
startMesh.PositionData[i](0),
|
||||
startMesh.PositionData[i](1),
|
||||
startMesh.PositionData[i](2), 1.0};
|
||||
|
||||
Vector4f finalPos = Vector4f{0.f, 0.f, 0.f, 0.f};
|
||||
|
||||
bool vMoved = false;
|
||||
//Vector3f finalPos = Vector3f{ 0.f, 0.f, 0.f };
|
||||
|
||||
for (int j = 0; j < MAX_BONE_COUNT; j++)
|
||||
{
|
||||
@ -695,7 +679,7 @@ namespace ZL
|
||||
}
|
||||
}
|
||||
|
||||
if (abs(finalPos.v[0] - originalPos.v[0]) > 1 || abs(finalPos.v[1] - originalPos.v[1]) > 1 || abs(finalPos.v[2] - originalPos.v[2]) > 1)
|
||||
if (abs(finalPos(0) - originalPos(0)) > 1 || abs(finalPos(1) - originalPos(1)) > 1 || abs(finalPos(2) - originalPos(2)) > 1)
|
||||
{
|
||||
|
||||
}
|
||||
@ -705,9 +689,9 @@ namespace ZL
|
||||
finalPos = originalPos;
|
||||
}
|
||||
|
||||
mesh.PositionData[i].v[0] = finalPos.v[0];
|
||||
mesh.PositionData[i].v[1] = finalPos.v[1];
|
||||
mesh.PositionData[i].v[2] = finalPos.v[2];
|
||||
mesh.PositionData[i](0) = finalPos(0);
|
||||
mesh.PositionData[i](1) = finalPos(1);
|
||||
mesh.PositionData[i](2) = finalPos(2);
|
||||
}
|
||||
|
||||
|
||||
|
||||
51
src/Game.cpp
51
src/Game.cpp
@ -19,12 +19,12 @@ namespace ZL
|
||||
|
||||
|
||||
|
||||
Vector4f generateRandomQuaternion(std::mt19937& gen)
|
||||
Eigen::Quaternionf generateRandomQuaternion(std::mt19937& gen)
|
||||
{
|
||||
|
||||
std::normal_distribution<> distrib(0.0, 1.0);
|
||||
|
||||
Vector4f randomQuat = {
|
||||
Eigen::Quaternionf randomQuat = {
|
||||
(float)distrib(gen),
|
||||
(float)distrib(gen),
|
||||
(float)distrib(gen),
|
||||
@ -81,7 +81,7 @@ namespace ZL
|
||||
|
||||
if (accepted)
|
||||
{
|
||||
Vector4f randomQuat = generateRandomQuaternion(gen);
|
||||
Eigen::Quaternionf randomQuat = generateRandomQuaternion(gen);
|
||||
|
||||
Matrix3f randomMatrix = QuatToMatrix(randomQuat);
|
||||
|
||||
@ -92,7 +92,6 @@ namespace ZL
|
||||
}
|
||||
|
||||
if (!accepted) {
|
||||
std::cerr << "Ïðåäóïðåæäåíèå: Íå óäàëîñü ñãåíåðèðîâàòü " << N << " îáúåêòîâ. Ñãåíåðèðîâàíî: " << generatedCount << std::endl;
|
||||
break;
|
||||
}
|
||||
}
|
||||
@ -556,27 +555,21 @@ namespace ZL
|
||||
|
||||
if (Environment::tapDownHold) {
|
||||
|
||||
float diffx = Environment::tapDownCurrentPos.v[0] - Environment::tapDownStartPos.v[0];
|
||||
float diffy = Environment::tapDownCurrentPos.v[1] - Environment::tapDownStartPos.v[1];
|
||||
float diffx = Environment::tapDownCurrentPos(0) - Environment::tapDownStartPos(0);
|
||||
float diffy = Environment::tapDownCurrentPos(1) - Environment::tapDownStartPos(1);
|
||||
|
||||
if (abs(diffy) > 5.0 || abs(diffx) > 5.0) //threshold
|
||||
{
|
||||
|
||||
float rotationPower = sqrtf(diffx * diffx + diffy * diffy);
|
||||
float deltaAlpha = rotationPower * delta * static_cast<float>(M_PI) / 500000.f;
|
||||
|
||||
//std::cout << rotationPower << std::endl;
|
||||
Eigen::Vector3f rotationDirection(diffy, diffx, 0.0f);
|
||||
rotationDirection.normalize(); // Eigen-way нормализация
|
||||
|
||||
float deltaAlpha = rotationPower * delta * M_PI / 500000.f;
|
||||
|
||||
Vector3f rotationDirection = { diffy, diffx, 0 };
|
||||
|
||||
rotationDirection = rotationDirection.normalized();
|
||||
|
||||
Vector4f rotateQuat = {
|
||||
rotationDirection.v[0] * sin(deltaAlpha * 0.5f),
|
||||
rotationDirection.v[1] * sin(deltaAlpha * 0.5f),
|
||||
rotationDirection.v[2] * sin(deltaAlpha * 0.5f),
|
||||
cos(deltaAlpha * 0.5f) };
|
||||
// Создаем кватернион через AngleAxis
|
||||
// Конструктор принимает (угол_в_радианах, ось_вращения)
|
||||
Eigen::Quaternionf rotateQuat(Eigen::AngleAxisf(deltaAlpha, rotationDirection));
|
||||
|
||||
Matrix3f rotateMat = QuatToMatrix(rotateQuat);
|
||||
|
||||
@ -677,8 +670,6 @@ namespace ZL
|
||||
Environment::exitGameLoop = true;
|
||||
}
|
||||
else if (event.type == SDL_MOUSEBUTTONDOWN) {
|
||||
// 1. Îáðàáîòêà íàæàòèÿ êíîïêè ìûøè
|
||||
|
||||
int mx = event.button.x;
|
||||
int my = event.button.y;
|
||||
int uiX = mx;
|
||||
@ -709,16 +700,16 @@ namespace ZL
|
||||
|
||||
if (!uiManager.isUiInteraction()) {
|
||||
Environment::tapDownHold = true;
|
||||
// Êîîðäèíàòû íà÷àëüíîãî íàæàòèÿ
|
||||
Environment::tapDownStartPos.v[0] = mx;
|
||||
Environment::tapDownStartPos.v[1] = my;
|
||||
// Íà÷àëüíàÿ ïîçèöèÿ òàêæå ñòàíîâèòñÿ òåêóùåé
|
||||
Environment::tapDownCurrentPos.v[0] = mx;
|
||||
Environment::tapDownCurrentPos.v[1] = my;
|
||||
|
||||
Environment::tapDownStartPos(0) = mx;
|
||||
Environment::tapDownStartPos(1) = my;
|
||||
|
||||
Environment::tapDownCurrentPos(0) = mx;
|
||||
Environment::tapDownCurrentPos(1) = my;
|
||||
}
|
||||
}
|
||||
else if (event.type == SDL_MOUSEBUTTONUP) {
|
||||
// 2. Îáðàáîòêà îòïóñêàíèÿ êíîïêè ìûøè
|
||||
|
||||
int mx = event.button.x;
|
||||
int my = event.button.y;
|
||||
int uiX = mx;
|
||||
@ -731,7 +722,7 @@ namespace ZL
|
||||
}
|
||||
}
|
||||
else if (event.type == SDL_MOUSEMOTION) {
|
||||
// 3. Îáðàáîòêà ïåðåìåùåíèÿ ìûøè
|
||||
|
||||
int mx = event.motion.x;
|
||||
int my = event.motion.y;
|
||||
int uiX = mx;
|
||||
@ -740,8 +731,8 @@ namespace ZL
|
||||
uiManager.onMouseMove(uiX, uiY);
|
||||
|
||||
if (Environment::tapDownHold && !uiManager.isUiInteraction()) {
|
||||
Environment::tapDownCurrentPos.v[0] = mx;
|
||||
Environment::tapDownCurrentPos.v[1] = my;
|
||||
Environment::tapDownCurrentPos(0) = mx;
|
||||
Environment::tapDownCurrentPos(1) = my;
|
||||
}
|
||||
}
|
||||
else if (event.type == SDL_MOUSEWHEEL) {
|
||||
|
||||
@ -46,13 +46,13 @@ namespace ZL {
|
||||
mesh.data.PositionData.clear();
|
||||
mesh.data.TexCoordData.clear();
|
||||
|
||||
mesh.data.PositionData.push_back({ pos.v[0] - half, pos.v[1] - half, pos.v[2] });
|
||||
mesh.data.PositionData.push_back({ pos.v[0] - half, pos.v[1] + half, pos.v[2] });
|
||||
mesh.data.PositionData.push_back({ pos.v[0] + half, pos.v[1] + half, pos.v[2] });
|
||||
mesh.data.PositionData.push_back({ pos(0) - half, pos(1) - half, pos(2) });
|
||||
mesh.data.PositionData.push_back({ pos(0) - half, pos(1) + half, pos(2) });
|
||||
mesh.data.PositionData.push_back({ pos(0) + half, pos(1) + half, pos(2) });
|
||||
|
||||
mesh.data.PositionData.push_back({ pos.v[0] - half, pos.v[1] - half, pos.v[2] });
|
||||
mesh.data.PositionData.push_back({ pos.v[0] + half, pos.v[1] + half, pos.v[2] });
|
||||
mesh.data.PositionData.push_back({ pos.v[0] + half, pos.v[1] - half, pos.v[2] });
|
||||
mesh.data.PositionData.push_back({ pos(0) - half, pos(1) - half, pos(2) });
|
||||
mesh.data.PositionData.push_back({ pos(0) + half, pos(1) + half, pos(2) });
|
||||
mesh.data.PositionData.push_back({ pos(0) + half, pos(1) - half, pos(2) });
|
||||
|
||||
mesh.data.TexCoordData.push_back({ 0.0f, 0.0f });
|
||||
mesh.data.TexCoordData.push_back({ 0.0f, 1.0f });
|
||||
|
||||
@ -69,7 +69,7 @@ namespace ZL {
|
||||
|
||||
for (const auto& particle : particles) {
|
||||
if (particle.active) {
|
||||
sortedParticles.push_back({ &particle, particle.position.v[2] });
|
||||
sortedParticles.push_back({ &particle, particle.position(2) });
|
||||
}
|
||||
}
|
||||
|
||||
@ -83,22 +83,22 @@ namespace ZL {
|
||||
Vector3f pos = particle.position;
|
||||
float size = particleSize * particle.scale;
|
||||
|
||||
drawPositions.push_back({ pos.v[0] - size, pos.v[1] - size, pos.v[2] });
|
||||
drawPositions.push_back({ pos(0) - size, pos(1) - size, pos(2) });
|
||||
drawTexCoords.push_back({ 0.0f, 0.0f });
|
||||
|
||||
drawPositions.push_back({ pos.v[0] - size, pos.v[1] + size, pos.v[2] });
|
||||
drawPositions.push_back({ pos(0) - size, pos(1) + size, pos(2) });
|
||||
drawTexCoords.push_back({ 0.0f, 1.0f });
|
||||
|
||||
drawPositions.push_back({ pos.v[0] + size, pos.v[1] + size, pos.v[2] });
|
||||
drawPositions.push_back({ pos(0) + size, pos(1) + size, pos(2) });
|
||||
drawTexCoords.push_back({ 1.0f, 1.0f });
|
||||
|
||||
drawPositions.push_back({ pos.v[0] - size, pos.v[1] - size, pos.v[2] });
|
||||
drawPositions.push_back({ pos(0) - size, pos(1) - size, pos(2) });
|
||||
drawTexCoords.push_back({ 0.0f, 0.0f });
|
||||
|
||||
drawPositions.push_back({ pos.v[0] + size, pos.v[1] + size, pos.v[2] });
|
||||
drawPositions.push_back({ pos(0) + size, pos(1) + size, pos(2) });
|
||||
drawTexCoords.push_back({ 1.0f, 1.0f });
|
||||
|
||||
drawPositions.push_back({ pos.v[0] + size, pos.v[1] - size, pos.v[2] });
|
||||
drawPositions.push_back({ pos(0) + size, pos(1) - size, pos(2) });
|
||||
drawTexCoords.push_back({ 1.0f, 0.0f });
|
||||
}
|
||||
|
||||
@ -182,9 +182,9 @@ namespace ZL {
|
||||
Vector3f oldPosition = particle.position;
|
||||
float oldScale = particle.scale;
|
||||
|
||||
particle.position.v[0] += particle.velocity.v[0] * deltaTimeMs / 1000.0f;
|
||||
particle.position.v[1] += particle.velocity.v[1] * deltaTimeMs / 1000.0f;
|
||||
particle.position.v[2] += particle.velocity.v[2] * deltaTimeMs / 1000.0f;
|
||||
particle.position(0) += particle.velocity(0) * deltaTimeMs / 1000.0f;
|
||||
particle.position(1) += particle.velocity(1) * deltaTimeMs / 1000.0f;
|
||||
particle.position(2) += particle.velocity(2) * deltaTimeMs / 1000.0f;
|
||||
|
||||
particle.lifeTime += deltaTimeMs;
|
||||
|
||||
@ -196,9 +196,9 @@ namespace ZL {
|
||||
float lifeRatio = particle.lifeTime / particle.maxLifeTime;
|
||||
particle.scale = 1.0f - lifeRatio * 0.8f;
|
||||
|
||||
if (oldPosition.v[0] != particle.position.v[0] ||
|
||||
oldPosition.v[1] != particle.position.v[1] ||
|
||||
oldPosition.v[2] != particle.position.v[2] ||
|
||||
if (oldPosition(0) != particle.position(0) ||
|
||||
oldPosition(1) != particle.position(1) ||
|
||||
oldPosition(2) != particle.position(2) ||
|
||||
oldScale != particle.scale) {
|
||||
anyChanged = true;
|
||||
}
|
||||
@ -404,8 +404,8 @@ namespace ZL {
|
||||
for (int k = 0; k < count; ++k) {
|
||||
Vector3f randomPoint{ dx(gen), dy(gen), dz(gen) };
|
||||
points.push_back(randomPoint);
|
||||
std::cout << "Random point " << k + 1 << ": [" << randomPoint.v[0]
|
||||
<< ", " << randomPoint.v[1] << ", " << randomPoint.v[2] << "]" << std::endl;
|
||||
std::cout << "Random point " << k + 1 << ": [" << randomPoint(0)
|
||||
<< ", " << randomPoint(1) << ", " << randomPoint(2) << "]" << std::endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -211,15 +211,9 @@ namespace ZL
|
||||
for (int i = 0; i < result.PositionData.size(); i++)
|
||||
{
|
||||
Vector3f tempVec = result.PositionData[i];
|
||||
result.PositionData[i].v[0] = tempVec.v[1];
|
||||
result.PositionData[i].v[1] = tempVec.v[2];
|
||||
result.PositionData[i].v[2] = tempVec.v[0];
|
||||
|
||||
/*
|
||||
tempVec = result.NormalData[i];
|
||||
result.NormalData[i].v[0] = tempVec.v[1];
|
||||
result.NormalData[i].v[1] = tempVec.v[2];
|
||||
result.NormalData[i].v[2] = tempVec.v[0];*/
|
||||
result.PositionData[i](0) = tempVec(1);
|
||||
result.PositionData[i](1) = tempVec(2);
|
||||
result.PositionData[i](2) = tempVec(0);
|
||||
|
||||
}
|
||||
|
||||
@ -369,14 +363,14 @@ namespace ZL
|
||||
for (size_t i = 0; i < result.PositionData.size(); i++)
|
||||
{
|
||||
Vector3f originalPos = result.PositionData[i];
|
||||
result.PositionData[i].v[0] = originalPos.v[1]; // New X = Old Y
|
||||
result.PositionData[i].v[1] = originalPos.v[2]; // New Y = Old Z
|
||||
result.PositionData[i].v[2] = originalPos.v[0]; // New Z = Old X
|
||||
result.PositionData[i](0) = originalPos(1); // New X = Old Y
|
||||
result.PositionData[i](1) = originalPos(2); // New Y = Old Z
|
||||
result.PositionData[i](2) = originalPos(0); // New Z = Old X
|
||||
|
||||
Vector3f originalNorm = result.NormalData[i];
|
||||
result.NormalData[i].v[0] = originalNorm.v[1];
|
||||
result.NormalData[i].v[1] = originalNorm.v[2];
|
||||
result.NormalData[i].v[2] = originalNorm.v[0];
|
||||
result.NormalData[i](0) = originalNorm(1);
|
||||
result.NormalData[i](1) = originalNorm(2);
|
||||
result.NormalData[i](2) = originalNorm(0);
|
||||
}
|
||||
|
||||
std::cout << "Model loaded: " << numberVertices << " verts, " << numberTriangles << " tris." << std::endl;
|
||||
|
||||
@ -169,7 +169,7 @@ namespace ZL {
|
||||
std::vector<int> PlanetData::getTrianglesUnderCameraNew2(const Vector3f& viewerPosition) {
|
||||
const LodLevel& finalLod = planetMeshLods[currentLod];
|
||||
Vector3f shipLocal = viewerPosition - PLANET_CENTER_OFFSET;
|
||||
float currentDist = shipLocal.length();
|
||||
float currentDist = shipLocal.norm();
|
||||
Vector3f targetDir = shipLocal.normalized();
|
||||
|
||||
// Æåëàåìûé ðàäèóñ ïîêðûòèÿ íà ïîâåðõíîñòè ïëàíåòû (â ìåòðàõ/åäèíèöàõ äâèæêà)
|
||||
@ -318,9 +318,9 @@ namespace ZL {
|
||||
// Èñïîëüçóåì îäèí øóì äëÿ âûáîðà ìåæäó ðîçîâûì è æåëòûì
|
||||
Vector3f dir = t.data[i].normalized();
|
||||
float blendFactor = colorPerlin.noise(
|
||||
dir.v[0] * colorFrequency,
|
||||
dir.v[1] * colorFrequency,
|
||||
dir.v[2] * colorFrequency
|
||||
dir(0) * colorFrequency,
|
||||
dir(1) * colorFrequency,
|
||||
dir(2) * colorFrequency
|
||||
);
|
||||
|
||||
// Ïðèâîäèì øóì èç äèàïàçîíà [-1, 1] â [0, 1]
|
||||
@ -328,9 +328,8 @@ namespace ZL {
|
||||
|
||||
// Ëèíåéíàÿ èíòåðïîëÿöèÿ ìåæäó äâóìÿ öâåòàìè
|
||||
Vector3f finalColor;
|
||||
finalColor.v[0] = colorPinkish.v[0] + blendFactor * (colorYellowish.v[0] - colorPinkish.v[0]);
|
||||
finalColor.v[1] = colorPinkish.v[1] + blendFactor * (colorYellowish.v[1] - colorPinkish.v[1]);
|
||||
finalColor.v[2] = colorPinkish.v[2] + blendFactor * (colorYellowish.v[2] - colorPinkish.v[2]);
|
||||
|
||||
finalColor = colorPinkish + blendFactor * (colorYellowish - colorPinkish);
|
||||
|
||||
lod.vertexData.ColorData.push_back(finalColor);
|
||||
}
|
||||
@ -368,9 +367,9 @@ namespace ZL {
|
||||
|
||||
// Ãåíåðèðóåì ID äëÿ áàçîâûõ âåðøèí (ìîæíî èñïîëüçîâàòü èõ êîîðäèíàòû)
|
||||
for (int i = 0; i < 3; ++i) {
|
||||
tri.ids[i] = std::to_string(tri.data[i].v[0]) + "_" +
|
||||
std::to_string(tri.data[i].v[1]) + "_" +
|
||||
std::to_string(tri.data[i].v[2]);
|
||||
tri.ids[i] = std::to_string(tri.data[i](0)) + "_" +
|
||||
std::to_string(tri.data[i](1)) + "_" +
|
||||
std::to_string(tri.data[i](2));
|
||||
}
|
||||
geometry.push_back(tri);
|
||||
}
|
||||
|
||||
@ -15,6 +15,15 @@ namespace ZL {
|
||||
using VertexID = std::string;
|
||||
using V2TMap = std::map<VertexID, std::vector<int>>;
|
||||
|
||||
struct Vector3fComparator {
|
||||
bool operator()(const Eigen::Vector3f& a, const Eigen::Vector3f& b) const {
|
||||
// Ëåêñèêîãðàôè÷åñêîå ñðàâíåíèå (x, çàòåì y, çàòåì z)
|
||||
if (a.x() != b.x()) return a.x() < b.x();
|
||||
if (a.y() != b.y()) return a.y() < b.y();
|
||||
return a.z() < b.z();
|
||||
}
|
||||
};
|
||||
|
||||
VertexID generateEdgeID(const VertexID& id1, const VertexID& id2);
|
||||
|
||||
constexpr static int MAX_LOD_LEVELS = 6;
|
||||
@ -82,7 +91,7 @@ namespace ZL {
|
||||
|
||||
int currentLod; // Ëîãè÷åñêèé òåêóùèé óðîâåíü äåòàëèçàöèè
|
||||
|
||||
std::map<Vector3f, VertexID> initialVertexMap;
|
||||
std::map<Vector3f, VertexID, Vector3fComparator> initialVertexMap;
|
||||
|
||||
// Âíóòðåííèå ìåòîäû ãåíåðàöèè
|
||||
std::vector<Triangle> subdivideTriangles(const std::vector<Triangle>& inputTriangles, float noiseCoeff);
|
||||
|
||||
@ -31,19 +31,13 @@ namespace ZL {
|
||||
Matrix3f rot;
|
||||
|
||||
// Столбец 0: Ось X
|
||||
rot.m[0] = x_axis.v[0];
|
||||
rot.m[3] = x_axis.v[1];
|
||||
rot.m[6] = x_axis.v[2];
|
||||
rot.col(0) = x_axis;
|
||||
|
||||
// Столбец 1: Ось Y
|
||||
rot.m[1] = y_axis.v[0];
|
||||
rot.m[4] = y_axis.v[1];
|
||||
rot.m[7] = y_axis.v[2];
|
||||
rot.col(1) = y_axis;
|
||||
|
||||
// Столбец 2: Ось Z
|
||||
rot.m[2] = z_axis.v[0];
|
||||
rot.m[5] = z_axis.v[1];
|
||||
rot.m[8] = z_axis.v[2];
|
||||
rot.col(2) = z_axis;
|
||||
|
||||
return rot;
|
||||
}
|
||||
@ -135,10 +129,10 @@ namespace ZL {
|
||||
Vector3f rC = MultMatrixVector(mr, tr.data[2]);
|
||||
|
||||
// 3. Вычисляем реальные границы треугольника после поворота
|
||||
float minX = min(rA.v[0], min(rB.v[0], rC.v[0]));
|
||||
float maxX = max(rA.v[0], max(rB.v[0], rC.v[0]));
|
||||
float minY = min(rA.v[1], min(rB.v[1], rC.v[1]));
|
||||
float maxY = max(rA.v[1], max(rB.v[1], rC.v[1]));
|
||||
float minX = min(rA(0), min(rB(0), rC(0)));
|
||||
float maxX = max(rA(0), max(rB(0), rC(0)));
|
||||
float minY = min(rA(1), min(rB(1), rC(1)));
|
||||
float maxY = max(rA(1), max(rB(1), rC(1)));
|
||||
|
||||
|
||||
// Находим центр и размеры
|
||||
@ -165,10 +159,10 @@ namespace ZL {
|
||||
|
||||
|
||||
// Извлекаем нормаль треугольника (это 3-й столбец нашей матрицы вращения)
|
||||
Vector3f planeNormal = { mr.m[2], mr.m[5], mr.m[8] };
|
||||
Vector3f planeNormal = mr.col(2);
|
||||
|
||||
renderer.RenderUniform3fv("uPlanePoint", &tr.data[0].v[0]);
|
||||
renderer.RenderUniform3fv("uPlaneNormal", &planeNormal.v[0]);
|
||||
renderer.RenderUniform3fv("uPlanePoint", tr.data[0].data());
|
||||
renderer.RenderUniform3fv("uPlaneNormal", planeNormal.data());
|
||||
renderer.RenderUniform1f("uMaxHeight", StoneParams::BASE_SCALE * 1.1f); // Соответствует BASE_SCALE + perturbation
|
||||
|
||||
|
||||
@ -267,7 +261,7 @@ namespace ZL {
|
||||
Matrix3f mr = GetRotationForTriangle(tr); // Та же матрица, что и при запекании
|
||||
|
||||
// Позиция камеры (корабля) в мире
|
||||
renderer.RenderUniform3fv("uViewPos", &Environment::shipPosition.v[0]);
|
||||
renderer.RenderUniform3fv("uViewPos", Environment::shipPosition.data());
|
||||
|
||||
//renderer.RenderUniform1f("uHeightScale", 0.08f);
|
||||
renderer.RenderUniform1f("uHeightScale", 0.0f);
|
||||
@ -335,7 +329,7 @@ namespace ZL {
|
||||
|
||||
renderer.RenderUniform1f("uDistanceToPlanetSurface", dist);
|
||||
renderer.RenderUniform1f("uCurrentZFar", currentZFar);
|
||||
renderer.RenderUniform3fv("uViewPos", &Environment::shipPosition.v[0]);
|
||||
renderer.RenderUniform3fv("uViewPos", Environment::shipPosition.data());
|
||||
|
||||
glEnable(GL_CULL_FACE);
|
||||
glCullFace(GL_BACK);
|
||||
@ -399,9 +393,9 @@ namespace ZL {
|
||||
Vector3f color = { 0.0, 0.5, 1.0 };
|
||||
|
||||
|
||||
renderer.RenderUniform3fv("uColor", &color.v[0]);
|
||||
renderer.RenderUniform3fv("uColor", color.data());
|
||||
|
||||
renderer.RenderUniformMatrix4fv("ModelViewMatrix", false, &viewMatrix.m[0]);
|
||||
renderer.RenderUniformMatrix4fv("ModelViewMatrix", false, viewMatrix.data());
|
||||
|
||||
renderer.RenderUniform1f("uDistanceToPlanetSurface", dist);
|
||||
|
||||
|
||||
@ -104,9 +104,9 @@ namespace ZL {
|
||||
|
||||
// Применяем масштабирование
|
||||
for (Vector3f& v : initialVertices) {
|
||||
v.v[0] *= scaleFactors.v[0];
|
||||
v.v[1] *= scaleFactors.v[1];
|
||||
v.v[2] *= scaleFactors.v[2];
|
||||
v(0) *= scaleFactors(0);
|
||||
v(1) *= scaleFactors(1);
|
||||
v(2) *= scaleFactors(2);
|
||||
}
|
||||
|
||||
/*
|
||||
@ -126,7 +126,7 @@ namespace ZL {
|
||||
VertexDataStruct result;
|
||||
// Карта для накопления нормалей по уникальным позициям вершин
|
||||
// (Требует определенного оператора < для Vector3f в ZLMath.h, который у вас есть)
|
||||
std::map<Vector3f, Vector3f> smoothNormalsMap;
|
||||
std::map<Vector3f, Vector3f, Vector3fComparator> smoothNormalsMap;
|
||||
|
||||
// Предварительное заполнение карты нормалями
|
||||
for (const auto& face : faces) {
|
||||
@ -178,18 +178,18 @@ namespace ZL {
|
||||
Vector3f vAxisRaw = vRaw - (uAxis * uProjLen);
|
||||
|
||||
// Длина оси V
|
||||
float vLen = vAxisRaw.length();
|
||||
float vLen = vAxisRaw.norm();
|
||||
|
||||
// Нормализованная ось V
|
||||
Vector3f vAxis = vAxisRaw.normalized();
|
||||
|
||||
// Координаты (u, v) для p1, p2, p3 относительно p1
|
||||
Vector2f uv1 = { 0.0f, 0.0f };
|
||||
Vector2f uv2 = { (p2 - p1).length(), 0.0f }; // p2-p1 вдоль оси U
|
||||
Vector2f uv2 = { (p2 - p1).norm(), 0.0f }; // p2-p1 вдоль оси U
|
||||
Vector2f uv3 = { uProjLen, vLen }; // p3-p1: u-компонента = uProjLen, v-компонента = vLen
|
||||
|
||||
// Находим максимальный размер, чтобы масштабировать в [0, 1]
|
||||
float maxUV = max(uv2.v[0], max(uv3.v[0], uv3.v[1]));
|
||||
float maxUV = max(uv2(0), max(uv3(0), uv3(1)));
|
||||
|
||||
if (maxUV > 0.000001f) {
|
||||
// Масштабируем:
|
||||
@ -326,9 +326,9 @@ namespace ZL {
|
||||
Vector3f p = baseStone.PositionData[j];
|
||||
Vector3f n = baseStone.NormalData[j];
|
||||
|
||||
p.v[0] *= inst.scale.v[0] * scaleModifier;
|
||||
p.v[1] *= inst.scale.v[1] * scaleModifier;
|
||||
p.v[2] *= inst.scale.v[2] * scaleModifier;
|
||||
p(0) *= inst.scale(0) * scaleModifier;
|
||||
p(1) *= inst.scale(1) * scaleModifier;
|
||||
p(2) *= inst.scale(2) * scaleModifier;
|
||||
|
||||
result.data.PositionData.push_back(MultMatrixVector(rotMat, p) + inst.position);
|
||||
result.data.NormalData.push_back(MultMatrixVector(rotMat, n));
|
||||
|
||||
@ -20,7 +20,7 @@ namespace ZL {
|
||||
uint64_t seed;
|
||||
Vector3f position;
|
||||
Vector3f scale;
|
||||
Vector4f rotation;
|
||||
Eigen::Quaternionf rotation;
|
||||
};
|
||||
|
||||
struct StoneGroup {
|
||||
|
||||
@ -50,10 +50,10 @@ namespace ZL {
|
||||
|
||||
Vector2f posTo = center + halfWidthHeight;
|
||||
|
||||
Vector3f pos1 = { posFrom.v[0], posFrom.v[1], zLevel };
|
||||
Vector3f pos2 = { posFrom.v[0], posTo.v[1], zLevel };
|
||||
Vector3f pos3 = { posTo.v[0], posTo.v[1], zLevel };
|
||||
Vector3f pos4 = { posTo.v[0], posFrom.v[1], zLevel };
|
||||
Vector3f pos1 = { posFrom(0), posFrom(1), zLevel };
|
||||
Vector3f pos2 = { posFrom(0), posTo(1), zLevel };
|
||||
Vector3f pos3 = { posTo(0), posTo(1), zLevel };
|
||||
Vector3f pos4 = { posTo(0), posFrom(1), zLevel };
|
||||
|
||||
|
||||
Vector2f texCoordPos1 = { 0.0f, 0.0f };
|
||||
@ -86,16 +86,16 @@ namespace ZL {
|
||||
|
||||
Vector2f posTo = center + halfWidthHeight;
|
||||
|
||||
float sectionWidth = halfWidthHeight.v[0] * 2.f;
|
||||
float sectionWidth = halfWidthHeight(0) * 2.f;
|
||||
|
||||
VertexDataStruct result;
|
||||
|
||||
for (size_t i = 0; i < sectionCount; i++)
|
||||
{
|
||||
Vector3f pos1 = { posFrom.v[0]+sectionWidth*i, posFrom.v[1], zLevel };
|
||||
Vector3f pos2 = { posFrom.v[0] + sectionWidth * i, posTo.v[1], zLevel };
|
||||
Vector3f pos3 = { posTo.v[0] + sectionWidth * i, posTo.v[1], zLevel };
|
||||
Vector3f pos4 = { posTo.v[0] + sectionWidth * i, posFrom.v[1], zLevel };
|
||||
Vector3f pos1 = { posFrom(0)+sectionWidth*i, posFrom(1), zLevel };
|
||||
Vector3f pos2 = { posFrom(0) + sectionWidth * i, posTo(1), zLevel };
|
||||
Vector3f pos3 = { posTo(0) + sectionWidth * i, posTo(1), zLevel };
|
||||
Vector3f pos4 = { posTo(0) + sectionWidth * i, posFrom(1), zLevel };
|
||||
|
||||
result.PositionData.push_back(pos1);
|
||||
result.PositionData.push_back(pos2);
|
||||
@ -362,9 +362,9 @@ namespace ZL {
|
||||
{
|
||||
for (int i = 0; i < PositionData.size(); i++)
|
||||
{
|
||||
auto value = PositionData[i].v[1];
|
||||
PositionData[i].v[1] = PositionData[i].v[2];
|
||||
PositionData[i].v[2] = value;
|
||||
auto value = PositionData[i](1);
|
||||
PositionData[i](1) = PositionData[i](2);
|
||||
PositionData[i](2) = value;
|
||||
}
|
||||
}
|
||||
|
||||
@ -493,11 +493,11 @@ namespace ZL {
|
||||
|
||||
static const std::string ProjectionModelViewMatrixName = "ProjectionModelViewMatrix";
|
||||
|
||||
RenderUniformMatrix4fv(ProjectionModelViewMatrixName, false, &ProjectionModelViewMatrix.m[0]);
|
||||
RenderUniformMatrix4fv(ProjectionModelViewMatrixName, false, ProjectionModelViewMatrix.data());
|
||||
|
||||
static const std::string ModelViewMatrixName = "ModelViewMatrix";
|
||||
|
||||
RenderUniformMatrix4fv(ModelViewMatrixName, false, &modelViewMatrix.m[0]);
|
||||
RenderUniformMatrix4fv(ModelViewMatrixName, false, modelViewMatrix.data());
|
||||
|
||||
}
|
||||
|
||||
@ -533,9 +533,9 @@ namespace ZL {
|
||||
{
|
||||
|
||||
Matrix4f m = Matrix4f::Identity();
|
||||
m.m[12] = p.v[0];
|
||||
m.m[13] = p.v[1];
|
||||
m.m[14] = p.v[2];
|
||||
m.data()[12] = p(0);
|
||||
m.data()[13] = p(1);
|
||||
m.data()[14] = p(2);
|
||||
|
||||
m = ModelviewMatrixStack.top() * m;
|
||||
|
||||
@ -553,9 +553,9 @@ namespace ZL {
|
||||
void Renderer::ScaleMatrix(float scale)
|
||||
{
|
||||
Matrix4f m = Matrix4f::Identity();
|
||||
m.m[0] = scale;
|
||||
m.m[5] = scale;
|
||||
m.m[10] = scale;
|
||||
m.data()[0] = scale;
|
||||
m.data()[5] = scale;
|
||||
m.data()[10] = scale;
|
||||
|
||||
m = ModelviewMatrixStack.top() * m;
|
||||
|
||||
@ -573,9 +573,9 @@ namespace ZL {
|
||||
void Renderer::ScaleMatrix(const Vector3f& scale)
|
||||
{
|
||||
Matrix4f m = Matrix4f::Identity();
|
||||
m.m[0] = scale.v[0];
|
||||
m.m[5] = scale.v[1];
|
||||
m.m[10] = scale.v[2];
|
||||
m.data()[0] = scale(0);
|
||||
m.data()[5] = scale(1);
|
||||
m.data()[10] = scale(2);
|
||||
|
||||
m = ModelviewMatrixStack.top() * m;
|
||||
|
||||
@ -590,23 +590,26 @@ namespace ZL {
|
||||
SetMatrix();
|
||||
}
|
||||
|
||||
void Renderer::RotateMatrix(const Vector4f& q)
|
||||
void Renderer::RotateMatrix(const Eigen::Quaternionf& q)
|
||||
{
|
||||
|
||||
Matrix3f m3 = QuatToMatrix(q);
|
||||
Matrix4f m = Matrix4f::Identity();
|
||||
m.m[0] = m3.m[0];
|
||||
m.m[1] = m3.m[1];
|
||||
m.m[2] = m3.m[2];
|
||||
|
||||
m.m[4] = m3.m[3];
|
||||
m.m[5] = m3.m[4];
|
||||
m.m[6] = m3.m[5];
|
||||
m.block<3, 3>(0, 0) = m3;
|
||||
/*
|
||||
m.m[0] = m3.data()[0];
|
||||
m.m[1] = m3.data()[1];
|
||||
m.m[2] = m3.data()[2];
|
||||
|
||||
m.m[8] = m3.m[6];
|
||||
m.m[9] = m3.m[7];
|
||||
m.m[10] = m3.m[8];
|
||||
m.m[4] = m3.data()[3];
|
||||
m.m[5] = m3.data()[4];
|
||||
m.m[6] = m3.data()[5];
|
||||
|
||||
m.m[8] = m3.data()[6];
|
||||
m.m[9] = m3.data()[7];
|
||||
m.m[10] = m3.data()[8];
|
||||
*/
|
||||
m = ModelviewMatrixStack.top() * m;
|
||||
|
||||
if (ModelviewMatrixStack.size() == 0)
|
||||
@ -624,17 +627,18 @@ namespace ZL {
|
||||
void Renderer::RotateMatrix(const Matrix3f& m3)
|
||||
{
|
||||
Matrix4f m = Matrix4f::Identity();
|
||||
m.m[0] = m3.m[0];
|
||||
m.m[1] = m3.m[1];
|
||||
m.m[2] = m3.m[2];
|
||||
/*m.m[0] = m3.data()[0];
|
||||
m.m[1] = m3.data()[1];
|
||||
m.m[2] = m3.data()[2];
|
||||
|
||||
m.m[4] = m3.m[3];
|
||||
m.m[5] = m3.m[4];
|
||||
m.m[6] = m3.m[5];
|
||||
m.m[4] = m3.data()[3];
|
||||
m.m[5] = m3.data()[4];
|
||||
m.m[6] = m3.data()[5];
|
||||
|
||||
m.m[8] = m3.m[6];
|
||||
m.m[9] = m3.m[7];
|
||||
m.m[10] = m3.m[8];
|
||||
m.m[8] = m3.data()[6];
|
||||
m.m[9] = m3.data()[7];
|
||||
m.m[10] = m3.data()[8];*/
|
||||
m.block<3, 3>(0, 0) = m3;
|
||||
|
||||
m = ModelviewMatrixStack.top() * m;
|
||||
|
||||
@ -818,11 +822,11 @@ namespace ZL {
|
||||
int screenWidth, int screenHeight,
|
||||
int& screenX, int& screenY) {
|
||||
|
||||
Vector4f inx = { objectPos.v[0], objectPos.v[1], objectPos.v[2], 1.0f };
|
||||
Vector4f inx = { objectPos(0), objectPos(1), objectPos(2), 1.0f };
|
||||
Vector4f clipCoords = MultMatrixVector(projectionModelView, inx);
|
||||
|
||||
float ndcX = clipCoords.v[0] / clipCoords.v[3];
|
||||
float ndcY = clipCoords.v[1] / clipCoords.v[3];
|
||||
float ndcX = clipCoords(0) / clipCoords(3);
|
||||
float ndcY = clipCoords(1) / clipCoords(3);
|
||||
|
||||
screenX = (int)((ndcX + 1.0f) * 0.5f * screenWidth);
|
||||
screenY = (int)((1.0f + ndcY) * 0.5f * screenHeight);
|
||||
|
||||
@ -102,7 +102,7 @@ namespace ZL {
|
||||
void TranslateMatrix(const Vector3f& p);
|
||||
void ScaleMatrix(float scale);
|
||||
void ScaleMatrix(const Vector3f& scale);
|
||||
void RotateMatrix(const Vector4f& q);
|
||||
void RotateMatrix(const Eigen::Quaternionf& q);
|
||||
void RotateMatrix(const Matrix3f& m3);
|
||||
void PushSpecialMatrix(const Matrix4f& m);
|
||||
void PopMatrix();
|
||||
|
||||
@ -62,7 +62,7 @@ namespace ZL {
|
||||
float frequency = 7.0f;
|
||||
|
||||
// Получаем значение шума (обычно от -1 до 1)
|
||||
float noiseValue = noise(pos.v[0] * frequency, pos.v[1] * frequency, pos.v[2] * frequency);
|
||||
float noiseValue = noise(pos(0) * frequency, pos(1) * frequency, pos(2) * frequency);
|
||||
|
||||
// Масштабируем: хотим отклонение от 1.0 до 1.1 (примерно)
|
||||
float height = 1.0f + (noiseValue * noiseCoeff);
|
||||
|
||||
@ -5,6 +5,7 @@
|
||||
|
||||
namespace ZL {
|
||||
|
||||
/*
|
||||
Vector2f operator+(const Vector2f& x, const Vector2f& y)
|
||||
{
|
||||
Vector2f result;
|
||||
@ -24,7 +25,8 @@ namespace ZL {
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
*/
|
||||
/*
|
||||
Vector3f operator+(const Vector3f& x, const Vector3f& y)
|
||||
{
|
||||
Vector3f result;
|
||||
@ -54,7 +56,8 @@ namespace ZL {
|
||||
result.v[2] = -x.v[2];
|
||||
return result;
|
||||
}
|
||||
|
||||
*/
|
||||
/*
|
||||
Vector4f operator+(const Vector4f& x, const Vector4f& y)
|
||||
{
|
||||
Vector4f result;
|
||||
@ -97,8 +100,8 @@ namespace ZL {
|
||||
|
||||
return r;
|
||||
|
||||
}
|
||||
|
||||
}*/
|
||||
/*
|
||||
Matrix4f Matrix4f::Identity()
|
||||
{
|
||||
Matrix4f r;
|
||||
@ -125,8 +128,8 @@ namespace ZL {
|
||||
|
||||
return r;
|
||||
|
||||
}
|
||||
|
||||
}*/
|
||||
/*
|
||||
Matrix4f operator*(const Matrix4f& m1, const Matrix4f& m2)
|
||||
{
|
||||
Matrix4f r;
|
||||
@ -153,7 +156,7 @@ namespace ZL {
|
||||
r.m[15] = m1.m[3] * m2.m[12] + m1.m[7] * m2.m[13] + m1.m[11] * m2.m[14] + m1.m[15] * m2.m[15];
|
||||
|
||||
return r;
|
||||
}
|
||||
}*/
|
||||
|
||||
Matrix4f MakeOrthoMatrix(float width, float height, float zNear, float zFar)
|
||||
{
|
||||
@ -166,25 +169,25 @@ namespace ZL {
|
||||
|
||||
Matrix4f r;
|
||||
|
||||
r.m[0] = 2.f / width;
|
||||
r.m[1] = 0;
|
||||
r.m[2] = 0;
|
||||
r.m[3] = 0;
|
||||
r.data()[0] = 2.f / width;
|
||||
r.data()[1] = 0;
|
||||
r.data()[2] = 0;
|
||||
r.data()[3] = 0;
|
||||
|
||||
r.m[4] = 0;
|
||||
r.m[5] = 2.f / height;
|
||||
r.m[6] = 0;
|
||||
r.m[7] = 0;
|
||||
r.data()[4] = 0;
|
||||
r.data()[5] = 2.f / height;
|
||||
r.data()[6] = 0;
|
||||
r.data()[7] = 0;
|
||||
|
||||
r.m[8] = 0;
|
||||
r.m[9] = 0;
|
||||
r.m[10] = -1 / depthRange;
|
||||
r.m[11] = 0;
|
||||
r.data()[8] = 0;
|
||||
r.data()[9] = 0;
|
||||
r.data()[10] = -1 / depthRange;
|
||||
r.data()[11] = 0;
|
||||
|
||||
r.m[12] = -1;
|
||||
r.m[13] = -1;
|
||||
r.m[14] = zNear / depthRange;
|
||||
r.m[15] = 1;
|
||||
r.data()[12] = -1;
|
||||
r.data()[13] = -1;
|
||||
r.data()[14] = zNear / depthRange;
|
||||
r.data()[15] = 1;
|
||||
|
||||
return r;
|
||||
}
|
||||
@ -203,20 +206,20 @@ namespace ZL {
|
||||
Matrix4f r;
|
||||
|
||||
// Масштабирование
|
||||
r.m[0] = 2.f / width;
|
||||
r.m[5] = 2.f / height;
|
||||
r.m[10] = -1.f / depthRange;
|
||||
r.data()[0] = 2.f / width;
|
||||
r.data()[5] = 2.f / height;
|
||||
r.data()[10] = -1.f / depthRange;
|
||||
|
||||
// Обнуление неиспользуемых компонентов
|
||||
r.m[1] = r.m[2] = r.m[3] = 0;
|
||||
r.m[4] = r.m[6] = r.m[7] = 0;
|
||||
r.m[8] = r.m[9] = r.m[11] = 0;
|
||||
r.data()[1] = r.data()[2] = r.data()[3] = 0;
|
||||
r.data()[4] = r.data()[6] = r.data()[7] = 0;
|
||||
r.data()[8] = r.data()[9] = r.data()[11] = 0;
|
||||
|
||||
// Трансляция (смещение)
|
||||
r.m[12] = -(xmax + xmin) / width;
|
||||
r.m[13] = -(ymax + ymin) / height;
|
||||
r.m[14] = zNear / depthRange;
|
||||
r.m[15] = 1.f;
|
||||
r.data()[12] = -(xmax + xmin) / width;
|
||||
r.data()[13] = -(ymax + ymin) / height;
|
||||
r.data()[14] = zNear / depthRange;
|
||||
r.data()[15] = 1.f;
|
||||
|
||||
return r;
|
||||
}
|
||||
@ -231,158 +234,60 @@ namespace ZL {
|
||||
throw std::runtime_error("Invalid perspective parameters");
|
||||
}
|
||||
|
||||
r.m[0] = 1.f / (aspectRatio * tanHalfFovy);
|
||||
r.m[1] = 0;
|
||||
r.m[2] = 0;
|
||||
r.m[3] = 0;
|
||||
r.data()[0] = 1.f / (aspectRatio * tanHalfFovy);
|
||||
r.data()[1] = 0;
|
||||
r.data()[2] = 0;
|
||||
r.data()[3] = 0;
|
||||
|
||||
r.m[4] = 0;
|
||||
r.m[5] = 1.f / (tanHalfFovy);
|
||||
r.m[6] = 0;
|
||||
r.m[7] = 0;
|
||||
r.data()[4] = 0;
|
||||
r.data()[5] = 1.f / (tanHalfFovy);
|
||||
r.data()[6] = 0;
|
||||
r.data()[7] = 0;
|
||||
|
||||
r.m[8] = 0;
|
||||
r.m[9] = 0;
|
||||
r.m[10] = -(zFar + zNear) / (zFar - zNear);
|
||||
r.m[11] = -1;
|
||||
r.data()[8] = 0;
|
||||
r.data()[9] = 0;
|
||||
r.data()[10] = -(zFar + zNear) / (zFar - zNear);
|
||||
r.data()[11] = -1;
|
||||
|
||||
r.m[12] = 0;
|
||||
r.m[13] = 0;
|
||||
r.m[14] = -(2.f * zFar * zNear) / (zFar - zNear);
|
||||
r.m[15] = 0;
|
||||
r.data()[12] = 0;
|
||||
r.data()[13] = 0;
|
||||
r.data()[14] = -(2.f * zFar * zNear) / (zFar - zNear);
|
||||
r.data()[15] = 0;
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
Matrix3f QuatToMatrix(const Vector4f& q)
|
||||
Matrix3f QuatToMatrix(const Eigen::Quaternionf& q)
|
||||
{
|
||||
Matrix3f m;
|
||||
|
||||
float wx, wy, wz, xx, yy, yz, xy, xz, zz, s, x2, y2, z2;
|
||||
|
||||
s = 2.0f / (q.v[0] * q.v[0] + q.v[1] * q.v[1] + q.v[2] * q.v[2] + q.v[3] * q.v[3]);
|
||||
|
||||
|
||||
x2 = q.v[0] * s;
|
||||
y2 = q.v[1] * s;
|
||||
z2 = q.v[2] * s;
|
||||
|
||||
wx = q.v[3] * x2; wy = q.v[3] * y2; wz = q.v[3] * z2;
|
||||
xx = q.v[0] * x2; xy = q.v[1] * x2; xz = q.v[2] * x2;
|
||||
yy = q.v[1] * y2; yz = q.v[2] * y2;
|
||||
zz = q.v[2] * z2;
|
||||
|
||||
m.m[0] = 1.0f - (yy + zz);
|
||||
m.m[1] = xy + wz;
|
||||
m.m[2] = xz - wy;
|
||||
|
||||
m.m[3] = xy - wz;
|
||||
m.m[4] = 1.0f - (xx + zz);
|
||||
m.m[5] = yz + wx;
|
||||
|
||||
m.m[6] = xz + wy;
|
||||
m.m[7] = yz - wx;
|
||||
m.m[8] = 1.0f - (xx + yy);
|
||||
|
||||
return m;
|
||||
return q.toRotationMatrix();
|
||||
|
||||
}
|
||||
|
||||
Vector4f MatrixToQuat(const Matrix3f& m)
|
||||
Eigen::Quaternionf MatrixToQuat(const Matrix3f& m)
|
||||
{
|
||||
Vector4f r;
|
||||
float trace = m.m[0] + m.m[4] + m.m[8];
|
||||
|
||||
if (trace > 0)
|
||||
{
|
||||
float s = 0.5f / sqrtf(trace + 1.0f);
|
||||
r.v[3] = 0.25f / s;
|
||||
r.v[0] = (m.m[5] - m.m[7]) * s;
|
||||
r.v[1] = (m.m[6] - m.m[2]) * s;
|
||||
r.v[2] = (m.m[1] - m.m[3]) * s;
|
||||
}
|
||||
else if (m.m[0] > m.m[4] && m.m[0] > m.m[8])
|
||||
{
|
||||
float s = 2.0f * sqrtf(1.0f + m.m[0] - m.m[4] - m.m[8]);
|
||||
r.v[3] = (m.m[5] - m.m[7]) / s;
|
||||
r.v[0] = 0.25f * s;
|
||||
r.v[1] = (m.m[1] + m.m[3]) / s;
|
||||
r.v[2] = (m.m[6] + m.m[2]) / s;
|
||||
}
|
||||
else if (m.m[4] > m.m[8])
|
||||
{
|
||||
float s = 2.0f * sqrtf(1.0f + m.m[4] - m.m[0] - m.m[8]);
|
||||
r.v[3] = (m.m[6] - m.m[2]) / s;
|
||||
r.v[0] = (m.m[1] + m.m[3]) / s;
|
||||
r.v[1] = 0.25f * s;
|
||||
r.v[2] = (m.m[5] + m.m[7]) / s;
|
||||
}
|
||||
else
|
||||
{
|
||||
float s = 2.0f * sqrtf(1.0f + m.m[8] - m.m[0] - m.m[4]);
|
||||
r.v[3] = (m.m[1] - m.m[3]) / s;
|
||||
r.v[0] = (m.m[6] + m.m[2]) / s;
|
||||
r.v[1] = (m.m[5] + m.m[7]) / s;
|
||||
r.v[2] = 0.25f * s;
|
||||
return Eigen::Quaternionf(m).normalized();
|
||||
}
|
||||
|
||||
return r.normalized();
|
||||
Eigen::Quaternionf QuatFromRotateAroundX(float angle) {
|
||||
return Eigen::Quaternionf(Eigen::AngleAxisf(angle, Eigen::Vector3f::UnitX()));
|
||||
}
|
||||
|
||||
Vector4f QuatFromRotateAroundX(float angle)
|
||||
{
|
||||
Vector4f result;
|
||||
|
||||
result.v[0] = sinf(angle * 0.5f);
|
||||
result.v[1] = 0.f;
|
||||
result.v[2] = 0.f;
|
||||
result.v[3] = cosf(angle * 0.5f);
|
||||
|
||||
return result;
|
||||
Eigen::Quaternionf QuatFromRotateAroundY(float angle) {
|
||||
return Eigen::Quaternionf(Eigen::AngleAxisf(angle, Eigen::Vector3f::UnitY()));
|
||||
}
|
||||
|
||||
Vector4f QuatFromRotateAroundY(float angle)
|
||||
{
|
||||
Vector4f result;
|
||||
|
||||
result.v[0] = 0.f;
|
||||
result.v[1] = sinf(angle * 0.5f);
|
||||
result.v[2] = 0.f;
|
||||
result.v[3] = cosf(angle * 0.5f);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
Vector4f QuatFromRotateAroundZ(float angle)
|
||||
{
|
||||
Vector4f result;
|
||||
|
||||
result.v[0] = 0.f;
|
||||
result.v[1] = 0.f;
|
||||
result.v[2] = sinf(angle * 0.5f);
|
||||
result.v[3] = cosf(angle * 0.5f);
|
||||
|
||||
return result;
|
||||
Eigen::Quaternionf QuatFromRotateAroundZ(float angle) {
|
||||
return Eigen::Quaternionf(Eigen::AngleAxisf(angle, Eigen::Vector3f::UnitZ()));
|
||||
}
|
||||
|
||||
Matrix3f TransposeMatrix(const Matrix3f& m)
|
||||
{
|
||||
Matrix3f r;
|
||||
r.m[0] = m.m[0];
|
||||
r.m[1] = m.m[3];
|
||||
r.m[2] = m.m[6];
|
||||
r.m[3] = m.m[1];
|
||||
r.m[4] = m.m[4];
|
||||
r.m[5] = m.m[7];
|
||||
r.m[6] = m.m[2];
|
||||
r.m[7] = m.m[5];
|
||||
r.m[8] = m.m[8];
|
||||
return r;
|
||||
return m.transpose();
|
||||
}
|
||||
|
||||
Matrix3f InverseMatrix(const Matrix3f& m)
|
||||
{
|
||||
float d;
|
||||
/*float d;
|
||||
Matrix3f r;
|
||||
|
||||
d = m.m[0] * (m.m[4] * m.m[8] - m.m[5] * m.m[7]);
|
||||
@ -410,12 +315,14 @@ namespace ZL {
|
||||
r.m[8] = (m.m[0] * m.m[4] - m.m[1] * m.m[3]) / d;
|
||||
|
||||
};
|
||||
return r;
|
||||
return r;*/
|
||||
return m.inverse();
|
||||
}
|
||||
|
||||
|
||||
Matrix4f InverseMatrix(const Matrix4f& mat)
|
||||
{
|
||||
/*
|
||||
Matrix4f inv;
|
||||
float det;
|
||||
|
||||
@ -531,7 +438,6 @@ namespace ZL {
|
||||
mat.m[8] * mat.m[1] * mat.m[6] -
|
||||
mat.m[8] * mat.m[2] * mat.m[5];
|
||||
|
||||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||||
det = mat.m[0] * inv.m[0] + mat.m[1] * inv.m[4] + mat.m[2] * inv.m[8] + mat.m[3] * inv.m[12];
|
||||
|
||||
if (std::fabs(det) < 0.01f)
|
||||
@ -539,30 +445,28 @@ namespace ZL {
|
||||
throw std::runtime_error("Error: matrix cannot be inversed!");
|
||||
}
|
||||
|
||||
// <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||||
det = 1.0f / det;
|
||||
for (int i = 0; i < 16; i++)
|
||||
{
|
||||
inv.m[i] *= det;
|
||||
}
|
||||
|
||||
return inv;
|
||||
return inv;*/
|
||||
|
||||
return mat.inverse();
|
||||
}
|
||||
|
||||
Matrix3f CreateZRotationMatrix(float angle)
|
||||
{
|
||||
Matrix3f result = Matrix3f::Identity();
|
||||
Eigen::Matrix3f m = Eigen::AngleAxisf(angle, Eigen::Vector3f::UnitZ()).toRotationMatrix();
|
||||
|
||||
result.m[0] = cosf(angle);
|
||||
result.m[1] = -sinf(angle);
|
||||
result.m[3] = sinf(angle);
|
||||
result.m[4] = cosf(angle);
|
||||
|
||||
return result;
|
||||
return m;
|
||||
}
|
||||
|
||||
Matrix4f MultMatrixMatrix(const Matrix4f& m1, const Matrix4f& m2)
|
||||
{
|
||||
return m1 * m2;
|
||||
/*
|
||||
Matrix4f rx;
|
||||
|
||||
rx.m[0] = m1.m[0] * m2.m[0] + m1.m[4] * m2.m[1] + m1.m[8] * m2.m[2] + m1.m[12] * m2.m[3];
|
||||
@ -586,35 +490,22 @@ namespace ZL {
|
||||
rx.m[14] = m1.m[2] * m2.m[12] + m1.m[6] * m2.m[13] + m1.m[10] * m2.m[14] + m1.m[14] * m2.m[15];
|
||||
rx.m[15] = m1.m[3] * m2.m[12] + m1.m[7] * m2.m[13] + m1.m[11] * m2.m[14] + m1.m[15] * m2.m[15];
|
||||
|
||||
return rx;
|
||||
return rx;*/
|
||||
}
|
||||
|
||||
Matrix3f MultMatrixMatrix(const Matrix3f& m1, const Matrix3f& m2)
|
||||
{
|
||||
Matrix3f r;
|
||||
|
||||
r.m[0] = m1.m[0] * m2.m[0] + m1.m[3] * m2.m[1] + m1.m[6] * m2.m[2];
|
||||
r.m[1] = m1.m[1] * m2.m[0] + m1.m[4] * m2.m[1] + m1.m[7] * m2.m[2];
|
||||
r.m[2] = m1.m[2] * m2.m[0] + m1.m[5] * m2.m[1] + m1.m[8] * m2.m[2];
|
||||
|
||||
r.m[3] = m1.m[0] * m2.m[3] + m1.m[3] * m2.m[4] + m1.m[6] * m2.m[5];
|
||||
r.m[4] = m1.m[1] * m2.m[3] + m1.m[4] * m2.m[4] + m1.m[7] * m2.m[5];
|
||||
r.m[5] = m1.m[2] * m2.m[3] + m1.m[5] * m2.m[4] + m1.m[8] * m2.m[5];
|
||||
|
||||
r.m[6] = m1.m[0] * m2.m[6] + m1.m[3] * m2.m[7] + m1.m[6] * m2.m[8] ;
|
||||
r.m[7] = m1.m[1] * m2.m[6] + m1.m[4] * m2.m[7] + m1.m[7] * m2.m[8];
|
||||
r.m[8] = m1.m[2] * m2.m[6] + m1.m[5] * m2.m[7] + m1.m[8] * m2.m[8];
|
||||
|
||||
return r;
|
||||
return m1 * m2;
|
||||
}
|
||||
|
||||
Matrix3f MakeTranslationMatrix(const Vector3f& p)
|
||||
/*
|
||||
Matrix4f MakeTranslationMatrix(const Vector3f& p)
|
||||
{
|
||||
Matrix3f r = Matrix3f::Identity();
|
||||
Matrix4f r = Matrix4f::Identity();
|
||||
|
||||
r.m[12] = p.v[0];
|
||||
r.m[13] = p.v[1];
|
||||
r.m[14] = p.v[2];
|
||||
r.m[12] = p(0);
|
||||
r.m[13] = p(1);
|
||||
r.m[14] = p(2);
|
||||
|
||||
return r;
|
||||
}
|
||||
@ -639,8 +530,8 @@ namespace ZL {
|
||||
r.m[14] = p.v[2];
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
}*/
|
||||
/*
|
||||
Vector2f operator*(Vector2f v, float scale)
|
||||
{
|
||||
Vector2f r = v;
|
||||
@ -649,8 +540,8 @@ namespace ZL {
|
||||
r.v[1] = v.v[1] * scale;
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
}*/
|
||||
/*
|
||||
Vector3f operator*(Vector3f v, float scale)
|
||||
{
|
||||
Vector3f r = v;
|
||||
@ -661,7 +552,8 @@ namespace ZL {
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
*/
|
||||
/*
|
||||
Vector4f operator*(Vector4f v, float scale)
|
||||
{
|
||||
Vector4f r = v;
|
||||
@ -673,53 +565,58 @@ namespace ZL {
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
*/
|
||||
Vector3f MultVectorMatrix(Vector3f v, Matrix3f mt)
|
||||
{
|
||||
return v.transpose() * mt;
|
||||
/*
|
||||
Vector3f r;
|
||||
|
||||
r.v[0] = v.v[0] * mt.m[0] + v.v[1] * mt.m[1] + v.v[2] * mt.m[2];
|
||||
r.v[1] = v.v[0] * mt.m[3] + v.v[1] * mt.m[4] + v.v[2] * mt.m[5];
|
||||
r.v[2] = v.v[0] * mt.m[6] + v.v[1] * mt.m[7] + v.v[2] * mt.m[8];
|
||||
r(0) = v(0) * mt.m[0] + v(1) * mt.m[1] + v(2) * mt.m[2];
|
||||
r(1) = v(0) * mt.m[3] + v(1) * mt.m[4] + v(2) * mt.m[5];
|
||||
r(2) = v(0) * mt.m[6] + v(1) * mt.m[7] + v(2) * mt.m[8];
|
||||
|
||||
return r;
|
||||
return r;*/
|
||||
}
|
||||
|
||||
Vector4f MultVectorMatrix(Vector4f v, Matrix4f mt)
|
||||
{
|
||||
Vector4f r;
|
||||
/*Vector4f r;
|
||||
|
||||
r.v[0] = v.v[0] * mt.m[0] + v.v[1] * mt.m[1] + v.v[2] * mt.m[2] + v.v[3] * mt.m[3];
|
||||
r.v[1] = v.v[0] * mt.m[4] + v.v[1] * mt.m[5] + v.v[2] * mt.m[6] + v.v[3] * mt.m[7];
|
||||
r.v[2] = v.v[0] * mt.m[8] + v.v[1] * mt.m[9] + v.v[2] * mt.m[10] + v.v[3] * mt.m[11];
|
||||
r.v[3] = v.v[0] * mt.m[12] + v.v[1] * mt.m[13] + v.v[2] * mt.m[14] + v.v[3] * mt.m[15];
|
||||
r(0) = v(0) * mt.m[0] + v(1) * mt.m[1] + v(2) * mt.m[2] + v(3) * mt.m[3];
|
||||
r(1) = v(0) * mt.m[4] + v(1) * mt.m[5] + v(2) * mt.m[6] + v(3) * mt.m[7];
|
||||
r(2) = v(0) * mt.m[8] + v(1) * mt.m[9] + v(2) * mt.m[10] + v(3) * mt.m[11];
|
||||
r(3) = v(0) * mt.m[12] + v(1) * mt.m[13] + v(2) * mt.m[14] + v(3) * mt.m[15];
|
||||
|
||||
return r;
|
||||
return r;*/
|
||||
return v.transpose() * mt;
|
||||
}
|
||||
|
||||
Vector4f MultMatrixVector(Matrix4f mt, Vector4f v)
|
||||
{
|
||||
Vector4f r;
|
||||
return mt * v;
|
||||
/*Vector4f r;
|
||||
|
||||
r.v[0] = v.v[0] * mt.m[0] + v.v[1] * mt.m[4] + v.v[2] * mt.m[8] + v.v[3] * mt.m[12];
|
||||
r.v[1] = v.v[0] * mt.m[1] + v.v[1] * mt.m[5] + v.v[2] * mt.m[9] + v.v[3] * mt.m[13];
|
||||
r.v[2] = v.v[0] * mt.m[2] + v.v[1] * mt.m[6] + v.v[2] * mt.m[10] + v.v[3] * mt.m[14];
|
||||
r.v[3] = v.v[0] * mt.m[3] + v.v[1] * mt.m[7] + v.v[2] * mt.m[11] + v.v[3] * mt.m[15];
|
||||
r(0) = v(0) * mt.m[0] + v(1) * mt.m[4] + v(2) * mt.m[8] + v(3) * mt.m[12];
|
||||
r(1) = v(0) * mt.m[1] + v(1) * mt.m[5] + v(2) * mt.m[9] + v(3) * mt.m[13];
|
||||
r(2) = v(0) * mt.m[2] + v(1) * mt.m[6] + v(2) * mt.m[10] + v(3) * mt.m[14];
|
||||
r(3) = v(0) * mt.m[3] + v(1) * mt.m[7] + v(2) * mt.m[11] + v(3) * mt.m[15];
|
||||
|
||||
return r;
|
||||
return r;*/
|
||||
}
|
||||
|
||||
Vector3f MultMatrixVector(Matrix3f mt, Vector3f v)
|
||||
{
|
||||
Vector3f r;
|
||||
return mt * v;
|
||||
/*Vector3f r;
|
||||
|
||||
r.v[0] = v.v[0] * mt.m[0] + v.v[1] * mt.m[3] + v.v[2] * mt.m[6];
|
||||
r.v[1] = v.v[0] * mt.m[1] + v.v[1] * mt.m[4] + v.v[2] * mt.m[7];
|
||||
r.v[2] = v.v[0] * mt.m[2] + v.v[1] * mt.m[5] + v.v[2] * mt.m[8];
|
||||
r(0) = v(0) * mt.m[0] + v(1) * mt.m[3] + v(2) * mt.m[6];
|
||||
r(1) = v(0) * mt.m[1] + v(1) * mt.m[4] + v(2) * mt.m[7];
|
||||
r(2) = v(0) * mt.m[2] + v(1) * mt.m[5] + v(2) * mt.m[8];
|
||||
|
||||
return r;
|
||||
return r;*/
|
||||
}
|
||||
|
||||
/*
|
||||
Vector4f slerp(const Vector4f& q1, const Vector4f& q2, float t)
|
||||
{
|
||||
const float epsilon = 1e-6f;
|
||||
@ -767,31 +664,17 @@ namespace ZL {
|
||||
result.v[3] = coeff1 * q1_norm.v[3] + coeff2 * q2_adjusted.v[3];
|
||||
|
||||
return result.normalized();
|
||||
}
|
||||
}*/
|
||||
|
||||
Matrix4f MakeMatrix4x4(const Matrix3f& m, const Vector3f pos)
|
||||
{
|
||||
Matrix4f r;
|
||||
Eigen::Matrix4f MakeMatrix4x4(const Eigen::Matrix3f& m, const Eigen::Vector3f& pos) {
|
||||
Eigen::Matrix4f r = Eigen::Matrix4f::Identity();
|
||||
|
||||
r.m[0] = m.m[0];
|
||||
r.m[1] = m.m[1];
|
||||
r.m[2] = m.m[2];
|
||||
r.m[3] = 0;
|
||||
// Копируем 3x3 матрицу в верхний левый угол
|
||||
r.block<3, 3>(0, 0) = m;
|
||||
|
||||
r.m[4] = m.m[3];
|
||||
r.m[5] = m.m[4];
|
||||
r.m[6] = m.m[5];
|
||||
r.m[7] = 0;
|
||||
// Копируем позицию в последний столбец (первые 3 элемента)
|
||||
r.block<3, 1>(0, 3) = pos;
|
||||
|
||||
r.m[8] = m.m[6];
|
||||
r.m[9] = m.m[7];
|
||||
r.m[10] = m.m[8];
|
||||
r.m[11] = 0;
|
||||
|
||||
r.m[12] = pos.v[0];
|
||||
r.m[13] = pos.v[1];
|
||||
r.m[14] = pos.v[2];
|
||||
r.m[15] = 1.0;
|
||||
return r;
|
||||
}
|
||||
|
||||
|
||||
@ -4,9 +4,17 @@
|
||||
#include <exception>
|
||||
#include <stdexcept>
|
||||
#include <cmath>
|
||||
#include <Eigen/Dense>
|
||||
|
||||
namespace ZL {
|
||||
|
||||
using Eigen::Vector2f;
|
||||
using Eigen::Vector3f;
|
||||
using Eigen::Vector4f;
|
||||
|
||||
using Eigen::Matrix3f;
|
||||
using Eigen::Matrix4f;
|
||||
/*
|
||||
struct Vector4f
|
||||
{
|
||||
Vector4f()
|
||||
@ -39,8 +47,8 @@ namespace ZL {
|
||||
double dot(const Vector4f& other) const {
|
||||
return v[0] * other.v[0] + v[1] * other.v[1] + v[2] * other.v[2] + v[3] * other.v[3];
|
||||
}
|
||||
};
|
||||
|
||||
};*/
|
||||
/*
|
||||
struct Vector3f
|
||||
{
|
||||
std::array<float, 3> v = { 0.f, 0.f, 0.f };
|
||||
@ -94,10 +102,10 @@ namespace ZL {
|
||||
if (v[1] != other.v[1]) return v[1] < other.v[1];
|
||||
return v[2] < other.v[2];
|
||||
}
|
||||
};
|
||||
|
||||
};*/
|
||||
|
||||
|
||||
/*
|
||||
struct Vector2f
|
||||
{
|
||||
std::array<float, 2> v = {0.f, 0.f};
|
||||
@ -115,17 +123,17 @@ namespace ZL {
|
||||
Vector2f operator+(const Vector2f& x, const Vector2f& y);
|
||||
|
||||
Vector2f operator-(const Vector2f& x, const Vector2f& y);
|
||||
*/
|
||||
//Vector3f operator+(const Vector3f& x, const Vector3f& y);
|
||||
|
||||
Vector3f operator+(const Vector3f& x, const Vector3f& y);
|
||||
//Vector3f operator-(const Vector3f& x, const Vector3f& y);
|
||||
//Vector4f operator+(const Vector4f& x, const Vector4f& y);
|
||||
|
||||
Vector3f operator-(const Vector3f& x, const Vector3f& y);
|
||||
Vector4f operator+(const Vector4f& x, const Vector4f& y);
|
||||
|
||||
Vector4f operator-(const Vector4f& x, const Vector4f& y);
|
||||
|
||||
Vector3f operator-(const Vector3f& x);
|
||||
//Vector4f operator-(const Vector4f& x, const Vector4f& y);
|
||||
|
||||
//Vector3f operator-(const Vector3f& x);
|
||||
|
||||
/*
|
||||
struct Matrix3f
|
||||
{
|
||||
std::array<float, 9> m = { 0.f, 0.f, 0.f,
|
||||
@ -133,8 +141,8 @@ namespace ZL {
|
||||
0.f, 0.f, 0.f, };
|
||||
|
||||
static Matrix3f Identity();
|
||||
};
|
||||
|
||||
};*/
|
||||
/*
|
||||
struct Matrix4f
|
||||
{
|
||||
std::array<float, 16> m = { 0.f, 0.f, 0.f, 0.f,
|
||||
@ -154,36 +162,36 @@ namespace ZL {
|
||||
return m[col * 4 + row];
|
||||
}
|
||||
};
|
||||
|
||||
Matrix4f operator*(const Matrix4f& m1, const Matrix4f& m2);
|
||||
*/
|
||||
//Matrix4f operator*(const Matrix4f& m1, const Matrix4f& m2);
|
||||
|
||||
Matrix4f MakeOrthoMatrix(float width, float height, float zNear, float zFar);
|
||||
Matrix4f MakeOrthoMatrix(float xmin, float xmax, float ymin, float ymax, float zNear, float zFar);
|
||||
|
||||
Matrix4f MakePerspectiveMatrix(float fovY, float aspectRatio, float zNear, float zFar);
|
||||
|
||||
Matrix3f QuatToMatrix(const Vector4f& q);
|
||||
Matrix3f QuatToMatrix(const Eigen::Quaternionf& q);
|
||||
|
||||
Vector4f MatrixToQuat(const Matrix3f& m);
|
||||
Eigen::Quaternionf MatrixToQuat(const Matrix3f& m);
|
||||
|
||||
Vector4f QuatFromRotateAroundX(float angle);
|
||||
Vector4f QuatFromRotateAroundY(float angle);
|
||||
Vector4f QuatFromRotateAroundZ(float angle);
|
||||
Eigen::Quaternionf QuatFromRotateAroundX(float angle);
|
||||
Eigen::Quaternionf QuatFromRotateAroundY(float angle);
|
||||
Eigen::Quaternionf QuatFromRotateAroundZ(float angle);
|
||||
|
||||
Vector2f operator*(Vector2f v, float scale);
|
||||
Vector3f operator*(Vector3f v, float scale);
|
||||
Vector4f operator*(Vector4f v, float scale);
|
||||
//Vector2f operator*(Vector2f v, float scale);
|
||||
//Vector3f operator*(Vector3f v, float scale);
|
||||
//Vector4f operator*(Vector4f v, float scale);
|
||||
|
||||
Vector3f MultVectorMatrix(Vector3f v, Matrix3f mt);
|
||||
Vector4f MultVectorMatrix(Vector4f v, Matrix4f mt);
|
||||
Vector4f MultMatrixVector(Matrix4f mt, Vector4f v);
|
||||
Vector3f MultMatrixVector(Matrix3f mt, Vector3f v);
|
||||
|
||||
Vector4f slerp(const Vector4f& q1, const Vector4f& q2, float t);
|
||||
//Vector4f slerp(const Vector4f& q1, const Vector4f& q2, float t);
|
||||
Matrix3f InverseMatrix(const Matrix3f& m);
|
||||
Matrix4f InverseMatrix(const Matrix4f& m);
|
||||
Matrix3f MultMatrixMatrix(const Matrix3f& m1, const Matrix3f& m2);
|
||||
Matrix4f MultMatrixMatrix(const Matrix4f& m1, const Matrix4f& m2);
|
||||
Matrix4f MakeMatrix4x4(const Matrix3f& m, const Vector3f pos);
|
||||
Matrix4f MakeMatrix4x4(const Eigen::Matrix3f& m, const Eigen::Vector3f& pos);
|
||||
|
||||
};
|
||||
|
||||
Loading…
Reference in New Issue
Block a user