Rasterization 学习笔记

2022-01-29 04:36:38

======================Barycentric interpolation======================================

<1>2d/3d Check point in triangle test

float areas(vector p1;vector p2;vector p3)

{

    return length(cross(p1-p2,p3-p2)) * 0.5f;

}

int ptInTri(vector inpt;vector p1;vector p2; vector p3)

{

    float s = areas(p1,p2,p3);

    float s1 = areas(inpt,p2,p3) / s;

    float s2 = areas(inpt,p3,p1) / s;

    float s3 = areas(inpt,p1,p2) / s;

    if(s1<0.0f || s1>1.0f)

    {

        return false;

    }

    if(s2 < 0.0f || s2 >)

    {

        return false;

    }

    if(s3 < 0.0f || s3 >)

    {

        return false;

    }

    float all = s1 + s2 + s3;

    if (all-1.0f<0.000001f)

        return true;

    else

        return false;

}

<2>2d check can use :

int ptInTri2(vector P;vector A;vector B; vector C)

{

    vector u = B - A;

    vector v = C - A;

    vector w = P - A;

    vector vCrossW = cross(v, w);

    vector vCrossU = cross(v, u);

    if (dot(vCrossW, vCrossU) < )

        return false;

    vector uCrossW = cross(u, w);

    vector uCrossV = cross(u, v);

    // Test sign of t

    if (dot(uCrossW, uCrossV) < )

        return false;

    float denom = length(uCrossV);

    float r = length(vCrossW) / denom;

    float t = length(uCrossW) / denom;

    return (r + t <= );

}

<3> Color Interpolation:

float areas(vector p1;vector p2;vector p3)

{

    return length(cross(p1-p2,p3-p2)) * 0.5f;

}

vector P = getInputP();

float s  = areas(p1,p2,p3);

float s1 = areas(P,p2,p3) / s;

float s2 = areas(P,p3,p1) / s;

float s3 = areas(P,p1,p2) / s;

vector PColor = p1.color * s1 + p2.color*s2 + p3.color*s3;

<4>we can use this method to getPointAt uv like maya function or houdini primuv();

float areas(vector p1;vector p2;vector p3)

{

    return length(cross(p1-p2,p3-p2)) * 0.5f;

}

vector getPointAtUV(float u;float v)

{

    clamp(u,,);

    clamp(v,,);

    // get current gdp's points

    vector gdpPtsPos[];

    for(int i=;i<;i++)

    {

        vector curl = point(,"P",i);

        //printf("%f ,%f , %f \n",curl[0],curl[1],curl[2]);

        append(gdpPtsPos,curl);

    }

    vector p1 = gdpPtsPos[];

    vector p2 = gdpPtsPos[];

    vector p3 = gdpPtsPos[];

    // tri area

    float s = areas(p1,p2,p3);

    // reverse to get base on  u value

    float uArea = u * 0.5 / s;

    // reverse to get base on  v value

    float vArea = v * 0.5 / s ;

    // the w value

    float wArea =;

    if( - uArea - vArea < )

    {

        wArea = ;

    }

    else

    {

        wArea =(  - u - v )*0.5 / s;

    }

    //https://www.scratchapixel.com/lessons/3d-basic-rendering/ray-tracing-rendering-a-triangle/barycentric-coordinates

    //P=uA+vB+wC.

    vector retP = p1 * uArea + p2*vArea + p3*wArea;

    return retP;

}

#define maxscatter 100000

for(int i=;i<maxscatter;i++)

{

    float u = rand(i);

    float v = rand(i*);

    vector retPos = getPointAtUV(u,v);

    addpoint(geoself(),retPos);

}

<4>Color Define:

(1)ARGB:uint32_t，也就是单位为uint8_t ,共4个,a ,r ,g ,b 0xFF FF FF FF (255,255,255,255)

//  uint32_t c;

A:(uint8_t)   ( (c & 0xFF   ) >>)

