Category

Development Platform
Home > SourceCode/Document > Graph program > Special Effects > View Code
MDLModel.cpp
Package: VCtracking.rar　[view]
Upload User: xuczgm
Upload Date: 2022-04-25
Package Size: 8601k
Code Size: 23k
Category:

Special Effects

Development Platform:

Visual C++

MDLModel.cpp：Code Content
  1. #include "stdafx.h"
  3. #include "MdlModel.h"
  5. DWORD CurrentTexture = 1;
  6. vec3_t TransformVertices[MAXVERTICES]; // Transformed vertices
  7. vec3_t LightValues[MAXVERTICES]; // Light surface normals
  8. vec3_t *TransformVertPtr;
  9. vec3_t *LightValuesPtr;
  10. vec3_t LightVector; // Light vector in model reference frame
  11. vec3_t BoneLightVector[MAXBONES]; // Light vectors in bone reference frames
  12. long AmbientLightColor; // Ambient world light
  13. float ShadeLight; // Direct world light
  14. vec3_t LightColor;
  15. float BoneTransforms[MAXBONES][3][4]; // Bone transformation matrix
  16. void TMDLModel::Init(char *Filename)
  17. { char TextureName[256];
  18. char SeqGroupName[256];
  19. Header = LoadModel(Filename);
  20. if (0 == Header->NumTextures)
  21. { strcpy(TextureName, Filename);
  22. // strcpy(&TextureName[strlen(TextureName) - 4], "T.mdl");
  23. TextureHeader = LoadModel(TextureName);
  24. }
  25. else
  26. { TextureHeader = Header;
  27. }
  28. if (Header->NumSeqGroups > 1)
  29. { for (long Loop = 1; Loop < Header->NumSeqGroups; Loop++)
  30. { strcpy(SeqGroupName, Filename);
  31. sprintf(&SeqGroupName[strlen(SeqGroupName) - 4], "%02d.mdl", Loop);
  32. AnimationHeader[Loop] = LoadDemandSequences(SeqGroupName);
  33. }
  34. }
  35. }
  36. void TMDLModel::AdvanceFrame(float Time)
  37. {
  38. tagMDLSeqDescription *SeqDescription = (tagMDLSeqDescription *)((BYTE *)Header + 
  39. Header->SequenceOffset) + CurrentSequence;
  41. if (Time > 0.1f)
  42. {
  43. Time = 0.1f;
  44. }
  46. CurrentFrame += Time * SeqDescription->Timing;
  48. if (SeqDescription->NumFrames <= 1)
  49. {
  50. CurrentFrame = 0;
  51. }
  53. else
  54. {
  55. CurrentFrame -= (long)(CurrentFrame / (SeqDescription->NumFrames - 1)) * 
  56. (SeqDescription->NumFrames - 1);
  57. }
  58. }
  60. void TMDLModel::ExtractBoundBox(float *Minimums, float *Maximums)
  61. {
  62. tagMDLSeqDescription *SeqDescription = (tagMDLSeqDescription *)((BYTE *)Header + 
  63. Header->SequenceOffset);
  65. Minimums[0] = SeqDescription[CurrentSequence].BoundingBoxMinimum[0];
  66. Minimums[1] = SeqDescription[CurrentSequence].BoundingBoxMinimum[1];
  67. Minimums[2] = SeqDescription[CurrentSequence].BoundingBoxMinimum[2];
  69. Maximums[0] = SeqDescription[CurrentSequence].BoundingBoxMaximum[0];
  70. Maximums[1] = SeqDescription[CurrentSequence].BoundingBoxMaximum[1];
  71. Maximums[2] = SeqDescription[CurrentSequence].BoundingBoxMaximum[2];
  72. }
  74. long TMDLModel::SetSequence(long Sequence)
  75. {
  76. if (Sequence > Header->NumSequences)
  77. {
  78. Sequence = 0;
  79. }
  81. else if (Sequence < 0)
  82. {
  83. Sequence = Header->NumSequences - 1;
  84. }
  86. CurrentSequence = Sequence;
  87. CurrentFrame = 0;
  89. return CurrentSequence;
  90. }
  92. long TMDLModel::GetSequence()
  93. {
  94. return CurrentSequence;
  95. }
  97. void TMDLModel::GetSequenceInfo(float *FrameRate, float *GroundSpeed)
  98. {
  99. tagMDLSeqDescription *SeqDescription = (tagMDLSeqDescription *)((BYTE *)Header + 
  100. Header->SequenceOffset) + CurrentSequence;
  102. if (SeqDescription->NumFrames > 1)
  103. {
  104. *FrameRate = 256 * SeqDescription->Timing / (SeqDescription->NumFrames - 1);
  105. *GroundSpeed = (float)sqrt(SeqDescription->LinearMovement[0] * 
  106. SeqDescription->LinearMovement[0] + SeqDescription->LinearMovement[1] * 
  107. SeqDescription->LinearMovement[1] + SeqDescription->LinearMovement[2] * 
  108. SeqDescription->LinearMovement[2]);
  110. *GroundSpeed = *GroundSpeed * SeqDescription->Timing / (SeqDescription->NumFrames - 1);
  111. }
  113. else
  114. {
  115. *FrameRate = 256.0f;
  116. *GroundSpeed = 0.0f;
  117. }
  118. }
  120. float TMDLModel::SetController(long ControllerIndex, float Value)
  121. {
  122. tagMDLBoneController *BoneController = 
  123. (tagMDLBoneController *)((BYTE *)Header + Header->BoneControllerOffset);
  125. for (long Loop = 0; Loop < Header->NumBoneControllers; Loop++, BoneController++)
  126. {
  127. if (BoneController->Index == ControllerIndex)
  128. {
  129. break;
  130. }
  131. }
  133. if (Loop >= Header->NumBoneControllers)
  134. {
  135. return Value;
  136. }
  138. if (BoneController->Type & (TRANSITION_XR | TRANSITION_YR | TRANSITION_ZR))
  139. {
  140. if (BoneController->End < BoneController->Start)
  141. {
  142. Value = -Value;
  143. }
  145. if (BoneController->Start + 359.0f >= BoneController->End)
  146. {
  147. if (Value > ((BoneController->Start + BoneController->End) / 2.0f) + 180)
  148. {
  149. Value = Value - 360.0f;
  150. }
  152. if (Value < ((BoneController->Start + BoneController->End) / 2.0f) - 180)
  153. {
  154. Value = Value + 360.0f;
  155. }
  156. }
  158. else
  159. {
  160. if (Value > 360.0f)
  161. {
  162. Value = Value - (long)(Value / 360.0f) * 360.0f;
  163. }
  165. else if (Value < 0.0f)
  166. {
  167. Value = Value + (long)((Value / -360.0f) + 1.0f) * 360.0f;
  168. }
  169. }
  170. }
  172. long Setting = (long)(255.0f * (Value - BoneController->Start) / (BoneController->End - 
  173. BoneController->Start));
  175. if (Setting < 0)
  176. {
  177. Setting = 0;
  178. }
  180. else if (Setting > 255)
  181. {
  182. Setting = 255;
  183. }
  185. Controller[ControllerIndex] = (BYTE)Setting;
  187. return Setting * (1.0f / 255.0f) * (BoneController->End - BoneController->Start) + 
  188. BoneController->Start;
  189. }
  191. float TMDLModel::SetMouth(float Value)
  192. {
  193. tagMDLBoneController *BoneController = 
  194. (tagMDLBoneController *)((BYTE *)Header + Header->BoneControllerOffset);
  196. for (long Loop = 0; Loop < Header->NumBoneControllers; Loop++, BoneController++)
  197. {
  198. if (4 == BoneController->Index)
  199. {
  200. break;
  201. }
  202. }
  204. if (BoneController->Type & (TRANSITION_XR | TRANSITION_YR | TRANSITION_ZR))
  205. {
  206. if (BoneController->End < BoneController->Start)
  207. {
  208. Value = -Value;
  209. }
  211. if (BoneController->Start + 359.0f >= BoneController->End)
  212. {
  213. if (Value > ((BoneController->Start + BoneController->End) / 2.0f) + 180.0f)
  214. {
  215. Value = Value - 360.0f;
  216. }
  218. if (Value < ((BoneController->Start + BoneController->End) / 2.0f) - 180.0f)
  219. {
  220. Value = Value + 360.0f;
  221. }
  222. }
  224. else
  225. {
  226. if (Value > 360.0f)
  227. {
  228. Value = Value - (long)(Value / 360.0f) * 360.0f;
  229. }
  231. else if (Value < 0.0f)
  232. {
  233. Value = Value + (long)((Value / -360.0f) + 1.0f) * 360.0f;
  234. }
  235. }
  236. }
  238. long Setting = (long)(64.0f * (Value - BoneController->Start) / (BoneController->End - 
  239. BoneController->Start));
  241. if (Setting < 0)
  242. {
  243. Setting = 0;
  244. }
  246. if (Setting > 64)
  247. {
  248. Setting = 64;
  249. }
  251. MouthPosition = (BYTE)Setting;
  253. return Setting * (1.0f / 64.0f) * (BoneController->End - BoneController->Start) + 
  254. BoneController->Start;
  255. }
  257. float TMDLModel::SetBlending(long Blender, float Value)
  258. {
  259. tagMDLSeqDescription *SeqDescription = 
  260. (tagMDLSeqDescription *)((BYTE *)Header + Header->SequenceOffset) + CurrentSequence;
  262. if (0 == SeqDescription->BlendType[Blender])
  263. {
  264. return Value;
  265. }
  267. if (SeqDescription->BlendType[Blender] & (TRANSITION_XR | TRANSITION_YR | TRANSITION_ZR))
  268. {
  269. if (SeqDescription->BlendEnd[Blender] < SeqDescription->BlendStart[Blender])
  270. {
  271. Value = -Value;
  272. }
  274. if (SeqDescription->BlendStart[Blender] + 359.0f >= SeqDescription->BlendEnd[Blender])
  275. {
  276. if (Value > ((SeqDescription->BlendStart[Blender] + 
  277. SeqDescription->BlendEnd[Blender]) / 2.0f) + 180.0f)
  278. {
  279. Value = Value - 360.0f;
  280. }
  282. if (Value < ((SeqDescription->BlendStart[Blender] + 
  283. SeqDescription->BlendEnd[Blender]) / 2.0f) - 180.0f)
  284. {
  285. Value = Value + 360.0f;
  286. }
  287. }
  288. }
  290. long Setting = (long)(255.0f * (Value - SeqDescription->BlendStart[Blender]) / 
  291. (SeqDescription->BlendEnd[Blender] - SeqDescription->BlendStart[Blender]));
  293. if (Setting < 0)
  294. {
  295. Setting = 0;
  296. }
  298. if (Setting > 255)
  299. {
  300. Setting = 255;
  301. }
  303. Blending[Blender] = (BYTE)Setting;
  305. return Setting * (1.0f / 255.0f) * (SeqDescription->BlendEnd[Blender] - 
  306. SeqDescription->BlendStart[Blender]) + SeqDescription->BlendStart[Blender];
  307. }
  309. long TMDLModel::SetBodyGroup(long Group, long Value)
  310. {
  311. if (Group > Header->NumBodyParts)
  312. {
  313. return -1;
  314. }
  316. tagMDLBodyPart *BodyPart = 
  317. (tagMDLBodyPart *)((BYTE *)Header + Header->BodyPartOffset) + Group;
  319. long Current = (CurrentBodyPart / BodyPart->Base) % BodyPart->NumModels;
  321. if (Value >= BodyPart->NumModels)
  322. {
  323. return Current;
  324. }
  326. CurrentBodyPart = (CurrentBodyPart - (Current * BodyPart->Base) + (Value * BodyPart->Base));
  328. return Value;
  329. }
  331. long TMDLModel::SetSkin(long Value)
  332. {
  333. if (Value < Header->NumSkinFamilies)
  334. {
  335. return CurrentSkin;
  336. }
  338. CurrentSkin = Value;
  340. return Value;
  341. }
  343. tagMDLHeader *TMDLModel::LoadModel(char *Filename)
  344. {
  345. FILE *Handle;
  346. long Size;
  347. BYTE *Buffer;
  349. Handle = fopen(Filename, "rb");
  351. if (NULL == Handle)
  352. {
  353. printf("Unable to open %sn", Filename);
  355. exit(1);
  356. }
  358. fseek(Handle, 0, SEEK_END);
  359. Size = ftell(Handle);
  361. rewind(Handle);
  363. Buffer = new BYTE[Size];
  365. if (NULL == Buffer)
  366. {
  367. printf("Unable to allocate memoryn");
  369. exit(1);
  370. }
  372. fread(Buffer, Size, 1, Handle);
  373. fclose(Handle);
  375. tagMDLHeader *MDLHeader = (tagMDLHeader *)Buffer;
  376. tagMDLTexture *Texture = (tagMDLTexture *)(Buffer + MDLHeader->TextureOffset);
  378. if (MDLHeader->TextureOffset != 0)
  379. {
  380. for (long Loop = 0; Loop < MDLHeader->NumTextures; Loop++)
  381. {
  382. UploadTexture(&Texture[Loop], Buffer + Texture[Loop].Index, Buffer + 
  383. Texture[Loop].Width * Texture[Loop].Height + Texture[Loop].Index);
  384. }
  385. }
  387. return (tagMDLHeader *)Buffer;
  388. }
  390. tagMDLSeqHeader *TMDLModel::LoadDemandSequences(char *Filename)
  391. {
  392. FILE *Handle;
  393. long Size;
  394. BYTE *Buffer;
  396. Handle = fopen(Filename, "rb");
  398. if (NULL == Handle)
  399. {
  400. printf("Unable to open %sn", Filename);
  402. exit(1);
  403. }
  405. fseek(Handle, 0, SEEK_END);
  406. Size = ftell(Handle);
  408. rewind(Handle);
  410. Buffer = new BYTE[Size];
  412. if (NULL == Buffer)
  413. {
  414. printf("Unable to allocate memoryn");
  416. exit(1);
  417. }
  419. fread(Buffer, Size, 1, Handle);
  420. fclose(Handle);
  422. return (tagMDLSeqHeader *)Buffer;
  423. }
  425. void TMDLModel::CalcBoneQuaternion(long Frame, float Value, tagMDLBone *Bone, tagAnimation *Anim, 
  426. float *Q)
  427. {
  428. vec3_t Angle1;
  429. vec3_t Angle2;
  430. tagMDLAnimFrame *AnimValue;
  432. for (long Loop = 0; Loop < 3; Loop++)
  433. {
  434. if (0 == Anim->Offset[Loop + 3])
  435. {
  436. Angle2[Loop] = Angle1[Loop] = Bone->Value[Loop + 3];
  437. }
  439. else
  440. {
  441. AnimValue = (tagMDLAnimFrame *)((BYTE *)Anim + Anim->Offset[Loop + 3]);
  443. long Index = Frame;
  445. while (AnimValue->Total <= Index)
  446. {
  447. Index -= AnimValue->Total;
  448. AnimValue += AnimValue->Valid + 1;
  449. }
  451. if (AnimValue->Valid > Index)
  452. {
  453. Angle1[Loop] = AnimValue[Index + 1].Value;
  455. if (AnimValue->Valid > Index + 1)
  456. {
  457. Angle2[Loop] = AnimValue[Index + 2].Value;
  458. }
  460. else
  461. {
  462. if (AnimValue->Total > Index + 1)
  463. {
  464. Angle2[Loop] = Angle1[Loop];
  465. }
  467. else
  468. {
  469. Angle2[Loop] = AnimValue[AnimValue->Valid + 2].Value;
  470. }
  471. }
  472. }
  474. else
  475. {
  476. Angle1[Loop] = AnimValue[AnimValue->Valid].Value;
  478. if (AnimValue->Total > Index + 1)
  479. {
  480. Angle2[Loop] = Angle1[Loop];
  481. }
  483. else
  484. {
  485. Angle2[Loop] = AnimValue[AnimValue->Valid + 2].Value;
  486. }
  487. }
  489. Angle1[Loop] = Bone->Value[Loop + 3] + Angle1[Loop] * Bone->Scale[Loop + 3];
  490. Angle2[Loop] = Bone->Value[Loop + 3] + Angle2[Loop] * Bone->Scale[Loop + 3];
  491. }
  492. }
  494. if (!VectorCompare(Angle1, Angle2))
  495. {
  496. vec4_t Q1;
  497. vec4_t Q2;
  499. AngleQuaternion(Angle1, Q1);
  500. AngleQuaternion(Angle2, Q2);
  501. QuaternionSlerp(Q1, Q2, Value, Q);
  502. }
  504. else
  505. {
  506. AngleQuaternion(Angle1, Q);
  507. }
  508. }
  510. void TMDLModel::CalcBonePosition(long Frame, float Value, tagMDLBone *Bone, tagAnimation *Anim, 
  511. float *Pos)
  512. {
  513. tagMDLAnimFrame *AnimValue;
  515. for (long Loop = 0; Loop < 3; Loop++)
  516. {
  517. Pos[Loop] = Bone->Value[Loop];
  519. if (Anim->Offset[Loop] != 0)
  520. {
  521. AnimValue = (tagMDLAnimFrame *)((BYTE *)Anim + Anim->Offset[Loop]);
  523. long Index = Frame;
  525. while (AnimValue->Total <= Index)
  526. {
  527. Index -= AnimValue->Total;
  528. AnimValue += AnimValue->Valid + 1;
  529. }
  531. if (AnimValue->Valid > Index)
  532. {
  533. if (AnimValue->Valid > Index + 1)
  534. {
  535. Pos[Loop] += (AnimValue[Index + 1].Value * (1.0f - Value) + Value * 
  536. AnimValue[Index + 2].Value) * Bone->Scale[Loop];
  537. }
  539. else
  540. {
  541. Pos[Loop] += AnimValue[Index + 1].Value * Bone->Scale[Loop];
  542. }
  543. }
  545. else
  546. {
  547. if (AnimValue->Total <= Index + 1)
  548. {
  549. Pos[Loop] += (AnimValue[AnimValue->Valid].Value * (1.0f - Value) + Value * 
  550. AnimValue[AnimValue->Valid + 2].Value) * Bone->Scale[Loop];
  551. }
  553. else
  554. {
  555. Pos[Loop] += AnimValue[AnimValue->Valid].Value * Bone->Scale[Loop];
  556. }
  557. }
  558. }
  559. }
  560. }
  562. void TMDLModel::CalcRotations(vec3_t *Pos, vec4_t *Q, tagMDLSeqDescription *SeqDescription, 
  563. tagAnimation *Anim, float FrameValue)
  564. {
  565. long Frame;
  566. float Fractional;
  568. Frame = (long)FrameValue;
  569. Fractional = (FrameValue - Frame);
  571. tagMDLBone *Bone = (tagMDLBone *)((BYTE *)Header + Header->BoneOffset);
  573. for (long Loop = 0; Loop < Header->NumBones; Loop++, Bone++, Anim++) 
  574. {
  575. CalcBoneQuaternion(Frame, Fractional, Bone, Anim, Q[Loop]);
  576. CalcBonePosition(Frame, Fractional, Bone, Anim, Pos[Loop]);
  577. }
  579. if (SeqDescription->MotionType & TRANSITION_X)
  580. {
  581. Pos[SeqDescription->MotionBone][0] = 0.0f;
  582. }
  584. if (SeqDescription->MotionType & TRANSITION_Y)
  585. {
  586. Pos[SeqDescription->MotionBone][1] = 0.0f;
  587. }
  589. if (SeqDescription->MotionType & TRANSITION_Z)
  590. {
  591. Pos[SeqDescription->MotionBone][2] = 0.0f;
  592. }
  593. }
  595. tagAnimation *TMDLModel::GetAnim(tagMDLSeqDescription *SeqDescription)
  596. {
  597. tagMDLSeqGroup *pseqgroup = (tagMDLSeqGroup *)((BYTE *)Header + 
  598. Header->SeqGroupOffset) + SeqDescription->SeqGroup;
  600. if (SeqDescription->SeqGroup == 0)
  601. {
  602. return (tagAnimation *)((BYTE *)Header + pseqgroup->Data + 
  603. SeqDescription->AnimOffset);
  604. }
  606. return (tagAnimation *)((BYTE *)AnimationHeader[SeqDescription->SeqGroup] + 
  607. SeqDescription->AnimOffset);
  608. }
  610. void TMDLModel::SlerpBones(vec4_t Q1[], vec3_t Pos1[], vec4_t Q2[], vec3_t Pos2[], float Value)
  611. {
  612. vec4_t Q3;
  613. float Inverse;
  615. if (Value < 0.0f)
  616. {
  617. Value = 0.0f;
  618. }
  620. else if (Value > 1.0f)
  621. {
  622. Value = 1.0f;
  623. }
  625. Inverse = 1.0f - Value;
  627. for (long Loop = 0; Loop < Header->NumBones; Loop++)
  628. {
  629. QuaternionSlerp(Q1[Loop], Q2[Loop], Value, Q3);
  630. Q1[Loop][0] = Q3[0];
  631. Q1[Loop][1] = Q3[1];
  632. Q1[Loop][2] = Q3[2];
  633. Q1[Loop][3] = Q3[3];
  634. Pos1[Loop][0] = Pos1[Loop][0] * Inverse + Pos2[Loop][0] * Value;
  635. Pos1[Loop][1] = Pos1[Loop][1] * Inverse + Pos2[Loop][1] * Value;
  636. Pos1[Loop][2] = Pos1[Loop][2] * Inverse + Pos2[Loop][2] * Value;
  637. }
  638. }
  640. void TMDLModel::SetUpBones()
  641. {
  642. float BoneMatrix[3][4];
  643. static vec3_t Pos1[MAXBONES];
  644. static vec4_t Q1[MAXBONES];
  645. static vec3_t Pos2[MAXBONES];
  646. static vec4_t Q2[MAXBONES];
  647. static vec3_t Pos3[MAXBONES];
  648. static vec4_t Q3[MAXBONES];
  649. static vec3_t Pos4[MAXBONES];
  650. static vec4_t Q4[MAXBONES];
  652. if (CurrentSequence >= Header->NumSequences)
  653. {
  654. CurrentSequence = 0;
  655. }
  657. tagMDLSeqDescription *SeqDescription = (tagMDLSeqDescription *)((BYTE *)Header + 
  658. Header->SequenceOffset) + CurrentSequence;
  660. tagAnimation *Anim = GetAnim(SeqDescription);
  662. CalcRotations(Pos1, Q1, SeqDescription, Anim, CurrentFrame);
  664. if (SeqDescription->NumBlends > 1)
  665. {
  666. float Value;
  668. Anim += Header->NumBones;
  669. CalcRotations(Pos2, Q2, SeqDescription, Anim, CurrentFrame);
  671. Value = Blending[0] / 255.0f;
  673. SlerpBones(Q1, Pos1, Q2, Pos2, Value);
  675. if (4 == SeqDescription->NumBlends)
  676. {
  677. Anim += Header->NumBones;
  678. CalcRotations(Pos3, Q3, SeqDescription, Anim, CurrentFrame);
  680. Anim += Header->NumBones;
  681. CalcRotations(Pos4, Q4, SeqDescription, Anim, CurrentFrame);
  683. Value = Blending[0] / 255.0f;
  684. SlerpBones(Q3, Pos3, Q4, Pos4, Value);
  686. Value = Blending[1] / 255.0f;
  687. SlerpBones(Q1, Pos1, Q3, Pos3, Value);
  688. }
  689. }
  691. tagMDLBone *Bones = (tagMDLBone *)((BYTE *)Header + Header->BoneOffset);
  693. for (long Loop = 0; Loop < Header->NumBones; Loop++)
  694. {
  695. QuaternionMatrix(Q1[Loop], BoneMatrix);
  697. BoneMatrix[0][3] = Pos1[Loop][0];
  698. BoneMatrix[1][3] = Pos1[Loop][1];
  699. BoneMatrix[2][3] = Pos1[Loop][2];
  701. if (-1 == Bones[Loop].Parent)
  702. {
  703. memcpy(BoneTransforms[Loop], BoneMatrix, sizeof(float) * 12);
  704. } 
  706. else
  707. {
  708. R_ConcatTransforms(BoneTransforms[Bones[Loop].Parent], BoneMatrix, 
  709. BoneTransforms[Loop]);
  710. }
  711. }
  712. }
  714. void TMDLModel::Lighting(float *lv, long Bone, long Flags, vec3_t Normal)
  715. {
  716. float  Illumination;
  717. float LightCosine;
  719. Illumination = (float)AmbientLightColor;
  721. if (Flags & LIGHT_FLATSHADE)
  722. {
  723. Illumination += ShadeLight * 0.8f;
  724. } 
  726. else 
  727. {
  728. float Value;
  730. LightCosine = DotProduct (Normal, BoneLightVector[Bone]);
  732. if (LightCosine > 1.0f)
  733. {
  734. LightCosine = 1.0f;
  735. }
  737. Illumination += ShadeLight;
  739. Value = 1.5f;
  741. if (Value <= 1.0f)
  742. {
  743. Value = 1.0f;
  744. }
  746. LightCosine = (LightCosine + (Value - 1.0f)) / Value; 
  748. if (LightCosine > 0.0f) 
  749. {
  750. Illumination -= ShadeLight * LightCosine; 
  751. }
  753. if (Illumination <= 0)
  754. {
  755. Illumination = 0;
  756. }
  757. }
  759. if (Illumination > 255) 
  760. {
  761. Illumination = 255;
  762. }
  764. *lv = Illumination / 255.0f;
  765. }
  767. void TMDLModel::SetupLighting()
  768. {
  769. AmbientLightColor = 32;
  770. ShadeLight = 192;
  772. LightVector[0] = 0.0f;
  773. LightVector[1] = 0.0f;
  774. LightVector[2] = -1.0f;
  776. LightColor[0] = 1.0f;
  777. LightColor[1] = 1.0f;
  778. LightColor[2] = 1.0f;
  780. for (long Loop = 0; Loop < Header->NumBones; Loop++)
  781. {
  782. VectorIRotate(LightVector, BoneTransforms[Loop], BoneLightVector[Loop]);
  783. }
  784. }
  786. void TMDLModel::SetupModel(long BodyPart)
  787. {
  788. if (BodyPart > Header->NumBodyParts)
  789. {
  790. BodyPart = 0;
  791. }
  793. tagMDLBodyPart   *BodyPartPtr = (tagMDLBodyPart *)((BYTE *)Header + Header->BodyPartOffset) + 
  794. BodyPart;
  796. long Index = CurrentBodyPart / BodyPartPtr->Base;
  797. Index = Index % BodyPartPtr->NumModels;
  799. Model = (tagMDLModel *)((BYTE *)Header + BodyPartPtr->ModelOffset) + Index;
  800. }
  801. void TMDLModel::DrawModel()
  802. { TransformVertPtr = &TransformVertices[0];
  803. LightValuesPtr = &LightValues[0];
  804. if (0 == Header->NumBodyParts) return;
  805. /* glPushMatrix();
  806.     glTranslatef(Origin[0], Origin[1], Origin[2]);
  807.     glRotatef(Rotation[1], 0, 0, 1);
  808.     glRotatef(Rotation[0], 0, 1, 0);
  809.     glRotatef(Rotation[2], 1, 0, 0);
  810. glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);*/
  811. SetUpBones();
  812. SetupLighting();
  813. for (long Loop = 0; Loop < Header->NumBodyParts; Loop++) 
  814. { SetupModel(Loop);
  815. DrawPoints();
  816. }
  817. // glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
  818. // glPopMatrix();
  819. }
  820. /////////////////////////////////////////////////////////////
  821. void TMDLModel::DrawPoints()//显示0
  822. { float *LightValue;
  823. BYTE *BoneVertexPtr = ((BYTE *)Header + Model->VertexInfoOffset);
  824. BYTE *BoneNormalPtr = ((BYTE *)Header + Model->NormalInfoOffset);
  825. tagMDLTexture *Texture = (tagMDLTexture *)((BYTE *)TextureHeader + 
  826. TextureHeader->TextureOffset);
  827. tagMDLMesh *MeshPtr = (tagMDLMesh *)((BYTE *)Header + Model->MeshOffset);
  828. vec3_t *Vertices = (vec3_t *)((BYTE *)Header + Model->VertexOffset);
  829. vec3_t *Normals = (vec3_t *)((BYTE *)Header + Model->NormalOffset);
  830. short *SkinReference = (short *)((BYTE *)TextureHeader + TextureHeader->SkinOffset);
  831. if (CurrentSkin != 0 && CurrentSkin < TextureHeader->NumSkinFamilies)
  832. SkinReference += (CurrentSkin * TextureHeader->NumSkinReferences);
  833. for (long Loop = 0; Loop < Model->NumVertices; Loop++)
  834. { VectorTransform(Vertices[Loop], BoneTransforms[BoneVertexPtr[Loop]], 
  835. TransformVertPtr[Loop]);
  836. }
  837. LightValue = (float *)LightValuesPtr;
  838. for (long OuterLoop = 0; OuterLoop < Model->NumMesh; OuterLoop++) 
  839. { long Flags = Texture[SkinReference[MeshPtr[OuterLoop].SkinReference]].Flags;
  840. for (long InnerLoop = 0; InnerLoop < MeshPtr[OuterLoop].NumNormals; InnerLoop++, 
  841. LightValue += 3, Normals++, BoneNormalPtr++)
  842. { float Temp;
  843. Lighting(&Temp, *BoneNormalPtr, Flags, (float *)Normals);
  844. LightValue[0] = Temp * LightColor[0];
  845. LightValue[1] = Temp * LightColor[1];
  846. LightValue[2] = Temp * LightColor[2];
  847. }
  848. }
  849. // glCullFace(GL_FRONT);
  850. for (Loop = 0; Loop < Model->NumMesh; Loop++) 
  851. { MeshPtr = (tagMDLMesh *)((BYTE *)Header + Model->MeshOffset) + Loop;
  852. short *Triangles = (short *)((BYTE *)Header + MeshPtr->TriangleOffset);
  853. float U = 1.0f / (float)Texture[SkinReference[MeshPtr->SkinReference]].Width;
  854. float V = 1.0f / (float)Texture[SkinReference[MeshPtr->SkinReference]].Height;
  855. glBindTexture(GL_TEXTURE_2D, Texture[SkinReference[MeshPtr->SkinReference]].Index);
  856. long NumTriangles;
  857. while (NumTriangles = *(Triangles++))
  858. { if (NumTriangles < 0)
  859. { glBegin(GL_TRIANGLE_FAN);
  860. NumTriangles = -NumTriangles;
  861. }
  862. else glBegin(GL_TRIANGLE_STRIP);
  863. for (; NumTriangles > 0; NumTriangles--, Triangles += 4)
  864. { glTexCoord2f(Triangles[2] * U, Triangles[3] * V);
  865. LightValue = LightValuesPtr[Triangles[1]];
  866. glColor4f(LightValue[0], LightValue[1], LightValue[2], 1.0f);
  867. float *Vertex = TransformVertPtr[Triangles[0]];
  868. glVertex3f(Vertex[0], Vertex[1], Vertex[2]);
  869. }
  870. glEnd();
  871. }
  872. }
  873. }
  874. void TMDLModel::UploadTexture(tagMDLTexture *Texture, BYTE *Data, BYTE *Palette)
  875. { long Row1[256];
  876. long Row2[256];
  877. long Column1[256];
  878. long Column2[256];
  879. BYTE *TextureBuffer;
  880. BYTE *BufferPtr;
  881. for (long OutWidth = 1; OutWidth < Texture->Width; OutWidth <<= 1);
  882. if (OutWidth > 256) OutWidth = 256;
  883. for (long OutHeight = 1; OutHeight < Texture->Height; OutHeight <<= 1);
  884. if (OutHeight > 256) OutHeight = 256;
  885. TextureBuffer = new BYTE[OutWidth * OutHeight * 4];
  886. if (NULL == TextureBuffer)
  887. { printf("Unable to allocate memory.n");
  888. exit(1);
  889. }
  890. BufferPtr = TextureBuffer;
  891. for (long Loop = 0; Loop < OutWidth; Loop++)
  892. {
  893. Column1[Loop] = (long)((Loop + 0.25f) * (Texture->Width / (float)OutWidth));
  894. Column2[Loop] = (long)((Loop + 0.75f) * (Texture->Width / (float)OutWidth));
  895. }
  897. for (Loop = 0; Loop < OutHeight; Loop++)
  898. {
  899. Row1[Loop] = (long)((Loop + 0.25f) * (Texture->Height / (float)OutHeight)) * 
  900. Texture->Width;
  902. Row2[Loop] = (long)((Loop + 0.75f) * (Texture->Height / (float)OutHeight)) * 
  903. Texture->Width;
  904. }
  906. for (long OuterLoop = 0;  OuterLoop < OutHeight; OuterLoop++)
  907. {
  908. for (long InnerLoop = 0; InnerLoop < OutWidth; InnerLoop++, BufferPtr += 4)
  909. {
  910. BYTE *Pixel1 = &Palette[Data[Row1[OuterLoop] + Column1[InnerLoop]] * 3];
  911. BYTE *Pixel2 = &Palette[Data[Row1[OuterLoop] + Column2[InnerLoop]] * 3];
  912. BYTE *Pixel3 = &Palette[Data[Row2[OuterLoop] + Column1[InnerLoop]] * 3];
  913. BYTE *Pixel4 = &Palette[Data[Row2[OuterLoop] + Column2[InnerLoop]] * 3];
  915. BufferPtr[0] = (Pixel1[0] + Pixel2[0] + Pixel3[0] + Pixel4[0]) >> 2;
  916. BufferPtr[1] = (Pixel1[1] + Pixel2[1] + Pixel3[1] + Pixel4[1]) >> 2;
  917. BufferPtr[2] = (Pixel1[2] + Pixel2[2] + Pixel3[2] + Pixel4[2]) >> 2;
  918. BufferPtr[3] = 0xFF;
  919. }
  920. }
  922. glBindTexture(GL_TEXTURE_2D, CurrentTexture);
  923. glTexImage2D(GL_TEXTURE_2D, 0, 3, OutWidth, OutHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, 
  924. TextureBuffer);
  926. glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  927. glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  928. glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  930. Texture->Index = CurrentTexture;
  932. CurrentTexture++;
  934. delete [] TextureBuffer;
  935. }