381 lines
11 KiB
C++
381 lines
11 KiB
C++
|
/******************************Module*Header*******************************\
|
||
|
|
* Module Name: genexpld.c
|
||
|
|
*
|
||
|
|
* The Explode style of the 3D Flying Objects screen saver.
|
||
|
|
*
|
||
|
|
* Simulation of a sphere that occasionally explodes.
|
||
|
|
*
|
||
|
|
* Copyright (c) 1994 Microsoft Corporation
|
||
|
|
*
|
||
|
|
\**************************************************************************/
|
||
|
|
|
||
|
|
#include <windows.h>
|
||
|
|
#include <math.h>
|
||
|
|
#include <d3dx8.h>
|
||
|
|
#include "D3DSaver.h"
|
||
|
|
#include "FlyingObjects.h"
|
||
|
|
#include "mesh.h"
|
||
|
|
|
||
|
|
#define RADIUS 0.3
|
||
|
|
#define STEPS 30
|
||
|
|
#define MAXPREC 20
|
||
|
|
|
||
|
|
static MATRIX *faceMat;
|
||
|
|
static float *xstep;
|
||
|
|
static float *ystep;
|
||
|
|
static float *zstep;
|
||
|
|
static float *xrot;
|
||
|
|
static float *yrot;
|
||
|
|
static float *zrot;
|
||
|
|
static MESH explodeMesh;
|
||
|
|
static int iPrec = 10;
|
||
|
|
|
||
|
|
// Data type accepted by glInterleavedArrays
|
||
|
|
typedef struct _POINT_N3F_V3F {
|
||
|
|
POINT3D normal;
|
||
|
|
POINT3D vertex;
|
||
|
|
} POINT_N3F_V3F;
|
||
|
|
|
||
|
|
static POINT_N3F_V3F *pN3V3;
|
||
|
|
|
||
|
|
static FLOAT matl1Diffuse[] = {1.0f, 0.8f, 0.0f, 1.0f};
|
||
|
|
static FLOAT matl2Diffuse[] = {0.8f, 0.8f, 0.8f, 1.0f};
|
||
|
|
static FLOAT matlSpecular[] = {1.0f, 1.0f, 1.0f, 1.0f};
|
||
|
|
static FLOAT light0Pos[] = {100.0f, 100.0f, 100.0f, 0.0f};
|
||
|
|
|
||
|
|
void genExplode()
|
||
|
|
{
|
||
|
|
int i;
|
||
|
|
POINT3D circle[MAXPREC+1];
|
||
|
|
double angle;
|
||
|
|
double step = -PI / (float)(iPrec - 1);
|
||
|
|
double start = PI / 2.0;
|
||
|
|
|
||
|
|
for (i = 0, angle = start; i < iPrec; i++, angle += step) {
|
||
|
|
circle[i].x = (float) (RADIUS * cos(angle));
|
||
|
|
circle[i].y = (float) (RADIUS * sin(angle));
|
||
|
|
circle[i].z = 0.0f;
|
||
|
|
}
|
||
|
|
|
||
|
|
revolveSurface(&explodeMesh, circle, iPrec);
|
||
|
|
|
||
|
|
for (i = 0; i < explodeMesh.numFaces; i++) {
|
||
|
|
ss_matrixIdent(&faceMat[i]);
|
||
|
|
xstep[i] = (float)(((float)(rand() & 0x3) * PI) / ((float)STEPS + 1.0));
|
||
|
|
ystep[i] = (float)(((float)(rand() & 0x3) * PI) / ((float)STEPS + 1.0));
|
||
|
|
zstep[i] = (float)(((float)(rand() & 0x3) * PI) / ((float)STEPS + 1.0));
|
||
|
|
xrot[i] = 0.0f;
|
||
|
|
yrot[i] = 0.0f;
|
||
|
|
zrot[i] = 0.0f;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOL initExplodeScene()
|
||
|
|
{
|
||
|
|
iPrec = (int)(fTesselFact * 10.5);
|
||
|
|
if (iPrec < 5)
|
||
|
|
iPrec = 5;
|
||
|
|
if (iPrec > MAXPREC)
|
||
|
|
iPrec = MAXPREC;
|
||
|
|
|
||
|
|
faceMat = (MATRIX *)SaverAlloc((iPrec * iPrec) *
|
||
|
|
(4 * 4 * sizeof(float)));
|
||
|
|
if( faceMat == NULL )
|
||
|
|
return FALSE;
|
||
|
|
|
||
|
|
xstep = (float*)SaverAlloc(iPrec * iPrec * sizeof(float));
|
||
|
|
if( xstep == NULL )
|
||
|
|
return FALSE;
|
||
|
|
|
||
|
|
ystep = (float*)SaverAlloc(iPrec * iPrec * sizeof(float));
|
||
|
|
if( ystep == NULL )
|
||
|
|
return FALSE;
|
||
|
|
|
||
|
|
zstep = (float*)SaverAlloc(iPrec * iPrec * sizeof(float));
|
||
|
|
if( zstep == NULL )
|
||
|
|
return FALSE;
|
||
|
|
|
||
|
|
xrot = (float*)SaverAlloc(iPrec * iPrec * sizeof(float));
|
||
|
|
if( xrot == NULL )
|
||
|
|
return FALSE;
|
||
|
|
|
||
|
|
yrot = (float*)SaverAlloc(iPrec * iPrec * sizeof(float));
|
||
|
|
if( yrot == NULL )
|
||
|
|
return FALSE;
|
||
|
|
|
||
|
|
zrot = (float*)SaverAlloc(iPrec * iPrec * sizeof(float));
|
||
|
|
if( zrot == NULL )
|
||
|
|
return FALSE;
|
||
|
|
|
||
|
|
|
||
|
|
genExplode();
|
||
|
|
|
||
|
|
/*
|
||
|
|
// Find out the OpenGL version that we are running on.
|
||
|
|
bOpenGL11 = ss_fOnGL11();
|
||
|
|
*/
|
||
|
|
|
||
|
|
// Setup the data arrays.
|
||
|
|
pN3V3 = (POINT_N3F_V3F*)SaverAlloc(explodeMesh.numFaces * 4 * sizeof(POINT_N3F_V3F));
|
||
|
|
/*
|
||
|
|
// If we are running on OpenGL 1.1, use the new vertex array functions.
|
||
|
|
if (bOpenGL11) {
|
||
|
|
glInterleavedArrays(GL_N3F_V3F, 0, pN3V3);
|
||
|
|
}
|
||
|
|
*/
|
||
|
|
|
||
|
|
myglMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, matl1Diffuse);
|
||
|
|
myglMaterialfv(GL_FRONT, GL_SPECULAR, matlSpecular);
|
||
|
|
myglMaterialf(GL_FRONT, GL_SHININESS, 100.0f);
|
||
|
|
/*
|
||
|
|
glMaterialfv(GL_BACK, GL_AMBIENT_AND_DIFFUSE, matl2Diffuse);
|
||
|
|
glMaterialfv(GL_BACK, GL_SPECULAR, matlSpecular);
|
||
|
|
glMaterialf(GL_BACK, GL_SHININESS, 60.0f);
|
||
|
|
*/
|
||
|
|
|
||
|
|
/*
|
||
|
|
D3DXMATRIX matProj;
|
||
|
|
D3DXMatrixPerspectiveLH( &matProj, 0.66f, 0.66f, 0.3f, 3.0f );
|
||
|
|
m_pd3dDevice->SetTransform( D3DTS_PROJECTION, &matProj );
|
||
|
|
*/
|
||
|
|
SetProjectionMatrixInfo( FALSE, 0.66f, 0.66f, 0.3f, 3.0f );
|
||
|
|
|
||
|
|
D3DXMATRIX matView;
|
||
|
|
D3DXVECTOR3 vUpVec( 0.0f, 1.0f, 0.0f );
|
||
|
|
D3DXVECTOR3 vEyePt(0, 0, 1.5f);
|
||
|
|
D3DXVECTOR3 vLookatPt(0, 0, 0);
|
||
|
|
D3DXMatrixLookAtLH( &matView, &vEyePt, &vLookatPt, &vUpVec );
|
||
|
|
m_pd3dDevice->SetTransform( D3DTS_VIEW, &matView );
|
||
|
|
|
||
|
|
m_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void delExplodeScene()
|
||
|
|
{
|
||
|
|
delMesh(&explodeMesh);
|
||
|
|
|
||
|
|
SaverFree(faceMat);
|
||
|
|
SaverFree(xstep);
|
||
|
|
SaverFree(ystep);
|
||
|
|
SaverFree(zstep);
|
||
|
|
SaverFree(xrot);
|
||
|
|
SaverFree(yrot);
|
||
|
|
SaverFree(zrot);
|
||
|
|
SaverFree(pN3V3);
|
||
|
|
}
|
||
|
|
|
||
|
|
void updateExplodeScene(int flags, FLOAT fElapsedTime)
|
||
|
|
{
|
||
|
|
static float maxR;
|
||
|
|
static float r = 0.0f;
|
||
|
|
static float rChange = 0.0f;
|
||
|
|
static float rChangePrev = 1.0f;
|
||
|
|
static float rotZ = 0.0f;
|
||
|
|
static int count = 0;
|
||
|
|
static float fCount = 0.0f;
|
||
|
|
static int direction = 1;
|
||
|
|
static FLOAT fRestCount = 0.0f;
|
||
|
|
static float lightSpin = 0.0f;
|
||
|
|
static float spinDelta = 5.0f;
|
||
|
|
static FLOAT fH = 0.0f;
|
||
|
|
static RGBA color;
|
||
|
|
if( fElapsedTime > 0.25f )
|
||
|
|
fElapsedTime = 0.25f;
|
||
|
|
FLOAT fTimeFactor = fElapsedTime * 20.0f;
|
||
|
|
int i;
|
||
|
|
MFACE *faces;
|
||
|
|
POINT_N3F_V3F *pn3v3;
|
||
|
|
D3DXMATRIX mat1, mat2, mat3, mat4, mat5, matFinal;
|
||
|
|
static FLOAT fTimer = 0.0f;
|
||
|
|
/*
|
||
|
|
// Only update 50x per second
|
||
|
|
fTimer += fElapsedTime;
|
||
|
|
if( fTimer < 1.0f/50.0f )
|
||
|
|
return;
|
||
|
|
fTimer = 0.0f;
|
||
|
|
*/
|
||
|
|
if (bColorCycle || fH == 0.0f)
|
||
|
|
{
|
||
|
|
ss_HsvToRgb(fH, 1.0f, 1.0f, &color);
|
||
|
|
|
||
|
|
myglMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, (FLOAT *) &color);
|
||
|
|
fH += fTimeFactor;
|
||
|
|
if( fH >= 360.0f )
|
||
|
|
fH -= 360.0f;
|
||
|
|
}
|
||
|
|
/*
|
||
|
|
glMatrixMode(GL_MODELVIEW);
|
||
|
|
glPushMatrix();
|
||
|
|
glRotatef(-lightSpin, 0.0f, 1.0f, 0.0f);
|
||
|
|
glLightfv(GL_LIGHT0, GL_POSITION, light0Pos);
|
||
|
|
|
||
|
|
lightSpin += spinDelta * fTimeFactor;
|
||
|
|
if ((lightSpin > 90.0) || (lightSpin < 0.0))
|
||
|
|
spinDelta = -spinDelta;
|
||
|
|
*/
|
||
|
|
/*
|
||
|
|
glPopMatrix();
|
||
|
|
|
||
|
|
if (!bOpenGL11) {
|
||
|
|
glBegin(GL_QUADS);
|
||
|
|
}
|
||
|
|
*/
|
||
|
|
for(
|
||
|
|
i = 0, faces = explodeMesh.faces, pn3v3 = pN3V3;
|
||
|
|
i < explodeMesh.numFaces;
|
||
|
|
i++, faces++, pn3v3 += 4
|
||
|
|
)
|
||
|
|
{
|
||
|
|
int a, b, c, d;
|
||
|
|
int j;
|
||
|
|
POINT3D vector;
|
||
|
|
|
||
|
|
ss_matrixIdent(&faceMat[i]);
|
||
|
|
ss_matrixRotate(&faceMat[i], xrot[i], yrot[i], zrot[i]);
|
||
|
|
|
||
|
|
if (fRestCount > 0.0f)
|
||
|
|
;
|
||
|
|
else {
|
||
|
|
xrot[i] += (xstep[i]) * fTimeFactor;
|
||
|
|
yrot[i] += (ystep[i]) * fTimeFactor;
|
||
|
|
zrot[i] += (zstep[i]) * fTimeFactor;
|
||
|
|
}
|
||
|
|
|
||
|
|
a = faces->p[0];
|
||
|
|
b = faces->p[1];
|
||
|
|
c = faces->p[3];
|
||
|
|
d = faces->p[2];
|
||
|
|
|
||
|
|
memcpy(&pn3v3[0].vertex, (explodeMesh.pts + a), sizeof(POINT3D));
|
||
|
|
memcpy(&pn3v3[1].vertex, (explodeMesh.pts + b), sizeof(POINT3D));
|
||
|
|
memcpy(&pn3v3[2].vertex, (explodeMesh.pts + c), sizeof(POINT3D));
|
||
|
|
memcpy(&pn3v3[3].vertex, (explodeMesh.pts + d), sizeof(POINT3D));
|
||
|
|
|
||
|
|
vector.x = pn3v3[0].vertex.x;
|
||
|
|
vector.y = pn3v3[0].vertex.y;
|
||
|
|
vector.z = pn3v3[0].vertex.z;
|
||
|
|
|
||
|
|
for (j = 0; j < 4; j++) {
|
||
|
|
pn3v3[j].vertex.x -= vector.x;
|
||
|
|
pn3v3[j].vertex.y -= vector.y;
|
||
|
|
pn3v3[j].vertex.z -= vector.z;
|
||
|
|
ss_xformPoint((POINT3D *)&pn3v3[j].vertex, (POINT3D *)&pn3v3[j].vertex, &faceMat[i]);
|
||
|
|
pn3v3[j].vertex.x += vector.x + (vector.x * r);
|
||
|
|
pn3v3[j].vertex.y += vector.y + (vector.y * r);
|
||
|
|
pn3v3[j].vertex.z += vector.z + (vector.z * r);
|
||
|
|
}
|
||
|
|
if (bSmoothShading) {
|
||
|
|
memcpy(&pn3v3[0].normal, (explodeMesh.norms + a), sizeof(POINT3D));
|
||
|
|
memcpy(&pn3v3[1].normal, (explodeMesh.norms + b), sizeof(POINT3D));
|
||
|
|
memcpy(&pn3v3[2].normal, (explodeMesh.norms + c), sizeof(POINT3D));
|
||
|
|
memcpy(&pn3v3[3].normal, (explodeMesh.norms + d), sizeof(POINT3D));
|
||
|
|
|
||
|
|
for (j = 0; j < 4; j++)
|
||
|
|
ss_xformNorm((POINT3D *)&pn3v3[j].normal, (POINT3D *)&pn3v3[j].normal, &faceMat[i]);
|
||
|
|
} else {
|
||
|
|
memcpy(&pn3v3[0].normal, &faces->norm, sizeof(POINT3D));
|
||
|
|
ss_xformNorm((POINT3D *)&pn3v3[0].normal, (POINT3D *)&pn3v3[0].normal, &faceMat[i]);
|
||
|
|
memcpy(&pn3v3[1].normal, &pn3v3[0].normal, sizeof(POINT3D));
|
||
|
|
memcpy(&pn3v3[2].normal, &pn3v3[0].normal, sizeof(POINT3D));
|
||
|
|
memcpy(&pn3v3[3].normal, &pn3v3[0].normal, sizeof(POINT3D));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
{
|
||
|
|
m_pd3dDevice->SetVertexShader( D3DFVF_MYVERTEX );
|
||
|
|
static WORD s_indexArray[5000];
|
||
|
|
static MYVERTEX s_vertexArray[5000];
|
||
|
|
INT numPrims = 0;
|
||
|
|
INT numIndices = 0;
|
||
|
|
INT numVertices = 0;
|
||
|
|
WORD iVertexA, iVertexB, iVertexC, iVertexD;
|
||
|
|
INT a,b,c,d;
|
||
|
|
HRESULT hr;
|
||
|
|
|
||
|
|
for( int iFace = 0; iFace < explodeMesh.numFaces; iFace++ )
|
||
|
|
{
|
||
|
|
a = iFace * 4 + 0;
|
||
|
|
b = iFace * 4 + 1;
|
||
|
|
c = iFace * 4 + 2;
|
||
|
|
d = iFace * 4 + 3;
|
||
|
|
|
||
|
|
s_vertexArray[numVertices].p = pN3V3[a].vertex;
|
||
|
|
s_vertexArray[numVertices].n = pN3V3[a].normal;
|
||
|
|
iVertexA = numVertices++;
|
||
|
|
s_vertexArray[numVertices].p = pN3V3[b].vertex;
|
||
|
|
s_vertexArray[numVertices].n = pN3V3[b].normal;
|
||
|
|
iVertexB = numVertices++;
|
||
|
|
s_vertexArray[numVertices].p = pN3V3[c].vertex;
|
||
|
|
s_vertexArray[numVertices].n = pN3V3[c].normal;
|
||
|
|
iVertexC = numVertices++;
|
||
|
|
s_vertexArray[numVertices].p = pN3V3[d].vertex;
|
||
|
|
s_vertexArray[numVertices].n = pN3V3[d].normal;
|
||
|
|
iVertexD = numVertices++;
|
||
|
|
|
||
|
|
s_indexArray[numIndices++] = iVertexA;
|
||
|
|
s_indexArray[numIndices++] = iVertexB;
|
||
|
|
s_indexArray[numIndices++] = iVertexC;
|
||
|
|
numPrims++;
|
||
|
|
s_indexArray[numIndices++] = iVertexA;
|
||
|
|
s_indexArray[numIndices++] = iVertexC;
|
||
|
|
s_indexArray[numIndices++] = iVertexD;
|
||
|
|
numPrims++;
|
||
|
|
}
|
||
|
|
hr = m_pd3dDevice->DrawIndexedPrimitiveUP( D3DPT_TRIANGLELIST, 0, numVertices,
|
||
|
|
numPrims, s_indexArray, D3DFMT_INDEX16, s_vertexArray, sizeof(MYVERTEX) );
|
||
|
|
}
|
||
|
|
/*
|
||
|
|
if (bOpenGL11) {
|
||
|
|
glDrawArrays(GL_QUADS, 0, explodeMesh.numFaces * 4);
|
||
|
|
} else {
|
||
|
|
glEnd();
|
||
|
|
}
|
||
|
|
*/
|
||
|
|
if (fRestCount > 0.0f) {
|
||
|
|
fRestCount -= fTimeFactor;
|
||
|
|
goto resting;
|
||
|
|
}
|
||
|
|
|
||
|
|
rChange += fTimeFactor;
|
||
|
|
while( (INT)rChangePrev < (INT)rChange )
|
||
|
|
{
|
||
|
|
rChangePrev += 1.0;
|
||
|
|
if (direction) {
|
||
|
|
maxR = r;
|
||
|
|
r += (float) (0.3 * pow((double)(STEPS - count) / (double)STEPS, 4.0));
|
||
|
|
} else {
|
||
|
|
r -= (float) (maxR / (double)(STEPS));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fCount += fTimeFactor;
|
||
|
|
count = (INT)fCount;
|
||
|
|
if (count > STEPS) {
|
||
|
|
direction ^= 1;
|
||
|
|
count = 0;
|
||
|
|
fCount = 0.0f;
|
||
|
|
|
||
|
|
if (direction == 1) {
|
||
|
|
fRestCount = 10.0f;
|
||
|
|
r = 0.0f;
|
||
|
|
rChange = 0.0f;
|
||
|
|
rChangePrev = 1.0f;
|
||
|
|
|
||
|
|
for (i = 0; i < explodeMesh.numFaces; i++) {
|
||
|
|
ss_matrixIdent(&faceMat[i]);
|
||
|
|
xstep[i] = (float) (((float)(rand() & 0x3) * PI) / ((float)STEPS + 1.0));
|
||
|
|
ystep[i] = (float) (((float)(rand() & 0x3) * PI) / ((float)STEPS + 1.0));
|
||
|
|
zstep[i] = (float) (((float)(rand() & 0x3) * PI) / ((float)STEPS + 1.0));
|
||
|
|
|
||
|
|
xrot[i] = 0.0f;
|
||
|
|
yrot[i] = 0.0f;
|
||
|
|
zrot[i] = 0.0f;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
resting:
|
||
|
|
;
|
||
|
|
}
|