Skip to content

Commit 98cd3e5

Browse files
bobtistabobtista
committed
Improves readability in HeightMapRenderObjClass::Update_Center
1 parent e2c0ddc commit 98cd3e5

File tree

1 file changed

+134
-116
lines changed

1 file changed

+134
-116
lines changed

‎src/game/client/heightmap.cpp

+134-116
Original file line numberDiff line numberDiff line change
@@ -658,250 +658,268 @@ int Invert_Value(int value)
658658
}
659659
}
660660

661+
/**
662+
* Update the center of the HeightMapRenderObjClass.
663+
*
664+
* @param camera Pointer to the CameraClass object.
665+
* @param lights Pointer to the RefMultiListIterator<RenderObjClass> object.
666+
*/
661667
void HeightMapRenderObjClass::Update_Center(CameraClass *camera, RefMultiListIterator<RenderObjClass> *lights)
662668
{
669+
// Check if the height map, updating flag, and vertex buffer are valid
663670
if (m_map != nullptr && !m_updating && m_vertexBufferTiles != nullptr) {
671+
// Update the center of the base height map render object
664672
BaseHeightMapRenderObjClass::Update_Center(camera, lights);
665673
m_updating = true;
666674

675+
// Perform a full update if necessary
667676
if (m_needFullUpdate) {
668677
m_needFullUpdate = false;
669678
Update_Block(0, 0, m_x - 1, m_y - 1, m_map, lights);
670679
m_updating = false;
671680
return;
672681
}
673682

683+
// Check if the dimensions of the height map have been reached
674684
if (m_x >= m_map->Get_X_Extent() && m_y >= m_map->Get_Y_Extent()) {
675685
m_updating = false;
676686
return;
677687
}
678688

679-
int i1 = 1;
689+
// Initialize variables
690+
int increment = 1;
680691
Matrix3D camera_transform = camera->Get_Transform();
681692
Vector3 camera_pos = camera->Get_Position();
682-
Vector3 v1;
683-
Vector3 v2;
693+
Vector3 view_direction;
694+
Vector3 intersection_point;
684695
const ViewportClass &viewport = camera->Get_Viewport();
685-
int height = WorldHeightMap::Get_Max_Height_Value();
696+
int max_height = WorldHeightMap::Get_Max_Height_Value();
686697

698+
// Find the minimum display height in the height map
687699
for (int x = 0; x < m_x; x++) {
688700
for (int y = 0; y < m_y; y++) {
689701
unsigned char display_height = m_map->Get_Display_Height(x, y);
690702

691-
if (display_height < height) {
692-
height = display_height;
703+
if (display_height < max_height) {
704+
max_height = display_height;
693705
}
694706
}
695707
}
696708

697-
float z = height;
698-
Vector2 min;
699-
Vector2 max;
700-
camera->Get_View_Plane(min, max);
701-
float x_dist = max.X - min.X;
702-
float y_dist = max.Y - min.Y;
703-
float f1 = -1.0f;
704-
float f2 = 200000.0f;
705-
float f3 = -200000.0f;
706-
float f4 = 200000.0f;
707-
float f5 = f3;
708-
709+
float z = max_height;
710+
Vector2 viewport_min;
711+
Vector2 viewport_max;
712+
camera->Get_View_Plane(viewport_min, viewport_max);
713+
float x_dist = viewport_max.X - viewport_min.X;
714+
float y_dist = viewport_max.Y - viewport_min.Y;
715+
float scale_factor = -1.0f;
716+
float min_x = 200000.0f;
717+
float max_x = -200000.0f;
718+
float min_y = 200000.0f;
719+
float max_y = max_x;
720+
721+
// Calculate the frustum corners
709722
for (int x = 0; x < 2; x++) {
710723
for (int y = 0; y < 2; y++) {
711-
float f6 = (-x + 0.5f + viewport.m_min.X) * f1 * x_dist;
712-
float f7 = (y - 0.5f - viewport.m_min.Y) * f1 * y_dist;
713-
float f8 = f1 * camera_transform[0][2];
714-
float f9 = f6 * camera_transform[0][0] + f8;
715-
float f10 = f7 * camera_transform[0][1] + f9;
716-
float f11 = f1 * camera_transform[1][2];
717-
float f12 = f6 * camera_transform[1][0] + f11;
718-
float f13 = f7 * camera_transform[1][1] + f12;
719-
float f14 = f1 * camera_transform[2][2];
720-
float f15 = f6 * camera_transform[2][0] + f14;
721-
float f16 = f7 * camera_transform[2][1] + f15;
722-
v1.Set(f10, f13, f16);
723-
v1.Normalize();
724-
v2 = camera_pos + v1;
725-
f10 = Vector3::Find_X_At_Z(z, camera_pos, v2);
726-
f13 = Vector3::Find_Y_At_Z(z, camera_pos, v2);
727-
728-
if (f10 < f2) {
729-
f2 = f10;
724+
float viewport_x_distance = (-x + 0.5f + viewport.m_min.X) * scale_factor * x_dist;
725+
float viewport_y_distance = (y - 0.5f - viewport.m_min.Y) * scale_factor * y_dist;
726+
float camera_transform_x = scale_factor * camera_transform[0][2];
727+
float x_transformed = viewport_x_distance * camera_transform[0][0] + camera_transform_x;
728+
float intersection_x = viewport_y_distance * camera_transform[0][1] + x_transformed;
729+
float camera_transform_y = scale_factor * camera_transform[1][2];
730+
float y_transformed = viewport_x_distance * camera_transform[1][0] + camera_transform_y;
731+
float intersection_y = viewport_y_distance * camera_transform[1][1] + y_transformed;
732+
float camera_transform_z = scale_factor * camera_transform[2][2];
733+
float z_transformed = viewport_x_distance * camera_transform[2][0] + camera_transform_z;
734+
float intersection_z = viewport_y_distance * camera_transform[2][1] + z_transformed;
735+
view_direction.Set(intersection_x, intersection_y, intersection_z);
736+
view_direction.Normalize();
737+
intersection_point = camera_pos + view_direction;
738+
intersection_x = Vector3::Find_X_At_Z(z, camera_pos, intersection_point);
739+
intersection_y = Vector3::Find_Y_At_Z(z, camera_pos, intersection_point);
740+
741+
// Update the frustum boundaries
742+
if (intersection_x < min_x) {
743+
min_x = intersection_x;
730744
}
731745

732-
if (f10 > f3) {
733-
f3 = f10;
746+
if (intersection_x > max_x) {
747+
max_x = intersection_x;
734748
}
735749

736-
if (f13 < f4) {
737-
f4 = f13;
750+
if (intersection_y < min_y) {
751+
min_y = intersection_y;
738752
}
739753

740-
if (f13 > f5) {
741-
f5 = f13;
754+
if (intersection_y > max_y) {
755+
max_y = intersection_y;
742756
}
743757
}
744758
}
745759

746-
f2 = f2 / 10.0f;
747-
f3 = f3 / 10.0f;
748-
f4 = f4 / 10.0f;
749-
f5 = f5 / 10.0f;
750-
f2 = m_map->Border_Size() + f2;
751-
f3 = m_map->Border_Size() + f3;
752-
f4 = m_map->Border_Size() + f4;
753-
f5 = m_map->Border_Size() + f5;
754-
760+
// Adjust the frustum boundaries
761+
min_x = min_x / 10.0f;
762+
max_x = max_x / 10.0f;
763+
min_y = min_y / 10.0f;
764+
max_y = max_y / 10.0f;
765+
min_x = m_map->Border_Size() + min_x;
766+
max_x = m_map->Border_Size() + max_x;
767+
min_y = m_map->Border_Size() + min_y;
768+
max_y = m_map->Border_Size() + max_y;
769+
770+
// Initialize the visibility boundaries
755771
s_visMinX = m_map->Get_X_Extent();
756772
s_visMinY = m_map->Get_Y_Extent();
757773
s_visMaxX = 0;
758774
s_visMaxY = 0;
759775

760-
if (f2 < 0.0f) {
761-
f2 = 0.0f;
776+
// Adjust frustum boundaries if necessary
777+
if (min_x < 0.0f) {
778+
min_x = 0.0f;
762779
}
763780

764-
if (f4 < 0.0f) {
765-
f4 = 0.0f;
781+
if (min_y < 0.0f) {
782+
min_y = 0.0f;
766783
}
767784

768-
if (s_visMinX < f3) {
769-
f3 = s_visMinX;
785+
if (s_visMinX < max_x) {
786+
max_x = s_visMinX;
770787
}
771788

772-
if (s_visMinY < f5) {
773-
f5 = s_visMinY;
789+
if (s_visMinY < max_y) {
790+
max_y = s_visMinY;
774791
}
775792

776793
const FrustumClass &frustum = camera->Get_Frustum();
777-
int limit = ((f3 - f2) / 2.0f);
794+
int limit = ((max_x - min_x) / 2.0f);
778795

779796
if (limit > 16) {
780797
limit = 16;
781798
}
782799

783-
Calc_Vis(frustum, m_map, (f2 - 16.0f), (f4 - 16.0f), (f3 + 16.0f), (f5 + 16.0f), limit);
800+
Calc_Vis(frustum, m_map, (min_x - 16.0f), (min_y - 16.0f), (max_x + 16.0f), (max_y + 16.0f), limit);
784801

785802
if (m_map != nullptr) {
786-
int x_org;
787-
int y_org;
803+
int x_origin;
804+
int y_origin;
788805

789806
if (s_visMaxX - s_visMinX <= m_x) {
790-
x_org = (((s_visMinX + s_visMaxX) / 2) - m_x / 2.0f);
807+
x_origin = (((s_visMinX + s_visMaxX) / 2) - m_x / 2.0f);
791808
} else {
792-
x_org = ((f3 + f2) / 2.0f - m_x / 2.0f);
809+
x_origin = ((max_x + min_x) / 2.0f - m_x / 2.0f);
793810
}
794811

795812
if (s_visMaxY - s_visMinY <= m_y) {
796-
y_org = (((s_visMinY + s_visMaxY) / 2) - m_y / 2.0f);
813+
y_origin = (((s_visMinY + s_visMaxY) / 2) - m_y / 2.0f);
797814
} else {
798-
y_org = s_visMinY + 1;
815+
y_origin = s_visMinY + 1;
799816
}
800817

801818
if (g_theTacticalView->Get_Field_Of_View() != 0.0f) {
802-
x_org = (((s_visMinX + s_visMaxX) / 2) - m_x / 2.0f);
803-
y_org = (((s_visMinY + s_visMaxY) / 2) - m_y / 2.0f);
819+
x_origin = (((s_visMinX + s_visMaxX) / 2) - m_x / 2.0f);
820+
y_origin = (((s_visMinY + s_visMaxY) / 2) - m_y / 2.0f);
804821
}
805822

806-
int i2 = x_org - m_map->Get_Draw_Origin_X();
807-
int i3 = y_org - m_map->Get_Draw_Origin_Y();
823+
int origin_offset_x = x_origin - m_map->Get_Draw_Origin_X();
824+
int origin_offset_y = y_origin - m_map->Get_Draw_Origin_Y();
808825

809-
if (Invert_Value(i2) > m_x / 2 || Invert_Value(i3) > m_x / 2) {
810-
m_map->Set_Draw_Origin(x_org, y_org);
826+
// Check if the origin needs to be updated
827+
if (Invert_Value(origin_offset_x) > m_x / 2 || Invert_Value(origin_offset_y) > m_x / 2) {
828+
m_map->Set_Draw_Origin(x_origin, y_origin);
811829
m_originY = 0;
812830
m_originX = 0;
813831
Update_Block(0, 0, m_x - 1, m_y - 1, m_map, lights);
814832
m_updating = false;
815833
return;
816834
}
817835

818-
if (abs(i2) > 2 || abs(i3) > 2) {
819-
if (abs(i3) >= 2) {
820-
if (m_map->Set_Draw_Origin(m_map->Get_Draw_Origin_X(), y_org)) {
821-
int i4 = 0;
822-
int i5 = 0;
823-
i3 -= y_org - m_map->Get_Draw_Origin_Y();
824-
m_originY += i3;
836+
if (abs(origin_offset_x) > 2 || abs(origin_offset_y) > 2) {
837+
if (abs(origin_offset_y) >= 2) {
838+
if (m_map->Set_Draw_Origin(m_map->Get_Draw_Origin_X(), y_origin)) {
839+
int y_start_tile = 0;
840+
int y_end_tile = 0;
841+
origin_offset_y -= y_origin - m_map->Get_Draw_Origin_Y();
842+
m_originY += origin_offset_y;
825843

826844
if (m_originY >= m_y - 1) {
827845
m_originY -= m_y - 1;
828846
}
829847

830-
if (i3 >= 0) {
831-
i4 = m_originY - i3;
832-
i5 = m_originY;
848+
if (origin_offset_y >= 0) {
849+
y_start_tile = m_originY - origin_offset_y;
850+
y_end_tile = m_originY;
833851
} else {
834-
i4 = m_originY;
835-
i5 = m_originY - i3;
852+
y_start_tile = m_originY;
853+
y_end_tile = m_originY - origin_offset_y;
836854
}
837855

838-
i4 -= i1;
856+
y_start_tile -= increment;
839857

840858
if (m_originY < 0) {
841859
m_originY = m_originY + m_y - 1;
842860
}
843861

844-
if (i4 >= 0) {
845-
Update_Block(0, i4, m_x - 1, i5, m_map, lights);
862+
if (y_start_tile >= 0) {
863+
Update_Block(0, y_start_tile, m_x - 1, y_end_tile, m_map, lights);
846864
} else {
847-
i4 = i4 + m_y - 1;
865+
y_start_tile = y_start_tile + m_y - 1;
848866

849-
if (i4 < 0) {
850-
i4 = 0;
867+
if (y_start_tile < 0) {
868+
y_start_tile = 0;
851869
}
852870

853-
Update_Block(0, i4, m_x - 1, m_y - 1, m_map, lights);
854-
Update_Block(0, 0, m_x - 1, i5, m_map, lights);
871+
Update_Block(0, y_start_tile, m_x - 1, m_y - 1, m_map, lights);
872+
Update_Block(0, 0, m_x - 1, y_end_tile, m_map, lights);
855873
}
856874
}
857875

858-
if (abs(i2) < 16 && !m_doXNextTime) {
876+
if (abs(origin_offset_x) < 16 && !m_doXNextTime) {
859877
m_updating = false;
860878
m_doXNextTime = true;
861879
return;
862880
}
863881
}
864882

865-
if (abs(i2) > 2) {
883+
if (abs(origin_offset_x) > 2) {
866884
m_doXNextTime = false;
867-
x_org = i2 + m_map->Get_Draw_Origin_X();
885+
x_origin = origin_offset_x + m_map->Get_Draw_Origin_X();
868886

869-
if (m_map->Set_Draw_Origin(x_org, m_map->Get_Draw_Origin_Y())) {
870-
int i6 = 0;
871-
int i7 = 0;
872-
i2 -= x_org - m_map->Get_Draw_Origin_X();
873-
m_originX += i2;
887+
if (m_map->Set_Draw_Origin(x_origin, m_map->Get_Draw_Origin_Y())) {
888+
int x_start_tile = 0;
889+
int x_end_tile = 0;
890+
origin_offset_x -= x_origin - m_map->Get_Draw_Origin_X();
891+
m_originX += origin_offset_x;
874892

875893
if (m_originX >= m_x - 1) {
876894
m_originX -= m_x - 1;
877895
}
878896

879-
if (i2 >= 0) {
880-
i6 = m_originX - i2;
881-
i7 = m_originX;
897+
if (origin_offset_x >= 0) {
898+
x_start_tile = m_originX - origin_offset_x;
899+
x_end_tile = m_originX;
882900
} else {
883-
i6 = m_originX;
884-
i7 = m_originX - i2;
901+
x_start_tile = m_originX;
902+
x_end_tile = m_originX - origin_offset_x;
885903
}
886904

887-
i6 -= i1;
888-
i7 += i1;
905+
x_start_tile -= increment;
906+
x_end_tile += increment;
889907

890908
if (m_originX < 0) {
891909
m_originX = m_originX + m_x - 1;
892910
}
893911

894-
if (i6 >= 0) {
895-
Update_Block(i6, 0, i7, m_y - 1, m_map, lights);
912+
if (x_start_tile >= 0) {
913+
Update_Block(x_start_tile, 0, x_end_tile, m_y - 1, m_map, lights);
896914
} else {
897-
i6 = i6 + m_x - 1;
915+
x_start_tile = x_start_tile + m_x - 1;
898916

899-
if (i6 < 0) {
900-
i6 = 0;
917+
if (x_start_tile < 0) {
918+
x_start_tile = 0;
901919
}
902920

903-
Update_Block(i6, 0, m_x - 1, m_y - 1, m_map, lights);
904-
Update_Block(0, 0, i7, m_y - 1, m_map, lights);
921+
Update_Block(x_start_tile, 0, m_x - 1, m_y - 1, m_map, lights);
922+
Update_Block(0, 0, x_end_tile, m_y - 1, m_map, lights);
905923
}
906924
}
907925
}

0 commit comments

Comments
 (0)