R:(uint8_t)   ( (c & 0x00 FF  ) >>)

G:(uint8_t)   ( (c & 0x00 FF  ) >>)

B:(uint8_t)   ( (c & 0x00   FF) >>)

(2)从uint8_t r,g,b,a转换到uint32_t,用位和求回去

((uint32_t)a<<) | ((uint32_t)r<<) | ((uint32_t)g<<) | ((uint32_t)b<<)

(2)float color:sixteen bytes:

struct color{float a, float r,float g,float b}

转换成ARGB(uint32_t)颜色也简单.

color fc = {1.0f,0.5f,0.0f,1.0f};
uint8_t r = (uint8_t) (floorf(fc.r*255.0f))

uint8_t g = (uint8_t) (floorf(fc.g*255.0f))

uint8_t b = (uint8_t) (floorf(fc.b*255.0f))

uint8_t a = (uint8_t) (floorf(fc.a*255.0f))

=========================Rasterization==================================================

<1>Line:

画斜线没用到斜率方程，直接用的线性差值。

DrawApi.h

#ifndef DRAWAPI_H

#define DRAWAPI_H

#include <QImage>

#include "LineSegment.h"

#include <glm/glm.hpp>

#include <iostream>

#include "MathUtility.h"

using namespace TopVertex;

class DrawApi

{

public:

    template <typename T = glm::vec3>

    static void drawLine(QImage &image ,LineSegment<T> &line,const glm::vec3 &color)

    {

        auto &sp = line.startPoint();

        auto &ep = line.endPoint();

        float m  = line.getSlope();

        if(line.getType() == LineSegment<T>::HORIZON)

        {

            std::cout << "write horizon line\n";

            auto y = sp[];

            for(int x=sp[] ; x <= ep[]; x++)

            {

                image.setPixel(x,y,qRgb(color[],color[],color[]));

            }

            return;

        }

        if(line.getType() == LineSegment<T>::VERTICAL)

        {

            std::cout << "write verticle line\n";

            auto x = sp[];

            auto y0 = sp[];

            auto y1 = ep[];

            if(y0 < y1)

            {

                for(int y=y0;y<=y1;y++)

                {

                    image.setPixel(x,y,qRgb(color[],color[],color[]));

                }

            }

            else

            {

                for(int y=y1;y<=y0;y++)

                {

                    image.setPixel(x,y,qRgb(color[],color[],color[]));

                }

            }

            return;

        }

        if(line.getType() == LineSegment<T>::NORMAL)

        {

            std::cout << "write normal line\n";

            int startRow = ;

            int endRow   = ;

            if(sp[] < ep[])

            {

                startRow = sp[];

                endRow   = ep[];

            }

            else

            {

                startRow = ep[];

                endRow   = sp[];

            }

            for(int r = startRow;r<=endRow;r++)

            {

                auto bias = GLY_MATH::fit<float>(r,startRow,endRow,0.1f,1.0f);

                auto pos  = GLY_MATH::linearInterpolation(sp,ep,bias);

                image.setPixel(pos[],pos[],qRgb(color[],color[],color[]));

            }

            return;

        }

    }

};

#endif // DRAWAPI_H

LineSegment.h

#ifndef LINESEGMENT_H

#define LINESEGMENT_H

#include <algorithm>

#include <cmath>

#include <string>

#include <iostream>

#include <glm/glm.hpp>

template <typename T>

class LineSegment

{

public:

    typedef T value_type;

    enum TYPE{VERTICAL,HORIZON,NORMAL};

    LineSegment(T startPoint,T endPoint):

        mStartPoint(startPoint),mEndPoint(endPoint)

    {

        // LINE PROPERTY

        evalLineProperty();

        // LINE PROPERTY

    }

    LineSegment()=default;

    void setPoints(const T &startPoint , const T &endPoint)

