コード例 #1
0
void DebugEmitterComponent::_CalculateNodeTransform(std::stack<mat4*>& stack, mat4* res)
{
	if (stack.size() == 1)
	{
		auto top = stack.top();
		stack.pop();

		mat4 result;
		mat4_copy(result, *top);
		mat4_copy(*res, result);
		float a = 0;
	}
	else
	{
		mat4 childRes;
		auto top = stack.top();
		stack.pop();
		_CalculateNodeTransform(stack, &childRes);

		mat4 result;

		mat4_mul_mat4(*top, childRes, result);
		mat4_copy(*res, result);
		float a = 0;
	}
}
コード例 #2
0
ファイル: tr_extra.c プロジェクト: dustinduse/etlegacy
void MatrixMultiplyShear(mat4_t m, vec_t x, vec_t y)
{
	mat4_t tmp, shear;

	mat4_copy(m, tmp);
	MatrixSetupShear(shear, x, y);
	mat4_mult(tmp, shear, m);
}
コード例 #3
0
ファイル: tr_extra.c プロジェクト: dustinduse/etlegacy
void MatrixMultiplyZRotation(mat4_t m, vec_t degrees)
{
	mat4_t tmp, rot;

	mat4_copy(m, tmp);
	MatrixSetupZRotation(rot, degrees);

	mat4_mult(tmp, rot, m);
}
コード例 #4
0
ファイル: move.c プロジェクト: IJDykeman/wangTiles
static int on_move(gesture3d_t *gest, void *user)
{
    float face_plane[4][4];
    cursor_t *curs = gest->cursor;
    tool_move_t *tool = user;
    float n[3], pos[3], d[3], ofs[3], v[3];
    layer_t *layer = goxel->image->active_layer;
    float mat[4][4];

    if (box_is_null(tool->box)) return GESTURE_FAILED;

    if (gest->type == GESTURE_HOVER) {
        goxel_set_help_text(goxel, "Drag to move face");
        if (curs->snaped != SNAP_LAYER_OUT) return GESTURE_FAILED;
        tool->snap_face = get_face(curs->normal);
        curs->snap_offset = 0;
        curs->snap_mask &= ~SNAP_ROUNDED;
        mat4_mul(tool->box, FACES_MATS[tool->snap_face], face_plane);
        render_img(&goxel->rend, NULL, face_plane, EFFECT_NO_SHADING);
        if (curs->flags & CURSOR_PRESSED) {
            gest->type = GESTURE_DRAG;
            vec3_normalize(face_plane[0], v);
            plane_from_vectors(goxel->tool_plane, curs->pos, curs->normal, v);
            image_history_push(goxel->image);
        }
        return 0;
    }
    if (gest->type == GESTURE_DRAG) {
        goxel_set_help_text(goxel, "Drag to move face");
        curs->snap_offset = 0;
        curs->snap_mask &= ~SNAP_ROUNDED;
        mat4_mul(tool->box, FACES_MATS[tool->snap_face], face_plane);

        vec3_normalize(face_plane[2], n);
        vec3_sub(curs->pos, goxel->tool_plane[3], v);
        vec3_project(v, n, v);
        vec3_add(goxel->tool_plane[3], v, pos);
        pos[0] = round(pos[0]);
        pos[1] = round(pos[1]);
        pos[2] = round(pos[2]);
        vec3_add(tool->box[3], face_plane[2], d);
        vec3_sub(pos, d, ofs);
        vec3_project(ofs, n, ofs);

        mat4_set_identity(mat);
        mat4_itranslate(mat, ofs[0], ofs[1], ofs[2]);
        do_move(layer, mat);

        if (gest->state == GESTURE_END) {
            gest->type = GESTURE_HOVER;
            mat4_copy(plane_null, goxel->tool_plane);
        }
        return 0;
    }
    return 0;
}
コード例 #5
0
void GL_LoadProjectionMatrix(const mat4_t m)
{
	if (mat4_compare(GLSTACK_PM, m))
	{
		return;
	}

	mat4_copy(m, GLSTACK_PM);
	mat4_mult(GLSTACK_PM, GLSTACK_MVM, GLSTACK_MVPM);
}
コード例 #6
0
void GL_LoadModelViewMatrix(const mat4_t m)
{
	if (mat4_compare(GLSTACK_MVM, m))
	{
		return;
	}

	mat4_copy(m, GLSTACK_MVM);
	mat4_mult(GLSTACK_PM, GLSTACK_MVM, GLSTACK_MVPM);
}
コード例 #7
0
ファイル: matrix.cpp プロジェクト: fdiskcn/DASSimulationProj
void mat4_rotateY(mat4 m, float theta) {
    mat4 transform = {
         cosf(theta), 0,  sinf(theta), 0,
                  0,  1,            0, 0,
        -sinf(theta), 0,  cosf(theta), 0,
                  0,  0,            0, 1
    };
    mat4 tmp;
    mat4_multiply(m, transform, tmp);
    mat4_copy(m, tmp);
}
コード例 #8
0
ファイル: matrix.cpp プロジェクト: fdiskcn/DASSimulationProj
void mat4_translate(mat4 m, float x, float y, float z) {
    mat4 transform = {
        1, 0, 0, x,
        0, 1, 0, y,
        0, 0, 1, z,
        0, 0, 0, 1
    };
    mat4 tmp;
    mat4_multiply(m, transform, tmp);
    mat4_copy(m, tmp);
}
コード例 #9
0
ファイル: mat4.c プロジェクト: jamiesyme/Rastafari
void mat4_mult(mat4_t mat1, mat4_t mat2)
{
	int x, y;
	float mat1t[16];
	mat4_copy(mat1t, mat1);
	
	for (y = 0; y < 4; y++) {
		for (x = 0; x < 4; x++) {
			mat1[y*4+x] = mat1t[y*4+0] * mat2[x+0] + 
			              mat1t[y*4+1] * mat2[x+4] + 
			              mat1t[y*4+2] * mat2[x+8] +
			              mat1t[y*4+3] * mat2[x+12];
		}
	}
}
コード例 #10
0
ファイル: tr_extra.c プロジェクト: dustinduse/etlegacy
void MatrixMultiplyTranslation(mat4_t m, vec_t x, vec_t y, vec_t z)
{
#if 1
	mat4_t tmp, trans;

	mat4_copy(m, tmp);
	mat4_reset_translate(trans, x, y, z);
	mat4_mult(tmp, trans, m);
#else
	m[12] += m[0] * x + m[4] * y + m[8] * z;
	m[13] += m[1] * x + m[5] * y + m[9] * z;
	m[14] += m[2] * x + m[6] * y + m[10] * z;
	m[15] += m[3] * x + m[7] * y + m[11] * z;
#endif
}
コード例 #11
0
ファイル: torus.cpp プロジェクト: entropian/CRaytracer
Torus* initTorus(const mat4 inv_transform, const float swept_radius, const float tube_radius, const float phi, 
                 Material* mat)
{
    GenericTorus* gt = (GenericTorus*)malloc(sizeof(GenericTorus));
    gt->swept_radius = swept_radius;
    gt->tube_radius = tube_radius;
    gt->phi = phi;
    gt->mat = mat;

    Torus* torus = (Torus*)malloc(sizeof(Torus));
    torus->obj.ptr = gt;
    torus->obj.type = GENERICTORUS;
    torus->mat = mat;
    mat4_copy(torus->inv_transform, inv_transform);
    return torus;
}
コード例 #12
0
ファイル: box.cpp プロジェクト: entropian/CRaytracer
Box* initBox(const mat4 inv_transform, const float x_span, const float y_span, const float z_span, Material* mat)
{
    float half_x = x_span / 2.0f;
    float half_y = y_span / 2.0f;
    float half_z = z_span / 2.0f;
    AABox* aabox = (AABox*)malloc(sizeof(AABox));
    vec3_assign(aabox->min, -half_x, -half_y, -half_z);
    vec3_assign(aabox->max, half_x, half_y, half_z);
    aabox->mat = mat;

    Box* box = (Box*)malloc(sizeof(Box));
    box->obj.ptr = aabox;
    box->obj.type = AABOX;
    box->mat = mat;
    mat4_copy(box->inv_transform, inv_transform);
    return box;
}
コード例 #13
0
void DebugEmitterComponent::_GetNodeTransform(ModelNode* node, mat4* result)
{
	std::stack<mat4*> transform_stack;

	//	Build the stack

	ModelNode* currentNode = node;

	while (currentNode)
	{
		transform_stack.push(&currentNode->Transformation);

		currentNode = currentNode->ParentNode;
	}

	mat4 res;

	_CalculateNodeTransform(transform_stack, &res);

	mat4_copy(*result, res);
}
コード例 #14
0
ファイル: ray.c プロジェクト: kaspermeerts/cg
static bool ray_surface_intersect(Ray ray, const Surface *surf, Hit *hit)
{
	float ts[2] = {-HUGE_VAL, -HUGE_VAL}, t;
	Vec3 tnormals[2] = {{0,0,0},{0,0,0}}, tnormal;
	Ray tray;
	Mat4 normal_matrix;
	Shape *shape = surf->shape;
	int hits;

	mat4_copy(normal_matrix, surf->world_to_model);
	mat4_transpose(normal_matrix);

	tray.origin = mat4_transform3_homo(surf->world_to_model, ray.origin);
	tray.direction = mat4_transform3_hetero(surf->world_to_model, ray.direction);
	tray.near = ray.near;
	tray.far = ray.far;

	switch(shape->type)
	{
	case SHAPE_PLANE:
		hits = ray_plane_intersect(tray, shape->u.plane, ts, tnormals);
		break;
	case SHAPE_DISK:
		hits = ray_disk_intersect(tray, shape->u.disk, ts, tnormals);
		break;
	case SHAPE_SPHERE:
		hits = ray_sphere_intersect(tray, shape->u.sphere, ts, tnormals);
		break;
	case SHAPE_CYLINDER:
		hits = ray_cylinder_intersect(tray, shape->u.cylinder, ts, tnormals);
		break;
	case SHAPE_CONE:
		hits = ray_cone_intersect(tray, shape->u.cone, ts, tnormals);
		break;
	case SHAPE_MESH:
		hits = ray_mesh_intersect(tray, shape->u.mesh, ts, tnormals);
		break;
	default:
		printf("Unknown shape\n");
		return false;
		break;
	}

	/* We're looking for the smallest hit that is between the near and far
	 * planes of the ray. */
	if (hits == 0)
		return false;
	if (hits == 1)
	{
		if (ts[0] < ray.near || ts[0] > ray.far)
			return false;

		t = ts[0];
		tnormal = tnormals[0];
	} else if (hits == 2)
	{
		bool t0_ok = ts[0] >= ray.near && ts[0] <= ray.far;
		bool t1_ok = ts[1] >= ray.near && ts[1] <= ray.far;

		     if (!t0_ok && !t1_ok)
		{
			return false;
		}
		else if (t0_ok && !t1_ok)
		{
			t = ts[0];
			tnormal = tnormals[0];
		}
		else if (!t0_ok && t1_ok)
		{
			t = ts[1];
			tnormal = tnormals[1];
		}
		else
		{
			if (ts[0] < ts[1])
			{
				t = ts[0];
				tnormal = tnormals[0];
			} else
			{
				t = ts[1];
				tnormal = tnormals[1];
			}
		}
	} else
	{
		printf("General t finding code unimplemented\n");
		return false;
	}

	hit->t = t;
	hit->position = vec3_add(ray.origin, vec3_scale(t, ray.direction));
	hit->normal = vec3_normalize(mat4_transform3_hetero(normal_matrix, tnormal));
	return true;
}