This file is indexed.

/usr/src/castle-game-engine-4.1.1/x3d/x3dnodes_coordpolygons.inc is in castle-game-engine-src 4.1.1-1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
type
  { Common utility class for nodes that implement CoordPolygons
    by calling MakeCoordRanges,
    and then doing the work inside HandleCoordRange. }
  TCoordRangePolygonizer = class
    Polygon: TIndexedPolygonHandler;

    { This should be overridden to call Polygon procedure. }
    procedure HandleCoordRange(const RangeNumber: Cardinal;
      BeginIndex, EndIndex: Integer); virtual; abstract;
  end;

{ TriangleFanSet ------------------------------------------------------------- }

type
  TTriangleFanSetPolygonizer = class(TCoordRangePolygonizer)
    procedure HandleCoordRange(const RangeNumber: Cardinal;
      BeginIndex, EndIndex: Integer); override;
  end;

procedure TTriangleFanSetPolygonizer.HandleCoordRange(
  const RangeNumber: Cardinal;
  BeginIndex, EndIndex: Integer);
var
  FirstIndex: Integer;
begin
  FirstIndex := BeginIndex;

  while BeginIndex + 2 < EndIndex do
  begin
    Polygon([FirstIndex, BeginIndex + 1, BeginIndex + 2]);
    Inc(BeginIndex);
  end;
end;

procedure TIndexedTriangleFanSetNode.CoordPolygons(
  State: TX3DGraphTraverseState;
  PolygonHandler: TIndexedPolygonHandler);
var
  Polygonizer: TTriangleFanSetPolygonizer;
begin
  Polygonizer := TTriangleFanSetPolygonizer.Create;
  try
    Polygonizer.Polygon := PolygonHandler;
    MakeCoordRanges(State, @Polygonizer.HandleCoordRange);
  finally FreeAndNil(Polygonizer) end;
end;

procedure TTriangleFanSetNode.CoordPolygons(
  State: TX3DGraphTraverseState;
  PolygonHandler: TIndexedPolygonHandler);
var
  Polygonizer: TTriangleFanSetPolygonizer;
begin
  Polygonizer := TTriangleFanSetPolygonizer.Create;
  try
    Polygonizer.Polygon := PolygonHandler;
    MakeCoordRanges(State, @Polygonizer.HandleCoordRange);
  finally FreeAndNil(Polygonizer) end;
end;

{ TriangleStripSet ----------------------------------------------------------- }

type
  TTriangleStripSetPolygonizer = class(TCoordRangePolygonizer)
    procedure HandleCoordRange(const RangeNumber: Cardinal;
      BeginIndex, EndIndex: Integer); override;
  end;

procedure TTriangleStripSetPolygonizer.HandleCoordRange(
  const RangeNumber: Cardinal;
  BeginIndex, EndIndex: Integer);
var
  NormalOrder: boolean;
begin
  NormalOrder := true;

  while BeginIndex + 2 < EndIndex do
  begin
    if NormalOrder then
      Polygon([BeginIndex    , BeginIndex + 1, BeginIndex + 2]) else
      Polygon([BeginIndex + 1, BeginIndex    , BeginIndex + 2]);
    Inc(BeginIndex);
    NormalOrder := not NormalOrder;
  end;
end;

procedure TIndexedTriangleStripSetNode.CoordPolygons(
  State: TX3DGraphTraverseState;
  PolygonHandler: TIndexedPolygonHandler);
var
  Polygonizer: TTriangleStripSetPolygonizer;
begin
  Polygonizer := TTriangleStripSetPolygonizer.Create;
  try
    Polygonizer.Polygon := PolygonHandler;
    MakeCoordRanges(State, @Polygonizer.HandleCoordRange);
  finally FreeAndNil(Polygonizer) end;
end;

procedure TTriangleStripSetNode.CoordPolygons(
  State: TX3DGraphTraverseState;
  PolygonHandler: TIndexedPolygonHandler);
var
  Polygonizer: TTriangleStripSetPolygonizer;
begin
  Polygonizer := TTriangleStripSetPolygonizer.Create;
  try
    Polygonizer.Polygon := PolygonHandler;
    MakeCoordRanges(State, @Polygonizer.HandleCoordRange);
  finally FreeAndNil(Polygonizer) end;
end;

