void ogl::mesh::cache_verts(const ogl::mesh *that, const mat4& M,
const mat4& I, int id)
{
const size_t n = that->vv.size();
// Cache that mesh's transformed vertices here. Update bounding volume.
vv.resize(n);
nv.resize(n);
tv.resize(n);
uv.resize(n);
bound = aabb();
for (size_t i = 0; i < n; ++i)
{
transform_vertex(vv[i].v, M, that->vv[i].v);
transform_normal(nv[i].v, transpose(I), that->nv[i].v);
transform_normal(tv[i].v, transpose(I), that->tv[i].v);
bound.merge(vec3(double(vv[i].v[0]),
double(vv[i].v[1]),
double(vv[i].v[2])));
// Handy trick: Store the unit ID in the texture coordinate.
uv[i].v[0] = that->uv[i].v[0];
uv[i].v[1] = that->uv[i].v[1];
uv[i].v[2] = GLfloat(id);
}
dirty_verts = true;
}
void transform_model(float *vtx, matrix mtx, int triangle_count)
{
int i;
i = 0;
while (i < triangle_count)
{
transform_vertex(vtx, mtx, i);
i += 3;
}
}
shared_str parse_vertex (luabind::object const &table, LPCSTR identifier, bool const &in)
{
return (
transform_vertex(
parse_string(
table,
identifier
),
in
)
);
}
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;
}
/*
* Draw a textured quad
*/
static void d3d_draw_textured_quad(
ALLEGRO_DISPLAY_D3D *disp, ALLEGRO_BITMAP_D3D *bmp, ALLEGRO_COLOR tint,
float sx, float sy, float sw, float sh, int flags)
{
float right;
float bottom;
float tu_start;
float tv_start;
float tu_end;
float tv_end;
int texture_w;
int texture_h;
DWORD d3d_color;
const float z = 0.0f;
ALLEGRO_DISPLAY* aldisp = (ALLEGRO_DISPLAY*)disp;
if (aldisp->num_cache_vertices != 0 && (uintptr_t)bmp != aldisp->cache_texture) {
aldisp->vt->flush_vertex_cache(aldisp);
}
aldisp->cache_texture = (uintptr_t)bmp;
D3D_TL_VERTEX* vertices = (D3D_TL_VERTEX*)aldisp->vt->prepare_vertex_cache(aldisp, 6);
right = sw;
bottom = sh;
texture_w = bmp->texture_w;
texture_h = bmp->texture_h;
tu_start = sx / texture_w;
tv_start = sy / texture_h;
tu_end = sw / texture_w + tu_start;
tv_end = sh / texture_h + tv_start;
if (flags & ALLEGRO_FLIP_HORIZONTAL) {
float temp = tu_start;
tu_start = tu_end;
tu_end = temp;
}
if (flags & ALLEGRO_FLIP_VERTICAL) {
float temp = tv_start;
tv_start = tv_end;
tv_end = temp;
}
d3d_color = D3DCOLOR_COLORVALUE(tint.r, tint.g, tint.b, tint.a);
vertices[0].x = 0;
vertices[0].y = 0;
vertices[0].z = z;
vertices[0].diffuse = d3d_color;
vertices[0].tu = tu_start;
vertices[0].tv = tv_start;
vertices[1].x = right;
vertices[1].y = 0;
vertices[1].z = z;
vertices[1].diffuse = d3d_color;
vertices[1].tu = tu_end;
vertices[1].tv = tv_start;
vertices[2].x = right;
vertices[2].y = bottom;
vertices[2].z = z;
vertices[2].diffuse = d3d_color;
vertices[2].tu = tu_end;
vertices[2].tv = tv_end;
vertices[5].x = 0;
vertices[5].y = bottom;
vertices[5].z = z;
vertices[5].diffuse = d3d_color;
vertices[5].tu = tu_start;
vertices[5].tv = tv_end;
if (aldisp->cache_enabled) {
transform_vertex(&vertices[0].x, &vertices[0].y);
transform_vertex(&vertices[1].x, &vertices[1].y);
transform_vertex(&vertices[2].x, &vertices[2].y);
transform_vertex(&vertices[5].x, &vertices[5].y);
}
vertices[3] = vertices[0];
vertices[4] = vertices[2];
if(!aldisp->cache_enabled)
aldisp->vt->flush_vertex_cache(aldisp);
}
void ram(void) {
int i;
frame = 0;
struct vertex2d projected[NUM_VERTICES];
float matrix_projection[16];
init_matrix_projection_fov(matrix_projection, DEG2RAD(2), 0.1, 50, 1);
while (true) {
lcdFill(COLOR_BACKGROUND);
float mat_a[16];
float mat_b[16];
float mat_c[16];
float matrix_worldviewprojection[16];
init_vertices(vertices);
// Calculate worldviewprojection matrix by concatenating the
// following operations:
// - rotate y axis
// - rotate x axis
// - translate
// - project
float rad = (float)frame * 0.015f;
init_matrix_rotation_y(mat_a, rad);
init_matrix_rotation_x(mat_b, -rad*0.8);
matrix_multiplication(mat_a, mat_b, mat_c);
init_matrix_translation(mat_a, 0, -2, 11.5f);
matrix_multiplication(mat_c, mat_a, mat_b);
matrix_multiplication(mat_b, matrix_projection, matrix_worldviewprojection);
// Transform vertices
for (i=0; i<NUM_VERTICES; i++) {
struct vertex transformed;
transform_vertex(&vertices[i], &transformed, matrix_worldviewprojection);
if (transformed.w > -0.0001)
projected[i].x = VERTEX_BEHIND_CAMERA;
else {
projected[i].x = (int)(transformed.x / transformed.w) + SCREEN_WIDTH / 2;
projected[i].y = (int)(transformed.y / transformed.w) + SCREEN_HEIGHT / 2;
}
}
// Draw line grid
struct vertex2d from, to;
for (int x=0; x<TESSELATION; x++)
for (int y=0; y<TESSELATION; y++)
{
if (x < (TESSELATION - 1)) {
from = projected[x + y * TESSELATION];
to = projected[x + y * TESSELATION + 1];
line(from.x, from.y, to.x, to.y, COLOR_LINE);
}
if (y < (TESSELATION - 1)) {
from = projected[x + y * TESSELATION];
to = projected[x + y * TESSELATION + TESSELATION];
line(from.x, from.y, to.x, to.y, COLOR_LINE);
}
}
lcdDisplay();
rad += 0.015;
frame++;
int key = getInputRaw();
if (key == BTN_ENTER)
break;
}
}
void GLWidget::zoomTo(int toothNum)
{
if (toothNum > 0 && toothNum <= N_TEETH)
{
context->makeCurrent();
glLoadIdentity();
glTranslatef(tx, ty - Rb*zoom, 0);
glScalef(zoom, zoom, zoom);
glRotatef(-ry, 1.0f, 0.0f, 0.0f);
glRotatef(rx, 0.0f, 1.0f, 0.0f);
glMultMatrixf(rotAccum);
glRotatef((toothNum-1) * 360.0f / N_TEETH, 0.0f, 0.0f, 1.0f);
// ---
glPushMatrix();
glRotatef(Radians2Degrees(PSI), 0.0f, 0.0f, 1.0f);
GLdouble mm1[16];
glGetDoublev(GL_MODELVIEW_MATRIX, mm1);
glPopMatrix();
// ----
glPushMatrix();
glRotatef(Radians2Degrees(-PSI), 0.0f, 0.0f, 1.0f);
GLdouble mm2[16];
glGetDoublev(GL_MODELVIEW_MATRIX, mm2);
glPopMatrix();
// ----
Vertex3D v1 = R_EVOL_IJ(0, 0);
Vertex3D v2 = R_EVOL_IJ(0, PHI1_STEPS-1);
Vertex3D v3 = L_EVOL_IJ(0, 0);
Vertex3D v4 = L_EVOL_IJ(0, PHI1_STEPS-1);
Vertex3D v1t, v2t, v3t, v4t;
transform_vertex(v1, mm1, v1t);
transform_vertex(v2, mm1, v2t);
transform_vertex(v3, mm2, v3t);
transform_vertex(v4, mm2, v4t);
float r1 = sqrtf((v1t.x - v4t.x) * (v1t.x - v4t.x) + (v1t.y - v4t.y) * (v1t.y - v4t.y)/* + (v1t.z - v4t.z) * (v1t.z - v4t.z)*/);
float r2 = sqrtf((v2t.x - v3t.x) * (v2t.x - v3t.x) + (v2t.y - v3t.y) * (v2t.y - v3t.y)/* + (v2t.z - v3t.z) * (v2t.z - v3t.z)*/);
float diam = (r1 > r2) ? r1 : r2;
float cx = (v2t.x + v3t.x) / 2;
float cy = (v2t.y + v3t.y) / 2;
GLdouble left = cx - diam;
GLdouble right = cx + diam;
GLdouble bottom = cy - diam;
GLdouble top = cy + diam;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(left, right, bottom, top, -1000, 1000);
glMatrixMode(GL_MODELVIEW);
updateGL();
}
}
