Esempio n. 1
0
void geMatrixMult(float* m){
//	geMatrix44Mult(ge_current_matrix, ge_current_matrix, m);
	float tmp[16];
	geMatrix44Mult(tmp, ge_current_matrix, m);
	memcpy(ge_current_matrix, tmp, sizeof(float)*16);
	ge_current_matrix_update = true;
}
Esempio n. 2
0
void ge_Translate(float* m, float x, float y, float z){
	float t[16];
	ge_LoadIdentity(t);
	t[12] = x;
	t[13] = y;
	t[14] = z;
	geMatrix44Mult(m, m, t);
}
Esempio n. 3
0
void geRotate(float x, float y, float z){
	float tx[16], ty[16], tz[16], tb[16];

	if(x != 0.0f){
		ge_LoadIdentity(tx);
		float cx = cosf(x);
		float sx = sinf(x);
		tx[1*4+1] = cx;
		tx[1*4+2] = sx;
		tx[2*4+1] = -sx;
		tx[2*4+2] = cx;

		memcpy(tb, ge_current_matrix, sizeof(float)*16);
		geMatrix44Mult(ge_current_matrix, tb, tx);
	}
	
	if(y != 0.0f){
		ge_LoadIdentity(ty);
		float cy = cosf(y);
		float sy = sinf(y);
		ty[0*4+0] = cy;
		ty[0*4+2] = -sy;
		ty[2*4+0] = sy;
		ty[2*4+2] = cy;

		float tb[16];
		memcpy(tb, ge_current_matrix, sizeof(float)*16);
		geMatrix44Mult(ge_current_matrix, tb, ty);
	}
	
	if(z != 0.0f){
		ge_LoadIdentity(tz);
		float cz = cosf(z);
		float sz = sinf(z);
		tz[0*4+0] = cz;
		tz[0*4+1] = sz;
		tz[1*4+0] = -sz;
		tz[1*4+1] = cz;

		float tb[16];
		memcpy(tb, ge_current_matrix, sizeof(float)*16);
		geMatrix44Mult(ge_current_matrix, tb, tz);
	}

	ge_current_matrix_update = true;
}
Esempio n. 4
0
void ge_Scale(float* m, float x, float y, float z){
	float t[16];
	ge_LoadIdentity(t);
	t[0] = x;
	t[5] = y;
	t[10] = z;

	geMatrix44Mult(m, m, t);
}
Esempio n. 5
0
void geTranslate(float x, float y, float z){
	float t[16];
	ge_LoadIdentity(t);
	t[12] = x;
	t[13] = y;
	t[14] = z;

	geMatrix44Mult(ge_current_matrix, ge_current_matrix, t);
	ge_current_matrix_update = true;
}
Esempio n. 6
0
void SendModelMatrices(){
	geSendMatrix(GE_MATRIX_MODELVIEW, (float*)&ge_matrices[GE_MATRIX_MODELVIEW]);
	geSendMatrix(GE_MATRIX_NORMAL, (float*)&ge_matrices[GE_MATRIX_NORMAL]);
	
	float temp[16]; //9
	geMatrix44Mult(temp, ge_matrices[GE_MATRIX_PROJECTION], ge_matrices[GE_MATRIX_MODELVIEW]);
	glUniformMatrix4fv(loc_mvp, 1, GL_FALSE, temp);
//	PrintMatrix("MatrixModelView", (float*)&ge_matrices[GE_MATRIX_MODELVIEW], 4);
//	PrintMatrix("MatrixNormal", (float*)&ge_matrices[GE_MATRIX_NORMAL], 4);
}
Esempio n. 7
0
void geScale(float x, float y, float z){
	float t[16];
	ge_LoadIdentity(t);
	t[0] = x;
	t[5] = y;
	t[10] = z;

	geMatrix44Mult(ge_current_matrix, ge_current_matrix, t);
	ge_current_matrix_update = true;
}
Esempio n. 8
0
void geLookAt(float eyeX, float eyeY, float eyeZ, float centerX, float centerY, float centerZ){
	float m[16];
	float f[4];
	float u[3];
	float s[4];

	f[0] = centerX - eyeX;
	f[1] = centerY - eyeY;
	f[2] = centerZ - eyeZ;
	f[3] = 0.0;

	geNormalize(f);
	geCrossProduct(s, f, u_vec);
	s[3] = 0.0;
	geNormalize(s);
	geCrossProduct(u, s, f);

	m[0] = s[0];
	m[4] = s[1];
	m[8] = s[2];
	m[12]= 0.0;

	m[1] = u[0];
	m[5] = u[1];
	m[9] = u[2];
	m[13]= 0.0;

	m[2] = -f[0];
	m[6] = -f[1];
	m[10]= -f[2];
	m[14]= 0.0;

	m[3] = 0.0;
	m[7] = 0.0;
	m[11]= 0.0;
	m[15]= 1.0;

	float result[16] = { 0.0 };
	geMatrix44Mult(result, ge_current_matrix, m);
	memcpy(ge_current_matrix, result, sizeof(float)*16);
	geTranslate(-eyeX, -eyeY, -eyeZ);

	ge_current_matrix_update = true;
}
Esempio n. 9
0
void CalculateModelMatrices(){
	float ModelView3[9];
	float temp[16]; //9
	
	geMatrix44Mult(ge_matrices[GE_MATRIX_MODELVIEW], ge_matrices[GE_MATRIX_VIEW], ge_matrices[GE_MATRIX_MODEL]);

	ModelView3[0]=ge_matrices[GE_MATRIX_MODELVIEW][0]; ModelView3[1]=ge_matrices[GE_MATRIX_MODELVIEW][1]; ModelView3[2]=ge_matrices[GE_MATRIX_MODELVIEW][2];
	ModelView3[3]=ge_matrices[GE_MATRIX_MODELVIEW][4]; ModelView3[4]=ge_matrices[GE_MATRIX_MODELVIEW][5]; ModelView3[5]=ge_matrices[GE_MATRIX_MODELVIEW][6];
	ModelView3[6]=ge_matrices[GE_MATRIX_MODELVIEW][8]; ModelView3[7]=ge_matrices[GE_MATRIX_MODELVIEW][9]; ModelView3[8]=ge_matrices[GE_MATRIX_MODELVIEW][10];
	
	geMatrixInverse(temp, ModelView3, 3);
	geMatrixTranspose(ge_matrices[GE_MATRIX_NORMAL], temp, 3);
/*
	float temp[16]; //9
	geMatrixInverse(temp, ge_matrices[GE_MATRIX_MODELVIEW], 4);
	geMatrixTranspose(temp2, temp, 4);
	ge_matrices[GE_MATRIX_NORMAL][0]=temp2[0]; ge_matrices[GE_MATRIX_NORMAL][1]=temp2[1]; ge_matrices[GE_MATRIX_NORMAL][2]=temp2[2];
	ge_matrices[GE_MATRIX_NORMAL][3]=temp2[4]; ge_matrices[GE_MATRIX_NORMAL][4]=temp2[5]; ge_matrices[GE_MATRIX_NORMAL][5]=temp2[6];
	ge_matrices[GE_MATRIX_NORMAL][6]=temp2[8]; ge_matrices[GE_MATRIX_NORMAL][7]=temp2[9]; ge_matrices[GE_MATRIX_NORMAL][8]=temp2[10];
*/
}
Esempio n. 10
0
void geLightComputeShadow(ge_Light* light, ge_Camera* cam, void (*render)(void*), void* udata){
	geFramebufferUse(light->shadow_fbo);
	geViewport(0, 0, light->shadow_fbo->depth->width, light->shadow_fbo->depth->height);
	glDisable(GL_SCISSOR_TEST);

	float save_proj[16];
	memcpy(save_proj, geGetMatrix(GE_MATRIX_PROJECTION), sizeof(float) * 16);
	u32 save_clear_color = libge_context->clear_color;

	geClearColor(0xFFFFFFFF);
//	glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
		
	//glDisable(GL_CULL_FACE);
	//glEnable(GL_CULL_FACE);
	//glCullFace(GL_BACK);
	glFrontFace(GL_CCW);
	geForceShader(light->shadow_shader);

	geMatrixMode(GE_MATRIX_VIEW);
	geLoadIdentity();
	float l_pos[3] = { light->position.x, light->position.y, light->position.z };

	geNormalize(l_pos);
	l_pos[0] *= 10000.0;
	l_pos[1] *= 10000.0;
	l_pos[2] *= 10000.0;
	float cCam[3] = { cam->cX - cam->x, cam->cY - cam->y, cam->cZ - cam->z };
	geNormalize(cCam);
	cCam[0] = cCam[0] * 10.0 + cam->x;
	cCam[1] = cCam[1] * 10.0 + cam->y;
	cCam[2] = cCam[2] * 10.0 + cam->z;
	l_pos[0] += cCam[0];
	l_pos[1] += cCam[1];
	l_pos[2] += cCam[2];
	geLookAt(l_pos[0], l_pos[1], l_pos[2], light->target.x + cCam[0], light->target.y + cCam[1], light->target.z + cCam[2]);

	static ge_Camera fake_cam;
	fake_cam.x = l_pos[0];
	fake_cam.y = l_pos[1];
	fake_cam.z = l_pos[2];
	ge_Camera* cam_save = ge_current_camera;
	ge_current_camera = &fake_cam;

/*
	float cCam[3] = { cam->cX - cam->x, cam->cY - cam->y, cam->cZ - cam->z };
	geNormalize(cCam);
	cCam[0] = cCam[0] * 20.0 + cam->x;
	cCam[1] = cCam[1] * 20.0 + cam->y;
	cCam[2] = cCam[2] * 20.0 + cam->z;

	l_pos[0] += cCam[0];
	l_pos[1] += cCam[1];
	l_pos[2] += cCam[2];

	geLookAt(l_pos[0], l_pos[1], l_pos[2], light->target.x + cCam[0], light->target.y + cCam[1], light->target.z + cCam[2]);
*/

//	geLookAt(light->position.x, light->position.y, light->position.z, light->position.x + light->target.x * 10.0, light->position.y + light->target.y * 10.0, light->position.z + light->target.z * 10.0);

	int i, j;
	light->iShadow = max(1, (light->iShadow + 1) % light->shadow_depth);
//	for(j=0; j<3; j++){
	for(j=0; j<2 && j<light->shadow_depth; j++){
		if(j == 0){
			i = 0;
		}else{
			i = max(1, (light->iShadow + j) % light->shadow_depth);
		}
		glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, light->shadow->id, 0, i);
		//glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, light->shadow->id, 0, i);
		//glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, light->shadow_fbo->depth->id, 0);

		geClearScreen();

		geMatrixMode(GE_MATRIX_PROJECTION);
		geLoadIdentity();
		if(light->type == GE_LIGHT_TYPE_SPOT){
			gePerspective(90.0, 1.0, 0.001, 500.0);
			//light->spot_cutoff
		}else{
			//float range = 10.0 * expf((float)i * 1.0);
			float range = 10.0 * powf(4.0, (float)i * light->shadow_factor);
			//float range = 10.0 * powf(2.0, (float)i * 1.0);
		//	geOrthogonal(-range, range, -range, range, 1.0, 5000.0);
			geOrthogonal(-range, range, -range, range, 1.0, 50000.0);
		}


		float bias[16] = {
			0.5, 0.0, 0.0, 0.0, 
			0.0, 0.5, 0.0, 0.0,
			0.0, 0.0, 0.5, 0.0,
			0.5, 0.5, 0.5, 1.0
		};
		float* m_projection = geGetMatrix(GE_MATRIX_PROJECTION);
		float* m_view = geGetMatrix(GE_MATRIX_VIEW);

		float m_1[16] = { 0.0 };
		geMatrix44Mult(m_1, m_projection, m_view);
		geMatrixMode(GE_MATRIX_TEXTURE7 - i);
		geLoadMatrix(bias);
		geMatrixMult(m_1);
	
		//geForceCap(GL_DEPTH_TEST, false);
		render(udata);
		//geForceCap(GL_DEPTH_TEST, -1);
	}
	
	//glEnable(GL_CULL_FACE);
	//glCullFace(GL_FRONT);
	glFrontFace(GL_CW);
	
	geForceShader(NULL);
	geFramebufferUse(NULL);
//	geClearMode(last_clear_mode);
	glEnable(GL_SCISSOR_TEST);
//	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
	geViewport(0, 0, geGetContext()->width, geGetContext()->height);

	geClearColor(save_clear_color);

	memcpy(libge_context->projection_matrix, save_proj, sizeof(float)*16);
	memcpy(geGetMatrix(GE_MATRIX_PROJECTION), save_proj, sizeof(float)*16);

	ge_current_camera = cam_save;
}