Start work on transparent surfaces

Makefile

@@ -99,11 +99,16 @@ TEXTURE_SCRIPTS = $(shell find assets/ -type f -name '*.ims')
 TEXTURE_IMAGES = $(TEXTURE_SCRIPTS:assets/%.ims=portal_pak_modified/%.png)
 TEXTURE_VTF_SOURCES = $(TEXTURE_SCRIPTS:assets/%.ims=portal_pak_dir/%.vtf)
 
+ALL_VTF_IMAGES = $(shell find portal_pak_dir/ -type f -name '*.vtf')
+ALL_PNG_IMAGES = $(ALL_VTF_IMAGES:%.vtf=%.png)
+
 $(TEXTURE_VTF_SOURCES): portal_pak_dir
 
 %.png: %.vtf
 	$(VTF2PNG) $< $@
 
+convert_all_png: $(ALL_PNG_IMAGES)
+
 portal_pak_modified/%.png: portal_pak_dir/%.png assets/%.ims 
 	@mkdir -p $(@D)
 	convert $< $(shell cat $(@:portal_pak_modified/%.png=assets/%.ims)) $@

assets/materials/glass/glasswindow_frosted_002.ims

@@ -0,0 +1 @@
+-crop 32x512+256+0 -resize 8x128

assets/materials/static.skm.yaml

@@ -1,4 +1,11 @@
 materials:
+  default:
+    gDPSetRenderMode: G_RM_ZB_OPA_SURF
+
+    gSPGeometryMode:
+      set: [G_CULL_BACK, G_ZBUFFER]
+      clear: [G_CULL_FRONT]
+
   concrete_modular_wall001d:
     gDPSetTile: 
       filename: ../../portal_pak_modified/materials/concrete/concrete_modular_wall001d.png
@@ -17,7 +24,7 @@ materials:
       siz: G_IM_SIZ_16b
     
     gDPSetCombineMode: G_CC_DECALRGB
-    gsDPSetCycleType: G_CYC_1CYCLE
+    gDPSetCycleType: G_CYC_1CYCLE
 
     properties:
       tileSizeS: 0.5
@@ -29,7 +36,7 @@ materials:
       siz: G_IM_SIZ_16b
 
     gDPSetCombineMode: G_CC_DECALRGB
-    gsDPSetCycleType: G_CYC_1CYCLE
+    gDPSetCycleType: G_CYC_1CYCLE
 
     properties:
       tileSizeS: 0.5
@@ -41,8 +48,30 @@ materials:
       siz: G_IM_SIZ_16b
 
     gDPSetCombineMode: G_CC_DECALRGB
-    gsDPSetCycleType: G_CYC_1CYCLE
+    gDPSetCycleType: G_CYC_1CYCLE
 
     properties:
       tileSizeS: 0.5
-      tileSizeT: 0.5
+      tileSizeT: 0.5
+
+  glasswindow_frosted_002:
+    gDPSetTile:
+      filename: ../../portal_pak_modified/materials/glass/glasswindow_frosted_002.png
+      siz: G_IM_SIZ_32b
+
+    gDPSetCombineMode: G_CC_DECALRGBA
+    gDPSetCycleType: G_CYC_1CYCLE
+    gDPSetRenderMode: G_RM_ZB_XLU_SURF
+    gDPSetTextureFilter: G_TF_POINT
+    gSPGeometryMode:
+      clear: [G_CULL_BACK, G_CULL_FRONT]
+
+    gDPSetPrimColor:
+      r: 128
+      g: 0
+      b: 0
+      a: 128
+
+    properties:
+      tileSizeS: 0.03125
+      tileSizeT: 2

skelatool64/main.cpp

@@ -116,6 +116,12 @@ int main(int argc, char *argv[]) {
         return 1;
     }
 