procedure TIndexedTriangleMeshNode_1.CoordPolygons(
  State: TX3DGraphTraverseState;
  PolygonHandler: TIndexedPolygonHandler);
var
  Polygonizer: TTriangleStripSetPolygonizer;
begin
  Polygonizer := TTriangleStripSetPolygonizer.Create;
  try
    Polygonizer.Polygon := PolygonHandler;
    MakeCoordRanges(State, @Polygonizer.HandleCoordRange);
  finally FreeAndNil(Polygonizer) end;
end;

{ TriangleSet ---------------------------------------------------------------- }

procedure TriangleSetPolygonizer(
  const CoordCount: Cardinal;
  PolygonHandler: TIndexedPolygonHandler);
var
  I: Cardinal;
begin
  I := 0;
  while I + 2 < CoordCount do
  begin
    PolygonHandler([I, I + 1, I + 2]);
    I += 3;
  end;
end;

procedure TIndexedTriangleSetNode.CoordPolygons(
  State: TX3DGraphTraverseState;
  PolygonHandler: TIndexedPolygonHandler);
begin
  if Coordinates(State) <> nil then
    TriangleSetPolygonizer(CoordIndex.Count, PolygonHandler);
end;

procedure TTriangleSetNode.CoordPolygons(
  State: TX3DGraphTraverseState;
  PolygonHandler: TIndexedPolygonHandler);
var
  ACoord: TMFVec3f;
begin
  ACoord := Coordinates(State);
  if ACoord <> nil then
    TriangleSetPolygonizer(ACoord.Count, PolygonHandler);
end;

{ QuadSet ---------------------------------------------------------------- }

procedure QuadSetPolygonizer(
  const CoordCount: Cardinal;
  PolygonHandler: TIndexedPolygonHandler);
var
  I: Cardinal;
begin
  I := 0;
  while I + 3 < CoordCount do
  begin
    PolygonHandler([I, I + 1, I + 2, I + 3]);
    I += 4;
  end;
end;

procedure TIndexedQuadSetNode.CoordPolygons(
  State: TX3DGraphTraverseState;
  PolygonHandler: TIndexedPolygonHandler);
begin
  if Coordinates(State) <> nil then
    QuadSetPolygonizer(CoordIndex.Count, PolygonHandler);
end;

procedure TQuadSetNode.CoordPolygons(
  State: TX3DGraphTraverseState;
  PolygonHandler: TIndexedPolygonHandler);
var
  ACoord: TMFVec3f;
begin
  ACoord := Coordinates(State);
  if ACoord <> nil then
    QuadSetPolygonizer(ACoord.Count, PolygonHandler);
end;

{ TriangleFanSet ------------------------------------------------------------- }

type
  TIndexedFaceSetPolygonizer = class(TCoordRangePolygonizer)
    procedure HandleCoordRange(const RangeNumber: Cardinal;
      BeginIndex, EndIndex: Integer); override;
  end;

procedure TIndexedFaceSetPolygonizer.HandleCoordRange(
  const RangeNumber: Cardinal;
  BeginIndex, EndIndex: Integer);
var
  Indexes: array of Cardinal;
  I: Cardinal;
begin
  SetLength(Indexes, EndIndex - BeginIndex);
  if High(Indexes) >= 0 then
    for I := 0 to High(Indexes) do
      Indexes[I] := I + Cardinal(BeginIndex);
  Polygon(Indexes);
end;

procedure TIndexedFaceSetNode_1.CoordPolygons(
  State: TX3DGraphTraverseState;
  PolygonHandler: TIndexedPolygonHandler);
var
  Polygonizer: TIndexedFaceSetPolygonizer;
begin
  Polygonizer := TIndexedFaceSetPolygonizer.Create;
  try
    Polygonizer.Polygon := PolygonHandler;
    MakeCoordRanges(State, @Polygonizer.HandleCoordRange);
  finally FreeAndNil(Polygonizer) end;
end;

procedure TIndexedFaceSetNode.CoordPolygons(
  State: TX3DGraphTraverseState;
  PolygonHandler: TIndexedPolygonHandler);
var
  Polygonizer: TIndexedFaceSetPolygonizer;
begin
  Polygonizer := TIndexedFaceSetPolygonizer.Create;
  try
    Polygonizer.Polygon := PolygonHandler;
    MakeCoordRanges(State, @Polygonizer.HandleCoordRange);
  finally FreeAndNil(Polygonizer) end;
end;