    {

        mStartPoint = startPoint;

        mEndPoint = endPoint;

        evalLineProperty();

    }

    inline T & operator[](int i)

    {

        if(i == )

        {

            return mStartPoint;

        }

        else if(i == )

        {

            return mEndPoint;

        }

        else

        {

            throw std::string("Can't get point over 2\n").c_str();

        }

    }

    TYPE getType();

    T &startPoint();

    T &endPoint();

    T startPoint()const;

    T endPoint()const;

    float getSlope()const;

    template <typename T2,typename T3>

    inline T2 intersect(const LineSegment<T3> &Line)

    {

        auto st_y = Line.startPoint()[];  // get line y value

        auto it_x = (st_y - startPoint()[] + startPoint()[]*getSlope())/getSlope(); // y slope function get x pos

        return T2(it_x,st_y);

    }

private:

    void evalLineProperty()

    {

        auto x0 = mStartPoint[];

        auto x1 = mEndPoint[];

        if(x0 > x1)

        {

            swap(mStartPoint,mEndPoint);

        }

        x0 = mStartPoint[];

        x1 = mEndPoint[];

        auto y0 = mStartPoint[];

        auto y1 = mEndPoint[];

        if(fabs(y1-y0) <= 0.0000001f)    // horizon line slope = 0

        {

            mSlope = 0.0f;

            mLineType = HORIZON;

        }

        else if(fabs(x1-x0) <= 0.000001f) // verticle line slope = 0

        {

            mSlope = 0.0f;

            mLineType = VERTICAL;

        }

        else                              // slope !=0

        {

            mSlope = (y1 - y0) / (x1-x0);

            mLineType = NORMAL;

        }

    }

    T mStartPoint;

    T mEndPoint;

    TYPE mLineType;

    float mSlope;

};

template<typename T>

typename LineSegment<T>::TYPE LineSegment<T>::getType()

{

    return mLineType;

}

template<typename T>

float LineSegment<T>::getSlope() const

{

    return mSlope;

}

template<typename T>

T &LineSegment<T>::startPoint()

{

    return mStartPoint;

}

template<typename T>

T &LineSegment<T>::endPoint()

{

    return mEndPoint;

}

template<typename T>

T LineSegment<T>::startPoint()const

{

    return mStartPoint;

}

template<typename T>

T LineSegment<T>::endPoint()const

{

    return mEndPoint;

}

// ostream

inline std::ostream& operator<<(std::ostream &os,LineSegment<glm::vec3> line)

{

    os << "Line start points:" << line.startPoint()[] << " " <<line.startPoint()[] << " "<<line.startPoint()[]

       << " | "

       << "end:" << line.endPoint()[]<< " "<< line.endPoint()[] << " "<< line.endPoint()[] ;

    return os;

}

inline std::ostream& operator<<(std::ostream &os,LineSegment<glm::vec2> line)

{

    os << "Line start points:" << line.startPoint()[] << " " <<line.startPoint()[] << "|"

              << "end:" << line.endPoint()[]<< " "<< line.endPoint()[] ;

    return os;

}

#endif // LINESEGMENT_H

MathUtility.h

#ifndef MATHUTILITY_H

#define MATHUTILITY_H

#include <string>

#include <vector>

#include <iostream>

#include <sstream>

using namespace std;

namespace TopVertex

{

    class GLY_MATH

    {

    public:

        template<typename T>

        static T linearInterpolation(T val1 , T val2,float bias)

        {

            return val1*(-bias) + val2*bias;

        }

        template<typename T>

        static T min(T a, T b) {

            if (a > b) {

                return b;

            } else {

                return a;

            }

        }

        template<typename T>

        static T max(T a, T b) {

            if (a > b) {

                return a;

            } else {

                return b;

            }

        }

        template<typename T>

        static bool zero_compare(T a, double tol = 0.00001) {

            return a >= -tol && a <= tol;

        }

        // DO NOT USE THIS FIT TO FIT VECTOR VALUE

