//receipt of b/w color peaks in accordance with its height
TGAColor getColorVertex(int x){
	if(x<0){
		x = 0;
	}
	if(x>255){
		x = 255;
	}
	return TGAColor(x, x, x, 255);
}
예제 #2
0
파일: main.cpp 프로젝트: Yevs/CPURenderer
void triangle(Vec3i t0, Vec3i t1, Vec3i t2, Vec2i uv0, Vec2i uv1, Vec2i uv2,
              float intensity, int* zbuf, TGAImage& image) {
    if (isDegenerated(t0,t1,t2)) return;
    if (t0.y > t1.y) {
        std::swap(t0, t1);
        std::swap(uv0, uv1);
    }
    if (t0.y > t2.y) {
        std::swap(t0, t2);
        std::swap(uv0, uv2);
    }
    if (t1.y > t2.y) {
        std::swap(t1, t2);
        std::swap(uv1, uv2);
    }
    int* boundbox = getBoundBox(t0, t1, t2);
    Vec2i vertex(t1.x - t0.x, t1.y - t0.y);
    Vec2i tmpUv(uv1.x - uv0.x, uv1.y - uv0.y);
    for (int x = boundbox[0]; x <= boundbox[2]; x++) {
        for (int y = boundbox[1]; y <= boundbox[3]; y++) {
            if (insideTriangle(x, y, t0, t1, t2)) {
                int idx = x + y * width;
                int z = find_z(x, y, t0, t1, t2);
                Vec2i P(x, y), v(t0.x, t0.y);
                Vec2i s01(t1.x - t0.x, t1.y - t0.y), s02(t2.x - t0.x, t2.y - t0.y), sp0(t0.x - P.x, t0.y - P.y);
                Vec3i tmp1(s01.x, s02.x, sp0.x), tmp2(s01.y, s02.y, sp0.y);
                Vec3i tmp3 = tmp1 ^ tmp2;
                Vec3f res(tmp3.x, tmp3.y, tmp3.z);
                if (res.z != 0) {
                    res = res * (1 / res.z);
                } else {
                    continue;
                }
                Vec2f uvP =  uv0 * (1 - res.x - res.y) + uv1 * res.x + uv2 * res.y;
                if (zbuf[idx] < z) {
                    zbuf[idx] =  z;
                    TGAColor color = model->getDiffusive(uvP);
                    image.set(x, y, TGAColor(color.r * intensity , color.g * intensity , color.b * intensity , 255));
                }
            }
        }
    }
    delete[] boundbox;
}
예제 #3
0
파일: main.cpp 프로젝트: Jach/tinyrenderer
#include <vector>
#include <cmath>
#include "tgaimage.h"
#include "model.h"
#include "geometry.h"

const TGAColor white = TGAColor(255, 255, 255, 255);
const TGAColor red   = TGAColor(255, 0,   0,   255);
Model *model = NULL;
const int width  = 800;
const int height = 800;

