diff --git a/src/mayaToAppleseed/mtap_devmodule/resources/checker.jpeg b/src/mayaToAppleseed/mtap_devmodule/resources/checker.jpeg
new file mode 100644
index 0000000..b837269
Binary files /dev/null and b/src/mayaToAppleseed/mtap_devmodule/resources/checker.jpeg differ
diff --git a/src/mayaToAppleseed/mtap_devmodule/resources/swatchRender.xml b/src/mayaToAppleseed/mtap_devmodule/resources/swatchRender.xml
new file mode 100644
index 0000000..a4fdf34
--- /dev/null
+++ b/src/mayaToAppleseed/mtap_devmodule/resources/swatchRender.xml
@@ -0,0 +1,458 @@
+
+
+
+
+
+ H:/UserDatenHaggi/Documents/coding/OpenMaya/src/mayaToAppleseed/mtap_devmodule/shaders
+
+
+ H:/UserDatenHaggi/Documents/coding/OpenMaya/src/mayaToAppleseed/mtap_devmodule/2015/plug-ins
+
+
+ H:/UserDatenHaggi/Documents/coding/OpenMaya/src/mayaToAppleseed/mtap_devmodule/shaders/surface
+
+
+ H:/UserDatenHaggi/Documents/coding/OpenMaya/src/mayaToAppleseed/mtap_devmodule/shaders/color
+
+
+ H:/UserDatenHaggi/Documents/coding/OpenMaya/src/mayaToAppleseed/mtap_devmodule/shaders/emission
+
+
+ H:/UserDatenHaggi/Documents/coding/OpenMaya/src/mayaToAppleseed/mtap_devmodule/shaders/maya
+
+
+ H:/UserDatenHaggi/Documents/coding/OpenMaya/src/mayaToAppleseed/mtap_devmodule/shaders/vector
+
+
+ H:/UserDatenHaggi/Documents/coding/OpenMaya/src/mayaToAppleseed/mtap_devmodule/shaders/texture3d
+
+
+ H:/UserDatenHaggi/Documents/coding/OpenMaya/src/mayaToAppleseed/mtap_devmodule/shaders/material
+
+
+ H:/UserDatenHaggi/Documents/coding/OpenMaya/src/mayaToAppleseed/mtap_devmodule/shaders/transparency
+
+
+ H:/UserDatenHaggi/Documents/coding/OpenMaya/src/mayaToAppleseed/mtap_devmodule/shaders/float
+
+
+ H:/UserDatenHaggi/Documents/coding/OpenMaya/src/mayaToAppleseed/mtap_devmodule/shaders/normal
+
+
+ H:/UserDatenHaggi/Documents/coding/OpenMaya/src/mayaToAppleseed/mtap_devmodule/shaders/transform
+
+
+ H:/UserDatenHaggi/Documents/coding/OpenMaya/src/mayaToAppleseed/mtap_devmodule/shaders/fresnel
+
+
+ H:/UserDatenHaggi/Documents/coding/OpenMaya/src/mayaToAppleseed/mtap_devmodule/shaders/input
+
+
+ H:/UserDatenHaggi/Documents/coding/OpenMaya/src/mayaToAppleseed/mtap_devmodule/shaders/texture2d
+
+
+ H:/UserDatenHaggi/Documents/coding/OpenMaya/src/mayaToAppleseed/mtap_devmodule/shaders/utility
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 1.000000000000000 0.000000000000000 0.000000000000000 0.000000000000000
+ 0.000000000000000 1.000000000000000 0.000000000000000 0.000000000000000
+ 0.000000000000000 0.000000000000000 1.000000000000000 0.026183956021985
+ 0.000000000000000 0.000000000000000 0.000000000000000 1.000000000000000
+
+
+
+
+
+
+
+ 1.000000 1.000000 1.000000
+
+
+ 1.000000
+
+
+
+
+
+
+ 1.000000 1.000000 1.000000
+
+
+ 1.000000
+
+
+
+
+
+
+ 0.600000 0.700000 0.900000
+
+
+ 1.000000
+
+
+
+
+
+
+ 0.800000 0.800000 0.900000
+
+
+ 1.000000
+
+
+
+
+
+
+ 0.200000 0.300000 0.600000
+
+
+ 1.000000
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 0.500000 0.500000 0.500000
+
+
+ 1.000000
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 2.000000000000000 0.000000000000000 0.000000000000000 0.000000000000000
+ 0.000000000000000 1.000000000000000 0.000000000000000 0.000000000000000
+ 0.000000000000000 0.000000000000000 1.000000000000000 0.000000000000000
+ 0.000000000000000 0.000000000000000 0.000000000000000 1.000000000000000
+
+
+
+
+
+
+
+ 2.880829495736127 0.026724595476459 0.008945042218900 -4.123433917033322
+ 0.008330395258277 -1.681090976944390 2.339623160476478 4.373258714237430
+ 0.026922523999788 -2.339485354628176 -1.681087818785416 6.591801961425044
+ 0.000000000000000 0.000000000000000 0.000000000000000 1.000000000000000
+
+
+
+
+
+
+
+ 1.000000000000000 0.000000000000000 0.000000000000000 0.000000000000000
+ 0.000000000000000 1.000000000000000 0.000000000000000 0.000000000000000
+ 0.000000000000000 0.000000000000000 1.000000000000000 0.000000000000000
+ 0.000000000000000 0.000000000000000 0.000000000000000 1.000000000000000
+
+
+
+
+
+
+
+
+
+
+
+
+ 1.000000000000000 0.000000000000000 0.000000000000000 0.000000000000000
+ 0.000000000000000 1.000000000000000 0.000000000000000 0.000000000000000
+ 0.000000000000000 0.000000000000000 1.000000000000000 0.000000000000000
+ 0.000000000000000 0.000000000000000 0.000000000000000 1.000000000000000
+
+
+
+
+
+
+
+ 0.909787924054713 -0.405999791405418 -0.086313976985035 -1.491024445174220
+ 0.306617011548300 0.517210506202792 0.799048997560626 2.000398599224409
+ -0.279771230603516 -0.753430462386681 0.595038315467488 -0.702855912829005
+ 0.000000000000000 0.000000000000000 0.000000000000000 1.000000000000000
+
+
+
+
+
+
+
+ 1.000000000000000 0.000000000000000 0.000000000000000 0.000000000000000
+ 0.000000000000000 1.000000000000000 0.000000000000000 0.000000000000000
+ 0.000000000000000 0.000000000000000 1.000000000000000 0.000000000000000
+ 0.000000000000000 0.000000000000000 0.000000000000000 1.000000000000000
+
+
+
+
+
+
+
+ 0.009999999776483 0.000000000000000 0.000000000000000 0.000000000000000
+ 0.000000000000000 0.009999999776483 0.000000000000000 0.000000000000000
+ 0.000000000000000 0.000000000000000 0.009999999776483 0.000000000000000
+ 0.000000000000000 0.000000000000000 0.000000000000000 1.000000000000000
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/mayaToAppleseed/mtap_devmodule/resources/swatchRenderBg.binarymesh b/src/mayaToAppleseed/mtap_devmodule/resources/swatchRenderBg.binarymesh
new file mode 100644
index 0000000..e9de75e
Binary files /dev/null and b/src/mayaToAppleseed/mtap_devmodule/resources/swatchRenderBg.binarymesh differ
diff --git a/src/mayaToAppleseed/mtap_devmodule/resources/swatchRenderMeshLight.binarymesh b/src/mayaToAppleseed/mtap_devmodule/resources/swatchRenderMeshLight.binarymesh
new file mode 100644
index 0000000..8ea3846
Binary files /dev/null and b/src/mayaToAppleseed/mtap_devmodule/resources/swatchRenderMeshLight.binarymesh differ
diff --git a/src/mayaToAppleseed/mtap_devmodule/resources/swatchRenderSphere.binarymesh b/src/mayaToAppleseed/mtap_devmodule/resources/swatchRenderSphere.binarymesh
new file mode 100644
index 0000000..c7ce772
Binary files /dev/null and b/src/mayaToAppleseed/mtap_devmodule/resources/swatchRenderSphere.binarymesh differ
diff --git a/src/mayaToCorona/mtco_devmodule/resources/Config-703093.conf b/src/mayaToCorona/mtco_devmodule/resources/Config-703093.conf
new file mode 100644
index 0000000..aa3699b
--- /dev/null
+++ b/src/mayaToCorona/mtco_devmodule/resources/Config-703093.conf
@@ -0,0 +1,140 @@
+#####################################################
+# Default Corona auto-generated initial config file #
+# #
+# format: #
+# type name = value #
+#####################################################
+ int system.drMaxDumpPixels = 500000
+string system.sceneReportFile =
+string system.sceneExportPath =
+ int system.randomSampler = 3
+ int system.randomSeed = 1234
+ int system.numThreads = 0
+ bool system.showPrevisualizations = true
+ bool system.minimizePrecomp = false
+ int system.vfbUpdateInterval = 1000
+ int system.threadPriority = 0
+ float geometry.shadowBias = -6.07
+ int geometry.minInstanceSaving = 50000
+ float geometry.maxNormalDiff = 0.55
+ int geometry.accelerationStructure = 2
+ bool geometry.embree.lowMemory = false
+ bool geometry.embree.highQuality = true
+ bool geometry.embree.precise = true
+ float geometry.bvh.costIteration = 1
+ float geometry.bvh.costTriangle = 1
+ int geometry.bvh.leafSizeMin = 2
+ int geometry.bvh.leafSizeMax = 6
+ int geometry.displace.subdivType = 0
+ float geometry.displace.maxSizeScreen = 2
+ float geometry.displace.maxSizeWorld = 1
+ bool geometry.displace.filterMap = false
+ bool geometry.displace.smoothNormals = true
+ float geometry.displace.maxSizeScreenOutFrustumMultiplier = 100
+ int progressive.passLimit = 0
+ int progressive.timeLimit = 0
+ int progressive.adaptivityInterval = 0
+ float progressive.adaptivityAmount = 0
+ int bucket.samplesPerIteration = 1
+ int bucket.passes = 2
+ float bucket.adaptiveThreshold = 0.03
+ int bucket.size = 32
+ bool bucket.showOrder = false
+ int image.width = 640
+ int image.height = 480
+ int image.region.startX = 0
+ int image.region.startY = 0
+ int image.region.endX = 0
+ int image.region.endY = 0
+ int image.internalResMult = 1
+ int image.filter.type = 3
+ float image.filter.width = 1.5
+ float image.filter.blurring = 0.5
+ float colorMap.gamma = 2.2
+ float colorMap.highlightCompression = 1
+ float colorMap.colorTemp = 6500
+ float colorMap.contrast = 1
+ bool colorMap.usePhotographic = false
+ float colorMap.simpleExposure = 0
+ float colorMap.iso = 100
+ float colorMap.fStop = 16
+ float colorMap.shutterSpeed = 50
+ Vec3 colorMap.tint = 1 1 1
+ bool shading.enable = true
+ bool shading.enableAa = true
+ int shading.renderEngine = 2
+ int shading.primarySolver = 1
+ int shading.secondarySolver = 4
+ float shading.maxSampleIntensity = 20
+ int shading.giToAaRatio = 16
+ float shading.firstPassQuality = 1
+ Vec3 shading.exitColor = 0 0 0
+ int shading.maxRayDepth = 25
+ float lights.samplesMult = 2
+ float lights.texturedRes = 0.3
+ int lights.samplingMode = 2
+ int lights.envResolution = 1000
+ int lights.areaMethod = 2
+ int lights.solver = 1
+ int lights.enviroSolver = 0
+ float lights.enviroSubdivThreshold = 0.005
+ float lights.enviroDistance = 10000
+ float lights.portalSampleFraction = 0.75
+ float lights.solverFracLocal = 0.33
+ float lights.solverFractGlobal = 0.33
+ bool gi.ic.incrementalBuild = false
+string gi.ic.incrementalFilename = incrementalIc.dat
+ int gi.ic.hemisphereSubdiv = 7
+ float gi.ic.precompAmount = 1
+ bool gi.ic.pathtracingCorners = true
+ float gi.ic.maxError = 0.6
+ float gi.ic.smoothing = 1.8
+ float gi.ic.colorThreshold = 10
+ float gi.ic.recordSpacingMin = 1
+ float gi.ic.recordSpacingMax = 20
+ bool gi.ic.useRotGrad = true
+ bool gi.ic.useTransGrad = true
+ int gi.ic.interpolationSchema = 1
+ int gi.ic.searchStructure = 0
+ bool gi.ic.relaxedInterpolation = true
+ int gi.ic.viz = 2
+ int gi.ic.minInterpSamples = 2
+ float gi.hdCache.precompDensity = 1
+ int gi.hdCache.interpolationCount = 3
+ float gi.hdCache.dirSensitivity = 2
+ float gi.hdCache.posSensitivity = 20
+ float gi.hdCache.normalSensitivity = 3
+ int gi.hdCache.recordQuality = 256
+ float gi.hdCache.smoothing = 2
+ float gi.hdCache.glossyThreshold = 0.9
+ int gi.hdCache.maxRecords = 100000
+ int gi.hdCache.writablePasses = 0
+ bool gi.hdCache.save = false
+ int gi.hdCache.precalcMode = 0
+string gi.hdCache.file = C:/HdCache.hdc
+ bool gi.hdCache.doViz = false
+ float gi.uhdcache.precision = 1
+ float gi.uhdcache.precompDensity = 1
+ int gi.uhdcache.interpolationCount = 5
+ int gi.uhdcache.recordQuality = 512
+ float gi.uhdcache.normalSensitivity = 2
+ float gi.uhdcache.dirSensitivity = 3
+ float gi.uhdcache.glossThreshold = 0.9
+ float gi.uhdcache.strictness = 0.075
+ float gi.uhdcache.msi = 3
+ bool gi.uhdcache.correlatePrecomp = true
+ int gi.photons.emitted = 5000000
+ bool gi.photons.storeDirect = true
+ int gi.photons.depth = -1
+ int gi.photons.lookupCount = 50
+ int gi.photons.filter = 1
+ int gi.vpl.emittedCount = 1000000
+ int gi.vpl.usedCount = 150
+ int gi.vpl.progressiveBatch = 150
+ float gi.vpl.clamping = 50
+ int gi.ppm.ptSamplesPerIter = 1
+ int gi.ppm.photonsPerIter = 5000000
+ float gi.ppm.alpha = 0.666
+ float gi.ppm.initialRadius = 2
+ bool gi.vcm.mis = true
+ int gi.vcm.mode = 4
diff --git a/src/mayaToCorona/mtco_devmodule/resources/releaseNotes.txt b/src/mayaToCorona/mtco_devmodule/resources/releaseNotes.txt
index 7eb137e..d6c1b46 100644
--- a/src/mayaToCorona/mtco_devmodule/resources/releaseNotes.txt
+++ b/src/mayaToCorona/mtco_devmodule/resources/releaseNotes.txt
@@ -5,6 +5,8 @@ release 0.42
- fixed some physical sky problems
- added area light render attributes
- added texturing for area lights
+- redesigned render globals UI
+- added wire/AO/Sky shader
release 0.41
- fixed a problem with esc key which caused a premature stop of the next rendering.
diff --git a/src/mayaToCorona/mtco_devmodule/scripts/Corona/AETemplate/AECoronaAOTemplate.py b/src/mayaToCorona/mtco_devmodule/scripts/Corona/AETemplate/AECoronaAOTemplate.py
new file mode 100644
index 0000000..69b8bc9
--- /dev/null
+++ b/src/mayaToCorona/mtco_devmodule/scripts/Corona/AETemplate/AECoronaAOTemplate.py
@@ -0,0 +1,54 @@
+import pymel.core as pm
+import logging
+
+log = logging.getLogger("ui")
+
+class BaseTemplate(pm.ui.AETemplate):
+
+ def addControl(self, control, label=None, **kwargs):
+ pm.ui.AETemplate.addControl(self, control, label=label, **kwargs)
+
+ def beginLayout(self, name, collapse=True):
+ pm.ui.AETemplate.beginLayout(self, name, collapse=collapse)
+
+
+class AECoronaAOTemplate(BaseTemplate):
+ def __init__(self, nodeName):
+ BaseTemplate.__init__(self,nodeName)
+ log.debug("AECoronaLightTemplate")
+ self.thisNode = None
+ self.node = pm.PyNode(self.nodeName)
+ pm.mel.AEswatchDisplay(nodeName)
+ self.beginScrollLayout()
+ self.buildBody(nodeName)
+ allAttributes = self.node.listAttr()
+ allowedAttributes = ["maxDist", "maxSamplesCount", "phongExponent", "mixExponent", "invert", "excludeMode", "useOffset", "offset"]
+ for att in allAttributes:
+ att = att.split(".")[-1]
+ if not att in allowedAttributes:
+ self.suppress(att)
+ self.addExtraControls("ExtraControls")
+ self.endScrollLayout()
+
+ def updateUI(self, nodeName=None):
+ self.thisNode = pm.PyNode(nodeName)
+ self.dimControl(nodeName, "offset", True)
+ if self.thisNode.useOffset.get():
+ self.dimControl(nodeName, "offset", False)
+
+ def buildBody(self, nodeName):
+ self.thisNode = pm.PyNode(nodeName)
+ self.beginLayout("Ambient Occlusion" ,collapse=0)
+ self.beginNoOptimize()
+ self.addControl("maxDist", label="Max Dist")
+ self.addControl("maxSamplesCount", label="Max Samples")
+ self.addControl("phongExponent", label="Phong Exponent")
+ self.addControl("mixExponent", label="Mix Exponent")
+ self.addControl("invert", label="Invert")
+ self.addControl("excludeMode", label="Exclude Node")
+ self.addControl("useOffset", label="Use Offset", changeCommand=self.updateUI)
+ self.addControl("offset", label="Offset")
+ self.endNoOptimize()
+ self.endLayout()
+ self.updateUI(self.thisNode)
+
\ No newline at end of file
diff --git a/src/mayaToCorona/mtco_devmodule/scripts/Corona/AETemplate/AECoronaFrontBackTemplate.py b/src/mayaToCorona/mtco_devmodule/scripts/Corona/AETemplate/AECoronaFrontBackTemplate.py
new file mode 100644
index 0000000..48228fd
--- /dev/null
+++ b/src/mayaToCorona/mtco_devmodule/scripts/Corona/AETemplate/AECoronaFrontBackTemplate.py
@@ -0,0 +1,50 @@
+import pymel.core as pm
+import logging
+
+log = logging.getLogger("ui")
+
+class BaseTemplate(pm.ui.AETemplate):
+
+ def addControl(self, control, label=None, **kwargs):
+ pm.ui.AETemplate.addControl(self, control, label=label, **kwargs)
+
+ def beginLayout(self, name, collapse=True):
+ pm.ui.AETemplate.beginLayout(self, name, collapse=collapse)
+
+
+class AECoronaFrontBackTemplate(BaseTemplate):
+ def __init__(self, nodeName):
+ BaseTemplate.__init__(self,nodeName)
+ log.debug("AECoronaLightTemplate")
+ self.thisNode = None
+ self.node = pm.PyNode(self.nodeName)
+ pm.mel.AEswatchDisplay(nodeName)
+ self.beginScrollLayout()
+ self.buildBody(nodeName)
+ allAttributes = self.node.listAttr()
+ allowedAttributes = ["frontMaterial", "backMaterial", "opacity"]
+ for att in allAttributes:
+ att = att.split(".")[-1]
+ if not att in allowedAttributes:
+ self.suppress(att)
+ self.addExtraControls("ExtraControls")
+ self.endScrollLayout()
+
+ def buildBody(self, nodeName):
+ self.thisNode = pm.PyNode(nodeName)
+ self.beginLayout("Emission" ,collapse=0)
+ self.beginNoOptimize()
+ self.addControl("frontMaterial", label="Front Material")
+ self.addControl("backMaterial", label="Back Material")
+ self.addSeparator()
+ self.addControl("iesProfile", label="IES Profile")
+ self.addControl("emissionSharpnessFake", label="Sharp Patterns")
+ #self.addControl("emissionDisableSampling", label="Disable Sampling")
+ #self.addControl("emissionSharpnessFakePoint", label="Sharpness Fake Point")
+ self.endNoOptimize()
+ self.endLayout()
+
+ #self.beginLayout("Hardware Texturing" ,collapse=0)
+ #pm.mel.eval('AEhardwareTextureTemplate "%s"' % self.nodeName + r'("diffuse emissionColor ")')
+ #self.endLayout()
+
\ No newline at end of file
diff --git a/src/mayaToCorona/mtco_devmodule/scripts/Corona/AETemplate/AECoronaSkyTemplate.py b/src/mayaToCorona/mtco_devmodule/scripts/Corona/AETemplate/AECoronaSkyTemplate.py
new file mode 100644
index 0000000..7606186
--- /dev/null
+++ b/src/mayaToCorona/mtco_devmodule/scripts/Corona/AETemplate/AECoronaSkyTemplate.py
@@ -0,0 +1,82 @@
+import pymel.core as pm
+import logging
+
+log = logging.getLogger("ui")
+
+class BaseTemplate(pm.ui.AETemplate):
+
+ def addControl(self, control, label=None, **kwargs):
+ pm.ui.AETemplate.addControl(self, control, label=label, **kwargs)
+
+ def beginLayout(self, name, collapse=True):
+ pm.ui.AETemplate.beginLayout(self, name, collapse=collapse)
+
+
+class AECoronaSkyTemplate(BaseTemplate):
+ def __init__(self, nodeName):
+ BaseTemplate.__init__(self,nodeName)
+ log.debug("AECoronaLightTemplate")
+ self.thisNode = None
+ self.node = pm.PyNode(self.nodeName)
+ pm.mel.AEswatchDisplay(nodeName)
+ self.beginScrollLayout()
+ self.buildBody(nodeName)
+ allAttributes = self.node.listAttr()
+ allowedAttributes = ["emissionColor", "emissionColorMultiplier", "opacity", "emitLight", "emissionGlossyness", "doubleSidedEmission", "iesProfile", "emissionSharpnessFake"]
+ for att in allAttributes:
+ att = att.split(".")[-1]
+ if not att in allowedAttributes:
+ print "Suppressing", att
+ self.suppress(att)
+ self.addExtraControls("ExtraControls")
+ self.endScrollLayout()
+
+ def updateUI(self, nodeName):
+ self.thisNode = pm.PyNode(nodeName)
+ self.dimControl(self.thisNode, "pSkyPreethamTurb", True)
+ self.dimControl(self.thisNode, "pSkyZenith", True)
+ self.dimControl(self.thisNode, "pSkyHorizon", True)
+ self.dimControl(self.thisNode, "pSkySunGlow", True)
+ self.dimControl(self.thisNode, "pSkySunSideGlow", True)
+ self.dimControl(self.thisNode, "pSkySunBleed", True)
+ self.dimControl(self.thisNode, "pSkySunFalloff", True)
+ if (self.thisNode.pSkyModel.get() == 0) or (self.thisNode.pSkyModel.get() == 2): #preetham or hosek
+ self.dimControl(self.thisNode, "pSkyPreethamTurb", False)
+ if self.thisNode.pSkyModel.get() == 1:
+ self.dimControl(self.thisNode, "pSkyZenith", False)
+ self.dimControl(self.thisNode, "pSkyHorizon", False)
+ self.dimControl(self.thisNode, "pSkySunGlow", False)
+ self.dimControl(self.thisNode, "pSkySunSideGlow", False)
+ self.dimControl(self.thisNode, "pSkySunBleed", False)
+ self.dimControl(self.thisNode, "pSkySunFalloff", False)
+
+ def buildBody(self, nodeName):
+ self.thisNode = pm.PyNode(nodeName)
+ self.beginLayout("Sky" ,collapse=0)
+ self.beginNoOptimize()
+ self.addControl("pSkyModel", label="Model", changeCommand=self.updateUI)
+ self.addSeparator()
+ self.addControl("pSkyMultiplier", label="Multiplier")
+ self.addControl("pSkyHorizBlur", label="Horizon Blur")
+ self.addControl("pSkyGroundColor", label="Ground Color")
+ self.addControl("pSkyAffectGround", label="Affect Ground")
+ self.addControl("sunSizeMulti", label="Sun Size Multiplier")
+ self.beginLayout("Rawafake" ,collapse=0)
+ self.addControl("pSkySunFalloff", label="Sun Falloff")
+ self.addControl("pSkyZenith", label="Zenit Color")
+ self.addControl("pSkyHorizon", label="Horizon Color")
+ self.addControl("pSkySunGlow", label="Sun Glow")
+ self.addControl("pSkySunSideGlow", label="Sun Side Glow")
+ self.addControl("pSkySunBleed", label="Sun Bleed")
+ self.endLayout()
+ self.beginLayout("Preetham/Hosek" ,collapse=0)
+ self.addControl("pSkyPreethamTurb", label="Turbidity")
+ self.endLayout()
+
+ self.endNoOptimize()
+ self.endLayout()
+
+ #self.beginLayout("Hardware Texturing" ,collapse=0)
+ #pm.mel.eval('AEhardwareTextureTemplate "%s"' % self.nodeName + r'("diffuse emissionColor ")')
+ #self.endLayout()
+
\ No newline at end of file
diff --git a/src/mayaToCorona/mtco_devmodule/scripts/Corona/AETemplate/AECoronaWireTemplate.py b/src/mayaToCorona/mtco_devmodule/scripts/Corona/AETemplate/AECoronaWireTemplate.py
new file mode 100644
index 0000000..0f35363
--- /dev/null
+++ b/src/mayaToCorona/mtco_devmodule/scripts/Corona/AETemplate/AECoronaWireTemplate.py
@@ -0,0 +1,55 @@
+import pymel.core as pm
+import logging
+
+log = logging.getLogger("ui")
+
+class BaseTemplate(pm.ui.AETemplate):
+
+ def addControl(self, control, label=None, **kwargs):
+ pm.ui.AETemplate.addControl(self, control, label=label, **kwargs)
+
+ def beginLayout(self, name, collapse=True):
+ pm.ui.AETemplate.beginLayout(self, name, collapse=collapse)
+
+
+class AECoronaLightTemplate(BaseTemplate):
+ def __init__(self, nodeName):
+ BaseTemplate.__init__(self,nodeName)
+ log.debug("AECoronaLightTemplate")
+ self.thisNode = None
+ self.node = pm.PyNode(self.nodeName)
+ pm.mel.AEswatchDisplay(nodeName)
+ self.beginScrollLayout()
+ self.buildBody(nodeName)
+ allAttributes = self.node.listAttr()
+ allowedAttributes = ["emissionColor", "emissionColorMultiplier", "opacity", "emitLight", "emissionGlossyness", "doubleSidedEmission", "iesProfile", "emissionSharpnessFake"]
+ for att in allAttributes:
+ att = att.split(".")[-1]
+ if not att in allowedAttributes:
+ print "Suppressing", att
+ self.suppress(att)
+ self.addExtraControls("ExtraControls")
+ self.endScrollLayout()
+
+ def buildBody(self, nodeName):
+ self.thisNode = pm.PyNode(nodeName)
+ self.beginLayout("Emission" ,collapse=0)
+ self.beginNoOptimize()
+ self.addControl("emissionColor", label="Color")
+ self.addControl("emissionColorMultiplier", label="Multiplier")
+ self.addControl("opacity", label="Opacity")
+ self.addControl("emitLight", label="Emit Light")
+ self.addControl("emissionGlossyness", label="Directionality")
+ self.addControl("doubleSidedEmission", label="Double Sided")
+ self.addSeparator()
+ self.addControl("iesProfile", label="IES Profile")
+ self.addControl("emissionSharpnessFake", label="Sharp Patterns")
+ #self.addControl("emissionDisableSampling", label="Disable Sampling")
+ #self.addControl("emissionSharpnessFakePoint", label="Sharpness Fake Point")
+ self.endNoOptimize()
+ self.endLayout()
+
+ #self.beginLayout("Hardware Texturing" ,collapse=0)
+ #pm.mel.eval('AEhardwareTextureTemplate "%s"' % self.nodeName + r'("diffuse emissionColor ")')
+ #self.endLayout()
+
\ No newline at end of file
diff --git a/src/mayaToCorona/mtco_devmodule/scripts/Corona/aeNodeTemplates.py b/src/mayaToCorona/mtco_devmodule/scripts/Corona/aeNodeTemplates.py
index 8920a1e..a55cfdc 100644
--- a/src/mayaToCorona/mtco_devmodule/scripts/Corona/aeNodeTemplates.py
+++ b/src/mayaToCorona/mtco_devmodule/scripts/Corona/aeNodeTemplates.py
@@ -19,11 +19,29 @@ def __init__(self, nodeName):
self.node = pm.PyNode(self.nodeName)
self.buildBody(nodeName)
log.debug("AECoronaNodeTemplate")
-
+
+ def updateSun(self, node = None):
+ thisLight = pm.PyNode(node)
+
+ if thisLight.mtco_useAsSun.get():
+ otherLights = []
+ for light in pm.ls(type="directionalLight"):
+ if light.mtco_useAsSun.get() and (light != thisLight):
+ otherLights.append(light)
+
+ if len(otherLights) > 0:
+ result = pm.confirmDialog(title="Sun Problem", message="Another Light already has sun activated, what should be done?", button=["Use This light", "Use Other Light"])
+ if result == "Use This light":
+ for light in otherLights:
+ light.mtco_useAsSun.set(False)
+ else:
+ thisLight.mtco_useAsSun.set(False)
+
def buildDirLightTemplate(self, nodeName):
self.thisNode = pm.PyNode(nodeName)
self.beginLayout("Corona" ,collapse=1)
- self.addControl("mtco_sun_multiplier", label="Sun Intensity Multiplier")
+ self.addControl("mtco_useAsSun", label="Use as Sun", changeCommand=self.updateSun)
+ #self.addControl("mtco_sun_multiplier", label="Sun Intensity Multiplier")
self.endLayout()
def buildAreaLightTemplate(self, nodeName):
diff --git a/src/mayaToCorona/mtco_devmodule/scripts/mtco_initialize.py b/src/mayaToCorona/mtco_devmodule/scripts/mtco_initialize.py
index b53422e..b1e45b6 100644
--- a/src/mayaToCorona/mtco_devmodule/scripts/mtco_initialize.py
+++ b/src/mayaToCorona/mtco_devmodule/scripts/mtco_initialize.py
@@ -167,61 +167,10 @@ def CoronaSceneCreateTab(self):
self.addRenderGlobalsUIElement(attName = 'colorMapping_colorTemperature', uiType = 'float', displayName = 'Color Temperature', default='6500.0', data='minmax:1000.0:99999.0', uiDict=uiDict)
self.addRenderGlobalsUIElement(attName = 'colorMapping_tint', uiType = 'color', displayName = 'Tint', default='1.0:1.0:1.0', uiDict=uiDict)
self.addRenderGlobalsUIElement(attName = 'colorMapping_contrast', uiType = 'float', displayName = 'Contrast', default='1.0', data='minmax:1.0:99.0', uiDict=uiDict)
- pm.separator()
-
-
-# with pm.frameLayout(label="Raytrace Features", collapsable=True, collapse=True):
-# with pm.columnLayout(self.rendererName + 'ColumnLayout', adjustableColumn=True, width=400):
-# # self.addRenderGlobalsUIElement(attName = 'raycaster_minDepth', uiType = 'int', displayName = 'Min Ray Depth', default='0', data='minmax:0:25', uiDict=uiDict)
-# self.addRenderGlobalsUIElement(attName='raycaster_maxDepth', uiType='int', displayName='Max Ray Depth', default='25', data='minmax:1:25', uiDict=uiDict)
-# self.addRenderGlobalsUIElement(attName='color_exit', uiType='color', displayName='Exit Color', uiDict=uiDict)
-# self.addRenderGlobalsUIElement(attName='system_maxNormalDev', uiType='float', displayName='Max Normal Diff', uiDict=uiDict)
-
-# with pm.frameLayout(label="Accerleration Structure", collapsable=True, collapse=True):
-# with pm.columnLayout(self.rendererName + 'ColumnLayout', adjustableColumn=True, width=400):
-# self.addRenderGlobalsUIElement(attName='accelerationStructure', uiType='enum', displayName='Accelerationstructure', default='Embree_bvh4_spatial', data='None:Embree_bvh4_spatial', uiDict=uiDict)
-# self.addRenderGlobalsUIElement(attName='embree_triangles', uiType='enum', displayName='Triangles', default='Fast', data='Fast:Avx', uiDict=uiDict)
-# self.addRenderGlobalsUIElement(attName='instance_minSize', uiType='int', displayName='Instance Min Size', default='1', data='minmax:1:999999', uiDict=uiDict)
- # self.addRenderGlobalsUIElement(attName = 'bvh_cost_iteration', uiType = 'float', displayName = 'Bvh_cost_iteration', default='1.0', data='minmax:0.01:1000.0', uiDict=uiDict)
-# self.addRenderGlobalsUIElement(attName = 'bvh_cost_triangle', uiType = 'float', displayName = 'Bvh_cost_triangle', default='1.0', data='minmax:0.01:1000.0', uiDict=uiDict)
-# self.addRenderGlobalsUIElement(attName = 'bvh_leafSizeMin', uiType = 'int', displayName = 'Bvh_leafsizemin', default='2', data='minmax:1:1000', uiDict=uiDict)
-# self.addRenderGlobalsUIElement(attName = 'bvh_leafSizeMax', uiType = 'int', displayName = 'Bvh_leafsizemax', default='6', data='minmax:2:1000', uiDict=uiDict)
-
with pm.frameLayout(label="Environment", collapsable=True, collapse=True):
with pm.columnLayout(self.rendererName + 'ColumnLayout', adjustableColumn=True, width=400):
- self.addRenderGlobalsUIElement(attName = 'bgType', uiType = 'enum', displayName = 'Background', default='0', data='Color/Image:PhysicalSky', uiDict=uiDict, callback=self.CoronaSceneUpdateTab)
- envLightingFrame = None
- physSkyFrame = None
- physSkyPreetham = None
- physSkyRawafake = None
- with pm.frameLayout(label="Color/Image", collapsable=False) as envLightingFrame:
- with pm.columnLayout(self.rendererName + 'ColumnLayout', adjustableColumn=True, width=400):
- self.addRenderGlobalsUIElement(attName='bgColor', uiType='color', displayName='Main Environment', default='0.4:0.4:1.0', uiDict=uiDict)
- with pm.frameLayout(label="Physical Sky", collapsable=True, collapse=False) as physSkyFrame:
- with pm.columnLayout(self.rendererName + 'ColumnLayout', adjustableColumn=True, width=400):
- self.addRenderGlobalsUIElement(attName = 'sunSizeMulti', uiType = 'float', displayName = 'Sun Size Multiplier', default='1.0', uiDict=uiDict)
- pm.separator()
- self.addRenderGlobalsUIElement(attName = 'pSkyModel', uiType = 'enum', displayName = 'Sky Model', default='0', data='Preetham:Rawafake:Hosek', uiDict=uiDict, callback=self.CoronaSceneUpdateTab)
- self.addRenderGlobalsUIElement(attName = 'pSkyMultiplier', uiType = 'float', displayName = 'Sky Multiplier', default='1.0', uiDict=uiDict)
- self.addRenderGlobalsUIElement(attName = 'pSkyHorizBlur', uiType = 'float', displayName = 'Sky Horizon Blur', default='0.1', uiDict=uiDict)
- self.addRenderGlobalsUIElement(attName = 'pSkyGroundColor', uiType = 'color', displayName = 'Ground Color', default='0.25:0.25:0.25', uiDict=uiDict)
- self.addRenderGlobalsUIElement(attName = 'pSkyAffectGround', uiType = 'bool', displayName = 'Sky Affect Ground', default='true', uiDict=uiDict)
- with pm.columnLayout(self.rendererName + 'ColumnLayoutphysSkyPreetham', adjustableColumn=True, width=400) as physSkyPreetham:
- self.addRenderGlobalsUIElement(attName = 'pSkyPreethamTurb', uiType = 'float', displayName = 'Turbidity', default='2.5', uiDict=uiDict)
- with pm.columnLayout(self.rendererName + 'ColumnLayoutphysSkyRawafake', adjustableColumn=True, width=400) as physSkyRawafake:
- self.addRenderGlobalsUIElement(attName = 'pSkySunFalloff', uiType = 'float', displayName = 'Sun Falloff', default='3.0', uiDict=uiDict)
- self.addRenderGlobalsUIElement(attName = 'pSkyZenith', uiType = 'color', displayName = 'Zenith Color', default='0.1:0.1:0.5', uiDict=uiDict)
- self.addRenderGlobalsUIElement(attName = 'pSkyHorizon', uiType = 'color', displayName = 'Horizon Color', default='0.25:0.5:0.5', uiDict=uiDict)
- self.addRenderGlobalsUIElement(attName = 'pSkySunGlow', uiType = 'float', displayName = 'Sun Glow', default='1.0', uiDict=uiDict)
- self.addRenderGlobalsUIElement(attName = 'pSkySunSideGlow', uiType = 'float', displayName = 'Sun Side Glow', default='0.2', uiDict=uiDict)
- self.addRenderGlobalsUIElement(attName = 'pSkySunBleed', uiType = 'float', displayName = 'Sun Bleed', default='1.0', uiDict=uiDict)
- uiDict['envLightingFrame'] = envLightingFrame
- uiDict['physSkyFrame'] = physSkyFrame
- uiDict['physSkyPreetham'] = physSkyPreetham
- uiDict['physSkyRawafake'] = physSkyRawafake
-
- #self.addRenderGlobalsUIElement(attName='useSunLightConnection', uiType='bool', displayName='Use Sun', uiDict=uiDict, callback=self.editSun)
+ self.addRenderGlobalsUIElement(attName= 'bgColor', uiType='color', displayName='Main Environment', default='0.4:0.4:1.0', uiDict=uiDict)
self.addRenderGlobalsUIElement(attName = 'useGlobalDirectOverride', uiType = 'bool', displayName = 'Use Direct Override', default='false', uiDict=uiDict, callback=self.CoronaSceneUpdateTab)
self.addRenderGlobalsUIElement(attName = 'globalDirectOverride', uiType = 'color', displayName = 'Direct Override', default='0.0:0.0:0.0', uiDict=uiDict)
self.addRenderGlobalsUIElement(attName = 'useGlobalReflectionOverride', uiType = 'bool', displayName = 'Use Reflection Override', default='false', uiDict=uiDict, callback=self.CoronaSceneUpdateTab)
@@ -293,29 +242,6 @@ def CoronaSceneUpdateTab(self, dummy=None):
if self.renderGlobalsNode.colorMapping_useSimpleExposure.get():
uiDict['colorMapping_simpleExposure'].setEnable(True)
- bgType = self.renderGlobalsNode.bgType.get()
- if bgType == 0: # color/image
- uiDict['envLightingFrame'].setEnable(True)
- uiDict['envLightingFrame'].setManage(True)
- uiDict['physSkyFrame'].setEnable(False)
- uiDict['physSkyFrame'].setManage(False)
- if bgType == 1: # color/image
- uiDict['envLightingFrame'].setEnable(False)
- uiDict['envLightingFrame'].setManage(False)
- uiDict['physSkyFrame'].setManage(True)
- uiDict['physSkyFrame'].setEnable(True)
- pSkyModel = self.renderGlobalsNode.pSkyModel.get()
-
- if pSkyModel == 0: #preetham
- uiDict['physSkyPreetham'].setEnable(True)
- uiDict['physSkyRawafake'].setEnable(False)
- if pSkyModel == 1: #Rawafake
- uiDict['physSkyPreetham'].setEnable(False)
- uiDict['physSkyRawafake'].setEnable(True)
- if pSkyModel == 2: #hosek
- uiDict['physSkyPreetham'].setEnable(False)
- uiDict['physSkyRawafake'].setEnable(False)
-
uiDict['globalMaterialOverride'].setEnable(False)
uiDict['globalDirectOverride'].setEnable(False)
uiDict['globalReflectionOverride'].setEnable(False)
@@ -645,6 +571,7 @@ def registerNodeExtensions(self):
# exponent for sun light
pm.addExtension(nodeType="directionalLight", longName="mtco_sun_multiplier", attributeType="float", defaultValue=1.0)
+ pm.addExtension(nodeType="directionalLight", longName="mtco_useAsSun", attributeType="bool", defaultValue=False)
pm.addExtension( nodeType='areaLight', longName='mtco_envPortal', attributeType='bool', defaultValue=False)
pm.addExtension( nodeType='areaLight', longName='mtco_areaVisible', attributeType='bool', defaultValue=True)
pm.addExtension( nodeType='areaLight', longName='mtco_doubleSided', attributeType='bool', defaultValue=False)
@@ -664,11 +591,12 @@ def registerNodeExtensions(self):
# gamma
pm.addExtension( nodeType='file', longName='fromSRGB', attributeType='bool', defaultValue=True)
pm.addExtension( nodeType='file', longName='toSRGB', attributeType='bool', defaultValue=False)
- pm.addExtension( nodeType='file', longName='textureFilter', attributeType='enum', enumName="SmartCubic:Cubic:Triangle:Box", defaultValue = 0.0)
+ pm.addExtension( nodeType='file', longName='textureFilter', attributeType='enum', enumName="Bilinear:Bicubic:Nearest", defaultValue = 0.0)
pm.addExtension( nodeType='file', longName='textureBlur', attributeType='float', defaultValue=0.0)
pm.addExtension( nodeType='file', longName='textureSblur', attributeType='float', defaultValue=0.0)
pm.addExtension( nodeType='file', longName='textureTblur', attributeType='float', defaultValue=0.0)
pm.addExtension( nodeType='file', longName='textureFilterWidth', attributeType='float', defaultValue=1.0)
+ pm.addExtension( nodeType='file', longName='environmentMappingType', attributeType='enum', enumName="Spherical:Screen", defaultValue = 0.0)
#mesh
pm.addExtension( nodeType='mesh', longName='mtco_visibleInGI', attributeType='bool', defaultValue=True)
@@ -714,14 +642,25 @@ def connectNodeToNodeOverrideCallback(self, srcNode, destNode):
def createRenderNode(self, nodeType=None, postCommand=None):
log.debug("createRenderNode callback for renderer {0} with node: {1}".format(self.rendererName.lower(), nodeType))
- mat = pm.shadingNode(nodeType, asShader=True)
- shadingGroup = pm.sets(renderable=True, noSurfaceShader=True, empty=True, name="{0}SG".format(mat))
- mat.outColor >> shadingGroup.surfaceShader
+ nodeClass = None
+ for cl in pm.getClassification(nodeType):
+ if "corona/material" in cl:
+ nodeClass = "shader"
+ if "corona/texture" in cl:
+ nodeClass = "texture"
+
+ if nodeClass == "shader":
+ mat = pm.shadingNode(nodeType, asShader=True)
+ shadingGroup = pm.sets(renderable=True, noSurfaceShader=True, empty=True, name="{0}SG".format(mat))
+ mat.outColor >> shadingGroup.surfaceShader
+ else:
+ mat = pm.shadingNode(nodeType, asTexture=True)
+
if postCommand is not None:
postCommand = postCommand.replace("%node", str(mat))
postCommand = postCommand.replace("%type", '\"\"')
pm.mel.eval(postCommand)
- return mat
+ return ""
def renderProcedure(self, width, height, doShadows, doGlow, camera, options):
log.debug("renderProcedure")
diff --git a/src/mayaToCorona/src/Corona/Corona.cpp b/src/mayaToCorona/src/Corona/Corona.cpp
index 6f1d76c..d72664c 100644
--- a/src/mayaToCorona/src/Corona/Corona.cpp
+++ b/src/mayaToCorona/src/Corona/Corona.cpp
@@ -12,10 +12,6 @@
#include "CoronaShaders.h"
#include
-//#include "CoronaTestScene.h"
-
-static Logging logger;
-
CoronaRenderer::CoronaRenderer()
{
MStatus stat;
@@ -30,40 +26,42 @@ CoronaRenderer::CoronaRenderer()
MObject renderGlobalsNode = getRenderGlobalsNode();
this->renderFbGlobalsNodeCallbackId = 0;
this->renderFbGlobalsNodeCallbackId = MNodeMessage::addNodeDirtyCallback(renderGlobalsNode, CoronaRenderer::frameBufferInteractiveCallback, nullptr, &stat);
-
- int numP = Corona::PropertyDescriptor::descriptorsCount();
- Logging::debug("Property descriptiors:");
- for (uint i = 0; i < 2000; i++)
- {
- const Corona::PropertyDescriptor* pd = Corona::PropertyDescriptor::get(i);
- if (pd)
- {
- MString ts;
- Corona::Abstract::Settings::Property prop = pd->valueDefault;
- if (pd->type == Corona::PropertyType::T_BOOL)
- {
- bool b = prop;
- ts += MString(" BOOL ") + b;
- }
- if (pd->type == Corona::PropertyType::T_FLOAT)
- {
- float f = prop;
- ts += MString(" FLOAT ") + f;
- }
- if (pd->type == Corona::PropertyType::T_INT)
- {
- int f = prop;
- ts += MString(" INT ") + f;
- }
- if (pd->type == Corona::PropertyType::T_STR)
- {
- Corona::String f = prop;
- ts += MString(" STRING ") + f.cStr();
- }
- Logging::debug(MString("Descriptor: ") + pd->name.cStr() + " id " + i + ts);
-
- }
- }
+ this->oslRenderer = new OSL::OSLShadingNetworkRenderer();
+ this->oslRenderer->setup();
+
+ //int numP = Corona::PropertyDescriptor::descriptorsCount();
+ //Logging::debug("Property descriptiors:");
+ //for (uint i = 0; i < 2000; i++)
+ //{
+ // const Corona::PropertyDescriptor* pd = Corona::PropertyDescriptor::get(i);
+ // if (pd)
+ // {
+ // MString ts;
+ // Corona::Abstract::Settings::Property prop = pd->valueDefault;
+ // if (pd->type == Corona::PropertyType::T_BOOL)
+ // {
+ // bool b = prop;
+ // ts += MString(" BOOL ") + b;
+ // }
+ // if (pd->type == Corona::PropertyType::T_FLOAT)
+ // {
+ // float f = prop;
+ // ts += MString(" FLOAT ") + f;
+ // }
+ // if (pd->type == Corona::PropertyType::T_INT)
+ // {
+ // int f = prop;
+ // ts += MString(" INT ") + f;
+ // }
+ // if (pd->type == Corona::PropertyType::T_STR)
+ // {
+ // Corona::String f = prop;
+ // ts += MString(" STRING ") + f.cStr();
+ // }
+ // Logging::debug(MString("Descriptor: ") + pd->name.cStr() + " id " + i + ts);
+
+ // }
+ //}
}
CoronaRenderer::~CoronaRenderer()
@@ -102,6 +100,9 @@ CoronaRenderer::~CoronaRenderer()
delete context.colorMappingData;
context.colorMappingData = nullptr;
}
+
+ clearDataList();
+ delete this->oslRenderer;
}
void CoronaRenderer::frameBufferInteractiveCallback(MObject& node, void *clientData)
@@ -156,7 +157,6 @@ void CoronaRenderer::render()
MGlobal::displayError(MString("Sorry! Could not get a valid license.") + reason);
return;
}
-
context.scene = context.core->createScene();
//createTestScene();
@@ -275,9 +275,9 @@ void CoronaRenderer::initializeRenderer()
context.logger = new mtco_Logger(context.core);
context.colorMappingData = new Corona::ColorMappingData;
- if (gFn.findPlug("useCoronaVFB").asBool())
- if (MGlobal::mayaState() != MGlobal::kBatch)
- vfbCallbacks.core = context.core;
+ //if (gFn.findPlug("useCoronaVFB").asBool())
+ // if (MGlobal::mayaState() != MGlobal::kBatch)
+ // vfbCallbacks.core = context.core;
ConfParser parser;
Corona::String resPath = (getRendererHome() + "resources/").asChar();
@@ -291,37 +291,27 @@ void CoronaRenderer::initializeRenderer()
context.fb->initFb(context.settings, context.renderPasses);
context.core->sanityCheck(context.settings);
- if (gFn.findPlug("useCoronaVFB").asBool())
- if (MGlobal::mayaState() != MGlobal::kBatch)
- context.core->getWxVfb().renderStarted(context.fb, &vfbCallbacks, IWxVfb::EnviroConfig());
+ //if (gFn.findPlug("useCoronaVFB").asBool())
+ // if (MGlobal::mayaState() != MGlobal::kBatch)
+ // context.core->getWxVfb().renderStarted(context.fb, &vfbCallbacks, IWxVfb::EnviroConfig());
// this can be extracted and placed in a button function in the render globals
- std::shared_ptr renderGlobals = MayaTo::getWorldPtr()->worldRenderGlobalsPtr;
- MFnDependencyNode renderGlobalsNode(getRenderGlobalsNode());
- Corona::String dumpFilename = (renderGlobals->getImageOutputFile() + ".dmp").asChar();
- if (getBoolAttr("dumpAndResume", renderGlobalsNode, false))
- {
- context.settings->set(Corona::PARAM_RANDOM_SEED, 0);
- if (!context.fb->accumulateFromExr(dumpFilename))
- {
- Logging::debug(MString("Accumulating from a dumpfile failed: ") + dumpFilename.cStr());
- }
- else{
- // random seed has to be 0 for resuming a render
- context.settings->set(Corona::PARAM_RESUME_RENDERING, true);
- context.settings->set(Corona::PARAM_RANDOM_SEED, 0);
- }
- }
-
- OSL::OSLShadingNetworkRenderer *r = (OSL::OSLShadingNetworkRenderer *)MayaTo::getWorldPtr()->getObjPtr("oslRenderer");
- if (r == nullptr)
- {
- Logging::debug("error CoronaRenderer::render: OSL renderer == nullptr");
- return;
- }
- this->oslRenderer = r;
- r->setup(); // delete existing shadingsys and reinit all
-
+ //std::shared_ptr renderGlobals = MayaTo::getWorldPtr()->worldRenderGlobalsPtr;
+ //MFnDependencyNode renderGlobalsNode(getRenderGlobalsNode());
+ //Corona::String dumpFilename = (renderGlobals->getImageOutputFile() + ".dmp").asChar();
+ //if (getBoolAttr("dumpAndResume", renderGlobalsNode, false))
+ //{
+ // context.settings->set(Corona::PARAM_RANDOM_SEED, 0);
+ // if (!context.fb->accumulateFromExr(dumpFilename))
+ // {
+ // Logging::debug(MString("Accumulating from a dumpfile failed: ") + dumpFilename.cStr());
+ // }
+ // else{
+ // // random seed has to be 0 for resuming a render
+ // context.settings->set(Corona::PARAM_RESUME_RENDERING, true);
+ // context.settings->set(Corona::PARAM_RANDOM_SEED, 0);
+ // }
+ //}
}
void CoronaRenderer::unInitializeRenderer()
diff --git a/src/mayaToCorona/src/Corona/Corona.h b/src/mayaToCorona/src/Corona/Corona.h
index 4ae307b..d2e5814 100644
--- a/src/mayaToCorona/src/Corona/Corona.h
+++ b/src/mayaToCorona/src/Corona/Corona.h
@@ -103,7 +103,11 @@ class mtco_Logger : public Corona::Abstract::Logger
mtco_Logger(Corona::ICore* core) : Corona::Abstract::Logger(&core->getStats()) { };
- virtual void logMsg(const Corona::String& message, const Corona::LogType type)
+ virtual void logMsg(const Corona::String& message, const Corona::LogType type)
+ {
+ Logging::info(MString("Message: ") + message.cStr());
+ }
+ virtual void logMsg(const Corona::String& message, const Corona::LogType type, const int errorCategory = 0)
{
Logging::info(MString("Message: ") + message.cStr());
}
@@ -131,7 +135,7 @@ class CoronaRenderer : public MayaTo::Renderer
OSL::OSLShadingNetworkRenderer *oslRenderer;
Context context;
- CornoaVfbCallbacks vfbCallbacks;
+ //CornoaVfbCallbacks vfbCallbacks;
CoronaRenderer();
virtual ~CoronaRenderer();
@@ -157,7 +161,7 @@ class CoronaRenderer : public MayaTo::Renderer
void setRenderStats(Corona::IMaterialSet& ms, std::shared_ptr obj);
bool assingExistingMat(MObject shadingGroup, std::shared_ptr obj);
void clearMaterialLists();
- void defineBump(MString& attributeName, MFnDependencyNode& depFn, ShadingNetwork& sn, Corona::NativeMtlData& data);
+ //void defineBump(MString& attributeName, MFnDependencyNode& depFn, ShadingNetwork& sn, Corona::NativeMtlData& data);
Corona::IGeometryGroup* getGeometryPointer(std::shared_ptr obj);
bool isSunLight(std::shared_ptr obj);
virtual void defineLights();
diff --git a/src/mayaToCorona/src/Corona/CoronaAOShader.h b/src/mayaToCorona/src/Corona/CoronaAOShader.h
index a2c4c68..8ff8462 100644
--- a/src/mayaToCorona/src/Corona/CoronaAOShader.h
+++ b/src/mayaToCorona/src/Corona/CoronaAOShader.h
@@ -1,6 +1,7 @@
#ifndef CORONA_AO_MAP
#define CORONA_AO_MAP
+#include
#include "CoronaCore/api/Api.h"
#include "CoronaCore/misc/Shaders/AoShader.h"
@@ -10,12 +11,16 @@ class AoMap : public Corona::Abstract::Map, Corona::AoShader
AoMap(MObject sObject);
~AoMap();
float maxDist;
+ Corona::String mapName = "AoMap";
virtual Corona::Rgb evalColor(const Corona::IShadeContext& context, Corona::TextureCache* cache, float& outAlpha);
virtual float evalMono(const Corona::IShadeContext& context, Corona::TextureCache* cache, float& outAlpha);
virtual Corona::Dir evalBump(const Corona::IShadeContext&, Corona::TextureCache*);
virtual void renderTo(Corona::Bitmap& output);
virtual void getChildren(Corona::Stack&) {}
+ virtual bool exportMap(Corona::IResourceManager& resourceManager, Corona::XmlWriterNode& outXml) const { return true; };
+ virtual Corona::String name() const { return mapName; };
+
};
diff --git a/src/mayaToCorona/src/Corona/CoronaCamera.cpp b/src/mayaToCorona/src/Corona/CoronaCamera.cpp
index b66b8b7..8587967 100644
--- a/src/mayaToCorona/src/Corona/CoronaCamera.cpp
+++ b/src/mayaToCorona/src/Corona/CoronaCamera.cpp
@@ -1,4 +1,5 @@
#include "Corona.h"
+#include "CoronaCamera.h"
#include
#include
#include "renderGlobals.h"
@@ -11,6 +12,128 @@
static Logging logger;
+void updateCamera(Corona::CameraData& cameraData, MObject& cameraObject, const MMatrix& matrix, float deviceAspect)
+{
+ //MVector cameraUpVector(0.0, 1.0, 0.0);
+ MVector cameraUpVector(0.0, -1.0, 0.0);
+ MFnCamera camFn(cameraObject);
+ MPoint pos, rot, scale;
+ MMatrix camMatrix = matrix * MayaTo::getWorldPtr()->globalConversionMatrix;
+ cameraUpVector *= camMatrix;
+ cameraUpVector.normalize();
+ Corona::Dir upVector(cameraUpVector.x, cameraUpVector.y, cameraUpVector.z);
+ getMatrixComponents(camMatrix, pos, rot, scale);
+ Corona::Pos cpos(pos.x, pos.y, pos.z);
+
+ float horizontalFilmAperture = getFloatAttr("horizontalFilmAperture", camFn, 1.0f);
+ float verticalFilmAperture = getFloatAttr("verticalFilmAperture", camFn, 35.0f);
+ float focalLength = getFloatAttr("focalLength", camFn, 55.0f);
+ bool dof = getBoolAttr("depthOfField", camFn, false);
+ float focusDistance = getFloatAttr("focusDistance", camFn, 100.f);
+ float fStop = getFloatAttr("fStop", camFn, 5.6f);
+ float coi = getFloatAttr("centerOfInterest", camFn, 100.0f);
+ focusDistance *= MayaTo::getWorldPtr()->scaleFactor;
+ MPoint coiBase(0, 0, -coi);
+ MPoint coiTransform = coiBase * camMatrix;
+ Corona::Pos center(coiTransform.x, coiTransform.y, coiTransform.z);
+ float factor = horizontalFilmAperture;
+ float fov = 2.0 * atan((factor * 0.5f) / (focalLength * 0.03937)); // make horizontal film fit the default
+ MFnCamera::FilmFit filmFit = camFn.filmFit();
+ float dAspect = deviceAspect;
+ double fAspect = horizontalFilmAperture / verticalFilmAperture;
+
+ switch (filmFit)
+ {
+ case MFnCamera::kHorizontalFilmFit:
+ {
+ fov = 2.0 * atan((factor * 0.5f) / (focalLength * 0.03937));
+ }
+ break;
+
+ case MFnCamera::kVerticalFilmFit:
+ {
+ factor = verticalFilmAperture * dAspect;
+ fov = 2.0 * atan((factor * 0.5f) / (focalLength * 0.03937));
+ }
+ break;
+
+ case MFnCamera::kFillFilmFit:
+ {}
+ break;
+
+ case MFnCamera::kOverscanFilmFit:
+ {}
+ break;
+
+ default:
+ break;
+ }
+
+ float fovDeg = fov * 57.29578;
+ Corona::AnimatedFloat fieldOfView(fov);
+ bool orthographic = getBoolAttr("orthographic", camFn, false);
+
+ if (orthographic)
+ {
+ Corona::AnimatedAffineTm tm;
+ tm.setSegments(0);
+ tm[0] = Corona::AffineTm::IDENTITY;
+ cameraData.createOrtho(tm, 10.0f);
+ }
+ else{
+ cameraData.createPerspective(Corona::AnimatedPos(cpos), Corona::AnimatedPos(center), Corona::AnimatedDir(upVector), fieldOfView);
+ }
+ cameraData.spherical.roll = Corona::AnimatedDir(upVector);
+ cameraData.cylindrical.roll = Corona::AnimatedDir(upVector);
+ cameraData.cylindrical.height = 1.0f;
+ int projType = getEnumInt("mtco_cameraType", camFn);
+ //CameraProjectionType
+ cameraData.type = Corona::PROJECTION_PERSPECTIVE;
+ if (projType == 1)
+ cameraData.type = Corona::PROJECTION_CYLINDRICAL;
+ if (projType == 2)
+ cameraData.type = Corona::PROJECTION_SPHERICAL;
+
+ Corona::AnimatedFloat focalDist(focusDistance);
+ cameraData.perspective.focalDist = focalDist;
+ cameraData.perspective.fStop = fStop;
+ cameraData.perspective.filmWidth = MayaTo::getWorldPtr()->toMillimeters(horizontalFilmAperture * 2.54f * 10.0f); //film width in mm
+
+ if (!getBoolAttr("bestFitClippingPlanes", camFn, false))
+ {
+ cameraData.distances.minimal = getFloatAttr("nearClipPlane", camFn, 0.001f) * MayaTo::getWorldPtr()->scaleFactor;
+ cameraData.distances.maximal = getFloatAttr("farClipPlane", camFn, 100000.0f) * MayaTo::getWorldPtr()->scaleFactor;
+ }
+
+ if (getBoolAttr("mtco_useBokeh", camFn, false))
+ {
+ cameraData.perspective.bokeh.use = true;
+ cameraData.perspective.bokeh.blades = getIntAttr("mtco_blades", camFn, 6);
+ cameraData.perspective.bokeh.bladesRotation = getIntAttr("mtco_bladeRotation", camFn, 0.0);
+ MPlug bokehBitMapPlug = camFn.findPlug("mtco_bokehBitmap");
+ if (!bokehBitMapPlug.isNull())
+ {
+ if (bokehBitMapPlug.isConnected())
+ {
+ MObject bitmapNode = getConnectedInNode(bokehBitMapPlug);
+ if (bitmapNode.hasFn(MFn::kFileTexture))
+ {
+ MFnDependencyNode bitMapFn(bitmapNode);
+ MPlug texNamePlug = bitMapFn.findPlug("fileTextureName");
+ if (!texNamePlug.isNull())
+ {
+ MString fileName = texNamePlug.asString();
+ Logging::debug(MString("Found bokeh bitmap file: ") + fileName);
+ Corona::Bitmap bokehBitmap;
+ Corona::loadImage(fileName.asChar(), bokehBitmap);
+ cameraData.perspective.bokeh.customShape = bokehBitmap;
+ }
+ }
+ }
+ }
+ }
+}
+
void CoronaRenderer::defineCamera()
{
MPoint rot, pos, scale;
diff --git a/src/mayaToCorona/src/Corona/CoronaCamera.h b/src/mayaToCorona/src/Corona/CoronaCamera.h
new file mode 100644
index 0000000..1dc61af
--- /dev/null
+++ b/src/mayaToCorona/src/Corona/CoronaCamera.h
@@ -0,0 +1,5 @@
+#include
+#include "CoronaCore/api/Api.h"
+
+void updateCamera(Corona::CameraData& camera, MObject& cameraObject, const MMatrix& matrix, float deviceAspect);
+
diff --git a/src/mayaToCorona/src/Corona/CoronaEnvironment.cpp b/src/mayaToCorona/src/Corona/CoronaEnvironment.cpp
index 1a503d4..e6c4dba 100644
--- a/src/mayaToCorona/src/Corona/CoronaEnvironment.cpp
+++ b/src/mayaToCorona/src/Corona/CoronaEnvironment.cpp
@@ -21,8 +21,48 @@ void CoronaRenderer::defineEnvironment()
{
MFnDependencyNode depFn(getRenderGlobalsNode());
Corona::Rgb bgRgb = toCorona(getColorAttr("bgColor", depFn));
- int bgType = getEnumInt("bgType", depFn);
- if (bgType == 0)
+
+
+ if (depFn.findPlug("globalVolume").isConnected())
+ {
+ Logging::debug("globalVolume is connected.");
+ MPlugArray plugArray;
+ MPlug gv = depFn.findPlug("globalVolume");
+ gv.connectedTo(plugArray, true, false);
+ if (plugArray.length() > 0)
+ {
+ Logging::debug(MString("Connected plug: ") + plugArray[0].name());
+ MFnDependencyNode sourceNode(plugArray[0].node());
+ if (sourceNode.typeName() == "CoronaVolume")
+ {
+ Logging::debug(MString("Connected node is from type CoronaVolume: ") + sourceNode.name());
+ this->context.scene->setGlobalMedium(defineCoronaMaterial(sourceNode.object(), nullptr));
+ }
+ }
+ }
+
+ // set background
+ if (!isConnected("bgColor", depFn.object(), true))
+ {
+ this->context.scene->setBackground(Corona::ColorOrMap(bgRgb, nullptr));
+ return;
+ }
+
+ MObject inObj = getConnectedInNode(depFn.object(), "bgColor");
+ if (inObj == MObject::kNullObj)
+ {
+ Logging::error(MString("Unable to get connected element for renderGlobals.bgColor attribute"));
+ return;
+ }
+ // at the moment we are restricted to two possibilites: sky map or fileTexture
+ MFnDependencyNode inDepFn(inObj);
+ if((inDepFn.typeName() != "CoronaSky") && (!inObj.hasFn(MFn::kFileTexture)))
+ {
+ Logging::error(MString("Connections to bgColor attribute of type: ") + inDepFn.typeName() + " are not yet supported");
+ return;
+ }
+
+ if (inObj.hasFn(MFn::kFileTexture))
{
MString texName;
MObject fileTextureObject;
@@ -36,11 +76,8 @@ void CoronaRenderer::defineEnvironment()
return;
}
- //MObject obj = objectFromName(MString("coronaGlobals"));
- //const Corona::ColorOrMap com = defineAttribute(MString("bgColor"), obj);
- //this->context.scene->setBackground(com);
+ mtco_MapLoader loader(fileTextureObject);
- mtco_MapLoader loader;
if (fileTextureObject != MObject::kNullObj)
{
MFnDependencyNode fileNode(fileTextureObject);
@@ -63,51 +100,13 @@ void CoronaRenderer::defineEnvironment()
this->context.scene->setBackground(Corona::ColorOrMap(bgRgb, nullptr));
}
}
- if (bgType == 1)
+
+ if (inDepFn.typeName() == "CoronaSky")
{
- SkyMap *texmap = new SkyMap;
- texmap->coronaRenderer = this;
- texmap->params->multiplier = getFloatAttr("pSkyMultiplier", depFn, 1.0);
- int skyModel = getEnumInt("pSkyModel", depFn);
- if (skyModel == 0)
- texmap->params->mode = Corona::SkyModelType::MODEL_PREETHAM;
- if (skyModel == 1)
- texmap->params->mode = Corona::SkyModelType::MODEL_RAWAFAKE;
- if (skyModel == 2)
- texmap->params->mode = Corona::SkyModelType::MODEL_HOSEK;
- texmap->params->groundColor = toCorona(getColorAttr("pSkyGroundColor", depFn));
- texmap->params->horizonBlur = getFloatAttr("pSkyHorizBlur", depFn, .1f);
- texmap->params->skyAffectGround = getBoolAttr("pSkyAffectGround", depFn, true);
- texmap->params->preetham.turbidity = getFloatAttr("pSkyPreethamTurb", depFn, 2.5f);
- texmap->params->rawafake.horizon = toCorona(getColorAttr("pSkyHorizon", depFn));
- texmap->params->rawafake.horizon = toCorona(getColorAttr("pSkyZenith", depFn));
- texmap->params->rawafake.sunBleed = getFloatAttr("pSkySunBleed", depFn, 1.0f);
- texmap->params->rawafake.sunFalloff = getFloatAttr("pSkySunFalloff", depFn, 3.0f);
- texmap->params->rawafake.sunGlow = getFloatAttr("pSkySunGlow", depFn, 1.0f);
- texmap->params->rawafake.sunSideGlow = getFloatAttr("pSkySunSideGlow", depFn, .2f);
- texmap->initSky();
+ SkyMap *texmap = new SkyMap(inDepFn.object());
this->context.scene->setBackground(Corona::ColorOrMap(bgRgb, texmap));
}
- // set global volume environment
- if (depFn.findPlug("globalVolume").isConnected())
- {
- Logging::debug("globalVolume is connected.");
- MPlugArray plugArray;
- MPlug gv = depFn.findPlug("globalVolume");
- gv.connectedTo(plugArray, true, false);
- if (plugArray.length() > 0)
- {
- Logging::debug(MString("Connected plug: ") + plugArray[0].name());
- MFnDependencyNode sourceNode(plugArray[0].node());
- if (sourceNode.typeName() == "CoronaVolume")
- {
- Logging::debug(MString("Connected node is from type CoronaVolume: ") + sourceNode.name());
- this->context.scene->setGlobalMedium(defineCoronaMaterial(sourceNode.object(), nullptr));
- }
- }
- }
- //
}
diff --git a/src/mayaToCorona/src/Corona/CoronaFrontBack.cpp b/src/mayaToCorona/src/Corona/CoronaFrontBack.cpp
new file mode 100644
index 0000000..efe5bf2
--- /dev/null
+++ b/src/mayaToCorona/src/Corona/CoronaFrontBack.cpp
@@ -0,0 +1,34 @@
+#include "Corona.h"
+#include "CoronaFrontBack.h"
+#include
+#include "utilities/attrTools.h"
+
+FrontBackMap::FrontBackMap(MObject shaderObject)
+{
+ MFnDependencyNode depFn(shaderObject);
+};
+
+FrontBackMap::~FrontBackMap(){};
+
+Corona::Rgb FrontBackMap::evalColor(const Corona::IShadeContext& context, Corona::TextureCache* cache, float& outAlpha)
+{
+ outAlpha = 1.0f;
+ float f = 1.0f;
+ return Corona::Rgb(f, f, f);
+}
+
+float FrontBackMap::evalMono(const Corona::IShadeContext& context, Corona::TextureCache* cache, float& outAlpha)
+{
+ return evalColor(context, cache, outAlpha).grayValue();
+}
+
+Corona::Dir FrontBackMap::evalBump(const Corona::IShadeContext&, Corona::TextureCache*)
+{
+ STOP; //currently not supported
+}
+
+void FrontBackMap::renderTo(Corona::Bitmap& output)
+{
+ STOP; //currently not supported
+}
+
diff --git a/src/mayaToCorona/src/Corona/CoronaFrontBack.h b/src/mayaToCorona/src/Corona/CoronaFrontBack.h
new file mode 100644
index 0000000..8bc684c
--- /dev/null
+++ b/src/mayaToCorona/src/Corona/CoronaFrontBack.h
@@ -0,0 +1,23 @@
+#ifndef CORONA_FRONTBACK_MAP
+#define CORONA_FRONTBACK_MAP
+
+#include
+#include "CoronaCore/api/Api.h"
+
+class FrontBackMap : public Corona::Abstract::Map
+{
+public:
+ FrontBackMap(MObject sObject);
+ ~FrontBackMap();
+ Corona::String mapName = "FrontBackMap";
+ virtual Corona::Rgb evalColor(const Corona::IShadeContext& context, Corona::TextureCache* cache, float& outAlpha);
+ virtual float evalMono(const Corona::IShadeContext& context, Corona::TextureCache* cache, float& outAlpha);
+ virtual Corona::Dir evalBump(const Corona::IShadeContext&, Corona::TextureCache*);
+ virtual void renderTo(Corona::Bitmap& output);
+ virtual void getChildren(Corona::Stack&) {}
+ virtual bool exportMap(Corona::IResourceManager& resourceManager, Corona::XmlWriterNode& outXml) const { return true; };
+ virtual Corona::String name() const { return mapName; };
+};
+
+
+#endif
\ No newline at end of file
diff --git a/src/mayaToCorona/src/Corona/CoronaGeometry.cpp b/src/mayaToCorona/src/Corona/CoronaGeometry.cpp
index 0c666b5..e43569f 100644
--- a/src/mayaToCorona/src/Corona/CoronaGeometry.cpp
+++ b/src/mayaToCorona/src/Corona/CoronaGeometry.cpp
@@ -1,6 +1,7 @@
#include
#include "Corona.h"
+#include "CoronaGeometry.h"
#include
#include "maya/MFnMesh.h"
#include "maya/MFnMeshData.h"
@@ -15,6 +16,7 @@
#include "utilities/logging.h"
#include "utilities/tools.h"
#include "utilities/attrTools.h"
+#include "utilities/meshTools.h"
#include "mayaScene.h"
#include "../mtco_common/mtco_mayaObject.h"
#include "shadingtools/shadingUtils.h"
@@ -25,6 +27,55 @@
static Logging logger;
+void defineStdPlane(Corona::IGeometryGroup *geom)
+{
+ geom->getVertices().push(Corona::Pos(-1, 1, 0));
+ geom->getVertices().push(Corona::Pos(1, 1, 0));
+ geom->getVertices().push(Corona::Pos(-1, -1, 0));
+ geom->getVertices().push(Corona::Pos(1, -1, 0));
+
+
+ geom->getNormals().push(Corona::Dir(0, 0, -1));
+ geom->getNormals().push(Corona::Dir(0, 0, -1));
+ geom->getNormals().push(Corona::Dir(0, 0, -1));
+ geom->getNormals().push(Corona::Dir(0, 0, -1));
+
+ geom->getMapCoords().push(Corona::Pos(0, 0, 0));
+ geom->getMapCoordIndices().push(0);
+ geom->getMapCoords().push(Corona::Pos(1, 0, 0));
+ geom->getMapCoordIndices().push(1);
+ geom->getMapCoords().push(Corona::Pos(1, 1, 0));
+ geom->getMapCoordIndices().push(2);
+ geom->getMapCoords().push(Corona::Pos(0, 1, 0));
+ geom->getMapCoordIndices().push(3);
+
+ Corona::TriangleData tri;
+ tri.v[0][0] = 0;
+ tri.v[0][1] = 1;
+ tri.v[0][2] = 2;
+ tri.n[0][0] = 0;
+ tri.n[0][1] = 1;
+ tri.n[0][2] = 2;
+ tri.t[0] = 0;
+ tri.t[1] = 1;
+ tri.t[2] = 2;
+ tri.materialId = 0;
+ tri.edgeVis[0] = tri.edgeVis[1] = tri.edgeVis[2] = true;
+ geom->addPrimitive(tri);
+ tri.v[0][0] = 2;
+ tri.v[0][1] = 1;
+ tri.v[0][2] = 3;
+ tri.n[0][0] = 2;
+ tri.n[0][1] = 1;
+ tri.n[0][2] = 3;
+ tri.t[0] = 2;
+ tri.t[1] = 1;
+ tri.t[2] = 3;
+ tri.materialId = 0;
+ tri.edgeVis[0] = tri.edgeVis[1] = tri.edgeVis[2] = true;
+ geom->addPrimitive(tri);
+}
+
Corona::IGeometryGroup* CoronaRenderer::defineStdPlane()
{
Corona::IGeometryGroup* geom = this->context.scene->addGeomGroup();
@@ -83,6 +134,168 @@ void CoronaRenderer::updateMesh(std::shared_ptr obj)
obj->addMeshData();
}
+void defineMesh(Corona::IGeometryGroup *group, const MObject& meshObject)
+{
+ MStatus stat = MStatus::kSuccess;
+ bool hasDisplacement = false;
+ Corona::SharedPtr displacementMap = nullptr;
+ float displacementMin = 0.0f;
+ float displacementMax = 0.01f;
+
+ MFnMesh meshFn(meshObject, &stat);
+ CHECK_MSTATUS(stat);
+
+ MPointArray points;
+ MFloatVectorArray normals;
+ MFloatArray uArray, vArray;
+ MIntArray triPointIds, triNormalIds, triUvIds, triMatIds, perFaceAssignments;
+ MObject mo = meshObject;
+ getMeshData(mo, points, normals, uArray, vArray, triPointIds, triNormalIds, triUvIds, triMatIds, perFaceAssignments);
+
+ Logging::debug(MString("Translating mesh object ") + meshFn.name().asChar());
+ MString meshFullName = makeGoodString(meshFn.fullPathName());
+
+ uint numVertices = points.length();
+ uint numNormals = normals.length();
+ uint numUvs = uArray.length();
+
+ Corona::TriangleData td;
+ Corona::IGeometryGroup* geom = group;
+
+ uint npts = 0;
+ for (uint vtxId = 0; vtxId < numVertices; vtxId++)
+ {
+ MPoint& p = points[vtxId];
+ geom->getVertices().push(Corona::Pos(p.x, p.y, p.z));
+ }
+
+ for (uint nId = 0; nId < numNormals; nId++)
+ {
+ MFloatVector& n = normals[nId];
+ geom->getNormals().push(Corona::Dir(n.x, n.y, n.z));
+ }
+
+ for (uint tId = 0; tId < numUvs; tId++)
+ {
+ size_t mcl = geom->getMapCoordIndices().size();
+ geom->getMapCoordIndices().push(mcl);
+ geom->getMapCoords().push(Corona::Pos(uArray[tId], vArray[tId], 0.0f));
+ }
+
+ int numTris = triPointIds.length() / 3;
+ for (uint triId = 0; triId < numTris; triId++)
+ {
+ uint index = triId * 3;
+ int perFaceShadingGroup = triMatIds[triId];
+ int vtxId0 = triPointIds[index];
+ int vtxId1 = triPointIds[index + 1];
+ int vtxId2 = triPointIds[index + 2];
+ int normalId0 = triNormalIds[index];
+ int normalId1 = triNormalIds[index + 1];
+ int normalId2 = triNormalIds[index + 2];
+ int uvId0 = triUvIds[index];
+ int uvId1 = triUvIds[index + 1];
+ int uvId2 = triUvIds[index + 2];
+
+ std::auto_ptr trip;
+
+ if (hasDisplacement)
+ {
+ trip = std::auto_ptr(new Corona::DisplacedTriangleData);
+ Corona::DisplacedTriangleData *dtri = (Corona::DisplacedTriangleData *)trip.get();
+ dtri->displacement.map = displacementMap;
+ dtri->displacement.waterLevel = -Corona::INFINITY;
+ dtri->displacement.min = displacementMin;
+ dtri->displacement.max = displacementMax;
+
+
+ //Corona::DisplacedTriangleData tri;
+ //tri.displacement.map = displacementMap;
+ //tri.displacement.waterLevel = -Corona::INFINITY;
+ //MPoint p0 = points[vtxId0];
+ //MPoint p1 = points[vtxId1];
+ //MPoint p2 = points[vtxId2];
+ //tri.v[0] = Corona::AnimatedPos(Corona::Pos(p0.x, p0.y, p0.z));
+ //tri.v[1] = Corona::AnimatedPos(Corona::Pos(p1.x, p1.y, p1.z));
+ //tri.v[2] = Corona::AnimatedPos(Corona::Pos(p2.x, p2.y, p2.z));
+ //MVector n0 = normals[normalId0];
+ //MVector n1 = normals[normalId1];
+ //MVector n2 = normals[normalId2];
+ //Corona::Dir dir0(n0.x, n0.y, n0.z);
+ //Corona::Dir dir1(n1.x, n1.y, n1.z);
+ //Corona::Dir dir2(n2.x, n2.y, n2.z);
+ //tri.n[0] = Corona::AnimatedDir(dir0);
+ //tri.n[1] = Corona::AnimatedDir(dir1);
+ //tri.n[2] = Corona::AnimatedDir(dir2);
+ //Corona::Pos uv0(uArray[uvId0], vArray[uvId0], 0.0);
+ //Corona::Pos uv1(uArray[uvId1], vArray[uvId1], 0.0);
+ //Corona::Pos uv2(uArray[uvId2], vArray[uvId2], 0.0);
+ //Corona::StaticArray uvp;
+ //if (numUvs > 0)
+ //{
+ // uvp[0] = uv0;
+ // uvp[1] = uv1;
+ // uvp[2] = uv2;
+ // tri.t.push(uvp);
+ //}
+ //tri.edgeVis[0] = tri.edgeVis[1] = tri.edgeVis[2] = true;
+ //tri.materialId = perFaceShadingGroup;
+ //tri.displacement.min = displacementMin;
+ //tri.displacement.max = displacementMax;
+ //geom->addPrimitive(tri);
+ }
+ else{
+ trip = std::auto_ptr(new Corona::TriangleData);
+ //Corona::TriangleData tri;
+
+ //tri.v.setSegments(1 - 1);
+ //tri.n.setSegments(1 - 1);
+
+ //for (int stepId = 0; stepId < 1; stepId++)
+ //{
+ // tri.v[stepId][0] = vtxId0 + numVertices * stepId;
+ // tri.v[stepId][1] = vtxId1 + numVertices * stepId;
+ // tri.v[stepId][2] = vtxId2 + numVertices * stepId;
+ // tri.n[stepId][0] = normalId0 + numNormals * stepId;
+ // tri.n[stepId][1] = normalId1 + numNormals * stepId;
+ // tri.n[stepId][2] = normalId2 + numNormals * stepId;
+ //}
+
+ //if (numUvs > 0)
+ //{
+ // tri.t[0] = uvId0;
+ // tri.t[1] = uvId1;
+ // tri.t[2] = uvId2;
+ //}
+ //tri.materialId = perFaceShadingGroup;
+ //tri.edgeVis[0] = tri.edgeVis[1] = tri.edgeVis[2] = true;
+ //geom->addPrimitive(tri);
+ }
+ trip->v.setSegments(1 - 1);
+ trip->n.setSegments(1 - 1);
+
+ for (int stepId = 0; stepId < 1; stepId++)
+ {
+ trip->v[stepId][0] = vtxId0 + numVertices * stepId;
+ trip->v[stepId][1] = vtxId1 + numVertices * stepId;
+ trip->v[stepId][2] = vtxId2 + numVertices * stepId;
+ trip->n[stepId][0] = normalId0 + numNormals * stepId;
+ trip->n[stepId][1] = normalId1 + numNormals * stepId;
+ trip->n[stepId][2] = normalId2 + numNormals * stepId;
+ }
+
+ if (numUvs > 0)
+ {
+ trip->t[0] = uvId0;
+ trip->t[1] = uvId1;
+ trip->t[2] = uvId2;
+ }
+ trip->materialId = perFaceShadingGroup;
+ trip->edgeVis[0] = trip->edgeVis[1] = trip->edgeVis[2] = true;
+ geom->addPrimitive(*trip);
+ }
+}
+
void CoronaRenderer::defineMesh(std::shared_ptr mobj)
{
std::shared_ptr mayaScene = MayaTo::getWorldPtr()->worldScenePtr;
@@ -121,7 +334,8 @@ void CoronaRenderer::defineMesh(std::shared_ptr mobj)
{
Logging::error(MString("File texture extension is not supported: ") + fileTexturePath);
}else{
- mtco_MapLoader loader;
+ MObject nullObj;
+ mtco_MapLoader loader(nullObj);
displacementMap = loader.loadBitmap(fileTexturePath.asChar());
hasDisplacement = true;
}
@@ -140,105 +354,6 @@ void CoronaRenderer::defineMesh(std::shared_ptr mobj)
Logging::debug("defineMesh pre getMeshData");
obj->getMeshData(points, normals, uArray, vArray, triPointIds, triNormalIds, triUvIds, triMatIds);
- //std::cout << "const float points[] = {\n";
- //for (uint i = 0; i < points.length(); i++)
- //{
- // MString p("");
- // for (uint k = 0; k < 3; k++)
- // {
- // MString ps = MString("") + points[i][k];
- // if (ps == "0")
- // ps = "0.0";
- // if (ps == "1")
- // ps = "1.0";
- // if (ps == "-1")
- // ps = "-1.0";
- // p = p + ps + "f";
- // if (i < points.length() - 1)
- // p = p + ",";
- // }
- // std::cout << p.asChar() << "\n";
- //}
- //std::cout << "}\n";
- //std::cout << "const float normals[] = {\n";
- //for (uint i = 0; i < normals.length(); i++)
- //{
- // MString p("");
- // for (uint k = 0; k < 3; k++)
- // {
- // MString ps = MString("") + normals[i][k];
- // if (ps == "0")
- // ps = "0.0";
- // if (ps == "1")
- // ps = "1.0";
- // if (ps == "-1")
- // ps = "-1.0";
- // p = p + ps + "f";
- // if (i < normals.length() - 1)
- // p = p + ",";
- // }
- // std::cout << p.asChar() << "\n";
- //}
- //std::cout << "}\n";
- //std::cout << "const float uv[] = {\n";
- //for (uint i = 0; i < uArray.length(); i++)
- //{
- // MString p("");
- // MString us = MString("") + uArray[i];
- // if (us == "0")
- // us = "0.0";
- // if (us == "1")
- // us = "1.0";
- // if (us == "-1")
- // us = "-1.0";
- // MString vs = MString("") + vArray[i];
- // if (vs == "0")
- // vs = "0.0";
- // if (vs == "1")
- // vs = "1.0";
- // if (vs == "-1")
- // vs = "-1.0";
- // p = p + us + "f, " + vs + "f";
- // if (i < uArray.length() - 1)
- // p = p + ",";
- // std::cout << p.asChar() << "\n";
- //}
- //std::cout << "}\n";
-
- //std::cout << "const int triPointIds[] = {\n";
- //for (uint i = 0; i < triPointIds.length(); i += 3)
- //{
- // MString p;
- // p = p + triPointIds[i] + ", " + triPointIds[i + 1] + ", " + triPointIds[i + 2];
- // if (i < triPointIds.length() - 3)
- // p = p + ",";
- // std::cout << p.asChar() << "\n";
- //}
- //std::cout << "};\n";
-
- //std::cout << "const int triNormalIds[] = {\n";
- //for (uint i = 0; i < triNormalIds.length(); i += 3)
- //{
- // MString p;
- // p = p + triNormalIds[i] + ", " + triNormalIds[i + 1] + ", " + triNormalIds[i + 2];
- // if (i < triNormalIds.length() - 3)
- // p = p + ",";
- // std::cout << p.asChar() << "\n";
- //}
- //std::cout << "};\n";
-
- //std::cout << "const int triUvIds[] = {\n";
- //for (uint i = 0; i < triUvIds.length(); i += 3)
- //{
- // MString p;
- // p = p + triUvIds[i] + ", " + triUvIds[i + 1] + ", " + triUvIds[i + 2];
- // if (i < triUvIds.length() - 3)
- // p = p + ",";
- // std::cout << p.asChar() << "\n";
- //}
- //std::cout << "};\n";
-
-
int numSteps = (int)obj->meshDataList.size();
uint numVertices = points.length();
uint numNormals = normals.length();
@@ -274,20 +389,15 @@ void CoronaRenderer::defineMesh(std::shared_ptr mobj)
}
}
npts = md.points.length();
- //Logging::debug(MString("Adding ") + npts + " points for step " + mbStep);
for( uint vtxId = 0; vtxId < md.points.length(); vtxId++)
{
MPoint& p = md.points[vtxId];
- //Logging::debug(MString("geom->getVertices().push(Corona::Pos(") + p.x + ", " + p.y + ", " + p.z + " ));");
geom->getVertices().push(Corona::Pos(p.x,p.y,p.z));
}
- //Logging::debug(MString("Adding ") + md.normals.length() + " normals for step " + mbStep);
for (uint nId = 0; nId < md.normals.length(); nId++)
{
MFloatVector& n = md.normals[nId];
- //Logging::debug(MString("geom->getNormals().push(Corona::Pos(") + n.x + ", " + n.y + ", " + n.z + " ));");
- //Logging::debug(MString("N id: ") + nId + ": " + n.x + " " + n.y + " " + n.z);
geom->getNormals().push(Corona::Dir(n.x, n.y, n.z));
}
}
@@ -296,22 +406,12 @@ void CoronaRenderer::defineMesh(std::shared_ptr mobj)
{
size_t mcl = geom->getMapCoordIndices().size();
geom->getMapCoordIndices().push(mcl);
- //Logging::debug(MString("geom->getMapCoordIndices().push(") + mcl + ");");
geom->getMapCoords().push(Corona::Pos(uArray[tId], vArray[tId], 0.0f));
- //Logging::debug(MString("geom->getMapCoords().push(Corona::Pos(") + uArray[tId] + ", " + vArray[tId] + ", 0.0f));");
- //Logging::debug(MString("Geom - Add Uvs : ") + uArray[tId] + " " + vArray[tId]);
}
- //geom->getMapCoordIndices().push(geom->getMapCoordIndices().size());
-
obj->geom = geom;
int numTris = triPointIds.length() / 3;
- //context.core->sanityCheck(context.scene);
-
- //Logging::debug(MString("Corona::TriangleData tri;"));
-
- //Logging::debug(MString("for (uint triId = 0; triId < ") + numTris + "; triId++)\n{");
for (uint triId = 0; triId < numTris; triId++)
{
uint index = triId * 3;
@@ -328,98 +428,108 @@ void CoronaRenderer::defineMesh(std::shared_ptr mobj)
if ((vtxId0 >= npts) || (vtxId1 >= npts) || (vtxId2 >= npts))
Logging::error(MString("Index > npts!!! -- Obj: ") + obj->shortName);
- //Logging::debug(MString("VtxIds: ") + vtxId0 + " " + vtxId1 + " " + vtxId2);
- //Logging::debug(MString("NorIds: ") + normalId0 + " " + normalId1 + " " + normalId2);
- //Logging::debug(MString("UVsIds: ") + uvId0 + " " + uvId1 + " " + uvId2);
- //Logging::debug(MString("") + points[vtxId0].x + " " + points[vtxId0].y + " " + points[vtxId0].z);
- //Logging::debug(MString("") + points[vtxId1].x + " " + points[vtxId1].y + " " + points[vtxId1].z);
- //Logging::debug(MString("") + points[vtxId2].x + " " + points[vtxId2].y + " " + points[vtxId2].z);
- //Logging::debug(MString("") + normals[normalId0].x + " " + normals[normalId0].y + " " + normals[normalId0].z);
- //Logging::debug(MString("") + normals[normalId1].x + " " + normals[normalId1].y + " " + normals[normalId1].z);
- //Logging::debug(MString("") + normals[normalId2].x + " " + normals[normalId2].y + " " + normals[normalId2].z);
-
- //Logging::debug(MString("") + uArray[uvId0] + " " + vArray[uvId0]);
- //Logging::debug(MString("") + uArray[uvId1] + " " + vArray[uvId1]);
- //Logging::debug(MString("") + uArray[uvId2] + " " + vArray[uvId2]);
+ std::auto_ptr trip;
if (hasDisplacement)
{
- Corona::DisplacedTriangleData tri;
- tri.displacement.map = displacementMap;
- tri.displacement.waterLevel = -Corona::INFINITY;
- MPoint p0 = points[vtxId0];
- MPoint p1 = points[vtxId1];
- MPoint p2 = points[vtxId2];
- tri.v[0] = Corona::AnimatedPos(Corona::Pos(p0.x, p0.y, p0.z));
- tri.v[1] = Corona::AnimatedPos(Corona::Pos(p1.x, p1.y, p1.z));
- tri.v[2] = Corona::AnimatedPos(Corona::Pos(p2.x, p2.y, p2.z));
- MVector n0 = normals[normalId0];
- MVector n1 = normals[normalId1];
- MVector n2 = normals[normalId2];
- Corona::Dir dir0(n0.x, n0.y, n0.z);
- Corona::Dir dir1(n1.x, n1.y, n1.z);
- Corona::Dir dir2(n2.x, n2.y, n2.z);
- tri.n[0] = Corona::AnimatedDir(dir0);
- tri.n[1] = Corona::AnimatedDir(dir1);
- tri.n[2] = Corona::AnimatedDir(dir2);
- Corona::Pos uv0(uArray[uvId0],vArray[uvId0],0.0);
- Corona::Pos uv1(uArray[uvId1],vArray[uvId1],0.0);
- Corona::Pos uv2(uArray[uvId2],vArray[uvId2],0.0);
- Corona::StaticArray uvp;
- if (numUvs > 0)
- {
- uvp[0] = uv0;
- uvp[1] = uv1;
- uvp[2] = uv2;
- tri.t.push(uvp);
- }
- tri.edgeVis[0] = tri.edgeVis[1] = tri.edgeVis[2] = true;
- tri.materialId = perFaceShadingGroup;
- tri.displacement.min = displacementMin;
- tri.displacement.max = displacementMax;
- geom->addPrimitive(tri);
+ trip = std::auto_ptr(new Corona::DisplacedTriangleData);
+ Corona::DisplacedTriangleData *dtri = (Corona::DisplacedTriangleData *)trip.get();
+ dtri->displacement.map = displacementMap;
+ dtri->displacement.waterLevel = -Corona::INFINITY;
+ dtri->displacement.min = displacementMin;
+ dtri->displacement.max = displacementMax;
}
else{
- Corona::TriangleData tri;
+ trip = std::auto_ptr(new Corona::TriangleData);
+ }
- tri.v.setSegments(numSteps - 1);
- tri.n.setSegments(numSteps - 1);
+ trip->v.setSegments(1 - 1);
+ trip->n.setSegments(1 - 1);
- for (int stepId = 0; stepId < numSteps; stepId++)
- {
- tri.v[stepId][0] = vtxId0 + numVertices * stepId;
- tri.v[stepId][1] = vtxId1 + numVertices * stepId;
- tri.v[stepId][2] = vtxId2 + numVertices * stepId;
- //Logging::debug(MString("TriId ") + triId + " vtx: " + vtxId0 + " " + vtxId1 + " " + vtxId2);
- tri.n[stepId][0] = normalId0 + numNormals * stepId;
- tri.n[stepId][1] = normalId1 + numNormals * stepId;
- tri.n[stepId][2] = normalId2 + numNormals * stepId;
- //Logging::debug(MString("tri.v[") + stepId + "][0] = " + (vtxId0 + numVertices * stepId) + ";");
- //Logging::debug(MString("tri.v[") + stepId + "][1] = " + (vtxId1 + numVertices * stepId) + ";");
- //Logging::debug(MString("tri.v[") + stepId + "][2] = " + (vtxId2 + numVertices * stepId) + ";");
- //Logging::debug(MString("tri.n[") + stepId + "][0] = " + (normalId0 + numNormals * stepId) + ";");
- //Logging::debug(MString("tri.n[") + stepId + "][1] = " + (normalId1 + numNormals * stepId) + ";");
- //Logging::debug(MString("tri.n[") + stepId + "][2] = " + (normalId2 + numNormals * stepId) + ";");
- }
+ for (int stepId = 0; stepId < 1; stepId++)
+ {
+ trip->v[stepId][0] = vtxId0 + numVertices * stepId;
+ trip->v[stepId][1] = vtxId1 + numVertices * stepId;
+ trip->v[stepId][2] = vtxId2 + numVertices * stepId;
+ trip->n[stepId][0] = normalId0 + numNormals * stepId;
+ trip->n[stepId][1] = normalId1 + numNormals * stepId;
+ trip->n[stepId][2] = normalId2 + numNormals * stepId;
+ }
- if (numUvs > 0)
- {
- tri.t[0] = uvId0;
- tri.t[1] = uvId1;
- tri.t[2] = uvId2;
- //Logging::debug(MString("tri.t[0] = ") + uvId0 + ";");
- //Logging::debug(MString("tri.t[1] = ") + uvId1 + ";");
- //Logging::debug(MString("tri.t[2] = ") + uvId2 + ";");
- }
- //Logging::debug(MString("tri.materialId = ") + perFaceShadingGroup + ";");
- tri.materialId = perFaceShadingGroup;
- //Logging::debug(MString("tri.edgeVis[0] = tri.edgeVis[1] = tri.edgeVis[2] = true;"));
- tri.edgeVis[0] = tri.edgeVis[1] = tri.edgeVis[2] = true;
- //Logging::debug(MString("geom->addPrimitive(tri);"));
- geom->addPrimitive(tri);
- //context.core->sanityCheck(context.scene);
+ if (numUvs > 0)
+ {
+ trip->t[0] = uvId0;
+ trip->t[1] = uvId1;
+ trip->t[2] = uvId2;
}
+ trip->materialId = perFaceShadingGroup;
+ trip->edgeVis[0] = trip->edgeVis[1] = trip->edgeVis[2] = true;
+ geom->addPrimitive(*trip);
+
+ //if (hasDisplacement)
+ //{
+ // Corona::DisplacedTriangleData tri;
+ // tri.displacement.map = displacementMap;
+ // tri.displacement.waterLevel = -Corona::INFINITY;
+ // MPoint p0 = points[vtxId0];
+ // MPoint p1 = points[vtxId1];
+ // MPoint p2 = points[vtxId2];
+ // tri.v[0] = Corona::AnimatedPos(Corona::Pos(p0.x, p0.y, p0.z));
+ // tri.v[1] = Corona::AnimatedPos(Corona::Pos(p1.x, p1.y, p1.z));
+ // tri.v[2] = Corona::AnimatedPos(Corona::Pos(p2.x, p2.y, p2.z));
+ // MVector n0 = normals[normalId0];
+ // MVector n1 = normals[normalId1];
+ // MVector n2 = normals[normalId2];
+ // Corona::Dir dir0(n0.x, n0.y, n0.z);
+ // Corona::Dir dir1(n1.x, n1.y, n1.z);
+ // Corona::Dir dir2(n2.x, n2.y, n2.z);
+ // tri.n[0] = Corona::AnimatedDir(dir0);
+ // tri.n[1] = Corona::AnimatedDir(dir1);
+ // tri.n[2] = Corona::AnimatedDir(dir2);
+ // Corona::Pos uv0(uArray[uvId0],vArray[uvId0],0.0);
+ // Corona::Pos uv1(uArray[uvId1],vArray[uvId1],0.0);
+ // Corona::Pos uv2(uArray[uvId2],vArray[uvId2],0.0);
+ // Corona::StaticArray uvp;
+ // if (numUvs > 0)
+ // {
+ // uvp[0] = uv0;
+ // uvp[1] = uv1;
+ // uvp[2] = uv2;
+ // tri.t.push(uvp);
+ // }
+ // tri.edgeVis[0] = tri.edgeVis[1] = tri.edgeVis[2] = true;
+ // tri.materialId = perFaceShadingGroup;
+ // tri.displacement.min = displacementMin;
+ // tri.displacement.max = displacementMax;
+ // geom->addPrimitive(tri);
+ //}
+ //else{
+ // Corona::TriangleData tri;
+
+ // tri.v.setSegments(numSteps - 1);
+ // tri.n.setSegments(numSteps - 1);
+
+ // for (int stepId = 0; stepId < numSteps; stepId++)
+ // {
+ // tri.v[stepId][0] = vtxId0 + numVertices * stepId;
+ // tri.v[stepId][1] = vtxId1 + numVertices * stepId;
+ // tri.v[stepId][2] = vtxId2 + numVertices * stepId;
+ // tri.n[stepId][0] = normalId0 + numNormals * stepId;
+ // tri.n[stepId][1] = normalId1 + numNormals * stepId;
+ // tri.n[stepId][2] = normalId2 + numNormals * stepId;
+ // }
+
+ // if (numUvs > 0)
+ // {
+ // tri.t[0] = uvId0;
+ // tri.t[1] = uvId1;
+ // tri.t[2] = uvId2;
+ // }
+ // tri.materialId = perFaceShadingGroup;
+ // tri.edgeVis[0] = tri.edgeVis[1] = tri.edgeVis[2] = true;
+ // geom->addPrimitive(tri);
+ //}
}
//Logging::debug("}");
obj->perFaceAssignments.clear();
@@ -476,7 +586,7 @@ void CoronaRenderer::defineGeometry()
Corona::AnimatedAffineTm atm;
this->setAnimatedTransformationMatrix(atm, obj);
obj->instance = geom->addInstance(atm, obj.get(), nullptr);
-
+
MFnDependencyNode depFn(obj->mobject);
if (getBoolAttr("mtco_envPortal", depFn, false))
{
diff --git a/src/mayaToCorona/src/Corona/CoronaGeometry.h b/src/mayaToCorona/src/Corona/CoronaGeometry.h
new file mode 100644
index 0000000..5aaf59b
--- /dev/null
+++ b/src/mayaToCorona/src/Corona/CoronaGeometry.h
@@ -0,0 +1,9 @@
+#ifndef CORONA_GEO_H
+#define CORONA_GEO_H
+
+#include "CoronaCore/api/Api.h"
+
+void defineStdPlane(Corona::IGeometryGroup *group);
+void defineMesh(Corona::IGeometryGroup *group, const MObject& geoObj);
+
+#endif
\ No newline at end of file
diff --git a/src/mayaToCorona/src/Corona/CoronaLights.cpp b/src/mayaToCorona/src/Corona/CoronaLights.cpp
index b061a50..ffa95b0 100644
--- a/src/mayaToCorona/src/Corona/CoronaLights.cpp
+++ b/src/mayaToCorona/src/Corona/CoronaLights.cpp
@@ -13,8 +13,6 @@
#include "world.h"
#include "../mtco_common/mtco_mayaObject.h"
-static Logging logger;
-
bool CoronaRenderer::isSunLight(std::shared_ptr obj)
{
// a sun light has a transform connection to the coronaGlobals.sunLightConnection plug
@@ -51,63 +49,65 @@ void CoronaRenderer::defineLights()
Corona::Rgb bgRgb = toCorona(getColorAttr("bgColor", depFn));
int bgType = getEnumInt("bgType", depFn);
- if( renderGlobals->useSunLightConnection)
- {
- getConnectedInNodes(MString("sunLightConnection"), coronaGlobals, nodeList);
- if( nodeList.length() > 0)
- {
- MObject sunObj = nodeList[0];
- if(sunObj.hasFn(MFn::kTransform))
- {
- // we suppose what's connected here is a dir light transform
- MVector lightDir(0, 0, 1); // default dir light dir
- MFnDagNode sunDagNode(sunObj);
- lightDir *= sunDagNode.transformationMatrix();
- lightDir *= renderGlobals->globalConversionMatrix;
- lightDir.normalize();
-
- MObject sunDagObj = sunDagNode.child(0, &stat);
- MColor sunColor(1);
- float colorMultiplier = 1.0f;
- if(sunDagObj.hasFn(MFn::kDirectionalLight))
- {
- MFnDependencyNode sunNode(sunDagObj);
- getColor("color", sunNode, sunColor);
- colorMultiplier = getFloatAttr("mtco_sun_multiplier", sunNode, 1.0f);
- }else{
- Logging::warning(MString("Sun connection is not a directional light - using transform only."));
- }
- const float intensityFactor = (1.f - cos(Corona::SUN_PROJECTED_HALF_ANGLE)) / (1.f - cos(getFloatAttr("sunSizeMulti", rGlNode, 1.0f) * Corona::SUN_PROJECTED_HALF_ANGLE));
- sunColor *= colorMultiplier * intensityFactor * 1.0;// 2000000;
- Corona::Sun sun;
+ //if( renderGlobals->useSunLightConnection)
+ //{
+ // getConnectedInNodes(MString("sunLightConnection"), coronaGlobals, nodeList);
+ // if( nodeList.length() > 0)
+ // {
+ // MObject sunObj = nodeList[0];
+ // if(sunObj.hasFn(MFn::kTransform))
+ // {
+ // // we suppose what's connected here is a dir light transform
+ // MVector lightDir(0, 0, 1); // default dir light dir
+ // MFnDagNode sunDagNode(sunObj);
+ // lightDir *= sunDagNode.transformationMatrix();
+ // lightDir *= renderGlobals->globalConversionMatrix;
+ // lightDir.normalize();
+ //
+ // MObject sunDagObj = sunDagNode.child(0, &stat);
+ // MColor sunColor(1);
+ // float colorMultiplier = 1.0f;
+ // if(sunDagObj.hasFn(MFn::kDirectionalLight))
+ // {
+ // MFnDependencyNode sunNode(sunDagObj);
+ // getColor("color", sunNode, sunColor);
+ // colorMultiplier = getFloatAttr("mtco_sun_multiplier", sunNode, 1.0f);
+ // }else{
+ // Logging::warning(MString("Sun connection is not a directional light - using transform only."));
+ // }
+ // const float intensityFactor = (1.f - cos(Corona::SUN_PROJECTED_HALF_ANGLE)) / (1.f - cos(getFloatAttr("sunSizeMulti", rGlNode, 1.0f) * Corona::SUN_PROJECTED_HALF_ANGLE));
+ // sunColor *= colorMultiplier * intensityFactor * 1.0;// 2000000;
+ // Corona::Sun sun;
- Corona::ColorOrMap bgCoMap = this->context.scene->getBackground();
- SkyMap *sky = dynamic_cast(bgCoMap.getMap());
- Corona::Rgb avgColor(1, 1, 1);
- if (sky != nullptr)
- {
- avgColor = sky->sc();
- }
+ // Corona::ColorOrMap bgCoMap = this->context.scene->getBackground();
+ // SkyMap *sky = dynamic_cast(bgCoMap.getMap());
+ // Corona::Rgb avgColor(1, 1, 1);
+ // if (sky != nullptr)
+ // {
+ // avgColor = sky->sc();
+ // }
- Corona::Rgb sColor(sunColor.r, sunColor.g, sunColor.b);
- sun.color = sColor * avgColor;
- sun.active = true;
- sun.dirTo = Corona::Dir(lightDir.x, lightDir.y, lightDir.z).getNormalized();
- //sun.color = Corona::Rgb(sunColor.r,sunColor.g,sunColor.b);
- sun.visibleDirect = true;
- sun.visibleReflect = true;
- sun.visibleRefract = true;
- sun.sizeMultiplier = getFloatAttr("sunSizeMulti", rGlNode, 1.0);
- this->context.scene->getSun() = sun;
- sky->initSky();
- if (sky != nullptr)
- {
- avgColor = sky->sc();
- this->context.scene->getSun().color = sColor * avgColor;
- }
- }
- }
- }
+ // Corona::Rgb sColor(sunColor.r, sunColor.g, sunColor.b);
+ // sun.color = sColor * avgColor;
+ // sun.active = true;
+ // sun.dirTo = Corona::Dir(lightDir.x, lightDir.y, lightDir.z).getNormalized();
+ // //sun.color = Corona::Rgb(sunColor.r,sunColor.g,sunColor.b);
+ // sun.visibleDirect = true;
+ // sun.visibleReflect = true;
+ // sun.visibleRefract = true;
+ // sun.sizeMultiplier = getFloatAttr("sunSizeMulti", rGlNode, 1.0);
+ // this->context.scene->getSun() = sun;
+ // sky->initSky();
+ // if (sky != nullptr)
+ // {
+ // avgColor = sky->sc();
+ // this->context.scene->getSun().color = sColor * avgColor;
+ // }
+ // }
+ // }
+ //}
+
+ MayaObject *sunLight = nullptr;
for (auto mobj : mayaScene->lightList)
{
@@ -116,8 +116,6 @@ void CoronaRenderer::defineLights()
if(!obj->visible)
continue;
- if( this->isSunLight(obj))
- continue;
MFnDependencyNode depFn(obj->mobject);
@@ -180,43 +178,92 @@ void CoronaRenderer::defineLights()
Corona::AffineTm tm;
setTransformationMatrix(sl->lightWorldInverseMatrix, m);
ShadingNetwork network(obj->mobject);
- sl->lightColorMap = defineAttribute(MString("color"), depFn, network);
+ sl->lightColorMap = defineAttribute(MString("color"), depFn, network, oslRenderer);
this->context.scene->addLightShader(sl);
}
if( obj->mobject.hasFn(MFn::kDirectionalLight))
{
- MVector lightDir(0, 0, -1);
- MVector lightDirTangent(1, 0, 0);
- MVector lightDirBiTangent(0, 1, 0);
- MColor col;
- getColor("color", depFn, col);
- float intensity = 1.0f;
- getFloat("intensity", depFn, intensity);
- MMatrix m = obj->transformMatrices[0] * renderGlobals->globalConversionMatrix;
- lightDir *= m;
- lightDirTangent *= m;
- lightDirBiTangent *= m;
- lightDir.normalize();
-
- Corona::Pos LP(m[3][0],m[3][1],m[3][2]);
- DirectionalLight *dl = new DirectionalLight;
- dl->LP = LP;
- dl->lightColor = Corona::Rgb(col.r, col.g, col.b);
- dl->lightIntensity = intensity;
- dl->LD = Corona::Dir(lightDir.x, lightDir.y, lightDir.z);
- dl->LT = Corona::Dir(lightDirTangent.x, lightDirTangent.y, lightDirTangent.z);
- dl->LBT = Corona::Dir(lightDirBiTangent.x, lightDirBiTangent.y, lightDirBiTangent.z);
- dl->lightAngle = getFloatAttr("lightAngle", depFn, 0.0);
- dl->doShadows = getBoolAttr("useRayTraceShadows", depFn, true);
- col = getColorAttr("shadowColor", depFn);
- dl->shadowColor = Corona::Rgb(col.r, col.g, col.b);
- for (auto excludedObj : obj->excludedObjects)
+ if (getBoolAttr("mtco_useAsSun", depFn, false))
{
- dl->excludeList.nodes.push(excludedObj.get());
+ if (sunLight != nullptr)
+ {
+ Logging::error(MString("A sun light is already defined, ignoring ") + obj->shortName);
+ continue;
+ }
+ sunLight = obj.get();
+ MVector lightDir(0, 0, 1); // default dir light dir
+ lightDir *= obj->transformMatrices[0];
+ lightDir *= renderGlobals->globalConversionMatrix;
+ lightDir.normalize();
+
+ MColor sunColor(1);
+ MFnDependencyNode sunNode(obj->mobject);
+ getColor("color", sunNode, sunColor);
+ sunColor *= getFloatAttr("intensity", sunNode, 1.0f);
+ //float colorMultiplier colorMultiplier = getFloatAttr("mtco_sun_multiplier", sunNode, 1.0f);
+ const float intensityFactor = (1.f - cos(Corona::SUN_PROJECTED_HALF_ANGLE)) / (1.f - cos(getFloatAttr("sunSizeMulti", rGlNode, 1.0f) * Corona::SUN_PROJECTED_HALF_ANGLE));
+ sunColor *= intensityFactor * 1.0;// 2000000;
+ Corona::Sun sun;
+
+ Corona::ColorOrMap bgCoMap = this->context.scene->getBackground();
+ SkyMap *sky = dynamic_cast(bgCoMap.getMap());
+ Corona::Rgb avgColor(1, 1, 1);
+ if (sky != nullptr)
+ {
+ avgColor = sky->sc();
+ }
+
+ Corona::Rgb sColor(sunColor.r, sunColor.g, sunColor.b);
+ sun.color = sColor * avgColor;
+ sun.active = true;
+ sun.dirTo = Corona::Dir(lightDir.x, lightDir.y, lightDir.z).getNormalized();
+ //sun.color = Corona::Rgb(sunColor.r,sunColor.g,sunColor.b);
+ sun.visibleDirect = true;
+ sun.visibleReflect = true;
+ sun.visibleRefract = true;
+ sun.sizeMultiplier = getFloatAttr("sunSizeMulti", rGlNode, 1.0);
+ this->context.scene->getSun() = sun;
+ sky->initSky();
+ if (sky != nullptr)
+ {
+ avgColor = sky->sc();
+ this->context.scene->getSun().color = sColor * avgColor;
+ }
}
+ else{
+ MVector lightDir(0, 0, -1);
+ MVector lightDirTangent(1, 0, 0);
+ MVector lightDirBiTangent(0, 1, 0);
+ MColor col;
+ getColor("color", depFn, col);
+ float intensity = 1.0f;
+ getFloat("intensity", depFn, intensity);
+ MMatrix m = obj->transformMatrices[0] * renderGlobals->globalConversionMatrix;
+ lightDir *= m;
+ lightDirTangent *= m;
+ lightDirBiTangent *= m;
+ lightDir.normalize();
- this->context.scene->addLightShader(dl);
+ Corona::Pos LP(m[3][0], m[3][1], m[3][2]);
+ DirectionalLight *dl = new DirectionalLight;
+ dl->LP = LP;
+ dl->lightColor = Corona::Rgb(col.r, col.g, col.b);
+ dl->lightIntensity = intensity;
+ dl->LD = Corona::Dir(lightDir.x, lightDir.y, lightDir.z);
+ dl->LT = Corona::Dir(lightDirTangent.x, lightDirTangent.y, lightDirTangent.z);
+ dl->LBT = Corona::Dir(lightDirBiTangent.x, lightDirBiTangent.y, lightDirBiTangent.z);
+ dl->lightAngle = getFloatAttr("lightAngle", depFn, 0.0);
+ dl->doShadows = getBoolAttr("useRayTraceShadows", depFn, true);
+ col = getColorAttr("shadowColor", depFn);
+ dl->shadowColor = Corona::Rgb(col.r, col.g, col.b);
+ for (auto excludedObj : obj->excludedObjects)
+ {
+ dl->excludeList.nodes.push(excludedObj.get());
+ }
+
+ this->context.scene->addLightShader(dl);
+ }
}
if( obj->mobject.hasFn(MFn::kAreaLight))
{
@@ -237,7 +284,7 @@ void CoronaRenderer::defineLights()
MColor lightColor = getColorAttr("color", depFn);
float intensity = getFloatAttr("intensity", depFn, 1.0f);
lightColor *= intensity;
- Corona::ColorOrMap com = defineAttribute(MString("color"), obj->mobject);
+ Corona::ColorOrMap com = defineAttribute(MString("color"), obj->mobject, oslRenderer);
OSLMap *oslmap = (OSLMap *)com.getMap();
if (oslmap != nullptr)
{
diff --git a/src/mayaToCorona/src/Corona/CoronaMap.cpp b/src/mayaToCorona/src/Corona/CoronaMap.cpp
index fd602af..7f4e3d5 100644
--- a/src/mayaToCorona/src/Corona/CoronaMap.cpp
+++ b/src/mayaToCorona/src/Corona/CoronaMap.cpp
@@ -1,5 +1,8 @@
#include "CoronaMap.h"
+#include
#include "utilities/pystring.h"
+#include "utilities/attrTools.h"
+#include "utilities/tools.h"
#include
bool textureFileSupported(MString fileName)
@@ -19,4 +22,42 @@ bool textureFileSupported(MString fileName)
return true;
return false;
-}
\ No newline at end of file
+}
+
+
+mtco_MapLoader::mtco_MapLoader(MObject& mobject)
+{
+ if (mobject == MObject::kNullObj)
+ return;
+ MFnDependencyNode depFn(mobject);
+ colorGain = getColorAttr("colorGain", depFn);
+ colorOffset = getColorAttr("colorOffset", depFn);
+ exposure = getFloatAttr("exposure", depFn, 0.0f);
+ MObject place2dNode = getConnectedInNode(mobject, "uvCoord");
+ if ((place2dNode != MObject::kNullObj) && (place2dNode.hasFn(MFn::kPlace2dTexture)))
+ {
+ MFnDependencyNode placeFn(place2dNode);
+ float coverageU = getFloatAttr("coverageU", placeFn, 1.0f);
+ float coverageV = getFloatAttr("coverageV", placeFn, 1.0f);
+ float translateFrameU = getFloatAttr("translateFrameU", placeFn, 0.0f);
+ float translateFrameV = getFloatAttr("translateFrameV", placeFn, 0.0f);
+ float rotateFrame = getFloatAttr("rotateFrame", placeFn, 0.0f);
+ float repeatU = getFloatAttr("repeatU", placeFn, 1.0f);
+ float repeatV = getFloatAttr("repeatV", placeFn, 1.0f);
+ float offsetU = getFloatAttr("offsetU", placeFn, 0.0f);
+ float offsetV = getFloatAttr("offsetV", placeFn, 0.0f);
+ float rotateUV = getFloatAttr("rotateUV", placeFn, 0.0f);
+ float noiseU = getFloatAttr("noiseU", placeFn, 1.0f);
+ float noiseV = getFloatAttr("noiseV", placeFn, 1.0f);
+ float mirrorU = getBoolAttr("mirrorU", placeFn, false);
+ float mirrorV = getBoolAttr("mirrorV", placeFn, false);
+ float wrapU = getBoolAttr("wrapU", placeFn, true);
+ float wrapV = getBoolAttr("wrapV", placeFn, true);
+ float stagger = getBoolAttr("stagger", placeFn, false);
+ Corona::TextureShader::Config tsConfig;
+
+ }
+}
+
+mtco_MapLoader::~mtco_MapLoader()
+{}
diff --git a/src/mayaToCorona/src/Corona/CoronaMap.h b/src/mayaToCorona/src/Corona/CoronaMap.h
index 946fb80..b5d49ae 100644
--- a/src/mayaToCorona/src/Corona/CoronaMap.h
+++ b/src/mayaToCorona/src/Corona/CoronaMap.h
@@ -42,75 +42,185 @@ class SidedMap : public Corona::Abstract::Map {
static int c = 0;
+
class mtco_MapLoader : public Corona::Object {
public:
MColor colorGain;
MColor colorOffset;
float exposure;
- Corona::Abstract::Map* loadBitmap(const Corona::String& filename) {
+ mtco_MapLoader::mtco_MapLoader(MObject& mobject);
+ mtco_MapLoader::~mtco_MapLoader();
+ Corona::Abstract::Map* loadBitmap(const Corona::String& filename)
+ {
class TextureMap : public Corona::Abstract::Map {
protected:
Corona::TextureShader shader;
public:
- MColor colorGain;
- MColor colorOffset;
- float exposure;
+ TextureMap(const Corona::String& filename, const int mapChannel) {
+ Corona::TextureShader::Config config;
+ config.mapping.uvwMapChannel = mapChannel;
+ config.texture = Corona::TextureShader::getImageTexture(filename);
+
+ this->shader.configure(config);
+ }
+
+ virtual Corona::Rgb evalColor(const Corona::IShadeContext& context, Corona::TextureCache* cache, float& outAlpha) {
+ outAlpha = 1.f;
+ bool outsideDummy;
+ return shader.eval(context, true, outsideDummy);
+ }
+
+ virtual float evalMono(const Corona::IShadeContext& context, Corona::TextureCache* cache, float& outAlpha) {
+ outAlpha = 1.f;
+
+ bool outsideDummy;
+ return shader.eval(context, true, outsideDummy).grayValue();
+ }
+
+ virtual Corona::Dir evalBump(const Corona::IShadeContext& context, Corona::TextureCache* cache) {
+ STOP;
+ }
+
+ virtual void renderTo(Corona::Bitmap& output) {
+ //shader.renderTo(output);
+ }
+
+
+ virtual Corona::String name() const {
+ return "TextureMap";
+ }
+ virtual void getChildren(Corona::Stack&) {}
+ virtual bool exportMap(Corona::IResourceManager& resourceManager, Corona::XmlWriterNode& outXml) const { return true; }
+
+ };
+
+ return new TextureMap(filename, 0);
+ }
+};
+
+class mtco_FileLoader : public Corona::Object {
+public:
+ Corona::Abstract::Map* loadBitmap(const Corona::String& filename)
+ {
+ class TextureMap : public Corona::Abstract::Map {
+ protected:
+ Corona::TextureShader shader;
+ public:
TextureMap(const Corona::String& filename, const int mapChannel) {
Corona::TextureShader::Config config;
config.mapping.uvwMapChannel = mapChannel;
config.texture = Corona::TextureShader::getImageTexture(filename);
+
this->shader.configure(config);
}
virtual Corona::Rgb evalColor(const Corona::IShadeContext& context, Corona::TextureCache* cache, float& outAlpha) {
outAlpha = 1.f;
bool outsideDummy;
- float ex = exposure;
- Corona::Rgb envColor = shader.eval(context, true, outsideDummy);
- //if (c < 100)
- //{
- // std::cout << "evalEnvCol " << envColor.r() << " " << envColor.g() << " " << envColor.g() << "\n";
- // c++;
- //}
- return envColor;
+ return shader.eval(context, true, outsideDummy);
}
- /// \brief Same as evalColor, only scalar value is returned
virtual float evalMono(const Corona::IShadeContext& context, Corona::TextureCache* cache, float& outAlpha) {
outAlpha = 1.f;
+
bool outsideDummy;
return shader.eval(context, true, outsideDummy).grayValue();
}
- /// \brief Evaluates bump mapping for this texture and returns a vector that have to be added to the
- /// current normal to create the bump effect (the normal perturbation)
virtual Corona::Dir evalBump(const Corona::IShadeContext& context, Corona::TextureCache* cache) {
STOP;
}
- /// \brief Renders the map to given output bitmap. Sets the output dimensions to adequate values.
virtual void renderTo(Corona::Bitmap& output) {
- shader.renderTo(output);
+ //shader.renderTo(output);
}
+
virtual Corona::String name() const {
return "TextureMap";
}
virtual void getChildren(Corona::Stack&) {}
+ virtual bool exportMap(Corona::IResourceManager& resourceManager, Corona::XmlWriterNode& outXml) const { return true; }
+
};
- TextureMap *texMap = new TextureMap(filename, 0);
- texMap->colorGain = colorGain;
- texMap->colorOffset = colorOffset;
- texMap->exposure = exposure;
- return texMap;
+ return new TextureMap(filename, 0);
}
};
+//class mtco_MapLoader : public Corona::Object {
+//public:
+// MColor colorGain;
+// MColor colorOffset;
+// float exposure;
+//
+// Corona::Abstract::Map* loadBitmap(const Corona::String& filename) {
+//
+// class TextureMap : public Corona::Abstract::Map {
+// protected:
+// Corona::TextureShader shader;
+// public:
+// MColor colorGain;
+// MColor colorOffset;
+// float exposure;
+//
+// TextureMap(const Corona::String& filename, const int mapChannel) {
+// Corona::TextureShader::Config config;
+// config.mapping.uvwMapChannel = mapChannel;
+// config.texture = Corona::TextureShader::getImageTexture(filename);
+// this->shader.configure(config);
+// }
+//
+// virtual Corona::Rgb evalColor(const Corona::IShadeContext& context, Corona::TextureCache* cache, float& outAlpha) {
+// outAlpha = 1.f;
+// bool outsideDummy;
+// float ex = exposure;
+// Corona::Rgb envColor = shader.eval(context, true, outsideDummy);
+// //if (c < 100)
+// //{
+// // std::cout << "evalEnvCol " << envColor.r() << " " << envColor.g() << " " << envColor.g() << "\n";
+// // c++;
+// //}
+// return envColor;
+// }
+//
+// /// \brief Same as evalColor, only scalar value is returned
+// virtual float evalMono(const Corona::IShadeContext& context, Corona::TextureCache* cache, float& outAlpha) {
+// outAlpha = 1.f;
+// bool outsideDummy;
+// return shader.eval(context, true, outsideDummy).grayValue();
+// }
+//
+// /// \brief Evaluates bump mapping for this texture and returns a vector that have to be added to the
+// /// current normal to create the bump effect (the normal perturbation)
+// virtual Corona::Dir evalBump(const Corona::IShadeContext& context, Corona::TextureCache* cache) {
+// STOP;
+// }
+//
+// /// \brief Renders the map to given output bitmap. Sets the output dimensions to adequate values.
+// virtual void renderTo(Corona::Bitmap& output) {
+// shader.renderTo(output);
+// }
+//
+// virtual Corona::String name() const {
+// return "TextureMap";
+// }
+// virtual void getChildren(Corona::Stack&) {}
+//
+// };
+//
+// TextureMap *texMap = new TextureMap(filename, 0);
+// texMap->colorGain = colorGain;
+// texMap->colorOffset = colorOffset;
+// texMap->exposure = exposure;
+// return texMap;
+// }
+//};
+
// Utility class for loading bitmap textures from files. In future, various procedural textures should be also
// loaded using this class.
//class MapLoader : public Corona::Object {
diff --git a/src/mayaToCorona/src/Corona/CoronaOSLMap.cpp b/src/mayaToCorona/src/Corona/CoronaOSLMap.cpp
index e6db8ee..88b3171 100644
--- a/src/mayaToCorona/src/Corona/CoronaOSLMap.cpp
+++ b/src/mayaToCorona/src/Corona/CoronaOSLMap.cpp
@@ -15,7 +15,6 @@ OSLMap::OSLMap()
void OSLMap::setShadingGlobals(const Corona::IShadeContext& context, OSL::ShaderGlobals &sg, int x, int y, OSL::Matrix44& Mshad, OSL::Matrix44& Mobj)
{
- //this->oslRenderer->renderer.setup_transformations(Mshad, Mobj);
// Just zero the whole thing out to start
memset(&sg, 0, sizeof(OSL::ShaderGlobals));
@@ -302,8 +301,10 @@ void OSLMap::renderTo(Corona::Bitmap& output)
STOP; //currently not supported
}
-OSLMap::~OSLMap()
+bool OSLMap::exportMap(Corona::IResourceManager& resourceManager, Corona::XmlWriterNode& outXml) const
{
- Logging::debug(MString("OSLMap resetting shader group"));
- this->shaderGroup.reset();
+ return true;
}
+
+OSLMap::~OSLMap()
+{}
diff --git a/src/mayaToCorona/src/Corona/CoronaOSLMap.h b/src/mayaToCorona/src/Corona/CoronaOSLMap.h
index 58c7b8b..8c07cf5 100644
--- a/src/mayaToCorona/src/Corona/CoronaOSLMap.h
+++ b/src/mayaToCorona/src/Corona/CoronaOSLMap.h
@@ -7,7 +7,6 @@ class CoronaRenderer;
class OSLMap : public Corona::Abstract::Map
{
public:
- //CoronaRenderer *coronaRenderer;
OSL::OSLShadingNetworkRenderer *oslRenderer;
enum BumpType { NONE = 0, BUMP, NORMALOBJECT, NORMALTANGENT, NORMALWORLD, BUMP3D};
BumpType bumpType;
@@ -16,6 +15,7 @@ class OSLMap : public Corona::Abstract::Map
bool isEnvMap;
bool isLightMap;
float multiplier;
+ Corona::String mapName = "OSLMap";
OSL::ShaderGroupRef shaderGroup;
OSLMap();
~OSLMap();
@@ -27,4 +27,6 @@ class OSLMap : public Corona::Abstract::Map
virtual Corona::Rgb evalColorBump(const Corona::IShadeContext& context, Corona::TextureCache* cache, float& outAlpha, float u, float v);
virtual void renderTo(Corona::Bitmap& output);
virtual void getChildren(Corona::Stack&) {}
+ virtual bool exportMap(Corona::IResourceManager& resourceManager, Corona::XmlWriterNode& outXml) const;
+ virtual Corona::String name() const { return mapName; };
};
diff --git a/src/mayaToCorona/src/Corona/CoronaRoundCorners.cpp b/src/mayaToCorona/src/Corona/CoronaRoundCorners.cpp
new file mode 100644
index 0000000..d3d96ce
--- /dev/null
+++ b/src/mayaToCorona/src/Corona/CoronaRoundCorners.cpp
@@ -0,0 +1,33 @@
+#include "Corona.h"
+#include "CoronaRoundCorners.h"
+#include
+#include "utilities/attrTools.h"
+
+RoundCorners::RoundCorners(MObject shaderObject)
+{
+ MFnDependencyNode depFn(shaderObject);
+};
+
+RoundCorners::~RoundCorners(){};
+
+Corona::Rgb RoundCorners::evalColor(const Corona::IShadeContext& context, Corona::TextureCache* cache, float& outAlpha)
+{
+ outAlpha = 1.0f;
+ float f = 1.0f;
+ return Corona::Rgb(f, f, f);
+}
+
+float RoundCorners::evalMono(const Corona::IShadeContext& context, Corona::TextureCache* cache, float& outAlpha)
+{
+ return evalColor(context, cache, outAlpha).grayValue();
+}
+
+Corona::Dir RoundCorners::evalBump(const Corona::IShadeContext&, Corona::TextureCache*)
+{
+ STOP; //currently not supported
+}
+
+void RoundCorners::renderTo(Corona::Bitmap& output)
+{
+ STOP; //currently not supported
+}
diff --git a/src/mayaToCorona/src/Corona/CoronaRoundCorners.h b/src/mayaToCorona/src/Corona/CoronaRoundCorners.h
new file mode 100644
index 0000000..9f45271
--- /dev/null
+++ b/src/mayaToCorona/src/Corona/CoronaRoundCorners.h
@@ -0,0 +1,32 @@
+#ifndef CORONA_ROUNDCORNERS_MAP
+#define CORONA_ROUNDCORNERS_MAP
+
+#include
+#include "CoronaCore/api/Api.h"
+#include "CoronaCore/misc/Shaders/RoundEdgesShader.h"
+
+class CoronaRenderer;
+
+class RoundCorners : public Corona::Abstract::Map, Corona::RoundEdgesShader
+{
+public:
+ CoronaRenderer *coronaRenderer;
+ RoundCorners();
+ RoundCorners(MObject sObject);
+ ~RoundCorners();
+ Corona::String mapName = "RoundCorners";
+ int samplesCount = 10;
+ float radius = 0.01f;
+
+ virtual Corona::Rgb evalColor(const Corona::IShadeContext& context, Corona::TextureCache* cache, float& outAlpha);
+ virtual float evalMono(const Corona::IShadeContext& context, Corona::TextureCache* cache, float& outAlpha);
+ virtual Corona::Dir evalBump(const Corona::IShadeContext&, Corona::TextureCache*);
+ //virtual void renderTo(Corona::Bitmap& output){};
+ virtual void getChildren(Corona::Stack&) {}
+ virtual bool exportMap(Corona::IResourceManager& resourceManager, Corona::XmlWriterNode& outXml) const { return true; };
+ virtual Corona::String name() const { return mapName; };
+
+};
+
+
+#endif
\ No newline at end of file
diff --git a/src/mayaToCorona/src/Corona/CoronaSettings.cpp b/src/mayaToCorona/src/Corona/CoronaSettings.cpp
index 2ebc567..bbb2345 100644
--- a/src/mayaToCorona/src/Corona/CoronaSettings.cpp
+++ b/src/mayaToCorona/src/Corona/CoronaSettings.cpp
@@ -21,6 +21,11 @@ void CoronaRenderer::defineSettings()
context.settings->set(Corona::PARAM_IMAGE_WIDTH, w);
context.settings->set(Corona::PARAM_IMAGE_HEIGHT, h);
+ if (getBoolAttr("lockSamplingPattern",depFn, false))
+ context.settings->set(Corona::PARAM_RANDOM_SEED, 1234);
+ else
+ context.settings->set(Corona::PARAM_RANDOM_SEED, 0);
+
if (renderGlobals->getUseRenderRegion())
{
int left, bottom, right, top;
@@ -39,7 +44,7 @@ void CoronaRenderer::defineSettings()
if( renderer == 2) // vcm rendering
context.settings->set(Corona::PARAM_RENDER_ENGINE, Corona::RENDER_ENGINE_VCM);
- context.settings->set(Corona::PARAM_RESUME_RENDERING, false);
+ //context.settings->set(Corona::PARAM_RESUME_RENDERING, false);
context.settings->set(Corona::PARAM_BUCKET_SIZE, getIntAttr("image_bucketSize", depFn, 64));
context.settings->set(Corona::PARAM_BUCKET_SAMPLES_PER_ITERATION, getIntAttr("buckets_initialSamples", depFn, 4));
@@ -61,7 +66,9 @@ void CoronaRenderer::defineSettings()
if (getBoolAttr("exportSceneFile", depFn, false))
context.settings->set(Corona::PARAM_EXPORT_PATH, renderGlobals->exportSceneFileName.asChar());
- context.settings->set(Corona::PARAM_LOW_PRIORITY, true); // always render with low priority
+ //context.settings->set(Corona::PARAM_LOW_PRIORITY, true); // always render with low priority
+ context.settings->set(Corona::PARAM_THREAD_PRIORITY, Corona::IScheduler::PRIORITY_BELOW_NORMAL); // always render with low priority
+
Corona::DisplaceSubdivType subdivTypes[] = { Corona::DisplaceSubdivType::DISPLACE_SUBDIV_PROJECTED, Corona::DisplaceSubdivType::DISPLACE_SUBDIV_WORLD };
context.settings->set(Corona::PARAM_DISPLACE_SUBDIV_TYPE, subdivTypes[(int)getBoolAttr("displace_useProjectionSize", depFn, true)]);
@@ -107,7 +114,9 @@ void CoronaRenderer::defineSettings()
context.settings->set(Corona::PARAM_HDCACHE_POS_SENSITIVITY, getFloatAttr("gi_hdCache_posSensitivity", depFn, 20.0f));
context.settings->set(Corona::PARAM_HDCACHE_NORMAL_SENSITIVITY, getFloatAttr("gi_hdCache_normalSensitivity", depFn, 3.0f));
- float uhd_precision = 1.0f;
+ float uhd_precision = getFloatAttr("uhdPrecision", depFn, 1.0f);
+ context.settings->set(Corona::PARAM_UHDCACHE_PRECISION, uhd_precision);
+
int uhd_recordQuality = 512;
float uhd_strictness = 0.075f;
float uhd_msi = 3.0f;
diff --git a/src/mayaToCorona/src/Corona/CoronaShaders.cpp b/src/mayaToCorona/src/Corona/CoronaShaders.cpp
index d271194..8c274bb 100644
--- a/src/mayaToCorona/src/Corona/CoronaShaders.cpp
+++ b/src/mayaToCorona/src/Corona/CoronaShaders.cpp
@@ -1,4 +1,5 @@
#include
+#include