2022-02-08 21:49:56 +00:00
|
|
|
/*
|
|
|
|
|
Copyright (C) 2007 Peter Mackay and Chris Swindle.
|
|
|
|
|
Copyright (C) 2021 Sergey Galushko
|
|
|
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
|
|
|
modify it under the terms of the GNU General Public License
|
|
|
|
|
as published by the Free Software Foundation; either version 2
|
|
|
|
|
of the License, or (at your option) any later version.
|
|
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
|
|
|
|
|
|
See the GNU General Public License for more details.
|
|
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
|
along with this program; if not, write to the Free Software
|
|
|
|
|
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#define CLIPPING_DEBUGGING 0
|
|
|
|
|
#define CLIP_LEFT 1
|
|
|
|
|
#define CLIP_RIGHT 1
|
|
|
|
|
#define CLIP_BOTTOM 1
|
|
|
|
|
#define CLIP_TOP 1
|
|
|
|
|
#define CLIP_NEAR 0
|
|
|
|
|
#define CLIP_FAR 0
|
|
|
|
|
|
|
|
|
|
#include "clipping.hpp"
|
|
|
|
|
|
|
|
|
|
#include <algorithm>
|
|
|
|
|
#include <pspgu.h>
|
|
|
|
|
#include <pspgum.h>
|
|
|
|
|
|
|
|
|
|
#include "math.hpp"
|
|
|
|
|
|
|
|
|
|
extern "C"
|
|
|
|
|
{
|
|
|
|
|
#include "../quakedef.h"
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
namespace quake
|
|
|
|
|
{
|
|
|
|
|
namespace clipping
|
|
|
|
|
{
|
|
|
|
|
// Plane types are sorted, most likely to clip first.
|
|
|
|
|
enum plane_index
|
|
|
|
|
{
|
|
|
|
|
#if CLIP_BOTTOM
|
|
|
|
|
plane_index_bottom,
|
|
|
|
|
#endif
|
|
|
|
|
#if CLIP_LEFT
|
|
|
|
|
plane_index_left,
|
|
|
|
|
#endif
|
|
|
|
|
#if CLIP_RIGHT
|
|
|
|
|
plane_index_right,
|
|
|
|
|
#endif
|
|
|
|
|
#if CLIP_TOP
|
|
|
|
|
plane_index_top,
|
|
|
|
|
#endif
|
|
|
|
|
#if CLIP_NEAR
|
|
|
|
|
plane_index_near,
|
|
|
|
|
#endif
|
|
|
|
|
#if CLIP_FAR
|
|
|
|
|
plane_index_far,
|
|
|
|
|
#endif
|
|
|
|
|
plane_count
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// Types.
|
|
|
|
|
typedef ScePspFVector4 plane_type;
|
|
|
|
|
typedef plane_type frustum_t[plane_count];
|
|
|
|
|
|
|
|
|
|
// Transformed frustum.
|
|
|
|
|
static ScePspFMatrix4 projection_view_matrix __attribute__((aligned(16)));
|
|
|
|
|
static frustum_t projection_view_frustum __attribute__((aligned(16)));
|
|
|
|
|
static frustum_t clipping_frustum __attribute__((aligned(16)));
|
2023-09-16 13:00:48 +00:00
|
|
|
/*
|
|
|
|
|
shpuld's magical clipping adventures:
|
|
|
|
|
|
|
|
|
|
wide frustum explained, PSP hardware cull happens when any vert goes past the 0-4095 virtual coordinate space (VCS)
|
|
|
|
|
the viewport is centered in the middle of the VCS, so verts that go enough pixels past any of the screen edges to reach
|
|
|
|
|
the edge of the VCS get culled completely. this is why we need some kind of frustum clipping. however clipping to view
|
|
|
|
|
frustum is very wasteful, as most polys clipped to it would not get rejected by HW cull, only a tiny minority reach the edge of VCS.
|
|
|
|
|
|
|
|
|
|
for this reason, we have a wider frustum to better approximate (not calculated precisely) if polys get actually close to the edges.
|
|
|
|
|
now we could just use wide frustum only in clipping, check if clipping is required with the wide one, as well as clip with the wide one.
|
|
|
|
|
however this turned out to be slower, as a lot of the polygons that are completely out of regular frustum get through and get rendered,
|
|
|
|
|
and in addition polygons that clip the wider frustum might be completely out of view too so it's wasteful to clip them at all.
|
|
|
|
|
|
|
|
|
|
the currently fastest system uses wide frustum to check if a poly should proceed to clipping, if not then it gets drawn fast, then
|
|
|
|
|
polygons that do require clipping are then clipped using the accurate view frustum, this allows for vast majority of them to be rejected
|
|
|
|
|
when they fall completely outside the view. as a result the amount of actually clipped polygons ends up being extremely low.
|
|
|
|
|
this is fast.
|
|
|
|
|
*/
|
|
|
|
|
static ScePspFMatrix4 wide_projection_view_matrix __attribute__((aligned(16)));
|
|
|
|
|
static frustum_t wide_projection_view_frustum __attribute__((aligned(16)));
|
|
|
|
|
static frustum_t wide_clipping_frustum __attribute__((aligned(16)));
|
2022-02-08 21:49:56 +00:00
|
|
|
|
|
|
|
|
// The temporary working buffers.
|
|
|
|
|
static const std::size_t max_clipped_vertices = 32;
|
|
|
|
|
static glvert_t work_buffer[2][max_clipped_vertices] __attribute__((aligned(16)));
|
|
|
|
|
|
|
|
|
|
static inline void calculate_frustum(const ScePspFMatrix4& clip, frustum_t* frustum)
|
|
|
|
|
{
|
|
|
|
|
__asm__ (
|
|
|
|
|
".set push\n" // save assembler option
|
|
|
|
|
".set noreorder\n" // suppress reordering
|
|
|
|
|
#if CLIP_NEAR_FAR
|
|
|
|
|
"lv.q C000, 0(%6)\n" // C000 = clip->x
|
|
|
|
|
"lv.q C010, 16(%6)\n" // C010 = clip->y
|
|
|
|
|
"lv.q C020, 32(%6)\n" // C020 = clip->z
|
|
|
|
|
"lv.q C030, 48(%6)\n" // C030 = clip->w
|
|
|
|
|
#else
|
|
|
|
|
"lv.q C000, 0(%4)\n" // C000 = clip->x
|
|
|
|
|
"lv.q C010, 16(%4)\n" // C010 = clip->y
|
|
|
|
|
"lv.q C020, 32(%4)\n" // C020 = clip->z
|
|
|
|
|
"lv.q C030, 48(%4)\n" // C030 = clip->w
|
|
|
|
|
#endif
|
|
|
|
|
/* Extract the BOTTOM plane */
|
|
|
|
|
"vadd.s S100, S003, S001\n" // S100 = clip->x.w + clip->x.y
|
|
|
|
|
"vadd.s S101, S013, S011\n" // S101 = clip->y.w + clip->y.y
|
|
|
|
|
"vadd.s S102, S023, S021\n" // S102 = clip->z.w + clip->z.y
|
|
|
|
|
"vadd.s S103, S033, S031\n" // S103 = clip->w.w + clip->w.y
|
|
|
|
|
"vdot.q S110, C100, C100\n" // S110 = S100*S100 + S101*S101 + S102*S102 + S103*S103
|
|
|
|
|
"vzero.s S111\n" // S111 = 0
|
|
|
|
|
"vcmp.s EZ, S110\n" // CC[0] = ( S110 == 0.0f )
|
|
|
|
|
"vrsq.s S110, S110\n" // S110 = 1.0 / sqrt( S110 )
|
|
|
|
|
"vcmovt.s S110, S111, 0\n" // if ( CC[0] ) S110 = S111
|
|
|
|
|
"vscl.q C100[-1:1,-1:1,-1:1,-1:1], C100, S110\n" // C100 = C100 * S110
|
|
|
|
|
"sv.q C100, %0\n" // Store plane from register
|
|
|
|
|
/* Extract the LEFT plane */
|
|
|
|
|
"vadd.s S100, S003, S000\n" // S100 = clip->x.w + clip->x.x
|
|
|
|
|
"vadd.s S101, S013, S010\n" // S101 = clip->y.w + clip->y.x
|
|
|
|
|
"vadd.s S102, S023, S020\n" // S102 = clip->z.w + clip->z.x
|
|
|
|
|
"vadd.s S103, S033, S030\n" // S103 = clip->w.w + clip->w.x
|
|
|
|
|
"vdot.q S110, C100, C100\n" // S110 = S100*S100 + S101*S101 + S102*S102 + S103*S103
|
|
|
|
|
"vzero.s S111\n" // S111 = 0
|
|
|
|
|
"vcmp.s EZ, S110\n" // CC[0] = ( S110 == 0.0f )
|
|
|
|
|
"vrsq.s S110, S110\n" // S110 = 1.0 / sqrt( S110 )
|
|
|
|
|
"vcmovt.s S110, S111, 0\n" // if ( CC[0] ) S110 = S111
|
|
|
|
|
"vscl.q C100[-1:1,-1:1,-1:1,-1:1], C100, S110\n" // C100 = C100 * S110
|
|
|
|
|
"sv.q C100, %1\n" // Store plane from register
|
|
|
|
|
/* Extract the RIGHT plane */
|
|
|
|
|
"vsub.s S100, S003, S000\n" // S100 = clip->x.w - clip->x.x
|
|
|
|
|
"vsub.s S101, S013, S010\n" // S101 = clip->y.w - clip->y.x
|
|
|
|
|
"vsub.s S102, S023, S020\n" // S102 = clip->z.w - clip->z.x
|
|
|
|
|
"vsub.s S103, S033, S030\n" // S103 = clip->w.w - clip->w.x
|
|
|
|
|
"vdot.q S110, C100, C100\n" // S110 = S100*S100 + S101*S101 + S102*S102 + S103*S103
|
|
|
|
|
"vzero.s S111\n" // S111 = 0
|
|
|
|
|
"vcmp.s EZ, S110\n" // CC[0] = ( S110 == 0.0f )
|
|
|
|
|
"vrsq.s S110, S110\n" // S110 = 1.0 / sqrt( S110 )
|
|
|
|
|
"vcmovt.s S110, S111, 0\n" // if ( CC[0] ) S110 = S111
|
|
|
|
|
"vscl.q C100[-1:1,-1:1,-1:1,-1:1], C100, S110\n" // C100 = C100 * S110
|
|
|
|
|
"sv.q C100, %2\n" // Store plane from register
|
|
|
|
|
/* Extract the TOP plane */
|
|
|
|
|
"vsub.s S100, S003, S001\n" // S100 = clip->x.w - clip->x.y
|
|
|
|
|
"vsub.s S101, S013, S011\n" // S101 = clip->y.w - clip->y.y
|
|
|
|
|
"vsub.s S102, S023, S021\n" // S102 = clip->z.w - clip->z.y
|
|
|
|
|
"vsub.s S103, S033, S031\n" // S103 = clip->w.w - clip->w.y
|
|
|
|
|
"vdot.q S110, C100, C100\n" // S110 = S100*S100 + S101*S101 + S102*S102 + S103*S103
|
|
|
|
|
"vzero.s S111\n" // S111 = 0
|
|
|
|
|
"vcmp.s EZ, S110\n" // CC[0] = ( S110 == 0.0f )
|
|
|
|
|
"vrsq.s S110, S110\n" // S110 = 1.0 / sqrt( S110 )
|
|
|
|
|
"vcmovt.s S110, S111, 0\n" // if ( CC[0] ) S110 = S111
|
|
|
|
|
"vscl.q C100[-1:1,-1:1,-1:1,-1:1], C100, S110\n" // C100 = C100 * S110
|
|
|
|
|
"sv.q C100, %3\n" // Store plane from register
|
|
|
|
|
#if CLIP_NEAR_FAR
|
|
|
|
|
/* Extract the NEAR plane */
|
|
|
|
|
"vadd.s S100, S003, S002\n" // S100 = clip->x.w + clip->x.z
|
|
|
|
|
"vadd.s S101, S013, S012\n" // S101 = clip->y.w + clip->y.z
|
|
|
|
|
"vadd.s S102, S023, S022\n" // S102 = clip->z.w + clip->z.z
|
|
|
|
|
"vadd.s S103, S033, S032\n" // S103 = clip->w.w + clip->w.z
|
|
|
|
|
"vdot.q S110, C100, C100\n" // S110 = S100*S100 + S101*S101 + S102*S102 + S103*S103
|
|
|
|
|
"vzero.s S111\n" // S111 = 0
|
|
|
|
|
"vcmp.s EZ, S110\n" // CC[0] = ( S110 == 0.0f )
|
|
|
|
|
"vrsq.s S110, S110\n" // S110 = 1.0 / sqrt( S110 )
|
|
|
|
|
"vcmovt.s S110, S111, 0\n" // if ( CC[0] ) S110 = S111
|
|
|
|
|
"vscl.q C100[-1:1,-1:1,-1:1,-1:1], C100, S110\n" // C100 = C100 * S110
|
|
|
|
|
"sv.q C100, %4\n" // Store plane from register
|
|
|
|
|
/* Extract the FAR plane */
|
|
|
|
|
"vsub.s S100, S003, S002\n" // S100 = clip->x.w - clip->x.z
|
|
|
|
|
"vsub.s S101, S013, S012\n" // S101 = clip->y.w - clip->y.z
|
|
|
|
|
"vsub.s S102, S023, S022\n" // S102 = clip->z.w - clip->z.z
|
|
|
|
|
"vsub.s S103, S033, S032\n" // S103 = clip->w.w - clip->w.z
|
|
|
|
|
"vdot.q S110, C100, C100\n" // S110 = S100*S100 + S101*S101 + S102*S102 + S103*S103
|
|
|
|
|
"vzero.s S111\n" // S111 = 0
|
|
|
|
|
"vcmp.s EZ, S110\n" // CC[0] = ( S110 == 0.0f )
|
|
|
|
|
"vrsq.s S110, S110\n" // S110 = 1.0 / sqrt( S110 )
|
|
|
|
|
"vcmovt.s S110, S111, 0\n" // if ( CC[0] ) S110 = S111
|
|
|
|
|
"vscl.q C100[-1:1,-1:1,-1:1,-1:1], C100, S110\n" // C100 = C100 * S110
|
|
|
|
|
"sv.q C100, %5\n" // Store plane from register
|
|
|
|
|
#endif
|
|
|
|
|
".set pop\n" // Restore assembler option
|
|
|
|
|
: "=m"( ( *frustum )[plane_index_bottom] ),
|
|
|
|
|
"=m"( ( *frustum )[plane_index_left] ),
|
|
|
|
|
"=m"( ( *frustum )[plane_index_right] ),
|
|
|
|
|
#if CLIP_NEAR_FAR
|
|
|
|
|
"=m"( ( *frustum )[plane_index_top] ),
|
|
|
|
|
"=m"( ( *frustum )[plane_index_near] ),
|
|
|
|
|
"=m"( ( *frustum )[plane_index_far] )
|
|
|
|
|
#else
|
|
|
|
|
"=m"( ( *frustum )[plane_index_top] )
|
|
|
|
|
#endif
|
|
|
|
|
: "r"( &clip )
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
|
2023-09-16 13:00:48 +00:00
|
|
|
void begin_frame(float regularfov, float wideclippingfov, float screenaspect)
|
2022-02-08 21:49:56 +00:00
|
|
|
{
|
|
|
|
|
// Get the projection matrix.
|
|
|
|
|
sceGumMatrixMode(GU_PROJECTION);
|
2023-09-16 13:00:48 +00:00
|
|
|
sceGumLoadIdentity();
|
|
|
|
|
sceGumPerspective(regularfov + 1.0f, screenaspect, 6, 4096); // add + 1.0f to reduce the 1px lines at the edge of viewport when polys get clipped
|
|
|
|
|
sceGumUpdateMatrix();
|
|
|
|
|
|
2022-02-08 21:49:56 +00:00
|
|
|
ScePspFMatrix4 proj;
|
|
|
|
|
sceGumStoreMatrix(&proj);
|
|
|
|
|
|
2023-09-16 13:00:48 +00:00
|
|
|
sceGumLoadIdentity();
|
|
|
|
|
sceGumPerspective(wideclippingfov, screenaspect, 6, 4096);
|
|
|
|
|
sceGumUpdateMatrix();
|
|
|
|
|
|
|
|
|
|
ScePspFMatrix4 wide_proj;
|
|
|
|
|
sceGumStoreMatrix(&wide_proj);
|
|
|
|
|
|
2022-02-08 21:49:56 +00:00
|
|
|
// Get the view matrix.
|
|
|
|
|
sceGumMatrixMode(GU_VIEW);
|
|
|
|
|
ScePspFMatrix4 view;
|
|
|
|
|
sceGumStoreMatrix(&view);
|
|
|
|
|
|
|
|
|
|
// Restore matrix mode.
|
|
|
|
|
sceGumMatrixMode(GU_MODEL);
|
|
|
|
|
|
|
|
|
|
// Combine the two matrices (multiply projection by view).
|
|
|
|
|
gumMultMatrix(&projection_view_matrix, &proj, &view);
|
2023-09-16 13:00:48 +00:00
|
|
|
gumMultMatrix(&wide_projection_view_matrix, &wide_proj, &view);
|
2022-02-08 21:49:56 +00:00
|
|
|
|
|
|
|
|
// Calculate and cache the clipping frustum.
|
|
|
|
|
calculate_frustum(projection_view_matrix, &projection_view_frustum);
|
2023-09-16 13:00:48 +00:00
|
|
|
calculate_frustum(wide_projection_view_matrix, &wide_projection_view_frustum);
|
2022-02-08 21:49:56 +00:00
|
|
|
|
|
|
|
|
__asm__ volatile (
|
|
|
|
|
"ulv.q C700, %4\n" // Load plane into register
|
|
|
|
|
"ulv.q C710, %5\n" // Load plane into register
|
|
|
|
|
"ulv.q C720, %6\n" // Load plane into register
|
|
|
|
|
"ulv.q C730, %7\n" // Load plane into register
|
|
|
|
|
"sv.q C700, %0\n" // Store plane from register
|
|
|
|
|
"sv.q C710, %1\n" // Store plane from register
|
|
|
|
|
"sv.q C720, %2\n" // Store plane from register
|
|
|
|
|
"sv.q C730, %3\n" // Store plane from register
|
|
|
|
|
: "=m"( clipping_frustum[plane_index_bottom] ),
|
|
|
|
|
"=m"( clipping_frustum[plane_index_left] ),
|
|
|
|
|
"=m"( clipping_frustum[plane_index_right] ),
|
|
|
|
|
"=m"( clipping_frustum[plane_index_top] )
|
|
|
|
|
: "m"( projection_view_frustum[plane_index_bottom] ),
|
|
|
|
|
"m"( projection_view_frustum[plane_index_left] ),
|
|
|
|
|
"m"( projection_view_frustum[plane_index_right] ),
|
|
|
|
|
"m"( projection_view_frustum[plane_index_top] )
|
|
|
|
|
);
|
2023-09-16 13:00:48 +00:00
|
|
|
|
|
|
|
|
__asm__ volatile (
|
|
|
|
|
"ulv.q C500, %4\n" // Load plane into register
|
|
|
|
|
"ulv.q C510, %5\n" // Load plane into register
|
|
|
|
|
"ulv.q C520, %6\n" // Load plane into register
|
|
|
|
|
"ulv.q C530, %7\n" // Load plane into register
|
|
|
|
|
"sv.q C500, %0\n" // Store plane from register
|
|
|
|
|
"sv.q C510, %1\n" // Store plane from register
|
|
|
|
|
"sv.q C520, %2\n" // Store plane from register
|
|
|
|
|
"sv.q C530, %3\n" // Store plane from register
|
|
|
|
|
: "=m"( wide_clipping_frustum[plane_index_bottom] ),
|
|
|
|
|
"=m"( wide_clipping_frustum[plane_index_left] ),
|
|
|
|
|
"=m"( wide_clipping_frustum[plane_index_right] ),
|
|
|
|
|
"=m"( wide_clipping_frustum[plane_index_top] )
|
|
|
|
|
: "m"( wide_projection_view_frustum[plane_index_bottom] ),
|
|
|
|
|
"m"( wide_projection_view_frustum[plane_index_left] ),
|
|
|
|
|
"m"( wide_projection_view_frustum[plane_index_right] ),
|
|
|
|
|
"m"( wide_projection_view_frustum[plane_index_top] )
|
|
|
|
|
);
|
2022-02-08 21:49:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void begin_brush_model()
|
|
|
|
|
{
|
|
|
|
|
// Get the model matrix.
|
|
|
|
|
ScePspFMatrix4 model_matrix;
|
|
|
|
|
sceGumStoreMatrix(&model_matrix);
|
|
|
|
|
|
|
|
|
|
// Combine the matrices (multiply projection-view by model).
|
|
|
|
|
ScePspFMatrix4 projection_view_model_matrix;
|
|
|
|
|
gumMultMatrix(&projection_view_model_matrix, &projection_view_matrix, &model_matrix);
|
|
|
|
|
|
|
|
|
|
// Calculate the clipping frustum.
|
|
|
|
|
calculate_frustum(projection_view_model_matrix, &clipping_frustum);
|
2023-09-16 13:00:48 +00:00
|
|
|
|
2022-02-08 21:49:56 +00:00
|
|
|
__asm__ volatile (
|
|
|
|
|
"ulv.q C700, %0\n" // Load plane into register
|
|
|
|
|
"ulv.q C710, %1\n" // Load plane into register
|
|
|
|
|
"ulv.q C720, %2\n" // Load plane into register
|
|
|
|
|
"ulv.q C730, %3\n" // Load plane into register
|
|
|
|
|
:: "m"(clipping_frustum[plane_index_bottom]),
|
|
|
|
|
"m"(clipping_frustum[plane_index_left]),
|
|
|
|
|
"m"(clipping_frustum[plane_index_right]),
|
|
|
|
|
"m"(clipping_frustum[plane_index_top])
|
|
|
|
|
);
|
2023-09-16 13:00:48 +00:00
|
|
|
|
|
|
|
|
// Combine the matrices (multiply projection-view by model).
|
|
|
|
|
ScePspFMatrix4 wide_projection_view_model_matrix;
|
|
|
|
|
gumMultMatrix(&wide_projection_view_model_matrix, &wide_projection_view_matrix, &model_matrix);
|
|
|
|
|
|
|
|
|
|
// Calculate the clipping frustum.
|
|
|
|
|
calculate_frustum(wide_projection_view_model_matrix, &wide_clipping_frustum);
|
|
|
|
|
|
|
|
|
|
__asm__ volatile (
|
|
|
|
|
"ulv.q C500, %0\n" // Load plane into register
|
|
|
|
|
"ulv.q C510, %1\n" // Load plane into register
|
|
|
|
|
"ulv.q C520, %2\n" // Load plane into register
|
|
|
|
|
"ulv.q C530, %3\n" // Load plane into register
|
|
|
|
|
:: "m"(wide_clipping_frustum[plane_index_bottom]),
|
|
|
|
|
"m"(wide_clipping_frustum[plane_index_left]),
|
|
|
|
|
"m"(wide_clipping_frustum[plane_index_right]),
|
|
|
|
|
"m"(wide_clipping_frustum[plane_index_top])
|
|
|
|
|
);
|
2022-02-08 21:49:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void end_brush_model()
|
|
|
|
|
{
|
|
|
|
|
// Restore the clipping frustum.
|
|
|
|
|
__asm__ volatile (
|
|
|
|
|
"ulv.q C700, %4\n" // Load plane into register
|
|
|
|
|
"ulv.q C710, %5\n" // Load plane into register
|
|
|
|
|
"ulv.q C720, %6\n" // Load plane into register
|
|
|
|
|
"ulv.q C730, %7\n" // Load plane into register
|
|
|
|
|
"sv.q C700, %0\n" // Store plane from register
|
|
|
|
|
"sv.q C710, %1\n" // Store plane from register
|
|
|
|
|
"sv.q C720, %2\n" // Store plane from register
|
|
|
|
|
"sv.q C730, %3\n" // Store plane from register
|
|
|
|
|
: "=m"( clipping_frustum[plane_index_bottom] ),
|
|
|
|
|
"=m"( clipping_frustum[plane_index_left] ),
|
|
|
|
|
"=m"( clipping_frustum[plane_index_right] ),
|
|
|
|
|
"=m"( clipping_frustum[plane_index_top] )
|
|
|
|
|
: "m"( projection_view_frustum[plane_index_bottom] ),
|
|
|
|
|
"m"( projection_view_frustum[plane_index_left] ),
|
|
|
|
|
"m"( projection_view_frustum[plane_index_right] ),
|
|
|
|
|
"m"( projection_view_frustum[plane_index_top] )
|
|
|
|
|
);
|
2023-09-16 13:00:48 +00:00
|
|
|
|
|
|
|
|
__asm__ volatile (
|
|
|
|
|
"ulv.q C500, %4\n" // Load plane into register
|
|
|
|
|
"ulv.q C510, %5\n" // Load plane into register
|
|
|
|
|
"ulv.q C520, %6\n" // Load plane into register
|
|
|
|
|
"ulv.q C530, %7\n" // Load plane into register
|
|
|
|
|
"sv.q C500, %0\n" // Store plane from register
|
|
|
|
|
"sv.q C510, %1\n" // Store plane from register
|
|
|
|
|
"sv.q C520, %2\n" // Store plane from register
|
|
|
|
|
"sv.q C530, %3\n" // Store plane from register
|
|
|
|
|
: "=m"( wide_clipping_frustum[plane_index_bottom] ),
|
|
|
|
|
"=m"( wide_clipping_frustum[plane_index_left] ),
|
|
|
|
|
"=m"( wide_clipping_frustum[plane_index_right] ),
|
|
|
|
|
"=m"( wide_clipping_frustum[plane_index_top] )
|
|
|
|
|
: "m"( wide_projection_view_frustum[plane_index_bottom] ),
|
|
|
|
|
"m"( wide_projection_view_frustum[plane_index_left] ),
|
|
|
|
|
"m"( wide_projection_view_frustum[plane_index_right] ),
|
|
|
|
|
"m"( wide_projection_view_frustum[plane_index_top] )
|
|
|
|
|
);
|
2022-02-08 21:49:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool is_clipping_required(const struct glvert_s* vertices, std::size_t vertex_count)
|
|
|
|
|
{
|
|
|
|
|
int res;
|
|
|
|
|
__asm__ (
|
|
|
|
|
".set push\n" // save assembler option
|
|
|
|
|
".set noreorder\n" // suppress reordering
|
2023-03-02 00:32:49 +00:00
|
|
|
"move $8, %1\n" // $8 = &v[0]
|
|
|
|
|
"move $9, %2\n" // $9 = vc
|
|
|
|
|
"li $10, 20\n" // $10 = 20( sizeof( gu_vert_t ) )
|
|
|
|
|
"mul $10, $10, $9\n" // $10 = $10 * $9
|
|
|
|
|
"addu $10, $10, $8\n" // $10 = $10 + $8
|
|
|
|
|
"addiu %0, $0, 1\n" // res = 1
|
|
|
|
|
"vzero.q C600\n" // C600 = [0.0f, 0.0f, 0.0f. 0.0f]
|
2022-02-08 21:49:56 +00:00
|
|
|
"0:\n" // loop
|
2023-03-02 00:32:49 +00:00
|
|
|
"lv.s S610, 8($8)\n" // S610 = v[i].xyz[0]
|
|
|
|
|
"lv.s S611, 12($8)\n" // S611 = v[i].xyz[1]
|
|
|
|
|
"lv.s S612, 16($8)\n" // S612 = v[i].xyz[2]
|
2023-09-16 13:00:48 +00:00
|
|
|
"vhtfm4.q C620, M500, C610\n" // C620 = frustrum * v[i].xyz, note: 500 is wide frustum, 700 is regular frustum
|
2023-03-02 00:32:49 +00:00
|
|
|
"vcmp.q LT, C620, C600\n" // S620 < 0.0f || S621 < 0.0f || S622 < 0.0f || S623 < 0.0f
|
2022-02-08 21:49:56 +00:00
|
|
|
"bvt 4, 1f\n" // if ( CC[4] == 1 ) jump to exit
|
2023-03-02 00:32:49 +00:00
|
|
|
"addiu $8, $8, 20\n" // $8 = $8 + 20( sizeof( gu_vert_t ) ) ( delay slot )
|
|
|
|
|
"bne $10, $8, 0b\n" // if ( $10 != $8 ) jump to loop
|
|
|
|
|
"nop\n" // ( delay slot )
|
2022-02-08 21:49:56 +00:00
|
|
|
"move %0, $0\n" // res = 0
|
|
|
|
|
"1:\n" // exit
|
|
|
|
|
".set pop\n" // Restore assembler option
|
|
|
|
|
: "=r"(res)
|
|
|
|
|
: "r"(vertices), "r"(vertex_count)
|
|
|
|
|
: "$8", "$9", "$10"
|
|
|
|
|
);
|
|
|
|
|
return (res == 1) ? true : false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Clips a polygon against a plane.
|
|
|
|
|
// http://hpcc.engin.umich.edu/CFD/users/charlton/Thesis/html/node90.html
|
|
|
|
|
static void clip_to_plane(
|
|
|
|
|
const plane_type& plane,
|
|
|
|
|
const glvert_t* const unclipped_vertices,
|
|
|
|
|
std::size_t const unclipped_vertex_count,
|
|
|
|
|
glvert_t* const clipped_vertices,
|
|
|
|
|
std::size_t* const clipped_vertex_count)
|
|
|
|
|
{
|
|
|
|
|
__asm__ (
|
|
|
|
|
".set push\n" // save assembler option
|
|
|
|
|
".set noreorder\n" // suppress reordering
|
|
|
|
|
"move $8, %1\n" // $8 = uv[0] is S
|
|
|
|
|
"addiu $9, $8, 20\n" // $9 = uv[1] is P
|
|
|
|
|
"move $10, %2\n" // $10 = uvc
|
|
|
|
|
"li $11, 20\n" // $11 = 20( sizeof( gu_vert_t ) )
|
|
|
|
|
"mul $11, $11, $10\n" // $11 = $11 * $10
|
|
|
|
|
"addu $11, $11, $8\n" // $11 = $11 + $8
|
|
|
|
|
"move $12, %3\n" // $12 = &cv[0]
|
|
|
|
|
"move %0, $0\n" // cvc = 0
|
|
|
|
|
"ulv.q C100, %4\n" // Load plane into register
|
|
|
|
|
"vzero.s S110\n" // Set zero for cmp
|
|
|
|
|
"0:\n" // loop
|
|
|
|
|
"ulv.q C000, 0($8)\n" // Load vertex S TEX(8b) into register
|
|
|
|
|
"vzero.p C002\n" // Set the 3th and 4th entry C000 to zero
|
|
|
|
|
"ulv.q C010, 8($8)\n" // Load vertex S XYZ(12b) into register
|
|
|
|
|
"vzero.s S013\n" // Set the 4th entry C010 to zero
|
|
|
|
|
"ulv.q C020, 0($9)\n" // Load vertex P TEX(8b) into register
|
|
|
|
|
"vzero.p C022\n" // Set the 3th and 4th entry C020 to zero
|
|
|
|
|
"ulv.q C030, 8($9)\n" // Load vertex P XYZ(12b) into register
|
|
|
|
|
"vzero.s S033\n" // Set the 4th entry C030 to zero
|
|
|
|
|
"vdot.q S111, C100, C010\n" // S111 = plane * S
|
|
|
|
|
"vdot.q S112, C100, C030\n" // S112 = plane * P
|
|
|
|
|
"vadd.s S111, S111, S103\n" // S111 = S111 + plane->w is S dist
|
|
|
|
|
"vadd.s S112, S112, S103\n" // S112 = S112 + plane->w is P dist
|
|
|
|
|
"vcmp.s LE, S111, S110\n" // (S dist <= 0.0f)
|
|
|
|
|
"bvt 0, 2f\n" // if ( CC[0] == 1 ) jump to 2f
|
|
|
|
|
"nop\n" // ( delay slot )
|
|
|
|
|
"vcmp.s LE, S112, S110\n" // (P dist <= 0.0f)
|
|
|
|
|
"bvt 0, 1f\n" // if ( CC[0] == 1 ) jump to 1f
|
|
|
|
|
"nop\n" // ( delay slot )
|
|
|
|
|
"sv.s S020, 0($12)\n" // cv->uv[0] = C020 TEX U
|
|
|
|
|
"sv.s S021, 4($12)\n" // cv->uv[1] = C021 TEX V
|
|
|
|
|
"sv.s S030, 8($12)\n" // cv->xyz[0] = C030 XYZ X
|
|
|
|
|
"sv.s S031, 12($12)\n" // cv->xyz[1] = C031 XYZ Y
|
|
|
|
|
"sv.s S032, 16($12)\n" // cv->xyz[2] = C032 XYZ Z
|
|
|
|
|
"addiu $12, $12, 20\n" // $12 = $12 + 20( sizeof( gu_vert_t ) )
|
|
|
|
|
"j 3f\n" // jump to next
|
|
|
|
|
"addiu %0, %0, 1\n" // cvc += 1 ( delay slot )
|
|
|
|
|
"1:\n"
|
|
|
|
|
"vsub.s S112, S111, S112\n" // S112 = ( S dist - P dist )
|
|
|
|
|
"vdiv.s S112, S111, S112\n" // S112 = S111 / S112
|
|
|
|
|
"vsub.q C120, C020, C000\n" // C120 = C020(P TEX) - C000(S TEX)
|
|
|
|
|
"vsub.q C130, C030, C010\n" // C130 = C030(P XYZ) - C010(S XYZ)
|
|
|
|
|
"vscl.q C120, C120, S112\n" // C120 = C020 * S112
|
|
|
|
|
"vscl.q C130, C130, S112\n" // C130 = C030 * S112
|
|
|
|
|
"vadd.q C120, C120, C000\n" // C120 = C120 + C000(S TEX)
|
|
|
|
|
"vadd.q C130, C130, C010\n" // C130 = C130 + C010(S XYZ)
|
|
|
|
|
"sv.s S120, 0($12)\n" // cv->uv[0] = S120 TEX U
|
|
|
|
|
"sv.s S121, 4($12)\n" // cv->uv[1] = S121 TEX V
|
|
|
|
|
"sv.s S130, 8($12)\n" // cv->xyz[0] = S130 XYZ X
|
|
|
|
|
"sv.s S131, 12($12)\n" // cv->xyz[1] = S131 XYZ Y
|
|
|
|
|
"sv.s S132, 16($12)\n" // cv->xyz[2] = S132 XYZ Z
|
|
|
|
|
"addiu $12, $12, 20\n" // $12 = $12 + 20( sizeof( gu_vert_t ) )
|
|
|
|
|
"j 3f\n" // jump to next
|
|
|
|
|
"addiu %0, %0, 1\n" // cvc += 1 ( delay slot )
|
|
|
|
|
"2:\n"
|
|
|
|
|
"vcmp.s LE, S112, S110\n" // (P dist <= 0.0f)
|
|
|
|
|
"bvt 0, 3f\n" // if ( CC[0] == 1 ) jump to next
|
|
|
|
|
"nop\n" // ( delay slot )
|
|
|
|
|
"vsub.s S112, S111, S112\n" // S112 = ( S dist - P dist )
|
|
|
|
|
"vdiv.s S112, S111, S112\n" // S112 = S111 / S112
|
|
|
|
|
"vsub.q C120, C020, C000\n" // C120 = C020(P TEX) - C000(S TEX)
|
|
|
|
|
"vsub.q C130, C030, C010\n" // C130 = C030(P XYZ) - C010(S XYZ)
|
|
|
|
|
"vscl.q C120, C120, S112\n" // C120 = C020 * S112
|
|
|
|
|
"vscl.q C130, C130, S112\n" // C130 = C030 * S112
|
|
|
|
|
"vadd.q C120, C120, C000\n" // C120 = C120 + C000(S TEX)
|
|
|
|
|
"vadd.q C130, C130, C010\n" // C130 = C130 + C010(S XYZ)
|
|
|
|
|
"sv.s S120, 0($12)\n" // cv->uv[0] = S120 TEX U
|
|
|
|
|
"sv.s S121, 4($12)\n" // cv->uv[1] = S121 TEX V
|
|
|
|
|
"sv.s S130, 8($12)\n" // cv->xyz[0] = S130 XYZ X
|
|
|
|
|
"sv.s S131, 12($12)\n" // cv->xyz[1] = S131 XYZ Y
|
|
|
|
|
"sv.s S132, 16($12)\n" // cv->xyz[2] = S132 XYZ Z
|
|
|
|
|
"addiu $12, $12, 20\n" // $12 = $12 + 20( sizeof( gu_vert_t ) )
|
|
|
|
|
"addiu %0, %0, 1\n" // cvc += 1
|
|
|
|
|
"sv.s S020, 0($12)\n" // cv->uv[0] = S020 TEX U
|
|
|
|
|
"sv.s S021, 4($12)\n" // cv->uv[1] = S021 TEX V
|
|
|
|
|
"sv.s S030, 8($12)\n" // cv->xyz[0] = S030 XYZ X
|
|
|
|
|
"sv.s S031, 12($12)\n" // cv->xyz[1] = S031 XYZ Y
|
|
|
|
|
"sv.s S032, 16($12)\n" // cv->xyz[2] = S032 XYZ Z
|
|
|
|
|
"addiu $12, $12, 20\n" // $12 = $12 + 20( sizeof( gu_vert_t ) )
|
|
|
|
|
"addiu %0, %0, 1\n" // cvc += 1
|
|
|
|
|
"3:\n" // next
|
|
|
|
|
"addiu $8, $8, 20\n" // $8 = $8 + 20( sizeof( gu_vert_t ) )
|
|
|
|
|
"addiu $9, $8, 20\n" // $9 = $8 + 20( sizeof( gu_vert_t ) )
|
|
|
|
|
"bne $9, $11, 4f\n" // if ( $11 != $9 ) jump to next
|
|
|
|
|
"nop\n"
|
|
|
|
|
"move $9, %1\n" // $9 = &uv[0] set P
|
|
|
|
|
"4:\n"
|
|
|
|
|
"bne $11, $8, 0b\n" // if ( $11 != $8 ) jump to loop
|
|
|
|
|
"nop\n" // ( delay slot )
|
|
|
|
|
".set pop\n" // Restore assembler option
|
|
|
|
|
: "+r"( *clipped_vertex_count )
|
|
|
|
|
: "r"( unclipped_vertices ), "r"( unclipped_vertex_count ), "r"( clipped_vertices ), "m"( plane )
|
|
|
|
|
: "$8", "$9", "$10", "$11", "$12"
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Clips a polygon against the frustum.
|
|
|
|
|
void clip(
|
|
|
|
|
const struct glvert_s* unclipped_vertices,
|
|
|
|
|
std::size_t unclipped_vertex_count,
|
|
|
|
|
const struct glvert_s** clipped_vertices,
|
|
|
|
|
std::size_t* clipped_vertex_count)
|
|
|
|
|
{
|
|
|
|
|
// No vertices to clip?
|
|
|
|
|
if (!unclipped_vertex_count)
|
|
|
|
|
{
|
|
|
|
|
// Error.
|
|
|
|
|
Sys_Error("Calling clip with zero vertices");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Set up constants.
|
|
|
|
|
const plane_type* const last_plane = &clipping_frustum[plane_count];
|
|
|
|
|
|
|
|
|
|
// Set up the work buffer pointers.
|
|
|
|
|
const glvert_t* src = unclipped_vertices;
|
|
|
|
|
glvert_t* dst = work_buffer[0];
|
|
|
|
|
std::size_t vertex_count = unclipped_vertex_count;
|
|
|
|
|
|
|
|
|
|
// For each frustum plane...
|
|
|
|
|
for (const plane_type* plane = &clipping_frustum[0]; plane != last_plane; ++plane)
|
|
|
|
|
{
|
|
|
|
|
// Clip the poly against this frustum plane.
|
|
|
|
|
clip_to_plane(*plane, src, vertex_count, dst, &vertex_count);
|
|
|
|
|
|
|
|
|
|
// No vertices left to clip?
|
|
|
|
|
if (!vertex_count)
|
|
|
|
|
{
|
|
|
|
|
// Quit early.
|
|
|
|
|
*clipped_vertex_count = 0;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Use the next pair of buffers.
|
|
|
|
|
src = dst;
|
|
|
|
|
if (dst == work_buffer[0])
|
|
|
|
|
{
|
|
|
|
|
dst = work_buffer[1];
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
dst = work_buffer[0];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Fill in the return data.
|
|
|
|
|
*clipped_vertices = src;
|
|
|
|
|
*clipped_vertex_count = vertex_count;
|
|
|
|
|
}
|
|
|
|
|
}
|
2023-09-16 13:00:48 +00:00
|
|
|
}
|