        template<typename T>

        static T fit(T var, T omin, T omax, T nmin, T nmax) {

            T d = omax - omin;

            if (zero_compare(d)) {

                return (nmin + nmax) * 0.5;

            }

            if (omin < omax) {

                if (var < omin) return nmin;

                if (var > omax) return nmax;

            } else {

                if (var < omax) return nmax;

                if (var > omin) return nmin;

            }

            return nmin + (nmax - nmin) * (var - omin) / d;

        }

        //return -1 to 1

        template<typename T>

        static T fit_negate(T var, T omin, T omax) {

            return fit(var, omin, omax, -1.0, 1.0);

        }

        //string split

        static std::vector<std::string> split_string(std::string &inputString, char &split_char) {

            std::stringstream ss(inputString);

            std::string sub_str;

            std::vector<std::string> sp_strPath;

            sp_strPath.clear();

            while (getline(ss, sub_str, split_char)) {

                sp_strPath.push_back(sub_str);

            }

            return sp_strPath;

        }

        //value to string

        template<typename T>

        // T must be a value int/float/double

        static std::string value_to_str(T &value) {

            std::ostringstream os;

            os << value;

            return os.str();

        }

        static int wang_inthash(int key) {

            // From http://www.concentric.net/~Ttwang/tech/inthash.htm

            key += ~(key << );

            key ^= (key >> );

            key += (key << );

            key ^= (key >> );

            key += ~(key << );

            key ^= (key >> );

            return key;

        }

        static int fastRandomInt(int seed) {

            int nseed = seed * +0XFFFFFFF;

            return wang_inthash(nseed);

        }

        static float fastRandom01(int seed)

        {

            return float(fastRandomInt(seed) % ) / 1000000.0f;

        }

    };

}

#endif // MATHUTILITY_H

Renderer.h

#ifndef RENDERER_H

#define RENDERER_H

#include <QImage>

#include <iostream>

#include <glm/glm.hpp>

using namespace std;

class Renderer

{

public:

    Renderer();

    void render();

};

#endif // RENDERER_H

Renderer.cpp

#include "Renderer.h"

#include "DrawApi.h"

Renderer::Renderer()

{

}

void Renderer::render()

{

    QImage image(,,QImage::Format_RGB32);

    image.fill(Qt::gray);

    glm::vec3 p0(,,);

    glm::vec3 p1(,,);

    glm::vec3 p2(,,);

    //  write horizon line

    glm::vec3 p3(,,);

    glm::vec3 p4(,,);

    auto hline1 = LineSegment<glm::vec3>(p3,p4);

    DrawApi::drawLine(image,hline1,glm::vec3(,,));

    // write verticle line

    glm::vec3 p5(,,);

    glm::vec3 p6(,,);

    auto hline2 = LineSegment<glm::vec3>(p5,p6);

    DrawApi::drawLine(image,hline2,glm::vec3(,,));

    // write normal line

    glm::vec3 p7(,,);

    glm::vec3 p8(,,);

    auto hline3 = LineSegment<glm::vec3>(p8,p7);

    DrawApi::drawLine(image,hline3,glm::vec3(,,));

    image.save("c:/Raster.jpg",,);

    return ;

}

main.cpp

auto render =  Renderer();

render.render();

以上的方法不过还是垃圾，因为还是循环像素row。对于以上的方法如果不考虑计算成本，直接暴力法循环row,

然后判断pixelPos是不是在triangle里面。是就给他画出来。

最好的方法:

线求交:

2，矩阵大法：

计算：

rotate:

Scale:

translate:

得到的XF = 1*x + 0*y + 1*tx = x + tx;

得到的YF = 0*x + 1*y + 1*ty = y + ty;

总体带x,y,w

3d:

Orthographic Matrix:

Perspective Matrix

Viewport Transform:

Raster Pipeline:

码农公寓

相关文章