framework/referencerenderer/rrRenderer.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program Reference Renderer
   3  * -----------------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Reference renderer interface.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "rrRenderer.hpp"
  25 #include "tcuVectorUtil.hpp"
  26 #include "tcuTextureUtil.hpp"
  27 #include "tcuFloat.hpp"
  28 #include "rrPrimitiveAssembler.hpp"
  29 #include "rrFragmentOperations.hpp"
  30 #include "rrRasterizer.hpp"
  31 #include "deMemory.h"
  32
  33 #include <set>
  34
  35 namespace rr
  36 {
  37 namespace
  38 {
  39
  40 typedef double ClipFloat; // floating point type used in clipping
  41
  42 typedef tcu::Vector<ClipFloat, 4> ClipVec4;
  43
  44 struct RasterizationInternalBuffers
  45 {
  46         std::vector<FragmentPacket>             fragmentPackets;
  47         std::vector<GenericVec4>                shaderOutputs;
  48         std::vector<Fragment>                   shadedFragments;
  49         float*                                                  fragmentDepthBuffer;
  50 };
  51
  52 deUint32 readIndexArray (const IndexType type, const void* ptr, size_t ndx)
  53 {
  54         switch (type)
  55         {
  56                 case INDEXTYPE_UINT8:
  57                         return ((const deUint8*)ptr)[ndx];
  58
  59                 case INDEXTYPE_UINT16:
  60                 {
  61                         deUint16 retVal;
  62                         deMemcpy(&retVal, (const deUint8*)ptr + ndx * sizeof(deUint16), sizeof(deUint16));
  63
  64                         return retVal;
  65                 }
  66
  67                 case INDEXTYPE_UINT32:
  68                 {
  69                         deUint32 retVal;
  70                         deMemcpy(&retVal, (const deUint8*)ptr + ndx * sizeof(deUint32), sizeof(deUint32));
  71
  72                         return retVal;
  73                 }
  74
  75                 default:
  76                         DE_ASSERT(false);
  77                         return 0;
  78         }
  79 }
  80
  81 tcu::IVec4 getBufferSize (const rr::MultisampleConstPixelBufferAccess& multisampleBuffer)
  82 {
  83         return tcu::IVec4(0, 0, multisampleBuffer.raw().getHeight(), multisampleBuffer.raw().getDepth());
  84 }
  85
  86 bool isEmpty (const rr::MultisampleConstPixelBufferAccess& access)
  87 {
  88         return access.raw().getWidth() == 0 || access.raw().getHeight() == 0 || access.raw().getDepth() == 0;
  89 }
  90
  91 struct DrawContext
  92 {
  93         int primitiveID;
  94
  95         DrawContext (void)
  96                 : primitiveID(0)
  97         {
  98         }
  99 };
 100
 101 /*--------------------------------------------------------------------*//*!
 102  * \brief Calculates intersection of two rects given as (left, bottom, width, height)
 103  *//*--------------------------------------------------------------------*/
 104 tcu::IVec4 rectIntersection (const tcu::IVec4& a, const tcu::IVec4& b)
 105 {
 106         const tcu::IVec2 pos    = tcu::IVec2(de::max(a.x(), b.x()), de::max(a.y(), b.y()));
 107         const tcu::IVec2 endPos = tcu::IVec2(de::min(a.x() + a.z(), b.x() + b.z()), de::min(a.y() + a.w(), b.y() + b.w()));
 108
 109         return tcu::IVec4(pos.x(), pos.y(), endPos.x() - pos.x(), endPos.y() - pos.y());
 110 }
 111
 112 void convertPrimitiveToBaseType(std::vector<pa::Triangle>& output, std::vector<pa::Triangle>& input)
 113 {
 114         std::swap(output, input);
 115 }
 116
 117 void convertPrimitiveToBaseType(std::vector<pa::Line>& output, std::vector<pa::Line>& input)
 118 {
 119         std::swap(output, input);
 120 }
 121
 122 void convertPrimitiveToBaseType(std::vector<pa::Point>& output, std::vector<pa::Point>& input)
 123 {
 124         std::swap(output, input);
 125 }
 126
 127 void convertPrimitiveToBaseType(std::vector<pa::Line>& output, std::vector<pa::LineAdjacency>& input)
 128 {
 129         output.resize(input.size());
 130         for (size_t i = 0; i < input.size(); ++i)
 131         {
 132                 const int adjacentProvokingVertex       = input[i].provokingIndex;
 133                 const int baseProvokingVertexIndex      = adjacentProvokingVertex-1;
 134                 output[i] = pa::Line(input[i].v1, input[i].v2, baseProvokingVertexIndex);
 135         }
 136 }
 137
 138 void convertPrimitiveToBaseType(std::vector<pa::Triangle>& output, std::vector<pa::TriangleAdjacency>& input)
 139 {
 140         output.resize(input.size());
 141         for (size_t i = 0; i < input.size(); ++i)
 142         {
 143                 const int adjacentProvokingVertex       = input[i].provokingIndex;
 144                 const int baseProvokingVertexIndex      = adjacentProvokingVertex/2;
 145                 output[i] = pa::Triangle(input[i].v0, input[i].v2, input[i].v4, baseProvokingVertexIndex);
 146         }
 147 }
 148
 149 namespace cliputil
 150 {
 151
 152 /*--------------------------------------------------------------------*//*!
 153  * \brief Get clipped portion of the second endpoint
 154  *
 155  * Calculate the intersection of line segment v0-v1 and a given plane. Line
 156  * segment is defined by a pair of one-dimensional homogeneous coordinates.
 157  *
 158  *//*--------------------------------------------------------------------*/
 159 ClipFloat getSegmentVolumeEdgeClip (const ClipFloat v0,
 160                                                                         const ClipFloat w0,
 161                                                                         const ClipFloat v1,
 162                                                                         const ClipFloat w1,
 163                                                                         const ClipFloat plane)
 164 {
 165         return (plane*w0 - v0) / ((v1 - v0) - plane*(w1 - w0));
 166 }
 167
 168 /*--------------------------------------------------------------------*//*!
 169  * \brief Get clipped portion of the endpoint
 170  *
 171  * How much (in [0-1] range) of a line segment v0-v1 would be clipped
 172  * of the v0 end of the line segment by clipping.
 173  *//*--------------------------------------------------------------------*/
 174 ClipFloat getLineEndpointClipping (const ClipVec4& v0, const ClipVec4& v1)
 175 {
 176         const ClipFloat clipVolumeSize = (ClipFloat)1.0;
 177
 178         if (v0.z() > v0.w())
 179         {
 180                 // Clip +Z
 181                 return getSegmentVolumeEdgeClip(v0.z(), v0.w(), v1.z(), v1.w(), clipVolumeSize);
 182         }
 183         else if (v0.z() < -v0.w())
 184         {
 185                 // Clip -Z
 186                 return getSegmentVolumeEdgeClip(v0.z(), v0.w(), v1.z(), v1.w(), -clipVolumeSize);
 187         }
 188         else
 189         {
 190                 // no clipping
 191                 return (ClipFloat)0.0;
 192         }
 193 }
 194
 195 ClipVec4 vec4ToClipVec4 (const tcu::Vec4& v)
 196 {
 197         return ClipVec4((ClipFloat)v.x(), (ClipFloat)v.y(), (ClipFloat)v.z(), (ClipFloat)v.w());
 198 }
 199
 200 tcu::Vec4 clipVec4ToVec4 (const ClipVec4& v)
 201 {
 202         return tcu::Vec4((float)v.x(), (float)v.y(), (float)v.z(), (float)v.w());
 203 }
 204
 205 class ClipVolumePlane
 206 {
 207 public:
 208         virtual bool            pointInClipVolume                       (const ClipVec4& p) const                                               = 0;
 209         virtual ClipFloat       clipLineSegmentEnd                      (const ClipVec4& v0, const ClipVec4& v1) const  = 0;
 210         virtual ClipVec4        getLineIntersectionPoint        (const ClipVec4& v0, const ClipVec4& v1) const  = 0;
 211 };
 212
 213 template <int Sign, int CompNdx>
 214 class ComponentPlane : public ClipVolumePlane
 215 {
 216         DE_STATIC_ASSERT(Sign == +1 || Sign == -1);
 217
 218 public:
 219         bool            pointInClipVolume                       (const ClipVec4& p) const;
 220         ClipFloat       clipLineSegmentEnd                      (const ClipVec4& v0, const ClipVec4& v1) const;
 221         ClipVec4        getLineIntersectionPoint        (const ClipVec4& v0, const ClipVec4& v1) const;
 222 };
 223
 224 template <int Sign, int CompNdx>
 225 bool ComponentPlane<Sign, CompNdx>::pointInClipVolume (const ClipVec4& p) const
 226 {
 227         const ClipFloat clipVolumeSize = (ClipFloat)1.0;
 228
 229         return (ClipFloat)(Sign * p[CompNdx]) <= clipVolumeSize * p.w();
 230 }
 231
 232 template <int Sign, int CompNdx>
 233 ClipFloat ComponentPlane<Sign, CompNdx>::clipLineSegmentEnd (const ClipVec4& v0, const ClipVec4& v1) const
 234 {
 235         const ClipFloat clipVolumeSize = (ClipFloat)1.0;
 236
 237         return getSegmentVolumeEdgeClip(v0[CompNdx], v0.w(),
 238                                                                         v1[CompNdx], v1.w(),
 239                                                                         (ClipFloat)Sign * clipVolumeSize);
 240 }
 241
 242 template <int Sign, int CompNdx>
 243 ClipVec4 ComponentPlane<Sign, CompNdx>::getLineIntersectionPoint (const ClipVec4& v0, const ClipVec4& v1) const
 244 {
 245         // A point on line might be far away, causing clipping ratio (clipLineSegmentEnd) to become extremely close to 1.0
 246         // even if the another point is not on the plane. Prevent clipping ratio from saturating by using points on line
 247         // that are (nearly) on this and (nearly) on the opposite plane.
 248
 249         const ClipVec4  clippedV0       = tcu::mix(v0, v1, ComponentPlane<+1, CompNdx>().clipLineSegmentEnd(v0, v1));
 250         const ClipVec4  clippedV1       = tcu::mix(v0, v1, ComponentPlane<-1, CompNdx>().clipLineSegmentEnd(v0, v1));
 251         const ClipFloat clipRatio       = clipLineSegmentEnd(clippedV0, clippedV1);
 252
 253         // Find intersection point of line from v0 to v1 and the current plane. Avoid ratios near 1.0
 254         if (clipRatio <= (ClipFloat)0.5)
 255                 return tcu::mix(clippedV0, clippedV1, clipRatio);
 256         else
 257         {
 258                 const ClipFloat complementClipRatio = clipLineSegmentEnd(clippedV1, clippedV0);
 259                 return tcu::mix(clippedV1, clippedV0, complementClipRatio);
 260         }
 261 }
 262
 263 struct TriangleVertex
 264 {
 265         ClipVec4        position;
 266         ClipFloat       weight[3];              //!< barycentrics
 267 };
 268
 269 struct SubTriangle
 270 {
 271         TriangleVertex vertices[3];
 272 };
 273
 274 void clipTriangleOneVertex (std::vector<TriangleVertex>& clippedEdges, const ClipVolumePlane& plane, const TriangleVertex& clipped, const TriangleVertex& v1, const TriangleVertex& v2)
 275 {
 276         const ClipFloat degenerateLimit = (ClipFloat)1.0;
 277
 278         // calc clip pos
 279         TriangleVertex  mid1;
 280         TriangleVertex  mid2;
 281         bool                    outputDegenerate = false;
 282
 283         {
 284                 const TriangleVertex&   inside  = v1;
 285                 const TriangleVertex&   outside = clipped;
 286                       TriangleVertex&   middle  = mid1;
 287
 288                 const ClipFloat                 hitDist = plane.clipLineSegmentEnd(inside.position, outside.position);
 289
 290                 if (hitDist >= degenerateLimit)
 291                 {
 292                         // do not generate degenerate triangles
 293                         outputDegenerate = true;
 294                 }
 295                 else
 296                 {
 297                         const ClipVec4 approximatedClipPoint    = tcu::mix(inside.position, outside.position, hitDist);
 298                         const ClipVec4 anotherPointOnLine               = (hitDist > (ClipFloat)0.5) ? (inside.position) : (outside.position);
 299
 300                         middle.position = plane.getLineIntersectionPoint(approximatedClipPoint, anotherPointOnLine);
 301                         middle.weight[0] = tcu::mix(inside.weight[0], outside.weight[0], hitDist);
 302                         middle.weight[1] = tcu::mix(inside.weight[1], outside.weight[1], hitDist);
 303                         middle.weight[2] = tcu::mix(inside.weight[2], outside.weight[2], hitDist);
 304                 }
 305         }
 306
 307         {
 308                 const TriangleVertex&   inside  = v2;
 309                 const TriangleVertex&   outside = clipped;
 310                       TriangleVertex&   middle  = mid2;
 311
 312                 const ClipFloat                 hitDist = plane.clipLineSegmentEnd(inside.position, outside.position);
 313
 314                 if (hitDist >= degenerateLimit)
 315                 {
 316                         // do not generate degenerate triangles
 317                         outputDegenerate = true;
 318                 }
 319                 else
 320                 {
 321                         const ClipVec4 approximatedClipPoint    = tcu::mix(inside.position, outside.position, hitDist);
 322                         const ClipVec4 anotherPointOnLine               = (hitDist > (ClipFloat)0.5) ? (inside.position) : (outside.position);
 323
 324                         middle.position = plane.getLineIntersectionPoint(approximatedClipPoint, anotherPointOnLine);
 325                         middle.weight[0] = tcu::mix(inside.weight[0], outside.weight[0], hitDist);
 326                         middle.weight[1] = tcu::mix(inside.weight[1], outside.weight[1], hitDist);
 327                         middle.weight[2] = tcu::mix(inside.weight[2], outside.weight[2], hitDist);
 328                 }
 329         }
 330
 331         if (!outputDegenerate)
 332         {
 333                 // gen quad (v1) -> mid1 -> mid2 -> (v2)
 334                 clippedEdges.push_back(v1);
 335                 clippedEdges.push_back(mid1);
 336                 clippedEdges.push_back(mid2);
 337                 clippedEdges.push_back(v2);
 338         }
 339         else
 340         {
 341                 // don't modify
 342                 clippedEdges.push_back(v1);
 343                 clippedEdges.push_back(clipped);
 344                 clippedEdges.push_back(v2);
 345         }
 346 }
 347
 348 void clipTriangleTwoVertices (std::vector<TriangleVertex>& clippedEdges, const ClipVolumePlane& plane, const TriangleVertex& v0, const TriangleVertex& clipped1, const TriangleVertex& clipped2)
 349 {
 350         const ClipFloat unclippableLimit = (ClipFloat)1.0;
 351
 352         // calc clip pos
 353         TriangleVertex  mid1;
 354         TriangleVertex  mid2;
 355         bool                    unclippableVertex1 = false;
 356         bool                    unclippableVertex2 = false;
 357
 358         {
 359                 const TriangleVertex&   inside  = v0;
 360                 const TriangleVertex&   outside = clipped1;
 361                       TriangleVertex&   middle  = mid1;
 362
 363                 const ClipFloat                 hitDist = plane.clipLineSegmentEnd(inside.position, outside.position);
 364
 365                 if (hitDist >= unclippableLimit)
 366                 {
 367                         // this edge cannot be clipped because the edge is really close to the volume boundary
 368                         unclippableVertex1 = true;
 369                 }
 370                 else
 371                 {
 372                         const ClipVec4 approximatedClipPoint    = tcu::mix(inside.position, outside.position, hitDist);
 373                         const ClipVec4 anotherPointOnLine               = (hitDist > (ClipFloat)0.5) ? (inside.position) : (outside.position);
 374
 375                         middle.position = plane.getLineIntersectionPoint(approximatedClipPoint, anotherPointOnLine);
 376                         middle.weight[0] = tcu::mix(inside.weight[0], outside.weight[0], hitDist);
 377                         middle.weight[1] = tcu::mix(inside.weight[1], outside.weight[1], hitDist);
 378                         middle.weight[2] = tcu::mix(inside.weight[2], outside.weight[2], hitDist);
 379                 }
 380         }
 381
 382         {
 383                 const TriangleVertex&   inside  = v0;
 384                 const TriangleVertex&   outside = clipped2;
 385                       TriangleVertex&   middle  = mid2;
 386
 387                 const ClipFloat                 hitDist = plane.clipLineSegmentEnd(inside.position, outside.position);
 388
 389                 if (hitDist >= unclippableLimit)
 390                 {
 391                         // this edge cannot be clipped because the edge is really close to the volume boundary
 392                         unclippableVertex2 = true;
 393                 }
 394                 else
 395                 {
 396                         const ClipVec4 approximatedClipPoint    = tcu::mix(inside.position, outside.position, hitDist);
 397                         const ClipVec4 anotherPointOnLine               = (hitDist > (ClipFloat)0.5) ? (inside.position) : (outside.position);
 398
 399                         middle.position = plane.getLineIntersectionPoint(approximatedClipPoint, anotherPointOnLine);
 400                         middle.weight[0] = tcu::mix(inside.weight[0], outside.weight[0], hitDist);
 401                         middle.weight[1] = tcu::mix(inside.weight[1], outside.weight[1], hitDist);
 402                         middle.weight[2] = tcu::mix(inside.weight[2], outside.weight[2], hitDist);
 403                 }
 404         }
 405
 406         if (!unclippableVertex1 && !unclippableVertex2)
 407         {
 408                 // gen triangle (v0) -> mid1 -> mid2
 409                 clippedEdges.push_back(v0);
 410                 clippedEdges.push_back(mid1);
 411                 clippedEdges.push_back(mid2);
 412         }
 413         else if (!unclippableVertex1 && unclippableVertex2)
 414         {
 415                 // clip just vertex 1
 416                 clippedEdges.push_back(v0);
 417                 clippedEdges.push_back(mid1);
 418                 clippedEdges.push_back(clipped2);
 419         }
 420         else if (unclippableVertex1 && !unclippableVertex2)
 421         {
 422                 // clip just vertex 2
 423                 clippedEdges.push_back(v0);
 424                 clippedEdges.push_back(clipped1);
 425                 clippedEdges.push_back(mid2);
 426         }
 427         else
 428         {
 429                 // don't modify
 430                 clippedEdges.push_back(v0);
 431                 clippedEdges.push_back(clipped1);
 432                 clippedEdges.push_back(clipped2);
 433         }
 434 }
 435
 436 void clipTriangleToPlane (std::vector<TriangleVertex>& clippedEdges, const TriangleVertex* vertices, const ClipVolumePlane& plane)
 437 {
 438         const bool v0Clipped = !plane.pointInClipVolume(vertices[0].position);
 439         const bool v1Clipped = !plane.pointInClipVolume(vertices[1].position);
 440         const bool v2Clipped = !plane.pointInClipVolume(vertices[2].position);
 441         const int  clipCount = ((v0Clipped) ? (1) : (0)) + ((v1Clipped) ? (1) : (0)) + ((v2Clipped) ? (1) : (0));
 442
 443         if (clipCount == 0)
 444         {
 445                 // pass
 446                 clippedEdges.insert(clippedEdges.begin(), vertices, vertices + 3);
 447         }
 448         else if (clipCount == 1)
 449         {
 450                 // clip one vertex
 451                 if (v0Clipped)                  clipTriangleOneVertex(clippedEdges, plane, vertices[0], vertices[1], vertices[2]);
 452                 else if (v1Clipped)             clipTriangleOneVertex(clippedEdges, plane, vertices[1], vertices[2], vertices[0]);
 453                 else                                    clipTriangleOneVertex(clippedEdges, plane, vertices[2], vertices[0], vertices[1]);
 454         }
 455         else if (clipCount == 2)
 456         {
 457                 // clip two vertices
 458                 if (!v0Clipped)                 clipTriangleTwoVertices(clippedEdges, plane, vertices[0], vertices[1], vertices[2]);
 459                 else if (!v1Clipped)    clipTriangleTwoVertices(clippedEdges, plane, vertices[1], vertices[2], vertices[0]);
 460                 else                                    clipTriangleTwoVertices(clippedEdges, plane, vertices[2], vertices[0], vertices[1]);
 461         }
 462         else if (clipCount == 3)
 463         {
 464                 // discard
 465         }
 466         else
 467         {
 468                 DE_ASSERT(DE_FALSE);
 469         }
 470 }
 471
 472 } // cliputil
 473
 474 tcu::Vec2 to2DCartesian (const tcu::Vec4& p)
 475 {
 476         return tcu::Vec2(p.x(), p.y()) / p.w();
 477 }
 478
 479 float cross2D (const tcu::Vec2& a, const tcu::Vec2& b)
 480 {
 481         return tcu::cross(tcu::Vec3(a.x(), a.y(), 0.0f), tcu::Vec3(b.x(), b.y(), 0.0f)).z();
 482 }
 483
 484 void flatshadePrimitiveVertices (pa::Triangle& target, size_t outputNdx)
 485 {
 486         const rr::GenericVec4 flatValue = target.getProvokingVertex()->outputs[outputNdx];
 487         target.v0->outputs[outputNdx] = flatValue;
 488         target.v1->outputs[outputNdx] = flatValue;
 489         target.v2->outputs[outputNdx] = flatValue;
 490 }
 491
 492 void flatshadePrimitiveVertices (pa::Line& target, size_t outputNdx)
 493 {
 494         const rr::GenericVec4 flatValue = target.getProvokingVertex()->outputs[outputNdx];
 495         target.v0->outputs[outputNdx] = flatValue;
 496         target.v1->outputs[outputNdx] = flatValue;
 497 }
 498
 499 void flatshadePrimitiveVertices (pa::Point& target, size_t outputNdx)
 500 {
 501         DE_UNREF(target);
 502         DE_UNREF(outputNdx);
 503 }
 504
 505 template <typename ContainerType>
 506 void flatshadeVertices (const Program& program, ContainerType& list)
 507 {
 508         // flatshade
 509         const std::vector<rr::VertexVaryingInfo>& fragInputs = (program.geometryShader) ? (program.geometryShader->getOutputs()) : (program.vertexShader->getOutputs());
 510
 511         for (size_t inputNdx = 0; inputNdx < fragInputs.size(); ++inputNdx)
 512                 if (fragInputs[inputNdx].flatshade)
 513                         for (typename ContainerType::iterator it = list.begin(); it != list.end(); ++it)
 514                                 flatshadePrimitiveVertices(*it, inputNdx);
 515 }
 516
 517 /*--------------------------------------------------------------------*//*!
 518  * Clip triangles to the clip volume.
 519  *//*--------------------------------------------------------------------*/
 520 void clipPrimitives (std::vector<pa::Triangle>&         list,
 521                                          const Program&                                 program,
 522                                          bool                                                   clipWithZPlanes,
 523                                          VertexPacketAllocator&                 vpalloc)
 524 {
 525         using namespace cliputil;
 526
 527         cliputil::ComponentPlane<+1, 0> clipPosX;
 528         cliputil::ComponentPlane<-1, 0> clipNegX;
 529         cliputil::ComponentPlane<+1, 1> clipPosY;
 530         cliputil::ComponentPlane<-1, 1> clipNegY;
 531         cliputil::ComponentPlane<+1, 2> clipPosZ;
 532         cliputil::ComponentPlane<-1, 2> clipNegZ;
 533
 534         const std::vector<rr::VertexVaryingInfo>&       fragInputs                      = (program.geometryShader) ? (program.geometryShader->getOutputs()) : (program.vertexShader->getOutputs());
 535         const ClipVolumePlane*                                          planes[]                        = { &clipPosX, &clipNegX, &clipPosY, &clipNegY, &clipPosZ, &clipNegZ };
 536         const int                                                                       numPlanes                       = (clipWithZPlanes) ? (6) : (4);
 537
 538         std::vector<pa::Triangle>                                       outputTriangles;
 539
 540         for (int inputTriangleNdx = 0; inputTriangleNdx < (int)list.size(); ++inputTriangleNdx)
 541         {
 542                 bool clippedByPlane[6];
 543
 544                 // Needs clipping?
 545                 {
 546                         bool discardPrimitive   = false;
 547                         bool fullyInClipVolume  = true;
 548
 549                         for (int planeNdx = 0; planeNdx < numPlanes; ++planeNdx)
 550                         {
 551                                 const ClipVolumePlane*  plane                   = planes[planeNdx];
 552                                 const bool                              v0InsidePlane   = plane->pointInClipVolume(vec4ToClipVec4(list[inputTriangleNdx].v0->position));
 553                                 const bool                              v1InsidePlane   = plane->pointInClipVolume(vec4ToClipVec4(list[inputTriangleNdx].v1->position));
 554                                 const bool                              v2InsidePlane   = plane->pointInClipVolume(vec4ToClipVec4(list[inputTriangleNdx].v2->position));
 555
 556                                 // Fully outside
 557                                 if (!v0InsidePlane && !v1InsidePlane && !v2InsidePlane)
 558                                 {
 559                                         discardPrimitive = true;
 560                                         break;
 561                                 }
 562                                 // Partially outside
 563                                 else if (!v0InsidePlane || !v1InsidePlane || !v2InsidePlane)
 564                                 {
 565                                         clippedByPlane[planeNdx] = true;
 566                                         fullyInClipVolume = false;
 567                                 }
 568                                 // Fully inside
 569                                 else
 570                                         clippedByPlane[planeNdx] = false;
 571                         }
 572
 573                         if (discardPrimitive)
 574                                 continue;
 575
 576                         if (fullyInClipVolume)
 577                         {
 578                                 outputTriangles.push_back(list[inputTriangleNdx]);
 579                                 continue;
 580                         }
 581                 }
 582
 583                 // Clip
 584                 {
 585                         std::vector<SubTriangle>        subTriangles    (1);
 586                         SubTriangle&                            initialTri              = subTriangles[0];
 587
 588                         initialTri.vertices[0].position = vec4ToClipVec4(list[inputTriangleNdx].v0->position);
 589                         initialTri.vertices[0].weight[0] = (ClipFloat)1.0;
 590                         initialTri.vertices[0].weight[1] = (ClipFloat)0.0;
 591                         initialTri.vertices[0].weight[2] = (ClipFloat)0.0;
 592
 593                         initialTri.vertices[1].position = vec4ToClipVec4(list[inputTriangleNdx].v1->position);
 594                         initialTri.vertices[1].weight[0] = (ClipFloat)0.0;
 595                         initialTri.vertices[1].weight[1] = (ClipFloat)1.0;
 596                         initialTri.vertices[1].weight[2] = (ClipFloat)0.0;
 597
 598                         initialTri.vertices[2].position = vec4ToClipVec4(list[inputTriangleNdx].v2->position);
 599                         initialTri.vertices[2].weight[0] = (ClipFloat)0.0;
 600                         initialTri.vertices[2].weight[1] = (ClipFloat)0.0;
 601                         initialTri.vertices[2].weight[2] = (ClipFloat)1.0;
 602
 603                         // Clip all subtriangles to all relevant planes
 604                         for (int planeNdx = 0; planeNdx < numPlanes; ++planeNdx)
 605                         {
 606                                 std::vector<SubTriangle> nextPhaseSubTriangles;
 607
 608                                 if (!clippedByPlane[planeNdx])
 609                                         continue;
 610
 611                                 for (int subTriangleNdx = 0; subTriangleNdx < (int)subTriangles.size(); ++subTriangleNdx)
 612                                 {
 613                                         std::vector<TriangleVertex> convexPrimitive;
 614
 615                                         // Clip triangle and form a convex n-gon ( n c {3, 4} )
 616                                         clipTriangleToPlane(convexPrimitive, subTriangles[subTriangleNdx].vertices, *planes[planeNdx]);
 617
 618                                         // Subtriangle completely discarded
 619                                         if (convexPrimitive.empty())
 620                                                 continue;
 621
 622                                         DE_ASSERT(convexPrimitive.size() == 3 || convexPrimitive.size() == 4);
 623
 624                                         //Triangulate planar convex n-gon
 625                                         {
 626                                                 TriangleVertex& v0 = convexPrimitive[0];
 627
 628                                                 for (int subsubTriangleNdx = 1; subsubTriangleNdx + 1 < (int)convexPrimitive.size(); ++subsubTriangleNdx)
 629                                                 {
 630                                                         const float                             degenerateEpsilon       = 1.0e-6f;
 631                                                         const TriangleVertex&   v1                                      = convexPrimitive[subsubTriangleNdx];
 632                                                         const TriangleVertex&   v2                                      = convexPrimitive[subsubTriangleNdx + 1];
 633                                                         const float                             visibleArea                     = de::abs(cross2D(to2DCartesian(clipVec4ToVec4(v1.position)) - to2DCartesian(clipVec4ToVec4(v0.position)),
 634                                                                                                                                                                                   to2DCartesian(clipVec4ToVec4(v2.position)) - to2DCartesian(clipVec4ToVec4(v0.position))));
 635
 636                                                         // has surface area (is not a degenerate)
 637                                                         if (visibleArea >= degenerateEpsilon)
 638                                                         {
 639                                                                 SubTriangle subsubTriangle;
 640
 641                                                                 subsubTriangle.vertices[0] = v0;
 642                                                                 subsubTriangle.vertices[1] = v1;
 643                                                                 subsubTriangle.vertices[2] = v2;
 644
 645                                                                 nextPhaseSubTriangles.push_back(subsubTriangle);
 646                                                         }
 647                                                 }
 648                                         }
 649                                 }
 650
 651                                 subTriangles.swap(nextPhaseSubTriangles);
 652                         }
 653
 654                         // Rebuild pa::Triangles from subtriangles
 655                         for (int subTriangleNdx = 0; subTriangleNdx < (int)subTriangles.size(); ++subTriangleNdx)
 656                         {
 657                                 VertexPacket*   p0                              = vpalloc.alloc();
 658                                 VertexPacket*   p1                              = vpalloc.alloc();
 659                                 VertexPacket*   p2                              = vpalloc.alloc();
 660                                 pa::Triangle    ngonFragment    (p0, p1, p2, -1);
 661
 662                                 p0->position = clipVec4ToVec4(subTriangles[subTriangleNdx].vertices[0].position);
 663                                 p1->position = clipVec4ToVec4(subTriangles[subTriangleNdx].vertices[1].position);
 664                                 p2->position = clipVec4ToVec4(subTriangles[subTriangleNdx].vertices[2].position);
 665
 666                                 for (size_t outputNdx = 0; outputNdx < fragInputs.size(); ++outputNdx)
 667                                 {
 668                                         if (fragInputs[outputNdx].type == GENERICVECTYPE_FLOAT)
 669                                         {
 670                                                 const tcu::Vec4 out0 = list[inputTriangleNdx].v0->outputs[outputNdx].get<float>();
 671                                                 const tcu::Vec4 out1 = list[inputTriangleNdx].v1->outputs[outputNdx].get<float>();
 672                                                 const tcu::Vec4 out2 = list[inputTriangleNdx].v2->outputs[outputNdx].get<float>();
 673
 674                                                 p0->outputs[outputNdx] = (float)subTriangles[subTriangleNdx].vertices[0].weight[0] * out0
 675                                                                                            + (float)subTriangles[subTriangleNdx].vertices[0].weight[1] * out1
 676                                                                                            + (float)subTriangles[subTriangleNdx].vertices[0].weight[2] * out2;
 677
 678                                                 p1->outputs[outputNdx] = (float)subTriangles[subTriangleNdx].vertices[1].weight[0] * out0
 679                                                                                            + (float)subTriangles[subTriangleNdx].vertices[1].weight[1] * out1
 680                                                                                            + (float)subTriangles[subTriangleNdx].vertices[1].weight[2] * out2;
 681
 682                                                 p2->outputs[outputNdx] = (float)subTriangles[subTriangleNdx].vertices[2].weight[0] * out0
 683                                                                                            + (float)subTriangles[subTriangleNdx].vertices[2].weight[1] * out1
 684                                                                                            + (float)subTriangles[subTriangleNdx].vertices[2].weight[2] * out2;
 685                                         }
 686                                         else
 687                                         {
 688                                                 // only floats are interpolated, all others must be flatshaded then
 689                                                 p0->outputs[outputNdx] = list[inputTriangleNdx].getProvokingVertex()->outputs[outputNdx];
 690                                                 p1->outputs[outputNdx] = list[inputTriangleNdx].getProvokingVertex()->outputs[outputNdx];
 691                                                 p2->outputs[outputNdx] = list[inputTriangleNdx].getProvokingVertex()->outputs[outputNdx];
 692                                         }
 693                                 }
 694
 695                                 outputTriangles.push_back(ngonFragment);
 696                         }
 697                 }
 698         }
 699
 700         // output result
 701         list.swap(outputTriangles);
 702 }
 703
 704 /*--------------------------------------------------------------------*//*!
 705  * Clip lines to the near and far clip planes.
 706  *
 707  * Clipping to other planes is a by-product of the viewport test  (i.e.
 708  * rasterization area selection).
 709  *//*--------------------------------------------------------------------*/
 710 void clipPrimitives (std::vector<pa::Line>&                     list,
 711                                          const Program&                                 program,
 712                                          bool                                                   clipWithZPlanes,
 713                                          VertexPacketAllocator&                 vpalloc)
 714 {
 715         DE_UNREF(vpalloc);
 716
 717         using namespace cliputil;
 718
 719         // Lines are clipped only by the far and the near planes here. Line clipping by other planes done in the rasterization phase
 720
 721         const std::vector<rr::VertexVaryingInfo>&       fragInputs      = (program.geometryShader) ? (program.geometryShader->getOutputs()) : (program.vertexShader->getOutputs());
 722         std::vector<pa::Line>                                           visibleLines;
 723
 724         // Z-clipping disabled, don't do anything
 725         if (!clipWithZPlanes)
 726                 return;
 727
 728         for (size_t ndx = 0; ndx < list.size(); ++ndx)
 729         {
 730                 pa::Line& l = list[ndx];
 731
 732                 // Totally discarded?
 733                 if ((l.v0->position.z() < -l.v0->position.w() && l.v1->position.z() < -l.v1->position.w()) ||
 734                         (l.v0->position.z() >  l.v0->position.w() && l.v1->position.z() >  l.v1->position.w()))
 735                         continue; // discard
 736
 737                 // Something is visible
 738
 739                 const ClipVec4  p0      = vec4ToClipVec4(l.v0->position);
 740                 const ClipVec4  p1      = vec4ToClipVec4(l.v1->position);
 741                 const ClipFloat t0      = getLineEndpointClipping(p0, p1);
 742                 const ClipFloat t1      = getLineEndpointClipping(p1, p0);
 743
 744                 // Not clipped at all?
 745                 if (t0 == (ClipFloat)0.0 && t1 == (ClipFloat)0.0)
 746                 {
 747                         visibleLines.push_back(pa::Line(l.v0, l.v1, -1));
 748                 }
 749                 else
 750                 {
 751                         // Clip position
 752                         l.v0->position = clipVec4ToVec4(tcu::mix(p0, p1, t0));
 753                         l.v1->position = clipVec4ToVec4(tcu::mix(p1, p0, t1));
 754
 755                         // Clip attributes
 756                         for (size_t outputNdx = 0; outputNdx < fragInputs.size(); ++outputNdx)
 757                         {
 758                                 // only floats are clipped, other types are flatshaded
 759                                 if (fragInputs[outputNdx].type == GENERICVECTYPE_FLOAT)
 760                                 {
 761                                         const tcu::Vec4 a0 = l.v0->outputs[outputNdx].get<float>();
 762                                         const tcu::Vec4 a1 = l.v1->outputs[outputNdx].get<float>();
 763
 764                                         l.v0->outputs[outputNdx] = tcu::mix(a0, a1, (float)t0);
 765                                         l.v1->outputs[outputNdx] = tcu::mix(a1, a0, (float)t1);
 766                                 }
 767                         }
 768
 769                         visibleLines.push_back(pa::Line(l.v0, l.v1, -1));
 770                 }
 771         }
 772
 773         // return visible in list
 774         std::swap(visibleLines, list);
 775 }
 776
 777 /*--------------------------------------------------------------------*//*!
 778  * Discard points not within clip volume. Clipping is a by-product
 779  * of the viewport test.
 780  *//*--------------------------------------------------------------------*/
 781 void clipPrimitives (std::vector<pa::Point>&            list,
 782                                          const Program&                                 program,
 783                                          bool                                                   clipWithZPlanes,
 784                                          VertexPacketAllocator&                 vpalloc)
 785 {
 786         DE_UNREF(vpalloc);
 787         DE_UNREF(program);
 788
 789         std::vector<pa::Point> visiblePoints;
 790
 791         // Z-clipping disabled, don't do anything
 792         if (!clipWithZPlanes)
 793                 return;
 794
 795         for (size_t ndx = 0; ndx < list.size(); ++ndx)
 796         {
 797                 pa::Point& p = list[ndx];
 798
 799                 // points are discarded if Z is not in range. (Wide) point clipping is done in the rasterization phase
 800                 if (de::inRange(p.v0->position.z(), -p.v0->position.w(), p.v0->position.w()))
 801                         visiblePoints.push_back(pa::Point(p.v0));
 802         }
 803
 804         // return visible in list
 805         std::swap(visiblePoints, list);
 806 }
 807
 808 void transformVertexClipCoordsToWindowCoords (const RenderState& state, VertexPacket& packet)
 809 {
 810         // To normalized device coords
 811         {
 812                 packet.position = tcu::Vec4(packet.position.x()/packet.position.w(),
 813                                                                         packet.position.y()/packet.position.w(),
 814                                                                         packet.position.z()/packet.position.w(),
 815                                                                         1.0f               /packet.position.w());
 816         }
 817
 818         // To window coords
 819         {
 820                 const WindowRectangle&  viewport        = state.viewport.rect;
 821                 const float                             halfW           = (float)(viewport.width) / 2.0f;
 822                 const float                             halfH           = (float)(viewport.height) / 2.0f;
 823                 const float                             oX                      = (float)viewport.left + halfW;
 824                 const float                             oY                      = (float)viewport.bottom + halfH;
 825                 const float                             zn                      = state.viewport.zn;
 826                 const float                             zf                      = state.viewport.zf;
 827
 828                 packet.position = tcu::Vec4(packet.position.x()*halfW + oX,
 829                                                                         packet.position.y()*halfH + oY,
 830                                                                         packet.position.z()*(zf - zn)/2.0f + (zn + zf)/2.0f,
 831                                                                         packet.position.w());
 832         }
 833 }
 834
 835 void transformPrimitiveClipCoordsToWindowCoords (const RenderState& state, pa::Triangle& target)
 836 {
 837         transformVertexClipCoordsToWindowCoords(state, *target.v0);
 838         transformVertexClipCoordsToWindowCoords(state, *target.v1);
 839         transformVertexClipCoordsToWindowCoords(state, *target.v2);
 840 }
 841
 842 void transformPrimitiveClipCoordsToWindowCoords (const RenderState& state, pa::Line& target)
 843 {
 844         transformVertexClipCoordsToWindowCoords(state, *target.v0);
 845         transformVertexClipCoordsToWindowCoords(state, *target.v1);
 846 }
 847
 848 void transformPrimitiveClipCoordsToWindowCoords (const RenderState& state, pa::Point& target)
 849 {
 850         transformVertexClipCoordsToWindowCoords(state, *target.v0);
 851 }
 852
 853 template <typename ContainerType>
 854 void transformClipCoordsToWindowCoords (const RenderState& state, ContainerType& list)
 855 {
 856         for (typename ContainerType::iterator it = list.begin(); it != list.end(); ++it)
 857                 transformPrimitiveClipCoordsToWindowCoords(state, *it);
 858 }
 859
 860 void makeSharedVerticeDistinct (VertexPacket*& packet, std::set<VertexPacket*, std::less<void*> >& vertices, VertexPacketAllocator& vpalloc)
 861 {
 862         // distinct
 863         if (vertices.find(packet) == vertices.end())
 864         {
 865                 vertices.insert(packet);
 866         }
 867         else
 868         {
 869                 VertexPacket* newPacket = vpalloc.alloc();
 870
 871                 // copy packet output values
 872                 newPacket->position             = packet->position;
 873                 newPacket->pointSize    = packet->pointSize;
 874                 newPacket->primitiveID  = packet->primitiveID;
 875
 876                 for (size_t outputNdx = 0; outputNdx < vpalloc.getNumVertexOutputs(); ++outputNdx)
 877                         newPacket->outputs[outputNdx] = packet->outputs[outputNdx];
 878
 879                 // no need to insert new packet to "vertices" as newPacket is unique
 880                 packet = newPacket;
 881         }
 882 }
 883
 884 void makeSharedVerticesDistinct (pa::Triangle& target, std::set<VertexPacket*, std::less<void*> >& vertices, VertexPacketAllocator& vpalloc)
 885 {
 886         makeSharedVerticeDistinct(target.v0, vertices, vpalloc);
 887         makeSharedVerticeDistinct(target.v1, vertices, vpalloc);
 888         makeSharedVerticeDistinct(target.v2, vertices, vpalloc);
 889 }
 890
 891 void makeSharedVerticesDistinct (pa::Line& target, std::set<VertexPacket*, std::less<void*> >& vertices, VertexPacketAllocator& vpalloc)
 892 {
 893         makeSharedVerticeDistinct(target.v0, vertices, vpalloc);
 894         makeSharedVerticeDistinct(target.v1, vertices, vpalloc);
 895 }
 896
 897 void makeSharedVerticesDistinct (pa::Point& target, std::set<VertexPacket*, std::less<void*> >& vertices, VertexPacketAllocator& vpalloc)
 898 {
 899         makeSharedVerticeDistinct(target.v0, vertices, vpalloc);
 900 }
 901
 902 template <typename ContainerType>
 903 void makeSharedVerticesDistinct (ContainerType& list, VertexPacketAllocator& vpalloc)
 904 {
 905         std::set<VertexPacket*, std::less<void*> > vertices;
 906
 907         for (typename ContainerType::iterator it = list.begin(); it != list.end(); ++it)
 908                 makeSharedVerticesDistinct(*it, vertices, vpalloc);
 909 }
 910
 911 void generatePrimitiveIDs (pa::Triangle& target, int id)
 912 {
 913         target.v0->primitiveID = id;
 914         target.v1->primitiveID = id;
 915         target.v2->primitiveID = id;
 916 }
 917
 918 void generatePrimitiveIDs (pa::Line& target, int id)
 919 {
 920         target.v0->primitiveID = id;
 921         target.v1->primitiveID = id;
 922 }
 923
 924 void generatePrimitiveIDs (pa::Point& target, int id)
 925 {
 926         target.v0->primitiveID = id;
 927 }
 928
 929 template <typename ContainerType>
 930 void generatePrimitiveIDs (ContainerType& list, DrawContext& drawContext)
 931 {
 932         for (typename ContainerType::iterator it = list.begin(); it != list.end(); ++it)
 933                 generatePrimitiveIDs(*it, drawContext.primitiveID++);
 934 }
 935
 936 static float findTriangleVertexDepthSlope (const tcu::Vec4& p, const tcu::Vec4& v0, const tcu::Vec4& v1)
 937 {
 938         // screen space
 939         const tcu::Vec3 ssp             =  p.swizzle(0, 1, 2);
 940         const tcu::Vec3 ssv0    = v0.swizzle(0, 1, 2);
 941         const tcu::Vec3 ssv1    = v1.swizzle(0, 1, 2);
 942
 943         // dx & dy
 944
 945         const tcu::Vec3 a               = ssv0.swizzle(0,1,2) - ssp.swizzle(0,1,2);
 946         const tcu::Vec3 b               = ssv1.swizzle(0,1,2) - ssp.swizzle(0,1,2);
 947         const float             epsilon = 0.0001f;
 948         const float             det             = (a.x() * b.y() - b.x() * a.y());
 949
 950         // degenerate triangle, it won't generate any fragments anyway. Return value doesn't matter
 951         if (de::abs(det) < epsilon)
 952                 return 0.0f;
 953
 954         const tcu::Vec2 dxDir   = tcu::Vec2( b.y(), -a.y()) / det;
 955         const tcu::Vec2 dyDir   = tcu::Vec2(-b.x(),  a.x()) / det;
 956
 957         const float             dzdx    = dxDir.x() * a.z() + dxDir.y() * b.z();
 958         const float             dzdy    = dyDir.x() * a.z() + dyDir.y() * b.z();
 959
 960         // approximate using max(|dz/dx|, |dz/dy|)
 961         return de::max(de::abs(dzdx), de::abs(dzdy));
 962 }
 963
 964 static float findPrimitiveMaximumDepthSlope (const pa::Triangle& triangle)
 965 {
 966         const float d1 = findTriangleVertexDepthSlope(triangle.v0->position, triangle.v1->position, triangle.v2->position);
 967         const float d2 = findTriangleVertexDepthSlope(triangle.v1->position, triangle.v2->position, triangle.v0->position);
 968         const float d3 = findTriangleVertexDepthSlope(triangle.v2->position, triangle.v0->position, triangle.v1->position);
 969
 970         return de::max(d1, de::max(d2, d3));
 971 }
 972
 973 static float getFloatingPointMinimumResolvableDifference (float maxZValue, tcu::TextureFormat::ChannelType type)
 974 {
 975         if (type == tcu::TextureFormat::FLOAT)
 976         {
 977                 // 32f
 978                 const int maxExponent = tcu::Float32(maxZValue).exponent();
 979                 return tcu::Float32::construct(+1, maxExponent - 23, 1 << 23).asFloat();
 980         }
 981
 982         // unexpected format
 983         DE_ASSERT(false);
 984         return 0.0f;
 985 }
 986
 987 static float getFixedPointMinimumResolvableDifference (int numBits)
 988 {
 989         return tcu::Float32::construct(+1, -numBits, 1 << 23).asFloat();
 990 }
 991
 992 static float findPrimitiveMinimumResolvableDifference (const pa::Triangle& triangle, const rr::MultisampleConstPixelBufferAccess& depthAccess)
 993 {
 994         const float                                                             maxZvalue               = de::max(de::max(triangle.v0->position.z(), triangle.v1->position.z()), triangle.v2->position.z());
 995         const tcu::TextureFormat                                format                  = depthAccess.raw().getFormat();
 996         const tcu::TextureFormat::ChannelOrder  order                   = format.order;
 997
 998         if (order == tcu::TextureFormat::D)
 999         {
1000                 // depth only
1001                 const tcu::TextureFormat::ChannelType   channelType             = format.type;
1002                 const tcu::TextureChannelClass                  channelClass    = tcu::getTextureChannelClass(channelType);
1003                 const int                                                               numBits                 = tcu::getTextureFormatBitDepth(format).x();
1004
1005                 if (channelClass == tcu::TEXTURECHANNELCLASS_FLOATING_POINT)
1006                         return getFloatingPointMinimumResolvableDifference(maxZvalue, channelType);
1007                 else
1008                         // \note channelClass might be CLASS_LAST but that's ok
1009                         return getFixedPointMinimumResolvableDifference(numBits);
1010         }
1011         else if (order == tcu::TextureFormat::DS)
1012         {
1013                 // depth stencil, special cases for possible combined formats
1014                 if (format.type == tcu::TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV)
1015                         return getFloatingPointMinimumResolvableDifference(maxZvalue, tcu::TextureFormat::FLOAT);
1016                 else if (format.type == tcu::TextureFormat::UNSIGNED_INT_24_8)
1017                         return getFixedPointMinimumResolvableDifference(24);
1018         }
1019
1020         // unexpected format
1021         DE_ASSERT(false);
1022         return 0.0f;
1023 }
1024
1025 void writeFragmentPackets (const RenderState&                                   state,
1026                                                    const RenderTarget&                                  renderTarget,
1027                                                    const Program&                                               program,
1028                                                    const FragmentPacket*                                fragmentPackets,
1029                                                    int                                                                  numRasterizedPackets,
1030                                                    rr::FaceType                                                 facetype,
1031                                                    const std::vector<rr::GenericVec4>&  fragmentOutputArray,
1032                                                    const float*                                                 depthValues,
1033                                                    std::vector<Fragment>&                               fragmentBuffer)
1034 {
1035         const int                       numSamples              = renderTarget.getNumSamples();
1036         const size_t            numOutputs              = program.fragmentShader->getOutputs().size();
1037         FragmentProcessor       fragProcessor;
1038
1039         DE_ASSERT(fragmentOutputArray.size() >= (size_t)numRasterizedPackets*4*numOutputs);
1040         DE_ASSERT(fragmentBuffer.size()      >= (size_t)numRasterizedPackets*4);
1041
1042         // Translate fragments but do not set the value yet
1043         {
1044                 int     fragCount = 0;
1045                 for (int packetNdx = 0; packetNdx < numRasterizedPackets; ++packetNdx)
1046                 for (int fragNdx = 0; fragNdx < 4; fragNdx++)
1047                 {
1048                         const FragmentPacket&   packet  = fragmentPackets[packetNdx];
1049                         const int                               xo              = fragNdx%2;
1050                         const int                               yo              = fragNdx/2;
1051
1052                         if (getCoverageAnyFragmentSampleLive(packet.coverage, numSamples, xo, yo))
1053                         {
1054                                 Fragment& fragment              = fragmentBuffer[fragCount++];
1055
1056                                 fragment.pixelCoord             = packet.position + tcu::IVec2(xo, yo);
1057                                 fragment.coverage               = (deUint32)((packet.coverage & getCoverageFragmentSampleBits(numSamples, xo, yo)) >> getCoverageOffset(numSamples, xo, yo));
1058                                 fragment.sampleDepths   = (depthValues) ? (&depthValues[(packetNdx*4 + yo*2 + xo)*numSamples]) : (DE_NULL);
1059                         }
1060                 }
1061         }
1062
1063         // Set per output output values
1064         {
1065                 rr::FragmentOperationState noStencilDepthWriteState(state.fragOps);
1066                 noStencilDepthWriteState.depthMask                                              = false;
1067                 noStencilDepthWriteState.stencilStates[facetype].sFail  = STENCILOP_KEEP;
1068                 noStencilDepthWriteState.stencilStates[facetype].dpFail = STENCILOP_KEEP;
1069                 noStencilDepthWriteState.stencilStates[facetype].dpPass = STENCILOP_KEEP;
1070
1071                 int     fragCount = 0;
1072                 for (size_t outputNdx = 0; outputNdx < numOutputs; ++outputNdx)
1073                 {
1074                         // Only the last output-pass has default state, other passes have stencil & depth writemask=0
1075                         const rr::FragmentOperationState& fragOpsState = (outputNdx == numOutputs-1) ? (state.fragOps) : (noStencilDepthWriteState);
1076
1077                         for (int packetNdx = 0; packetNdx < numRasterizedPackets; ++packetNdx)
1078                         for (int fragNdx = 0; fragNdx < 4; fragNdx++)
1079                         {
1080                                 const FragmentPacket&   packet  = fragmentPackets[packetNdx];
1081                                 const int                               xo              = fragNdx%2;
1082                                 const int                               yo              = fragNdx/2;
1083
1084                                 // Add only fragments that have live samples to shaded fragments queue.
1085                                 if (getCoverageAnyFragmentSampleLive(packet.coverage, numSamples, xo, yo))
1086                                 {
1087                                         Fragment& fragment              = fragmentBuffer[fragCount++];
1088                                         fragment.value                  = fragmentOutputArray[(packetNdx*4 + fragNdx) * numOutputs + outputNdx];
1089                                 }
1090                         }
1091
1092                         // Execute per-fragment ops and write
1093                         fragProcessor.render(renderTarget.getColorBuffer((int)outputNdx), renderTarget.getDepthBuffer(), renderTarget.getStencilBuffer(), &fragmentBuffer[0], fragCount, facetype, fragOpsState);
1094                 }
1095         }
1096 }
1097
1098 void rasterizePrimitive (const RenderState&                                     state,
1099                                                  const RenderTarget&                            renderTarget,
1100                                                  const Program&                                         program,
1101                                                  const pa::Triangle&                            triangle,
1102                                                  const tcu::IVec4&                                      renderTargetRect,
1103                                                  RasterizationInternalBuffers&          buffers)
1104 {
1105         const int                       numSamples              = renderTarget.getNumSamples();
1106         const float                     depthClampMin   = de::min(state.viewport.zn, state.viewport.zf);
1107         const float                     depthClampMax   = de::max(state.viewport.zn, state.viewport.zf);
1108         TriangleRasterizer      rasterizer              (renderTargetRect, numSamples, state.rasterization);
1109         float                           depthOffset             = 0.0f;
1110
1111         rasterizer.init(triangle.v0->position, triangle.v1->position, triangle.v2->position);
1112
1113         // Culling
1114         const FaceType visibleFace = rasterizer.getVisibleFace();
1115         if ((state.cullMode == CULLMODE_FRONT   && visibleFace == FACETYPE_FRONT) ||
1116                 (state.cullMode == CULLMODE_BACK        && visibleFace == FACETYPE_BACK))
1117                 return;
1118
1119         // Shading context
1120         FragmentShadingContext shadingContext(triangle.v0->outputs, triangle.v1->outputs, triangle.v2->outputs, &buffers.shaderOutputs[0], buffers.fragmentDepthBuffer, triangle.v2->primitiveID, (int)program.fragmentShader->getOutputs().size(), numSamples);
1121
1122         // Polygon offset
1123         if (buffers.fragmentDepthBuffer && state.fragOps.polygonOffsetEnabled)
1124         {
1125                 const float maximumDepthSlope                   = findPrimitiveMaximumDepthSlope(triangle);
1126                 const float minimumResolvableDifference = findPrimitiveMinimumResolvableDifference(triangle, renderTarget.getDepthBuffer());
1127
1128                 depthOffset = maximumDepthSlope * state.fragOps.polygonOffsetFactor + minimumResolvableDifference * state.fragOps.polygonOffsetUnits;
1129         }
1130
1131         // Execute rasterize - shade - write loop
1132         for (;;)
1133         {
1134                 const int       maxFragmentPackets              = (int)buffers.fragmentPackets.size();
1135                 int                     numRasterizedPackets    = 0;
1136
1137                 // Rasterize
1138
1139                 rasterizer.rasterize(&buffers.fragmentPackets[0], buffers.fragmentDepthBuffer, maxFragmentPackets, numRasterizedPackets);
1140
1141                 // numRasterizedPackets is guaranteed to be greater than zero for shadeFragments()
1142
1143                 if (!numRasterizedPackets)
1144                         break; // Rasterization finished.
1145
1146                 // Polygon offset
1147                 if (buffers.fragmentDepthBuffer && state.fragOps.polygonOffsetEnabled)
1148                         for (int sampleNdx = 0; sampleNdx < numRasterizedPackets * 4 * numSamples; ++sampleNdx)
1149                                 buffers.fragmentDepthBuffer[sampleNdx] = de::clamp(buffers.fragmentDepthBuffer[sampleNdx] + depthOffset, 0.0f, 1.0f);
1150
1151                 // Shade
1152
1153                 program.fragmentShader->shadeFragments(&buffers.fragmentPackets[0], numRasterizedPackets, shadingContext);
1154
1155                 // Depth clamp
1156                 if (buffers.fragmentDepthBuffer && state.fragOps.depthClampEnabled)
1157                         for (int sampleNdx = 0; sampleNdx < numRasterizedPackets * 4 * numSamples; ++sampleNdx)
1158                                 buffers.fragmentDepthBuffer[sampleNdx] = de::clamp(buffers.fragmentDepthBuffer[sampleNdx], depthClampMin, depthClampMax);
1159
1160                 // Handle fragment shader outputs
1161
1162                 writeFragmentPackets(state, renderTarget, program, &buffers.fragmentPackets[0], numRasterizedPackets, visibleFace, buffers.shaderOutputs, buffers.fragmentDepthBuffer, buffers.shadedFragments);
1163         }
1164 }
1165
1166 void rasterizePrimitive (const RenderState&                                     state,
1167                                                  const RenderTarget&                            renderTarget,
1168                                                  const Program&                                         program,
1169                                                  const pa::Line&                                        line,
1170                                                  const tcu::IVec4&                                      renderTargetRect,
1171                                                  RasterizationInternalBuffers&          buffers)
1172 {
1173         const int                                       numSamples                      = renderTarget.getNumSamples();
1174         const float                                     depthClampMin           = de::min(state.viewport.zn, state.viewport.zf);
1175         const float                                     depthClampMax           = de::max(state.viewport.zn, state.viewport.zf);
1176         const bool                                      msaa                            = numSamples > 1;
1177         FragmentShadingContext          shadingContext          (line.v0->outputs, line.v1->outputs, DE_NULL, &buffers.shaderOutputs[0], buffers.fragmentDepthBuffer, line.v1->primitiveID, (int)program.fragmentShader->getOutputs().size(), numSamples);
1178         SingleSampleLineRasterizer      aliasedRasterizer       (renderTargetRect);
1179         MultiSampleLineRasterizer       msaaRasterizer          (numSamples, renderTargetRect);
1180
1181         // Initialize rasterization.
1182         if (msaa)
1183                 msaaRasterizer.init(line.v0->position, line.v1->position, state.line.lineWidth);
1184         else
1185                 aliasedRasterizer.init(line.v0->position, line.v1->position, state.line.lineWidth);
1186
1187         for (;;)
1188         {
1189                 const int       maxFragmentPackets              = (int)buffers.fragmentPackets.size();
1190                 int                     numRasterizedPackets    = 0;
1191
1192                 // Rasterize
1193
1194                 if (msaa)
1195                         msaaRasterizer.rasterize        (&buffers.fragmentPackets[0], buffers.fragmentDepthBuffer, maxFragmentPackets, numRasterizedPackets);
1196                 else
1197                         aliasedRasterizer.rasterize     (&buffers.fragmentPackets[0], buffers.fragmentDepthBuffer, maxFragmentPackets, numRasterizedPackets);
1198
1199                 // numRasterizedPackets is guaranteed to be greater than zero for shadeFragments()
1200
1201                 if (!numRasterizedPackets)
1202                         break; // Rasterization finished.
1203
1204                 // Shade
1205
1206                 program.fragmentShader->shadeFragments(&buffers.fragmentPackets[0], numRasterizedPackets, shadingContext);
1207
1208                 // Depth clamp
1209                 if (buffers.fragmentDepthBuffer && state.fragOps.depthClampEnabled)
1210                         for (int sampleNdx = 0; sampleNdx < numRasterizedPackets * 4 * numSamples; ++sampleNdx)
1211                                 buffers.fragmentDepthBuffer[sampleNdx] = de::clamp(buffers.fragmentDepthBuffer[sampleNdx], depthClampMin, depthClampMax);
1212
1213                 // Handle fragment shader outputs
1214
1215                 writeFragmentPackets(state, renderTarget, program, &buffers.fragmentPackets[0], numRasterizedPackets, rr::FACETYPE_FRONT, buffers.shaderOutputs, buffers.fragmentDepthBuffer, buffers.shadedFragments);
1216         }
1217 }
1218
1219 void rasterizePrimitive (const RenderState&                                     state,
1220                                                  const RenderTarget&                            renderTarget,
1221                                                  const Program&                                         program,
1222                                                  const pa::Point&                                       point,
1223                                                  const tcu::IVec4&                                      renderTargetRect,
1224                                                  RasterizationInternalBuffers&          buffers)
1225 {
1226         const int                       numSamples              = renderTarget.getNumSamples();
1227         const float                     depthClampMin   = de::min(state.viewport.zn, state.viewport.zf);
1228         const float                     depthClampMax   = de::max(state.viewport.zn, state.viewport.zf);
1229         TriangleRasterizer      rasterizer1             (renderTargetRect, numSamples, state.rasterization);
1230         TriangleRasterizer      rasterizer2             (renderTargetRect, numSamples, state.rasterization);
1231
1232         // draw point as two triangles
1233         const float offset                              = point.v0->pointSize / 2.0f;
1234         const tcu::Vec4         w0                      = tcu::Vec4(point.v0->position.x() + offset, point.v0->position.y() + offset, point.v0->position.z(), point.v0->position.w());
1235         const tcu::Vec4         w1                      = tcu::Vec4(point.v0->position.x() - offset, point.v0->position.y() + offset, point.v0->position.z(), point.v0->position.w());
1236         const tcu::Vec4         w2                      = tcu::Vec4(point.v0->position.x() - offset, point.v0->position.y() - offset, point.v0->position.z(), point.v0->position.w());
1237         const tcu::Vec4         w3                      = tcu::Vec4(point.v0->position.x() + offset, point.v0->position.y() - offset, point.v0->position.z(), point.v0->position.w());
1238
1239         rasterizer1.init(w0, w1, w2);
1240         rasterizer2.init(w0, w2, w3);
1241
1242         // Shading context
1243         FragmentShadingContext shadingContext(point.v0->outputs, DE_NULL, DE_NULL, &buffers.shaderOutputs[0], buffers.fragmentDepthBuffer, point.v0->primitiveID, (int)program.fragmentShader->getOutputs().size(), numSamples);
1244
1245         // Execute rasterize - shade - write loop
1246         for (;;)
1247         {
1248                 const int       maxFragmentPackets              = (int)buffers.fragmentPackets.size();
1249                 int                     numRasterizedPackets    = 0;
1250
1251                 // Rasterize both triangles
1252
1253                 rasterizer1.rasterize(&buffers.fragmentPackets[0], buffers.fragmentDepthBuffer, maxFragmentPackets, numRasterizedPackets);
1254                 if (numRasterizedPackets != maxFragmentPackets)
1255                 {
1256                         float* const    depthBufferAppendPointer        = (buffers.fragmentDepthBuffer) ? (buffers.fragmentDepthBuffer + numRasterizedPackets*numSamples*4) : (DE_NULL);
1257                         int                             numRasterizedPackets2           = 0;
1258
1259                         rasterizer2.rasterize(&buffers.fragmentPackets[numRasterizedPackets], depthBufferAppendPointer, maxFragmentPackets - numRasterizedPackets, numRasterizedPackets2);
1260
1261                         numRasterizedPackets += numRasterizedPackets2;
1262                 }
1263
1264                 // numRasterizedPackets is guaranteed to be greater than zero for shadeFragments()
1265
1266                 if (!numRasterizedPackets)
1267                         break; // Rasterization finished.
1268
1269                 // Shade
1270
1271                 program.fragmentShader->shadeFragments(&buffers.fragmentPackets[0], numRasterizedPackets, shadingContext);
1272
1273                 // Depth clamp
1274                 if (buffers.fragmentDepthBuffer && state.fragOps.depthClampEnabled)
1275                         for (int sampleNdx = 0; sampleNdx < numRasterizedPackets * 4 * numSamples; ++sampleNdx)
1276                                 buffers.fragmentDepthBuffer[sampleNdx] = de::clamp(buffers.fragmentDepthBuffer[sampleNdx], depthClampMin, depthClampMax);
1277
1278                 // Handle fragment shader outputs
1279
1280                 writeFragmentPackets(state, renderTarget, program, &buffers.fragmentPackets[0], numRasterizedPackets, rr::FACETYPE_FRONT, buffers.shaderOutputs, buffers.fragmentDepthBuffer, buffers.shadedFragments);
1281         }
1282 }
1283
1284 template <typename ContainerType>
1285 void rasterize (const RenderState&                                      state,
1286                                 const RenderTarget&                                     renderTarget,
1287                                 const Program&                                          program,
1288                                 const ContainerType&                            list)
1289 {
1290         const int                                               numSamples                      = renderTarget.getNumSamples();
1291         const int                                               numFragmentOutputs      = (int)program.fragmentShader->getOutputs().size();
1292         const size_t                                    maxFragmentPackets      = 128;
1293
1294         const tcu::IVec4                                viewportRect            = tcu::IVec4(state.viewport.rect.left, state.viewport.rect.bottom, state.viewport.rect.width, state.viewport.rect.height);
1295         const tcu::IVec4                                bufferRect                      = getBufferSize(renderTarget.getColorBuffer(0));
1296         const tcu::IVec4                                renderTargetRect        = rectIntersection(viewportRect, bufferRect);
1297
1298         // shared buffers for all primitives
1299         std::vector<FragmentPacket>             fragmentPackets         (maxFragmentPackets);
1300         std::vector<GenericVec4>                shaderOutputs           (maxFragmentPackets*4*numFragmentOutputs);
1301         std::vector<Fragment>                   shadedFragments         (maxFragmentPackets*4);
1302         std::vector<float>                              depthValues                     (0);
1303         float*                                                  depthBufferPointer      = DE_NULL;
1304
1305         RasterizationInternalBuffers    buffers;
1306
1307         // calculate depth only if we have a depth buffer
1308         if (!isEmpty(renderTarget.getDepthBuffer()))
1309         {
1310                 depthValues.resize(maxFragmentPackets*4*numSamples);
1311                 depthBufferPointer = &depthValues[0];
1312         }
1313
1314         // set buffers
1315         buffers.fragmentPackets.swap(fragmentPackets);
1316         buffers.shaderOutputs.swap(shaderOutputs);
1317         buffers.shadedFragments.swap(shadedFragments);
1318         buffers.fragmentDepthBuffer = depthBufferPointer;
1319
1320         // rasterize
1321         for (typename ContainerType::const_iterator it = list.begin(); it != list.end(); ++it)
1322                 rasterizePrimitive(state, renderTarget, program, *it, renderTargetRect, buffers);
1323 }
1324
1325 /*--------------------------------------------------------------------*//*!
1326  * Draws transformed triangles, lines or points to render target
1327  *//*--------------------------------------------------------------------*/
1328 template <typename ContainerType>
1329 void drawBasicPrimitives (const RenderState& state, const RenderTarget& renderTarget, const Program& program, ContainerType& primList, VertexPacketAllocator& vpalloc)
1330 {
1331         const bool clipZ = !state.fragOps.depthClampEnabled;
1332
1333         // Transform feedback
1334
1335         // Flatshading
1336         flatshadeVertices(program, primList);
1337
1338         // Clipping
1339         // \todo [jarkko] is creating & swapping std::vectors really a good solution?
1340         clipPrimitives(primList, program, clipZ, vpalloc);
1341
1342         // Transform vertices to window coords
1343         transformClipCoordsToWindowCoords(state, primList);
1344
1345         // Rasterize and paint
1346         rasterize(state, renderTarget, program, primList);
1347 }
1348
1349 void copyVertexPacketPointers(const VertexPacket** dst, const pa::Point& in)
1350 {
1351         dst[0] = in.v0;
1352 }
1353
1354 void copyVertexPacketPointers(const VertexPacket** dst, const pa::Line& in)
1355 {
1356         dst[0] = in.v0;
1357         dst[1] = in.v1;
1358 }
1359
1360 void copyVertexPacketPointers(const VertexPacket** dst, const pa::Triangle& in)
1361 {
1362         dst[0] = in.v0;
1363         dst[1] = in.v1;
1364         dst[2] = in.v2;
1365 }
1366
1367 void copyVertexPacketPointers(const VertexPacket** dst, const pa::LineAdjacency& in)
1368 {
1369         dst[0] = in.v0;
1370         dst[1] = in.v1;
1371         dst[2] = in.v2;
1372         dst[3] = in.v3;
1373 }
1374
1375 void copyVertexPacketPointers(const VertexPacket** dst, const pa::TriangleAdjacency& in)
1376 {
1377         dst[0] = in.v0;
1378         dst[1] = in.v1;
1379         dst[2] = in.v2;
1380         dst[3] = in.v3;
1381         dst[4] = in.v4;
1382         dst[5] = in.v5;
1383 }
1384
1385 template <PrimitiveType DrawPrimitiveType> // \note DrawPrimitiveType  can only be Points, line_strip, or triangle_strip
1386 void drawGeometryShaderOutputAsPrimitives (const RenderState& state, const RenderTarget& renderTarget, const Program& program, VertexPacket* const* vertices, size_t numVertices, VertexPacketAllocator& vpalloc)
1387 {
1388         // Run primitive assembly for generated stream
1389
1390         const size_t                                                                                                                    assemblerPrimitiveCount         = PrimitiveTypeTraits<DrawPrimitiveType>::Assembler::getPrimitiveCount(numVertices);
1391         std::vector<typename PrimitiveTypeTraits<DrawPrimitiveType>::BaseType>  inputPrimitives                         (assemblerPrimitiveCount);
1392
1393         PrimitiveTypeTraits<DrawPrimitiveType>::Assembler::exec(inputPrimitives.begin(), vertices, numVertices, state.provokingVertexConvention); // \note input Primitives are baseType_t => only basic primitives (non adjacency) will compile
1394
1395         // Make shared vertices distinct
1396
1397         makeSharedVerticesDistinct(inputPrimitives, vpalloc);
1398
1399         // Draw assembled primitives
1400
1401         drawBasicPrimitives(state, renderTarget, program, inputPrimitives, vpalloc);
1402 }
1403
1404 template <PrimitiveType DrawPrimitiveType>
1405 void drawWithGeometryShader(const RenderState& state, const RenderTarget& renderTarget, const Program& program, std::vector<typename PrimitiveTypeTraits<DrawPrimitiveType>::Type>& input, DrawContext& drawContext)
1406 {
1407         // Vertices outputted by geometry shader may have different number of output variables than the original, create new memory allocator
1408         VertexPacketAllocator vpalloc(program.geometryShader->getOutputs().size());
1409
1410         // Run geometry shader for all primitives
1411         GeometryEmitter                                 emitter                 (vpalloc, program.geometryShader->getNumVerticesOut());
1412         std::vector<PrimitivePacket>    primitives              (input.size());
1413         const int                                               numInvocations  = (int)program.geometryShader->getNumInvocations();
1414         const int                                               verticesIn              = PrimitiveTypeTraits<DrawPrimitiveType>::Type::NUM_VERTICES;
1415
1416         for (size_t primitiveNdx = 0; primitiveNdx < input.size(); ++primitiveNdx)
1417         {
1418                 primitives[primitiveNdx].primitiveIDIn = drawContext.primitiveID++;
1419                 copyVertexPacketPointers(primitives[primitiveNdx].vertices, input[primitiveNdx]);
1420         }
1421
1422         if (primitives.empty())
1423                 return;
1424
1425         for (int invocationNdx = 0; invocationNdx < numInvocations; ++invocationNdx)
1426         {
1427                 // Shading invocation
1428
1429                 program.geometryShader->shadePrimitives(emitter, verticesIn, &primitives[0], (int)primitives.size(), invocationNdx);
1430
1431                 // Find primitives in the emitted vertices
1432
1433                 std::vector<VertexPacket*> emitted;
1434                 emitter.moveEmittedTo(emitted);
1435
1436                 for (size_t primitiveBegin = 0; primitiveBegin < emitted.size();)
1437                 {
1438                         size_t primitiveEnd;
1439
1440                         // Find primitive begin
1441                         if (!emitted[primitiveBegin])
1442                         {
1443                                 ++primitiveBegin;
1444                                 continue;
1445                         }
1446
1447                         // Find primitive end
1448
1449                         primitiveEnd = primitiveBegin + 1;
1450                         for (; (primitiveEnd < emitted.size()) && emitted[primitiveEnd]; ++primitiveEnd); // find primitive end
1451
1452                         // Draw range [begin, end)
1453
1454                         switch (program.geometryShader->getOutputType())
1455                         {
1456                                 case rr::GEOMETRYSHADEROUTPUTTYPE_POINTS:                       drawGeometryShaderOutputAsPrimitives<PRIMITIVETYPE_POINTS>                      (state, renderTarget, program, &emitted[primitiveBegin], primitiveEnd-primitiveBegin, vpalloc); break;
1457                                 case rr::GEOMETRYSHADEROUTPUTTYPE_LINE_STRIP:           drawGeometryShaderOutputAsPrimitives<PRIMITIVETYPE_LINE_STRIP>          (state, renderTarget, program, &emitted[primitiveBegin], primitiveEnd-primitiveBegin, vpalloc); break;
1458                                 case rr::GEOMETRYSHADEROUTPUTTYPE_TRIANGLE_STRIP:       drawGeometryShaderOutputAsPrimitives<PRIMITIVETYPE_TRIANGLE_STRIP>      (state, renderTarget, program, &emitted[primitiveBegin], primitiveEnd-primitiveBegin, vpalloc); break;
1459                                 default:
1460                                         DE_ASSERT(DE_FALSE);
1461                         }
1462
1463                         // Next primitive
1464                         primitiveBegin = primitiveEnd + 1;
1465                 }
1466         }
1467 }
1468
1469 /*--------------------------------------------------------------------*//*!
1470  * Assembles, tesselates, runs geometry shader and draws primitives of any type from vertex list.
1471  *//*--------------------------------------------------------------------*/
1472 template <PrimitiveType DrawPrimitiveType>
1473 void drawAsPrimitives (const RenderState& state, const RenderTarget& renderTarget, const Program& program, VertexPacket* const* vertices, int numVertices, DrawContext& drawContext, VertexPacketAllocator& vpalloc)
1474 {
1475         // Assemble primitives (deconstruct stips & loops)
1476         const size_t                                                                                                                    assemblerPrimitiveCount         = PrimitiveTypeTraits<DrawPrimitiveType>::Assembler::getPrimitiveCount(numVertices);
1477         std::vector<typename PrimitiveTypeTraits<DrawPrimitiveType>::Type>              inputPrimitives                         (assemblerPrimitiveCount);
1478
1479         PrimitiveTypeTraits<DrawPrimitiveType>::Assembler::exec(inputPrimitives.begin(), vertices, (size_t)numVertices, state.provokingVertexConvention);
1480
1481         // Tesselate
1482         //if (state.tesselation)
1483         //      primList = state.tesselation.exec(primList);
1484
1485         // Geometry shader
1486         if (program.geometryShader)
1487         {
1488                 // If there is an active geometry shader, it will convert any primitive type to basic types
1489                 drawWithGeometryShader<DrawPrimitiveType>(state, renderTarget, program, inputPrimitives, drawContext);
1490         }
1491         else
1492         {
1493                 std::vector<typename PrimitiveTypeTraits<DrawPrimitiveType>::BaseType> basePrimitives;
1494
1495                 // convert types from X_adjacency to X
1496                 convertPrimitiveToBaseType(basePrimitives, inputPrimitives);
1497
1498                 // Make shared vertices distinct. Needed for that the translation to screen space happens only once per vertex, and for flatshading
1499                 makeSharedVerticesDistinct(basePrimitives, vpalloc);
1500
1501                 // A primitive ID will be generated even if no geometry shader is active
1502                 generatePrimitiveIDs(basePrimitives, drawContext);
1503
1504                 // Draw as a basic type
1505                 drawBasicPrimitives(state, renderTarget, program, basePrimitives, vpalloc);
1506         }
1507 }
1508
1509 bool isValidCommand (const DrawCommand& command, int numInstances)
1510 {
1511         // numInstances should be valid
1512         if (numInstances < 1)
1513                 return false;
1514
1515         // Shaders should have the same varyings
1516         if (command.program.geometryShader)
1517         {
1518                 if (command.program.vertexShader->getOutputs() != command.program.geometryShader->getInputs())
1519                         return false;
1520
1521                 if (command.program.geometryShader->getOutputs() != command.program.fragmentShader->getInputs())
1522                         return false;
1523         }
1524         else
1525         {
1526                 if (command.program.vertexShader->getOutputs() != command.program.fragmentShader->getInputs())
1527                         return false;
1528         }
1529
1530         // Shader input/output types are set
1531         for (size_t varyingNdx = 0; varyingNdx < command.program.vertexShader->getInputs().size(); ++varyingNdx)
1532                 if (command.program.vertexShader->getInputs()[varyingNdx].type != GENERICVECTYPE_FLOAT &&
1533                         command.program.vertexShader->getInputs()[varyingNdx].type != GENERICVECTYPE_INT32 &&
1534                         command.program.vertexShader->getInputs()[varyingNdx].type != GENERICVECTYPE_UINT32)
1535                         return false;
1536         for (size_t varyingNdx = 0; varyingNdx < command.program.vertexShader->getOutputs().size(); ++varyingNdx)
1537                 if (command.program.vertexShader->getOutputs()[varyingNdx].type != GENERICVECTYPE_FLOAT &&
1538                         command.program.vertexShader->getOutputs()[varyingNdx].type != GENERICVECTYPE_INT32 &&
1539                         command.program.vertexShader->getOutputs()[varyingNdx].type != GENERICVECTYPE_UINT32)
1540                         return false;
1541
1542         for (size_t varyingNdx = 0; varyingNdx < command.program.fragmentShader->getInputs().size(); ++varyingNdx)
1543                 if (command.program.fragmentShader->getInputs()[varyingNdx].type != GENERICVECTYPE_FLOAT &&
1544                         command.program.fragmentShader->getInputs()[varyingNdx].type != GENERICVECTYPE_INT32 &&
1545                         command.program.fragmentShader->getInputs()[varyingNdx].type != GENERICVECTYPE_UINT32)
1546                         return false;
1547         for (size_t varyingNdx = 0; varyingNdx < command.program.fragmentShader->getOutputs().size(); ++varyingNdx)
1548                 if (command.program.fragmentShader->getOutputs()[varyingNdx].type != GENERICVECTYPE_FLOAT &&
1549                         command.program.fragmentShader->getOutputs()[varyingNdx].type != GENERICVECTYPE_INT32 &&
1550                         command.program.fragmentShader->getOutputs()[varyingNdx].type != GENERICVECTYPE_UINT32)
1551                         return false;
1552
1553         if (command.program.geometryShader)
1554         {
1555                 for (size_t varyingNdx = 0; varyingNdx < command.program.geometryShader->getInputs().size(); ++varyingNdx)
1556                         if (command.program.geometryShader->getInputs()[varyingNdx].type != GENERICVECTYPE_FLOAT &&
1557                                 command.program.geometryShader->getInputs()[varyingNdx].type != GENERICVECTYPE_INT32 &&
1558                                 command.program.geometryShader->getInputs()[varyingNdx].type != GENERICVECTYPE_UINT32)
1559                                 return false;
1560                 for (size_t varyingNdx = 0; varyingNdx < command.program.geometryShader->getOutputs().size(); ++varyingNdx)
1561                         if (command.program.geometryShader->getOutputs()[varyingNdx].type != GENERICVECTYPE_FLOAT &&
1562                                 command.program.geometryShader->getOutputs()[varyingNdx].type != GENERICVECTYPE_INT32 &&
1563                                 command.program.geometryShader->getOutputs()[varyingNdx].type != GENERICVECTYPE_UINT32)
1564                                 return false;
1565         }
1566
1567         // Enough vertex inputs?
1568         if ((size_t)command.numVertexAttribs < command.program.vertexShader->getInputs().size())
1569                 return false;
1570
1571         // There is a fragment output sink for each output?
1572         if ((size_t)command.renderTarget.getNumColorBuffers() < command.program.fragmentShader->getOutputs().size())
1573                 return false;
1574
1575         // All destination buffers should have same number of samples and same size
1576         for (int outputNdx = 0; outputNdx < command.renderTarget.getNumColorBuffers(); ++outputNdx)
1577         {
1578                 if (getBufferSize(command.renderTarget.getColorBuffer(0)) != getBufferSize(command.renderTarget.getColorBuffer(outputNdx)))
1579                         return false;
1580
1581                 if (command.renderTarget.getNumSamples() != command.renderTarget.getColorBuffer(outputNdx).getNumSamples())
1582                         return false;
1583         }
1584
1585         // All destination buffers should have same basic type as matching fragment output
1586         for (size_t varyingNdx = 0; varyingNdx < command.program.fragmentShader->getOutputs().size(); ++varyingNdx)
1587         {
1588                 const tcu::TextureChannelClass  colorbufferClass = tcu::getTextureChannelClass(command.renderTarget.getColorBuffer((int)varyingNdx).raw().getFormat().type);
1589                 const GenericVecType                    colorType                = (colorbufferClass == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER) ? (rr::GENERICVECTYPE_INT32) : ((colorbufferClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER) ? (rr::GENERICVECTYPE_UINT32) : (rr::GENERICVECTYPE_FLOAT));
1590
1591                 if (command.program.fragmentShader->getOutputs()[varyingNdx].type != colorType)
1592                         return false;
1593         }
1594
1595         // Integer values are flatshaded
1596         for (size_t outputNdx = 0; outputNdx < command.program.vertexShader->getOutputs().size(); ++outputNdx)
1597         {
1598                 if (!command.program.vertexShader->getOutputs()[outputNdx].flatshade &&
1599                         (command.program.vertexShader->getOutputs()[outputNdx].type == GENERICVECTYPE_INT32 ||
1600                          command.program.vertexShader->getOutputs()[outputNdx].type == GENERICVECTYPE_UINT32))
1601                         return false;
1602         }
1603         if (command.program.geometryShader)
1604                 for (size_t outputNdx = 0; outputNdx < command.program.geometryShader->getOutputs().size(); ++outputNdx)
1605                 {
1606                         if (!command.program.geometryShader->getOutputs()[outputNdx].flatshade &&
1607                                 (command.program.geometryShader->getOutputs()[outputNdx].type == GENERICVECTYPE_INT32 ||
1608                                  command.program.geometryShader->getOutputs()[outputNdx].type == GENERICVECTYPE_UINT32))
1609                                 return false;
1610                 }
1611
1612         // Draw primitive is valid for geometry shader
1613         if (command.program.geometryShader)
1614         {
1615                 if (command.program.geometryShader->getInputType() == rr::GEOMETRYSHADERINPUTTYPE_POINTS && command.primitives.getPrimitiveType() != PRIMITIVETYPE_POINTS)
1616                         return false;
1617
1618                 if (command.program.geometryShader->getInputType() == rr::GEOMETRYSHADERINPUTTYPE_LINES &&
1619                         (command.primitives.getPrimitiveType() != PRIMITIVETYPE_LINES &&
1620                          command.primitives.getPrimitiveType() != PRIMITIVETYPE_LINE_STRIP &&
1621                          command.primitives.getPrimitiveType() != PRIMITIVETYPE_LINE_LOOP))
1622                         return false;
1623
1624                 if (command.program.geometryShader->getInputType() == rr::GEOMETRYSHADERINPUTTYPE_TRIANGLES &&
1625                         (command.primitives.getPrimitiveType() != PRIMITIVETYPE_TRIANGLES &&
1626                          command.primitives.getPrimitiveType() != PRIMITIVETYPE_TRIANGLE_STRIP &&
1627                          command.primitives.getPrimitiveType() != PRIMITIVETYPE_TRIANGLE_FAN))
1628                         return false;
1629
1630                 if (command.program.geometryShader->getInputType() == rr::GEOMETRYSHADERINPUTTYPE_LINES_ADJACENCY &&
1631                         (command.primitives.getPrimitiveType() != PRIMITIVETYPE_LINES_ADJACENCY &&
1632                          command.primitives.getPrimitiveType() != PRIMITIVETYPE_LINE_STRIP_ADJACENCY))
1633                         return false;
1634
1635                 if (command.program.geometryShader->getInputType() == rr::GEOMETRYSHADERINPUTTYPE_TRIANGLES_ADJACENCY &&
1636                         (command.primitives.getPrimitiveType() != PRIMITIVETYPE_TRIANGLES_ADJACENCY &&
1637                          command.primitives.getPrimitiveType() != PRIMITIVETYPE_TRIANGLE_STRIP_ADJACENCY))
1638                         return false;
1639         }
1640
1641         return true;
1642 }
1643
1644 } // anonymous
1645
1646 RenderTarget::RenderTarget (const MultisamplePixelBufferAccess& colorMultisampleBuffer,
1647                                                         const MultisamplePixelBufferAccess& depthMultisampleBuffer,
1648                                                         const MultisamplePixelBufferAccess& stencilMultisampleBuffer)
1649         : m_numColorBuffers     (1)
1650         , m_depthBuffer         (MultisamplePixelBufferAccess::fromMultisampleAccess(tcu::getEffectiveDepthStencilAccess(depthMultisampleBuffer.raw(), tcu::Sampler::MODE_DEPTH)))
1651         , m_stencilBuffer       (MultisamplePixelBufferAccess::fromMultisampleAccess(tcu::getEffectiveDepthStencilAccess(stencilMultisampleBuffer.raw(), tcu::Sampler::MODE_STENCIL)))
1652 {
1653         m_colorBuffers[0] = colorMultisampleBuffer;
1654 }
1655
1656 int RenderTarget::getNumSamples (void) const
1657 {
1658         DE_ASSERT(m_numColorBuffers > 0);
1659         return m_colorBuffers[0].getNumSamples();
1660 }
1661
1662 DrawIndices::DrawIndices (const deUint32* ptr, int baseVertex_)
1663         : indices       (ptr)
1664         , indexType     (INDEXTYPE_UINT32)
1665         , baseVertex(baseVertex_)
1666 {
1667 }
1668
1669 DrawIndices::DrawIndices (const deUint16* ptr, int baseVertex_)
1670         : indices       (ptr)
1671         , indexType     (INDEXTYPE_UINT16)
1672         , baseVertex(baseVertex_)
1673 {
1674 }
1675
1676 DrawIndices::DrawIndices (const deUint8* ptr, int baseVertex_)
1677         : indices       (ptr)
1678         , indexType     (INDEXTYPE_UINT8)
1679         , baseVertex(baseVertex_)
1680 {
1681 }
1682
1683 DrawIndices::DrawIndices (const void* ptr, IndexType type, int baseVertex_)
1684         : indices       (ptr)
1685         , indexType     (type)
1686         , baseVertex(baseVertex_)
1687 {
1688 }
1689
1690 PrimitiveList::PrimitiveList (PrimitiveType primitiveType, int numElements, const int firstElement)
1691         : m_primitiveType       (primitiveType)
1692         , m_numElements         (numElements)
1693         , m_indices                     (DE_NULL)
1694         , m_indexType           (INDEXTYPE_LAST)
1695         , m_baseVertex          (firstElement)
1696 {
1697         DE_ASSERT(numElements >= 0 && "Invalid numElements");
1698         DE_ASSERT(firstElement >= 0 && "Invalid firstElement");
1699 }
1700
1701 PrimitiveList::PrimitiveList (PrimitiveType primitiveType, int numElements, const DrawIndices& indices)
1702         : m_primitiveType       (primitiveType)
1703         , m_numElements         ((size_t)numElements)
1704         , m_indices                     (indices.indices)
1705         , m_indexType           (indices.indexType)
1706         , m_baseVertex          (indices.baseVertex)
1707 {
1708         DE_ASSERT(numElements >= 0 && "Invalid numElements");
1709 }
1710
1711 size_t PrimitiveList::getIndex (size_t elementNdx) const
1712 {
1713         // indices == DE_NULL interpreted as command.indices = [first (=baseVertex) + 0, first + 1, first + 2...]
1714         if (m_indices)
1715         {
1716                 int index = m_baseVertex + (int)readIndexArray(m_indexType, m_indices, elementNdx);
1717                 DE_ASSERT(index >= 0); // do not access indices < 0
1718
1719                 return (size_t)index;
1720         }
1721         else
1722                 return (size_t)(m_baseVertex) + elementNdx;
1723 }
1724
1725 bool PrimitiveList::isRestartIndex (size_t elementNdx, deUint32 restartIndex) const
1726 {
1727         // implicit index or explicit index (without base vertex) equals restart
1728         if (m_indices)
1729                 return readIndexArray(m_indexType, m_indices, elementNdx) == restartIndex;
1730         else
1731                 return elementNdx == (size_t)restartIndex;
1732 }
1733
1734 Renderer::Renderer (void)
1735 {
1736 }
1737
1738 Renderer::~Renderer (void)
1739 {
1740 }
1741
1742 void Renderer::draw (const DrawCommand& command) const
1743 {
1744         drawInstanced(command, 1);
1745 }
1746
1747 void Renderer::drawInstanced (const DrawCommand& command, int numInstances) const
1748 {
1749         // Do not run bad commands
1750         {
1751                 const bool validCommand = isValidCommand(command, numInstances);
1752                 if (!validCommand)
1753                 {
1754                         DE_ASSERT(false);
1755                         return;
1756                 }
1757         }
1758
1759         // Do not draw if nothing to draw
1760         {
1761                 if (command.primitives.getNumElements() == 0 || numInstances == 0)
1762                         return;
1763         }
1764
1765         // Prepare transformation
1766
1767         const size_t                            numVaryings = command.program.vertexShader->getOutputs().size();
1768         VertexPacketAllocator           vpalloc(numVaryings);
1769         std::vector<VertexPacket*>      vertexPackets = vpalloc.allocArray(command.primitives.getNumElements());
1770         DrawContext                                     drawContext;
1771
1772         for (int instanceID = 0; instanceID < numInstances; ++instanceID)
1773         {
1774                 // Each instance has its own primitives
1775                 drawContext.primitiveID = 0;
1776
1777                 for (size_t elementNdx = 0; elementNdx < command.primitives.getNumElements(); ++elementNdx)
1778                 {
1779                         int numVertexPackets = 0;
1780
1781                         // collect primitive vertices until restart
1782
1783                         while (elementNdx < command.primitives.getNumElements() &&
1784                                         !(command.state.restart.enabled && command.primitives.isRestartIndex(elementNdx, command.state.restart.restartIndex)))
1785                         {
1786                                 // input
1787                                 vertexPackets[numVertexPackets]->instanceNdx    = instanceID;
1788                                 vertexPackets[numVertexPackets]->vertexNdx              = (int)command.primitives.getIndex(elementNdx);
1789
1790                                 // output
1791                                 vertexPackets[numVertexPackets]->pointSize              = command.state.point.pointSize;        // default value from the current state
1792                                 vertexPackets[numVertexPackets]->position               = tcu::Vec4(0, 0, 0, 0);                        // no undefined values
1793
1794                                 ++numVertexPackets;
1795                                 ++elementNdx;
1796                         }
1797
1798                         // Duplicated restart shade
1799                         if (numVertexPackets == 0)
1800                                 continue;
1801
1802                         // \todo Vertex cache?
1803
1804                         // Transform vertices
1805
1806                         command.program.vertexShader->shadeVertices(command.vertexAttribs, &vertexPackets[0], numVertexPackets);
1807
1808                         // Draw primitives
1809
1810                         switch (command.primitives.getPrimitiveType())
1811                         {
1812                                 case PRIMITIVETYPE_TRIANGLES:                           { drawAsPrimitives<PRIMITIVETYPE_TRIANGLES>                                     (command.state, command.renderTarget, command.program, &vertexPackets[0], numVertexPackets, drawContext, vpalloc);      break; }
1813                                 case PRIMITIVETYPE_TRIANGLE_STRIP:                      { drawAsPrimitives<PRIMITIVETYPE_TRIANGLE_STRIP>                        (command.state, command.renderTarget, command.program, &vertexPackets[0], numVertexPackets, drawContext, vpalloc);      break; }
1814                                 case PRIMITIVETYPE_TRIANGLE_FAN:                        { drawAsPrimitives<PRIMITIVETYPE_TRIANGLE_FAN>                          (command.state, command.renderTarget, command.program, &vertexPackets[0], numVertexPackets, drawContext, vpalloc);      break; }
1815                                 case PRIMITIVETYPE_LINES:                                       { drawAsPrimitives<PRIMITIVETYPE_LINES>                                         (command.state, command.renderTarget, command.program, &vertexPackets[0], numVertexPackets, drawContext, vpalloc);      break; }
1816                                 case PRIMITIVETYPE_LINE_STRIP:                          { drawAsPrimitives<PRIMITIVETYPE_LINE_STRIP>                            (command.state, command.renderTarget, command.program, &vertexPackets[0], numVertexPackets, drawContext, vpalloc);      break; }
1817                                 case PRIMITIVETYPE_LINE_LOOP:                           { drawAsPrimitives<PRIMITIVETYPE_LINE_LOOP>                                     (command.state, command.renderTarget, command.program, &vertexPackets[0], numVertexPackets, drawContext, vpalloc);      break; }
1818                                 case PRIMITIVETYPE_POINTS:                                      { drawAsPrimitives<PRIMITIVETYPE_POINTS>                                        (command.state, command.renderTarget, command.program, &vertexPackets[0], numVertexPackets, drawContext, vpalloc);      break; }
1819                                 case PRIMITIVETYPE_LINES_ADJACENCY:                     { drawAsPrimitives<PRIMITIVETYPE_LINES_ADJACENCY>                       (command.state, command.renderTarget, command.program, &vertexPackets[0], numVertexPackets, drawContext, vpalloc);      break; }
1820                                 case PRIMITIVETYPE_LINE_STRIP_ADJACENCY:        { drawAsPrimitives<PRIMITIVETYPE_LINE_STRIP_ADJACENCY>          (command.state, command.renderTarget, command.program, &vertexPackets[0], numVertexPackets, drawContext, vpalloc);      break; }
1821                                 case PRIMITIVETYPE_TRIANGLES_ADJACENCY:         { drawAsPrimitives<PRIMITIVETYPE_TRIANGLES_ADJACENCY>           (command.state, command.renderTarget, command.program, &vertexPackets[0], numVertexPackets, drawContext, vpalloc);      break; }
1822                                 case PRIMITIVETYPE_TRIANGLE_STRIP_ADJACENCY:{ drawAsPrimitives<PRIMITIVETYPE_TRIANGLE_STRIP_ADJACENCY>  (command.state, command.renderTarget, command.program, &vertexPackets[0], numVertexPackets, drawContext, vpalloc);      break; }
1823                                 default:
1824                                         DE_ASSERT(DE_FALSE);
1825                         }
1826                 }
1827         }
1828 }
1829
1830 } // rr