?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
!XT (Code) Update copyright headers in Code/Sandbox.
[CRYENGINE.git] / Code / Sandbox / EditorQt / Objects / RoadObject.cpp
blob95db357dd005865b884cded1d90116460f32fe57
1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
2
3 #include "StdAfx.h"
4 #include "RoadObject.h"
5 #include "Viewport.h"
6 #include "Terrain/Heightmap.h"
7 #include "Material/Material.h"
8 #include "../Vegetation/VegetationMap.h"
9 #include "../Vegetation/VegetationObject.h"
10 #include "Objects/ObjectLoader.h"
11 #include "Objects/InspectorWidgetCreator.h"
12 #include <Cry3DEngine/I3DEngine.h>
13 #include <CryCore/Containers/CryArray.h>
14 #include "Util/MFCUtil.h"
15 #include "Serialization/Decorators/EditorActionButton.h"
16 #include <Preferences/ViewportPreferences.h>
17
18 #include "CryEditDoc.h"
19
20 //////////////////////////////////////////////////////////////////////////
21 // class CRoadSector
22
23 void CRoadSector::Release()
24 {
25 if (m_pRoadSector)
26 GetIEditorImpl()->Get3DEngine()->DeleteRenderNode(m_pRoadSector);
27 m_pRoadSector = 0;
28 }
29
30 //////////////////////////////////////////////////////////////////////////
31 // CRoadObject implementation.
32 //////////////////////////////////////////////////////////////////////////
33 IMPLEMENT_DYNCREATE(CRoadObject, CSplineObject)
34
35 #define RAY_DISTANCE 100000.0f
36
37 //////////////////////////////////////////////////////////////////////////
38 CRoadObject::CRoadObject()
39 {
40 m_bNeedUpdateSectors = true;
41 mv_width = 4.0f;
42 mv_borderWidth = 6.0f;
43 mv_eraseVegWidth = 3.f;
44 mv_eraseVegWidthVar = 0.f;
45 mv_step = 4.0f;
46 mv_tileLength = 4.0f;
47 mv_sortPrio = 0;
48 m_ignoreTerrainHoles = false;
49 m_physicalize = false;
50
51 m_bIgnoreParamUpdate = false;
52
53 SetColor(CMFCUtils::Vec2Rgb(Vec3(0, 0.8f, 1)));
54 mv_ratioViewDist = 100;
55 }
56
57 //////////////////////////////////////////////////////////////////////////
58 void CRoadObject::Done()
59 {
60 m_sectors.clear();
61 __super::Done();
62 }
63
64 //////////////////////////////////////////////////////////////////////////
65 void CRoadObject::InitBaseVariables()
66 {
67 if (m_pVarObject == nullptr)
68 {
69 m_pVarObject = stl::make_unique<CVarObject>();
70 }
71
72 m_pVarObject->AddVariable(mv_width, "Width", functor(*this, &CRoadObject::OnParamChange));
73 m_pVarObject->AddVariable(mv_borderWidth, "BorderWidth", functor(*this, &CRoadObject::OnParamChange));
74 m_pVarObject->AddVariable(mv_eraseVegWidth, "EraseVegWidth");
75 m_pVarObject->AddVariable(mv_eraseVegWidthVar, "EraseVegWidthVar");
76 m_pVarObject->AddVariable(mv_step, "StepSize", functor(*this, &CRoadObject::OnParamChange));
77 m_pVarObject->AddVariable(mv_ratioViewDist, "ViewDistRatio", functor(*this, &CRoadObject::OnParamChange));
78 mv_ratioViewDist.SetLimits(0, 255);
79 m_pVarObject->AddVariable(mv_tileLength, "TileLength", functor(*this, &CRoadObject::OnParamChange));
80 mv_step.SetLimits(0.25f, 10.f);
81 mv_tileLength.SetLimits(0.001f, 1000.f);
82 }
83
84 //////////////////////////////////////////////////////////////////////////
85 void CRoadObject::InitVariables()
86 {
87 InitBaseVariables();
88
89 m_pVarObject->AddVariable(mv_sortPrio, "SortPriority", functor(*this, &CRoadObject::OnParamChange));
90 mv_sortPrio.SetLimits(0, 255);
91
92 m_pVarObject->AddVariable(m_ignoreTerrainHoles, "IgnoreTerrainHoles", functor(*this, &CRoadObject::OnParamChange));
93 m_pVarObject->AddVariable(m_physicalize, "Physicalize", functor(*this, &CRoadObject::OnParamChange));
94 }
95
96 //////////////////////////////////////////////////////////////////////////
97 void CRoadObject::InvalidateTM(int nWhyFlags)
98 {
99 __super::InvalidateTM(nWhyFlags);
100 SetRoadSectors();
101 }
102
103 //////////////////////////////////////////////////////////////////////////
104 void CRoadObject::CreateInspectorWidgets(CInspectorWidgetCreator& creator)
105 {
106 CSplineObject::CreateInspectorWidgets(creator);
107
108 creator.AddPropertyTree<CRoadObject>("Road", [](CRoadObject* pObject, Serialization::IArchive& ar, bool bMultiEdit)
109 {
110 pObject->m_pVarObject->SerializeVariable(&pObject->mv_width, ar);
111 pObject->m_pVarObject->SerializeVariable(&pObject->mv_borderWidth, ar);
112 pObject->m_pVarObject->SerializeVariable(&pObject->mv_eraseVegWidth, ar);
113 pObject->m_pVarObject->SerializeVariable(&pObject->mv_eraseVegWidthVar, ar);
114 pObject->m_pVarObject->SerializeVariable(&pObject->mv_step, ar);
115 pObject->m_pVarObject->SerializeVariable(&pObject->mv_ratioViewDist, ar);
116 pObject->m_pVarObject->SerializeVariable(&pObject->mv_tileLength, ar);
117
118 if (ar.openBlock("operators", "<operators"))
119 {
120 ar(Serialization::ActionButton(std::bind(&CRoadObject::AlignHeightMap, pObject)), "align_heightmap", "^Align Height Map");
121 ar(Serialization::ActionButton(std::bind(&CRoadObject::EraseVegetation, pObject)), "erase_vegetation", "^Erase Vegetation");
122 ar.closeBlock();
123 }
124 });
125 }
126
127 //////////////////////////////////////////////////////////////////////////
128 float CRoadObject::GetLocalWidth(int index, float t)
129 {
130 float kof = t;
131 int i = index;
132
133 if (index >= m_points.size() - 1)
134 {
135 kof = 1.0f + t;
136 i = m_points.size() - 2;
137 if (i < 0)
138 return mv_width;
139 }
140
141 float an1 = m_points[i].isDefaultWidth ? mv_width : m_points[i].width;
142 float an2 = m_points[i + 1].isDefaultWidth ? mv_width : m_points[i + 1].width;
143
144 if (an1 == an2)
145 return an1;
146
147 float af = kof * 2 - 1.0f;
148 float ed = 1.0f;
149 if (af < 0.0f)
150 ed = -1.0f;
151 //af = ed-af;
152 af = af;
153 //af = ed-af;
154 af = (af + 1.0f) / 2;
155 return ((1.0f - af) * an1 + af * an2);
156 }
157
158 //////////////////////////////////////////////////////////////////////////
159 void CRoadObject::OnUpdate()
160 {
161 SetRoadSectors();
162 }
163
164 //////////////////////////////////////////////////////////////////////////
165 void CRoadObject::SetRoadSectors()
166 {
167 const Matrix34& wtm = GetWorldTM();
168
169 int sizeOld = m_sectors.size();
170 int sizeNew = 0;
171
172 int points_size = m_points.size();
173
174 float fSegLen = 0.0f;
175
176 for (int i = 0; i < points_size - 1; ++i)
177 {
178 int kn = GetRoadSectorCount(i);
179
180 for (int k = 0; k <= kn; ++k)
181 {
182 if (i != points_size - 2 && k == kn)
183 break;
184 float t = float(k) / kn;
185 Vec3 p = GetBezierPos(i, t);
186 Vec3 n = GetLocalBezierNormal(i, t);
187
188 float fWidth = GetLocalWidth(i, t);
189
190 Vec3 r = p - 0.5f * fWidth * n;
191 Vec3 l = p + 0.5f * fWidth * n;
192
193 if (sizeNew >= sizeOld)
194 {
195 CRoadSector sector;
196 m_sectors.push_back(sector);
197 }
198
199 m_sectors[sizeNew].points.clear();
200 m_sectors[sizeNew].points.push_back(l);
201 m_sectors[sizeNew].points.push_back(r);
202 m_sectors[sizeNew].points.push_back(l);
203 m_sectors[sizeNew].points.push_back(r);
204
205 m_sectors[sizeNew].t0 = (fSegLen + GetBezierSegmentLength(i, t)) / mv_tileLength;
206
207 sizeNew++;
208 }
209 fSegLen += GetBezierSegmentLength(i);
210 }
211
212 if (sizeNew < sizeOld)
213 m_sectors.resize(sizeNew);
214
215 for (size_t i = 0; i < m_sectors.size(); ++i)
216 {
217 m_sectors[i].points[0] = wtm.TransformPoint(m_sectors[i].points[0]);
218 m_sectors[i].points[1] = wtm.TransformPoint(m_sectors[i].points[1]);
219
220 if (i > 0)
221 {
222 // adjust mesh
223 m_sectors[i - 1].points[2] = m_sectors[i].points[0];
224 m_sectors[i - 1].points[3] = m_sectors[i].points[1];
225 m_sectors[i - 1].t1 = m_sectors[i].t0;
226 }
227 }
228
229 if (m_sectors.size() > 0)
230 m_sectors.pop_back();
231
232 // mark end of the road for road alpha fading
233 if (m_sectors.size() > 0)
234 m_sectors[m_sectors.size() - 1].t1 *= -1.f;
235
236 // call only in the end of this function
237 UpdateSectors();
238 }
239
240 //////////////////////////////////////////////////////////////////////////
241 int CRoadObject::GetRoadSectorCount(int index)
242 {
243 int kn = int((GetBezierSegmentLength(index) + 0.5f) / GetStepSize());
244 if (kn == 0)
245 return 1;
246 return kn;
247 }
248
249 //////////////////////////////////////////////////////////////////////////
250 void CRoadObject::UpdateSectors()
251 {
252 if (!m_bNeedUpdateSectors)
253 return;
254
255 m_mergeIndex = -1;
256
257 if (!m_sectors.size())
258 return;
259
260 for (size_t i = 0; i < m_sectors.size(); ++i)
261 {
262 if (m_sectors[i].m_pRoadSector)
263 GetIEditorImpl()->Get3DEngine()->DeleteRenderNode(m_sectors[i].m_pRoadSector);
264 m_sectors[i].m_pRoadSector = 0;
265 }
266
267 int MAX_TRAPEZOIDS_IN_CHUNK = 16;
268 int nChunksNum = m_sectors.size() / MAX_TRAPEZOIDS_IN_CHUNK + 1;
269
270 CRoadSector& sectorFirstGlobal = m_sectors[0];
271 CRoadSector& sectorLastGlobal = m_sectors[m_sectors.size() - 1];
272
273 for (int nChunkId = 0; nChunkId < nChunksNum; ++nChunkId)
274 {
275 int nStartSecId = nChunkId * MAX_TRAPEZOIDS_IN_CHUNK;
276 int nSectorsNum = min(MAX_TRAPEZOIDS_IN_CHUNK, (int)m_sectors.size() - nStartSecId);
277
278 if (!nSectorsNum)
279 break;
280
281 CRoadSector& sectorFirst = m_sectors[nStartSecId];
282
283 // make render node
284 if (!sectorFirst.m_pRoadSector)
285 sectorFirst.m_pRoadSector = GetIEditorImpl()->Get3DEngine()->CreateRenderNode(eERType_Road);
286 if (!sectorFirst.m_pRoadSector)
287 return;
288 int renderFlags = 0;
289 if (CheckFlags(OBJFLAG_INVISIBLE) || IsHiddenBySpec())
290 renderFlags = ERF_HIDDEN;
291 sectorFirst.m_pRoadSector->SetRndFlags(renderFlags);
292 sectorFirst.m_pRoadSector->SetViewDistRatio(mv_ratioViewDist);
293 sectorFirst.m_pRoadSector->SetMinSpec(GetMinSpec());
294 sectorFirst.m_pRoadSector->SetMaterialLayers(GetMaterialLayersMask());
295 sectorFirst.m_pRoadSector->SetEditorObjectId(GetId().hipart >> 32);
296
297 // make list of verts
298 PodArray<Vec3> lstPoints;
299 for (int i = 0; i < nSectorsNum; ++i)
300 {
301 lstPoints.Add(m_sectors[nStartSecId + i].points[0]);
302 lstPoints.Add(m_sectors[nStartSecId + i].points[1]);
303 }
304
305 CRoadSector& sectorLast = m_sectors[nStartSecId + nSectorsNum - 1];
306
307 // Extend final boundary to cover holes in roads caused by f16 meshes.
308 // Overlapping the roads slightly seems to be the nicest way to fix the issue
309 Vec3 sectorLastOffset2 = sectorLast.points[2] - sectorLast.points[0];
310 Vec3 sectorLastOffset3 = sectorLast.points[3] - sectorLast.points[1];
311
312 sectorLastOffset2.Normalize();
313 sectorLastOffset3.Normalize();
314
315 const float sectorLastOffset = 0.075f;
316 sectorLastOffset2 *= sectorLastOffset;
317 sectorLastOffset3 *= sectorLastOffset;
318
319 lstPoints.Add(sectorLast.points[2] + sectorLastOffset2);
320 lstPoints.Add(sectorLast.points[3] + sectorLastOffset3);
321
322 //assert(lstPoints.Count()>=4);
323 assert(!(lstPoints.Count() & 1));
324
325 IRoadRenderNode* pRoadRN = static_cast<IRoadRenderNode*>(sectorFirst.m_pRoadSector);
326 pRoadRN->SetVertices(lstPoints.GetElements(), lstPoints.Count(), fabs(sectorFirst.t0), fabs(sectorLast.t1), fabs(sectorFirstGlobal.t0), fabs(sectorLastGlobal.t1));
327 pRoadRN->SetSortPriority(mv_sortPrio);
328 pRoadRN->SetIgnoreTerrainHoles(m_ignoreTerrainHoles);
329 pRoadRN->SetPhysicalize(m_physicalize);
330
331 if (GetMaterial())
332 ((CMaterial*)GetMaterial())->AssignToEntity(sectorFirst.m_pRoadSector);
333 else
334 sectorFirst.m_pRoadSector->SetMaterial(NULL);
335 }
336 }
337
338 void CRoadObject::OnEvent(ObjectEvent event)
339 {
340 if (event == EVENT_CONFIG_SPEC_CHANGE)
341 {
342 m_bNeedUpdateSectors = true;
343 UpdateSectors();
344 }
345 __super::OnEvent(event);
346 }
347
348 //////////////////////////////////////////////////////////////////////////
349 void CRoadObject::SetHidden(bool bHidden)
350 {
351 __super::SetHidden(bHidden);
352 UpdateSectors();
353 }
354
355 //////////////////////////////////////////////////////////////////////////
356 void CRoadObject::UpdateVisibility(bool visible)
357 {
358 if (visible == CheckFlags(OBJFLAG_INVISIBLE))
359 {
360 __super::UpdateVisibility(visible);
361 UpdateSectors();
362 }
363 }
364
365 //////////////////////////////////////////////////////////////////////////
366
367 void CRoadObject::RegisterOnEngine()
368 {
369 for (CRoadSectorVector::size_type i = 0; i < m_sectors.size(); ++i)
370 {
371 if (m_sectors[i].m_pRoadSector)
372 {
373 GetIEditorImpl()->Get3DEngine()->RegisterEntity(m_sectors[i].m_pRoadSector);
374 }
375 }
376 }
377
378 //////////////////////////////////////////////////////////////////////////
379
380 void CRoadObject::UnRegisterFromEngine()
381 {
382 for (CRoadSectorVector::size_type i = 0; i < m_sectors.size(); ++i)
383 {
384 if (m_sectors[i].m_pRoadSector)
385 {
386 GetIEditorImpl()->Get3DEngine()->UnRegisterEntityAsJob(m_sectors[i].m_pRoadSector);
387 }
388 }
389 }
390
391 //////////////////////////////////////////////////////////////////////////
392 void CRoadObject::SetMaterial(IEditorMaterial* pMaterial)
393 {
394 CMaterial* pPrevMaterial = (CMaterial*)GetMaterial();
395 __super::SetMaterial(pMaterial);
396
397 if (pPrevMaterial != pMaterial)
398 UpdateSectors();
399 }
400
401 //////////////////////////////////////////////////////////////////////////
402 void CRoadObject::DrawSectorLines(DisplayContext& dc)
403 {
404 const Matrix34& wtm = GetWorldTM();
405 float fPointSize = 0.5f;
406
407 dc.SetColor(RGB(127, 127, 255));
408 for (size_t i = 0; i < m_sectors.size(); ++i)
409 {
410 dc.DrawLine(m_sectors[i].points[0], m_sectors[i].points[1]);
411 for (size_t k = 0; k < m_sectors[i].points.size(); k += 2)
412 {
413 if (k + 3 < m_sectors[i].points.size())
414 {
415 dc.DrawLine(m_sectors[i].points[k + 1], m_sectors[i].points[k + 3]);
416 dc.DrawLine(m_sectors[i].points[k + 3], m_sectors[i].points[k + 2]);
417 dc.DrawLine(m_sectors[i].points[k + 2], m_sectors[i].points[k]);
418 }
419 }
420 }
421 }
422
423 //////////////////////////////////////////////////////////////////////////
424 void CRoadObject::DrawRoadObject(DisplayContext& dc, COLORREF col)
425 {
426 if (IsSelected())
427 {
428 DrawSectorLines(dc);
429 }
430 }
431
432 //////////////////////////////////////////////////////////////////////////
433 void CRoadObject::Display(CObjectRenderHelper& objRenderHelper)
434 {
435 DisplayContext& dc = objRenderHelper.GetDisplayContextRef();
436
437 if (!gViewportDebugPreferences.showRoadObjectHelper)
438 return;
439
440 COLORREF col = 0;
441
442 if (m_points.size() > 1)
443 {
444 if ((IsSelected() || IsHighlighted()))
445 {
446 col = dc.GetSelectedColor();
447 dc.SetColor(col);
448 }
449 else
450 {
451 if (IsFrozen())
452 dc.SetFreezeColor();
453 else
454 dc.SetColor(GetColor());
455 col = GetColor();
456 }
457
458 DrawRoadObject(dc, col);
459 }
460 __super::Display(objRenderHelper);
461 }
462
463 //////////////////////////////////////////////////////////////////////////
464 void CRoadObject::Serialize(CObjectArchive& ar)
465 {
466 m_bIgnoreParamUpdate = true;
467 m_bNeedUpdateSectors = false;
468 __super::Serialize(ar);
469 m_bNeedUpdateSectors = true;
470 m_bIgnoreParamUpdate = false;
471 if (ar.bLoading)
472 UpdateSectors();
473 }
474
475 //////////////////////////////////////////////////////////////////////////
476 XmlNodeRef CRoadObject::Export(const string& levelPath, XmlNodeRef& xmlNode)
477 {
478 //XmlNodeRef objNode = __super::Export( levelPath,xmlNode );
479 //return objNode;
480 return 0;
481 }
482
483 //////////////////////////////////////////////////////////////////////////
484 void CRoadObject::OnParamChange(IVariable* var)
485 {
486 if (!m_bIgnoreParamUpdate)
487 SetRoadSectors();
488 }
489
490 //////////////////////////////////////////////////////////////////////////
491 void CRoadObject::SetSelected(bool bSelect)
492 {
493 __super::SetSelected(bSelect);
494 SetRoadSectors();
495 }
496
497 //////////////////////////////////////////////////////////////////////////
498 void CRoadObject::AlignHeightMap()
499 {
500 if (!GetIEditorImpl()->GetIUndoManager()->IsUndoRecording())
501 GetIEditorImpl()->GetIUndoManager()->Begin();
502
503 CHeightmap* heightmap = GetIEditorImpl()->GetHeightmap();
504 float unitSize = heightmap->GetUnitSize();
505 const Matrix34& wtm = GetWorldTM();
506
507 int minx = 0, miny = 0, maxx = 0, maxy = 0;
508 bool bIsInitMinMax = false;
509
510 const int nPoints = GetPointCount();
511
512 for (int i = 0; i < nPoints - 1; ++i)
513 {
514 float fminx = 0, fminy = 0, fmaxx = 0, fmaxy = 0;
515 bool bIsInitminmax = false;
516 int kn = int (0.5f + (GetBezierSegmentLength(i) + 1) * 4);
517
518 Vec3 tmp;
519
520 for (int k = 0; k <= kn; ++k)
521 {
522 float t = float(k) / kn;
523 Vec3 p = GetBezierPos(i, t);
524 Vec3 n = GetLocalBezierNormal(i, t);
525
526 float fWidth = GetLocalWidth(i, t);
527 if (fWidth < 2)
528 fWidth = 2;
529
530 Vec3 p1 = p - (0.5f * fWidth + mv_borderWidth + 0.5f * unitSize) * n;
531 Vec3 p2 = p + (0.5f * fWidth + mv_borderWidth + 0.5f * unitSize) * n;
532
533 p1 = wtm.TransformPoint(p1);
534 p2 = wtm.TransformPoint(p2);
535
536 tmp = p1;
537
538 if (!bIsInitminmax)
539 {
540 fminx = p1.x;
541 fminy = p1.y;
542 fmaxx = p1.x;
543 fmaxy = p1.y;
544 bIsInitminmax = true;
545 }
546 fminx = min(fminx, p1.x);
547 fminx = min(fminx, p2.x);
548 fminy = min(fminy, p1.y);
549 fminy = min(fminy, p2.y);
550 fmaxx = max(fmaxx, p1.x);
551 fmaxx = max(fmaxx, p2.x);
552 fmaxy = max(fmaxy, p1.y);
553 fmaxy = max(fmaxy, p2.y);
554 }
555
556 heightmap->RecordUndo(int(fminy / unitSize) - 1, int(fminx / unitSize) - 1, int(fmaxy / unitSize) + unitSize - int(fminy / unitSize) + 1, int(fmaxx / unitSize) + unitSize - int(fminx / unitSize) + 1);
557
558 for (int ty = int(fminx / unitSize); ty <= int(fmaxx / unitSize) + unitSize; ++ty)
559 for (int tx = int(fminy / unitSize); tx <= int(fmaxy / unitSize) + unitSize; ++tx)
560 {
561 int x = ty * unitSize;
562 int y = tx * unitSize;
563
564 Vec3 p3 = Vec3(x, y, 0.0f);
565
566 int findk = -1;
567 float fWidth = GetLocalWidth(i, 0);
568 float fWidth1 = GetLocalWidth(i, 1);
569 if (fWidth < fWidth1)
570 fWidth = fWidth1;
571 float mind = 0.5f * fWidth + mv_borderWidth + 0.5f * unitSize;
572
573 for (int k = 0; k < kn; ++k)
574 {
575 float t = float(k) / kn;
576 Vec3 p1 = wtm.TransformPoint(GetBezierPos(i, t));
577 Vec3 p2 = wtm.TransformPoint(GetBezierPos(i, t + 1.0f / kn));
578 p1.z = 0.0f;
579 p2.z = 0.0f;
580
581 //Vec3 d = p2 - p1;
582 //float u = d.Dot(p3-p1) / (d).GetLengthSquared();
583 //if (-0.1f <= u && u <=1.1f)
584 //{
585 float d = PointToLineDistance(p1, p2, p3);
586 if (d < mind)
587 {
588 findk = k;
589 mind = d;
590 }
591 //}
592 }
593
594 if (findk != -1)
595 {
596 float t = float(findk) / kn;
597
598 float st = 1.0f / kn;
599 int sign = 1;
600 for (int tt = 0; tt < 24; ++tt)
601 {
602 Vec3 p0 = wtm.TransformPoint(GetBezierPos(i, t));
603 ;
604 p0.z = 0.0f;
605
606 Vec3 ploc = GetBezierPos(i, t);
607 Vec3 nloc = GetLocalBezierNormal(i, t);
608
609 Vec3 p1 = wtm.TransformPoint(ploc - nloc);
610 p1.z = 0.0f;
611
612 if (((p0 - p1).Cross(p3 - p1).z) < 0.0f)
613 sign = 1;
614 else
615 sign = -1;
616
617 st /= 1.618f;
618 t = t + sign * st;
619 }
620
621 if (t < 0.0f || t > 1.0f)
622 continue;
623
624 Vec3 p1 = wtm.TransformPoint(GetBezierPos(i, t));
625 Vec3 p2 = wtm.TransformPoint(GetBezierPos(i, t + 1.0f / kn));
626
627 Vec3 p1_0 = p1;
628 p1_0.z = 0.0f;
629 p2.z = 0.0f;
630 Vec3 p = Vec3(x, y, 0.0f);
631 Vec3 e = (p2 - p1_0).Cross(p1_0 - p);
632
633 Vec3 p1loc = GetBezierPos(i, t);
634 Vec3 nloc = GetLocalBezierNormal(i, t);
635
636 Vec3 n = wtm.TransformPoint(p1loc - nloc) - p1;
637 n.Normalize();
638
639 Vec3 nproj = n;
640 nproj.z = 0.0f;
641
642 float kof = nproj.GetLength();
643
644 float length = (p1_0 - p).GetLength() / kof;
645
646 Vec3 pos;
647
648 if (e.z < 0.0f)
649 pos = p1 - length * n;
650 else
651 pos = p1 + length * n;
652
653 float fWidth = GetLocalWidth(i, t);
654 if (length <= fWidth / 2 + mv_borderWidth + 0.5 * unitSize)
655 {
656 //int tx = pos_directed_rounding(y / unitSize);
657 //int ty = pos_directed_rounding(x / unitSize);
658
659 float z;
660 if (length <= fWidth / 2 + 0.5 * unitSize)
661 z = pos.z;
662 else
663 {
664 //continue;
665 float kof = (length - (fWidth / 2 + 0.5 * unitSize)) / mv_borderWidth;
666 kof = 1.0f - (cos(kof * 3.141593f) + 1.0f) / 2;
667 float z1 = heightmap->GetXY(tx, ty);
668 z = kof * z1 + (1.0f - kof) * pos.z;
669 }
670
671 heightmap->SetXY(tx, ty, clamp_tpl(z, 0.0f, heightmap->GetMaxHeight()));
672
673 if (!bIsInitMinMax)
674 {
675 minx = tx;
676 miny = ty;
677 maxx = tx;
678 maxy = ty;
679 bIsInitMinMax = true;
680 }
681 if (minx > tx) minx = tx;
682 if (miny > ty) miny = ty;
683 if (maxx < tx) maxx = tx;
684 if (maxy < ty) maxy = ty;
685 }
686 }
687 }
688 //break;
689 }
690
691 int w = maxx - minx;
692 if (w < maxy - miny) w = maxy - miny;
693 heightmap->UpdateEngineTerrain(minx, miny, w, w, CHeightmap::ETerrainUpdateType::Elevation);
694
695 if (GetIEditorImpl()->GetIUndoManager()->IsUndoRecording())
696 GetIEditorImpl()->GetIUndoManager()->Accept("Heightmap Aligning");
697
698 SetRoadSectors();
699 }
700
701 //////////////////////////////////////////////////////////////////////////
702 void CRoadObject::EraseVegetation()
703 {
704 if (CVegetationMap* vegetationMap = GetIEditorImpl()->GetVegetationMap())
705 {
706 if (!GetIEditorImpl()->GetIUndoManager()->IsUndoRecording())
707 GetIEditorImpl()->GetIUndoManager()->Begin();
708
709 bool bModified = false;
710
711 vegetationMap->StoreBaseUndo(CVegetationMap::eStoreUndo_Begin);
712
713 const Matrix34& wtm = GetWorldTM();
714 const int nPoints = GetPointCount();
715 const float fEraseWidth = mv_eraseVegWidth + mv_eraseVegWidthVar * 0.5f;
716 const float fSpareWidth = 5.0f;
717
718 for (int i = 0; i < nPoints - 1; ++i)
719 {
720 const int nSegment = GetBezierSegmentLength(i);
721 const int nSector = GetRoadSectorCount(i);
722
723 for (int k = 0; k < nSector; ++k)
724 {
725 const float t1 = float(k) / nSector;
726 const float t2 = float(k + 1) / nSector;
727
728 const Vec3 p1 = GetBezierPos(i, t1);
729 const Vec3 n1 = GetLocalBezierNormal(i, t1);
730 const Vec3 p2 = GetBezierPos(i, t2);
731 const Vec3 n2 = GetLocalBezierNormal(i, t2);
732
733 const float fRoadWidth1 = GetLocalWidth(i, t1);
734 const float fRoadWidth2 = GetLocalWidth(i, t2);
735
736 const Vec3 r1(wtm.TransformPoint(p1 - (0.5f * fRoadWidth1 + fEraseWidth + fSpareWidth) * n1));
737 const Vec3 l1(wtm.TransformPoint(p1 + (0.5f * fRoadWidth1 + fEraseWidth + fSpareWidth) * n1));
738 const Vec3 r2(wtm.TransformPoint(p2 - (0.5f * fRoadWidth2 + fEraseWidth + fSpareWidth) * n2));
739 const Vec3 l2(wtm.TransformPoint(p2 + (0.5f * fRoadWidth2 + fEraseWidth + fSpareWidth) * n2));
740
741 const float fminx = min(r1.x, min(l1.x, min(r2.x, l2.x)));
742 const float fminy = min(r1.y, min(l1.y, min(r2.y, l2.y)));
743 const float fmaxx = max(r1.x, max(l1.x, max(r2.x, l2.x)));
744 const float fmaxy = max(r1.y, max(l1.y, max(r2.y, l2.y)));
745
746 std::vector<CVegetationInstance*> instances;
747 vegetationMap->GetObjectInstances(fminx, fminy, fmaxx, fmaxy, instances);
748
749 const int segmentStart = k * nSegment / nSector;
750 const int segmentEnd = (k + 1) * nSegment / nSector;
751
752 for (std::vector<CVegetationInstance*>::iterator it = instances.begin(); it != instances.end(); ++it)
753 {
754 float fFinalEraseWidth = fEraseWidth;
755
756 if (mv_eraseVegWidthVar != 0.f)
757 {
758 fFinalEraseWidth -= float(rand() % int(mv_eraseVegWidthVar * 10.f)) * 0.1f;
759 }
760 if (CVegetationObject* obj = (*it)->object)
761 {
762 fFinalEraseWidth += obj->GetObjectSize() * 0.5f;
763 }
764 for (int l = segmentStart; l < segmentEnd; ++l)
765 {
766 const float ts = float(l) / nSegment;
767 const float fWidth = 0.5f * GetLocalWidth(i, ts) + fFinalEraseWidth;
768
769 const Vec2 pos1(wtm.TransformPoint(GetBezierPos(i, ts)));
770 const Vec2 pos2((*it)->pos);
771
772 const float fDistance = pos1.GetDistance(pos2);
773
774 if (fDistance <= fWidth)
775 {
776 vegetationMap->StoreBaseUndo(CVegetationMap::eStoreUndo_Once);
777 vegetationMap->DeleteObjInstance(*it);
778
779 if (!bModified)
780 {
781 GetIEditorImpl()->SetModifiedFlag();
782 bModified = true;
783 }
784 break;
785 }
786 }
787 }
788 }
789 }
790 vegetationMap->StoreBaseUndo(CVegetationMap::eStoreUndo_End);
791
792 if (GetIEditorImpl()->GetIUndoManager()->IsUndoRecording())
793 {
794 if (bModified)
795 {
796 GetIEditorImpl()->GetIUndoManager()->Accept("Erase Vegetation On Road");
797 }
798 else
799 {
800 GetIEditorImpl()->GetIUndoManager()->Cancel();
801 }
802 }
803 }
804 }
805
806 //////////////////////////////////////////////////////////////////////////
807 void CRoadObject::SetMinSpec(uint32 nSpec, bool bSetChildren)
808 {
809 __super::SetMinSpec(nSpec, bSetChildren);
810 UpdateSectors();
811 }
812
813 //////////////////////////////////////////////////////////////////////////
814 void CRoadObject::SetMaterialLayersMask(uint32 nLayersMask)
815 {
816 __super::SetMaterialLayersMask(nLayersMask);
817 UpdateSectors();
818 }
819
820 //////////////////////////////////////////////////////////////////////////
821 void CRoadObject::SetLayerId(uint16 nLayerId)
822 {
823 for (size_t i = 0; i < m_sectors.size(); ++i)
824 {
825 if (m_sectors[i].m_pRoadSector)
826 m_sectors[i].m_pRoadSector->SetLayerId(nLayerId);
827 }
828 }
829
830 void CRoadObject::UpdateHighlightPassState(bool bSelected, bool bHighlighted)
831 {
832 for (size_t i = 0; i < m_sectors.size(); ++i)
833 {
834 if (m_sectors[i].m_pRoadSector)
835 m_sectors[i].m_pRoadSector->SetEditorObjectInfo(bSelected, bHighlighted);
836 }
837 }
838
839
840 //////////////////////////////////////////////////////////////////////////
841 void CRoadObject::SetPhysics(bool isPhysics)
842 {
843 for (size_t i = 0; i < m_sectors.size(); ++i)
844 {
845 IRenderNode* pRenderNode = m_sectors[i].m_pRoadSector;
846 if (pRenderNode)
847 {
848 if (isPhysics)
849 pRenderNode->SetRndFlags(pRenderNode->GetRndFlags() & ~ERF_NO_PHYSICS);
850 else
851 pRenderNode->SetRndFlags(pRenderNode->GetRndFlags() | ERF_NO_PHYSICS);
852 }
853 }
854 }
855
856 //////////////////////////////////////////////////////////////////////////
857 // Class Description of RoadObject.
858
859 //////////////////////////////////////////////////////////////////////////
860 class CRoadObjectClassDesc : public CObjectClassDesc
861 {
862 public:
863 ObjectType GetObjectType() { return OBJTYPE_ROAD; };
864 const char* ClassName() { return "Road"; };
865 const char* Category() { return "Misc"; };
866 CRuntimeClass* GetRuntimeClass() { return RUNTIME_CLASS(CRoadObject); };
867 };
868
869 REGISTER_CLASS_DESC(CRoadObjectClassDesc);
CRYENGINE is a powerful real-time game development platform created by Crytek.