示例#1
0
void
ClCmdQueue::enqueueMapImage(cl::Image2D& img, cl_mem_flags flags,
                            bool blocking) {
    // Set origin to 0,0,0 offset within the image to copy from
    cl::size_t<3> origin = makeCoords(0, 0, 0);
    // Set the region to be copied based on the width and height of image
    size_t width = 0, height = 0;
    img.getImageInfo<size_t>(CL_IMAGE_WIDTH, &width);
    img.getImageInfo<size_t>(CL_IMAGE_HEIGHT, &height);
    cl::size_t<3> region = makeCoords(width, height, 1);
    // The following two variables are not really used by are needed for the
    // API call.
    size_t rowPitch  = 0, slicePitch = 0;
    queue.enqueueMapImage(img, blocking, flags, origin,  region,
                          &rowPitch, &slicePitch);
}
示例#2
0
int renCalcVisibility(S_Renderer *pRenderer, const S_Coords *point, const S_Coords *normal)
{
    S_Coords cvec;

    IZG_ASSERT(pRenderer && point && normal);

    /* vektor od kamery k plosce, pozice kamery je (0, 0, -camera_dist) */
    cvec = makeCoords(point->x, point->y, point->z + pRenderer->camera_dist);
    coordsNormalize(&cvec);

    /* test zda je normala privracena
     * skalarni soucin vektoru od kamery a normaly */
    return (normal->x * cvec.x + normal->y * cvec.y + normal->z * cvec.z > 0) ? 0 : 1;
}
示例#3
0
void renInit(S_Renderer *pRenderer)
{
    IZG_ASSERT(pRenderer);

    /* frame buffer prozatim neni */
    pRenderer->frame_buffer = NULL;
    pRenderer->frame_w = 0;
    pRenderer->frame_h = 0;

    /* podobne take depth buffer */
    pRenderer->depth_buffer = NULL;
    pRenderer->max_depth = 1000.0;

    /* nastaveni pozice kamery */
    pRenderer->camera_dist = 1000;

    /* pocatecni nastaveni trackballu (natoceni a zoom sceny) */
    pRenderer->scene_rot_x = 0;
    pRenderer->scene_rot_y = 0;
    pRenderer->scene_move_z = -980;
    pRenderer->scene_move_x = 0;
    pRenderer->scene_move_y = 0;

    /* default material */
    pRenderer->mat_ambient = makeMaterial(0.8, 0.8, 0.8);
    pRenderer->mat_diffuse = makeMaterial(0.8, 0.8, 0.8);
    pRenderer->mat_specular = makeMaterial(0.8, 0.8, 0.8);

    /* default zdroj svetla */
    pRenderer->light_position  = makeCoords(3.0, -3.0, -pRenderer->camera_dist);
    pRenderer->light_ambient   = makeLight(0.2, 0.2, 0.2);
    pRenderer->light_diffuse   = makeLight(0.7, 0.7, 0.7);
    pRenderer->light_specular  = makeLight(0.7, 0.7, 0.7);

    /* nastaveni ukazatelu na fce */
    pRenderer->releaseFunc         = renRelease;
    pRenderer->createBuffersFunc   = renCreateBuffers;
    pRenderer->clearBuffersFunc    = renClearBuffers;
    pRenderer->projectTriangleFunc = renProjectTriangle;
    pRenderer->calcReflectanceFunc = renLambertianReflectance;
}
示例#4
0
S_RGBA renLambertianReflectance(S_Renderer *pRenderer, const S_Coords *point, const S_Coords *normal)
{
    S_Coords    lvec;
    double      diffuse, r, g, b;
    S_RGBA      color;

    IZG_ASSERT(pRenderer && point && normal);

    /* vektor ke zdroji svetla */
    lvec = makeCoords(pRenderer->light_position.x - point->x,
                      pRenderer->light_position.y - point->y,
                      pRenderer->light_position.z - point->z);
    coordsNormalize(&lvec);

    /* ambientni cast */
    r = pRenderer->light_ambient.red * pRenderer->mat_ambient.red;
    g = pRenderer->light_ambient.green * pRenderer->mat_ambient.green;
    b = pRenderer->light_ambient.blue * pRenderer->mat_ambient.blue;

    /* difuzni cast */
    diffuse = lvec.x * normal->x + lvec.y * normal->y + lvec.z * normal->z;
    if( diffuse > 0 )
    {
        r += diffuse * pRenderer->light_diffuse.red * pRenderer->mat_diffuse.red;
        g += diffuse * pRenderer->light_diffuse.green * pRenderer->mat_diffuse.green;
        b += diffuse * pRenderer->light_diffuse.blue * pRenderer->mat_diffuse.blue;
    }
    
    /* saturace osvetleni*/
    r = MIN(1, r);
    g = MIN(1, g);
    b = MIN(1, b);

    /* kreslici barva */
    color.red = ROUND2BYTE(255 * r);
    color.green = ROUND2BYTE(255 * g);
    color.blue = ROUND2BYTE(255 * b);
    return color;
}
示例#5
0
S_Coords curvePoint(S_Curve *pCurve, double t)
{
    S_Coords    point = makeCoords(0.0, 0.0, 0.0);
    double      A, denom = 0.0;
    int         i, size;

    IZG_ASSERT(pCurve);

    /* velikost krivky */
    size = curveSize(pCurve);

    /* kontrola hodnoty parametru t <0, 1> */
    if( t < 0.0 ) t = 0.0;
    else if( t >= 1.0 ) t = 1.0;

    /* vypocet bodu krivky pomoci Bernsteinovych polynomu */
    for( i = 0; i < size; ++i )
    {
        A = dvecGet(pCurve->weights, i) * splineFunc(i, pCurve->degree, pCurve->knots, t);
        point.x += cvecGet(pCurve->points, i).x * A;
        point.y += cvecGet(pCurve->points, i).y * A;
        point.z += cvecGet(pCurve->points, i).z * A;
        denom += A;
    }     

    /* podeleni jmenovatelem */
    if( !IS_ZERO(denom) )
    {
        denom = 1.0 / denom;
    }
    point.x *= denom;
    point.y *= denom;
    point.z *= denom;

    return point;
}
示例#6
0
void curveResize(S_Curve *pCurve, int size, int k)
{
    int     i, n;

    IZG_ASSERT(pCurve && size >= 0 && k >= 2);

    /* stupen krivky */
    pCurve->degree = k;

    /* zmena velikosti vektoru */
    n = cvecSize(pCurve->points);
    cvecResize(pCurve->points, size);
    dvecResize(pCurve->weights, size);

    /* inicializace novych dat */
    for( i = n; i < size; ++i )
    {
        cvecGet(pCurve->points, i) = makeCoords(0.0, 0.0, 0.0);
        dvecGet(pCurve->weights, i) = 1.0;
    }

    /* inicializace uzloveho vektoru */
    curveInitKnotVector(pCurve);
}
示例#7
0
//===========================================================================
void CellDivision::constructCells()
//===========================================================================
{
    // @@@ NOTE
    //
    // This implementation depends upon using bounding boxes that are
    // aligned with the principal axis and box-shaped.

    // First we check if big_box_ is valid. @jbt
    if (!big_box_.valid()) {
        MESSAGE("Big box is invalid - returning empty cell vector.");
        cells_.clear();
        return;
    }

    if (dim_ < 1) {
        MESSAGE("Incorrect number of space dimensions.");
        cells_.clear();
        return;
    }

    // We partition space into cells.
    
    makeCoords();

    double tol = 1.0e-9;  // VSK, 082017. To avoid loosing surfaces in
    // planar cases
    int ncells = ncells_[0];
    for (int i = 1; i < dim_; ++i)
        ncells *= ncells_[i];
    cells_.resize(ncells);
    Point low = big_box_.low();
    Point len = big_box_.high() - low;
    cell_delta_.resize(dim_);
    for (int i = 0; i < dim_; ++i)
        cell_delta_[i] = len[i] / ncells_[i];

    Point corner;
    corner.resize(dim_);
    for (int i = 0; i < ncells; ++i) {
        for (int dd = 0; dd < dim_; ++dd) {
            corner[dd] = low[dd] + coords_[i][dd] * cell_delta_[dd];
        }
        cells_[i].setBox(BoundingBox(corner, corner + cell_delta_));
    }

    // Now that we have the cells, we check every face, and add its pointer
    // to every cell overlapping its bounding box.
    for (size_t f=0; f<faces_.size(); ++f) {
        BoundingBox b = faces_[f]->boundingBox();
        for (int i = 0; i < ncells; ++i) {
	  if (b.overlaps(cells_[i].box(), tol)) {
                cells_[i].addFace(faces_[f]);
                cells_[i].addFaceBox(b);
            }
        }
    }


//    // The following code depends on dimensionality 3 - commenting out. @jbt
//    int i, j, k;
//
//    // We partition space into cells.
//    cells_.resize(ncellsx_*ncellsy_*ncellsz_);
//    Point low = big_box_.low();
//    Point len = big_box_.high() - low;
//    cell_delta_ = Point(len[0]/ncellsx_, len[1]/ncellsy_, len[2]/ncellsz_);
//    const Point& delta = cell_delta_;
//
//    double x = low[0];
//    double y = low[1];
//    double z = low[2];
//    Point corner;
//
//    for (i=0; i<ncellsx_; ++i) {
//        y = low[1];
//        for (j=0; j<ncellsy_; ++j) {
//            z = low[2];
//            for (k=0; k<ncellsz_; ++k) {
//                corner.setValue(x, y, z);
//                cells_[i + j*ncellsx_ + k*ncellsx_*ncellsy_]
//                    .setBox(BoundingBox(corner, corner + delta));
//                z += delta[2];
//            }
//            y += delta[1];
//        }
//        x += delta[0];
//    }
//
//    int x1, x2, y1, y2, z1, z2;
//    Point lo, hi;
//    // Now that we have the cells, we check every face, and add its pointer
//    // to every cell overlapping its bounding box.
//    for (size_t f=0; f<faces_.size(); ++f) {
//        BoundingBox b = faces_[f]->boundingBox();
//        lo = b.low();
//        hi = b.high();
//        cellContaining(lo, x1, y1, z1);
//        cellContaining(hi, x2, y2, z2);
//        for (i=x1; i<=x2; ++i)
//            for (j=y1; j<=y2; ++j)
//                for (k=z1; k<=z2; ++k)
//                {
//                    cells_[i + j*ncellsx_ + k*ncellsx_*ncellsy_].addFace(faces_[f]);
//                    cells_[i + j*ncellsx_ + k*ncellsx_*ncellsy_].addFaceBox(b);
//                }
//    }
//
//#ifdef DEBUG_CELLS
//    for (i=0; i<ncellsx_*ncellsy_*ncellsz_; ++i) {
//        cout << "Cell " << i << " has "
//             << cells_[i].num_faces() << " faces ";
//        for (j=0; j<cells_[i].num_faces(); ++j)
//            cout << cells_[i].face(j)->GetId() << " ";
//        cout << endl;
//    }
//#endif

}
示例#8
0
文件: student.c 项目: zcsevcik/edu
S_RGBA studrenPhongReflectance(S_Renderer *pRenderer, const S_Coords *point, const S_Coords *normal)
{
    S_Coords    lvec, eyevec, reflect;
    double      diffuse, specular, reflect_scalar;
    double      r, g, b;

    /* If = Ia + Id + Is */
    S_RGBA      color;

    IZG_ASSERT(pRenderer && point && normal);

    /* vektor ke zdroji svetla */
    lvec = makeCoords(pRenderer->light_position.x - point->x,
                      pRenderer->light_position.y - point->y,
                      pRenderer->light_position.z - point->z);
    coordsNormalize(&lvec);

    /* vektor ke kamere */
    eyevec = makeCoords(-point->x,
                        -point->y,
                        -pRenderer->camera_dist - point->z);
    coordsNormalize(&eyevec);

    /* ambientni cast -- Ia = (Al * Am) + (As * Am) */
    /* As je barva sceny, muzeme zanedbat */
    r = pRenderer->light_ambient.red * pRenderer->mat_ambient.red;
    g = pRenderer->light_ambient.green * pRenderer->mat_ambient.green;
    b = pRenderer->light_ambient.blue * pRenderer->mat_ambient.blue;

    /* difuzni cast -- Id = Dl * Dm * LambertTerm */
    /* LambertTerm = dot(N, L) */
    diffuse = lvec.x * normal->x + lvec.y * normal->y + lvec.z * normal->z;
    if( diffuse > 0 )
    {
        r += diffuse * pRenderer->light_diffuse.red * pRenderer->mat_diffuse.red;
        g += diffuse * pRenderer->light_diffuse.green * pRenderer->mat_diffuse.green;
        b += diffuse * pRenderer->light_diffuse.blue * pRenderer->mat_diffuse.blue;
    }

    /* odraziva cast -- Is = Sm * Sl * pow( max( dot(R, E), 0.0), f ) */
    /* R = reflect(-L, N) = 2 * dot(N, L) * N - L */
    reflect_scalar = 2 * (normal->x * lvec.x + normal->y * lvec.y + normal->z * lvec.z);
    reflect.x = reflect_scalar * normal->x - lvec.x;
    reflect.y = reflect_scalar * normal->y - lvec.y;
    reflect.z = reflect_scalar * normal->z - lvec.z;

    specular = pow(
        MAX(reflect.x * eyevec.x + reflect.y * eyevec.y + reflect.z * eyevec.z, 0.0f),
        ((S_StudentRenderer*)pRenderer)->mat_shininess);

    r += specular * pRenderer->light_specular.red * pRenderer->mat_specular.red;
    g += specular * pRenderer->light_specular.green * pRenderer->mat_specular.green;
    b += specular * pRenderer->light_specular.blue * pRenderer->mat_specular.blue;

    /* saturace osvetleni*/
    r = MIN(1, r);
    g = MIN(1, g);
    b = MIN(1, b);

    /* kreslici barva */
    color.red = ROUND2BYTE(255 * r);
    color.green = ROUND2BYTE(255 * g);
    color.blue = ROUND2BYTE(255 * b);
    return color;
}
示例#9
0
文件: student.c 项目: zcsevcik/edu
void studrenDrawTriangle(S_Renderer *pRenderer,
                         S_Coords *v1, S_Coords *v2, S_Coords *v3,
                         S_Coords *n1, S_Coords *n2, S_Coords *n3,
                         int x1, int y1,
                         int x2, int y2,
                         int x3, int y3
                         )
{
    // oblast trojuhelniku
    int min[2] = {
        MIN(x1, MIN(x2, x3)),
        MIN(y1, MIN(y2, y3))
    };
    int max[2] = {
        MAX(x1, MAX(x2, x3)),
        MAX(y1, MAX(y2, y3))
    };

    // oriznuti rozmerem okna
    min[0] = MAX(min[0], 0);
    min[1] = MAX(min[1], 0);
    max[0] = MIN(max[0], pRenderer->frame_w - 1);
    max[1] = MIN(max[1], pRenderer->frame_h - 1);

    // pro urceni hranic trojuhelnika pouzijeme pineduv algoritmus
    // hranova funkce je rovnice Ax + By + C = 0
    // A,B je normalovy vektor primky, tzn. (-dy, dx)
    // C vyjadrime jako x1y2 - x2y1
    int A[3] = {
        { y1 - y2 },
        { y2 - y3 },
        { y3 - y1 }
    };
    int B[3] = {
        { x2 - x1 },
        { x3 - x2 },
        { x1 - x3 }
    };
    int C[3] = {
        { x1 * y2 - x2 * y1 },
        { x2 * y3 - x3 * y2 },
        { x3 * y1 - x1 * y3 }
    };

    // do hranove funkce dosadime protejsi vrcholy
    // provedeme normalizaci, aby kladna strana byla uvnitr oblasti
    int s0 = A[0] * x3 + B[0] * y3 + C[0];
    int s1 = A[1] * x1 + B[1] * y1 + C[1];
    int s2 = A[2] * x2 + B[2] * y2 + C[2];

    if (s0 < 0) {
        A[0] *= -1; B[0] *= -1; C[0] *= -1;
        s0 *= -1;
    }
    if (s1 < 0) {
        A[1] *= -1; B[1] *= -1; C[1] *= -1;
        s1 *= -1;
    }
    if (s2 < 0) {
        A[2] *= -1; B[2] *= -1; C[2] *= -1;
        s2 *= -1;
    }

    double _s0 = 1.0f / (double)s0;
    double _s1 = 1.0f / (double)s1;
    double _s2 = 1.0f / (double)s2;

    /* gourandovo stinovani */
    //S_RGBA color, b1, b2, b3;
    //b1 = pRenderer->calcReflectanceFunc(pRenderer, v1, n1);
    //b2 = pRenderer->calcReflectanceFunc(pRenderer, v2, n2);
    //b3 = pRenderer->calcReflectanceFunc(pRenderer, v3, n3);

    // vyplnovani pinedovim algoritmem
    for (int y = min[1]; y <= max[1]; ++y) {
        int e[3] = {
            A[0] * min[0] + B[0] * y + C[0],
            A[1] * min[0] + B[1] * y + C[1],
            A[2] * min[0] + B[2] * y + C[2]
        };

        for (int x = min[0]; x <= max[0]; ++x) {
            // uvnitr trojuhelniku jsou cisla kladna
            if (e[0] >= 0 && e[1] >= 0 && e[2] >= 0) {

                // spocitame barycentricke koeficienty u,v,w
                double u = e[1] * _s1;
                double v = e[2] * _s2;
                double w = e[0] * _s0;

                // nemelo by nastat, protoze jsme uvnitr trojuhelniku
                //if (u < 0.0f || u > 1.0f) continue;
                //if (v < 0.0f || v > 1.0f) continue;
                //if (w < 0.0f || w > 1.0f) continue;

                // bod v trojuhelniku pred projekci ve 3D
                S_Coords pt = makeCoords(
                    u * v1->x + v * v2->x + w * v3->x,
                    u * v1->y + v * v2->y + w * v3->y,
                    u * v1->z + v * v2->z + w * v3->z);

                /* gourandovo stinovani */
                //double r = u * b1.red   + v * b2.red   + w * b3.red;
                //double g = u * b1.green + v * b2.green + w * b3.green;
                //double b = u * b1.blue  + v * b2.blue  + w * b3.blue;
                //double a = u * b1.alpha + v * b2.alpha + w * b3.alpha;

                //r = MIN(255.0f, MAX(r, 0.0f));
                //g = MIN(255.0f, MAX(g, 0.0f));
                //b = MIN(255.0f, MAX(b, 0.0f));
                //a = MIN(255.0f, MAX(a, 0.0f));

                //color.red   = ROUND2BYTE(r);
                //color.green = ROUND2BYTE(g);
                //color.blue  = ROUND2BYTE(b);
                //color.alpha = ROUND2BYTE(a);

                // vektor smerujici od bodu ke kamere
                S_Coords P_Cam = makeCoords(
                    -pt.x,
                    -pt.y,
                    -pRenderer->camera_dist - pt.z);

                // vykreslime jen blizsi body
                double depth = sqrt(P_Cam.x * P_Cam.x + P_Cam.y * P_Cam.y + P_Cam.z * P_Cam.z);
                if (depth <= DEPTH(pRenderer, x, y))
                {
                    // normala bodu
                    S_Coords n = makeCoords(
                        u * n1->x + v * n2->x + w * n3->x,
                        u * n1->y + v * n2->y + w * n3->y,
                        u * n1->z + v * n2->z + w * n3->z);
                    coordsNormalize(&n);

                    S_RGBA color;
                    color = pRenderer->calcReflectanceFunc(pRenderer, &pt, &n);

                    /* vybarvi objekt normalou */
                    //color.red = ROUND2BYTE(255.0f * (n.x / 2.0f + 0.5f));
                    //color.green = ROUND2BYTE(255.0f * (n.y / 2.0f + 0.5f));
                    //color.blue = ROUND2BYTE(255.0f * (-n.z / 2.0f + 0.5f));
                    //color.alpha = 255;

                    DEPTH(pRenderer, x, y) = depth;
                    PIXEL(pRenderer, x, y) = color;
                }
            }

            // Ei(x+1,y) = Ei(x,y) + dy
            e[0] += A[0];
            e[1] += A[1];
            e[2] += A[2];
        }
    }
}