| // Copyright 2016 The SwiftShader Authors. All Rights Reserved. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| #include "Clipper.hpp" |
| |
| #include "Polygon.hpp" |
| #include "Renderer.hpp" |
| #include "System/Debug.hpp" |
| |
| namespace sw |
| { |
| Clipper::Clipper(bool symmetricNormalizedDepth) |
| { |
| n = symmetricNormalizedDepth ? -1.0f : 0.0f; |
| } |
| |
| Clipper::~Clipper() |
| { |
| } |
| |
| unsigned int Clipper::computeClipFlags(const float4 &v) |
| { |
| return ((v.x > v.w) ? CLIP_RIGHT : 0) | |
| ((v.y > v.w) ? CLIP_TOP : 0) | |
| ((v.z > v.w) ? CLIP_FAR : 0) | |
| ((v.x < -v.w) ? CLIP_LEFT : 0) | |
| ((v.y < -v.w) ? CLIP_BOTTOM : 0) | |
| ((v.z < n * v.w) ? CLIP_NEAR : 0) | |
| Clipper::CLIP_FINITE; // FIXME: xyz finite |
| } |
| |
| bool Clipper::clip(Polygon &polygon, int clipFlagsOr, const DrawCall &draw) |
| { |
| if(clipFlagsOr & CLIP_FRUSTUM) |
| { |
| if(clipFlagsOr & CLIP_NEAR) clipNear(polygon); |
| if(polygon.n >= 3) { |
| if(clipFlagsOr & CLIP_FAR) clipFar(polygon); |
| if(polygon.n >= 3) { |
| if(clipFlagsOr & CLIP_LEFT) clipLeft(polygon); |
| if(polygon.n >= 3) { |
| if(clipFlagsOr & CLIP_RIGHT) clipRight(polygon); |
| if(polygon.n >= 3) { |
| if(clipFlagsOr & CLIP_TOP) clipTop(polygon); |
| if(polygon.n >= 3) { |
| if(clipFlagsOr & CLIP_BOTTOM) clipBottom(polygon); |
| }}}}} |
| } |
| |
| if(clipFlagsOr & CLIP_USER) |
| { |
| int clipFlags = draw.clipFlags; |
| DrawData &data = *draw.data; |
| |
| if(polygon.n >= 3) { |
| if(clipFlags & CLIP_PLANE0) clipPlane(polygon, data.clipPlane[0]); |
| if(polygon.n >= 3) { |
| if(clipFlags & CLIP_PLANE1) clipPlane(polygon, data.clipPlane[1]); |
| if(polygon.n >= 3) { |
| if(clipFlags & CLIP_PLANE2) clipPlane(polygon, data.clipPlane[2]); |
| if(polygon.n >= 3) { |
| if(clipFlags & CLIP_PLANE3) clipPlane(polygon, data.clipPlane[3]); |
| if(polygon.n >= 3) { |
| if(clipFlags & CLIP_PLANE4) clipPlane(polygon, data.clipPlane[4]); |
| if(polygon.n >= 3) { |
| if(clipFlags & CLIP_PLANE5) clipPlane(polygon, data.clipPlane[5]); |
| }}}}}} |
| } |
| |
| return polygon.n >= 3; |
| } |
| |
| void Clipper::clipNear(Polygon &polygon) |
| { |
| const float4 **V = polygon.P[polygon.i]; |
| const float4 **T = polygon.P[polygon.i + 1]; |
| |
| int t = 0; |
| |
| for(int i = 0; i < polygon.n; i++) |
| { |
| int j = i == polygon.n - 1 ? 0 : i + 1; |
| |
| float di = V[i]->z - n * V[i]->w; |
| float dj = V[j]->z - n * V[j]->w; |
| |
| if(di >= 0) |
| { |
| T[t++] = V[i]; |
| |
| if(dj < 0) |
| { |
| clipEdge(polygon.B[polygon.b], *V[i], *V[j], di, dj); |
| T[t++] = &polygon.B[polygon.b++]; |
| } |
| } |
| else |
| { |
| if(dj > 0) |
| { |
| clipEdge(polygon.B[polygon.b], *V[j], *V[i], dj, di); |
| T[t++] = &polygon.B[polygon.b++]; |
| } |
| } |
| } |
| |
| polygon.n = t; |
| polygon.i += 1; |
| } |
| |
| void Clipper::clipFar(Polygon &polygon) |
| { |
| const float4 **V = polygon.P[polygon.i]; |
| const float4 **T = polygon.P[polygon.i + 1]; |
| |
| int t = 0; |
| |
| for(int i = 0; i < polygon.n; i++) |
| { |
| int j = i == polygon.n - 1 ? 0 : i + 1; |
| |
| float di = V[i]->w - V[i]->z; |
| float dj = V[j]->w - V[j]->z; |
| |
| if(di >= 0) |
| { |
| T[t++] = V[i]; |
| |
| if(dj < 0) |
| { |
| clipEdge(polygon.B[polygon.b], *V[i], *V[j], di, dj); |
| T[t++] = &polygon.B[polygon.b++]; |
| } |
| } |
| else |
| { |
| if(dj > 0) |
| { |
| clipEdge(polygon.B[polygon.b], *V[j], *V[i], dj, di); |
| T[t++] = &polygon.B[polygon.b++]; |
| } |
| } |
| } |
| |
| polygon.n = t; |
| polygon.i += 1; |
| } |
| |
| void Clipper::clipLeft(Polygon &polygon) |
| { |
| const float4 **V = polygon.P[polygon.i]; |
| const float4 **T = polygon.P[polygon.i + 1]; |
| |
| int t = 0; |
| |
| for(int i = 0; i < polygon.n; i++) |
| { |
| int j = i == polygon.n - 1 ? 0 : i + 1; |
| |
| float di = V[i]->w + V[i]->x; |
| float dj = V[j]->w + V[j]->x; |
| |
| if(di >= 0) |
| { |
| T[t++] = V[i]; |
| |
| if(dj < 0) |
| { |
| clipEdge(polygon.B[polygon.b], *V[i], *V[j], di, dj); |
| T[t++] = &polygon.B[polygon.b++]; |
| } |
| } |
| else |
| { |
| if(dj > 0) |
| { |
| clipEdge(polygon.B[polygon.b], *V[j], *V[i], dj, di); |
| T[t++] = &polygon.B[polygon.b++]; |
| } |
| } |
| } |
| |
| polygon.n = t; |
| polygon.i += 1; |
| } |
| |
| void Clipper::clipRight(Polygon &polygon) |
| { |
| const float4 **V = polygon.P[polygon.i]; |
| const float4 **T = polygon.P[polygon.i + 1]; |
| |
| int t = 0; |
| |
| for(int i = 0; i < polygon.n; i++) |
| { |
| int j = i == polygon.n - 1 ? 0 : i + 1; |
| |
| float di = V[i]->w - V[i]->x; |
| float dj = V[j]->w - V[j]->x; |
| |
| if(di >= 0) |
| { |
| T[t++] = V[i]; |
| |
| if(dj < 0) |
| { |
| clipEdge(polygon.B[polygon.b], *V[i], *V[j], di, dj); |
| T[t++] = &polygon.B[polygon.b++]; |
| } |
| } |
| else |
| { |
| if(dj > 0) |
| { |
| clipEdge(polygon.B[polygon.b], *V[j], *V[i], dj, di); |
| T[t++] = &polygon.B[polygon.b++]; |
| } |
| } |
| } |
| |
| polygon.n = t; |
| polygon.i += 1; |
| } |
| |
| void Clipper::clipTop(Polygon &polygon) |
| { |
| const float4 **V = polygon.P[polygon.i]; |
| const float4 **T = polygon.P[polygon.i + 1]; |
| |
| int t = 0; |
| |
| for(int i = 0; i < polygon.n; i++) |
| { |
| int j = i == polygon.n - 1 ? 0 : i + 1; |
| |
| float di = V[i]->w - V[i]->y; |
| float dj = V[j]->w - V[j]->y; |
| |
| if(di >= 0) |
| { |
| T[t++] = V[i]; |
| |
| if(dj < 0) |
| { |
| clipEdge(polygon.B[polygon.b], *V[i], *V[j], di, dj); |
| T[t++] = &polygon.B[polygon.b++]; |
| } |
| } |
| else |
| { |
| if(dj > 0) |
| { |
| clipEdge(polygon.B[polygon.b], *V[j], *V[i], dj, di); |
| T[t++] = &polygon.B[polygon.b++]; |
| } |
| } |
| } |
| |
| polygon.n = t; |
| polygon.i += 1; |
| } |
| |
| void Clipper::clipBottom(Polygon &polygon) |
| { |
| const float4 **V = polygon.P[polygon.i]; |
| const float4 **T = polygon.P[polygon.i + 1]; |
| |
| int t = 0; |
| |
| for(int i = 0; i < polygon.n; i++) |
| { |
| int j = i == polygon.n - 1 ? 0 : i + 1; |
| |
| float di = V[i]->w + V[i]->y; |
| float dj = V[j]->w + V[j]->y; |
| |
| if(di >= 0) |
| { |
| T[t++] = V[i]; |
| |
| if(dj < 0) |
| { |
| clipEdge(polygon.B[polygon.b], *V[i], *V[j], di, dj); |
| T[t++] = &polygon.B[polygon.b++]; |
| } |
| } |
| else |
| { |
| if(dj > 0) |
| { |
| clipEdge(polygon.B[polygon.b], *V[j], *V[i], dj, di); |
| T[t++] = &polygon.B[polygon.b++]; |
| } |
| } |
| } |
| |
| polygon.n = t; |
| polygon.i += 1; |
| } |
| |
| void Clipper::clipPlane(Polygon &polygon, const Plane &p) |
| { |
| const float4 **V = polygon.P[polygon.i]; |
| const float4 **T = polygon.P[polygon.i + 1]; |
| |
| int t = 0; |
| |
| for(int i = 0; i < polygon.n; i++) |
| { |
| int j = i == polygon.n - 1 ? 0 : i + 1; |
| |
| float di = p.A * V[i]->x + p.B * V[i]->y + p.C * V[i]->z + p.D * V[i]->w; |
| float dj = p.A * V[j]->x + p.B * V[j]->y + p.C * V[j]->z + p.D * V[j]->w; |
| |
| if(di >= 0) |
| { |
| T[t++] = V[i]; |
| |
| if(dj < 0) |
| { |
| clipEdge(polygon.B[polygon.b], *V[i], *V[j], di, dj); |
| T[t++] = &polygon.B[polygon.b++]; |
| } |
| } |
| else |
| { |
| if(dj > 0) |
| { |
| clipEdge(polygon.B[polygon.b], *V[j], *V[i], dj, di); |
| T[t++] = &polygon.B[polygon.b++]; |
| } |
| } |
| } |
| |
| polygon.n = t; |
| polygon.i += 1; |
| } |
| |
| inline void Clipper::clipEdge(float4 &Vo, const float4 &Vi, const float4 &Vj, float di, float dj) const |
| { |
| float D = 1.0f / (dj - di); |
| |
| Vo.x = (dj * Vi.x - di * Vj.x) * D; |
| Vo.y = (dj * Vi.y - di * Vj.y) * D; |
| Vo.z = (dj * Vi.z - di * Vj.z) * D; |
| Vo.w = (dj * Vi.w - di * Vj.w) * D; |
| } |
| } |