+    auto defaultMaterial = settings.mMaterials.find("default");
+
+    if (defaultMaterial != settings.mMaterials.end()) {
+        settings.mDefaultMaterialState = defaultMaterial->second->mState;
+    }
+
     const aiScene* scene = NULL;
 
     if (args.mInputFile.length()) {

skelatool64/src/definition_generator/MaterialGenerator.cpp

@@ -1,6 +1,7 @@
 #include "MaterialGenerator.h"
 
 #include "../StringUtils.h"
+#include "../materials/RenderMode.h"
 
 MaterialGenerator::MaterialGenerator(const DisplayListSettings& settings): mSettings(settings) {}
 
@@ -9,6 +10,19 @@ bool MaterialGenerator::ShouldIncludeNode(aiNode* node) {
     return false;
 }
 
+int sortOrderForMaterial(const Material& material) {
+    // assume opaque
+    if (!material.mState.hasRenderMode) {
+        return 0;
+    }
+
+    if (material.mState.cycle1RenderMode.data & FORCE_BL) {
+        return 1;
+    }
+
+    return 0;
+}
+
 void MaterialGenerator::GenerateDefinitions(const aiScene* scene, CFileDefinition& fileDefinition) {
     std::set<std::shared_ptr<TextureDefinition>> textures;
 
@@ -29,28 +43,45 @@ void MaterialGenerator::GenerateDefinitions(const aiScene* scene, CFileDefinitio
     std::unique_ptr<StructureDataChunk> materialList(new StructureDataChunk());
     std::unique_ptr<StructureDataChunk> revertList(new StructureDataChunk());
 
+    std::vector<std::shared_ptr<Material>> materialsAsVector;
+
     for (auto& entry : mSettings.mMaterials) {
-        std::string name = fileDefinition.GetUniqueName(entry.first);
+        materialsAsVector.push_back(entry.second);
+    }
+
+    std::sort(materialsAsVector.begin(), materialsAsVector.end(), [&](const std::shared_ptr<Material>& a, const std::shared_ptr<Material>& b) -> bool {
+        return sortOrderForMaterial(*a) < sortOrderForMaterial(*b);
+    });
+
+    for (auto& entry : materialsAsVector) {
+        std::string name = fileDefinition.GetUniqueName(entry->mName);
 
         DisplayList dl(name);
-        entry.second->Write(fileDefinition, mSettings.mDefaultMaterialState, dl.GetDataChunk());
+        entry->Write(fileDefinition, mSettings.mDefaultMaterialState, dl.GetDataChunk());
         std::unique_ptr<FileDefinition> material = dl.Generate("_mat");
         materialList->AddPrimitive(material->GetName());
         fileDefinition.AddDefinition(std::move(material));
 
-        std::string revertName = fileDefinition.GetUniqueName(entry.first + "_revert");
+        std::string revertName = fileDefinition.GetUniqueName(entry->mName + "_revert");
         DisplayList revertDL(revertName);
-        generateMaterial(fileDefinition, entry.second->mState, mSettings.mDefaultMaterialState, revertDL.GetDataChunk());
+        generateMaterial(fileDefinition, entry->mState, mSettings.mDefaultMaterialState, revertDL.GetDataChunk());
         std::unique_ptr<FileDefinition> materialRevert = revertDL.Generate("_mat");
         revertList->AddPrimitive(materialRevert->GetName());
         fileDefinition.AddDefinition(std::move(materialRevert));
 
-        fileDefinition.AddMacro(MaterialIndexMacroName(entry.second->mName), std::to_string(index));
+        fileDefinition.AddMacro(MaterialIndexMacroName(entry->mName), std::to_string(index));
 
         ++index;
     }
 
+    unsigned transparentIndex = 0;
+
+    while (transparentIndex < materialsAsVector.size() && sortOrderForMaterial(*materialsAsVector[transparentIndex]) == 0) {
+        ++transparentIndex;
+    }
+
     fileDefinition.AddMacro(fileDefinition.GetMacroName("MATERIAL_COUNT"), std::to_string(index));
+    fileDefinition.AddMacro(fileDefinition.GetMacroName("TRANSPARENT_START"), std::to_string(transparentIndex + 1));
 
     fileDefinition.AddDefinition(std::unique_ptr<FileDefinition>(new DataFileDefinition("Gfx*", fileDefinition.GetUniqueName("material_list"), true, "_mat", std::move(materialList))));
     fileDefinition.AddDefinition(std::unique_ptr<FileDefinition>(new DataFileDefinition("Gfx*", fileDefinition.GetUniqueName("material_revert_list"), true, "_mat", std::move(revertList))));

skelatool64/src/materials/MaterialState.cpp

@@ -115,6 +115,10 @@ bool RenderModeState::operator==(const RenderModeState& other) const {
     return data == other.data;
 }
 
+int RenderModeState::GetZMode() const {
+    return data & ZMODE_MASK;
+}
+
 #define DEFINE_RENDER_MODE_ENTRY(name)  std::make_pair(std::string(#name), RenderModeState(name))
 
 std::pair<std::string, RenderModeState> gRenderModes[] = {

skelatool64/src/materials/MaterialState.h

@@ -75,6 +75,8 @@ public:
     RenderModeState(int data);
 
     bool operator==(const RenderModeState& other) const;
+
+    int GetZMode() const;
     
     int data;
 };

src/levels/levels.c

@@ -27,6 +27,10 @@ int levelMaterialCount() {
     return STATIC_MATERIAL_COUNT;
 }
 
+int levelMaterialTransparentStart() {
+    return STATIC_TRANSPARENT_START;
+}
+
 Gfx* levelMaterial(int index) {
     if (index < 0 || index >= STATIC_MATERIAL_COUNT) {
         return NULL;
@@ -35,6 +39,10 @@ Gfx* levelMaterial(int index) {
     return static_material_list[index];
 }
 
+Gfx* levelMaterialDefault() {
+    return static_material_list[DEFAULT_INDEX];
+}
+
 Gfx* levelMaterialRevert(int index) {
     if (index < 0 || index >= STATIC_MATERIAL_COUNT) {
         return NULL;

src/levels/levels.h

@@ -10,7 +10,9 @@ void levelLoad(int index);
 extern struct LevelDefinition* gCurrentLevel;
 
 int levelMaterialCount();
+int levelMaterialTransparentStart();
 Gfx* levelMaterial(int index);
+Gfx* levelMaterialDefault();
 Gfx* levelMaterialRevert(int index);
 
 int levelQuadIndex(struct CollisionObject* pointer);

src/levels/static_render.c

@@ -2,6 +2,7 @@
 
 #include "levels.h"
 #include "util/memory.h"
+#include "defs.h"
 
 u16* gRenderOrder;
 u16* gRenderOrderCopy;
@@ -13,9 +14,21 @@ void staticRenderInit() {
     gSortKey = malloc(sizeof(int) * gCurrentLevel->staticContentCount);
 }
 
-int staticRenderGenerateSortKey(int index) {
+int staticRenderGenerateSortKey(int index, struct FrustrumCullingInformation* cullingInfo) {
-    // TODO determine distance
+    struct BoundingBoxs16* box = &gCurrentLevel->staticBoundingBoxes[index];
-    return (int)gCurrentLevel->staticContent[index].materialIndex << 23;
+    struct Vector3 boxCenter;
+    boxCenter.x = (box->minX + box->maxX) >> 1;
+    boxCenter.y = (box->minY + box->maxY) >> 1;
+    boxCenter.z = (box->minZ + box->maxZ) >> 1;
+
+    int distance = (int)sqrtf(vector3DistSqrd(&boxCenter, &cullingInfo->cameraPosScaled));
+
+    // sort transparent surfaces from back to front
+    if (gCurrentLevel->staticContent[index].materialIndex >= levelMaterialTransparentStart()) {
+        distance = 0x1000000 - distance;
+    }
+
+    return ((int)gCurrentLevel->staticContent[index].materialIndex << 23) | (distance & 0x7FFFFF);
 }
 
 void staticRenderSort(int min, int max) {
@@ -91,15 +104,16 @@ void staticRender(struct FrustrumCullingInformation* cullingInfo, struct RenderS
             continue;
         }
 
-        // TODO filter
         gRenderOrder[renderCount] = i;
-        gSortKey[renderCount] = staticRenderGenerateSortKey(i);
+        gSortKey[i] = staticRenderGenerateSortKey(i, cullingInfo);
         ++renderCount;
     }
 
     staticRenderSort(0, renderCount);
 
     int prevMaterial = -1;
+
+    gSPDisplayList(renderState->dl++, levelMaterialDefault());
     
     for (int i = 0; i < renderCount; ++i) {
         struct StaticContentElement* element = &gCurrentLevel->staticContent[gRenderOrder[i]];

src/scene/camera.c

@@ -71,6 +71,7 @@ Mtx* cameraSetupMatrices(struct Camera* camera, struct RenderState* renderState,
         cameraExtractClippingPlane(combined, &clippingInfo->clippingPlanes[2], 1, 1.0f);
         cameraExtractClippingPlane(combined, &clippingInfo->clippingPlanes[3], 1, -1.0f);
         cameraExtractClippingPlane(combined, &clippingInfo->clippingPlanes[4], 2, 1.0f);
+        vector3Scale(&camera->transform.position, &clippingInfo->cameraPosScaled, SCENE_SCALE);
     }
 
     gSPMatrix(renderState->dl++, osVirtualToPhysical(&viewProjMatrix[1]), G_MTX_PROJECTION | G_MTX_LOAD | G_MTX_NOPUSH);

src/scene/camera.h

@@ -11,10 +11,6 @@
 
 #define CLIPPING_PLANE_COUNT    5
 
-struct FrustrumCullingInformation {
-    struct Plane clippingPlanes[CLIPPING_PLANE_COUNT];
-};
-
 struct Camera {
     struct Transform transform;
     float nearPlane;
@@ -22,6 +18,12 @@ struct Camera {
     float fov;
 };
 
+struct FrustrumCullingInformation {
+    struct Plane clippingPlanes[CLIPPING_PLANE_COUNT];
+
+    struct Vector3 cameraPosScaled;
+};
+
 void cameraInit(struct Camera* camera, float fov, float near, float far);
 void cameraBuildViewMatrix(struct Camera* camera, float matrix[4][4]);
 void cameraBuildProjectionMatrix(struct Camera* camera, float matrix[4][4], u16* perspectiveNorm, float aspectRatio);