int render_test() {
init_screen(-2, -2, 2, 2, 500, 500);
float theta = M_PI / 3;
struct timeval start, end;
long mtime, secs, usecs;
int i = 0;
matrix edge = init_identity(4);
eye.x = 0;
eye.y = 5;
eye.z = 10;
draw_box(1, 1, 1, 1, 0, 0, &edge);
//draw_sphere(-1, 0, 0, 1, &edge);
SDL_Color s;
s.r = 0;
s.g = 0;
s.b = 255;
float total_frames = 0;
gettimeofday(&start, NULL);
while( i < 300 ) {
//theta = theta + M_PI / 30;
matrix transformer = init_identity( 4 );
//multiply_matrix_onto_self(rotation_matrix_x(theta), &transformer);
//multiply_matrix_onto_self(rotation_matrix_z(theta), &transformer);
//multiply_matrix_onto_self(rotation_matrix_y(theta), &transformer);
double s[3];
s[0] =.4;
s[1] =.4;
s[2] =.4;
multiply_matrix_onto_self(scale_matrix(s), &transformer);
matrix to_render = multiply_matrix(transformer, *m);
draw_to_screen(eye.x, eye.y, eye.z, &to_render, *(Uint32 *)&s);
eye.x += .01;
eye.y += .01;
//printf("y: %f\n", eye.y);
//eye.y -= .01;
//printf("Or %f seconds\n", l);
total_frames++;
//printf("Frames per sec: %f\n", l);
//1 / framerate = 1000 * millseconds
//ez = ez + 1;*/
i++;
}
gettimeofday(&end, NULL);
secs = end.tv_sec - start.tv_sec;
usecs = end.tv_usec - start.tv_usec;
mtime = ((secs) * 1000 + usecs/1000.0) + 0.5;
//printf("Elapsed time: %ld millisecs\n", mtime);
double l = (double) mtime / 1000;
printf("Total frames: %f\n", total_frames);
printf("Total time: %f\n", l);
printf("Average fps: %f\n", total_frames / l);
return 0;
}
static void
Render(unsigned int width, unsigned int height, shader_data* data)
{
float matrix_rotate[16], matrix_modelview[16], matrix_perspective[16], matrix_mvp[16];
/*
* Do some rotation with Euler angles. It is not a fixed axis as
* quaterions would be, but the effect is cool.
*/
rotate_matrix((float)data->angle_x, 1.0f, 0.0f, 0.0f, matrix_modelview);
rotate_matrix((float)data->angle_y, 0.0f, 1.0f, 0.0f, matrix_rotate);
multiply_matrix(matrix_rotate, matrix_modelview, matrix_modelview);
rotate_matrix((float)data->angle_z, 0.0f, 1.0f, 0.0f, matrix_rotate);
multiply_matrix(matrix_rotate, matrix_modelview, matrix_modelview);
/* Pull the camera back from the cube */
matrix_modelview[14] -= 2.5;
perspective_matrix(45.0f, (float)width/height, 0.01f, 100.0f, matrix_perspective);
multiply_matrix(matrix_perspective, matrix_modelview, matrix_mvp);
GL_CHECK(glUniformMatrix4fv(data->attr_mvp, 1, GL_FALSE, matrix_mvp));
data->angle_x += 3;
data->angle_y += 2;
data->angle_z += 1;
if(data->angle_x >= 360) data->angle_x -= 360;
if(data->angle_x < 0) data->angle_x += 360;
if(data->angle_y >= 360) data->angle_y -= 360;
if(data->angle_y < 0) data->angle_y += 360;
if(data->angle_z >= 360) data->angle_z -= 360;
if(data->angle_z < 0) data->angle_z += 360;
GL_CHECK(glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT));
GL_CHECK(glDrawArrays(GL_TRIANGLES, 0, 36));
}
void hmm_set_tprob(hmm_t *hmm, double *tprob, int ntprob)
{
hmm->ntprob_arr = ntprob;
if ( ntprob<=0 ) ntprob = 1;
if ( !hmm->tprob_arr )
hmm->tprob_arr = (double*) malloc(sizeof(double)*hmm->nstates*hmm->nstates*ntprob);
memcpy(hmm->tprob_arr,tprob,sizeof(double)*hmm->nstates*hmm->nstates);
int i;
for (i=1; i<ntprob; i++)
multiply_matrix(hmm->nstates, hmm->tprob_arr, hmm->tprob_arr+(i-1)*hmm->nstates*hmm->nstates, hmm->tprob_arr+i*hmm->nstates*hmm->nstates, hmm->tmp);
}
void* pthread_mul_matrix(void* _tid) {
int tid = *((int*) _tid);
double start;
double finish;
GET_TIME(start);
multiply_matrix(tid);
GET_TIME(finish);
printf("Thread_%02d,%lf,%lf\n", tid, start - start_time, finish - start_time);
//printf("Thread: %d finish - %lf\n", tid, finish - start_time);
return NULL;
}
void draw_objects(simulation_t *simulation, buffer_t *buffer, shader_t *shader, GLfloat camera[16]) {
GLfloat modelview[16];
for (unsigned int i = 0; i < simulation->count; i++) {
particle_t particle = simulation->src_buf[i];
vec3f p = particle.position;
load_identity(modelview);
translate(modelview, p.x, p.y, p.z);
scale(modelview, particle.radius, particle.radius, particle.radius);
multiply_matrix(modelview, camera, modelview);
set_matrix(shader, MODELVIEW_MATRIX, modelview);
glColor3f(particle.r, particle.g, particle.b);
draw_vbo(buffer);
}
}
int main(void)
{
int mat1[MAX][MAX];
int mat2[MAX][MAX];
int mat3[MAX][MAX];
input_matrix(mat1, MAX);
input_matrix(mat2, MAX);
multiply_matrix(mat1, mat2, mat3, MAX);
printf("\n Answer : ");
print_matrix(mat3, MAX);
return 0;
}
static void _set_tprob(hmm_t *hmm, int pos_diff)
{
assert( pos_diff>=0 );
int i, n;
n = hmm->ntprob_arr ? pos_diff % hmm->ntprob_arr : 0; // n-th precalculated matrix
memcpy(hmm->curr_tprob, hmm->tprob_arr+n*hmm->nstates*hmm->nstates, sizeof(*hmm->curr_tprob)*hmm->nstates*hmm->nstates);
if ( hmm->ntprob_arr > 0 )
{
n = pos_diff / hmm->ntprob_arr; // number of full blocks to jump
for (i=0; i<n; i++)
multiply_matrix(hmm->nstates, hmm->tprob_arr+(hmm->ntprob_arr-1)*hmm->nstates*hmm->nstates, hmm->curr_tprob, hmm->curr_tprob, hmm->tmp);
}
}
void multiply_matrix_blocked(int n, dense_matrix matA, dense_matrix matB, int blocksize, int lld, dense_matrix matprod)
{
int i,j,k;
int blocks;
if (n%blocksize!=0){
printf("blocksize not correct");
return;
}
blocks= n/blocksize;
for (i=0; i<blocks; ++i) {
for (j=0; j<blocks; ++j) {
for (k=0; k<blocks; ++k) {
multiply_matrix(blocksize,matA+i*blocksize*lld+k*blocksize,matB+j*blocksize+k*blocksize*lld,n,matprod+j*blocksize+i*blocksize*lld);
}
}
}
return;
}
void estimate(KalmanFilter f) {
/* Calculate innovation */
multiply_matrix(f.observation_model, f.predicted_state,
f.innovation);
subtract_matrix(f.observation, f.innovation,
f.innovation);
/* Calculate innovation covariance */
multiply_by_transpose_matrix(f.predicted_estimate_covariance,
f.observation_model,
f.vertical_scratch);
multiply_matrix(f.observation_model, f.vertical_scratch,
f.innovation_covariance);
add_matrix(f.innovation_covariance, f.observation_noise_covariance,
f.innovation_covariance);
/* Invert the innovation covariance.
Note: this destroys the innovation covariance.
TODO: handle inversion failure intelligently. */
destructive_invert_matrix(f.innovation_covariance,
f.inverse_innovation_covariance);
/* Calculate the optimal Kalman gain.
Note we still have a useful partial product in vertical scratch
from the innovation covariance. */
multiply_matrix(f.vertical_scratch, f.inverse_innovation_covariance,
f.optimal_gain);
/* Estimate the state */
multiply_matrix(f.optimal_gain, f.innovation,
f.state_estimate);
add_matrix(f.state_estimate, f.predicted_state,
f.state_estimate);
/* Estimate the state covariance */
multiply_matrix(f.optimal_gain, f.observation_model,
f.big_square_scratch);
subtract_from_identity_matrix(f.big_square_scratch);
multiply_matrix(f.big_square_scratch, f.predicted_estimate_covariance,
f.estimate_covariance);
}
void make_fit(int number,double *newcast)
{
double *sj,*si,lavi,lavj,fav;
long i,i1,j,j1,hi,hj,hi1,hj1,n,which;
static int hdim;
hdim=(embed-1)*DELAY;
for (i=0;i<dim*embed;i++)
localav[i]=0.0;
for (i=0;i<dim;i++)
foreav[i]=0.0;
for (n=0;n<number;n++) {
which=found[n];
for (j=0;j<dim;j++) {
sj=series[j];
foreav[j] += sj[which+1];
for (j1=0;j1<embed;j1++) {
hj=j*embed+j1;
localav[hj] += sj[which-j1*DELAY];
}
}
}
for (i=0;i<dim*embed;i++)
localav[i] /= number;
for (i=0;i<dim;i++)
foreav[i] /= number;
for (i=0;i<dim;i++) {
si=series[i];
for (i1=0;i1<embed;i1++) {
hi=i*embed+i1;
lavi=localav[hi];
hi1=i1*DELAY;
for (j=0;j<dim;j++) {
sj=series[j];
for (j1=0;j1<embed;j1++) {
hj=j*embed+j1;
lavj=localav[hj];
hj1=j1*DELAY;
mat[hi][hj]=0.0;
if (hj >= hi) {
for (n=0;n<number;n++) {
which=found[n];
mat[hi][hj] += (si[which-hi1]-lavi)*(sj[which-hj1]-lavj);
}
}
}
}
}
}
for (i=0;i<dim*embed;i++)
for (j=i;j<dim*embed;j++) {
mat[i][j] /= number;
mat[j][i]=mat[i][j];
}
imat=invert_matrix(mat,dim*embed);
for (i=0;i<dim;i++) {
si=series[i];
fav=foreav[i];
for (j=0;j<dim;j++) {
sj=series[j];
for (j1=0;j1<embed;j1++) {
hj=j*embed+j1;
lavj=localav[hj];
hj1=j1*DELAY;
vec[hj]=0.0;
for (n=0;n<number;n++) {
which=found[n];
vec[hj] += (si[which+1]-fav)*(sj[which-hj1]-lavj);
}
vec[hj] /= number;
}
}
multiply_matrix(imat,vec);
newcast[i]=foreav[i];
for (j=0;j<dim;j++) {
for (j1=0;j1<embed;j1++) {
hj=j*embed+j1;
newcast[i] += vec[hj]*(cast[hdim-j1*DELAY][j]-localav[hj]);
}
}
}
for (i=0;i<dim*embed;i++)
free(imat[i]);
free(imat);
}
HRESULT d3d_execute_buffer_execute(struct d3d_execute_buffer *buffer,
struct d3d_device *device, struct d3d_viewport *viewport)
{
DWORD vs = buffer->data.dwVertexOffset;
DWORD is = buffer->data.dwInstructionOffset;
char *instr = (char *)buffer->desc.lpData + is;
if (viewport->active_device != device)
{
WARN("Viewport %p active device is %p.\n",
viewport, viewport->active_device);
return DDERR_INVALIDPARAMS;
}
/* Activate the viewport */
viewport_activate(viewport, FALSE);
TRACE("ExecuteData :\n");
if (TRACE_ON(ddraw))
_dump_executedata(&(buffer->data));
while (1) {
LPD3DINSTRUCTION current = (LPD3DINSTRUCTION) instr;
BYTE size;
WORD count;
count = current->wCount;
size = current->bSize;
instr += sizeof(D3DINSTRUCTION);
switch (current->bOpcode) {
case D3DOP_POINT: {
WARN("POINT-s (%d)\n", count);
instr += count * size;
} break;
case D3DOP_LINE: {
WARN("LINE-s (%d)\n", count);
instr += count * size;
} break;
case D3DOP_TRIANGLE: {
int i;
D3DTLVERTEX *tl_vx = buffer->vertex_data;
TRACE("TRIANGLE (%d)\n", count);
if (buffer->nb_indices < count * 3)
{
buffer->nb_indices = count * 3;
HeapFree(GetProcessHeap(), 0, buffer->indices);
buffer->indices = HeapAlloc(GetProcessHeap(), 0, sizeof(*buffer->indices) * buffer->nb_indices);
}
for (i = 0; i < count; i++) {
LPD3DTRIANGLE ci = (LPD3DTRIANGLE) instr;
TRACE(" v1: %d v2: %d v3: %d\n",ci->u1.v1, ci->u2.v2, ci->u3.v3);
TRACE(" Flags : ");
if (TRACE_ON(ddraw))
{
/* Wireframe */
if (ci->wFlags & D3DTRIFLAG_EDGEENABLE1)
TRACE("EDGEENABLE1 ");
if (ci->wFlags & D3DTRIFLAG_EDGEENABLE2)
TRACE("EDGEENABLE2 ");
if (ci->wFlags & D3DTRIFLAG_EDGEENABLE1)
TRACE("EDGEENABLE3 ");
/* Strips / Fans */
if (ci->wFlags == D3DTRIFLAG_EVEN)
TRACE("EVEN ");
if (ci->wFlags == D3DTRIFLAG_ODD)
TRACE("ODD ");
if (ci->wFlags == D3DTRIFLAG_START)
TRACE("START ");
if ((ci->wFlags > 0) && (ci->wFlags < 30))
TRACE("STARTFLAT(%u) ", ci->wFlags);
TRACE("\n");
}
buffer->indices[(i * 3) ] = ci->u1.v1;
buffer->indices[(i * 3) + 1] = ci->u2.v2;
buffer->indices[(i * 3) + 2] = ci->u3.v3;
instr += size;
}
IDirect3DDevice7_DrawIndexedPrimitive(&device->IDirect3DDevice7_iface,
D3DPT_TRIANGLELIST, D3DFVF_TLVERTEX, tl_vx, 0, buffer->indices, count * 3, 0);
} break;
case D3DOP_MATRIXLOAD:
WARN("MATRIXLOAD-s (%d)\n", count);
instr += count * size;
break;
case D3DOP_MATRIXMULTIPLY: {
int i;
TRACE("MATRIXMULTIPLY (%d)\n", count);
for (i = 0; i < count; ++i)
{
D3DMATRIXMULTIPLY *ci = (D3DMATRIXMULTIPLY *)instr;
D3DMATRIX *a, *b, *c;
a = ddraw_get_object(&device->handle_table, ci->hDestMatrix - 1, DDRAW_HANDLE_MATRIX);
b = ddraw_get_object(&device->handle_table, ci->hSrcMatrix1 - 1, DDRAW_HANDLE_MATRIX);
c = ddraw_get_object(&device->handle_table, ci->hSrcMatrix2 - 1, DDRAW_HANDLE_MATRIX);
if (!a || !b || !c)
{
ERR("Invalid matrix handle (a %#x -> %p, b %#x -> %p, c %#x -> %p).\n",
ci->hDestMatrix, a, ci->hSrcMatrix1, b, ci->hSrcMatrix2, c);
}
else
{
TRACE("dst %p, src1 %p, src2 %p.\n", a, b, c);
multiply_matrix(a, c, b);
}
instr += size;
}
} break;
case D3DOP_STATETRANSFORM: {
int i;
TRACE("STATETRANSFORM (%d)\n", count);
for (i = 0; i < count; ++i)
{
D3DSTATE *ci = (D3DSTATE *)instr;
D3DMATRIX *m;
m = ddraw_get_object(&device->handle_table, ci->u2.dwArg[0] - 1, DDRAW_HANDLE_MATRIX);
if (!m)
{
ERR("Invalid matrix handle %#x.\n", ci->u2.dwArg[0]);
}
else
{
if (ci->u1.dtstTransformStateType == D3DTRANSFORMSTATE_WORLD)
device->world = ci->u2.dwArg[0];
if (ci->u1.dtstTransformStateType == D3DTRANSFORMSTATE_VIEW)
device->view = ci->u2.dwArg[0];
if (ci->u1.dtstTransformStateType == D3DTRANSFORMSTATE_PROJECTION)
device->proj = ci->u2.dwArg[0];
IDirect3DDevice7_SetTransform(&device->IDirect3DDevice7_iface,
ci->u1.dtstTransformStateType, m);
}
instr += size;
}
} break;
case D3DOP_STATELIGHT: {
int i;
TRACE("STATELIGHT (%d)\n", count);
for (i = 0; i < count; i++) {
LPD3DSTATE ci = (LPD3DSTATE) instr;
TRACE("(%08x,%08x)\n", ci->u1.dlstLightStateType, ci->u2.dwArg[0]);
if (!ci->u1.dlstLightStateType || (ci->u1.dlstLightStateType > D3DLIGHTSTATE_COLORVERTEX))
ERR("Unexpected Light State Type %d\n", ci->u1.dlstLightStateType);
else if (ci->u1.dlstLightStateType == D3DLIGHTSTATE_MATERIAL /* 1 */)
{
struct d3d_material *m;
m = ddraw_get_object(&device->handle_table, ci->u2.dwArg[0] - 1, DDRAW_HANDLE_MATERIAL);
if (!m)
ERR("Invalid material handle %#x.\n", ci->u2.dwArg[0]);
else
material_activate(m);
}
else if (ci->u1.dlstLightStateType == D3DLIGHTSTATE_COLORMODEL /* 3 */)
{
switch (ci->u2.dwArg[0]) {
case D3DCOLOR_MONO:
ERR("DDCOLOR_MONO should not happen!\n");
break;
case D3DCOLOR_RGB:
/* We are already in this mode */
break;
default:
ERR("Unknown color model!\n");
}
} else {
D3DRENDERSTATETYPE rs = 0;
switch (ci->u1.dlstLightStateType) {
case D3DLIGHTSTATE_AMBIENT: /* 2 */
rs = D3DRENDERSTATE_AMBIENT;
break;
case D3DLIGHTSTATE_FOGMODE: /* 4 */
rs = D3DRENDERSTATE_FOGVERTEXMODE;
break;
case D3DLIGHTSTATE_FOGSTART: /* 5 */
rs = D3DRENDERSTATE_FOGSTART;
break;
case D3DLIGHTSTATE_FOGEND: /* 6 */
rs = D3DRENDERSTATE_FOGEND;
break;
case D3DLIGHTSTATE_FOGDENSITY: /* 7 */
rs = D3DRENDERSTATE_FOGDENSITY;
break;
case D3DLIGHTSTATE_COLORVERTEX: /* 8 */
rs = D3DRENDERSTATE_COLORVERTEX;
break;
default:
break;
}
IDirect3DDevice7_SetRenderState(&device->IDirect3DDevice7_iface, rs, ci->u2.dwArg[0]);
}
instr += size;
}
} break;
case D3DOP_STATERENDER: {
int i;
IDirect3DDevice2 *d3d_device2 = &device->IDirect3DDevice2_iface;
TRACE("STATERENDER (%d)\n", count);
for (i = 0; i < count; i++) {
LPD3DSTATE ci = (LPD3DSTATE) instr;
IDirect3DDevice2_SetRenderState(d3d_device2, ci->u1.drstRenderStateType, ci->u2.dwArg[0]);
instr += size;
}
} break;
case D3DOP_PROCESSVERTICES:
{
/* TODO: Share code with IDirect3DVertexBuffer::ProcessVertices and / or
* IWineD3DDevice::ProcessVertices
*/
int i;
D3DMATRIX view_mat, world_mat, proj_mat;
TRACE("PROCESSVERTICES (%d)\n", count);
/* Get the transform and world matrix */
/* Note: D3DMATRIX is compatible with struct wined3d_matrix. */
wined3d_device_get_transform(device->wined3d_device,
D3DTRANSFORMSTATE_VIEW, (struct wined3d_matrix *)&view_mat);
wined3d_device_get_transform(device->wined3d_device,
D3DTRANSFORMSTATE_PROJECTION, (struct wined3d_matrix *)&proj_mat);
wined3d_device_get_transform(device->wined3d_device,
WINED3D_TS_WORLD_MATRIX(0), (struct wined3d_matrix *)&world_mat);
for (i = 0; i < count; i++) {
LPD3DPROCESSVERTICES ci = (LPD3DPROCESSVERTICES) instr;
TRACE(" Start : %d Dest : %d Count : %d\n",
ci->wStart, ci->wDest, ci->dwCount);
TRACE(" Flags : ");
if (TRACE_ON(ddraw))
{
if (ci->dwFlags & D3DPROCESSVERTICES_COPY)
TRACE("COPY ");
if (ci->dwFlags & D3DPROCESSVERTICES_NOCOLOR)
TRACE("NOCOLOR ");
if (ci->dwFlags == D3DPROCESSVERTICES_OPMASK)
TRACE("OPMASK ");
if (ci->dwFlags & D3DPROCESSVERTICES_TRANSFORM)
TRACE("TRANSFORM ");
if (ci->dwFlags == D3DPROCESSVERTICES_TRANSFORMLIGHT)
TRACE("TRANSFORMLIGHT ");
if (ci->dwFlags & D3DPROCESSVERTICES_UPDATEEXTENTS)
TRACE("UPDATEEXTENTS ");
TRACE("\n");
}
/* This is where doing Direct3D on top on OpenGL is quite difficult.
This method transforms a set of vertices using the CURRENT state
(lighting, projection, ...) but does not rasterize them.
They will only be put on screen later (with the POINT / LINE and
TRIANGLE op-codes). The problem is that you can have a triangle
with each point having been transformed using another state...
In this implementation, I will emulate only ONE thing : each
vertex can have its own "WORLD" transformation (this is used in the
TWIST.EXE demo of the 5.2 SDK). I suppose that all vertices of the
execute buffer use the same state.
If I find applications that change other states, I will try to do a
more 'fine-tuned' state emulation (but I may become quite tricky if
it changes a light position in the middle of a triangle).
In this case, a 'direct' approach (i.e. without using OpenGL, but
writing our own 3D rasterizer) would be easier. */
/* The current method (with the hypothesis that only the WORLD matrix
will change between two points) is like this :
- I transform 'manually' all the vertices with the current WORLD
matrix and store them in the vertex buffer
- during the rasterization phase, the WORLD matrix will be set to
the Identity matrix */
/* Enough for the moment */
if (ci->dwFlags == D3DPROCESSVERTICES_TRANSFORMLIGHT) {
unsigned int nb;
D3DVERTEX *src = ((D3DVERTEX *)((char *)buffer->desc.lpData + vs)) + ci->wStart;
D3DTLVERTEX *dst = ((D3DTLVERTEX *)buffer->vertex_data) + ci->wDest;
D3DVIEWPORT *Viewport = &viewport->viewports.vp1;
D3DMATRIX mat;
if (TRACE_ON(ddraw))
{
TRACE(" Projection Matrix : (%p)\n", &proj_mat);
dump_D3DMATRIX(&proj_mat);
TRACE(" View Matrix : (%p)\n", &view_mat);
dump_D3DMATRIX(&view_mat);
TRACE(" World Matrix : (%p)\n", &world_mat);
dump_D3DMATRIX(&world_mat);
}
multiply_matrix(&mat,&view_mat,&world_mat);
multiply_matrix(&mat,&proj_mat,&mat);
for (nb = 0; nb < ci->dwCount; nb++) {
/* No lighting yet */
dst->u5.color = 0xFFFFFFFF; /* Opaque white */
dst->u6.specular = 0xFF000000; /* No specular and no fog factor */
dst->u7.tu = src->u7.tu;
dst->u8.tv = src->u8.tv;
/* Now, the matrix multiplication */
dst->u1.sx = (src->u1.x * mat._11) + (src->u2.y * mat._21) + (src->u3.z * mat._31) + (1.0 * mat._41);
dst->u2.sy = (src->u1.x * mat._12) + (src->u2.y * mat._22) + (src->u3.z * mat._32) + (1.0 * mat._42);
dst->u3.sz = (src->u1.x * mat._13) + (src->u2.y * mat._23) + (src->u3.z * mat._33) + (1.0 * mat._43);
dst->u4.rhw = (src->u1.x * mat._14) + (src->u2.y * mat._24) + (src->u3.z * mat._34) + (1.0 * mat._44);
dst->u1.sx = dst->u1.sx / dst->u4.rhw * Viewport->dvScaleX
+ Viewport->dwX + Viewport->dwWidth / 2;
dst->u2.sy = (-dst->u2.sy) / dst->u4.rhw * Viewport->dvScaleY
+ Viewport->dwY + Viewport->dwHeight / 2;
dst->u3.sz /= dst->u4.rhw;
dst->u4.rhw = 1 / dst->u4.rhw;
src++;
dst++;
}
} else if (ci->dwFlags == D3DPROCESSVERTICES_TRANSFORM) {
unsigned int nb;
D3DLVERTEX *src = ((D3DLVERTEX *)((char *)buffer->desc.lpData + vs)) + ci->wStart;
D3DTLVERTEX *dst = ((D3DTLVERTEX *)buffer->vertex_data) + ci->wDest;
D3DVIEWPORT *Viewport = &viewport->viewports.vp1;
D3DMATRIX mat;
if (TRACE_ON(ddraw))
{
TRACE(" Projection Matrix : (%p)\n", &proj_mat);
dump_D3DMATRIX(&proj_mat);
TRACE(" View Matrix : (%p)\n",&view_mat);
dump_D3DMATRIX(&view_mat);
TRACE(" World Matrix : (%p)\n", &world_mat);
dump_D3DMATRIX(&world_mat);
}
multiply_matrix(&mat,&view_mat,&world_mat);
multiply_matrix(&mat,&proj_mat,&mat);
for (nb = 0; nb < ci->dwCount; nb++) {
dst->u5.color = src->u4.color;
dst->u6.specular = src->u5.specular;
dst->u7.tu = src->u6.tu;
dst->u8.tv = src->u7.tv;
/* Now, the matrix multiplication */
dst->u1.sx = (src->u1.x * mat._11) + (src->u2.y * mat._21) + (src->u3.z * mat._31) + (1.0 * mat._41);
dst->u2.sy = (src->u1.x * mat._12) + (src->u2.y * mat._22) + (src->u3.z * mat._32) + (1.0 * mat._42);
dst->u3.sz = (src->u1.x * mat._13) + (src->u2.y * mat._23) + (src->u3.z * mat._33) + (1.0 * mat._43);
dst->u4.rhw = (src->u1.x * mat._14) + (src->u2.y * mat._24) + (src->u3.z * mat._34) + (1.0 * mat._44);
dst->u1.sx = dst->u1.sx / dst->u4.rhw * Viewport->dvScaleX
+ Viewport->dwX + Viewport->dwWidth / 2;
dst->u2.sy = (-dst->u2.sy) / dst->u4.rhw * Viewport->dvScaleY
+ Viewport->dwY + Viewport->dwHeight / 2;
dst->u3.sz /= dst->u4.rhw;
dst->u4.rhw = 1 / dst->u4.rhw;
src++;
dst++;
}
}
else if (ci->dwFlags == D3DPROCESSVERTICES_COPY)
{
D3DTLVERTEX *src = ((D3DTLVERTEX *)((char *)buffer->desc.lpData + vs)) + ci->wStart;
D3DTLVERTEX *dst = ((D3DTLVERTEX *)buffer->vertex_data) + ci->wDest;
memcpy(dst, src, ci->dwCount * sizeof(D3DTLVERTEX));
} else {
ERR("Unhandled vertex processing flag %#x.\n", ci->dwFlags);
}
instr += size;
}
} break;
case D3DOP_TEXTURELOAD: {
WARN("TEXTURELOAD-s (%d)\n", count);
instr += count * size;
} break;
case D3DOP_EXIT: {
TRACE("EXIT (%d)\n", count);
/* We did this instruction */
instr += size;
/* Exit this loop */
goto end_of_buffer;
} break;
case D3DOP_BRANCHFORWARD: {
int i;
TRACE("BRANCHFORWARD (%d)\n", count);
for (i = 0; i < count; i++) {
LPD3DBRANCH ci = (LPD3DBRANCH) instr;
if ((buffer->data.dsStatus.dwStatus & ci->dwMask) == ci->dwValue)
{
if (!ci->bNegate)
{
TRACE(" Branch to %d\n", ci->dwOffset);
if (ci->dwOffset) {
instr = (char*)current + ci->dwOffset;
break;
}
}
} else {
if (ci->bNegate) {
TRACE(" Branch to %d\n", ci->dwOffset);
if (ci->dwOffset) {
instr = (char*)current + ci->dwOffset;
break;
}
}
}
instr += size;
}
} break;
case D3DOP_SPAN: {
WARN("SPAN-s (%d)\n", count);
instr += count * size;
} break;
case D3DOP_SETSTATUS: {
int i;
TRACE("SETSTATUS (%d)\n", count);
for (i = 0; i < count; i++) {
LPD3DSTATUS ci = (LPD3DSTATUS) instr;
buffer->data.dsStatus = *ci;
instr += size;
}
} break;
default:
ERR("Unhandled OpCode %d !!!\n",current->bOpcode);
/* Try to save ... */
instr += count * size;
break;
}
}
end_of_buffer:
return D3D_OK;
}
int main(int argc, char **argv) {
EGLDisplay sEGLDisplay;
EGLContext sEGLContext;
EGLSurface sEGLSurface;
/* EGL Configuration */
EGLint aEGLAttributes[] = {
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_DEPTH_SIZE, 16,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_NONE
};
EGLint aEGLContextAttributes[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
EGLConfig aEGLConfigs[1];
EGLint cEGLConfigs;
#ifdef _WIN32
MSG sMessage;
#else
XSetWindowAttributes win_attrs;
int attrs[64], idx = 0, num_config = 0;
int major, minor;
Colormap colormap;
XVisualInfo *pVisual;
XEvent e;
#endif
GLint iLocPosition = 0;
GLint iLocColour, iLocTexCoord, iLocNormal, iLocMVP;
GLint iLocXangle, iLocYangle, iLocZangle;
GLint iLocAspect, iLocLightPos, iLocSampler, iLocSampler2;
GLuint uiProgram, uiFragShader, uiVertShader;
GLenum myTex, myTex2;
int bDone = 0;
const unsigned int uiWidth = 640;
const unsigned int uiHeight = 480;
int iXangle = 0, iYangle = 0, iZangle = 0;
float aTBNmatrix1[9], aTBNmatrix2[9];
float aLightPos[] = { 0.0f, 0.0f, -1.0f }; // Light is nearest camera.
unsigned char *myPixels = calloc(1, 128*128*4); // Holds texture data.
unsigned char *myPixels2 = calloc(1, 128*128*4); // Holds texture data.
float aRotate[16], aModelView[16], aPerspective[16], aMVP[16];
int i;
/* EGL Init */
#ifdef _WIN32
hDisplay = EGL_DEFAULT_DISPLAY;
#else
hDisplay = XOpenDisplay(NULL);
if (!hDisplay) {
printf("Could not open display\n");
exit(-1);
}
#endif
sEGLDisplay = EGL_CHECK(eglGetDisplay(hDisplay));
EGL_CHECK(eglInitialize(sEGLDisplay, NULL, NULL));
EGL_CHECK(eglChooseConfig(sEGLDisplay, aEGLAttributes, aEGLConfigs, 1, &cEGLConfigs));
if (cEGLConfigs == 0) {
printf("No EGL configurations were returned.\n");
exit(-1);
}
#ifdef _WIN32
hWindow = create_window(uiWidth, uiHeight);
#else
hWindow = create_window("OpenGL ES 2.0 Example on a Linux Desktop", uiWidth,
uiHeight, hDisplay, sEGLDisplay, aEGLConfigs[0], &colormap, &pVisual);
#endif
sEGLSurface = EGL_CHECK(eglCreateWindowSurface(sEGLDisplay, aEGLConfigs[0], (EGLNativeWindowType)hWindow, NULL));
if (sEGLSurface == EGL_NO_SURFACE) {
printf("Failed to create EGL surface.\n");
exit(-1);
}
sEGLContext = EGL_CHECK(eglCreateContext(sEGLDisplay, aEGLConfigs[0], EGL_NO_CONTEXT, aEGLContextAttributes));
if (sEGLContext == EGL_NO_CONTEXT) {
printf("Failed to create EGL context.\n");
exit(-1);
}
EGL_CHECK(eglMakeCurrent(sEGLDisplay, sEGLSurface, sEGLSurface, sEGLContext));
/* Shader Initialisation */
process_shader(&uiVertShader, "shader.vert", GL_VERTEX_SHADER);
process_shader(&uiFragShader, "shader.frag", GL_FRAGMENT_SHADER);
/* Create uiProgram (ready to attach shaders) */
uiProgram = GL_CHECK(glCreateProgram());
/* Attach shaders and link uiProgram */
GL_CHECK(glAttachShader(uiProgram, uiVertShader));
GL_CHECK(glAttachShader(uiProgram, uiFragShader));
GL_CHECK(glLinkProgram(uiProgram));
/* Get attribute locations of non-fixed attributes like colour and texture coordinates. */
iLocPosition = GL_CHECK(glGetAttribLocation(uiProgram, "av4position"));
iLocColour = GL_CHECK(glGetAttribLocation(uiProgram, "av3colour"));
#ifdef DEBUG
printf("iLocPosition = %i\n", iLocPosition);
printf("iLocColour = %i\n", iLocColour);
#endif
/* Get uniform locations */
iLocMVP = GL_CHECK(glGetUniformLocation(uiProgram, "mvp"));
#ifdef DEBUG
printf("iLocMVP = %i\n", iLocMVP);
#endif
GL_CHECK(glUseProgram(uiProgram));
/* Enable attributes for position, colour and texture coordinates etc. */
GL_CHECK(glEnableVertexAttribArray(iLocPosition));
GL_CHECK(glEnableVertexAttribArray(iLocColour));
/* Populate attributes for position, colour and texture coordinates etc. */
GL_CHECK(glVertexAttribPointer(iLocPosition, 3, GL_FLOAT, GL_FALSE, 0, aVertices));
GL_CHECK(glVertexAttribPointer(iLocColour, 3, GL_FLOAT, GL_FALSE, 0, aColours));
GL_CHECK(glEnable(GL_CULL_FACE));
GL_CHECK(glEnable(GL_DEPTH_TEST));
#ifndef _WIN32
XSelectInput(hDisplay, hWindow, KeyPressMask | ExposureMask | EnterWindowMask
| LeaveWindowMask | PointerMotionMask | VisibilityChangeMask | ButtonPressMask
| ButtonReleaseMask | StructureNotifyMask);
#endif
/* Enter event loop */
while (!bDone) {
#ifdef _WIN32
if(PeekMessage(&sMessage, NULL, 0, 0, PM_REMOVE)) {
if(sMessage.message == WM_QUIT) {
bDone = 1;
} else {
TranslateMessage(&sMessage);
DispatchMessage(&sMessage);
}
}
#else
while (XPending(hDisplay) > 0) {
XNextEvent(hDisplay, &e);
if (e.type == ButtonPress) {
bDone = 1;
}
}
#endif
/*
* Do some rotation with Euler angles. It is not a fixed axis as
* quaterions would be, but the effect is cool.
*/
rotate_matrix(iXangle, 1.0, 0.0, 0.0, aModelView);
rotate_matrix(iYangle, 0.0, 1.0, 0.0, aRotate);
multiply_matrix(aRotate, aModelView, aModelView);
rotate_matrix(iZangle, 0.0, 1.0, 0.0, aRotate);
multiply_matrix(aRotate, aModelView, aModelView);
/* Pull the camera back from the cube */
aModelView[14] -= 2.5;
perspective_matrix(45.0, (double)uiWidth/(double)uiHeight, 0.01, 100.0, aPerspective);
multiply_matrix(aPerspective, aModelView, aMVP);
GL_CHECK(glUniformMatrix4fv(iLocMVP, 1, GL_FALSE, aMVP));
iXangle += 3;
iYangle += 2;
iZangle += 1;
if(iXangle >= 360) iXangle -= 360;
if(iXangle < 0) iXangle += 360;
if(iYangle >= 360) iYangle -= 360;
if(iYangle < 0) iYangle += 360;
if(iZangle >= 360) iZangle -= 360;
if(iZangle < 0) iZangle += 360;
GL_CHECK(glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT));
GL_CHECK(glDrawArrays(GL_TRIANGLES, 0, 36));
if (!eglSwapBuffers(sEGLDisplay, sEGLSurface)) {
printf("Failed to swap buffers.\n");
}
#ifdef _WIN32
Sleep(20);
#else
usleep(20000);
#endif
}
/* Cleanup shaders */
GL_CHECK(glUseProgram(0));
GL_CHECK(glDeleteShader(uiVertShader));
GL_CHECK(glDeleteShader(uiFragShader));
GL_CHECK(glDeleteProgram(uiProgram));
/* EGL clean up */
EGL_CHECK(eglMakeCurrent(sEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
EGL_CHECK(eglDestroySurface(sEGLDisplay, sEGLSurface));
EGL_CHECK(eglDestroyContext(sEGLDisplay, sEGLContext));
EGL_CHECK(eglTerminate(sEGLDisplay));
#ifndef _WIN32
/* X windows clean up */
XDestroyWindow(hDisplay, hWindow);
XFreeColormap(hDisplay, colormap);
XFree(pVisual);
XCloseDisplay(hDisplay);
#endif
return 0;
}
/*****************************************************************************
* IDirect3DViewport3::TransformVertices
*
* Transforms vertices by the transformation matrix.
*
* This function is pretty similar to IDirect3DVertexBuffer7::ProcessVertices,
* so it's tempting to forward it to there. However, there are some
* tiny differences. First, the lpOffscreen flag that is reported back,
* then there is the homogeneous vertex that is generated. Also there's a lack
* of FVFs, but still a custom stride. Last, the d3d1 - d3d3 viewport has some
* settings (scale) that d3d7 and wined3d do not have. All in all wrapping to
* ProcessVertices doesn't pay of in terms of wrapper code needed and code
* reused.
*
* Params:
* dwVertexCount: The number of vertices to be transformed
* lpData: Pointer to the vertex data
* dwFlags: D3DTRANSFORM_CLIPPED or D3DTRANSFORM_UNCLIPPED
* lpOffScreen: Set to the clipping plane clipping the vertex, if only one
* vertex is transformed and clipping is on. 0 otherwise
*
* Returns:
* D3D_OK on success
* D3DERR_VIEWPORTHASNODEVICE if the viewport is not assigned to a device
* DDERR_INVALIDPARAMS if no clipping flag is specified
*
*****************************************************************************/
static HRESULT WINAPI
IDirect3DViewportImpl_TransformVertices(IDirect3DViewport3 *iface,
DWORD dwVertexCount,
D3DTRANSFORMDATA *lpData,
DWORD dwFlags,
DWORD *lpOffScreen)
{
IDirect3DViewportImpl *This = (IDirect3DViewportImpl *)iface;
D3DMATRIX view_mat, world_mat, proj_mat, mat;
float *in;
float *out;
float x, y, z, w;
unsigned int i;
D3DVIEWPORT vp = This->viewports.vp1;
D3DHVERTEX *outH;
TRACE("iface %p, vertex_count %u, vertex_data %p, flags %#x, clip_plane %p.\n",
iface, dwVertexCount, lpData, dwFlags, lpOffScreen);
/* Tests on windows show that Windows crashes when this occurs,
* so don't return the (intuitive) return value
if(!This->active_device)
{
WARN("No device active, returning D3DERR_VIEWPORTHASNODEVICE\n");
return D3DERR_VIEWPORTHASNODEVICE;
}
*/
if(!(dwFlags & (D3DTRANSFORM_UNCLIPPED | D3DTRANSFORM_CLIPPED)))
{
WARN("No clipping flag passed, returning DDERR_INVALIDPARAMS\n");
return DDERR_INVALIDPARAMS;
}
EnterCriticalSection(&ddraw_cs);
IWineD3DDevice_GetTransform(This->active_device->wineD3DDevice,
D3DTRANSFORMSTATE_VIEW,
(WINED3DMATRIX*) &view_mat);
IWineD3DDevice_GetTransform(This->active_device->wineD3DDevice,
D3DTRANSFORMSTATE_PROJECTION,
(WINED3DMATRIX*) &proj_mat);
IWineD3DDevice_GetTransform(This->active_device->wineD3DDevice,
WINED3DTS_WORLDMATRIX(0),
(WINED3DMATRIX*) &world_mat);
multiply_matrix(&mat,&view_mat,&world_mat);
multiply_matrix(&mat,&proj_mat,&mat);
in = lpData->lpIn;
out = lpData->lpOut;
outH = lpData->lpHOut;
for(i = 0; i < dwVertexCount; i++)
{
x = (in[0] * mat._11) + (in[1] * mat._21) + (in[2] * mat._31) + (1.0 * mat._41);
y = (in[0] * mat._12) + (in[1] * mat._22) + (in[2] * mat._32) + (1.0 * mat._42);
z = (in[0] * mat._13) + (in[1] * mat._23) + (in[2] * mat._33) + (1.0 * mat._43);
w = (in[0] * mat._14) + (in[1] * mat._24) + (in[2] * mat._34) + (1.0 * mat._44);
if(dwFlags & D3DTRANSFORM_CLIPPED)
{
/* If clipping is enabled, Windows assumes that outH is
* a valid pointer
*/
outH[i].u1.hx = x; outH[i].u2.hy = y; outH[i].u3.hz = z;
outH[i].dwFlags = 0;
if(x * vp.dvScaleX > ((float) vp.dwWidth * 0.5))
outH[i].dwFlags |= D3DCLIP_RIGHT;
if(x * vp.dvScaleX <= -((float) vp.dwWidth) * 0.5)
outH[i].dwFlags |= D3DCLIP_LEFT;
if(y * vp.dvScaleY > ((float) vp.dwHeight * 0.5))
outH[i].dwFlags |= D3DCLIP_TOP;
if(y * vp.dvScaleY <= -((float) vp.dwHeight) * 0.5)
outH[i].dwFlags |= D3DCLIP_BOTTOM;
if(z < 0.0)
outH[i].dwFlags |= D3DCLIP_FRONT;
if(z > 1.0)
outH[i].dwFlags |= D3DCLIP_BACK;
if(outH[i].dwFlags)
{
/* Looks like native just drops the vertex, leaves whatever data
* it has in the output buffer and goes on with the next vertex.
* The exact scheme hasn't been figured out yet, but windows
* definitely writes something there.
*/
out[0] = x;
out[1] = y;
out[2] = z;
out[3] = w;
in = (float *) ((char *) in + lpData->dwInSize);
out = (float *) ((char *) out + lpData->dwOutSize);
continue;
}
}
w = 1 / w;
x *= w; y *= w; z *= w;
out[0] = vp.dwWidth / 2 + vp.dwX + x * vp.dvScaleX;
out[1] = vp.dwHeight / 2 + vp.dwY - y * vp.dvScaleY;
out[2] = z;
out[3] = w;
in = (float *) ((char *) in + lpData->dwInSize);
out = (float *) ((char *) out + lpData->dwOutSize);
}
/* According to the d3d test, the offscreen flag is set only
* if exactly one vertex is transformed. Its not documented,
* but the test shows that the lpOffscreen flag is set to the
* flag combination of clipping planes that clips the vertex.
*
* If clipping is requested, Windows assumes that the offscreen
* param is a valid pointer.
*/
if(dwVertexCount == 1 && dwFlags & D3DTRANSFORM_CLIPPED)
{
*lpOffScreen = outH[0].dwFlags;
}
else if(*lpOffScreen)
{
*lpOffScreen = 0;
}
LeaveCriticalSection(&ddraw_cs);
TRACE("All done\n");
return DD_OK;
}
void renderFrame() {
static float grey;
//grey += 0.01f;
//if (grey > 1.0f) {
// grey = 0.0f;
//}
glClearColor(grey, grey, grey, 1.0f);
checkGlError("glClearColor");
glClear( GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
checkGlError("glClear");
glUseProgram(gProgram);
checkGlError("glUseProgram");
#if USE_MESH
glVertexAttribPointer(gvPositionHandle, 4, GL_FLOAT, GL_FALSE, 0, gpMesh->m_pTriangleList);
#else
glVertexAttribPointer(gvPositionHandle, 3, GL_FLOAT, GL_FALSE, 0, gCubeVertices);
#endif
glEnableVertexAttribArray(gvPositionHandle);
checkGlError("glEnableVertexAttribArray");
#if USE_MESH
glVertexAttribPointer(gvColorHandle, 3, GL_FLOAT, GL_FALSE, 0, gpMesh->m_pVertexColor);
checkGlError("glVertexAttribPointer");
#else
glVertexAttribPointer(gvColorHandle, 3, GL_FLOAT, GL_FALSE, 0, gCubeColors);
checkGlError("glVertexAttribPointer");
#endif
glEnableVertexAttribArray(gvColorHandle);
checkGlError("glEnableVertexAttribArray");
//rotate - begin
rotate_matrix(iXangle, 1.0, 0.0, 0.0, aModelView);
rotate_matrix(iYangle, 0.0, 1.0, 0.0, aRotate);
multiply_matrix(aRotate, aModelView, aModelView);
rotate_matrix(iZangle, 0.0, 0.0, 1.0, aRotate);
multiply_matrix(aRotate, aModelView, aModelView);
//Pull the camera back from the geometry
aModelView[14] -= 3.5;
#if USE_MESH
//translate to lower left of geometry to lower-left of screen
aModelView[12] -= 1.0;
aModelView[13] -= 1.7;
#endif
perspective_matrix(45.0, (double)uiWidth/(double)uiHeight, 0.01, 100.0, aPerspective);
multiply_matrix(aPerspective, aModelView, aMVP);
glUniformMatrix4fv(gmvP, 1, GL_FALSE, aMVP);
glUniform1f(gAHandle, -1.0*(1.0 - animParam));
glUniform1f(gThetaHandle, animParam*_HALF_PI);
animParam -= 0.01;
if(animParam < 0.0) animParam = 1.0f;
#if !USE_MESH
//Comment the lines below to disable rotation
iZangle += 2;
iYangle += 2;
#endif
if(iXangle >= 360) iXangle -= 360;
if(iXangle < 0) iXangle += 360;
if(iYangle >= 360) iYangle -= 360;
if(iYangle < 0) iYangle += 360;
if(iZangle >= 360) iZangle -= 360;
if(iZangle < 0) iZangle += 360;
//rotate - end
#if USE_MESH
glDrawArrays(GL_TRIANGLES, 0, gpMesh->m_numTriangles);
#else
glDrawArrays(GL_TRIANGLES, 0, 36);
#endif
checkGlError("glDrawArrays");
}
void VoxelEditor::paintGL()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glEnable(GL_DEPTH_TEST);
view_matrix = mat4();
view_matrix = glm::translate(view_matrix,
vec3(width() / 2, height() / 2, 0.0f));
view_matrix = glm::translate(view_matrix, pos);
view_matrix = glm::scale(view_matrix, vec3(scale, scale, scale));
view_matrix = glm::rotate(view_matrix, rotate_x, vec3(1.0f, 0.0f, 0.0f));
view_matrix = glm::rotate(view_matrix, rotate_z, vec3(0.0f, 0.0f, 1.0f));
mvp = projection_matrix * view_matrix;
inverse_mvp = glm::inverse(mvp);
multiply_matrix(view_matrix);
glEnable(GL_LIGHTING);
setup_lighting();
model->draw_immediate();
SelectedVoxels::const_iterator it;
for (it = selected_list.begin(); it != selected_list.end(); it++) {
const SelectedVoxel & v = *it;
RGBColor & c = global_palette[v.v];
draw_cube(v.x, v.y, v.z, v.x + 1.0f, v.y + 1.0f, v.z + 1.0f,
c.r, c.g, c.b, 255);
glDisable(GL_LIGHTING);
draw_wireframe_cube(v.x, v.y, v.z, v.x + 1.0f, v.y + 1.0f, v.z + 1.0f,
255, 255, 255, 255);
glEnable(GL_LIGHTING);
}
glDisable(GL_LIGHTING);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
vec3 min = voxel->get_min();
vec3 max = voxel->get_max();
float x1 = min.x;
float x2 = max.x;
float y1 = min.y;
float y2 = max.y;
float z1 = min.z;
float z2 = max.z;
draw_wireframe_cube(x1, y1, z1, x2, y2, z2, 255, 255, 255, 255);
// checkerboard
glNormal3f(0.0f, 0.0f, 1.0f);
glBegin(GL_QUADS);
for (int x = 0; x < voxel->x_size; x++)
for (int y = 0; y < voxel->y_size; y++) {
float gl_x1 = x1 + float(x);
float gl_x2 = gl_x1 + 1.0f;
float gl_y1 = y1 + float(y);
float gl_y2 = gl_y1 + 1.0f;
unsigned char r, g, b;
if ((x + y) % 2 == 0)
r = g = b = 100;
else
r = g = b = 180;
glColor4ub(r, g, b, 255);
glVertex3f(gl_x1, gl_y1, z1 - 0.01f);
glVertex3f(gl_x2, gl_y1, z1 - 0.01f);
glVertex3f(gl_x2, gl_y2, z1 - 0.01f);
glVertex3f(gl_x1, gl_y2, z1 - 0.01f);
}
glEnd();
// draw axis lines
glLineWidth(1.0f);
glBegin(GL_LINES);
glColor4ub(GREY_R, GREY_G, GREY_B, 255);
glVertex3f(-COORD_LINE_SIZE, 0.0f, 0.0f);
glVertex3f(0, 0.0f, 0.0f);
glVertex3f(0.0f, -COORD_LINE_SIZE, 0.0f);
glVertex3f(0.0f, 0, 0.0f);
glColor4ub(RED_R, RED_G, RED_B, 255);
glVertex3f(0, 0.0f, 0.0f);
glVertex3f(COORD_LINE_SIZE, 0.0f, 0.0f);
glColor4ub(BLUE_R, BLUE_G, BLUE_B, 255);
glVertex3f(0.0f, 0, 0.0f);
glVertex3f(0.0f, COORD_LINE_SIZE, 0.0f);
glColor4ub(GREEN_R, GREEN_G, GREEN_B, 255);
glVertex3f(0.0f, 0.0f, 0);
glVertex3f(0.0f, 0.0f, COORD_LINE_SIZE);
glEnd();
glDisable(GL_DEPTH_TEST);
if (selected_list.size() > 0)
pos_arrows.draw();
if (window->test_current_window(this)) {
ReferencePoint * ref = window->model_properties->get_point();
if (ref != NULL) {
float x, y, z;
x = float(ref->x);
y = float(ref->y);
z = float(ref->z);
draw_cube(x, y, z, 0.5f, 127, 127, 127, 127);
draw_cube(x, y, z, 0.2f, 0, 0, 255, 255);
}
}
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
}
HRESULT d3d_execute_buffer_execute(struct d3d_execute_buffer *buffer,
struct d3d_device *device, struct d3d_viewport *viewport)
{
DWORD vs = buffer->data.dwVertexOffset;
DWORD is = buffer->data.dwInstructionOffset;
char *instr = (char *)buffer->desc.lpData + is;
unsigned int i;
if (viewport->active_device != device)
{
WARN("Viewport %p active device is %p.\n",
viewport, viewport->active_device);
return DDERR_INVALIDPARAMS;
}
/* Activate the viewport */
viewport_activate(viewport, FALSE);
TRACE("ExecuteData :\n");
if (TRACE_ON(ddraw))
_dump_executedata(&(buffer->data));
for (;;)
{
D3DINSTRUCTION *current = (D3DINSTRUCTION *)instr;
BYTE size;
WORD count;
count = current->wCount;
size = current->bSize;
instr += sizeof(D3DINSTRUCTION);
switch (current->bOpcode) {
case D3DOP_POINT: {
WARN("POINT-s (%d)\n", count);
instr += count * size;
} break;
case D3DOP_LINE: {
WARN("LINE-s (%d)\n", count);
instr += count * size;
} break;
case D3DOP_TRIANGLE:
{
D3DTLVERTEX *tl_vx = buffer->vertex_data;
TRACE("TRIANGLE (%d)\n", count);
if (buffer->nb_indices < count * 3)
{
buffer->nb_indices = count * 3;
HeapFree(GetProcessHeap(), 0, buffer->indices);
buffer->indices = HeapAlloc(GetProcessHeap(), 0, sizeof(*buffer->indices) * buffer->nb_indices);
}
for (i = 0; i < count; ++i)
{
D3DTRIANGLE *ci = (D3DTRIANGLE *)instr;
TRACE(" v1: %d v2: %d v3: %d\n",ci->u1.v1, ci->u2.v2, ci->u3.v3);
TRACE(" Flags : ");
if (TRACE_ON(ddraw))
{
/* Wireframe */
if (ci->wFlags & D3DTRIFLAG_EDGEENABLE1)
TRACE("EDGEENABLE1 ");
if (ci->wFlags & D3DTRIFLAG_EDGEENABLE2)
TRACE("EDGEENABLE2 ");
if (ci->wFlags & D3DTRIFLAG_EDGEENABLE1)
TRACE("EDGEENABLE3 ");
/* Strips / Fans */
if (ci->wFlags == D3DTRIFLAG_EVEN)
TRACE("EVEN ");
if (ci->wFlags == D3DTRIFLAG_ODD)
TRACE("ODD ");
if (ci->wFlags == D3DTRIFLAG_START)
TRACE("START ");
if ((ci->wFlags > 0) && (ci->wFlags < 30))
TRACE("STARTFLAT(%u) ", ci->wFlags);
TRACE("\n");
}
buffer->indices[(i * 3) ] = ci->u1.v1;
buffer->indices[(i * 3) + 1] = ci->u2.v2;
buffer->indices[(i * 3) + 2] = ci->u3.v3;
instr += size;
}
if (count)
IDirect3DDevice7_DrawIndexedPrimitive(&device->IDirect3DDevice7_iface,
D3DPT_TRIANGLELIST, D3DFVF_TLVERTEX, tl_vx, buffer->nb_vertices,
buffer->indices, count * 3, 0);
} break;
case D3DOP_MATRIXLOAD:
WARN("MATRIXLOAD-s (%d)\n", count);
instr += count * size;
break;
case D3DOP_MATRIXMULTIPLY:
TRACE("MATRIXMULTIPLY (%d)\n", count);
for (i = 0; i < count; ++i)
{
D3DMATRIXMULTIPLY *ci = (D3DMATRIXMULTIPLY *)instr;
D3DMATRIX *a, *b, *c;
a = ddraw_get_object(&device->handle_table, ci->hDestMatrix - 1, DDRAW_HANDLE_MATRIX);
b = ddraw_get_object(&device->handle_table, ci->hSrcMatrix1 - 1, DDRAW_HANDLE_MATRIX);
c = ddraw_get_object(&device->handle_table, ci->hSrcMatrix2 - 1, DDRAW_HANDLE_MATRIX);
if (!a || !b || !c)
{
ERR("Invalid matrix handle (a %#x -> %p, b %#x -> %p, c %#x -> %p).\n",
ci->hDestMatrix, a, ci->hSrcMatrix1, b, ci->hSrcMatrix2, c);
}
else
{
TRACE("dst %p, src1 %p, src2 %p.\n", a, b, c);
multiply_matrix(a, c, b);
}
instr += size;
}
break;
case D3DOP_STATETRANSFORM:
TRACE("STATETRANSFORM (%d)\n", count);
for (i = 0; i < count; ++i)
{
D3DSTATE *ci = (D3DSTATE *)instr;
D3DMATRIX *m;
m = ddraw_get_object(&device->handle_table, ci->u2.dwArg[0] - 1, DDRAW_HANDLE_MATRIX);
if (!m)
{
ERR("Invalid matrix handle %#x.\n", ci->u2.dwArg[0]);
}
else
{
if (ci->u1.dtstTransformStateType == D3DTRANSFORMSTATE_WORLD)
device->world = ci->u2.dwArg[0];
if (ci->u1.dtstTransformStateType == D3DTRANSFORMSTATE_VIEW)
device->view = ci->u2.dwArg[0];
if (ci->u1.dtstTransformStateType == D3DTRANSFORMSTATE_PROJECTION)
device->proj = ci->u2.dwArg[0];
IDirect3DDevice7_SetTransform(&device->IDirect3DDevice7_iface,
ci->u1.dtstTransformStateType, m);
}
instr += size;
}
break;
case D3DOP_STATELIGHT:
TRACE("STATELIGHT (%d)\n", count);
for (i = 0; i < count; ++i)
{
D3DSTATE *ci = (D3DSTATE *)instr;
if (FAILED(IDirect3DDevice3_SetLightState(&device->IDirect3DDevice3_iface,
ci->u1.dlstLightStateType, ci->u2.dwArg[0])))
WARN("Failed to set light state.\n");
instr += size;
}
break;
case D3DOP_STATERENDER:
TRACE("STATERENDER (%d)\n", count);
for (i = 0; i < count; ++i)
{
D3DSTATE *ci = (D3DSTATE *)instr;
if (FAILED(IDirect3DDevice3_SetRenderState(&device->IDirect3DDevice3_iface,
ci->u1.drstRenderStateType, ci->u2.dwArg[0])))
WARN("Failed to set render state.\n");
instr += size;
}
break;
case D3DOP_PROCESSVERTICES:
{
/* TODO: Share code with d3d_vertex_buffer7_ProcessVertices()
* and / or wined3d_device_process_vertices(). */
D3DMATRIX view_mat, world_mat, proj_mat, mat;
TRACE("PROCESSVERTICES (%d)\n", count);
/* Get the transform and world matrix */
/* Note: D3DMATRIX is compatible with struct wined3d_matrix. */
wined3d_device_get_transform(device->wined3d_device,
D3DTRANSFORMSTATE_VIEW, (struct wined3d_matrix *)&view_mat);
wined3d_device_get_transform(device->wined3d_device,
D3DTRANSFORMSTATE_PROJECTION, (struct wined3d_matrix *)&proj_mat);
wined3d_device_get_transform(device->wined3d_device,
WINED3D_TS_WORLD_MATRIX(0), (struct wined3d_matrix *)&world_mat);
if (TRACE_ON(ddraw))
{
TRACE(" Projection Matrix:\n");
dump_D3DMATRIX(&proj_mat);
TRACE(" View Matrix:\n");
dump_D3DMATRIX(&view_mat);
TRACE(" World Matrix:\n");
dump_D3DMATRIX(&world_mat);
}
multiply_matrix(&mat, &view_mat, &world_mat);
multiply_matrix(&mat, &proj_mat, &mat);
for (i = 0; i < count; ++i)
{
D3DPROCESSVERTICES *ci = (D3DPROCESSVERTICES *)instr;
D3DTLVERTEX *dst = (D3DTLVERTEX *)buffer->vertex_data + ci->wDest;
DWORD op = ci->dwFlags & D3DPROCESSVERTICES_OPMASK;
TRACE(" start %u, dest %u, count %u, flags %#x.\n",
ci->wStart, ci->wDest, ci->dwCount, ci->dwFlags);
if (ci->dwFlags & D3DPROCESSVERTICES_UPDATEEXTENTS)
FIXME("D3DPROCESSVERTICES_UPDATEEXTENTS not implemented.\n");
if (ci->dwFlags & D3DPROCESSVERTICES_NOCOLOR)
FIXME("D3DPROCESSVERTICES_NOCOLOR not implemented.\n");
switch (op)
{
case D3DPROCESSVERTICES_TRANSFORMLIGHT:
{
const D3DVERTEX *src = (D3DVERTEX *)((char *)buffer->desc.lpData + vs) + ci->wStart;
unsigned int vtx_idx;
static unsigned int once;
if (!once++)
FIXME("Lighting not implemented.\n");
for (vtx_idx = 0; vtx_idx < ci->dwCount; ++vtx_idx)
{
transform_vertex(&dst[vtx_idx], &mat, &viewport->viewports.vp1,
src[vtx_idx].u1.x, src[vtx_idx].u2.y, src[vtx_idx].u3.z);
/* No lighting yet */
dst[vtx_idx].u5.color = 0xffffffff; /* Opaque white */
dst[vtx_idx].u6.specular = 0xff000000; /* No specular and no fog factor */
dst[vtx_idx].u7.tu = src[vtx_idx].u7.tu;
dst[vtx_idx].u8.tv = src[vtx_idx].u8.tv;
}
break;
}
case D3DPROCESSVERTICES_TRANSFORM:
{
const D3DLVERTEX *src = (D3DLVERTEX *)((char *)buffer->desc.lpData + vs) + ci->wStart;
unsigned int vtx_idx;
for (vtx_idx = 0; vtx_idx < ci->dwCount; ++vtx_idx)
{
transform_vertex(&dst[vtx_idx], &mat, &viewport->viewports.vp1,
src[vtx_idx].u1.x, src[vtx_idx].u2.y, src[vtx_idx].u3.z);
dst[vtx_idx].u5.color = src[vtx_idx].u4.color;
dst[vtx_idx].u6.specular = src[vtx_idx].u5.specular;
dst[vtx_idx].u7.tu = src[vtx_idx].u6.tu;
dst[vtx_idx].u8.tv = src[vtx_idx].u7.tv;
}
break;
}
case D3DPROCESSVERTICES_COPY:
{
const D3DTLVERTEX *src = (D3DTLVERTEX *)((char *)buffer->desc.lpData + vs) + ci->wStart;
memcpy(dst, src, ci->dwCount * sizeof(*dst));
break;
}
default:
FIXME("Unhandled vertex processing op %#x.\n", op);
break;
}
instr += size;
}
break;
}
case D3DOP_TEXTURELOAD: {
WARN("TEXTURELOAD-s (%d)\n", count);
instr += count * size;
} break;
case D3DOP_EXIT: {
TRACE("EXIT (%d)\n", count);
/* We did this instruction */
instr += size;
/* Exit this loop */
goto end_of_buffer;
} break;
case D3DOP_BRANCHFORWARD:
TRACE("BRANCHFORWARD (%d)\n", count);
for (i = 0; i < count; ++i)
{
D3DBRANCH *ci = (D3DBRANCH *)instr;
if ((buffer->data.dsStatus.dwStatus & ci->dwMask) == ci->dwValue)
{
if (!ci->bNegate)
{
TRACE(" Branch to %d\n", ci->dwOffset);
if (ci->dwOffset) {
instr = (char*)current + ci->dwOffset;
break;
}
}
} else {
if (ci->bNegate) {
TRACE(" Branch to %d\n", ci->dwOffset);
if (ci->dwOffset) {
instr = (char*)current + ci->dwOffset;
break;
}
}
}
instr += size;
}
break;
case D3DOP_SPAN: {
WARN("SPAN-s (%d)\n", count);
instr += count * size;
} break;
case D3DOP_SETSTATUS:
TRACE("SETSTATUS (%d)\n", count);
for (i = 0; i < count; ++i)
{
buffer->data.dsStatus = *(D3DSTATUS *)instr;
instr += size;
}
break;
default:
ERR("Unhandled OpCode %d !!!\n",current->bOpcode);
/* Try to save ... */
instr += count * size;
break;
}
}
end_of_buffer:
return D3D_OK;
}
// O primeiro parâmetro é o tamanho do vetor, e o segundo é o número de threads.
int main(int argc, char *argv[]) {
if (argc!=3) {
printf("Número incorreto de parâmetros\n");
printf("Uso: ./<nome do programa> <ordem da matriz> <qtd. de threads>\n");
return 0;
}
int thread_quantity, sum, sum_thread=0, counter;
int offset=0, partition_size;
long int **matrix_copy;
int_tuple *offset_vector;
double time_main, time_thread;
// Um vetor de pthreads permite a criação dinâmica de threads.
pthread_t *thread_vector;
sscanf(argv[1],"%d",&matrix_size);
sscanf(argv[2],"%d",&thread_quantity);
printf("Criando dados para as matrizes... ");
thread_vector=(pthread_t*)malloc(sizeof(pthread_t)*thread_quantity);
offset_vector=(int_tuple*)malloc(sizeof(int_tuple)*thread_quantity);
partition_size=matrix_size/thread_quantity;
partition_size--;
for(counter=0; counter<thread_quantity-1; counter++) {
offset_vector[counter].start=offset;
offset=offset+partition_size;
offset_vector[counter].end=offset;
offset++;
}
offset_vector[thread_quantity-1].start=offset;
offset_vector[thread_quantity-1].end=matrix_size-1;
matrix_a=create_random_matrix();
matrix_b=create_random_matrix();
printf("feito.\n\n");
matrix_result=(long int**)malloc(sizeof(long int*)*matrix_size);
for(counter=0; counter<matrix_size; counter++)
matrix_result[counter]=(long int*)malloc(sizeof(long int)*matrix_size);
printf("Iniciando as contas na função main().\n");
set_start_time();
multiply_matrix();
set_end_time();
time_main=end_time-start_time;
printf("As contas na main() foram finalizadas.\n");
/* Aloca uma nova matriz para fazer uma cópia do resultado.
* Isso é feito para saber se a multiplicação está igual.
*/
matrix_copy=(long int**)malloc(sizeof(long int*)*matrix_size);
for(counter=0; counter<matrix_size; counter++)
matrix_copy[counter]=(long int*)malloc(sizeof(long int)*matrix_size);
for(counter=0; counter<matrix_size; counter++) {
for(offset=0; offset<matrix_size; offset++)
matrix_copy[counter][offset]=matrix_result[counter][offset];
}
printf("\nIniciando as contas com %d threads.\n",thread_quantity);
// Inicia as contas com as threads, assim como a marcação de tempo.
set_start_time();
for(counter=0; counter<thread_quantity; counter++)
pthread_create(thread_vector+counter,NULL,threaded_matrix_multiplier,(void*)(offset_vector+counter));
for(counter=0; counter<thread_quantity; counter++)
pthread_join(thread_vector[counter],NULL);
set_end_time();
time_thread=end_time-start_time;
printf("As threads foram finalizadas.\n\n");
check_matrix_match(matrix_copy);
printf("\n");
printf("Tempo na main(): %f segundos\n",time_main);
printf("Tempo com threads: %f segundos\n",time_thread);
//Libera tudo que foi alocado.
free(thread_vector);
free(offset_vector);
for(counter=0; counter<matrix_size; counter++) {
free(matrix_a[counter]);
free(matrix_b[counter]);
free(matrix_result[counter]);
free(matrix_copy[counter]);
}
free(matrix_a);
free(matrix_b);
free(matrix_result);
free(matrix_copy);
return 0;
}
static void draw_gl(Evas_Object *obj)
{
static int i=0;
appdata_s *ad = evas_object_data_get(obj, "ad");
float model[16], view[16];
float aspect;
if (!ad)
return;
init_matrix(model);
init_matrix(view);
aspect = (float) ad->glview_w / (float) ad->glview_h;
view_set_perspective(view, 60.0f, aspect, 1.0f, 20.0f);
translate_xyz(model, 0.0f, 0.0f, -2.5f);
rotate_xyz(model, ad->xangle, ad->yangle, 0.0f);
multiply_matrix(ad->mvp, view, model);
glViewport(0, 0, ad->glview_w, ad->glview_h);
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glVertexAttribPointer(ad->idx_position, 3, GL_FLOAT, GL_FALSE,
3 * sizeof(float), cube_vertices);
glVertexAttribPointer(ad->idx_color, 4, GL_FLOAT, GL_FALSE,
4 * sizeof(float), cube_colors);
glEnableVertexAttribArray(ad->idx_position);
glEnableVertexAttribArray(ad->idx_color);
glUniformMatrix4fv(ad->idx_mvp, 1, GL_FALSE, ad->mvp);
glDrawElements(GL_TRIANGLES, cube_indices_count, GL_UNSIGNED_SHORT,
cube_indices);
//3rd
glVertexAttribPointer(ad->idx_position, 3, GL_FLOAT, GL_FALSE,
3 * sizeof(float), cubeBFL_vertices);
glVertexAttribPointer(ad->idx_color, 4, GL_FLOAT, GL_FALSE,
4 * sizeof(float), cube_colors);
glEnableVertexAttribArray(ad->idx_position);
glEnableVertexAttribArray(ad->idx_color);
glUniformMatrix4fv(ad->idx_mvp, 1, GL_FALSE, ad->mvp);
//glRotatef(45,0,1,1);
i = (i+10)%360;
glDrawElements(GL_TRIANGLES, cubeBFL_indices_count, GL_UNSIGNED_SHORT,
cubeBFL_indices);
glFlush();
display_fps();
}
int main(void) {
multiply_matrix(10);
return 0;
}