void line(int x0, int y0, int x1, int y1, TGAImage &image, TGAColor color) {
    bool steep = false;
    if (std::abs(x0-x1)<std::abs(y0-y1)) {
        std::swap(x0, y0);
        std::swap(x1, y1);
        steep = true;
    }
    if (x0>x1) {
        std::swap(x0, x1);
        std::swap(y0, y1);
    }

    for (int x=x0; x<=x1; x++) {
        float t = (x-x0)/(float)(x1-x0);
        int y = y0*(1.-t) + y1*t;
        if (steep) {
            image.set(y, x, color);
        } else {
            image.set(x, y, color);
예제 #4
0
파일: tgaimage.cpp 프로젝트: MakSim345/cpp
TGAColor TGAImage::get(int x, int y) {
	if (!data || x<0 || y<0 || x>=width || y>=height) {
		return TGAColor();
	}
	return TGAColor(data+(x+y*width)*bytespp, bytespp);
}
예제 #5
0
TGAColor TGAImage::get(int x, int y) {
    if (!m_data || x<0 || y<0 || x>=m_width || y>=m_height) {
        return TGAColor();
    }
    return TGAColor(m_data + index(x, y), m_bytespp);
}
예제 #6
0
 virtual bool fragment(Vec3f bar, TGAColor &color) {
     Vec4f p = varying_tri*bar;
     color = TGAColor(255, 255, 255)*(p[2]/m_lightDistance);
     return false;
 }
예제 #7
0
파일: main.cpp 프로젝트: pvlbzn/Renderer
#include <vector>
#include <cmath>
#include "tgaimage.h"
#include "model.h"
#include "geometry.h"

const TGAColor WHITE = TGAColor(255, 255, 255, 255);
const TGAColor DGREY = TGAColor( 29,  29,  29, 255);
const TGAColor RED   = TGAColor(255,   0,   0, 255);

Model *model = NULL;

const int WIDTH  = 1600;
const int HEIGHT = 1600;

/*
void wrong_line(int x0, int y0, int x1, int y1, TGAImage &image, TGAColor color) {
    for (float i = 0.; i < 1.; i += .01) {
        int x = x0 * (1. - i) + x1 * i;
        int y = y0 * (1. - i) + y1 * i;
        image.set(x, y, color);
    }
    std::clog << "Printed" << std::endl;
}
*/

void line(int x0, int y0, int x1, int y1, TGAImage &image, TGAColor color) {
    bool steep = false;

    /* If the line is steep, we transpose the image. */
    if (std::abs(x0 - x1) < std::abs(y0 - y1)) {
예제 #8
0
파일: main.cpp 프로젝트: evlinkov/projects
    void rendering() {
        TGAImage image(width, height, TGAImage::RGB);
        for (int i = 0; i < faces[0].size(); ++i) {
            Vector3D <int> gridCoordinates[NUMBER];
            for (int j = 0; j < 3; ++j) {
                Vector3D<double> point = vertices[faces[j][i][0]];
                gridCoordinates[j] = Vector3D<int> (int((point[0] + 1.) * width * 0.5 + 0.5),int((point[1] + 1.) * height * 0.5 + 0.5),
                                                        int((point[2] + 1.) * depth * 0.5) + 0.5);
                
            }
            Vector3D<double> normal = (vertices[faces[2][i][0]] - vertices[faces[0][i][0]]) ^
                                        (vertices[faces[1][i][0]] - vertices[faces[0][i][0]]);
            normal.normalize();
            double intensity = normal * light;
            if (intensity > 0) { /* we can see it */
                /*Vector2D<int> uv[NUMBER];
                for (int j = 0; j < NUMBER; ++j) {
                    int id = faces[j][i][1];
                    uv[j] = Vector2D<int> (textureVertices[id][0] * diffusemap.get_width(),
                                           textureVertices[id][1] * diffusemap.get_height());
                }*/
                triangle(gridCoordinates[0], gridCoordinates[1], gridCoordinates[2], image, TGAColor(intensity*255,
                                                            intensity*255, intensity*255, 255), buffer);

            }
        }
        image.flip_vertically();
        image.write_tga_file("picture.tga");
    }
예제 #9
0
파일: main.cpp 프로젝트: olage/renderer
#include <algorithm>
#include "tgaimage.h"
#include "model.h"
#include "texture.h"

const int width = 800;
const int height = 800;
const int depth = 255;

const Vector3f kLightDirection{ 1.f / 3, 1.f / 3, 1.f / 3 };
//const Vector3f kLightDirection{ 0, 0, 1 };
const Vector3f            kEye{ 1, 1, 3 };
const Vector3f         kCenter{ 0, 0, 0 };
const Vector3f             kUp{ 0, 1, 0 };

const TGAColor red = TGAColor(depth, 0, 0, depth);
const TGAColor white = TGAColor(depth, depth, depth, depth);

class IShader {
public:
  virtual Matrix43f Vertex(int face_idx) = 0;
  virtual bool Fragment(Vector3f barycentric_coords, TGAColor& color) = 0;
};

class Shader : public IShader {
public:
  Shader(Model& model, Texture& texture, Texture& normal_map, Matrix44f uniform_world, Matrix44f uniform_M) 
    : model_(model), uniform_world_(uniform_world), texture_(texture), normal_map_(normal_map), 
    uniform_M_(uniform_M), uniform_MIT_(uniform_M_.InvertTranspose())
  {}