#include <gp/coord.h>
#include <gp/colors.h>
#include "frame_buffer.h"
class Our_3D {
public:
Our_3D(pFrame_Buffer& fbp)
:frame_buffer(fbp)
{
vtx_colors = nullptr;
vtx_coors = nullptr;
topology_strip = false;
vtx_normals = nullptr;
};
Our_3D& transform_eye_from_object_set(const pMatrix& m)
{
eye_from_object = m;
return *this;
}
Our_3D& transform_clip_from_eye_set(const pMatrix& m)
{
clip_from_eye = m;
return *this;
}
Our_3D& light_location_set(const pCoor c)
{
light_location = c;
return *this;
}
Our_3D& light_color_set(const pColor c)
{
light_color = c;
return *this;
}
Our_3D& vtx_coors_set(vector<pCoor>& c)
{
vtx_coors = &c;
return *this;
}
Our_3D& vtx_colors_set(vector<pColor>& c)
{
vtx_colors = &c;
return *this;
}
Our_3D& topology_strip_set( bool strip = true )
{
topology_strip = strip;
return *this;
}
Our_3D& vtx_normals_set()
{
vtx_normals = nullptr;
return *this;
}
Our_3D& vtx_normals_set(vector<pVect4>& c)
{
vtx_normals = c.data();
return *this;
}
Our_3D& draw_rasterization();
pFrame_Buffer& frame_buffer;
pMatrix eye_from_object, clip_from_eye;
pCoor light_location;
pColor light_color;
vector<pCoor> *vtx_coors;
vector<pColor> *vtx_colors;
bool opt_tryout1, opt_tryout2;
bool topology_strip;
pVect4 *vtx_normals;
};
class World : public World_Base {
public:
World(pFrame_Buffer& fb):World_Base(fb),gc(fb){}
Our_3D gc;
virtual void render(bool first_time)
{
if ( first_time ) init_scene();
render_scene();
}
void init_scene();
void render_scene();
pCoor eye_location, light_location;
pCoor *adj_location;
pVect eye_direction;
bool opt_strip, opt_normals;
bool opt_tryout1,opt_tryout2;
};
void
World::init_scene()
{
eye_location = pCoor(-1.2,.5,10.2);
light_location = pCoor(-2.2,1.5,10.2);
eye_direction = pVect(.1,0,-1);
adj_location = &eye_location;
opt_tryout1 = opt_tryout2 = false;
gc.opt_tryout1 = opt_tryout1;
gc.opt_tryout2 = opt_tryout2;
opt_normals = opt_strip = false;
}
void
World::render_scene()
{
pFrame_Buffer& frame_buffer = gc.frame_buffer;
switch ( frame_buffer.keyboard_key ) {
case FB_KEY_LEFT: adj_location->x -= 0.1; break;
case FB_KEY_RIGHT: adj_location->x += 0.1; break;
case FB_KEY_PAGE_UP: adj_location->y += 0.1; break;
case FB_KEY_PAGE_DOWN: adj_location->y -= 0.1; break;
case FB_KEY_UP: adj_location->z -= 0.1; break;
case FB_KEY_DOWN: adj_location->z += 0.1; break;
case 'e': case 'E': adj_location = &eye_location; break;
case 'l': case 'L': adj_location = &light_location; break;
case 'y': gc.opt_tryout1 = opt_tryout1 = !opt_tryout1; break;
case 'Y': gc.opt_tryout2 = opt_tryout2 = !opt_tryout2; break;
case 'n': case 'N': opt_normals = !opt_normals; break;
case 's': case 'S': opt_strip = !opt_strip; break;
}
gc.frame_buffer.fbprintf
("Strip %s ('s') Normals %s ('n') Tryout1 %s ('y') Tryout2 %s ('Y') \n",
opt_strip ? "ON " : "OFF", opt_normals ? "ON " : "OFF",
opt_tryout1 ? "ON " : "OFF", opt_tryout2 ? "ON " : "OFF");
gc.light_location_set( light_location ).light_color_set( color_white * 100 );
const uint win_width = frame_buffer.width_get();
const uint win_height = frame_buffer.height_get();
const float aspect = 1.0 * win_width / win_height;
const float width_m = 0.8; const float height_m = width_m / aspect;
pMatrix_Translate center_eye(-eye_location);
pMatrix_Rotation rotate_eye(eye_direction,pVect(0,0,-1));
pMatrix eye_from_object = rotate_eye * center_eye;
gc.transform_eye_from_object_set(eye_from_object);
pMatrix_Frustum clip_from_eye
( -width_m/2, width_m/2, -height_m/2, height_m/2, 1, 5000 );
gc.transform_clip_from_eye_set(clip_from_eye);
vector<pCoor> coors_os;
vector<pColor> colors;
coors_os << pCoor( 0, 0, 0 ) << pCoor( 9, 6, -5 ) << pCoor( 0, 7, -3 );
colors << color_white << color_white << color_white;
coors_os << pCoor(7,2,1) << pCoor(-3,3,-3.5) << pCoor(9,0,0);
colors << color_lsu_spirit_purple << color_lsu_spirit_purple
<< color_lsu_spirit_purple;
coors_os << pCoor(-4,0,-3) << pCoor(-4,2,-3) << pCoor(-2,0,-3);
colors << color_lsu_spirit_gold << color_lsu_spirit_gold
<< color_lsu_spirit_gold;
coors_os << pCoor(-4,2,-3) << pCoor(-2,2,-3) << pCoor(-2,0,-3);
colors << color_blue << color_green << color_red;
int n_segs = 20;
pCoor center(1,-1,-3);
pVect sz( 0, 0.75, 0.05 );
pNorm ax( 0, -sz.z, sz.y ), ay = cross(sz,ax);
vector<pCoor> strip_coor(n_segs+1);
float r = 4, d_th = 2 * M_PI / n_segs;
coors_os << pCoor(-2,2,-3) << pCoor(-2,0,-3) << center + sz;
colors << color_orange_red << color_orange_red << color_orange_red;
gc.topology_strip_set(false);
gc.vtx_normals_set();
gc.vtx_coors_set(coors_os).vtx_colors_set(colors);
gc.draw_rasterization();
coors_os.clear(); colors.clear();
vector<pVect4> strip_norms(n_segs+1);
for ( int i=0; i<=n_segs; i++ )
{
strip_norms[i] = ax * cosf(i*d_th) + ay * sinf(i*d_th);
strip_coor[i] = center + r*strip_norms[i];
}
vector<pVect4> norms_os;
if ( opt_strip )
{
for ( int i=0; i<=n_segs; i++ )
{
coors_os << strip_coor[i] + sz << strip_coor[i];
colors << color_cyan << color_cyan;
norms_os << strip_norms[i] << strip_norms[i];
}
}
else
{
for ( int i=0; i<n_segs; i++ )
{
coors_os << strip_coor[i] << strip_coor[i+1] << strip_coor[i] + sz;
coors_os << strip_coor[i]+sz << strip_coor[i+1]+sz << strip_coor[i+1];
for ( int i=0; i<6; i++ ) colors << color_cyan;
norms_os << strip_norms[i] << strip_norms[i+1] << strip_norms[i];
norms_os << strip_norms[i] << strip_norms[i+1] << strip_norms[i+1];
}
}
if ( opt_normals ) gc.vtx_normals_set(norms_os); else gc.vtx_normals_set();
gc.topology_strip_set(opt_strip);
gc.vtx_coors_set(coors_os).vtx_colors_set(colors);
gc.draw_rasterization();
}
Our_3D&
Our_3D::draw_rasterization()
{
const uint win_width = frame_buffer.width_get();
const uint win_height = frame_buffer.height_get();
pMatrix_Translate recenter(pVect(1,1,0));
pMatrix_Scale scale( win_width/2, win_height/2, 1 );
pMatrix window_from_clip = scale * recenter;
pMatrix ws_from_os = window_from_clip * clip_from_eye * eye_from_object;
frame_buffer.n_vtx_frame += vtx_coors->size();
float* const zbuffer = frame_buffer.buffer_depth_get();
auto& coors_os = *vtx_coors;
auto& colors = *vtx_colors;
const size_t inc = topology_strip ? 1 : 3;
for ( size_t i=0; i+2<coors_os.size(); i += inc )
{
frame_buffer.n_tri_frame++;
pCoor o0 = coors_os[i+0], o1 = coors_os[i+1], o2 = coors_os[i+2];
pCoor_Homogenized
w0( ws_from_os * o0 ), w1( ws_from_os * o1 ), w2( ws_from_os * o2 );
pColor c0 = colors[i+0], c1 = colors[i+1], c2 = colors[i+2];
pNorm tn = cross(o0,o1,o2);
pVect4 n0, n1, n2;
if ( vtx_normals )
{
n0 = vtx_normals[i+0];
n1 = vtx_normals[i+1];
n2 = vtx_normals[i+2];
}
pVect v20(w2,w0), v21(w2,w1);
const float db0 = 1/max(fabs(v20.x),fabs(v20.y));
const float db1 = 1/max(fabs(v21.x),fabs(v21.y));
const float w0ow2z = w0.z / w2.z, w1ow2z = w1.z / w2.z;
for ( float b0=0; b0<=1; b0 += db0 )
for ( float b1=0; b1<=1-b0; b1 += db1 )
{
frame_buffer.n_frag_frame++; const float b2 = 1 - b0 - b1;
pCoor wf = b0*w0 + b1*w1 + b2*w2;
if ( uint(wf.x) >= win_width || uint(wf.y) >= win_height ) continue;
const size_t idx = wf.x + int(wf.y) * win_width;
float zinv = wf.z;
if ( zinv < 0 || zinv > 1 ) continue;
if ( zbuffer[ idx ] < zinv ) continue;
zbuffer[ idx ] = zinv;
float bc0 = b0 ? 1/( w0ow2z * (1-b0)/b0 + 1 ) : 0;
float bc1 = b1 ? 1/( w1ow2z * (1-b1)/b1 + 1 ) : 0;
float bc2 = 1 - bc0 - bc1;
pVect4 n = vtx_normals ? bc0*n0 + bc1*n1 + bc2*n2 : tn;
pColor color = bc0*c0 + bc1*c1 + bc2*c2;
pCoor of = bc0*o0 + bc1*o1 + bc2*o2;
pNorm f_to_l(of,light_location);
float phase = fabs(dot(n,f_to_l));
pColor lighted_color = phase / f_to_l.mag_sq * light_color * color;
frame_buffer[ idx ] = lighted_color.int_rgb();
frame_buffer.n_px_frame++; }
}
return *this;
}
int
main(int argc, char **argv)
{
pFrame_Buffer demo_frame_buffer(argc,argv);
WRender render( demo_frame_buffer );
World our_world( demo_frame_buffer );
WRENDER_INSERT(render, our_world);
render.run();
return 0;
}