Matrix4x4<Real> LookAtMatrix (const Vector3<Real> &camPos,
const Vector3<Real> &target,
const Vector3<Real> &camUp)
{
Matrix4x4<Real> rot, trans;
Vector3<Real> forward (camPos - target);
forward.normalize ();
Vector3<Real> right (CrossProduct (camUp, forward));
Vector3<Real> up (CrossProduct (forward, right));
right.normalize ();
up.normalize ();
rot._m11 = right._x;
rot._m21 = right._y;
rot._m31 = right._z;
rot._m12 = up._x;
rot._m22 = up._y;
rot._m32 = up._z;
rot._m13 = forward._x;
rot._m23 = forward._y;
rot._m33 = forward._z;
rot._tx = 0.0;
rot._ty = 0.0;
rot._tz = 0.0;
trans = TranslationMatrix (-camPos);
return (rot * trans);
}
/*
=============
R_SetupMatrix
=============
*/
void R_SetupMatrix (void)
{
GL_Viewport(glx + r_refdef.vrect.x,
gly + glheight - r_refdef.vrect.y - r_refdef.vrect.height,
r_refdef.vrect.width,
r_refdef.vrect.height);
// Projection matrix
GL_FrustumMatrix(vulkan_globals.projection_matrix, DEG2RAD(r_fovx), DEG2RAD(r_fovy));
// View matrix
float rotation_matrix[16];
RotationMatrix(vulkan_globals.view_matrix, -M_PI / 2.0f, 1.0f, 0.0f, 0.0f);
RotationMatrix(rotation_matrix, M_PI / 2.0f, 0.0f, 0.0f, 1.0f);
MatrixMultiply(vulkan_globals.view_matrix, rotation_matrix);
RotationMatrix(rotation_matrix, DEG2RAD(-r_refdef.viewangles[2]), 1.0f, 0.0f, 0.0f);
MatrixMultiply(vulkan_globals.view_matrix, rotation_matrix);
RotationMatrix(rotation_matrix, DEG2RAD(-r_refdef.viewangles[0]), 0.0f, 1.0f, 0.0f);
MatrixMultiply(vulkan_globals.view_matrix, rotation_matrix);
RotationMatrix(rotation_matrix, DEG2RAD(-r_refdef.viewangles[1]), 0.0f, 0.0f, 1.0f);
MatrixMultiply(vulkan_globals.view_matrix, rotation_matrix);
float translation_matrix[16];
TranslationMatrix(translation_matrix, -r_refdef.vieworg[0], -r_refdef.vieworg[1], -r_refdef.vieworg[2]);
MatrixMultiply(vulkan_globals.view_matrix, translation_matrix);
// View projection matrix
memcpy(vulkan_globals.view_projection_matrix, vulkan_globals.projection_matrix, 16 * sizeof(float));
MatrixMultiply(vulkan_globals.view_projection_matrix, vulkan_globals.view_matrix);
vkCmdPushConstants(vulkan_globals.command_buffer, vulkan_globals.basic_pipeline_layout, VK_SHADER_STAGE_ALL_GRAPHICS, 0, 16 * sizeof(float), vulkan_globals.view_projection_matrix);
}
const bool Test_Matrix_TranslationMatrix()
{
const TVector3d kTranslate_d{1.0, 2.0, 3.0};
const TMatrix4d kTranslationMatrix_d = TranslationMatrix(TMatrix4d(), kTranslate_d);
const TVector4d kTranslatedPointA_d = VectorMultiply(TVector4d(), kTranslationMatrix_d, TVector4d{0.0, 0.0, 0.0, 1.0});
const TVector3d kTranslatedPointB_d{kTranslatedPointA_d.m_dX, kTranslatedPointA_d.m_dY, kTranslatedPointA_d.m_dZ};
const bool kbPass_d = Equal(kTranslate_d, kTranslatedPointB_d, s_kdEpsilon);
const TVector3f kTranslate_f{1.0f, 2.0f, 3.0f};
const TMatrix4f kTranslationMatrix_f = TranslationMatrix(TMatrix4f(), kTranslate_f);
const TVector4f kTranslatedPointA_f = VectorMultiply(TVector4f(), kTranslationMatrix_f, TVector4f{0.0f, 0.0f, 0.0f, 1.0f});
const TVector3f kTranslatedPointB_f{kTranslatedPointA_f.m_fX, kTranslatedPointA_f.m_fY, kTranslatedPointA_f.m_fZ};
const bool kbPass_f = Equal(kTranslate_f, kTranslatedPointB_f, s_kfEpsilon);
return(kbPass_d && kbPass_f);
}
const bool Test_Matrix_TransformationMatrix()
{
const TVector3d kTranslate_d{1.0, 2.0, 3.0};
const TVector3d kAxis_d = Normalize(TVector3d(), TVector3d{1.0, 1.0, 1.0});
const double kdAngle = s_kdTau / 8.0;
const TVector4d kQuatOrient_d = AxisAngleQuaternion(TVector4d(), kAxis_d, kdAngle);
const double kdScale = 2.0;
const TMatrix4d kTranslation_d = TranslationMatrix(TMatrix4d(), kTranslate_d);
const TMatrix4d kOrientation_d = RotationMatrix(TMatrix4d(), kQuatOrient_d);
const TMatrix4d kScaling_d = ScalingMatrix(TMatrix4d(), kdScale, kdScale, kdScale);
const TMatrix4d kTransformA_d = Multiply(TMatrix4d(), kScaling_d, kOrientation_d);
const TMatrix4d kTransformB_d = Multiply(TMatrix4d(), kTranslation_d, kTransformA_d);
const TVector3d kBasisX_d = QuaternionRotate(TVector3d(), TVector3d{kdScale, 0.0, 0.0}, kQuatOrient_d);
const TVector3d kBasisY_d = QuaternionRotate(TVector3d(), TVector3d{0.0, kdScale, 0.0}, kQuatOrient_d);
const TVector3d kBasisZ_d = QuaternionRotate(TVector3d(), TVector3d{0.0, 0.0, kdScale}, kQuatOrient_d);
const TMatrix4d kTransformC_d = TransformationMatrix(TMatrix4d(), kBasisX_d, kBasisY_d, kBasisZ_d, kTranslate_d);
const bool kbPass_d = Equal(kTransformC_d, kTransformB_d, s_kdEpsilon);
//
const TVector3f kTranslate_f{1.0f, 2.0f, 3.0f};
const TVector3f kAxis_f = Normalize(TVector3f(), TVector3f{1.0f, 1.0f, 1.0f});
const float kfAngle = s_kfTau / 8.0f;
const TVector4f kQuatOrient_f = AxisAngleQuaternion(TVector4f(), kAxis_f, kfAngle);
const float kfScale = 2.0f;
const TMatrix4f kTranslation_f = TranslationMatrix(TMatrix4f(), kTranslate_f);
const TMatrix4f kOrientation_f = RotationMatrix(TMatrix4f(), kQuatOrient_f);
const TMatrix4f kScaling_f = ScalingMatrix(TMatrix4f(), kfScale, kfScale, kfScale);
const TMatrix4f kTransformA_f = Multiply(TMatrix4f(), kScaling_f, kOrientation_f);
const TMatrix4f kTransformB_f = Multiply(TMatrix4f(), kTranslation_f, kTransformA_f);
const TVector3f kBasisX_f = QuaternionRotate(TVector3f(), TVector3f{kfScale, 0.0f, 0.0f}, kQuatOrient_f);
const TVector3f kBasisY_f = QuaternionRotate(TVector3f(), TVector3f{0.0f, kfScale, 0.0f}, kQuatOrient_f);
const TVector3f kBasisZ_f = QuaternionRotate(TVector3f(), TVector3f{0.0f, 0.0f, kfScale}, kQuatOrient_f);
const TMatrix4f kTransformC_f = TransformationMatrix(TMatrix4f(), kBasisX_f, kBasisY_f, kBasisZ_f, kTranslate_f);
const bool kbPass_f = Equal(kTransformC_f, kTransformB_f, s_kfEpsilon);
return(kbPass_d && kbPass_f);
}
int APIENTRY _tWinMain(HINSTANCE hInstance,
HINSTANCE,
LPTSTR,
int nCmdShow)
{
{ // code block
Helper::Window mainWindow( hInstance, nCmdShow, &WndProc,
L"Skinning", L"skinning", 4 );
D3DPRESENT_PARAMETERS params;
ZeroMemory( ¶ms, sizeof( params ) );
params.Windowed = TRUE;
params.SwapEffect = D3DSWAPEFFECT_DISCARD;
params.BackBufferFormat = D3DFMT_UNKNOWN;
params.EnableAutoDepthStencil = TRUE;
params.AutoDepthStencilFormat = D3DFMT_D16;
params.MultiSampleType = D3DMULTISAMPLE_NONE;
D3D::GraphicDevice graphicDevice( mainWindow.GetHWND(), params );
graphicDevice.SetRenderState( D3DRS_FILLMODE, D3DFILL_WIREFRAME );
graphicDevice.SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
Helper::SpectatorCoords spectatorCoords( 40.0f, D3DX_PI / 2, -D3DX_PI / 2 );
Cylinder cylinder(nPointsPerCircle, nPointsPerGeneratrix, Height, Radius, graphicDevice, Freq, MaxAngle);
cylinder.SetPositionMatrix( RotateZMatrix(D3DX_PI/2)*TranslationMatrix(0, -Height/2*0, 0) );
cylinder.SetViewMatrix( ViewMatrix( spectatorCoords.GetCartesianCoords(),
D3DXVECTOR3(0.0f, 0.0f, 0.0f),
D3DXVECTOR3(0.0f, 1.0f, 0.0f)) );
cylinder.SetProjectiveMatrix( ProjectiveMatrix( FrontClippingPlane, BackClippingPlane ) );
SetWindowLong(mainWindow.GetHWND(), 0, reinterpret_cast<LONG>(&spectatorCoords));
SetWindowLong(mainWindow.GetHWND(), sizeof(LONG), reinterpret_cast<LONG>(&cylinder));
MSG msg;
ZeroMemory(&msg, sizeof(msg));
while( msg.message != WM_QUIT )
{
if( PeekMessage( &msg, NULL, 0U, 0U, PM_REMOVE ) )
{
TranslateMessage( &msg );
DispatchMessage( &msg );
}
else
{
Render(graphicDevice, spectatorCoords, cylinder);
}
}
} // code block
_CrtDumpMemoryLeaks();
return 0;
}
Mtx44 Transformation::Matrix() const
{
Mtx44 translation, rotation, scalation, reorientate;
translation.SetToTranslation(translate);
reorientate.SetToTranslation(pivot);
scalation.SetToScale(scale.x,scale.y,scale.z);
rotation = reorientate.GetInverse() * rotate.MatrixX() * rotate.MatrixY() * rotate.MatrixZ() * reorientate;
return TranslationMatrix() * RotationMatrix() * ScalationMatrix();
}
void R_RotateForEntity (float matrix[16], vec3_t origin, vec3_t angles)
{
float translation_matrix[16];
TranslationMatrix (translation_matrix, origin[0], origin[1], origin[2]);
MatrixMultiply (matrix, translation_matrix);
float rotation_matrix[16];
RotationMatrix (rotation_matrix, DEG2RAD(angles[1]), 0, 0, 1);
MatrixMultiply (matrix, rotation_matrix);
RotationMatrix (rotation_matrix, DEG2RAD(-angles[0]), 0, 1, 0);
MatrixMultiply (matrix, rotation_matrix);
RotationMatrix (rotation_matrix, DEG2RAD(angles[2]), 1, 0, 0);
MatrixMultiply (matrix, rotation_matrix);
}
Mapping *
LinearMappingCreate(
Vector *center,
Vector *vaxis,
Vector *uaxis)
{
Mapping *res;
RSMatrix m;
Vector n;
res = (Mapping *)Malloc(sizeof(Mapping));
res->flags = OBJSPACE;
res->method= LinearMapping;
if (center)
res->center = *center;
else
res->center.x = res->center.y = res->center.z = 0.;
if (uaxis && vaxis) {
VecCross(uaxis, vaxis, &n);
/* this is wrong, since uaxis and vaxis
* give U and V in world space, and we
* need the inverse.
*/
ArbitraryMatrix(
uaxis->x, uaxis->y, uaxis->z,
vaxis->x, vaxis->y, vaxis->z,
n.x, n.y, n.z,
res->center.x, res->center.y, res->center.z,
&m);
MatrixInvert(&m, &res->m);
res->uaxis = *uaxis;
res->vaxis = *vaxis;
VecNormalize(&res->uaxis);
VecNormalize(&res->vaxis);
} else {
VecScale(-1., res->center, &n);
TranslationMatrix(n.x, n.y, n.z, &res->m);
res->uaxis.x = res->vaxis.y = 1.;
res->uaxis.y = res->uaxis.z = res->vaxis.x =
res->vaxis.z = 0.;
}
return res;
}
void PointLight::Insert(std::ostream& fout) const {
MStatus status;
fout << "TransformBegin" << std::endl;
if (TranslationMatrix(fout) != MStatus::kSuccess) { MGlobal::displayError("Error in outputting light translation"); return; }
// get the color data
MColor color = light.color();
float intensity = light.intensity();
// output the light source
fout << "LightSource \"point\" ";
fout << "\"color I\" [" << color.r*intensity << " " << color.g*intensity << " " << color.b*intensity << "]" << std::endl;
fout << "TransformEnd" << std::endl;
}
float4x4 LookAtMatrixRh(const float3 & eye, const float3 & center, const float3 & up)
{
auto f = norm(center - eye), s = norm(cross(f, up)), u = norm(cross(s, f));
return mul(transpose(float4x4({s,0},{u,0},{-f,0},{0,0,0,1})), TranslationMatrix(-eye));
}
infi_camera_t::operator core::mat4() const {
mat4 proj = Perspective( fov, InfiGetRatio(), closeview, farview );
mat4 move = ExpandMat4( toMatrix( rotation ) ) * TranslationMatrix( -position );
mat4 ret = proj * transform_matrix * move;
return ret;
}
void R_VR_DrawHud()
{
float fov = vr_hud_fov->value;
float depth = vr_hud_depth->value;
int numsegments = vr_hud_segments->value;
int index = 0;
vec_t mat[4][4], temp[4][4];
if (!vr_enabled->value)
return;
// enable alpha testing so only pixels that have alpha info get written out
// prevents black pixels from being rendered into the view
GL_Enable(GL_ALPHA_TEST);
GL_AlphaFunc(GL_GREATER, 0.0f);
// if hud transparency is enabled, enable blending
if (vr_hud_transparency->value)
{
GL_Enable(GL_BLEND);
GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
// bind the texture
GL_MBind(0, hud.texture);
// disable this for the loading screens since they are not at 60fps
if ((vr_hud_bounce->value > 0) && !loadingScreen && ((int32_t) vr_aimmode->value > 0))
{
// load the quaternion directly into a rotation matrix
vec4_t q;
VR_GetOrientationEMAQuat(q);
q[2] = -q[2];
QuatToRotation(q, mat);
} else {
// identity matrix
TranslationMatrix(0,0,0,mat);
}
// set proper mode
// glEnableClientState (GL_TEXTURE_COORD_ARRAY);
// glEnableClientState (GL_VERTEX_ARRAY);
glDisableClientState (GL_COLOR_ARRAY);
// bind vertex buffer and set tex coord parameters
R_BindIVBO(&hudVBO,NULL,0);
glTexCoordPointer(2,GL_FLOAT,sizeof(vert_t),(void *)( sizeof(GL_FLOAT) * 3));
glVertexPointer(3,GL_FLOAT,sizeof(vert_t),NULL);
for (index = 0; index < 2; index++)
{
// bind the eye FBO
R_BindFBO(vrState.eyeFBO[index]);
// set the perspective matrix for that eye
R_PerspectiveScale(vrState.renderParams[index].projection, 0.24, 251.0);
// build the eye translation matrix
if (vr_autoipd->value)
{
TranslationMatrix(-vrState.renderParams[index].viewOffset[0], vrState.renderParams[index].viewOffset[1], vrState.renderParams[index].viewOffset[2], temp);
} else {
float viewOffset = (vr_ipd->value / 2000.0);
TranslationMatrix((-1 + index * 2) * -viewOffset, 0, 0, temp);
}
// load the view matrix
MatrixMultiply(temp, mat, temp);
GL_LoadMatrix(GL_MODELVIEW, temp);
// draw the hud for that eye
R_DrawIVBO(&hudVBO);
}
// teardown
R_ReleaseIVBO();
GL_MBind(0, 0);
glEnableClientState (GL_COLOR_ARRAY);
glTexCoordPointer (2, GL_FLOAT, sizeof(texCoordArray[0][0]), texCoordArray[0][0]);
glVertexPointer (3, GL_FLOAT, sizeof(vertexArray[0]), vertexArray[0]);
GL_Disable(GL_BLEND);
GL_Disable(GL_ALPHA_TEST);
}
Matrix4 Matrix4::TranslationMatrix(Vector3 translation)
{
return TranslationMatrix(translation.x,translation.y,translation.z);
}
// Draw the scene to the screen
void draw() {
// Update time
time += 2.0f * timeStep;
/////////////////////// PART 1: SIMULATION /////////////////////////////////
// Grab buffers for OpenCL
acquireGLBuffer(particles.particleBuffer[particles.currentBuffer]);
acquireGLBuffer(particles.particleBuffer[1 - particles.currentBuffer]);
// Prepare to run some kernels
cl_int numParticles = NUM_PARTICLES;
cl_int gridElements = GRID_SIZE * GRID_SIZE * GRID_SIZE;
cl_uint workSize[3] = {numParticles, 0, 0};
cl_uint gridWorkSize[3] = {gridElements, 0, 0};
cl_uint workgroupSize[3] = {256, 0, 0};
// Clear grid
clSetKernelArg(openCLKernels.gridClearKernel, 0, sizeof(cl_mem), &particles.gridSizeBuffer);
clSetKernelArg(openCLKernels.gridClearKernel, 1, sizeof(cl_int), &gridElements);
clRunKernel(openCLKernels.gridClearKernel, gridWorkSize, workgroupSize);
// Compute grid positions
clSetKernelArg(openCLKernels.gridKernel, 0, sizeof(cl_mem), &particles.particleBuffer[particles.currentBuffer]);
clSetKernelArg(openCLKernels.gridKernel, 1, sizeof(cl_mem), &particles.offsetBuffer);
clSetKernelArg(openCLKernels.gridKernel, 2, sizeof(cl_mem), &particles.gridSizeBuffer);
clSetKernelArg(openCLKernels.gridKernel, 3, sizeof(cl_int), &numParticles);
clRunKernel(openCLKernels.gridKernel, workSize, workgroupSize);
// Compute prefix sum for grid
clSetKernelArg(openCLKernels.prefixSumKernel, 2, sizeof(cl_uint), (void*)&gridElements);
int pingpong = 0;
for(cl_int offset = 1; offset <= gridElements; offset *= 2) {
if(offset == 1) {
clSetKernelArg(openCLKernels.prefixSumKernel, 0, sizeof(cl_mem), (void*)&particles.gridSizeBuffer);
}
else {
clSetKernelArg(openCLKernels.prefixSumKernel, 0, sizeof(cl_mem), (void*)&(pingpong == 0 ? particles.gridBuffer[0] : particles.gridBuffer[1]));
}
clSetKernelArg(openCLKernels.prefixSumKernel, 1, sizeof(cl_mem), (void*)&(pingpong == 0 ? particles.gridBuffer[1] : particles.gridBuffer[0]));
clSetKernelArg(openCLKernels.prefixSumKernel, 3, sizeof(cl_int), (void*)&offset);
clRunKernel(openCLKernels.prefixSumKernel, gridWorkSize, workgroupSize);
pingpong = 1 - pingpong;
}
// Reorganize particles
clSetKernelArg(openCLKernels.gridReorderKernel, 0, sizeof(cl_mem), &particles.particleBuffer[particles.currentBuffer]);
clSetKernelArg(openCLKernels.gridReorderKernel, 1, sizeof(cl_mem), &particles.particleBuffer[1 - particles.currentBuffer]);
clSetKernelArg(openCLKernels.gridReorderKernel, 2, sizeof(cl_mem), &particles.velocityBuffer[particles.currentBuffer]);
clSetKernelArg(openCLKernels.gridReorderKernel, 3, sizeof(cl_mem), &particles.velocityBuffer[1 - particles.currentBuffer]);
clSetKernelArg(openCLKernels.gridReorderKernel, 4, sizeof(cl_mem), &particles.offsetBuffer);
clSetKernelArg(openCLKernels.gridReorderKernel, 5, sizeof(cl_mem), (void*)&particles.gridSizeBuffer);
clSetKernelArg(openCLKernels.gridReorderKernel, 6, sizeof(cl_mem), (void*)&(pingpong == 0 ? particles.gridBuffer[0] : particles.gridBuffer[1]));
clSetKernelArg(openCLKernels.gridReorderKernel, 7, sizeof(cl_int), &numParticles);
clRunKernel(openCLKernels.gridReorderKernel, workSize, workgroupSize);
particle* testData = (particle*)malloc(sizeof(cl_float) * numParticles * 4);
// Swap particle buffers
particles.currentBuffer = 1 - particles.currentBuffer;
// Send new cell select buffer
int cellSelect[27];
for(int i = 0; i < 27; i++) {
cellSelect[i] = i;
}
shuffle(cellSelect, 27);
clEnqueueWriteBuffer(clCommandQueue(), particles.cellSelectBuffer, true, 0, 27 * sizeof(cl_int), cellSelect, 0, 0, 0);
clFinish(clCommandQueue());
// Recalculate densities and normalized pressure derivatives
clSetKernelArg(openCLKernels.dataKernel, 0, sizeof(cl_mem), &particles.particleBuffer[particles.currentBuffer]);
clSetKernelArg(openCLKernels.dataKernel, 1, sizeof(cl_mem), &particles.dataBuffer);
clSetKernelArg(openCLKernels.dataKernel, 2, sizeof(cl_mem), (void*)&particles.gridSizeBuffer);
clSetKernelArg(openCLKernels.dataKernel, 3, sizeof(cl_mem), (void*)&(pingpong == 0 ? particles.gridBuffer[1] : particles.gridBuffer[0]));
clSetKernelArg(openCLKernels.dataKernel, 4, sizeof(cl_mem), (void*)&particles.cellSelectBuffer);
clSetKernelArg(openCLKernels.dataKernel, 5, sizeof(cl_int), &numParticles);
clRunKernel(openCLKernels.dataKernel, workSize, workgroupSize);
// Send new cell select buffer
cellSelect[27];
for(int i = 0; i < 27; i++) {
cellSelect[i] = i;
}
shuffle(cellSelect, 27);
clEnqueueWriteBuffer(clCommandQueue(), particles.cellSelectBuffer, true, 0, 27 * sizeof(cl_int), cellSelect, 0, 0, 0);
clFinish(clCommandQueue());
// Integrate position
float dT = timeStep;
clSetKernelArg(openCLKernels.simulationKernel, 0, sizeof(cl_mem), &particles.particleBuffer[particles.currentBuffer]);
clSetKernelArg(openCLKernels.simulationKernel, 1, sizeof(cl_mem), &particles.particleBuffer[1 - particles.currentBuffer]);
clSetKernelArg(openCLKernels.simulationKernel, 2, sizeof(cl_mem), &particles.velocityBuffer[particles.currentBuffer]);
clSetKernelArg(openCLKernels.simulationKernel, 3, sizeof(cl_mem), &particles.velocityBuffer[1 - particles.currentBuffer]);
clSetKernelArg(openCLKernels.simulationKernel, 4, sizeof(cl_mem), &particles.dataBuffer);
clSetKernelArg(openCLKernels.simulationKernel, 5, sizeof(cl_mem), (void*)&particles.gridSizeBuffer);
clSetKernelArg(openCLKernels.simulationKernel, 6, sizeof(cl_mem), (void*)&(pingpong == 0 ? particles.gridBuffer[1] : particles.gridBuffer[0]));
clSetKernelArg(openCLKernels.simulationKernel, 7, sizeof(cl_mem), (void*)&particles.cellSelectBuffer);
clSetKernelArg(openCLKernels.simulationKernel, 8, sizeof(cl_float), &dT);
clSetKernelArg(openCLKernels.simulationKernel, 9, sizeof(cl_float), &time);
clSetKernelArg(openCLKernels.simulationKernel, 10, sizeof(cl_int), &numParticles);
clSetKernelArg(openCLKernels.simulationKernel, 11, sizeof(cl_mem), &particles.terrainBuffer);
PaddedVector windDir = PadVector(
TransformVector(YAxisRotationMatrix(particles.windAngle), MakeVector(1.0f, 0.0f, 0.0f))
);
clSetKernelArg(openCLKernels.simulationKernel, 12, sizeof(cl_float) * 4, &windDir);
clSetKernelArg(openCLKernels.simulationKernel, 13, sizeof(cl_float), &particles.windPower);
clRunKernel(openCLKernels.simulationKernel, workSize, workgroupSize);
// Release buffers back to OpenGL
releaseGLBuffer(particles.particleBuffer[particles.currentBuffer]);
releaseGLBuffer(particles.particleBuffer[1 - particles.currentBuffer]);
// Swap particle buffers
particles.currentBuffer = 1 - particles.currentBuffer;
//////////////////////// PART 2: RENDERIING ////////////////////////////////
// Clear everything first thing.
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glBindFramebuffer(GL_FRAMEBUFFER, framebuffers.backgroundFBO);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Activate shader.
glUseProgram(objectShader.shaderProgram);
// Set projection
Matrix projection = PerspectiveMatrix(
45.0f,
(float)WINDOW_WIDTH/(float)WINDOW_HEIGHT,
0.01f,
100.0f
);
MatrixAsUniform(objectShader.projectionMatrix, projection);
// Vertices
glBindBuffer(GL_ARRAY_BUFFER, terrain.vertexBuffer);
glVertexAttribPointer(
objectShader.vertexPosition,
4,
GL_FLOAT,
GL_FALSE,
sizeof(GLfloat) * 4,
(void*)0
);
glEnableVertexAttribArray(objectShader.vertexPosition);
// Set modelview according to camera
Matrix rot = lookatMatrix(camera.pos, VectorAdd(camera.pos, camera.front), camera.up);
rot = MatrixMul(RotationMatrix(camera.elevation, MakeVector(1, 0, 0)), rot);
Matrix trans = TranslationMatrix(-camera.pos.x, -camera.pos.y, -camera.pos.z);
Matrix modelview = MatrixMul(rot, trans);
MatrixAsUniform(objectShader.modelviewMatrix, modelview);
// Normal view matrix - inverse transpose of modelview.
Matrix normalview = MatrixTranspose(FastMatrixInverse(modelview));
MatrixAsUniform(objectShader.normalviewMatrix, normalview);
// Set heightmap texture
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, terrain.heightTexture );
glUniform1i(objectShader.terrainTexture, 0);
// Set color textures
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, terrain.lowTexture);
glUniform1i(objectShader.lowTexture, 1);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, terrain.highTexture);
glUniform1i(objectShader.highTexture, 2);
// Turn off culling
glDisable(GL_CULL_FACE);
// Send element buffer to GPU and draw.
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, terrain.elementBuffer);
glDrawElements(
GL_TRIANGLES,
512 * 512 * 6,
GL_UNSIGNED_INT,
(void*)0
);
// Turn culling back on
glEnable(GL_CULL_FACE);
// Switch to low-res viewport
glViewport(0, 0, WINDOW_WIDTH / RESOLUTION_DIVIDER, WINDOW_HEIGHT / RESOLUTION_DIVIDER);
// Low-res projection matrix
Matrix projectionLowres = PerspectiveMatrix(
45.0f,
(float)(WINDOW_WIDTH / RESOLUTION_DIVIDER) / (float)(WINDOW_HEIGHT / RESOLUTION_DIVIDER),
0.01f,
100.0f
);
// Activate particle depth FBO
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glBindFramebuffer(GL_FRAMEBUFFER, framebuffers.particleFBO[0]);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Activate shader
glUseProgram(particleShader.shaderProgram);
// Set textures
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, framebuffers.backgroundTexture);
glUniform1i(particleShader.terrainTexture, 0);
// Send uniforms
MatrixAsUniform(particleShader.modelviewMatrix, modelview);
MatrixAsUniform(particleShader.projectionMatrix, projectionLowres);
glUniform2f(particleShader.screenSize, WINDOW_WIDTH / RESOLUTION_DIVIDER, WINDOW_HEIGHT / RESOLUTION_DIVIDER);
// Bind new buffer and set up arrtibutes
glBindBuffer(GL_ARRAY_BUFFER, particles.vertexBuffer[particles.currentBuffer]);
glVertexAttribPointer(
particleShader.vertexPosition,
4,
GL_FLOAT,
GL_FALSE,
sizeof(GLfloat) * 4,
(void*)0
);
glEnableVertexAttribArray(particleShader.vertexPosition);
// Bind element buffer and draw particles
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, particles.elementBuffer);
glDrawElements(
GL_POINTS,
NUM_PARTICLES,
GL_UNSIGNED_INT,
(void*)0
);
// Activate particle thickness FBO
glBindFramebuffer(GL_FRAMEBUFFER, framebuffers.particleThicknessFBO[0]);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Activate shader
glUseProgram(particleThicknessShader.shaderProgram);
// Send uniforms
MatrixAsUniform(particleThicknessShader.modelviewMatrix, modelview);
MatrixAsUniform(particleThicknessShader.projectionMatrix, projectionLowres);
glUniform2f(particleThicknessShader.screenSize, WINDOW_WIDTH / RESOLUTION_DIVIDER, WINDOW_HEIGHT / RESOLUTION_DIVIDER);
// Set textures
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, framebuffers.backgroundTexture);
glUniform1i(particleThicknessShader.terrainTexture, 0);
// Bind new buffer and set up arrtibutes
glBindBuffer(GL_ARRAY_BUFFER, particles.vertexBuffer[particles.currentBuffer]);
glVertexAttribPointer(
particleThicknessShader.vertexPosition,
4,
GL_FLOAT,
GL_FALSE,
sizeof(GLfloat) * 4,
(void*)0
);
glEnableVertexAttribArray(particleThicknessShader.vertexPosition);
// Enable additive blending and disable depth test
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
glDisable(GL_DEPTH_TEST);
// Bind element buffer and draw particles, this time rendering thickness map
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, particles.elementBuffer);
glDrawElements(
GL_POINTS,
NUM_PARTICLES,
GL_UNSIGNED_INT,
(void*)0
);
// Turn blending back off and depth test back on
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
// Activate particle velocity FBO
glBindFramebuffer(GL_FRAMEBUFFER, framebuffers.velocityFBO);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Activate shader
glUseProgram(particleVelocityShader.shaderProgram);
// Send uniforms
MatrixAsUniform(particleVelocityShader.modelviewMatrix, modelview);
MatrixAsUniform(particleVelocityShader.projectionMatrix, projectionLowres);
glUniform2f(particleVelocityShader.screenSize, WINDOW_WIDTH / RESOLUTION_DIVIDER, WINDOW_HEIGHT / RESOLUTION_DIVIDER);
// Bind new buffer and set up arrtibutes
glBindBuffer(GL_ARRAY_BUFFER, particles.vertexBuffer[particles.currentBuffer]);
glVertexAttribPointer(
particleVelocityShader.vertexPosition,
4,
GL_FLOAT,
GL_FALSE,
sizeof(GLfloat) * 4,
(void*)0
);
glEnableVertexAttribArray(particleVelocityShader.vertexPosition);
// Bind element buffer and draw particles, this time rendering velocity map
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, particles.elementBuffer);
glDrawElements(
GL_POINTS,
NUM_PARTICLES,
GL_UNSIGNED_INT,
(void*)0
);
// Curvature flow smoothing begins
glUseProgram(curvatureFlowShader.shaderProgram);
// Send uniforms
glUniform1i(curvatureFlowShader.particleTexture, 0);
glUniform2f(curvatureFlowShader.screenSize, WINDOW_WIDTH / RESOLUTION_DIVIDER, WINDOW_HEIGHT / RESOLUTION_DIVIDER);
MatrixAsUniform(curvatureFlowShader.projectionMatrix, projectionLowres);
// Prepare state
glActiveTexture(GL_TEXTURE0);
glBindBuffer(GL_ARRAY_BUFFER, screenQuad.vertexBuffer);
glVertexAttribPointer(
curvatureFlowShader.vertexPosition,
3,
GL_FLOAT,
GL_FALSE,
sizeof(GLfloat) * 3,
(void*)0
);
glEnableVertexAttribArray(curvatureFlowShader.vertexPosition);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, screenQuad.elementBuffer);
// Smoothing loop
glDisable(GL_DEPTH_TEST);
pingpong = 0;
for(int i = 0; i < smoothingIterations; i++) {
// Bind no FBO
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// Bind texture
glBindTexture(GL_TEXTURE_2D, framebuffers.particleTexture[pingpong]);
// Activate proper FBO and clear
glBindFramebuffer(GL_FRAMEBUFFER, framebuffers.particleFBO[1 - pingpong]);
// Draw a quad
glDrawElements(
GL_TRIANGLES,
6,
GL_UNSIGNED_INT,
(void*)0
);
// Switch buffers
pingpong = 1 - pingpong;
}
glEnable(GL_DEPTH_TEST);
// Activate particle color FBO
glBindFramebuffer(GL_FRAMEBUFFER, framebuffers.particleColorFBO);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Liquid shading shader
glUseProgram(liquidShadeShader.shaderProgram);
// Bind and set textures
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, framebuffers.particleTexture[0]);
glUniform1i(liquidShadeShader.particleTexture, 0);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, framebuffers.particleThicknessTexture[0]);
glUniform1i(liquidShadeShader.particleThicknessTexture, 1);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, terrain.envTexture);
glUniform1i(liquidShadeShader.environmentTexture, 2);
glActiveTexture(GL_TEXTURE3);
glBindTexture(GL_TEXTURE_2D, framebuffers.particleVelocityTexture);
glUniform1i(liquidShadeShader.velocityTexture, 3);
// Send uniforms
glUniform2f(liquidShadeShader.screenSize, WINDOW_WIDTH, WINDOW_HEIGHT);
MatrixAsUniform(liquidShadeShader.modelviewMatrix, modelview);
MatrixAsUniform(liquidShadeShader.projectionMatrix, projection);
glUniform1i(liquidShadeShader.useThickness, useThickness);
// Draw a quad
glDisable(GL_DEPTH_TEST);
glBindBuffer(GL_ARRAY_BUFFER, screenQuad.vertexBuffer);
glVertexAttribPointer(
liquidShadeShader.vertexPosition,
3,
GL_FLOAT,
GL_FALSE,
sizeof(GLfloat) * 3,
(void*)0
);
glEnableVertexAttribArray(liquidShadeShader.vertexPosition);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, screenQuad.elementBuffer);
glDrawElements(
GL_TRIANGLES,
6,
GL_UNSIGNED_INT,
(void*)0
);
glEnable(GL_DEPTH_TEST);
// Switch back to full-res viewport
glViewport(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT);
// Deactivate FBOs
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Compose shader
glUseProgram(compositionShader.shaderProgram);
// Bind and set textures
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, terrain.envTexture);
glUniform1i(compositionShader.backgroundTexture, 0);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, framebuffers.particleColorTexture);
glUniform1i(compositionShader.particleTexture, 1);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, framebuffers.backgroundTexture);
glUniform1i(compositionShader.terrainTexture, 2);
// Send uniforms
MatrixAsUniform(compositionShader.modelviewMatrix, modelview);
// Draw a quad
glDisable(GL_DEPTH_TEST);
glBindBuffer(GL_ARRAY_BUFFER, screenQuad.vertexBuffer);
glVertexAttribPointer(
compositionShader.vertexPosition,
3,
GL_FLOAT,
GL_FALSE,
sizeof(GLfloat) * 3,
(void*)0
);
glEnableVertexAttribArray(compositionShader.vertexPosition);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, screenQuad.elementBuffer);
glDrawElements(
GL_TRIANGLES,
6,
GL_UNSIGNED_INT,
(void*)0
);
glEnable(GL_DEPTH_TEST);
// Switch drawing area and displayed area.
glutSwapBuffers();
}
Matrix4x4<Real> TranslationMatrix (Real x, Real y, Real z)
{
return TranslationMatrix (Vector3<Real> (x, y, z));
}
void ISprite::Update(f32 delta)
{
//IBasicMesh::Update(delta);
if (bPlaying && bAnimation)
{
fFrameTime += delta;
if (fFrameTime > fCurrentFrameRate)
{
fFrameTime -= fCurrentFrameRate;
if (iCurrentFrame + 1 == iFrames)
{
if (bLoop)
{
iCurrentFrame = 0;
}
else
{
bChanged = FALSE;
}
}
else
iCurrentFrame++;
u32 oldId = pFrame->iFileId;
pFrame = &pAnimationFrames[iCurrentFrame];
if (oldId != pFrame->iFileId)
{
sRelease(pFrameImage);
pFrameImage = static_cast<ITexture *>(pRes->Get(_F(pFrame->iFileId), Seed::ObjectTexture, pPool));
}
this->ReconfigureFrame();
}
}
if (!bChanged && !this->IsChanged())
return;
uPixel p = iColor;
p.rgba.r = iColor.argb.r;
p.rgba.g = iColor.argb.g;
p.rgba.b = iColor.argb.b;
p.rgba.a = iColor.argb.a;
if (!arCustomVertexData)
{
arCurrentVertexData = &vert[0];
vert[0].cVertex = Vector3f(-fAspectHalfWidth, -fAspectHalfHeight, (f32)iPriority);
vert[0].iColor = p;
vert[0].cCoords = Point2f(fTexS0, fTexT0);
vert[1].cVertex = Vector3f(+fAspectHalfWidth, -fAspectHalfHeight, (f32)iPriority);
vert[1].iColor = p;
vert[1].cCoords = Point2f(fTexS1, fTexT0);
vert[2].cVertex = Vector3f(-fAspectHalfWidth, +fAspectHalfHeight, (f32)iPriority);
vert[2].iColor = p;
vert[2].cCoords = Point2f(fTexS0, fTexT1);
vert[3].cVertex = Vector3f(+fAspectHalfWidth, +fAspectHalfHeight, (f32)iPriority);
vert[3].iColor = p;
vert[3].cCoords = Point2f(fTexS1, fTexT1);
}
else
{
arCurrentVertexData = arCustomVertexData;
}
f32 ratio = pScreen->GetAspectRatio();
f32 x = fAspectHalfWidth + ISprite::GetX();
f32 y = fAspectHalfHeight + ISprite::GetY() * ratio;
f32 lx = ISprite::GetLocalX();
f32 ly = ISprite::GetLocalY() * ratio;
Matrix4x4f t1, t2, r, s;
t1 = TranslationMatrix(lx + x, ly + y, 0.0f);
r = RotationMatrix(AxisZ, DegToRad(ISprite::GetRotation()));
s = ScaleMatrix(ISprite::GetScaleX(), ISprite::GetScaleY(), 1.0f);
t2 = TranslationMatrix(-lx, -ly, 0.0f);
Matrix4x4f transform = ((t1 * r) * s) * t2;
if (bTransformationChanged || !arCustomVertexData)
{
for (u32 i = 0; i < iNumVertices; i++)
{
transform.Transform(arCurrentVertexData[i].cVertex);
}
}
bChanged = FALSE;
bTransformationChanged = FALSE;
}
bool ZEffectBillboardTexAniList::Draw()
{
if(!m_pVB) return false;
if( size()==0 ) return true;
BeginState();
RSetFog(FALSE);
HRESULT hr;
DWORD dwRemainNum = (DWORD)size();
iterator itr = begin();
while(dwRemainNum)
{
if(m_dwBase >= EFFECTBASE_DISCARD_COUNT)
m_dwBase = 0;
DWORD dwThisNum = min( dwRemainNum , static_cast<DWORD>(BILLBOARD_FLUSH_COUNT) );
dwThisNum = min( dwThisNum , EFFECTBASE_DISCARD_COUNT - m_dwBase );
BYTE *pVertices;
if( FAILED( hr = m_pVB->Lock( m_dwBase * sizeof(ZEFFECTCUSTOMVERTEX) * 4, dwThisNum * sizeof(ZEFFECTCUSTOMVERTEX) * 4,
(VOID**)&pVertices, m_dwBase ? D3DLOCK_NOOVERWRITE : D3DLOCK_DISCARD ) ) )
{
return false;
}
BYTE *pInd;
if( FAILED( hr = m_pIB->Lock( m_dwBase * sizeof(WORD) * 6, dwThisNum * sizeof(WORD) * 6,
(VOID**)&pInd, m_dwBase ? D3DLOCK_NOOVERWRITE : D3DLOCK_DISCARD ) ) )
{
return false;
}
int nRenderCnt = 0;
ZCharacter* pChar = NULL;
for(DWORD j=0;j<dwThisNum;j++)
{
ZEFFECTBILLBOARDTEXANIITEM *p = (ZEFFECTBILLBOARDTEXANIITEM*)*itr;
if(p->fElapsedTime < p->fAddTime ) {
itr++;
continue;
}
pChar = ZGetCharacterManager()->Find(p->CharUID);
if( pChar ) {
if( pChar->m_pVMesh ) {
if( pChar->m_pVMesh->m_bIsRender==false) {
itr++;
continue;
}
}
}
nRenderCnt++;
// Transform
rmatrix matTranslation;
rmatrix matScaling;
rmatrix matWorld;
rvector dir = p->normal;
rvector up = p->up;
rvector right;
if (IS_EQ(dir.z, 1.f)) up = rvector(1, 0, 0);
right = Normalized(CrossProduct(up, dir));
up = Normalized(CrossProduct(right, dir));
rmatrix mat;
GetIdentityMatrix(mat);
mat._11 = right.x; mat._12 = right.y; mat._13 = right.z;
mat._21 = up.x; mat._22 = up.y; mat._23 = up.z;
mat._31 = dir.x; mat._32 = dir.y; mat._33 = dir.z;
rvector pos = p->position;
float fInt = min(1.f, max(0.f, (p->fLifeTime - p->fElapsedTime) / p->fLifeTime));
float fScale=p->fStartSize * fInt + p->fEndSize * (1.f - fInt);
matScaling = ScalingMatrix(fScale * m_Scale);
matTranslation = TranslationMatrix(pos);
matWorld = matScaling * mat;
matWorld *= matTranslation;
DWORD color = ((DWORD)(p->fOpacity * 255))<<24 | p->dwColor;
static ZEFFECTCUSTOMVERTEX v[] = {
{{-1, -1, 0}, 0xFFFFFFFF, 1, 0 },
{{-1, 1, 0}, 0xFFFFFFFF, 1, 1},
{{ 1, 1, 0}, 0xFFFFFFFF, 0, 1},
{{ 1, -1, 0}, 0xFFFFFFFF, 0, 0},
};
static rvector sv[4] = { rvector(-1,-1,0) , rvector(-1,1,0) , rvector(1,1,0) , rvector(1,-1,0) };
GetFrameUV( min( p->frame,m_nMaxFrame-1) );
v[0].tu = m_fUV[0];
v[0].tv = m_fUV[1];
v[1].tu = m_fUV[2];
v[1].tv = m_fUV[3];
v[2].tu = m_fUV[4];
v[2].tv = m_fUV[5];
v[3].tu = m_fUV[6];
v[3].tv = m_fUV[7];
for (size_t i{}; i < 4; ++i)
v[i].pos = TransformCoord(sv[i], matWorld);
v[0].color=v[1].color=v[2].color=v[3].color=color;
memcpy(pVertices,v,sizeof(ZEFFECTCUSTOMVERTEX)*4);
pVertices+=sizeof(ZEFFECTCUSTOMVERTEX)*4;
WORD inds[] = { 0,1,2,0,2,3 };
for(int k=0;k<6;k++)
{
inds[k]+=(m_dwBase+j)*4;
}
memcpy(pInd,inds,sizeof(inds));
pInd+=sizeof(inds);
itr++;
}
m_pVB->Unlock();
m_pIB->Unlock();
if(FAILED( hr = RGetDevice()->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,0,m_dwBase*4,nRenderCnt*4,m_dwBase*6,nRenderCnt*2) ))
return false;
m_dwBase+=dwThisNum;
dwRemainNum-=dwThisNum;
}
RGetDevice()->SetStreamSource( 0, NULL , 0,0 );
RGetDevice()->SetIndices(NULL);
if(ZGetWorld()) {
ZGetWorld()->SetFog(true);
}
EndState();
return true;
}
bool ZEffectBillboardList::Draw()
{
if(!m_pVB) return false;
if( size()==0 ) return true;
BeginState();
HRESULT hr;
DWORD dwRemainNum = (DWORD)size();
iterator itr=begin();
while(dwRemainNum)
{
if(m_dwBase >= EFFECTBASE_DISCARD_COUNT)
m_dwBase = 0;
DWORD dwThisNum = min( dwRemainNum , static_cast<DWORD>(BILLBOARD_FLUSH_COUNT) );
dwThisNum = min( dwThisNum , EFFECTBASE_DISCARD_COUNT - m_dwBase );
BYTE *pVertices;
if( FAILED( hr = m_pVB->Lock( m_dwBase * sizeof(ZEFFECTCUSTOMVERTEX) * 4, dwThisNum * sizeof(ZEFFECTCUSTOMVERTEX) * 4,
(VOID**)&pVertices, m_dwBase ? D3DLOCK_NOOVERWRITE : D3DLOCK_DISCARD ) ) )
{
return false;
}
BYTE *pInd;
if( FAILED( hr = m_pIB->Lock( m_dwBase * sizeof(WORD) * 6, dwThisNum * sizeof(WORD) * 6,
(VOID**)&pInd, m_dwBase ? D3DLOCK_NOOVERWRITE : D3DLOCK_DISCARD ) ) )
{
return false;
}
for(DWORD j=0;j<dwThisNum;j++)
{
ZEFFECTBILLBOARDITEM *p = (ZEFFECTBILLBOARDITEM*)*itr;
// Transform
rmatrix matTranslation;
rmatrix matScaling;
rmatrix matWorld;
rvector dir = p->normal;
rvector up=p->up;
rvector right;
if(IS_EQ(dir.z,1.f)) up=rvector(1,0,0);
right = Normalized(CrossProduct(up, dir));
up = Normalized(CrossProduct(right, dir));
rmatrix mat;
GetIdentityMatrix(mat);
mat._11=right.x;mat._12=right.y;mat._13=right.z;
mat._21=up.x;mat._22=up.y;mat._23=up.z;
mat._31=dir.x;mat._32=dir.y;mat._33=dir.z;
rvector pos=p->position;
float fInt = min(1.f, max(0.f, (p->fLifeTime - p->fElapsedTime) / p->fLifeTime));
float fScale=p->fStartSize * fInt + p->fEndSize * (1.f - fInt);
if( p->bUseTrainSmoke ) {
float fRatio = GetLifeRatio(p);
float fAddScale = (p->fEndSize - p->fStartSize) / p->fLifeTime;
if(fRatio < 0.1f ) {
fAddScale *= 0.001f;
}
else if(fRatio < 0.4) {
fAddScale *= 0.02f;
}
else {
fAddScale *= 0.05f;
}
p->fCurScale += fAddScale;
if(p->fCurScale > p->fEndSize)
p->fCurScale = p->fEndSize;
fScale = p->fCurScale;
}
matScaling = ScalingMatrix(fScale * m_Scale);
matTranslation = TranslationMatrix(pos);
matWorld = matScaling * mat;
matWorld *= matTranslation;
DWORD color = ((DWORD)(p->fOpacity * 255))<<24 | p->dwColor;
static ZEFFECTCUSTOMVERTEX v[] = {
{{-1, -1, 0}, 0xFFFFFFFF, 1, 0 },
{{-1, 1, 0}, 0xFFFFFFFF, 1, 1 },
{{ 1, 1, 0 }, 0xFFFFFFFF, 0, 1},
{ { 1, -1, 0}, 0xFFFFFFFF, 0, 0 },
};
static const rvector sv[4] = { rvector(-1,-1,0) , rvector(-1,1,0) , rvector(1,1,0) , rvector(1,-1,0) };
for (size_t i{}; i < 4; ++i)
v[i].pos = TransformCoord(sv[i], matWorld);
v[0].color=v[1].color=v[2].color=v[3].color=color;
memcpy(pVertices,v,sizeof(ZEFFECTCUSTOMVERTEX)*4);
pVertices+=sizeof(ZEFFECTCUSTOMVERTEX)*4;
WORD inds[] = { 0,1,2,0,2,3 };
for(int k=0;k<6;k++)
{
inds[k]+=(m_dwBase+j)*4;
}
memcpy(pInd,inds,sizeof(inds));
pInd+=sizeof(inds);
itr++;
}
m_pVB->Unlock();
m_pIB->Unlock();
if(FAILED( hr = RGetDevice()->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,0,m_dwBase*4,dwThisNum*4,m_dwBase*6,dwThisNum*2) ))
return false;
m_dwBase+=dwThisNum;
dwRemainNum-=dwThisNum;
}
RGetDevice()->SetStreamSource( 0, NULL , 0,0 );
RGetDevice()->SetIndices(NULL);
EndState();
return true;
}
void Matrix44f::translate( const float &x, const float &y, const float &z )
{
*this = *this * TranslationMatrix( x, y, z ) ;
//*this = TranslationMatrix( x, y, z ) * *this;
}
void Matrix44f::translate( const Vec3f &translation )
{
*this = *this * TranslationMatrix( translation );
//*this = TranslationMatrix( translation ) * *this;
}
